react-audio-wavekit 0.1.5 → 0.1.6

package/dist/node_modules/standardized-audio-context/build/es2019/factories/detect-cycles.cjs

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const audioNode = require("../guards/audio-node.cjs");
+const delayNode = require("../guards/delay-node.cjs");
+const createDetectCycles = (audioParamAudioNodeStore, getAudioNodeConnections, getValueForKey) => {
+  return function detectCycles(chain, nextLink) {
+    const audioNode$1 = audioNode.isAudioNode(nextLink) ? nextLink : getValueForKey(audioParamAudioNodeStore, nextLink);
+    if (delayNode.isDelayNode(audioNode$1)) {
+      return [];
+    }
+    if (chain[0] === audioNode$1) {
+      return [chain];
+    }
+    if (chain.includes(audioNode$1)) {
+      return [];
+    }
+    const { outputs } = getAudioNodeConnections(audioNode$1);
+    return Array.from(outputs).map((outputConnection) => detectCycles([...chain, audioNode$1], outputConnection[0])).reduce((mergedCycles, nestedCycles) => mergedCycles.concat(nestedCycles), []);
+  };
+};
+exports.createDetectCycles = createDetectCycles;

package/dist/node_modules/standardized-audio-context/build/es2019/factories/detect-cycles.js

@@ -0,0 +1,21 @@
+import { isAudioNode } from "../guards/audio-node.js";
+import { isDelayNode } from "../guards/delay-node.js";
+const createDetectCycles = (audioParamAudioNodeStore, getAudioNodeConnections, getValueForKey) => {
+  return function detectCycles(chain, nextLink) {
+    const audioNode = isAudioNode(nextLink) ? nextLink : getValueForKey(audioParamAudioNodeStore, nextLink);
+    if (isDelayNode(audioNode)) {
+      return [];
+    }
+    if (chain[0] === audioNode) {
+      return [chain];
+    }
+    if (chain.includes(audioNode)) {
+      return [];
+    }
+    const { outputs } = getAudioNodeConnections(audioNode);
+    return Array.from(outputs).map((outputConnection) => detectCycles([...chain, audioNode], outputConnection[0])).reduce((mergedCycles, nestedCycles) => mergedCycles.concat(nestedCycles), []);
+  };
+};
+export {
+  createDetectCycles
+};

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

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const DEFAULT_OPTIONS = {
+  attack: 3e-3,
+  channelCount: 2,
+  channelCountMode: "clamped-max",
+  channelInterpretation: "speakers",
+  knee: 30,
+  ratio: 12,
+  release: 0.25,
+  threshold: -24
+};
+const createDynamicsCompressorNodeConstructor = (audioNodeConstructor, createAudioParam, createDynamicsCompressorNodeRenderer, createNativeDynamicsCompressorNode, createNotSupportedError, getNativeContext, isNativeOfflineAudioContext, setAudioNodeTailTime) => {
+  return class DynamicsCompressorNode extends audioNodeConstructor {
+    constructor(context, options) {
+      const nativeContext = getNativeContext(context);
+      const mergedOptions = { ...DEFAULT_OPTIONS, ...options };
+      const nativeDynamicsCompressorNode = createNativeDynamicsCompressorNode(nativeContext, mergedOptions);
+      const isOffline = isNativeOfflineAudioContext(nativeContext);
+      const dynamicsCompressorNodeRenderer = isOffline ? createDynamicsCompressorNodeRenderer() : null;
+      super(context, false, nativeDynamicsCompressorNode, dynamicsCompressorNodeRenderer);
+      this._attack = createAudioParam(this, isOffline, nativeDynamicsCompressorNode.attack);
+      this._knee = createAudioParam(this, isOffline, nativeDynamicsCompressorNode.knee);
+      this._nativeDynamicsCompressorNode = nativeDynamicsCompressorNode;
+      this._ratio = createAudioParam(this, isOffline, nativeDynamicsCompressorNode.ratio);
+      this._release = createAudioParam(this, isOffline, nativeDynamicsCompressorNode.release);
+      this._threshold = createAudioParam(this, isOffline, nativeDynamicsCompressorNode.threshold);
+      setAudioNodeTailTime(this, 6e-3);
+    }
+    get attack() {
+      return this._attack;
+    }
+    // Bug #108: Safari allows a channelCount of three and above which is why the getter and setter needs to be overwritten here.
+    get channelCount() {
+      return this._nativeDynamicsCompressorNode.channelCount;
+    }
+    set channelCount(value) {
+      const previousChannelCount = this._nativeDynamicsCompressorNode.channelCount;
+      this._nativeDynamicsCompressorNode.channelCount = value;
+      if (value > 2) {
+        this._nativeDynamicsCompressorNode.channelCount = previousChannelCount;
+        throw createNotSupportedError();
+      }
+    }
+    /*
+     * Bug #109: Only Chrome and Firefox disallow a channelCountMode of 'max' yet which is why the getter and setter needs to be
+     * overwritten here.
+     */
+    get channelCountMode() {
+      return this._nativeDynamicsCompressorNode.channelCountMode;
+    }
+    set channelCountMode(value) {
+      const previousChannelCount = this._nativeDynamicsCompressorNode.channelCountMode;
+      this._nativeDynamicsCompressorNode.channelCountMode = value;
+      if (value === "max") {
+        this._nativeDynamicsCompressorNode.channelCountMode = previousChannelCount;
+        throw createNotSupportedError();
+      }
+    }
+    get knee() {
+      return this._knee;
+    }
+    get ratio() {
+      return this._ratio;
+    }
+    get reduction() {
+      if (typeof this._nativeDynamicsCompressorNode.reduction.value === "number") {
+        return this._nativeDynamicsCompressorNode.reduction.value;
+      }
+      return this._nativeDynamicsCompressorNode.reduction;
+    }
+    get release() {
+      return this._release;
+    }
+    get threshold() {
+      return this._threshold;
+    }
+  };
+};
+exports.createDynamicsCompressorNodeConstructor = createDynamicsCompressorNodeConstructor;

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

