react-audio-wavekit 0.1.4 → 0.1.6

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

@@ -0,0 +1,8 @@
+const createIsNativeOfflineAudioContext = (nativeOfflineAudioContextConstructor) => {
+  return (anything) => {
+    return nativeOfflineAudioContextConstructor !== null && anything instanceof nativeOfflineAudioContextConstructor;
+  };
+};
+export {
+  createIsNativeOfflineAudioContext
+};

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

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const createIsSecureContext = (window) => window !== null && window.isSecureContext;
+exports.createIsSecureContext = createIsSecureContext;

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

@@ -0,0 +1,4 @@
+const createIsSecureContext = (window) => window !== null && window.isSecureContext;
+export {
+  createIsSecureContext
+};

package/dist/node_modules/standardized-audio-context/build/es2019/factories/minimal-base-audio-context-constructor.cjs

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const globals = require("../globals.cjs");
+const createMinimalBaseAudioContextConstructor = (audioDestinationNodeConstructor, createAudioListener, eventTargetConstructor, isNativeOfflineAudioContext, unrenderedAudioWorkletNodeStore, wrapEventListener) => {
+  return class MinimalBaseAudioContext extends eventTargetConstructor {
+    constructor(_nativeContext, numberOfChannels) {
+      super(_nativeContext);
+      this._nativeContext = _nativeContext;
+      globals.CONTEXT_STORE.set(this, _nativeContext);
+      if (isNativeOfflineAudioContext(_nativeContext)) {
+        unrenderedAudioWorkletNodeStore.set(_nativeContext, /* @__PURE__ */ new Set());
+      }
+      this._destination = new audioDestinationNodeConstructor(this, numberOfChannels);
+      this._listener = createAudioListener(this, _nativeContext);
+      this._onstatechange = null;
+    }
+    get currentTime() {
+      return this._nativeContext.currentTime;
+    }
+    get destination() {
+      return this._destination;
+    }
+    get listener() {
+      return this._listener;
+    }
+    get onstatechange() {
+      return this._onstatechange;
+    }
+    set onstatechange(value) {
+      const wrappedListener = typeof value === "function" ? wrapEventListener(this, value) : null;
+      this._nativeContext.onstatechange = wrappedListener;
+      const nativeOnStateChange = this._nativeContext.onstatechange;
+      this._onstatechange = nativeOnStateChange !== null && nativeOnStateChange === wrappedListener ? value : nativeOnStateChange;
+    }
+    get sampleRate() {
+      return this._nativeContext.sampleRate;
+    }
+    get state() {
+      return this._nativeContext.state;
+    }
+  };
+};
+exports.createMinimalBaseAudioContextConstructor = createMinimalBaseAudioContextConstructor;

package/dist/node_modules/standardized-audio-context/build/es2019/factories/minimal-base-audio-context-constructor.js

