react-audio-wavekit 0.1.4 → 0.1.6

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

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const isOwnedByContext = require("../helpers/is-owned-by-context.cjs");
+const createAudioBufferSourceNodeRendererFactory = (connectAudioParam, createNativeAudioBufferSourceNode, getNativeAudioNode, renderAutomation, renderInputsOfAudioNode) => {
+  return () => {
+    const renderedNativeAudioBufferSourceNodes = /* @__PURE__ */ new WeakMap();
+    let start = null;
+    let stop = null;
+    const createAudioBufferSourceNode = async (proxy, nativeOfflineAudioContext) => {
+      let nativeAudioBufferSourceNode = getNativeAudioNode(proxy);
+      const nativeAudioBufferSourceNodeIsOwnedByContext = isOwnedByContext.isOwnedByContext(nativeAudioBufferSourceNode, nativeOfflineAudioContext);
+      if (!nativeAudioBufferSourceNodeIsOwnedByContext) {
+        const options = {
+          buffer: nativeAudioBufferSourceNode.buffer,
+          channelCount: nativeAudioBufferSourceNode.channelCount,
+          channelCountMode: nativeAudioBufferSourceNode.channelCountMode,
+          channelInterpretation: nativeAudioBufferSourceNode.channelInterpretation,
+          // Bug #149: Safari does not yet support the detune AudioParam.
+          loop: nativeAudioBufferSourceNode.loop,
+          loopEnd: nativeAudioBufferSourceNode.loopEnd,
+          loopStart: nativeAudioBufferSourceNode.loopStart,
+          playbackRate: nativeAudioBufferSourceNode.playbackRate.value
+        };
+        nativeAudioBufferSourceNode = createNativeAudioBufferSourceNode(nativeOfflineAudioContext, options);
+        if (start !== null) {
+          nativeAudioBufferSourceNode.start(...start);
+        }
+        if (stop !== null) {
+          nativeAudioBufferSourceNode.stop(stop);
+        }
+      }
+      renderedNativeAudioBufferSourceNodes.set(nativeOfflineAudioContext, nativeAudioBufferSourceNode);
+      if (!nativeAudioBufferSourceNodeIsOwnedByContext) {
+        await renderAutomation(nativeOfflineAudioContext, proxy.playbackRate, nativeAudioBufferSourceNode.playbackRate);
+      } else {
+        await connectAudioParam(nativeOfflineAudioContext, proxy.playbackRate, nativeAudioBufferSourceNode.playbackRate);
+      }
+      await renderInputsOfAudioNode(proxy, nativeOfflineAudioContext, nativeAudioBufferSourceNode);
+      return nativeAudioBufferSourceNode;
+    };
+    return {
+      set start(value) {
+        start = value;
+      },
+      set stop(value) {
+        stop = value;
+      },
+      render(proxy, nativeOfflineAudioContext) {
+        const renderedNativeAudioBufferSourceNode = renderedNativeAudioBufferSourceNodes.get(nativeOfflineAudioContext);
+        if (renderedNativeAudioBufferSourceNode !== void 0) {
+          return Promise.resolve(renderedNativeAudioBufferSourceNode);
+        }
+        return createAudioBufferSourceNode(proxy, nativeOfflineAudioContext);
+      }
+    };
+  };
+};
+exports.createAudioBufferSourceNodeRendererFactory = createAudioBufferSourceNodeRendererFactory;

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

