react-audio-wavekit 0.1.7 → 0.1.8

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

@@ -1,274 +0,0 @@
-import { AUDIO_NODE_STORE, EVENT_LISTENERS } from "../globals.js";
-import { isAudioNode } from "../guards/audio-node.js";
-import { isAudioNodeOutputConnection } from "../guards/audio-node-output-connection.js";
-import { addActiveInputConnectionToAudioParam } from "../helpers/add-active-input-connection-to-audio-param.js";
-import { addPassiveInputConnectionToAudioParam } from "../helpers/add-passive-input-connection-to-audio-param.js";
-import { connectNativeAudioNodeToNativeAudioNode } from "../helpers/connect-native-audio-node-to-native-audio-node.js";
-import { deleteActiveInputConnection } from "../helpers/delete-active-input-connection.js";
-import { deleteActiveInputConnectionToAudioParam } from "../helpers/delete-active-input-connection-to-audio-param.js";
-import { deleteEventListenerOfAudioNode } from "../helpers/delete-event-listeners-of-audio-node.js";
-import { deletePassiveInputConnectionToAudioNode } from "../helpers/delete-passive-input-connection-to-audio-node.js";
-import { deletePassiveInputConnectionToAudioParam } from "../helpers/delete-passive-input-connection-to-audio-param.js";
-import { disconnectNativeAudioNodeFromNativeAudioNode } from "../helpers/disconnect-native-audio-node-from-native-audio-node.js";
-import { getAudioNodeConnections } from "../helpers/get-audio-node-connections.js";
-import { getAudioParamConnections } from "../helpers/get-audio-param-connections.js";
-import { getEventListenersOfAudioNode } from "../helpers/get-event-listeners-of-audio-node.js";
-import { getNativeAudioNode } from "../helpers/get-native-audio-node.js";
-import { getNativeAudioParam } from "../helpers/get-native-audio-param.js";
-import { insertElementInSet } from "../helpers/insert-element-in-set.js";
-import { isActiveAudioNode } from "../helpers/is-active-audio-node.js";
-import { isPartOfACycle } from "../helpers/is-part-of-a-cycle.js";
-import { isPassiveAudioNode } from "../helpers/is-passive-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";
-import { testAudioNodeDisconnectMethodSupport } from "../helpers/test-audio-node-disconnect-method-support.js";
-import { visitEachAudioNodeOnce } from "../helpers/visit-each-audio-node-once.js";
-import { wrapAudioNodeDisconnectMethod } from "../helpers/wrap-audio-node-disconnect-method.js";
-const addConnectionToAudioParamOfAudioContext = (source, destination, output, isOffline) => {
-  const { activeInputs, passiveInputs } = getAudioParamConnections(destination);
-  const { outputs } = getAudioNodeConnections(source);
-  const eventListeners = getEventListenersOfAudioNode(source);
-  const eventListener = (isActive) => {
-    const nativeAudioNode = getNativeAudioNode(source);
-    const nativeAudioParam = getNativeAudioParam(destination);
-    if (isActive) {
-      const partialConnection = deletePassiveInputConnectionToAudioParam(passiveInputs, source, output);
-      addActiveInputConnectionToAudioParam(activeInputs, source, partialConnection, false);
-      if (!isOffline && !isPartOfACycle(source)) {
-        nativeAudioNode.connect(nativeAudioParam, output);
-      }
-    } else {
-      const partialConnection = deleteActiveInputConnectionToAudioParam(activeInputs, source, output);
-      addPassiveInputConnectionToAudioParam(passiveInputs, partialConnection, false);
-      if (!isOffline && !isPartOfACycle(source)) {
-        nativeAudioNode.disconnect(nativeAudioParam, output);
-      }
-    }
-  };
-  if (insertElementInSet(outputs, [destination, output], (outputConnection) => outputConnection[0] === destination && outputConnection[1] === output, true)) {
-    eventListeners.add(eventListener);
-    if (isActiveAudioNode(source)) {
-      addActiveInputConnectionToAudioParam(activeInputs, source, [output, eventListener], true);
-    } else {
-      addPassiveInputConnectionToAudioParam(passiveInputs, [source, output, eventListener], true);
-    }
-    return true;
-  }
-  return false;
-};
-const deleteInputConnectionOfAudioNode = (source, destination, output, input) => {
-  const { activeInputs, passiveInputs } = getAudioNodeConnections(destination);
-  const activeInputConnection = deleteActiveInputConnection(activeInputs[input], source, output);
-  if (activeInputConnection === null) {
-    const passiveInputConnection = deletePassiveInputConnectionToAudioNode(passiveInputs, source, output, input);
-    return [passiveInputConnection[2], false];
-  }
-  return [activeInputConnection[2], true];
-};
-const deleteInputConnectionOfAudioParam = (source, destination, output) => {
-  const { activeInputs, passiveInputs } = getAudioParamConnections(destination);
-  const activeInputConnection = deleteActiveInputConnection(activeInputs, source, output);
-  if (activeInputConnection === null) {
-    const passiveInputConnection = deletePassiveInputConnectionToAudioParam(passiveInputs, source, output);
-    return [passiveInputConnection[1], false];
-  }
-  return [activeInputConnection[2], true];
-};
-const deleteInputsOfAudioNode = (source, isOffline, destination, output, input) => {
-  const [listener, isActive] = deleteInputConnectionOfAudioNode(source, destination, output, input);
-  if (listener !== null) {
-    deleteEventListenerOfAudioNode(source, listener);
-    if (isActive && !isOffline && !isPartOfACycle(source)) {
-      disconnectNativeAudioNodeFromNativeAudioNode(getNativeAudioNode(source), getNativeAudioNode(destination), output, input);
-    }
-  }
-  if (isActiveAudioNode(destination)) {
-    const { activeInputs } = getAudioNodeConnections(destination);
-    setInternalStateToPassiveWhenNecessary(destination, activeInputs);
-  }
-};
-const deleteInputsOfAudioParam = (source, isOffline, destination, output) => {
-  const [listener, isActive] = deleteInputConnectionOfAudioParam(source, destination, output);
-  if (listener !== null) {
-    deleteEventListenerOfAudioNode(source, listener);
-    if (isActive && !isOffline && !isPartOfACycle(source)) {
-      getNativeAudioNode(source).disconnect(getNativeAudioParam(destination), output);
-    }
-  }
-};
-const deleteAnyConnection = (source, isOffline) => {
-  const audioNodeConnectionsOfSource = getAudioNodeConnections(source);
-  const destinations = [];
-  for (const outputConnection of audioNodeConnectionsOfSource.outputs) {
-    if (isAudioNodeOutputConnection(outputConnection)) {
-      deleteInputsOfAudioNode(source, isOffline, ...outputConnection);
-    } else {
-      deleteInputsOfAudioParam(source, isOffline, ...outputConnection);
-    }
-    destinations.push(outputConnection[0]);
-  }
-  audioNodeConnectionsOfSource.outputs.clear();
-  return destinations;
-};
-const deleteConnectionAtOutput = (source, isOffline, output) => {
-  const audioNodeConnectionsOfSource = getAudioNodeConnections(source);
-  const destinations = [];
-  for (const outputConnection of audioNodeConnectionsOfSource.outputs) {
-    if (outputConnection[1] === output) {
-      if (isAudioNodeOutputConnection(outputConnection)) {
-        deleteInputsOfAudioNode(source, isOffline, ...outputConnection);
-      } else {
-        deleteInputsOfAudioParam(source, isOffline, ...outputConnection);
-      }
-      destinations.push(outputConnection[0]);
-      audioNodeConnectionsOfSource.outputs.delete(outputConnection);
-    }
-  }
-  return destinations;
-};
-const deleteConnectionToDestination = (source, isOffline, destination, output, input) => {
-  const audioNodeConnectionsOfSource = getAudioNodeConnections(source);
-  return Array.from(audioNodeConnectionsOfSource.outputs).filter((outputConnection) => outputConnection[0] === destination && (output === void 0 || outputConnection[1] === output) && (input === void 0 || outputConnection[2] === input)).map((outputConnection) => {
-    if (isAudioNodeOutputConnection(outputConnection)) {
-      deleteInputsOfAudioNode(source, isOffline, ...outputConnection);
-    } else {
-      deleteInputsOfAudioParam(source, isOffline, ...outputConnection);
-    }
-    audioNodeConnectionsOfSource.outputs.delete(outputConnection);
-    return outputConnection[0];
-  });
-};
-const createAudioNodeConstructor = (addAudioNodeConnections, addConnectionToAudioNode, cacheTestResult, createIncrementCycleCounter, createIndexSizeError, createInvalidAccessError, createNotSupportedError, decrementCycleCounter, detectCycles, eventTargetConstructor, getNativeContext, isNativeAudioContext, isNativeAudioNode, isNativeAudioParam, isNativeOfflineAudioContext, nativeAudioWorkletNodeConstructor) => {
-  return class AudioNode extends eventTargetConstructor {
-    constructor(context, isActive, nativeAudioNode, audioNodeRenderer) {
-      super(nativeAudioNode);
-      this._context = context;
-      this._nativeAudioNode = nativeAudioNode;
-      const nativeContext = getNativeContext(context);
-      if (isNativeAudioContext(nativeContext) && true !== cacheTestResult(testAudioNodeDisconnectMethodSupport, () => {
-        return testAudioNodeDisconnectMethodSupport(nativeContext, nativeAudioWorkletNodeConstructor);
-      })) {
-        wrapAudioNodeDisconnectMethod(nativeAudioNode);
-      }
-      AUDIO_NODE_STORE.set(this, nativeAudioNode);
-      EVENT_LISTENERS.set(this, /* @__PURE__ */ new Set());
-      if (context.state !== "closed" && isActive) {
-        setInternalStateToActive(this);
-      }
-      addAudioNodeConnections(this, audioNodeRenderer, nativeAudioNode);
-    }
-    get channelCount() {
-      return this._nativeAudioNode.channelCount;
-    }
-    set channelCount(value) {
-      this._nativeAudioNode.channelCount = value;
-    }
-    get channelCountMode() {
-      return this._nativeAudioNode.channelCountMode;
-    }
-    set channelCountMode(value) {
-      this._nativeAudioNode.channelCountMode = value;
-    }
-    get channelInterpretation() {
-      return this._nativeAudioNode.channelInterpretation;
-    }
-    set channelInterpretation(value) {
-      this._nativeAudioNode.channelInterpretation = value;
-    }
-    get context() {
-      return this._context;
-    }
-    get numberOfInputs() {
-      return this._nativeAudioNode.numberOfInputs;
-    }
-    get numberOfOutputs() {
-      return this._nativeAudioNode.numberOfOutputs;
-    }
-    // tslint:disable-next-line:invalid-void
-    connect(destination, output = 0, input = 0) {
-      if (output < 0 || output >= this._nativeAudioNode.numberOfOutputs) {
-        throw createIndexSizeError();
-      }
-      const nativeContext = getNativeContext(this._context);
-      const isOffline = isNativeOfflineAudioContext(nativeContext);
-      if (isNativeAudioNode(destination) || isNativeAudioParam(destination)) {
-        throw createInvalidAccessError();
-      }
-      if (isAudioNode(destination)) {
-        const nativeDestinationAudioNode = getNativeAudioNode(destination);
-        try {
-          const connection = connectNativeAudioNodeToNativeAudioNode(this._nativeAudioNode, nativeDestinationAudioNode, output, input);
-          const isPassive = isPassiveAudioNode(this);
-          if (isOffline || isPassive) {
-            this._nativeAudioNode.disconnect(...connection);
-          }
-          if (this.context.state !== "closed" && !isPassive && isPassiveAudioNode(destination)) {
-            setInternalStateToActive(destination);
-          }
-        } catch (err) {
-          if (err.code === 12) {
-            throw createInvalidAccessError();
-          }
-          throw err;
-        }
-        const isNewConnectionToAudioNode = addConnectionToAudioNode(this, destination, output, input, isOffline);
-        if (isNewConnectionToAudioNode) {
-          const cycles = detectCycles([this], destination);
-          visitEachAudioNodeOnce(cycles, createIncrementCycleCounter(isOffline));
-        }
-        return destination;
-      }
-      const nativeAudioParam = getNativeAudioParam(destination);
-      if (nativeAudioParam.name === "playbackRate" && nativeAudioParam.maxValue === 1024) {
-        throw createNotSupportedError();
-      }
-      try {
-        this._nativeAudioNode.connect(nativeAudioParam, output);
-        if (isOffline || isPassiveAudioNode(this)) {
-          this._nativeAudioNode.disconnect(nativeAudioParam, output);
-        }
-      } catch (err) {
-        if (err.code === 12) {
-          throw createInvalidAccessError();
-        }
-        throw err;
-      }
-      const isNewConnectionToAudioParam = addConnectionToAudioParamOfAudioContext(this, destination, output, isOffline);
-      if (isNewConnectionToAudioParam) {
-        const cycles = detectCycles([this], destination);
-        visitEachAudioNodeOnce(cycles, createIncrementCycleCounter(isOffline));
-      }
-    }
-    disconnect(destinationOrOutput, output, input) {
-      let destinations;
-      const nativeContext = getNativeContext(this._context);
-      const isOffline = isNativeOfflineAudioContext(nativeContext);
-      if (destinationOrOutput === void 0) {
-        destinations = deleteAnyConnection(this, isOffline);
-      } else if (typeof destinationOrOutput === "number") {
-        if (destinationOrOutput < 0 || destinationOrOutput >= this.numberOfOutputs) {
-          throw createIndexSizeError();
-        }
-        destinations = deleteConnectionAtOutput(this, isOffline, destinationOrOutput);
-      } else {
-        if (output !== void 0 && (output < 0 || output >= this.numberOfOutputs)) {
-          throw createIndexSizeError();
-        }
-        if (isAudioNode(destinationOrOutput) && input !== void 0 && (input < 0 || input >= destinationOrOutput.numberOfInputs)) {
-          throw createIndexSizeError();
-        }
-        destinations = deleteConnectionToDestination(this, isOffline, destinationOrOutput, output, input);
-        if (destinations.length === 0) {
-          throw createInvalidAccessError();
-        }
-      }
-      for (const destination of destinations) {
-        const cycles = detectCycles([this], destination);
-        visitEachAudioNodeOnce(cycles, decrementCycleCounter);
-      }
-    }
-  };
-};
-export {
-  createAudioNodeConstructor
-};

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

