react-audio-wavekit 0.1.4 → 0.1.6

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

@@ -0,0 +1,53 @@
+import { isOwnedByContext } from "../helpers/is-owned-by-context.js";
+const createConstantSourceNodeRendererFactory = (connectAudioParam, createNativeConstantSourceNode, getNativeAudioNode, renderAutomation, renderInputsOfAudioNode) => {
+  return () => {
+    const renderedNativeConstantSourceNodes = /* @__PURE__ */ new WeakMap();
+    let start = null;
+    let stop = null;
+    const createConstantSourceNode = async (proxy, nativeOfflineAudioContext) => {
+      let nativeConstantSourceNode = getNativeAudioNode(proxy);
+      const nativeConstantSourceNodeIsOwnedByContext = isOwnedByContext(nativeConstantSourceNode, nativeOfflineAudioContext);
+      if (!nativeConstantSourceNodeIsOwnedByContext) {
+        const options = {
+          channelCount: nativeConstantSourceNode.channelCount,
+          channelCountMode: nativeConstantSourceNode.channelCountMode,
+          channelInterpretation: nativeConstantSourceNode.channelInterpretation,
+          offset: nativeConstantSourceNode.offset.value
+        };
+        nativeConstantSourceNode = createNativeConstantSourceNode(nativeOfflineAudioContext, options);
+        if (start !== null) {
+          nativeConstantSourceNode.start(start);
+        }
+        if (stop !== null) {
+          nativeConstantSourceNode.stop(stop);
+        }
+      }
+      renderedNativeConstantSourceNodes.set(nativeOfflineAudioContext, nativeConstantSourceNode);
+      if (!nativeConstantSourceNodeIsOwnedByContext) {
+        await renderAutomation(nativeOfflineAudioContext, proxy.offset, nativeConstantSourceNode.offset);
+      } else {
+        await connectAudioParam(nativeOfflineAudioContext, proxy.offset, nativeConstantSourceNode.offset);
+      }
+      await renderInputsOfAudioNode(proxy, nativeOfflineAudioContext, nativeConstantSourceNode);
+      return nativeConstantSourceNode;
+    };
+    return {
+      set start(value) {
+        start = value;
+      },
+      set stop(value) {
+        stop = value;
+      },
+      render(proxy, nativeOfflineAudioContext) {
+        const renderedNativeConstantSourceNode = renderedNativeConstantSourceNodes.get(nativeOfflineAudioContext);
+        if (renderedNativeConstantSourceNode !== void 0) {
+          return Promise.resolve(renderedNativeConstantSourceNode);
+        }
+        return createConstantSourceNode(proxy, nativeOfflineAudioContext);
+      }
+    };
+  };
+};
+export {
+  createConstantSourceNodeRendererFactory
+};

package/dist/node_modules/standardized-audio-context/build/es2019/factories/convert-number-to-unsigned-long.cjs

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const createConvertNumberToUnsignedLong = (unit32Array) => {
+  return (value) => {
+    unit32Array[0] = value;
+    return unit32Array[0];
+  };
+};
+exports.createConvertNumberToUnsignedLong = createConvertNumberToUnsignedLong;

package/dist/node_modules/standardized-audio-context/build/es2019/factories/convert-number-to-unsigned-long.js