@@ -0,0 +1,43 @@
+import { CONTEXT_STORE } from "../globals.js";
+const createMinimalBaseAudioContextConstructor = (audioDestinationNodeConstructor, createAudioListener, eventTargetConstructor, isNativeOfflineAudioContext, unrenderedAudioWorkletNodeStore, wrapEventListener) => {
+  return class MinimalBaseAudioContext extends eventTargetConstructor {
+    constructor(_nativeContext, numberOfChannels) {
+      super(_nativeContext);
+      this._nativeContext = _nativeContext;
+      CONTEXT_STORE.set(this, _nativeContext);
+      if (isNativeOfflineAudioContext(_nativeContext)) {
+        unrenderedAudioWorkletNodeStore.set(_nativeContext, /* @__PURE__ */ new Set());
+      }
+      this._destination = new audioDestinationNodeConstructor(this, numberOfChannels);
+      this._listener = createAudioListener(this, _nativeContext);
+      this._onstatechange = null;
+    }
+    get currentTime() {
+      return this._nativeContext.currentTime;
+    }
+    get destination() {
+      return this._destination;
+    }
+    get listener() {
+      return this._listener;
+    }
+    get onstatechange() {
+      return this._onstatechange;
+    }
+    set onstatechange(value) {
+      const wrappedListener = typeof value === "function" ? wrapEventListener(this, value) : null;
+      this._nativeContext.onstatechange = wrappedListener;
+      const nativeOnStateChange = this._nativeContext.onstatechange;
+      this._onstatechange = nativeOnStateChange !== null && nativeOnStateChange === wrappedListener ? value : nativeOnStateChange;
+    }
+    get sampleRate() {
+      return this._nativeContext.sampleRate;
+    }
+    get state() {
+      return this._nativeContext.state;
+    }
+  };
+};
+export {
+  createMinimalBaseAudioContextConstructor
+};

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

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const createMonitorConnections = (insertElementInSet, isNativeAudioNode) => {
+  return (nativeAudioNode, whenConnected, whenDisconnected) => {
+    const connections = /* @__PURE__ */ new Set();
+    nativeAudioNode.connect = /* @__PURE__ */ ((connect) => {
+      return (destination, output = 0, input = 0) => {
+        const wasDisconnected = connections.size === 0;
+        if (isNativeAudioNode(destination)) {
+          connect.call(nativeAudioNode, destination, output, input);
+          insertElementInSet(connections, [destination, output, input], (connection) => connection[0] === destination && connection[1] === output && connection[2] === input, true);
+          if (wasDisconnected) {
+            whenConnected();
+          }
+          return destination;
+        }
+        connect.call(nativeAudioNode, destination, output);
+        insertElementInSet(connections, [destination, output], (connection) => connection[0] === destination && connection[1] === output, true);
+        if (wasDisconnected) {
+          whenConnected();
+        }
+        return;
+      };
+    })(nativeAudioNode.connect);
+    nativeAudioNode.disconnect = /* @__PURE__ */ ((disconnect) => {
+      return (destinationOrOutput, output, input) => {
+        const wasConnected = connections.size > 0;
+        if (destinationOrOutput === void 0) {
+          disconnect.apply(nativeAudioNode);
+          connections.clear();
+        } else if (typeof destinationOrOutput === "number") {
+          disconnect.call(nativeAudioNode, destinationOrOutput);
+          for (const connection of connections) {
+            if (connection[1] === destinationOrOutput) {
+              connections.delete(connection);
+            }
+          }
+        } else {
+          if (isNativeAudioNode(destinationOrOutput)) {
+            disconnect.call(nativeAudioNode, destinationOrOutput, output, input);
+          } else {
+            disconnect.call(nativeAudioNode, destinationOrOutput, output);
+          }
+          for (const connection of connections) {
+            if (connection[0] === destinationOrOutput && (output === void 0 || connection[1] === output) && (input === void 0 || connection[2] === input)) {
+              connections.delete(connection);
+            }
+          }
+        }
+        const isDisconnected = connections.size === 0;
+        if (wasConnected && isDisconnected) {
+          whenDisconnected();
+        }
+      };
+    })(nativeAudioNode.disconnect);
+    return nativeAudioNode;
+  };
+};
+exports.createMonitorConnections = createMonitorConnections;

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