@@ -1,152 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const automationEventList = require("../../../../automation-events/build/es2019/classes/automation-event-list.cjs");
-const createAudioParamFactory = (addAudioParamConnections, audioParamAudioNodeStore, audioParamStore, createAudioParamRenderer, createCancelAndHoldAutomationEvent, createCancelScheduledValuesAutomationEvent, createExponentialRampToValueAutomationEvent, createLinearRampToValueAutomationEvent, createSetTargetAutomationEvent, createSetValueAutomationEvent, createSetValueCurveAutomationEvent, nativeAudioContextConstructor, setValueAtTimeUntilPossible) => {
-  return (audioNode, isAudioParamOfOfflineAudioContext, nativeAudioParam, maxValue = null, minValue = null) => {
-    const defaultValue = nativeAudioParam.value;
-    const automationEventList$1 = new automationEventList.AutomationEventList(defaultValue);
-    const audioParamRenderer = isAudioParamOfOfflineAudioContext ? createAudioParamRenderer(automationEventList$1) : null;
-    const audioParam = {
-      get defaultValue() {
-        return defaultValue;
-      },
-      get maxValue() {
-        return maxValue === null ? nativeAudioParam.maxValue : maxValue;
-      },
-      get minValue() {
-        return minValue === null ? nativeAudioParam.minValue : minValue;
-      },
-      get value() {
-        return nativeAudioParam.value;
-      },
-      set value(value) {
-        nativeAudioParam.value = value;
-        audioParam.setValueAtTime(value, audioNode.context.currentTime);
-      },
-      cancelAndHoldAtTime(cancelTime) {
-        if (typeof nativeAudioParam.cancelAndHoldAtTime === "function") {
-          if (audioParamRenderer === null) {
-            automationEventList$1.flush(audioNode.context.currentTime);
-          }
-          automationEventList$1.add(createCancelAndHoldAutomationEvent(cancelTime));
-          nativeAudioParam.cancelAndHoldAtTime(cancelTime);
-        } else {
-          const previousLastEvent = Array.from(automationEventList$1).pop();
-          if (audioParamRenderer === null) {
-            automationEventList$1.flush(audioNode.context.currentTime);
-          }
-          automationEventList$1.add(createCancelAndHoldAutomationEvent(cancelTime));
-          const currentLastEvent = Array.from(automationEventList$1).pop();
-          nativeAudioParam.cancelScheduledValues(cancelTime);
-          if (previousLastEvent !== currentLastEvent && currentLastEvent !== void 0) {
-            if (currentLastEvent.type === "exponentialRampToValue") {
-              nativeAudioParam.exponentialRampToValueAtTime(currentLastEvent.value, currentLastEvent.endTime);
-            } else if (currentLastEvent.type === "linearRampToValue") {
-              nativeAudioParam.linearRampToValueAtTime(currentLastEvent.value, currentLastEvent.endTime);
-            } else if (currentLastEvent.type === "setValue") {
-              nativeAudioParam.setValueAtTime(currentLastEvent.value, currentLastEvent.startTime);
-            } else if (currentLastEvent.type === "setValueCurve") {
-              nativeAudioParam.setValueCurveAtTime(currentLastEvent.values, currentLastEvent.startTime, currentLastEvent.duration);
-            }
-          }
-        }
-        return audioParam;
-      },
-      cancelScheduledValues(cancelTime) {
-        if (audioParamRenderer === null) {
-          automationEventList$1.flush(audioNode.context.currentTime);
-        }
-        automationEventList$1.add(createCancelScheduledValuesAutomationEvent(cancelTime));
-        nativeAudioParam.cancelScheduledValues(cancelTime);
-        return audioParam;
-      },
-      exponentialRampToValueAtTime(value, endTime) {
-        if (value === 0) {
-          throw new RangeError();
-        }
-        if (!Number.isFinite(endTime) || endTime < 0) {
-          throw new RangeError();
-        }
-        const currentTime = audioNode.context.currentTime;
-        if (audioParamRenderer === null) {
-          automationEventList$1.flush(currentTime);
-        }
-        if (Array.from(automationEventList$1).length === 0) {
-          automationEventList$1.add(createSetValueAutomationEvent(defaultValue, currentTime));
-          nativeAudioParam.setValueAtTime(defaultValue, currentTime);
-        }
-        automationEventList$1.add(createExponentialRampToValueAutomationEvent(value, endTime));
-        nativeAudioParam.exponentialRampToValueAtTime(value, endTime);
-        return audioParam;
-      },
-      linearRampToValueAtTime(value, endTime) {
-        const currentTime = audioNode.context.currentTime;
-        if (audioParamRenderer === null) {
-          automationEventList$1.flush(currentTime);
-        }
-        if (Array.from(automationEventList$1).length === 0) {
-          automationEventList$1.add(createSetValueAutomationEvent(defaultValue, currentTime));
-          nativeAudioParam.setValueAtTime(defaultValue, currentTime);
-        }
-        automationEventList$1.add(createLinearRampToValueAutomationEvent(value, endTime));
-        nativeAudioParam.linearRampToValueAtTime(value, endTime);
-        return audioParam;
-      },
-      setTargetAtTime(target, startTime, timeConstant) {
-        if (audioParamRenderer === null) {
-          automationEventList$1.flush(audioNode.context.currentTime);
-        }
-        automationEventList$1.add(createSetTargetAutomationEvent(target, startTime, timeConstant));
-        nativeAudioParam.setTargetAtTime(target, startTime, timeConstant);
-        return audioParam;
-      },
-      setValueAtTime(value, startTime) {
-        if (audioParamRenderer === null) {
-          automationEventList$1.flush(audioNode.context.currentTime);
-        }
-        automationEventList$1.add(createSetValueAutomationEvent(value, startTime));
-        nativeAudioParam.setValueAtTime(value, startTime);
-        return audioParam;
-      },
-      setValueCurveAtTime(values, startTime, duration) {
-        const convertedValues = values instanceof Float32Array ? values : new Float32Array(values);
-        if (nativeAudioContextConstructor !== null && nativeAudioContextConstructor.name === "webkitAudioContext") {
-          const endTime = startTime + duration;
-          const sampleRate = audioNode.context.sampleRate;
-          const firstSample = Math.ceil(startTime * sampleRate);
-          const lastSample = Math.floor(endTime * sampleRate);
-          const numberOfInterpolatedValues = lastSample - firstSample;
-          const interpolatedValues = new Float32Array(numberOfInterpolatedValues);
-          for (let i = 0; i < numberOfInterpolatedValues; i += 1) {
-            const theoreticIndex = (convertedValues.length - 1) / duration * ((firstSample + i) / sampleRate - startTime);
-            const lowerIndex = Math.floor(theoreticIndex);
-            const upperIndex = Math.ceil(theoreticIndex);
-            interpolatedValues[i] = lowerIndex === upperIndex ? convertedValues[lowerIndex] : (1 - (theoreticIndex - lowerIndex)) * convertedValues[lowerIndex] + (1 - (upperIndex - theoreticIndex)) * convertedValues[upperIndex];
-          }
-          if (audioParamRenderer === null) {
-            automationEventList$1.flush(audioNode.context.currentTime);
-          }
-          automationEventList$1.add(createSetValueCurveAutomationEvent(interpolatedValues, startTime, duration));
-          nativeAudioParam.setValueCurveAtTime(interpolatedValues, startTime, duration);
-          const timeOfLastSample = lastSample / sampleRate;
-          if (timeOfLastSample < endTime) {
-            setValueAtTimeUntilPossible(audioParam, interpolatedValues[interpolatedValues.length - 1], timeOfLastSample);
-          }
-          setValueAtTimeUntilPossible(audioParam, convertedValues[convertedValues.length - 1], endTime);
-        } else {
-          if (audioParamRenderer === null) {
-            automationEventList$1.flush(audioNode.context.currentTime);
-          }
-          automationEventList$1.add(createSetValueCurveAutomationEvent(convertedValues, startTime, duration));
-          nativeAudioParam.setValueCurveAtTime(convertedValues, startTime, duration);
-        }
-        return audioParam;
-      }
-    };
-    audioParamStore.set(audioParam, nativeAudioParam);
-    audioParamAudioNodeStore.set(audioParam, audioNode);
-    addAudioParamConnections(audioParam, audioParamRenderer);
-    return audioParam;
-  };
-};
-exports.createAudioParamFactory = createAudioParamFactory;

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

