react-audio-wavekit 0.1.4 → 0.1.6

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

@@ -0,0 +1,166 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const nativeAudioNodeFaker = require("../guards/native-audio-node-faker.cjs");
+const isOwnedByContext = require("../helpers/is-owned-by-context.cjs");
+const createPannerNodeRendererFactory = (connectAudioParam, createNativeChannelMergerNode, createNativeConstantSourceNode, createNativeGainNode, createNativePannerNode, getNativeAudioNode, nativeOfflineAudioContextConstructor, renderAutomation, renderInputsOfAudioNode, renderNativeOfflineAudioContext) => {
+  return () => {
+    const renderedNativeAudioNodes = /* @__PURE__ */ new WeakMap();
+    let renderedBufferPromise = null;
+    const createAudioNode = async (proxy, nativeOfflineAudioContext) => {
+      let nativeGainNode = null;
+      let nativePannerNode = getNativeAudioNode(proxy);
+      const commonAudioNodeOptions = {
+        channelCount: nativePannerNode.channelCount,
+        channelCountMode: nativePannerNode.channelCountMode,
+        channelInterpretation: nativePannerNode.channelInterpretation
+      };
+      const commonNativePannerNodeOptions = {
+        ...commonAudioNodeOptions,
+        coneInnerAngle: nativePannerNode.coneInnerAngle,
+        coneOuterAngle: nativePannerNode.coneOuterAngle,
+        coneOuterGain: nativePannerNode.coneOuterGain,
+        distanceModel: nativePannerNode.distanceModel,
+        maxDistance: nativePannerNode.maxDistance,
+        panningModel: nativePannerNode.panningModel,
+        refDistance: nativePannerNode.refDistance,
+        rolloffFactor: nativePannerNode.rolloffFactor
+      };
+      const nativePannerNodeIsOwnedByContext = isOwnedByContext.isOwnedByContext(nativePannerNode, nativeOfflineAudioContext);
+      if ("bufferSize" in nativePannerNode) {
+        nativeGainNode = createNativeGainNode(nativeOfflineAudioContext, { ...commonAudioNodeOptions, gain: 1 });
+      } else if (!nativePannerNodeIsOwnedByContext) {
+        const options = {
+          ...commonNativePannerNodeOptions,
+          orientationX: nativePannerNode.orientationX.value,
+          orientationY: nativePannerNode.orientationY.value,
+          orientationZ: nativePannerNode.orientationZ.value,
+          positionX: nativePannerNode.positionX.value,
+          positionY: nativePannerNode.positionY.value,
+          positionZ: nativePannerNode.positionZ.value
+        };
+        nativePannerNode = createNativePannerNode(nativeOfflineAudioContext, options);
+      }
+      renderedNativeAudioNodes.set(nativeOfflineAudioContext, nativeGainNode === null ? nativePannerNode : nativeGainNode);
+      if (nativeGainNode !== null) {
+        if (renderedBufferPromise === null) {
+          if (nativeOfflineAudioContextConstructor === null) {
+            throw new Error("Missing the native OfflineAudioContext constructor.");
+          }
+          const partialOfflineAudioContext = new nativeOfflineAudioContextConstructor(
+            6,
+            // Bug #17: Safari does not yet expose the length.
+            proxy.context.length,
+            nativeOfflineAudioContext.sampleRate
+          );
+          const nativeChannelMergerNode = createNativeChannelMergerNode(partialOfflineAudioContext, {
+            channelCount: 1,
+            channelCountMode: "explicit",
+            channelInterpretation: "speakers",
+            numberOfInputs: 6
+          });
+          nativeChannelMergerNode.connect(partialOfflineAudioContext.destination);
+          renderedBufferPromise = (async () => {
+            const nativeConstantSourceNodes = await Promise.all([
+              proxy.orientationX,
+              proxy.orientationY,
+              proxy.orientationZ,
+              proxy.positionX,
+              proxy.positionY,
+              proxy.positionZ
+            ].map(async (audioParam, index) => {
+              const nativeConstantSourceNode = createNativeConstantSourceNode(partialOfflineAudioContext, {
+                channelCount: 1,
+                channelCountMode: "explicit",
+                channelInterpretation: "discrete",
+                offset: index === 0 ? 1 : 0
+              });
+              await renderAutomation(partialOfflineAudioContext, audioParam, nativeConstantSourceNode.offset);
+              return nativeConstantSourceNode;
+            }));
+            for (let i = 0; i < 6; i += 1) {
+              nativeConstantSourceNodes[i].connect(nativeChannelMergerNode, 0, i);
+              nativeConstantSourceNodes[i].start(0);
+            }
+            return renderNativeOfflineAudioContext(partialOfflineAudioContext);
+          })();
+        }
+        const renderedBuffer = await renderedBufferPromise;
+        const inputGainNode = createNativeGainNode(nativeOfflineAudioContext, { ...commonAudioNodeOptions, gain: 1 });
+        await renderInputsOfAudioNode(proxy, nativeOfflineAudioContext, inputGainNode);
+        const channelDatas = [];
+        for (let i = 0; i < renderedBuffer.numberOfChannels; i += 1) {
+          channelDatas.push(renderedBuffer.getChannelData(i));
+        }
+        let lastOrientation = [channelDatas[0][0], channelDatas[1][0], channelDatas[2][0]];
+        let lastPosition = [channelDatas[3][0], channelDatas[4][0], channelDatas[5][0]];
+        let gateGainNode = createNativeGainNode(nativeOfflineAudioContext, { ...commonAudioNodeOptions, gain: 1 });
+        let partialPannerNode = createNativePannerNode(nativeOfflineAudioContext, {
+          ...commonNativePannerNodeOptions,
+          orientationX: lastOrientation[0],
+          orientationY: lastOrientation[1],
+          orientationZ: lastOrientation[2],
+          positionX: lastPosition[0],
+          positionY: lastPosition[1],
+          positionZ: lastPosition[2]
+        });
+        inputGainNode.connect(gateGainNode).connect(partialPannerNode.inputs[0]);
+        partialPannerNode.connect(nativeGainNode);
+        for (let i = 128; i < renderedBuffer.length; i += 128) {
+          const orientation = [channelDatas[0][i], channelDatas[1][i], channelDatas[2][i]];
+          const positon = [channelDatas[3][i], channelDatas[4][i], channelDatas[5][i]];
+          if (orientation.some((value, index) => value !== lastOrientation[index]) || positon.some((value, index) => value !== lastPosition[index])) {
+            lastOrientation = orientation;
+            lastPosition = positon;
+            const currentTime = i / nativeOfflineAudioContext.sampleRate;
+            gateGainNode.gain.setValueAtTime(0, currentTime);
+            gateGainNode = createNativeGainNode(nativeOfflineAudioContext, { ...commonAudioNodeOptions, gain: 0 });
+            partialPannerNode = createNativePannerNode(nativeOfflineAudioContext, {
+              ...commonNativePannerNodeOptions,
+              orientationX: lastOrientation[0],
+              orientationY: lastOrientation[1],
+              orientationZ: lastOrientation[2],
+              positionX: lastPosition[0],
+              positionY: lastPosition[1],
+              positionZ: lastPosition[2]
+            });
+            gateGainNode.gain.setValueAtTime(1, currentTime);
+            inputGainNode.connect(gateGainNode).connect(partialPannerNode.inputs[0]);
+            partialPannerNode.connect(nativeGainNode);
+          }
+        }
+        return nativeGainNode;
+      }
+      if (!nativePannerNodeIsOwnedByContext) {
+        await renderAutomation(nativeOfflineAudioContext, proxy.orientationX, nativePannerNode.orientationX);
+        await renderAutomation(nativeOfflineAudioContext, proxy.orientationY, nativePannerNode.orientationY);
+        await renderAutomation(nativeOfflineAudioContext, proxy.orientationZ, nativePannerNode.orientationZ);
+        await renderAutomation(nativeOfflineAudioContext, proxy.positionX, nativePannerNode.positionX);
+        await renderAutomation(nativeOfflineAudioContext, proxy.positionY, nativePannerNode.positionY);
+        await renderAutomation(nativeOfflineAudioContext, proxy.positionZ, nativePannerNode.positionZ);
+      } else {
+        await connectAudioParam(nativeOfflineAudioContext, proxy.orientationX, nativePannerNode.orientationX);
+        await connectAudioParam(nativeOfflineAudioContext, proxy.orientationY, nativePannerNode.orientationY);
+        await connectAudioParam(nativeOfflineAudioContext, proxy.orientationZ, nativePannerNode.orientationZ);
+        await connectAudioParam(nativeOfflineAudioContext, proxy.positionX, nativePannerNode.positionX);
+        await connectAudioParam(nativeOfflineAudioContext, proxy.positionY, nativePannerNode.positionY);
+        await connectAudioParam(nativeOfflineAudioContext, proxy.positionZ, nativePannerNode.positionZ);
+      }
+      if (nativeAudioNodeFaker.isNativeAudioNodeFaker(nativePannerNode)) {
+        await renderInputsOfAudioNode(proxy, nativeOfflineAudioContext, nativePannerNode.inputs[0]);
+      } else {
+        await renderInputsOfAudioNode(proxy, nativeOfflineAudioContext, nativePannerNode);
+      }
+      return nativePannerNode;
+    };
+    return {
+      render(proxy, nativeOfflineAudioContext) {
+        const renderedNativeGainNodeOrNativePannerNode = renderedNativeAudioNodes.get(nativeOfflineAudioContext);
+        if (renderedNativeGainNodeOrNativePannerNode !== void 0) {
+          return Promise.resolve(renderedNativeGainNodeOrNativePannerNode);
+        }
+        return createAudioNode(proxy, nativeOfflineAudioContext);
+      }
+    };
+  };
+};
+exports.createPannerNodeRendererFactory = createPannerNodeRendererFactory;

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