@@ -0,0 +1,59 @@
+const createMonitorConnections = (insertElementInSet, isNativeAudioNode) => {
+  return (nativeAudioNode, whenConnected, whenDisconnected) => {
+    const connections = /* @__PURE__ */ new Set();
+    nativeAudioNode.connect = /* @__PURE__ */ ((connect) => {
+      return (destination, output = 0, input = 0) => {
+        const wasDisconnected = connections.size === 0;
+        if (isNativeAudioNode(destination)) {
+          connect.call(nativeAudioNode, destination, output, input);
+          insertElementInSet(connections, [destination, output, input], (connection) => connection[0] === destination && connection[1] === output && connection[2] === input, true);
+          if (wasDisconnected) {
+            whenConnected();
+          }
+          return destination;
+        }
+        connect.call(nativeAudioNode, destination, output);
+        insertElementInSet(connections, [destination, output], (connection) => connection[0] === destination && connection[1] === output, true);
+        if (wasDisconnected) {
+          whenConnected();
+        }
+        return;
+      };
+    })(nativeAudioNode.connect);
+    nativeAudioNode.disconnect = /* @__PURE__ */ ((disconnect) => {
+      return (destinationOrOutput, output, input) => {
+        const wasConnected = connections.size > 0;
+        if (destinationOrOutput === void 0) {
+          disconnect.apply(nativeAudioNode);
+          connections.clear();
+        } else if (typeof destinationOrOutput === "number") {
+          disconnect.call(nativeAudioNode, destinationOrOutput);
+          for (const connection of connections) {
+            if (connection[1] === destinationOrOutput) {
+              connections.delete(connection);
+            }
+          }
+        } else {
+          if (isNativeAudioNode(destinationOrOutput)) {
+            disconnect.call(nativeAudioNode, destinationOrOutput, output, input);
+          } else {
+            disconnect.call(nativeAudioNode, destinationOrOutput, output);
+          }
+          for (const connection of connections) {
+            if (connection[0] === destinationOrOutput && (output === void 0 || connection[1] === output) && (input === void 0 || connection[2] === input)) {
+              connections.delete(connection);
+            }
+          }
+        }
+        const isDisconnected = connections.size === 0;
+        if (wasConnected && isDisconnected) {
+          whenDisconnected();
+        }
+      };
+    })(nativeAudioNode.disconnect);
+    return nativeAudioNode;
+  };
+};
+export {
+  createMonitorConnections
+};

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

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const assignNativeAudioNodeOption = require("../helpers/assign-native-audio-node-option.cjs");
+const assignNativeAudioNodeOptions = require("../helpers/assign-native-audio-node-options.cjs");
+const testAnalyserNodeGetFloatTimeDomainDataMethodSupport = require("../helpers/test-analyser-node-get-float-time-domain-data-method-support.cjs");
+const wrapAnalyserNodeGetFloatTimeDomainDataMethod = require("../helpers/wrap-analyser-node-get-float-time-domain-data-method.cjs");
+const createNativeAnalyserNodeFactory = (cacheTestResult, createIndexSizeError) => {
+  return (nativeContext, options) => {
+    const nativeAnalyserNode = nativeContext.createAnalyser();
+    assignNativeAudioNodeOptions.assignNativeAudioNodeOptions(nativeAnalyserNode, options);
+    if (!(options.maxDecibels > options.minDecibels)) {
+      throw createIndexSizeError();
+    }
+    assignNativeAudioNodeOption.assignNativeAudioNodeOption(nativeAnalyserNode, options, "fftSize");
+    assignNativeAudioNodeOption.assignNativeAudioNodeOption(nativeAnalyserNode, options, "maxDecibels");
+    assignNativeAudioNodeOption.assignNativeAudioNodeOption(nativeAnalyserNode, options, "minDecibels");
+    assignNativeAudioNodeOption.assignNativeAudioNodeOption(nativeAnalyserNode, options, "smoothingTimeConstant");
+    if (!cacheTestResult(testAnalyserNodeGetFloatTimeDomainDataMethodSupport.testAnalyserNodeGetFloatTimeDomainDataMethodSupport, () => testAnalyserNodeGetFloatTimeDomainDataMethodSupport.testAnalyserNodeGetFloatTimeDomainDataMethodSupport(nativeAnalyserNode))) {
+      wrapAnalyserNodeGetFloatTimeDomainDataMethod.wrapAnalyserNodeGetFloatTimeDomainDataMethod(nativeAnalyserNode);
+    }
+    return nativeAnalyserNode;
+  };
+};
+exports.createNativeAnalyserNodeFactory = createNativeAnalyserNodeFactory;

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

@@ -0,0 +1,24 @@
+import { assignNativeAudioNodeOption } from "../helpers/assign-native-audio-node-option.js";
+import { assignNativeAudioNodeOptions } from "../helpers/assign-native-audio-node-options.js";
+import { testAnalyserNodeGetFloatTimeDomainDataMethodSupport } from "../helpers/test-analyser-node-get-float-time-domain-data-method-support.js";
+import { wrapAnalyserNodeGetFloatTimeDomainDataMethod } from "../helpers/wrap-analyser-node-get-float-time-domain-data-method.js";
+const createNativeAnalyserNodeFactory = (cacheTestResult, createIndexSizeError) => {
+  return (nativeContext, options) => {
+    const nativeAnalyserNode = nativeContext.createAnalyser();
+    assignNativeAudioNodeOptions(nativeAnalyserNode, options);
+    if (!(options.maxDecibels > options.minDecibels)) {
+      throw createIndexSizeError();
+    }
+    assignNativeAudioNodeOption(nativeAnalyserNode, options, "fftSize");
+    assignNativeAudioNodeOption(nativeAnalyserNode, options, "maxDecibels");
+    assignNativeAudioNodeOption(nativeAnalyserNode, options, "minDecibels");
+    assignNativeAudioNodeOption(nativeAnalyserNode, options, "smoothingTimeConstant");
+    if (!cacheTestResult(testAnalyserNodeGetFloatTimeDomainDataMethodSupport, () => testAnalyserNodeGetFloatTimeDomainDataMethodSupport(nativeAnalyserNode))) {
+      wrapAnalyserNodeGetFloatTimeDomainDataMethod(nativeAnalyserNode);
+    }
+    return nativeAnalyserNode;
+  };
+};
+export {
+  createNativeAnalyserNodeFactory
+};

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

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const createNativeAudioBufferConstructor = (window) => {
+  if (window === null) {
+    return null;
+  }
+  if (window.hasOwnProperty("AudioBuffer")) {
+    return window.AudioBuffer;
+  }
+  return null;
+};
+exports.createNativeAudioBufferConstructor = createNativeAudioBufferConstructor;

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

