react-audio-wavekit 0.1.5 → 0.1.6

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

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const isOwnedByContext = require("../helpers/is-owned-by-context.cjs");
+const createBiquadFilterNodeRendererFactory = (connectAudioParam, createNativeBiquadFilterNode, getNativeAudioNode, renderAutomation, renderInputsOfAudioNode) => {
+  return () => {
+    const renderedNativeBiquadFilterNodes = /* @__PURE__ */ new WeakMap();
+    const createBiquadFilterNode = async (proxy, nativeOfflineAudioContext) => {
+      let nativeBiquadFilterNode = getNativeAudioNode(proxy);
+      const nativeBiquadFilterNodeIsOwnedByContext = isOwnedByContext.isOwnedByContext(nativeBiquadFilterNode, nativeOfflineAudioContext);
+      if (!nativeBiquadFilterNodeIsOwnedByContext) {
+        const options = {
+          Q: nativeBiquadFilterNode.Q.value,
+          channelCount: nativeBiquadFilterNode.channelCount,
+          channelCountMode: nativeBiquadFilterNode.channelCountMode,
+          channelInterpretation: nativeBiquadFilterNode.channelInterpretation,
+          detune: nativeBiquadFilterNode.detune.value,
+          frequency: nativeBiquadFilterNode.frequency.value,
+          gain: nativeBiquadFilterNode.gain.value,
+          type: nativeBiquadFilterNode.type
+        };
+        nativeBiquadFilterNode = createNativeBiquadFilterNode(nativeOfflineAudioContext, options);
+      }
+      renderedNativeBiquadFilterNodes.set(nativeOfflineAudioContext, nativeBiquadFilterNode);
+      if (!nativeBiquadFilterNodeIsOwnedByContext) {
+        await renderAutomation(nativeOfflineAudioContext, proxy.Q, nativeBiquadFilterNode.Q);
+        await renderAutomation(nativeOfflineAudioContext, proxy.detune, nativeBiquadFilterNode.detune);
+        await renderAutomation(nativeOfflineAudioContext, proxy.frequency, nativeBiquadFilterNode.frequency);
+        await renderAutomation(nativeOfflineAudioContext, proxy.gain, nativeBiquadFilterNode.gain);
+      } else {
+        await connectAudioParam(nativeOfflineAudioContext, proxy.Q, nativeBiquadFilterNode.Q);
+        await connectAudioParam(nativeOfflineAudioContext, proxy.detune, nativeBiquadFilterNode.detune);
+        await connectAudioParam(nativeOfflineAudioContext, proxy.frequency, nativeBiquadFilterNode.frequency);
+        await connectAudioParam(nativeOfflineAudioContext, proxy.gain, nativeBiquadFilterNode.gain);
+      }
+      await renderInputsOfAudioNode(proxy, nativeOfflineAudioContext, nativeBiquadFilterNode);
+      return nativeBiquadFilterNode;
+    };
+    return {
+      render(proxy, nativeOfflineAudioContext) {
+        const renderedNativeBiquadFilterNode = renderedNativeBiquadFilterNodes.get(nativeOfflineAudioContext);
+        if (renderedNativeBiquadFilterNode !== void 0) {
+          return Promise.resolve(renderedNativeBiquadFilterNode);
+        }
+        return createBiquadFilterNode(proxy, nativeOfflineAudioContext);
+      }
+    };
+  };
+};
+exports.createBiquadFilterNodeRendererFactory = createBiquadFilterNodeRendererFactory;

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

