react-audio-wavekit 0.1.5 → 0.1.6

package/dist/node_modules/standardized-audio-context/build/es2019/helpers/wrap-audio-node-disconnect-method.cjs

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const nativeAudioNode = require("../guards/native-audio-node.cjs");
+const wrapAudioNodeDisconnectMethod = (nativeAudioNode$1) => {
+  const connections = /* @__PURE__ */ new Map();
+  nativeAudioNode$1.connect = /* @__PURE__ */ ((connect) => {
+    return (destination, output = 0, input = 0) => {
+      const returnValue = nativeAudioNode.isNativeAudioNode(destination) ? connect(destination, output, input) : connect(destination, output);
+      const connectionsToDestination = connections.get(destination);
+      if (connectionsToDestination === void 0) {
+        connections.set(destination, [{ input, output }]);
+      } else {
+        if (connectionsToDestination.every((connection) => connection.input !== input || connection.output !== output)) {
+          connectionsToDestination.push({ input, output });
+        }
+      }
+      return returnValue;
+    };
+  })(nativeAudioNode$1.connect.bind(nativeAudioNode$1));
+  nativeAudioNode$1.disconnect = /* @__PURE__ */ ((disconnect) => {
+    return (destinationOrOutput, output, input) => {
+      disconnect.apply(nativeAudioNode$1);
+      if (destinationOrOutput === void 0) {
+        connections.clear();
+      } else if (typeof destinationOrOutput === "number") {
+        for (const [destination, connectionsToDestination] of connections) {
+          const filteredConnections = connectionsToDestination.filter((connection) => connection.output !== destinationOrOutput);
+          if (filteredConnections.length === 0) {
+            connections.delete(destination);
+          } else {
+            connections.set(destination, filteredConnections);
+          }
+        }
+      } else if (connections.has(destinationOrOutput)) {
+        if (output === void 0) {
+          connections.delete(destinationOrOutput);
+        } else {
+          const connectionsToDestination = connections.get(destinationOrOutput);
+          if (connectionsToDestination !== void 0) {
+            const filteredConnections = connectionsToDestination.filter((connection) => connection.output !== output && (connection.input !== input || input === void 0));
+            if (filteredConnections.length === 0) {
+              connections.delete(destinationOrOutput);
+            } else {
+              connections.set(destinationOrOutput, filteredConnections);
+            }
+          }
+        }
+      }
+      for (const [destination, connectionsToDestination] of connections) {
+        connectionsToDestination.forEach((connection) => {
+          if (nativeAudioNode.isNativeAudioNode(destination)) {
+            nativeAudioNode$1.connect(destination, connection.output, connection.input);
+          } else {
+            nativeAudioNode$1.connect(destination, connection.output);
+          }
+        });
+      }
+    };
+  })(nativeAudioNode$1.disconnect);
+};
+exports.wrapAudioNodeDisconnectMethod = wrapAudioNodeDisconnectMethod;

package/dist/node_modules/standardized-audio-context/build/es2019/helpers/wrap-audio-node-disconnect-method.js

@@ -0,0 +1,61 @@
+import { isNativeAudioNode } from "../guards/native-audio-node.js";
+const wrapAudioNodeDisconnectMethod = (nativeAudioNode) => {
+  const connections = /* @__PURE__ */ new Map();
+  nativeAudioNode.connect = /* @__PURE__ */ ((connect) => {
+    return (destination, output = 0, input = 0) => {
+      const returnValue = isNativeAudioNode(destination) ? connect(destination, output, input) : connect(destination, output);
+      const connectionsToDestination = connections.get(destination);
+      if (connectionsToDestination === void 0) {
+        connections.set(destination, [{ input, output }]);
+      } else {
+        if (connectionsToDestination.every((connection) => connection.input !== input || connection.output !== output)) {
+          connectionsToDestination.push({ input, output });
+        }
+      }
+      return returnValue;
+    };
+  })(nativeAudioNode.connect.bind(nativeAudioNode));
+  nativeAudioNode.disconnect = /* @__PURE__ */ ((disconnect) => {
+    return (destinationOrOutput, output, input) => {
+      disconnect.apply(nativeAudioNode);
+      if (destinationOrOutput === void 0) {
+        connections.clear();
+      } else if (typeof destinationOrOutput === "number") {
+        for (const [destination, connectionsToDestination] of connections) {
+          const filteredConnections = connectionsToDestination.filter((connection) => connection.output !== destinationOrOutput);
+          if (filteredConnections.length === 0) {
+            connections.delete(destination);
+          } else {
+            connections.set(destination, filteredConnections);
+          }
+        }
+      } else if (connections.has(destinationOrOutput)) {
+        if (output === void 0) {
+          connections.delete(destinationOrOutput);
+        } else {
+          const connectionsToDestination = connections.get(destinationOrOutput);
+          if (connectionsToDestination !== void 0) {
+            const filteredConnections = connectionsToDestination.filter((connection) => connection.output !== output && (connection.input !== input || input === void 0));
+            if (filteredConnections.length === 0) {
+              connections.delete(destinationOrOutput);
+            } else {
+              connections.set(destinationOrOutput, filteredConnections);
+            }
+          }
+        }
+      }
+      for (const [destination, connectionsToDestination] of connections) {
+        connectionsToDestination.forEach((connection) => {
+          if (isNativeAudioNode(destination)) {
+            nativeAudioNode.connect(destination, connection.output, connection.input);
+          } else {
+            nativeAudioNode.connect(destination, connection.output);
+          }
+        });
+      }
+    };
+  })(nativeAudioNode.disconnect);
+};
+export {
+  wrapAudioNodeDisconnectMethod
+};

