react-audio-wavekit 0.1.5 → 0.1.7

package/dist/node_modules/automation-events/build/es2019/functions/get-value-of-automation-event-at-index-at-time.js

@@ -0,0 +1,11 @@
+import { getTargetValueAtTime } from "./get-target-value-at-time.js";
+import { isAnyRampToValueAutomationEvent } from "../guards/any-ramp-to-value-automation-event.js";
+import { isSetValueAutomationEvent } from "../guards/set-value-automation-event.js";
+import { isSetValueCurveAutomationEvent } from "../guards/set-value-curve-automation-event.js";
+const getValueOfAutomationEventAtIndexAtTime = (automationEvents, index, time, defaultValue) => {
+  const automationEvent = automationEvents[index];
+  return automationEvent === void 0 ? defaultValue : isAnyRampToValueAutomationEvent(automationEvent) || isSetValueAutomationEvent(automationEvent) ? automationEvent.value : isSetValueCurveAutomationEvent(automationEvent) ? automationEvent.values[automationEvent.values.length - 1] : getTargetValueAtTime(time, getValueOfAutomationEventAtIndexAtTime(automationEvents, index - 1, automationEvent.startTime, defaultValue), automationEvent);
+};
+export {
+  getValueOfAutomationEventAtIndexAtTime
+};

package/dist/node_modules/automation-events/build/es2019/functions/interpolate-value.cjs

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const interpolateValue = (values, theoreticIndex) => {
+  const lowerIndex = Math.floor(theoreticIndex);
+  const upperIndex = Math.ceil(theoreticIndex);
+  if (lowerIndex === upperIndex) {
+    return values[lowerIndex];
+  }
+  return (1 - (theoreticIndex - lowerIndex)) * values[lowerIndex] + (1 - (upperIndex - theoreticIndex)) * values[upperIndex];
+};
+exports.interpolateValue = interpolateValue;

package/dist/node_modules/automation-events/build/es2019/functions/interpolate-value.js

@@ -0,0 +1,11 @@
+const interpolateValue = (values, theoreticIndex) => {
+  const lowerIndex = Math.floor(theoreticIndex);
+  const upperIndex = Math.ceil(theoreticIndex);
+  if (lowerIndex === upperIndex) {
+    return values[lowerIndex];
+  }
+  return (1 - (theoreticIndex - lowerIndex)) * values[lowerIndex] + (1 - (upperIndex - theoreticIndex)) * values[upperIndex];
+};
+export {
+  interpolateValue
+};

package/dist/node_modules/automation-events/build/es2019/guards/any-ramp-to-value-automation-event.cjs

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const exponentialRampToValueAutomationEvent = require("./exponential-ramp-to-value-automation-event.cjs");
+const linearRampToValueAutomationEvent = require("./linear-ramp-to-value-automation-event.cjs");
+const isAnyRampToValueAutomationEvent = (automationEvent) => {
+  return exponentialRampToValueAutomationEvent.isExponentialRampToValueAutomationEvent(automationEvent) || linearRampToValueAutomationEvent.isLinearRampToValueAutomationEvent(automationEvent);
+};
+exports.isAnyRampToValueAutomationEvent = isAnyRampToValueAutomationEvent;

package/dist/node_modules/automation-events/build/es2019/guards/any-ramp-to-value-automation-event.js

@@ -0,0 +1,8 @@
+import { isExponentialRampToValueAutomationEvent } from "./exponential-ramp-to-value-automation-event.js";
+import { isLinearRampToValueAutomationEvent } from "./linear-ramp-to-value-automation-event.js";
+const isAnyRampToValueAutomationEvent = (automationEvent) => {
+  return isExponentialRampToValueAutomationEvent(automationEvent) || isLinearRampToValueAutomationEvent(automationEvent);
+};
+export {
+  isAnyRampToValueAutomationEvent
+};

package/dist/node_modules/automation-events/build/es2019/guards/cancel-and-hold-automation-event.cjs

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const isCancelAndHoldAutomationEvent = (automationEvent) => {
+  return automationEvent.type === "cancelAndHold";
+};
+exports.isCancelAndHoldAutomationEvent = isCancelAndHoldAutomationEvent;

package/dist/node_modules/automation-events/build/es2019/guards/cancel-and-hold-automation-event.js

@@ -0,0 +1,6 @@
+const isCancelAndHoldAutomationEvent = (automationEvent) => {
+  return automationEvent.type === "cancelAndHold";
+};
+export {
+  isCancelAndHoldAutomationEvent
+};

