react-audio-wavekit 0.1.5 → 0.1.6

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

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const assignNativeAudioNodeAudioParamValue = require("../helpers/assign-native-audio-node-audio-param-value.cjs");
+const assignNativeAudioNodeOptions = require("../helpers/assign-native-audio-node-options.cjs");
+const 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 createNativeConstantSourceNodeFactory = (addSilentConnection, cacheTestResult, createNativeConstantSourceNodeFaker, testAudioScheduledSourceNodeStartMethodNegativeParametersSupport, testAudioScheduledSourceNodeStopMethodNegativeParametersSupport) => {
+  return (nativeContext, options) => {
+    if (nativeContext.createConstantSource === void 0) {
+      return createNativeConstantSourceNodeFaker(nativeContext, options);
+    }
+    const nativeConstantSourceNode = nativeContext.createConstantSource();
+    assignNativeAudioNodeOptions.assignNativeAudioNodeOptions(nativeConstantSourceNode, options);
+    assignNativeAudioNodeAudioParamValue.assignNativeAudioNodeAudioParamValue(nativeConstantSourceNode, options, "offset");
+    if (!cacheTestResult(testAudioScheduledSourceNodeStartMethodNegativeParametersSupport, () => testAudioScheduledSourceNodeStartMethodNegativeParametersSupport(nativeContext))) {
+      wrapAudioScheduledSourceNodeStartMethodNegativeParameters.wrapAudioScheduledSourceNodeStartMethodNegativeParameters(nativeConstantSourceNode);
+    }
+    if (!cacheTestResult(testAudioScheduledSourceNodeStopMethodNegativeParametersSupport, () => testAudioScheduledSourceNodeStopMethodNegativeParametersSupport(nativeContext))) {
+      wrapAudioScheduledSourceNodeStopMethodNegativeParameters.wrapAudioScheduledSourceNodeStopMethodNegativeParameters(nativeConstantSourceNode);
+    }
+    addSilentConnection(nativeContext, nativeConstantSourceNode);
+    return nativeConstantSourceNode;
+  };
+};
+exports.createNativeConstantSourceNodeFactory = createNativeConstantSourceNodeFactory;

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

