react-audio-wavekit 0.1.4 → 0.1.6

package/dist/node_modules/standardized-audio-context/build/es2019/module.js

@@ -0,0 +1,298 @@
+import { createSetValueAutomationEvent } from "../../../automation-events/build/es2019/functions/create-set-value-automation-event.js";
+import { createSetValueCurveAutomationEvent } from "../../../automation-events/build/es2019/functions/create-set-value-curve-automation-event.js";
+import { createCancelAndHoldAutomationEvent } from "../../../automation-events/build/es2019/functions/create-cancel-and-hold-automation-event.js";
+import { createCancelScheduledValuesAutomationEvent } from "../../../automation-events/build/es2019/functions/create-cancel-scheduled-values-automation-event.js";
+import { createExponentialRampToValueAutomationEvent } from "../../../automation-events/build/es2019/functions/create-exponential-ramp-to-value-automation-event.js";
+import { createLinearRampToValueAutomationEvent } from "../../../automation-events/build/es2019/functions/create-linear-ramp-to-value-automation-event.js";
+import { createSetTargetAutomationEvent } from "../../../automation-events/build/es2019/functions/create-set-target-automation-event.js";
+import { createAbortError } from "./factories/abort-error.js";
+import { createAddActiveInputConnectionToAudioNode } from "./factories/add-active-input-connection-to-audio-node.js";
+import { createAddAudioNodeConnections } from "./factories/add-audio-node-connections.js";
+import { createAddAudioParamConnections } from "./factories/add-audio-param-connections.js";
+import { createAddAudioWorkletModule } from "./factories/add-audio-worklet-module.js";
+import { createAddConnectionToAudioNode } from "./factories/add-connection-to-audio-node.js";
+import { createAddPassiveInputConnectionToAudioNode } from "./factories/add-passive-input-connection-to-audio-node.js";
+import { createAddSilentConnection } from "./factories/add-silent-connection.js";
+import { createAnalyserNodeConstructor } from "./factories/analyser-node-constructor.js";
+import { createAnalyserNodeRendererFactory } from "./factories/analyser-node-renderer-factory.js";
+import { createAudioBufferConstructor } from "./factories/audio-buffer-constructor.js";
+import { createAudioBufferSourceNodeConstructor } from "./factories/audio-buffer-source-node-constructor.js";
+import { createAudioBufferSourceNodeRendererFactory } from "./factories/audio-buffer-source-node-renderer-factory.js";
+import { getAudioNodeConnections } from "./helpers/get-audio-node-connections.js";
+import { getAudioParamConnections } from "./helpers/get-audio-param-connections.js";
+import { isActiveAudioNode } from "./helpers/is-active-audio-node.js";
+import { CONTEXT_STORE, AUDIO_PARAM_STORE, CYCLE_COUNTERS, AUDIO_NODE_CONNECTIONS_STORE, AUDIO_PARAM_CONNECTIONS_STORE } from "./globals.js";
+import { getEventListenersOfAudioNode } from "./helpers/get-event-listeners-of-audio-node.js";
+import { createAudioDestinationNodeConstructor } from "./factories/audio-destination-node-constructor.js";
+import { createAudioDestinationNodeRenderer } from "./factories/audio-destination-node-renderer-factory.js";
+import { createAudioListenerFactory } from "./factories/audio-listener-factory.js";
+import { createAudioNodeConstructor } from "./factories/audio-node-constructor.js";
+import { createAudioParamFactory } from "./factories/audio-param-factory.js";
+import { createAudioParamRenderer } from "./factories/audio-param-renderer.js";
+import { getNativeAudioNode } from "./helpers/get-native-audio-node.js";
+import { getValueForKey } from "./helpers/get-value-for-key.js";
+import { createBaseAudioContextConstructor } from "./factories/base-audio-context-constructor.js";
+import { createBiquadFilterNodeConstructor } from "./factories/biquad-filter-node-constructor.js";
+import { createBiquadFilterNodeRendererFactory } from "./factories/biquad-filter-node-renderer-factory.js";
+import { createCacheTestResult } from "./factories/cache-test-result.js";
+import { createChannelMergerNodeConstructor } from "./factories/channel-merger-node-constructor.js";
+import { createChannelMergerNodeRendererFactory } from "./factories/channel-merger-node-renderer-factory.js";
+import { createChannelSplitterNodeConstructor } from "./factories/channel-splitter-node-constructor.js";
+import { createChannelSplitterNodeRendererFactory } from "./factories/channel-splitter-node-renderer-factory.js";
+import { createConnectAudioParam } from "./factories/connect-audio-param.js";
+import { createConnectedNativeAudioBufferSourceNodeFactory } from "./factories/connected-native-audio-buffer-source-node-factory.js";
+import { createConstantSourceNodeConstructor } from "./factories/constant-source-node-constructor.js";
+import { createConstantSourceNodeRendererFactory } from "./factories/constant-source-node-renderer-factory.js";
+import { createConvertNumberToUnsignedLong } from "./factories/convert-number-to-unsigned-long.js";
+import { createConvolverNodeConstructor } from "./factories/convolver-node-constructor.js";
+import { createConvolverNodeRendererFactory } from "./factories/convolver-node-renderer-factory.js";
+import { createCreateNativeOfflineAudioContext } from "./factories/create-native-offline-audio-context.js";
+import { createDataCloneError } from "./factories/data-clone-error.js";
+import { createDecodeAudioData } from "./factories/decode-audio-data.js";
+import { createDecrementCycleCounter } from "./factories/decrement-cycle-counter.js";
+import { createDelayNodeConstructor } from "./factories/delay-node-constructor.js";
+import { createDelayNodeRendererFactory } from "./factories/delay-node-renderer-factory.js";
+import { createDeleteActiveInputConnectionToAudioNode } from "./factories/delete-active-input-connection-to-audio-node.js";
+import { createDetectCycles } from "./factories/detect-cycles.js";
+import { createDynamicsCompressorNodeConstructor } from "./factories/dynamics-compressor-node-constructor.js";
+import { createDynamicsCompressorNodeRendererFactory } from "./factories/dynamics-compressor-node-renderer-factory.js";
+import { createEncodingError } from "./factories/encoding-error.js";
+import { createEvaluateSource } from "./factories/evaluate-source.js";
+import { createEventTargetConstructor } from "./factories/event-target-constructor.js";
+import { createExposeCurrentFrameAndCurrentTime } from "./factories/expose-current-frame-and-current-time.js";
+import { createFetchSource } from "./factories/fetch-source.js";
+import { createGainNodeConstructor } from "./factories/gain-node-constructor.js";
+import { createGainNodeRendererFactory } from "./factories/gain-node-renderer-factory.js";
+import { createGetAudioNodeRenderer } from "./factories/get-audio-node-renderer.js";
+import { createGetAudioNodeTailTime } from "./factories/get-audio-node-tail-time.js";
+import { createGetAudioParamRenderer } from "./factories/get-audio-param-renderer.js";
+import { createGetNativeContext } from "./factories/get-native-context.js";
+import { createGetOrCreateBackupOfflineAudioContext } from "./factories/get-or-create-backup-offline-audio-context.js";
+import { createGetUnrenderedAudioWorkletNodes } from "./factories/get-unrendered-audio-worklet-nodes.js";
+import { createIIRFilterNodeConstructor } from "./factories/iir-filter-node-constructor.js";
+import { createIIRFilterNodeRendererFactory } from "./factories/iir-filter-node-renderer-factory.js";
+import { createIncrementCycleCounterFactory } from "./factories/increment-cycle-counter-factory.js";
+import { createIndexSizeError } from "./factories/index-size-error.js";
+import { createInvalidAccessError } from "./factories/invalid-access-error.js";
+import { createInvalidStateError } from "./factories/invalid-state-error.js";
+import { createIsNativeAudioContext } from "./factories/is-native-audio-context.js";
+import { createIsNativeAudioNode } from "./factories/is-native-audio-node.js";
+import { createIsNativeAudioParam } from "./factories/is-native-audio-param.js";
+import { createIsNativeContext } from "./factories/is-native-context.js";
+import { createIsNativeOfflineAudioContext } from "./factories/is-native-offline-audio-context.js";
+import { createIsSecureContext } from "./factories/is-secure-context.js";
+import { createMinimalBaseAudioContextConstructor } from "./factories/minimal-base-audio-context-constructor.js";
+import { testPromiseSupport } from "./helpers/test-promise-support.js";
+import { createMonitorConnections } from "./factories/monitor-connections.js";
+import { createNativeAnalyserNodeFactory } from "./factories/native-analyser-node-factory.js";
+import { createNativeAudioBufferConstructor } from "./factories/native-audio-buffer-constructor.js";
+import { createNativeAudioBufferSourceNodeFactory } from "./factories/native-audio-buffer-source-node-factory.js";
+import { createNativeAudioContextConstructor } from "./factories/native-audio-context-constructor.js";
+import { createNativeAudioDestinationNodeFactory } from "./factories/native-audio-destination-node.js";
+import { createNativeAudioWorkletNodeConstructor } from "./factories/native-audio-worklet-node-constructor.js";
+import { createNativeBiquadFilterNode } from "./factories/native-biquad-filter-node.js";
+import { createNativeChannelMergerNodeFactory } from "./factories/native-channel-merger-node-factory.js";
+import { createNativeChannelSplitterNode } from "./factories/native-channel-splitter-node.js";
+import { createNativeConstantSourceNodeFactory } from "./factories/native-constant-source-node-factory.js";
+import { createNativeConstantSourceNodeFakerFactory } from "./factories/native-constant-source-node-faker-factory.js";
+import { createNativeConvolverNodeFactory } from "./factories/native-convolver-node-factory.js";
+import { createNativeDelayNode } from "./factories/native-delay-node.js";
+import { createNativeDynamicsCompressorNodeFactory } from "./factories/native-dynamics-compressor-node-factory.js";
+import { createNativeGainNode } from "./factories/native-gain-node.js";
+import { createNativeIIRFilterNodeFactory } from "./factories/native-iir-filter-node-factory.js";
+import { createNativeIIRFilterNodeFakerFactory } from "./factories/native-iir-filter-node-faker-factory.js";
+import { createNativeOfflineAudioContextConstructor } from "./factories/native-offline-audio-context-constructor.js";
+import { createNativeOscillatorNodeFactory } from "./factories/native-oscillator-node-factory.js";
+import { createNativePannerNodeFactory } from "./factories/native-panner-node-factory.js";
+import { createNativePannerNodeFakerFactory } from "./factories/native-panner-node-faker-factory.js";
+import { createNativePeriodicWaveFactory } from "./factories/native-periodic-wave-factory.js";
+import { createNativeScriptProcessorNode } from "./factories/native-script-processor-node.js";
+import { createNativeStereoPannerNodeFactory } from "./factories/native-stereo-panner-node-factory.js";
+import { createNativeStereoPannerNodeFakerFactory } from "./factories/native-stereo-panner-node-faker-factory.js";
+import { createNativeWaveShaperNodeFactory } from "./factories/native-wave-shaper-node-factory.js";
+import { createNativeWaveShaperNodeFakerFactory } from "./factories/native-wave-shaper-node-faker-factory.js";
+import { createNotSupportedError } from "./factories/not-supported-error.js";
+import { createOfflineAudioContextConstructor } from "./factories/offline-audio-context-constructor.js";
+import { createOscillatorNodeConstructor } from "./factories/oscillator-node-constructor.js";
+import { createOscillatorNodeRendererFactory } from "./factories/oscillator-node-renderer-factory.js";
+import { createPannerNodeConstructor } from "./factories/panner-node-constructor.js";
+import { createPannerNodeRendererFactory } from "./factories/panner-node-renderer-factory.js";
+import { createPeriodicWaveConstructor } from "./factories/periodic-wave-constructor.js";
+import { createRenderAutomation } from "./factories/render-automation.js";
+import { createRenderInputsOfAudioNode } from "./factories/render-inputs-of-audio-node.js";
+import { createRenderInputsOfAudioParam } from "./factories/render-inputs-of-audio-param.js";
+import { createRenderNativeOfflineAudioContext } from "./factories/render-native-offline-audio-context.js";
+import { createSetAudioNodeTailTime } from "./factories/set-audio-node-tail-time.js";
+import { createStartRendering } from "./factories/start-rendering.js";
+import { createStereoPannerNodeConstructor } from "./factories/stereo-panner-node-constructor.js";
+import { createStereoPannerNodeRendererFactory } from "./factories/stereo-panner-node-renderer-factory.js";
+import { createTestAudioBufferConstructorSupport } from "./factories/test-audio-buffer-constructor-support.js";
+import { createTestAudioWorkletProcessorPostMessageSupport } from "./factories/test-audio-worklet-processor-post-message-support.js";
+import { createTestOfflineAudioContextCurrentTimeSupport } from "./factories/test-offline-audio-context-current-time-support.js";
+import { createWaveShaperNodeConstructor } from "./factories/wave-shaper-node-constructor.js";
+import { createWaveShaperNodeRendererFactory } from "./factories/wave-shaper-node-renderer-factory.js";
+import { createWindow } from "./factories/window.js";
+import { createWrapAudioBufferCopyChannelMethods } from "./factories/wrap-audio-buffer-copy-channel-methods.js";
+import { createWrapAudioBufferCopyChannelMethodsOutOfBounds } from "./factories/wrap-audio-buffer-copy-channel-methods-out-of-bounds.js";
+import { createWrapAudioBufferSourceNodeStopMethodNullifiedBuffer } from "./factories/wrap-audio-buffer-source-node-stop-method-nullified-buffer.js";
+import { createWrapChannelMergerNode } from "./factories/wrap-channel-merger-node.js";
+import { connectNativeAudioNodeToNativeAudioNode } from "./helpers/connect-native-audio-node-to-native-audio-node.js";
+import { disconnectNativeAudioNodeFromNativeAudioNode } from "./helpers/disconnect-native-audio-node-from-native-audio-node.js";
+import { getFirstSample } from "./helpers/get-first-sample.js";
+import { getNativeAudioParam } from "./helpers/get-native-audio-param.js";
+import { insertElementInSet } from "./helpers/insert-element-in-set.js";
+import { isDCCurve } from "./helpers/is-dc-curve.js";
+import { isPartOfACycle } from "./helpers/is-part-of-a-cycle.js";
+import { isPassiveAudioNode } from "./helpers/is-passive-audio-node.js";
+import { overwriteAccessors } from "./helpers/overwrite-accessors.js";
+import { pickElementFromSet } from "./helpers/pick-element-from-set.js";
+import { sanitizeChannelSplitterOptions } from "./helpers/sanitize-channel-splitter-options.js";
+import { sanitizePeriodicWaveOptions } from "./helpers/sanitize-periodic-wave-options.js";
+import { setValueAtTimeUntilPossible } from "./helpers/set-value-at-time-until-possible.js";
+import { testAudioBufferCopyChannelMethodsOutOfBoundsSupport } from "./helpers/test-audio-buffer-copy-channel-methods-out-of-bounds-support.js";
+import { testAudioBufferSourceNodeStartMethodConsecutiveCallsSupport } from "./helpers/test-audio-buffer-source-node-start-method-consecutive-calls-support.js";
+import { testAudioBufferSourceNodeStartMethodOffsetClampingSupport } from "./helpers/test-audio-buffer-source-node-start-method-offset-clamping-support.js";
+import { testAudioBufferSourceNodeStopMethodNullifiedBufferSupport } from "./helpers/test-audio-buffer-source-node-stop-method-nullified-buffer-support.js";
+import { testAudioScheduledSourceNodeStartMethodNegativeParametersSupport } from "./helpers/test-audio-scheduled-source-node-start-method-negative-parameters-support.js";
+import { testAudioScheduledSourceNodeStopMethodConsecutiveCallsSupport } from "./helpers/test-audio-scheduled-source-node-stop-method-consecutive-calls-support.js";
+import { testAudioScheduledSourceNodeStopMethodNegativeParametersSupport } from "./helpers/test-audio-scheduled-source-node-stop-method-negative-parameters-support.js";
+import { wrapAudioBufferSourceNodeStartMethodOffsetClamping } from "./helpers/wrap-audio-buffer-source-node-start-method-offset-clamping.js";
+import { wrapAudioScheduledSourceNodeStopMethodConsecutiveCalls } from "./helpers/wrap-audio-scheduled-source-node-stop-method-consecutive-calls.js";
+import { wrapEventListener } from "./helpers/wrap-event-listener.js";
+const addActiveInputConnectionToAudioNode = createAddActiveInputConnectionToAudioNode(insertElementInSet);
+const addPassiveInputConnectionToAudioNode = createAddPassiveInputConnectionToAudioNode(insertElementInSet);
+const deleteActiveInputConnectionToAudioNode = createDeleteActiveInputConnectionToAudioNode(pickElementFromSet);
+const audioNodeTailTimeStore = /* @__PURE__ */ new WeakMap();
+const getAudioNodeTailTime = createGetAudioNodeTailTime(audioNodeTailTimeStore);
+const cacheTestResult = createCacheTestResult(/* @__PURE__ */ new Map(), /* @__PURE__ */ new WeakMap());
+const window = createWindow();
+const createNativeAnalyserNode = createNativeAnalyserNodeFactory(cacheTestResult, createIndexSizeError);
+const getAudioNodeRenderer = createGetAudioNodeRenderer(getAudioNodeConnections);
+const renderInputsOfAudioNode = createRenderInputsOfAudioNode(getAudioNodeConnections, getAudioNodeRenderer, isPartOfACycle);
+const createAnalyserNodeRenderer = createAnalyserNodeRendererFactory(createNativeAnalyserNode, getNativeAudioNode, renderInputsOfAudioNode);
+const getNativeContext = createGetNativeContext(CONTEXT_STORE);
+const nativeOfflineAudioContextConstructor = createNativeOfflineAudioContextConstructor(window);
+const isNativeOfflineAudioContext = createIsNativeOfflineAudioContext(nativeOfflineAudioContextConstructor);
+const audioParamAudioNodeStore = /* @__PURE__ */ new WeakMap();
+const eventTargetConstructor = createEventTargetConstructor(wrapEventListener);
+const nativeAudioContextConstructor = createNativeAudioContextConstructor(window);
+const isNativeAudioContext = createIsNativeAudioContext(nativeAudioContextConstructor);
+const isNativeAudioNode = createIsNativeAudioNode(window);
+const isNativeAudioParam = createIsNativeAudioParam(window);
+const nativeAudioWorkletNodeConstructor = createNativeAudioWorkletNodeConstructor(window);
+const audioNodeConstructor = createAudioNodeConstructor(createAddAudioNodeConnections(AUDIO_NODE_CONNECTIONS_STORE), createAddConnectionToAudioNode(addActiveInputConnectionToAudioNode, addPassiveInputConnectionToAudioNode, connectNativeAudioNodeToNativeAudioNode, deleteActiveInputConnectionToAudioNode, disconnectNativeAudioNodeFromNativeAudioNode, getAudioNodeConnections, getAudioNodeTailTime, getEventListenersOfAudioNode, getNativeAudioNode, insertElementInSet, isActiveAudioNode, isPartOfACycle, isPassiveAudioNode), cacheTestResult, createIncrementCycleCounterFactory(CYCLE_COUNTERS, disconnectNativeAudioNodeFromNativeAudioNode, getAudioNodeConnections, getNativeAudioNode, getNativeAudioParam, isActiveAudioNode), createIndexSizeError, createInvalidAccessError, createNotSupportedError, createDecrementCycleCounter(connectNativeAudioNodeToNativeAudioNode, CYCLE_COUNTERS, getAudioNodeConnections, getNativeAudioNode, getNativeAudioParam, getNativeContext, isActiveAudioNode, isNativeOfflineAudioContext), createDetectCycles(audioParamAudioNodeStore, getAudioNodeConnections, getValueForKey), eventTargetConstructor, getNativeContext, isNativeAudioContext, isNativeAudioNode, isNativeAudioParam, isNativeOfflineAudioContext, nativeAudioWorkletNodeConstructor);
+const analyserNodeConstructor = createAnalyserNodeConstructor(audioNodeConstructor, createAnalyserNodeRenderer, createIndexSizeError, createNativeAnalyserNode, getNativeContext, isNativeOfflineAudioContext);
+const audioBufferStore = /* @__PURE__ */ new WeakSet();
+const nativeAudioBufferConstructor = createNativeAudioBufferConstructor(window);
+const convertNumberToUnsignedLong = createConvertNumberToUnsignedLong(new Uint32Array(1));
+const wrapAudioBufferCopyChannelMethods = createWrapAudioBufferCopyChannelMethods(convertNumberToUnsignedLong, createIndexSizeError);
+const wrapAudioBufferCopyChannelMethodsOutOfBounds = createWrapAudioBufferCopyChannelMethodsOutOfBounds(convertNumberToUnsignedLong);
+const audioBufferConstructor = createAudioBufferConstructor(audioBufferStore, cacheTestResult, createNotSupportedError, nativeAudioBufferConstructor, nativeOfflineAudioContextConstructor, createTestAudioBufferConstructorSupport(nativeAudioBufferConstructor), wrapAudioBufferCopyChannelMethods, wrapAudioBufferCopyChannelMethodsOutOfBounds);
+const addSilentConnection = createAddSilentConnection(createNativeGainNode);
+const renderInputsOfAudioParam = createRenderInputsOfAudioParam(getAudioNodeRenderer, getAudioParamConnections, isPartOfACycle);
+const connectAudioParam = createConnectAudioParam(renderInputsOfAudioParam);
+const createNativeAudioBufferSourceNode = createNativeAudioBufferSourceNodeFactory(addSilentConnection, cacheTestResult, testAudioBufferSourceNodeStartMethodConsecutiveCallsSupport, testAudioBufferSourceNodeStartMethodOffsetClampingSupport, testAudioBufferSourceNodeStopMethodNullifiedBufferSupport, testAudioScheduledSourceNodeStartMethodNegativeParametersSupport, testAudioScheduledSourceNodeStopMethodConsecutiveCallsSupport, testAudioScheduledSourceNodeStopMethodNegativeParametersSupport, wrapAudioBufferSourceNodeStartMethodOffsetClamping, createWrapAudioBufferSourceNodeStopMethodNullifiedBuffer(overwriteAccessors), wrapAudioScheduledSourceNodeStopMethodConsecutiveCalls);
+const renderAutomation = createRenderAutomation(createGetAudioParamRenderer(getAudioParamConnections), renderInputsOfAudioParam);
+const createAudioBufferSourceNodeRenderer = createAudioBufferSourceNodeRendererFactory(connectAudioParam, createNativeAudioBufferSourceNode, getNativeAudioNode, renderAutomation, renderInputsOfAudioNode);
+const createAudioParam = createAudioParamFactory(createAddAudioParamConnections(AUDIO_PARAM_CONNECTIONS_STORE), audioParamAudioNodeStore, AUDIO_PARAM_STORE, createAudioParamRenderer, createCancelAndHoldAutomationEvent, createCancelScheduledValuesAutomationEvent, createExponentialRampToValueAutomationEvent, createLinearRampToValueAutomationEvent, createSetTargetAutomationEvent, createSetValueAutomationEvent, createSetValueCurveAutomationEvent, nativeAudioContextConstructor, setValueAtTimeUntilPossible);
+const audioBufferSourceNodeConstructor = createAudioBufferSourceNodeConstructor(audioNodeConstructor, createAudioBufferSourceNodeRenderer, createAudioParam, createInvalidStateError, createNativeAudioBufferSourceNode, getNativeContext, isNativeOfflineAudioContext, wrapEventListener);
+const audioDestinationNodeConstructor = createAudioDestinationNodeConstructor(audioNodeConstructor, createAudioDestinationNodeRenderer, createIndexSizeError, createInvalidStateError, createNativeAudioDestinationNodeFactory(createNativeGainNode, overwriteAccessors), getNativeContext, isNativeOfflineAudioContext, renderInputsOfAudioNode);
+const createBiquadFilterNodeRenderer = createBiquadFilterNodeRendererFactory(connectAudioParam, createNativeBiquadFilterNode, getNativeAudioNode, renderAutomation, renderInputsOfAudioNode);
+const setAudioNodeTailTime = createSetAudioNodeTailTime(audioNodeTailTimeStore);
+const biquadFilterNodeConstructor = createBiquadFilterNodeConstructor(audioNodeConstructor, createAudioParam, createBiquadFilterNodeRenderer, createInvalidAccessError, createNativeBiquadFilterNode, getNativeContext, isNativeOfflineAudioContext, setAudioNodeTailTime);
+const monitorConnections = createMonitorConnections(insertElementInSet, isNativeAudioNode);
+const wrapChannelMergerNode = createWrapChannelMergerNode(createInvalidStateError, monitorConnections);
+const createNativeChannelMergerNode = createNativeChannelMergerNodeFactory(nativeAudioContextConstructor, wrapChannelMergerNode);
+const createChannelMergerNodeRenderer = createChannelMergerNodeRendererFactory(createNativeChannelMergerNode, getNativeAudioNode, renderInputsOfAudioNode);
+const channelMergerNodeConstructor = createChannelMergerNodeConstructor(audioNodeConstructor, createChannelMergerNodeRenderer, createNativeChannelMergerNode, getNativeContext, isNativeOfflineAudioContext);
+const createChannelSplitterNodeRenderer = createChannelSplitterNodeRendererFactory(createNativeChannelSplitterNode, getNativeAudioNode, renderInputsOfAudioNode);
+const channelSplitterNodeConstructor = createChannelSplitterNodeConstructor(audioNodeConstructor, createChannelSplitterNodeRenderer, createNativeChannelSplitterNode, getNativeContext, isNativeOfflineAudioContext, sanitizeChannelSplitterOptions);
+const createNativeConstantSourceNodeFaker = createNativeConstantSourceNodeFakerFactory(addSilentConnection, createNativeAudioBufferSourceNode, createNativeGainNode, monitorConnections);
+const createNativeConstantSourceNode = createNativeConstantSourceNodeFactory(addSilentConnection, cacheTestResult, createNativeConstantSourceNodeFaker, testAudioScheduledSourceNodeStartMethodNegativeParametersSupport, testAudioScheduledSourceNodeStopMethodNegativeParametersSupport);
+const createConstantSourceNodeRenderer = createConstantSourceNodeRendererFactory(connectAudioParam, createNativeConstantSourceNode, getNativeAudioNode, renderAutomation, renderInputsOfAudioNode);
+const constantSourceNodeConstructor = createConstantSourceNodeConstructor(audioNodeConstructor, createAudioParam, createConstantSourceNodeRenderer, createNativeConstantSourceNode, getNativeContext, isNativeOfflineAudioContext, wrapEventListener);
+const createNativeConvolverNode = createNativeConvolverNodeFactory(createNotSupportedError, overwriteAccessors);
+const createConvolverNodeRenderer = createConvolverNodeRendererFactory(createNativeConvolverNode, getNativeAudioNode, renderInputsOfAudioNode);
+const convolverNodeConstructor = createConvolverNodeConstructor(audioNodeConstructor, createConvolverNodeRenderer, createNativeConvolverNode, getNativeContext, isNativeOfflineAudioContext, setAudioNodeTailTime);
+const createDelayNodeRenderer = createDelayNodeRendererFactory(connectAudioParam, createNativeDelayNode, getNativeAudioNode, renderAutomation, renderInputsOfAudioNode);
+const delayNodeConstructor = createDelayNodeConstructor(audioNodeConstructor, createAudioParam, createDelayNodeRenderer, createNativeDelayNode, getNativeContext, isNativeOfflineAudioContext, setAudioNodeTailTime);
+const createNativeDynamicsCompressorNode = createNativeDynamicsCompressorNodeFactory(createNotSupportedError);
+const createDynamicsCompressorNodeRenderer = createDynamicsCompressorNodeRendererFactory(connectAudioParam, createNativeDynamicsCompressorNode, getNativeAudioNode, renderAutomation, renderInputsOfAudioNode);
+const dynamicsCompressorNodeConstructor = createDynamicsCompressorNodeConstructor(audioNodeConstructor, createAudioParam, createDynamicsCompressorNodeRenderer, createNativeDynamicsCompressorNode, createNotSupportedError, getNativeContext, isNativeOfflineAudioContext, setAudioNodeTailTime);
+const createGainNodeRenderer = createGainNodeRendererFactory(connectAudioParam, createNativeGainNode, getNativeAudioNode, renderAutomation, renderInputsOfAudioNode);
+const gainNodeConstructor = createGainNodeConstructor(audioNodeConstructor, createAudioParam, createGainNodeRenderer, createNativeGainNode, getNativeContext, isNativeOfflineAudioContext);
+const createNativeIIRFilterNodeFaker = createNativeIIRFilterNodeFakerFactory(createInvalidAccessError, createInvalidStateError, createNativeScriptProcessorNode, createNotSupportedError);
+const renderNativeOfflineAudioContext = createRenderNativeOfflineAudioContext(cacheTestResult, createNativeGainNode, createNativeScriptProcessorNode, createTestOfflineAudioContextCurrentTimeSupport(createNativeGainNode, nativeOfflineAudioContextConstructor));
+const createIIRFilterNodeRenderer = createIIRFilterNodeRendererFactory(createNativeAudioBufferSourceNode, getNativeAudioNode, nativeOfflineAudioContextConstructor, renderInputsOfAudioNode, renderNativeOfflineAudioContext);
+const createNativeIIRFilterNode = createNativeIIRFilterNodeFactory(createNativeIIRFilterNodeFaker);
+const iIRFilterNodeConstructor = createIIRFilterNodeConstructor(audioNodeConstructor, createNativeIIRFilterNode, createIIRFilterNodeRenderer, getNativeContext, isNativeOfflineAudioContext, setAudioNodeTailTime);
+const createAudioListener = createAudioListenerFactory(createAudioParam, createNativeChannelMergerNode, createNativeConstantSourceNode, createNativeScriptProcessorNode, createNotSupportedError, getFirstSample, isNativeOfflineAudioContext, overwriteAccessors);
+const unrenderedAudioWorkletNodeStore = /* @__PURE__ */ new WeakMap();
+const minimalBaseAudioContextConstructor = createMinimalBaseAudioContextConstructor(audioDestinationNodeConstructor, createAudioListener, eventTargetConstructor, isNativeOfflineAudioContext, unrenderedAudioWorkletNodeStore, wrapEventListener);
+const createNativeOscillatorNode = createNativeOscillatorNodeFactory(addSilentConnection, cacheTestResult, testAudioScheduledSourceNodeStartMethodNegativeParametersSupport, testAudioScheduledSourceNodeStopMethodConsecutiveCallsSupport, testAudioScheduledSourceNodeStopMethodNegativeParametersSupport, wrapAudioScheduledSourceNodeStopMethodConsecutiveCalls);
+const createOscillatorNodeRenderer = createOscillatorNodeRendererFactory(connectAudioParam, createNativeOscillatorNode, getNativeAudioNode, renderAutomation, renderInputsOfAudioNode);
+const oscillatorNodeConstructor = createOscillatorNodeConstructor(audioNodeConstructor, createAudioParam, createNativeOscillatorNode, createOscillatorNodeRenderer, getNativeContext, isNativeOfflineAudioContext, wrapEventListener);
+const createConnectedNativeAudioBufferSourceNode = createConnectedNativeAudioBufferSourceNodeFactory(createNativeAudioBufferSourceNode);
+const createNativeWaveShaperNodeFaker = createNativeWaveShaperNodeFakerFactory(createConnectedNativeAudioBufferSourceNode, createInvalidStateError, createNativeGainNode, isDCCurve, monitorConnections);
+const createNativeWaveShaperNode = createNativeWaveShaperNodeFactory(createConnectedNativeAudioBufferSourceNode, createInvalidStateError, createNativeWaveShaperNodeFaker, isDCCurve, monitorConnections, nativeAudioContextConstructor, overwriteAccessors);
+const createNativePannerNodeFaker = createNativePannerNodeFakerFactory(connectNativeAudioNodeToNativeAudioNode, createInvalidStateError, createNativeChannelMergerNode, createNativeGainNode, createNativeScriptProcessorNode, createNativeWaveShaperNode, createNotSupportedError, disconnectNativeAudioNodeFromNativeAudioNode, getFirstSample, monitorConnections);
+const createNativePannerNode = createNativePannerNodeFactory(createNativePannerNodeFaker);
+const createPannerNodeRenderer = createPannerNodeRendererFactory(connectAudioParam, createNativeChannelMergerNode, createNativeConstantSourceNode, createNativeGainNode, createNativePannerNode, getNativeAudioNode, nativeOfflineAudioContextConstructor, renderAutomation, renderInputsOfAudioNode, renderNativeOfflineAudioContext);
+const pannerNodeConstructor = createPannerNodeConstructor(audioNodeConstructor, createAudioParam, createNativePannerNode, createPannerNodeRenderer, getNativeContext, isNativeOfflineAudioContext, setAudioNodeTailTime);
+const createNativePeriodicWave = createNativePeriodicWaveFactory(createIndexSizeError);
+const periodicWaveConstructor = createPeriodicWaveConstructor(createNativePeriodicWave, getNativeContext, /* @__PURE__ */ new WeakSet(), sanitizePeriodicWaveOptions);
+const nativeStereoPannerNodeFakerFactory = createNativeStereoPannerNodeFakerFactory(createNativeChannelMergerNode, createNativeChannelSplitterNode, createNativeGainNode, createNativeWaveShaperNode, createNotSupportedError, monitorConnections);
+const createNativeStereoPannerNode = createNativeStereoPannerNodeFactory(nativeStereoPannerNodeFakerFactory, createNotSupportedError);
+const createStereoPannerNodeRenderer = createStereoPannerNodeRendererFactory(connectAudioParam, createNativeStereoPannerNode, getNativeAudioNode, renderAutomation, renderInputsOfAudioNode);
+const stereoPannerNodeConstructor = createStereoPannerNodeConstructor(audioNodeConstructor, createAudioParam, createNativeStereoPannerNode, createStereoPannerNodeRenderer, getNativeContext, isNativeOfflineAudioContext);
+const createWaveShaperNodeRenderer = createWaveShaperNodeRendererFactory(createNativeWaveShaperNode, getNativeAudioNode, renderInputsOfAudioNode);
+const waveShaperNodeConstructor = createWaveShaperNodeConstructor(audioNodeConstructor, createInvalidStateError, createNativeWaveShaperNode, createWaveShaperNodeRenderer, getNativeContext, isNativeOfflineAudioContext, setAudioNodeTailTime);
+const isSecureContext = createIsSecureContext(window);
+const exposeCurrentFrameAndCurrentTime = createExposeCurrentFrameAndCurrentTime(window);
+const backupOfflineAudioContextStore = /* @__PURE__ */ new WeakMap();
+const getOrCreateBackupOfflineAudioContext = createGetOrCreateBackupOfflineAudioContext(backupOfflineAudioContextStore, nativeOfflineAudioContextConstructor);
+const addAudioWorkletModule = isSecureContext ? createAddAudioWorkletModule(
+  cacheTestResult,
+  createNotSupportedError,
+  createEvaluateSource(window),
+  exposeCurrentFrameAndCurrentTime,
+  createFetchSource(createAbortError),
+  getNativeContext,
+  getOrCreateBackupOfflineAudioContext,
+  isNativeOfflineAudioContext,
+  nativeAudioWorkletNodeConstructor,
+  /* @__PURE__ */ new WeakMap(),
+  /* @__PURE__ */ new WeakMap(),
+  createTestAudioWorkletProcessorPostMessageSupport(nativeAudioWorkletNodeConstructor, nativeOfflineAudioContextConstructor),
+  // @todo window is guaranteed to be defined because isSecureContext checks that as well.
+  window
+) : void 0;
+const isNativeContext = createIsNativeContext(isNativeAudioContext, isNativeOfflineAudioContext);
+const decodeAudioData = createDecodeAudioData(audioBufferStore, cacheTestResult, createDataCloneError, createEncodingError, /* @__PURE__ */ new WeakSet(), getNativeContext, isNativeContext, testAudioBufferCopyChannelMethodsOutOfBoundsSupport, testPromiseSupport, wrapAudioBufferCopyChannelMethods, wrapAudioBufferCopyChannelMethodsOutOfBounds);
+const baseAudioContextConstructor = createBaseAudioContextConstructor(addAudioWorkletModule, analyserNodeConstructor, audioBufferConstructor, audioBufferSourceNodeConstructor, biquadFilterNodeConstructor, channelMergerNodeConstructor, channelSplitterNodeConstructor, constantSourceNodeConstructor, convolverNodeConstructor, decodeAudioData, delayNodeConstructor, dynamicsCompressorNodeConstructor, gainNodeConstructor, iIRFilterNodeConstructor, minimalBaseAudioContextConstructor, oscillatorNodeConstructor, pannerNodeConstructor, periodicWaveConstructor, stereoPannerNodeConstructor, waveShaperNodeConstructor);
+const getUnrenderedAudioWorkletNodes = createGetUnrenderedAudioWorkletNodes(unrenderedAudioWorkletNodeStore);
+const createNativeOfflineAudioContext = createCreateNativeOfflineAudioContext(createNotSupportedError, nativeOfflineAudioContextConstructor);
+const startRendering = createStartRendering(audioBufferStore, cacheTestResult, getAudioNodeRenderer, getUnrenderedAudioWorkletNodes, renderNativeOfflineAudioContext, testAudioBufferCopyChannelMethodsOutOfBoundsSupport, wrapAudioBufferCopyChannelMethods, wrapAudioBufferCopyChannelMethodsOutOfBounds);
+const offlineAudioContextConstructor = createOfflineAudioContextConstructor(baseAudioContextConstructor, cacheTestResult, createInvalidStateError, createNativeOfflineAudioContext, startRendering);
+export {
+  analyserNodeConstructor as AnalyserNode,
+  audioBufferConstructor as AudioBuffer,
+  audioBufferSourceNodeConstructor as AudioBufferSourceNode,
+  biquadFilterNodeConstructor as BiquadFilterNode,
+  channelMergerNodeConstructor as ChannelMergerNode,
+  channelSplitterNodeConstructor as ChannelSplitterNode,
+  constantSourceNodeConstructor as ConstantSourceNode,
+  convolverNodeConstructor as ConvolverNode,
+  delayNodeConstructor as DelayNode,
+  dynamicsCompressorNodeConstructor as DynamicsCompressorNode,
+  gainNodeConstructor as GainNode,
+  iIRFilterNodeConstructor as IIRFilterNode,
+  offlineAudioContextConstructor as OfflineAudioContext,
+  oscillatorNodeConstructor as OscillatorNode,
+  pannerNodeConstructor as PannerNode,
+  periodicWaveConstructor as PeriodicWave,
+  stereoPannerNodeConstructor as StereoPannerNode,
+  waveShaperNodeConstructor as WaveShaperNode,
+  addAudioWorkletModule,
+  decodeAudioData
+};