@@ -0,0 +1,9 @@
+const createConvertNumberToUnsignedLong = (unit32Array) => {
+  return (value) => {
+    unit32Array[0] = value;
+    return unit32Array[0];
+  };
+};
+export {
+  createConvertNumberToUnsignedLong
+};

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

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const DEFAULT_OPTIONS = {
+  buffer: null,
+  channelCount: 2,
+  channelCountMode: "clamped-max",
+  channelInterpretation: "speakers",
+  disableNormalization: false
+};
+const createConvolverNodeConstructor = (audioNodeConstructor, createConvolverNodeRenderer, createNativeConvolverNode, getNativeContext, isNativeOfflineAudioContext, setAudioNodeTailTime) => {
+  return class ConvolverNode extends audioNodeConstructor {
+    constructor(context, options) {
+      const nativeContext = getNativeContext(context);
+      const mergedOptions = { ...DEFAULT_OPTIONS, ...options };
+      const nativeConvolverNode = createNativeConvolverNode(nativeContext, mergedOptions);
+      const isOffline = isNativeOfflineAudioContext(nativeContext);
+      const convolverNodeRenderer = isOffline ? createConvolverNodeRenderer() : null;
+      super(context, false, nativeConvolverNode, convolverNodeRenderer);
+      this._isBufferNullified = false;
+      this._nativeConvolverNode = nativeConvolverNode;
+      if (mergedOptions.buffer !== null) {
+        setAudioNodeTailTime(this, mergedOptions.buffer.duration);
+      }
+    }
+    get buffer() {
+      if (this._isBufferNullified) {
+        return null;
+      }
+      return this._nativeConvolverNode.buffer;
+    }
+    set buffer(value) {
+      this._nativeConvolverNode.buffer = value;
+      if (value === null && this._nativeConvolverNode.buffer !== null) {
+        const nativeContext = this._nativeConvolverNode.context;
+        this._nativeConvolverNode.buffer = nativeContext.createBuffer(1, 1, nativeContext.sampleRate);
+        this._isBufferNullified = true;
+        setAudioNodeTailTime(this, 0);
+      } else {
+        this._isBufferNullified = false;
+        setAudioNodeTailTime(this, this._nativeConvolverNode.buffer === null ? 0 : this._nativeConvolverNode.buffer.duration);
+      }
+    }
+    get normalize() {
+      return this._nativeConvolverNode.normalize;
+    }
+    set normalize(value) {
+      this._nativeConvolverNode.normalize = value;
+    }
+  };
+};
+exports.createConvolverNodeConstructor = createConvolverNodeConstructor;

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

@@ -0,0 +1,51 @@
+const DEFAULT_OPTIONS = {
+  buffer: null,
+  channelCount: 2,
+  channelCountMode: "clamped-max",
+  channelInterpretation: "speakers",
+  disableNormalization: false
+};
+const createConvolverNodeConstructor = (audioNodeConstructor, createConvolverNodeRenderer, createNativeConvolverNode, getNativeContext, isNativeOfflineAudioContext, setAudioNodeTailTime) => {
+  return class ConvolverNode extends audioNodeConstructor {
+    constructor(context, options) {
+      const nativeContext = getNativeContext(context);
+      const mergedOptions = { ...DEFAULT_OPTIONS, ...options };
+      const nativeConvolverNode = createNativeConvolverNode(nativeContext, mergedOptions);
+      const isOffline = isNativeOfflineAudioContext(nativeContext);
+      const convolverNodeRenderer = isOffline ? createConvolverNodeRenderer() : null;
+      super(context, false, nativeConvolverNode, convolverNodeRenderer);
+      this._isBufferNullified = false;
+      this._nativeConvolverNode = nativeConvolverNode;
+      if (mergedOptions.buffer !== null) {
+        setAudioNodeTailTime(this, mergedOptions.buffer.duration);
+      }
+    }
+    get buffer() {
+      if (this._isBufferNullified) {
+        return null;
+      }
+      return this._nativeConvolverNode.buffer;
+    }
+    set buffer(value) {
+      this._nativeConvolverNode.buffer = value;
+      if (value === null && this._nativeConvolverNode.buffer !== null) {
+        const nativeContext = this._nativeConvolverNode.context;
+        this._nativeConvolverNode.buffer = nativeContext.createBuffer(1, 1, nativeContext.sampleRate);
+        this._isBufferNullified = true;
+        setAudioNodeTailTime(this, 0);
+      } else {
+        this._isBufferNullified = false;
+        setAudioNodeTailTime(this, this._nativeConvolverNode.buffer === null ? 0 : this._nativeConvolverNode.buffer.duration);
+      }
+    }
+    get normalize() {
+      return this._nativeConvolverNode.normalize;
+    }
+    set normalize(value) {
+      this._nativeConvolverNode.normalize = value;
+    }
+  };
+};
+export {
+  createConvolverNodeConstructor
+};

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

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const nativeAudioNodeFaker = require("../guards/native-audio-node-faker.cjs");
+const isOwnedByContext = require("../helpers/is-owned-by-context.cjs");
+const createConvolverNodeRendererFactory = (createNativeConvolverNode, getNativeAudioNode, renderInputsOfAudioNode) => {
+  return () => {
+    const renderedNativeConvolverNodes = /* @__PURE__ */ new WeakMap();
+    const createConvolverNode = async (proxy, nativeOfflineAudioContext) => {
+      let nativeConvolverNode = getNativeAudioNode(proxy);
+      const nativeConvolverNodeIsOwnedByContext = isOwnedByContext.isOwnedByContext(nativeConvolverNode, nativeOfflineAudioContext);
+      if (!nativeConvolverNodeIsOwnedByContext) {
+        const options = {
+          buffer: nativeConvolverNode.buffer,
+          channelCount: nativeConvolverNode.channelCount,
+          channelCountMode: nativeConvolverNode.channelCountMode,
+          channelInterpretation: nativeConvolverNode.channelInterpretation,
+          disableNormalization: !nativeConvolverNode.normalize
+        };
+        nativeConvolverNode = createNativeConvolverNode(nativeOfflineAudioContext, options);
+      }
+      renderedNativeConvolverNodes.set(nativeOfflineAudioContext, nativeConvolverNode);
+      if (nativeAudioNodeFaker.isNativeAudioNodeFaker(nativeConvolverNode)) {
+        await renderInputsOfAudioNode(proxy, nativeOfflineAudioContext, nativeConvolverNode.inputs[0]);
+      } else {
+        await renderInputsOfAudioNode(proxy, nativeOfflineAudioContext, nativeConvolverNode);
+      }
+      return nativeConvolverNode;
+    };
+    return {
+      render(proxy, nativeOfflineAudioContext) {
+        const renderedNativeConvolverNode = renderedNativeConvolverNodes.get(nativeOfflineAudioContext);
+        if (renderedNativeConvolverNode !== void 0) {
+          return Promise.resolve(renderedNativeConvolverNode);
+        }
+        return createConvolverNode(proxy, nativeOfflineAudioContext);
+      }
+    };
+  };
+};
+exports.createConvolverNodeRendererFactory = createConvolverNodeRendererFactory;

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