@@ -0,0 +1,25 @@
+import { assignNativeAudioNodeAudioParamValue } from "../helpers/assign-native-audio-node-audio-param-value.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 createNativeConstantSourceNodeFactory = (addSilentConnection, cacheTestResult, createNativeConstantSourceNodeFaker, testAudioScheduledSourceNodeStartMethodNegativeParametersSupport, testAudioScheduledSourceNodeStopMethodNegativeParametersSupport) => {
+  return (nativeContext, options) => {
+    if (nativeContext.createConstantSource === void 0) {
+      return createNativeConstantSourceNodeFaker(nativeContext, options);
+    }
+    const nativeConstantSourceNode = nativeContext.createConstantSource();
+    assignNativeAudioNodeOptions(nativeConstantSourceNode, options);
+    assignNativeAudioNodeAudioParamValue(nativeConstantSourceNode, options, "offset");
+    if (!cacheTestResult(testAudioScheduledSourceNodeStartMethodNegativeParametersSupport, () => testAudioScheduledSourceNodeStartMethodNegativeParametersSupport(nativeContext))) {
+      wrapAudioScheduledSourceNodeStartMethodNegativeParameters(nativeConstantSourceNode);
+    }
+    if (!cacheTestResult(testAudioScheduledSourceNodeStopMethodNegativeParametersSupport, () => testAudioScheduledSourceNodeStopMethodNegativeParametersSupport(nativeContext))) {
+      wrapAudioScheduledSourceNodeStopMethodNegativeParameters(nativeConstantSourceNode);
+    }
+    addSilentConnection(nativeContext, nativeConstantSourceNode);
+    return nativeConstantSourceNode;
+  };
+};
+export {
+  createNativeConstantSourceNodeFactory
+};

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

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const interceptConnections = require("../helpers/intercept-connections.cjs");
+const createNativeConstantSourceNodeFakerFactory = (addSilentConnection, createNativeAudioBufferSourceNode, createNativeGainNode, monitorConnections) => {
+  return (nativeContext, { offset, ...audioNodeOptions }) => {
+    const audioBuffer = nativeContext.createBuffer(1, 2, 44100);
+    const audioBufferSourceNode = createNativeAudioBufferSourceNode(nativeContext, {
+      buffer: null,
+      channelCount: 2,
+      channelCountMode: "max",
+      channelInterpretation: "speakers",
+      loop: false,
+      loopEnd: 0,
+      loopStart: 0,
+      playbackRate: 1
+    });
+    const gainNode = createNativeGainNode(nativeContext, { ...audioNodeOptions, gain: offset });
+    const channelData = audioBuffer.getChannelData(0);
+    channelData[0] = 1;
+    channelData[1] = 1;
+    audioBufferSourceNode.buffer = audioBuffer;
+    audioBufferSourceNode.loop = true;
+    const nativeConstantSourceNodeFaker = {
+      get bufferSize() {
+        return void 0;
+      },
+      get channelCount() {
+        return gainNode.channelCount;
+      },
+      set channelCount(value) {
+        gainNode.channelCount = value;
+      },
+      get channelCountMode() {
+        return gainNode.channelCountMode;
+      },
+      set channelCountMode(value) {
+        gainNode.channelCountMode = value;
+      },
+      get channelInterpretation() {
+        return gainNode.channelInterpretation;
+      },
+      set channelInterpretation(value) {
+        gainNode.channelInterpretation = value;
+      },
+      get context() {
+        return gainNode.context;
+      },
+      get inputs() {
+        return [];
+      },
+      get numberOfInputs() {
+        return audioBufferSourceNode.numberOfInputs;
+      },
+      get numberOfOutputs() {
+        return gainNode.numberOfOutputs;
+      },
+      get offset() {
+        return gainNode.gain;
+      },
+      get onended() {
+        return audioBufferSourceNode.onended;
+      },
+      set onended(value) {
+        audioBufferSourceNode.onended = value;
+      },
+      addEventListener(...args) {
+        return audioBufferSourceNode.addEventListener(args[0], args[1], args[2]);
+      },
+      dispatchEvent(...args) {
+        return audioBufferSourceNode.dispatchEvent(args[0]);
+      },
+      removeEventListener(...args) {
+        return audioBufferSourceNode.removeEventListener(args[0], args[1], args[2]);
+      },
+      start(when = 0) {
+        audioBufferSourceNode.start.call(audioBufferSourceNode, when);
+      },
+      stop(when = 0) {
+        audioBufferSourceNode.stop.call(audioBufferSourceNode, when);
+      }
+    };
+    const whenConnected = () => audioBufferSourceNode.connect(gainNode);
+    const whenDisconnected = () => audioBufferSourceNode.disconnect(gainNode);
+    addSilentConnection(nativeContext, audioBufferSourceNode);
+    return monitorConnections(interceptConnections.interceptConnections(nativeConstantSourceNodeFaker, gainNode), whenConnected, whenDisconnected);
+  };
+};
+exports.createNativeConstantSourceNodeFakerFactory = createNativeConstantSourceNodeFakerFactory;

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