@@ -0,0 +1,80 @@
+const DEFAULT_OPTIONS = {
+  attack: 3e-3,
+  channelCount: 2,
+  channelCountMode: "clamped-max",
+  channelInterpretation: "speakers",
+  knee: 30,
+  ratio: 12,
+  release: 0.25,
+  threshold: -24
+};
+const createDynamicsCompressorNodeConstructor = (audioNodeConstructor, createAudioParam, createDynamicsCompressorNodeRenderer, createNativeDynamicsCompressorNode, createNotSupportedError, getNativeContext, isNativeOfflineAudioContext, setAudioNodeTailTime) => {
+  return class DynamicsCompressorNode extends audioNodeConstructor {
+    constructor(context, options) {
+      const nativeContext = getNativeContext(context);
+      const mergedOptions = { ...DEFAULT_OPTIONS, ...options };
+      const nativeDynamicsCompressorNode = createNativeDynamicsCompressorNode(nativeContext, mergedOptions);
+      const isOffline = isNativeOfflineAudioContext(nativeContext);
+      const dynamicsCompressorNodeRenderer = isOffline ? createDynamicsCompressorNodeRenderer() : null;
+      super(context, false, nativeDynamicsCompressorNode, dynamicsCompressorNodeRenderer);
+      this._attack = createAudioParam(this, isOffline, nativeDynamicsCompressorNode.attack);
+      this._knee = createAudioParam(this, isOffline, nativeDynamicsCompressorNode.knee);
+      this._nativeDynamicsCompressorNode = nativeDynamicsCompressorNode;
+      this._ratio = createAudioParam(this, isOffline, nativeDynamicsCompressorNode.ratio);
+      this._release = createAudioParam(this, isOffline, nativeDynamicsCompressorNode.release);
+      this._threshold = createAudioParam(this, isOffline, nativeDynamicsCompressorNode.threshold);
+      setAudioNodeTailTime(this, 6e-3);
+    }
+    get attack() {
+      return this._attack;
+    }
+    // Bug #108: Safari allows a channelCount of three and above which is why the getter and setter needs to be overwritten here.
+    get channelCount() {
+      return this._nativeDynamicsCompressorNode.channelCount;
+    }
+    set channelCount(value) {
+      const previousChannelCount = this._nativeDynamicsCompressorNode.channelCount;
+      this._nativeDynamicsCompressorNode.channelCount = value;
+      if (value > 2) {
+        this._nativeDynamicsCompressorNode.channelCount = previousChannelCount;
+        throw createNotSupportedError();
+      }
+    }
+    /*
+     * Bug #109: Only Chrome and Firefox disallow a channelCountMode of 'max' yet which is why the getter and setter needs to be
+     * overwritten here.
+     */
+    get channelCountMode() {
+      return this._nativeDynamicsCompressorNode.channelCountMode;
+    }
+    set channelCountMode(value) {
+      const previousChannelCount = this._nativeDynamicsCompressorNode.channelCountMode;
+      this._nativeDynamicsCompressorNode.channelCountMode = value;
+      if (value === "max") {
+        this._nativeDynamicsCompressorNode.channelCountMode = previousChannelCount;
+        throw createNotSupportedError();
+      }
+    }
+    get knee() {
+      return this._knee;
+    }
+    get ratio() {
+      return this._ratio;
+    }
+    get reduction() {
+      if (typeof this._nativeDynamicsCompressorNode.reduction.value === "number") {
+        return this._nativeDynamicsCompressorNode.reduction.value;
+      }
+      return this._nativeDynamicsCompressorNode.reduction;
+    }
+    get release() {
+      return this._release;
+    }
+    get threshold() {
+      return this._threshold;
+    }
+  };
+};
+export {
+  createDynamicsCompressorNodeConstructor
+};

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

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const isOwnedByContext = require("../helpers/is-owned-by-context.cjs");
+const createDynamicsCompressorNodeRendererFactory = (connectAudioParam, createNativeDynamicsCompressorNode, getNativeAudioNode, renderAutomation, renderInputsOfAudioNode) => {
+  return () => {
+    const renderedNativeDynamicsCompressorNodes = /* @__PURE__ */ new WeakMap();
+    const createDynamicsCompressorNode = async (proxy, nativeOfflineAudioContext) => {
+      let nativeDynamicsCompressorNode = getNativeAudioNode(proxy);
+      const nativeDynamicsCompressorNodeIsOwnedByContext = isOwnedByContext.isOwnedByContext(nativeDynamicsCompressorNode, nativeOfflineAudioContext);
+      if (!nativeDynamicsCompressorNodeIsOwnedByContext) {
+        const options = {
+          attack: nativeDynamicsCompressorNode.attack.value,
+          channelCount: nativeDynamicsCompressorNode.channelCount,
+          channelCountMode: nativeDynamicsCompressorNode.channelCountMode,
+          channelInterpretation: nativeDynamicsCompressorNode.channelInterpretation,
+          knee: nativeDynamicsCompressorNode.knee.value,
+          ratio: nativeDynamicsCompressorNode.ratio.value,
+          release: nativeDynamicsCompressorNode.release.value,
+          threshold: nativeDynamicsCompressorNode.threshold.value
+        };
+        nativeDynamicsCompressorNode = createNativeDynamicsCompressorNode(nativeOfflineAudioContext, options);
+      }
+      renderedNativeDynamicsCompressorNodes.set(nativeOfflineAudioContext, nativeDynamicsCompressorNode);
+      if (!nativeDynamicsCompressorNodeIsOwnedByContext) {
+        await renderAutomation(nativeOfflineAudioContext, proxy.attack, nativeDynamicsCompressorNode.attack);
+        await renderAutomation(nativeOfflineAudioContext, proxy.knee, nativeDynamicsCompressorNode.knee);
+        await renderAutomation(nativeOfflineAudioContext, proxy.ratio, nativeDynamicsCompressorNode.ratio);
+        await renderAutomation(nativeOfflineAudioContext, proxy.release, nativeDynamicsCompressorNode.release);
+        await renderAutomation(nativeOfflineAudioContext, proxy.threshold, nativeDynamicsCompressorNode.threshold);
+      } else {
+        await connectAudioParam(nativeOfflineAudioContext, proxy.attack, nativeDynamicsCompressorNode.attack);
+        await connectAudioParam(nativeOfflineAudioContext, proxy.knee, nativeDynamicsCompressorNode.knee);
+        await connectAudioParam(nativeOfflineAudioContext, proxy.ratio, nativeDynamicsCompressorNode.ratio);
+        await connectAudioParam(nativeOfflineAudioContext, proxy.release, nativeDynamicsCompressorNode.release);
+        await connectAudioParam(nativeOfflineAudioContext, proxy.threshold, nativeDynamicsCompressorNode.threshold);
+      }
+      await renderInputsOfAudioNode(proxy, nativeOfflineAudioContext, nativeDynamicsCompressorNode);
+      return nativeDynamicsCompressorNode;
+    };
+    return {
+      render(proxy, nativeOfflineAudioContext) {
+        const renderedNativeDynamicsCompressorNode = renderedNativeDynamicsCompressorNodes.get(nativeOfflineAudioContext);
+        if (renderedNativeDynamicsCompressorNode !== void 0) {
+          return Promise.resolve(renderedNativeDynamicsCompressorNode);
+        }
+        return createDynamicsCompressorNode(proxy, nativeOfflineAudioContext);
+      }
+    };
+  };
+};
+exports.createDynamicsCompressorNodeRendererFactory = createDynamicsCompressorNodeRendererFactory;

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