@@ -0,0 +1,166 @@
+import { isNativeAudioNodeFaker } from "../guards/native-audio-node-faker.js";
+import { isOwnedByContext } from "../helpers/is-owned-by-context.js";
+const createPannerNodeRendererFactory = (connectAudioParam, createNativeChannelMergerNode, createNativeConstantSourceNode, createNativeGainNode, createNativePannerNode, getNativeAudioNode, nativeOfflineAudioContextConstructor, renderAutomation, renderInputsOfAudioNode, renderNativeOfflineAudioContext) => {
+  return () => {
+    const renderedNativeAudioNodes = /* @__PURE__ */ new WeakMap();
+    let renderedBufferPromise = null;
+    const createAudioNode = async (proxy, nativeOfflineAudioContext) => {
+      let nativeGainNode = null;
+      let nativePannerNode = getNativeAudioNode(proxy);
+      const commonAudioNodeOptions = {
+        channelCount: nativePannerNode.channelCount,
+        channelCountMode: nativePannerNode.channelCountMode,
+        channelInterpretation: nativePannerNode.channelInterpretation
+      };
+      const commonNativePannerNodeOptions = {
+        ...commonAudioNodeOptions,
+        coneInnerAngle: nativePannerNode.coneInnerAngle,
+        coneOuterAngle: nativePannerNode.coneOuterAngle,
+        coneOuterGain: nativePannerNode.coneOuterGain,
+        distanceModel: nativePannerNode.distanceModel,
+        maxDistance: nativePannerNode.maxDistance,
+        panningModel: nativePannerNode.panningModel,
+        refDistance: nativePannerNode.refDistance,
+        rolloffFactor: nativePannerNode.rolloffFactor
+      };
+      const nativePannerNodeIsOwnedByContext = isOwnedByContext(nativePannerNode, nativeOfflineAudioContext);
+      if ("bufferSize" in nativePannerNode) {
+        nativeGainNode = createNativeGainNode(nativeOfflineAudioContext, { ...commonAudioNodeOptions, gain: 1 });
+      } else if (!nativePannerNodeIsOwnedByContext) {
+        const options = {
+          ...commonNativePannerNodeOptions,
+          orientationX: nativePannerNode.orientationX.value,
+          orientationY: nativePannerNode.orientationY.value,
+          orientationZ: nativePannerNode.orientationZ.value,
+          positionX: nativePannerNode.positionX.value,
+          positionY: nativePannerNode.positionY.value,
+          positionZ: nativePannerNode.positionZ.value
+        };
+        nativePannerNode = createNativePannerNode(nativeOfflineAudioContext, options);
+      }
+      renderedNativeAudioNodes.set(nativeOfflineAudioContext, nativeGainNode === null ? nativePannerNode : nativeGainNode);
+      if (nativeGainNode !== null) {
+        if (renderedBufferPromise === null) {
+          if (nativeOfflineAudioContextConstructor === null) {
+            throw new Error("Missing the native OfflineAudioContext constructor.");
+          }
+          const partialOfflineAudioContext = new nativeOfflineAudioContextConstructor(
+            6,
+            // Bug #17: Safari does not yet expose the length.
+            proxy.context.length,
+            nativeOfflineAudioContext.sampleRate
+          );
+          const nativeChannelMergerNode = createNativeChannelMergerNode(partialOfflineAudioContext, {
+            channelCount: 1,
+            channelCountMode: "explicit",
+            channelInterpretation: "speakers",
+            numberOfInputs: 6
+          });
+          nativeChannelMergerNode.connect(partialOfflineAudioContext.destination);
+          renderedBufferPromise = (async () => {
+            const nativeConstantSourceNodes = await Promise.all([
+              proxy.orientationX,
+              proxy.orientationY,
+              proxy.orientationZ,
+              proxy.positionX,
+              proxy.positionY,
+              proxy.positionZ
+            ].map(async (audioParam, index) => {
+              const nativeConstantSourceNode = createNativeConstantSourceNode(partialOfflineAudioContext, {
+                channelCount: 1,
+                channelCountMode: "explicit",
+                channelInterpretation: "discrete",
+                offset: index === 0 ? 1 : 0
+              });
+              await renderAutomation(partialOfflineAudioContext, audioParam, nativeConstantSourceNode.offset);
+              return nativeConstantSourceNode;
+            }));
+            for (let i = 0; i < 6; i += 1) {
+              nativeConstantSourceNodes[i].connect(nativeChannelMergerNode, 0, i);
+              nativeConstantSourceNodes[i].start(0);
+            }
+            return renderNativeOfflineAudioContext(partialOfflineAudioContext);
+          })();
+        }
+        const renderedBuffer = await renderedBufferPromise;
+        const inputGainNode = createNativeGainNode(nativeOfflineAudioContext, { ...commonAudioNodeOptions, gain: 1 });
+        await renderInputsOfAudioNode(proxy, nativeOfflineAudioContext, inputGainNode);
+        const channelDatas = [];
+        for (let i = 0; i < renderedBuffer.numberOfChannels; i += 1) {
+          channelDatas.push(renderedBuffer.getChannelData(i));
+        }
+        let lastOrientation = [channelDatas[0][0], channelDatas[1][0], channelDatas[2][0]];
+        let lastPosition = [channelDatas[3][0], channelDatas[4][0], channelDatas[5][0]];
+        let gateGainNode = createNativeGainNode(nativeOfflineAudioContext, { ...commonAudioNodeOptions, gain: 1 });
+        let partialPannerNode = createNativePannerNode(nativeOfflineAudioContext, {
+          ...commonNativePannerNodeOptions,
+          orientationX: lastOrientation[0],
+          orientationY: lastOrientation[1],
+          orientationZ: lastOrientation[2],
+          positionX: lastPosition[0],
+          positionY: lastPosition[1],
+          positionZ: lastPosition[2]
+        });
+        inputGainNode.connect(gateGainNode).connect(partialPannerNode.inputs[0]);
+        partialPannerNode.connect(nativeGainNode);
+        for (let i = 128; i < renderedBuffer.length; i += 128) {
+          const orientation = [channelDatas[0][i], channelDatas[1][i], channelDatas[2][i]];
+          const positon = [channelDatas[3][i], channelDatas[4][i], channelDatas[5][i]];
+          if (orientation.some((value, index) => value !== lastOrientation[index]) || positon.some((value, index) => value !== lastPosition[index])) {
+            lastOrientation = orientation;
+            lastPosition = positon;
+            const currentTime = i / nativeOfflineAudioContext.sampleRate;
+            gateGainNode.gain.setValueAtTime(0, currentTime);
+            gateGainNode = createNativeGainNode(nativeOfflineAudioContext, { ...commonAudioNodeOptions, gain: 0 });
+            partialPannerNode = createNativePannerNode(nativeOfflineAudioContext, {
+              ...commonNativePannerNodeOptions,
+              orientationX: lastOrientation[0],
+              orientationY: lastOrientation[1],
+              orientationZ: lastOrientation[2],
+              positionX: lastPosition[0],
+              positionY: lastPosition[1],
+              positionZ: lastPosition[2]
+            });
+            gateGainNode.gain.setValueAtTime(1, currentTime);
+            inputGainNode.connect(gateGainNode).connect(partialPannerNode.inputs[0]);
+            partialPannerNode.connect(nativeGainNode);
+          }
+        }
+        return nativeGainNode;
+      }
+      if (!nativePannerNodeIsOwnedByContext) {
+        await renderAutomation(nativeOfflineAudioContext, proxy.orientationX, nativePannerNode.orientationX);
+        await renderAutomation(nativeOfflineAudioContext, proxy.orientationY, nativePannerNode.orientationY);
+        await renderAutomation(nativeOfflineAudioContext, proxy.orientationZ, nativePannerNode.orientationZ);
+        await renderAutomation(nativeOfflineAudioContext, proxy.positionX, nativePannerNode.positionX);
+        await renderAutomation(nativeOfflineAudioContext, proxy.positionY, nativePannerNode.positionY);
+        await renderAutomation(nativeOfflineAudioContext, proxy.positionZ, nativePannerNode.positionZ);
+      } else {
+        await connectAudioParam(nativeOfflineAudioContext, proxy.orientationX, nativePannerNode.orientationX);
+        await connectAudioParam(nativeOfflineAudioContext, proxy.orientationY, nativePannerNode.orientationY);
+        await connectAudioParam(nativeOfflineAudioContext, proxy.orientationZ, nativePannerNode.orientationZ);
+        await connectAudioParam(nativeOfflineAudioContext, proxy.positionX, nativePannerNode.positionX);
+        await connectAudioParam(nativeOfflineAudioContext, proxy.positionY, nativePannerNode.positionY);
+        await connectAudioParam(nativeOfflineAudioContext, proxy.positionZ, nativePannerNode.positionZ);
+      }
+      if (isNativeAudioNodeFaker(nativePannerNode)) {
+        await renderInputsOfAudioNode(proxy, nativeOfflineAudioContext, nativePannerNode.inputs[0]);
+      } else {
+        await renderInputsOfAudioNode(proxy, nativeOfflineAudioContext, nativePannerNode);
+      }
+      return nativePannerNode;
+    };
+    return {
+      render(proxy, nativeOfflineAudioContext) {
+        const renderedNativeGainNodeOrNativePannerNode = renderedNativeAudioNodes.get(nativeOfflineAudioContext);
+        if (renderedNativeGainNodeOrNativePannerNode !== void 0) {
+          return Promise.resolve(renderedNativeGainNodeOrNativePannerNode);
+        }
+        return createAudioNode(proxy, nativeOfflineAudioContext);
+      }
+    };
+  };
+};
+export {
+  createPannerNodeRendererFactory
+};

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

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const DEFAULT_OPTIONS = {
+  disableNormalization: false
+};
+const createPeriodicWaveConstructor = (createNativePeriodicWave, getNativeContext, periodicWaveStore, sanitizePeriodicWaveOptions) => {
+  return class PeriodicWave {
+    constructor(context, options) {
+      const nativeContext = getNativeContext(context);
+      const mergedOptions = sanitizePeriodicWaveOptions({ ...DEFAULT_OPTIONS, ...options });
+      const periodicWave = createNativePeriodicWave(nativeContext, mergedOptions);
+      periodicWaveStore.add(periodicWave);
+      return periodicWave;
+    }
+    static [Symbol.hasInstance](instance) {
+      return instance !== null && typeof instance === "object" && Object.getPrototypeOf(instance) === PeriodicWave.prototype || periodicWaveStore.has(instance);
+    }
+  };
+};
+exports.createPeriodicWaveConstructor = createPeriodicWaveConstructor;

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

