react-audio-wavekit 0.1.5 → 0.1.6

package/dist/node_modules/standardized-audio-context/build/es2019/factories/add-silent-connection.cjs

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const createAddSilentConnection = (createNativeGainNode) => {
+  return (nativeContext, nativeAudioScheduledSourceNode) => {
+    const nativeGainNode = createNativeGainNode(nativeContext, {
+      channelCount: 1,
+      channelCountMode: "explicit",
+      channelInterpretation: "discrete",
+      gain: 0
+    });
+    nativeAudioScheduledSourceNode.connect(nativeGainNode).connect(nativeContext.destination);
+    const disconnect = () => {
+      nativeAudioScheduledSourceNode.removeEventListener("ended", disconnect);
+      nativeAudioScheduledSourceNode.disconnect(nativeGainNode);
+      nativeGainNode.disconnect();
+    };
+    nativeAudioScheduledSourceNode.addEventListener("ended", disconnect);
+  };
+};
+exports.createAddSilentConnection = createAddSilentConnection;

package/dist/node_modules/standardized-audio-context/build/es2019/factories/add-silent-connection.js

@@ -0,0 +1,20 @@
+const createAddSilentConnection = (createNativeGainNode) => {
+  return (nativeContext, nativeAudioScheduledSourceNode) => {
+    const nativeGainNode = createNativeGainNode(nativeContext, {
+      channelCount: 1,
+      channelCountMode: "explicit",
+      channelInterpretation: "discrete",
+      gain: 0
+    });
+    nativeAudioScheduledSourceNode.connect(nativeGainNode).connect(nativeContext.destination);
+    const disconnect = () => {
+      nativeAudioScheduledSourceNode.removeEventListener("ended", disconnect);
+      nativeAudioScheduledSourceNode.disconnect(nativeGainNode);
+      nativeGainNode.disconnect();
+    };
+    nativeAudioScheduledSourceNode.addEventListener("ended", disconnect);
+  };
+};
+export {
+  createAddSilentConnection
+};

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

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const DEFAULT_OPTIONS = {
+  channelCount: 2,
+  channelCountMode: "max",
+  channelInterpretation: "speakers",
+  fftSize: 2048,
+  maxDecibels: -30,
+  minDecibels: -100,
+  smoothingTimeConstant: 0.8
+};
+const createAnalyserNodeConstructor = (audionNodeConstructor, createAnalyserNodeRenderer, createIndexSizeError, createNativeAnalyserNode, getNativeContext, isNativeOfflineAudioContext) => {
+  return class AnalyserNode extends audionNodeConstructor {
+    constructor(context, options) {
+      const nativeContext = getNativeContext(context);
+      const mergedOptions = { ...DEFAULT_OPTIONS, ...options };
+      const nativeAnalyserNode = createNativeAnalyserNode(nativeContext, mergedOptions);
+      const analyserNodeRenderer = isNativeOfflineAudioContext(nativeContext) ? createAnalyserNodeRenderer() : null;
+      super(context, false, nativeAnalyserNode, analyserNodeRenderer);
+      this._nativeAnalyserNode = nativeAnalyserNode;
+    }
+    get fftSize() {
+      return this._nativeAnalyserNode.fftSize;
+    }
+    set fftSize(value) {
+      this._nativeAnalyserNode.fftSize = value;
+    }
+    get frequencyBinCount() {
+      return this._nativeAnalyserNode.frequencyBinCount;
+    }
+    get maxDecibels() {
+      return this._nativeAnalyserNode.maxDecibels;
+    }
+    set maxDecibels(value) {
+      const maxDecibels = this._nativeAnalyserNode.maxDecibels;
+      this._nativeAnalyserNode.maxDecibels = value;
+      if (!(value > this._nativeAnalyserNode.minDecibels)) {
+        this._nativeAnalyserNode.maxDecibels = maxDecibels;
+        throw createIndexSizeError();
+      }
+    }
+    get minDecibels() {
+      return this._nativeAnalyserNode.minDecibels;
+    }
+    set minDecibels(value) {
+      const minDecibels = this._nativeAnalyserNode.minDecibels;
+      this._nativeAnalyserNode.minDecibels = value;
+      if (!(this._nativeAnalyserNode.maxDecibels > value)) {
+        this._nativeAnalyserNode.minDecibels = minDecibels;
+        throw createIndexSizeError();
+      }
+    }
+    get smoothingTimeConstant() {
+      return this._nativeAnalyserNode.smoothingTimeConstant;
+    }
+    set smoothingTimeConstant(value) {
+      this._nativeAnalyserNode.smoothingTimeConstant = value;
+    }
+    getByteFrequencyData(array) {
+      this._nativeAnalyserNode.getByteFrequencyData(array);
+    }
+    getByteTimeDomainData(array) {
+      this._nativeAnalyserNode.getByteTimeDomainData(array);
+    }
+    getFloatFrequencyData(array) {
+      this._nativeAnalyserNode.getFloatFrequencyData(array);
+    }
+    getFloatTimeDomainData(array) {
+      this._nativeAnalyserNode.getFloatTimeDomainData(array);
+    }
+  };
+};
+exports.createAnalyserNodeConstructor = createAnalyserNodeConstructor;

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

