react-audio-wavekit 0.1.4 → 0.1.6

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

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const deactivateAudioGraph = require("../helpers/deactivate-audio-graph.cjs");
+const testPromiseSupport = require("../helpers/test-promise-support.cjs");
+const DEFAULT_OPTIONS = {
+  numberOfChannels: 1
+};
+const createOfflineAudioContextConstructor = (baseAudioContextConstructor, cacheTestResult, createInvalidStateError, createNativeOfflineAudioContext, startRendering) => {
+  return class OfflineAudioContext extends baseAudioContextConstructor {
+    constructor(a, b, c) {
+      let options;
+      if (typeof a === "number" && b !== void 0 && c !== void 0) {
+        options = { length: b, numberOfChannels: a, sampleRate: c };
+      } else if (typeof a === "object") {
+        options = a;
+      } else {
+        throw new Error("The given parameters are not valid.");
+      }
+      const { length, numberOfChannels, sampleRate } = { ...DEFAULT_OPTIONS, ...options };
+      const nativeOfflineAudioContext = createNativeOfflineAudioContext(numberOfChannels, length, sampleRate);
+      if (!cacheTestResult(testPromiseSupport.testPromiseSupport, () => testPromiseSupport.testPromiseSupport(nativeOfflineAudioContext))) {
+        nativeOfflineAudioContext.addEventListener("statechange", /* @__PURE__ */ (() => {
+          let i = 0;
+          const delayStateChangeEvent = (event) => {
+            if (this._state === "running") {
+              if (i > 0) {
+                nativeOfflineAudioContext.removeEventListener("statechange", delayStateChangeEvent);
+                event.stopImmediatePropagation();
+                this._waitForThePromiseToSettle(event);
+              } else {
+                i += 1;
+              }
+            }
+          };
+          return delayStateChangeEvent;
+        })());
+      }
+      super(nativeOfflineAudioContext, numberOfChannels);
+      this._length = length;
+      this._nativeOfflineAudioContext = nativeOfflineAudioContext;
+      this._state = null;
+    }
+    get length() {
+      if (this._nativeOfflineAudioContext.length === void 0) {
+        return this._length;
+      }
+      return this._nativeOfflineAudioContext.length;
+    }
+    get state() {
+      return this._state === null ? this._nativeOfflineAudioContext.state : this._state;
+    }
+    startRendering() {
+      if (this._state === "running") {
+        return Promise.reject(createInvalidStateError());
+      }
+      this._state = "running";
+      return startRendering(this.destination, this._nativeOfflineAudioContext).finally(() => {
+        this._state = null;
+        deactivateAudioGraph.deactivateAudioGraph(this);
+      });
+    }
+    _waitForThePromiseToSettle(event) {
+      if (this._state === null) {
+        this._nativeOfflineAudioContext.dispatchEvent(event);
+      } else {
+        setTimeout(() => this._waitForThePromiseToSettle(event));
+      }
+    }
+  };
+};
+exports.createOfflineAudioContextConstructor = createOfflineAudioContextConstructor;

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