@@ -0,0 +1,20 @@
+const DEFAULT_OPTIONS = {
+  disableNormalization: false
+};
+const createPeriodicWaveConstructor = (createNativePeriodicWave, getNativeContext, periodicWaveStore, sanitizePeriodicWaveOptions) => {
+  return class PeriodicWave {
+    constructor(context, options) {
+      const nativeContext = getNativeContext(context);
+      const mergedOptions = sanitizePeriodicWaveOptions({ ...DEFAULT_OPTIONS, ...options });
+      const periodicWave = createNativePeriodicWave(nativeContext, mergedOptions);
+      periodicWaveStore.add(periodicWave);
+      return periodicWave;
+    }
+    static [Symbol.hasInstance](instance) {
+      return instance !== null && typeof instance === "object" && Object.getPrototypeOf(instance) === PeriodicWave.prototype || periodicWaveStore.has(instance);
+    }
+  };
+};
+export {
+  createPeriodicWaveConstructor
+};

package/dist/node_modules/standardized-audio-context/build/es2019/factories/render-automation.cjs

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

package/dist/node_modules/standardized-audio-context/build/es2019/factories/render-automation.js

@@ -0,0 +1,10 @@
+const createRenderAutomation = (getAudioParamRenderer, renderInputsOfAudioParam) => {
+  return (nativeOfflineAudioContext, audioParam, nativeAudioParam) => {
+    const audioParamRenderer = getAudioParamRenderer(audioParam);
+    audioParamRenderer.replay(nativeAudioParam);
+    return renderInputsOfAudioParam(audioParam, nativeOfflineAudioContext, nativeAudioParam);
+  };
+};
+export {
+  createRenderAutomation
+};