@@ -0,0 +1,40 @@
+import { isNativeAudioNodeFaker } from "../guards/native-audio-node-faker.js";
+import { isOwnedByContext } from "../helpers/is-owned-by-context.js";
+const createConvolverNodeRendererFactory = (createNativeConvolverNode, getNativeAudioNode, renderInputsOfAudioNode) => {
+  return () => {
+    const renderedNativeConvolverNodes = /* @__PURE__ */ new WeakMap();
+    const createConvolverNode = async (proxy, nativeOfflineAudioContext) => {
+      let nativeConvolverNode = getNativeAudioNode(proxy);
+      const nativeConvolverNodeIsOwnedByContext = isOwnedByContext(nativeConvolverNode, nativeOfflineAudioContext);
+      if (!nativeConvolverNodeIsOwnedByContext) {
+        const options = {
+          buffer: nativeConvolverNode.buffer,
+          channelCount: nativeConvolverNode.channelCount,
+          channelCountMode: nativeConvolverNode.channelCountMode,
+          channelInterpretation: nativeConvolverNode.channelInterpretation,
+          disableNormalization: !nativeConvolverNode.normalize
+        };
+        nativeConvolverNode = createNativeConvolverNode(nativeOfflineAudioContext, options);
+      }
+      renderedNativeConvolverNodes.set(nativeOfflineAudioContext, nativeConvolverNode);
+      if (isNativeAudioNodeFaker(nativeConvolverNode)) {
+        await renderInputsOfAudioNode(proxy, nativeOfflineAudioContext, nativeConvolverNode.inputs[0]);
+      } else {
+        await renderInputsOfAudioNode(proxy, nativeOfflineAudioContext, nativeConvolverNode);
+      }
+      return nativeConvolverNode;
+    };
+    return {
+      render(proxy, nativeOfflineAudioContext) {
+        const renderedNativeConvolverNode = renderedNativeConvolverNodes.get(nativeOfflineAudioContext);
+        if (renderedNativeConvolverNode !== void 0) {
+          return Promise.resolve(renderedNativeConvolverNode);
+        }
+        return createConvolverNode(proxy, nativeOfflineAudioContext);
+      }
+    };
+  };
+};
+export {
+  createConvolverNodeRendererFactory
+};

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

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const createCreateNativeOfflineAudioContext = (createNotSupportedError, nativeOfflineAudioContextConstructor) => {
+  return (numberOfChannels, length, sampleRate) => {
+    if (nativeOfflineAudioContextConstructor === null) {
+      throw new Error("Missing the native OfflineAudioContext constructor.");
+    }
+    try {
+      return new nativeOfflineAudioContextConstructor(numberOfChannels, length, sampleRate);
+    } catch (err) {
+      if (err.name === "SyntaxError") {
+        throw createNotSupportedError();
+      }
+      throw err;
+    }
+  };
+};
+exports.createCreateNativeOfflineAudioContext = createCreateNativeOfflineAudioContext;

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