@@ -0,0 +1,88 @@
+import { interceptConnections } from "../helpers/intercept-connections.js";
+const createNativeConstantSourceNodeFakerFactory = (addSilentConnection, createNativeAudioBufferSourceNode, createNativeGainNode, monitorConnections) => {
+  return (nativeContext, { offset, ...audioNodeOptions }) => {
+    const audioBuffer = nativeContext.createBuffer(1, 2, 44100);
+    const audioBufferSourceNode = createNativeAudioBufferSourceNode(nativeContext, {
+      buffer: null,
+      channelCount: 2,
+      channelCountMode: "max",
+      channelInterpretation: "speakers",
+      loop: false,
+      loopEnd: 0,
+      loopStart: 0,
+      playbackRate: 1
+    });
+    const gainNode = createNativeGainNode(nativeContext, { ...audioNodeOptions, gain: offset });
+    const channelData = audioBuffer.getChannelData(0);
+    channelData[0] = 1;
+    channelData[1] = 1;
+    audioBufferSourceNode.buffer = audioBuffer;
+    audioBufferSourceNode.loop = true;
+    const nativeConstantSourceNodeFaker = {
+      get bufferSize() {
+        return void 0;
+      },
+      get channelCount() {
+        return gainNode.channelCount;
+      },
+      set channelCount(value) {
+        gainNode.channelCount = value;
+      },
+      get channelCountMode() {
+        return gainNode.channelCountMode;
+      },
+      set channelCountMode(value) {
+        gainNode.channelCountMode = value;
+      },
+      get channelInterpretation() {
+        return gainNode.channelInterpretation;
+      },
+      set channelInterpretation(value) {
+        gainNode.channelInterpretation = value;
+      },
+      get context() {
+        return gainNode.context;
+      },
+      get inputs() {
+        return [];
+      },
+      get numberOfInputs() {
+        return audioBufferSourceNode.numberOfInputs;
+      },
+      get numberOfOutputs() {
+        return gainNode.numberOfOutputs;
+      },
+      get offset() {
+        return gainNode.gain;
+      },
+      get onended() {
+        return audioBufferSourceNode.onended;
+      },
+      set onended(value) {
+        audioBufferSourceNode.onended = value;
+      },
+      addEventListener(...args) {
+        return audioBufferSourceNode.addEventListener(args[0], args[1], args[2]);
+      },
+      dispatchEvent(...args) {
+        return audioBufferSourceNode.dispatchEvent(args[0]);
+      },
+      removeEventListener(...args) {
+        return audioBufferSourceNode.removeEventListener(args[0], args[1], args[2]);
+      },
+      start(when = 0) {
+        audioBufferSourceNode.start.call(audioBufferSourceNode, when);
+      },
+      stop(when = 0) {
+        audioBufferSourceNode.stop.call(audioBufferSourceNode, when);
+      }
+    };
+    const whenConnected = () => audioBufferSourceNode.connect(gainNode);
+    const whenDisconnected = () => audioBufferSourceNode.disconnect(gainNode);
+    addSilentConnection(nativeContext, audioBufferSourceNode);
+    return monitorConnections(interceptConnections(nativeConstantSourceNodeFaker, gainNode), whenConnected, whenDisconnected);
+  };
+};
+export {
+  createNativeConstantSourceNodeFakerFactory
+};

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

@@ -0,0 +1,34 @@
+"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 createNativeConvolverNodeFactory = (createNotSupportedError, overwriteAccessors) => {
+  return (nativeContext, options) => {
+    const nativeConvolverNode = nativeContext.createConvolver();
+    assignNativeAudioNodeOptions.assignNativeAudioNodeOptions(nativeConvolverNode, options);
+    if (options.disableNormalization === nativeConvolverNode.normalize) {
+      nativeConvolverNode.normalize = !options.disableNormalization;
+    }
+    assignNativeAudioNodeOption.assignNativeAudioNodeOption(nativeConvolverNode, options, "buffer");
+    if (options.channelCount > 2) {
+      throw createNotSupportedError();
+    }
+    overwriteAccessors(nativeConvolverNode, "channelCount", (get) => () => get.call(nativeConvolverNode), (set) => (value) => {
+      if (value > 2) {
+        throw createNotSupportedError();
+      }
+      return set.call(nativeConvolverNode, value);
+    });
+    if (options.channelCountMode === "max") {
+      throw createNotSupportedError();
+    }
+    overwriteAccessors(nativeConvolverNode, "channelCountMode", (get) => () => get.call(nativeConvolverNode), (set) => (value) => {
+      if (value === "max") {
+        throw createNotSupportedError();
+      }
+      return set.call(nativeConvolverNode, value);
+    });
+    return nativeConvolverNode;
+  };
+};
+exports.createNativeConvolverNodeFactory = createNativeConvolverNodeFactory;

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