package/dist/node_modules/automation-events/build/es2019/guards/cancel-scheduled-values-automation-event.cjs

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const isCancelScheduledValuesAutomationEvent = (automationEvent) => {
+  return automationEvent.type === "cancelScheduledValues";
+};
+exports.isCancelScheduledValuesAutomationEvent = isCancelScheduledValuesAutomationEvent;

package/dist/node_modules/automation-events/build/es2019/guards/cancel-scheduled-values-automation-event.js

@@ -0,0 +1,6 @@
+const isCancelScheduledValuesAutomationEvent = (automationEvent) => {
+  return automationEvent.type === "cancelScheduledValues";
+};
+export {
+  isCancelScheduledValuesAutomationEvent
+};

package/dist/node_modules/automation-events/build/es2019/guards/exponential-ramp-to-value-automation-event.cjs

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const isExponentialRampToValueAutomationEvent = (automationEvent) => {
+  return automationEvent.type === "exponentialRampToValue";
+};
+exports.isExponentialRampToValueAutomationEvent = isExponentialRampToValueAutomationEvent;

package/dist/node_modules/automation-events/build/es2019/guards/exponential-ramp-to-value-automation-event.js

@@ -0,0 +1,6 @@
+const isExponentialRampToValueAutomationEvent = (automationEvent) => {
+  return automationEvent.type === "exponentialRampToValue";
+};
+export {
+  isExponentialRampToValueAutomationEvent
+};

package/dist/node_modules/automation-events/build/es2019/guards/linear-ramp-to-value-automation-event.cjs

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const isLinearRampToValueAutomationEvent = (automationEvent) => {
+  return automationEvent.type === "linearRampToValue";
+};
+exports.isLinearRampToValueAutomationEvent = isLinearRampToValueAutomationEvent;

package/dist/node_modules/automation-events/build/es2019/guards/linear-ramp-to-value-automation-event.js

@@ -0,0 +1,6 @@
+const isLinearRampToValueAutomationEvent = (automationEvent) => {
+  return automationEvent.type === "linearRampToValue";
+};
+export {
+  isLinearRampToValueAutomationEvent
+};

package/dist/node_modules/automation-events/build/es2019/guards/set-target-automation-event.cjs

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const isSetTargetAutomationEvent = (automationEvent) => {
+  return automationEvent.type === "setTarget";
+};
+exports.isSetTargetAutomationEvent = isSetTargetAutomationEvent;

package/dist/node_modules/automation-events/build/es2019/guards/set-target-automation-event.js

@@ -0,0 +1,6 @@
+const isSetTargetAutomationEvent = (automationEvent) => {
+  return automationEvent.type === "setTarget";
+};
+export {
+  isSetTargetAutomationEvent
+};

package/dist/node_modules/automation-events/build/es2019/guards/set-value-automation-event.cjs

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const isSetValueAutomationEvent = (automationEvent) => {
+  return automationEvent.type === "setValue";
+};
+exports.isSetValueAutomationEvent = isSetValueAutomationEvent;

package/dist/node_modules/automation-events/build/es2019/guards/set-value-automation-event.js

@@ -0,0 +1,6 @@
+const isSetValueAutomationEvent = (automationEvent) => {
+  return automationEvent.type === "setValue";
+};
+export {
+  isSetValueAutomationEvent
+};

package/dist/node_modules/automation-events/build/es2019/guards/set-value-curve-automation-event.cjs

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const isSetValueCurveAutomationEvent = (automationEvent) => {
+  return automationEvent.type === "setValueCurve";
+};
+exports.isSetValueCurveAutomationEvent = isSetValueCurveAutomationEvent;

package/dist/node_modules/automation-events/build/es2019/guards/set-value-curve-automation-event.js

@@ -0,0 +1,6 @@
+const isSetValueCurveAutomationEvent = (automationEvent) => {
+  return automationEvent.type === "setValueCurve";
+};
+export {
+  isSetValueCurveAutomationEvent
+};

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

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const MOST_NEGATIVE_SINGLE_FLOAT = -34028234663852886e22;
+const MOST_POSITIVE_SINGLE_FLOAT = -MOST_NEGATIVE_SINGLE_FLOAT;
+exports.MOST_NEGATIVE_SINGLE_FLOAT = MOST_NEGATIVE_SINGLE_FLOAT;
+exports.MOST_POSITIVE_SINGLE_FLOAT = MOST_POSITIVE_SINGLE_FLOAT;

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

