react-audio-wavekit 0.1.5 → 0.1.6

package/dist/node_modules/standardized-audio-context/build/es2019/factories/audio-param-factory.cjs

@@ -0,0 +1,152 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const automationEventList = require("../../../../automation-events/build/es2019/classes/automation-event-list.cjs");
+const createAudioParamFactory = (addAudioParamConnections, audioParamAudioNodeStore, audioParamStore, createAudioParamRenderer, createCancelAndHoldAutomationEvent, createCancelScheduledValuesAutomationEvent, createExponentialRampToValueAutomationEvent, createLinearRampToValueAutomationEvent, createSetTargetAutomationEvent, createSetValueAutomationEvent, createSetValueCurveAutomationEvent, nativeAudioContextConstructor, setValueAtTimeUntilPossible) => {
+  return (audioNode, isAudioParamOfOfflineAudioContext, nativeAudioParam, maxValue = null, minValue = null) => {
+    const defaultValue = nativeAudioParam.value;
+    const automationEventList$1 = new automationEventList.AutomationEventList(defaultValue);
+    const audioParamRenderer = isAudioParamOfOfflineAudioContext ? createAudioParamRenderer(automationEventList$1) : null;
+    const audioParam = {
+      get defaultValue() {
+        return defaultValue;
+      },
+      get maxValue() {
+        return maxValue === null ? nativeAudioParam.maxValue : maxValue;
+      },
+      get minValue() {
+        return minValue === null ? nativeAudioParam.minValue : minValue;
+      },
+      get value() {
+        return nativeAudioParam.value;
+      },
+      set value(value) {
+        nativeAudioParam.value = value;
+        audioParam.setValueAtTime(value, audioNode.context.currentTime);
+      },
+      cancelAndHoldAtTime(cancelTime) {
+        if (typeof nativeAudioParam.cancelAndHoldAtTime === "function") {
+          if (audioParamRenderer === null) {
+            automationEventList$1.flush(audioNode.context.currentTime);
+          }
+          automationEventList$1.add(createCancelAndHoldAutomationEvent(cancelTime));
+          nativeAudioParam.cancelAndHoldAtTime(cancelTime);
+        } else {
+          const previousLastEvent = Array.from(automationEventList$1).pop();
+          if (audioParamRenderer === null) {
+            automationEventList$1.flush(audioNode.context.currentTime);
+          }
+          automationEventList$1.add(createCancelAndHoldAutomationEvent(cancelTime));
+          const currentLastEvent = Array.from(automationEventList$1).pop();
+          nativeAudioParam.cancelScheduledValues(cancelTime);
+          if (previousLastEvent !== currentLastEvent && currentLastEvent !== void 0) {
+            if (currentLastEvent.type === "exponentialRampToValue") {
+              nativeAudioParam.exponentialRampToValueAtTime(currentLastEvent.value, currentLastEvent.endTime);
+            } else if (currentLastEvent.type === "linearRampToValue") {
+              nativeAudioParam.linearRampToValueAtTime(currentLastEvent.value, currentLastEvent.endTime);
+            } else if (currentLastEvent.type === "setValue") {
+              nativeAudioParam.setValueAtTime(currentLastEvent.value, currentLastEvent.startTime);
+            } else if (currentLastEvent.type === "setValueCurve") {
+              nativeAudioParam.setValueCurveAtTime(currentLastEvent.values, currentLastEvent.startTime, currentLastEvent.duration);
+            }
+          }
+        }
+        return audioParam;
+      },
+      cancelScheduledValues(cancelTime) {
+        if (audioParamRenderer === null) {
+          automationEventList$1.flush(audioNode.context.currentTime);
+        }
+        automationEventList$1.add(createCancelScheduledValuesAutomationEvent(cancelTime));
+        nativeAudioParam.cancelScheduledValues(cancelTime);
+        return audioParam;
+      },
+      exponentialRampToValueAtTime(value, endTime) {
+        if (value === 0) {
+          throw new RangeError();
+        }
+        if (!Number.isFinite(endTime) || endTime < 0) {
+          throw new RangeError();
+        }
+        const currentTime = audioNode.context.currentTime;
+        if (audioParamRenderer === null) {
+          automationEventList$1.flush(currentTime);
+        }
+        if (Array.from(automationEventList$1).length === 0) {
+          automationEventList$1.add(createSetValueAutomationEvent(defaultValue, currentTime));
+          nativeAudioParam.setValueAtTime(defaultValue, currentTime);
+        }
+        automationEventList$1.add(createExponentialRampToValueAutomationEvent(value, endTime));
+        nativeAudioParam.exponentialRampToValueAtTime(value, endTime);
+        return audioParam;
+      },
+      linearRampToValueAtTime(value, endTime) {
+        const currentTime = audioNode.context.currentTime;
+        if (audioParamRenderer === null) {
+          automationEventList$1.flush(currentTime);
+        }
+        if (Array.from(automationEventList$1).length === 0) {
+          automationEventList$1.add(createSetValueAutomationEvent(defaultValue, currentTime));
+          nativeAudioParam.setValueAtTime(defaultValue, currentTime);
+        }
+        automationEventList$1.add(createLinearRampToValueAutomationEvent(value, endTime));
+        nativeAudioParam.linearRampToValueAtTime(value, endTime);
+        return audioParam;
+      },
+      setTargetAtTime(target, startTime, timeConstant) {
+        if (audioParamRenderer === null) {
+          automationEventList$1.flush(audioNode.context.currentTime);
+        }
+        automationEventList$1.add(createSetTargetAutomationEvent(target, startTime, timeConstant));
+        nativeAudioParam.setTargetAtTime(target, startTime, timeConstant);
+        return audioParam;
+      },
+      setValueAtTime(value, startTime) {
+        if (audioParamRenderer === null) {
+          automationEventList$1.flush(audioNode.context.currentTime);
+        }
+        automationEventList$1.add(createSetValueAutomationEvent(value, startTime));
+        nativeAudioParam.setValueAtTime(value, startTime);
+        return audioParam;
+      },
+      setValueCurveAtTime(values, startTime, duration) {
+        const convertedValues = values instanceof Float32Array ? values : new Float32Array(values);
+        if (nativeAudioContextConstructor !== null && nativeAudioContextConstructor.name === "webkitAudioContext") {
+          const endTime = startTime + duration;
+          const sampleRate = audioNode.context.sampleRate;
+          const firstSample = Math.ceil(startTime * sampleRate);
+          const lastSample = Math.floor(endTime * sampleRate);
+          const numberOfInterpolatedValues = lastSample - firstSample;
+          const interpolatedValues = new Float32Array(numberOfInterpolatedValues);
+          for (let i = 0; i < numberOfInterpolatedValues; i += 1) {
+            const theoreticIndex = (convertedValues.length - 1) / duration * ((firstSample + i) / sampleRate - startTime);
+            const lowerIndex = Math.floor(theoreticIndex);
+            const upperIndex = Math.ceil(theoreticIndex);
+            interpolatedValues[i] = lowerIndex === upperIndex ? convertedValues[lowerIndex] : (1 - (theoreticIndex - lowerIndex)) * convertedValues[lowerIndex] + (1 - (upperIndex - theoreticIndex)) * convertedValues[upperIndex];
+          }
+          if (audioParamRenderer === null) {
+            automationEventList$1.flush(audioNode.context.currentTime);
+          }
+          automationEventList$1.add(createSetValueCurveAutomationEvent(interpolatedValues, startTime, duration));
+          nativeAudioParam.setValueCurveAtTime(interpolatedValues, startTime, duration);
+          const timeOfLastSample = lastSample / sampleRate;
+          if (timeOfLastSample < endTime) {
+            setValueAtTimeUntilPossible(audioParam, interpolatedValues[interpolatedValues.length - 1], timeOfLastSample);
+          }
+          setValueAtTimeUntilPossible(audioParam, convertedValues[convertedValues.length - 1], endTime);
+        } else {
+          if (audioParamRenderer === null) {
+            automationEventList$1.flush(audioNode.context.currentTime);
+          }
+          automationEventList$1.add(createSetValueCurveAutomationEvent(convertedValues, startTime, duration));
+          nativeAudioParam.setValueCurveAtTime(convertedValues, startTime, duration);
+        }
+        return audioParam;
+      }
+    };
+    audioParamStore.set(audioParam, nativeAudioParam);
+    audioParamAudioNodeStore.set(audioParam, audioNode);
+    addAudioParamConnections(audioParam, audioParamRenderer);
+    return audioParam;
+  };
+};
+exports.createAudioParamFactory = createAudioParamFactory;