@@ -0,0 +1,51 @@
+import { isOwnedByContext } from "../helpers/is-owned-by-context.js";
+const createDynamicsCompressorNodeRendererFactory = (connectAudioParam, createNativeDynamicsCompressorNode, getNativeAudioNode, renderAutomation, renderInputsOfAudioNode) => {
+  return () => {
+    const renderedNativeDynamicsCompressorNodes = /* @__PURE__ */ new WeakMap();
+    const createDynamicsCompressorNode = async (proxy, nativeOfflineAudioContext) => {
+      let nativeDynamicsCompressorNode = getNativeAudioNode(proxy);
+      const nativeDynamicsCompressorNodeIsOwnedByContext = isOwnedByContext(nativeDynamicsCompressorNode, nativeOfflineAudioContext);
+      if (!nativeDynamicsCompressorNodeIsOwnedByContext) {
+        const options = {
+          attack: nativeDynamicsCompressorNode.attack.value,
+          channelCount: nativeDynamicsCompressorNode.channelCount,
+          channelCountMode: nativeDynamicsCompressorNode.channelCountMode,
+          channelInterpretation: nativeDynamicsCompressorNode.channelInterpretation,
+          knee: nativeDynamicsCompressorNode.knee.value,
+          ratio: nativeDynamicsCompressorNode.ratio.value,
+          release: nativeDynamicsCompressorNode.release.value,
+          threshold: nativeDynamicsCompressorNode.threshold.value
+        };
+        nativeDynamicsCompressorNode = createNativeDynamicsCompressorNode(nativeOfflineAudioContext, options);
+      }
+      renderedNativeDynamicsCompressorNodes.set(nativeOfflineAudioContext, nativeDynamicsCompressorNode);
+      if (!nativeDynamicsCompressorNodeIsOwnedByContext) {
+        await renderAutomation(nativeOfflineAudioContext, proxy.attack, nativeDynamicsCompressorNode.attack);
+        await renderAutomation(nativeOfflineAudioContext, proxy.knee, nativeDynamicsCompressorNode.knee);
+        await renderAutomation(nativeOfflineAudioContext, proxy.ratio, nativeDynamicsCompressorNode.ratio);
+        await renderAutomation(nativeOfflineAudioContext, proxy.release, nativeDynamicsCompressorNode.release);
+        await renderAutomation(nativeOfflineAudioContext, proxy.threshold, nativeDynamicsCompressorNode.threshold);
+      } else {
+        await connectAudioParam(nativeOfflineAudioContext, proxy.attack, nativeDynamicsCompressorNode.attack);
+        await connectAudioParam(nativeOfflineAudioContext, proxy.knee, nativeDynamicsCompressorNode.knee);
+        await connectAudioParam(nativeOfflineAudioContext, proxy.ratio, nativeDynamicsCompressorNode.ratio);
+        await connectAudioParam(nativeOfflineAudioContext, proxy.release, nativeDynamicsCompressorNode.release);
+        await connectAudioParam(nativeOfflineAudioContext, proxy.threshold, nativeDynamicsCompressorNode.threshold);
+      }
+      await renderInputsOfAudioNode(proxy, nativeOfflineAudioContext, nativeDynamicsCompressorNode);
+      return nativeDynamicsCompressorNode;
+    };
+    return {
+      render(proxy, nativeOfflineAudioContext) {
+        const renderedNativeDynamicsCompressorNode = renderedNativeDynamicsCompressorNodes.get(nativeOfflineAudioContext);
+        if (renderedNativeDynamicsCompressorNode !== void 0) {
+          return Promise.resolve(renderedNativeDynamicsCompressorNode);
+        }
+        return createDynamicsCompressorNode(proxy, nativeOfflineAudioContext);
+      }
+    };
+  };
+};
+export {
+  createDynamicsCompressorNodeRendererFactory
+};

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

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

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

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