package/dist/node_modules/standardized-audio-context/build/es2019/factories/render-inputs-of-audio-node.cjs

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const createRenderInputsOfAudioNode = (getAudioNodeConnections, getAudioNodeRenderer, isPartOfACycle) => {
+  return async (audioNode, nativeOfflineAudioContext, nativeAudioNode) => {
+    const audioNodeConnections = getAudioNodeConnections(audioNode);
+    await Promise.all(audioNodeConnections.activeInputs.map((connections, input) => Array.from(connections).map(async ([source, output]) => {
+      const audioNodeRenderer = getAudioNodeRenderer(source);
+      const renderedNativeAudioNode = await audioNodeRenderer.render(source, nativeOfflineAudioContext);
+      const destination = audioNode.context.destination;
+      if (!isPartOfACycle(source) && (audioNode !== destination || !isPartOfACycle(audioNode))) {
+        renderedNativeAudioNode.connect(nativeAudioNode, output, input);
+      }
+    })).reduce((allRenderingPromises, renderingPromises) => [...allRenderingPromises, ...renderingPromises], []));
+  };
+};
+exports.createRenderInputsOfAudioNode = createRenderInputsOfAudioNode;

package/dist/node_modules/standardized-audio-context/build/es2019/factories/render-inputs-of-audio-node.js