@@ -0,0 +1,34 @@
+import { assignNativeAudioNodeOption } from "../helpers/assign-native-audio-node-option.js";
+import { assignNativeAudioNodeOptions } from "../helpers/assign-native-audio-node-options.js";
+const createNativeConvolverNodeFactory = (createNotSupportedError, overwriteAccessors) => {
+  return (nativeContext, options) => {
+    const nativeConvolverNode = nativeContext.createConvolver();
+    assignNativeAudioNodeOptions(nativeConvolverNode, options);
+    if (options.disableNormalization === nativeConvolverNode.normalize) {
+      nativeConvolverNode.normalize = !options.disableNormalization;
+    }
+    assignNativeAudioNodeOption(nativeConvolverNode, options, "buffer");
+    if (options.channelCount > 2) {
+      throw createNotSupportedError();
+    }
+    overwriteAccessors(nativeConvolverNode, "channelCount", (get) => () => get.call(nativeConvolverNode), (set) => (value) => {
+      if (value > 2) {
+        throw createNotSupportedError();
+      }
+      return set.call(nativeConvolverNode, value);
+    });
+    if (options.channelCountMode === "max") {
+      throw createNotSupportedError();
+    }
+    overwriteAccessors(nativeConvolverNode, "channelCountMode", (get) => () => get.call(nativeConvolverNode), (set) => (value) => {
+      if (value === "max") {
+        throw createNotSupportedError();
+      }
+      return set.call(nativeConvolverNode, value);
+    });
+    return nativeConvolverNode;
+  };
+};
+export {
+  createNativeConvolverNodeFactory
+};

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

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const assignNativeAudioNodeAudioParamValue = require("../helpers/assign-native-audio-node-audio-param-value.cjs");
+const assignNativeAudioNodeOptions = require("../helpers/assign-native-audio-node-options.cjs");
+const createNativeDelayNode = (nativeContext, options) => {
+  const nativeDelayNode = nativeContext.createDelay(options.maxDelayTime);
+  assignNativeAudioNodeOptions.assignNativeAudioNodeOptions(nativeDelayNode, options);
+  assignNativeAudioNodeAudioParamValue.assignNativeAudioNodeAudioParamValue(nativeDelayNode, options, "delayTime");
+  return nativeDelayNode;
+};
+exports.createNativeDelayNode = createNativeDelayNode;

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

@@ -0,0 +1,11 @@
+import { assignNativeAudioNodeAudioParamValue } from "../helpers/assign-native-audio-node-audio-param-value.js";
+import { assignNativeAudioNodeOptions } from "../helpers/assign-native-audio-node-options.js";
+const createNativeDelayNode = (nativeContext, options) => {
+  const nativeDelayNode = nativeContext.createDelay(options.maxDelayTime);
+  assignNativeAudioNodeOptions(nativeDelayNode, options);
+  assignNativeAudioNodeAudioParamValue(nativeDelayNode, options, "delayTime");
+  return nativeDelayNode;
+};
+export {
+  createNativeDelayNode
+};

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

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const assignNativeAudioNodeAudioParamValue = require("../helpers/assign-native-audio-node-audio-param-value.cjs");
+const assignNativeAudioNodeOptions = require("../helpers/assign-native-audio-node-options.cjs");
+const createNativeDynamicsCompressorNodeFactory = (createNotSupportedError) => {
+  return (nativeContext, options) => {
+    const nativeDynamicsCompressorNode = nativeContext.createDynamicsCompressor();
+    assignNativeAudioNodeOptions.assignNativeAudioNodeOptions(nativeDynamicsCompressorNode, options);
+    if (options.channelCount > 2) {
+      throw createNotSupportedError();
+    }
+    if (options.channelCountMode === "max") {
+      throw createNotSupportedError();
+    }
+    assignNativeAudioNodeAudioParamValue.assignNativeAudioNodeAudioParamValue(nativeDynamicsCompressorNode, options, "attack");
+    assignNativeAudioNodeAudioParamValue.assignNativeAudioNodeAudioParamValue(nativeDynamicsCompressorNode, options, "knee");
+    assignNativeAudioNodeAudioParamValue.assignNativeAudioNodeAudioParamValue(nativeDynamicsCompressorNode, options, "ratio");
+    assignNativeAudioNodeAudioParamValue.assignNativeAudioNodeAudioParamValue(nativeDynamicsCompressorNode, options, "release");
+    assignNativeAudioNodeAudioParamValue.assignNativeAudioNodeAudioParamValue(nativeDynamicsCompressorNode, options, "threshold");
+    return nativeDynamicsCompressorNode;
+  };
+};
+exports.createNativeDynamicsCompressorNodeFactory = createNativeDynamicsCompressorNodeFactory;

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