@@ -0,0 +1,49 @@
+import { isOwnedByContext } from "../helpers/is-owned-by-context.js";
+const createBiquadFilterNodeRendererFactory = (connectAudioParam, createNativeBiquadFilterNode, getNativeAudioNode, renderAutomation, renderInputsOfAudioNode) => {
+  return () => {
+    const renderedNativeBiquadFilterNodes = /* @__PURE__ */ new WeakMap();
+    const createBiquadFilterNode = async (proxy, nativeOfflineAudioContext) => {
+      let nativeBiquadFilterNode = getNativeAudioNode(proxy);
+      const nativeBiquadFilterNodeIsOwnedByContext = isOwnedByContext(nativeBiquadFilterNode, nativeOfflineAudioContext);
+      if (!nativeBiquadFilterNodeIsOwnedByContext) {
+        const options = {
+          Q: nativeBiquadFilterNode.Q.value,
+          channelCount: nativeBiquadFilterNode.channelCount,
+          channelCountMode: nativeBiquadFilterNode.channelCountMode,
+          channelInterpretation: nativeBiquadFilterNode.channelInterpretation,
+          detune: nativeBiquadFilterNode.detune.value,
+          frequency: nativeBiquadFilterNode.frequency.value,
+          gain: nativeBiquadFilterNode.gain.value,
+          type: nativeBiquadFilterNode.type
+        };
+        nativeBiquadFilterNode = createNativeBiquadFilterNode(nativeOfflineAudioContext, options);
+      }
+      renderedNativeBiquadFilterNodes.set(nativeOfflineAudioContext, nativeBiquadFilterNode);
+      if (!nativeBiquadFilterNodeIsOwnedByContext) {
+        await renderAutomation(nativeOfflineAudioContext, proxy.Q, nativeBiquadFilterNode.Q);
+        await renderAutomation(nativeOfflineAudioContext, proxy.detune, nativeBiquadFilterNode.detune);
+        await renderAutomation(nativeOfflineAudioContext, proxy.frequency, nativeBiquadFilterNode.frequency);
+        await renderAutomation(nativeOfflineAudioContext, proxy.gain, nativeBiquadFilterNode.gain);
+      } else {
+        await connectAudioParam(nativeOfflineAudioContext, proxy.Q, nativeBiquadFilterNode.Q);
+        await connectAudioParam(nativeOfflineAudioContext, proxy.detune, nativeBiquadFilterNode.detune);
+        await connectAudioParam(nativeOfflineAudioContext, proxy.frequency, nativeBiquadFilterNode.frequency);
+        await connectAudioParam(nativeOfflineAudioContext, proxy.gain, nativeBiquadFilterNode.gain);
+      }
+      await renderInputsOfAudioNode(proxy, nativeOfflineAudioContext, nativeBiquadFilterNode);
+      return nativeBiquadFilterNode;
+    };
+    return {
+      render(proxy, nativeOfflineAudioContext) {
+        const renderedNativeBiquadFilterNode = renderedNativeBiquadFilterNodes.get(nativeOfflineAudioContext);
+        if (renderedNativeBiquadFilterNode !== void 0) {
+          return Promise.resolve(renderedNativeBiquadFilterNode);
+        }
+        return createBiquadFilterNode(proxy, nativeOfflineAudioContext);
+      }
+    };
+  };
+};
+export {
+  createBiquadFilterNodeRendererFactory
+};

package/dist/node_modules/standardized-audio-context/build/es2019/factories/cache-test-result.cjs

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const createCacheTestResult = (ongoingTests, testResults) => {
+  return (tester, test) => {
+    const cachedTestResult = testResults.get(tester);
+    if (cachedTestResult !== void 0) {
+      return cachedTestResult;
+    }
+    const ongoingTest = ongoingTests.get(tester);
+    if (ongoingTest !== void 0) {
+      return ongoingTest;
+    }
+    try {
+      const synchronousTestResult = test();
+      if (synchronousTestResult instanceof Promise) {
+        ongoingTests.set(tester, synchronousTestResult);
+        return synchronousTestResult.catch(() => false).then((finalTestResult) => {
+          ongoingTests.delete(tester);
+          testResults.set(tester, finalTestResult);
+          return finalTestResult;
+        });
+      }
+      testResults.set(tester, synchronousTestResult);
+      return synchronousTestResult;
+    } catch {
+      testResults.set(tester, false);
+      return false;
+    }
+  };
+};
+exports.createCacheTestResult = createCacheTestResult;

package/dist/node_modules/standardized-audio-context/build/es2019/factories/cache-test-result.js