@@ -0,0 +1,6 @@
+const MOST_NEGATIVE_SINGLE_FLOAT = -34028234663852886e22;
+const MOST_POSITIVE_SINGLE_FLOAT = -MOST_NEGATIVE_SINGLE_FLOAT;
+export {
+  MOST_NEGATIVE_SINGLE_FLOAT,
+  MOST_POSITIVE_SINGLE_FLOAT
+};

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

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const createAbortError = () => new DOMException("", "AbortError");
+exports.createAbortError = createAbortError;

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

@@ -0,0 +1,4 @@
+const createAbortError = () => new DOMException("", "AbortError");
+export {
+  createAbortError
+};

package/dist/node_modules/standardized-audio-context/build/es2019/factories/add-active-input-connection-to-audio-node.cjs

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const createAddActiveInputConnectionToAudioNode = (insertElementInSet) => {
+  return (activeInputs, source, [output, input, eventListener], ignoreDuplicates) => {
+    insertElementInSet(activeInputs[input], [source, output, eventListener], (activeInputConnection) => activeInputConnection[0] === source && activeInputConnection[1] === output, ignoreDuplicates);
+  };
+};
+exports.createAddActiveInputConnectionToAudioNode = createAddActiveInputConnectionToAudioNode;

package/dist/node_modules/standardized-audio-context/build/es2019/factories/add-active-input-connection-to-audio-node.js

@@ -0,0 +1,8 @@
+const createAddActiveInputConnectionToAudioNode = (insertElementInSet) => {
+  return (activeInputs, source, [output, input, eventListener], ignoreDuplicates) => {
+    insertElementInSet(activeInputs[input], [source, output, eventListener], (activeInputConnection) => activeInputConnection[0] === source && activeInputConnection[1] === output, ignoreDuplicates);
+  };
+};
+export {
+  createAddActiveInputConnectionToAudioNode
+};

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

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const createAddAudioNodeConnections = (audioNodeConnectionsStore) => {
+  return (audioNode, audioNodeRenderer, nativeAudioNode) => {
+    const activeInputs = [];
+    for (let i = 0; i < nativeAudioNode.numberOfInputs; i += 1) {
+      activeInputs.push(/* @__PURE__ */ new Set());
+    }
+    audioNodeConnectionsStore.set(audioNode, {
+      activeInputs,
+      outputs: /* @__PURE__ */ new Set(),
+      passiveInputs: /* @__PURE__ */ new WeakMap(),
+      renderer: audioNodeRenderer
+    });
+  };
+};
+exports.createAddAudioNodeConnections = createAddAudioNodeConnections;

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

@@ -0,0 +1,17 @@
+const createAddAudioNodeConnections = (audioNodeConnectionsStore) => {
+  return (audioNode, audioNodeRenderer, nativeAudioNode) => {
+    const activeInputs = [];
+    for (let i = 0; i < nativeAudioNode.numberOfInputs; i += 1) {
+      activeInputs.push(/* @__PURE__ */ new Set());
+    }
+    audioNodeConnectionsStore.set(audioNode, {
+      activeInputs,
+      outputs: /* @__PURE__ */ new Set(),
+      passiveInputs: /* @__PURE__ */ new WeakMap(),
+      renderer: audioNodeRenderer
+    });
+  };
+};
+export {
+  createAddAudioNodeConnections
+};

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

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const createAddAudioParamConnections = (audioParamConnectionsStore) => {
+  return (audioParam, audioParamRenderer) => {
+    audioParamConnectionsStore.set(audioParam, { activeInputs: /* @__PURE__ */ new Set(), passiveInputs: /* @__PURE__ */ new WeakMap(), renderer: audioParamRenderer });
+  };
+};
+exports.createAddAudioParamConnections = createAddAudioParamConnections;

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

@@ -0,0 +1,8 @@
+const createAddAudioParamConnections = (audioParamConnectionsStore) => {
+  return (audioParam, audioParamRenderer) => {
+    audioParamConnectionsStore.set(audioParam, { activeInputs: /* @__PURE__ */ new Set(), passiveInputs: /* @__PURE__ */ new WeakMap(), renderer: audioParamRenderer });
+  };
+};
+export {
+  createAddAudioParamConnections
+};