package/dist/node_modules/standardized-audio-context/build/es2019/factories/audio-param-factory.js

@@ -0,0 +1,152 @@
+import { AutomationEventList } from "../../../../automation-events/build/es2019/classes/automation-event-list.js";
+const createAudioParamFactory = (addAudioParamConnections, audioParamAudioNodeStore, audioParamStore, createAudioParamRenderer, createCancelAndHoldAutomationEvent, createCancelScheduledValuesAutomationEvent, createExponentialRampToValueAutomationEvent, createLinearRampToValueAutomationEvent, createSetTargetAutomationEvent, createSetValueAutomationEvent, createSetValueCurveAutomationEvent, nativeAudioContextConstructor, setValueAtTimeUntilPossible) => {
+  return (audioNode, isAudioParamOfOfflineAudioContext, nativeAudioParam, maxValue = null, minValue = null) => {
+    const defaultValue = nativeAudioParam.value;
+    const automationEventList = new AutomationEventList(defaultValue);
+    const audioParamRenderer = isAudioParamOfOfflineAudioContext ? createAudioParamRenderer(automationEventList) : null;
+    const audioParam = {
+      get defaultValue() {
+        return defaultValue;
+      },
+      get maxValue() {
+        return maxValue === null ? nativeAudioParam.maxValue : maxValue;
+      },
+      get minValue() {
+        return minValue === null ? nativeAudioParam.minValue : minValue;
+      },
+      get value() {
+        return nativeAudioParam.value;
+      },
+      set value(value) {
+        nativeAudioParam.value = value;
+        audioParam.setValueAtTime(value, audioNode.context.currentTime);
+      },
+      cancelAndHoldAtTime(cancelTime) {
+        if (typeof nativeAudioParam.cancelAndHoldAtTime === "function") {
+          if (audioParamRenderer === null) {
+            automationEventList.flush(audioNode.context.currentTime);
+          }
+          automationEventList.add(createCancelAndHoldAutomationEvent(cancelTime));
+          nativeAudioParam.cancelAndHoldAtTime(cancelTime);
+        } else {
+          const previousLastEvent = Array.from(automationEventList).pop();
+          if (audioParamRenderer === null) {
+            automationEventList.flush(audioNode.context.currentTime);
+          }
+          automationEventList.add(createCancelAndHoldAutomationEvent(cancelTime));
+          const currentLastEvent = Array.from(automationEventList).pop();
+          nativeAudioParam.cancelScheduledValues(cancelTime);
+          if (previousLastEvent !== currentLastEvent && currentLastEvent !== void 0) {
+            if (currentLastEvent.type === "exponentialRampToValue") {
+              nativeAudioParam.exponentialRampToValueAtTime(currentLastEvent.value, currentLastEvent.endTime);
+            } else if (currentLastEvent.type === "linearRampToValue") {
+              nativeAudioParam.linearRampToValueAtTime(currentLastEvent.value, currentLastEvent.endTime);
+            } else if (currentLastEvent.type === "setValue") {
+              nativeAudioParam.setValueAtTime(currentLastEvent.value, currentLastEvent.startTime);
+            } else if (currentLastEvent.type === "setValueCurve") {
+              nativeAudioParam.setValueCurveAtTime(currentLastEvent.values, currentLastEvent.startTime, currentLastEvent.duration);
+            }
+          }
+        }
+        return audioParam;
+      },
+      cancelScheduledValues(cancelTime) {
+        if (audioParamRenderer === null) {
+          automationEventList.flush(audioNode.context.currentTime);
+        }
+        automationEventList.add(createCancelScheduledValuesAutomationEvent(cancelTime));
+        nativeAudioParam.cancelScheduledValues(cancelTime);
+        return audioParam;
+      },
+      exponentialRampToValueAtTime(value, endTime) {
+        if (value === 0) {
+          throw new RangeError();
+        }
+        if (!Number.isFinite(endTime) || endTime < 0) {
+          throw new RangeError();
+        }
+        const currentTime = audioNode.context.currentTime;
+        if (audioParamRenderer === null) {
+          automationEventList.flush(currentTime);
+        }
+        if (Array.from(automationEventList).length === 0) {
+          automationEventList.add(createSetValueAutomationEvent(defaultValue, currentTime));
+          nativeAudioParam.setValueAtTime(defaultValue, currentTime);
+        }
+        automationEventList.add(createExponentialRampToValueAutomationEvent(value, endTime));
+        nativeAudioParam.exponentialRampToValueAtTime(value, endTime);
+        return audioParam;
+      },
+      linearRampToValueAtTime(value, endTime) {
+        const currentTime = audioNode.context.currentTime;
+        if (audioParamRenderer === null) {
+          automationEventList.flush(currentTime);
+        }
+        if (Array.from(automationEventList).length === 0) {
+          automationEventList.add(createSetValueAutomationEvent(defaultValue, currentTime));
+          nativeAudioParam.setValueAtTime(defaultValue, currentTime);
+        }
+        automationEventList.add(createLinearRampToValueAutomationEvent(value, endTime));
+        nativeAudioParam.linearRampToValueAtTime(value, endTime);
+        return audioParam;
+      },
+      setTargetAtTime(target, startTime, timeConstant) {
+        if (audioParamRenderer === null) {
+          automationEventList.flush(audioNode.context.currentTime);
+        }
+        automationEventList.add(createSetTargetAutomationEvent(target, startTime, timeConstant));
+        nativeAudioParam.setTargetAtTime(target, startTime, timeConstant);
+        return audioParam;
+      },
+      setValueAtTime(value, startTime) {
+        if (audioParamRenderer === null) {
+          automationEventList.flush(audioNode.context.currentTime);
+        }
+        automationEventList.add(createSetValueAutomationEvent(value, startTime));
+        nativeAudioParam.setValueAtTime(value, startTime);
+        return audioParam;
+      },
+      setValueCurveAtTime(values, startTime, duration) {
+        const convertedValues = values instanceof Float32Array ? values : new Float32Array(values);
+        if (nativeAudioContextConstructor !== null && nativeAudioContextConstructor.name === "webkitAudioContext") {
+          const endTime = startTime + duration;
+          const sampleRate = audioNode.context.sampleRate;
+          const firstSample = Math.ceil(startTime * sampleRate);
+          const lastSample = Math.floor(endTime * sampleRate);
+          const numberOfInterpolatedValues = lastSample - firstSample;
+          const interpolatedValues = new Float32Array(numberOfInterpolatedValues);
+          for (let i = 0; i < numberOfInterpolatedValues; i += 1) {
+            const theoreticIndex = (convertedValues.length - 1) / duration * ((firstSample + i) / sampleRate - startTime);
+            const lowerIndex = Math.floor(theoreticIndex);
+            const upperIndex = Math.ceil(theoreticIndex);
+            interpolatedValues[i] = lowerIndex === upperIndex ? convertedValues[lowerIndex] : (1 - (theoreticIndex - lowerIndex)) * convertedValues[lowerIndex] + (1 - (upperIndex - theoreticIndex)) * convertedValues[upperIndex];
+          }
+          if (audioParamRenderer === null) {
+            automationEventList.flush(audioNode.context.currentTime);
+          }
+          automationEventList.add(createSetValueCurveAutomationEvent(interpolatedValues, startTime, duration));
+          nativeAudioParam.setValueCurveAtTime(interpolatedValues, startTime, duration);
+          const timeOfLastSample = lastSample / sampleRate;
+          if (timeOfLastSample < endTime) {
+            setValueAtTimeUntilPossible(audioParam, interpolatedValues[interpolatedValues.length - 1], timeOfLastSample);
+          }
+          setValueAtTimeUntilPossible(audioParam, convertedValues[convertedValues.length - 1], endTime);
+        } else {
+          if (audioParamRenderer === null) {
+            automationEventList.flush(audioNode.context.currentTime);
+          }
+          automationEventList.add(createSetValueCurveAutomationEvent(convertedValues, startTime, duration));
+          nativeAudioParam.setValueCurveAtTime(convertedValues, startTime, duration);
+        }
+        return audioParam;
+      }
+    };
+    audioParamStore.set(audioParam, nativeAudioParam);
+    audioParamAudioNodeStore.set(audioParam, audioNode);
+    addAudioParamConnections(audioParam, audioParamRenderer);
+    return audioParam;
+  };
+};
+export {
+  createAudioParamFactory
+};