@@ -0,0 +1,73 @@
+const DEFAULT_OPTIONS = {
+  channelCount: 2,
+  channelCountMode: "max",
+  channelInterpretation: "speakers",
+  fftSize: 2048,
+  maxDecibels: -30,
+  minDecibels: -100,
+  smoothingTimeConstant: 0.8
+};
+const createAnalyserNodeConstructor = (audionNodeConstructor, createAnalyserNodeRenderer, createIndexSizeError, createNativeAnalyserNode, getNativeContext, isNativeOfflineAudioContext) => {
+  return class AnalyserNode extends audionNodeConstructor {
+    constructor(context, options) {
+      const nativeContext = getNativeContext(context);
+      const mergedOptions = { ...DEFAULT_OPTIONS, ...options };
+      const nativeAnalyserNode = createNativeAnalyserNode(nativeContext, mergedOptions);
+      const analyserNodeRenderer = isNativeOfflineAudioContext(nativeContext) ? createAnalyserNodeRenderer() : null;
+      super(context, false, nativeAnalyserNode, analyserNodeRenderer);
+      this._nativeAnalyserNode = nativeAnalyserNode;
+    }
+    get fftSize() {
+      return this._nativeAnalyserNode.fftSize;
+    }
+    set fftSize(value) {
+      this._nativeAnalyserNode.fftSize = value;
+    }
+    get frequencyBinCount() {
+      return this._nativeAnalyserNode.frequencyBinCount;
+    }
+    get maxDecibels() {
+      return this._nativeAnalyserNode.maxDecibels;
+    }
+    set maxDecibels(value) {
+      const maxDecibels = this._nativeAnalyserNode.maxDecibels;
+      this._nativeAnalyserNode.maxDecibels = value;
+      if (!(value > this._nativeAnalyserNode.minDecibels)) {
+        this._nativeAnalyserNode.maxDecibels = maxDecibels;
+        throw createIndexSizeError();
+      }
+    }
+    get minDecibels() {
+      return this._nativeAnalyserNode.minDecibels;
+    }
+    set minDecibels(value) {
+      const minDecibels = this._nativeAnalyserNode.minDecibels;
+      this._nativeAnalyserNode.minDecibels = value;
+      if (!(this._nativeAnalyserNode.maxDecibels > value)) {
+        this._nativeAnalyserNode.minDecibels = minDecibels;
+        throw createIndexSizeError();
+      }
+    }
+    get smoothingTimeConstant() {
+      return this._nativeAnalyserNode.smoothingTimeConstant;
+    }
+    set smoothingTimeConstant(value) {
+      this._nativeAnalyserNode.smoothingTimeConstant = value;
+    }
+    getByteFrequencyData(array) {
+      this._nativeAnalyserNode.getByteFrequencyData(array);
+    }
+    getByteTimeDomainData(array) {
+      this._nativeAnalyserNode.getByteTimeDomainData(array);
+    }
+    getFloatFrequencyData(array) {
+      this._nativeAnalyserNode.getFloatFrequencyData(array);
+    }
+    getFloatTimeDomainData(array) {
+      this._nativeAnalyserNode.getFloatTimeDomainData(array);
+    }
+  };
+};
+export {
+  createAnalyserNodeConstructor
+};

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

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const isOwnedByContext = require("../helpers/is-owned-by-context.cjs");
+const createAnalyserNodeRendererFactory = (createNativeAnalyserNode, getNativeAudioNode, renderInputsOfAudioNode) => {
+  return () => {
+    const renderedNativeAnalyserNodes = /* @__PURE__ */ new WeakMap();
+    const createAnalyserNode = async (proxy, nativeOfflineAudioContext) => {
+      let nativeAnalyserNode = getNativeAudioNode(proxy);
+      const nativeAnalyserNodeIsOwnedByContext = isOwnedByContext.isOwnedByContext(nativeAnalyserNode, nativeOfflineAudioContext);
+      if (!nativeAnalyserNodeIsOwnedByContext) {
+        const options = {
+          channelCount: nativeAnalyserNode.channelCount,
+          channelCountMode: nativeAnalyserNode.channelCountMode,
+          channelInterpretation: nativeAnalyserNode.channelInterpretation,
+          fftSize: nativeAnalyserNode.fftSize,
+          maxDecibels: nativeAnalyserNode.maxDecibels,
+          minDecibels: nativeAnalyserNode.minDecibels,
+          smoothingTimeConstant: nativeAnalyserNode.smoothingTimeConstant
+        };
+        nativeAnalyserNode = createNativeAnalyserNode(nativeOfflineAudioContext, options);
+      }
+      renderedNativeAnalyserNodes.set(nativeOfflineAudioContext, nativeAnalyserNode);
+      await renderInputsOfAudioNode(proxy, nativeOfflineAudioContext, nativeAnalyserNode);
+      return nativeAnalyserNode;
+    };
+    return {
+      render(proxy, nativeOfflineAudioContext) {
+        const renderedNativeAnalyserNode = renderedNativeAnalyserNodes.get(nativeOfflineAudioContext);
+        if (renderedNativeAnalyserNode !== void 0) {
+          return Promise.resolve(renderedNativeAnalyserNode);
+        }
+        return createAnalyserNode(proxy, nativeOfflineAudioContext);
+      }
+    };
+  };
+};
+exports.createAnalyserNodeRendererFactory = createAnalyserNodeRendererFactory;

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