package/dist/node_modules/standardized-audio-context/build/es2019/factories/evaluate-source.cjs

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const createEvaluateSource = (window) => {
+  return (source) => new Promise((resolve, reject) => {
+    if (window === null) {
+      reject(new SyntaxError());
+      return;
+    }
+    const head = window.document.head;
+    if (head === null) {
+      reject(new SyntaxError());
+    } else {
+      const script = window.document.createElement("script");
+      const blob = new Blob([source], { type: "application/javascript" });
+      const url = URL.createObjectURL(blob);
+      const originalOnErrorHandler = window.onerror;
+      const removeErrorEventListenerAndRevokeUrl = () => {
+        window.onerror = originalOnErrorHandler;
+        URL.revokeObjectURL(url);
+      };
+      window.onerror = (message, src, lineno, colno, error) => {
+        if (src === url || src === window.location.href && lineno === 1 && colno === 1) {
+          removeErrorEventListenerAndRevokeUrl();
+          reject(error);
+          return false;
+        }
+        if (originalOnErrorHandler !== null) {
+          return originalOnErrorHandler(message, src, lineno, colno, error);
+        }
+      };
+      script.onerror = () => {
+        removeErrorEventListenerAndRevokeUrl();
+        reject(new SyntaxError());
+      };
+      script.onload = () => {
+        removeErrorEventListenerAndRevokeUrl();
+        resolve();
+      };
+      script.src = url;
+      script.type = "module";
+      head.appendChild(script);
+    }
+  });
+};
+exports.createEvaluateSource = createEvaluateSource;