@@ -0,0 +1,31 @@
+const createCacheTestResult = (ongoingTests, testResults) => {
+  return (tester, test) => {
+    const cachedTestResult = testResults.get(tester);
+    if (cachedTestResult !== void 0) {
+      return cachedTestResult;
+    }
+    const ongoingTest = ongoingTests.get(tester);
+    if (ongoingTest !== void 0) {
+      return ongoingTest;
+    }
+    try {
+      const synchronousTestResult = test();
+      if (synchronousTestResult instanceof Promise) {
+        ongoingTests.set(tester, synchronousTestResult);
+        return synchronousTestResult.catch(() => false).then((finalTestResult) => {
+          ongoingTests.delete(tester);
+          testResults.set(tester, finalTestResult);
+          return finalTestResult;
+        });
+      }
+      testResults.set(tester, synchronousTestResult);
+      return synchronousTestResult;
+    } catch {
+      testResults.set(tester, false);
+      return false;
+    }
+  };
+};
+export {
+  createCacheTestResult
+};

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

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const DEFAULT_OPTIONS = {
+  channelCount: 1,
+  channelCountMode: "explicit",
+  channelInterpretation: "speakers",
+  numberOfInputs: 6
+};
+const createChannelMergerNodeConstructor = (audioNodeConstructor, createChannelMergerNodeRenderer, createNativeChannelMergerNode, getNativeContext, isNativeOfflineAudioContext) => {
+  return class ChannelMergerNode extends audioNodeConstructor {
+    constructor(context, options) {
+      const nativeContext = getNativeContext(context);
+      const mergedOptions = { ...DEFAULT_OPTIONS, ...options };
+      const nativeChannelMergerNode = createNativeChannelMergerNode(nativeContext, mergedOptions);
+      const channelMergerNodeRenderer = isNativeOfflineAudioContext(nativeContext) ? createChannelMergerNodeRenderer() : null;
+      super(context, false, nativeChannelMergerNode, channelMergerNodeRenderer);
+    }
+  };
+};
+exports.createChannelMergerNodeConstructor = createChannelMergerNodeConstructor;

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

@@ -0,0 +1,20 @@
+const DEFAULT_OPTIONS = {
+  channelCount: 1,
+  channelCountMode: "explicit",
+  channelInterpretation: "speakers",
+  numberOfInputs: 6
+};
+const createChannelMergerNodeConstructor = (audioNodeConstructor, createChannelMergerNodeRenderer, createNativeChannelMergerNode, getNativeContext, isNativeOfflineAudioContext) => {
+  return class ChannelMergerNode extends audioNodeConstructor {
+    constructor(context, options) {
+      const nativeContext = getNativeContext(context);
+      const mergedOptions = { ...DEFAULT_OPTIONS, ...options };
+      const nativeChannelMergerNode = createNativeChannelMergerNode(nativeContext, mergedOptions);
+      const channelMergerNodeRenderer = isNativeOfflineAudioContext(nativeContext) ? createChannelMergerNodeRenderer() : null;
+      super(context, false, nativeChannelMergerNode, channelMergerNodeRenderer);
+    }
+  };
+};
+export {
+  createChannelMergerNodeConstructor
+};

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

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const isOwnedByContext = require("../helpers/is-owned-by-context.cjs");
+const createChannelMergerNodeRendererFactory = (createNativeChannelMergerNode, getNativeAudioNode, renderInputsOfAudioNode) => {
+  return () => {
+    const renderedNativeAudioNodes = /* @__PURE__ */ new WeakMap();
+    const createAudioNode = async (proxy, nativeOfflineAudioContext) => {
+      let nativeAudioNode = getNativeAudioNode(proxy);
+      const nativeAudioNodeIsOwnedByContext = isOwnedByContext.isOwnedByContext(nativeAudioNode, nativeOfflineAudioContext);
+      if (!nativeAudioNodeIsOwnedByContext) {
+        const options = {
+          channelCount: nativeAudioNode.channelCount,
+          channelCountMode: nativeAudioNode.channelCountMode,
+          channelInterpretation: nativeAudioNode.channelInterpretation,
+          numberOfInputs: nativeAudioNode.numberOfInputs
+        };
+        nativeAudioNode = createNativeChannelMergerNode(nativeOfflineAudioContext, options);
+      }
+      renderedNativeAudioNodes.set(nativeOfflineAudioContext, nativeAudioNode);
+      await renderInputsOfAudioNode(proxy, nativeOfflineAudioContext, nativeAudioNode);
+      return nativeAudioNode;
+    };
+    return {
+      render(proxy, nativeOfflineAudioContext) {
+        const renderedNativeAudioNode = renderedNativeAudioNodes.get(nativeOfflineAudioContext);
+        if (renderedNativeAudioNode !== void 0) {
+          return Promise.resolve(renderedNativeAudioNode);
+        }
+        return createAudioNode(proxy, nativeOfflineAudioContext);
+      }
+    };
+  };
+};
+exports.createChannelMergerNodeRendererFactory = createChannelMergerNodeRendererFactory;

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