@@ -0,0 +1,12 @@
+const createNativeAudioBufferConstructor = (window) => {
+  if (window === null) {
+    return null;
+  }
+  if (window.hasOwnProperty("AudioBuffer")) {
+    return window.AudioBuffer;
+  }
+  return null;
+};
+export {
+  createNativeAudioBufferConstructor
+};

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

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const assignNativeAudioNodeAudioParamValue = require("../helpers/assign-native-audio-node-audio-param-value.cjs");
+const assignNativeAudioNodeOption = require("../helpers/assign-native-audio-node-option.cjs");
+const assignNativeAudioNodeOptions = require("../helpers/assign-native-audio-node-options.cjs");
+const wrapAudioBufferSourceNodeStartMethodConsecutiveCalls = require("../helpers/wrap-audio-buffer-source-node-start-method-consecutive-calls.cjs");
+const wrapAudioScheduledSourceNodeStartMethodNegativeParameters = require("../helpers/wrap-audio-scheduled-source-node-start-method-negative-parameters.cjs");
+const wrapAudioScheduledSourceNodeStopMethodNegativeParameters = require("../helpers/wrap-audio-scheduled-source-node-stop-method-negative-parameters.cjs");
+const createNativeAudioBufferSourceNodeFactory = (addSilentConnection, cacheTestResult, testAudioBufferSourceNodeStartMethodConsecutiveCallsSupport, testAudioBufferSourceNodeStartMethodOffsetClampingSupport, testAudioBufferSourceNodeStopMethodNullifiedBufferSupport, testAudioScheduledSourceNodeStartMethodNegativeParametersSupport, testAudioScheduledSourceNodeStopMethodConsecutiveCallsSupport, testAudioScheduledSourceNodeStopMethodNegativeParametersSupport, wrapAudioBufferSourceNodeStartMethodOffsetClampling, wrapAudioBufferSourceNodeStopMethodNullifiedBuffer, wrapAudioScheduledSourceNodeStopMethodConsecutiveCalls) => {
+  return (nativeContext, options) => {
+    const nativeAudioBufferSourceNode = nativeContext.createBufferSource();
+    assignNativeAudioNodeOptions.assignNativeAudioNodeOptions(nativeAudioBufferSourceNode, options);
+    assignNativeAudioNodeAudioParamValue.assignNativeAudioNodeAudioParamValue(nativeAudioBufferSourceNode, options, "playbackRate");
+    assignNativeAudioNodeOption.assignNativeAudioNodeOption(nativeAudioBufferSourceNode, options, "buffer");
+    assignNativeAudioNodeOption.assignNativeAudioNodeOption(nativeAudioBufferSourceNode, options, "loop");
+    assignNativeAudioNodeOption.assignNativeAudioNodeOption(nativeAudioBufferSourceNode, options, "loopEnd");
+    assignNativeAudioNodeOption.assignNativeAudioNodeOption(nativeAudioBufferSourceNode, options, "loopStart");
+    if (!cacheTestResult(testAudioBufferSourceNodeStartMethodConsecutiveCallsSupport, () => testAudioBufferSourceNodeStartMethodConsecutiveCallsSupport(nativeContext))) {
+      wrapAudioBufferSourceNodeStartMethodConsecutiveCalls.wrapAudioBufferSourceNodeStartMethodConsecutiveCalls(nativeAudioBufferSourceNode);
+    }
+    if (!cacheTestResult(testAudioBufferSourceNodeStartMethodOffsetClampingSupport, () => testAudioBufferSourceNodeStartMethodOffsetClampingSupport(nativeContext))) {
+      wrapAudioBufferSourceNodeStartMethodOffsetClampling(nativeAudioBufferSourceNode);
+    }
+    if (!cacheTestResult(testAudioBufferSourceNodeStopMethodNullifiedBufferSupport, () => testAudioBufferSourceNodeStopMethodNullifiedBufferSupport(nativeContext))) {
+      wrapAudioBufferSourceNodeStopMethodNullifiedBuffer(nativeAudioBufferSourceNode, nativeContext);
+    }
+    if (!cacheTestResult(testAudioScheduledSourceNodeStartMethodNegativeParametersSupport, () => testAudioScheduledSourceNodeStartMethodNegativeParametersSupport(nativeContext))) {
+      wrapAudioScheduledSourceNodeStartMethodNegativeParameters.wrapAudioScheduledSourceNodeStartMethodNegativeParameters(nativeAudioBufferSourceNode);
+    }
+    if (!cacheTestResult(testAudioScheduledSourceNodeStopMethodConsecutiveCallsSupport, () => testAudioScheduledSourceNodeStopMethodConsecutiveCallsSupport(nativeContext))) {
+      wrapAudioScheduledSourceNodeStopMethodConsecutiveCalls(nativeAudioBufferSourceNode, nativeContext);
+    }
+    if (!cacheTestResult(testAudioScheduledSourceNodeStopMethodNegativeParametersSupport, () => testAudioScheduledSourceNodeStopMethodNegativeParametersSupport(nativeContext))) {
+      wrapAudioScheduledSourceNodeStopMethodNegativeParameters.wrapAudioScheduledSourceNodeStopMethodNegativeParameters(nativeAudioBufferSourceNode);
+    }
+    addSilentConnection(nativeContext, nativeAudioBufferSourceNode);
+    return nativeAudioBufferSourceNode;
+  };
+};
+exports.createNativeAudioBufferSourceNodeFactory = createNativeAudioBufferSourceNodeFactory;

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