@@ -0,0 +1,58 @@
+import { isOwnedByContext } from "../helpers/is-owned-by-context.js";
+const createAudioBufferSourceNodeRendererFactory = (connectAudioParam, createNativeAudioBufferSourceNode, getNativeAudioNode, renderAutomation, renderInputsOfAudioNode) => {
+  return () => {
+    const renderedNativeAudioBufferSourceNodes = /* @__PURE__ */ new WeakMap();
+    let start = null;
+    let stop = null;
+    const createAudioBufferSourceNode = async (proxy, nativeOfflineAudioContext) => {
+      let nativeAudioBufferSourceNode = getNativeAudioNode(proxy);
+      const nativeAudioBufferSourceNodeIsOwnedByContext = isOwnedByContext(nativeAudioBufferSourceNode, nativeOfflineAudioContext);
+      if (!nativeAudioBufferSourceNodeIsOwnedByContext) {
+        const options = {
+          buffer: nativeAudioBufferSourceNode.buffer,
+          channelCount: nativeAudioBufferSourceNode.channelCount,
+          channelCountMode: nativeAudioBufferSourceNode.channelCountMode,
+          channelInterpretation: nativeAudioBufferSourceNode.channelInterpretation,
+          // Bug #149: Safari does not yet support the detune AudioParam.
+          loop: nativeAudioBufferSourceNode.loop,
+          loopEnd: nativeAudioBufferSourceNode.loopEnd,
+          loopStart: nativeAudioBufferSourceNode.loopStart,
+          playbackRate: nativeAudioBufferSourceNode.playbackRate.value
+        };
+        nativeAudioBufferSourceNode = createNativeAudioBufferSourceNode(nativeOfflineAudioContext, options);
+        if (start !== null) {
+          nativeAudioBufferSourceNode.start(...start);
+        }
+        if (stop !== null) {
+          nativeAudioBufferSourceNode.stop(stop);
+        }
+      }
+      renderedNativeAudioBufferSourceNodes.set(nativeOfflineAudioContext, nativeAudioBufferSourceNode);
+      if (!nativeAudioBufferSourceNodeIsOwnedByContext) {
+        await renderAutomation(nativeOfflineAudioContext, proxy.playbackRate, nativeAudioBufferSourceNode.playbackRate);
+      } else {
+        await connectAudioParam(nativeOfflineAudioContext, proxy.playbackRate, nativeAudioBufferSourceNode.playbackRate);
+      }
+      await renderInputsOfAudioNode(proxy, nativeOfflineAudioContext, nativeAudioBufferSourceNode);
+      return nativeAudioBufferSourceNode;
+    };
+    return {
+      set start(value) {
+        start = value;
+      },
+      set stop(value) {
+        stop = value;
+      },
+      render(proxy, nativeOfflineAudioContext) {
+        const renderedNativeAudioBufferSourceNode = renderedNativeAudioBufferSourceNodes.get(nativeOfflineAudioContext);
+        if (renderedNativeAudioBufferSourceNode !== void 0) {
+          return Promise.resolve(renderedNativeAudioBufferSourceNode);
+        }
+        return createAudioBufferSourceNode(proxy, nativeOfflineAudioContext);
+      }
+    };
+  };
+};
+export {
+  createAudioBufferSourceNodeRendererFactory
+};

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

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const createAudioDestinationNodeConstructor = (audioNodeConstructor, createAudioDestinationNodeRenderer, createIndexSizeError, createInvalidStateError, createNativeAudioDestinationNode, getNativeContext, isNativeOfflineAudioContext, renderInputsOfAudioNode) => {
+  return class AudioDestinationNode extends audioNodeConstructor {
+    constructor(context, channelCount) {
+      const nativeContext = getNativeContext(context);
+      const isOffline = isNativeOfflineAudioContext(nativeContext);
+      const nativeAudioDestinationNode = createNativeAudioDestinationNode(nativeContext, channelCount, isOffline);
+      const audioDestinationNodeRenderer = isOffline ? createAudioDestinationNodeRenderer(renderInputsOfAudioNode) : null;
+      super(context, false, nativeAudioDestinationNode, audioDestinationNodeRenderer);
+      this._isNodeOfNativeOfflineAudioContext = isOffline;
+      this._nativeAudioDestinationNode = nativeAudioDestinationNode;
+    }
+    get channelCount() {
+      return this._nativeAudioDestinationNode.channelCount;
+    }
+    set channelCount(value) {
+      if (this._isNodeOfNativeOfflineAudioContext) {
+        throw createInvalidStateError();
+      }
+      if (value > this._nativeAudioDestinationNode.maxChannelCount) {
+        throw createIndexSizeError();
+      }
+      this._nativeAudioDestinationNode.channelCount = value;
+    }
+    get channelCountMode() {
+      return this._nativeAudioDestinationNode.channelCountMode;
+    }
+    set channelCountMode(value) {
+      if (this._isNodeOfNativeOfflineAudioContext) {
+        throw createInvalidStateError();
+      }
+      this._nativeAudioDestinationNode.channelCountMode = value;
+    }
+    get maxChannelCount() {
+      return this._nativeAudioDestinationNode.maxChannelCount;
+    }
+  };
+};
+exports.createAudioDestinationNodeConstructor = createAudioDestinationNodeConstructor;

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