@@ -0,0 +1,34 @@
+import { isOwnedByContext } from "../helpers/is-owned-by-context.js";
+const createChannelMergerNodeRendererFactory = (createNativeChannelMergerNode, getNativeAudioNode, renderInputsOfAudioNode) => {
+  return () => {
+    const renderedNativeAudioNodes = /* @__PURE__ */ new WeakMap();
+    const createAudioNode = async (proxy, nativeOfflineAudioContext) => {
+      let nativeAudioNode = getNativeAudioNode(proxy);
+      const nativeAudioNodeIsOwnedByContext = isOwnedByContext(nativeAudioNode, nativeOfflineAudioContext);
+      if (!nativeAudioNodeIsOwnedByContext) {
+        const options = {
+          channelCount: nativeAudioNode.channelCount,
+          channelCountMode: nativeAudioNode.channelCountMode,
+          channelInterpretation: nativeAudioNode.channelInterpretation,
+          numberOfInputs: nativeAudioNode.numberOfInputs
+        };
+        nativeAudioNode = createNativeChannelMergerNode(nativeOfflineAudioContext, options);
+      }
+      renderedNativeAudioNodes.set(nativeOfflineAudioContext, nativeAudioNode);
+      await renderInputsOfAudioNode(proxy, nativeOfflineAudioContext, nativeAudioNode);
+      return nativeAudioNode;
+    };
+    return {
+      render(proxy, nativeOfflineAudioContext) {
+        const renderedNativeAudioNode = renderedNativeAudioNodes.get(nativeOfflineAudioContext);
+        if (renderedNativeAudioNode !== void 0) {
+          return Promise.resolve(renderedNativeAudioNode);
+        }
+        return createAudioNode(proxy, nativeOfflineAudioContext);
+      }
+    };
+  };
+};
+export {
+  createChannelMergerNodeRendererFactory
+};

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

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const DEFAULT_OPTIONS = {
+  channelCount: 6,
+  channelCountMode: "explicit",
+  channelInterpretation: "discrete",
+  numberOfOutputs: 6
+};
+const createChannelSplitterNodeConstructor = (audioNodeConstructor, createChannelSplitterNodeRenderer, createNativeChannelSplitterNode, getNativeContext, isNativeOfflineAudioContext, sanitizeChannelSplitterOptions) => {
+  return class ChannelSplitterNode extends audioNodeConstructor {
+    constructor(context, options) {
+      const nativeContext = getNativeContext(context);
+      const mergedOptions = sanitizeChannelSplitterOptions({ ...DEFAULT_OPTIONS, ...options });
+      const nativeChannelSplitterNode = createNativeChannelSplitterNode(nativeContext, mergedOptions);
+      const channelSplitterNodeRenderer = isNativeOfflineAudioContext(nativeContext) ? createChannelSplitterNodeRenderer() : null;
+      super(context, false, nativeChannelSplitterNode, channelSplitterNodeRenderer);
+    }
+  };
+};
+exports.createChannelSplitterNodeConstructor = createChannelSplitterNodeConstructor;

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