@@ -0,0 +1,40 @@
+import { assignNativeAudioNodeAudioParamValue } from "../helpers/assign-native-audio-node-audio-param-value.js";
+import { assignNativeAudioNodeOption } from "../helpers/assign-native-audio-node-option.js";
+import { assignNativeAudioNodeOptions } from "../helpers/assign-native-audio-node-options.js";
+import { wrapAudioBufferSourceNodeStartMethodConsecutiveCalls } from "../helpers/wrap-audio-buffer-source-node-start-method-consecutive-calls.js";
+import { wrapAudioScheduledSourceNodeStartMethodNegativeParameters } from "../helpers/wrap-audio-scheduled-source-node-start-method-negative-parameters.js";
+import { wrapAudioScheduledSourceNodeStopMethodNegativeParameters } from "../helpers/wrap-audio-scheduled-source-node-stop-method-negative-parameters.js";
+const createNativeAudioBufferSourceNodeFactory = (addSilentConnection, cacheTestResult, testAudioBufferSourceNodeStartMethodConsecutiveCallsSupport, testAudioBufferSourceNodeStartMethodOffsetClampingSupport, testAudioBufferSourceNodeStopMethodNullifiedBufferSupport, testAudioScheduledSourceNodeStartMethodNegativeParametersSupport, testAudioScheduledSourceNodeStopMethodConsecutiveCallsSupport, testAudioScheduledSourceNodeStopMethodNegativeParametersSupport, wrapAudioBufferSourceNodeStartMethodOffsetClampling, wrapAudioBufferSourceNodeStopMethodNullifiedBuffer, wrapAudioScheduledSourceNodeStopMethodConsecutiveCalls) => {
+  return (nativeContext, options) => {
+    const nativeAudioBufferSourceNode = nativeContext.createBufferSource();
+    assignNativeAudioNodeOptions(nativeAudioBufferSourceNode, options);
+    assignNativeAudioNodeAudioParamValue(nativeAudioBufferSourceNode, options, "playbackRate");
+    assignNativeAudioNodeOption(nativeAudioBufferSourceNode, options, "buffer");
+    assignNativeAudioNodeOption(nativeAudioBufferSourceNode, options, "loop");
+    assignNativeAudioNodeOption(nativeAudioBufferSourceNode, options, "loopEnd");
+    assignNativeAudioNodeOption(nativeAudioBufferSourceNode, options, "loopStart");
+    if (!cacheTestResult(testAudioBufferSourceNodeStartMethodConsecutiveCallsSupport, () => testAudioBufferSourceNodeStartMethodConsecutiveCallsSupport(nativeContext))) {
+      wrapAudioBufferSourceNodeStartMethodConsecutiveCalls(nativeAudioBufferSourceNode);
+    }
+    if (!cacheTestResult(testAudioBufferSourceNodeStartMethodOffsetClampingSupport, () => testAudioBufferSourceNodeStartMethodOffsetClampingSupport(nativeContext))) {
+      wrapAudioBufferSourceNodeStartMethodOffsetClampling(nativeAudioBufferSourceNode);
+    }
+    if (!cacheTestResult(testAudioBufferSourceNodeStopMethodNullifiedBufferSupport, () => testAudioBufferSourceNodeStopMethodNullifiedBufferSupport(nativeContext))) {
+      wrapAudioBufferSourceNodeStopMethodNullifiedBuffer(nativeAudioBufferSourceNode, nativeContext);
+    }
+    if (!cacheTestResult(testAudioScheduledSourceNodeStartMethodNegativeParametersSupport, () => testAudioScheduledSourceNodeStartMethodNegativeParametersSupport(nativeContext))) {
+      wrapAudioScheduledSourceNodeStartMethodNegativeParameters(nativeAudioBufferSourceNode);
+    }
+    if (!cacheTestResult(testAudioScheduledSourceNodeStopMethodConsecutiveCallsSupport, () => testAudioScheduledSourceNodeStopMethodConsecutiveCallsSupport(nativeContext))) {
+      wrapAudioScheduledSourceNodeStopMethodConsecutiveCalls(nativeAudioBufferSourceNode, nativeContext);
+    }
+    if (!cacheTestResult(testAudioScheduledSourceNodeStopMethodNegativeParametersSupport, () => testAudioScheduledSourceNodeStopMethodNegativeParametersSupport(nativeContext))) {
+      wrapAudioScheduledSourceNodeStopMethodNegativeParameters(nativeAudioBufferSourceNode);
+    }
+    addSilentConnection(nativeContext, nativeAudioBufferSourceNode);
+    return nativeAudioBufferSourceNode;
+  };
+};
+export {
+  createNativeAudioBufferSourceNodeFactory
+};

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

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const createNativeAudioContextConstructor = (window) => {
+  if (window === null) {
+    return null;
+  }
+  if (window.hasOwnProperty("AudioContext")) {
+    return window.AudioContext;
+  }
+  return window.hasOwnProperty("webkitAudioContext") ? window.webkitAudioContext : null;
+};
+exports.createNativeAudioContextConstructor = createNativeAudioContextConstructor;

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

