react-audio-wavekit 0.1.5 → 0.1.7

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

@@ -0,0 +1,44 @@
+"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 createStereoPannerNodeRendererFactory = (connectAudioParam, createNativeStereoPannerNode, getNativeAudioNode, renderAutomation, renderInputsOfAudioNode) => {
+  return () => {
+    const renderedNativeStereoPannerNodes = /* @__PURE__ */ new WeakMap();
+    const createStereoPannerNode = async (proxy, nativeOfflineAudioContext) => {
+      let nativeStereoPannerNode = getNativeAudioNode(proxy);
+      const nativeStereoPannerNodeIsOwnedByContext = isOwnedByContext.isOwnedByContext(nativeStereoPannerNode, nativeOfflineAudioContext);
+      if (!nativeStereoPannerNodeIsOwnedByContext) {
+        const options = {
+          channelCount: nativeStereoPannerNode.channelCount,
+          channelCountMode: nativeStereoPannerNode.channelCountMode,
+          channelInterpretation: nativeStereoPannerNode.channelInterpretation,
+          pan: nativeStereoPannerNode.pan.value
+        };
+        nativeStereoPannerNode = createNativeStereoPannerNode(nativeOfflineAudioContext, options);
+      }
+      renderedNativeStereoPannerNodes.set(nativeOfflineAudioContext, nativeStereoPannerNode);
+      if (!nativeStereoPannerNodeIsOwnedByContext) {
+        await renderAutomation(nativeOfflineAudioContext, proxy.pan, nativeStereoPannerNode.pan);
+      } else {
+        await connectAudioParam(nativeOfflineAudioContext, proxy.pan, nativeStereoPannerNode.pan);
+      }
+      if (nativeAudioNodeFaker.isNativeAudioNodeFaker(nativeStereoPannerNode)) {
+        await renderInputsOfAudioNode(proxy, nativeOfflineAudioContext, nativeStereoPannerNode.inputs[0]);
+      } else {
+        await renderInputsOfAudioNode(proxy, nativeOfflineAudioContext, nativeStereoPannerNode);
+      }
+      return nativeStereoPannerNode;
+    };
+    return {
+      render(proxy, nativeOfflineAudioContext) {
+        const renderedNativeStereoPannerNode = renderedNativeStereoPannerNodes.get(nativeOfflineAudioContext);
+        if (renderedNativeStereoPannerNode !== void 0) {
+          return Promise.resolve(renderedNativeStereoPannerNode);
+        }
+        return createStereoPannerNode(proxy, nativeOfflineAudioContext);
+      }
+    };
+  };
+};
+exports.createStereoPannerNodeRendererFactory = createStereoPannerNodeRendererFactory;

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

@@ -0,0 +1,44 @@
+import { isNativeAudioNodeFaker } from "../guards/native-audio-node-faker.js";
+import { isOwnedByContext } from "../helpers/is-owned-by-context.js";
+const createStereoPannerNodeRendererFactory = (connectAudioParam, createNativeStereoPannerNode, getNativeAudioNode, renderAutomation, renderInputsOfAudioNode) => {
+  return () => {
+    const renderedNativeStereoPannerNodes = /* @__PURE__ */ new WeakMap();
+    const createStereoPannerNode = async (proxy, nativeOfflineAudioContext) => {
+      let nativeStereoPannerNode = getNativeAudioNode(proxy);
+      const nativeStereoPannerNodeIsOwnedByContext = isOwnedByContext(nativeStereoPannerNode, nativeOfflineAudioContext);
+      if (!nativeStereoPannerNodeIsOwnedByContext) {
+        const options = {
+          channelCount: nativeStereoPannerNode.channelCount,
+          channelCountMode: nativeStereoPannerNode.channelCountMode,
+          channelInterpretation: nativeStereoPannerNode.channelInterpretation,
+          pan: nativeStereoPannerNode.pan.value
+        };
+        nativeStereoPannerNode = createNativeStereoPannerNode(nativeOfflineAudioContext, options);
+      }
+      renderedNativeStereoPannerNodes.set(nativeOfflineAudioContext, nativeStereoPannerNode);
+      if (!nativeStereoPannerNodeIsOwnedByContext) {
+        await renderAutomation(nativeOfflineAudioContext, proxy.pan, nativeStereoPannerNode.pan);
+      } else {
+        await connectAudioParam(nativeOfflineAudioContext, proxy.pan, nativeStereoPannerNode.pan);
+      }
+      if (isNativeAudioNodeFaker(nativeStereoPannerNode)) {
+        await renderInputsOfAudioNode(proxy, nativeOfflineAudioContext, nativeStereoPannerNode.inputs[0]);
+      } else {
+        await renderInputsOfAudioNode(proxy, nativeOfflineAudioContext, nativeStereoPannerNode);
+      }
+      return nativeStereoPannerNode;
+    };
+    return {
+      render(proxy, nativeOfflineAudioContext) {
+        const renderedNativeStereoPannerNode = renderedNativeStereoPannerNodes.get(nativeOfflineAudioContext);
+        if (renderedNativeStereoPannerNode !== void 0) {
+          return Promise.resolve(renderedNativeStereoPannerNode);
+        }
+        return createStereoPannerNode(proxy, nativeOfflineAudioContext);
+      }
+    };
+  };
+};
+export {
+  createStereoPannerNodeRendererFactory
+};