package/dist/node_modules/standardized-audio-context/build/es2019/factories/audio-param-renderer.cjs

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const createAudioParamRenderer = (automationEventList) => {
+  return {
+    replay(audioParam) {
+      for (const automationEvent of automationEventList) {
+        if (automationEvent.type === "exponentialRampToValue") {
+          const { endTime, value } = automationEvent;
+          audioParam.exponentialRampToValueAtTime(value, endTime);
+        } else if (automationEvent.type === "linearRampToValue") {
+          const { endTime, value } = automationEvent;
+          audioParam.linearRampToValueAtTime(value, endTime);
+        } else if (automationEvent.type === "setTarget") {
+          const { startTime, target, timeConstant } = automationEvent;
+          audioParam.setTargetAtTime(target, startTime, timeConstant);
+        } else if (automationEvent.type === "setValue") {
+          const { startTime, value } = automationEvent;
+          audioParam.setValueAtTime(value, startTime);
+        } else if (automationEvent.type === "setValueCurve") {
+          const { duration, startTime, values } = automationEvent;
+          audioParam.setValueCurveAtTime(values, startTime, duration);
+        } else {
+          throw new Error("Can't apply an unknown automation.");
+        }
+      }
+    }
+  };
+};
+exports.createAudioParamRenderer = createAudioParamRenderer;