@@ -0,0 +1,12 @@
+const createNativeAudioContextConstructor = (window) => {
+  if (window === null) {
+    return null;
+  }
+  if (window.hasOwnProperty("AudioContext")) {
+    return window.AudioContext;
+  }
+  return window.hasOwnProperty("webkitAudioContext") ? window.webkitAudioContext : null;
+};
+export {
+  createNativeAudioContextConstructor
+};

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

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const createNativeAudioDestinationNodeFactory = (createNativeGainNode, overwriteAccessors) => {
+  return (nativeContext, channelCount, isNodeOfNativeOfflineAudioContext) => {
+    const nativeAudioDestinationNode = nativeContext.destination;
+    if (nativeAudioDestinationNode.channelCount !== channelCount) {
+      try {
+        nativeAudioDestinationNode.channelCount = channelCount;
+      } catch {
+      }
+    }
+    if (isNodeOfNativeOfflineAudioContext && nativeAudioDestinationNode.channelCountMode !== "explicit") {
+      nativeAudioDestinationNode.channelCountMode = "explicit";
+    }
+    if (nativeAudioDestinationNode.maxChannelCount === 0) {
+      Object.defineProperty(nativeAudioDestinationNode, "maxChannelCount", {
+        value: channelCount
+      });
+    }
+    const gainNode = createNativeGainNode(nativeContext, {
+      channelCount,
+      channelCountMode: nativeAudioDestinationNode.channelCountMode,
+      channelInterpretation: nativeAudioDestinationNode.channelInterpretation,
+      gain: 1
+    });
+    overwriteAccessors(gainNode, "channelCount", (get) => () => get.call(gainNode), (set) => (value) => {
+      set.call(gainNode, value);
+      try {
+        nativeAudioDestinationNode.channelCount = value;
+      } catch (err) {
+        if (value > nativeAudioDestinationNode.maxChannelCount) {
+          throw err;
+        }
+      }
+    });
+    overwriteAccessors(gainNode, "channelCountMode", (get) => () => get.call(gainNode), (set) => (value) => {
+      set.call(gainNode, value);
+      nativeAudioDestinationNode.channelCountMode = value;
+    });
+    overwriteAccessors(gainNode, "channelInterpretation", (get) => () => get.call(gainNode), (set) => (value) => {
+      set.call(gainNode, value);
+      nativeAudioDestinationNode.channelInterpretation = value;
+    });
+    Object.defineProperty(gainNode, "maxChannelCount", {
+      get: () => nativeAudioDestinationNode.maxChannelCount
+    });
+    gainNode.connect(nativeAudioDestinationNode);
+    return gainNode;
+  };
+};
+exports.createNativeAudioDestinationNodeFactory = createNativeAudioDestinationNodeFactory;

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