package/dist/node_modules/standardized-audio-context/build/es2019/factories/test-audio-buffer-constructor-support.cjs

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const createTestAudioBufferConstructorSupport = (nativeAudioBufferConstructor) => {
+  return () => {
+    if (nativeAudioBufferConstructor === null) {
+      return false;
+    }
+    try {
+      new nativeAudioBufferConstructor({ length: 1, sampleRate: 44100 });
+    } catch {
+      return false;
+    }
+    return true;
+  };
+};
+exports.createTestAudioBufferConstructorSupport = createTestAudioBufferConstructorSupport;

package/dist/node_modules/standardized-audio-context/build/es2019/factories/test-audio-buffer-constructor-support.js

@@ -0,0 +1,16 @@
+const createTestAudioBufferConstructorSupport = (nativeAudioBufferConstructor) => {
+  return () => {
+    if (nativeAudioBufferConstructor === null) {
+      return false;
+    }
+    try {
+      new nativeAudioBufferConstructor({ length: 1, sampleRate: 44100 });
+    } catch {
+      return false;
+    }
+    return true;
+  };
+};
+export {
+  createTestAudioBufferConstructorSupport
+};

package/dist/node_modules/standardized-audio-context/build/es2019/factories/test-audio-worklet-processor-post-message-support.cjs

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const createTestAudioWorkletProcessorPostMessageSupport = (nativeAudioWorkletNodeConstructor, nativeOfflineAudioContextConstructor) => {
+  return async () => {
+    if (nativeAudioWorkletNodeConstructor === null) {
+      return true;
+    }
+    if (nativeOfflineAudioContextConstructor === null) {
+      return false;
+    }
+    const blob = new Blob(['class A extends AudioWorkletProcessor{process(i){this.port.postMessage(i,[i[0][0].buffer])}}registerProcessor("a",A)'], {
+      type: "application/javascript; charset=utf-8"
+    });
+    const offlineAudioContext = new nativeOfflineAudioContextConstructor(1, 128, 44100);
+    const url = URL.createObjectURL(blob);
+    let isEmittingMessageEvents = false;
+    let isEmittingProcessorErrorEvents = false;
+    try {
+      await offlineAudioContext.audioWorklet.addModule(url);
+      const audioWorkletNode = new nativeAudioWorkletNodeConstructor(offlineAudioContext, "a", { numberOfOutputs: 0 });
+      const oscillator = offlineAudioContext.createOscillator();
+      audioWorkletNode.port.onmessage = () => isEmittingMessageEvents = true;
+      audioWorkletNode.onprocessorerror = () => isEmittingProcessorErrorEvents = true;
+      oscillator.connect(audioWorkletNode);
+      oscillator.start(0);
+      await offlineAudioContext.startRendering();
+      await new Promise((resolve) => setTimeout(resolve));
+    } catch {
+    } finally {
+      URL.revokeObjectURL(url);
+    }
+    return isEmittingMessageEvents && !isEmittingProcessorErrorEvents;
+  };
+};
+exports.createTestAudioWorkletProcessorPostMessageSupport = createTestAudioWorkletProcessorPostMessageSupport;