@@ -0,0 +1,18 @@
+const createCreateNativeOfflineAudioContext = (createNotSupportedError, nativeOfflineAudioContextConstructor) => {
+  return (numberOfChannels, length, sampleRate) => {
+    if (nativeOfflineAudioContextConstructor === null) {
+      throw new Error("Missing the native OfflineAudioContext constructor.");
+    }
+    try {
+      return new nativeOfflineAudioContextConstructor(numberOfChannels, length, sampleRate);
+    } catch (err) {
+      if (err.name === "SyntaxError") {
+        throw createNotSupportedError();
+      }
+      throw err;
+    }
+  };
+};
+export {
+  createCreateNativeOfflineAudioContext
+};

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

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

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

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

package/dist/node_modules/standardized-audio-context/build/es2019/factories/decode-audio-data.cjs

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const detachArrayBuffer = require("../helpers/detach-array-buffer.cjs");
+const wrapAudioBufferGetChannelDataMethod = require("../helpers/wrap-audio-buffer-get-channel-data-method.cjs");
+const createDecodeAudioData = (audioBufferStore, cacheTestResult, createDataCloneError, createEncodingError, detachedArrayBuffers, getNativeContext, isNativeContext, testAudioBufferCopyChannelMethodsOutOfBoundsSupport, testPromiseSupport, wrapAudioBufferCopyChannelMethods, wrapAudioBufferCopyChannelMethodsOutOfBounds) => {
+  return (anyContext, audioData) => {
+    const nativeContext = isNativeContext(anyContext) ? anyContext : getNativeContext(anyContext);
+    if (detachedArrayBuffers.has(audioData)) {
+      const err = createDataCloneError();
+      return Promise.reject(err);
+    }
+    try {
+      detachedArrayBuffers.add(audioData);
+    } catch {
+    }
+    if (cacheTestResult(testPromiseSupport, () => testPromiseSupport(nativeContext))) {
+      return nativeContext.decodeAudioData(audioData).then((audioBuffer) => {
+        detachArrayBuffer.detachArrayBuffer(audioData).catch(() => {
+        });
+        if (!cacheTestResult(testAudioBufferCopyChannelMethodsOutOfBoundsSupport, () => testAudioBufferCopyChannelMethodsOutOfBoundsSupport(audioBuffer))) {
+          wrapAudioBufferCopyChannelMethodsOutOfBounds(audioBuffer);
+        }
+        audioBufferStore.add(audioBuffer);
+        return audioBuffer;
+      });
+    }
+    return new Promise((resolve, reject) => {
+      const complete = async () => {
+        try {
+          await detachArrayBuffer.detachArrayBuffer(audioData);
+        } catch {
+        }
+      };
+      const fail = (err) => {
+        reject(err);
+        complete();
+      };
+      try {
+        nativeContext.decodeAudioData(audioData, (audioBuffer) => {
+          if (typeof audioBuffer.copyFromChannel !== "function") {
+            wrapAudioBufferCopyChannelMethods(audioBuffer);
+            wrapAudioBufferGetChannelDataMethod.wrapAudioBufferGetChannelDataMethod(audioBuffer);
+          }
+          audioBufferStore.add(audioBuffer);
+          complete().then(() => resolve(audioBuffer));
+        }, (err) => {
+          if (err === null) {
+            fail(createEncodingError());
+          } else {
+            fail(err);
+          }
+        });
+      } catch (err) {
+        fail(err);
+      }
+    });
+  };
+};
+exports.createDecodeAudioData = createDecodeAudioData;

package/dist/node_modules/standardized-audio-context/build/es2019/factories/decode-audio-data.js