package/dist/recorder/live-recorder/index.cjs

@@ -11,6 +11,7 @@ const LiveRecorder = react.forwardRef(
     fftSize = 2048,
     smoothingTimeConstant = 0.8,
     showIdleState = true,
+    amplitudeScale = 1.5,
     ...props
   }, ref) => {
     const canvasRef = react.useRef(null);
@@ -60,7 +61,7 @@ const LiveRecorder = react.forwardRef(
         for (let i = 0; i < numBars; i++) {
           const dataIndex = Math.floor(i / numBars * bufferLength);
           const value = dataArray[dataIndex] || 0;
-          const amplitude = Math.abs(value - 128) / 128;
+          const amplitude = Math.min(1, Math.abs(value - 128) / 128 * amplitudeScale);
           const barHeight = Math.max(2, amplitude * height * barHeightScale);
           const x = i * totalBarWidth;
           const y = (height - barHeight) / 2;
@@ -90,7 +91,7 @@ const LiveRecorder = react.forwardRef(
           animationRef.current = null;
         }
       };
-    }, [mediaRecorder, appearance, analyserRef, dataArrayRef, bufferLengthRef]);
+    }, [mediaRecorder, appearance, amplitudeScale, analyserRef, dataArrayRef, bufferLengthRef]);
     react.useEffect(() => {
       if (mediaRecorder || !showIdleState || !canvasRef.current) return;
       const canvas = canvasRef.current;

package/dist/recorder/live-recorder/index.js

@@ -9,6 +9,7 @@ const LiveRecorder = forwardRef(
     fftSize = 2048,
     smoothingTimeConstant = 0.8,
     showIdleState = true,
+    amplitudeScale = 1.5,
     ...props
   }, ref) => {
     const canvasRef = useRef(null);
@@ -58,7 +59,7 @@ const LiveRecorder = forwardRef(
         for (let i = 0; i < numBars; i++) {
           const dataIndex = Math.floor(i / numBars * bufferLength);
           const value = dataArray[dataIndex] || 0;
-          const amplitude = Math.abs(value - 128) / 128;
+          const amplitude = Math.min(1, Math.abs(value - 128) / 128 * amplitudeScale);
           const barHeight = Math.max(2, amplitude * height * barHeightScale);
           const x = i * totalBarWidth;
           const y = (height - barHeight) / 2;
@@ -88,7 +89,7 @@ const LiveRecorder = forwardRef(
           animationRef.current = null;
         }
       };
-    }, [mediaRecorder, appearance, analyserRef, dataArrayRef, bufferLengthRef]);
+    }, [mediaRecorder, appearance, amplitudeScale, analyserRef, dataArrayRef, bufferLengthRef]);
     useEffect(() => {
       if (mediaRecorder || !showIdleState || !canvasRef.current) return;
       const canvas = canvasRef.current;

package/dist/recorder/live-streaming/use-recording-amplitudes.cjs

@@ -3,7 +3,13 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const react = require("react");
 const useAudioAnalyser = require("../use-audio-analyser.cjs");
 function useRecordingAmplitudes(options) {
-  const { mediaRecorder, fftSize = 2048, smoothingTimeConstant = 0.4, sampleInterval = 50 } = options;
+  const {
+    mediaRecorder,
+    fftSize = 2048,
+    smoothingTimeConstant = 0.4,
+    sampleInterval = 50,
+    amplitudeScale = 1.5
+  } = options;
   const amplitudeDataRef = react.useRef([]);
   const listenersRef = react.useRef(/* @__PURE__ */ new Set());
   const samplingIntervalRef = react.useRef(null);
@@ -51,7 +57,7 @@ function useRecordingAmplitudes(options) {
         sum += normalized * normalized;
       }
       const rms = Math.sqrt(sum / bufferLength);
-      const amplitude = Math.min(1, rms * 2);
+      const amplitude = Math.min(1, rms * amplitudeScale);
       amplitudeDataRef.current.push(amplitude);
       notifyListeners();
     };
@@ -79,7 +85,7 @@ function useRecordingAmplitudes(options) {
       mediaRecorder.removeEventListener("resume", handleResume);
       stopSampling();
     };
-  }, [mediaRecorder, sampleInterval, analyserRef, dataArrayRef, bufferLengthRef, notifyListeners]);
+  }, [mediaRecorder, sampleInterval, amplitudeScale, analyserRef, dataArrayRef, bufferLengthRef, notifyListeners]);
   return {
     amplitudes,
     audioContext: audioContextRef.current,

package/dist/recorder/live-streaming/use-recording-amplitudes.js

@@ -1,7 +1,13 @@
 import { useRef, useCallback, useSyncExternalStore, useEffect } from "react";
 import { useAudioAnalyser } from "../use-audio-analyser.js";
 function useRecordingAmplitudes(options) {
-  const { mediaRecorder, fftSize = 2048, smoothingTimeConstant = 0.4, sampleInterval = 50 } = options;
+  const {
+    mediaRecorder,
+    fftSize = 2048,
+    smoothingTimeConstant = 0.4,
+    sampleInterval = 50,
+    amplitudeScale = 1.5
+  } = options;
   const amplitudeDataRef = useRef([]);
   const listenersRef = useRef(/* @__PURE__ */ new Set());
   const samplingIntervalRef = useRef(null);
@@ -49,7 +55,7 @@ function useRecordingAmplitudes(options) {
         sum += normalized * normalized;
       }
       const rms = Math.sqrt(sum / bufferLength);
-      const amplitude = Math.min(1, rms * 2);
+      const amplitude = Math.min(1, rms * amplitudeScale);
       amplitudeDataRef.current.push(amplitude);
       notifyListeners();
     };
@@ -77,7 +83,7 @@ function useRecordingAmplitudes(options) {
       mediaRecorder.removeEventListener("resume", handleResume);
       stopSampling();
     };
-  }, [mediaRecorder, sampleInterval, analyserRef, dataArrayRef, bufferLengthRef, notifyListeners]);
+  }, [mediaRecorder, sampleInterval, amplitudeScale, analyserRef, dataArrayRef, bufferLengthRef, notifyListeners]);
   return {
     amplitudes,
     audioContext: audioContextRef.current,

package/dist/waveform/util-audio-decoder.cjs

@@ -1,17 +1,16 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const module$1 = require("../node_modules/standardized-audio-context/build/es2019/module.cjs");
 async function decodeAudioBlob(blob, sampleCount) {
-  const audioContext = new AudioContext();
   const arrayBuffer = await blob.arrayBuffer();
   if (arrayBuffer.byteLength === 0) {
-    await audioContext.close();
     throw new Error("Audio blob is empty");
   }
+  const offlineContext = new module$1.OfflineAudioContext({ length: 1, sampleRate: 44100 });
   let audioBuffer;
   try {
-    audioBuffer = await audioContext.decodeAudioData(arrayBuffer);
+    audioBuffer = await offlineContext.decodeAudioData(arrayBuffer);
   } catch {
-    await audioContext.close();
     throw new Error(
       `Unable to decode audio data (type: ${blob.type}, size: ${blob.size} bytes). This may be due to an unsupported audio format or corrupted data.`
     );
@@ -29,7 +28,6 @@ async function decodeAudioBlob(blob, sampleCount) {
   }
   const maxPeak = Math.max(...peaks);
   const normalizedPeaks = maxPeak > 0 ? peaks.map((p) => p / maxPeak) : peaks;
-  await audioContext.close();
   return normalizedPeaks;
 }
 const audioDataCache = /* @__PURE__ */ new WeakMap();

package/dist/waveform/util-audio-decoder.js

@@ -1,15 +1,14 @@
+import { OfflineAudioContext as offlineAudioContextConstructor } from "../node_modules/standardized-audio-context/build/es2019/module.js";
 async function decodeAudioBlob(blob, sampleCount) {
-  const audioContext = new AudioContext();
   const arrayBuffer = await blob.arrayBuffer();
   if (arrayBuffer.byteLength === 0) {
-    await audioContext.close();
     throw new Error("Audio blob is empty");
   }
+  const offlineContext = new offlineAudioContextConstructor({ length: 1, sampleRate: 44100 });
   let audioBuffer;
   try {
-    audioBuffer = await audioContext.decodeAudioData(arrayBuffer);
+    audioBuffer = await offlineContext.decodeAudioData(arrayBuffer);
   } catch {
-    await audioContext.close();
     throw new Error(
       `Unable to decode audio data (type: ${blob.type}, size: ${blob.size} bytes). This may be due to an unsupported audio format or corrupted data.`
     );
@@ -27,7 +26,6 @@ async function decodeAudioBlob(blob, sampleCount) {
   }
   const maxPeak = Math.max(...peaks);
   const normalizedPeaks = maxPeak > 0 ? peaks.map((p) => p / maxPeak) : peaks;
-  await audioContext.close();
   return normalizedPeaks;
 }
 const audioDataCache = /* @__PURE__ */ new WeakMap();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-audio-wavekit",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "license": "CC0-1.0",
   "type": "module",
   "main": "dist/index.cjs",
@@ -69,6 +69,7 @@
   },
   "dependencies": {
     "overlayscrollbars": "^2.13.0",
-    "overlayscrollbars-react": "^0.5.6"
+    "overlayscrollbars-react": "^0.5.6",
+    "standardized-audio-context": "^25.3.77"
   }
 }