package/dist/node_modules/standardized-audio-context/build/es2019/factories/test-audio-worklet-processor-post-message-support.js

@@ -0,0 +1,35 @@
+const createTestAudioWorkletProcessorPostMessageSupport = (nativeAudioWorkletNodeConstructor, nativeOfflineAudioContextConstructor) => {
+  return async () => {
+    if (nativeAudioWorkletNodeConstructor === null) {
+      return true;
+    }
+    if (nativeOfflineAudioContextConstructor === null) {
+      return false;
+    }
+    const blob = new Blob(['class A extends AudioWorkletProcessor{process(i){this.port.postMessage(i,[i[0][0].buffer])}}registerProcessor("a",A)'], {
+      type: "application/javascript; charset=utf-8"
+    });
+    const offlineAudioContext = new nativeOfflineAudioContextConstructor(1, 128, 44100);
+    const url = URL.createObjectURL(blob);
+    let isEmittingMessageEvents = false;
+    let isEmittingProcessorErrorEvents = false;
+    try {
+      await offlineAudioContext.audioWorklet.addModule(url);
+      const audioWorkletNode = new nativeAudioWorkletNodeConstructor(offlineAudioContext, "a", { numberOfOutputs: 0 });
+      const oscillator = offlineAudioContext.createOscillator();
+      audioWorkletNode.port.onmessage = () => isEmittingMessageEvents = true;
+      audioWorkletNode.onprocessorerror = () => isEmittingProcessorErrorEvents = true;
+      oscillator.connect(audioWorkletNode);
+      oscillator.start(0);
+      await offlineAudioContext.startRendering();
+      await new Promise((resolve) => setTimeout(resolve));
+    } catch {
+    } finally {
+      URL.revokeObjectURL(url);
+    }
+    return isEmittingMessageEvents && !isEmittingProcessorErrorEvents;
+  };
+};
+export {
+  createTestAudioWorkletProcessorPostMessageSupport
+};

package/dist/node_modules/standardized-audio-context/build/es2019/factories/test-offline-audio-context-current-time-support.cjs

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const createTestOfflineAudioContextCurrentTimeSupport = (createNativeGainNode, nativeOfflineAudioContextConstructor) => {
+  return () => {
+    if (nativeOfflineAudioContextConstructor === null) {
+      return Promise.resolve(false);
+    }
+    const nativeOfflineAudioContext = new nativeOfflineAudioContextConstructor(1, 1, 44100);
+    const gainNode = createNativeGainNode(nativeOfflineAudioContext, {
+      channelCount: 1,
+      channelCountMode: "explicit",
+      channelInterpretation: "discrete",
+      gain: 0
+    });
+    return new Promise((resolve) => {
+      nativeOfflineAudioContext.oncomplete = () => {
+        gainNode.disconnect();
+        resolve(nativeOfflineAudioContext.currentTime !== 0);
+      };
+      nativeOfflineAudioContext.startRendering();
+    });
+  };
+};
+exports.createTestOfflineAudioContextCurrentTimeSupport = createTestOfflineAudioContextCurrentTimeSupport;

package/dist/node_modules/standardized-audio-context/build/es2019/factories/test-offline-audio-context-current-time-support.js