package/dist/node_modules/standardized-audio-context/build/es2019/helpers/wrap-audio-scheduled-source-node-start-method-negative-parameters.cjs

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const wrapAudioScheduledSourceNodeStartMethodNegativeParameters = (nativeAudioScheduledSourceNode) => {
+  nativeAudioScheduledSourceNode.start = /* @__PURE__ */ ((start) => {
+    return (when = 0, offset = 0, duration) => {
+      if (typeof duration === "number" && duration < 0 || offset < 0 || when < 0) {
+        throw new RangeError("The parameters can't be negative.");
+      }
+      start.call(nativeAudioScheduledSourceNode, when, offset, duration);
+    };
+  })(nativeAudioScheduledSourceNode.start);
+};
+exports.wrapAudioScheduledSourceNodeStartMethodNegativeParameters = wrapAudioScheduledSourceNodeStartMethodNegativeParameters;

package/dist/node_modules/standardized-audio-context/build/es2019/helpers/wrap-audio-scheduled-source-node-start-method-negative-parameters.js

@@ -0,0 +1,13 @@
+const wrapAudioScheduledSourceNodeStartMethodNegativeParameters = (nativeAudioScheduledSourceNode) => {
+  nativeAudioScheduledSourceNode.start = /* @__PURE__ */ ((start) => {
+    return (when = 0, offset = 0, duration) => {
+      if (typeof duration === "number" && duration < 0 || offset < 0 || when < 0) {
+        throw new RangeError("The parameters can't be negative.");
+      }
+      start.call(nativeAudioScheduledSourceNode, when, offset, duration);
+    };
+  })(nativeAudioScheduledSourceNode.start);
+};
+export {
+  wrapAudioScheduledSourceNodeStartMethodNegativeParameters
+};

package/dist/node_modules/standardized-audio-context/build/es2019/helpers/wrap-audio-scheduled-source-node-stop-method-consecutive-calls.cjs

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const interceptConnections = require("./intercept-connections.cjs");
+const wrapAudioScheduledSourceNodeStopMethodConsecutiveCalls = (nativeAudioScheduledSourceNode, nativeContext) => {
+  const nativeGainNode = nativeContext.createGain();
+  nativeAudioScheduledSourceNode.connect(nativeGainNode);
+  const disconnectGainNode = /* @__PURE__ */ ((disconnect) => {
+    return () => {
+      disconnect.call(nativeAudioScheduledSourceNode, nativeGainNode);
+      nativeAudioScheduledSourceNode.removeEventListener("ended", disconnectGainNode);
+    };
+  })(nativeAudioScheduledSourceNode.disconnect);
+  nativeAudioScheduledSourceNode.addEventListener("ended", disconnectGainNode);
+  interceptConnections.interceptConnections(nativeAudioScheduledSourceNode, nativeGainNode);
+  nativeAudioScheduledSourceNode.stop = /* @__PURE__ */ ((stop) => {
+    let isStopped = false;
+    return (when = 0) => {
+      if (isStopped) {
+        try {
+          stop.call(nativeAudioScheduledSourceNode, when);
+        } catch {
+          nativeGainNode.gain.setValueAtTime(0, when);
+        }
+      } else {
+        stop.call(nativeAudioScheduledSourceNode, when);
+        isStopped = true;
+      }
+    };
+  })(nativeAudioScheduledSourceNode.stop);
+};
+exports.wrapAudioScheduledSourceNodeStopMethodConsecutiveCalls = wrapAudioScheduledSourceNodeStopMethodConsecutiveCalls;