@@ -0,0 +1,23 @@
+import { assignNativeAudioNodeAudioParamValue } from "../helpers/assign-native-audio-node-audio-param-value.js";
+import { assignNativeAudioNodeOptions } from "../helpers/assign-native-audio-node-options.js";
+const createNativeDynamicsCompressorNodeFactory = (createNotSupportedError) => {
+  return (nativeContext, options) => {
+    const nativeDynamicsCompressorNode = nativeContext.createDynamicsCompressor();
+    assignNativeAudioNodeOptions(nativeDynamicsCompressorNode, options);
+    if (options.channelCount > 2) {
+      throw createNotSupportedError();
+    }
+    if (options.channelCountMode === "max") {
+      throw createNotSupportedError();
+    }
+    assignNativeAudioNodeAudioParamValue(nativeDynamicsCompressorNode, options, "attack");
+    assignNativeAudioNodeAudioParamValue(nativeDynamicsCompressorNode, options, "knee");
+    assignNativeAudioNodeAudioParamValue(nativeDynamicsCompressorNode, options, "ratio");
+    assignNativeAudioNodeAudioParamValue(nativeDynamicsCompressorNode, options, "release");
+    assignNativeAudioNodeAudioParamValue(nativeDynamicsCompressorNode, options, "threshold");
+    return nativeDynamicsCompressorNode;
+  };
+};
+export {
+  createNativeDynamicsCompressorNodeFactory
+};

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

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const assignNativeAudioNodeAudioParamValue = require("../helpers/assign-native-audio-node-audio-param-value.cjs");
+const assignNativeAudioNodeOptions = require("../helpers/assign-native-audio-node-options.cjs");
+const createNativeGainNode = (nativeContext, options) => {
+  const nativeGainNode = nativeContext.createGain();
+  assignNativeAudioNodeOptions.assignNativeAudioNodeOptions(nativeGainNode, options);
+  assignNativeAudioNodeAudioParamValue.assignNativeAudioNodeAudioParamValue(nativeGainNode, options, "gain");
+  return nativeGainNode;
+};
+exports.createNativeGainNode = createNativeGainNode;

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

@@ -0,0 +1,11 @@
+import { assignNativeAudioNodeAudioParamValue } from "../helpers/assign-native-audio-node-audio-param-value.js";
+import { assignNativeAudioNodeOptions } from "../helpers/assign-native-audio-node-options.js";
+const createNativeGainNode = (nativeContext, options) => {
+  const nativeGainNode = nativeContext.createGain();
+  assignNativeAudioNodeOptions(nativeGainNode, options);
+  assignNativeAudioNodeAudioParamValue(nativeGainNode, options, "gain");
+  return nativeGainNode;
+};
+export {
+  createNativeGainNode
+};

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

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const assignNativeAudioNodeOptions = require("../helpers/assign-native-audio-node-options.cjs");
+const createNativeIIRFilterNodeFactory = (createNativeIIRFilterNodeFaker) => {
+  return (nativeContext, baseLatency, options) => {
+    if (nativeContext.createIIRFilter === void 0) {
+      return createNativeIIRFilterNodeFaker(nativeContext, baseLatency, options);
+    }
+    const nativeIIRFilterNode = nativeContext.createIIRFilter(options.feedforward, options.feedback);
+    assignNativeAudioNodeOptions.assignNativeAudioNodeOptions(nativeIIRFilterNode, options);
+    return nativeIIRFilterNode;
+  };
+};
+exports.createNativeIIRFilterNodeFactory = createNativeIIRFilterNodeFactory;

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

@@ -0,0 +1,14 @@
+import { assignNativeAudioNodeOptions } from "../helpers/assign-native-audio-node-options.js";
+const createNativeIIRFilterNodeFactory = (createNativeIIRFilterNodeFaker) => {
+  return (nativeContext, baseLatency, options) => {
+    if (nativeContext.createIIRFilter === void 0) {
+      return createNativeIIRFilterNodeFaker(nativeContext, baseLatency, options);
+    }
+    const nativeIIRFilterNode = nativeContext.createIIRFilter(options.feedforward, options.feedback);
+    assignNativeAudioNodeOptions(nativeIIRFilterNode, options);
+    return nativeIIRFilterNode;
+  };
+};
+export {
+  createNativeIIRFilterNodeFactory
+};

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

@@ -0,0 +1,139 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const computeBufferSize = require("../helpers/compute-buffer-size.cjs");
+const filterBuffer = require("../helpers/filter-buffer.cjs");
+const interceptConnections = require("../helpers/intercept-connections.cjs");
+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.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.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.interceptConnections(nativeIIRFilterNodeFaker, scriptProcessorNode);
+  };
+};
+exports.createNativeIIRFilterNodeFakerFactory = createNativeIIRFilterNodeFakerFactory;