@@ -0,0 +1,24 @@
+const createTestOfflineAudioContextCurrentTimeSupport = (createNativeGainNode, nativeOfflineAudioContextConstructor) => {
+  return () => {
+    if (nativeOfflineAudioContextConstructor === null) {
+      return Promise.resolve(false);
+    }
+    const nativeOfflineAudioContext = new nativeOfflineAudioContextConstructor(1, 1, 44100);
+    const gainNode = createNativeGainNode(nativeOfflineAudioContext, {
+      channelCount: 1,
+      channelCountMode: "explicit",
+      channelInterpretation: "discrete",
+      gain: 0
+    });
+    return new Promise((resolve) => {
+      nativeOfflineAudioContext.oncomplete = () => {
+        gainNode.disconnect();
+        resolve(nativeOfflineAudioContext.currentTime !== 0);
+      };
+      nativeOfflineAudioContext.startRendering();
+    });
+  };
+};
+export {
+  createTestOfflineAudioContextCurrentTimeSupport
+};

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

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const DEFAULT_OPTIONS = {
+  channelCount: 2,
+  channelCountMode: "max",
+  channelInterpretation: "speakers",
+  curve: null,
+  oversample: "none"
+};
+const createWaveShaperNodeConstructor = (audioNodeConstructor, createInvalidStateError, createNativeWaveShaperNode, createWaveShaperNodeRenderer, getNativeContext, isNativeOfflineAudioContext, setAudioNodeTailTime) => {
+  return class WaveShaperNode extends audioNodeConstructor {
+    constructor(context, options) {
+      const nativeContext = getNativeContext(context);
+      const mergedOptions = { ...DEFAULT_OPTIONS, ...options };
+      const nativeWaveShaperNode = createNativeWaveShaperNode(nativeContext, mergedOptions);
+      const isOffline = isNativeOfflineAudioContext(nativeContext);
+      const waveShaperNodeRenderer = isOffline ? createWaveShaperNodeRenderer() : null;
+      super(context, true, nativeWaveShaperNode, waveShaperNodeRenderer);
+      this._isCurveNullified = false;
+      this._nativeWaveShaperNode = nativeWaveShaperNode;
+      setAudioNodeTailTime(this, 1);
+    }
+    get curve() {
+      if (this._isCurveNullified) {
+        return null;
+      }
+      return this._nativeWaveShaperNode.curve;
+    }
+    set curve(value) {
+      if (value === null) {
+        this._isCurveNullified = true;
+        this._nativeWaveShaperNode.curve = new Float32Array([0, 0]);
+      } else {
+        if (value.length < 2) {
+          throw createInvalidStateError();
+        }
+        this._isCurveNullified = false;
+        this._nativeWaveShaperNode.curve = value;
+      }
+    }
+    get oversample() {
+      return this._nativeWaveShaperNode.oversample;
+    }
+    set oversample(value) {
+      this._nativeWaveShaperNode.oversample = value;
+    }
+  };
+};
+exports.createWaveShaperNodeConstructor = createWaveShaperNodeConstructor;

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

@@ -0,0 +1,49 @@
+const DEFAULT_OPTIONS = {
+  channelCount: 2,
+  channelCountMode: "max",
+  channelInterpretation: "speakers",
+  curve: null,
+  oversample: "none"
+};
+const createWaveShaperNodeConstructor = (audioNodeConstructor, createInvalidStateError, createNativeWaveShaperNode, createWaveShaperNodeRenderer, getNativeContext, isNativeOfflineAudioContext, setAudioNodeTailTime) => {
+  return class WaveShaperNode extends audioNodeConstructor {
+    constructor(context, options) {
+      const nativeContext = getNativeContext(context);
+      const mergedOptions = { ...DEFAULT_OPTIONS, ...options };
+      const nativeWaveShaperNode = createNativeWaveShaperNode(nativeContext, mergedOptions);
+      const isOffline = isNativeOfflineAudioContext(nativeContext);
+      const waveShaperNodeRenderer = isOffline ? createWaveShaperNodeRenderer() : null;
+      super(context, true, nativeWaveShaperNode, waveShaperNodeRenderer);
+      this._isCurveNullified = false;
+      this._nativeWaveShaperNode = nativeWaveShaperNode;
+      setAudioNodeTailTime(this, 1);
+    }
+    get curve() {
+      if (this._isCurveNullified) {
+        return null;
+      }
+      return this._nativeWaveShaperNode.curve;
+    }
+    set curve(value) {
+      if (value === null) {
+        this._isCurveNullified = true;
+        this._nativeWaveShaperNode.curve = new Float32Array([0, 0]);
+      } else {
+        if (value.length < 2) {
+          throw createInvalidStateError();
+        }
+        this._isCurveNullified = false;
+        this._nativeWaveShaperNode.curve = value;
+      }
+    }
+    get oversample() {
+      return this._nativeWaveShaperNode.oversample;
+    }
+    set oversample(value) {
+      this._nativeWaveShaperNode.oversample = value;
+    }
+  };
+};
+export {
+  createWaveShaperNodeConstructor
+};

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