@@ -0,0 +1,37 @@
+import { isOwnedByContext } from "../helpers/is-owned-by-context.js";
+const createAnalyserNodeRendererFactory = (createNativeAnalyserNode, getNativeAudioNode, renderInputsOfAudioNode) => {
+  return () => {
+    const renderedNativeAnalyserNodes = /* @__PURE__ */ new WeakMap();
+    const createAnalyserNode = async (proxy, nativeOfflineAudioContext) => {
+      let nativeAnalyserNode = getNativeAudioNode(proxy);
+      const nativeAnalyserNodeIsOwnedByContext = isOwnedByContext(nativeAnalyserNode, nativeOfflineAudioContext);
+      if (!nativeAnalyserNodeIsOwnedByContext) {
+        const options = {
+          channelCount: nativeAnalyserNode.channelCount,
+          channelCountMode: nativeAnalyserNode.channelCountMode,
+          channelInterpretation: nativeAnalyserNode.channelInterpretation,
+          fftSize: nativeAnalyserNode.fftSize,
+          maxDecibels: nativeAnalyserNode.maxDecibels,
+          minDecibels: nativeAnalyserNode.minDecibels,
+          smoothingTimeConstant: nativeAnalyserNode.smoothingTimeConstant
+        };
+        nativeAnalyserNode = createNativeAnalyserNode(nativeOfflineAudioContext, options);
+      }
+      renderedNativeAnalyserNodes.set(nativeOfflineAudioContext, nativeAnalyserNode);
+      await renderInputsOfAudioNode(proxy, nativeOfflineAudioContext, nativeAnalyserNode);
+      return nativeAnalyserNode;
+    };
+    return {
+      render(proxy, nativeOfflineAudioContext) {
+        const renderedNativeAnalyserNode = renderedNativeAnalyserNodes.get(nativeOfflineAudioContext);
+        if (renderedNativeAnalyserNode !== void 0) {
+          return Promise.resolve(renderedNativeAnalyserNode);
+        }
+        return createAnalyserNode(proxy, nativeOfflineAudioContext);
+      }
+    };
+  };
+};
+export {
+  createAnalyserNodeRendererFactory
+};

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

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const testAudioBufferCopyChannelMethodsOutOfBoundsSupport = require("../helpers/test-audio-buffer-copy-channel-methods-out-of-bounds-support.cjs");
+const wrapAudioBufferGetChannelDataMethod = require("../helpers/wrap-audio-buffer-get-channel-data-method.cjs");
+const DEFAULT_OPTIONS = {
+  numberOfChannels: 1
+};
+const createAudioBufferConstructor = (audioBufferStore, cacheTestResult, createNotSupportedError, nativeAudioBufferConstructor, nativeOfflineAudioContextConstructor, testNativeAudioBufferConstructorSupport, wrapAudioBufferCopyChannelMethods, wrapAudioBufferCopyChannelMethodsOutOfBounds) => {
+  let nativeOfflineAudioContext = null;
+  return class AudioBuffer {
+    constructor(options) {
+      if (nativeOfflineAudioContextConstructor === null) {
+        throw new Error("Missing the native OfflineAudioContext constructor.");
+      }
+      const { length, numberOfChannels, sampleRate } = { ...DEFAULT_OPTIONS, ...options };
+      if (nativeOfflineAudioContext === null) {
+        nativeOfflineAudioContext = new nativeOfflineAudioContextConstructor(1, 1, 44100);
+      }
+      const audioBuffer = nativeAudioBufferConstructor !== null && cacheTestResult(testNativeAudioBufferConstructorSupport, testNativeAudioBufferConstructorSupport) ? new nativeAudioBufferConstructor({ length, numberOfChannels, sampleRate }) : nativeOfflineAudioContext.createBuffer(numberOfChannels, length, sampleRate);
+      if (audioBuffer.numberOfChannels === 0) {
+        throw createNotSupportedError();
+      }
+      if (typeof audioBuffer.copyFromChannel !== "function") {
+        wrapAudioBufferCopyChannelMethods(audioBuffer);
+        wrapAudioBufferGetChannelDataMethod.wrapAudioBufferGetChannelDataMethod(audioBuffer);
+      } else if (!cacheTestResult(testAudioBufferCopyChannelMethodsOutOfBoundsSupport.testAudioBufferCopyChannelMethodsOutOfBoundsSupport, () => testAudioBufferCopyChannelMethodsOutOfBoundsSupport.testAudioBufferCopyChannelMethodsOutOfBoundsSupport(audioBuffer))) {
+        wrapAudioBufferCopyChannelMethodsOutOfBounds(audioBuffer);
+      }
+      audioBufferStore.add(audioBuffer);
+      return audioBuffer;
+    }
+    static [Symbol.hasInstance](instance) {
+      return instance !== null && typeof instance === "object" && Object.getPrototypeOf(instance) === AudioBuffer.prototype || audioBufferStore.has(instance);
+    }
+  };
+};
+exports.createAudioBufferConstructor = createAudioBufferConstructor;

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