@@ -0,0 +1,20 @@
+const DEFAULT_OPTIONS = {
+  channelCount: 6,
+  channelCountMode: "explicit",
+  channelInterpretation: "discrete",
+  numberOfOutputs: 6
+};
+const createChannelSplitterNodeConstructor = (audioNodeConstructor, createChannelSplitterNodeRenderer, createNativeChannelSplitterNode, getNativeContext, isNativeOfflineAudioContext, sanitizeChannelSplitterOptions) => {
+  return class ChannelSplitterNode extends audioNodeConstructor {
+    constructor(context, options) {
+      const nativeContext = getNativeContext(context);
+      const mergedOptions = sanitizeChannelSplitterOptions({ ...DEFAULT_OPTIONS, ...options });
+      const nativeChannelSplitterNode = createNativeChannelSplitterNode(nativeContext, mergedOptions);
+      const channelSplitterNodeRenderer = isNativeOfflineAudioContext(nativeContext) ? createChannelSplitterNodeRenderer() : null;
+      super(context, false, nativeChannelSplitterNode, channelSplitterNodeRenderer);
+    }
+  };
+};
+export {
+  createChannelSplitterNodeConstructor
+};

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

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const isOwnedByContext = require("../helpers/is-owned-by-context.cjs");
+const createChannelSplitterNodeRendererFactory = (createNativeChannelSplitterNode, getNativeAudioNode, renderInputsOfAudioNode) => {
+  return () => {
+    const renderedNativeAudioNodes = /* @__PURE__ */ new WeakMap();
+    const createAudioNode = async (proxy, nativeOfflineAudioContext) => {
+      let nativeAudioNode = getNativeAudioNode(proxy);
+      const nativeAudioNodeIsOwnedByContext = isOwnedByContext.isOwnedByContext(nativeAudioNode, nativeOfflineAudioContext);
+      if (!nativeAudioNodeIsOwnedByContext) {
+        const options = {
+          channelCount: nativeAudioNode.channelCount,
+          channelCountMode: nativeAudioNode.channelCountMode,
+          channelInterpretation: nativeAudioNode.channelInterpretation,
+          numberOfOutputs: nativeAudioNode.numberOfOutputs
+        };
+        nativeAudioNode = createNativeChannelSplitterNode(nativeOfflineAudioContext, options);
+      }
+      renderedNativeAudioNodes.set(nativeOfflineAudioContext, nativeAudioNode);
+      await renderInputsOfAudioNode(proxy, nativeOfflineAudioContext, nativeAudioNode);
+      return nativeAudioNode;
+    };
+    return {
+      render(proxy, nativeOfflineAudioContext) {
+        const renderedNativeAudioNode = renderedNativeAudioNodes.get(nativeOfflineAudioContext);
+        if (renderedNativeAudioNode !== void 0) {
+          return Promise.resolve(renderedNativeAudioNode);
+        }
+        return createAudioNode(proxy, nativeOfflineAudioContext);
+      }
+    };
+  };
+};
+exports.createChannelSplitterNodeRendererFactory = createChannelSplitterNodeRendererFactory;

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

@@ -0,0 +1,34 @@
+import { isOwnedByContext } from "../helpers/is-owned-by-context.js";
+const createChannelSplitterNodeRendererFactory = (createNativeChannelSplitterNode, getNativeAudioNode, renderInputsOfAudioNode) => {
+  return () => {
+    const renderedNativeAudioNodes = /* @__PURE__ */ new WeakMap();
+    const createAudioNode = async (proxy, nativeOfflineAudioContext) => {
+      let nativeAudioNode = getNativeAudioNode(proxy);
+      const nativeAudioNodeIsOwnedByContext = isOwnedByContext(nativeAudioNode, nativeOfflineAudioContext);
+      if (!nativeAudioNodeIsOwnedByContext) {
+        const options = {
+          channelCount: nativeAudioNode.channelCount,
+          channelCountMode: nativeAudioNode.channelCountMode,
+          channelInterpretation: nativeAudioNode.channelInterpretation,
+          numberOfOutputs: nativeAudioNode.numberOfOutputs
+        };
+        nativeAudioNode = createNativeChannelSplitterNode(nativeOfflineAudioContext, options);
+      }
+      renderedNativeAudioNodes.set(nativeOfflineAudioContext, nativeAudioNode);
+      await renderInputsOfAudioNode(proxy, nativeOfflineAudioContext, nativeAudioNode);
+      return nativeAudioNode;
+    };
+    return {
+      render(proxy, nativeOfflineAudioContext) {
+        const renderedNativeAudioNode = renderedNativeAudioNodes.get(nativeOfflineAudioContext);
+        if (renderedNativeAudioNode !== void 0) {
+          return Promise.resolve(renderedNativeAudioNode);
+        }
+        return createAudioNode(proxy, nativeOfflineAudioContext);
+      }
+    };
+  };
+};
+export {
+  createChannelSplitterNodeRendererFactory
+};

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

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const createConnectAudioParam = (renderInputsOfAudioParam) => {
+  return (nativeOfflineAudioContext, audioParam, nativeAudioParam) => {
+    return renderInputsOfAudioParam(audioParam, nativeOfflineAudioContext, nativeAudioParam);
+  };
+};
+exports.createConnectAudioParam = createConnectAudioParam;

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