@@ -0,0 +1,71 @@
+import { deactivateAudioGraph } from "../helpers/deactivate-audio-graph.js";
+import { testPromiseSupport } from "../helpers/test-promise-support.js";
+const DEFAULT_OPTIONS = {
+  numberOfChannels: 1
+};
+const createOfflineAudioContextConstructor = (baseAudioContextConstructor, cacheTestResult, createInvalidStateError, createNativeOfflineAudioContext, startRendering) => {
+  return class OfflineAudioContext extends baseAudioContextConstructor {
+    constructor(a, b, c) {
+      let options;
+      if (typeof a === "number" && b !== void 0 && c !== void 0) {
+        options = { length: b, numberOfChannels: a, sampleRate: c };
+      } else if (typeof a === "object") {
+        options = a;
+      } else {
+        throw new Error("The given parameters are not valid.");
+      }
+      const { length, numberOfChannels, sampleRate } = { ...DEFAULT_OPTIONS, ...options };
+      const nativeOfflineAudioContext = createNativeOfflineAudioContext(numberOfChannels, length, sampleRate);
+      if (!cacheTestResult(testPromiseSupport, () => testPromiseSupport(nativeOfflineAudioContext))) {
+        nativeOfflineAudioContext.addEventListener("statechange", /* @__PURE__ */ (() => {
+          let i = 0;
+          const delayStateChangeEvent = (event) => {
+            if (this._state === "running") {
+              if (i > 0) {
+                nativeOfflineAudioContext.removeEventListener("statechange", delayStateChangeEvent);
+                event.stopImmediatePropagation();
+                this._waitForThePromiseToSettle(event);
+              } else {
+                i += 1;
+              }
+            }
+          };
+          return delayStateChangeEvent;
+        })());
+      }
+      super(nativeOfflineAudioContext, numberOfChannels);
+      this._length = length;
+      this._nativeOfflineAudioContext = nativeOfflineAudioContext;
+      this._state = null;
+    }
+    get length() {
+      if (this._nativeOfflineAudioContext.length === void 0) {
+        return this._length;
+      }
+      return this._nativeOfflineAudioContext.length;
+    }
+    get state() {
+      return this._state === null ? this._nativeOfflineAudioContext.state : this._state;
+    }
+    startRendering() {
+      if (this._state === "running") {
+        return Promise.reject(createInvalidStateError());
+      }
+      this._state = "running";
+      return startRendering(this.destination, this._nativeOfflineAudioContext).finally(() => {
+        this._state = null;
+        deactivateAudioGraph(this);
+      });
+    }
+    _waitForThePromiseToSettle(event) {
+      if (this._state === null) {
+        this._nativeOfflineAudioContext.dispatchEvent(event);
+      } else {
+        setTimeout(() => this._waitForThePromiseToSettle(event));
+      }
+    }
+  };
+};
+export {
+  createOfflineAudioContextConstructor
+};

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

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const isActiveAudioNode = require("../helpers/is-active-audio-node.cjs");
+const setInternalStateToActive = require("../helpers/set-internal-state-to-active.cjs");
+const setInternalStateToPassive = require("../helpers/set-internal-state-to-passive.cjs");
+const DEFAULT_OPTIONS = {
+  channelCount: 2,
+  channelCountMode: "max",
+  // This attribute has no effect for nodes with no inputs.
+  channelInterpretation: "speakers",
+  // This attribute has no effect for nodes with no inputs.
+  detune: 0,
+  frequency: 440,
+  periodicWave: void 0,
+  type: "sine"
+};
+const createOscillatorNodeConstructor = (audioNodeConstructor, createAudioParam, createNativeOscillatorNode, createOscillatorNodeRenderer, getNativeContext, isNativeOfflineAudioContext, wrapEventListener) => {
+  return class OscillatorNode extends audioNodeConstructor {
+    constructor(context, options) {
+      const nativeContext = getNativeContext(context);
+      const mergedOptions = { ...DEFAULT_OPTIONS, ...options };
+      const nativeOscillatorNode = createNativeOscillatorNode(nativeContext, mergedOptions);
+      const isOffline = isNativeOfflineAudioContext(nativeContext);
+      const oscillatorNodeRenderer = isOffline ? createOscillatorNodeRenderer() : null;
+      const nyquist = context.sampleRate / 2;
+      super(context, false, nativeOscillatorNode, oscillatorNodeRenderer);
+      this._detune = createAudioParam(this, isOffline, nativeOscillatorNode.detune, 153600, -153600);
+      this._frequency = createAudioParam(this, isOffline, nativeOscillatorNode.frequency, nyquist, -nyquist);
+      this._nativeOscillatorNode = nativeOscillatorNode;
+      this._onended = null;
+      this._oscillatorNodeRenderer = oscillatorNodeRenderer;
+      if (this._oscillatorNodeRenderer !== null && mergedOptions.periodicWave !== void 0) {
+        this._oscillatorNodeRenderer.periodicWave = mergedOptions.periodicWave;
+      }
+    }
+    get detune() {
+      return this._detune;
+    }
+    get frequency() {
+      return this._frequency;
+    }
+    get onended() {
+      return this._onended;
+    }
+    set onended(value) {
+      const wrappedListener = typeof value === "function" ? wrapEventListener(this, value) : null;
+      this._nativeOscillatorNode.onended = wrappedListener;
+      const nativeOnEnded = this._nativeOscillatorNode.onended;
+      this._onended = nativeOnEnded !== null && nativeOnEnded === wrappedListener ? value : nativeOnEnded;
+    }
+    get type() {
+      return this._nativeOscillatorNode.type;
+    }
+    set type(value) {
+      this._nativeOscillatorNode.type = value;
+      if (this._oscillatorNodeRenderer !== null) {
+        this._oscillatorNodeRenderer.periodicWave = null;
+      }
+    }
+    setPeriodicWave(periodicWave) {
+      this._nativeOscillatorNode.setPeriodicWave(periodicWave);
+      if (this._oscillatorNodeRenderer !== null) {
+        this._oscillatorNodeRenderer.periodicWave = periodicWave;
+      }
+    }
+    start(when = 0) {
+      this._nativeOscillatorNode.start(when);
+      if (this._oscillatorNodeRenderer !== null) {
+        this._oscillatorNodeRenderer.start = when;
+      }
+      if (this.context.state !== "closed") {
+        setInternalStateToActive.setInternalStateToActive(this);
+        const resetInternalStateToPassive = () => {
+          this._nativeOscillatorNode.removeEventListener("ended", resetInternalStateToPassive);
+          if (isActiveAudioNode.isActiveAudioNode(this)) {
+            setInternalStateToPassive.setInternalStateToPassive(this);
+          }
+        };
+        this._nativeOscillatorNode.addEventListener("ended", resetInternalStateToPassive);
+      }
+    }
+    stop(when = 0) {
+      this._nativeOscillatorNode.stop(when);
+      if (this._oscillatorNodeRenderer !== null) {
+        this._oscillatorNodeRenderer.stop = when;
+      }
+    }
+  };
+};
+exports.createOscillatorNodeConstructor = createOscillatorNodeConstructor;

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