@@ -0,0 +1,59 @@
+import { detachArrayBuffer } from "../helpers/detach-array-buffer.js";
+import { wrapAudioBufferGetChannelDataMethod } from "../helpers/wrap-audio-buffer-get-channel-data-method.js";
+const createDecodeAudioData = (audioBufferStore, cacheTestResult, createDataCloneError, createEncodingError, detachedArrayBuffers, getNativeContext, isNativeContext, testAudioBufferCopyChannelMethodsOutOfBoundsSupport, testPromiseSupport, wrapAudioBufferCopyChannelMethods, wrapAudioBufferCopyChannelMethodsOutOfBounds) => {
+  return (anyContext, audioData) => {
+    const nativeContext = isNativeContext(anyContext) ? anyContext : getNativeContext(anyContext);
+    if (detachedArrayBuffers.has(audioData)) {
+      const err = createDataCloneError();
+      return Promise.reject(err);
+    }
+    try {
+      detachedArrayBuffers.add(audioData);
+    } catch {
+    }
+    if (cacheTestResult(testPromiseSupport, () => testPromiseSupport(nativeContext))) {
+      return nativeContext.decodeAudioData(audioData).then((audioBuffer) => {
+        detachArrayBuffer(audioData).catch(() => {
+        });
+        if (!cacheTestResult(testAudioBufferCopyChannelMethodsOutOfBoundsSupport, () => testAudioBufferCopyChannelMethodsOutOfBoundsSupport(audioBuffer))) {
+          wrapAudioBufferCopyChannelMethodsOutOfBounds(audioBuffer);
+        }
+        audioBufferStore.add(audioBuffer);
+        return audioBuffer;
+      });
+    }
+    return new Promise((resolve, reject) => {
+      const complete = async () => {
+        try {
+          await detachArrayBuffer(audioData);
+        } catch {
+        }
+      };
+      const fail = (err) => {
+        reject(err);
+        complete();
+      };
+      try {
+        nativeContext.decodeAudioData(audioData, (audioBuffer) => {
+          if (typeof audioBuffer.copyFromChannel !== "function") {
+            wrapAudioBufferCopyChannelMethods(audioBuffer);
+            wrapAudioBufferGetChannelDataMethod(audioBuffer);
+          }
+          audioBufferStore.add(audioBuffer);
+          complete().then(() => resolve(audioBuffer));
+        }, (err) => {
+          if (err === null) {
+            fail(createEncodingError());
+          } else {
+            fail(err);
+          }
+        });
+      } catch (err) {
+        fail(err);
+      }
+    });
+  };
+};
+export {
+  createDecodeAudioData
+};

package/dist/node_modules/standardized-audio-context/build/es2019/factories/decrement-cycle-counter.cjs

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const audioNodeOutputConnection = require("../guards/audio-node-output-connection.cjs");
+const createDecrementCycleCounter = (connectNativeAudioNodeToNativeAudioNode, cycleCounters, getAudioNodeConnections, getNativeAudioNode, getNativeAudioParam, getNativeContext, isActiveAudioNode, isNativeOfflineAudioContext) => {
+  return (audioNode, count) => {
+    const cycleCounter = cycleCounters.get(audioNode);
+    if (cycleCounter === void 0) {
+      throw new Error("Missing the expected cycle count.");
+    }
+    const nativeContext = getNativeContext(audioNode.context);
+    const isOffline = isNativeOfflineAudioContext(nativeContext);
+    if (cycleCounter === count) {
+      cycleCounters.delete(audioNode);
+      if (!isOffline && isActiveAudioNode(audioNode)) {
+        const nativeSourceAudioNode = getNativeAudioNode(audioNode);
+        const { outputs } = getAudioNodeConnections(audioNode);
+        for (const output of outputs) {
+          if (audioNodeOutputConnection.isAudioNodeOutputConnection(output)) {
+            const nativeDestinationAudioNode = getNativeAudioNode(output[0]);
+            connectNativeAudioNodeToNativeAudioNode(nativeSourceAudioNode, nativeDestinationAudioNode, output[1], output[2]);
+          } else {
+            const nativeDestinationAudioParam = getNativeAudioParam(output[0]);
+            nativeSourceAudioNode.connect(nativeDestinationAudioParam, output[1]);
+          }
+        }
+      }
+    } else {
+      cycleCounters.set(audioNode, cycleCounter - count);
+    }
+  };
+};
+exports.createDecrementCycleCounter = createDecrementCycleCounter;

package/dist/node_modules/standardized-audio-context/build/es2019/factories/decrement-cycle-counter.js