package/dist/node_modules/standardized-audio-context/build/es2019/helpers/wrap-audio-scheduled-source-node-stop-method-consecutive-calls.js

@@ -0,0 +1,31 @@
+import { interceptConnections } from "./intercept-connections.js";
+const wrapAudioScheduledSourceNodeStopMethodConsecutiveCalls = (nativeAudioScheduledSourceNode, nativeContext) => {
+  const nativeGainNode = nativeContext.createGain();
+  nativeAudioScheduledSourceNode.connect(nativeGainNode);
+  const disconnectGainNode = /* @__PURE__ */ ((disconnect) => {
+    return () => {
+      disconnect.call(nativeAudioScheduledSourceNode, nativeGainNode);
+      nativeAudioScheduledSourceNode.removeEventListener("ended", disconnectGainNode);
+    };
+  })(nativeAudioScheduledSourceNode.disconnect);
+  nativeAudioScheduledSourceNode.addEventListener("ended", disconnectGainNode);
+  interceptConnections(nativeAudioScheduledSourceNode, nativeGainNode);
+  nativeAudioScheduledSourceNode.stop = /* @__PURE__ */ ((stop) => {
+    let isStopped = false;
+    return (when = 0) => {
+      if (isStopped) {
+        try {
+          stop.call(nativeAudioScheduledSourceNode, when);
+        } catch {
+          nativeGainNode.gain.setValueAtTime(0, when);
+        }
+      } else {
+        stop.call(nativeAudioScheduledSourceNode, when);
+        isStopped = true;
+      }
+    };
+  })(nativeAudioScheduledSourceNode.stop);
+};
+export {
+  wrapAudioScheduledSourceNodeStopMethodConsecutiveCalls
+};

package/dist/node_modules/standardized-audio-context/build/es2019/helpers/wrap-audio-scheduled-source-node-stop-method-negative-parameters.cjs

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const wrapAudioScheduledSourceNodeStopMethodNegativeParameters = (nativeAudioScheduledSourceNode) => {
+  nativeAudioScheduledSourceNode.stop = /* @__PURE__ */ ((stop) => {
+    return (when = 0) => {
+      if (when < 0) {
+        throw new RangeError("The parameter can't be negative.");
+      }
+      stop.call(nativeAudioScheduledSourceNode, when);
+    };
+  })(nativeAudioScheduledSourceNode.stop);
+};
+exports.wrapAudioScheduledSourceNodeStopMethodNegativeParameters = wrapAudioScheduledSourceNodeStopMethodNegativeParameters;

package/dist/node_modules/standardized-audio-context/build/es2019/helpers/wrap-audio-scheduled-source-node-stop-method-negative-parameters.js

@@ -0,0 +1,13 @@
+const wrapAudioScheduledSourceNodeStopMethodNegativeParameters = (nativeAudioScheduledSourceNode) => {
+  nativeAudioScheduledSourceNode.stop = /* @__PURE__ */ ((stop) => {
+    return (when = 0) => {
+      if (when < 0) {
+        throw new RangeError("The parameter can't be negative.");
+      }
+      stop.call(nativeAudioScheduledSourceNode, when);
+    };
+  })(nativeAudioScheduledSourceNode.stop);
+};
+export {
+  wrapAudioScheduledSourceNodeStopMethodNegativeParameters
+};

package/dist/node_modules/standardized-audio-context/build/es2019/helpers/wrap-channel-splitter-node.cjs

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const invalidStateError = require("../factories/invalid-state-error.cjs");
+const wrapChannelSplitterNode = (channelSplitterNode) => {
+  const channelCount = channelSplitterNode.numberOfOutputs;
+  Object.defineProperty(channelSplitterNode, "channelCount", {
+    get: () => channelCount,
+    set: (value) => {
+      if (value !== channelCount) {
+        throw invalidStateError.createInvalidStateError();
+      }
+    }
+  });
+  Object.defineProperty(channelSplitterNode, "channelCountMode", {
+    get: () => "explicit",
+    set: (value) => {
+      if (value !== "explicit") {
+        throw invalidStateError.createInvalidStateError();
+      }
+    }
+  });
+  Object.defineProperty(channelSplitterNode, "channelInterpretation", {
+    get: () => "discrete",
+    set: (value) => {
+      if (value !== "discrete") {
+        throw invalidStateError.createInvalidStateError();
+      }
+    }
+  });
+};
+exports.wrapChannelSplitterNode = wrapChannelSplitterNode;