@@ -0,0 +1,90 @@
+import { isActiveAudioNode } from "../helpers/is-active-audio-node.js";
+import { setInternalStateToActive } from "../helpers/set-internal-state-to-active.js";
+import { setInternalStateToPassive } from "../helpers/set-internal-state-to-passive.js";
+const DEFAULT_OPTIONS = {
+  channelCount: 2,
+  channelCountMode: "max",
+  // This attribute has no effect for nodes with no inputs.
+  channelInterpretation: "speakers",
+  // This attribute has no effect for nodes with no inputs.
+  detune: 0,
+  frequency: 440,
+  periodicWave: void 0,
+  type: "sine"
+};
+const createOscillatorNodeConstructor = (audioNodeConstructor, createAudioParam, createNativeOscillatorNode, createOscillatorNodeRenderer, getNativeContext, isNativeOfflineAudioContext, wrapEventListener) => {
+  return class OscillatorNode extends audioNodeConstructor {
+    constructor(context, options) {
+      const nativeContext = getNativeContext(context);
+      const mergedOptions = { ...DEFAULT_OPTIONS, ...options };
+      const nativeOscillatorNode = createNativeOscillatorNode(nativeContext, mergedOptions);
+      const isOffline = isNativeOfflineAudioContext(nativeContext);
+      const oscillatorNodeRenderer = isOffline ? createOscillatorNodeRenderer() : null;
+      const nyquist = context.sampleRate / 2;
+      super(context, false, nativeOscillatorNode, oscillatorNodeRenderer);
+      this._detune = createAudioParam(this, isOffline, nativeOscillatorNode.detune, 153600, -153600);
+      this._frequency = createAudioParam(this, isOffline, nativeOscillatorNode.frequency, nyquist, -nyquist);
+      this._nativeOscillatorNode = nativeOscillatorNode;
+      this._onended = null;
+      this._oscillatorNodeRenderer = oscillatorNodeRenderer;
+      if (this._oscillatorNodeRenderer !== null && mergedOptions.periodicWave !== void 0) {
+        this._oscillatorNodeRenderer.periodicWave = mergedOptions.periodicWave;
+      }
+    }
+    get detune() {
+      return this._detune;
+    }
+    get frequency() {
+      return this._frequency;
+    }
+    get onended() {
+      return this._onended;
+    }
+    set onended(value) {
+      const wrappedListener = typeof value === "function" ? wrapEventListener(this, value) : null;
+      this._nativeOscillatorNode.onended = wrappedListener;
+      const nativeOnEnded = this._nativeOscillatorNode.onended;
+      this._onended = nativeOnEnded !== null && nativeOnEnded === wrappedListener ? value : nativeOnEnded;
+    }
+    get type() {
+      return this._nativeOscillatorNode.type;
+    }
+    set type(value) {
+      this._nativeOscillatorNode.type = value;
+      if (this._oscillatorNodeRenderer !== null) {
+        this._oscillatorNodeRenderer.periodicWave = null;
+      }
+    }
+    setPeriodicWave(periodicWave) {
+      this._nativeOscillatorNode.setPeriodicWave(periodicWave);
+      if (this._oscillatorNodeRenderer !== null) {
+        this._oscillatorNodeRenderer.periodicWave = periodicWave;
+      }
+    }
+    start(when = 0) {
+      this._nativeOscillatorNode.start(when);
+      if (this._oscillatorNodeRenderer !== null) {
+        this._oscillatorNodeRenderer.start = when;
+      }
+      if (this.context.state !== "closed") {
+        setInternalStateToActive(this);
+        const resetInternalStateToPassive = () => {
+          this._nativeOscillatorNode.removeEventListener("ended", resetInternalStateToPassive);
+          if (isActiveAudioNode(this)) {
+            setInternalStateToPassive(this);
+          }
+        };
+        this._nativeOscillatorNode.addEventListener("ended", resetInternalStateToPassive);
+      }
+    }
+    stop(when = 0) {
+      this._nativeOscillatorNode.stop(when);
+      if (this._oscillatorNodeRenderer !== null) {
+        this._oscillatorNodeRenderer.stop = when;
+      }
+    }
+  };
+};
+export {
+  createOscillatorNodeConstructor
+};