@@ -0,0 +1,40 @@
+const createAudioDestinationNodeConstructor = (audioNodeConstructor, createAudioDestinationNodeRenderer, createIndexSizeError, createInvalidStateError, createNativeAudioDestinationNode, getNativeContext, isNativeOfflineAudioContext, renderInputsOfAudioNode) => {
+  return class AudioDestinationNode extends audioNodeConstructor {
+    constructor(context, channelCount) {
+      const nativeContext = getNativeContext(context);
+      const isOffline = isNativeOfflineAudioContext(nativeContext);
+      const nativeAudioDestinationNode = createNativeAudioDestinationNode(nativeContext, channelCount, isOffline);
+      const audioDestinationNodeRenderer = isOffline ? createAudioDestinationNodeRenderer(renderInputsOfAudioNode) : null;
+      super(context, false, nativeAudioDestinationNode, audioDestinationNodeRenderer);
+      this._isNodeOfNativeOfflineAudioContext = isOffline;
+      this._nativeAudioDestinationNode = nativeAudioDestinationNode;
+    }
+    get channelCount() {
+      return this._nativeAudioDestinationNode.channelCount;
+    }
+    set channelCount(value) {
+      if (this._isNodeOfNativeOfflineAudioContext) {
+        throw createInvalidStateError();
+      }
+      if (value > this._nativeAudioDestinationNode.maxChannelCount) {
+        throw createIndexSizeError();
+      }
+      this._nativeAudioDestinationNode.channelCount = value;
+    }
+    get channelCountMode() {
+      return this._nativeAudioDestinationNode.channelCountMode;
+    }
+    set channelCountMode(value) {
+      if (this._isNodeOfNativeOfflineAudioContext) {
+        throw createInvalidStateError();
+      }
+      this._nativeAudioDestinationNode.channelCountMode = value;
+    }
+    get maxChannelCount() {
+      return this._nativeAudioDestinationNode.maxChannelCount;
+    }
+  };
+};
+export {
+  createAudioDestinationNodeConstructor
+};

package/dist/node_modules/standardized-audio-context/build/es2019/factories/audio-destination-node-renderer-factory.cjs

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const createAudioDestinationNodeRenderer = (renderInputsOfAudioNode) => {
+  const renderedNativeAudioDestinationNodes = /* @__PURE__ */ new WeakMap();
+  const createAudioDestinationNode = async (proxy, nativeOfflineAudioContext) => {
+    const nativeAudioDestinationNode = nativeOfflineAudioContext.destination;
+    renderedNativeAudioDestinationNodes.set(nativeOfflineAudioContext, nativeAudioDestinationNode);
+    await renderInputsOfAudioNode(proxy, nativeOfflineAudioContext, nativeAudioDestinationNode);
+    return nativeAudioDestinationNode;
+  };
+  return {
+    render(proxy, nativeOfflineAudioContext) {
+      const renderedNativeAudioDestinationNode = renderedNativeAudioDestinationNodes.get(nativeOfflineAudioContext);
+      if (renderedNativeAudioDestinationNode !== void 0) {
+        return Promise.resolve(renderedNativeAudioDestinationNode);
+      }
+      return createAudioDestinationNode(proxy, nativeOfflineAudioContext);
+    }
+  };
+};
+exports.createAudioDestinationNodeRenderer = createAudioDestinationNodeRenderer;

package/dist/node_modules/standardized-audio-context/build/es2019/factories/audio-destination-node-renderer-factory.js

@@ -0,0 +1,21 @@
+const createAudioDestinationNodeRenderer = (renderInputsOfAudioNode) => {
+  const renderedNativeAudioDestinationNodes = /* @__PURE__ */ new WeakMap();
+  const createAudioDestinationNode = async (proxy, nativeOfflineAudioContext) => {
+    const nativeAudioDestinationNode = nativeOfflineAudioContext.destination;
+    renderedNativeAudioDestinationNodes.set(nativeOfflineAudioContext, nativeAudioDestinationNode);
+    await renderInputsOfAudioNode(proxy, nativeOfflineAudioContext, nativeAudioDestinationNode);
+    return nativeAudioDestinationNode;
+  };
+  return {
+    render(proxy, nativeOfflineAudioContext) {
+      const renderedNativeAudioDestinationNode = renderedNativeAudioDestinationNodes.get(nativeOfflineAudioContext);
+      if (renderedNativeAudioDestinationNode !== void 0) {
+        return Promise.resolve(renderedNativeAudioDestinationNode);
+      }
+      return createAudioDestinationNode(proxy, nativeOfflineAudioContext);
+    }
+  };
+};
+export {
+  createAudioDestinationNodeRenderer
+};

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