package/dist/node_modules/standardized-audio-context/build/es2019/factories/audio-param-renderer.js

@@ -0,0 +1,29 @@
+const createAudioParamRenderer = (automationEventList) => {
+  return {
+    replay(audioParam) {
+      for (const automationEvent of automationEventList) {
+        if (automationEvent.type === "exponentialRampToValue") {
+          const { endTime, value } = automationEvent;
+          audioParam.exponentialRampToValueAtTime(value, endTime);
+        } else if (automationEvent.type === "linearRampToValue") {
+          const { endTime, value } = automationEvent;
+          audioParam.linearRampToValueAtTime(value, endTime);
+        } else if (automationEvent.type === "setTarget") {
+          const { startTime, target, timeConstant } = automationEvent;
+          audioParam.setTargetAtTime(target, startTime, timeConstant);
+        } else if (automationEvent.type === "setValue") {
+          const { startTime, value } = automationEvent;
+          audioParam.setValueAtTime(value, startTime);
+        } else if (automationEvent.type === "setValueCurve") {
+          const { duration, startTime, values } = automationEvent;
+          audioParam.setValueCurveAtTime(values, startTime, duration);
+        } else {
+          throw new Error("Can't apply an unknown automation.");
+        }
+      }
+    }
+  };
+};
+export {
+  createAudioParamRenderer
+};

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

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const createBaseAudioContextConstructor = (addAudioWorkletModule, analyserNodeConstructor, audioBufferConstructor, audioBufferSourceNodeConstructor, biquadFilterNodeConstructor, channelMergerNodeConstructor, channelSplitterNodeConstructor, constantSourceNodeConstructor, convolverNodeConstructor, decodeAudioData, delayNodeConstructor, dynamicsCompressorNodeConstructor, gainNodeConstructor, iIRFilterNodeConstructor, minimalBaseAudioContextConstructor, oscillatorNodeConstructor, pannerNodeConstructor, periodicWaveConstructor, stereoPannerNodeConstructor, waveShaperNodeConstructor) => {
+  return class BaseAudioContext extends minimalBaseAudioContextConstructor {
+    constructor(_nativeContext, numberOfChannels) {
+      super(_nativeContext, numberOfChannels);
+      this._nativeContext = _nativeContext;
+      this._audioWorklet = addAudioWorkletModule === void 0 ? void 0 : {
+        addModule: (moduleURL, options) => {
+          return addAudioWorkletModule(this, moduleURL, options);
+        }
+      };
+    }
+    get audioWorklet() {
+      return this._audioWorklet;
+    }
+    createAnalyser() {
+      return new analyserNodeConstructor(this);
+    }
+    createBiquadFilter() {
+      return new biquadFilterNodeConstructor(this);
+    }
+    createBuffer(numberOfChannels, length, sampleRate) {
+      return new audioBufferConstructor({ length, numberOfChannels, sampleRate });
+    }
+    createBufferSource() {
+      return new audioBufferSourceNodeConstructor(this);
+    }
+    createChannelMerger(numberOfInputs = 6) {
+      return new channelMergerNodeConstructor(this, { numberOfInputs });
+    }
+    createChannelSplitter(numberOfOutputs = 6) {
+      return new channelSplitterNodeConstructor(this, { numberOfOutputs });
+    }
+    createConstantSource() {
+      return new constantSourceNodeConstructor(this);
+    }
+    createConvolver() {
+      return new convolverNodeConstructor(this);
+    }
+    createDelay(maxDelayTime = 1) {
+      return new delayNodeConstructor(this, { maxDelayTime });
+    }
+    createDynamicsCompressor() {
+      return new dynamicsCompressorNodeConstructor(this);
+    }
+    createGain() {
+      return new gainNodeConstructor(this);
+    }
+    createIIRFilter(feedforward, feedback) {
+      return new iIRFilterNodeConstructor(this, { feedback, feedforward });
+    }
+    createOscillator() {
+      return new oscillatorNodeConstructor(this);
+    }
+    createPanner() {
+      return new pannerNodeConstructor(this);
+    }
+    createPeriodicWave(real, imag, constraints = { disableNormalization: false }) {
+      return new periodicWaveConstructor(this, { ...constraints, imag, real });
+    }
+    createStereoPanner() {
+      return new stereoPannerNodeConstructor(this);
+    }
+    createWaveShaper() {
+      return new waveShaperNodeConstructor(this);
+    }
+    decodeAudioData(audioData, successCallback, errorCallback) {
+      return decodeAudioData(this._nativeContext, audioData).then((audioBuffer) => {
+        if (typeof successCallback === "function") {
+          successCallback(audioBuffer);
+        }
+        return audioBuffer;
+      }, (err) => {
+        if (typeof errorCallback === "function") {
+          errorCallback(err);
+        }
+        throw err;
+      });
+    }
+  };
+};
+exports.createBaseAudioContextConstructor = createBaseAudioContextConstructor;

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