@@ -1,152 +0,0 @@
-import { AutomationEventList } from "../../../../automation-events/build/es2019/classes/automation-event-list.js";
-const createAudioParamFactory = (addAudioParamConnections, audioParamAudioNodeStore, audioParamStore, createAudioParamRenderer, createCancelAndHoldAutomationEvent, createCancelScheduledValuesAutomationEvent, createExponentialRampToValueAutomationEvent, createLinearRampToValueAutomationEvent, createSetTargetAutomationEvent, createSetValueAutomationEvent, createSetValueCurveAutomationEvent, nativeAudioContextConstructor, setValueAtTimeUntilPossible) => {
-  return (audioNode, isAudioParamOfOfflineAudioContext, nativeAudioParam, maxValue = null, minValue = null) => {
-    const defaultValue = nativeAudioParam.value;
-    const automationEventList = new AutomationEventList(defaultValue);
-    const audioParamRenderer = isAudioParamOfOfflineAudioContext ? createAudioParamRenderer(automationEventList) : null;
-    const audioParam = {
-      get defaultValue() {
-        return defaultValue;
-      },
-      get maxValue() {
-        return maxValue === null ? nativeAudioParam.maxValue : maxValue;
-      },
-      get minValue() {
-        return minValue === null ? nativeAudioParam.minValue : minValue;
-      },
-      get value() {
-        return nativeAudioParam.value;
-      },
-      set value(value) {
-        nativeAudioParam.value = value;
-        audioParam.setValueAtTime(value, audioNode.context.currentTime);
-      },
-      cancelAndHoldAtTime(cancelTime) {
-        if (typeof nativeAudioParam.cancelAndHoldAtTime === "function") {
-          if (audioParamRenderer === null) {
-            automationEventList.flush(audioNode.context.currentTime);
-          }
-          automationEventList.add(createCancelAndHoldAutomationEvent(cancelTime));
-          nativeAudioParam.cancelAndHoldAtTime(cancelTime);
-        } else {
-          const previousLastEvent = Array.from(automationEventList).pop();
-          if (audioParamRenderer === null) {
-            automationEventList.flush(audioNode.context.currentTime);
-          }
-          automationEventList.add(createCancelAndHoldAutomationEvent(cancelTime));
-          const currentLastEvent = Array.from(automationEventList).pop();
-          nativeAudioParam.cancelScheduledValues(cancelTime);
-          if (previousLastEvent !== currentLastEvent && currentLastEvent !== void 0) {
-            if (currentLastEvent.type === "exponentialRampToValue") {
-              nativeAudioParam.exponentialRampToValueAtTime(currentLastEvent.value, currentLastEvent.endTime);
-            } else if (currentLastEvent.type === "linearRampToValue") {
-              nativeAudioParam.linearRampToValueAtTime(currentLastEvent.value, currentLastEvent.endTime);
-            } else if (currentLastEvent.type === "setValue") {
-              nativeAudioParam.setValueAtTime(currentLastEvent.value, currentLastEvent.startTime);
-            } else if (currentLastEvent.type === "setValueCurve") {
-              nativeAudioParam.setValueCurveAtTime(currentLastEvent.values, currentLastEvent.startTime, currentLastEvent.duration);
-            }
-          }
-        }
-        return audioParam;
-      },
-      cancelScheduledValues(cancelTime) {
-        if (audioParamRenderer === null) {
-          automationEventList.flush(audioNode.context.currentTime);
-        }
-        automationEventList.add(createCancelScheduledValuesAutomationEvent(cancelTime));
-        nativeAudioParam.cancelScheduledValues(cancelTime);
-        return audioParam;
-      },
-      exponentialRampToValueAtTime(value, endTime) {
-        if (value === 0) {
-          throw new RangeError();
-        }
-        if (!Number.isFinite(endTime) || endTime < 0) {
-          throw new RangeError();
-        }
-        const currentTime = audioNode.context.currentTime;
-        if (audioParamRenderer === null) {
-          automationEventList.flush(currentTime);
-        }
-        if (Array.from(automationEventList).length === 0) {
-          automationEventList.add(createSetValueAutomationEvent(defaultValue, currentTime));
-          nativeAudioParam.setValueAtTime(defaultValue, currentTime);
-        }
-        automationEventList.add(createExponentialRampToValueAutomationEvent(value, endTime));
-        nativeAudioParam.exponentialRampToValueAtTime(value, endTime);
-        return audioParam;
-      },
-      linearRampToValueAtTime(value, endTime) {
-        const currentTime = audioNode.context.currentTime;
-        if (audioParamRenderer === null) {
-          automationEventList.flush(currentTime);
-        }
-        if (Array.from(automationEventList).length === 0) {
-          automationEventList.add(createSetValueAutomationEvent(defaultValue, currentTime));
-          nativeAudioParam.setValueAtTime(defaultValue, currentTime);
-        }
-        automationEventList.add(createLinearRampToValueAutomationEvent(value, endTime));
-        nativeAudioParam.linearRampToValueAtTime(value, endTime);
-        return audioParam;
-      },
-      setTargetAtTime(target, startTime, timeConstant) {
-        if (audioParamRenderer === null) {
-          automationEventList.flush(audioNode.context.currentTime);
-        }
-        automationEventList.add(createSetTargetAutomationEvent(target, startTime, timeConstant));
-        nativeAudioParam.setTargetAtTime(target, startTime, timeConstant);
-        return audioParam;
-      },
-      setValueAtTime(value, startTime) {
-        if (audioParamRenderer === null) {
-          automationEventList.flush(audioNode.context.currentTime);
-        }
-        automationEventList.add(createSetValueAutomationEvent(value, startTime));
-        nativeAudioParam.setValueAtTime(value, startTime);
-        return audioParam;
-      },
-      setValueCurveAtTime(values, startTime, duration) {
-        const convertedValues = values instanceof Float32Array ? values : new Float32Array(values);
-        if (nativeAudioContextConstructor !== null && nativeAudioContextConstructor.name === "webkitAudioContext") {
-          const endTime = startTime + duration;
-          const sampleRate = audioNode.context.sampleRate;
-          const firstSample = Math.ceil(startTime * sampleRate);
-          const lastSample = Math.floor(endTime * sampleRate);
-          const numberOfInterpolatedValues = lastSample - firstSample;
-          const interpolatedValues = new Float32Array(numberOfInterpolatedValues);
-          for (let i = 0; i < numberOfInterpolatedValues; i += 1) {
-            const theoreticIndex = (convertedValues.length - 1) / duration * ((firstSample + i) / sampleRate - startTime);
-            const lowerIndex = Math.floor(theoreticIndex);
-            const upperIndex = Math.ceil(theoreticIndex);
-            interpolatedValues[i] = lowerIndex === upperIndex ? convertedValues[lowerIndex] : (1 - (theoreticIndex - lowerIndex)) * convertedValues[lowerIndex] + (1 - (upperIndex - theoreticIndex)) * convertedValues[upperIndex];
-          }
-          if (audioParamRenderer === null) {
-            automationEventList.flush(audioNode.context.currentTime);
-          }
-          automationEventList.add(createSetValueCurveAutomationEvent(interpolatedValues, startTime, duration));
-          nativeAudioParam.setValueCurveAtTime(interpolatedValues, startTime, duration);
-          const timeOfLastSample = lastSample / sampleRate;
-          if (timeOfLastSample < endTime) {
-            setValueAtTimeUntilPossible(audioParam, interpolatedValues[interpolatedValues.length - 1], timeOfLastSample);
-          }
-          setValueAtTimeUntilPossible(audioParam, convertedValues[convertedValues.length - 1], endTime);
-        } else {
-          if (audioParamRenderer === null) {
-            automationEventList.flush(audioNode.context.currentTime);
-          }
-          automationEventList.add(createSetValueCurveAutomationEvent(convertedValues, startTime, duration));
-          nativeAudioParam.setValueCurveAtTime(convertedValues, startTime, duration);
-        }
-        return audioParam;
-      }
-    };
-    audioParamStore.set(audioParam, nativeAudioParam);
-    audioParamAudioNodeStore.set(audioParam, audioNode);
-    addAudioParamConnections(audioParam, audioParamRenderer);
-    return audioParam;
-  };
-};
-export {
-  createAudioParamFactory
-};

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