package/dist/node_modules/standardized-audio-context/build/es2019/factories/add-audio-worklet-module.cjs

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const globals = require("../globals.cjs");
+const isConstructible = require("../helpers/is-constructible.cjs");
+const splitImportStatements = require("../helpers/split-import-statements.cjs");
+const verifyParameterDescriptors = (parameterDescriptors) => {
+  if (parameterDescriptors !== void 0 && !Array.isArray(parameterDescriptors)) {
+    throw new TypeError("The parameterDescriptors property of given value for processorCtor is not an array.");
+  }
+};
+const verifyProcessorCtor = (processorCtor) => {
+  if (!isConstructible.isConstructible(processorCtor)) {
+    throw new TypeError("The given value for processorCtor should be a constructor.");
+  }
+  if (processorCtor.prototype === null || typeof processorCtor.prototype !== "object") {
+    throw new TypeError("The given value for processorCtor should have a prototype.");
+  }
+};
+const createAddAudioWorkletModule = (cacheTestResult, createNotSupportedError, evaluateSource, exposeCurrentFrameAndCurrentTime, fetchSource, getNativeContext, getOrCreateBackupOfflineAudioContext, isNativeOfflineAudioContext, nativeAudioWorkletNodeConstructor, ongoingRequests, resolvedRequests, testAudioWorkletProcessorPostMessageSupport, window) => {
+  let index = 0;
+  return (context, moduleURL, options = { credentials: "omit" }) => {
+    const resolvedRequestsOfContext = resolvedRequests.get(context);
+    if (resolvedRequestsOfContext !== void 0 && resolvedRequestsOfContext.has(moduleURL)) {
+      return Promise.resolve();
+    }
+    const ongoingRequestsOfContext = ongoingRequests.get(context);
+    if (ongoingRequestsOfContext !== void 0) {
+      const promiseOfOngoingRequest = ongoingRequestsOfContext.get(moduleURL);
+      if (promiseOfOngoingRequest !== void 0) {
+        return promiseOfOngoingRequest;
+      }
+    }
+    const nativeContext = getNativeContext(context);
+    const promise = nativeContext.audioWorklet === void 0 ? fetchSource(moduleURL).then(([source, absoluteUrl]) => {
+      const [importStatements, sourceWithoutImportStatements] = splitImportStatements.splitImportStatements(source, absoluteUrl);
+      const wrappedSource = `${importStatements};((a,b)=>{(a[b]=a[b]||[]).push((AudioWorkletProcessor,global,registerProcessor,sampleRate,self,window)=>{${sourceWithoutImportStatements}
+})})(window,'_AWGS')`;
+      return evaluateSource(wrappedSource);
+    }).then(() => {
+      const evaluateAudioWorkletGlobalScope = window._AWGS.pop();
+      if (evaluateAudioWorkletGlobalScope === void 0) {
+        throw new SyntaxError();
+      }
+      exposeCurrentFrameAndCurrentTime(nativeContext.currentTime, nativeContext.sampleRate, () => evaluateAudioWorkletGlobalScope(class AudioWorkletProcessor {
+      }, void 0, (name, processorCtor) => {
+        if (name.trim() === "") {
+          throw createNotSupportedError();
+        }
+        const nodeNameToProcessorConstructorMap = globals.NODE_NAME_TO_PROCESSOR_CONSTRUCTOR_MAPS.get(nativeContext);
+        if (nodeNameToProcessorConstructorMap !== void 0) {
+          if (nodeNameToProcessorConstructorMap.has(name)) {
+            throw createNotSupportedError();
+          }
+          verifyProcessorCtor(processorCtor);
+          verifyParameterDescriptors(processorCtor.parameterDescriptors);
+          nodeNameToProcessorConstructorMap.set(name, processorCtor);
+        } else {
+          verifyProcessorCtor(processorCtor);
+          verifyParameterDescriptors(processorCtor.parameterDescriptors);
+          globals.NODE_NAME_TO_PROCESSOR_CONSTRUCTOR_MAPS.set(nativeContext, /* @__PURE__ */ new Map([[name, processorCtor]]));
+        }
+      }, nativeContext.sampleRate, void 0, void 0));
+    }) : Promise.all([
+      fetchSource(moduleURL),
+      Promise.resolve(cacheTestResult(testAudioWorkletProcessorPostMessageSupport, testAudioWorkletProcessorPostMessageSupport))
+    ]).then(([[source, absoluteUrl], isSupportingPostMessage]) => {
+      const currentIndex = index + 1;
+      index = currentIndex;
+      const [importStatements, sourceWithoutImportStatements] = splitImportStatements.splitImportStatements(source, absoluteUrl);
+      const patchedAudioWorkletProcessor = isSupportingPostMessage ? "AudioWorkletProcessor" : "class extends AudioWorkletProcessor {__b=new WeakSet();constructor(){super();(p=>p.postMessage=(q=>(m,t)=>q.call(p,m,t?t.filter(u=>!this.__b.has(u)):t))(p.postMessage))(this.port)}}";
+      const memberDefinition = isSupportingPostMessage ? "" : "__c = (a) => a.forEach(e=>this.__b.add(e.buffer));";
+      const bufferRegistration = isSupportingPostMessage ? "" : "i.forEach(this.__c);o.forEach(this.__c);this.__c(Object.values(p));";
+      const wrappedSource = `${importStatements};((AudioWorkletProcessor,registerProcessor)=>{${sourceWithoutImportStatements}
+})(${patchedAudioWorkletProcessor},(n,p)=>registerProcessor(n,class extends p{${memberDefinition}process(i,o,p){${bufferRegistration}return super.process(i.map(j=>j.some(k=>k.length===0)?[]:j),o,p)}}));registerProcessor('__sac${currentIndex}',class extends AudioWorkletProcessor{process(){return !1}})`;
+      const blob = new Blob([wrappedSource], { type: "application/javascript; charset=utf-8" });
+      const url = URL.createObjectURL(blob);
+      return nativeContext.audioWorklet.addModule(url, options).then(() => {
+        if (isNativeOfflineAudioContext(nativeContext)) {
+          return nativeContext;
+        }
+        const backupOfflineAudioContext = getOrCreateBackupOfflineAudioContext(nativeContext);
+        return backupOfflineAudioContext.audioWorklet.addModule(url, options).then(() => backupOfflineAudioContext);
+      }).then((nativeContextOrBackupOfflineAudioContext) => {
+        if (nativeAudioWorkletNodeConstructor === null) {
+          throw new SyntaxError();
+        }
+        try {
+          new nativeAudioWorkletNodeConstructor(nativeContextOrBackupOfflineAudioContext, `__sac${currentIndex}`);
+        } catch {
+          throw new SyntaxError();
+        }
+      }).finally(() => URL.revokeObjectURL(url));
+    });
+    if (ongoingRequestsOfContext === void 0) {
+      ongoingRequests.set(context, /* @__PURE__ */ new Map([[moduleURL, promise]]));
+    } else {
+      ongoingRequestsOfContext.set(moduleURL, promise);
+    }
+    promise.then(() => {
+      const updatedResolvedRequestsOfContext = resolvedRequests.get(context);
+      if (updatedResolvedRequestsOfContext === void 0) {
+        resolvedRequests.set(context, /* @__PURE__ */ new Set([moduleURL]));
+      } else {
+        updatedResolvedRequestsOfContext.add(moduleURL);
+      }
+    }).finally(() => {
+      const updatedOngoingRequestsOfContext = ongoingRequests.get(context);
+      if (updatedOngoingRequestsOfContext !== void 0) {
+        updatedOngoingRequestsOfContext.delete(moduleURL);
+      }
+    });
+    return promise;
+  };
+};
+exports.createAddAudioWorkletModule = createAddAudioWorkletModule;