@@ -0,0 +1,83 @@
+const createBaseAudioContextConstructor = (addAudioWorkletModule, analyserNodeConstructor, audioBufferConstructor, audioBufferSourceNodeConstructor, biquadFilterNodeConstructor, channelMergerNodeConstructor, channelSplitterNodeConstructor, constantSourceNodeConstructor, convolverNodeConstructor, decodeAudioData, delayNodeConstructor, dynamicsCompressorNodeConstructor, gainNodeConstructor, iIRFilterNodeConstructor, minimalBaseAudioContextConstructor, oscillatorNodeConstructor, pannerNodeConstructor, periodicWaveConstructor, stereoPannerNodeConstructor, waveShaperNodeConstructor) => {
+  return class BaseAudioContext extends minimalBaseAudioContextConstructor {
+    constructor(_nativeContext, numberOfChannels) {
+      super(_nativeContext, numberOfChannels);
+      this._nativeContext = _nativeContext;
+      this._audioWorklet = addAudioWorkletModule === void 0 ? void 0 : {
+        addModule: (moduleURL, options) => {
+          return addAudioWorkletModule(this, moduleURL, options);
+        }
+      };
+    }
+    get audioWorklet() {
+      return this._audioWorklet;
+    }
+    createAnalyser() {
+      return new analyserNodeConstructor(this);
+    }
+    createBiquadFilter() {
+      return new biquadFilterNodeConstructor(this);
+    }
+    createBuffer(numberOfChannels, length, sampleRate) {
+      return new audioBufferConstructor({ length, numberOfChannels, sampleRate });
+    }
+    createBufferSource() {
+      return new audioBufferSourceNodeConstructor(this);
+    }
+    createChannelMerger(numberOfInputs = 6) {
+      return new channelMergerNodeConstructor(this, { numberOfInputs });
+    }
+    createChannelSplitter(numberOfOutputs = 6) {
+      return new channelSplitterNodeConstructor(this, { numberOfOutputs });
+    }
+    createConstantSource() {
+      return new constantSourceNodeConstructor(this);
+    }
+    createConvolver() {
+      return new convolverNodeConstructor(this);
+    }
+    createDelay(maxDelayTime = 1) {
+      return new delayNodeConstructor(this, { maxDelayTime });
+    }
+    createDynamicsCompressor() {
+      return new dynamicsCompressorNodeConstructor(this);
+    }
+    createGain() {
+      return new gainNodeConstructor(this);
+    }
+    createIIRFilter(feedforward, feedback) {
+      return new iIRFilterNodeConstructor(this, { feedback, feedforward });
+    }
+    createOscillator() {
+      return new oscillatorNodeConstructor(this);
+    }
+    createPanner() {
+      return new pannerNodeConstructor(this);
+    }
+    createPeriodicWave(real, imag, constraints = { disableNormalization: false }) {
+      return new periodicWaveConstructor(this, { ...constraints, imag, real });
+    }
+    createStereoPanner() {
+      return new stereoPannerNodeConstructor(this);
+    }
+    createWaveShaper() {
+      return new waveShaperNodeConstructor(this);
+    }
+    decodeAudioData(audioData, successCallback, errorCallback) {
+      return decodeAudioData(this._nativeContext, audioData).then((audioBuffer) => {
+        if (typeof successCallback === "function") {
+          successCallback(audioBuffer);
+        }
+        return audioBuffer;
+      }, (err) => {
+        if (typeof errorCallback === "function") {
+          errorCallback(err);
+        }
+        throw err;
+      });
+    }
+  };
+};
+export {
+  createBaseAudioContextConstructor
+};

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

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const constants = require("../constants.cjs");
+const DEFAULT_OPTIONS = {
+  Q: 1,
+  channelCount: 2,
+  channelCountMode: "max",
+  channelInterpretation: "speakers",
+  detune: 0,
+  frequency: 350,
+  gain: 0,
+  type: "lowpass"
+};
+const createBiquadFilterNodeConstructor = (audioNodeConstructor, createAudioParam, createBiquadFilterNodeRenderer, createInvalidAccessError, createNativeBiquadFilterNode, getNativeContext, isNativeOfflineAudioContext, setAudioNodeTailTime) => {
+  return class BiquadFilterNode extends audioNodeConstructor {
+    constructor(context, options) {
+      const nativeContext = getNativeContext(context);
+      const mergedOptions = { ...DEFAULT_OPTIONS, ...options };
+      const nativeBiquadFilterNode = createNativeBiquadFilterNode(nativeContext, mergedOptions);
+      const isOffline = isNativeOfflineAudioContext(nativeContext);
+      const biquadFilterNodeRenderer = isOffline ? createBiquadFilterNodeRenderer() : null;
+      super(context, false, nativeBiquadFilterNode, biquadFilterNodeRenderer);
+      this._Q = createAudioParam(this, isOffline, nativeBiquadFilterNode.Q, constants.MOST_POSITIVE_SINGLE_FLOAT, constants.MOST_NEGATIVE_SINGLE_FLOAT);
+      this._detune = createAudioParam(this, isOffline, nativeBiquadFilterNode.detune, 1200 * Math.log2(constants.MOST_POSITIVE_SINGLE_FLOAT), -1200 * Math.log2(constants.MOST_POSITIVE_SINGLE_FLOAT));
+      this._frequency = createAudioParam(this, isOffline, nativeBiquadFilterNode.frequency, context.sampleRate / 2, 0);
+      this._gain = createAudioParam(this, isOffline, nativeBiquadFilterNode.gain, 40 * Math.log10(constants.MOST_POSITIVE_SINGLE_FLOAT), constants.MOST_NEGATIVE_SINGLE_FLOAT);
+      this._nativeBiquadFilterNode = nativeBiquadFilterNode;
+      setAudioNodeTailTime(this, 1);
+    }
+    get detune() {
+      return this._detune;
+    }
+    get frequency() {
+      return this._frequency;
+    }
+    get gain() {
+      return this._gain;
+    }
+    get Q() {
+      return this._Q;
+    }
+    get type() {
+      return this._nativeBiquadFilterNode.type;
+    }
+    set type(value) {
+      this._nativeBiquadFilterNode.type = value;
+    }
+    getFrequencyResponse(frequencyHz, magResponse, phaseResponse) {
+      try {
+        this._nativeBiquadFilterNode.getFrequencyResponse(frequencyHz, magResponse, phaseResponse);
+      } catch (err) {
+        if (err.code === 11) {
+          throw createInvalidAccessError();
+        }
+        throw err;
+      }
+      if (frequencyHz.length !== magResponse.length || magResponse.length !== phaseResponse.length) {
+        throw createInvalidAccessError();
+      }
+    }
+  };
+};
+exports.createBiquadFilterNodeConstructor = createBiquadFilterNodeConstructor;

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