package/dist/node_modules/standardized-audio-context/build/es2019/helpers/wrap-channel-splitter-node.js

@@ -0,0 +1,31 @@
+import { createInvalidStateError } from "../factories/invalid-state-error.js";
+const wrapChannelSplitterNode = (channelSplitterNode) => {
+  const channelCount = channelSplitterNode.numberOfOutputs;
+  Object.defineProperty(channelSplitterNode, "channelCount", {
+    get: () => channelCount,
+    set: (value) => {
+      if (value !== channelCount) {
+        throw createInvalidStateError();
+      }
+    }
+  });
+  Object.defineProperty(channelSplitterNode, "channelCountMode", {
+    get: () => "explicit",
+    set: (value) => {
+      if (value !== "explicit") {
+        throw createInvalidStateError();
+      }
+    }
+  });
+  Object.defineProperty(channelSplitterNode, "channelInterpretation", {
+    get: () => "discrete",
+    set: (value) => {
+      if (value !== "discrete") {
+        throw createInvalidStateError();
+      }
+    }
+  });
+};
+export {
+  wrapChannelSplitterNode
+};

package/dist/node_modules/standardized-audio-context/build/es2019/helpers/wrap-event-listener.cjs

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const wrapEventListener = (target, eventListener) => {
+  return (event) => {
+    const descriptor = { value: target };
+    Object.defineProperties(event, {
+      currentTarget: descriptor,
+      target: descriptor
+    });
+    if (typeof eventListener === "function") {
+      return eventListener.call(target, event);
+    }
+    return eventListener.handleEvent.call(target, event);
+  };
+};
+exports.wrapEventListener = wrapEventListener;

package/dist/node_modules/standardized-audio-context/build/es2019/helpers/wrap-event-listener.js

@@ -0,0 +1,16 @@
+const wrapEventListener = (target, eventListener) => {
+  return (event) => {
+    const descriptor = { value: target };
+    Object.defineProperties(event, {
+      currentTarget: descriptor,
+      target: descriptor
+    });
+    if (typeof eventListener === "function") {
+      return eventListener.call(target, event);
+    }
+    return eventListener.handleEvent.call(target, event);
+  };
+};
+export {
+  wrapEventListener
+};

package/dist/node_modules/standardized-audio-context/build/es2019/helpers/wrap-iir-filter-node-get-frequency-response-method.cjs

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const invalidAccessError = require("../factories/invalid-access-error.cjs");
+const wrapIIRFilterNodeGetFrequencyResponseMethod = (nativeIIRFilterNode) => {
+  nativeIIRFilterNode.getFrequencyResponse = /* @__PURE__ */ ((getFrequencyResponse) => {
+    return (frequencyHz, magResponse, phaseResponse) => {
+      if (frequencyHz.length !== magResponse.length || magResponse.length !== phaseResponse.length) {
+        throw invalidAccessError.createInvalidAccessError();
+      }
+      return getFrequencyResponse.call(nativeIIRFilterNode, frequencyHz, magResponse, phaseResponse);
+    };
+  })(nativeIIRFilterNode.getFrequencyResponse);
+};
+exports.wrapIIRFilterNodeGetFrequencyResponseMethod = wrapIIRFilterNodeGetFrequencyResponseMethod;

package/dist/node_modules/standardized-audio-context/build/es2019/helpers/wrap-iir-filter-node-get-frequency-response-method.js

@@ -0,0 +1,14 @@
+import { createInvalidAccessError } from "../factories/invalid-access-error.js";
+const wrapIIRFilterNodeGetFrequencyResponseMethod = (nativeIIRFilterNode) => {
+  nativeIIRFilterNode.getFrequencyResponse = /* @__PURE__ */ ((getFrequencyResponse) => {
+    return (frequencyHz, magResponse, phaseResponse) => {
+      if (frequencyHz.length !== magResponse.length || magResponse.length !== phaseResponse.length) {
+        throw createInvalidAccessError();
+      }
+      return getFrequencyResponse.call(nativeIIRFilterNode, frequencyHz, magResponse, phaseResponse);
+    };
+  })(nativeIIRFilterNode.getFrequencyResponse);
+};
+export {
+  wrapIIRFilterNodeGetFrequencyResponseMethod
+};