@@ -0,0 +1,37 @@
+import { testAudioBufferCopyChannelMethodsOutOfBoundsSupport } from "../helpers/test-audio-buffer-copy-channel-methods-out-of-bounds-support.js";
+import { wrapAudioBufferGetChannelDataMethod } from "../helpers/wrap-audio-buffer-get-channel-data-method.js";
+const DEFAULT_OPTIONS = {
+  numberOfChannels: 1
+};
+const createAudioBufferConstructor = (audioBufferStore, cacheTestResult, createNotSupportedError, nativeAudioBufferConstructor, nativeOfflineAudioContextConstructor, testNativeAudioBufferConstructorSupport, wrapAudioBufferCopyChannelMethods, wrapAudioBufferCopyChannelMethodsOutOfBounds) => {
+  let nativeOfflineAudioContext = null;
+  return class AudioBuffer {
+    constructor(options) {
+      if (nativeOfflineAudioContextConstructor === null) {
+        throw new Error("Missing the native OfflineAudioContext constructor.");
+      }
+      const { length, numberOfChannels, sampleRate } = { ...DEFAULT_OPTIONS, ...options };
+      if (nativeOfflineAudioContext === null) {
+        nativeOfflineAudioContext = new nativeOfflineAudioContextConstructor(1, 1, 44100);
+      }
+      const audioBuffer = nativeAudioBufferConstructor !== null && cacheTestResult(testNativeAudioBufferConstructorSupport, testNativeAudioBufferConstructorSupport) ? new nativeAudioBufferConstructor({ length, numberOfChannels, sampleRate }) : nativeOfflineAudioContext.createBuffer(numberOfChannels, length, sampleRate);
+      if (audioBuffer.numberOfChannels === 0) {
+        throw createNotSupportedError();
+      }
+      if (typeof audioBuffer.copyFromChannel !== "function") {
+        wrapAudioBufferCopyChannelMethods(audioBuffer);
+        wrapAudioBufferGetChannelDataMethod(audioBuffer);
+      } else if (!cacheTestResult(testAudioBufferCopyChannelMethodsOutOfBoundsSupport, () => testAudioBufferCopyChannelMethodsOutOfBoundsSupport(audioBuffer))) {
+        wrapAudioBufferCopyChannelMethodsOutOfBounds(audioBuffer);
+      }
+      audioBufferStore.add(audioBuffer);
+      return audioBuffer;
+    }
+    static [Symbol.hasInstance](instance) {
+      return instance !== null && typeof instance === "object" && Object.getPrototypeOf(instance) === AudioBuffer.prototype || audioBufferStore.has(instance);
+    }
+  };
+};
+export {
+  createAudioBufferConstructor
+};

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

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const constants = require("../constants.cjs");
+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 = {
+  buffer: null,
+  channelCount: 2,
+  channelCountMode: "max",
+  channelInterpretation: "speakers",
+  // Bug #149: Safari does not yet support the detune AudioParam.
+  loop: false,
+  loopEnd: 0,
+  loopStart: 0,
+  playbackRate: 1
+};
+const createAudioBufferSourceNodeConstructor = (audioNodeConstructor, createAudioBufferSourceNodeRenderer, createAudioParam, createInvalidStateError, createNativeAudioBufferSourceNode, getNativeContext, isNativeOfflineAudioContext, wrapEventListener) => {
+  return class AudioBufferSourceNode extends audioNodeConstructor {
+    constructor(context, options) {
+      const nativeContext = getNativeContext(context);
+      const mergedOptions = { ...DEFAULT_OPTIONS, ...options };
+      const nativeAudioBufferSourceNode = createNativeAudioBufferSourceNode(nativeContext, mergedOptions);
+      const isOffline = isNativeOfflineAudioContext(nativeContext);
+      const audioBufferSourceNodeRenderer = isOffline ? createAudioBufferSourceNodeRenderer() : null;
+      super(context, false, nativeAudioBufferSourceNode, audioBufferSourceNodeRenderer);
+      this._audioBufferSourceNodeRenderer = audioBufferSourceNodeRenderer;
+      this._isBufferNullified = false;
+      this._isBufferSet = mergedOptions.buffer !== null;
+      this._nativeAudioBufferSourceNode = nativeAudioBufferSourceNode;
+      this._onended = null;
+      this._playbackRate = createAudioParam(this, isOffline, nativeAudioBufferSourceNode.playbackRate, constants.MOST_POSITIVE_SINGLE_FLOAT, constants.MOST_NEGATIVE_SINGLE_FLOAT);
+    }
+    get buffer() {
+      if (this._isBufferNullified) {
+        return null;
+      }
+      return this._nativeAudioBufferSourceNode.buffer;
+    }
+    set buffer(value) {
+      this._nativeAudioBufferSourceNode.buffer = value;
+      if (value !== null) {
+        if (this._isBufferSet) {
+          throw createInvalidStateError();
+        }
+        this._isBufferSet = true;
+      }
+    }
+    get loop() {
+      return this._nativeAudioBufferSourceNode.loop;
+    }
+    set loop(value) {
+      this._nativeAudioBufferSourceNode.loop = value;
+    }
+    get loopEnd() {
+      return this._nativeAudioBufferSourceNode.loopEnd;
+    }
+    set loopEnd(value) {
+      this._nativeAudioBufferSourceNode.loopEnd = value;
+    }
+    get loopStart() {
+      return this._nativeAudioBufferSourceNode.loopStart;
+    }
+    set loopStart(value) {
+      this._nativeAudioBufferSourceNode.loopStart = value;
+    }
+    get onended() {
+      return this._onended;
+    }
+    set onended(value) {
+      const wrappedListener = typeof value === "function" ? wrapEventListener(this, value) : null;
+      this._nativeAudioBufferSourceNode.onended = wrappedListener;
+      const nativeOnEnded = this._nativeAudioBufferSourceNode.onended;
+      this._onended = nativeOnEnded !== null && nativeOnEnded === wrappedListener ? value : nativeOnEnded;
+    }
+    get playbackRate() {
+      return this._playbackRate;
+    }
+    start(when = 0, offset = 0, duration) {
+      this._nativeAudioBufferSourceNode.start(when, offset, duration);
+      if (this._audioBufferSourceNodeRenderer !== null) {
+        this._audioBufferSourceNodeRenderer.start = duration === void 0 ? [when, offset] : [when, offset, duration];
+      }
+      if (this.context.state !== "closed") {
+        setInternalStateToActive.setInternalStateToActive(this);
+        const resetInternalStateToPassive = () => {
+          this._nativeAudioBufferSourceNode.removeEventListener("ended", resetInternalStateToPassive);
+          if (isActiveAudioNode.isActiveAudioNode(this)) {
+            setInternalStateToPassive.setInternalStateToPassive(this);
+          }
+        };
+        this._nativeAudioBufferSourceNode.addEventListener("ended", resetInternalStateToPassive);
+      }
+    }
+    stop(when = 0) {
+      this._nativeAudioBufferSourceNode.stop(when);
+      if (this._audioBufferSourceNodeRenderer !== null) {
+        this._audioBufferSourceNodeRenderer.stop = when;
+      }
+    }
+  };
+};
+exports.createAudioBufferSourceNodeConstructor = createAudioBufferSourceNodeConstructor;

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