@@ -0,0 +1,220 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const constants = require("../constants.cjs");
+const createAudioListenerFactory = (createAudioParam, createNativeChannelMergerNode, createNativeConstantSourceNode, createNativeScriptProcessorNode, createNotSupportedError, getFirstSample, isNativeOfflineAudioContext, overwriteAccessors) => {
+  return (context, nativeContext) => {
+    const nativeListener = nativeContext.listener;
+    const createFakeAudioParams = () => {
+      const buffer = new Float32Array(1);
+      const channelMergerNode = createNativeChannelMergerNode(nativeContext, {
+        channelCount: 1,
+        channelCountMode: "explicit",
+        channelInterpretation: "speakers",
+        numberOfInputs: 9
+      });
+      const isOffline = isNativeOfflineAudioContext(nativeContext);
+      let isScriptProcessorNodeCreated = false;
+      let lastOrientation = [0, 0, -1, 0, 1, 0];
+      let lastPosition = [0, 0, 0];
+      const createScriptProcessorNode = () => {
+        if (isScriptProcessorNodeCreated) {
+          return;
+        }
+        isScriptProcessorNodeCreated = true;
+        const scriptProcessorNode = createNativeScriptProcessorNode(nativeContext, 256, 9, 0);
+        scriptProcessorNode.onaudioprocess = ({ inputBuffer }) => {
+          const orientation = [
+            getFirstSample(inputBuffer, buffer, 0),
+            getFirstSample(inputBuffer, buffer, 1),
+            getFirstSample(inputBuffer, buffer, 2),
+            getFirstSample(inputBuffer, buffer, 3),
+            getFirstSample(inputBuffer, buffer, 4),
+            getFirstSample(inputBuffer, buffer, 5)
+          ];
+          if (orientation.some((value, index) => value !== lastOrientation[index])) {
+            nativeListener.setOrientation(...orientation);
+            lastOrientation = orientation;
+          }
+          const positon = [
+            getFirstSample(inputBuffer, buffer, 6),
+            getFirstSample(inputBuffer, buffer, 7),
+            getFirstSample(inputBuffer, buffer, 8)
+          ];
+          if (positon.some((value, index) => value !== lastPosition[index])) {
+            nativeListener.setPosition(...positon);
+            lastPosition = positon;
+          }
+        };
+        channelMergerNode.connect(scriptProcessorNode);
+      };
+      const createSetOrientation = (index) => (value) => {
+        if (value !== lastOrientation[index]) {
+          lastOrientation[index] = value;
+          nativeListener.setOrientation(...lastOrientation);
+        }
+      };
+      const createSetPosition = (index) => (value) => {
+        if (value !== lastPosition[index]) {
+          lastPosition[index] = value;
+          nativeListener.setPosition(...lastPosition);
+        }
+      };
+      const createFakeAudioParam = (input, initialValue, setValue) => {
+        const constantSourceNode = createNativeConstantSourceNode(nativeContext, {
+          channelCount: 1,
+          channelCountMode: "explicit",
+          channelInterpretation: "discrete",
+          offset: initialValue
+        });
+        constantSourceNode.connect(channelMergerNode, 0, input);
+        constantSourceNode.start();
+        Object.defineProperty(constantSourceNode.offset, "defaultValue", {
+          get() {
+            return initialValue;
+          }
+        });
+        const audioParam = createAudioParam({ context }, isOffline, constantSourceNode.offset, constants.MOST_POSITIVE_SINGLE_FLOAT, constants.MOST_NEGATIVE_SINGLE_FLOAT);
+        overwriteAccessors(audioParam, "value", (get) => () => get.call(audioParam), (set) => (value) => {
+          try {
+            set.call(audioParam, value);
+          } catch (err) {
+            if (err.code !== 9) {
+              throw err;
+            }
+          }
+          createScriptProcessorNode();
+          if (isOffline) {
+            setValue(value);
+          }
+        });
+        audioParam.cancelAndHoldAtTime = ((cancelAndHoldAtTime) => {
+          if (isOffline) {
+            return () => {
+              throw createNotSupportedError();
+            };
+          }
+          return (...args) => {
+            const value = cancelAndHoldAtTime.apply(audioParam, args);
+            createScriptProcessorNode();
+            return value;
+          };
+        })(audioParam.cancelAndHoldAtTime);
+        audioParam.cancelScheduledValues = ((cancelScheduledValues) => {
+          if (isOffline) {
+            return () => {
+              throw createNotSupportedError();
+            };
+          }
+          return (...args) => {
+            const value = cancelScheduledValues.apply(audioParam, args);
+            createScriptProcessorNode();
+            return value;
+          };
+        })(audioParam.cancelScheduledValues);
+        audioParam.exponentialRampToValueAtTime = ((exponentialRampToValueAtTime) => {
+          if (isOffline) {
+            return () => {
+              throw createNotSupportedError();
+            };
+          }
+          return (...args) => {
+            const value = exponentialRampToValueAtTime.apply(audioParam, args);
+            createScriptProcessorNode();
+            return value;
+          };
+        })(audioParam.exponentialRampToValueAtTime);
+        audioParam.linearRampToValueAtTime = ((linearRampToValueAtTime) => {
+          if (isOffline) {
+            return () => {
+              throw createNotSupportedError();
+            };
+          }
+          return (...args) => {
+            const value = linearRampToValueAtTime.apply(audioParam, args);
+            createScriptProcessorNode();
+            return value;
+          };
+        })(audioParam.linearRampToValueAtTime);
+        audioParam.setTargetAtTime = ((setTargetAtTime) => {
+          if (isOffline) {
+            return () => {
+              throw createNotSupportedError();
+            };
+          }
+          return (...args) => {
+            const value = setTargetAtTime.apply(audioParam, args);
+            createScriptProcessorNode();
+            return value;
+          };
+        })(audioParam.setTargetAtTime);
+        audioParam.setValueAtTime = ((setValueAtTime) => {
+          if (isOffline) {
+            return () => {
+              throw createNotSupportedError();
+            };
+          }
+          return (...args) => {
+            const value = setValueAtTime.apply(audioParam, args);
+            createScriptProcessorNode();
+            return value;
+          };
+        })(audioParam.setValueAtTime);
+        audioParam.setValueCurveAtTime = ((setValueCurveAtTime) => {
+          if (isOffline) {
+            return () => {
+              throw createNotSupportedError();
+            };
+          }
+          return (...args) => {
+            const value = setValueCurveAtTime.apply(audioParam, args);
+            createScriptProcessorNode();
+            return value;
+          };
+        })(audioParam.setValueCurveAtTime);
+        return audioParam;
+      };
+      return {
+        forwardX: createFakeAudioParam(0, 0, createSetOrientation(0)),
+        forwardY: createFakeAudioParam(1, 0, createSetOrientation(1)),
+        forwardZ: createFakeAudioParam(2, -1, createSetOrientation(2)),
+        positionX: createFakeAudioParam(6, 0, createSetPosition(0)),
+        positionY: createFakeAudioParam(7, 0, createSetPosition(1)),
+        positionZ: createFakeAudioParam(8, 0, createSetPosition(2)),
+        upX: createFakeAudioParam(3, 0, createSetOrientation(3)),
+        upY: createFakeAudioParam(4, 1, createSetOrientation(4)),
+        upZ: createFakeAudioParam(5, 0, createSetOrientation(5))
+      };
+    };
+    const { forwardX, forwardY, forwardZ, positionX, positionY, positionZ, upX, upY, upZ } = nativeListener.forwardX === void 0 ? createFakeAudioParams() : nativeListener;
+    return {
+      get forwardX() {
+        return forwardX;
+      },
+      get forwardY() {
+        return forwardY;
+      },
+      get forwardZ() {
+        return forwardZ;
+      },
+      get positionX() {
+        return positionX;
+      },
+      get positionY() {
+        return positionY;
+      },
+      get positionZ() {
+        return positionZ;
+      },
+      get upX() {
+        return upX;
+      },
+      get upY() {
+        return upY;
+      },
+      get upZ() {
+        return upZ;
+      }
+    };
+  };
+};
+exports.createAudioListenerFactory = createAudioListenerFactory;

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