@@ -0,0 +1,16 @@
+const createRenderInputsOfAudioNode = (getAudioNodeConnections, getAudioNodeRenderer, isPartOfACycle) => {
+  return async (audioNode, nativeOfflineAudioContext, nativeAudioNode) => {
+    const audioNodeConnections = getAudioNodeConnections(audioNode);
+    await Promise.all(audioNodeConnections.activeInputs.map((connections, input) => Array.from(connections).map(async ([source, output]) => {
+      const audioNodeRenderer = getAudioNodeRenderer(source);
+      const renderedNativeAudioNode = await audioNodeRenderer.render(source, nativeOfflineAudioContext);
+      const destination = audioNode.context.destination;
+      if (!isPartOfACycle(source) && (audioNode !== destination || !isPartOfACycle(audioNode))) {
+        renderedNativeAudioNode.connect(nativeAudioNode, output, input);
+      }
+    })).reduce((allRenderingPromises, renderingPromises) => [...allRenderingPromises, ...renderingPromises], []));
+  };
+};
+export {
+  createRenderInputsOfAudioNode
+};

package/dist/node_modules/standardized-audio-context/build/es2019/factories/render-inputs-of-audio-param.cjs

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const createRenderInputsOfAudioParam = (getAudioNodeRenderer, getAudioParamConnections, isPartOfACycle) => {
+  return async (audioParam, nativeOfflineAudioContext, nativeAudioParam) => {
+    const audioParamConnections = getAudioParamConnections(audioParam);
+    await Promise.all(Array.from(audioParamConnections.activeInputs).map(async ([source, output]) => {
+      const audioNodeRenderer = getAudioNodeRenderer(source);
+      const renderedNativeAudioNode = await audioNodeRenderer.render(source, nativeOfflineAudioContext);
+      if (!isPartOfACycle(source)) {
+        renderedNativeAudioNode.connect(nativeAudioParam, output);
+      }
+    }));
+  };
+};
+exports.createRenderInputsOfAudioParam = createRenderInputsOfAudioParam;