@@ -0,0 +1,40 @@
+"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 createWaveShaperNodeRendererFactory = (createNativeWaveShaperNode, getNativeAudioNode, renderInputsOfAudioNode) => {
+  return () => {
+    const renderedNativeWaveShaperNodes = /* @__PURE__ */ new WeakMap();
+    const createWaveShaperNode = async (proxy, nativeOfflineAudioContext) => {
+      let nativeWaveShaperNode = getNativeAudioNode(proxy);
+      const nativeWaveShaperNodeIsOwnedByContext = isOwnedByContext.isOwnedByContext(nativeWaveShaperNode, nativeOfflineAudioContext);
+      if (!nativeWaveShaperNodeIsOwnedByContext) {
+        const options = {
+          channelCount: nativeWaveShaperNode.channelCount,
+          channelCountMode: nativeWaveShaperNode.channelCountMode,
+          channelInterpretation: nativeWaveShaperNode.channelInterpretation,
+          curve: nativeWaveShaperNode.curve,
+          oversample: nativeWaveShaperNode.oversample
+        };
+        nativeWaveShaperNode = createNativeWaveShaperNode(nativeOfflineAudioContext, options);
+      }
+      renderedNativeWaveShaperNodes.set(nativeOfflineAudioContext, nativeWaveShaperNode);
+      if (nativeAudioNodeFaker.isNativeAudioNodeFaker(nativeWaveShaperNode)) {
+        await renderInputsOfAudioNode(proxy, nativeOfflineAudioContext, nativeWaveShaperNode.inputs[0]);
+      } else {
+        await renderInputsOfAudioNode(proxy, nativeOfflineAudioContext, nativeWaveShaperNode);
+      }
+      return nativeWaveShaperNode;
+    };
+    return {
+      render(proxy, nativeOfflineAudioContext) {
+        const renderedNativeWaveShaperNode = renderedNativeWaveShaperNodes.get(nativeOfflineAudioContext);
+        if (renderedNativeWaveShaperNode !== void 0) {
+          return Promise.resolve(renderedNativeWaveShaperNode);
+        }
+        return createWaveShaperNode(proxy, nativeOfflineAudioContext);
+      }
+    };
+  };
+};
+exports.createWaveShaperNodeRendererFactory = createWaveShaperNodeRendererFactory;

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