@@ -0,0 +1,51 @@
+const createNativeAudioDestinationNodeFactory = (createNativeGainNode, overwriteAccessors) => {
+  return (nativeContext, channelCount, isNodeOfNativeOfflineAudioContext) => {
+    const nativeAudioDestinationNode = nativeContext.destination;
+    if (nativeAudioDestinationNode.channelCount !== channelCount) {
+      try {
+        nativeAudioDestinationNode.channelCount = channelCount;
+      } catch {
+      }
+    }
+    if (isNodeOfNativeOfflineAudioContext && nativeAudioDestinationNode.channelCountMode !== "explicit") {
+      nativeAudioDestinationNode.channelCountMode = "explicit";
+    }
+    if (nativeAudioDestinationNode.maxChannelCount === 0) {
+      Object.defineProperty(nativeAudioDestinationNode, "maxChannelCount", {
+        value: channelCount
+      });
+    }
+    const gainNode = createNativeGainNode(nativeContext, {
+      channelCount,
+      channelCountMode: nativeAudioDestinationNode.channelCountMode,
+      channelInterpretation: nativeAudioDestinationNode.channelInterpretation,
+      gain: 1
+    });
+    overwriteAccessors(gainNode, "channelCount", (get) => () => get.call(gainNode), (set) => (value) => {
+      set.call(gainNode, value);
+      try {
+        nativeAudioDestinationNode.channelCount = value;
+      } catch (err) {
+        if (value > nativeAudioDestinationNode.maxChannelCount) {
+          throw err;
+        }
+      }
+    });
+    overwriteAccessors(gainNode, "channelCountMode", (get) => () => get.call(gainNode), (set) => (value) => {
+      set.call(gainNode, value);
+      nativeAudioDestinationNode.channelCountMode = value;
+    });
+    overwriteAccessors(gainNode, "channelInterpretation", (get) => () => get.call(gainNode), (set) => (value) => {
+      set.call(gainNode, value);
+      nativeAudioDestinationNode.channelInterpretation = value;
+    });
+    Object.defineProperty(gainNode, "maxChannelCount", {
+      get: () => nativeAudioDestinationNode.maxChannelCount
+    });
+    gainNode.connect(nativeAudioDestinationNode);
+    return gainNode;
+  };
+};
+export {
+  createNativeAudioDestinationNodeFactory
+};

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

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const createNativeAudioWorkletNodeConstructor = (window) => {
+  if (window === null) {
+    return null;
+  }
+  return window.hasOwnProperty("AudioWorkletNode") ? window.AudioWorkletNode : null;
+};
+exports.createNativeAudioWorkletNodeConstructor = createNativeAudioWorkletNodeConstructor;

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

@@ -0,0 +1,9 @@
+const createNativeAudioWorkletNodeConstructor = (window) => {
+  if (window === null) {
+    return null;
+  }
+  return window.hasOwnProperty("AudioWorkletNode") ? window.AudioWorkletNode : null;
+};
+export {
+  createNativeAudioWorkletNodeConstructor
+};

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

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const assignNativeAudioNodeAudioParamValue = require("../helpers/assign-native-audio-node-audio-param-value.cjs");
+const assignNativeAudioNodeOption = require("../helpers/assign-native-audio-node-option.cjs");
+const assignNativeAudioNodeOptions = require("../helpers/assign-native-audio-node-options.cjs");
+const createNativeBiquadFilterNode = (nativeContext, options) => {
+  const nativeBiquadFilterNode = nativeContext.createBiquadFilter();
+  assignNativeAudioNodeOptions.assignNativeAudioNodeOptions(nativeBiquadFilterNode, options);
+  assignNativeAudioNodeAudioParamValue.assignNativeAudioNodeAudioParamValue(nativeBiquadFilterNode, options, "Q");
+  assignNativeAudioNodeAudioParamValue.assignNativeAudioNodeAudioParamValue(nativeBiquadFilterNode, options, "detune");
+  assignNativeAudioNodeAudioParamValue.assignNativeAudioNodeAudioParamValue(nativeBiquadFilterNode, options, "frequency");
+  assignNativeAudioNodeAudioParamValue.assignNativeAudioNodeAudioParamValue(nativeBiquadFilterNode, options, "gain");
+  assignNativeAudioNodeOption.assignNativeAudioNodeOption(nativeBiquadFilterNode, options, "type");
+  return nativeBiquadFilterNode;
+};
+exports.createNativeBiquadFilterNode = createNativeBiquadFilterNode;

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