@@ -0,0 +1,32 @@
+import { isAudioNodeOutputConnection } from "../guards/audio-node-output-connection.js";
+const createDecrementCycleCounter = (connectNativeAudioNodeToNativeAudioNode, cycleCounters, getAudioNodeConnections, getNativeAudioNode, getNativeAudioParam, getNativeContext, isActiveAudioNode, isNativeOfflineAudioContext) => {
+  return (audioNode, count) => {
+    const cycleCounter = cycleCounters.get(audioNode);
+    if (cycleCounter === void 0) {
+      throw new Error("Missing the expected cycle count.");
+    }
+    const nativeContext = getNativeContext(audioNode.context);
+    const isOffline = isNativeOfflineAudioContext(nativeContext);
+    if (cycleCounter === count) {
+      cycleCounters.delete(audioNode);
+      if (!isOffline && isActiveAudioNode(audioNode)) {
+        const nativeSourceAudioNode = getNativeAudioNode(audioNode);
+        const { outputs } = getAudioNodeConnections(audioNode);
+        for (const output of outputs) {
+          if (isAudioNodeOutputConnection(output)) {
+            const nativeDestinationAudioNode = getNativeAudioNode(output[0]);
+            connectNativeAudioNodeToNativeAudioNode(nativeSourceAudioNode, nativeDestinationAudioNode, output[1], output[2]);
+          } else {
+            const nativeDestinationAudioParam = getNativeAudioParam(output[0]);
+            nativeSourceAudioNode.connect(nativeDestinationAudioParam, output[1]);
+          }
+        }
+      }
+    } else {
+      cycleCounters.set(audioNode, cycleCounter - count);
+    }
+  };
+};
+export {
+  createDecrementCycleCounter
+};

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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const DEFAULT_OPTIONS = {
+  channelCount: 2,
+  channelCountMode: "max",
+  channelInterpretation: "speakers",
+  delayTime: 0,
+  maxDelayTime: 1
+};
+const createDelayNodeConstructor = (audioNodeConstructor, createAudioParam, createDelayNodeRenderer, createNativeDelayNode, getNativeContext, isNativeOfflineAudioContext, setAudioNodeTailTime) => {
+  return class DelayNode extends audioNodeConstructor {
+    constructor(context, options) {
+      const nativeContext = getNativeContext(context);
+      const mergedOptions = { ...DEFAULT_OPTIONS, ...options };
+      const nativeDelayNode = createNativeDelayNode(nativeContext, mergedOptions);
+      const isOffline = isNativeOfflineAudioContext(nativeContext);
+      const delayNodeRenderer = isOffline ? createDelayNodeRenderer(mergedOptions.maxDelayTime) : null;
+      super(context, false, nativeDelayNode, delayNodeRenderer);
+      this._delayTime = createAudioParam(this, isOffline, nativeDelayNode.delayTime);
+      setAudioNodeTailTime(this, mergedOptions.maxDelayTime);
+    }
+    get delayTime() {
+      return this._delayTime;
+    }
+  };
+};
+exports.createDelayNodeConstructor = createDelayNodeConstructor;

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