@@ -1,29 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const createAudioParamRenderer = (automationEventList) => {
-  return {
-    replay(audioParam) {
-      for (const automationEvent of automationEventList) {
-        if (automationEvent.type === "exponentialRampToValue") {
-          const { endTime, value } = automationEvent;
-          audioParam.exponentialRampToValueAtTime(value, endTime);
-        } else if (automationEvent.type === "linearRampToValue") {
-          const { endTime, value } = automationEvent;
-          audioParam.linearRampToValueAtTime(value, endTime);
-        } else if (automationEvent.type === "setTarget") {
-          const { startTime, target, timeConstant } = automationEvent;
-          audioParam.setTargetAtTime(target, startTime, timeConstant);
-        } else if (automationEvent.type === "setValue") {
-          const { startTime, value } = automationEvent;
-          audioParam.setValueAtTime(value, startTime);
-        } else if (automationEvent.type === "setValueCurve") {
-          const { duration, startTime, values } = automationEvent;
-          audioParam.setValueCurveAtTime(values, startTime, duration);
-        } else {
-          throw new Error("Can't apply an unknown automation.");
-        }
-      }
-    }
-  };
-};
-exports.createAudioParamRenderer = createAudioParamRenderer;

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

@@ -1,29 +0,0 @@
-const createAudioParamRenderer = (automationEventList) => {
-  return {
-    replay(audioParam) {
-      for (const automationEvent of automationEventList) {
-        if (automationEvent.type === "exponentialRampToValue") {
-          const { endTime, value } = automationEvent;
-          audioParam.exponentialRampToValueAtTime(value, endTime);
-        } else if (automationEvent.type === "linearRampToValue") {
-          const { endTime, value } = automationEvent;
-          audioParam.linearRampToValueAtTime(value, endTime);
-        } else if (automationEvent.type === "setTarget") {
-          const { startTime, target, timeConstant } = automationEvent;
-          audioParam.setTargetAtTime(target, startTime, timeConstant);
-        } else if (automationEvent.type === "setValue") {
-          const { startTime, value } = automationEvent;
-          audioParam.setValueAtTime(value, startTime);
-        } else if (automationEvent.type === "setValueCurve") {
-          const { duration, startTime, values } = automationEvent;
-          audioParam.setValueCurveAtTime(values, startTime, duration);
-        } else {
-          throw new Error("Can't apply an unknown automation.");
-        }
-      }
-    }
-  };
-};
-export {
-  createAudioParamRenderer
-};