@@ -0,0 +1,16 @@
+import { assignNativeAudioNodeAudioParamValue } from "../helpers/assign-native-audio-node-audio-param-value.js";
+import { assignNativeAudioNodeOption } from "../helpers/assign-native-audio-node-option.js";
+import { assignNativeAudioNodeOptions } from "../helpers/assign-native-audio-node-options.js";
+const createNativeBiquadFilterNode = (nativeContext, options) => {
+  const nativeBiquadFilterNode = nativeContext.createBiquadFilter();
+  assignNativeAudioNodeOptions(nativeBiquadFilterNode, options);
+  assignNativeAudioNodeAudioParamValue(nativeBiquadFilterNode, options, "Q");
+  assignNativeAudioNodeAudioParamValue(nativeBiquadFilterNode, options, "detune");
+  assignNativeAudioNodeAudioParamValue(nativeBiquadFilterNode, options, "frequency");
+  assignNativeAudioNodeAudioParamValue(nativeBiquadFilterNode, options, "gain");
+  assignNativeAudioNodeOption(nativeBiquadFilterNode, options, "type");
+  return nativeBiquadFilterNode;
+};
+export {
+  createNativeBiquadFilterNode
+};

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

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const assignNativeAudioNodeOptions = require("../helpers/assign-native-audio-node-options.cjs");
+const createNativeChannelMergerNodeFactory = (nativeAudioContextConstructor, wrapChannelMergerNode) => {
+  return (nativeContext, options) => {
+    const nativeChannelMergerNode = nativeContext.createChannelMerger(options.numberOfInputs);
+    if (nativeAudioContextConstructor !== null && nativeAudioContextConstructor.name === "webkitAudioContext") {
+      wrapChannelMergerNode(nativeContext, nativeChannelMergerNode);
+    }
+    assignNativeAudioNodeOptions.assignNativeAudioNodeOptions(nativeChannelMergerNode, options);
+    return nativeChannelMergerNode;
+  };
+};
+exports.createNativeChannelMergerNodeFactory = createNativeChannelMergerNodeFactory;

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

@@ -0,0 +1,14 @@
+import { assignNativeAudioNodeOptions } from "../helpers/assign-native-audio-node-options.js";
+const createNativeChannelMergerNodeFactory = (nativeAudioContextConstructor, wrapChannelMergerNode) => {
+  return (nativeContext, options) => {
+    const nativeChannelMergerNode = nativeContext.createChannelMerger(options.numberOfInputs);
+    if (nativeAudioContextConstructor !== null && nativeAudioContextConstructor.name === "webkitAudioContext") {
+      wrapChannelMergerNode(nativeContext, nativeChannelMergerNode);
+    }
+    assignNativeAudioNodeOptions(nativeChannelMergerNode, options);
+    return nativeChannelMergerNode;
+  };
+};
+export {
+  createNativeChannelMergerNodeFactory
+};

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

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const assignNativeAudioNodeOptions = require("../helpers/assign-native-audio-node-options.cjs");
+const wrapChannelSplitterNode = require("../helpers/wrap-channel-splitter-node.cjs");
+const createNativeChannelSplitterNode = (nativeContext, options) => {
+  const nativeChannelSplitterNode = nativeContext.createChannelSplitter(options.numberOfOutputs);
+  assignNativeAudioNodeOptions.assignNativeAudioNodeOptions(nativeChannelSplitterNode, options);
+  wrapChannelSplitterNode.wrapChannelSplitterNode(nativeChannelSplitterNode);
+  return nativeChannelSplitterNode;
+};
+exports.createNativeChannelSplitterNode = createNativeChannelSplitterNode;

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

@@ -0,0 +1,11 @@
+import { assignNativeAudioNodeOptions } from "../helpers/assign-native-audio-node-options.js";
+import { wrapChannelSplitterNode } from "../helpers/wrap-channel-splitter-node.js";
+const createNativeChannelSplitterNode = (nativeContext, options) => {
+  const nativeChannelSplitterNode = nativeContext.createChannelSplitter(options.numberOfOutputs);
+  assignNativeAudioNodeOptions(nativeChannelSplitterNode, options);
+  wrapChannelSplitterNode(nativeChannelSplitterNode);
+  return nativeChannelSplitterNode;
+};
+export {
+  createNativeChannelSplitterNode
+};