@@ -0,0 +1,40 @@
+import { isNativeAudioNodeFaker } from "../guards/native-audio-node-faker.js";
+import { isOwnedByContext } from "../helpers/is-owned-by-context.js";
+const createWaveShaperNodeRendererFactory = (createNativeWaveShaperNode, getNativeAudioNode, renderInputsOfAudioNode) => {
+  return () => {
+    const renderedNativeWaveShaperNodes = /* @__PURE__ */ new WeakMap();
+    const createWaveShaperNode = async (proxy, nativeOfflineAudioContext) => {
+      let nativeWaveShaperNode = getNativeAudioNode(proxy);
+      const nativeWaveShaperNodeIsOwnedByContext = isOwnedByContext(nativeWaveShaperNode, nativeOfflineAudioContext);
+      if (!nativeWaveShaperNodeIsOwnedByContext) {
+        const options = {
+          channelCount: nativeWaveShaperNode.channelCount,
+          channelCountMode: nativeWaveShaperNode.channelCountMode,
+          channelInterpretation: nativeWaveShaperNode.channelInterpretation,
+          curve: nativeWaveShaperNode.curve,
+          oversample: nativeWaveShaperNode.oversample
+        };
+        nativeWaveShaperNode = createNativeWaveShaperNode(nativeOfflineAudioContext, options);
+      }
+      renderedNativeWaveShaperNodes.set(nativeOfflineAudioContext, nativeWaveShaperNode);
+      if (isNativeAudioNodeFaker(nativeWaveShaperNode)) {
+        await renderInputsOfAudioNode(proxy, nativeOfflineAudioContext, nativeWaveShaperNode.inputs[0]);
+      } else {
+        await renderInputsOfAudioNode(proxy, nativeOfflineAudioContext, nativeWaveShaperNode);
+      }
+      return nativeWaveShaperNode;
+    };
+    return {
+      render(proxy, nativeOfflineAudioContext) {
+        const renderedNativeWaveShaperNode = renderedNativeWaveShaperNodes.get(nativeOfflineAudioContext);
+        if (renderedNativeWaveShaperNode !== void 0) {
+          return Promise.resolve(renderedNativeWaveShaperNode);
+        }
+        return createWaveShaperNode(proxy, nativeOfflineAudioContext);
+      }
+    };
+  };
+};
+export {
+  createWaveShaperNodeRendererFactory
+};

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

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const createWindow = () => typeof window === "undefined" ? null : window;
+exports.createWindow = createWindow;

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

@@ -0,0 +1,4 @@
+const createWindow = () => typeof window === "undefined" ? null : window;
+export {
+  createWindow
+};

package/dist/node_modules/standardized-audio-context/build/es2019/factories/wrap-audio-buffer-copy-channel-methods-out-of-bounds.cjs

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const createWrapAudioBufferCopyChannelMethodsOutOfBounds = (convertNumberToUnsignedLong) => {
+  return (audioBuffer) => {
+    audioBuffer.copyFromChannel = /* @__PURE__ */ ((copyFromChannel) => {
+      return (destination, channelNumberAsNumber, bufferOffsetAsNumber = 0) => {
+        const bufferOffset = convertNumberToUnsignedLong(bufferOffsetAsNumber);
+        const channelNumber = convertNumberToUnsignedLong(channelNumberAsNumber);
+        if (bufferOffset < audioBuffer.length) {
+          return copyFromChannel.call(audioBuffer, destination, channelNumber, bufferOffset);
+        }
+      };
+    })(audioBuffer.copyFromChannel);
+    audioBuffer.copyToChannel = /* @__PURE__ */ ((copyToChannel) => {
+      return (source, channelNumberAsNumber, bufferOffsetAsNumber = 0) => {
+        const bufferOffset = convertNumberToUnsignedLong(bufferOffsetAsNumber);
+        const channelNumber = convertNumberToUnsignedLong(channelNumberAsNumber);
+        if (bufferOffset < audioBuffer.length) {
+          return copyToChannel.call(audioBuffer, source, channelNumber, bufferOffset);
+        }
+      };
+    })(audioBuffer.copyToChannel);
+  };
+};
+exports.createWrapAudioBufferCopyChannelMethodsOutOfBounds = createWrapAudioBufferCopyChannelMethodsOutOfBounds;

package/dist/node_modules/standardized-audio-context/build/es2019/factories/wrap-audio-buffer-copy-channel-methods-out-of-bounds.js

@@ -0,0 +1,25 @@
+const createWrapAudioBufferCopyChannelMethodsOutOfBounds = (convertNumberToUnsignedLong) => {
+  return (audioBuffer) => {
+    audioBuffer.copyFromChannel = /* @__PURE__ */ ((copyFromChannel) => {
+      return (destination, channelNumberAsNumber, bufferOffsetAsNumber = 0) => {
+        const bufferOffset = convertNumberToUnsignedLong(bufferOffsetAsNumber);
+        const channelNumber = convertNumberToUnsignedLong(channelNumberAsNumber);
+        if (bufferOffset < audioBuffer.length) {
+          return copyFromChannel.call(audioBuffer, destination, channelNumber, bufferOffset);
+        }
+      };
+    })(audioBuffer.copyFromChannel);
+    audioBuffer.copyToChannel = /* @__PURE__ */ ((copyToChannel) => {
+      return (source, channelNumberAsNumber, bufferOffsetAsNumber = 0) => {
+        const bufferOffset = convertNumberToUnsignedLong(bufferOffsetAsNumber);
+        const channelNumber = convertNumberToUnsignedLong(channelNumberAsNumber);
+        if (bufferOffset < audioBuffer.length) {
+          return copyToChannel.call(audioBuffer, source, channelNumber, bufferOffset);
+        }
+      };
+    })(audioBuffer.copyToChannel);
+  };
+};
+export {
+  createWrapAudioBufferCopyChannelMethodsOutOfBounds
+};