@@ -0,0 +1,103 @@
+import { MOST_POSITIVE_SINGLE_FLOAT, MOST_NEGATIVE_SINGLE_FLOAT } from "../constants.js";
+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 = {
+  buffer: null,
+  channelCount: 2,
+  channelCountMode: "max",
+  channelInterpretation: "speakers",
+  // Bug #149: Safari does not yet support the detune AudioParam.
+  loop: false,
+  loopEnd: 0,
+  loopStart: 0,
+  playbackRate: 1
+};
+const createAudioBufferSourceNodeConstructor = (audioNodeConstructor, createAudioBufferSourceNodeRenderer, createAudioParam, createInvalidStateError, createNativeAudioBufferSourceNode, getNativeContext, isNativeOfflineAudioContext, wrapEventListener) => {
+  return class AudioBufferSourceNode extends audioNodeConstructor {
+    constructor(context, options) {
+      const nativeContext = getNativeContext(context);
+      const mergedOptions = { ...DEFAULT_OPTIONS, ...options };
+      const nativeAudioBufferSourceNode = createNativeAudioBufferSourceNode(nativeContext, mergedOptions);
+      const isOffline = isNativeOfflineAudioContext(nativeContext);
+      const audioBufferSourceNodeRenderer = isOffline ? createAudioBufferSourceNodeRenderer() : null;
+      super(context, false, nativeAudioBufferSourceNode, audioBufferSourceNodeRenderer);
+      this._audioBufferSourceNodeRenderer = audioBufferSourceNodeRenderer;
+      this._isBufferNullified = false;
+      this._isBufferSet = mergedOptions.buffer !== null;
+      this._nativeAudioBufferSourceNode = nativeAudioBufferSourceNode;
+      this._onended = null;
+      this._playbackRate = createAudioParam(this, isOffline, nativeAudioBufferSourceNode.playbackRate, MOST_POSITIVE_SINGLE_FLOAT, MOST_NEGATIVE_SINGLE_FLOAT);
+    }
+    get buffer() {
+      if (this._isBufferNullified) {
+        return null;
+      }
+      return this._nativeAudioBufferSourceNode.buffer;
+    }
+    set buffer(value) {
+      this._nativeAudioBufferSourceNode.buffer = value;
+      if (value !== null) {
+        if (this._isBufferSet) {
+          throw createInvalidStateError();
+        }
+        this._isBufferSet = true;
+      }
+    }
+    get loop() {
+      return this._nativeAudioBufferSourceNode.loop;
+    }
+    set loop(value) {
+      this._nativeAudioBufferSourceNode.loop = value;
+    }
+    get loopEnd() {
+      return this._nativeAudioBufferSourceNode.loopEnd;
+    }
+    set loopEnd(value) {
+      this._nativeAudioBufferSourceNode.loopEnd = value;
+    }
+    get loopStart() {
+      return this._nativeAudioBufferSourceNode.loopStart;
+    }
+    set loopStart(value) {
+      this._nativeAudioBufferSourceNode.loopStart = value;
+    }
+    get onended() {
+      return this._onended;
+    }
+    set onended(value) {
+      const wrappedListener = typeof value === "function" ? wrapEventListener(this, value) : null;
+      this._nativeAudioBufferSourceNode.onended = wrappedListener;
+      const nativeOnEnded = this._nativeAudioBufferSourceNode.onended;
+      this._onended = nativeOnEnded !== null && nativeOnEnded === wrappedListener ? value : nativeOnEnded;
+    }
+    get playbackRate() {
+      return this._playbackRate;
+    }
+    start(when = 0, offset = 0, duration) {
+      this._nativeAudioBufferSourceNode.start(when, offset, duration);
+      if (this._audioBufferSourceNodeRenderer !== null) {
+        this._audioBufferSourceNodeRenderer.start = duration === void 0 ? [when, offset] : [when, offset, duration];
+      }
+      if (this.context.state !== "closed") {
+        setInternalStateToActive(this);
+        const resetInternalStateToPassive = () => {
+          this._nativeAudioBufferSourceNode.removeEventListener("ended", resetInternalStateToPassive);
+          if (isActiveAudioNode(this)) {
+            setInternalStateToPassive(this);
+          }
+        };
+        this._nativeAudioBufferSourceNode.addEventListener("ended", resetInternalStateToPassive);
+      }
+    }
+    stop(when = 0) {
+      this._nativeAudioBufferSourceNode.stop(when);
+      if (this._audioBufferSourceNodeRenderer !== null) {
+        this._audioBufferSourceNodeRenderer.stop = when;
+      }
+    }
+  };
+};
+export {
+  createAudioBufferSourceNodeConstructor
+};

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

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const isOwnedByContext = require("../helpers/is-owned-by-context.cjs");
+const createAudioBufferSourceNodeRendererFactory = (connectAudioParam, createNativeAudioBufferSourceNode, getNativeAudioNode, renderAutomation, renderInputsOfAudioNode) => {
+  return () => {
+    const renderedNativeAudioBufferSourceNodes = /* @__PURE__ */ new WeakMap();
+    let start = null;
+    let stop = null;
+    const createAudioBufferSourceNode = async (proxy, nativeOfflineAudioContext) => {
+      let nativeAudioBufferSourceNode = getNativeAudioNode(proxy);
+      const nativeAudioBufferSourceNodeIsOwnedByContext = isOwnedByContext.isOwnedByContext(nativeAudioBufferSourceNode, nativeOfflineAudioContext);
+      if (!nativeAudioBufferSourceNodeIsOwnedByContext) {
+        const options = {
+          buffer: nativeAudioBufferSourceNode.buffer,
+          channelCount: nativeAudioBufferSourceNode.channelCount,
+          channelCountMode: nativeAudioBufferSourceNode.channelCountMode,
+          channelInterpretation: nativeAudioBufferSourceNode.channelInterpretation,
+          // Bug #149: Safari does not yet support the detune AudioParam.
+          loop: nativeAudioBufferSourceNode.loop,
+          loopEnd: nativeAudioBufferSourceNode.loopEnd,
+          loopStart: nativeAudioBufferSourceNode.loopStart,
+          playbackRate: nativeAudioBufferSourceNode.playbackRate.value
+        };
+        nativeAudioBufferSourceNode = createNativeAudioBufferSourceNode(nativeOfflineAudioContext, options);
+        if (start !== null) {
+          nativeAudioBufferSourceNode.start(...start);
+        }
+        if (stop !== null) {
+          nativeAudioBufferSourceNode.stop(stop);
+        }
+      }
+      renderedNativeAudioBufferSourceNodes.set(nativeOfflineAudioContext, nativeAudioBufferSourceNode);
+      if (!nativeAudioBufferSourceNodeIsOwnedByContext) {
+        await renderAutomation(nativeOfflineAudioContext, proxy.playbackRate, nativeAudioBufferSourceNode.playbackRate);
+      } else {
+        await connectAudioParam(nativeOfflineAudioContext, proxy.playbackRate, nativeAudioBufferSourceNode.playbackRate);
+      }
+      await renderInputsOfAudioNode(proxy, nativeOfflineAudioContext, nativeAudioBufferSourceNode);
+      return nativeAudioBufferSourceNode;
+    };
+    return {
+      set start(value) {
+        start = value;
+      },
+      set stop(value) {
+        stop = value;
+      },
+      render(proxy, nativeOfflineAudioContext) {
+        const renderedNativeAudioBufferSourceNode = renderedNativeAudioBufferSourceNodes.get(nativeOfflineAudioContext);
+        if (renderedNativeAudioBufferSourceNode !== void 0) {
+          return Promise.resolve(renderedNativeAudioBufferSourceNode);
+        }
+        return createAudioBufferSourceNode(proxy, nativeOfflineAudioContext);
+      }
+    };
+  };
+};
+exports.createAudioBufferSourceNodeRendererFactory = createAudioBufferSourceNodeRendererFactory;

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

