react-audio-wavekit 0.1.7 → 0.1.8

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

@@ -1,220 +0,0 @@
-import { MOST_POSITIVE_SINGLE_FLOAT, MOST_NEGATIVE_SINGLE_FLOAT } from "../constants.js";
-const createAudioListenerFactory = (createAudioParam, createNativeChannelMergerNode, createNativeConstantSourceNode, createNativeScriptProcessorNode, createNotSupportedError, getFirstSample, isNativeOfflineAudioContext, overwriteAccessors) => {
-  return (context, nativeContext) => {
-    const nativeListener = nativeContext.listener;
-    const createFakeAudioParams = () => {
-      const buffer = new Float32Array(1);
-      const channelMergerNode = createNativeChannelMergerNode(nativeContext, {
-        channelCount: 1,
-        channelCountMode: "explicit",
-        channelInterpretation: "speakers",
-        numberOfInputs: 9
-      });
-      const isOffline = isNativeOfflineAudioContext(nativeContext);
-      let isScriptProcessorNodeCreated = false;
-      let lastOrientation = [0, 0, -1, 0, 1, 0];
-      let lastPosition = [0, 0, 0];
-      const createScriptProcessorNode = () => {
-        if (isScriptProcessorNodeCreated) {
-          return;
-        }
-        isScriptProcessorNodeCreated = true;
-        const scriptProcessorNode = createNativeScriptProcessorNode(nativeContext, 256, 9, 0);
-        scriptProcessorNode.onaudioprocess = ({ inputBuffer }) => {
-          const orientation = [
-            getFirstSample(inputBuffer, buffer, 0),
-            getFirstSample(inputBuffer, buffer, 1),
-            getFirstSample(inputBuffer, buffer, 2),
-            getFirstSample(inputBuffer, buffer, 3),
-            getFirstSample(inputBuffer, buffer, 4),
-            getFirstSample(inputBuffer, buffer, 5)
-          ];
-          if (orientation.some((value, index) => value !== lastOrientation[index])) {
-            nativeListener.setOrientation(...orientation);
-            lastOrientation = orientation;
-          }
-          const positon = [
-            getFirstSample(inputBuffer, buffer, 6),
-            getFirstSample(inputBuffer, buffer, 7),
-            getFirstSample(inputBuffer, buffer, 8)
-          ];
-          if (positon.some((value, index) => value !== lastPosition[index])) {
-            nativeListener.setPosition(...positon);
-            lastPosition = positon;
-          }
-        };
-        channelMergerNode.connect(scriptProcessorNode);
-      };
-      const createSetOrientation = (index) => (value) => {
-        if (value !== lastOrientation[index]) {
-          lastOrientation[index] = value;
-          nativeListener.setOrientation(...lastOrientation);
-        }
-      };
-      const createSetPosition = (index) => (value) => {
-        if (value !== lastPosition[index]) {
-          lastPosition[index] = value;
-          nativeListener.setPosition(...lastPosition);
-        }
-      };
-      const createFakeAudioParam = (input, initialValue, setValue) => {
-        const constantSourceNode = createNativeConstantSourceNode(nativeContext, {
-          channelCount: 1,
-          channelCountMode: "explicit",
-          channelInterpretation: "discrete",
-          offset: initialValue
-        });
-        constantSourceNode.connect(channelMergerNode, 0, input);
-        constantSourceNode.start();
-        Object.defineProperty(constantSourceNode.offset, "defaultValue", {
-          get() {
-            return initialValue;
-          }
-        });
-        const audioParam = createAudioParam({ context }, isOffline, constantSourceNode.offset, MOST_POSITIVE_SINGLE_FLOAT, MOST_NEGATIVE_SINGLE_FLOAT);
-        overwriteAccessors(audioParam, "value", (get) => () => get.call(audioParam), (set) => (value) => {
-          try {
-            set.call(audioParam, value);
-          } catch (err) {
-            if (err.code !== 9) {
-              throw err;
-            }
-          }
-          createScriptProcessorNode();
-          if (isOffline) {
-            setValue(value);
-          }
-        });
-        audioParam.cancelAndHoldAtTime = ((cancelAndHoldAtTime) => {
-          if (isOffline) {
-            return () => {
-              throw createNotSupportedError();
-            };
-          }
-          return (...args) => {
-            const value = cancelAndHoldAtTime.apply(audioParam, args);
-            createScriptProcessorNode();
-            return value;
-          };
-        })(audioParam.cancelAndHoldAtTime);
-        audioParam.cancelScheduledValues = ((cancelScheduledValues) => {
-          if (isOffline) {
-            return () => {
-              throw createNotSupportedError();
-            };
-          }
-          return (...args) => {
-            const value = cancelScheduledValues.apply(audioParam, args);
-            createScriptProcessorNode();
-            return value;
-          };
-        })(audioParam.cancelScheduledValues);
-        audioParam.exponentialRampToValueAtTime = ((exponentialRampToValueAtTime) => {
-          if (isOffline) {
-            return () => {
-              throw createNotSupportedError();
-            };
-          }
-          return (...args) => {
-            const value = exponentialRampToValueAtTime.apply(audioParam, args);
-            createScriptProcessorNode();
-            return value;
-          };
-        })(audioParam.exponentialRampToValueAtTime);
-        audioParam.linearRampToValueAtTime = ((linearRampToValueAtTime) => {
-          if (isOffline) {
-            return () => {
-              throw createNotSupportedError();
-            };
-          }
-          return (...args) => {
-            const value = linearRampToValueAtTime.apply(audioParam, args);
-            createScriptProcessorNode();
-            return value;
-          };
-        })(audioParam.linearRampToValueAtTime);
-        audioParam.setTargetAtTime = ((setTargetAtTime) => {
-          if (isOffline) {
-            return () => {
-              throw createNotSupportedError();
-            };
-          }
-          return (...args) => {
-            const value = setTargetAtTime.apply(audioParam, args);
-            createScriptProcessorNode();
-            return value;
-          };
-        })(audioParam.setTargetAtTime);
-        audioParam.setValueAtTime = ((setValueAtTime) => {
-          if (isOffline) {
-            return () => {
-              throw createNotSupportedError();
-            };
-          }
-          return (...args) => {
-            const value = setValueAtTime.apply(audioParam, args);
-            createScriptProcessorNode();
-            return value;
-          };
-        })(audioParam.setValueAtTime);
-        audioParam.setValueCurveAtTime = ((setValueCurveAtTime) => {
-          if (isOffline) {
-            return () => {
-              throw createNotSupportedError();
-            };
-          }
-          return (...args) => {
-            const value = setValueCurveAtTime.apply(audioParam, args);
-            createScriptProcessorNode();
-            return value;
-          };
-        })(audioParam.setValueCurveAtTime);
-        return audioParam;
-      };
-      return {
-        forwardX: createFakeAudioParam(0, 0, createSetOrientation(0)),
-        forwardY: createFakeAudioParam(1, 0, createSetOrientation(1)),
-        forwardZ: createFakeAudioParam(2, -1, createSetOrientation(2)),
-        positionX: createFakeAudioParam(6, 0, createSetPosition(0)),
-        positionY: createFakeAudioParam(7, 0, createSetPosition(1)),
-        positionZ: createFakeAudioParam(8, 0, createSetPosition(2)),
-        upX: createFakeAudioParam(3, 0, createSetOrientation(3)),
-        upY: createFakeAudioParam(4, 1, createSetOrientation(4)),
-        upZ: createFakeAudioParam(5, 0, createSetOrientation(5))
-      };
-    };
-    const { forwardX, forwardY, forwardZ, positionX, positionY, positionZ, upX, upY, upZ } = nativeListener.forwardX === void 0 ? createFakeAudioParams() : nativeListener;
-    return {
-      get forwardX() {
-        return forwardX;
-      },
-      get forwardY() {
-        return forwardY;
-      },
-      get forwardZ() {
-        return forwardZ;
-      },
-      get positionX() {
-        return positionX;
-      },
-      get positionY() {
-        return positionY;
-      },
-      get positionZ() {
-        return positionZ;
-      },
-      get upX() {
-        return upX;
-      },
-      get upY() {
-        return upY;
-      },
-      get upZ() {
-        return upZ;
-      }
-    };
-  };
-};
-export {
-  createAudioListenerFactory
-};

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