package/dist/node_modules/standardized-audio-context/build/es2019/factories/oscillator-node-renderer-factory.cjs

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const isOwnedByContext = require("../helpers/is-owned-by-context.cjs");
+const createOscillatorNodeRendererFactory = (connectAudioParam, createNativeOscillatorNode, getNativeAudioNode, renderAutomation, renderInputsOfAudioNode) => {
+  return () => {
+    const renderedNativeOscillatorNodes = /* @__PURE__ */ new WeakMap();
+    let periodicWave = null;
+    let start = null;
+    let stop = null;
+    const createOscillatorNode = async (proxy, nativeOfflineAudioContext) => {
+      let nativeOscillatorNode = getNativeAudioNode(proxy);
+      const nativeOscillatorNodeIsOwnedByContext = isOwnedByContext.isOwnedByContext(nativeOscillatorNode, nativeOfflineAudioContext);
+      if (!nativeOscillatorNodeIsOwnedByContext) {
+        const options = {
+          channelCount: nativeOscillatorNode.channelCount,
+          channelCountMode: nativeOscillatorNode.channelCountMode,
+          channelInterpretation: nativeOscillatorNode.channelInterpretation,
+          detune: nativeOscillatorNode.detune.value,
+          frequency: nativeOscillatorNode.frequency.value,
+          periodicWave: periodicWave === null ? void 0 : periodicWave,
+          type: nativeOscillatorNode.type
+        };
+        nativeOscillatorNode = createNativeOscillatorNode(nativeOfflineAudioContext, options);
+        if (start !== null) {
+          nativeOscillatorNode.start(start);
+        }
+        if (stop !== null) {
+          nativeOscillatorNode.stop(stop);
+        }
+      }
+      renderedNativeOscillatorNodes.set(nativeOfflineAudioContext, nativeOscillatorNode);
+      if (!nativeOscillatorNodeIsOwnedByContext) {
+        await renderAutomation(nativeOfflineAudioContext, proxy.detune, nativeOscillatorNode.detune);
+        await renderAutomation(nativeOfflineAudioContext, proxy.frequency, nativeOscillatorNode.frequency);
+      } else {
+        await connectAudioParam(nativeOfflineAudioContext, proxy.detune, nativeOscillatorNode.detune);
+        await connectAudioParam(nativeOfflineAudioContext, proxy.frequency, nativeOscillatorNode.frequency);
+      }
+      await renderInputsOfAudioNode(proxy, nativeOfflineAudioContext, nativeOscillatorNode);
+      return nativeOscillatorNode;
+    };
+    return {
+      set periodicWave(value) {
+        periodicWave = value;
+      },
+      set start(value) {
+        start = value;
+      },
+      set stop(value) {
+        stop = value;
+      },
+      render(proxy, nativeOfflineAudioContext) {
+        const renderedNativeOscillatorNode = renderedNativeOscillatorNodes.get(nativeOfflineAudioContext);
+        if (renderedNativeOscillatorNode !== void 0) {
+          return Promise.resolve(renderedNativeOscillatorNode);
+        }
+        return createOscillatorNode(proxy, nativeOfflineAudioContext);
+      }
+    };
+  };
+};
+exports.createOscillatorNodeRendererFactory = createOscillatorNodeRendererFactory;