package/dist/node_modules/standardized-audio-context/build/es2019/factories/add-audio-worklet-module.js

@@ -0,0 +1,115 @@
+import { NODE_NAME_TO_PROCESSOR_CONSTRUCTOR_MAPS } from "../globals.js";
+import { isConstructible } from "../helpers/is-constructible.js";
+import { splitImportStatements } from "../helpers/split-import-statements.js";
+const verifyParameterDescriptors = (parameterDescriptors) => {
+  if (parameterDescriptors !== void 0 && !Array.isArray(parameterDescriptors)) {
+    throw new TypeError("The parameterDescriptors property of given value for processorCtor is not an array.");
+  }
+};
+const verifyProcessorCtor = (processorCtor) => {
+  if (!isConstructible(processorCtor)) {
+    throw new TypeError("The given value for processorCtor should be a constructor.");
+  }
+  if (processorCtor.prototype === null || typeof processorCtor.prototype !== "object") {
+    throw new TypeError("The given value for processorCtor should have a prototype.");
+  }
+};
+const createAddAudioWorkletModule = (cacheTestResult, createNotSupportedError, evaluateSource, exposeCurrentFrameAndCurrentTime, fetchSource, getNativeContext, getOrCreateBackupOfflineAudioContext, isNativeOfflineAudioContext, nativeAudioWorkletNodeConstructor, ongoingRequests, resolvedRequests, testAudioWorkletProcessorPostMessageSupport, window) => {
+  let index = 0;
+  return (context, moduleURL, options = { credentials: "omit" }) => {
+    const resolvedRequestsOfContext = resolvedRequests.get(context);
+    if (resolvedRequestsOfContext !== void 0 && resolvedRequestsOfContext.has(moduleURL)) {
+      return Promise.resolve();
+    }
+    const ongoingRequestsOfContext = ongoingRequests.get(context);
+    if (ongoingRequestsOfContext !== void 0) {
+      const promiseOfOngoingRequest = ongoingRequestsOfContext.get(moduleURL);
+      if (promiseOfOngoingRequest !== void 0) {
+        return promiseOfOngoingRequest;
+      }
+    }
+    const nativeContext = getNativeContext(context);
+    const promise = nativeContext.audioWorklet === void 0 ? fetchSource(moduleURL).then(([source, absoluteUrl]) => {
+      const [importStatements, sourceWithoutImportStatements] = splitImportStatements(source, absoluteUrl);
+      const wrappedSource = `${importStatements};((a,b)=>{(a[b]=a[b]||[]).push((AudioWorkletProcessor,global,registerProcessor,sampleRate,self,window)=>{${sourceWithoutImportStatements}
+})})(window,'_AWGS')`;
+      return evaluateSource(wrappedSource);
+    }).then(() => {
+      const evaluateAudioWorkletGlobalScope = window._AWGS.pop();
+      if (evaluateAudioWorkletGlobalScope === void 0) {
+        throw new SyntaxError();
+      }
+      exposeCurrentFrameAndCurrentTime(nativeContext.currentTime, nativeContext.sampleRate, () => evaluateAudioWorkletGlobalScope(class AudioWorkletProcessor {
+      }, void 0, (name, processorCtor) => {
+        if (name.trim() === "") {
+          throw createNotSupportedError();
+        }
+        const nodeNameToProcessorConstructorMap = NODE_NAME_TO_PROCESSOR_CONSTRUCTOR_MAPS.get(nativeContext);
+        if (nodeNameToProcessorConstructorMap !== void 0) {
+          if (nodeNameToProcessorConstructorMap.has(name)) {
+            throw createNotSupportedError();
+          }
+          verifyProcessorCtor(processorCtor);
+          verifyParameterDescriptors(processorCtor.parameterDescriptors);
+          nodeNameToProcessorConstructorMap.set(name, processorCtor);
+        } else {
+          verifyProcessorCtor(processorCtor);
+          verifyParameterDescriptors(processorCtor.parameterDescriptors);
+          NODE_NAME_TO_PROCESSOR_CONSTRUCTOR_MAPS.set(nativeContext, /* @__PURE__ */ new Map([[name, processorCtor]]));
+        }
+      }, nativeContext.sampleRate, void 0, void 0));
+    }) : Promise.all([
+      fetchSource(moduleURL),
+      Promise.resolve(cacheTestResult(testAudioWorkletProcessorPostMessageSupport, testAudioWorkletProcessorPostMessageSupport))
+    ]).then(([[source, absoluteUrl], isSupportingPostMessage]) => {
+      const currentIndex = index + 1;
+      index = currentIndex;
+      const [importStatements, sourceWithoutImportStatements] = splitImportStatements(source, absoluteUrl);
+      const patchedAudioWorkletProcessor = isSupportingPostMessage ? "AudioWorkletProcessor" : "class extends AudioWorkletProcessor {__b=new WeakSet();constructor(){super();(p=>p.postMessage=(q=>(m,t)=>q.call(p,m,t?t.filter(u=>!this.__b.has(u)):t))(p.postMessage))(this.port)}}";
+      const memberDefinition = isSupportingPostMessage ? "" : "__c = (a) => a.forEach(e=>this.__b.add(e.buffer));";
+      const bufferRegistration = isSupportingPostMessage ? "" : "i.forEach(this.__c);o.forEach(this.__c);this.__c(Object.values(p));";
+      const wrappedSource = `${importStatements};((AudioWorkletProcessor,registerProcessor)=>{${sourceWithoutImportStatements}
+})(${patchedAudioWorkletProcessor},(n,p)=>registerProcessor(n,class extends p{${memberDefinition}process(i,o,p){${bufferRegistration}return super.process(i.map(j=>j.some(k=>k.length===0)?[]:j),o,p)}}));registerProcessor('__sac${currentIndex}',class extends AudioWorkletProcessor{process(){return !1}})`;
+      const blob = new Blob([wrappedSource], { type: "application/javascript; charset=utf-8" });
+      const url = URL.createObjectURL(blob);
+      return nativeContext.audioWorklet.addModule(url, options).then(() => {
+        if (isNativeOfflineAudioContext(nativeContext)) {
+          return nativeContext;
+        }
+        const backupOfflineAudioContext = getOrCreateBackupOfflineAudioContext(nativeContext);
+        return backupOfflineAudioContext.audioWorklet.addModule(url, options).then(() => backupOfflineAudioContext);
+      }).then((nativeContextOrBackupOfflineAudioContext) => {
+        if (nativeAudioWorkletNodeConstructor === null) {
+          throw new SyntaxError();
+        }
+        try {
+          new nativeAudioWorkletNodeConstructor(nativeContextOrBackupOfflineAudioContext, `__sac${currentIndex}`);
+        } catch {
+          throw new SyntaxError();
+        }
+      }).finally(() => URL.revokeObjectURL(url));
+    });
+    if (ongoingRequestsOfContext === void 0) {
+      ongoingRequests.set(context, /* @__PURE__ */ new Map([[moduleURL, promise]]));
+    } else {
+      ongoingRequestsOfContext.set(moduleURL, promise);
+    }
+    promise.then(() => {
+      const updatedResolvedRequestsOfContext = resolvedRequests.get(context);
+      if (updatedResolvedRequestsOfContext === void 0) {
+        resolvedRequests.set(context, /* @__PURE__ */ new Set([moduleURL]));
+      } else {
+        updatedResolvedRequestsOfContext.add(moduleURL);
+      }
+    }).finally(() => {
+      const updatedOngoingRequestsOfContext = ongoingRequests.get(context);
+      if (updatedOngoingRequestsOfContext !== void 0) {
+        updatedOngoingRequestsOfContext.delete(moduleURL);
+      }
+    });
+    return promise;
+  };
+};
+export {
+  createAddAudioWorkletModule
+};