package/dist/node_modules/standardized-audio-context/build/es2019/factories/render-inputs-of-audio-param.js

@@ -0,0 +1,15 @@
+const createRenderInputsOfAudioParam = (getAudioNodeRenderer, getAudioParamConnections, isPartOfACycle) => {
+  return async (audioParam, nativeOfflineAudioContext, nativeAudioParam) => {
+    const audioParamConnections = getAudioParamConnections(audioParam);
+    await Promise.all(Array.from(audioParamConnections.activeInputs).map(async ([source, output]) => {
+      const audioNodeRenderer = getAudioNodeRenderer(source);
+      const renderedNativeAudioNode = await audioNodeRenderer.render(source, nativeOfflineAudioContext);
+      if (!isPartOfACycle(source)) {
+        renderedNativeAudioNode.connect(nativeAudioParam, output);
+      }
+    }));
+  };
+};
+export {
+  createRenderInputsOfAudioParam
+};

package/dist/node_modules/standardized-audio-context/build/es2019/factories/render-native-offline-audio-context.cjs

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const testPromiseSupport = require("../helpers/test-promise-support.cjs");
+const createRenderNativeOfflineAudioContext = (cacheTestResult, createNativeGainNode, createNativeScriptProcessorNode, testOfflineAudioContextCurrentTimeSupport) => {
+  return (nativeOfflineAudioContext) => {
+    if (cacheTestResult(testPromiseSupport.testPromiseSupport, () => testPromiseSupport.testPromiseSupport(nativeOfflineAudioContext))) {
+      return Promise.resolve(cacheTestResult(testOfflineAudioContextCurrentTimeSupport, testOfflineAudioContextCurrentTimeSupport)).then((isOfflineAudioContextCurrentTimeSupported) => {
+        if (!isOfflineAudioContextCurrentTimeSupported) {
+          const scriptProcessorNode = createNativeScriptProcessorNode(nativeOfflineAudioContext, 512, 0, 1);
+          nativeOfflineAudioContext.oncomplete = () => {
+            scriptProcessorNode.onaudioprocess = null;
+            scriptProcessorNode.disconnect();
+          };
+          scriptProcessorNode.onaudioprocess = () => nativeOfflineAudioContext.currentTime;
+          scriptProcessorNode.connect(nativeOfflineAudioContext.destination);
+        }
+        return nativeOfflineAudioContext.startRendering();
+      });
+    }
+    return new Promise((resolve) => {
+      const gainNode = createNativeGainNode(nativeOfflineAudioContext, {
+        channelCount: 1,
+        channelCountMode: "explicit",
+        channelInterpretation: "discrete",
+        gain: 0
+      });
+      nativeOfflineAudioContext.oncomplete = (event) => {
+        gainNode.disconnect();
+        resolve(event.renderedBuffer);
+      };
+      gainNode.connect(nativeOfflineAudioContext.destination);
+      nativeOfflineAudioContext.startRendering();
+    });
+  };
+};
+exports.createRenderNativeOfflineAudioContext = createRenderNativeOfflineAudioContext;