package/dist/node_modules/standardized-audio-context/build/es2019/factories/evaluate-source.js

@@ -0,0 +1,45 @@
+const createEvaluateSource = (window) => {
+  return (source) => new Promise((resolve, reject) => {
+    if (window === null) {
+      reject(new SyntaxError());
+      return;
+    }
+    const head = window.document.head;
+    if (head === null) {
+      reject(new SyntaxError());
+    } else {
+      const script = window.document.createElement("script");
+      const blob = new Blob([source], { type: "application/javascript" });
+      const url = URL.createObjectURL(blob);
+      const originalOnErrorHandler = window.onerror;
+      const removeErrorEventListenerAndRevokeUrl = () => {
+        window.onerror = originalOnErrorHandler;
+        URL.revokeObjectURL(url);
+      };
+      window.onerror = (message, src, lineno, colno, error) => {
+        if (src === url || src === window.location.href && lineno === 1 && colno === 1) {
+          removeErrorEventListenerAndRevokeUrl();
+          reject(error);
+          return false;
+        }
+        if (originalOnErrorHandler !== null) {
+          return originalOnErrorHandler(message, src, lineno, colno, error);
+        }
+      };
+      script.onerror = () => {
+        removeErrorEventListenerAndRevokeUrl();
+        reject(new SyntaxError());
+      };
+      script.onload = () => {
+        removeErrorEventListenerAndRevokeUrl();
+        resolve();
+      };
+      script.src = url;
+      script.type = "module";
+      head.appendChild(script);
+    }
+  });
+};
+export {
+  createEvaluateSource
+};

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

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const createEventTargetConstructor = (wrapEventListener) => {
+  return class EventTarget {
+    constructor(_nativeEventTarget) {
+      this._nativeEventTarget = _nativeEventTarget;
+      this._listeners = /* @__PURE__ */ new WeakMap();
+    }
+    addEventListener(type, listener, options) {
+      if (listener !== null) {
+        let wrappedEventListener = this._listeners.get(listener);
+        if (wrappedEventListener === void 0) {
+          wrappedEventListener = wrapEventListener(this, listener);
+          if (typeof listener === "function") {
+            this._listeners.set(listener, wrappedEventListener);
+          }
+        }
+        this._nativeEventTarget.addEventListener(type, wrappedEventListener, options);
+      }
+    }
+    dispatchEvent(event) {
+      return this._nativeEventTarget.dispatchEvent(event);
+    }
+    removeEventListener(type, listener, options) {
+      const wrappedEventListener = listener === null ? void 0 : this._listeners.get(listener);
+      this._nativeEventTarget.removeEventListener(type, wrappedEventListener === void 0 ? null : wrappedEventListener, options);
+    }
+  };
+};
+exports.createEventTargetConstructor = createEventTargetConstructor;

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