@@ -0,0 +1,220 @@
+import { MOST_POSITIVE_SINGLE_FLOAT, MOST_NEGATIVE_SINGLE_FLOAT } from "../constants.js";
+const createAudioListenerFactory = (createAudioParam, createNativeChannelMergerNode, createNativeConstantSourceNode, createNativeScriptProcessorNode, createNotSupportedError, getFirstSample, isNativeOfflineAudioContext, overwriteAccessors) => {
+  return (context, nativeContext) => {
+    const nativeListener = nativeContext.listener;
+    const createFakeAudioParams = () => {
+      const buffer = new Float32Array(1);
+      const channelMergerNode = createNativeChannelMergerNode(nativeContext, {
+        channelCount: 1,
+        channelCountMode: "explicit",
+        channelInterpretation: "speakers",
+        numberOfInputs: 9
+      });
+      const isOffline = isNativeOfflineAudioContext(nativeContext);
+      let isScriptProcessorNodeCreated = false;
+      let lastOrientation = [0, 0, -1, 0, 1, 0];
+      let lastPosition = [0, 0, 0];
+      const createScriptProcessorNode = () => {
+        if (isScriptProcessorNodeCreated) {
+          return;
+        }
+        isScriptProcessorNodeCreated = true;
+        const scriptProcessorNode = createNativeScriptProcessorNode(nativeContext, 256, 9, 0);
+        scriptProcessorNode.onaudioprocess = ({ inputBuffer }) => {
+          const orientation = [
+            getFirstSample(inputBuffer, buffer, 0),
+            getFirstSample(inputBuffer, buffer, 1),
+            getFirstSample(inputBuffer, buffer, 2),
+            getFirstSample(inputBuffer, buffer, 3),
+            getFirstSample(inputBuffer, buffer, 4),
+            getFirstSample(inputBuffer, buffer, 5)
+          ];
+          if (orientation.some((value, index) => value !== lastOrientation[index])) {
+            nativeListener.setOrientation(...orientation);
+            lastOrientation = orientation;
+          }
+          const positon = [
+            getFirstSample(inputBuffer, buffer, 6),
+            getFirstSample(inputBuffer, buffer, 7),
+            getFirstSample(inputBuffer, buffer, 8)
+          ];
+          if (positon.some((value, index) => value !== lastPosition[index])) {
+            nativeListener.setPosition(...positon);
+            lastPosition = positon;
+          }
+        };
+        channelMergerNode.connect(scriptProcessorNode);
+      };
+      const createSetOrientation = (index) => (value) => {
+        if (value !== lastOrientation[index]) {
+          lastOrientation[index] = value;
+          nativeListener.setOrientation(...lastOrientation);
+        }
+      };
+      const createSetPosition = (index) => (value) => {
+        if (value !== lastPosition[index]) {
+          lastPosition[index] = value;
+          nativeListener.setPosition(...lastPosition);
+        }
+      };
+      const createFakeAudioParam = (input, initialValue, setValue) => {
+        const constantSourceNode = createNativeConstantSourceNode(nativeContext, {
+          channelCount: 1,
+          channelCountMode: "explicit",
+          channelInterpretation: "discrete",
+          offset: initialValue
+        });
+        constantSourceNode.connect(channelMergerNode, 0, input);
+        constantSourceNode.start();
+        Object.defineProperty(constantSourceNode.offset, "defaultValue", {
+          get() {
+            return initialValue;
+          }
+        });
+        const audioParam = createAudioParam({ context }, isOffline, constantSourceNode.offset, MOST_POSITIVE_SINGLE_FLOAT, MOST_NEGATIVE_SINGLE_FLOAT);
+        overwriteAccessors(audioParam, "value", (get) => () => get.call(audioParam), (set) => (value) => {
+          try {
+            set.call(audioParam, value);
+          } catch (err) {
+            if (err.code !== 9) {
+              throw err;
+            }
+          }
+          createScriptProcessorNode();
+          if (isOffline) {
+            setValue(value);
+          }
+        });
+        audioParam.cancelAndHoldAtTime = ((cancelAndHoldAtTime) => {
+          if (isOffline) {
+            return () => {
+              throw createNotSupportedError();
+            };
+          }
+          return (...args) => {
+            const value = cancelAndHoldAtTime.apply(audioParam, args);
+            createScriptProcessorNode();
+            return value;
+          };
+        })(audioParam.cancelAndHoldAtTime);
+        audioParam.cancelScheduledValues = ((cancelScheduledValues) => {
+          if (isOffline) {
+            return () => {
+              throw createNotSupportedError();
+            };
+          }
+          return (...args) => {
+            const value = cancelScheduledValues.apply(audioParam, args);
+            createScriptProcessorNode();
+            return value;
+          };
+        })(audioParam.cancelScheduledValues);
+        audioParam.exponentialRampToValueAtTime = ((exponentialRampToValueAtTime) => {
+          if (isOffline) {
+            return () => {
+              throw createNotSupportedError();
+            };
+          }
+          return (...args) => {
+            const value = exponentialRampToValueAtTime.apply(audioParam, args);
+            createScriptProcessorNode();
+            return value;
+          };
+        })(audioParam.exponentialRampToValueAtTime);
+        audioParam.linearRampToValueAtTime = ((linearRampToValueAtTime) => {
+          if (isOffline) {
+            return () => {
+              throw createNotSupportedError();
+            };
+          }
+          return (...args) => {
+            const value = linearRampToValueAtTime.apply(audioParam, args);
+            createScriptProcessorNode();
+            return value;
+          };
+        })(audioParam.linearRampToValueAtTime);
+        audioParam.setTargetAtTime = ((setTargetAtTime) => {
+          if (isOffline) {
+            return () => {
+              throw createNotSupportedError();
+            };
+          }
+          return (...args) => {
+            const value = setTargetAtTime.apply(audioParam, args);
+            createScriptProcessorNode();
+            return value;
+          };
+        })(audioParam.setTargetAtTime);
+        audioParam.setValueAtTime = ((setValueAtTime) => {
+          if (isOffline) {
+            return () => {
+              throw createNotSupportedError();
+            };
+          }
+          return (...args) => {
+            const value = setValueAtTime.apply(audioParam, args);
+            createScriptProcessorNode();
+            return value;
+          };
+        })(audioParam.setValueAtTime);
+        audioParam.setValueCurveAtTime = ((setValueCurveAtTime) => {
+          if (isOffline) {
+            return () => {
+              throw createNotSupportedError();
+            };
+          }
+          return (...args) => {
+            const value = setValueCurveAtTime.apply(audioParam, args);
+            createScriptProcessorNode();
+            return value;
+          };
+        })(audioParam.setValueCurveAtTime);
+        return audioParam;
+      };
+      return {
+        forwardX: createFakeAudioParam(0, 0, createSetOrientation(0)),
+        forwardY: createFakeAudioParam(1, 0, createSetOrientation(1)),
+        forwardZ: createFakeAudioParam(2, -1, createSetOrientation(2)),
+        positionX: createFakeAudioParam(6, 0, createSetPosition(0)),
+        positionY: createFakeAudioParam(7, 0, createSetPosition(1)),
+        positionZ: createFakeAudioParam(8, 0, createSetPosition(2)),
+        upX: createFakeAudioParam(3, 0, createSetOrientation(3)),
+        upY: createFakeAudioParam(4, 1, createSetOrientation(4)),
+        upZ: createFakeAudioParam(5, 0, createSetOrientation(5))
+      };
+    };
+    const { forwardX, forwardY, forwardZ, positionX, positionY, positionZ, upX, upY, upZ } = nativeListener.forwardX === void 0 ? createFakeAudioParams() : nativeListener;
+    return {
+      get forwardX() {
+        return forwardX;
+      },
+      get forwardY() {
+        return forwardY;
+      },
+      get forwardZ() {
+        return forwardZ;
+      },
+      get positionX() {
+        return positionX;
+      },
+      get positionY() {
+        return positionY;
+      },
+      get positionZ() {
+        return positionZ;
+      },
+      get upX() {
+        return upX;
+      },
+      get upY() {
+        return upY;
+      },
+      get upZ() {
+        return upZ;
+      }
+    };
+  };
+};
+export {
+  createAudioListenerFactory
+};