@@ -0,0 +1,58 @@
+import { isOwnedByContext } from "../helpers/is-owned-by-context.js";
+const createAudioBufferSourceNodeRendererFactory = (connectAudioParam, createNativeAudioBufferSourceNode, getNativeAudioNode, renderAutomation, renderInputsOfAudioNode) => {
+  return () => {
+    const renderedNativeAudioBufferSourceNodes = /* @__PURE__ */ new WeakMap();
+    let start = null;
+    let stop = null;
+    const createAudioBufferSourceNode = async (proxy, nativeOfflineAudioContext) => {
+      let nativeAudioBufferSourceNode = getNativeAudioNode(proxy);
+      const nativeAudioBufferSourceNodeIsOwnedByContext = isOwnedByContext(nativeAudioBufferSourceNode, nativeOfflineAudioContext);
+      if (!nativeAudioBufferSourceNodeIsOwnedByContext) {
+        const options = {
+          buffer: nativeAudioBufferSourceNode.buffer,
+          channelCount: nativeAudioBufferSourceNode.channelCount,
+          channelCountMode: nativeAudioBufferSourceNode.channelCountMode,
+          channelInterpretation: nativeAudioBufferSourceNode.channelInterpretation,
+          // Bug #149: Safari does not yet support the detune AudioParam.
+          loop: nativeAudioBufferSourceNode.loop,
+          loopEnd: nativeAudioBufferSourceNode.loopEnd,
+          loopStart: nativeAudioBufferSourceNode.loopStart,
+          playbackRate: nativeAudioBufferSourceNode.playbackRate.value
+        };
+        nativeAudioBufferSourceNode = createNativeAudioBufferSourceNode(nativeOfflineAudioContext, options);
+        if (start !== null) {
+          nativeAudioBufferSourceNode.start(...start);
+        }
+        if (stop !== null) {
+          nativeAudioBufferSourceNode.stop(stop);
+        }
+      }
+      renderedNativeAudioBufferSourceNodes.set(nativeOfflineAudioContext, nativeAudioBufferSourceNode);
+      if (!nativeAudioBufferSourceNodeIsOwnedByContext) {
+        await renderAutomation(nativeOfflineAudioContext, proxy.playbackRate, nativeAudioBufferSourceNode.playbackRate);
+      } else {
+        await connectAudioParam(nativeOfflineAudioContext, proxy.playbackRate, nativeAudioBufferSourceNode.playbackRate);
+      }
+      await renderInputsOfAudioNode(proxy, nativeOfflineAudioContext, nativeAudioBufferSourceNode);
+      return nativeAudioBufferSourceNode;
+    };
+    return {
+      set start(value) {
+        start = value;
+      },
+      set stop(value) {
+        stop = value;
+      },
+      render(proxy, nativeOfflineAudioContext) {
+        const renderedNativeAudioBufferSourceNode = renderedNativeAudioBufferSourceNodes.get(nativeOfflineAudioContext);
+        if (renderedNativeAudioBufferSourceNode !== void 0) {
+          return Promise.resolve(renderedNativeAudioBufferSourceNode);
+        }
+        return createAudioBufferSourceNode(proxy, nativeOfflineAudioContext);
+      }
+    };
+  };
+};
+export {
+  createAudioBufferSourceNodeRendererFactory
+};