@@ -0,0 +1,30 @@
+const createEventTargetConstructor = (wrapEventListener) => {
+  return class EventTarget {
+    constructor(_nativeEventTarget) {
+      this._nativeEventTarget = _nativeEventTarget;
+      this._listeners = /* @__PURE__ */ new WeakMap();
+    }
+    addEventListener(type, listener, options) {
+      if (listener !== null) {
+        let wrappedEventListener = this._listeners.get(listener);
+        if (wrappedEventListener === void 0) {
+          wrappedEventListener = wrapEventListener(this, listener);
+          if (typeof listener === "function") {
+            this._listeners.set(listener, wrappedEventListener);
+          }
+        }
+        this._nativeEventTarget.addEventListener(type, wrappedEventListener, options);
+      }
+    }
+    dispatchEvent(event) {
+      return this._nativeEventTarget.dispatchEvent(event);
+    }
+    removeEventListener(type, listener, options) {
+      const wrappedEventListener = listener === null ? void 0 : this._listeners.get(listener);
+      this._nativeEventTarget.removeEventListener(type, wrappedEventListener === void 0 ? null : wrappedEventListener, options);
+    }
+  };
+};
+export {
+  createEventTargetConstructor
+};

package/dist/node_modules/standardized-audio-context/build/es2019/factories/expose-current-frame-and-current-time.cjs

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const createExposeCurrentFrameAndCurrentTime = (window) => {
+  return (currentTime, sampleRate, fn) => {
+    Object.defineProperties(window, {
+      currentFrame: {
+        configurable: true,
+        get() {
+          return Math.round(currentTime * sampleRate);
+        }
+      },
+      currentTime: {
+        configurable: true,
+        get() {
+          return currentTime;
+        }
+      }
+    });
+    try {
+      return fn();
+    } finally {
+      if (window !== null) {
+        delete window.currentFrame;
+        delete window.currentTime;
+      }
+    }
+  };
+};
+exports.createExposeCurrentFrameAndCurrentTime = createExposeCurrentFrameAndCurrentTime;

package/dist/node_modules/standardized-audio-context/build/es2019/factories/expose-current-frame-and-current-time.js

@@ -0,0 +1,29 @@
+const createExposeCurrentFrameAndCurrentTime = (window) => {
+  return (currentTime, sampleRate, fn) => {
+    Object.defineProperties(window, {
+      currentFrame: {
+        configurable: true,
+        get() {
+          return Math.round(currentTime * sampleRate);
+        }
+      },
+      currentTime: {
+        configurable: true,
+        get() {
+          return currentTime;
+        }
+      }
+    });
+    try {
+      return fn();
+    } finally {
+      if (window !== null) {
+        delete window.currentFrame;
+        delete window.currentTime;
+      }
+    }
+  };
+};
+export {
+  createExposeCurrentFrameAndCurrentTime
+};

package/dist/node_modules/standardized-audio-context/build/es2019/factories/fetch-source.cjs

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const createFetchSource = (createAbortError) => {
+  return async (url) => {
+    try {
+      const response = await fetch(url);
+      if (response.ok) {
+        return [await response.text(), response.url];
+      }
+    } catch {
+    }
+    throw createAbortError();
+  };
+};
+exports.createFetchSource = createFetchSource;

package/dist/node_modules/standardized-audio-context/build/es2019/factories/fetch-source.js