@@ -0,0 +1,27 @@
+const DEFAULT_OPTIONS = {
+  channelCount: 2,
+  channelCountMode: "max",
+  channelInterpretation: "speakers",
+  delayTime: 0,
+  maxDelayTime: 1
+};
+const createDelayNodeConstructor = (audioNodeConstructor, createAudioParam, createDelayNodeRenderer, createNativeDelayNode, getNativeContext, isNativeOfflineAudioContext, setAudioNodeTailTime) => {
+  return class DelayNode extends audioNodeConstructor {
+    constructor(context, options) {
+      const nativeContext = getNativeContext(context);
+      const mergedOptions = { ...DEFAULT_OPTIONS, ...options };
+      const nativeDelayNode = createNativeDelayNode(nativeContext, mergedOptions);
+      const isOffline = isNativeOfflineAudioContext(nativeContext);
+      const delayNodeRenderer = isOffline ? createDelayNodeRenderer(mergedOptions.maxDelayTime) : null;
+      super(context, false, nativeDelayNode, delayNodeRenderer);
+      this._delayTime = createAudioParam(this, isOffline, nativeDelayNode.delayTime);
+      setAudioNodeTailTime(this, mergedOptions.maxDelayTime);
+    }
+    get delayTime() {
+      return this._delayTime;
+    }
+  };
+};
+export {
+  createDelayNodeConstructor
+};

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

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const isOwnedByContext = require("../helpers/is-owned-by-context.cjs");
+const createDelayNodeRendererFactory = (connectAudioParam, createNativeDelayNode, getNativeAudioNode, renderAutomation, renderInputsOfAudioNode) => {
+  return (maxDelayTime) => {
+    const renderedNativeDelayNodes = /* @__PURE__ */ new WeakMap();
+    const createDelayNode = async (proxy, nativeOfflineAudioContext) => {
+      let nativeDelayNode = getNativeAudioNode(proxy);
+      const nativeDelayNodeIsOwnedByContext = isOwnedByContext.isOwnedByContext(nativeDelayNode, nativeOfflineAudioContext);
+      if (!nativeDelayNodeIsOwnedByContext) {
+        const options = {
+          channelCount: nativeDelayNode.channelCount,
+          channelCountMode: nativeDelayNode.channelCountMode,
+          channelInterpretation: nativeDelayNode.channelInterpretation,
+          delayTime: nativeDelayNode.delayTime.value,
+          maxDelayTime
+        };
+        nativeDelayNode = createNativeDelayNode(nativeOfflineAudioContext, options);
+      }
+      renderedNativeDelayNodes.set(nativeOfflineAudioContext, nativeDelayNode);
+      if (!nativeDelayNodeIsOwnedByContext) {
+        await renderAutomation(nativeOfflineAudioContext, proxy.delayTime, nativeDelayNode.delayTime);
+      } else {
+        await connectAudioParam(nativeOfflineAudioContext, proxy.delayTime, nativeDelayNode.delayTime);
+      }
+      await renderInputsOfAudioNode(proxy, nativeOfflineAudioContext, nativeDelayNode);
+      return nativeDelayNode;
+    };
+    return {
+      render(proxy, nativeOfflineAudioContext) {
+        const renderedNativeDelayNode = renderedNativeDelayNodes.get(nativeOfflineAudioContext);
+        if (renderedNativeDelayNode !== void 0) {
+          return Promise.resolve(renderedNativeDelayNode);
+        }
+        return createDelayNode(proxy, nativeOfflineAudioContext);
+      }
+    };
+  };
+};
+exports.createDelayNodeRendererFactory = createDelayNodeRendererFactory;

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

@@ -0,0 +1,40 @@
+import { isOwnedByContext } from "../helpers/is-owned-by-context.js";
+const createDelayNodeRendererFactory = (connectAudioParam, createNativeDelayNode, getNativeAudioNode, renderAutomation, renderInputsOfAudioNode) => {
+  return (maxDelayTime) => {
+    const renderedNativeDelayNodes = /* @__PURE__ */ new WeakMap();
+    const createDelayNode = async (proxy, nativeOfflineAudioContext) => {
+      let nativeDelayNode = getNativeAudioNode(proxy);
+      const nativeDelayNodeIsOwnedByContext = isOwnedByContext(nativeDelayNode, nativeOfflineAudioContext);
+      if (!nativeDelayNodeIsOwnedByContext) {
+        const options = {
+          channelCount: nativeDelayNode.channelCount,
+          channelCountMode: nativeDelayNode.channelCountMode,
+          channelInterpretation: nativeDelayNode.channelInterpretation,
+          delayTime: nativeDelayNode.delayTime.value,
+          maxDelayTime
+        };
+        nativeDelayNode = createNativeDelayNode(nativeOfflineAudioContext, options);
+      }
+      renderedNativeDelayNodes.set(nativeOfflineAudioContext, nativeDelayNode);
+      if (!nativeDelayNodeIsOwnedByContext) {
+        await renderAutomation(nativeOfflineAudioContext, proxy.delayTime, nativeDelayNode.delayTime);
+      } else {
+        await connectAudioParam(nativeOfflineAudioContext, proxy.delayTime, nativeDelayNode.delayTime);
+      }
+      await renderInputsOfAudioNode(proxy, nativeOfflineAudioContext, nativeDelayNode);
+      return nativeDelayNode;
+    };
+    return {
+      render(proxy, nativeOfflineAudioContext) {
+        const renderedNativeDelayNode = renderedNativeDelayNodes.get(nativeOfflineAudioContext);
+        if (renderedNativeDelayNode !== void 0) {
+          return Promise.resolve(renderedNativeDelayNode);
+        }
+        return createDelayNode(proxy, nativeOfflineAudioContext);
+      }
+    };
+  };
+};
+export {
+  createDelayNodeRendererFactory
+};

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

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

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

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