package/dist/node_modules/standardized-audio-context/build/es2019/factories/add-connection-to-audio-node.cjs

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const deletePassiveInputConnectionToAudioNode = require("../helpers/delete-passive-input-connection-to-audio-node.cjs");
+const setInternalStateToActive = require("../helpers/set-internal-state-to-active.cjs");
+const setInternalStateToPassiveWhenNecessary = require("../helpers/set-internal-state-to-passive-when-necessary.cjs");
+const createAddConnectionToAudioNode = (addActiveInputConnectionToAudioNode, addPassiveInputConnectionToAudioNode, connectNativeAudioNodeToNativeAudioNode, deleteActiveInputConnectionToAudioNode, disconnectNativeAudioNodeFromNativeAudioNode, getAudioNodeConnections, getAudioNodeTailTime, getEventListenersOfAudioNode, getNativeAudioNode, insertElementInSet, isActiveAudioNode, isPartOfACycle, isPassiveAudioNode) => {
+  const tailTimeTimeoutIds = /* @__PURE__ */ new WeakMap();
+  return (source, destination, output, input, isOffline) => {
+    const { activeInputs, passiveInputs } = getAudioNodeConnections(destination);
+    const { outputs } = getAudioNodeConnections(source);
+    const eventListeners = getEventListenersOfAudioNode(source);
+    const eventListener = (isActive) => {
+      const nativeDestinationAudioNode = getNativeAudioNode(destination);
+      const nativeSourceAudioNode = getNativeAudioNode(source);
+      if (isActive) {
+        const partialConnection = deletePassiveInputConnectionToAudioNode.deletePassiveInputConnectionToAudioNode(passiveInputs, source, output, input);
+        addActiveInputConnectionToAudioNode(activeInputs, source, partialConnection, false);
+        if (!isOffline && !isPartOfACycle(source)) {
+          connectNativeAudioNodeToNativeAudioNode(nativeSourceAudioNode, nativeDestinationAudioNode, output, input);
+        }
+        if (isPassiveAudioNode(destination)) {
+          setInternalStateToActive.setInternalStateToActive(destination);
+        }
+      } else {
+        const partialConnection = deleteActiveInputConnectionToAudioNode(activeInputs, source, output, input);
+        addPassiveInputConnectionToAudioNode(passiveInputs, input, partialConnection, false);
+        if (!isOffline && !isPartOfACycle(source)) {
+          disconnectNativeAudioNodeFromNativeAudioNode(nativeSourceAudioNode, nativeDestinationAudioNode, output, input);
+        }
+        const tailTime = getAudioNodeTailTime(destination);
+        if (tailTime === 0) {
+          if (isActiveAudioNode(destination)) {
+            setInternalStateToPassiveWhenNecessary.setInternalStateToPassiveWhenNecessary(destination, activeInputs);
+          }
+        } else {
+          const tailTimeTimeoutId = tailTimeTimeoutIds.get(destination);
+          if (tailTimeTimeoutId !== void 0) {
+            clearTimeout(tailTimeTimeoutId);
+          }
+          tailTimeTimeoutIds.set(destination, setTimeout(() => {
+            if (isActiveAudioNode(destination)) {
+              setInternalStateToPassiveWhenNecessary.setInternalStateToPassiveWhenNecessary(destination, activeInputs);
+            }
+          }, tailTime * 1e3));
+        }
+      }
+    };
+    if (insertElementInSet(outputs, [destination, output, input], (outputConnection) => outputConnection[0] === destination && outputConnection[1] === output && outputConnection[2] === input, true)) {
+      eventListeners.add(eventListener);
+      if (isActiveAudioNode(source)) {
+        addActiveInputConnectionToAudioNode(activeInputs, source, [output, input, eventListener], true);
+      } else {
+        addPassiveInputConnectionToAudioNode(passiveInputs, input, [source, output, eventListener], true);
+      }
+      return true;
+    }
+    return false;
+  };
+};
+exports.createAddConnectionToAudioNode = createAddConnectionToAudioNode;