@@ -0,0 +1,15 @@
+const createFetchSource = (createAbortError) => {
+  return async (url) => {
+    try {
+      const response = await fetch(url);
+      if (response.ok) {
+        return [await response.text(), response.url];
+      }
+    } catch {
+    }
+    throw createAbortError();
+  };
+};
+export {
+  createFetchSource
+};

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

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const constants = require("../constants.cjs");
+const DEFAULT_OPTIONS = {
+  channelCount: 2,
+  channelCountMode: "max",
+  channelInterpretation: "speakers",
+  gain: 1
+};
+const createGainNodeConstructor = (audioNodeConstructor, createAudioParam, createGainNodeRenderer, createNativeGainNode, getNativeContext, isNativeOfflineAudioContext) => {
+  return class GainNode extends audioNodeConstructor {
+    constructor(context, options) {
+      const nativeContext = getNativeContext(context);
+      const mergedOptions = { ...DEFAULT_OPTIONS, ...options };
+      const nativeGainNode = createNativeGainNode(nativeContext, mergedOptions);
+      const isOffline = isNativeOfflineAudioContext(nativeContext);
+      const gainNodeRenderer = isOffline ? createGainNodeRenderer() : null;
+      super(context, false, nativeGainNode, gainNodeRenderer);
+      this._gain = createAudioParam(this, isOffline, nativeGainNode.gain, constants.MOST_POSITIVE_SINGLE_FLOAT, constants.MOST_NEGATIVE_SINGLE_FLOAT);
+    }
+    get gain() {
+      return this._gain;
+    }
+  };
+};
+exports.createGainNodeConstructor = createGainNodeConstructor;

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

@@ -0,0 +1,26 @@
+import { MOST_POSITIVE_SINGLE_FLOAT, MOST_NEGATIVE_SINGLE_FLOAT } from "../constants.js";
+const DEFAULT_OPTIONS = {
+  channelCount: 2,
+  channelCountMode: "max",
+  channelInterpretation: "speakers",
+  gain: 1
+};
+const createGainNodeConstructor = (audioNodeConstructor, createAudioParam, createGainNodeRenderer, createNativeGainNode, getNativeContext, isNativeOfflineAudioContext) => {
+  return class GainNode extends audioNodeConstructor {
+    constructor(context, options) {
+      const nativeContext = getNativeContext(context);
+      const mergedOptions = { ...DEFAULT_OPTIONS, ...options };
+      const nativeGainNode = createNativeGainNode(nativeContext, mergedOptions);
+      const isOffline = isNativeOfflineAudioContext(nativeContext);
+      const gainNodeRenderer = isOffline ? createGainNodeRenderer() : null;
+      super(context, false, nativeGainNode, gainNodeRenderer);
+      this._gain = createAudioParam(this, isOffline, nativeGainNode.gain, MOST_POSITIVE_SINGLE_FLOAT, MOST_NEGATIVE_SINGLE_FLOAT);
+    }
+    get gain() {
+      return this._gain;
+    }
+  };
+};
+export {
+  createGainNodeConstructor
+};

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

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const isOwnedByContext = require("../helpers/is-owned-by-context.cjs");
+const createGainNodeRendererFactory = (connectAudioParam, createNativeGainNode, getNativeAudioNode, renderAutomation, renderInputsOfAudioNode) => {
+  return () => {
+    const renderedNativeGainNodes = /* @__PURE__ */ new WeakMap();
+    const createGainNode = async (proxy, nativeOfflineAudioContext) => {
+      let nativeGainNode = getNativeAudioNode(proxy);
+      const nativeGainNodeIsOwnedByContext = isOwnedByContext.isOwnedByContext(nativeGainNode, nativeOfflineAudioContext);
+      if (!nativeGainNodeIsOwnedByContext) {
+        const options = {
+          channelCount: nativeGainNode.channelCount,
+          channelCountMode: nativeGainNode.channelCountMode,
+          channelInterpretation: nativeGainNode.channelInterpretation,
+          gain: nativeGainNode.gain.value
+        };
+        nativeGainNode = createNativeGainNode(nativeOfflineAudioContext, options);
+      }
+      renderedNativeGainNodes.set(nativeOfflineAudioContext, nativeGainNode);
+      if (!nativeGainNodeIsOwnedByContext) {
+        await renderAutomation(nativeOfflineAudioContext, proxy.gain, nativeGainNode.gain);
+      } else {
+        await connectAudioParam(nativeOfflineAudioContext, proxy.gain, nativeGainNode.gain);
+      }
+      await renderInputsOfAudioNode(proxy, nativeOfflineAudioContext, nativeGainNode);
+      return nativeGainNode;
+    };
+    return {
+      render(proxy, nativeOfflineAudioContext) {
+        const renderedNativeGainNode = renderedNativeGainNodes.get(nativeOfflineAudioContext);
+        if (renderedNativeGainNode !== void 0) {
+          return Promise.resolve(renderedNativeGainNode);
+        }
+        return createGainNode(proxy, nativeOfflineAudioContext);
+      }
+    };
+  };
+};
+exports.createGainNodeRendererFactory = createGainNodeRendererFactory;