@@ -1,274 +0,0 @@
-"use strict";
-Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const globals = require("../globals.cjs");
-const audioNode = require("../guards/audio-node.cjs");
-const audioNodeOutputConnection = require("../guards/audio-node-output-connection.cjs");
-const addActiveInputConnectionToAudioParam = require("../helpers/add-active-input-connection-to-audio-param.cjs");
-const addPassiveInputConnectionToAudioParam = require("../helpers/add-passive-input-connection-to-audio-param.cjs");
-const connectNativeAudioNodeToNativeAudioNode = require("../helpers/connect-native-audio-node-to-native-audio-node.cjs");
-const deleteActiveInputConnection = require("../helpers/delete-active-input-connection.cjs");
-const deleteActiveInputConnectionToAudioParam = require("../helpers/delete-active-input-connection-to-audio-param.cjs");
-const deleteEventListenersOfAudioNode = require("../helpers/delete-event-listeners-of-audio-node.cjs");
-const deletePassiveInputConnectionToAudioNode = require("../helpers/delete-passive-input-connection-to-audio-node.cjs");
-const deletePassiveInputConnectionToAudioParam = require("../helpers/delete-passive-input-connection-to-audio-param.cjs");
-const disconnectNativeAudioNodeFromNativeAudioNode = require("../helpers/disconnect-native-audio-node-from-native-audio-node.cjs");
-const getAudioNodeConnections = require("../helpers/get-audio-node-connections.cjs");
-const getAudioParamConnections = require("../helpers/get-audio-param-connections.cjs");
-const getEventListenersOfAudioNode = require("../helpers/get-event-listeners-of-audio-node.cjs");
-const getNativeAudioNode = require("../helpers/get-native-audio-node.cjs");
-const getNativeAudioParam = require("../helpers/get-native-audio-param.cjs");
-const insertElementInSet = require("../helpers/insert-element-in-set.cjs");
-const isActiveAudioNode = require("../helpers/is-active-audio-node.cjs");
-const isPartOfACycle = require("../helpers/is-part-of-a-cycle.cjs");
-const isPassiveAudioNode = require("../helpers/is-passive-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 testAudioNodeDisconnectMethodSupport = require("../helpers/test-audio-node-disconnect-method-support.cjs");
-const visitEachAudioNodeOnce = require("../helpers/visit-each-audio-node-once.cjs");
-const wrapAudioNodeDisconnectMethod = require("../helpers/wrap-audio-node-disconnect-method.cjs");
-const addConnectionToAudioParamOfAudioContext = (source, destination, output, isOffline) => {
-  const { activeInputs, passiveInputs } = getAudioParamConnections.getAudioParamConnections(destination);
-  const { outputs } = getAudioNodeConnections.getAudioNodeConnections(source);
-  const eventListeners = getEventListenersOfAudioNode.getEventListenersOfAudioNode(source);
-  const eventListener = (isActive) => {
-    const nativeAudioNode = getNativeAudioNode.getNativeAudioNode(source);
-    const nativeAudioParam = getNativeAudioParam.getNativeAudioParam(destination);
-    if (isActive) {
-      const partialConnection = deletePassiveInputConnectionToAudioParam.deletePassiveInputConnectionToAudioParam(passiveInputs, source, output);
-      addActiveInputConnectionToAudioParam.addActiveInputConnectionToAudioParam(activeInputs, source, partialConnection, false);
-      if (!isOffline && !isPartOfACycle.isPartOfACycle(source)) {
-        nativeAudioNode.connect(nativeAudioParam, output);
-      }
-    } else {
-      const partialConnection = deleteActiveInputConnectionToAudioParam.deleteActiveInputConnectionToAudioParam(activeInputs, source, output);
-      addPassiveInputConnectionToAudioParam.addPassiveInputConnectionToAudioParam(passiveInputs, partialConnection, false);
-      if (!isOffline && !isPartOfACycle.isPartOfACycle(source)) {
-        nativeAudioNode.disconnect(nativeAudioParam, output);
-      }
-    }
-  };
-  if (insertElementInSet.insertElementInSet(outputs, [destination, output], (outputConnection) => outputConnection[0] === destination && outputConnection[1] === output, true)) {
-    eventListeners.add(eventListener);
-    if (isActiveAudioNode.isActiveAudioNode(source)) {
-      addActiveInputConnectionToAudioParam.addActiveInputConnectionToAudioParam(activeInputs, source, [output, eventListener], true);
-    } else {
-      addPassiveInputConnectionToAudioParam.addPassiveInputConnectionToAudioParam(passiveInputs, [source, output, eventListener], true);
-    }
-    return true;
-  }
-  return false;
-};
-const deleteInputConnectionOfAudioNode = (source, destination, output, input) => {
-  const { activeInputs, passiveInputs } = getAudioNodeConnections.getAudioNodeConnections(destination);
-  const activeInputConnection = deleteActiveInputConnection.deleteActiveInputConnection(activeInputs[input], source, output);
-  if (activeInputConnection === null) {
-    const passiveInputConnection = deletePassiveInputConnectionToAudioNode.deletePassiveInputConnectionToAudioNode(passiveInputs, source, output, input);
-    return [passiveInputConnection[2], false];
-  }
-  return [activeInputConnection[2], true];
-};
-const deleteInputConnectionOfAudioParam = (source, destination, output) => {
-  const { activeInputs, passiveInputs } = getAudioParamConnections.getAudioParamConnections(destination);
-  const activeInputConnection = deleteActiveInputConnection.deleteActiveInputConnection(activeInputs, source, output);
-  if (activeInputConnection === null) {
-    const passiveInputConnection = deletePassiveInputConnectionToAudioParam.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) {
-    deleteEventListenersOfAudioNode.deleteEventListenerOfAudioNode(source, listener);
-    if (isActive && !isOffline && !isPartOfACycle.isPartOfACycle(source)) {
-      disconnectNativeAudioNodeFromNativeAudioNode.disconnectNativeAudioNodeFromNativeAudioNode(getNativeAudioNode.getNativeAudioNode(source), getNativeAudioNode.getNativeAudioNode(destination), output, input);
-    }
-  }
-  if (isActiveAudioNode.isActiveAudioNode(destination)) {
-    const { activeInputs } = getAudioNodeConnections.getAudioNodeConnections(destination);
-    setInternalStateToPassiveWhenNecessary.setInternalStateToPassiveWhenNecessary(destination, activeInputs);
-  }
-};
-const deleteInputsOfAudioParam = (source, isOffline, destination, output) => {
-  const [listener, isActive] = deleteInputConnectionOfAudioParam(source, destination, output);
-  if (listener !== null) {
-    deleteEventListenersOfAudioNode.deleteEventListenerOfAudioNode(source, listener);
-    if (isActive && !isOffline && !isPartOfACycle.isPartOfACycle(source)) {
-      getNativeAudioNode.getNativeAudioNode(source).disconnect(getNativeAudioParam.getNativeAudioParam(destination), output);
-    }
-  }
-};
-const deleteAnyConnection = (source, isOffline) => {
-  const audioNodeConnectionsOfSource = getAudioNodeConnections.getAudioNodeConnections(source);
-  const destinations = [];
-  for (const outputConnection of audioNodeConnectionsOfSource.outputs) {
-    if (audioNodeOutputConnection.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.getAudioNodeConnections(source);
-  const destinations = [];
-  for (const outputConnection of audioNodeConnectionsOfSource.outputs) {
-    if (outputConnection[1] === output) {
-      if (audioNodeOutputConnection.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.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 (audioNodeOutputConnection.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.testAudioNodeDisconnectMethodSupport, () => {
-        return testAudioNodeDisconnectMethodSupport.testAudioNodeDisconnectMethodSupport(nativeContext, nativeAudioWorkletNodeConstructor);
-      })) {
-        wrapAudioNodeDisconnectMethod.wrapAudioNodeDisconnectMethod(nativeAudioNode);
-      }
-      globals.AUDIO_NODE_STORE.set(this, nativeAudioNode);
-      globals.EVENT_LISTENERS.set(this, /* @__PURE__ */ new Set());
-      if (context.state !== "closed" && isActive) {
-        setInternalStateToActive.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 (audioNode.isAudioNode(destination)) {
-        const nativeDestinationAudioNode = getNativeAudioNode.getNativeAudioNode(destination);
-        try {
-          const connection = connectNativeAudioNodeToNativeAudioNode.connectNativeAudioNodeToNativeAudioNode(this._nativeAudioNode, nativeDestinationAudioNode, output, input);
-          const isPassive = isPassiveAudioNode.isPassiveAudioNode(this);
-          if (isOffline || isPassive) {
-            this._nativeAudioNode.disconnect(...connection);
-          }
-          if (this.context.state !== "closed" && !isPassive && isPassiveAudioNode.isPassiveAudioNode(destination)) {
-            setInternalStateToActive.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.visitEachAudioNodeOnce(cycles, createIncrementCycleCounter(isOffline));
-        }
-        return destination;
-      }
-      const nativeAudioParam = getNativeAudioParam.getNativeAudioParam(destination);
-      if (nativeAudioParam.name === "playbackRate" && nativeAudioParam.maxValue === 1024) {
-        throw createNotSupportedError();
-      }
-      try {
-        this._nativeAudioNode.connect(nativeAudioParam, output);
-        if (isOffline || isPassiveAudioNode.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.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 (audioNode.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.visitEachAudioNodeOnce(cycles, decrementCycleCounter);
-      }
-    }
-  };
-};
-exports.createAudioNodeConstructor = createAudioNodeConstructor;