@@ -0,0 +1,8 @@
+const createConnectAudioParam = (renderInputsOfAudioParam) => {
+  return (nativeOfflineAudioContext, audioParam, nativeAudioParam) => {
+    return renderInputsOfAudioParam(audioParam, nativeOfflineAudioContext, nativeAudioParam);
+  };
+};
+export {
+  createConnectAudioParam
+};

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

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const createConnectedNativeAudioBufferSourceNodeFactory = (createNativeAudioBufferSourceNode) => {
+  return (nativeContext, nativeAudioNode) => {
+    const nativeAudioBufferSourceNode = createNativeAudioBufferSourceNode(nativeContext, {
+      buffer: null,
+      channelCount: 2,
+      channelCountMode: "max",
+      channelInterpretation: "speakers",
+      loop: false,
+      loopEnd: 0,
+      loopStart: 0,
+      playbackRate: 1
+    });
+    const nativeAudioBuffer = nativeContext.createBuffer(1, 2, 44100);
+    nativeAudioBufferSourceNode.buffer = nativeAudioBuffer;
+    nativeAudioBufferSourceNode.loop = true;
+    nativeAudioBufferSourceNode.connect(nativeAudioNode);
+    nativeAudioBufferSourceNode.start();
+    return () => {
+      nativeAudioBufferSourceNode.stop();
+      nativeAudioBufferSourceNode.disconnect(nativeAudioNode);
+    };
+  };
+};
+exports.createConnectedNativeAudioBufferSourceNodeFactory = createConnectedNativeAudioBufferSourceNodeFactory;

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