package/dist/node_modules/standardized-audio-context/build/es2019/factories/wrap-audio-buffer-copy-channel-methods.cjs

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const createWrapAudioBufferCopyChannelMethods = (convertNumberToUnsignedLong, createIndexSizeError) => {
+  return (audioBuffer) => {
+    audioBuffer.copyFromChannel = (destination, channelNumberAsNumber, bufferOffsetAsNumber = 0) => {
+      const bufferOffset = convertNumberToUnsignedLong(bufferOffsetAsNumber);
+      const channelNumber = convertNumberToUnsignedLong(channelNumberAsNumber);
+      if (channelNumber >= audioBuffer.numberOfChannels) {
+        throw createIndexSizeError();
+      }
+      const audioBufferLength = audioBuffer.length;
+      const channelData = audioBuffer.getChannelData(channelNumber);
+      const destinationLength = destination.length;
+      for (let i = bufferOffset < 0 ? -bufferOffset : 0; i + bufferOffset < audioBufferLength && i < destinationLength; i += 1) {
+        destination[i] = channelData[i + bufferOffset];
+      }
+    };
+    audioBuffer.copyToChannel = (source, channelNumberAsNumber, bufferOffsetAsNumber = 0) => {
+      const bufferOffset = convertNumberToUnsignedLong(bufferOffsetAsNumber);
+      const channelNumber = convertNumberToUnsignedLong(channelNumberAsNumber);
+      if (channelNumber >= audioBuffer.numberOfChannels) {
+        throw createIndexSizeError();
+      }
+      const audioBufferLength = audioBuffer.length;
+      const channelData = audioBuffer.getChannelData(channelNumber);
+      const sourceLength = source.length;
+      for (let i = bufferOffset < 0 ? -bufferOffset : 0; i + bufferOffset < audioBufferLength && i < sourceLength; i += 1) {
+        channelData[i + bufferOffset] = source[i];
+      }
+    };
+  };
+};
+exports.createWrapAudioBufferCopyChannelMethods = createWrapAudioBufferCopyChannelMethods;

package/dist/node_modules/standardized-audio-context/build/es2019/factories/wrap-audio-buffer-copy-channel-methods.js

@@ -0,0 +1,33 @@
+const createWrapAudioBufferCopyChannelMethods = (convertNumberToUnsignedLong, createIndexSizeError) => {
+  return (audioBuffer) => {
+    audioBuffer.copyFromChannel = (destination, channelNumberAsNumber, bufferOffsetAsNumber = 0) => {
+      const bufferOffset = convertNumberToUnsignedLong(bufferOffsetAsNumber);
+      const channelNumber = convertNumberToUnsignedLong(channelNumberAsNumber);
+      if (channelNumber >= audioBuffer.numberOfChannels) {
+        throw createIndexSizeError();
+      }
+      const audioBufferLength = audioBuffer.length;
+      const channelData = audioBuffer.getChannelData(channelNumber);
+      const destinationLength = destination.length;
+      for (let i = bufferOffset < 0 ? -bufferOffset : 0; i + bufferOffset < audioBufferLength && i < destinationLength; i += 1) {
+        destination[i] = channelData[i + bufferOffset];
+      }
+    };
+    audioBuffer.copyToChannel = (source, channelNumberAsNumber, bufferOffsetAsNumber = 0) => {
+      const bufferOffset = convertNumberToUnsignedLong(bufferOffsetAsNumber);
+      const channelNumber = convertNumberToUnsignedLong(channelNumberAsNumber);
+      if (channelNumber >= audioBuffer.numberOfChannels) {
+        throw createIndexSizeError();
+      }
+      const audioBufferLength = audioBuffer.length;
+      const channelData = audioBuffer.getChannelData(channelNumber);
+      const sourceLength = source.length;
+      for (let i = bufferOffset < 0 ? -bufferOffset : 0; i + bufferOffset < audioBufferLength && i < sourceLength; i += 1) {
+        channelData[i + bufferOffset] = source[i];
+      }
+    };
+  };
+};
+export {
+  createWrapAudioBufferCopyChannelMethods
+};