package/dist/node_modules/standardized-audio-context/build/es2019/factories/add-connection-to-audio-node.js

@@ -0,0 +1,60 @@
+import { deletePassiveInputConnectionToAudioNode } from "../helpers/delete-passive-input-connection-to-audio-node.js";
+import { setInternalStateToActive } from "../helpers/set-internal-state-to-active.js";
+import { setInternalStateToPassiveWhenNecessary } from "../helpers/set-internal-state-to-passive-when-necessary.js";
+const createAddConnectionToAudioNode = (addActiveInputConnectionToAudioNode, addPassiveInputConnectionToAudioNode, connectNativeAudioNodeToNativeAudioNode, deleteActiveInputConnectionToAudioNode, disconnectNativeAudioNodeFromNativeAudioNode, getAudioNodeConnections, getAudioNodeTailTime, getEventListenersOfAudioNode, getNativeAudioNode, insertElementInSet, isActiveAudioNode, isPartOfACycle, isPassiveAudioNode) => {
+  const tailTimeTimeoutIds = /* @__PURE__ */ new WeakMap();
+  return (source, destination, output, input, isOffline) => {
+    const { activeInputs, passiveInputs } = getAudioNodeConnections(destination);
+    const { outputs } = getAudioNodeConnections(source);
+    const eventListeners = getEventListenersOfAudioNode(source);
+    const eventListener = (isActive) => {
+      const nativeDestinationAudioNode = getNativeAudioNode(destination);
+      const nativeSourceAudioNode = getNativeAudioNode(source);
+      if (isActive) {
+        const partialConnection = deletePassiveInputConnectionToAudioNode(passiveInputs, source, output, input);
+        addActiveInputConnectionToAudioNode(activeInputs, source, partialConnection, false);
+        if (!isOffline && !isPartOfACycle(source)) {
+          connectNativeAudioNodeToNativeAudioNode(nativeSourceAudioNode, nativeDestinationAudioNode, output, input);
+        }
+        if (isPassiveAudioNode(destination)) {
+          setInternalStateToActive(destination);
+        }
+      } else {
+        const partialConnection = deleteActiveInputConnectionToAudioNode(activeInputs, source, output, input);
+        addPassiveInputConnectionToAudioNode(passiveInputs, input, partialConnection, false);
+        if (!isOffline && !isPartOfACycle(source)) {
+          disconnectNativeAudioNodeFromNativeAudioNode(nativeSourceAudioNode, nativeDestinationAudioNode, output, input);
+        }
+        const tailTime = getAudioNodeTailTime(destination);
+        if (tailTime === 0) {
+          if (isActiveAudioNode(destination)) {
+            setInternalStateToPassiveWhenNecessary(destination, activeInputs);
+          }
+        } else {
+          const tailTimeTimeoutId = tailTimeTimeoutIds.get(destination);
+          if (tailTimeTimeoutId !== void 0) {
+            clearTimeout(tailTimeTimeoutId);
+          }
+          tailTimeTimeoutIds.set(destination, setTimeout(() => {
+            if (isActiveAudioNode(destination)) {
+              setInternalStateToPassiveWhenNecessary(destination, activeInputs);
+            }
+          }, tailTime * 1e3));
+        }
+      }
+    };
+    if (insertElementInSet(outputs, [destination, output, input], (outputConnection) => outputConnection[0] === destination && outputConnection[1] === output && outputConnection[2] === input, true)) {
+      eventListeners.add(eventListener);
+      if (isActiveAudioNode(source)) {
+        addActiveInputConnectionToAudioNode(activeInputs, source, [output, input, eventListener], true);
+      } else {
+        addPassiveInputConnectionToAudioNode(passiveInputs, input, [source, output, eventListener], true);
+      }
+      return true;
+    }
+    return false;
+  };
+};
+export {
+  createAddConnectionToAudioNode
+};