@@ -0,0 +1,26 @@
+const createConnectedNativeAudioBufferSourceNodeFactory = (createNativeAudioBufferSourceNode) => {
+  return (nativeContext, nativeAudioNode) => {
+    const nativeAudioBufferSourceNode = createNativeAudioBufferSourceNode(nativeContext, {
+      buffer: null,
+      channelCount: 2,
+      channelCountMode: "max",
+      channelInterpretation: "speakers",
+      loop: false,
+      loopEnd: 0,
+      loopStart: 0,
+      playbackRate: 1
+    });
+    const nativeAudioBuffer = nativeContext.createBuffer(1, 2, 44100);
+    nativeAudioBufferSourceNode.buffer = nativeAudioBuffer;
+    nativeAudioBufferSourceNode.loop = true;
+    nativeAudioBufferSourceNode.connect(nativeAudioNode);
+    nativeAudioBufferSourceNode.start();
+    return () => {
+      nativeAudioBufferSourceNode.stop();
+      nativeAudioBufferSourceNode.disconnect(nativeAudioNode);
+    };
+  };
+};
+export {
+  createConnectedNativeAudioBufferSourceNodeFactory
+};

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

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const constants = require("../constants.cjs");
+const isActiveAudioNode = require("../helpers/is-active-audio-node.cjs");
+const setInternalStateToActive = require("../helpers/set-internal-state-to-active.cjs");
+const setInternalStateToPassive = require("../helpers/set-internal-state-to-passive.cjs");
+const DEFAULT_OPTIONS = {
+  channelCount: 2,
+  channelCountMode: "max",
+  channelInterpretation: "speakers",
+  offset: 1
+};
+const createConstantSourceNodeConstructor = (audioNodeConstructor, createAudioParam, createConstantSourceNodeRendererFactory, createNativeConstantSourceNode, getNativeContext, isNativeOfflineAudioContext, wrapEventListener) => {
+  return class ConstantSourceNode extends audioNodeConstructor {
+    constructor(context, options) {
+      const nativeContext = getNativeContext(context);
+      const mergedOptions = { ...DEFAULT_OPTIONS, ...options };
+      const nativeConstantSourceNode = createNativeConstantSourceNode(nativeContext, mergedOptions);
+      const isOffline = isNativeOfflineAudioContext(nativeContext);
+      const constantSourceNodeRenderer = isOffline ? createConstantSourceNodeRendererFactory() : null;
+      super(context, false, nativeConstantSourceNode, constantSourceNodeRenderer);
+      this._constantSourceNodeRenderer = constantSourceNodeRenderer;
+      this._nativeConstantSourceNode = nativeConstantSourceNode;
+      this._offset = createAudioParam(this, isOffline, nativeConstantSourceNode.offset, constants.MOST_POSITIVE_SINGLE_FLOAT, constants.MOST_NEGATIVE_SINGLE_FLOAT);
+      this._onended = null;
+    }
+    get offset() {
+      return this._offset;
+    }
+    get onended() {
+      return this._onended;
+    }
+    set onended(value) {
+      const wrappedListener = typeof value === "function" ? wrapEventListener(this, value) : null;
+      this._nativeConstantSourceNode.onended = wrappedListener;
+      const nativeOnEnded = this._nativeConstantSourceNode.onended;
+      this._onended = nativeOnEnded !== null && nativeOnEnded === wrappedListener ? value : nativeOnEnded;
+    }
+    start(when = 0) {
+      this._nativeConstantSourceNode.start(when);
+      if (this._constantSourceNodeRenderer !== null) {
+        this._constantSourceNodeRenderer.start = when;
+      }
+      if (this.context.state !== "closed") {
+        setInternalStateToActive.setInternalStateToActive(this);
+        const resetInternalStateToPassive = () => {
+          this._nativeConstantSourceNode.removeEventListener("ended", resetInternalStateToPassive);
+          if (isActiveAudioNode.isActiveAudioNode(this)) {
+            setInternalStateToPassive.setInternalStateToPassive(this);
+          }
+        };
+        this._nativeConstantSourceNode.addEventListener("ended", resetInternalStateToPassive);
+      }
+    }
+    stop(when = 0) {
+      this._nativeConstantSourceNode.stop(when);
+      if (this._constantSourceNodeRenderer !== null) {
+        this._constantSourceNodeRenderer.stop = when;
+      }
+    }
+  };
+};
+exports.createConstantSourceNodeConstructor = createConstantSourceNodeConstructor;

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