package/dist/node_modules/standardized-audio-context/build/es2019/factories/wrap-audio-buffer-source-node-stop-method-nullified-buffer.cjs

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const createWrapAudioBufferSourceNodeStopMethodNullifiedBuffer = (overwriteAccessors) => {
+  return (nativeAudioBufferSourceNode, nativeContext) => {
+    const nullifiedBuffer = nativeContext.createBuffer(1, 1, 44100);
+    if (nativeAudioBufferSourceNode.buffer === null) {
+      nativeAudioBufferSourceNode.buffer = nullifiedBuffer;
+    }
+    overwriteAccessors(nativeAudioBufferSourceNode, "buffer", (get) => () => {
+      const value = get.call(nativeAudioBufferSourceNode);
+      return value === nullifiedBuffer ? null : value;
+    }, (set) => (value) => {
+      return set.call(nativeAudioBufferSourceNode, value === null ? nullifiedBuffer : value);
+    });
+  };
+};
+exports.createWrapAudioBufferSourceNodeStopMethodNullifiedBuffer = createWrapAudioBufferSourceNodeStopMethodNullifiedBuffer;

package/dist/node_modules/standardized-audio-context/build/es2019/factories/wrap-audio-buffer-source-node-stop-method-nullified-buffer.js

@@ -0,0 +1,17 @@
+const createWrapAudioBufferSourceNodeStopMethodNullifiedBuffer = (overwriteAccessors) => {
+  return (nativeAudioBufferSourceNode, nativeContext) => {
+    const nullifiedBuffer = nativeContext.createBuffer(1, 1, 44100);
+    if (nativeAudioBufferSourceNode.buffer === null) {
+      nativeAudioBufferSourceNode.buffer = nullifiedBuffer;
+    }
+    overwriteAccessors(nativeAudioBufferSourceNode, "buffer", (get) => () => {
+      const value = get.call(nativeAudioBufferSourceNode);
+      return value === nullifiedBuffer ? null : value;
+    }, (set) => (value) => {
+      return set.call(nativeAudioBufferSourceNode, value === null ? nullifiedBuffer : value);
+    });
+  };
+};
+export {
+  createWrapAudioBufferSourceNodeStopMethodNullifiedBuffer
+};

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

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const createWrapChannelMergerNode = (createInvalidStateError, monitorConnections) => {
+  return (nativeContext, channelMergerNode) => {
+    channelMergerNode.channelCount = 1;
+    channelMergerNode.channelCountMode = "explicit";
+    Object.defineProperty(channelMergerNode, "channelCount", {
+      get: () => 1,
+      set: () => {
+        throw createInvalidStateError();
+      }
+    });
+    Object.defineProperty(channelMergerNode, "channelCountMode", {
+      get: () => "explicit",
+      set: () => {
+        throw createInvalidStateError();
+      }
+    });
+    const audioBufferSourceNode = nativeContext.createBufferSource();
+    const whenConnected = () => {
+      const length = channelMergerNode.numberOfInputs;
+      for (let i = 0; i < length; i += 1) {
+        audioBufferSourceNode.connect(channelMergerNode, 0, i);
+      }
+    };
+    const whenDisconnected = () => audioBufferSourceNode.disconnect(channelMergerNode);
+    monitorConnections(channelMergerNode, whenConnected, whenDisconnected);
+  };
+};
+exports.createWrapChannelMergerNode = createWrapChannelMergerNode;