package/dist/node_modules/standardized-audio-context/build/es2019/factories/oscillator-node-renderer-factory.js

@@ -0,0 +1,62 @@
+import { isOwnedByContext } from "../helpers/is-owned-by-context.js";
+const createOscillatorNodeRendererFactory = (connectAudioParam, createNativeOscillatorNode, getNativeAudioNode, renderAutomation, renderInputsOfAudioNode) => {
+  return () => {
+    const renderedNativeOscillatorNodes = /* @__PURE__ */ new WeakMap();
+    let periodicWave = null;
+    let start = null;
+    let stop = null;
+    const createOscillatorNode = async (proxy, nativeOfflineAudioContext) => {
+      let nativeOscillatorNode = getNativeAudioNode(proxy);
+      const nativeOscillatorNodeIsOwnedByContext = isOwnedByContext(nativeOscillatorNode, nativeOfflineAudioContext);
+      if (!nativeOscillatorNodeIsOwnedByContext) {
+        const options = {
+          channelCount: nativeOscillatorNode.channelCount,
+          channelCountMode: nativeOscillatorNode.channelCountMode,
+          channelInterpretation: nativeOscillatorNode.channelInterpretation,
+          detune: nativeOscillatorNode.detune.value,
+          frequency: nativeOscillatorNode.frequency.value,
+          periodicWave: periodicWave === null ? void 0 : periodicWave,
+          type: nativeOscillatorNode.type
+        };
+        nativeOscillatorNode = createNativeOscillatorNode(nativeOfflineAudioContext, options);
+        if (start !== null) {
+          nativeOscillatorNode.start(start);
+        }
+        if (stop !== null) {
+          nativeOscillatorNode.stop(stop);
+        }
+      }
+      renderedNativeOscillatorNodes.set(nativeOfflineAudioContext, nativeOscillatorNode);
+      if (!nativeOscillatorNodeIsOwnedByContext) {
+        await renderAutomation(nativeOfflineAudioContext, proxy.detune, nativeOscillatorNode.detune);
+        await renderAutomation(nativeOfflineAudioContext, proxy.frequency, nativeOscillatorNode.frequency);
+      } else {
+        await connectAudioParam(nativeOfflineAudioContext, proxy.detune, nativeOscillatorNode.detune);
+        await connectAudioParam(nativeOfflineAudioContext, proxy.frequency, nativeOscillatorNode.frequency);
+      }
+      await renderInputsOfAudioNode(proxy, nativeOfflineAudioContext, nativeOscillatorNode);
+      return nativeOscillatorNode;
+    };
+    return {
+      set periodicWave(value) {
+        periodicWave = value;
+      },
+      set start(value) {
+        start = value;
+      },
+      set stop(value) {
+        stop = value;
+      },
+      render(proxy, nativeOfflineAudioContext) {
+        const renderedNativeOscillatorNode = renderedNativeOscillatorNodes.get(nativeOfflineAudioContext);
+        if (renderedNativeOscillatorNode !== void 0) {
+          return Promise.resolve(renderedNativeOscillatorNode);
+        }
+        return createOscillatorNode(proxy, nativeOfflineAudioContext);
+      }
+    };
+  };
+};
+export {
+  createOscillatorNodeRendererFactory
+};

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

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const constants = require("../constants.cjs");
+const DEFAULT_OPTIONS = {
+  channelCount: 2,
+  channelCountMode: "clamped-max",
+  channelInterpretation: "speakers",
+  coneInnerAngle: 360,
+  coneOuterAngle: 360,
+  coneOuterGain: 0,
+  distanceModel: "inverse",
+  maxDistance: 1e4,
+  orientationX: 1,
+  orientationY: 0,
+  orientationZ: 0,
+  panningModel: "equalpower",
+  positionX: 0,
+  positionY: 0,
+  positionZ: 0,
+  refDistance: 1,
+  rolloffFactor: 1
+};
+const createPannerNodeConstructor = (audioNodeConstructor, createAudioParam, createNativePannerNode, createPannerNodeRenderer, getNativeContext, isNativeOfflineAudioContext, setAudioNodeTailTime) => {
+  return class PannerNode extends audioNodeConstructor {
+    constructor(context, options) {
+      const nativeContext = getNativeContext(context);
+      const mergedOptions = { ...DEFAULT_OPTIONS, ...options };
+      const nativePannerNode = createNativePannerNode(nativeContext, mergedOptions);
+      const isOffline = isNativeOfflineAudioContext(nativeContext);
+      const pannerNodeRenderer = isOffline ? createPannerNodeRenderer() : null;
+      super(context, false, nativePannerNode, pannerNodeRenderer);
+      this._nativePannerNode = nativePannerNode;
+      this._orientationX = createAudioParam(this, isOffline, nativePannerNode.orientationX, constants.MOST_POSITIVE_SINGLE_FLOAT, constants.MOST_NEGATIVE_SINGLE_FLOAT);
+      this._orientationY = createAudioParam(this, isOffline, nativePannerNode.orientationY, constants.MOST_POSITIVE_SINGLE_FLOAT, constants.MOST_NEGATIVE_SINGLE_FLOAT);
+      this._orientationZ = createAudioParam(this, isOffline, nativePannerNode.orientationZ, constants.MOST_POSITIVE_SINGLE_FLOAT, constants.MOST_NEGATIVE_SINGLE_FLOAT);
+      this._positionX = createAudioParam(this, isOffline, nativePannerNode.positionX, constants.MOST_POSITIVE_SINGLE_FLOAT, constants.MOST_NEGATIVE_SINGLE_FLOAT);
+      this._positionY = createAudioParam(this, isOffline, nativePannerNode.positionY, constants.MOST_POSITIVE_SINGLE_FLOAT, constants.MOST_NEGATIVE_SINGLE_FLOAT);
+      this._positionZ = createAudioParam(this, isOffline, nativePannerNode.positionZ, constants.MOST_POSITIVE_SINGLE_FLOAT, constants.MOST_NEGATIVE_SINGLE_FLOAT);
+      setAudioNodeTailTime(this, 1);
+    }
+    get coneInnerAngle() {
+      return this._nativePannerNode.coneInnerAngle;
+    }
+    set coneInnerAngle(value) {
+      this._nativePannerNode.coneInnerAngle = value;
+    }
+    get coneOuterAngle() {
+      return this._nativePannerNode.coneOuterAngle;
+    }
+    set coneOuterAngle(value) {
+      this._nativePannerNode.coneOuterAngle = value;
+    }
+    get coneOuterGain() {
+      return this._nativePannerNode.coneOuterGain;
+    }
+    set coneOuterGain(value) {
+      this._nativePannerNode.coneOuterGain = value;
+    }
+    get distanceModel() {
+      return this._nativePannerNode.distanceModel;
+    }
+    set distanceModel(value) {
+      this._nativePannerNode.distanceModel = value;
+    }
+    get maxDistance() {
+      return this._nativePannerNode.maxDistance;
+    }
+    set maxDistance(value) {
+      this._nativePannerNode.maxDistance = value;
+    }
+    get orientationX() {
+      return this._orientationX;
+    }
+    get orientationY() {
+      return this._orientationY;
+    }
+    get orientationZ() {
+      return this._orientationZ;
+    }
+    get panningModel() {
+      return this._nativePannerNode.panningModel;
+    }
+    set panningModel(value) {
+      this._nativePannerNode.panningModel = value;
+    }
+    get positionX() {
+      return this._positionX;
+    }
+    get positionY() {
+      return this._positionY;
+    }
+    get positionZ() {
+      return this._positionZ;
+    }
+    get refDistance() {
+      return this._nativePannerNode.refDistance;
+    }
+    set refDistance(value) {
+      this._nativePannerNode.refDistance = value;
+    }
+    get rolloffFactor() {
+      return this._nativePannerNode.rolloffFactor;
+    }
+    set rolloffFactor(value) {
+      this._nativePannerNode.rolloffFactor = value;
+    }
+  };
+};
+exports.createPannerNodeConstructor = createPannerNodeConstructor;

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