@@ -0,0 +1,63 @@
+import { MOST_POSITIVE_SINGLE_FLOAT, MOST_NEGATIVE_SINGLE_FLOAT } from "../constants.js";
+import { isActiveAudioNode } from "../helpers/is-active-audio-node.js";
+import { setInternalStateToActive } from "../helpers/set-internal-state-to-active.js";
+import { setInternalStateToPassive } from "../helpers/set-internal-state-to-passive.js";
+const DEFAULT_OPTIONS = {
+  channelCount: 2,
+  channelCountMode: "max",
+  channelInterpretation: "speakers",
+  offset: 1
+};
+const createConstantSourceNodeConstructor = (audioNodeConstructor, createAudioParam, createConstantSourceNodeRendererFactory, createNativeConstantSourceNode, getNativeContext, isNativeOfflineAudioContext, wrapEventListener) => {
+  return class ConstantSourceNode extends audioNodeConstructor {
+    constructor(context, options) {
+      const nativeContext = getNativeContext(context);
+      const mergedOptions = { ...DEFAULT_OPTIONS, ...options };
+      const nativeConstantSourceNode = createNativeConstantSourceNode(nativeContext, mergedOptions);
+      const isOffline = isNativeOfflineAudioContext(nativeContext);
+      const constantSourceNodeRenderer = isOffline ? createConstantSourceNodeRendererFactory() : null;
+      super(context, false, nativeConstantSourceNode, constantSourceNodeRenderer);
+      this._constantSourceNodeRenderer = constantSourceNodeRenderer;
+      this._nativeConstantSourceNode = nativeConstantSourceNode;
+      this._offset = createAudioParam(this, isOffline, nativeConstantSourceNode.offset, MOST_POSITIVE_SINGLE_FLOAT, MOST_NEGATIVE_SINGLE_FLOAT);
+      this._onended = null;
+    }
+    get offset() {
+      return this._offset;
+    }
+    get onended() {
+      return this._onended;
+    }
+    set onended(value) {
+      const wrappedListener = typeof value === "function" ? wrapEventListener(this, value) : null;
+      this._nativeConstantSourceNode.onended = wrappedListener;
+      const nativeOnEnded = this._nativeConstantSourceNode.onended;
+      this._onended = nativeOnEnded !== null && nativeOnEnded === wrappedListener ? value : nativeOnEnded;
+    }
+    start(when = 0) {
+      this._nativeConstantSourceNode.start(when);
+      if (this._constantSourceNodeRenderer !== null) {
+        this._constantSourceNodeRenderer.start = when;
+      }
+      if (this.context.state !== "closed") {
+        setInternalStateToActive(this);
+        const resetInternalStateToPassive = () => {
+          this._nativeConstantSourceNode.removeEventListener("ended", resetInternalStateToPassive);
+          if (isActiveAudioNode(this)) {
+            setInternalStateToPassive(this);
+          }
+        };
+        this._nativeConstantSourceNode.addEventListener("ended", resetInternalStateToPassive);
+      }
+    }
+    stop(when = 0) {
+      this._nativeConstantSourceNode.stop(when);
+      if (this._constantSourceNodeRenderer !== null) {
+        this._constantSourceNodeRenderer.stop = when;
+      }
+    }
+  };
+};
+export {
+  createConstantSourceNodeConstructor
+};

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

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const isOwnedByContext = require("../helpers/is-owned-by-context.cjs");
+const createConstantSourceNodeRendererFactory = (connectAudioParam, createNativeConstantSourceNode, getNativeAudioNode, renderAutomation, renderInputsOfAudioNode) => {
+  return () => {
+    const renderedNativeConstantSourceNodes = /* @__PURE__ */ new WeakMap();
+    let start = null;
+    let stop = null;
+    const createConstantSourceNode = async (proxy, nativeOfflineAudioContext) => {
+      let nativeConstantSourceNode = getNativeAudioNode(proxy);
+      const nativeConstantSourceNodeIsOwnedByContext = isOwnedByContext.isOwnedByContext(nativeConstantSourceNode, nativeOfflineAudioContext);
+      if (!nativeConstantSourceNodeIsOwnedByContext) {
+        const options = {
+          channelCount: nativeConstantSourceNode.channelCount,
+          channelCountMode: nativeConstantSourceNode.channelCountMode,
+          channelInterpretation: nativeConstantSourceNode.channelInterpretation,
+          offset: nativeConstantSourceNode.offset.value
+        };
+        nativeConstantSourceNode = createNativeConstantSourceNode(nativeOfflineAudioContext, options);
+        if (start !== null) {
+          nativeConstantSourceNode.start(start);
+        }
+        if (stop !== null) {
+          nativeConstantSourceNode.stop(stop);
+        }
+      }
+      renderedNativeConstantSourceNodes.set(nativeOfflineAudioContext, nativeConstantSourceNode);
+      if (!nativeConstantSourceNodeIsOwnedByContext) {
+        await renderAutomation(nativeOfflineAudioContext, proxy.offset, nativeConstantSourceNode.offset);
+      } else {
+        await connectAudioParam(nativeOfflineAudioContext, proxy.offset, nativeConstantSourceNode.offset);
+      }
+      await renderInputsOfAudioNode(proxy, nativeOfflineAudioContext, nativeConstantSourceNode);
+      return nativeConstantSourceNode;
+    };
+    return {
+      set start(value) {
+        start = value;
+      },
+      set stop(value) {
+        stop = value;
+      },
+      render(proxy, nativeOfflineAudioContext) {
+        const renderedNativeConstantSourceNode = renderedNativeConstantSourceNodes.get(nativeOfflineAudioContext);
+        if (renderedNativeConstantSourceNode !== void 0) {
+          return Promise.resolve(renderedNativeConstantSourceNode);
+        }
+        return createConstantSourceNode(proxy, nativeOfflineAudioContext);
+      }
+    };
+  };
+};
+exports.createConstantSourceNodeRendererFactory = createConstantSourceNodeRendererFactory;