package/dist/node_modules/standardized-audio-context/build/es2019/factories/render-native-offline-audio-context.js

@@ -0,0 +1,36 @@
+import { testPromiseSupport } from "../helpers/test-promise-support.js";
+const createRenderNativeOfflineAudioContext = (cacheTestResult, createNativeGainNode, createNativeScriptProcessorNode, testOfflineAudioContextCurrentTimeSupport) => {
+  return (nativeOfflineAudioContext) => {
+    if (cacheTestResult(testPromiseSupport, () => testPromiseSupport(nativeOfflineAudioContext))) {
+      return Promise.resolve(cacheTestResult(testOfflineAudioContextCurrentTimeSupport, testOfflineAudioContextCurrentTimeSupport)).then((isOfflineAudioContextCurrentTimeSupported) => {
+        if (!isOfflineAudioContextCurrentTimeSupported) {
+          const scriptProcessorNode = createNativeScriptProcessorNode(nativeOfflineAudioContext, 512, 0, 1);
+          nativeOfflineAudioContext.oncomplete = () => {
+            scriptProcessorNode.onaudioprocess = null;
+            scriptProcessorNode.disconnect();
+          };
+          scriptProcessorNode.onaudioprocess = () => nativeOfflineAudioContext.currentTime;
+          scriptProcessorNode.connect(nativeOfflineAudioContext.destination);
+        }
+        return nativeOfflineAudioContext.startRendering();
+      });
+    }
+    return new Promise((resolve) => {
+      const gainNode = createNativeGainNode(nativeOfflineAudioContext, {
+        channelCount: 1,
+        channelCountMode: "explicit",
+        channelInterpretation: "discrete",
+        gain: 0
+      });
+      nativeOfflineAudioContext.oncomplete = (event) => {
+        gainNode.disconnect();
+        resolve(event.renderedBuffer);
+      };
+      gainNode.connect(nativeOfflineAudioContext.destination);
+      nativeOfflineAudioContext.startRendering();
+    });
+  };
+};
+export {
+  createRenderNativeOfflineAudioContext
+};

package/dist/node_modules/standardized-audio-context/build/es2019/factories/set-audio-node-tail-time.cjs

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const createSetAudioNodeTailTime = (audioNodeTailTimeStore) => {
+  return (audioNode, tailTime) => audioNodeTailTimeStore.set(audioNode, tailTime);
+};
+exports.createSetAudioNodeTailTime = createSetAudioNodeTailTime;

package/dist/node_modules/standardized-audio-context/build/es2019/factories/set-audio-node-tail-time.js

@@ -0,0 +1,6 @@
+const createSetAudioNodeTailTime = (audioNodeTailTimeStore) => {
+  return (audioNode, tailTime) => audioNodeTailTimeStore.set(audioNode, tailTime);
+};
+export {
+  createSetAudioNodeTailTime
+};

package/dist/node_modules/standardized-audio-context/build/es2019/factories/start-rendering.cjs

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const wrapAudioBufferGetChannelDataMethod = require("../helpers/wrap-audio-buffer-get-channel-data-method.cjs");
+const createStartRendering = (audioBufferStore, cacheTestResult, getAudioNodeRenderer, getUnrenderedAudioWorkletNodes, renderNativeOfflineAudioContext, testAudioBufferCopyChannelMethodsOutOfBoundsSupport, wrapAudioBufferCopyChannelMethods, wrapAudioBufferCopyChannelMethodsOutOfBounds) => {
+  return (destination, nativeOfflineAudioContext) => getAudioNodeRenderer(destination).render(destination, nativeOfflineAudioContext).then(() => Promise.all(Array.from(getUnrenderedAudioWorkletNodes(nativeOfflineAudioContext)).map((audioWorkletNode) => getAudioNodeRenderer(audioWorkletNode).render(audioWorkletNode, nativeOfflineAudioContext)))).then(() => renderNativeOfflineAudioContext(nativeOfflineAudioContext)).then((audioBuffer) => {
+    if (typeof audioBuffer.copyFromChannel !== "function") {
+      wrapAudioBufferCopyChannelMethods(audioBuffer);
+      wrapAudioBufferGetChannelDataMethod.wrapAudioBufferGetChannelDataMethod(audioBuffer);
+    } else if (!cacheTestResult(testAudioBufferCopyChannelMethodsOutOfBoundsSupport, () => testAudioBufferCopyChannelMethodsOutOfBoundsSupport(audioBuffer))) {
+      wrapAudioBufferCopyChannelMethodsOutOfBounds(audioBuffer);
+    }
+    audioBufferStore.add(audioBuffer);
+    return audioBuffer;
+  });
+};
+exports.createStartRendering = createStartRendering;