@@ -0,0 +1,109 @@
+import { MOST_POSITIVE_SINGLE_FLOAT, MOST_NEGATIVE_SINGLE_FLOAT } from "../constants.js";
+const DEFAULT_OPTIONS = {
+  channelCount: 2,
+  channelCountMode: "clamped-max",
+  channelInterpretation: "speakers",
+  coneInnerAngle: 360,
+  coneOuterAngle: 360,
+  coneOuterGain: 0,
+  distanceModel: "inverse",
+  maxDistance: 1e4,
+  orientationX: 1,
+  orientationY: 0,
+  orientationZ: 0,
+  panningModel: "equalpower",
+  positionX: 0,
+  positionY: 0,
+  positionZ: 0,
+  refDistance: 1,
+  rolloffFactor: 1
+};
+const createPannerNodeConstructor = (audioNodeConstructor, createAudioParam, createNativePannerNode, createPannerNodeRenderer, getNativeContext, isNativeOfflineAudioContext, setAudioNodeTailTime) => {
+  return class PannerNode extends audioNodeConstructor {
+    constructor(context, options) {
+      const nativeContext = getNativeContext(context);
+      const mergedOptions = { ...DEFAULT_OPTIONS, ...options };
+      const nativePannerNode = createNativePannerNode(nativeContext, mergedOptions);
+      const isOffline = isNativeOfflineAudioContext(nativeContext);
+      const pannerNodeRenderer = isOffline ? createPannerNodeRenderer() : null;
+      super(context, false, nativePannerNode, pannerNodeRenderer);
+      this._nativePannerNode = nativePannerNode;
+      this._orientationX = createAudioParam(this, isOffline, nativePannerNode.orientationX, MOST_POSITIVE_SINGLE_FLOAT, MOST_NEGATIVE_SINGLE_FLOAT);
+      this._orientationY = createAudioParam(this, isOffline, nativePannerNode.orientationY, MOST_POSITIVE_SINGLE_FLOAT, MOST_NEGATIVE_SINGLE_FLOAT);
+      this._orientationZ = createAudioParam(this, isOffline, nativePannerNode.orientationZ, MOST_POSITIVE_SINGLE_FLOAT, MOST_NEGATIVE_SINGLE_FLOAT);
+      this._positionX = createAudioParam(this, isOffline, nativePannerNode.positionX, MOST_POSITIVE_SINGLE_FLOAT, MOST_NEGATIVE_SINGLE_FLOAT);
+      this._positionY = createAudioParam(this, isOffline, nativePannerNode.positionY, MOST_POSITIVE_SINGLE_FLOAT, MOST_NEGATIVE_SINGLE_FLOAT);
+      this._positionZ = createAudioParam(this, isOffline, nativePannerNode.positionZ, MOST_POSITIVE_SINGLE_FLOAT, MOST_NEGATIVE_SINGLE_FLOAT);
+      setAudioNodeTailTime(this, 1);
+    }
+    get coneInnerAngle() {
+      return this._nativePannerNode.coneInnerAngle;
+    }
+    set coneInnerAngle(value) {
+      this._nativePannerNode.coneInnerAngle = value;
+    }
+    get coneOuterAngle() {
+      return this._nativePannerNode.coneOuterAngle;
+    }
+    set coneOuterAngle(value) {
+      this._nativePannerNode.coneOuterAngle = value;
+    }
+    get coneOuterGain() {
+      return this._nativePannerNode.coneOuterGain;
+    }
+    set coneOuterGain(value) {
+      this._nativePannerNode.coneOuterGain = value;
+    }
+    get distanceModel() {
+      return this._nativePannerNode.distanceModel;
+    }
+    set distanceModel(value) {
+      this._nativePannerNode.distanceModel = value;
+    }
+    get maxDistance() {
+      return this._nativePannerNode.maxDistance;
+    }
+    set maxDistance(value) {
+      this._nativePannerNode.maxDistance = value;
+    }
+    get orientationX() {
+      return this._orientationX;
+    }
+    get orientationY() {
+      return this._orientationY;
+    }
+    get orientationZ() {
+      return this._orientationZ;
+    }
+    get panningModel() {
+      return this._nativePannerNode.panningModel;
+    }
+    set panningModel(value) {
+      this._nativePannerNode.panningModel = value;
+    }
+    get positionX() {
+      return this._positionX;
+    }
+    get positionY() {
+      return this._positionY;
+    }
+    get positionZ() {
+      return this._positionZ;
+    }
+    get refDistance() {
+      return this._nativePannerNode.refDistance;
+    }
+    set refDistance(value) {
+      this._nativePannerNode.refDistance = value;
+    }
+    get rolloffFactor() {
+      return this._nativePannerNode.rolloffFactor;
+    }
+    set rolloffFactor(value) {
+      this._nativePannerNode.rolloffFactor = value;
+    }
+  };
+};
+export {
+  createPannerNodeConstructor
+};