@@ -0,0 +1,63 @@
+import { MOST_POSITIVE_SINGLE_FLOAT, MOST_NEGATIVE_SINGLE_FLOAT } from "../constants.js";
+const DEFAULT_OPTIONS = {
+  Q: 1,
+  channelCount: 2,
+  channelCountMode: "max",
+  channelInterpretation: "speakers",
+  detune: 0,
+  frequency: 350,
+  gain: 0,
+  type: "lowpass"
+};
+const createBiquadFilterNodeConstructor = (audioNodeConstructor, createAudioParam, createBiquadFilterNodeRenderer, createInvalidAccessError, createNativeBiquadFilterNode, getNativeContext, isNativeOfflineAudioContext, setAudioNodeTailTime) => {
+  return class BiquadFilterNode extends audioNodeConstructor {
+    constructor(context, options) {
+      const nativeContext = getNativeContext(context);
+      const mergedOptions = { ...DEFAULT_OPTIONS, ...options };
+      const nativeBiquadFilterNode = createNativeBiquadFilterNode(nativeContext, mergedOptions);
+      const isOffline = isNativeOfflineAudioContext(nativeContext);
+      const biquadFilterNodeRenderer = isOffline ? createBiquadFilterNodeRenderer() : null;
+      super(context, false, nativeBiquadFilterNode, biquadFilterNodeRenderer);
+      this._Q = createAudioParam(this, isOffline, nativeBiquadFilterNode.Q, MOST_POSITIVE_SINGLE_FLOAT, MOST_NEGATIVE_SINGLE_FLOAT);
+      this._detune = createAudioParam(this, isOffline, nativeBiquadFilterNode.detune, 1200 * Math.log2(MOST_POSITIVE_SINGLE_FLOAT), -1200 * Math.log2(MOST_POSITIVE_SINGLE_FLOAT));
+      this._frequency = createAudioParam(this, isOffline, nativeBiquadFilterNode.frequency, context.sampleRate / 2, 0);
+      this._gain = createAudioParam(this, isOffline, nativeBiquadFilterNode.gain, 40 * Math.log10(MOST_POSITIVE_SINGLE_FLOAT), MOST_NEGATIVE_SINGLE_FLOAT);
+      this._nativeBiquadFilterNode = nativeBiquadFilterNode;
+      setAudioNodeTailTime(this, 1);
+    }
+    get detune() {
+      return this._detune;
+    }
+    get frequency() {
+      return this._frequency;
+    }
+    get gain() {
+      return this._gain;
+    }
+    get Q() {
+      return this._Q;
+    }
+    get type() {
+      return this._nativeBiquadFilterNode.type;
+    }
+    set type(value) {
+      this._nativeBiquadFilterNode.type = value;
+    }
+    getFrequencyResponse(frequencyHz, magResponse, phaseResponse) {
+      try {
+        this._nativeBiquadFilterNode.getFrequencyResponse(frequencyHz, magResponse, phaseResponse);
+      } catch (err) {
+        if (err.code === 11) {
+          throw createInvalidAccessError();
+        }
+        throw err;
+      }
+      if (frequencyHz.length !== magResponse.length || magResponse.length !== phaseResponse.length) {
+        throw createInvalidAccessError();
+      }
+    }
+  };
+};
+export {
+  createBiquadFilterNodeConstructor
+};