package/dist/node_modules/standardized-audio-context/build/es2019/factories/start-rendering.js

@@ -0,0 +1,16 @@
+import { wrapAudioBufferGetChannelDataMethod } from "../helpers/wrap-audio-buffer-get-channel-data-method.js";
+const createStartRendering = (audioBufferStore, cacheTestResult, getAudioNodeRenderer, getUnrenderedAudioWorkletNodes, renderNativeOfflineAudioContext, testAudioBufferCopyChannelMethodsOutOfBoundsSupport, wrapAudioBufferCopyChannelMethods, wrapAudioBufferCopyChannelMethodsOutOfBounds) => {
+  return (destination, nativeOfflineAudioContext) => getAudioNodeRenderer(destination).render(destination, nativeOfflineAudioContext).then(() => Promise.all(Array.from(getUnrenderedAudioWorkletNodes(nativeOfflineAudioContext)).map((audioWorkletNode) => getAudioNodeRenderer(audioWorkletNode).render(audioWorkletNode, nativeOfflineAudioContext)))).then(() => renderNativeOfflineAudioContext(nativeOfflineAudioContext)).then((audioBuffer) => {
+    if (typeof audioBuffer.copyFromChannel !== "function") {
+      wrapAudioBufferCopyChannelMethods(audioBuffer);
+      wrapAudioBufferGetChannelDataMethod(audioBuffer);
+    } else if (!cacheTestResult(testAudioBufferCopyChannelMethodsOutOfBoundsSupport, () => testAudioBufferCopyChannelMethodsOutOfBoundsSupport(audioBuffer))) {
+      wrapAudioBufferCopyChannelMethodsOutOfBounds(audioBuffer);
+    }
+    audioBufferStore.add(audioBuffer);
+    return audioBuffer;
+  });
+};
+export {
+  createStartRendering
+};

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

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const DEFAULT_OPTIONS = {
+  channelCount: 2,
+  /*
+   * Bug #105: The channelCountMode should be 'clamped-max' according to the spec but is set to 'explicit' to achieve consistent
+   * behavior.
+   */
+  channelCountMode: "explicit",
+  channelInterpretation: "speakers",
+  pan: 0
+};
+const createStereoPannerNodeConstructor = (audioNodeConstructor, createAudioParam, createNativeStereoPannerNode, createStereoPannerNodeRenderer, getNativeContext, isNativeOfflineAudioContext) => {
+  return class StereoPannerNode extends audioNodeConstructor {
+    constructor(context, options) {
+      const nativeContext = getNativeContext(context);
+      const mergedOptions = { ...DEFAULT_OPTIONS, ...options };
+      const nativeStereoPannerNode = createNativeStereoPannerNode(nativeContext, mergedOptions);
+      const isOffline = isNativeOfflineAudioContext(nativeContext);
+      const stereoPannerNodeRenderer = isOffline ? createStereoPannerNodeRenderer() : null;
+      super(context, false, nativeStereoPannerNode, stereoPannerNodeRenderer);
+      this._pan = createAudioParam(this, isOffline, nativeStereoPannerNode.pan);
+    }
+    get pan() {
+      return this._pan;
+    }
+  };
+};
+exports.createStereoPannerNodeConstructor = createStereoPannerNodeConstructor;

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

@@ -0,0 +1,29 @@
+const DEFAULT_OPTIONS = {
+  channelCount: 2,
+  /*
+   * Bug #105: The channelCountMode should be 'clamped-max' according to the spec but is set to 'explicit' to achieve consistent
+   * behavior.
+   */
+  channelCountMode: "explicit",
+  channelInterpretation: "speakers",
+  pan: 0
+};
+const createStereoPannerNodeConstructor = (audioNodeConstructor, createAudioParam, createNativeStereoPannerNode, createStereoPannerNodeRenderer, getNativeContext, isNativeOfflineAudioContext) => {
+  return class StereoPannerNode extends audioNodeConstructor {
+    constructor(context, options) {
+      const nativeContext = getNativeContext(context);
+      const mergedOptions = { ...DEFAULT_OPTIONS, ...options };
+      const nativeStereoPannerNode = createNativeStereoPannerNode(nativeContext, mergedOptions);
+      const isOffline = isNativeOfflineAudioContext(nativeContext);
+      const stereoPannerNodeRenderer = isOffline ? createStereoPannerNodeRenderer() : null;
+      super(context, false, nativeStereoPannerNode, stereoPannerNodeRenderer);
+      this._pan = createAudioParam(this, isOffline, nativeStereoPannerNode.pan);
+    }
+    get pan() {
+      return this._pan;
+    }
+  };
+};
+export {
+  createStereoPannerNodeConstructor
+};