{"version":3,"file":"Tone.js","mappings":"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","sources":["webpack://Tone/webpack/universalModuleDefinition","webpack://Tone/./node_modules/@babel/runtime/helpers/arrayLikeToArray.js","webpack://Tone/./node_modules/@babel/runtime/helpers/arrayWithHoles.js","webpack://Tone/./node_modules/@babel/runtime/helpers/classCallCheck.js","webpack://Tone/./node_modules/@babel/runtime/helpers/createClass.js","webpack://Tone/./node_modules/@babel/runtime/helpers/iterableToArrayLimit.js","webpack://Tone/./node_modules/@babel/runtime/helpers/nonIterableRest.js","webpack://Tone/./node_modules/@babel/runtime/helpers/slicedToArray.js","webpack://Tone/./node_modules/@babel/runtime/helpers/unsupportedIterableToArray.js","webpack://Tone/./node_modules/automation-events/build/es5/bundle.js","webpack://Tone/webpack/bootstrap","webpack://Tone/webpack/runtime/define property getters","webpack://Tone/webpack/runtime/hasOwnProperty shorthand","webpack://Tone/webpack/runtime/make namespace object","webpack://Tone/./Tone/version.ts","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/abort-error.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/globals.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/helpers/is-constructible.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/helpers/split-import-statements.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/add-audio-worklet-module.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/helpers/get-value-for-key.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/helpers/pick-element-from-set.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/helpers/delete-passive-input-connection-to-audio-node.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/helpers/get-event-listeners-of-audio-node.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/helpers/set-internal-state-to-active.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/guards/audio-worklet-node.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/helpers/set-internal-state-to-passive.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/helpers/set-internal-state-to-passive-when-necessary.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/analyser-node-constructor.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/helpers/is-owned-by-context.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/helpers/test-audio-buffer-copy-channel-methods-out-of-bounds-support.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/index-size-error.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/helpers/wrap-audio-buffer-get-channel-data-method.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/audio-buffer-constructor.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/constants.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/helpers/is-active-audio-node.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/audio-buffer-source-node-constructor.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/helpers/get-audio-node-connections.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/helpers/get-audio-param-connections.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/helpers/deactivate-active-audio-node-input-connections.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/guards/audio-buffer-source-node.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/guards/biquad-filter-node.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/guards/constant-source-node.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/guards/gain-node.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/guards/oscillator-node.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/guards/stereo-panner-node.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/helpers/deactivate-audio-graph.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/guards/audio-node.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/guards/audio-node-output-connection.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/helpers/insert-element-in-set.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/helpers/add-active-input-connection-to-audio-param.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/helpers/add-passive-input-connection-to-audio-param.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/guards/native-audio-node-faker.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/helpers/connect-native-audio-node-to-native-audio-node.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/helpers/delete-active-input-connection.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/helpers/delete-event-listeners-of-audio-node.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/helpers/delete-passive-input-connection-to-audio-param.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/helpers/disconnect-native-audio-node-from-native-audio-node.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/helpers/get-native-audio-node.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/helpers/get-native-audio-param.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/helpers/is-part-of-a-cycle.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/helpers/is-passive-audio-node.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/helpers/test-audio-node-disconnect-method-support.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/helpers/visit-each-audio-node-once.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/guards/native-audio-node.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/helpers/wrap-audio-node-disconnect-method.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/audio-node-constructor.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/read-only-map.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/audio-worklet-node-constructor.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/helpers/copy-from-channel.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/helpers/copy-to-channel.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/helpers/create-nested-arrays.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/audio-worklet-node-renderer-factory.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/helpers/get-audio-worklet-processor.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/biquad-filter-node-constructor.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/channel-merger-node-constructor.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/channel-splitter-node-constructor.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/constant-source-node-constructor.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/convolver-node-constructor.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/helpers/detach-array-buffer.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/delay-node-constructor.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/disconnect-multiple-outputs.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/dynamics-compressor-node-constructor.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/gain-node-constructor.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/invalid-state-error.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/invalid-access-error.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/iir-filter-node-constructor.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/helpers/filter-buffer.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/media-stream-audio-destination-node-constructor.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/helpers/test-promise-support.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/helpers/assign-native-audio-node-option.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/helpers/assign-native-audio-node-options.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/helpers/test-analyser-node-get-float-time-domain-data-method-support.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/helpers/assign-native-audio-node-audio-param-value.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/helpers/wrap-audio-scheduled-source-node-start-method-negative-parameters.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/helpers/wrap-audio-scheduled-source-node-stop-method-negative-parameters.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/helpers/compute-buffer-size.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/native-biquad-filter-node.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/native-channel-splitter-node.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/helpers/wrap-channel-splitter-node.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/helpers/intercept-connections.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/native-delay-node.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/native-gain-node.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/native-iir-filter-node-faker-factory.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/native-script-processor-node.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/not-supported-error.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/offline-audio-context-constructor.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/oscillator-node-constructor.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/panner-node-constructor.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/periodic-wave-constructor.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/stereo-panner-node-constructor.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/unknown-error.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/wave-shaper-node-constructor.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/helpers/get-first-sample.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/helpers/is-dc-curve.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/helpers/overwrite-accessors.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/helpers/set-value-at-time-until-possible.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/helpers/test-audio-scheduled-source-node-start-method-negative-parameters-support.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/helpers/test-audio-scheduled-source-node-stop-method-consecutive-calls-support.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/helpers/test-audio-scheduled-source-node-stop-method-negative-parameters-support.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/helpers/test-dom-exception-constructor-support.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/helpers/test-transferables-support.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/helpers/wrap-audio-scheduled-source-node-stop-method-consecutive-calls.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/helpers/wrap-event-listener.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/module.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/add-active-input-connection-to-audio-node.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/add-passive-input-connection-to-audio-node.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/delete-active-input-connection-to-audio-node.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/get-audio-node-tail-time.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/cache-test-result.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/window.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/native-analyser-node-factory.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/helpers/wrap-analyser-node-get-float-time-domain-data-method.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/get-audio-node-renderer.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/render-inputs-of-audio-node.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/analyser-node-renderer-factory.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/get-native-context.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/native-offline-audio-context-constructor.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/is-native-offline-audio-context.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/event-target-constructor.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/native-audio-context-constructor.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/is-native-audio-context.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/is-native-audio-node.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/is-native-audio-param.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/native-audio-worklet-node-constructor.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/helpers/delete-active-input-connection-to-audio-param.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/add-audio-node-connections.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/add-connection-to-audio-node.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/increment-cycle-counter-factory.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/decrement-cycle-counter.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/detect-cycles.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/guards/delay-node.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/native-audio-buffer-constructor.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/convert-number-to-unsigned-long.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/wrap-audio-buffer-copy-channel-methods.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/wrap-audio-buffer-copy-channel-methods-out-of-bounds.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/test-audio-buffer-constructor-support.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/add-silent-connection.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/render-inputs-of-audio-param.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/connect-audio-param.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/native-audio-buffer-source-node-factory.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/helpers/wrap-audio-buffer-source-node-start-method-consecutive-calls.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/helpers/wrap-audio-buffer-source-node-start-method-offset-clamping.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/helpers/test-audio-buffer-source-node-start-method-consecutive-calls-support.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/helpers/test-audio-buffer-source-node-start-method-offset-clamping-support.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/helpers/test-audio-buffer-source-node-stop-method-nullified-buffer-support.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/wrap-audio-buffer-source-node-stop-method-nullified-buffer.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/render-automation.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/get-audio-param-renderer.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/audio-buffer-source-node-renderer-factory.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/audio-param-factory.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/audio-param-renderer.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/add-audio-param-connections.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/audio-destination-node-constructor.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/audio-destination-node-renderer-factory.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/native-audio-destination-node.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/biquad-filter-node-renderer-factory.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/set-audio-node-tail-time.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/monitor-connections.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/wrap-channel-merger-node.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/native-channel-merger-node-factory.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/channel-merger-node-renderer-factory.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/channel-splitter-node-renderer-factory.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/helpers/sanitize-channel-splitter-options.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/native-constant-source-node-faker-factory.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/native-constant-source-node-factory.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/constant-source-node-renderer-factory.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/native-convolver-node-factory.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/convolver-node-renderer-factory.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/delay-node-renderer-factory.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/native-dynamics-compressor-node-factory.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/dynamics-compressor-node-renderer-factory.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/gain-node-renderer-factory.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/render-native-offline-audio-context.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/test-offline-audio-context-current-time-support.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/iir-filter-node-renderer-factory.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/native-iir-filter-node-factory.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/helpers/wrap-iir-filter-node-get-frequency-response-method.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/audio-listener-factory.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/minimal-base-audio-context-constructor.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/native-oscillator-node-factory.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/oscillator-node-renderer-factory.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/connected-native-audio-buffer-source-node-factory.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/native-wave-shaper-node-faker-factory.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/native-wave-shaper-node-factory.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/native-panner-node-faker-factory.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/native-panner-node-factory.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/panner-node-renderer-factory.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/native-periodic-wave-factory.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/helpers/sanitize-periodic-wave-options.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/native-stereo-panner-node-faker-factory.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/native-stereo-panner-node-factory.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/stereo-panner-node-renderer-factory.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/wave-shaper-node-renderer-factory.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/is-secure-context.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/expose-current-frame-and-current-time.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/get-or-create-backup-offline-audio-context.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/evaluate-source.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/fetch-source.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/test-audio-worklet-processor-post-message-support.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/is-native-context.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/decode-audio-data.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/data-clone-error.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/encoding-error.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/base-audio-context-constructor.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/media-element-audio-source-node-constructor.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/native-media-element-audio-source-node.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/native-media-stream-audio-destination-node.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/media-stream-audio-source-node-constructor.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/native-media-stream-audio-source-node.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/native-media-stream-track-audio-source-node-factory.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/media-stream-track-audio-source-node-constructor.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/audio-context-constructor.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/helpers/is-valid-latency-hint.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/get-unrendered-audio-worklet-nodes.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/add-unrendered-audio-worklet-node.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/connect-multiple-outputs.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/delete-unrendered-audio-worklet-node.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/get-active-audio-worklet-node-inputs.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/native-audio-worklet-node-faker-factory.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/helpers/create-audio-worklet-processor.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/helpers/create-audio-worklet-processor-promise.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/helpers/clone-audio-worklet-node-options.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/native-audio-worklet-node-factory.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/helpers/test-clonability-of-audio-worklet-node-options.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/get-backup-offline-audio-context.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/set-active-audio-worklet-node-inputs.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/helpers/sanitize-audio-worklet-node-options.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/helpers/test-audio-worklet-node-options-clonability.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/create-native-offline-audio-context.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/start-rendering.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/is-any-audio-context.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/is-any-audio-node.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/is-any-audio-param.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/is-any-offline-audio-context.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/is-supported-promise.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/test-audio-buffer-copy-channel-methods-subarray-support.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/test-audio-context-close-method-support.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/test-audio-context-decode-audio-data-method-type-error-support.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/test-audio-context-options-support.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/test-audio-node-connect-method-support.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/test-audio-worklet-processor-no-outputs-support.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/test-channel-merger-node-channel-count-support.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/test-constant-source-node-accurate-scheduling-support.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/test-convolver-node-buffer-reassignability-support.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/test-convolver-node-channel-count-support.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/test-is-secure-context-support.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/test-media-stream-audio-source-node-media-stream-without-audio-track-support.js","webpack://Tone/./node_modules/standardized-audio-context/build/es2019/factories/test-stereo-panner-node-default-value-support.js","webpack://Tone/./Tone/core/util/TypeCheck.ts","webpack://Tone/./Tone/core/util/Debug.ts","webpack://Tone/./Tone/core/context/AudioContext.ts","webpack://Tone/./node_modules/tslib/tslib.es6.js","webpack://Tone/./Tone/core/clock/Ticker.ts","webpack://Tone/./Tone/core/util/AdvancedTypeCheck.ts","webpack://Tone/./Tone/core/util/Defaults.ts","webpack://Tone/./Tone/core/Tone.ts","webpack://Tone/./Tone/core/util/Math.ts","webpack://Tone/./Tone/core/util/Timeline.ts","webpack://Tone/./Tone/core/context/ContextInitialization.ts","webpack://Tone/./Tone/core/util/Emitter.ts","webpack://Tone/./Tone/core/context/BaseContext.ts","webpack://Tone/./Tone/core/context/Context.ts","webpack://Tone/./Tone/core/util/Interface.ts","webpack://Tone/./Tone/core/context/ToneAudioBuffer.ts","webpack://Tone/./Tone/core/context/OfflineContext.ts","webpack://Tone/./Tone/core/Global.ts","webpack://Tone/./Tone/core/context/DummyContext.ts","webpack://Tone/./Tone/core/type/Conversions.ts","webpack://Tone/./Tone/core/type/TimeBase.ts","webpack://Tone/./Tone/core/type/Time.ts","webpack://Tone/./Tone/core/type/Frequency.ts","webpack://Tone/./Tone/core/type/TransportTime.ts","webpack://Tone/./Tone/core/context/ToneWithContext.ts","webpack://Tone/./Tone/core/util/StateTimeline.ts","webpack://Tone/./Tone/core/context/Param.ts","webpack://Tone/./Tone/core/context/ToneAudioNode.ts","webpack://Tone/./Tone/core/context/Gain.ts","webpack://Tone/./Tone/source/OneShotSource.ts","webpack://Tone/./Tone/signal/ToneConstantSource.ts","webpack://Tone/./Tone/signal/Signal.ts","webpack://Tone/./Tone/core/clock/TickParam.ts","webpack://Tone/./Tone/core/clock/TickSignal.ts","webpack://Tone/./Tone/core/clock/TickSource.ts","webpack://Tone/./Tone/core/clock/Clock.ts","webpack://Tone/./Tone/core/context/Delay.ts","webpack://Tone/./Tone/core/context/Offline.ts","webpack://Tone/./Tone/core/context/ToneAudioBuffers.ts","webpack://Tone/./Tone/core/type/Midi.ts","webpack://Tone/./Tone/core/type/Ticks.ts","webpack://Tone/./Tone/core/util/Draw.ts","webpack://Tone/./Tone/core/util/IntervalTimeline.ts","webpack://Tone/./Tone/component/channel/Volume.ts","webpack://Tone/./Tone/core/context/Destination.ts","webpack://Tone/./Tone/core/util/TimelineValue.ts","webpack://Tone/./Tone/core/clock/TransportEvent.ts","webpack://Tone/./Tone/core/clock/TransportRepeatEvent.ts","webpack://Tone/./Tone/core/clock/Transport.ts","webpack://Tone/./Tone/source/Source.ts","webpack://Tone/./Tone/source/buffer/ToneBufferSource.ts","webpack://Tone/./Tone/source/Noise.ts","webpack://Tone/./Tone/source/UserMedia.ts","webpack://Tone/./Tone/source/oscillator/OscillatorInterface.ts","webpack://Tone/./Tone/source/oscillator/ToneOscillatorNode.ts","webpack://Tone/./Tone/source/oscillator/Oscillator.ts","webpack://Tone/./Tone/signal/SignalOperator.ts","webpack://Tone/./Tone/signal/WaveShaper.ts","webpack://Tone/./Tone/signal/AudioToGain.ts","webpack://Tone/./Tone/signal/Multiply.ts","webpack://Tone/./Tone/source/oscillator/AMOscillator.ts","webpack://Tone/./Tone/source/oscillator/FMOscillator.ts","webpack://Tone/./Tone/source/oscillator/PulseOscillator.ts","webpack://Tone/./Tone/source/oscillator/FatOscillator.ts","webpack://Tone/./Tone/source/oscillator/PWMOscillator.ts","webpack://Tone/./Tone/source/oscillator/OmniOscillator.ts","webpack://Tone/./Tone/signal/Add.ts","webpack://Tone/./Tone/signal/Scale.ts","webpack://Tone/./Tone/signal/Zero.ts","webpack://Tone/./Tone/source/oscillator/LFO.ts","webpack://Tone/./Tone/core/util/Decorator.ts","webpack://Tone/./Tone/source/buffer/Player.ts","webpack://Tone/./Tone/source/buffer/Players.ts","webpack://Tone/./Tone/source/buffer/GrainPlayer.ts","webpack://Tone/./Tone/signal/Abs.ts","webpack://Tone/./Tone/signal/GainToAudio.ts","webpack://Tone/./Tone/signal/Negate.ts","webpack://Tone/./Tone/signal/Subtract.ts","webpack://Tone/./Tone/signal/GreaterThanZero.ts","webpack://Tone/./Tone/signal/GreaterThan.ts","webpack://Tone/./Tone/signal/Pow.ts","webpack://Tone/./Tone/signal/ScaleExp.ts","webpack://Tone/./Tone/signal/SyncedSignal.ts","webpack://Tone/./Tone/component/envelope/Envelope.ts","webpack://Tone/./Tone/instrument/Instrument.ts","webpack://Tone/./Tone/instrument/Monophonic.ts","webpack://Tone/./Tone/component/envelope/AmplitudeEnvelope.ts","webpack://Tone/./Tone/instrument/Synth.ts","webpack://Tone/./Tone/instrument/ModulationSynth.ts","webpack://Tone/./Tone/instrument/AMSynth.ts","webpack://Tone/./Tone/component/filter/BiquadFilter.ts","webpack://Tone/./Tone/component/filter/Filter.ts","webpack://Tone/./Tone/component/envelope/FrequencyEnvelope.ts","webpack://Tone/./Tone/instrument/MonoSynth.ts","webpack://Tone/./Tone/instrument/DuoSynth.ts","webpack://Tone/./Tone/instrument/FMSynth.ts","webpack://Tone/./Tone/instrument/MetalSynth.ts","webpack://Tone/./Tone/instrument/MembraneSynth.ts","webpack://Tone/./Tone/instrument/NoiseSynth.ts","webpack://Tone/./Tone/core/worklet/WorkletGlobalScope.ts","webpack://Tone/./Tone/core/worklet/ToneAudioWorklet.ts","webpack://Tone/./Tone/core/worklet/ToneAudioWorkletProcessor.worklet.ts","webpack://Tone/./Tone/core/worklet/SingleIOProcessor.worklet.ts","webpack://Tone/./Tone/core/worklet/DelayLine.worklet.ts","webpack://Tone/./Tone/component/filter/FeedbackCombFilter.worklet.ts","webpack://Tone/./Tone/component/filter/FeedbackCombFilter.ts","webpack://Tone/./Tone/component/filter/OnePoleFilter.ts","webpack://Tone/./Tone/component/filter/LowpassCombFilter.ts","webpack://Tone/./Tone/instrument/PluckSynth.ts","webpack://Tone/./Tone/instrument/PolySynth.ts","webpack://Tone/./Tone/instrument/Sampler.ts","webpack://Tone/./Tone/event/ToneEvent.ts","webpack://Tone/./Tone/event/Loop.ts","webpack://Tone/./Tone/event/Part.ts","webpack://Tone/./Tone/event/PatternGenerator.ts","webpack://Tone/./Tone/event/Pattern.ts","webpack://Tone/./Tone/event/Sequence.ts","webpack://Tone/./Tone/component/channel/CrossFade.ts","webpack://Tone/./Tone/effect/Effect.ts","webpack://Tone/./Tone/effect/LFOEffect.ts","webpack://Tone/./Tone/effect/AutoFilter.ts","webpack://Tone/./Tone/component/channel/Panner.ts","webpack://Tone/./Tone/effect/AutoPanner.ts","webpack://Tone/./Tone/component/analysis/Follower.ts","webpack://Tone/./Tone/effect/AutoWah.ts","webpack://Tone/./Tone/effect/BitCrusher.worklet.ts","webpack://Tone/./Tone/effect/BitCrusher.ts","webpack://Tone/./Tone/effect/Chebyshev.ts","webpack://Tone/./Tone/component/channel/Split.ts","webpack://Tone/./Tone/component/channel/Merge.ts","webpack://Tone/./Tone/effect/StereoEffect.ts","webpack://Tone/./Tone/effect/StereoFeedbackEffect.ts","webpack://Tone/./Tone/effect/Chorus.ts","webpack://Tone/./Tone/effect/Distortion.ts","webpack://Tone/./Tone/effect/FeedbackEffect.ts","webpack://Tone/./Tone/effect/FeedbackDelay.ts","webpack://Tone/./Tone/component/filter/PhaseShiftAllpass.ts","webpack://Tone/./Tone/effect/FrequencyShifter.ts","webpack://Tone/./Tone/effect/Freeverb.ts","webpack://Tone/./Tone/effect/JCReverb.ts","webpack://Tone/./Tone/effect/StereoXFeedbackEffect.ts","webpack://Tone/./Tone/effect/PingPongDelay.ts","webpack://Tone/./Tone/effect/PitchShift.ts","webpack://Tone/./Tone/effect/Phaser.ts","webpack://Tone/./Tone/effect/Reverb.ts","webpack://Tone/./Tone/component/channel/MidSideSplit.ts","webpack://Tone/./Tone/component/channel/MidSideMerge.ts","webpack://Tone/./Tone/effect/MidSideEffect.ts","webpack://Tone/./Tone/effect/StereoWidener.ts","webpack://Tone/./Tone/effect/Tremolo.ts","webpack://Tone/./Tone/effect/Vibrato.ts","webpack://Tone/./Tone/component/analysis/Analyser.ts","webpack://Tone/./Tone/component/analysis/MeterBase.ts","webpack://Tone/./Tone/component/analysis/Meter.ts","webpack://Tone/./Tone/component/analysis/FFT.ts","webpack://Tone/./Tone/component/analysis/DCMeter.ts","webpack://Tone/./Tone/component/analysis/Waveform.ts","webpack://Tone/./Tone/component/channel/Solo.ts","webpack://Tone/./Tone/component/channel/PanVol.ts","webpack://Tone/./Tone/component/channel/Channel.ts","webpack://Tone/./Tone/component/channel/Mono.ts","webpack://Tone/./Tone/component/channel/MultibandSplit.ts","webpack://Tone/./Tone/core/context/Listener.ts","webpack://Tone/./Tone/component/channel/Panner3D.ts","webpack://Tone/./Tone/component/channel/Recorder.ts","webpack://Tone/./Tone/component/dynamics/Compressor.ts","webpack://Tone/./Tone/component/dynamics/Gate.ts","webpack://Tone/./Tone/component/dynamics/Limiter.ts","webpack://Tone/./Tone/component/dynamics/MidSideCompressor.ts","webpack://Tone/./Tone/component/dynamics/MultibandCompressor.ts","webpack://Tone/./Tone/component/filter/EQ3.ts","webpack://Tone/./Tone/component/filter/Convolver.ts","webpack://Tone/./Tone/index.ts"],"sourcesContent":["(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"Tone\"] = factory();\n\telse\n\t\troot[\"Tone\"] = factory();\n})(typeof self !== 'undefined' ? self : this, function() {\nreturn ","function _arrayLikeToArray(arr, len) {\n  if (len == null || len > arr.length) len = arr.length;\n\n  for (var i = 0, arr2 = new Array(len); i < len; i++) {\n    arr2[i] = arr[i];\n  }\n\n  return arr2;\n}\n\nmodule.exports = _arrayLikeToArray;\nmodule.exports[\"default\"] = module.exports, module.exports.__esModule = true;","function _arrayWithHoles(arr) {\n  if (Array.isArray(arr)) return arr;\n}\n\nmodule.exports = _arrayWithHoles;\nmodule.exports[\"default\"] = module.exports, module.exports.__esModule = true;","function _classCallCheck(instance, Constructor) {\n  if (!(instance instanceof Constructor)) {\n    throw new TypeError(\"Cannot call a class as a function\");\n  }\n}\n\nmodule.exports = _classCallCheck;\nmodule.exports[\"default\"] = module.exports, module.exports.__esModule = true;","function _defineProperties(target, props) {\n  for (var i = 0; i < props.length; i++) {\n    var descriptor = props[i];\n    descriptor.enumerable = descriptor.enumerable || false;\n    descriptor.configurable = true;\n    if (\"value\" in descriptor) descriptor.writable = true;\n    Object.defineProperty(target, descriptor.key, descriptor);\n  }\n}\n\nfunction _createClass(Constructor, protoProps, staticProps) {\n  if (protoProps) _defineProperties(Constructor.prototype, protoProps);\n  if (staticProps) _defineProperties(Constructor, staticProps);\n  return Constructor;\n}\n\nmodule.exports = _createClass;\nmodule.exports[\"default\"] = module.exports, module.exports.__esModule = true;","function _iterableToArrayLimit(arr, i) {\n  var _i = arr == null ? null : typeof Symbol !== \"undefined\" && arr[Symbol.iterator] || arr[\"@@iterator\"];\n\n  if (_i == null) return;\n  var _arr = [];\n  var _n = true;\n  var _d = false;\n\n  var _s, _e;\n\n  try {\n    for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) {\n      _arr.push(_s.value);\n\n      if (i && _arr.length === i) break;\n    }\n  } catch (err) {\n    _d = true;\n    _e = err;\n  } finally {\n    try {\n      if (!_n && _i[\"return\"] != null) _i[\"return\"]();\n    } finally {\n      if (_d) throw _e;\n    }\n  }\n\n  return _arr;\n}\n\nmodule.exports = _iterableToArrayLimit;\nmodule.exports[\"default\"] = module.exports, module.exports.__esModule = true;","function _nonIterableRest() {\n  throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n}\n\nmodule.exports = _nonIterableRest;\nmodule.exports[\"default\"] = module.exports, module.exports.__esModule = true;","var arrayWithHoles = require(\"./arrayWithHoles.js\");\n\nvar iterableToArrayLimit = require(\"./iterableToArrayLimit.js\");\n\nvar unsupportedIterableToArray = require(\"./unsupportedIterableToArray.js\");\n\nvar nonIterableRest = require(\"./nonIterableRest.js\");\n\nfunction _slicedToArray(arr, i) {\n  return arrayWithHoles(arr) || iterableToArrayLimit(arr, i) || unsupportedIterableToArray(arr, i) || nonIterableRest();\n}\n\nmodule.exports = _slicedToArray;\nmodule.exports[\"default\"] = module.exports, module.exports.__esModule = true;","var arrayLikeToArray = require(\"./arrayLikeToArray.js\");\n\nfunction _unsupportedIterableToArray(o, minLen) {\n  if (!o) return;\n  if (typeof o === \"string\") return arrayLikeToArray(o, minLen);\n  var n = Object.prototype.toString.call(o).slice(8, -1);\n  if (n === \"Object\" && o.constructor) n = o.constructor.name;\n  if (n === \"Map\" || n === \"Set\") return Array.from(o);\n  if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return arrayLikeToArray(o, minLen);\n}\n\nmodule.exports = _unsupportedIterableToArray;\nmodule.exports[\"default\"] = module.exports, module.exports.__esModule = true;","(function (global, factory) {\n    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@babel/runtime/helpers/slicedToArray'), require('@babel/runtime/helpers/classCallCheck'), require('@babel/runtime/helpers/createClass')) :\n    typeof define === 'function' && define.amd ? define(['exports', '@babel/runtime/helpers/slicedToArray', '@babel/runtime/helpers/classCallCheck', '@babel/runtime/helpers/createClass'], factory) :\n    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.automationEvents = {}, global._slicedToArray, global._classCallCheck, global._createClass));\n})(this, (function (exports, _slicedToArray, _classCallCheck, _createClass) { 'use strict';\n\n    function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }\n\n    var _slicedToArray__default = /*#__PURE__*/_interopDefaultLegacy(_slicedToArray);\n    var _classCallCheck__default = /*#__PURE__*/_interopDefaultLegacy(_classCallCheck);\n    var _createClass__default = /*#__PURE__*/_interopDefaultLegacy(_createClass);\n\n    var createExtendedExponentialRampToValueAutomationEvent = function createExtendedExponentialRampToValueAutomationEvent(value, endTime, insertTime) {\n      return {\n        endTime: endTime,\n        insertTime: insertTime,\n        type: 'exponentialRampToValue',\n        value: value\n      };\n    };\n\n    var createExtendedLinearRampToValueAutomationEvent = function createExtendedLinearRampToValueAutomationEvent(value, endTime, insertTime) {\n      return {\n        endTime: endTime,\n        insertTime: insertTime,\n        type: 'linearRampToValue',\n        value: value\n      };\n    };\n\n    var createSetValueAutomationEvent = function createSetValueAutomationEvent(value, startTime) {\n      return {\n        startTime: startTime,\n        type: 'setValue',\n        value: value\n      };\n    };\n\n    var createSetValueCurveAutomationEvent = function createSetValueCurveAutomationEvent(values, startTime, duration) {\n      return {\n        duration: duration,\n        startTime: startTime,\n        type: 'setValueCurve',\n        values: values\n      };\n    };\n\n    var getTargetValueAtTime = function getTargetValueAtTime(time, valueAtStartTime, _ref) {\n      var startTime = _ref.startTime,\n          target = _ref.target,\n          timeConstant = _ref.timeConstant;\n      return target + (valueAtStartTime - target) * Math.exp((startTime - time) / timeConstant);\n    };\n\n    var isExponentialRampToValueAutomationEvent = function isExponentialRampToValueAutomationEvent(automationEvent) {\n      return automationEvent.type === 'exponentialRampToValue';\n    };\n\n    var isLinearRampToValueAutomationEvent = function isLinearRampToValueAutomationEvent(automationEvent) {\n      return automationEvent.type === 'linearRampToValue';\n    };\n\n    var isAnyRampToValueAutomationEvent = function isAnyRampToValueAutomationEvent(automationEvent) {\n      return isExponentialRampToValueAutomationEvent(automationEvent) || isLinearRampToValueAutomationEvent(automationEvent);\n    };\n\n    var isSetValueAutomationEvent = function isSetValueAutomationEvent(automationEvent) {\n      return automationEvent.type === 'setValue';\n    };\n\n    var isSetValueCurveAutomationEvent = function isSetValueCurveAutomationEvent(automationEvent) {\n      return automationEvent.type === 'setValueCurve';\n    };\n\n    var getValueOfAutomationEventAtIndexAtTime = function getValueOfAutomationEventAtIndexAtTime(automationEvents, index, time, defaultValue) {\n      var automationEvent = automationEvents[index];\n      return automationEvent === undefined ? defaultValue : isAnyRampToValueAutomationEvent(automationEvent) || isSetValueAutomationEvent(automationEvent) ? automationEvent.value : isSetValueCurveAutomationEvent(automationEvent) ? automationEvent.values[automationEvent.values.length - 1] : getTargetValueAtTime(time, getValueOfAutomationEventAtIndexAtTime(automationEvents, index - 1, automationEvent.startTime, defaultValue), automationEvent);\n    };\n\n    var getEndTimeAndValueOfPreviousAutomationEvent = function getEndTimeAndValueOfPreviousAutomationEvent(automationEvents, index, currentAutomationEvent, nextAutomationEvent, defaultValue) {\n      return currentAutomationEvent === undefined ? [nextAutomationEvent.insertTime, defaultValue] : isAnyRampToValueAutomationEvent(currentAutomationEvent) ? [currentAutomationEvent.endTime, currentAutomationEvent.value] : isSetValueAutomationEvent(currentAutomationEvent) ? [currentAutomationEvent.startTime, currentAutomationEvent.value] : isSetValueCurveAutomationEvent(currentAutomationEvent) ? [currentAutomationEvent.startTime + currentAutomationEvent.duration, currentAutomationEvent.values[currentAutomationEvent.values.length - 1]] : [currentAutomationEvent.startTime, getValueOfAutomationEventAtIndexAtTime(automationEvents, index - 1, currentAutomationEvent.startTime, defaultValue)];\n    };\n\n    var isCancelAndHoldAutomationEvent = function isCancelAndHoldAutomationEvent(automationEvent) {\n      return automationEvent.type === 'cancelAndHold';\n    };\n\n    var isCancelScheduledValuesAutomationEvent = function isCancelScheduledValuesAutomationEvent(automationEvent) {\n      return automationEvent.type === 'cancelScheduledValues';\n    };\n\n    var getEventTime = function getEventTime(automationEvent) {\n      if (isCancelAndHoldAutomationEvent(automationEvent) || isCancelScheduledValuesAutomationEvent(automationEvent)) {\n        return automationEvent.cancelTime;\n      }\n\n      if (isExponentialRampToValueAutomationEvent(automationEvent) || isLinearRampToValueAutomationEvent(automationEvent)) {\n        return automationEvent.endTime;\n      }\n\n      return automationEvent.startTime;\n    };\n\n    var getExponentialRampValueAtTime = function getExponentialRampValueAtTime(time, startTime, valueAtStartTime, _ref) {\n      var endTime = _ref.endTime,\n          value = _ref.value;\n\n      if (valueAtStartTime === value) {\n        return value;\n      }\n\n      if (0 < valueAtStartTime && 0 < value || valueAtStartTime < 0 && value < 0) {\n        return valueAtStartTime * Math.pow(value / valueAtStartTime, (time - startTime) / (endTime - startTime));\n      }\n\n      return 0;\n    };\n\n    var getLinearRampValueAtTime = function getLinearRampValueAtTime(time, startTime, valueAtStartTime, _ref) {\n      var endTime = _ref.endTime,\n          value = _ref.value;\n      return valueAtStartTime + (time - startTime) / (endTime - startTime) * (value - valueAtStartTime);\n    };\n\n    var interpolateValue = function interpolateValue(values, theoreticIndex) {\n      var lowerIndex = Math.floor(theoreticIndex);\n      var upperIndex = Math.ceil(theoreticIndex);\n\n      if (lowerIndex === upperIndex) {\n        return values[lowerIndex];\n      }\n\n      return (1 - (theoreticIndex - lowerIndex)) * values[lowerIndex] + (1 - (upperIndex - theoreticIndex)) * values[upperIndex];\n    };\n\n    var getValueCurveValueAtTime = function getValueCurveValueAtTime(time, _ref) {\n      var duration = _ref.duration,\n          startTime = _ref.startTime,\n          values = _ref.values;\n      var theoreticIndex = (time - startTime) / duration * (values.length - 1);\n      return interpolateValue(values, theoreticIndex);\n    };\n\n    var isSetTargetAutomationEvent = function isSetTargetAutomationEvent(automationEvent) {\n      return automationEvent.type === 'setTarget';\n    };\n\n    var AutomationEventList = /*#__PURE__*/function (_Symbol$iterator) {\n      function AutomationEventList(defaultValue) {\n        _classCallCheck__default[\"default\"](this, AutomationEventList);\n\n        this._automationEvents = [];\n        this._currenTime = 0;\n        this._defaultValue = defaultValue;\n      }\n\n      _createClass__default[\"default\"](AutomationEventList, [{\n        key: _Symbol$iterator,\n        value: function value() {\n          return this._automationEvents[Symbol.iterator]();\n        }\n      }, {\n        key: \"add\",\n        value: function add(automationEvent) {\n          var eventTime = getEventTime(automationEvent);\n\n          if (isCancelAndHoldAutomationEvent(automationEvent) || isCancelScheduledValuesAutomationEvent(automationEvent)) {\n            var index = this._automationEvents.findIndex(function (currentAutomationEvent) {\n              if (isCancelScheduledValuesAutomationEvent(automationEvent) && isSetValueCurveAutomationEvent(currentAutomationEvent)) {\n                return currentAutomationEvent.startTime + currentAutomationEvent.duration >= eventTime;\n              }\n\n              return getEventTime(currentAutomationEvent) >= eventTime;\n            });\n\n            var removedAutomationEvent = this._automationEvents[index];\n\n            if (index !== -1) {\n              this._automationEvents = this._automationEvents.slice(0, index);\n            }\n\n            if (isCancelAndHoldAutomationEvent(automationEvent)) {\n              var lastAutomationEvent = this._automationEvents[this._automationEvents.length - 1];\n\n              if (removedAutomationEvent !== undefined && isAnyRampToValueAutomationEvent(removedAutomationEvent)) {\n                if (isSetTargetAutomationEvent(lastAutomationEvent)) {\n                  throw new Error('The internal list is malformed.');\n                }\n\n                var startTime = isSetValueCurveAutomationEvent(lastAutomationEvent) ? lastAutomationEvent.startTime + lastAutomationEvent.duration : getEventTime(lastAutomationEvent);\n                var startValue = isSetValueCurveAutomationEvent(lastAutomationEvent) ? lastAutomationEvent.values[lastAutomationEvent.values.length - 1] : lastAutomationEvent.value;\n                var value = isExponentialRampToValueAutomationEvent(removedAutomationEvent) ? getExponentialRampValueAtTime(eventTime, startTime, startValue, removedAutomationEvent) : getLinearRampValueAtTime(eventTime, startTime, startValue, removedAutomationEvent);\n                var truncatedAutomationEvent = isExponentialRampToValueAutomationEvent(removedAutomationEvent) ? createExtendedExponentialRampToValueAutomationEvent(value, eventTime, this._currenTime) : createExtendedLinearRampToValueAutomationEvent(value, eventTime, this._currenTime);\n\n                this._automationEvents.push(truncatedAutomationEvent);\n              }\n\n              if (lastAutomationEvent !== undefined && isSetTargetAutomationEvent(lastAutomationEvent)) {\n                this._automationEvents.push(createSetValueAutomationEvent(this.getValue(eventTime), eventTime));\n              }\n\n              if (lastAutomationEvent !== undefined && isSetValueCurveAutomationEvent(lastAutomationEvent) && lastAutomationEvent.startTime + lastAutomationEvent.duration > eventTime) {\n                this._automationEvents[this._automationEvents.length - 1] = createSetValueCurveAutomationEvent(new Float32Array([6, 7]), lastAutomationEvent.startTime, eventTime - lastAutomationEvent.startTime);\n              }\n            }\n          } else {\n            var _index = this._automationEvents.findIndex(function (currentAutomationEvent) {\n              return getEventTime(currentAutomationEvent) > eventTime;\n            });\n\n            var previousAutomationEvent = _index === -1 ? this._automationEvents[this._automationEvents.length - 1] : this._automationEvents[_index - 1];\n\n            if (previousAutomationEvent !== undefined && isSetValueCurveAutomationEvent(previousAutomationEvent) && getEventTime(previousAutomationEvent) + previousAutomationEvent.duration > eventTime) {\n              return false;\n            }\n\n            var persistentAutomationEvent = isExponentialRampToValueAutomationEvent(automationEvent) ? createExtendedExponentialRampToValueAutomationEvent(automationEvent.value, automationEvent.endTime, this._currenTime) : isLinearRampToValueAutomationEvent(automationEvent) ? createExtendedLinearRampToValueAutomationEvent(automationEvent.value, eventTime, this._currenTime) : automationEvent;\n\n            if (_index === -1) {\n              this._automationEvents.push(persistentAutomationEvent);\n            } else {\n              if (isSetValueCurveAutomationEvent(automationEvent) && eventTime + automationEvent.duration > getEventTime(this._automationEvents[_index])) {\n                return false;\n              }\n\n              this._automationEvents.splice(_index, 0, persistentAutomationEvent);\n            }\n          }\n\n          return true;\n        }\n      }, {\n        key: \"flush\",\n        value: function flush(time) {\n          var index = this._automationEvents.findIndex(function (currentAutomationEvent) {\n            return getEventTime(currentAutomationEvent) > time;\n          });\n\n          if (index > 1) {\n            var remainingAutomationEvents = this._automationEvents.slice(index - 1);\n\n            var firstRemainingAutomationEvent = remainingAutomationEvents[0];\n\n            if (isSetTargetAutomationEvent(firstRemainingAutomationEvent)) {\n              remainingAutomationEvents.unshift(createSetValueAutomationEvent(getValueOfAutomationEventAtIndexAtTime(this._automationEvents, index - 2, firstRemainingAutomationEvent.startTime, this._defaultValue), firstRemainingAutomationEvent.startTime));\n            }\n\n            this._automationEvents = remainingAutomationEvents;\n          }\n        }\n      }, {\n        key: \"getValue\",\n        value: function getValue(time) {\n          if (this._automationEvents.length === 0) {\n            return this._defaultValue;\n          }\n\n          var indexOfNextEvent = this._automationEvents.findIndex(function (automationEvent) {\n            return getEventTime(automationEvent) > time;\n          });\n\n          var nextAutomationEvent = this._automationEvents[indexOfNextEvent];\n          var indexOfCurrentEvent = (indexOfNextEvent === -1 ? this._automationEvents.length : indexOfNextEvent) - 1;\n          var currentAutomationEvent = this._automationEvents[indexOfCurrentEvent];\n\n          if (currentAutomationEvent !== undefined && isSetTargetAutomationEvent(currentAutomationEvent) && (nextAutomationEvent === undefined || !isAnyRampToValueAutomationEvent(nextAutomationEvent) || nextAutomationEvent.insertTime > time)) {\n            return getTargetValueAtTime(time, getValueOfAutomationEventAtIndexAtTime(this._automationEvents, indexOfCurrentEvent - 1, currentAutomationEvent.startTime, this._defaultValue), currentAutomationEvent);\n          }\n\n          if (currentAutomationEvent !== undefined && isSetValueAutomationEvent(currentAutomationEvent) && (nextAutomationEvent === undefined || !isAnyRampToValueAutomationEvent(nextAutomationEvent))) {\n            return currentAutomationEvent.value;\n          }\n\n          if (currentAutomationEvent !== undefined && isSetValueCurveAutomationEvent(currentAutomationEvent) && (nextAutomationEvent === undefined || !isAnyRampToValueAutomationEvent(nextAutomationEvent) || currentAutomationEvent.startTime + currentAutomationEvent.duration > time)) {\n            if (time < currentAutomationEvent.startTime + currentAutomationEvent.duration) {\n              return getValueCurveValueAtTime(time, currentAutomationEvent);\n            }\n\n            return currentAutomationEvent.values[currentAutomationEvent.values.length - 1];\n          }\n\n          if (currentAutomationEvent !== undefined && isAnyRampToValueAutomationEvent(currentAutomationEvent) && (nextAutomationEvent === undefined || !isAnyRampToValueAutomationEvent(nextAutomationEvent))) {\n            return currentAutomationEvent.value;\n          }\n\n          if (nextAutomationEvent !== undefined && isExponentialRampToValueAutomationEvent(nextAutomationEvent)) {\n            var _getEndTimeAndValueOf = getEndTimeAndValueOfPreviousAutomationEvent(this._automationEvents, indexOfCurrentEvent, currentAutomationEvent, nextAutomationEvent, this._defaultValue),\n                _getEndTimeAndValueOf2 = _slicedToArray__default[\"default\"](_getEndTimeAndValueOf, 2),\n                startTime = _getEndTimeAndValueOf2[0],\n                value = _getEndTimeAndValueOf2[1];\n\n            return getExponentialRampValueAtTime(time, startTime, value, nextAutomationEvent);\n          }\n\n          if (nextAutomationEvent !== undefined && isLinearRampToValueAutomationEvent(nextAutomationEvent)) {\n            var _getEndTimeAndValueOf3 = getEndTimeAndValueOfPreviousAutomationEvent(this._automationEvents, indexOfCurrentEvent, currentAutomationEvent, nextAutomationEvent, this._defaultValue),\n                _getEndTimeAndValueOf4 = _slicedToArray__default[\"default\"](_getEndTimeAndValueOf3, 2),\n                _startTime = _getEndTimeAndValueOf4[0],\n                _value = _getEndTimeAndValueOf4[1];\n\n            return getLinearRampValueAtTime(time, _startTime, _value, nextAutomationEvent);\n          }\n\n          return this._defaultValue;\n        }\n      }]);\n\n      return AutomationEventList;\n    }(Symbol.iterator);\n\n    var createCancelAndHoldAutomationEvent = function createCancelAndHoldAutomationEvent(cancelTime) {\n      return {\n        cancelTime: cancelTime,\n        type: 'cancelAndHold'\n      };\n    };\n\n    var createCancelScheduledValuesAutomationEvent = function createCancelScheduledValuesAutomationEvent(cancelTime) {\n      return {\n        cancelTime: cancelTime,\n        type: 'cancelScheduledValues'\n      };\n    };\n\n    var createExponentialRampToValueAutomationEvent = function createExponentialRampToValueAutomationEvent(value, endTime) {\n      return {\n        endTime: endTime,\n        type: 'exponentialRampToValue',\n        value: value\n      };\n    };\n\n    var createLinearRampToValueAutomationEvent = function createLinearRampToValueAutomationEvent(value, endTime) {\n      return {\n        endTime: endTime,\n        type: 'linearRampToValue',\n        value: value\n      };\n    };\n\n    var createSetTargetAutomationEvent = function createSetTargetAutomationEvent(target, startTime, timeConstant) {\n      return {\n        startTime: startTime,\n        target: target,\n        timeConstant: timeConstant,\n        type: 'setTarget'\n      };\n    };\n\n    exports.AutomationEventList = AutomationEventList;\n    exports.createCancelAndHoldAutomationEvent = createCancelAndHoldAutomationEvent;\n    exports.createCancelScheduledValuesAutomationEvent = createCancelScheduledValuesAutomationEvent;\n    exports.createExponentialRampToValueAutomationEvent = createExponentialRampToValueAutomationEvent;\n    exports.createLinearRampToValueAutomationEvent = createLinearRampToValueAutomationEvent;\n    exports.createSetTargetAutomationEvent = createSetTargetAutomationEvent;\n    exports.createSetValueAutomationEvent = createSetValueAutomationEvent;\n    exports.createSetValueCurveAutomationEvent = createSetValueCurveAutomationEvent;\n\n    Object.defineProperty(exports, '__esModule', { value: true });\n\n}));\n","// The module cache\nvar __webpack_module_cache__ = {};\n\n// The require function\nfunction __webpack_require__(moduleId) {\n\t// Check if module is in cache\n\tvar cachedModule = __webpack_module_cache__[moduleId];\n\tif (cachedModule !== undefined) {\n\t\treturn cachedModule.exports;\n\t}\n\t// Create a new module (and put it into the cache)\n\tvar module = __webpack_module_cache__[moduleId] = {\n\t\t// no module.id needed\n\t\t// no module.loaded needed\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\n","// define getter functions for harmony exports\n__webpack_require__.d = (exports, definition) => {\n\tfor(var key in definition) {\n\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n\t\t}\n\t}\n};","__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))","// define __esModule on exports\n__webpack_require__.r = (exports) => {\n\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n\t}\n\tObject.defineProperty(exports, '__esModule', { value: true });\n};","export const version: string = \"14.8.32\";\n","export const createAbortError = () => new DOMException('', 'AbortError');\n//# sourceMappingURL=abort-error.js.map","export const ACTIVE_AUDIO_NODE_STORE = new WeakSet();\nexport const AUDIO_NODE_CONNECTIONS_STORE = new WeakMap();\nexport const AUDIO_NODE_STORE = new WeakMap();\nexport const AUDIO_PARAM_CONNECTIONS_STORE = new WeakMap();\nexport const AUDIO_PARAM_STORE = new WeakMap();\nexport const CONTEXT_STORE = new WeakMap();\nexport const EVENT_LISTENERS = new WeakMap();\nexport const CYCLE_COUNTERS = new WeakMap();\n// This clunky name is borrowed from the spec. :-)\nexport const NODE_NAME_TO_PROCESSOR_CONSTRUCTOR_MAPS = new WeakMap();\nexport const NODE_TO_PROCESSOR_MAPS = new WeakMap();\n//# sourceMappingURL=globals.js.map","const handler = {\n    construct() {\n        return handler;\n    }\n};\nexport const isConstructible = (constructible) => {\n    try {\n        const proxy = new Proxy(constructible, handler);\n        new proxy(); // tslint:disable-line:no-unused-expression\n    }\n    catch {\n        return false;\n    }\n    return true;\n};\n//# sourceMappingURL=is-constructible.js.map","/*\n * This massive regex tries to cover all the following cases.\n *\n * import './path';\n * import defaultImport from './path';\n * import { namedImport } from './path';\n * import { namedImport as renamendImport } from './path';\n * import * as namespaceImport from './path';\n * import defaultImport, { namedImport } from './path';\n * import defaultImport, { namedImport as renamendImport } from './path';\n * import defaultImport, * as namespaceImport from './path';\n */\nconst IMPORT_STATEMENT_REGEX = /^import(?:(?:[\\s]+[\\w]+|(?:[\\s]+[\\w]+[\\s]*,)?[\\s]*\\{[\\s]*[\\w]+(?:[\\s]+as[\\s]+[\\w]+)?(?:[\\s]*,[\\s]*[\\w]+(?:[\\s]+as[\\s]+[\\w]+)?)*[\\s]*}|(?:[\\s]+[\\w]+[\\s]*,)?[\\s]*\\*[\\s]+as[\\s]+[\\w]+)[\\s]+from)?(?:[\\s]*)(\"([^\"\\\\]|\\\\.)+\"|'([^'\\\\]|\\\\.)+')(?:[\\s]*);?/; // tslint:disable-line:max-line-length\nexport const splitImportStatements = (source, url) => {\n    const importStatements = [];\n    let sourceWithoutImportStatements = source.replace(/^[\\s]+/, '');\n    let result = sourceWithoutImportStatements.match(IMPORT_STATEMENT_REGEX);\n    while (result !== null) {\n        const unresolvedUrl = result[1].slice(1, -1);\n        const importStatementWithResolvedUrl = result[0]\n            .replace(/([\\s]+)?;?$/, '')\n            .replace(unresolvedUrl, new URL(unresolvedUrl, url).toString());\n        importStatements.push(importStatementWithResolvedUrl);\n        sourceWithoutImportStatements = sourceWithoutImportStatements.slice(result[0].length).replace(/^[\\s]+/, '');\n        result = sourceWithoutImportStatements.match(IMPORT_STATEMENT_REGEX);\n    }\n    return [importStatements.join(';'), sourceWithoutImportStatements];\n};\n//# sourceMappingURL=split-import-statements.js.map","import { NODE_NAME_TO_PROCESSOR_CONSTRUCTOR_MAPS } from '../globals';\nimport { isConstructible } from '../helpers/is-constructible';\nimport { splitImportStatements } from '../helpers/split-import-statements';\nconst verifyParameterDescriptors = (parameterDescriptors) => {\n    if (parameterDescriptors !== undefined && !Array.isArray(parameterDescriptors)) {\n        throw new TypeError('The parameterDescriptors property of given value for processorCtor is not an array.');\n    }\n};\nconst verifyProcessorCtor = (processorCtor) => {\n    if (!isConstructible(processorCtor)) {\n        throw new TypeError('The given value for processorCtor should be a constructor.');\n    }\n    if (processorCtor.prototype === null || typeof processorCtor.prototype !== 'object') {\n        throw new TypeError('The given value for processorCtor should have a prototype.');\n    }\n};\nexport const createAddAudioWorkletModule = (cacheTestResult, createNotSupportedError, evaluateSource, exposeCurrentFrameAndCurrentTime, fetchSource, getNativeContext, getOrCreateBackupOfflineAudioContext, isNativeOfflineAudioContext, nativeAudioWorkletNodeConstructor, ongoingRequests, resolvedRequests, testAudioWorkletProcessorPostMessageSupport, window) => {\n    let index = 0;\n    return (context, moduleURL, options = { credentials: 'omit' }) => {\n        const resolvedRequestsOfContext = resolvedRequests.get(context);\n        if (resolvedRequestsOfContext !== undefined && resolvedRequestsOfContext.has(moduleURL)) {\n            return Promise.resolve();\n        }\n        const ongoingRequestsOfContext = ongoingRequests.get(context);\n        if (ongoingRequestsOfContext !== undefined) {\n            const promiseOfOngoingRequest = ongoingRequestsOfContext.get(moduleURL);\n            if (promiseOfOngoingRequest !== undefined) {\n                return promiseOfOngoingRequest;\n            }\n        }\n        const nativeContext = getNativeContext(context);\n        // Bug #59: Safari does not implement the audioWorklet property.\n        const promise = nativeContext.audioWorklet === undefined\n            ? fetchSource(moduleURL)\n                .then(([source, absoluteUrl]) => {\n                const [importStatements, sourceWithoutImportStatements] = splitImportStatements(source, absoluteUrl);\n                /*\n                 * This is the unminified version of the code used below:\n                 *\n                 * ```js\n                 * ${ importStatements };\n                 * ((a, b) => {\n                 *     (a[b] = a[b] || [ ]).push(\n                 *         (AudioWorkletProcessor, global, registerProcessor, sampleRate, self, window) => {\n                 *             ${ sourceWithoutImportStatements }\n                 *         }\n                 *     );\n                 * })(window, '_AWGS');\n                 * ```\n                 */\n                // tslint:disable-next-line:max-line-length\n                const wrappedSource = `${importStatements};((a,b)=>{(a[b]=a[b]||[]).push((AudioWorkletProcessor,global,registerProcessor,sampleRate,self,window)=>{${sourceWithoutImportStatements}\n})})(window,'_AWGS')`;\n                // @todo Evaluating the given source code is a possible security problem.\n                return evaluateSource(wrappedSource);\n            })\n                .then(() => {\n                const evaluateAudioWorkletGlobalScope = window._AWGS.pop();\n                if (evaluateAudioWorkletGlobalScope === undefined) {\n                    // Bug #182 Chrome, Edge and Opera do throw an instance of a SyntaxError instead of a DOMException.\n                    throw new SyntaxError();\n                }\n                exposeCurrentFrameAndCurrentTime(nativeContext.currentTime, nativeContext.sampleRate, () => evaluateAudioWorkletGlobalScope(class AudioWorkletProcessor {\n                }, undefined, (name, processorCtor) => {\n                    if (name.trim() === '') {\n                        throw createNotSupportedError();\n                    }\n                    const nodeNameToProcessorConstructorMap = NODE_NAME_TO_PROCESSOR_CONSTRUCTOR_MAPS.get(nativeContext);\n                    if (nodeNameToProcessorConstructorMap !== undefined) {\n                        if (nodeNameToProcessorConstructorMap.has(name)) {\n                            throw createNotSupportedError();\n                        }\n                        verifyProcessorCtor(processorCtor);\n                        verifyParameterDescriptors(processorCtor.parameterDescriptors);\n                        nodeNameToProcessorConstructorMap.set(name, processorCtor);\n                    }\n                    else {\n                        verifyProcessorCtor(processorCtor);\n                        verifyParameterDescriptors(processorCtor.parameterDescriptors);\n                        NODE_NAME_TO_PROCESSOR_CONSTRUCTOR_MAPS.set(nativeContext, new Map([[name, processorCtor]]));\n                    }\n                }, nativeContext.sampleRate, undefined, undefined));\n            })\n            : Promise.all([\n                fetchSource(moduleURL),\n                Promise.resolve(cacheTestResult(testAudioWorkletProcessorPostMessageSupport, testAudioWorkletProcessorPostMessageSupport))\n            ]).then(([[source, absoluteUrl], isSupportingPostMessage]) => {\n                const currentIndex = index + 1;\n                index = currentIndex;\n                const [importStatements, sourceWithoutImportStatements] = splitImportStatements(source, absoluteUrl);\n                /*\n                 * Bug #179: Firefox does not allow to transfer any buffer which has been passed to the process() method as an argument.\n                 *\n                 * This is the unminified version of the code used below.\n                 *\n                 * ```js\n                 * class extends AudioWorkletProcessor {\n                 *\n                 *     __buffers = new WeakSet();\n                 *\n                 *     constructor () {\n                 *         super();\n                 *\n                 *         this.port.postMessage = ((postMessage) => {\n                 *             return (message, transferables) => {\n                 *                 const filteredTransferables = (transferables)\n                 *                     ? transferables.filter((transferable) => !this.__buffers.has(transferable))\n                 *                     : transferables;\n                 *\n                 *                 return postMessage.call(this.port, message, filteredTransferables);\n                 *              };\n                 *         })(this.port.postMessage);\n                 *     }\n                 * }\n                 * ```\n                 */\n                const patchedAudioWorkletProcessor = isSupportingPostMessage\n                    ? 'AudioWorkletProcessor'\n                    : 'class extends AudioWorkletProcessor {__b=new WeakSet();constructor(){super();(p=>p.postMessage=(q=>(m,t)=>q.call(p,m,t?t.filter(u=>!this.__b.has(u)):t))(p.postMessage))(this.port)}}';\n                /*\n                 * Bug #170: Chrome and Edge do call process() with an array with empty channelData for each input if no input is connected.\n                 *\n                 * Bug #179: Firefox does not allow to transfer any buffer which has been passed to the process() method as an argument.\n                 *\n                 * Bug #190: Safari doesn't throw an error when loading an unparsable module.\n                 *\n                 * This is the unminified version of the code used below:\n                 *\n                 * ```js\n                 * `${ importStatements };\n                 * ((AudioWorkletProcessor, registerProcessor) => {${ sourceWithoutImportStatements }\n                 * })(\n                 *     ${ patchedAudioWorkletProcessor },\n                 *     (name, processorCtor) => registerProcessor(name, class extends processorCtor {\n                 *\n                 *         __collectBuffers = (array) => {\n                 *             array.forEach((element) => this.__buffers.add(element.buffer));\n                 *         };\n                 *\n                 *         process (inputs, outputs, parameters) {\n                 *             inputs.forEach(this.__collectBuffers);\n                 *             outputs.forEach(this.__collectBuffers);\n                 *             this.__collectBuffers(Object.values(parameters));\n                 *\n                 *             return super.process(\n                 *                 (inputs.map((input) => input.some((channelData) => channelData.length === 0)) ? [ ] : input),\n                 *                 outputs,\n                 *                 parameters\n                 *             );\n                 *         }\n                 *\n                 *     })\n                 * );\n                 *\n                 * registerProcessor(`__sac${currentIndex}`, class extends AudioWorkletProcessor{\n                 *\n                 *     process () {\n                 *         return false;\n                 *     }\n                 *\n                 * })`\n                 * ```\n                 */\n                const memberDefinition = isSupportingPostMessage ? '' : '__c = (a) => a.forEach(e=>this.__b.add(e.buffer));';\n                const bufferRegistration = isSupportingPostMessage\n                    ? ''\n                    : 'i.forEach(this.__c);o.forEach(this.__c);this.__c(Object.values(p));';\n                const wrappedSource = `${importStatements};((AudioWorkletProcessor,registerProcessor)=>{${sourceWithoutImportStatements}\n})(${patchedAudioWorkletProcessor},(n,p)=>registerProcessor(n,class extends p{${memberDefinition}process(i,o,p){${bufferRegistration}return super.process(i.map(j=>j.some(k=>k.length===0)?[]:j),o,p)}}));registerProcessor('__sac${currentIndex}',class extends AudioWorkletProcessor{process(){return !1}})`;\n                const blob = new Blob([wrappedSource], { type: 'application/javascript; charset=utf-8' });\n                const url = URL.createObjectURL(blob);\n                return nativeContext.audioWorklet\n                    .addModule(url, options)\n                    .then(() => {\n                    if (isNativeOfflineAudioContext(nativeContext)) {\n                        return nativeContext;\n                    }\n                    // Bug #186: Chrome, Edge and Opera do not allow to create an AudioWorkletNode on a closed AudioContext.\n                    const backupOfflineAudioContext = getOrCreateBackupOfflineAudioContext(nativeContext);\n                    return backupOfflineAudioContext.audioWorklet.addModule(url, options).then(() => backupOfflineAudioContext);\n                })\n                    .then((nativeContextOrBackupOfflineAudioContext) => {\n                    if (nativeAudioWorkletNodeConstructor === null) {\n                        throw new SyntaxError();\n                    }\n                    try {\n                        // Bug #190: Safari doesn't throw an error when loading an unparsable module.\n                        new nativeAudioWorkletNodeConstructor(nativeContextOrBackupOfflineAudioContext, `__sac${currentIndex}`); // tslint:disable-line:no-unused-expression\n                    }\n                    catch {\n                        throw new SyntaxError();\n                    }\n                })\n                    .finally(() => URL.revokeObjectURL(url));\n            });\n        if (ongoingRequestsOfContext === undefined) {\n            ongoingRequests.set(context, new Map([[moduleURL, promise]]));\n        }\n        else {\n            ongoingRequestsOfContext.set(moduleURL, promise);\n        }\n        promise\n            .then(() => {\n            const updatedResolvedRequestsOfContext = resolvedRequests.get(context);\n            if (updatedResolvedRequestsOfContext === undefined) {\n                resolvedRequests.set(context, new Set([moduleURL]));\n            }\n            else {\n                updatedResolvedRequestsOfContext.add(moduleURL);\n            }\n        })\n            .finally(() => {\n            const updatedOngoingRequestsOfContext = ongoingRequests.get(context);\n            if (updatedOngoingRequestsOfContext !== undefined) {\n                updatedOngoingRequestsOfContext.delete(moduleURL);\n            }\n        });\n        return promise;\n    };\n};\n//# sourceMappingURL=add-audio-worklet-module.js.map","export const getValueForKey = (map, key) => {\n    const value = map.get(key);\n    if (value === undefined) {\n        throw new Error('A value with the given key could not be found.');\n    }\n    return value;\n};\n//# sourceMappingURL=get-value-for-key.js.map","export const pickElementFromSet = (set, predicate) => {\n    const matchingElements = Array.from(set).filter(predicate);\n    if (matchingElements.length > 1) {\n        throw Error('More than one element was found.');\n    }\n    if (matchingElements.length === 0) {\n        throw Error('No element was found.');\n    }\n    const [matchingElement] = matchingElements;\n    set.delete(matchingElement);\n    return matchingElement;\n};\n//# sourceMappingURL=pick-element-from-set.js.map","import { getValueForKey } from './get-value-for-key';\nimport { pickElementFromSet } from './pick-element-from-set';\nexport const deletePassiveInputConnectionToAudioNode = (passiveInputs, source, output, input) => {\n    const passiveInputConnections = getValueForKey(passiveInputs, source);\n    const matchingConnection = pickElementFromSet(passiveInputConnections, (passiveInputConnection) => passiveInputConnection[0] === output && passiveInputConnection[1] === input);\n    if (passiveInputConnections.size === 0) {\n        passiveInputs.delete(source);\n    }\n    return matchingConnection;\n};\n//# sourceMappingURL=delete-passive-input-connection-to-audio-node.js.map","import { EVENT_LISTENERS } from '../globals';\nimport { getValueForKey } from './get-value-for-key';\nexport const getEventListenersOfAudioNode = (audioNode) => {\n    return getValueForKey(EVENT_LISTENERS, audioNode);\n};\n//# sourceMappingURL=get-event-listeners-of-audio-node.js.map","import { ACTIVE_AUDIO_NODE_STORE } from '../globals';\nimport { getEventListenersOfAudioNode } from './get-event-listeners-of-audio-node';\nexport const setInternalStateToActive = (audioNode) => {\n    if (ACTIVE_AUDIO_NODE_STORE.has(audioNode)) {\n        throw new Error('The AudioNode is already stored.');\n    }\n    ACTIVE_AUDIO_NODE_STORE.add(audioNode);\n    getEventListenersOfAudioNode(audioNode).forEach((eventListener) => eventListener(true));\n};\n//# sourceMappingURL=set-internal-state-to-active.js.map","export const isAudioWorkletNode = (audioNode) => {\n    return 'port' in audioNode;\n};\n//# sourceMappingURL=audio-worklet-node.js.map","import { ACTIVE_AUDIO_NODE_STORE } from '../globals';\nimport { getEventListenersOfAudioNode } from './get-event-listeners-of-audio-node';\nexport const setInternalStateToPassive = (audioNode) => {\n    if (!ACTIVE_AUDIO_NODE_STORE.has(audioNode)) {\n        throw new Error('The AudioNode is not stored.');\n    }\n    ACTIVE_AUDIO_NODE_STORE.delete(audioNode);\n    getEventListenersOfAudioNode(audioNode).forEach((eventListener) => eventListener(false));\n};\n//# sourceMappingURL=set-internal-state-to-passive.js.map","import { isAudioWorkletNode } from '../guards/audio-worklet-node';\nimport { setInternalStateToPassive } from './set-internal-state-to-passive';\n// Set the internalState of the audioNode to 'passive' if it is not an AudioWorkletNode and if it has no 'active' input connections.\nexport const setInternalStateToPassiveWhenNecessary = (audioNode, activeInputs) => {\n    if (!isAudioWorkletNode(audioNode) && activeInputs.every((connections) => connections.size === 0)) {\n        setInternalStateToPassive(audioNode);\n    }\n};\n//# sourceMappingURL=set-internal-state-to-passive-when-necessary.js.map","const DEFAULT_OPTIONS = {\n    channelCount: 2,\n    channelCountMode: 'max',\n    channelInterpretation: 'speakers',\n    fftSize: 2048,\n    maxDecibels: -30,\n    minDecibels: -100,\n    smoothingTimeConstant: 0.8\n};\nexport const createAnalyserNodeConstructor = (audionNodeConstructor, createAnalyserNodeRenderer, createIndexSizeError, createNativeAnalyserNode, getNativeContext, isNativeOfflineAudioContext) => {\n    return class AnalyserNode extends audionNodeConstructor {\n        constructor(context, options) {\n            const nativeContext = getNativeContext(context);\n            const mergedOptions = { ...DEFAULT_OPTIONS, ...options };\n            const nativeAnalyserNode = createNativeAnalyserNode(nativeContext, mergedOptions);\n            const analyserNodeRenderer = ((isNativeOfflineAudioContext(nativeContext) ? createAnalyserNodeRenderer() : null));\n            super(context, false, nativeAnalyserNode, analyserNodeRenderer);\n            this._nativeAnalyserNode = nativeAnalyserNode;\n        }\n        get fftSize() {\n            return this._nativeAnalyserNode.fftSize;\n        }\n        set fftSize(value) {\n            this._nativeAnalyserNode.fftSize = value;\n        }\n        get frequencyBinCount() {\n            return this._nativeAnalyserNode.frequencyBinCount;\n        }\n        get maxDecibels() {\n            return this._nativeAnalyserNode.maxDecibels;\n        }\n        set maxDecibels(value) {\n            // Bug #118: Safari does not throw an error if maxDecibels is not more than minDecibels.\n            const maxDecibels = this._nativeAnalyserNode.maxDecibels;\n            this._nativeAnalyserNode.maxDecibels = value;\n            if (!(value > this._nativeAnalyserNode.minDecibels)) {\n                this._nativeAnalyserNode.maxDecibels = maxDecibels;\n                throw createIndexSizeError();\n            }\n        }\n        get minDecibels() {\n            return this._nativeAnalyserNode.minDecibels;\n        }\n        set minDecibels(value) {\n            // Bug #118: Safari does not throw an error if maxDecibels is not more than minDecibels.\n            const minDecibels = this._nativeAnalyserNode.minDecibels;\n            this._nativeAnalyserNode.minDecibels = value;\n            if (!(this._nativeAnalyserNode.maxDecibels > value)) {\n                this._nativeAnalyserNode.minDecibels = minDecibels;\n                throw createIndexSizeError();\n            }\n        }\n        get smoothingTimeConstant() {\n            return this._nativeAnalyserNode.smoothingTimeConstant;\n        }\n        set smoothingTimeConstant(value) {\n            this._nativeAnalyserNode.smoothingTimeConstant = value;\n        }\n        getByteFrequencyData(array) {\n            this._nativeAnalyserNode.getByteFrequencyData(array);\n        }\n        getByteTimeDomainData(array) {\n            this._nativeAnalyserNode.getByteTimeDomainData(array);\n        }\n        getFloatFrequencyData(array) {\n            this._nativeAnalyserNode.getFloatFrequencyData(array);\n        }\n        getFloatTimeDomainData(array) {\n            this._nativeAnalyserNode.getFloatTimeDomainData(array);\n        }\n    };\n};\n//# sourceMappingURL=analyser-node-constructor.js.map","export const isOwnedByContext = (nativeAudioNode, nativeContext) => {\n    return nativeAudioNode.context === nativeContext;\n};\n//# sourceMappingURL=is-owned-by-context.js.map","export const testAudioBufferCopyChannelMethodsOutOfBoundsSupport = (nativeAudioBuffer) => {\n    try {\n        nativeAudioBuffer.copyToChannel(new Float32Array(1), 0, -1);\n    }\n    catch {\n        return false;\n    }\n    return true;\n};\n//# sourceMappingURL=test-audio-buffer-copy-channel-methods-out-of-bounds-support.js.map","export const createIndexSizeError = () => new DOMException('', 'IndexSizeError');\n//# sourceMappingURL=index-size-error.js.map","import { createIndexSizeError } from '../factories/index-size-error';\nexport const wrapAudioBufferGetChannelDataMethod = (audioBuffer) => {\n    audioBuffer.getChannelData = ((getChannelData) => {\n        return (channel) => {\n            try {\n                return getChannelData.call(audioBuffer, channel);\n            }\n            catch (err) {\n                if (err.code === 12) {\n                    throw createIndexSizeError();\n                }\n                throw err;\n            }\n        };\n    })(audioBuffer.getChannelData);\n};\n//# sourceMappingURL=wrap-audio-buffer-get-channel-data-method.js.map","import { testAudioBufferCopyChannelMethodsOutOfBoundsSupport } from '../helpers/test-audio-buffer-copy-channel-methods-out-of-bounds-support';\nimport { wrapAudioBufferGetChannelDataMethod } from '../helpers/wrap-audio-buffer-get-channel-data-method';\nconst DEFAULT_OPTIONS = {\n    numberOfChannels: 1\n};\nexport const createAudioBufferConstructor = (audioBufferStore, cacheTestResult, createNotSupportedError, nativeAudioBufferConstructor, nativeOfflineAudioContextConstructor, testNativeAudioBufferConstructorSupport, wrapAudioBufferCopyChannelMethods, wrapAudioBufferCopyChannelMethodsOutOfBounds) => {\n    let nativeOfflineAudioContext = null;\n    return class AudioBuffer {\n        constructor(options) {\n            if (nativeOfflineAudioContextConstructor === null) {\n                throw new Error('Missing the native OfflineAudioContext constructor.');\n            }\n            const { length, numberOfChannels, sampleRate } = { ...DEFAULT_OPTIONS, ...options };\n            if (nativeOfflineAudioContext === null) {\n                nativeOfflineAudioContext = new nativeOfflineAudioContextConstructor(1, 1, 44100);\n            }\n            /*\n             * Bug #99: Firefox does not throw a NotSupportedError when the numberOfChannels is zero. But it only does it when using the\n             * factory function. But since Firefox also supports the constructor everything should be fine.\n             */\n            const audioBuffer = nativeAudioBufferConstructor !== null &&\n                cacheTestResult(testNativeAudioBufferConstructorSupport, testNativeAudioBufferConstructorSupport)\n                ? new nativeAudioBufferConstructor({ length, numberOfChannels, sampleRate })\n                : nativeOfflineAudioContext.createBuffer(numberOfChannels, length, sampleRate);\n            // Bug #99: Safari does not throw an error when the numberOfChannels is zero.\n            if (audioBuffer.numberOfChannels === 0) {\n                throw createNotSupportedError();\n            }\n            // Bug #5: Safari does not support copyFromChannel() and copyToChannel().\n            // Bug #100: Safari does throw a wrong error when calling getChannelData() with an out-of-bounds value.\n            if (typeof audioBuffer.copyFromChannel !== 'function') {\n                wrapAudioBufferCopyChannelMethods(audioBuffer);\n                wrapAudioBufferGetChannelDataMethod(audioBuffer);\n                // Bug #157: Firefox does not allow the bufferOffset to be out-of-bounds.\n            }\n            else if (!cacheTestResult(testAudioBufferCopyChannelMethodsOutOfBoundsSupport, () => testAudioBufferCopyChannelMethodsOutOfBoundsSupport(audioBuffer))) {\n                wrapAudioBufferCopyChannelMethodsOutOfBounds(audioBuffer);\n            }\n            audioBufferStore.add(audioBuffer);\n            /*\n             * This does violate all good pratices but it is necessary to allow this AudioBuffer to be used with native\n             * (Offline)AudioContexts.\n             */\n            return audioBuffer;\n        }\n        static [Symbol.hasInstance](instance) {\n            return ((instance !== null && typeof instance === 'object' && Object.getPrototypeOf(instance) === AudioBuffer.prototype) ||\n                audioBufferStore.has(instance));\n        }\n    };\n};\n//# sourceMappingURL=audio-buffer-constructor.js.map","export const MOST_NEGATIVE_SINGLE_FLOAT = -3.4028234663852886e38;\nexport const MOST_POSITIVE_SINGLE_FLOAT = -MOST_NEGATIVE_SINGLE_FLOAT;\n//# sourceMappingURL=constants.js.map","import { ACTIVE_AUDIO_NODE_STORE } from '../globals';\nexport const isActiveAudioNode = (audioNode) => ACTIVE_AUDIO_NODE_STORE.has(audioNode);\n//# sourceMappingURL=is-active-audio-node.js.map","import { MOST_NEGATIVE_SINGLE_FLOAT, MOST_POSITIVE_SINGLE_FLOAT } from '../constants';\nimport { isActiveAudioNode } from '../helpers/is-active-audio-node';\nimport { setInternalStateToActive } from '../helpers/set-internal-state-to-active';\nimport { setInternalStateToPassive } from '../helpers/set-internal-state-to-passive';\nconst DEFAULT_OPTIONS = {\n    buffer: null,\n    channelCount: 2,\n    channelCountMode: 'max',\n    channelInterpretation: 'speakers',\n    // Bug #149: Safari does not yet support the detune AudioParam.\n    loop: false,\n    loopEnd: 0,\n    loopStart: 0,\n    playbackRate: 1\n};\nexport const createAudioBufferSourceNodeConstructor = (audioNodeConstructor, createAudioBufferSourceNodeRenderer, createAudioParam, createInvalidStateError, createNativeAudioBufferSourceNode, getNativeContext, isNativeOfflineAudioContext, wrapEventListener) => {\n    return class AudioBufferSourceNode extends audioNodeConstructor {\n        constructor(context, options) {\n            const nativeContext = getNativeContext(context);\n            const mergedOptions = { ...DEFAULT_OPTIONS, ...options };\n            const nativeAudioBufferSourceNode = createNativeAudioBufferSourceNode(nativeContext, mergedOptions);\n            const isOffline = isNativeOfflineAudioContext(nativeContext);\n            const audioBufferSourceNodeRenderer = ((isOffline ? createAudioBufferSourceNodeRenderer() : null));\n            super(context, false, nativeAudioBufferSourceNode, audioBufferSourceNodeRenderer);\n            this._audioBufferSourceNodeRenderer = audioBufferSourceNodeRenderer;\n            this._isBufferNullified = false;\n            this._isBufferSet = mergedOptions.buffer !== null;\n            this._nativeAudioBufferSourceNode = nativeAudioBufferSourceNode;\n            this._onended = null;\n            // Bug #73: Safari does not export the correct values for maxValue and minValue.\n            this._playbackRate = createAudioParam(this, isOffline, nativeAudioBufferSourceNode.playbackRate, MOST_POSITIVE_SINGLE_FLOAT, MOST_NEGATIVE_SINGLE_FLOAT);\n        }\n        get buffer() {\n            if (this._isBufferNullified) {\n                return null;\n            }\n            return this._nativeAudioBufferSourceNode.buffer;\n        }\n        set buffer(value) {\n            this._nativeAudioBufferSourceNode.buffer = value;\n            // Bug #72: Only Chrome, Edge & Opera do not allow to reassign the buffer yet.\n            if (value !== null) {\n                if (this._isBufferSet) {\n                    throw createInvalidStateError();\n                }\n                this._isBufferSet = true;\n            }\n        }\n        get loop() {\n            return this._nativeAudioBufferSourceNode.loop;\n        }\n        set loop(value) {\n            this._nativeAudioBufferSourceNode.loop = value;\n        }\n        get loopEnd() {\n            return this._nativeAudioBufferSourceNode.loopEnd;\n        }\n        set loopEnd(value) {\n            this._nativeAudioBufferSourceNode.loopEnd = value;\n        }\n        get loopStart() {\n            return this._nativeAudioBufferSourceNode.loopStart;\n        }\n        set loopStart(value) {\n            this._nativeAudioBufferSourceNode.loopStart = value;\n        }\n        get onended() {\n            return this._onended;\n        }\n        set onended(value) {\n            const wrappedListener = typeof value === 'function' ? wrapEventListener(this, value) : null;\n            this._nativeAudioBufferSourceNode.onended = wrappedListener;\n            const nativeOnEnded = this._nativeAudioBufferSourceNode.onended;\n            this._onended = nativeOnEnded !== null && nativeOnEnded === wrappedListener ? value : nativeOnEnded;\n        }\n        get playbackRate() {\n            return this._playbackRate;\n        }\n        start(when = 0, offset = 0, duration) {\n            this._nativeAudioBufferSourceNode.start(when, offset, duration);\n            if (this._audioBufferSourceNodeRenderer !== null) {\n                this._audioBufferSourceNodeRenderer.start = duration === undefined ? [when, offset] : [when, offset, duration];\n            }\n            if (this.context.state !== 'closed') {\n                setInternalStateToActive(this);\n                const resetInternalStateToPassive = () => {\n                    this._nativeAudioBufferSourceNode.removeEventListener('ended', resetInternalStateToPassive);\n                    if (isActiveAudioNode(this)) {\n                        setInternalStateToPassive(this);\n                    }\n                };\n                this._nativeAudioBufferSourceNode.addEventListener('ended', resetInternalStateToPassive);\n            }\n        }\n        stop(when = 0) {\n            this._nativeAudioBufferSourceNode.stop(when);\n            if (this._audioBufferSourceNodeRenderer !== null) {\n                this._audioBufferSourceNodeRenderer.stop = when;\n            }\n        }\n    };\n};\n//# sourceMappingURL=audio-buffer-source-node-constructor.js.map","import { AUDIO_NODE_CONNECTIONS_STORE } from '../globals';\nimport { getValueForKey } from './get-value-for-key';\nexport const getAudioNodeConnections = (audioNode) => {\n    return getValueForKey(AUDIO_NODE_CONNECTIONS_STORE, audioNode);\n};\n//# sourceMappingURL=get-audio-node-connections.js.map","import { AUDIO_PARAM_CONNECTIONS_STORE } from '../globals';\nimport { getValueForKey } from './get-value-for-key';\nexport const getAudioParamConnections = (audioParam) => {\n    return getValueForKey(AUDIO_PARAM_CONNECTIONS_STORE, audioParam);\n};\n//# sourceMappingURL=get-audio-param-connections.js.map","import { isAudioBufferSourceNode } from '../guards/audio-buffer-source-node';\nimport { isAudioWorkletNode } from '../guards/audio-worklet-node';\nimport { isBiquadFilterNode } from '../guards/biquad-filter-node';\nimport { isConstantSourceNode } from '../guards/constant-source-node';\nimport { isGainNode } from '../guards/gain-node';\nimport { isOscillatorNode } from '../guards/oscillator-node';\nimport { isStereoPannerNode } from '../guards/stereo-panner-node';\nimport { getAudioNodeConnections } from './get-audio-node-connections';\nimport { getAudioParamConnections } from './get-audio-param-connections';\nimport { isActiveAudioNode } from './is-active-audio-node';\nimport { setInternalStateToPassive } from './set-internal-state-to-passive';\nexport const deactivateActiveAudioNodeInputConnections = (audioNode, trace) => {\n    const { activeInputs } = getAudioNodeConnections(audioNode);\n    activeInputs.forEach((connections) => connections.forEach(([source]) => {\n        if (!trace.includes(audioNode)) {\n            deactivateActiveAudioNodeInputConnections(source, [...trace, audioNode]);\n        }\n    }));\n    const audioParams = isAudioBufferSourceNode(audioNode)\n        ? [\n            // Bug #149: Safari does not yet support the detune AudioParam.\n            audioNode.playbackRate\n        ]\n        : isAudioWorkletNode(audioNode)\n            ? Array.from(audioNode.parameters.values())\n            : isBiquadFilterNode(audioNode)\n                ? [audioNode.Q, audioNode.detune, audioNode.frequency, audioNode.gain]\n                : isConstantSourceNode(audioNode)\n                    ? [audioNode.offset]\n                    : isGainNode(audioNode)\n                        ? [audioNode.gain]\n                        : isOscillatorNode(audioNode)\n                            ? [audioNode.detune, audioNode.frequency]\n                            : isStereoPannerNode(audioNode)\n                                ? [audioNode.pan]\n                                : [];\n    for (const audioParam of audioParams) {\n        const audioParamConnections = getAudioParamConnections(audioParam);\n        if (audioParamConnections !== undefined) {\n            audioParamConnections.activeInputs.forEach(([source]) => deactivateActiveAudioNodeInputConnections(source, trace));\n        }\n    }\n    if (isActiveAudioNode(audioNode)) {\n        setInternalStateToPassive(audioNode);\n    }\n};\n//# sourceMappingURL=deactivate-active-audio-node-input-connections.js.map","export const isAudioBufferSourceNode = (audioNode) => {\n    return 'playbackRate' in audioNode;\n};\n//# sourceMappingURL=audio-buffer-source-node.js.map","export const isBiquadFilterNode = (audioNode) => {\n    return 'frequency' in audioNode && 'gain' in audioNode;\n};\n//# sourceMappingURL=biquad-filter-node.js.map","export const isConstantSourceNode = (audioNode) => {\n    return 'offset' in audioNode;\n};\n//# sourceMappingURL=constant-source-node.js.map","export const isGainNode = (audioNode) => {\n    return !('frequency' in audioNode) && 'gain' in audioNode;\n};\n//# sourceMappingURL=gain-node.js.map","export const isOscillatorNode = (audioNode) => {\n    return 'detune' in audioNode && 'frequency' in audioNode;\n};\n//# sourceMappingURL=oscillator-node.js.map","export const isStereoPannerNode = (audioNode) => {\n    return 'pan' in audioNode;\n};\n//# sourceMappingURL=stereo-panner-node.js.map","import { deactivateActiveAudioNodeInputConnections } from './deactivate-active-audio-node-input-connections';\nexport const deactivateAudioGraph = (context) => {\n    deactivateActiveAudioNodeInputConnections(context.destination, []);\n};\n//# sourceMappingURL=deactivate-audio-graph.js.map","export const isAudioNode = (audioNodeOrAudioParam) => {\n    return 'context' in audioNodeOrAudioParam;\n};\n//# sourceMappingURL=audio-node.js.map","import { isAudioNode } from './audio-node';\nexport const isAudioNodeOutputConnection = (outputConnection) => {\n    return isAudioNode(outputConnection[0]);\n};\n//# sourceMappingURL=audio-node-output-connection.js.map","export const insertElementInSet = (set, element, predicate, ignoreDuplicates) => {\n    for (const lmnt of set) {\n        if (predicate(lmnt)) {\n            if (ignoreDuplicates) {\n                return false;\n            }\n            throw Error('The set contains at least one similar element.');\n        }\n    }\n    set.add(element);\n    return true;\n};\n//# sourceMappingURL=insert-element-in-set.js.map","import { insertElementInSet } from './insert-element-in-set';\nexport const addActiveInputConnectionToAudioParam = (activeInputs, source, [output, eventListener], ignoreDuplicates) => {\n    insertElementInSet(activeInputs, [source, output, eventListener], (activeInputConnection) => activeInputConnection[0] === source && activeInputConnection[1] === output, ignoreDuplicates);\n};\n//# sourceMappingURL=add-active-input-connection-to-audio-param.js.map","import { insertElementInSet } from './insert-element-in-set';\nexport const addPassiveInputConnectionToAudioParam = (passiveInputs, [source, output, eventListener], ignoreDuplicates) => {\n    const passiveInputConnections = passiveInputs.get(source);\n    if (passiveInputConnections === undefined) {\n        passiveInputs.set(source, new Set([[output, eventListener]]));\n    }\n    else {\n        insertElementInSet(passiveInputConnections, [output, eventListener], (passiveInputConnection) => passiveInputConnection[0] === output, ignoreDuplicates);\n    }\n};\n//# sourceMappingURL=add-passive-input-connection-to-audio-param.js.map","export const isNativeAudioNodeFaker = (nativeAudioNodeOrNativeAudioNodeFaker) => {\n    return 'inputs' in nativeAudioNodeOrNativeAudioNodeFaker;\n};\n//# sourceMappingURL=native-audio-node-faker.js.map","import { isNativeAudioNodeFaker } from '../guards/native-audio-node-faker';\nexport const connectNativeAudioNodeToNativeAudioNode = (nativeSourceAudioNode, nativeDestinationAudioNode, output, input) => {\n    if (isNativeAudioNodeFaker(nativeDestinationAudioNode)) {\n        const fakeNativeDestinationAudioNode = nativeDestinationAudioNode.inputs[input];\n        nativeSourceAudioNode.connect(fakeNativeDestinationAudioNode, output, 0);\n        return [fakeNativeDestinationAudioNode, output, 0];\n    }\n    nativeSourceAudioNode.connect(nativeDestinationAudioNode, output, input);\n    return [nativeDestinationAudioNode, output, input];\n};\n//# sourceMappingURL=connect-native-audio-node-to-native-audio-node.js.map","export const deleteActiveInputConnection = (activeInputConnections, source, output) => {\n    for (const activeInputConnection of activeInputConnections) {\n        if (activeInputConnection[0] === source && activeInputConnection[1] === output) {\n            activeInputConnections.delete(activeInputConnection);\n            return activeInputConnection;\n        }\n    }\n    return null;\n};\n//# sourceMappingURL=delete-active-input-connection.js.map","import { getEventListenersOfAudioNode } from './get-event-listeners-of-audio-node';\nexport const deleteEventListenerOfAudioNode = (audioNode, eventListener) => {\n    const eventListeners = getEventListenersOfAudioNode(audioNode);\n    if (!eventListeners.delete(eventListener)) {\n        throw new Error('Missing the expected event listener.');\n    }\n};\n//# sourceMappingURL=delete-event-listeners-of-audio-node.js.map","import { getValueForKey } from './get-value-for-key';\nimport { pickElementFromSet } from './pick-element-from-set';\nexport const deletePassiveInputConnectionToAudioParam = (passiveInputs, source, output) => {\n    const passiveInputConnections = getValueForKey(passiveInputs, source);\n    const matchingConnection = pickElementFromSet(passiveInputConnections, (passiveInputConnection) => passiveInputConnection[0] === output);\n    if (passiveInputConnections.size === 0) {\n        passiveInputs.delete(source);\n    }\n    return matchingConnection;\n};\n//# sourceMappingURL=delete-passive-input-connection-to-audio-param.js.map","import { isNativeAudioNodeFaker } from '../guards/native-audio-node-faker';\nexport const disconnectNativeAudioNodeFromNativeAudioNode = (nativeSourceAudioNode, nativeDestinationAudioNode, output, input) => {\n    if (isNativeAudioNodeFaker(nativeDestinationAudioNode)) {\n        nativeSourceAudioNode.disconnect(nativeDestinationAudioNode.inputs[input], output, 0);\n    }\n    else {\n        nativeSourceAudioNode.disconnect(nativeDestinationAudioNode, output, input);\n    }\n};\n//# sourceMappingURL=disconnect-native-audio-node-from-native-audio-node.js.map","import { AUDIO_NODE_STORE } from '../globals';\nimport { getValueForKey } from './get-value-for-key';\nexport const getNativeAudioNode = (audioNode) => {\n    return getValueForKey(AUDIO_NODE_STORE, audioNode);\n};\n//# sourceMappingURL=get-native-audio-node.js.map","import { AUDIO_PARAM_STORE } from '../globals';\nimport { getValueForKey } from './get-value-for-key';\nexport const getNativeAudioParam = (audioParam) => {\n    return getValueForKey(AUDIO_PARAM_STORE, audioParam);\n};\n//# sourceMappingURL=get-native-audio-param.js.map","import { CYCLE_COUNTERS } from '../globals';\nexport const isPartOfACycle = (audioNode) => {\n    return CYCLE_COUNTERS.has(audioNode);\n};\n//# sourceMappingURL=is-part-of-a-cycle.js.map","import { ACTIVE_AUDIO_NODE_STORE } from '../globals';\nexport const isPassiveAudioNode = (audioNode) => {\n    return !ACTIVE_AUDIO_NODE_STORE.has(audioNode);\n};\n//# sourceMappingURL=is-passive-audio-node.js.map","export const testAudioNodeDisconnectMethodSupport = (nativeAudioContext, nativeAudioWorkletNodeConstructor) => {\n    return new Promise((resolve) => {\n        /*\n         * This bug existed in Safari up until v14.0.2. Since AudioWorklets were not supported in Safari until v14.1 the presence of the\n         * constructor for an AudioWorkletNode can be used here to skip the test.\n         */\n        if (nativeAudioWorkletNodeConstructor !== null) {\n            resolve(true);\n        }\n        else {\n            const analyzer = nativeAudioContext.createScriptProcessor(256, 1, 1); // tslint:disable-line deprecation\n            const dummy = nativeAudioContext.createGain();\n            // Bug #95: Safari does not play one sample buffers.\n            const ones = nativeAudioContext.createBuffer(1, 2, 44100);\n            const channelData = ones.getChannelData(0);\n            channelData[0] = 1;\n            channelData[1] = 1;\n            const source = nativeAudioContext.createBufferSource();\n            source.buffer = ones;\n            source.loop = true;\n            source.connect(analyzer).connect(nativeAudioContext.destination);\n            source.connect(dummy);\n            source.disconnect(dummy);\n            // tslint:disable-next-line:deprecation\n            analyzer.onaudioprocess = (event) => {\n                const chnnlDt = event.inputBuffer.getChannelData(0); // tslint:disable-line deprecation\n                if (Array.prototype.some.call(chnnlDt, (sample) => sample === 1)) {\n                    resolve(true);\n                }\n                else {\n                    resolve(false);\n                }\n                source.stop();\n                analyzer.onaudioprocess = null; // tslint:disable-line:deprecation\n                source.disconnect(analyzer);\n                analyzer.disconnect(nativeAudioContext.destination);\n            };\n            source.start();\n        }\n    });\n};\n//# sourceMappingURL=test-audio-node-disconnect-method-support.js.map","export const visitEachAudioNodeOnce = (cycles, visitor) => {\n    const counts = new Map();\n    for (const cycle of cycles) {\n        for (const audioNode of cycle) {\n            const count = counts.get(audioNode);\n            counts.set(audioNode, count === undefined ? 1 : count + 1);\n        }\n    }\n    counts.forEach((count, audioNode) => visitor(audioNode, count));\n};\n//# sourceMappingURL=visit-each-audio-node-once.js.map","export const isNativeAudioNode = (nativeAudioNodeOrAudioParam) => {\n    return 'context' in nativeAudioNodeOrAudioParam;\n};\n//# sourceMappingURL=native-audio-node.js.map","import { isNativeAudioNode } from '../guards/native-audio-node';\nexport const wrapAudioNodeDisconnectMethod = (nativeAudioNode) => {\n    const connections = new Map();\n    nativeAudioNode.connect = ((connect) => {\n        // tslint:disable-next-line:invalid-void\n        return (destination, output = 0, input = 0) => {\n            const returnValue = isNativeAudioNode(destination) ? connect(destination, output, input) : connect(destination, output);\n            // Save the new connection only if the calls to connect above didn't throw an error.\n            const connectionsToDestination = connections.get(destination);\n            if (connectionsToDestination === undefined) {\n                connections.set(destination, [{ input, output }]);\n            }\n            else {\n                if (connectionsToDestination.every((connection) => connection.input !== input || connection.output !== output)) {\n                    connectionsToDestination.push({ input, output });\n                }\n            }\n            return returnValue;\n        };\n    })(nativeAudioNode.connect.bind(nativeAudioNode));\n    nativeAudioNode.disconnect = ((disconnect) => {\n        return (destinationOrOutput, output, input) => {\n            disconnect.apply(nativeAudioNode);\n            if (destinationOrOutput === undefined) {\n                connections.clear();\n            }\n            else if (typeof destinationOrOutput === 'number') {\n                for (const [destination, connectionsToDestination] of connections) {\n                    const filteredConnections = connectionsToDestination.filter((connection) => connection.output !== destinationOrOutput);\n                    if (filteredConnections.length === 0) {\n                        connections.delete(destination);\n                    }\n                    else {\n                        connections.set(destination, filteredConnections);\n                    }\n                }\n            }\n            else if (connections.has(destinationOrOutput)) {\n                if (output === undefined) {\n                    connections.delete(destinationOrOutput);\n                }\n                else {\n                    const connectionsToDestination = connections.get(destinationOrOutput);\n                    if (connectionsToDestination !== undefined) {\n                        const filteredConnections = connectionsToDestination.filter((connection) => connection.output !== output && (connection.input !== input || input === undefined));\n                        if (filteredConnections.length === 0) {\n                            connections.delete(destinationOrOutput);\n                        }\n                        else {\n                            connections.set(destinationOrOutput, filteredConnections);\n                        }\n                    }\n                }\n            }\n            for (const [destination, connectionsToDestination] of connections) {\n                connectionsToDestination.forEach((connection) => {\n                    if (isNativeAudioNode(destination)) {\n                        nativeAudioNode.connect(destination, connection.output, connection.input);\n                    }\n                    else {\n                        nativeAudioNode.connect(destination, connection.output);\n                    }\n                });\n            }\n        };\n    })(nativeAudioNode.disconnect);\n};\n//# sourceMappingURL=wrap-audio-node-disconnect-method.js.map","import { AUDIO_NODE_STORE, EVENT_LISTENERS } from '../globals';\nimport { isAudioNode } from '../guards/audio-node';\nimport { isAudioNodeOutputConnection } from '../guards/audio-node-output-connection';\nimport { addActiveInputConnectionToAudioParam } from '../helpers/add-active-input-connection-to-audio-param';\nimport { addPassiveInputConnectionToAudioParam } from '../helpers/add-passive-input-connection-to-audio-param';\nimport { connectNativeAudioNodeToNativeAudioNode } from '../helpers/connect-native-audio-node-to-native-audio-node';\nimport { deleteActiveInputConnection } from '../helpers/delete-active-input-connection';\nimport { deleteActiveInputConnectionToAudioParam } from '../helpers/delete-active-input-connection-to-audio-param';\nimport { deleteEventListenerOfAudioNode } from '../helpers/delete-event-listeners-of-audio-node';\nimport { deletePassiveInputConnectionToAudioNode } from '../helpers/delete-passive-input-connection-to-audio-node';\nimport { deletePassiveInputConnectionToAudioParam } from '../helpers/delete-passive-input-connection-to-audio-param';\nimport { disconnectNativeAudioNodeFromNativeAudioNode } from '../helpers/disconnect-native-audio-node-from-native-audio-node';\nimport { getAudioNodeConnections } from '../helpers/get-audio-node-connections';\nimport { getAudioParamConnections } from '../helpers/get-audio-param-connections';\nimport { getEventListenersOfAudioNode } from '../helpers/get-event-listeners-of-audio-node';\nimport { getNativeAudioNode } from '../helpers/get-native-audio-node';\nimport { getNativeAudioParam } from '../helpers/get-native-audio-param';\nimport { insertElementInSet } from '../helpers/insert-element-in-set';\nimport { isActiveAudioNode } from '../helpers/is-active-audio-node';\nimport { isPartOfACycle } from '../helpers/is-part-of-a-cycle';\nimport { isPassiveAudioNode } from '../helpers/is-passive-audio-node';\nimport { setInternalStateToActive } from '../helpers/set-internal-state-to-active';\nimport { setInternalStateToPassiveWhenNecessary } from '../helpers/set-internal-state-to-passive-when-necessary';\nimport { testAudioNodeDisconnectMethodSupport } from '../helpers/test-audio-node-disconnect-method-support';\nimport { visitEachAudioNodeOnce } from '../helpers/visit-each-audio-node-once';\nimport { wrapAudioNodeDisconnectMethod } from '../helpers/wrap-audio-node-disconnect-method';\nconst addConnectionToAudioParamOfAudioContext = (source, destination, output, isOffline) => {\n    const { activeInputs, passiveInputs } = getAudioParamConnections(destination);\n    const { outputs } = getAudioNodeConnections(source);\n    const eventListeners = getEventListenersOfAudioNode(source);\n    const eventListener = (isActive) => {\n        const nativeAudioNode = getNativeAudioNode(source);\n        const nativeAudioParam = getNativeAudioParam(destination);\n        if (isActive) {\n            const partialConnection = deletePassiveInputConnectionToAudioParam(passiveInputs, source, output);\n            addActiveInputConnectionToAudioParam(activeInputs, source, partialConnection, false);\n            if (!isOffline && !isPartOfACycle(source)) {\n                nativeAudioNode.connect(nativeAudioParam, output);\n            }\n        }\n        else {\n            const partialConnection = deleteActiveInputConnectionToAudioParam(activeInputs, source, output);\n            addPassiveInputConnectionToAudioParam(passiveInputs, partialConnection, false);\n            if (!isOffline && !isPartOfACycle(source)) {\n                nativeAudioNode.disconnect(nativeAudioParam, output);\n            }\n        }\n    };\n    if (insertElementInSet(outputs, [destination, output], (outputConnection) => outputConnection[0] === destination && outputConnection[1] === output, true)) {\n        eventListeners.add(eventListener);\n        if (isActiveAudioNode(source)) {\n            addActiveInputConnectionToAudioParam(activeInputs, source, [output, eventListener], true);\n        }\n        else {\n            addPassiveInputConnectionToAudioParam(passiveInputs, [source, output, eventListener], true);\n        }\n        return true;\n    }\n    return false;\n};\nconst deleteInputConnectionOfAudioNode = (source, destination, output, input) => {\n    const { activeInputs, passiveInputs } = getAudioNodeConnections(destination);\n    const activeInputConnection = deleteActiveInputConnection(activeInputs[input], source, output);\n    if (activeInputConnection === null) {\n        const passiveInputConnection = deletePassiveInputConnectionToAudioNode(passiveInputs, source, output, input);\n        return [passiveInputConnection[2], false];\n    }\n    return [activeInputConnection[2], true];\n};\nconst deleteInputConnectionOfAudioParam = (source, destination, output) => {\n    const { activeInputs, passiveInputs } = getAudioParamConnections(destination);\n    const activeInputConnection = deleteActiveInputConnection(activeInputs, source, output);\n    if (activeInputConnection === null) {\n        const passiveInputConnection = deletePassiveInputConnectionToAudioParam(passiveInputs, source, output);\n        return [passiveInputConnection[1], false];\n    }\n    return [activeInputConnection[2], true];\n};\nconst deleteInputsOfAudioNode = (source, isOffline, destination, output, input) => {\n    const [listener, isActive] = deleteInputConnectionOfAudioNode(source, destination, output, input);\n    if (listener !== null) {\n        deleteEventListenerOfAudioNode(source, listener);\n        if (isActive && !isOffline && !isPartOfACycle(source)) {\n            disconnectNativeAudioNodeFromNativeAudioNode(getNativeAudioNode(source), getNativeAudioNode(destination), output, input);\n        }\n    }\n    if (isActiveAudioNode(destination)) {\n        const { activeInputs } = getAudioNodeConnections(destination);\n        setInternalStateToPassiveWhenNecessary(destination, activeInputs);\n    }\n};\nconst deleteInputsOfAudioParam = (source, isOffline, destination, output) => {\n    const [listener, isActive] = deleteInputConnectionOfAudioParam(source, destination, output);\n    if (listener !== null) {\n        deleteEventListenerOfAudioNode(source, listener);\n        if (isActive && !isOffline && !isPartOfACycle(source)) {\n            getNativeAudioNode(source).disconnect(getNativeAudioParam(destination), output);\n        }\n    }\n};\nconst deleteAnyConnection = (source, isOffline) => {\n    const audioNodeConnectionsOfSource = getAudioNodeConnections(source);\n    const destinations = [];\n    for (const outputConnection of audioNodeConnectionsOfSource.outputs) {\n        if (isAudioNodeOutputConnection(outputConnection)) {\n            deleteInputsOfAudioNode(source, isOffline, ...outputConnection);\n        }\n        else {\n            deleteInputsOfAudioParam(source, isOffline, ...outputConnection);\n        }\n        destinations.push(outputConnection[0]);\n    }\n    audioNodeConnectionsOfSource.outputs.clear();\n    return destinations;\n};\nconst deleteConnectionAtOutput = (source, isOffline, output) => {\n    const audioNodeConnectionsOfSource = getAudioNodeConnections(source);\n    const destinations = [];\n    for (const outputConnection of audioNodeConnectionsOfSource.outputs) {\n        if (outputConnection[1] === output) {\n            if (isAudioNodeOutputConnection(outputConnection)) {\n                deleteInputsOfAudioNode(source, isOffline, ...outputConnection);\n            }\n            else {\n                deleteInputsOfAudioParam(source, isOffline, ...outputConnection);\n            }\n            destinations.push(outputConnection[0]);\n            audioNodeConnectionsOfSource.outputs.delete(outputConnection);\n        }\n    }\n    return destinations;\n};\nconst deleteConnectionToDestination = (source, isOffline, destination, output, input) => {\n    const audioNodeConnectionsOfSource = getAudioNodeConnections(source);\n    return Array.from(audioNodeConnectionsOfSource.outputs)\n        .filter((outputConnection) => outputConnection[0] === destination &&\n        (output === undefined || outputConnection[1] === output) &&\n        (input === undefined || outputConnection[2] === input))\n        .map((outputConnection) => {\n        if (isAudioNodeOutputConnection(outputConnection)) {\n            deleteInputsOfAudioNode(source, isOffline, ...outputConnection);\n        }\n        else {\n            deleteInputsOfAudioParam(source, isOffline, ...outputConnection);\n        }\n        audioNodeConnectionsOfSource.outputs.delete(outputConnection);\n        return outputConnection[0];\n    });\n};\nexport const createAudioNodeConstructor = (addAudioNodeConnections, addConnectionToAudioNode, cacheTestResult, createIncrementCycleCounter, createIndexSizeError, createInvalidAccessError, createNotSupportedError, decrementCycleCounter, detectCycles, eventTargetConstructor, getNativeContext, isNativeAudioContext, isNativeAudioNode, isNativeAudioParam, isNativeOfflineAudioContext, nativeAudioWorkletNodeConstructor) => {\n    return class AudioNode extends eventTargetConstructor {\n        constructor(context, isActive, nativeAudioNode, audioNodeRenderer) {\n            super(nativeAudioNode);\n            this._context = context;\n            this._nativeAudioNode = nativeAudioNode;\n            const nativeContext = getNativeContext(context);\n            // Bug #12: Safari does not support to disconnect a specific destination.\n            if (isNativeAudioContext(nativeContext) &&\n                true !==\n                    cacheTestResult(testAudioNodeDisconnectMethodSupport, () => {\n                        return testAudioNodeDisconnectMethodSupport(nativeContext, nativeAudioWorkletNodeConstructor);\n                    })) {\n                wrapAudioNodeDisconnectMethod(nativeAudioNode);\n            }\n            AUDIO_NODE_STORE.set(this, nativeAudioNode);\n            EVENT_LISTENERS.set(this, new Set());\n            if (context.state !== 'closed' && isActive) {\n                setInternalStateToActive(this);\n            }\n            addAudioNodeConnections(this, audioNodeRenderer, nativeAudioNode);\n        }\n        get channelCount() {\n            return this._nativeAudioNode.channelCount;\n        }\n        set channelCount(value) {\n            this._nativeAudioNode.channelCount = value;\n        }\n        get channelCountMode() {\n            return this._nativeAudioNode.channelCountMode;\n        }\n        set channelCountMode(value) {\n            this._nativeAudioNode.channelCountMode = value;\n        }\n        get channelInterpretation() {\n            return this._nativeAudioNode.channelInterpretation;\n        }\n        set channelInterpretation(value) {\n            this._nativeAudioNode.channelInterpretation = value;\n        }\n        get context() {\n            return this._context;\n        }\n        get numberOfInputs() {\n            return this._nativeAudioNode.numberOfInputs;\n        }\n        get numberOfOutputs() {\n            return this._nativeAudioNode.numberOfOutputs;\n        }\n        // tslint:disable-next-line:invalid-void\n        connect(destination, output = 0, input = 0) {\n            // Bug #174: Safari does expose a wrong numberOfOutputs for MediaStreamAudioDestinationNodes.\n            if (output < 0 || output >= this._nativeAudioNode.numberOfOutputs) {\n                throw createIndexSizeError();\n            }\n            const nativeContext = getNativeContext(this._context);\n            const isOffline = isNativeOfflineAudioContext(nativeContext);\n            if (isNativeAudioNode(destination) || isNativeAudioParam(destination)) {\n                throw createInvalidAccessError();\n            }\n            if (isAudioNode(destination)) {\n                const nativeDestinationAudioNode = getNativeAudioNode(destination);\n                try {\n                    const connection = connectNativeAudioNodeToNativeAudioNode(this._nativeAudioNode, nativeDestinationAudioNode, output, input);\n                    const isPassive = isPassiveAudioNode(this);\n                    if (isOffline || isPassive) {\n                        this._nativeAudioNode.disconnect(...connection);\n                    }\n                    if (this.context.state !== 'closed' && !isPassive && isPassiveAudioNode(destination)) {\n                        setInternalStateToActive(destination);\n                    }\n                }\n                catch (err) {\n                    // Bug #41: Safari does not throw the correct exception so far.\n                    if (err.code === 12) {\n                        throw createInvalidAccessError();\n                    }\n                    throw err;\n                }\n                const isNewConnectionToAudioNode = addConnectionToAudioNode(this, destination, output, input, isOffline);\n                // Bug #164: Only Firefox detects cycles so far.\n                if (isNewConnectionToAudioNode) {\n                    const cycles = detectCycles([this], destination);\n                    visitEachAudioNodeOnce(cycles, createIncrementCycleCounter(isOffline));\n                }\n                return destination;\n            }\n            const nativeAudioParam = getNativeAudioParam(destination);\n            /*\n             * Bug #73, #147 & #153: Safari does not support to connect an input signal to the playbackRate AudioParam of an\n             * AudioBufferSourceNode. This can't be easily detected and that's why the outdated name property is used here to identify\n             * Safari. In addition to that the maxValue property is used to only detect the affected versions below v14.0.2.\n             */\n            if (nativeAudioParam.name === 'playbackRate' && nativeAudioParam.maxValue === 1024) {\n                throw createNotSupportedError();\n            }\n            try {\n                this._nativeAudioNode.connect(nativeAudioParam, output);\n                if (isOffline || isPassiveAudioNode(this)) {\n                    this._nativeAudioNode.disconnect(nativeAudioParam, output);\n                }\n            }\n            catch (err) {\n                // Bug #58: Safari doesn't throw an InvalidAccessError yet.\n                if (err.code === 12) {\n                    throw createInvalidAccessError();\n                }\n                throw err;\n            }\n            const isNewConnectionToAudioParam = addConnectionToAudioParamOfAudioContext(this, destination, output, isOffline);\n            // Bug #164: Only Firefox detects cycles so far.\n            if (isNewConnectionToAudioParam) {\n                const cycles = detectCycles([this], destination);\n                visitEachAudioNodeOnce(cycles, createIncrementCycleCounter(isOffline));\n            }\n        }\n        disconnect(destinationOrOutput, output, input) {\n            let destinations;\n            const nativeContext = getNativeContext(this._context);\n            const isOffline = isNativeOfflineAudioContext(nativeContext);\n            if (destinationOrOutput === undefined) {\n                destinations = deleteAnyConnection(this, isOffline);\n            }\n            else if (typeof destinationOrOutput === 'number') {\n                if (destinationOrOutput < 0 || destinationOrOutput >= this.numberOfOutputs) {\n                    throw createIndexSizeError();\n                }\n                destinations = deleteConnectionAtOutput(this, isOffline, destinationOrOutput);\n            }\n            else {\n                if (output !== undefined && (output < 0 || output >= this.numberOfOutputs)) {\n                    throw createIndexSizeError();\n                }\n                if (isAudioNode(destinationOrOutput) && input !== undefined && (input < 0 || input >= destinationOrOutput.numberOfInputs)) {\n                    throw createIndexSizeError();\n                }\n                destinations = deleteConnectionToDestination(this, isOffline, destinationOrOutput, output, input);\n                if (destinations.length === 0) {\n                    throw createInvalidAccessError();\n                }\n            }\n            // Bug #164: Only Firefox detects cycles so far.\n            for (const destination of destinations) {\n                const cycles = detectCycles([this], destination);\n                visitEachAudioNodeOnce(cycles, decrementCycleCounter);\n            }\n        }\n    };\n};\n//# sourceMappingURL=audio-node-constructor.js.map","export class ReadOnlyMap {\n    constructor(parameters) {\n        this._map = new Map(parameters);\n    }\n    get size() {\n        return this._map.size;\n    }\n    entries() {\n        return this._map.entries();\n    }\n    forEach(callback, thisArg = null) {\n        return this._map.forEach((value, key) => callback.call(thisArg, value, key, this));\n    }\n    get(name) {\n        return this._map.get(name);\n    }\n    has(name) {\n        return this._map.has(name);\n    }\n    keys() {\n        return this._map.keys();\n    }\n    values() {\n        return this._map.values();\n    }\n}\n//# sourceMappingURL=read-only-map.js.map","import { NODE_NAME_TO_PROCESSOR_CONSTRUCTOR_MAPS } from '../globals';\nimport { ReadOnlyMap } from '../read-only-map';\nconst DEFAULT_OPTIONS = {\n    channelCount: 2,\n    // Bug #61: The channelCountMode should be 'max' according to the spec but is set to 'explicit' to achieve consistent behavior.\n    channelCountMode: 'explicit',\n    channelInterpretation: 'speakers',\n    numberOfInputs: 1,\n    numberOfOutputs: 1,\n    parameterData: {},\n    processorOptions: {}\n};\nexport const createAudioWorkletNodeConstructor = (addUnrenderedAudioWorkletNode, audioNodeConstructor, createAudioParam, createAudioWorkletNodeRenderer, createNativeAudioWorkletNode, getAudioNodeConnections, getBackupOfflineAudioContext, getNativeContext, isNativeOfflineAudioContext, nativeAudioWorkletNodeConstructor, sanitizeAudioWorkletNodeOptions, setActiveAudioWorkletNodeInputs, testAudioWorkletNodeOptionsClonability, wrapEventListener) => {\n    return class AudioWorkletNode extends audioNodeConstructor {\n        constructor(context, name, options) {\n            var _a;\n            const nativeContext = getNativeContext(context);\n            const isOffline = isNativeOfflineAudioContext(nativeContext);\n            const mergedOptions = sanitizeAudioWorkletNodeOptions({ ...DEFAULT_OPTIONS, ...options });\n            // Bug #191: Safari doesn't throw an error if the options aren't clonable.\n            testAudioWorkletNodeOptionsClonability(mergedOptions);\n            const nodeNameToProcessorConstructorMap = NODE_NAME_TO_PROCESSOR_CONSTRUCTOR_MAPS.get(nativeContext);\n            const processorConstructor = nodeNameToProcessorConstructorMap === null || nodeNameToProcessorConstructorMap === void 0 ? void 0 : nodeNameToProcessorConstructorMap.get(name);\n            // Bug #186: Chrome, Edge and Opera do not allow to create an AudioWorkletNode on a closed AudioContext.\n            const nativeContextOrBackupOfflineAudioContext = isOffline || nativeContext.state !== 'closed'\n                ? nativeContext\n                : (_a = getBackupOfflineAudioContext(nativeContext)) !== null && _a !== void 0 ? _a : nativeContext;\n            const nativeAudioWorkletNode = createNativeAudioWorkletNode(nativeContextOrBackupOfflineAudioContext, isOffline ? null : context.baseLatency, nativeAudioWorkletNodeConstructor, name, processorConstructor, mergedOptions);\n            const audioWorkletNodeRenderer = ((isOffline ? createAudioWorkletNodeRenderer(name, mergedOptions, processorConstructor) : null));\n            /*\n             * @todo Add a mechanism to switch an AudioWorkletNode to passive once the process() function of the AudioWorkletProcessor\n             * returns false.\n             */\n            super(context, true, nativeAudioWorkletNode, audioWorkletNodeRenderer);\n            const parameters = [];\n            nativeAudioWorkletNode.parameters.forEach((nativeAudioParam, nm) => {\n                const audioParam = createAudioParam(this, isOffline, nativeAudioParam);\n                parameters.push([nm, audioParam]);\n            });\n            this._nativeAudioWorkletNode = nativeAudioWorkletNode;\n            this._onprocessorerror = null;\n            this._parameters = new ReadOnlyMap(parameters);\n            /*\n             * Bug #86 & #87: Invoking the renderer of an AudioWorkletNode might be necessary if it has no direct or indirect connection to\n             * the destination.\n             */\n            if (isOffline) {\n                addUnrenderedAudioWorkletNode(nativeContext, this);\n            }\n            const { activeInputs } = getAudioNodeConnections(this);\n            setActiveAudioWorkletNodeInputs(nativeAudioWorkletNode, activeInputs);\n        }\n        get onprocessorerror() {\n            return this._onprocessorerror;\n        }\n        set onprocessorerror(value) {\n            const wrappedListener = typeof value === 'function' ? wrapEventListener(this, value) : null;\n            this._nativeAudioWorkletNode.onprocessorerror = wrappedListener;\n            const nativeOnProcessorError = this._nativeAudioWorkletNode.onprocessorerror;\n            this._onprocessorerror =\n                nativeOnProcessorError !== null && nativeOnProcessorError === wrappedListener\n                    ? value\n                    : nativeOnProcessorError;\n        }\n        get parameters() {\n            if (this._parameters === null) {\n                // @todo The definition that TypeScript uses of the AudioParamMap is lacking many methods.\n                return this._nativeAudioWorkletNode.parameters;\n            }\n            return this._parameters;\n        }\n        get port() {\n            return this._nativeAudioWorkletNode.port;\n        }\n    };\n};\n//# sourceMappingURL=audio-worklet-node-constructor.js.map","export function copyFromChannel(audioBuffer, \n// @todo There is currently no way to define something like { [ key: number | string ]: Float32Array }\nparent, key, channelNumber, bufferOffset) {\n    if (typeof audioBuffer.copyFromChannel === 'function') {\n        // The byteLength will be 0 when the ArrayBuffer was transferred.\n        if (parent[key].byteLength === 0) {\n            parent[key] = new Float32Array(128);\n        }\n        audioBuffer.copyFromChannel(parent[key], channelNumber, bufferOffset);\n        // Bug #5: Safari does not support copyFromChannel().\n    }\n    else {\n        const channelData = audioBuffer.getChannelData(channelNumber);\n        // The byteLength will be 0 when the ArrayBuffer was transferred.\n        if (parent[key].byteLength === 0) {\n            parent[key] = channelData.slice(bufferOffset, bufferOffset + 128);\n        }\n        else {\n            const slicedInput = new Float32Array(channelData.buffer, bufferOffset * Float32Array.BYTES_PER_ELEMENT, 128);\n            parent[key].set(slicedInput);\n        }\n    }\n}\n//# sourceMappingURL=copy-from-channel.js.map","export const copyToChannel = (audioBuffer, parent, key, channelNumber, bufferOffset) => {\n    if (typeof audioBuffer.copyToChannel === 'function') {\n        // The byteLength will be 0 when the ArrayBuffer was transferred.\n        if (parent[key].byteLength !== 0) {\n            audioBuffer.copyToChannel(parent[key], channelNumber, bufferOffset);\n        }\n        // Bug #5: Safari does not support copyToChannel().\n    }\n    else {\n        // The byteLength will be 0 when the ArrayBuffer was transferred.\n        if (parent[key].byteLength !== 0) {\n            audioBuffer.getChannelData(channelNumber).set(parent[key], bufferOffset);\n        }\n    }\n};\n//# sourceMappingURL=copy-to-channel.js.map","export const createNestedArrays = (x, y) => {\n    const arrays = [];\n    for (let i = 0; i < x; i += 1) {\n        const array = [];\n        const length = typeof y === 'number' ? y : y[i];\n        for (let j = 0; j < length; j += 1) {\n            array.push(new Float32Array(128));\n        }\n        arrays.push(array);\n    }\n    return arrays;\n};\n//# sourceMappingURL=create-nested-arrays.js.map","import { copyFromChannel } from '../helpers/copy-from-channel';\nimport { copyToChannel } from '../helpers/copy-to-channel';\nimport { createNestedArrays } from '../helpers/create-nested-arrays';\nimport { getAudioNodeConnections } from '../helpers/get-audio-node-connections';\nimport { getAudioWorkletProcessor } from '../helpers/get-audio-worklet-processor';\nimport { isOwnedByContext } from '../helpers/is-owned-by-context';\nconst processBuffer = async (proxy, renderedBuffer, nativeOfflineAudioContext, options, outputChannelCount, processorConstructor, exposeCurrentFrameAndCurrentTime) => {\n    // Ceil the length to the next full render quantum.\n    // Bug #17: Safari does not yet expose the length.\n    const length = renderedBuffer === null ? Math.ceil(proxy.context.length / 128) * 128 : renderedBuffer.length;\n    const numberOfInputChannels = options.channelCount * options.numberOfInputs;\n    const numberOfOutputChannels = outputChannelCount.reduce((sum, value) => sum + value, 0);\n    const processedBuffer = numberOfOutputChannels === 0\n        ? null\n        : nativeOfflineAudioContext.createBuffer(numberOfOutputChannels, length, nativeOfflineAudioContext.sampleRate);\n    if (processorConstructor === undefined) {\n        throw new Error('Missing the processor constructor.');\n    }\n    const audioNodeConnections = getAudioNodeConnections(proxy);\n    const audioWorkletProcessor = await getAudioWorkletProcessor(nativeOfflineAudioContext, proxy);\n    const inputs = createNestedArrays(options.numberOfInputs, options.channelCount);\n    const outputs = createNestedArrays(options.numberOfOutputs, outputChannelCount);\n    const parameters = Array.from(proxy.parameters.keys()).reduce((prmtrs, name) => ({ ...prmtrs, [name]: new Float32Array(128) }), {});\n    for (let i = 0; i < length; i += 128) {\n        if (options.numberOfInputs > 0 && renderedBuffer !== null) {\n            for (let j = 0; j < options.numberOfInputs; j += 1) {\n                for (let k = 0; k < options.channelCount; k += 1) {\n                    copyFromChannel(renderedBuffer, inputs[j], k, k, i);\n                }\n            }\n        }\n        if (processorConstructor.parameterDescriptors !== undefined && renderedBuffer !== null) {\n            processorConstructor.parameterDescriptors.forEach(({ name }, index) => {\n                copyFromChannel(renderedBuffer, parameters, name, numberOfInputChannels + index, i);\n            });\n        }\n        for (let j = 0; j < options.numberOfInputs; j += 1) {\n            for (let k = 0; k < outputChannelCount[j]; k += 1) {\n                // The byteLength will be 0 when the ArrayBuffer was transferred.\n                if (outputs[j][k].byteLength === 0) {\n                    outputs[j][k] = new Float32Array(128);\n                }\n            }\n        }\n        try {\n            const potentiallyEmptyInputs = inputs.map((input, index) => {\n                if (audioNodeConnections.activeInputs[index].size === 0) {\n                    return [];\n                }\n                return input;\n            });\n            const activeSourceFlag = exposeCurrentFrameAndCurrentTime(i / nativeOfflineAudioContext.sampleRate, nativeOfflineAudioContext.sampleRate, () => audioWorkletProcessor.process(potentiallyEmptyInputs, outputs, parameters));\n            if (processedBuffer !== null) {\n                for (let j = 0, outputChannelSplitterNodeOutput = 0; j < options.numberOfOutputs; j += 1) {\n                    for (let k = 0; k < outputChannelCount[j]; k += 1) {\n                        copyToChannel(processedBuffer, outputs[j], k, outputChannelSplitterNodeOutput + k, i);\n                    }\n                    outputChannelSplitterNodeOutput += outputChannelCount[j];\n                }\n            }\n            if (!activeSourceFlag) {\n                break;\n            }\n        }\n        catch (error) {\n            proxy.dispatchEvent(new ErrorEvent('processorerror', {\n                colno: error.colno,\n                filename: error.filename,\n                lineno: error.lineno,\n                message: error.message\n            }));\n            break;\n        }\n    }\n    return processedBuffer;\n};\nexport const createAudioWorkletNodeRendererFactory = (connectAudioParam, connectMultipleOutputs, createNativeAudioBufferSourceNode, createNativeChannelMergerNode, createNativeChannelSplitterNode, createNativeConstantSourceNode, createNativeGainNode, deleteUnrenderedAudioWorkletNode, disconnectMultipleOutputs, exposeCurrentFrameAndCurrentTime, getNativeAudioNode, nativeAudioWorkletNodeConstructor, nativeOfflineAudioContextConstructor, renderAutomation, renderInputsOfAudioNode, renderNativeOfflineAudioContext) => {\n    return (name, options, processorConstructor) => {\n        const renderedNativeAudioNodes = new WeakMap();\n        let processedBufferPromise = null;\n        const createAudioNode = async (proxy, nativeOfflineAudioContext, trace) => {\n            let nativeAudioWorkletNode = getNativeAudioNode(proxy);\n            let nativeOutputNodes = null;\n            const nativeAudioWorkletNodeIsOwnedByContext = isOwnedByContext(nativeAudioWorkletNode, nativeOfflineAudioContext);\n            const outputChannelCount = Array.isArray(options.outputChannelCount)\n                ? options.outputChannelCount\n                : Array.from(options.outputChannelCount);\n            // Bug #61: Only Chrome, Edge, Firefox & Opera have an implementation of the AudioWorkletNode yet.\n            if (nativeAudioWorkletNodeConstructor === null) {\n                const numberOfOutputChannels = outputChannelCount.reduce((sum, value) => sum + value, 0);\n                const outputChannelSplitterNode = createNativeChannelSplitterNode(nativeOfflineAudioContext, {\n                    channelCount: Math.max(1, numberOfOutputChannels),\n                    channelCountMode: 'explicit',\n                    channelInterpretation: 'discrete',\n                    numberOfOutputs: Math.max(1, numberOfOutputChannels)\n                });\n                const outputChannelMergerNodes = [];\n                for (let i = 0; i < proxy.numberOfOutputs; i += 1) {\n                    outputChannelMergerNodes.push(createNativeChannelMergerNode(nativeOfflineAudioContext, {\n                        channelCount: 1,\n                        channelCountMode: 'explicit',\n                        channelInterpretation: 'speakers',\n                        numberOfInputs: outputChannelCount[i]\n                    }));\n                }\n                const outputGainNode = createNativeGainNode(nativeOfflineAudioContext, {\n                    channelCount: options.channelCount,\n                    channelCountMode: options.channelCountMode,\n                    channelInterpretation: options.channelInterpretation,\n                    gain: 1\n                });\n                outputGainNode.connect = connectMultipleOutputs.bind(null, outputChannelMergerNodes);\n                outputGainNode.disconnect = disconnectMultipleOutputs.bind(null, outputChannelMergerNodes);\n                nativeOutputNodes = [outputChannelSplitterNode, outputChannelMergerNodes, outputGainNode];\n            }\n            else if (!nativeAudioWorkletNodeIsOwnedByContext) {\n                nativeAudioWorkletNode = new nativeAudioWorkletNodeConstructor(nativeOfflineAudioContext, name);\n            }\n            renderedNativeAudioNodes.set(nativeOfflineAudioContext, nativeOutputNodes === null ? nativeAudioWorkletNode : nativeOutputNodes[2]);\n            if (nativeOutputNodes !== null) {\n                if (processedBufferPromise === null) {\n                    if (processorConstructor === undefined) {\n                        throw new Error('Missing the processor constructor.');\n                    }\n                    if (nativeOfflineAudioContextConstructor === null) {\n                        throw new Error('Missing the native OfflineAudioContext constructor.');\n                    }\n                    // Bug #47: The AudioDestinationNode in Safari gets not initialized correctly.\n                    const numberOfInputChannels = proxy.channelCount * proxy.numberOfInputs;\n                    const numberOfParameters = processorConstructor.parameterDescriptors === undefined ? 0 : processorConstructor.parameterDescriptors.length;\n                    const numberOfChannels = numberOfInputChannels + numberOfParameters;\n                    const renderBuffer = async () => {\n                        const partialOfflineAudioContext = new nativeOfflineAudioContextConstructor(numberOfChannels, \n                        // Ceil the length to the next full render quantum.\n                        // Bug #17: Safari does not yet expose the length.\n                        Math.ceil(proxy.context.length / 128) * 128, nativeOfflineAudioContext.sampleRate);\n                        const gainNodes = [];\n                        const inputChannelSplitterNodes = [];\n                        for (let i = 0; i < options.numberOfInputs; i += 1) {\n                            gainNodes.push(createNativeGainNode(partialOfflineAudioContext, {\n                                channelCount: options.channelCount,\n                                channelCountMode: options.channelCountMode,\n                                channelInterpretation: options.channelInterpretation,\n                                gain: 1\n                            }));\n                            inputChannelSplitterNodes.push(createNativeChannelSplitterNode(partialOfflineAudioContext, {\n                                channelCount: options.channelCount,\n                                channelCountMode: 'explicit',\n                                channelInterpretation: 'discrete',\n                                numberOfOutputs: options.channelCount\n                            }));\n                        }\n                        const constantSourceNodes = await Promise.all(Array.from(proxy.parameters.values()).map(async (audioParam) => {\n                            const constantSourceNode = createNativeConstantSourceNode(partialOfflineAudioContext, {\n                                channelCount: 1,\n                                channelCountMode: 'explicit',\n                                channelInterpretation: 'discrete',\n                                offset: audioParam.value\n                            });\n                            await renderAutomation(partialOfflineAudioContext, audioParam, constantSourceNode.offset, trace);\n                            return constantSourceNode;\n                        }));\n                        const inputChannelMergerNode = createNativeChannelMergerNode(partialOfflineAudioContext, {\n                            channelCount: 1,\n                            channelCountMode: 'explicit',\n                            channelInterpretation: 'speakers',\n                            numberOfInputs: Math.max(1, numberOfInputChannels + numberOfParameters)\n                        });\n                        for (let i = 0; i < options.numberOfInputs; i += 1) {\n                            gainNodes[i].connect(inputChannelSplitterNodes[i]);\n                            for (let j = 0; j < options.channelCount; j += 1) {\n                                inputChannelSplitterNodes[i].connect(inputChannelMergerNode, j, i * options.channelCount + j);\n                            }\n                        }\n                        for (const [index, constantSourceNode] of constantSourceNodes.entries()) {\n                            constantSourceNode.connect(inputChannelMergerNode, 0, numberOfInputChannels + index);\n                            constantSourceNode.start(0);\n                        }\n                        inputChannelMergerNode.connect(partialOfflineAudioContext.destination);\n                        await Promise.all(gainNodes.map((gainNode) => renderInputsOfAudioNode(proxy, partialOfflineAudioContext, gainNode, trace)));\n                        return renderNativeOfflineAudioContext(partialOfflineAudioContext);\n                    };\n                    processedBufferPromise = processBuffer(proxy, numberOfChannels === 0 ? null : await renderBuffer(), nativeOfflineAudioContext, options, outputChannelCount, processorConstructor, exposeCurrentFrameAndCurrentTime);\n                }\n                const processedBuffer = await processedBufferPromise;\n                const audioBufferSourceNode = createNativeAudioBufferSourceNode(nativeOfflineAudioContext, {\n                    buffer: null,\n                    channelCount: 2,\n                    channelCountMode: 'max',\n                    channelInterpretation: 'speakers',\n                    loop: false,\n                    loopEnd: 0,\n                    loopStart: 0,\n                    playbackRate: 1\n                });\n                const [outputChannelSplitterNode, outputChannelMergerNodes, outputGainNode] = nativeOutputNodes;\n                if (processedBuffer !== null) {\n                    audioBufferSourceNode.buffer = processedBuffer;\n                    audioBufferSourceNode.start(0);\n                }\n                audioBufferSourceNode.connect(outputChannelSplitterNode);\n                for (let i = 0, outputChannelSplitterNodeOutput = 0; i < proxy.numberOfOutputs; i += 1) {\n                    const outputChannelMergerNode = outputChannelMergerNodes[i];\n                    for (let j = 0; j < outputChannelCount[i]; j += 1) {\n                        outputChannelSplitterNode.connect(outputChannelMergerNode, outputChannelSplitterNodeOutput + j, j);\n                    }\n                    outputChannelSplitterNodeOutput += outputChannelCount[i];\n                }\n                return outputGainNode;\n            }\n            if (!nativeAudioWorkletNodeIsOwnedByContext) {\n                for (const [nm, audioParam] of proxy.parameters.entries()) {\n                    await renderAutomation(nativeOfflineAudioContext, audioParam, \n                    // @todo The definition that TypeScript uses of the AudioParamMap is lacking many methods.\n                    nativeAudioWorkletNode.parameters.get(nm), trace);\n                }\n            }\n            else {\n                for (const [nm, audioParam] of proxy.parameters.entries()) {\n                    await connectAudioParam(nativeOfflineAudioContext, audioParam, \n                    // @todo The definition that TypeScript uses of the AudioParamMap is lacking many methods.\n                    nativeAudioWorkletNode.parameters.get(nm), trace);\n                }\n            }\n            await renderInputsOfAudioNode(proxy, nativeOfflineAudioContext, nativeAudioWorkletNode, trace);\n            return nativeAudioWorkletNode;\n        };\n        return {\n            render(proxy, nativeOfflineAudioContext, trace) {\n                deleteUnrenderedAudioWorkletNode(nativeOfflineAudioContext, proxy);\n                const renderedNativeAudioWorkletNodeOrGainNode = renderedNativeAudioNodes.get(nativeOfflineAudioContext);\n                if (renderedNativeAudioWorkletNodeOrGainNode !== undefined) {\n                    return Promise.resolve(renderedNativeAudioWorkletNodeOrGainNode);\n                }\n                return createAudioNode(proxy, nativeOfflineAudioContext, trace);\n            }\n        };\n    };\n};\n//# sourceMappingURL=audio-worklet-node-renderer-factory.js.map","import { NODE_TO_PROCESSOR_MAPS } from '../globals';\nimport { getNativeAudioNode } from './get-native-audio-node';\nimport { getValueForKey } from './get-value-for-key';\nexport const getAudioWorkletProcessor = (nativeOfflineAudioContext, proxy) => {\n    const nodeToProcessorMap = getValueForKey(NODE_TO_PROCESSOR_MAPS, nativeOfflineAudioContext);\n    const nativeAudioWorkletNode = getNativeAudioNode(proxy);\n    return getValueForKey(nodeToProcessorMap, nativeAudioWorkletNode);\n};\n//# sourceMappingURL=get-audio-worklet-processor.js.map","import { MOST_NEGATIVE_SINGLE_FLOAT, MOST_POSITIVE_SINGLE_FLOAT } from '../constants';\nconst DEFAULT_OPTIONS = {\n    Q: 1,\n    channelCount: 2,\n    channelCountMode: 'max',\n    channelInterpretation: 'speakers',\n    detune: 0,\n    frequency: 350,\n    gain: 0,\n    type: 'lowpass'\n};\nexport const createBiquadFilterNodeConstructor = (audioNodeConstructor, createAudioParam, createBiquadFilterNodeRenderer, createInvalidAccessError, createNativeBiquadFilterNode, getNativeContext, isNativeOfflineAudioContext, setAudioNodeTailTime) => {\n    return class BiquadFilterNode extends audioNodeConstructor {\n        constructor(context, options) {\n            const nativeContext = getNativeContext(context);\n            const mergedOptions = { ...DEFAULT_OPTIONS, ...options };\n            const nativeBiquadFilterNode = createNativeBiquadFilterNode(nativeContext, mergedOptions);\n            const isOffline = isNativeOfflineAudioContext(nativeContext);\n            const biquadFilterNodeRenderer = (isOffline ? createBiquadFilterNodeRenderer() : null);\n            super(context, false, nativeBiquadFilterNode, biquadFilterNodeRenderer);\n            // Bug #80: Safari does not export the correct values for maxValue and minValue.\n            this._Q = createAudioParam(this, isOffline, nativeBiquadFilterNode.Q, MOST_POSITIVE_SINGLE_FLOAT, MOST_NEGATIVE_SINGLE_FLOAT);\n            // Bug #78: Firefox & Safari do not export the correct values for maxValue and minValue.\n            this._detune = createAudioParam(this, isOffline, nativeBiquadFilterNode.detune, 1200 * Math.log2(MOST_POSITIVE_SINGLE_FLOAT), -1200 * Math.log2(MOST_POSITIVE_SINGLE_FLOAT));\n            // Bug #77: Firefox & Safari do not export the correct value for minValue.\n            this._frequency = createAudioParam(this, isOffline, nativeBiquadFilterNode.frequency, context.sampleRate / 2, 0);\n            // Bug #79: Firefox & Safari do not export the correct values for maxValue and minValue.\n            this._gain = createAudioParam(this, isOffline, nativeBiquadFilterNode.gain, 40 * Math.log10(MOST_POSITIVE_SINGLE_FLOAT), MOST_NEGATIVE_SINGLE_FLOAT);\n            this._nativeBiquadFilterNode = nativeBiquadFilterNode;\n            // @todo Determine a meaningful tail-time instead of just using one second.\n            setAudioNodeTailTime(this, 1);\n        }\n        get detune() {\n            return this._detune;\n        }\n        get frequency() {\n            return this._frequency;\n        }\n        get gain() {\n            return this._gain;\n        }\n        get Q() {\n            return this._Q;\n        }\n        get type() {\n            return this._nativeBiquadFilterNode.type;\n        }\n        set type(value) {\n            this._nativeBiquadFilterNode.type = value;\n        }\n        getFrequencyResponse(frequencyHz, magResponse, phaseResponse) {\n            // Bug #189: Safari does throw an InvalidStateError.\n            try {\n                this._nativeBiquadFilterNode.getFrequencyResponse(frequencyHz, magResponse, phaseResponse);\n            }\n            catch (err) {\n                if (err.code === 11) {\n                    throw createInvalidAccessError();\n                }\n                throw err;\n            }\n            // Bug #68: Safari does not throw an error if the parameters differ in their length.\n            if (frequencyHz.length !== magResponse.length || magResponse.length !== phaseResponse.length) {\n                throw createInvalidAccessError();\n            }\n        }\n    };\n};\n//# sourceMappingURL=biquad-filter-node-constructor.js.map","const DEFAULT_OPTIONS = {\n    channelCount: 1,\n    channelCountMode: 'explicit',\n    channelInterpretation: 'speakers',\n    numberOfInputs: 6\n};\nexport const createChannelMergerNodeConstructor = (audioNodeConstructor, createChannelMergerNodeRenderer, createNativeChannelMergerNode, getNativeContext, isNativeOfflineAudioContext) => {\n    return class ChannelMergerNode extends audioNodeConstructor {\n        constructor(context, options) {\n            const nativeContext = getNativeContext(context);\n            const mergedOptions = { ...DEFAULT_OPTIONS, ...options };\n            const nativeChannelMergerNode = createNativeChannelMergerNode(nativeContext, mergedOptions);\n            const channelMergerNodeRenderer = ((isNativeOfflineAudioContext(nativeContext) ? createChannelMergerNodeRenderer() : null));\n            super(context, false, nativeChannelMergerNode, channelMergerNodeRenderer);\n        }\n    };\n};\n//# sourceMappingURL=channel-merger-node-constructor.js.map","const DEFAULT_OPTIONS = {\n    channelCount: 6,\n    channelCountMode: 'explicit',\n    channelInterpretation: 'discrete',\n    numberOfOutputs: 6\n};\nexport const createChannelSplitterNodeConstructor = (audioNodeConstructor, createChannelSplitterNodeRenderer, createNativeChannelSplitterNode, getNativeContext, isNativeOfflineAudioContext, sanitizeChannelSplitterOptions) => {\n    return class ChannelSplitterNode extends audioNodeConstructor {\n        constructor(context, options) {\n            const nativeContext = getNativeContext(context);\n            const mergedOptions = sanitizeChannelSplitterOptions({ ...DEFAULT_OPTIONS, ...options });\n            const nativeChannelSplitterNode = createNativeChannelSplitterNode(nativeContext, mergedOptions);\n            const channelSplitterNodeRenderer = ((isNativeOfflineAudioContext(nativeContext) ? createChannelSplitterNodeRenderer() : null));\n            super(context, false, nativeChannelSplitterNode, channelSplitterNodeRenderer);\n        }\n    };\n};\n//# sourceMappingURL=channel-splitter-node-constructor.js.map","import { MOST_NEGATIVE_SINGLE_FLOAT, MOST_POSITIVE_SINGLE_FLOAT } from '../constants';\nimport { isActiveAudioNode } from '../helpers/is-active-audio-node';\nimport { setInternalStateToActive } from '../helpers/set-internal-state-to-active';\nimport { setInternalStateToPassive } from '../helpers/set-internal-state-to-passive';\nconst DEFAULT_OPTIONS = {\n    channelCount: 2,\n    channelCountMode: 'max',\n    channelInterpretation: 'speakers',\n    offset: 1\n};\nexport const createConstantSourceNodeConstructor = (audioNodeConstructor, createAudioParam, createConstantSourceNodeRendererFactory, createNativeConstantSourceNode, getNativeContext, isNativeOfflineAudioContext, wrapEventListener) => {\n    return class ConstantSourceNode extends audioNodeConstructor {\n        constructor(context, options) {\n            const nativeContext = getNativeContext(context);\n            const mergedOptions = { ...DEFAULT_OPTIONS, ...options };\n            const nativeConstantSourceNode = createNativeConstantSourceNode(nativeContext, mergedOptions);\n            const isOffline = isNativeOfflineAudioContext(nativeContext);\n            const constantSourceNodeRenderer = ((isOffline ? createConstantSourceNodeRendererFactory() : null));\n            super(context, false, nativeConstantSourceNode, constantSourceNodeRenderer);\n            this._constantSourceNodeRenderer = constantSourceNodeRenderer;\n            this._nativeConstantSourceNode = nativeConstantSourceNode;\n            /*\n             * Bug #62 & #74: Safari does not support ConstantSourceNodes and does not export the correct values for maxValue and minValue\n             * for GainNodes.\n             */\n            this._offset = createAudioParam(this, isOffline, nativeConstantSourceNode.offset, MOST_POSITIVE_SINGLE_FLOAT, MOST_NEGATIVE_SINGLE_FLOAT);\n            this._onended = null;\n        }\n        get offset() {\n            return this._offset;\n        }\n        get onended() {\n            return this._onended;\n        }\n        set onended(value) {\n            const wrappedListener = typeof value === 'function' ? wrapEventListener(this, value) : null;\n            this._nativeConstantSourceNode.onended = wrappedListener;\n            const nativeOnEnded = this._nativeConstantSourceNode.onended;\n            this._onended = nativeOnEnded !== null && nativeOnEnded === wrappedListener ? value : nativeOnEnded;\n        }\n        start(when = 0) {\n            this._nativeConstantSourceNode.start(when);\n            if (this._constantSourceNodeRenderer !== null) {\n                this._constantSourceNodeRenderer.start = when;\n            }\n            if (this.context.state !== 'closed') {\n                setInternalStateToActive(this);\n                const resetInternalStateToPassive = () => {\n                    this._nativeConstantSourceNode.removeEventListener('ended', resetInternalStateToPassive);\n                    if (isActiveAudioNode(this)) {\n                        setInternalStateToPassive(this);\n                    }\n                };\n                this._nativeConstantSourceNode.addEventListener('ended', resetInternalStateToPassive);\n            }\n        }\n        stop(when = 0) {\n            this._nativeConstantSourceNode.stop(when);\n            if (this._constantSourceNodeRenderer !== null) {\n                this._constantSourceNodeRenderer.stop = when;\n            }\n        }\n    };\n};\n//# sourceMappingURL=constant-source-node-constructor.js.map","const DEFAULT_OPTIONS = {\n    buffer: null,\n    channelCount: 2,\n    channelCountMode: 'clamped-max',\n    channelInterpretation: 'speakers',\n    disableNormalization: false\n};\nexport const createConvolverNodeConstructor = (audioNodeConstructor, createConvolverNodeRenderer, createNativeConvolverNode, getNativeContext, isNativeOfflineAudioContext, setAudioNodeTailTime) => {\n    return class ConvolverNode extends audioNodeConstructor {\n        constructor(context, options) {\n            const nativeContext = getNativeContext(context);\n            const mergedOptions = { ...DEFAULT_OPTIONS, ...options };\n            const nativeConvolverNode = createNativeConvolverNode(nativeContext, mergedOptions);\n            const isOffline = isNativeOfflineAudioContext(nativeContext);\n            const convolverNodeRenderer = (isOffline ? createConvolverNodeRenderer() : null);\n            super(context, false, nativeConvolverNode, convolverNodeRenderer);\n            this._isBufferNullified = false;\n            this._nativeConvolverNode = nativeConvolverNode;\n            if (mergedOptions.buffer !== null) {\n                setAudioNodeTailTime(this, mergedOptions.buffer.duration);\n            }\n        }\n        get buffer() {\n            if (this._isBufferNullified) {\n                return null;\n            }\n            return this._nativeConvolverNode.buffer;\n        }\n        set buffer(value) {\n            this._nativeConvolverNode.buffer = value;\n            // Bug #115: Safari does not allow to set the buffer to null.\n            if (value === null && this._nativeConvolverNode.buffer !== null) {\n                const nativeContext = this._nativeConvolverNode.context;\n                this._nativeConvolverNode.buffer = nativeContext.createBuffer(1, 1, 44100);\n                this._isBufferNullified = true;\n                setAudioNodeTailTime(this, 0);\n            }\n            else {\n                this._isBufferNullified = false;\n                setAudioNodeTailTime(this, this._nativeConvolverNode.buffer === null ? 0 : this._nativeConvolverNode.buffer.duration);\n            }\n        }\n        get normalize() {\n            return this._nativeConvolverNode.normalize;\n        }\n        set normalize(value) {\n            this._nativeConvolverNode.normalize = value;\n        }\n    };\n};\n//# sourceMappingURL=convolver-node-constructor.js.map","export const detachArrayBuffer = (arrayBuffer) => {\n    const { port1, port2 } = new MessageChannel();\n    return new Promise((resolve) => {\n        const closeAndResolve = () => {\n            port2.onmessage = null;\n            port1.close();\n            port2.close();\n            resolve();\n        };\n        port2.onmessage = () => closeAndResolve();\n        try {\n            port1.postMessage(arrayBuffer, [arrayBuffer]);\n        }\n        finally {\n            closeAndResolve();\n        }\n    });\n};\n//# sourceMappingURL=detach-array-buffer.js.map","const DEFAULT_OPTIONS = {\n    channelCount: 2,\n    channelCountMode: 'max',\n    channelInterpretation: 'speakers',\n    delayTime: 0,\n    maxDelayTime: 1\n};\nexport const createDelayNodeConstructor = (audioNodeConstructor, createAudioParam, createDelayNodeRenderer, createNativeDelayNode, getNativeContext, isNativeOfflineAudioContext, setAudioNodeTailTime) => {\n    return class DelayNode extends audioNodeConstructor {\n        constructor(context, options) {\n            const nativeContext = getNativeContext(context);\n            const mergedOptions = { ...DEFAULT_OPTIONS, ...options };\n            const nativeDelayNode = createNativeDelayNode(nativeContext, mergedOptions);\n            const isOffline = isNativeOfflineAudioContext(nativeContext);\n            const delayNodeRenderer = (isOffline ? createDelayNodeRenderer(mergedOptions.maxDelayTime) : null);\n            super(context, false, nativeDelayNode, delayNodeRenderer);\n            this._delayTime = createAudioParam(this, isOffline, nativeDelayNode.delayTime);\n            setAudioNodeTailTime(this, mergedOptions.maxDelayTime);\n        }\n        get delayTime() {\n            return this._delayTime;\n        }\n    };\n};\n//# sourceMappingURL=delay-node-constructor.js.map","import { isNativeAudioNode } from '../guards/native-audio-node';\nconst getOutputAudioNodeAtIndex = (createIndexSizeError, outputAudioNodes, output) => {\n    const outputAudioNode = outputAudioNodes[output];\n    if (outputAudioNode === undefined) {\n        throw createIndexSizeError();\n    }\n    return outputAudioNode;\n};\nexport const createDisconnectMultipleOutputs = (createIndexSizeError) => {\n    return (outputAudioNodes, destinationOrOutput = undefined, output = undefined, input = 0) => {\n        if (destinationOrOutput === undefined) {\n            return outputAudioNodes.forEach((outputAudioNode) => outputAudioNode.disconnect());\n        }\n        if (typeof destinationOrOutput === 'number') {\n            return getOutputAudioNodeAtIndex(createIndexSizeError, outputAudioNodes, destinationOrOutput).disconnect();\n        }\n        if (isNativeAudioNode(destinationOrOutput)) {\n            if (output === undefined) {\n                return outputAudioNodes.forEach((outputAudioNode) => outputAudioNode.disconnect(destinationOrOutput));\n            }\n            if (input === undefined) {\n                return getOutputAudioNodeAtIndex(createIndexSizeError, outputAudioNodes, output).disconnect(destinationOrOutput, 0);\n            }\n            return getOutputAudioNodeAtIndex(createIndexSizeError, outputAudioNodes, output).disconnect(destinationOrOutput, 0, input);\n        }\n        if (output === undefined) {\n            return outputAudioNodes.forEach((outputAudioNode) => outputAudioNode.disconnect(destinationOrOutput));\n        }\n        return getOutputAudioNodeAtIndex(createIndexSizeError, outputAudioNodes, output).disconnect(destinationOrOutput, 0);\n    };\n};\n//# sourceMappingURL=disconnect-multiple-outputs.js.map","const DEFAULT_OPTIONS = {\n    attack: 0.003,\n    channelCount: 2,\n    channelCountMode: 'clamped-max',\n    channelInterpretation: 'speakers',\n    knee: 30,\n    ratio: 12,\n    release: 0.25,\n    threshold: -24\n};\nexport const createDynamicsCompressorNodeConstructor = (audioNodeConstructor, createAudioParam, createDynamicsCompressorNodeRenderer, createNativeDynamicsCompressorNode, createNotSupportedError, getNativeContext, isNativeOfflineAudioContext, setAudioNodeTailTime) => {\n    return class DynamicsCompressorNode extends audioNodeConstructor {\n        constructor(context, options) {\n            const nativeContext = getNativeContext(context);\n            const mergedOptions = { ...DEFAULT_OPTIONS, ...options };\n            const nativeDynamicsCompressorNode = createNativeDynamicsCompressorNode(nativeContext, mergedOptions);\n            const isOffline = isNativeOfflineAudioContext(nativeContext);\n            const dynamicsCompressorNodeRenderer = (isOffline ? createDynamicsCompressorNodeRenderer() : null);\n            super(context, false, nativeDynamicsCompressorNode, dynamicsCompressorNodeRenderer);\n            this._attack = createAudioParam(this, isOffline, nativeDynamicsCompressorNode.attack);\n            this._knee = createAudioParam(this, isOffline, nativeDynamicsCompressorNode.knee);\n            this._nativeDynamicsCompressorNode = nativeDynamicsCompressorNode;\n            this._ratio = createAudioParam(this, isOffline, nativeDynamicsCompressorNode.ratio);\n            this._release = createAudioParam(this, isOffline, nativeDynamicsCompressorNode.release);\n            this._threshold = createAudioParam(this, isOffline, nativeDynamicsCompressorNode.threshold);\n            setAudioNodeTailTime(this, 0.006);\n        }\n        get attack() {\n            return this._attack;\n        }\n        // Bug #108: Safari allows a channelCount of three and above which is why the getter and setter needs to be overwritten here.\n        get channelCount() {\n            return this._nativeDynamicsCompressorNode.channelCount;\n        }\n        set channelCount(value) {\n            const previousChannelCount = this._nativeDynamicsCompressorNode.channelCount;\n            this._nativeDynamicsCompressorNode.channelCount = value;\n            if (value > 2) {\n                this._nativeDynamicsCompressorNode.channelCount = previousChannelCount;\n                throw createNotSupportedError();\n            }\n        }\n        /*\n         * Bug #109: Only Chrome, Firefox and Opera disallow a channelCountMode of 'max' yet which is why the getter and setter needs to be\n         * overwritten here.\n         */\n        get channelCountMode() {\n            return this._nativeDynamicsCompressorNode.channelCountMode;\n        }\n        set channelCountMode(value) {\n            const previousChannelCount = this._nativeDynamicsCompressorNode.channelCountMode;\n            this._nativeDynamicsCompressorNode.channelCountMode = value;\n            if (value === 'max') {\n                this._nativeDynamicsCompressorNode.channelCountMode = previousChannelCount;\n                throw createNotSupportedError();\n            }\n        }\n        get knee() {\n            return this._knee;\n        }\n        get ratio() {\n            return this._ratio;\n        }\n        get reduction() {\n            // Bug #111: Safari returns an AudioParam instead of a number.\n            if (typeof this._nativeDynamicsCompressorNode.reduction.value === 'number') {\n                return this._nativeDynamicsCompressorNode.reduction.value;\n            }\n            return this._nativeDynamicsCompressorNode.reduction;\n        }\n        get release() {\n            return this._release;\n        }\n        get threshold() {\n            return this._threshold;\n        }\n    };\n};\n//# sourceMappingURL=dynamics-compressor-node-constructor.js.map","import { MOST_NEGATIVE_SINGLE_FLOAT, MOST_POSITIVE_SINGLE_FLOAT } from '../constants';\nconst DEFAULT_OPTIONS = {\n    channelCount: 2,\n    channelCountMode: 'max',\n    channelInterpretation: 'speakers',\n    gain: 1\n};\nexport const createGainNodeConstructor = (audioNodeConstructor, createAudioParam, createGainNodeRenderer, createNativeGainNode, getNativeContext, isNativeOfflineAudioContext) => {\n    return class GainNode extends audioNodeConstructor {\n        constructor(context, options) {\n            const nativeContext = getNativeContext(context);\n            const mergedOptions = { ...DEFAULT_OPTIONS, ...options };\n            const nativeGainNode = createNativeGainNode(nativeContext, mergedOptions);\n            const isOffline = isNativeOfflineAudioContext(nativeContext);\n            const gainNodeRenderer = (isOffline ? createGainNodeRenderer() : null);\n            super(context, false, nativeGainNode, gainNodeRenderer);\n            // Bug #74: Safari does not export the correct values for maxValue and minValue.\n            this._gain = createAudioParam(this, isOffline, nativeGainNode.gain, MOST_POSITIVE_SINGLE_FLOAT, MOST_NEGATIVE_SINGLE_FLOAT);\n        }\n        get gain() {\n            return this._gain;\n        }\n    };\n};\n//# sourceMappingURL=gain-node-constructor.js.map","export const createInvalidStateError = () => new DOMException('', 'InvalidStateError');\n//# sourceMappingURL=invalid-state-error.js.map","export const createInvalidAccessError = () => new DOMException('', 'InvalidAccessError');\n//# sourceMappingURL=invalid-access-error.js.map","import { wrapIIRFilterNodeGetFrequencyResponseMethod } from '../helpers/wrap-iir-filter-node-get-frequency-response-method';\nconst DEFAULT_OPTIONS = {\n    channelCount: 2,\n    channelCountMode: 'max',\n    channelInterpretation: 'speakers'\n};\nexport const createIIRFilterNodeConstructor = (audioNodeConstructor, createNativeIIRFilterNode, createIIRFilterNodeRenderer, getNativeContext, isNativeOfflineAudioContext, setAudioNodeTailTime) => {\n    return class IIRFilterNode extends audioNodeConstructor {\n        constructor(context, options) {\n            const nativeContext = getNativeContext(context);\n            const isOffline = isNativeOfflineAudioContext(nativeContext);\n            const mergedOptions = { ...DEFAULT_OPTIONS, ...options };\n            const nativeIIRFilterNode = createNativeIIRFilterNode(nativeContext, isOffline ? null : context.baseLatency, mergedOptions);\n            const iirFilterNodeRenderer = ((isOffline ? createIIRFilterNodeRenderer(mergedOptions.feedback, mergedOptions.feedforward) : null));\n            super(context, false, nativeIIRFilterNode, iirFilterNodeRenderer);\n            // Bug #23 & #24: FirefoxDeveloper does not throw an InvalidAccessError.\n            // @todo Write a test which allows other browsers to remain unpatched.\n            wrapIIRFilterNodeGetFrequencyResponseMethod(nativeIIRFilterNode);\n            this._nativeIIRFilterNode = nativeIIRFilterNode;\n            // @todo Determine a meaningful tail-time instead of just using one second.\n            setAudioNodeTailTime(this, 1);\n        }\n        getFrequencyResponse(frequencyHz, magResponse, phaseResponse) {\n            return this._nativeIIRFilterNode.getFrequencyResponse(frequencyHz, magResponse, phaseResponse);\n        }\n    };\n};\n//# sourceMappingURL=iir-filter-node-constructor.js.map","// This implementation as shamelessly inspired by source code of\n// tslint:disable-next-line:max-line-length\n// {@link https://chromium.googlesource.com/chromium/src.git/+/master/third_party/WebKit/Source/platform/audio/IIRFilter.cpp|Chromium's IIRFilter}.\nexport const filterBuffer = (feedback, feedbackLength, feedforward, feedforwardLength, minLength, xBuffer, yBuffer, bufferIndex, bufferLength, input, output) => {\n    const inputLength = input.length;\n    let i = bufferIndex;\n    for (let j = 0; j < inputLength; j += 1) {\n        let y = feedforward[0] * input[j];\n        for (let k = 1; k < minLength; k += 1) {\n            const x = (i - k) & (bufferLength - 1); // tslint:disable-line:no-bitwise\n            y += feedforward[k] * xBuffer[x];\n            y -= feedback[k] * yBuffer[x];\n        }\n        for (let k = minLength; k < feedforwardLength; k += 1) {\n            y += feedforward[k] * xBuffer[(i - k) & (bufferLength - 1)]; // tslint:disable-line:no-bitwise\n        }\n        for (let k = minLength; k < feedbackLength; k += 1) {\n            y -= feedback[k] * yBuffer[(i - k) & (bufferLength - 1)]; // tslint:disable-line:no-bitwise\n        }\n        xBuffer[i] = input[j];\n        yBuffer[i] = y;\n        i = (i + 1) & (bufferLength - 1); // tslint:disable-line:no-bitwise\n        output[j] = y;\n    }\n    return i;\n};\n//# sourceMappingURL=filter-buffer.js.map","const DEFAULT_OPTIONS = {\n    channelCount: 2,\n    channelCountMode: 'explicit',\n    channelInterpretation: 'speakers'\n};\nexport const createMediaStreamAudioDestinationNodeConstructor = (audioNodeConstructor, createNativeMediaStreamAudioDestinationNode, getNativeContext, isNativeOfflineAudioContext) => {\n    return class MediaStreamAudioDestinationNode extends audioNodeConstructor {\n        constructor(context, options) {\n            const nativeContext = getNativeContext(context);\n            // Bug #173: Safari allows to create a MediaStreamAudioDestinationNode with an OfflineAudioContext.\n            if (isNativeOfflineAudioContext(nativeContext)) {\n                throw new TypeError();\n            }\n            const mergedOptions = { ...DEFAULT_OPTIONS, ...options };\n            const nativeMediaStreamAudioDestinationNode = createNativeMediaStreamAudioDestinationNode(nativeContext, mergedOptions);\n            super(context, false, nativeMediaStreamAudioDestinationNode, null);\n            this._nativeMediaStreamAudioDestinationNode = nativeMediaStreamAudioDestinationNode;\n        }\n        get stream() {\n            return this._nativeMediaStreamAudioDestinationNode.stream;\n        }\n    };\n};\n//# sourceMappingURL=media-stream-audio-destination-node-constructor.js.map","export const testPromiseSupport = (nativeContext) => {\n    // This 12 numbers represent the 48 bytes of an empty WAVE file with a single sample.\n    const uint32Array = new Uint32Array([1179011410, 40, 1163280727, 544501094, 16, 131073, 44100, 176400, 1048580, 1635017060, 4, 0]);\n    try {\n        // Bug #1: Safari requires a successCallback.\n        const promise = nativeContext.decodeAudioData(uint32Array.buffer, () => {\n            // Ignore the success callback.\n        });\n        if (promise === undefined) {\n            return false;\n        }\n        promise.catch(() => {\n            // Ignore rejected errors.\n        });\n        return true;\n    }\n    catch {\n        // Ignore errors.\n    }\n    return false;\n};\n//# sourceMappingURL=test-promise-support.js.map","export const assignNativeAudioNodeOption = (nativeAudioNode, options, option) => {\n    const value = options[option];\n    if (value !== undefined && value !== nativeAudioNode[option]) {\n        nativeAudioNode[option] = value;\n    }\n};\n//# sourceMappingURL=assign-native-audio-node-option.js.map","import { assignNativeAudioNodeOption } from './assign-native-audio-node-option';\nexport const assignNativeAudioNodeOptions = (nativeAudioNode, options) => {\n    assignNativeAudioNodeOption(nativeAudioNode, options, 'channelCount');\n    assignNativeAudioNodeOption(nativeAudioNode, options, 'channelCountMode');\n    assignNativeAudioNodeOption(nativeAudioNode, options, 'channelInterpretation');\n};\n//# sourceMappingURL=assign-native-audio-node-options.js.map","export const testAnalyserNodeGetFloatTimeDomainDataMethodSupport = (nativeAnalyserNode) => {\n    return typeof nativeAnalyserNode.getFloatTimeDomainData === 'function';\n};\n//# sourceMappingURL=test-analyser-node-get-float-time-domain-data-method-support.js.map","export const assignNativeAudioNodeAudioParamValue = (nativeAudioNode, options, audioParam) => {\n    const value = options[audioParam];\n    if (value !== undefined && value !== nativeAudioNode[audioParam].value) {\n        nativeAudioNode[audioParam].value = value;\n    }\n};\n//# sourceMappingURL=assign-native-audio-node-audio-param-value.js.map","export const wrapAudioScheduledSourceNodeStartMethodNegativeParameters = (nativeAudioScheduledSourceNode) => {\n    nativeAudioScheduledSourceNode.start = ((start) => {\n        return (when = 0, offset = 0, duration) => {\n            if ((typeof duration === 'number' && duration < 0) || offset < 0 || when < 0) {\n                throw new RangeError(\"The parameters can't be negative.\");\n            }\n            // @todo TypeScript cannot infer the overloaded signature with 3 arguments yet.\n            start.call(nativeAudioScheduledSourceNode, when, offset, duration);\n        };\n    })(nativeAudioScheduledSourceNode.start);\n};\n//# sourceMappingURL=wrap-audio-scheduled-source-node-start-method-negative-parameters.js.map","export const wrapAudioScheduledSourceNodeStopMethodNegativeParameters = (nativeAudioScheduledSourceNode) => {\n    nativeAudioScheduledSourceNode.stop = ((stop) => {\n        return (when = 0) => {\n            if (when < 0) {\n                throw new RangeError(\"The parameter can't be negative.\");\n            }\n            stop.call(nativeAudioScheduledSourceNode, when);\n        };\n    })(nativeAudioScheduledSourceNode.stop);\n};\n//# sourceMappingURL=wrap-audio-scheduled-source-node-stop-method-negative-parameters.js.map","export const computeBufferSize = (baseLatency, sampleRate) => {\n    if (baseLatency === null) {\n        return 512;\n    }\n    return Math.max(512, Math.min(16384, Math.pow(2, Math.round(Math.log2(baseLatency * sampleRate)))));\n};\n//# sourceMappingURL=compute-buffer-size.js.map","import { assignNativeAudioNodeAudioParamValue } from '../helpers/assign-native-audio-node-audio-param-value';\nimport { assignNativeAudioNodeOption } from '../helpers/assign-native-audio-node-option';\nimport { assignNativeAudioNodeOptions } from '../helpers/assign-native-audio-node-options';\nexport const createNativeBiquadFilterNode = (nativeContext, options) => {\n    const nativeBiquadFilterNode = nativeContext.createBiquadFilter();\n    assignNativeAudioNodeOptions(nativeBiquadFilterNode, options);\n    assignNativeAudioNodeAudioParamValue(nativeBiquadFilterNode, options, 'Q');\n    assignNativeAudioNodeAudioParamValue(nativeBiquadFilterNode, options, 'detune');\n    assignNativeAudioNodeAudioParamValue(nativeBiquadFilterNode, options, 'frequency');\n    assignNativeAudioNodeAudioParamValue(nativeBiquadFilterNode, options, 'gain');\n    assignNativeAudioNodeOption(nativeBiquadFilterNode, options, 'type');\n    return nativeBiquadFilterNode;\n};\n//# sourceMappingURL=native-biquad-filter-node.js.map","import { assignNativeAudioNodeOptions } from '../helpers/assign-native-audio-node-options';\nimport { wrapChannelSplitterNode } from '../helpers/wrap-channel-splitter-node';\nexport const createNativeChannelSplitterNode = (nativeContext, options) => {\n    const nativeChannelSplitterNode = nativeContext.createChannelSplitter(options.numberOfOutputs);\n    // Bug #96: Safari does not have the correct channelCount.\n    // Bug #29: Safari does not have the correct channelCountMode.\n    // Bug #31: Safari does not have the correct channelInterpretation.\n    assignNativeAudioNodeOptions(nativeChannelSplitterNode, options);\n    // Bug #29, #30, #31, #32, #96 & #97: Only Chrome, Edge, Firefox & Opera partially support the spec yet.\n    wrapChannelSplitterNode(nativeChannelSplitterNode);\n    return nativeChannelSplitterNode;\n};\n//# sourceMappingURL=native-channel-splitter-node.js.map","import { createInvalidStateError } from '../factories/invalid-state-error';\nexport const wrapChannelSplitterNode = (channelSplitterNode) => {\n    const channelCount = channelSplitterNode.numberOfOutputs;\n    // Bug #97: Safari does not throw an error when attempting to change the channelCount to something other than its initial value.\n    Object.defineProperty(channelSplitterNode, 'channelCount', {\n        get: () => channelCount,\n        set: (value) => {\n            if (value !== channelCount) {\n                throw createInvalidStateError();\n            }\n        }\n    });\n    // Bug #30: Safari does not throw an error when attempting to change the channelCountMode to something other than explicit.\n    Object.defineProperty(channelSplitterNode, 'channelCountMode', {\n        get: () => 'explicit',\n        set: (value) => {\n            if (value !== 'explicit') {\n                throw createInvalidStateError();\n            }\n        }\n    });\n    // Bug #32: Safari does not throw an error when attempting to change the channelInterpretation to something other than discrete.\n    Object.defineProperty(channelSplitterNode, 'channelInterpretation', {\n        get: () => 'discrete',\n        set: (value) => {\n            if (value !== 'discrete') {\n                throw createInvalidStateError();\n            }\n        }\n    });\n};\n//# sourceMappingURL=wrap-channel-splitter-node.js.map","export const interceptConnections = (original, interceptor) => {\n    original.connect = interceptor.connect.bind(interceptor);\n    original.disconnect = interceptor.disconnect.bind(interceptor);\n    return original;\n};\n//# sourceMappingURL=intercept-connections.js.map","import { assignNativeAudioNodeAudioParamValue } from '../helpers/assign-native-audio-node-audio-param-value';\nimport { assignNativeAudioNodeOptions } from '../helpers/assign-native-audio-node-options';\nexport const createNativeDelayNode = (nativeContext, options) => {\n    const nativeDelayNode = nativeContext.createDelay(options.maxDelayTime);\n    assignNativeAudioNodeOptions(nativeDelayNode, options);\n    assignNativeAudioNodeAudioParamValue(nativeDelayNode, options, 'delayTime');\n    return nativeDelayNode;\n};\n//# sourceMappingURL=native-delay-node.js.map","import { assignNativeAudioNodeAudioParamValue } from '../helpers/assign-native-audio-node-audio-param-value';\nimport { assignNativeAudioNodeOptions } from '../helpers/assign-native-audio-node-options';\nexport const createNativeGainNode = (nativeContext, options) => {\n    const nativeGainNode = nativeContext.createGain();\n    assignNativeAudioNodeOptions(nativeGainNode, options);\n    assignNativeAudioNodeAudioParamValue(nativeGainNode, options, 'gain');\n    return nativeGainNode;\n};\n//# sourceMappingURL=native-gain-node.js.map","import { computeBufferSize } from '../helpers/compute-buffer-size';\nimport { filterBuffer } from '../helpers/filter-buffer';\nimport { interceptConnections } from '../helpers/intercept-connections';\nfunction divide(a, b) {\n    const denominator = b[0] * b[0] + b[1] * b[1];\n    return [(a[0] * b[0] + a[1] * b[1]) / denominator, (a[1] * b[0] - a[0] * b[1]) / denominator];\n}\nfunction multiply(a, b) {\n    return [a[0] * b[0] - a[1] * b[1], a[0] * b[1] + a[1] * b[0]];\n}\nfunction evaluatePolynomial(coefficient, z) {\n    let result = [0, 0];\n    for (let i = coefficient.length - 1; i >= 0; i -= 1) {\n        result = multiply(result, z);\n        result[0] += coefficient[i];\n    }\n    return result;\n}\nexport const createNativeIIRFilterNodeFakerFactory = (createInvalidAccessError, createInvalidStateError, createNativeScriptProcessorNode, createNotSupportedError) => {\n    return (nativeContext, baseLatency, { channelCount, channelCountMode, channelInterpretation, feedback, feedforward }) => {\n        const bufferSize = computeBufferSize(baseLatency, nativeContext.sampleRate);\n        const convertedFeedback = feedback instanceof Float64Array ? feedback : new Float64Array(feedback);\n        const convertedFeedforward = feedforward instanceof Float64Array ? feedforward : new Float64Array(feedforward);\n        const feedbackLength = convertedFeedback.length;\n        const feedforwardLength = convertedFeedforward.length;\n        const minLength = Math.min(feedbackLength, feedforwardLength);\n        if (feedbackLength === 0 || feedbackLength > 20) {\n            throw createNotSupportedError();\n        }\n        if (convertedFeedback[0] === 0) {\n            throw createInvalidStateError();\n        }\n        if (feedforwardLength === 0 || feedforwardLength > 20) {\n            throw createNotSupportedError();\n        }\n        if (convertedFeedforward[0] === 0) {\n            throw createInvalidStateError();\n        }\n        if (convertedFeedback[0] !== 1) {\n            for (let i = 0; i < feedforwardLength; i += 1) {\n                convertedFeedforward[i] /= convertedFeedback[0];\n            }\n            for (let i = 1; i < feedbackLength; i += 1) {\n                convertedFeedback[i] /= convertedFeedback[0];\n            }\n        }\n        const scriptProcessorNode = createNativeScriptProcessorNode(nativeContext, bufferSize, channelCount, channelCount);\n        scriptProcessorNode.channelCount = channelCount;\n        scriptProcessorNode.channelCountMode = channelCountMode;\n        scriptProcessorNode.channelInterpretation = channelInterpretation;\n        const bufferLength = 32;\n        const bufferIndexes = [];\n        const xBuffers = [];\n        const yBuffers = [];\n        for (let i = 0; i < channelCount; i += 1) {\n            bufferIndexes.push(0);\n            const xBuffer = new Float32Array(bufferLength);\n            const yBuffer = new Float32Array(bufferLength);\n            xBuffer.fill(0);\n            yBuffer.fill(0);\n            xBuffers.push(xBuffer);\n            yBuffers.push(yBuffer);\n        }\n        // tslint:disable-next-line:deprecation\n        scriptProcessorNode.onaudioprocess = (event) => {\n            const inputBuffer = event.inputBuffer;\n            const outputBuffer = event.outputBuffer;\n            const numberOfChannels = inputBuffer.numberOfChannels;\n            for (let i = 0; i < numberOfChannels; i += 1) {\n                const input = inputBuffer.getChannelData(i);\n                const output = outputBuffer.getChannelData(i);\n                bufferIndexes[i] = filterBuffer(convertedFeedback, feedbackLength, convertedFeedforward, feedforwardLength, minLength, xBuffers[i], yBuffers[i], bufferIndexes[i], bufferLength, input, output);\n            }\n        };\n        const nyquist = nativeContext.sampleRate / 2;\n        const nativeIIRFilterNodeFaker = {\n            get bufferSize() {\n                return bufferSize;\n            },\n            get channelCount() {\n                return scriptProcessorNode.channelCount;\n            },\n            set channelCount(value) {\n                scriptProcessorNode.channelCount = value;\n            },\n            get channelCountMode() {\n                return scriptProcessorNode.channelCountMode;\n            },\n            set channelCountMode(value) {\n                scriptProcessorNode.channelCountMode = value;\n            },\n            get channelInterpretation() {\n                return scriptProcessorNode.channelInterpretation;\n            },\n            set channelInterpretation(value) {\n                scriptProcessorNode.channelInterpretation = value;\n            },\n            get context() {\n                return scriptProcessorNode.context;\n            },\n            get inputs() {\n                return [scriptProcessorNode];\n            },\n            get numberOfInputs() {\n                return scriptProcessorNode.numberOfInputs;\n            },\n            get numberOfOutputs() {\n                return scriptProcessorNode.numberOfOutputs;\n            },\n            addEventListener(...args) {\n                // @todo Dissallow adding an audioprocess listener.\n                return scriptProcessorNode.addEventListener(args[0], args[1], args[2]);\n            },\n            dispatchEvent(...args) {\n                return scriptProcessorNode.dispatchEvent(args[0]);\n            },\n            getFrequencyResponse(frequencyHz, magResponse, phaseResponse) {\n                if (frequencyHz.length !== magResponse.length || magResponse.length !== phaseResponse.length) {\n                    throw createInvalidAccessError();\n                }\n                const length = frequencyHz.length;\n                for (let i = 0; i < length; i += 1) {\n                    const omega = -Math.PI * (frequencyHz[i] / nyquist);\n                    const z = [Math.cos(omega), Math.sin(omega)];\n                    const numerator = evaluatePolynomial(convertedFeedforward, z);\n                    const denominator = evaluatePolynomial(convertedFeedback, z);\n                    const response = divide(numerator, denominator);\n                    magResponse[i] = Math.sqrt(response[0] * response[0] + response[1] * response[1]);\n                    phaseResponse[i] = Math.atan2(response[1], response[0]);\n                }\n            },\n            removeEventListener(...args) {\n                return scriptProcessorNode.removeEventListener(args[0], args[1], args[2]);\n            }\n        };\n        return interceptConnections(nativeIIRFilterNodeFaker, scriptProcessorNode);\n    };\n};\n//# sourceMappingURL=native-iir-filter-node-faker-factory.js.map","export const createNativeScriptProcessorNode = (nativeContext, bufferSize, numberOfInputChannels, numberOfOutputChannels) => {\n    return nativeContext.createScriptProcessor(bufferSize, numberOfInputChannels, numberOfOutputChannels); // tslint:disable-line deprecation\n};\n//# sourceMappingURL=native-script-processor-node.js.map","export const createNotSupportedError = () => new DOMException('', 'NotSupportedError');\n//# sourceMappingURL=not-supported-error.js.map","import { deactivateAudioGraph } from '../helpers/deactivate-audio-graph';\nimport { testPromiseSupport } from '../helpers/test-promise-support';\nconst DEFAULT_OPTIONS = {\n    numberOfChannels: 1\n};\nexport const createOfflineAudioContextConstructor = (baseAudioContextConstructor, cacheTestResult, createInvalidStateError, createNativeOfflineAudioContext, startRendering) => {\n    return class OfflineAudioContext extends baseAudioContextConstructor {\n        constructor(a, b, c) {\n            let options;\n            if (typeof a === 'number' && b !== undefined && c !== undefined) {\n                options = { length: b, numberOfChannels: a, sampleRate: c };\n            }\n            else if (typeof a === 'object') {\n                options = a;\n            }\n            else {\n                throw new Error('The given parameters are not valid.');\n            }\n            const { length, numberOfChannels, sampleRate } = { ...DEFAULT_OPTIONS, ...options };\n            const nativeOfflineAudioContext = createNativeOfflineAudioContext(numberOfChannels, length, sampleRate);\n            // #21 Safari does not support promises and therefore would fire the statechange event before the promise can be resolved.\n            if (!cacheTestResult(testPromiseSupport, () => testPromiseSupport(nativeOfflineAudioContext))) {\n                nativeOfflineAudioContext.addEventListener('statechange', (() => {\n                    let i = 0;\n                    const delayStateChangeEvent = (event) => {\n                        if (this._state === 'running') {\n                            if (i > 0) {\n                                nativeOfflineAudioContext.removeEventListener('statechange', delayStateChangeEvent);\n                                event.stopImmediatePropagation();\n                                this._waitForThePromiseToSettle(event);\n                            }\n                            else {\n                                i += 1;\n                            }\n                        }\n                    };\n                    return delayStateChangeEvent;\n                })());\n            }\n            super(nativeOfflineAudioContext, numberOfChannels);\n            this._length = length;\n            this._nativeOfflineAudioContext = nativeOfflineAudioContext;\n            this._state = null;\n        }\n        get length() {\n            // Bug #17: Safari does not yet expose the length.\n            if (this._nativeOfflineAudioContext.length === undefined) {\n                return this._length;\n            }\n            return this._nativeOfflineAudioContext.length;\n        }\n        get state() {\n            return this._state === null ? this._nativeOfflineAudioContext.state : this._state;\n        }\n        startRendering() {\n            /*\n             * Bug #9 & #59: It is theoretically possible that startRendering() will first render a partialOfflineAudioContext. Therefore\n             * the state of the nativeOfflineAudioContext might no transition to running immediately.\n             */\n            if (this._state === 'running') {\n                return Promise.reject(createInvalidStateError());\n            }\n            this._state = 'running';\n            return startRendering(this.destination, this._nativeOfflineAudioContext).finally(() => {\n                this._state = null;\n                deactivateAudioGraph(this);\n            });\n        }\n        _waitForThePromiseToSettle(event) {\n            if (this._state === null) {\n                this._nativeOfflineAudioContext.dispatchEvent(event);\n            }\n            else {\n                setTimeout(() => this._waitForThePromiseToSettle(event));\n            }\n        }\n    };\n};\n//# sourceMappingURL=offline-audio-context-constructor.js.map","import { isActiveAudioNode } from '../helpers/is-active-audio-node';\nimport { setInternalStateToActive } from '../helpers/set-internal-state-to-active';\nimport { setInternalStateToPassive } from '../helpers/set-internal-state-to-passive';\nconst DEFAULT_OPTIONS = {\n    channelCount: 2,\n    channelCountMode: 'max',\n    channelInterpretation: 'speakers',\n    detune: 0,\n    frequency: 440,\n    periodicWave: undefined,\n    type: 'sine'\n};\nexport const createOscillatorNodeConstructor = (audioNodeConstructor, createAudioParam, createNativeOscillatorNode, createOscillatorNodeRenderer, getNativeContext, isNativeOfflineAudioContext, wrapEventListener) => {\n    return class OscillatorNode extends audioNodeConstructor {\n        constructor(context, options) {\n            const nativeContext = getNativeContext(context);\n            const mergedOptions = { ...DEFAULT_OPTIONS, ...options };\n            const nativeOscillatorNode = createNativeOscillatorNode(nativeContext, mergedOptions);\n            const isOffline = isNativeOfflineAudioContext(nativeContext);\n            const oscillatorNodeRenderer = (isOffline ? createOscillatorNodeRenderer() : null);\n            const nyquist = context.sampleRate / 2;\n            super(context, false, nativeOscillatorNode, oscillatorNodeRenderer);\n            // Bug #81: Firefox & Safari do not export the correct values for maxValue and minValue.\n            this._detune = createAudioParam(this, isOffline, nativeOscillatorNode.detune, 153600, -153600);\n            // Bug #76: Safari does not export the correct values for maxValue and minValue.\n            this._frequency = createAudioParam(this, isOffline, nativeOscillatorNode.frequency, nyquist, -nyquist);\n            this._nativeOscillatorNode = nativeOscillatorNode;\n            this._onended = null;\n            this._oscillatorNodeRenderer = oscillatorNodeRenderer;\n            if (this._oscillatorNodeRenderer !== null && mergedOptions.periodicWave !== undefined) {\n                this._oscillatorNodeRenderer.periodicWave =\n                    mergedOptions.periodicWave;\n            }\n        }\n        get detune() {\n            return this._detune;\n        }\n        get frequency() {\n            return this._frequency;\n        }\n        get onended() {\n            return this._onended;\n        }\n        set onended(value) {\n            const wrappedListener = typeof value === 'function' ? wrapEventListener(this, value) : null;\n            this._nativeOscillatorNode.onended = wrappedListener;\n            const nativeOnEnded = this._nativeOscillatorNode.onended;\n            this._onended = nativeOnEnded !== null && nativeOnEnded === wrappedListener ? value : nativeOnEnded;\n        }\n        get type() {\n            return this._nativeOscillatorNode.type;\n        }\n        set type(value) {\n            this._nativeOscillatorNode.type = value;\n            if (this._oscillatorNodeRenderer !== null) {\n                this._oscillatorNodeRenderer.periodicWave = null;\n            }\n        }\n        setPeriodicWave(periodicWave) {\n            this._nativeOscillatorNode.setPeriodicWave(periodicWave);\n            if (this._oscillatorNodeRenderer !== null) {\n                this._oscillatorNodeRenderer.periodicWave = periodicWave;\n            }\n        }\n        start(when = 0) {\n            this._nativeOscillatorNode.start(when);\n            if (this._oscillatorNodeRenderer !== null) {\n                this._oscillatorNodeRenderer.start = when;\n            }\n            if (this.context.state !== 'closed') {\n                setInternalStateToActive(this);\n                const resetInternalStateToPassive = () => {\n                    this._nativeOscillatorNode.removeEventListener('ended', resetInternalStateToPassive);\n                    if (isActiveAudioNode(this)) {\n                        setInternalStateToPassive(this);\n                    }\n                };\n                this._nativeOscillatorNode.addEventListener('ended', resetInternalStateToPassive);\n            }\n        }\n        stop(when = 0) {\n            this._nativeOscillatorNode.stop(when);\n            if (this._oscillatorNodeRenderer !== null) {\n                this._oscillatorNodeRenderer.stop = when;\n            }\n        }\n    };\n};\n//# sourceMappingURL=oscillator-node-constructor.js.map","import { MOST_NEGATIVE_SINGLE_FLOAT, MOST_POSITIVE_SINGLE_FLOAT } from '../constants';\nconst DEFAULT_OPTIONS = {\n    channelCount: 2,\n    channelCountMode: 'clamped-max',\n    channelInterpretation: 'speakers',\n    coneInnerAngle: 360,\n    coneOuterAngle: 360,\n    coneOuterGain: 0,\n    distanceModel: 'inverse',\n    maxDistance: 10000,\n    orientationX: 1,\n    orientationY: 0,\n    orientationZ: 0,\n    panningModel: 'equalpower',\n    positionX: 0,\n    positionY: 0,\n    positionZ: 0,\n    refDistance: 1,\n    rolloffFactor: 1\n};\nexport const createPannerNodeConstructor = (audioNodeConstructor, createAudioParam, createNativePannerNode, createPannerNodeRenderer, getNativeContext, isNativeOfflineAudioContext, setAudioNodeTailTime) => {\n    return class PannerNode extends audioNodeConstructor {\n        constructor(context, options) {\n            const nativeContext = getNativeContext(context);\n            const mergedOptions = { ...DEFAULT_OPTIONS, ...options };\n            const nativePannerNode = createNativePannerNode(nativeContext, mergedOptions);\n            const isOffline = isNativeOfflineAudioContext(nativeContext);\n            const pannerNodeRenderer = (isOffline ? createPannerNodeRenderer() : null);\n            super(context, false, nativePannerNode, pannerNodeRenderer);\n            this._nativePannerNode = nativePannerNode;\n            // Bug #74: Safari does not export the correct values for maxValue and minValue.\n            this._orientationX = createAudioParam(this, isOffline, nativePannerNode.orientationX, MOST_POSITIVE_SINGLE_FLOAT, MOST_NEGATIVE_SINGLE_FLOAT);\n            this._orientationY = createAudioParam(this, isOffline, nativePannerNode.orientationY, MOST_POSITIVE_SINGLE_FLOAT, MOST_NEGATIVE_SINGLE_FLOAT);\n            this._orientationZ = createAudioParam(this, isOffline, nativePannerNode.orientationZ, MOST_POSITIVE_SINGLE_FLOAT, MOST_NEGATIVE_SINGLE_FLOAT);\n            this._positionX = createAudioParam(this, isOffline, nativePannerNode.positionX, MOST_POSITIVE_SINGLE_FLOAT, MOST_NEGATIVE_SINGLE_FLOAT);\n            this._positionY = createAudioParam(this, isOffline, nativePannerNode.positionY, MOST_POSITIVE_SINGLE_FLOAT, MOST_NEGATIVE_SINGLE_FLOAT);\n            this._positionZ = createAudioParam(this, isOffline, nativePannerNode.positionZ, MOST_POSITIVE_SINGLE_FLOAT, MOST_NEGATIVE_SINGLE_FLOAT);\n            // @todo Determine a meaningful tail-time instead of just using one second.\n            setAudioNodeTailTime(this, 1);\n        }\n        get coneInnerAngle() {\n            return this._nativePannerNode.coneInnerAngle;\n        }\n        set coneInnerAngle(value) {\n            this._nativePannerNode.coneInnerAngle = value;\n        }\n        get coneOuterAngle() {\n            return this._nativePannerNode.coneOuterAngle;\n        }\n        set coneOuterAngle(value) {\n            this._nativePannerNode.coneOuterAngle = value;\n        }\n        get coneOuterGain() {\n            return this._nativePannerNode.coneOuterGain;\n        }\n        set coneOuterGain(value) {\n            this._nativePannerNode.coneOuterGain = value;\n        }\n        get distanceModel() {\n            return this._nativePannerNode.distanceModel;\n        }\n        set distanceModel(value) {\n            this._nativePannerNode.distanceModel = value;\n        }\n        get maxDistance() {\n            return this._nativePannerNode.maxDistance;\n        }\n        set maxDistance(value) {\n            this._nativePannerNode.maxDistance = value;\n        }\n        get orientationX() {\n            return this._orientationX;\n        }\n        get orientationY() {\n            return this._orientationY;\n        }\n        get orientationZ() {\n            return this._orientationZ;\n        }\n        get panningModel() {\n            return this._nativePannerNode.panningModel;\n        }\n        set panningModel(value) {\n            this._nativePannerNode.panningModel = value;\n        }\n        get positionX() {\n            return this._positionX;\n        }\n        get positionY() {\n            return this._positionY;\n        }\n        get positionZ() {\n            return this._positionZ;\n        }\n        get refDistance() {\n            return this._nativePannerNode.refDistance;\n        }\n        set refDistance(value) {\n            this._nativePannerNode.refDistance = value;\n        }\n        get rolloffFactor() {\n            return this._nativePannerNode.rolloffFactor;\n        }\n        set rolloffFactor(value) {\n            this._nativePannerNode.rolloffFactor = value;\n        }\n    };\n};\n//# sourceMappingURL=panner-node-constructor.js.map","const DEFAULT_OPTIONS = {\n    disableNormalization: false\n};\nexport const createPeriodicWaveConstructor = (createNativePeriodicWave, getNativeContext, periodicWaveStore, sanitizePeriodicWaveOptions) => {\n    return class PeriodicWave {\n        constructor(context, options) {\n            const nativeContext = getNativeContext(context);\n            const mergedOptions = sanitizePeriodicWaveOptions({ ...DEFAULT_OPTIONS, ...options });\n            const periodicWave = createNativePeriodicWave(nativeContext, mergedOptions);\n            periodicWaveStore.add(periodicWave);\n            // This does violate all good pratices but it is used here to simplify the handling of periodic waves.\n            return periodicWave;\n        }\n        static [Symbol.hasInstance](instance) {\n            return ((instance !== null && typeof instance === 'object' && Object.getPrototypeOf(instance) === PeriodicWave.prototype) ||\n                periodicWaveStore.has(instance));\n        }\n    };\n};\n//# sourceMappingURL=periodic-wave-constructor.js.map","const DEFAULT_OPTIONS = {\n    channelCount: 2,\n    /*\n     * Bug #105: The channelCountMode should be 'clamped-max' according to the spec but is set to 'explicit' to achieve consistent\n     * behavior.\n     */\n    channelCountMode: 'explicit',\n    channelInterpretation: 'speakers',\n    pan: 0\n};\nexport const createStereoPannerNodeConstructor = (audioNodeConstructor, createAudioParam, createNativeStereoPannerNode, createStereoPannerNodeRenderer, getNativeContext, isNativeOfflineAudioContext) => {\n    return class StereoPannerNode extends audioNodeConstructor {\n        constructor(context, options) {\n            const nativeContext = getNativeContext(context);\n            const mergedOptions = { ...DEFAULT_OPTIONS, ...options };\n            const nativeStereoPannerNode = createNativeStereoPannerNode(nativeContext, mergedOptions);\n            const isOffline = isNativeOfflineAudioContext(nativeContext);\n            const stereoPannerNodeRenderer = (isOffline ? createStereoPannerNodeRenderer() : null);\n            super(context, false, nativeStereoPannerNode, stereoPannerNodeRenderer);\n            this._pan = createAudioParam(this, isOffline, nativeStereoPannerNode.pan);\n        }\n        get pan() {\n            return this._pan;\n        }\n    };\n};\n//# sourceMappingURL=stereo-panner-node-constructor.js.map","export const createUnknownError = () => new DOMException('', 'UnknownError');\n//# sourceMappingURL=unknown-error.js.map","const DEFAULT_OPTIONS = {\n    channelCount: 2,\n    channelCountMode: 'max',\n    channelInterpretation: 'speakers',\n    curve: null,\n    oversample: 'none'\n};\nexport const createWaveShaperNodeConstructor = (audioNodeConstructor, createInvalidStateError, createNativeWaveShaperNode, createWaveShaperNodeRenderer, getNativeContext, isNativeOfflineAudioContext, setAudioNodeTailTime) => {\n    return class WaveShaperNode extends audioNodeConstructor {\n        constructor(context, options) {\n            const nativeContext = getNativeContext(context);\n            const mergedOptions = { ...DEFAULT_OPTIONS, ...options };\n            const nativeWaveShaperNode = createNativeWaveShaperNode(nativeContext, mergedOptions);\n            const isOffline = isNativeOfflineAudioContext(nativeContext);\n            const waveShaperNodeRenderer = (isOffline ? createWaveShaperNodeRenderer() : null);\n            // @todo Add a mechanism to only switch a WaveShaperNode to active while it is connected.\n            super(context, true, nativeWaveShaperNode, waveShaperNodeRenderer);\n            this._isCurveNullified = false;\n            this._nativeWaveShaperNode = nativeWaveShaperNode;\n            // @todo Determine a meaningful tail-time instead of just using one second.\n            setAudioNodeTailTime(this, 1);\n        }\n        get curve() {\n            if (this._isCurveNullified) {\n                return null;\n            }\n            return this._nativeWaveShaperNode.curve;\n        }\n        set curve(value) {\n            // Bug #103: Safari does not allow to set the curve to null.\n            if (value === null) {\n                this._isCurveNullified = true;\n                this._nativeWaveShaperNode.curve = new Float32Array([0, 0]);\n            }\n            else {\n                // Bug #102: Safari does not throw an InvalidStateError when the curve has less than two samples.\n                // Bug #104: Chrome, Edge and Opera will throw an InvalidAccessError when the curve has less than two samples.\n                if (value.length < 2) {\n                    throw createInvalidStateError();\n                }\n                this._isCurveNullified = false;\n                this._nativeWaveShaperNode.curve = value;\n            }\n        }\n        get oversample() {\n            return this._nativeWaveShaperNode.oversample;\n        }\n        set oversample(value) {\n            this._nativeWaveShaperNode.oversample = value;\n        }\n    };\n};\n//# sourceMappingURL=wave-shaper-node-constructor.js.map","export const getFirstSample = (audioBuffer, buffer, channelNumber) => {\n    // Bug #5: Safari does not support copyFromChannel() and copyToChannel().\n    if (audioBuffer.copyFromChannel === undefined) {\n        return audioBuffer.getChannelData(channelNumber)[0];\n    }\n    audioBuffer.copyFromChannel(buffer, channelNumber);\n    return buffer[0];\n};\n//# sourceMappingURL=get-first-sample.js.map","export const isDCCurve = (curve) => {\n    if (curve === null) {\n        return false;\n    }\n    const length = curve.length;\n    if (length % 2 !== 0) {\n        return curve[Math.floor(length / 2)] !== 0;\n    }\n    return curve[length / 2 - 1] + curve[length / 2] !== 0;\n};\n//# sourceMappingURL=is-dc-curve.js.map","export const overwriteAccessors = (object, property, createGetter, createSetter) => {\n    let prototype = object;\n    while (!prototype.hasOwnProperty(property)) {\n        prototype = Object.getPrototypeOf(prototype);\n    }\n    const { get, set } = Object.getOwnPropertyDescriptor(prototype, property);\n    Object.defineProperty(object, property, { get: createGetter(get), set: createSetter(set) });\n};\n//# sourceMappingURL=overwrite-accessors.js.map","export const setValueAtTimeUntilPossible = (audioParam, value, startTime) => {\n    try {\n        audioParam.setValueAtTime(value, startTime);\n    }\n    catch (err) {\n        if (err.code !== 9) {\n            throw err;\n        }\n        setValueAtTimeUntilPossible(audioParam, value, startTime + 1e-7);\n    }\n};\n//# sourceMappingURL=set-value-at-time-until-possible.js.map","export const testAudioScheduledSourceNodeStartMethodNegativeParametersSupport = (nativeContext) => {\n    const nativeAudioBufferSourceNode = nativeContext.createOscillator();\n    try {\n        nativeAudioBufferSourceNode.start(-1);\n    }\n    catch (err) {\n        return err instanceof RangeError;\n    }\n    return false;\n};\n//# sourceMappingURL=test-audio-scheduled-source-node-start-method-negative-parameters-support.js.map","export const testAudioScheduledSourceNodeStopMethodConsecutiveCallsSupport = (nativeContext) => {\n    const nativeAudioBuffer = nativeContext.createBuffer(1, 1, 44100);\n    const nativeAudioBufferSourceNode = nativeContext.createBufferSource();\n    nativeAudioBufferSourceNode.buffer = nativeAudioBuffer;\n    nativeAudioBufferSourceNode.start();\n    nativeAudioBufferSourceNode.stop();\n    try {\n        nativeAudioBufferSourceNode.stop();\n        return true;\n    }\n    catch {\n        return false;\n    }\n};\n//# sourceMappingURL=test-audio-scheduled-source-node-stop-method-consecutive-calls-support.js.map","export const testAudioScheduledSourceNodeStopMethodNegativeParametersSupport = (nativeContext) => {\n    const nativeAudioBufferSourceNode = nativeContext.createOscillator();\n    try {\n        nativeAudioBufferSourceNode.stop(-1);\n    }\n    catch (err) {\n        return err instanceof RangeError;\n    }\n    return false;\n};\n//# sourceMappingURL=test-audio-scheduled-source-node-stop-method-negative-parameters-support.js.map","/*\n * Bug #122: Edge up to version v18 did not allow to construct a DOMException'. It also had a couple more bugs but since this is easy to\n * test it's used here as a placeholder.\n *\n * Bug #27: Edge up to version v18 did reject an invalid arrayBuffer passed to decodeAudioData() with a DOMException.\n *\n * Bug #50: Edge up to version v18 did not allow to create AudioNodes on a closed context.\n *\n * Bug #57: Edge up to version v18 did not throw an error when assigning the type of an OscillatorNode to 'custom'.\n *\n * Bug #63: Edge up to version v18 did not expose the mediaElement property of a MediaElementAudioSourceNode.\n *\n * Bug #64: Edge up to version v18 did not support the MediaStreamAudioDestinationNode.\n *\n * Bug #71: Edge up to version v18 did not allow to set the buffer of an AudioBufferSourceNode to null.\n *\n * Bug #93: Edge up to version v18 did set the sampleRate of an AudioContext to zero when it was closed.\n *\n * Bug #101: Edge up to version v18 refused to execute decodeAudioData() on a closed context.\n *\n * Bug #106: Edge up to version v18 did not expose the maxValue and minValue properties of the pan AudioParam of a StereoPannerNode.\n *\n * Bug #110: Edge up to version v18 did not expose the maxValue and minValue properties of the attack, knee, ratio, release and threshold AudioParams of a DynamicsCompressorNode.\n *\n * Bug #123: Edge up to version v18 did not support HRTF as the panningModel for a PannerNode.\n *\n * Bug #145: Edge up to version v18 did throw an IndexSizeError when an OfflineAudioContext was created with a sampleRate of zero.\n *\n * Bug #161: Edge up to version v18 did not expose the maxValue and minValue properties of the delayTime AudioParam of a DelayNode.\n */\nexport const testDomExceptionConstructorSupport = () => {\n    try {\n        new DOMException(); // tslint:disable-line:no-unused-expression\n    }\n    catch {\n        return false;\n    }\n    return true;\n};\n//# sourceMappingURL=test-dom-exception-constructor-support.js.map","// Safari at version 11 did not support transferables.\nexport const testTransferablesSupport = () => new Promise((resolve) => {\n    const arrayBuffer = new ArrayBuffer(0);\n    const { port1, port2 } = new MessageChannel();\n    port1.onmessage = ({ data }) => resolve(data !== null);\n    port2.postMessage(arrayBuffer, [arrayBuffer]);\n});\n//# sourceMappingURL=test-transferables-support.js.map","import { interceptConnections } from './intercept-connections';\nexport const wrapAudioScheduledSourceNodeStopMethodConsecutiveCalls = (nativeAudioScheduledSourceNode, nativeContext) => {\n    const nativeGainNode = nativeContext.createGain();\n    nativeAudioScheduledSourceNode.connect(nativeGainNode);\n    const disconnectGainNode = ((disconnect) => {\n        return () => {\n            // @todo TypeScript cannot infer the overloaded signature with 1 argument yet.\n            disconnect.call(nativeAudioScheduledSourceNode, nativeGainNode);\n            nativeAudioScheduledSourceNode.removeEventListener('ended', disconnectGainNode);\n        };\n    })(nativeAudioScheduledSourceNode.disconnect);\n    nativeAudioScheduledSourceNode.addEventListener('ended', disconnectGainNode);\n    interceptConnections(nativeAudioScheduledSourceNode, nativeGainNode);\n    nativeAudioScheduledSourceNode.stop = ((stop) => {\n        let isStopped = false;\n        return (when = 0) => {\n            if (isStopped) {\n                try {\n                    stop.call(nativeAudioScheduledSourceNode, when);\n                }\n                catch {\n                    nativeGainNode.gain.setValueAtTime(0, when);\n                }\n            }\n            else {\n                stop.call(nativeAudioScheduledSourceNode, when);\n                isStopped = true;\n            }\n        };\n    })(nativeAudioScheduledSourceNode.stop);\n};\n//# sourceMappingURL=wrap-audio-scheduled-source-node-stop-method-consecutive-calls.js.map","export const wrapEventListener = (target, eventListener) => {\n    return (event) => {\n        const descriptor = { value: target };\n        Object.defineProperties(event, {\n            currentTarget: descriptor,\n            target: descriptor\n        });\n        if (typeof eventListener === 'function') {\n            return eventListener.call(target, event);\n        }\n        return eventListener.handleEvent.call(target, event);\n    };\n};\n//# sourceMappingURL=wrap-event-listener.js.map","import { createCancelAndHoldAutomationEvent, createCancelScheduledValuesAutomationEvent, createExponentialRampToValueAutomationEvent, createLinearRampToValueAutomationEvent, createSetTargetAutomationEvent, createSetValueAutomationEvent, createSetValueCurveAutomationEvent } from 'automation-events';\nimport { createAbortError } from './factories/abort-error';\nimport { createAddActiveInputConnectionToAudioNode } from './factories/add-active-input-connection-to-audio-node';\nimport { createAddAudioNodeConnections } from './factories/add-audio-node-connections';\nimport { createAddAudioParamConnections } from './factories/add-audio-param-connections';\nimport { createAddAudioWorkletModule } from './factories/add-audio-worklet-module';\nimport { createAddConnectionToAudioNode } from './factories/add-connection-to-audio-node';\nimport { createAddPassiveInputConnectionToAudioNode } from './factories/add-passive-input-connection-to-audio-node';\nimport { createAddSilentConnection } from './factories/add-silent-connection';\nimport { createAddUnrenderedAudioWorkletNode } from './factories/add-unrendered-audio-worklet-node';\nimport { createAnalyserNodeConstructor } from './factories/analyser-node-constructor';\nimport { createAnalyserNodeRendererFactory } from './factories/analyser-node-renderer-factory';\nimport { createAudioBufferConstructor } from './factories/audio-buffer-constructor';\nimport { createAudioBufferSourceNodeConstructor } from './factories/audio-buffer-source-node-constructor';\nimport { createAudioBufferSourceNodeRendererFactory } from './factories/audio-buffer-source-node-renderer-factory';\nimport { createAudioContextConstructor } from './factories/audio-context-constructor';\nimport { createAudioDestinationNodeConstructor } from './factories/audio-destination-node-constructor';\nimport { createAudioDestinationNodeRenderer } from './factories/audio-destination-node-renderer-factory';\nimport { createAudioListenerFactory } from './factories/audio-listener-factory';\nimport { createAudioNodeConstructor } from './factories/audio-node-constructor';\nimport { createAudioParamFactory } from './factories/audio-param-factory';\nimport { createAudioParamRenderer } from './factories/audio-param-renderer';\nimport { createAudioWorkletNodeConstructor } from './factories/audio-worklet-node-constructor';\nimport { createAudioWorkletNodeRendererFactory } from './factories/audio-worklet-node-renderer-factory';\nimport { createBaseAudioContextConstructor } from './factories/base-audio-context-constructor';\nimport { createBiquadFilterNodeConstructor } from './factories/biquad-filter-node-constructor';\nimport { createBiquadFilterNodeRendererFactory } from './factories/biquad-filter-node-renderer-factory';\nimport { createCacheTestResult } from './factories/cache-test-result';\nimport { createChannelMergerNodeConstructor } from './factories/channel-merger-node-constructor';\nimport { createChannelMergerNodeRendererFactory } from './factories/channel-merger-node-renderer-factory';\nimport { createChannelSplitterNodeConstructor } from './factories/channel-splitter-node-constructor';\nimport { createChannelSplitterNodeRendererFactory } from './factories/channel-splitter-node-renderer-factory';\nimport { createConnectAudioParam } from './factories/connect-audio-param';\nimport { createConnectMultipleOutputs } from './factories/connect-multiple-outputs';\nimport { createConnectedNativeAudioBufferSourceNodeFactory } from './factories/connected-native-audio-buffer-source-node-factory';\nimport { createConstantSourceNodeConstructor } from './factories/constant-source-node-constructor';\nimport { createConstantSourceNodeRendererFactory } from './factories/constant-source-node-renderer-factory';\nimport { createConvertNumberToUnsignedLong } from './factories/convert-number-to-unsigned-long';\nimport { createConvolverNodeConstructor } from './factories/convolver-node-constructor';\nimport { createConvolverNodeRendererFactory } from './factories/convolver-node-renderer-factory';\nimport { createCreateNativeOfflineAudioContext } from './factories/create-native-offline-audio-context';\nimport { createDataCloneError } from './factories/data-clone-error';\nimport { createDecodeAudioData } from './factories/decode-audio-data';\nimport { createDecrementCycleCounter } from './factories/decrement-cycle-counter';\nimport { createDelayNodeConstructor } from './factories/delay-node-constructor';\nimport { createDelayNodeRendererFactory } from './factories/delay-node-renderer-factory';\nimport { createDeleteActiveInputConnectionToAudioNode } from './factories/delete-active-input-connection-to-audio-node';\nimport { createDeleteUnrenderedAudioWorkletNode } from './factories/delete-unrendered-audio-worklet-node';\nimport { createDetectCycles } from './factories/detect-cycles';\nimport { createDisconnectMultipleOutputs } from './factories/disconnect-multiple-outputs';\nimport { createDynamicsCompressorNodeConstructor } from './factories/dynamics-compressor-node-constructor';\nimport { createDynamicsCompressorNodeRendererFactory } from './factories/dynamics-compressor-node-renderer-factory';\nimport { createEncodingError } from './factories/encoding-error';\nimport { createEvaluateSource } from './factories/evaluate-source';\nimport { createEventTargetConstructor } from './factories/event-target-constructor';\nimport { createExposeCurrentFrameAndCurrentTime } from './factories/expose-current-frame-and-current-time';\nimport { createFetchSource } from './factories/fetch-source';\nimport { createGainNodeConstructor } from './factories/gain-node-constructor';\nimport { createGainNodeRendererFactory } from './factories/gain-node-renderer-factory';\nimport { createGetActiveAudioWorkletNodeInputs } from './factories/get-active-audio-worklet-node-inputs';\nimport { createGetAudioNodeRenderer } from './factories/get-audio-node-renderer';\nimport { createGetAudioNodeTailTime } from './factories/get-audio-node-tail-time';\nimport { createGetAudioParamRenderer } from './factories/get-audio-param-renderer';\nimport { createGetBackupOfflineAudioContext } from './factories/get-backup-offline-audio-context';\nimport { createGetNativeContext } from './factories/get-native-context';\nimport { createGetOrCreateBackupOfflineAudioContext } from './factories/get-or-create-backup-offline-audio-context';\nimport { createGetUnrenderedAudioWorkletNodes } from './factories/get-unrendered-audio-worklet-nodes';\nimport { createIIRFilterNodeConstructor } from './factories/iir-filter-node-constructor';\nimport { createIIRFilterNodeRendererFactory } from './factories/iir-filter-node-renderer-factory';\nimport { createIncrementCycleCounterFactory } from './factories/increment-cycle-counter-factory';\nimport { createIndexSizeError } from './factories/index-size-error';\nimport { createInvalidAccessError } from './factories/invalid-access-error';\nimport { createInvalidStateError } from './factories/invalid-state-error';\nimport { createIsAnyAudioContext } from './factories/is-any-audio-context';\nimport { createIsAnyAudioNode } from './factories/is-any-audio-node';\nimport { createIsAnyAudioParam } from './factories/is-any-audio-param';\nimport { createIsAnyOfflineAudioContext } from './factories/is-any-offline-audio-context';\nimport { createIsNativeAudioContext } from './factories/is-native-audio-context';\nimport { createIsNativeAudioNode } from './factories/is-native-audio-node';\nimport { createIsNativeAudioParam } from './factories/is-native-audio-param';\nimport { createIsNativeContext } from './factories/is-native-context';\nimport { createIsNativeOfflineAudioContext } from './factories/is-native-offline-audio-context';\nimport { createIsSecureContext } from './factories/is-secure-context';\nimport { createIsSupportedPromise } from './factories/is-supported-promise';\nimport { createMediaElementAudioSourceNodeConstructor } from './factories/media-element-audio-source-node-constructor';\nimport { createMediaStreamAudioDestinationNodeConstructor } from './factories/media-stream-audio-destination-node-constructor';\nimport { createMediaStreamAudioSourceNodeConstructor } from './factories/media-stream-audio-source-node-constructor';\nimport { createMediaStreamTrackAudioSourceNodeConstructor } from './factories/media-stream-track-audio-source-node-constructor';\nimport { createMinimalAudioContextConstructor } from './factories/minimal-audio-context-constructor';\nimport { createMinimalBaseAudioContextConstructor } from './factories/minimal-base-audio-context-constructor';\nimport { createMinimalOfflineAudioContextConstructor } from './factories/minimal-offline-audio-context-constructor';\nimport { createMonitorConnections } from './factories/monitor-connections';\nimport { createNativeAnalyserNodeFactory } from './factories/native-analyser-node-factory';\nimport { createNativeAudioBufferConstructor } from './factories/native-audio-buffer-constructor';\nimport { createNativeAudioBufferSourceNodeFactory } from './factories/native-audio-buffer-source-node-factory';\nimport { createNativeAudioContextConstructor } from './factories/native-audio-context-constructor';\nimport { createNativeAudioDestinationNodeFactory } from './factories/native-audio-destination-node';\nimport { createNativeAudioWorkletNodeConstructor } from './factories/native-audio-worklet-node-constructor';\nimport { createNativeAudioWorkletNodeFactory } from './factories/native-audio-worklet-node-factory';\nimport { createNativeAudioWorkletNodeFakerFactory } from './factories/native-audio-worklet-node-faker-factory';\nimport { createNativeBiquadFilterNode } from './factories/native-biquad-filter-node';\nimport { createNativeChannelMergerNodeFactory } from './factories/native-channel-merger-node-factory';\nimport { createNativeChannelSplitterNode } from './factories/native-channel-splitter-node';\nimport { createNativeConstantSourceNodeFactory } from './factories/native-constant-source-node-factory';\nimport { createNativeConstantSourceNodeFakerFactory } from './factories/native-constant-source-node-faker-factory';\nimport { createNativeConvolverNodeFactory } from './factories/native-convolver-node-factory';\nimport { createNativeDelayNode } from './factories/native-delay-node';\nimport { createNativeDynamicsCompressorNodeFactory } from './factories/native-dynamics-compressor-node-factory';\nimport { createNativeGainNode } from './factories/native-gain-node';\nimport { createNativeIIRFilterNodeFactory } from './factories/native-iir-filter-node-factory';\nimport { createNativeIIRFilterNodeFakerFactory } from './factories/native-iir-filter-node-faker-factory';\nimport { createNativeMediaElementAudioSourceNode } from './factories/native-media-element-audio-source-node';\nimport { createNativeMediaStreamAudioDestinationNode } from './factories/native-media-stream-audio-destination-node';\nimport { createNativeMediaStreamAudioSourceNode } from './factories/native-media-stream-audio-source-node';\nimport { createNativeMediaStreamTrackAudioSourceNodeFactory } from './factories/native-media-stream-track-audio-source-node-factory';\nimport { createNativeOfflineAudioContextConstructor } from './factories/native-offline-audio-context-constructor';\nimport { createNativeOscillatorNodeFactory } from './factories/native-oscillator-node-factory';\nimport { createNativePannerNodeFactory } from './factories/native-panner-node-factory';\nimport { createNativePannerNodeFakerFactory } from './factories/native-panner-node-faker-factory';\nimport { createNativePeriodicWaveFactory } from './factories/native-periodic-wave-factory';\nimport { createNativeScriptProcessorNode } from './factories/native-script-processor-node';\nimport { createNativeStereoPannerNodeFactory } from './factories/native-stereo-panner-node-factory';\nimport { createNativeStereoPannerNodeFakerFactory } from './factories/native-stereo-panner-node-faker-factory';\nimport { createNativeWaveShaperNodeFactory } from './factories/native-wave-shaper-node-factory';\nimport { createNativeWaveShaperNodeFakerFactory } from './factories/native-wave-shaper-node-faker-factory';\nimport { createNotSupportedError } from './factories/not-supported-error';\nimport { createOfflineAudioContextConstructor } from './factories/offline-audio-context-constructor';\nimport { createOscillatorNodeConstructor } from './factories/oscillator-node-constructor';\nimport { createOscillatorNodeRendererFactory } from './factories/oscillator-node-renderer-factory';\nimport { createPannerNodeConstructor } from './factories/panner-node-constructor';\nimport { createPannerNodeRendererFactory } from './factories/panner-node-renderer-factory';\nimport { createPeriodicWaveConstructor } from './factories/periodic-wave-constructor';\nimport { createRenderAutomation } from './factories/render-automation';\nimport { createRenderInputsOfAudioNode } from './factories/render-inputs-of-audio-node';\nimport { createRenderInputsOfAudioParam } from './factories/render-inputs-of-audio-param';\nimport { createRenderNativeOfflineAudioContext } from './factories/render-native-offline-audio-context';\nimport { createSetActiveAudioWorkletNodeInputs } from './factories/set-active-audio-worklet-node-inputs';\nimport { createSetAudioNodeTailTime } from './factories/set-audio-node-tail-time';\nimport { createStartRendering } from './factories/start-rendering';\nimport { createStereoPannerNodeConstructor } from './factories/stereo-panner-node-constructor';\nimport { createStereoPannerNodeRendererFactory } from './factories/stereo-panner-node-renderer-factory';\nimport { createTestAudioBufferConstructorSupport } from './factories/test-audio-buffer-constructor-support';\nimport { createTestAudioBufferCopyChannelMethodsSubarraySupport } from './factories/test-audio-buffer-copy-channel-methods-subarray-support';\nimport { createTestAudioContextCloseMethodSupport } from './factories/test-audio-context-close-method-support';\nimport { createTestAudioContextDecodeAudioDataMethodTypeErrorSupport } from './factories/test-audio-context-decode-audio-data-method-type-error-support';\nimport { createTestAudioContextOptionsSupport } from './factories/test-audio-context-options-support';\nimport { createTestAudioNodeConnectMethodSupport } from './factories/test-audio-node-connect-method-support';\nimport { createTestAudioWorkletProcessorNoOutputsSupport } from './factories/test-audio-worklet-processor-no-outputs-support';\nimport { createTestAudioWorkletProcessorPostMessageSupport } from './factories/test-audio-worklet-processor-post-message-support';\nimport { createTestChannelMergerNodeChannelCountSupport } from './factories/test-channel-merger-node-channel-count-support';\nimport { createTestConstantSourceNodeAccurateSchedulingSupport } from './factories/test-constant-source-node-accurate-scheduling-support';\nimport { createTestConvolverNodeBufferReassignabilitySupport } from './factories/test-convolver-node-buffer-reassignability-support';\nimport { createTestConvolverNodeChannelCountSupport } from './factories/test-convolver-node-channel-count-support';\nimport { createTestIsSecureContextSupport } from './factories/test-is-secure-context-support';\nimport { createTestMediaStreamAudioSourceNodeMediaStreamWithoutAudioTrackSupport } from './factories/test-media-stream-audio-source-node-media-stream-without-audio-track-support';\nimport { createTestOfflineAudioContextCurrentTimeSupport } from './factories/test-offline-audio-context-current-time-support';\nimport { createTestStereoPannerNodeDefaultValueSupport } from './factories/test-stereo-panner-node-default-value-support';\nimport { createUnknownError } from './factories/unknown-error';\nimport { createWaveShaperNodeConstructor } from './factories/wave-shaper-node-constructor';\nimport { createWaveShaperNodeRendererFactory } from './factories/wave-shaper-node-renderer-factory';\nimport { createWindow } from './factories/window';\nimport { createWrapAudioBufferCopyChannelMethods } from './factories/wrap-audio-buffer-copy-channel-methods';\nimport { createWrapAudioBufferCopyChannelMethodsOutOfBounds } from './factories/wrap-audio-buffer-copy-channel-methods-out-of-bounds';\nimport { createWrapAudioBufferSourceNodeStopMethodNullifiedBuffer } from './factories/wrap-audio-buffer-source-node-stop-method-nullified-buffer';\nimport { createWrapChannelMergerNode } from './factories/wrap-channel-merger-node';\nimport { AUDIO_NODE_CONNECTIONS_STORE, AUDIO_NODE_STORE, AUDIO_PARAM_CONNECTIONS_STORE, AUDIO_PARAM_STORE, CONTEXT_STORE, CYCLE_COUNTERS } from './globals';\nimport { connectNativeAudioNodeToNativeAudioNode } from './helpers/connect-native-audio-node-to-native-audio-node';\nimport { disconnectNativeAudioNodeFromNativeAudioNode } from './helpers/disconnect-native-audio-node-from-native-audio-node';\nimport { getAudioNodeConnections } from './helpers/get-audio-node-connections';\nimport { getAudioParamConnections } from './helpers/get-audio-param-connections';\nimport { getEventListenersOfAudioNode } from './helpers/get-event-listeners-of-audio-node';\nimport { getFirstSample } from './helpers/get-first-sample';\nimport { getNativeAudioNode } from './helpers/get-native-audio-node';\nimport { getNativeAudioParam } from './helpers/get-native-audio-param';\nimport { getValueForKey } from './helpers/get-value-for-key';\nimport { insertElementInSet } from './helpers/insert-element-in-set';\nimport { isActiveAudioNode } from './helpers/is-active-audio-node';\nimport { isDCCurve } from './helpers/is-dc-curve';\nimport { isPartOfACycle } from './helpers/is-part-of-a-cycle';\nimport { isPassiveAudioNode } from './helpers/is-passive-audio-node';\nimport { overwriteAccessors } from './helpers/overwrite-accessors';\nimport { pickElementFromSet } from './helpers/pick-element-from-set';\nimport { sanitizeAudioWorkletNodeOptions } from './helpers/sanitize-audio-worklet-node-options';\nimport { sanitizeChannelSplitterOptions } from './helpers/sanitize-channel-splitter-options';\nimport { sanitizePeriodicWaveOptions } from './helpers/sanitize-periodic-wave-options';\nimport { setValueAtTimeUntilPossible } from './helpers/set-value-at-time-until-possible';\nimport { testAudioBufferCopyChannelMethodsOutOfBoundsSupport } from './helpers/test-audio-buffer-copy-channel-methods-out-of-bounds-support';\nimport { testAudioBufferSourceNodeStartMethodConsecutiveCallsSupport } from './helpers/test-audio-buffer-source-node-start-method-consecutive-calls-support';\nimport { testAudioBufferSourceNodeStartMethodOffsetClampingSupport } from './helpers/test-audio-buffer-source-node-start-method-offset-clamping-support';\nimport { testAudioBufferSourceNodeStopMethodNullifiedBufferSupport } from './helpers/test-audio-buffer-source-node-stop-method-nullified-buffer-support';\nimport { testAudioScheduledSourceNodeStartMethodNegativeParametersSupport } from './helpers/test-audio-scheduled-source-node-start-method-negative-parameters-support';\nimport { testAudioScheduledSourceNodeStopMethodConsecutiveCallsSupport } from './helpers/test-audio-scheduled-source-node-stop-method-consecutive-calls-support';\nimport { testAudioScheduledSourceNodeStopMethodNegativeParametersSupport } from './helpers/test-audio-scheduled-source-node-stop-method-negative-parameters-support';\nimport { testAudioWorkletNodeOptionsClonability } from './helpers/test-audio-worklet-node-options-clonability';\nimport { testDomExceptionConstructorSupport } from './helpers/test-dom-exception-constructor-support';\nimport { testPromiseSupport } from './helpers/test-promise-support';\nimport { testTransferablesSupport } from './helpers/test-transferables-support';\nimport { wrapAudioBufferSourceNodeStartMethodOffsetClamping } from './helpers/wrap-audio-buffer-source-node-start-method-offset-clamping';\nimport { wrapAudioScheduledSourceNodeStopMethodConsecutiveCalls } from './helpers/wrap-audio-scheduled-source-node-stop-method-consecutive-calls';\nimport { wrapEventListener } from './helpers/wrap-event-listener';\n/*\n * @todo Explicitly referencing the barrel file seems to be necessary when enabling the\n * isolatedModules compiler option.\n */\nexport * from './interfaces/index';\nexport * from './types/index';\nconst addActiveInputConnectionToAudioNode = createAddActiveInputConnectionToAudioNode(insertElementInSet);\nconst addPassiveInputConnectionToAudioNode = createAddPassiveInputConnectionToAudioNode(insertElementInSet);\nconst deleteActiveInputConnectionToAudioNode = createDeleteActiveInputConnectionToAudioNode(pickElementFromSet);\nconst audioNodeTailTimeStore = new WeakMap();\nconst getAudioNodeTailTime = createGetAudioNodeTailTime(audioNodeTailTimeStore);\nconst cacheTestResult = createCacheTestResult(new Map(), new WeakMap());\nconst window = createWindow();\nconst createNativeAnalyserNode = createNativeAnalyserNodeFactory(cacheTestResult, createIndexSizeError);\nconst getAudioNodeRenderer = createGetAudioNodeRenderer(getAudioNodeConnections);\nconst renderInputsOfAudioNode = createRenderInputsOfAudioNode(getAudioNodeConnections, getAudioNodeRenderer, isPartOfACycle);\nconst createAnalyserNodeRenderer = createAnalyserNodeRendererFactory(createNativeAnalyserNode, getNativeAudioNode, renderInputsOfAudioNode);\nconst getNativeContext = createGetNativeContext(CONTEXT_STORE);\nconst nativeOfflineAudioContextConstructor = createNativeOfflineAudioContextConstructor(window);\nconst isNativeOfflineAudioContext = createIsNativeOfflineAudioContext(nativeOfflineAudioContextConstructor);\nconst audioParamAudioNodeStore = new WeakMap();\nconst eventTargetConstructor = createEventTargetConstructor(wrapEventListener);\nconst nativeAudioContextConstructor = createNativeAudioContextConstructor(window);\nconst isNativeAudioContext = createIsNativeAudioContext(nativeAudioContextConstructor);\nconst isNativeAudioNode = createIsNativeAudioNode(window);\nconst isNativeAudioParam = createIsNativeAudioParam(window);\nconst nativeAudioWorkletNodeConstructor = createNativeAudioWorkletNodeConstructor(window);\nconst 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);\nconst analyserNodeConstructor = createAnalyserNodeConstructor(audioNodeConstructor, createAnalyserNodeRenderer, createIndexSizeError, createNativeAnalyserNode, getNativeContext, isNativeOfflineAudioContext);\nexport { analyserNodeConstructor as AnalyserNode };\nconst audioBufferStore = new WeakSet();\nconst nativeAudioBufferConstructor = createNativeAudioBufferConstructor(window);\nconst convertNumberToUnsignedLong = createConvertNumberToUnsignedLong(new Uint32Array(1));\nconst wrapAudioBufferCopyChannelMethods = createWrapAudioBufferCopyChannelMethods(convertNumberToUnsignedLong, createIndexSizeError);\nconst wrapAudioBufferCopyChannelMethodsOutOfBounds = createWrapAudioBufferCopyChannelMethodsOutOfBounds(convertNumberToUnsignedLong);\nconst audioBufferConstructor = createAudioBufferConstructor(audioBufferStore, cacheTestResult, createNotSupportedError, nativeAudioBufferConstructor, nativeOfflineAudioContextConstructor, createTestAudioBufferConstructorSupport(nativeAudioBufferConstructor), wrapAudioBufferCopyChannelMethods, wrapAudioBufferCopyChannelMethodsOutOfBounds);\nexport { audioBufferConstructor as AudioBuffer };\nconst addSilentConnection = createAddSilentConnection(createNativeGainNode);\nconst renderInputsOfAudioParam = createRenderInputsOfAudioParam(getAudioNodeRenderer, getAudioParamConnections, isPartOfACycle);\nconst connectAudioParam = createConnectAudioParam(renderInputsOfAudioParam);\nconst createNativeAudioBufferSourceNode = createNativeAudioBufferSourceNodeFactory(addSilentConnection, cacheTestResult, testAudioBufferSourceNodeStartMethodConsecutiveCallsSupport, testAudioBufferSourceNodeStartMethodOffsetClampingSupport, testAudioBufferSourceNodeStopMethodNullifiedBufferSupport, testAudioScheduledSourceNodeStartMethodNegativeParametersSupport, testAudioScheduledSourceNodeStopMethodConsecutiveCallsSupport, testAudioScheduledSourceNodeStopMethodNegativeParametersSupport, wrapAudioBufferSourceNodeStartMethodOffsetClamping, createWrapAudioBufferSourceNodeStopMethodNullifiedBuffer(overwriteAccessors), wrapAudioScheduledSourceNodeStopMethodConsecutiveCalls);\nconst renderAutomation = createRenderAutomation(createGetAudioParamRenderer(getAudioParamConnections), renderInputsOfAudioParam);\nconst createAudioBufferSourceNodeRenderer = createAudioBufferSourceNodeRendererFactory(connectAudioParam, createNativeAudioBufferSourceNode, getNativeAudioNode, renderAutomation, renderInputsOfAudioNode);\nconst createAudioParam = createAudioParamFactory(createAddAudioParamConnections(AUDIO_PARAM_CONNECTIONS_STORE), audioParamAudioNodeStore, AUDIO_PARAM_STORE, createAudioParamRenderer, createCancelAndHoldAutomationEvent, createCancelScheduledValuesAutomationEvent, createExponentialRampToValueAutomationEvent, createLinearRampToValueAutomationEvent, createSetTargetAutomationEvent, createSetValueAutomationEvent, createSetValueCurveAutomationEvent, nativeAudioContextConstructor, setValueAtTimeUntilPossible);\nconst audioBufferSourceNodeConstructor = createAudioBufferSourceNodeConstructor(audioNodeConstructor, createAudioBufferSourceNodeRenderer, createAudioParam, createInvalidStateError, createNativeAudioBufferSourceNode, getNativeContext, isNativeOfflineAudioContext, wrapEventListener);\nexport { audioBufferSourceNodeConstructor as AudioBufferSourceNode };\nconst audioDestinationNodeConstructor = createAudioDestinationNodeConstructor(audioNodeConstructor, createAudioDestinationNodeRenderer, createIndexSizeError, createInvalidStateError, createNativeAudioDestinationNodeFactory(createNativeGainNode, overwriteAccessors), getNativeContext, isNativeOfflineAudioContext, renderInputsOfAudioNode);\nconst createBiquadFilterNodeRenderer = createBiquadFilterNodeRendererFactory(connectAudioParam, createNativeBiquadFilterNode, getNativeAudioNode, renderAutomation, renderInputsOfAudioNode);\nconst setAudioNodeTailTime = createSetAudioNodeTailTime(audioNodeTailTimeStore);\nconst biquadFilterNodeConstructor = createBiquadFilterNodeConstructor(audioNodeConstructor, createAudioParam, createBiquadFilterNodeRenderer, createInvalidAccessError, createNativeBiquadFilterNode, getNativeContext, isNativeOfflineAudioContext, setAudioNodeTailTime);\nconst monitorConnections = createMonitorConnections(insertElementInSet, isNativeAudioNode);\nconst wrapChannelMergerNode = createWrapChannelMergerNode(createInvalidStateError, monitorConnections);\nconst createNativeChannelMergerNode = createNativeChannelMergerNodeFactory(nativeAudioContextConstructor, wrapChannelMergerNode);\nconst createChannelMergerNodeRenderer = createChannelMergerNodeRendererFactory(createNativeChannelMergerNode, getNativeAudioNode, renderInputsOfAudioNode);\nconst channelMergerNodeConstructor = createChannelMergerNodeConstructor(audioNodeConstructor, createChannelMergerNodeRenderer, createNativeChannelMergerNode, getNativeContext, isNativeOfflineAudioContext);\nconst createChannelSplitterNodeRenderer = createChannelSplitterNodeRendererFactory(createNativeChannelSplitterNode, getNativeAudioNode, renderInputsOfAudioNode);\nconst channelSplitterNodeConstructor = createChannelSplitterNodeConstructor(audioNodeConstructor, createChannelSplitterNodeRenderer, createNativeChannelSplitterNode, getNativeContext, isNativeOfflineAudioContext, sanitizeChannelSplitterOptions);\nconst createNativeConstantSourceNodeFaker = createNativeConstantSourceNodeFakerFactory(addSilentConnection, createNativeAudioBufferSourceNode, createNativeGainNode, monitorConnections);\nconst createNativeConstantSourceNode = createNativeConstantSourceNodeFactory(addSilentConnection, cacheTestResult, createNativeConstantSourceNodeFaker, testAudioScheduledSourceNodeStartMethodNegativeParametersSupport, testAudioScheduledSourceNodeStopMethodNegativeParametersSupport);\nconst createConstantSourceNodeRenderer = createConstantSourceNodeRendererFactory(connectAudioParam, createNativeConstantSourceNode, getNativeAudioNode, renderAutomation, renderInputsOfAudioNode);\nconst constantSourceNodeConstructor = createConstantSourceNodeConstructor(audioNodeConstructor, createAudioParam, createConstantSourceNodeRenderer, createNativeConstantSourceNode, getNativeContext, isNativeOfflineAudioContext, wrapEventListener);\nconst createNativeConvolverNode = createNativeConvolverNodeFactory(createNotSupportedError, overwriteAccessors);\nconst createConvolverNodeRenderer = createConvolverNodeRendererFactory(createNativeConvolverNode, getNativeAudioNode, renderInputsOfAudioNode);\nconst convolverNodeConstructor = createConvolverNodeConstructor(audioNodeConstructor, createConvolverNodeRenderer, createNativeConvolverNode, getNativeContext, isNativeOfflineAudioContext, setAudioNodeTailTime);\nconst createDelayNodeRenderer = createDelayNodeRendererFactory(connectAudioParam, createNativeDelayNode, getNativeAudioNode, renderAutomation, renderInputsOfAudioNode);\nconst delayNodeConstructor = createDelayNodeConstructor(audioNodeConstructor, createAudioParam, createDelayNodeRenderer, createNativeDelayNode, getNativeContext, isNativeOfflineAudioContext, setAudioNodeTailTime);\nconst createNativeDynamicsCompressorNode = createNativeDynamicsCompressorNodeFactory(createNotSupportedError);\nconst createDynamicsCompressorNodeRenderer = createDynamicsCompressorNodeRendererFactory(connectAudioParam, createNativeDynamicsCompressorNode, getNativeAudioNode, renderAutomation, renderInputsOfAudioNode);\nconst dynamicsCompressorNodeConstructor = createDynamicsCompressorNodeConstructor(audioNodeConstructor, createAudioParam, createDynamicsCompressorNodeRenderer, createNativeDynamicsCompressorNode, createNotSupportedError, getNativeContext, isNativeOfflineAudioContext, setAudioNodeTailTime);\nconst createGainNodeRenderer = createGainNodeRendererFactory(connectAudioParam, createNativeGainNode, getNativeAudioNode, renderAutomation, renderInputsOfAudioNode);\nconst gainNodeConstructor = createGainNodeConstructor(audioNodeConstructor, createAudioParam, createGainNodeRenderer, createNativeGainNode, getNativeContext, isNativeOfflineAudioContext);\nconst createNativeIIRFilterNodeFaker = createNativeIIRFilterNodeFakerFactory(createInvalidAccessError, createInvalidStateError, createNativeScriptProcessorNode, createNotSupportedError);\nconst renderNativeOfflineAudioContext = createRenderNativeOfflineAudioContext(cacheTestResult, createNativeGainNode, createNativeScriptProcessorNode, createTestOfflineAudioContextCurrentTimeSupport(createNativeGainNode, nativeOfflineAudioContextConstructor));\nconst createIIRFilterNodeRenderer = createIIRFilterNodeRendererFactory(createNativeAudioBufferSourceNode, getNativeAudioNode, nativeOfflineAudioContextConstructor, renderInputsOfAudioNode, renderNativeOfflineAudioContext);\nconst createNativeIIRFilterNode = createNativeIIRFilterNodeFactory(createNativeIIRFilterNodeFaker);\nconst iIRFilterNodeConstructor = createIIRFilterNodeConstructor(audioNodeConstructor, createNativeIIRFilterNode, createIIRFilterNodeRenderer, getNativeContext, isNativeOfflineAudioContext, setAudioNodeTailTime);\nconst createAudioListener = createAudioListenerFactory(createAudioParam, createNativeChannelMergerNode, createNativeConstantSourceNode, createNativeScriptProcessorNode, createNotSupportedError, getFirstSample, isNativeOfflineAudioContext, overwriteAccessors);\nconst unrenderedAudioWorkletNodeStore = new WeakMap();\nconst minimalBaseAudioContextConstructor = createMinimalBaseAudioContextConstructor(audioDestinationNodeConstructor, createAudioListener, eventTargetConstructor, isNativeOfflineAudioContext, unrenderedAudioWorkletNodeStore, wrapEventListener);\nconst createNativeOscillatorNode = createNativeOscillatorNodeFactory(addSilentConnection, cacheTestResult, testAudioScheduledSourceNodeStartMethodNegativeParametersSupport, testAudioScheduledSourceNodeStopMethodConsecutiveCallsSupport, testAudioScheduledSourceNodeStopMethodNegativeParametersSupport, wrapAudioScheduledSourceNodeStopMethodConsecutiveCalls);\nconst createOscillatorNodeRenderer = createOscillatorNodeRendererFactory(connectAudioParam, createNativeOscillatorNode, getNativeAudioNode, renderAutomation, renderInputsOfAudioNode);\nconst oscillatorNodeConstructor = createOscillatorNodeConstructor(audioNodeConstructor, createAudioParam, createNativeOscillatorNode, createOscillatorNodeRenderer, getNativeContext, isNativeOfflineAudioContext, wrapEventListener);\nconst createConnectedNativeAudioBufferSourceNode = createConnectedNativeAudioBufferSourceNodeFactory(createNativeAudioBufferSourceNode);\nconst createNativeWaveShaperNodeFaker = createNativeWaveShaperNodeFakerFactory(createConnectedNativeAudioBufferSourceNode, createInvalidStateError, createNativeGainNode, isDCCurve, monitorConnections);\nconst createNativeWaveShaperNode = createNativeWaveShaperNodeFactory(createConnectedNativeAudioBufferSourceNode, createInvalidStateError, createNativeWaveShaperNodeFaker, isDCCurve, monitorConnections, nativeAudioContextConstructor, overwriteAccessors);\nconst createNativePannerNodeFaker = createNativePannerNodeFakerFactory(connectNativeAudioNodeToNativeAudioNode, createInvalidStateError, createNativeChannelMergerNode, createNativeGainNode, createNativeScriptProcessorNode, createNativeWaveShaperNode, createNotSupportedError, disconnectNativeAudioNodeFromNativeAudioNode, getFirstSample, monitorConnections);\nconst createNativePannerNode = createNativePannerNodeFactory(createNativePannerNodeFaker);\nconst createPannerNodeRenderer = createPannerNodeRendererFactory(connectAudioParam, createNativeChannelMergerNode, createNativeConstantSourceNode, createNativeGainNode, createNativePannerNode, getNativeAudioNode, nativeOfflineAudioContextConstructor, renderAutomation, renderInputsOfAudioNode, renderNativeOfflineAudioContext);\nconst pannerNodeConstructor = createPannerNodeConstructor(audioNodeConstructor, createAudioParam, createNativePannerNode, createPannerNodeRenderer, getNativeContext, isNativeOfflineAudioContext, setAudioNodeTailTime);\nconst createNativePeriodicWave = createNativePeriodicWaveFactory(createIndexSizeError);\nconst periodicWaveConstructor = createPeriodicWaveConstructor(createNativePeriodicWave, getNativeContext, new WeakSet(), sanitizePeriodicWaveOptions);\nconst nativeStereoPannerNodeFakerFactory = createNativeStereoPannerNodeFakerFactory(createNativeChannelMergerNode, createNativeChannelSplitterNode, createNativeGainNode, createNativeWaveShaperNode, createNotSupportedError, monitorConnections);\nconst createNativeStereoPannerNode = createNativeStereoPannerNodeFactory(nativeStereoPannerNodeFakerFactory, createNotSupportedError);\nconst createStereoPannerNodeRenderer = createStereoPannerNodeRendererFactory(connectAudioParam, createNativeStereoPannerNode, getNativeAudioNode, renderAutomation, renderInputsOfAudioNode);\nconst stereoPannerNodeConstructor = createStereoPannerNodeConstructor(audioNodeConstructor, createAudioParam, createNativeStereoPannerNode, createStereoPannerNodeRenderer, getNativeContext, isNativeOfflineAudioContext);\nconst createWaveShaperNodeRenderer = createWaveShaperNodeRendererFactory(createNativeWaveShaperNode, getNativeAudioNode, renderInputsOfAudioNode);\nconst waveShaperNodeConstructor = createWaveShaperNodeConstructor(audioNodeConstructor, createInvalidStateError, createNativeWaveShaperNode, createWaveShaperNodeRenderer, getNativeContext, isNativeOfflineAudioContext, setAudioNodeTailTime);\nconst isSecureContext = createIsSecureContext(window);\nconst exposeCurrentFrameAndCurrentTime = createExposeCurrentFrameAndCurrentTime(window);\nconst backupOfflineAudioContextStore = new WeakMap();\nconst getOrCreateBackupOfflineAudioContext = createGetOrCreateBackupOfflineAudioContext(backupOfflineAudioContextStore, nativeOfflineAudioContextConstructor);\n// The addAudioWorkletModule() function is only available in a SecureContext.\nexport const addAudioWorkletModule = isSecureContext\n    ? createAddAudioWorkletModule(cacheTestResult, createNotSupportedError, createEvaluateSource(window), exposeCurrentFrameAndCurrentTime, createFetchSource(createAbortError), getNativeContext, getOrCreateBackupOfflineAudioContext, isNativeOfflineAudioContext, nativeAudioWorkletNodeConstructor, new WeakMap(), new WeakMap(), createTestAudioWorkletProcessorPostMessageSupport(nativeAudioWorkletNodeConstructor, nativeOfflineAudioContextConstructor), \n    // @todo window is guaranteed to be defined because isSecureContext checks that as well.\n    window)\n    : undefined;\nconst isNativeContext = createIsNativeContext(isNativeAudioContext, isNativeOfflineAudioContext);\nexport const decodeAudioData = createDecodeAudioData(audioBufferStore, cacheTestResult, createDataCloneError, createEncodingError, new WeakSet(), getNativeContext, isNativeContext, testAudioBufferCopyChannelMethodsOutOfBoundsSupport, testPromiseSupport, wrapAudioBufferCopyChannelMethods, wrapAudioBufferCopyChannelMethodsOutOfBounds);\nconst baseAudioContextConstructor = createBaseAudioContextConstructor(addAudioWorkletModule, analyserNodeConstructor, audioBufferConstructor, audioBufferSourceNodeConstructor, biquadFilterNodeConstructor, channelMergerNodeConstructor, channelSplitterNodeConstructor, constantSourceNodeConstructor, convolverNodeConstructor, decodeAudioData, delayNodeConstructor, dynamicsCompressorNodeConstructor, gainNodeConstructor, iIRFilterNodeConstructor, minimalBaseAudioContextConstructor, oscillatorNodeConstructor, pannerNodeConstructor, periodicWaveConstructor, stereoPannerNodeConstructor, waveShaperNodeConstructor);\nconst mediaElementAudioSourceNodeConstructor = createMediaElementAudioSourceNodeConstructor(audioNodeConstructor, createNativeMediaElementAudioSourceNode, getNativeContext, isNativeOfflineAudioContext);\nconst mediaStreamAudioDestinationNodeConstructor = createMediaStreamAudioDestinationNodeConstructor(audioNodeConstructor, createNativeMediaStreamAudioDestinationNode, getNativeContext, isNativeOfflineAudioContext);\nconst mediaStreamAudioSourceNodeConstructor = createMediaStreamAudioSourceNodeConstructor(audioNodeConstructor, createNativeMediaStreamAudioSourceNode, getNativeContext, isNativeOfflineAudioContext);\nconst createNativeMediaStreamTrackAudioSourceNode = createNativeMediaStreamTrackAudioSourceNodeFactory(createInvalidStateError, isNativeOfflineAudioContext);\nconst mediaStreamTrackAudioSourceNodeConstructor = createMediaStreamTrackAudioSourceNodeConstructor(audioNodeConstructor, createNativeMediaStreamTrackAudioSourceNode, getNativeContext);\nconst audioContextConstructor = createAudioContextConstructor(baseAudioContextConstructor, createInvalidStateError, createNotSupportedError, createUnknownError, mediaElementAudioSourceNodeConstructor, mediaStreamAudioDestinationNodeConstructor, mediaStreamAudioSourceNodeConstructor, mediaStreamTrackAudioSourceNodeConstructor, nativeAudioContextConstructor);\nexport { audioContextConstructor as AudioContext };\nconst getUnrenderedAudioWorkletNodes = createGetUnrenderedAudioWorkletNodes(unrenderedAudioWorkletNodeStore);\nconst addUnrenderedAudioWorkletNode = createAddUnrenderedAudioWorkletNode(getUnrenderedAudioWorkletNodes);\nconst connectMultipleOutputs = createConnectMultipleOutputs(createIndexSizeError);\nconst deleteUnrenderedAudioWorkletNode = createDeleteUnrenderedAudioWorkletNode(getUnrenderedAudioWorkletNodes);\nconst disconnectMultipleOutputs = createDisconnectMultipleOutputs(createIndexSizeError);\nconst activeAudioWorkletNodeInputsStore = new WeakMap();\nconst getActiveAudioWorkletNodeInputs = createGetActiveAudioWorkletNodeInputs(activeAudioWorkletNodeInputsStore, getValueForKey);\nconst createNativeAudioWorkletNodeFaker = createNativeAudioWorkletNodeFakerFactory(connectMultipleOutputs, createIndexSizeError, createInvalidStateError, createNativeChannelMergerNode, createNativeChannelSplitterNode, createNativeConstantSourceNode, createNativeGainNode, createNativeScriptProcessorNode, createNotSupportedError, disconnectMultipleOutputs, exposeCurrentFrameAndCurrentTime, getActiveAudioWorkletNodeInputs, monitorConnections);\nconst createNativeAudioWorkletNode = createNativeAudioWorkletNodeFactory(createInvalidStateError, createNativeAudioWorkletNodeFaker, createNativeGainNode, createNotSupportedError, monitorConnections);\nconst createAudioWorkletNodeRenderer = createAudioWorkletNodeRendererFactory(connectAudioParam, connectMultipleOutputs, createNativeAudioBufferSourceNode, createNativeChannelMergerNode, createNativeChannelSplitterNode, createNativeConstantSourceNode, createNativeGainNode, deleteUnrenderedAudioWorkletNode, disconnectMultipleOutputs, exposeCurrentFrameAndCurrentTime, getNativeAudioNode, nativeAudioWorkletNodeConstructor, nativeOfflineAudioContextConstructor, renderAutomation, renderInputsOfAudioNode, renderNativeOfflineAudioContext);\nconst getBackupOfflineAudioContext = createGetBackupOfflineAudioContext(backupOfflineAudioContextStore);\nconst setActiveAudioWorkletNodeInputs = createSetActiveAudioWorkletNodeInputs(activeAudioWorkletNodeInputsStore);\n// The AudioWorkletNode constructor is only available in a SecureContext.\nconst audioWorkletNodeConstructor = isSecureContext\n    ? createAudioWorkletNodeConstructor(addUnrenderedAudioWorkletNode, audioNodeConstructor, createAudioParam, createAudioWorkletNodeRenderer, createNativeAudioWorkletNode, getAudioNodeConnections, getBackupOfflineAudioContext, getNativeContext, isNativeOfflineAudioContext, nativeAudioWorkletNodeConstructor, sanitizeAudioWorkletNodeOptions, setActiveAudioWorkletNodeInputs, testAudioWorkletNodeOptionsClonability, wrapEventListener)\n    : undefined;\nexport { audioWorkletNodeConstructor as AudioWorkletNode };\nexport { biquadFilterNodeConstructor as BiquadFilterNode };\nexport { channelMergerNodeConstructor as ChannelMergerNode };\nexport { channelSplitterNodeConstructor as ChannelSplitterNode };\nexport { convolverNodeConstructor as ConvolverNode };\nexport { constantSourceNodeConstructor as ConstantSourceNode };\nexport { delayNodeConstructor as DelayNode };\nexport { dynamicsCompressorNodeConstructor as DynamicsCompressorNode };\nexport { gainNodeConstructor as GainNode };\nexport { iIRFilterNodeConstructor as IIRFilterNode };\nexport { mediaElementAudioSourceNodeConstructor as MediaElementAudioSourceNode };\nexport { mediaStreamAudioDestinationNodeConstructor as MediaStreamAudioDestinationNode };\nexport { mediaStreamAudioSourceNodeConstructor as MediaStreamAudioSourceNode };\nexport { mediaStreamTrackAudioSourceNodeConstructor as MediaStreamTrackAudioSourceNode };\nconst minimalAudioContextConstructor = createMinimalAudioContextConstructor(createInvalidStateError, createNotSupportedError, createUnknownError, minimalBaseAudioContextConstructor, nativeAudioContextConstructor);\nexport { minimalAudioContextConstructor as MinimalAudioContext };\nconst createNativeOfflineAudioContext = createCreateNativeOfflineAudioContext(createNotSupportedError, nativeOfflineAudioContextConstructor);\nconst startRendering = createStartRendering(audioBufferStore, cacheTestResult, getAudioNodeRenderer, getUnrenderedAudioWorkletNodes, renderNativeOfflineAudioContext, testAudioBufferCopyChannelMethodsOutOfBoundsSupport, wrapAudioBufferCopyChannelMethods, wrapAudioBufferCopyChannelMethodsOutOfBounds);\nconst minimalOfflineAudioContextConstructor = createMinimalOfflineAudioContextConstructor(cacheTestResult, createInvalidStateError, createNativeOfflineAudioContext, minimalBaseAudioContextConstructor, startRendering);\nexport { minimalOfflineAudioContextConstructor as MinimalOfflineAudioContext };\nconst offlineAudioContextConstructor = createOfflineAudioContextConstructor(baseAudioContextConstructor, cacheTestResult, createInvalidStateError, createNativeOfflineAudioContext, startRendering);\nexport { offlineAudioContextConstructor as OfflineAudioContext };\nexport { oscillatorNodeConstructor as OscillatorNode };\nexport { pannerNodeConstructor as PannerNode };\nexport { periodicWaveConstructor as PeriodicWave };\nexport { stereoPannerNodeConstructor as StereoPannerNode };\nexport { waveShaperNodeConstructor as WaveShaperNode };\nexport const isAnyAudioContext = createIsAnyAudioContext(CONTEXT_STORE, isNativeAudioContext);\nexport const isAnyAudioNode = createIsAnyAudioNode(AUDIO_NODE_STORE, isNativeAudioNode);\nexport const isAnyAudioParam = createIsAnyAudioParam(AUDIO_PARAM_STORE, isNativeAudioParam);\nexport const isAnyOfflineAudioContext = createIsAnyOfflineAudioContext(CONTEXT_STORE, isNativeOfflineAudioContext);\nexport const isSupported = () => createIsSupportedPromise(cacheTestResult, createTestAudioBufferCopyChannelMethodsSubarraySupport(nativeOfflineAudioContextConstructor), createTestAudioContextCloseMethodSupport(nativeAudioContextConstructor), createTestAudioContextDecodeAudioDataMethodTypeErrorSupport(nativeOfflineAudioContextConstructor), createTestAudioContextOptionsSupport(nativeAudioContextConstructor), createTestAudioNodeConnectMethodSupport(nativeOfflineAudioContextConstructor), createTestAudioWorkletProcessorNoOutputsSupport(nativeAudioWorkletNodeConstructor, nativeOfflineAudioContextConstructor), createTestChannelMergerNodeChannelCountSupport(nativeOfflineAudioContextConstructor), createTestConstantSourceNodeAccurateSchedulingSupport(nativeOfflineAudioContextConstructor), createTestConvolverNodeBufferReassignabilitySupport(nativeOfflineAudioContextConstructor), createTestConvolverNodeChannelCountSupport(nativeOfflineAudioContextConstructor), testDomExceptionConstructorSupport, createTestIsSecureContextSupport(window), createTestMediaStreamAudioSourceNodeMediaStreamWithoutAudioTrackSupport(nativeAudioContextConstructor), createTestStereoPannerNodeDefaultValueSupport(nativeOfflineAudioContextConstructor), testTransferablesSupport);\n//# sourceMappingURL=module.js.map","export const createAddActiveInputConnectionToAudioNode = (insertElementInSet) => {\n    return (activeInputs, source, [output, input, eventListener], ignoreDuplicates) => {\n        insertElementInSet(activeInputs[input], [source, output, eventListener], (activeInputConnection) => activeInputConnection[0] === source && activeInputConnection[1] === output, ignoreDuplicates);\n    };\n};\n//# sourceMappingURL=add-active-input-connection-to-audio-node.js.map","export const createAddPassiveInputConnectionToAudioNode = (insertElementInSet) => {\n    return (passiveInputs, input, [source, output, eventListener], ignoreDuplicates) => {\n        const passiveInputConnections = passiveInputs.get(source);\n        if (passiveInputConnections === undefined) {\n            passiveInputs.set(source, new Set([[output, input, eventListener]]));\n        }\n        else {\n            insertElementInSet(passiveInputConnections, [output, input, eventListener], (passiveInputConnection) => passiveInputConnection[0] === output && passiveInputConnection[1] === input, ignoreDuplicates);\n        }\n    };\n};\n//# sourceMappingURL=add-passive-input-connection-to-audio-node.js.map","export const createDeleteActiveInputConnectionToAudioNode = (pickElementFromSet) => {\n    return (activeInputs, source, output, input) => {\n        return pickElementFromSet(activeInputs[input], (activeInputConnection) => activeInputConnection[0] === source && activeInputConnection[1] === output);\n    };\n};\n//# sourceMappingURL=delete-active-input-connection-to-audio-node.js.map","export const createGetAudioNodeTailTime = (audioNodeTailTimeStore) => {\n    return (audioNode) => { var _a; return (_a = audioNodeTailTimeStore.get(audioNode)) !== null && _a !== void 0 ? _a : 0; };\n};\n//# sourceMappingURL=get-audio-node-tail-time.js.map","export const createCacheTestResult = (ongoingTests, testResults) => {\n    return (tester, test) => {\n        const cachedTestResult = testResults.get(tester);\n        if (cachedTestResult !== undefined) {\n            return cachedTestResult;\n        }\n        const ongoingTest = ongoingTests.get(tester);\n        if (ongoingTest !== undefined) {\n            return ongoingTest;\n        }\n        try {\n            const synchronousTestResult = test();\n            if (synchronousTestResult instanceof Promise) {\n                ongoingTests.set(tester, synchronousTestResult);\n                return synchronousTestResult\n                    .catch(() => false)\n                    .then((finalTestResult) => {\n                    ongoingTests.delete(tester);\n                    testResults.set(tester, finalTestResult);\n                    return finalTestResult;\n                });\n            }\n            testResults.set(tester, synchronousTestResult);\n            return synchronousTestResult;\n        }\n        catch {\n            testResults.set(tester, false);\n            return false;\n        }\n    };\n};\n//# sourceMappingURL=cache-test-result.js.map","export const createWindow = () => (typeof window === 'undefined' ? null : window);\n//# sourceMappingURL=window.js.map","import { assignNativeAudioNodeOption } from '../helpers/assign-native-audio-node-option';\nimport { assignNativeAudioNodeOptions } from '../helpers/assign-native-audio-node-options';\nimport { testAnalyserNodeGetFloatTimeDomainDataMethodSupport } from '../helpers/test-analyser-node-get-float-time-domain-data-method-support';\nimport { wrapAnalyserNodeGetFloatTimeDomainDataMethod } from '../helpers/wrap-analyser-node-get-float-time-domain-data-method';\nexport const createNativeAnalyserNodeFactory = (cacheTestResult, createIndexSizeError) => {\n    return (nativeContext, options) => {\n        const nativeAnalyserNode = nativeContext.createAnalyser();\n        // Bug #37: Firefox does not create an AnalyserNode with the default properties.\n        assignNativeAudioNodeOptions(nativeAnalyserNode, options);\n        // Bug #118: Safari does not throw an error if maxDecibels is not more than minDecibels.\n        if (!(options.maxDecibels > options.minDecibels)) {\n            throw createIndexSizeError();\n        }\n        assignNativeAudioNodeOption(nativeAnalyserNode, options, 'fftSize');\n        assignNativeAudioNodeOption(nativeAnalyserNode, options, 'maxDecibels');\n        assignNativeAudioNodeOption(nativeAnalyserNode, options, 'minDecibels');\n        assignNativeAudioNodeOption(nativeAnalyserNode, options, 'smoothingTimeConstant');\n        // Bug #36: Safari does not support getFloatTimeDomainData() yet.\n        if (!cacheTestResult(testAnalyserNodeGetFloatTimeDomainDataMethodSupport, () => testAnalyserNodeGetFloatTimeDomainDataMethodSupport(nativeAnalyserNode))) {\n            wrapAnalyserNodeGetFloatTimeDomainDataMethod(nativeAnalyserNode);\n        }\n        return nativeAnalyserNode;\n    };\n};\n//# sourceMappingURL=native-analyser-node-factory.js.map","export const wrapAnalyserNodeGetFloatTimeDomainDataMethod = (nativeAnalyserNode) => {\n    nativeAnalyserNode.getFloatTimeDomainData = (array) => {\n        const byteTimeDomainData = new Uint8Array(array.length);\n        nativeAnalyserNode.getByteTimeDomainData(byteTimeDomainData);\n        const length = Math.max(byteTimeDomainData.length, nativeAnalyserNode.fftSize);\n        for (let i = 0; i < length; i += 1) {\n            array[i] = (byteTimeDomainData[i] - 128) * 0.0078125;\n        }\n        return array;\n    };\n};\n//# sourceMappingURL=wrap-analyser-node-get-float-time-domain-data-method.js.map","export const createGetAudioNodeRenderer = (getAudioNodeConnections) => {\n    return (audioNode) => {\n        const audioNodeConnections = getAudioNodeConnections(audioNode);\n        if (audioNodeConnections.renderer === null) {\n            throw new Error('Missing the renderer of the given AudioNode in the audio graph.');\n        }\n        return audioNodeConnections.renderer;\n    };\n};\n//# sourceMappingURL=get-audio-node-renderer.js.map","export const createRenderInputsOfAudioNode = (getAudioNodeConnections, getAudioNodeRenderer, isPartOfACycle) => {\n    return async (audioNode, nativeOfflineAudioContext, nativeAudioNode, trace) => {\n        const audioNodeConnections = getAudioNodeConnections(audioNode);\n        const nextTrace = [...trace, audioNode];\n        await Promise.all(audioNodeConnections.activeInputs\n            .map((connections, input) => Array.from(connections)\n            .filter(([source]) => !nextTrace.includes(source))\n            .map(async ([source, output]) => {\n            const audioNodeRenderer = getAudioNodeRenderer(source);\n            const renderedNativeAudioNode = await audioNodeRenderer.render(source, nativeOfflineAudioContext, nextTrace);\n            const destination = audioNode.context.destination;\n            if (!isPartOfACycle(source) && (audioNode !== destination || !isPartOfACycle(audioNode))) {\n                renderedNativeAudioNode.connect(nativeAudioNode, output, input);\n            }\n        }))\n            .reduce((allRenderingPromises, renderingPromises) => [...allRenderingPromises, ...renderingPromises], []));\n    };\n};\n//# sourceMappingURL=render-inputs-of-audio-node.js.map","import { isOwnedByContext } from '../helpers/is-owned-by-context';\nexport const createAnalyserNodeRendererFactory = (createNativeAnalyserNode, getNativeAudioNode, renderInputsOfAudioNode) => {\n    return () => {\n        const renderedNativeAnalyserNodes = new WeakMap();\n        const createAnalyserNode = async (proxy, nativeOfflineAudioContext, trace) => {\n            let nativeAnalyserNode = getNativeAudioNode(proxy);\n            // If the initially used nativeAnalyserNode was not constructed on the same OfflineAudioContext it needs to be created again.\n            const nativeAnalyserNodeIsOwnedByContext = isOwnedByContext(nativeAnalyserNode, nativeOfflineAudioContext);\n            if (!nativeAnalyserNodeIsOwnedByContext) {\n                const options = {\n                    channelCount: nativeAnalyserNode.channelCount,\n                    channelCountMode: nativeAnalyserNode.channelCountMode,\n                    channelInterpretation: nativeAnalyserNode.channelInterpretation,\n                    fftSize: nativeAnalyserNode.fftSize,\n                    maxDecibels: nativeAnalyserNode.maxDecibels,\n                    minDecibels: nativeAnalyserNode.minDecibels,\n                    smoothingTimeConstant: nativeAnalyserNode.smoothingTimeConstant\n                };\n                nativeAnalyserNode = createNativeAnalyserNode(nativeOfflineAudioContext, options);\n            }\n            renderedNativeAnalyserNodes.set(nativeOfflineAudioContext, nativeAnalyserNode);\n            await renderInputsOfAudioNode(proxy, nativeOfflineAudioContext, nativeAnalyserNode, trace);\n            return nativeAnalyserNode;\n        };\n        return {\n            render(proxy, nativeOfflineAudioContext, trace) {\n                const renderedNativeAnalyserNode = renderedNativeAnalyserNodes.get(nativeOfflineAudioContext);\n                if (renderedNativeAnalyserNode !== undefined) {\n                    return Promise.resolve(renderedNativeAnalyserNode);\n                }\n                return createAnalyserNode(proxy, nativeOfflineAudioContext, trace);\n            }\n        };\n    };\n};\n//# sourceMappingURL=analyser-node-renderer-factory.js.map","import { createInvalidStateError } from './invalid-state-error';\nexport const createGetNativeContext = (contextStore) => {\n    return (context) => {\n        const nativeContext = contextStore.get(context);\n        if (nativeContext === undefined) {\n            throw createInvalidStateError();\n        }\n        return (nativeContext);\n    };\n};\n//# sourceMappingURL=get-native-context.js.map","export const createNativeOfflineAudioContextConstructor = (window) => {\n    if (window === null) {\n        return null;\n    }\n    if (window.hasOwnProperty('OfflineAudioContext')) {\n        return window.OfflineAudioContext;\n    }\n    return window.hasOwnProperty('webkitOfflineAudioContext') ? window.webkitOfflineAudioContext : null;\n};\n//# sourceMappingURL=native-offline-audio-context-constructor.js.map","export const createIsNativeOfflineAudioContext = (nativeOfflineAudioContextConstructor) => {\n    return (anything) => {\n        return nativeOfflineAudioContextConstructor !== null && anything instanceof nativeOfflineAudioContextConstructor;\n    };\n};\n//# sourceMappingURL=is-native-offline-audio-context.js.map","export const createEventTargetConstructor = (wrapEventListener) => {\n    return class EventTarget {\n        constructor(_nativeEventTarget) {\n            this._nativeEventTarget = _nativeEventTarget;\n            this._listeners = new WeakMap();\n        }\n        addEventListener(type, listener, options) {\n            if (listener !== null) {\n                let wrappedEventListener = this._listeners.get(listener);\n                if (wrappedEventListener === undefined) {\n                    wrappedEventListener = wrapEventListener(this, listener);\n                    if (typeof listener === 'function') {\n                        this._listeners.set(listener, wrappedEventListener);\n                    }\n                }\n                this._nativeEventTarget.addEventListener(type, wrappedEventListener, options);\n            }\n        }\n        dispatchEvent(event) {\n            return this._nativeEventTarget.dispatchEvent(event);\n        }\n        removeEventListener(type, listener, options) {\n            const wrappedEventListener = listener === null ? undefined : this._listeners.get(listener);\n            this._nativeEventTarget.removeEventListener(type, wrappedEventListener === undefined ? null : wrappedEventListener, options);\n        }\n    };\n};\n//# sourceMappingURL=event-target-constructor.js.map","export const createNativeAudioContextConstructor = (window) => {\n    if (window === null) {\n        return null;\n    }\n    if (window.hasOwnProperty('AudioContext')) {\n        return window.AudioContext;\n    }\n    return window.hasOwnProperty('webkitAudioContext') ? window.webkitAudioContext : null;\n};\n//# sourceMappingURL=native-audio-context-constructor.js.map","export const createIsNativeAudioContext = (nativeAudioContextConstructor) => {\n    return (anything) => {\n        return nativeAudioContextConstructor !== null && anything instanceof nativeAudioContextConstructor;\n    };\n};\n//# sourceMappingURL=is-native-audio-context.js.map","export const createIsNativeAudioNode = (window) => {\n    return (anything) => {\n        return window !== null && typeof window.AudioNode === 'function' && anything instanceof window.AudioNode;\n    };\n};\n//# sourceMappingURL=is-native-audio-node.js.map","export const createIsNativeAudioParam = (window) => {\n    return (anything) => {\n        return window !== null && typeof window.AudioParam === 'function' && anything instanceof window.AudioParam;\n    };\n};\n//# sourceMappingURL=is-native-audio-param.js.map","export const createNativeAudioWorkletNodeConstructor = (window) => {\n    if (window === null) {\n        return null;\n    }\n    return window.hasOwnProperty('AudioWorkletNode') ? window.AudioWorkletNode : null;\n};\n//# sourceMappingURL=native-audio-worklet-node-constructor.js.map","import { pickElementFromSet } from './pick-element-from-set';\nexport const deleteActiveInputConnectionToAudioParam = (activeInputs, source, output) => {\n    return pickElementFromSet(activeInputs, (activeInputConnection) => activeInputConnection[0] === source && activeInputConnection[1] === output);\n};\n//# sourceMappingURL=delete-active-input-connection-to-audio-param.js.map","export const createAddAudioNodeConnections = (audioNodeConnectionsStore) => {\n    return (audioNode, audioNodeRenderer, nativeAudioNode) => {\n        const activeInputs = [];\n        for (let i = 0; i < nativeAudioNode.numberOfInputs; i += 1) {\n            activeInputs.push(new Set());\n        }\n        audioNodeConnectionsStore.set(audioNode, {\n            activeInputs,\n            outputs: new Set(),\n            passiveInputs: new WeakMap(),\n            renderer: audioNodeRenderer\n        });\n    };\n};\n//# sourceMappingURL=add-audio-node-connections.js.map","import { deletePassiveInputConnectionToAudioNode } from '../helpers/delete-passive-input-connection-to-audio-node';\nimport { setInternalStateToActive } from '../helpers/set-internal-state-to-active';\nimport { setInternalStateToPassiveWhenNecessary } from '../helpers/set-internal-state-to-passive-when-necessary';\nexport const createAddConnectionToAudioNode = (addActiveInputConnectionToAudioNode, addPassiveInputConnectionToAudioNode, connectNativeAudioNodeToNativeAudioNode, deleteActiveInputConnectionToAudioNode, disconnectNativeAudioNodeFromNativeAudioNode, getAudioNodeConnections, getAudioNodeTailTime, getEventListenersOfAudioNode, getNativeAudioNode, insertElementInSet, isActiveAudioNode, isPartOfACycle, isPassiveAudioNode) => {\n    const tailTimeTimeoutIds = new WeakMap();\n    return (source, destination, output, input, isOffline) => {\n        const { activeInputs, passiveInputs } = getAudioNodeConnections(destination);\n        const { outputs } = getAudioNodeConnections(source);\n        const eventListeners = getEventListenersOfAudioNode(source);\n        const eventListener = (isActive) => {\n            const nativeDestinationAudioNode = getNativeAudioNode(destination);\n            const nativeSourceAudioNode = getNativeAudioNode(source);\n            if (isActive) {\n                const partialConnection = deletePassiveInputConnectionToAudioNode(passiveInputs, source, output, input);\n                addActiveInputConnectionToAudioNode(activeInputs, source, partialConnection, false);\n                if (!isOffline && !isPartOfACycle(source)) {\n                    connectNativeAudioNodeToNativeAudioNode(nativeSourceAudioNode, nativeDestinationAudioNode, output, input);\n                }\n                if (isPassiveAudioNode(destination)) {\n                    setInternalStateToActive(destination);\n                }\n            }\n            else {\n                const partialConnection = deleteActiveInputConnectionToAudioNode(activeInputs, source, output, input);\n                addPassiveInputConnectionToAudioNode(passiveInputs, input, partialConnection, false);\n                if (!isOffline && !isPartOfACycle(source)) {\n                    disconnectNativeAudioNodeFromNativeAudioNode(nativeSourceAudioNode, nativeDestinationAudioNode, output, input);\n                }\n                const tailTime = getAudioNodeTailTime(destination);\n                if (tailTime === 0) {\n                    if (isActiveAudioNode(destination)) {\n                        setInternalStateToPassiveWhenNecessary(destination, activeInputs);\n                    }\n                }\n                else {\n                    const tailTimeTimeoutId = tailTimeTimeoutIds.get(destination);\n                    if (tailTimeTimeoutId !== undefined) {\n                        clearTimeout(tailTimeTimeoutId);\n                    }\n                    tailTimeTimeoutIds.set(destination, setTimeout(() => {\n                        if (isActiveAudioNode(destination)) {\n                            setInternalStateToPassiveWhenNecessary(destination, activeInputs);\n                        }\n                    }, tailTime * 1000));\n                }\n            }\n        };\n        if (insertElementInSet(outputs, [destination, output, input], (outputConnection) => outputConnection[0] === destination && outputConnection[1] === output && outputConnection[2] === input, true)) {\n            eventListeners.add(eventListener);\n            if (isActiveAudioNode(source)) {\n                addActiveInputConnectionToAudioNode(activeInputs, source, [output, input, eventListener], true);\n            }\n            else {\n                addPassiveInputConnectionToAudioNode(passiveInputs, input, [source, output, eventListener], true);\n            }\n            return true;\n        }\n        return false;\n    };\n};\n//# sourceMappingURL=add-connection-to-audio-node.js.map","import { isAudioNodeOutputConnection } from '../guards/audio-node-output-connection';\nexport const createIncrementCycleCounterFactory = (cycleCounters, disconnectNativeAudioNodeFromNativeAudioNode, getAudioNodeConnections, getNativeAudioNode, getNativeAudioParam, isActiveAudioNode) => {\n    return (isOffline) => {\n        return (audioNode, count) => {\n            const cycleCounter = cycleCounters.get(audioNode);\n            if (cycleCounter === undefined) {\n                if (!isOffline && isActiveAudioNode(audioNode)) {\n                    const nativeSourceAudioNode = getNativeAudioNode(audioNode);\n                    const { outputs } = getAudioNodeConnections(audioNode);\n                    for (const output of outputs) {\n                        if (isAudioNodeOutputConnection(output)) {\n                            const nativeDestinationAudioNode = getNativeAudioNode(output[0]);\n                            disconnectNativeAudioNodeFromNativeAudioNode(nativeSourceAudioNode, nativeDestinationAudioNode, output[1], output[2]);\n                        }\n                        else {\n                            const nativeDestinationAudioParam = getNativeAudioParam(output[0]);\n                            nativeSourceAudioNode.disconnect(nativeDestinationAudioParam, output[1]);\n                        }\n                    }\n                }\n                cycleCounters.set(audioNode, count);\n            }\n            else {\n                cycleCounters.set(audioNode, cycleCounter + count);\n            }\n        };\n    };\n};\n//# sourceMappingURL=increment-cycle-counter-factory.js.map","import { isAudioNodeOutputConnection } from '../guards/audio-node-output-connection';\nexport const createDecrementCycleCounter = (connectNativeAudioNodeToNativeAudioNode, cycleCounters, getAudioNodeConnections, getNativeAudioNode, getNativeAudioParam, getNativeContext, isActiveAudioNode, isNativeOfflineAudioContext) => {\n    return (audioNode, count) => {\n        const cycleCounter = cycleCounters.get(audioNode);\n        if (cycleCounter === undefined) {\n            throw new Error('Missing the expected cycle count.');\n        }\n        const nativeContext = getNativeContext(audioNode.context);\n        const isOffline = isNativeOfflineAudioContext(nativeContext);\n        if (cycleCounter === count) {\n            cycleCounters.delete(audioNode);\n            if (!isOffline && isActiveAudioNode(audioNode)) {\n                const nativeSourceAudioNode = getNativeAudioNode(audioNode);\n                const { outputs } = getAudioNodeConnections(audioNode);\n                for (const output of outputs) {\n                    if (isAudioNodeOutputConnection(output)) {\n                        const nativeDestinationAudioNode = getNativeAudioNode(output[0]);\n                        connectNativeAudioNodeToNativeAudioNode(nativeSourceAudioNode, nativeDestinationAudioNode, output[1], output[2]);\n                    }\n                    else {\n                        const nativeDestinationAudioParam = getNativeAudioParam(output[0]);\n                        nativeSourceAudioNode.connect(nativeDestinationAudioParam, output[1]);\n                    }\n                }\n            }\n        }\n        else {\n            cycleCounters.set(audioNode, cycleCounter - count);\n        }\n    };\n};\n//# sourceMappingURL=decrement-cycle-counter.js.map","import { isAudioNode } from '../guards/audio-node';\nimport { isDelayNode } from '../guards/delay-node';\nexport const createDetectCycles = (audioParamAudioNodeStore, getAudioNodeConnections, getValueForKey) => {\n    return function detectCycles(chain, nextLink) {\n        const audioNode = isAudioNode(nextLink) ? nextLink : getValueForKey(audioParamAudioNodeStore, nextLink);\n        if (isDelayNode(audioNode)) {\n            return [];\n        }\n        if (chain[0] === audioNode) {\n            return [chain];\n        }\n        if (chain.includes(audioNode)) {\n            return [];\n        }\n        const { outputs } = getAudioNodeConnections(audioNode);\n        return Array.from(outputs)\n            .map((outputConnection) => detectCycles([...chain, audioNode], outputConnection[0]))\n            .reduce((mergedCycles, nestedCycles) => mergedCycles.concat(nestedCycles), []);\n    };\n};\n//# sourceMappingURL=detect-cycles.js.map","export const isDelayNode = (audioNode) => {\n    return 'delayTime' in audioNode;\n};\n//# sourceMappingURL=delay-node.js.map","export const createNativeAudioBufferConstructor = (window) => {\n    if (window === null) {\n        return null;\n    }\n    if (window.hasOwnProperty('AudioBuffer')) {\n        return window.AudioBuffer;\n    }\n    return null;\n};\n//# sourceMappingURL=native-audio-buffer-constructor.js.map","export const createConvertNumberToUnsignedLong = (unit32Array) => {\n    return (value) => {\n        unit32Array[0] = value;\n        return unit32Array[0];\n    };\n};\n//# sourceMappingURL=convert-number-to-unsigned-long.js.map","export const createWrapAudioBufferCopyChannelMethods = (convertNumberToUnsignedLong, createIndexSizeError) => {\n    return (audioBuffer) => {\n        audioBuffer.copyFromChannel = (destination, channelNumberAsNumber, bufferOffsetAsNumber = 0) => {\n            const bufferOffset = convertNumberToUnsignedLong(bufferOffsetAsNumber);\n            const channelNumber = convertNumberToUnsignedLong(channelNumberAsNumber);\n            if (channelNumber >= audioBuffer.numberOfChannels) {\n                throw createIndexSizeError();\n            }\n            const audioBufferLength = audioBuffer.length;\n            const channelData = audioBuffer.getChannelData(channelNumber);\n            const destinationLength = destination.length;\n            for (let i = bufferOffset < 0 ? -bufferOffset : 0; i + bufferOffset < audioBufferLength && i < destinationLength; i += 1) {\n                destination[i] = channelData[i + bufferOffset];\n            }\n        };\n        audioBuffer.copyToChannel = (source, channelNumberAsNumber, bufferOffsetAsNumber = 0) => {\n            const bufferOffset = convertNumberToUnsignedLong(bufferOffsetAsNumber);\n            const channelNumber = convertNumberToUnsignedLong(channelNumberAsNumber);\n            if (channelNumber >= audioBuffer.numberOfChannels) {\n                throw createIndexSizeError();\n            }\n            const audioBufferLength = audioBuffer.length;\n            const channelData = audioBuffer.getChannelData(channelNumber);\n            const sourceLength = source.length;\n            for (let i = bufferOffset < 0 ? -bufferOffset : 0; i + bufferOffset < audioBufferLength && i < sourceLength; i += 1) {\n                channelData[i + bufferOffset] = source[i];\n            }\n        };\n    };\n};\n//# sourceMappingURL=wrap-audio-buffer-copy-channel-methods.js.map","export const createWrapAudioBufferCopyChannelMethodsOutOfBounds = (convertNumberToUnsignedLong) => {\n    return (audioBuffer) => {\n        audioBuffer.copyFromChannel = ((copyFromChannel) => {\n            return (destination, channelNumberAsNumber, bufferOffsetAsNumber = 0) => {\n                const bufferOffset = convertNumberToUnsignedLong(bufferOffsetAsNumber);\n                const channelNumber = convertNumberToUnsignedLong(channelNumberAsNumber);\n                if (bufferOffset < audioBuffer.length) {\n                    return copyFromChannel.call(audioBuffer, destination, channelNumber, bufferOffset);\n                }\n            };\n        })(audioBuffer.copyFromChannel);\n        audioBuffer.copyToChannel = ((copyToChannel) => {\n            return (source, channelNumberAsNumber, bufferOffsetAsNumber = 0) => {\n                const bufferOffset = convertNumberToUnsignedLong(bufferOffsetAsNumber);\n                const channelNumber = convertNumberToUnsignedLong(channelNumberAsNumber);\n                if (bufferOffset < audioBuffer.length) {\n                    return copyToChannel.call(audioBuffer, source, channelNumber, bufferOffset);\n                }\n            };\n        })(audioBuffer.copyToChannel);\n    };\n};\n//# sourceMappingURL=wrap-audio-buffer-copy-channel-methods-out-of-bounds.js.map","// Bug #33: Safari exposes an AudioBuffer but it can't be used as a constructor.\nexport const createTestAudioBufferConstructorSupport = (nativeAudioBufferConstructor) => {\n    return () => {\n        if (nativeAudioBufferConstructor === null) {\n            return false;\n        }\n        try {\n            new nativeAudioBufferConstructor({ length: 1, sampleRate: 44100 }); // tslint:disable-line:no-unused-expression\n        }\n        catch {\n            return false;\n        }\n        return true;\n    };\n};\n//# sourceMappingURL=test-audio-buffer-constructor-support.js.map","export const createAddSilentConnection = (createNativeGainNode) => {\n    return (nativeContext, nativeAudioScheduledSourceNode) => {\n        const nativeGainNode = createNativeGainNode(nativeContext, {\n            channelCount: 1,\n            channelCountMode: 'explicit',\n            channelInterpretation: 'discrete',\n            gain: 0\n        });\n        nativeAudioScheduledSourceNode.connect(nativeGainNode).connect(nativeContext.destination);\n        const disconnect = () => {\n            nativeAudioScheduledSourceNode.removeEventListener('ended', disconnect);\n            nativeAudioScheduledSourceNode.disconnect(nativeGainNode);\n            nativeGainNode.disconnect();\n        };\n        nativeAudioScheduledSourceNode.addEventListener('ended', disconnect);\n    };\n};\n//# sourceMappingURL=add-silent-connection.js.map","export const createRenderInputsOfAudioParam = (getAudioNodeRenderer, getAudioParamConnections, isPartOfACycle) => {\n    return async (audioParam, nativeOfflineAudioContext, nativeAudioParam, trace) => {\n        const audioParamConnections = getAudioParamConnections(audioParam);\n        await Promise.all(Array.from(audioParamConnections.activeInputs).map(async ([source, output]) => {\n            const audioNodeRenderer = getAudioNodeRenderer(source);\n            const renderedNativeAudioNode = await audioNodeRenderer.render(source, nativeOfflineAudioContext, trace);\n            if (!isPartOfACycle(source)) {\n                renderedNativeAudioNode.connect(nativeAudioParam, output);\n            }\n        }));\n    };\n};\n//# sourceMappingURL=render-inputs-of-audio-param.js.map","export const createConnectAudioParam = (renderInputsOfAudioParam) => {\n    return (nativeOfflineAudioContext, audioParam, nativeAudioParam, trace) => {\n        return renderInputsOfAudioParam(audioParam, nativeOfflineAudioContext, nativeAudioParam, trace);\n    };\n};\n//# sourceMappingURL=connect-audio-param.js.map","import { assignNativeAudioNodeAudioParamValue } from '../helpers/assign-native-audio-node-audio-param-value';\nimport { assignNativeAudioNodeOption } from '../helpers/assign-native-audio-node-option';\nimport { assignNativeAudioNodeOptions } from '../helpers/assign-native-audio-node-options';\nimport { wrapAudioBufferSourceNodeStartMethodConsecutiveCalls } from '../helpers/wrap-audio-buffer-source-node-start-method-consecutive-calls';\nimport { wrapAudioScheduledSourceNodeStartMethodNegativeParameters } from '../helpers/wrap-audio-scheduled-source-node-start-method-negative-parameters';\nimport { wrapAudioScheduledSourceNodeStopMethodNegativeParameters } from '../helpers/wrap-audio-scheduled-source-node-stop-method-negative-parameters';\nexport const createNativeAudioBufferSourceNodeFactory = (addSilentConnection, cacheTestResult, testAudioBufferSourceNodeStartMethodConsecutiveCallsSupport, testAudioBufferSourceNodeStartMethodOffsetClampingSupport, testAudioBufferSourceNodeStopMethodNullifiedBufferSupport, testAudioScheduledSourceNodeStartMethodNegativeParametersSupport, testAudioScheduledSourceNodeStopMethodConsecutiveCallsSupport, testAudioScheduledSourceNodeStopMethodNegativeParametersSupport, wrapAudioBufferSourceNodeStartMethodOffsetClampling, wrapAudioBufferSourceNodeStopMethodNullifiedBuffer, wrapAudioScheduledSourceNodeStopMethodConsecutiveCalls) => {\n    return (nativeContext, options) => {\n        const nativeAudioBufferSourceNode = nativeContext.createBufferSource();\n        assignNativeAudioNodeOptions(nativeAudioBufferSourceNode, options);\n        assignNativeAudioNodeAudioParamValue(nativeAudioBufferSourceNode, options, 'playbackRate');\n        assignNativeAudioNodeOption(nativeAudioBufferSourceNode, options, 'buffer');\n        // Bug #149: Safari does not yet support the detune AudioParam.\n        assignNativeAudioNodeOption(nativeAudioBufferSourceNode, options, 'loop');\n        assignNativeAudioNodeOption(nativeAudioBufferSourceNode, options, 'loopEnd');\n        assignNativeAudioNodeOption(nativeAudioBufferSourceNode, options, 'loopStart');\n        // Bug #69: Safari does allow calls to start() of an already scheduled AudioBufferSourceNode.\n        if (!cacheTestResult(testAudioBufferSourceNodeStartMethodConsecutiveCallsSupport, () => testAudioBufferSourceNodeStartMethodConsecutiveCallsSupport(nativeContext))) {\n            wrapAudioBufferSourceNodeStartMethodConsecutiveCalls(nativeAudioBufferSourceNode);\n        }\n        // Bug #154 & #155: Safari does not handle offsets which are equal to or greater than the duration of the buffer.\n        if (!cacheTestResult(testAudioBufferSourceNodeStartMethodOffsetClampingSupport, () => testAudioBufferSourceNodeStartMethodOffsetClampingSupport(nativeContext))) {\n            wrapAudioBufferSourceNodeStartMethodOffsetClampling(nativeAudioBufferSourceNode);\n        }\n        // Bug #162: Safari does throw an error when stop() is called on an AudioBufferSourceNode which has no buffer assigned to it.\n        if (!cacheTestResult(testAudioBufferSourceNodeStopMethodNullifiedBufferSupport, () => testAudioBufferSourceNodeStopMethodNullifiedBufferSupport(nativeContext))) {\n            wrapAudioBufferSourceNodeStopMethodNullifiedBuffer(nativeAudioBufferSourceNode, nativeContext);\n        }\n        // Bug #44: Safari does not throw a RangeError yet.\n        if (!cacheTestResult(testAudioScheduledSourceNodeStartMethodNegativeParametersSupport, () => testAudioScheduledSourceNodeStartMethodNegativeParametersSupport(nativeContext))) {\n            wrapAudioScheduledSourceNodeStartMethodNegativeParameters(nativeAudioBufferSourceNode);\n        }\n        // Bug #19: Safari does not ignore calls to stop() of an already stopped AudioBufferSourceNode.\n        if (!cacheTestResult(testAudioScheduledSourceNodeStopMethodConsecutiveCallsSupport, () => testAudioScheduledSourceNodeStopMethodConsecutiveCallsSupport(nativeContext))) {\n            wrapAudioScheduledSourceNodeStopMethodConsecutiveCalls(nativeAudioBufferSourceNode, nativeContext);\n        }\n        // Bug #44: Only Firefox does not throw a RangeError yet.\n        if (!cacheTestResult(testAudioScheduledSourceNodeStopMethodNegativeParametersSupport, () => testAudioScheduledSourceNodeStopMethodNegativeParametersSupport(nativeContext))) {\n            wrapAudioScheduledSourceNodeStopMethodNegativeParameters(nativeAudioBufferSourceNode);\n        }\n        // Bug #175: Safari will not fire an ended event if the AudioBufferSourceNode is unconnected.\n        addSilentConnection(nativeContext, nativeAudioBufferSourceNode);\n        return nativeAudioBufferSourceNode;\n    };\n};\n//# sourceMappingURL=native-audio-buffer-source-node-factory.js.map","import { createInvalidStateError } from '../factories/invalid-state-error';\nexport const wrapAudioBufferSourceNodeStartMethodConsecutiveCalls = (nativeAudioBufferSourceNode) => {\n    nativeAudioBufferSourceNode.start = ((start) => {\n        let isScheduled = false;\n        return (when = 0, offset = 0, duration) => {\n            if (isScheduled) {\n                throw createInvalidStateError();\n            }\n            start.call(nativeAudioBufferSourceNode, when, offset, duration);\n            isScheduled = true;\n        };\n    })(nativeAudioBufferSourceNode.start);\n};\n//# sourceMappingURL=wrap-audio-buffer-source-node-start-method-consecutive-calls.js.map","export const wrapAudioBufferSourceNodeStartMethodOffsetClamping = (nativeAudioBufferSourceNode) => {\n    nativeAudioBufferSourceNode.start = ((start) => {\n        return (when = 0, offset = 0, duration) => {\n            const buffer = nativeAudioBufferSourceNode.buffer;\n            // Bug #154: Safari does not clamp the offset if it is equal to or greater than the duration of the buffer.\n            const clampedOffset = buffer === null ? offset : Math.min(buffer.duration, offset);\n            // Bug #155: Safari does not handle the offset correctly if it would cause the buffer to be not be played at all.\n            if (buffer !== null && clampedOffset > buffer.duration - 0.5 / nativeAudioBufferSourceNode.context.sampleRate) {\n                start.call(nativeAudioBufferSourceNode, when, 0, 0);\n            }\n            else {\n                start.call(nativeAudioBufferSourceNode, when, clampedOffset, duration);\n            }\n        };\n    })(nativeAudioBufferSourceNode.start);\n};\n//# sourceMappingURL=wrap-audio-buffer-source-node-start-method-offset-clamping.js.map","export const testAudioBufferSourceNodeStartMethodConsecutiveCallsSupport = (nativeContext) => {\n    const nativeAudioBufferSourceNode = nativeContext.createBufferSource();\n    nativeAudioBufferSourceNode.start();\n    try {\n        nativeAudioBufferSourceNode.start();\n    }\n    catch {\n        return true;\n    }\n    return false;\n};\n//# sourceMappingURL=test-audio-buffer-source-node-start-method-consecutive-calls-support.js.map","export const testAudioBufferSourceNodeStartMethodOffsetClampingSupport = (nativeContext) => {\n    const nativeAudioBufferSourceNode = nativeContext.createBufferSource();\n    const nativeAudioBuffer = nativeContext.createBuffer(1, 1, 44100);\n    nativeAudioBufferSourceNode.buffer = nativeAudioBuffer;\n    try {\n        nativeAudioBufferSourceNode.start(0, 1);\n    }\n    catch {\n        return false;\n    }\n    return true;\n};\n//# sourceMappingURL=test-audio-buffer-source-node-start-method-offset-clamping-support.js.map","export const testAudioBufferSourceNodeStopMethodNullifiedBufferSupport = (nativeContext) => {\n    const nativeAudioBufferSourceNode = nativeContext.createBufferSource();\n    nativeAudioBufferSourceNode.start();\n    try {\n        nativeAudioBufferSourceNode.stop();\n    }\n    catch {\n        return false;\n    }\n    return true;\n};\n//# sourceMappingURL=test-audio-buffer-source-node-stop-method-nullified-buffer-support.js.map","export const createWrapAudioBufferSourceNodeStopMethodNullifiedBuffer = (overwriteAccessors) => {\n    return (nativeAudioBufferSourceNode, nativeContext) => {\n        const nullifiedBuffer = nativeContext.createBuffer(1, 1, 44100);\n        if (nativeAudioBufferSourceNode.buffer === null) {\n            nativeAudioBufferSourceNode.buffer = nullifiedBuffer;\n        }\n        overwriteAccessors(nativeAudioBufferSourceNode, 'buffer', (get) => () => {\n            const value = get.call(nativeAudioBufferSourceNode);\n            return value === nullifiedBuffer ? null : value;\n        }, (set) => (value) => {\n            return set.call(nativeAudioBufferSourceNode, value === null ? nullifiedBuffer : value);\n        });\n    };\n};\n//# sourceMappingURL=wrap-audio-buffer-source-node-stop-method-nullified-buffer.js.map","export const createRenderAutomation = (getAudioParamRenderer, renderInputsOfAudioParam) => {\n    return (nativeOfflineAudioContext, audioParam, nativeAudioParam, trace) => {\n        const audioParamRenderer = getAudioParamRenderer(audioParam);\n        audioParamRenderer.replay(nativeAudioParam);\n        return renderInputsOfAudioParam(audioParam, nativeOfflineAudioContext, nativeAudioParam, trace);\n    };\n};\n//# sourceMappingURL=render-automation.js.map","export const createGetAudioParamRenderer = (getAudioParamConnections) => {\n    return (audioParam) => {\n        const audioParamConnections = getAudioParamConnections(audioParam);\n        if (audioParamConnections.renderer === null) {\n            throw new Error('Missing the renderer of the given AudioParam in the audio graph.');\n        }\n        return audioParamConnections.renderer;\n    };\n};\n//# sourceMappingURL=get-audio-param-renderer.js.map","import { isOwnedByContext } from '../helpers/is-owned-by-context';\nexport const createAudioBufferSourceNodeRendererFactory = (connectAudioParam, createNativeAudioBufferSourceNode, getNativeAudioNode, renderAutomation, renderInputsOfAudioNode) => {\n    return () => {\n        const renderedNativeAudioBufferSourceNodes = new WeakMap();\n        let start = null;\n        let stop = null;\n        const createAudioBufferSourceNode = async (proxy, nativeOfflineAudioContext, trace) => {\n            let nativeAudioBufferSourceNode = getNativeAudioNode(proxy);\n            /*\n             * If the initially used nativeAudioBufferSourceNode was not constructed on the same OfflineAudioContext it needs to be created\n             * again.\n             */\n            const nativeAudioBufferSourceNodeIsOwnedByContext = isOwnedByContext(nativeAudioBufferSourceNode, nativeOfflineAudioContext);\n            if (!nativeAudioBufferSourceNodeIsOwnedByContext) {\n                const options = {\n                    buffer: nativeAudioBufferSourceNode.buffer,\n                    channelCount: nativeAudioBufferSourceNode.channelCount,\n                    channelCountMode: nativeAudioBufferSourceNode.channelCountMode,\n                    channelInterpretation: nativeAudioBufferSourceNode.channelInterpretation,\n                    // Bug #149: Safari does not yet support the detune AudioParam.\n                    loop: nativeAudioBufferSourceNode.loop,\n                    loopEnd: nativeAudioBufferSourceNode.loopEnd,\n                    loopStart: nativeAudioBufferSourceNode.loopStart,\n                    playbackRate: nativeAudioBufferSourceNode.playbackRate.value\n                };\n                nativeAudioBufferSourceNode = createNativeAudioBufferSourceNode(nativeOfflineAudioContext, options);\n                if (start !== null) {\n                    nativeAudioBufferSourceNode.start(...start);\n                }\n                if (stop !== null) {\n                    nativeAudioBufferSourceNode.stop(stop);\n                }\n            }\n            renderedNativeAudioBufferSourceNodes.set(nativeOfflineAudioContext, nativeAudioBufferSourceNode);\n            if (!nativeAudioBufferSourceNodeIsOwnedByContext) {\n                // Bug #149: Safari does not yet support the detune AudioParam.\n                await renderAutomation(nativeOfflineAudioContext, proxy.playbackRate, nativeAudioBufferSourceNode.playbackRate, trace);\n            }\n            else {\n                // Bug #149: Safari does not yet support the detune AudioParam.\n                await connectAudioParam(nativeOfflineAudioContext, proxy.playbackRate, nativeAudioBufferSourceNode.playbackRate, trace);\n            }\n            await renderInputsOfAudioNode(proxy, nativeOfflineAudioContext, nativeAudioBufferSourceNode, trace);\n            return nativeAudioBufferSourceNode;\n        };\n        return {\n            set start(value) {\n                start = value;\n            },\n            set stop(value) {\n                stop = value;\n            },\n            render(proxy, nativeOfflineAudioContext, trace) {\n                const renderedNativeAudioBufferSourceNode = renderedNativeAudioBufferSourceNodes.get(nativeOfflineAudioContext);\n                if (renderedNativeAudioBufferSourceNode !== undefined) {\n                    return Promise.resolve(renderedNativeAudioBufferSourceNode);\n                }\n                return createAudioBufferSourceNode(proxy, nativeOfflineAudioContext, trace);\n            }\n        };\n    };\n};\n//# sourceMappingURL=audio-buffer-source-node-renderer-factory.js.map","import { AutomationEventList } from 'automation-events';\nexport const createAudioParamFactory = (addAudioParamConnections, audioParamAudioNodeStore, audioParamStore, createAudioParamRenderer, createCancelAndHoldAutomationEvent, createCancelScheduledValuesAutomationEvent, createExponentialRampToValueAutomationEvent, createLinearRampToValueAutomationEvent, createSetTargetAutomationEvent, createSetValueAutomationEvent, createSetValueCurveAutomationEvent, nativeAudioContextConstructor, setValueAtTimeUntilPossible) => {\n    return (audioNode, isAudioParamOfOfflineAudioContext, nativeAudioParam, maxValue = null, minValue = null) => {\n        const automationEventList = new AutomationEventList(nativeAudioParam.defaultValue);\n        const audioParamRenderer = isAudioParamOfOfflineAudioContext ? createAudioParamRenderer(automationEventList) : null;\n        const audioParam = {\n            get defaultValue() {\n                return nativeAudioParam.defaultValue;\n            },\n            get maxValue() {\n                return maxValue === null ? nativeAudioParam.maxValue : maxValue;\n            },\n            get minValue() {\n                return minValue === null ? nativeAudioParam.minValue : minValue;\n            },\n            get value() {\n                return nativeAudioParam.value;\n            },\n            set value(value) {\n                nativeAudioParam.value = value;\n                // Bug #98: Firefox & Safari do not yet treat the value setter like a call to setValueAtTime().\n                audioParam.setValueAtTime(value, audioNode.context.currentTime);\n            },\n            cancelAndHoldAtTime(cancelTime) {\n                // Bug #28: Firefox & Safari do not yet implement cancelAndHoldAtTime().\n                if (typeof nativeAudioParam.cancelAndHoldAtTime === 'function') {\n                    if (audioParamRenderer === null) {\n                        automationEventList.flush(audioNode.context.currentTime);\n                    }\n                    automationEventList.add(createCancelAndHoldAutomationEvent(cancelTime));\n                    nativeAudioParam.cancelAndHoldAtTime(cancelTime);\n                }\n                else {\n                    const previousLastEvent = Array.from(automationEventList).pop();\n                    if (audioParamRenderer === null) {\n                        automationEventList.flush(audioNode.context.currentTime);\n                    }\n                    automationEventList.add(createCancelAndHoldAutomationEvent(cancelTime));\n                    const currentLastEvent = Array.from(automationEventList).pop();\n                    nativeAudioParam.cancelScheduledValues(cancelTime);\n                    if (previousLastEvent !== currentLastEvent && currentLastEvent !== undefined) {\n                        if (currentLastEvent.type === 'exponentialRampToValue') {\n                            nativeAudioParam.exponentialRampToValueAtTime(currentLastEvent.value, currentLastEvent.endTime);\n                        }\n                        else if (currentLastEvent.type === 'linearRampToValue') {\n                            nativeAudioParam.linearRampToValueAtTime(currentLastEvent.value, currentLastEvent.endTime);\n                        }\n                        else if (currentLastEvent.type === 'setValue') {\n                            nativeAudioParam.setValueAtTime(currentLastEvent.value, currentLastEvent.startTime);\n                        }\n                        else if (currentLastEvent.type === 'setValueCurve') {\n                            nativeAudioParam.setValueCurveAtTime(currentLastEvent.values, currentLastEvent.startTime, currentLastEvent.duration);\n                        }\n                    }\n                }\n                return audioParam;\n            },\n            cancelScheduledValues(cancelTime) {\n                if (audioParamRenderer === null) {\n                    automationEventList.flush(audioNode.context.currentTime);\n                }\n                automationEventList.add(createCancelScheduledValuesAutomationEvent(cancelTime));\n                nativeAudioParam.cancelScheduledValues(cancelTime);\n                return audioParam;\n            },\n            exponentialRampToValueAtTime(value, endTime) {\n                // Bug #45: Safari does not throw an error yet.\n                if (value === 0) {\n                    throw new RangeError();\n                }\n                // Bug #187: Safari does not throw an error yet.\n                if (!Number.isFinite(endTime) || endTime < 0) {\n                    throw new RangeError();\n                }\n                if (audioParamRenderer === null) {\n                    automationEventList.flush(audioNode.context.currentTime);\n                }\n                automationEventList.add(createExponentialRampToValueAutomationEvent(value, endTime));\n                nativeAudioParam.exponentialRampToValueAtTime(value, endTime);\n                return audioParam;\n            },\n            linearRampToValueAtTime(value, endTime) {\n                if (audioParamRenderer === null) {\n                    automationEventList.flush(audioNode.context.currentTime);\n                }\n                automationEventList.add(createLinearRampToValueAutomationEvent(value, endTime));\n                nativeAudioParam.linearRampToValueAtTime(value, endTime);\n                return audioParam;\n            },\n            setTargetAtTime(target, startTime, timeConstant) {\n                if (audioParamRenderer === null) {\n                    automationEventList.flush(audioNode.context.currentTime);\n                }\n                automationEventList.add(createSetTargetAutomationEvent(target, startTime, timeConstant));\n                nativeAudioParam.setTargetAtTime(target, startTime, timeConstant);\n                return audioParam;\n            },\n            setValueAtTime(value, startTime) {\n                if (audioParamRenderer === null) {\n                    automationEventList.flush(audioNode.context.currentTime);\n                }\n                automationEventList.add(createSetValueAutomationEvent(value, startTime));\n                nativeAudioParam.setValueAtTime(value, startTime);\n                return audioParam;\n            },\n            setValueCurveAtTime(values, startTime, duration) {\n                // Bug 183: Safari only accepts a Float32Array.\n                const convertedValues = values instanceof Float32Array ? values : new Float32Array(values);\n                /*\n                 * Bug #152: Safari does not correctly interpolate the values of the curve.\n                 * @todo Unfortunately there is no way to test for this behavior in a synchronous fashion which is why testing for the\n                 * existence of the webkitAudioContext is used as a workaround here.\n                 */\n                if (nativeAudioContextConstructor !== null && nativeAudioContextConstructor.name === 'webkitAudioContext') {\n                    const endTime = startTime + duration;\n                    const sampleRate = audioNode.context.sampleRate;\n                    const firstSample = Math.ceil(startTime * sampleRate);\n                    const lastSample = Math.floor(endTime * sampleRate);\n                    const numberOfInterpolatedValues = lastSample - firstSample;\n                    const interpolatedValues = new Float32Array(numberOfInterpolatedValues);\n                    for (let i = 0; i < numberOfInterpolatedValues; i += 1) {\n                        const theoreticIndex = ((convertedValues.length - 1) / duration) * ((firstSample + i) / sampleRate - startTime);\n                        const lowerIndex = Math.floor(theoreticIndex);\n                        const upperIndex = Math.ceil(theoreticIndex);\n                        interpolatedValues[i] =\n                            lowerIndex === upperIndex\n                                ? convertedValues[lowerIndex]\n                                : (1 - (theoreticIndex - lowerIndex)) * convertedValues[lowerIndex] +\n                                    (1 - (upperIndex - theoreticIndex)) * convertedValues[upperIndex];\n                    }\n                    if (audioParamRenderer === null) {\n                        automationEventList.flush(audioNode.context.currentTime);\n                    }\n                    automationEventList.add(createSetValueCurveAutomationEvent(interpolatedValues, startTime, duration));\n                    nativeAudioParam.setValueCurveAtTime(interpolatedValues, startTime, duration);\n                    const timeOfLastSample = lastSample / sampleRate;\n                    if (timeOfLastSample < endTime) {\n                        setValueAtTimeUntilPossible(audioParam, interpolatedValues[interpolatedValues.length - 1], timeOfLastSample);\n                    }\n                    setValueAtTimeUntilPossible(audioParam, convertedValues[convertedValues.length - 1], endTime);\n                }\n                else {\n                    if (audioParamRenderer === null) {\n                        automationEventList.flush(audioNode.context.currentTime);\n                    }\n                    automationEventList.add(createSetValueCurveAutomationEvent(convertedValues, startTime, duration));\n                    nativeAudioParam.setValueCurveAtTime(convertedValues, startTime, duration);\n                }\n                return audioParam;\n            }\n        };\n        audioParamStore.set(audioParam, nativeAudioParam);\n        audioParamAudioNodeStore.set(audioParam, audioNode);\n        addAudioParamConnections(audioParam, audioParamRenderer);\n        return audioParam;\n    };\n};\n//# sourceMappingURL=audio-param-factory.js.map","export const createAudioParamRenderer = (automationEventList) => {\n    return {\n        replay(audioParam) {\n            for (const automationEvent of automationEventList) {\n                if (automationEvent.type === 'exponentialRampToValue') {\n                    const { endTime, value } = automationEvent;\n                    audioParam.exponentialRampToValueAtTime(value, endTime);\n                }\n                else if (automationEvent.type === 'linearRampToValue') {\n                    const { endTime, value } = automationEvent;\n                    audioParam.linearRampToValueAtTime(value, endTime);\n                }\n                else if (automationEvent.type === 'setTarget') {\n                    const { startTime, target, timeConstant } = automationEvent;\n                    audioParam.setTargetAtTime(target, startTime, timeConstant);\n                }\n                else if (automationEvent.type === 'setValue') {\n                    const { startTime, value } = automationEvent;\n                    audioParam.setValueAtTime(value, startTime);\n                }\n                else if (automationEvent.type === 'setValueCurve') {\n                    const { duration, startTime, values } = automationEvent;\n                    audioParam.setValueCurveAtTime(values, startTime, duration);\n                }\n                else {\n                    throw new Error(\"Can't apply an unknown automation.\");\n                }\n            }\n        }\n    };\n};\n//# sourceMappingURL=audio-param-renderer.js.map","export const createAddAudioParamConnections = (audioParamConnectionsStore) => {\n    return (audioParam, audioParamRenderer) => {\n        audioParamConnectionsStore.set(audioParam, { activeInputs: new Set(), passiveInputs: new WeakMap(), renderer: audioParamRenderer });\n    };\n};\n//# sourceMappingURL=add-audio-param-connections.js.map","export const createAudioDestinationNodeConstructor = (audioNodeConstructor, createAudioDestinationNodeRenderer, createIndexSizeError, createInvalidStateError, createNativeAudioDestinationNode, getNativeContext, isNativeOfflineAudioContext, renderInputsOfAudioNode) => {\n    return class AudioDestinationNode extends audioNodeConstructor {\n        constructor(context, channelCount) {\n            const nativeContext = getNativeContext(context);\n            const isOffline = isNativeOfflineAudioContext(nativeContext);\n            const nativeAudioDestinationNode = createNativeAudioDestinationNode(nativeContext, channelCount, isOffline);\n            const audioDestinationNodeRenderer = ((isOffline ? createAudioDestinationNodeRenderer(renderInputsOfAudioNode) : null));\n            super(context, false, nativeAudioDestinationNode, audioDestinationNodeRenderer);\n            this._isNodeOfNativeOfflineAudioContext = isOffline;\n            this._nativeAudioDestinationNode = nativeAudioDestinationNode;\n        }\n        get channelCount() {\n            return this._nativeAudioDestinationNode.channelCount;\n        }\n        set channelCount(value) {\n            // Bug #52: Chrome, Edge, Opera & Safari do not throw an exception at all.\n            // Bug #54: Firefox does throw an IndexSizeError.\n            if (this._isNodeOfNativeOfflineAudioContext) {\n                throw createInvalidStateError();\n            }\n            // Bug #47: The AudioDestinationNode in Safari does not initialize the maxChannelCount property correctly.\n            if (value > this._nativeAudioDestinationNode.maxChannelCount) {\n                throw createIndexSizeError();\n            }\n            this._nativeAudioDestinationNode.channelCount = value;\n        }\n        get channelCountMode() {\n            return this._nativeAudioDestinationNode.channelCountMode;\n        }\n        set channelCountMode(value) {\n            // Bug #53: No browser does throw an exception yet.\n            if (this._isNodeOfNativeOfflineAudioContext) {\n                throw createInvalidStateError();\n            }\n            this._nativeAudioDestinationNode.channelCountMode = value;\n        }\n        get maxChannelCount() {\n            return this._nativeAudioDestinationNode.maxChannelCount;\n        }\n    };\n};\n//# sourceMappingURL=audio-destination-node-constructor.js.map","export const createAudioDestinationNodeRenderer = (renderInputsOfAudioNode) => {\n    let nativeAudioDestinationNodePromise = null;\n    const createAudioDestinationNode = async (proxy, nativeOfflineAudioContext, trace) => {\n        const nativeAudioDestinationNode = nativeOfflineAudioContext.destination;\n        await renderInputsOfAudioNode(proxy, nativeOfflineAudioContext, nativeAudioDestinationNode, trace);\n        return nativeAudioDestinationNode;\n    };\n    return {\n        render(proxy, nativeOfflineAudioContext, trace) {\n            if (nativeAudioDestinationNodePromise === null) {\n                nativeAudioDestinationNodePromise = createAudioDestinationNode(proxy, nativeOfflineAudioContext, trace);\n            }\n            return nativeAudioDestinationNodePromise;\n        }\n    };\n};\n//# sourceMappingURL=audio-destination-node-renderer-factory.js.map","export const createNativeAudioDestinationNodeFactory = (createNativeGainNode, overwriteAccessors) => {\n    return (nativeContext, channelCount, isNodeOfNativeOfflineAudioContext) => {\n        const nativeAudioDestinationNode = nativeContext.destination;\n        // Bug #132: Safari does not have the correct channelCount.\n        if (nativeAudioDestinationNode.channelCount !== channelCount) {\n            try {\n                nativeAudioDestinationNode.channelCount = channelCount;\n            }\n            catch {\n                // Bug #169: Safari throws an error on each attempt to change the channelCount.\n            }\n        }\n        // Bug #83: Safari does not have the correct channelCountMode.\n        if (isNodeOfNativeOfflineAudioContext && nativeAudioDestinationNode.channelCountMode !== 'explicit') {\n            nativeAudioDestinationNode.channelCountMode = 'explicit';\n        }\n        // Bug #47: The AudioDestinationNode in Safari does not initialize the maxChannelCount property correctly.\n        if (nativeAudioDestinationNode.maxChannelCount === 0) {\n            Object.defineProperty(nativeAudioDestinationNode, 'maxChannelCount', {\n                value: channelCount\n            });\n        }\n        // Bug #168: No browser does yet have an AudioDestinationNode with an output.\n        const gainNode = createNativeGainNode(nativeContext, {\n            channelCount,\n            channelCountMode: nativeAudioDestinationNode.channelCountMode,\n            channelInterpretation: nativeAudioDestinationNode.channelInterpretation,\n            gain: 1\n        });\n        overwriteAccessors(gainNode, 'channelCount', (get) => () => get.call(gainNode), (set) => (value) => {\n            set.call(gainNode, value);\n            try {\n                nativeAudioDestinationNode.channelCount = value;\n            }\n            catch (err) {\n                // Bug #169: Safari throws an error on each attempt to change the channelCount.\n                if (value > nativeAudioDestinationNode.maxChannelCount) {\n                    throw err;\n                }\n            }\n        });\n        overwriteAccessors(gainNode, 'channelCountMode', (get) => () => get.call(gainNode), (set) => (value) => {\n            set.call(gainNode, value);\n            nativeAudioDestinationNode.channelCountMode = value;\n        });\n        overwriteAccessors(gainNode, 'channelInterpretation', (get) => () => get.call(gainNode), (set) => (value) => {\n            set.call(gainNode, value);\n            nativeAudioDestinationNode.channelInterpretation = value;\n        });\n        Object.defineProperty(gainNode, 'maxChannelCount', {\n            get: () => nativeAudioDestinationNode.maxChannelCount\n        });\n        // @todo This should be disconnected when the context is closed.\n        gainNode.connect(nativeAudioDestinationNode);\n        return gainNode;\n    };\n};\n//# sourceMappingURL=native-audio-destination-node.js.map","import { isOwnedByContext } from '../helpers/is-owned-by-context';\nexport const createBiquadFilterNodeRendererFactory = (connectAudioParam, createNativeBiquadFilterNode, getNativeAudioNode, renderAutomation, renderInputsOfAudioNode) => {\n    return () => {\n        const renderedNativeBiquadFilterNodes = new WeakMap();\n        const createBiquadFilterNode = async (proxy, nativeOfflineAudioContext, trace) => {\n            let nativeBiquadFilterNode = getNativeAudioNode(proxy);\n            /*\n             * If the initially used nativeBiquadFilterNode was not constructed on the same OfflineAudioContext it needs to be created\n             * again.\n             */\n            const nativeBiquadFilterNodeIsOwnedByContext = isOwnedByContext(nativeBiquadFilterNode, nativeOfflineAudioContext);\n            if (!nativeBiquadFilterNodeIsOwnedByContext) {\n                const options = {\n                    Q: nativeBiquadFilterNode.Q.value,\n                    channelCount: nativeBiquadFilterNode.channelCount,\n                    channelCountMode: nativeBiquadFilterNode.channelCountMode,\n                    channelInterpretation: nativeBiquadFilterNode.channelInterpretation,\n                    detune: nativeBiquadFilterNode.detune.value,\n                    frequency: nativeBiquadFilterNode.frequency.value,\n                    gain: nativeBiquadFilterNode.gain.value,\n                    type: nativeBiquadFilterNode.type\n                };\n                nativeBiquadFilterNode = createNativeBiquadFilterNode(nativeOfflineAudioContext, options);\n            }\n            renderedNativeBiquadFilterNodes.set(nativeOfflineAudioContext, nativeBiquadFilterNode);\n            if (!nativeBiquadFilterNodeIsOwnedByContext) {\n                await renderAutomation(nativeOfflineAudioContext, proxy.Q, nativeBiquadFilterNode.Q, trace);\n                await renderAutomation(nativeOfflineAudioContext, proxy.detune, nativeBiquadFilterNode.detune, trace);\n                await renderAutomation(nativeOfflineAudioContext, proxy.frequency, nativeBiquadFilterNode.frequency, trace);\n                await renderAutomation(nativeOfflineAudioContext, proxy.gain, nativeBiquadFilterNode.gain, trace);\n            }\n            else {\n                await connectAudioParam(nativeOfflineAudioContext, proxy.Q, nativeBiquadFilterNode.Q, trace);\n                await connectAudioParam(nativeOfflineAudioContext, proxy.detune, nativeBiquadFilterNode.detune, trace);\n                await connectAudioParam(nativeOfflineAudioContext, proxy.frequency, nativeBiquadFilterNode.frequency, trace);\n                await connectAudioParam(nativeOfflineAudioContext, proxy.gain, nativeBiquadFilterNode.gain, trace);\n            }\n            await renderInputsOfAudioNode(proxy, nativeOfflineAudioContext, nativeBiquadFilterNode, trace);\n            return nativeBiquadFilterNode;\n        };\n        return {\n            render(proxy, nativeOfflineAudioContext, trace) {\n                const renderedNativeBiquadFilterNode = renderedNativeBiquadFilterNodes.get(nativeOfflineAudioContext);\n                if (renderedNativeBiquadFilterNode !== undefined) {\n                    return Promise.resolve(renderedNativeBiquadFilterNode);\n                }\n                return createBiquadFilterNode(proxy, nativeOfflineAudioContext, trace);\n            }\n        };\n    };\n};\n//# sourceMappingURL=biquad-filter-node-renderer-factory.js.map","export const createSetAudioNodeTailTime = (audioNodeTailTimeStore) => {\n    return (audioNode, tailTime) => audioNodeTailTimeStore.set(audioNode, tailTime);\n};\n//# sourceMappingURL=set-audio-node-tail-time.js.map","export const createMonitorConnections = (insertElementInSet, isNativeAudioNode) => {\n    return (nativeAudioNode, whenConnected, whenDisconnected) => {\n        const connections = new Set();\n        nativeAudioNode.connect = ((connect) => {\n            // tslint:disable-next-line:invalid-void\n            return (destination, output = 0, input = 0) => {\n                const wasDisconnected = connections.size === 0;\n                if (isNativeAudioNode(destination)) {\n                    // @todo TypeScript cannot infer the overloaded signature with 3 arguments yet.\n                    connect.call(nativeAudioNode, destination, output, input);\n                    insertElementInSet(connections, [destination, output, input], (connection) => connection[0] === destination && connection[1] === output && connection[2] === input, true);\n                    if (wasDisconnected) {\n                        whenConnected();\n                    }\n                    return destination;\n                }\n                connect.call(nativeAudioNode, destination, output);\n                insertElementInSet(connections, [destination, output], (connection) => connection[0] === destination && connection[1] === output, true);\n                if (wasDisconnected) {\n                    whenConnected();\n                }\n                return;\n            };\n        })(nativeAudioNode.connect);\n        nativeAudioNode.disconnect = ((disconnect) => {\n            return (destinationOrOutput, output, input) => {\n                const wasConnected = connections.size > 0;\n                if (destinationOrOutput === undefined) {\n                    disconnect.apply(nativeAudioNode);\n                    connections.clear();\n                }\n                else if (typeof destinationOrOutput === 'number') {\n                    // @todo TypeScript cannot infer the overloaded signature with 1 argument yet.\n                    disconnect.call(nativeAudioNode, destinationOrOutput);\n                    for (const connection of connections) {\n                        if (connection[1] === destinationOrOutput) {\n                            connections.delete(connection);\n                        }\n                    }\n                }\n                else {\n                    if (isNativeAudioNode(destinationOrOutput)) {\n                        // @todo TypeScript cannot infer the overloaded signature with 3 arguments yet.\n                        disconnect.call(nativeAudioNode, destinationOrOutput, output, input);\n                    }\n                    else {\n                        // @todo TypeScript cannot infer the overloaded signature with 2 arguments yet.\n                        disconnect.call(nativeAudioNode, destinationOrOutput, output);\n                    }\n                    for (const connection of connections) {\n                        if (connection[0] === destinationOrOutput &&\n                            (output === undefined || connection[1] === output) &&\n                            (input === undefined || connection[2] === input)) {\n                            connections.delete(connection);\n                        }\n                    }\n                }\n                const isDisconnected = connections.size === 0;\n                if (wasConnected && isDisconnected) {\n                    whenDisconnected();\n                }\n            };\n        })(nativeAudioNode.disconnect);\n        return nativeAudioNode;\n    };\n};\n//# sourceMappingURL=monitor-connections.js.map","export const createWrapChannelMergerNode = (createInvalidStateError, monitorConnections) => {\n    return (nativeContext, channelMergerNode) => {\n        // Bug #15: Safari does not return the default properties.\n        channelMergerNode.channelCount = 1;\n        channelMergerNode.channelCountMode = 'explicit';\n        // Bug #16: Safari does not throw an error when setting a different channelCount or channelCountMode.\n        Object.defineProperty(channelMergerNode, 'channelCount', {\n            get: () => 1,\n            set: () => {\n                throw createInvalidStateError();\n            }\n        });\n        Object.defineProperty(channelMergerNode, 'channelCountMode', {\n            get: () => 'explicit',\n            set: () => {\n                throw createInvalidStateError();\n            }\n        });\n        // Bug #20: Safari requires a connection of any kind to treat the input signal correctly.\n        const audioBufferSourceNode = nativeContext.createBufferSource();\n        const whenConnected = () => {\n            const length = channelMergerNode.numberOfInputs;\n            for (let i = 0; i < length; i += 1) {\n                audioBufferSourceNode.connect(channelMergerNode, 0, i);\n            }\n        };\n        const whenDisconnected = () => audioBufferSourceNode.disconnect(channelMergerNode);\n        monitorConnections(channelMergerNode, whenConnected, whenDisconnected);\n    };\n};\n//# sourceMappingURL=wrap-channel-merger-node.js.map","import { assignNativeAudioNodeOptions } from '../helpers/assign-native-audio-node-options';\nexport const createNativeChannelMergerNodeFactory = (nativeAudioContextConstructor, wrapChannelMergerNode) => {\n    return (nativeContext, options) => {\n        const nativeChannelMergerNode = nativeContext.createChannelMerger(options.numberOfInputs);\n        /*\n         * Bug #20: Safari requires a connection of any kind to treat the input signal correctly.\n         * @todo Unfortunately there is no way to test for this behavior in a synchronous fashion which is why testing for the existence of\n         * the webkitAudioContext is used as a workaround here.\n         */\n        if (nativeAudioContextConstructor !== null && nativeAudioContextConstructor.name === 'webkitAudioContext') {\n            wrapChannelMergerNode(nativeContext, nativeChannelMergerNode);\n        }\n        assignNativeAudioNodeOptions(nativeChannelMergerNode, options);\n        return nativeChannelMergerNode;\n    };\n};\n//# sourceMappingURL=native-channel-merger-node-factory.js.map","import { isOwnedByContext } from '../helpers/is-owned-by-context';\nexport const createChannelMergerNodeRendererFactory = (createNativeChannelMergerNode, getNativeAudioNode, renderInputsOfAudioNode) => {\n    return () => {\n        const renderedNativeAudioNodes = new WeakMap();\n        const createAudioNode = async (proxy, nativeOfflineAudioContext, trace) => {\n            let nativeAudioNode = getNativeAudioNode(proxy);\n            // If the initially used nativeAudioNode was not constructed on the same OfflineAudioContext it needs to be created again.\n            const nativeAudioNodeIsOwnedByContext = isOwnedByContext(nativeAudioNode, nativeOfflineAudioContext);\n            if (!nativeAudioNodeIsOwnedByContext) {\n                const options = {\n                    channelCount: nativeAudioNode.channelCount,\n                    channelCountMode: nativeAudioNode.channelCountMode,\n                    channelInterpretation: nativeAudioNode.channelInterpretation,\n                    numberOfInputs: nativeAudioNode.numberOfInputs\n                };\n                nativeAudioNode = createNativeChannelMergerNode(nativeOfflineAudioContext, options);\n            }\n            renderedNativeAudioNodes.set(nativeOfflineAudioContext, nativeAudioNode);\n            await renderInputsOfAudioNode(proxy, nativeOfflineAudioContext, nativeAudioNode, trace);\n            return nativeAudioNode;\n        };\n        return {\n            render(proxy, nativeOfflineAudioContext, trace) {\n                const renderedNativeAudioNode = renderedNativeAudioNodes.get(nativeOfflineAudioContext);\n                if (renderedNativeAudioNode !== undefined) {\n                    return Promise.resolve(renderedNativeAudioNode);\n                }\n                return createAudioNode(proxy, nativeOfflineAudioContext, trace);\n            }\n        };\n    };\n};\n//# sourceMappingURL=channel-merger-node-renderer-factory.js.map","import { isOwnedByContext } from '../helpers/is-owned-by-context';\nexport const createChannelSplitterNodeRendererFactory = (createNativeChannelSplitterNode, getNativeAudioNode, renderInputsOfAudioNode) => {\n    return () => {\n        const renderedNativeAudioNodes = new WeakMap();\n        const createAudioNode = async (proxy, nativeOfflineAudioContext, trace) => {\n            let nativeAudioNode = getNativeAudioNode(proxy);\n            // If the initially used nativeAudioNode was not constructed on the same OfflineAudioContext it needs to be created again.\n            const nativeAudioNodeIsOwnedByContext = isOwnedByContext(nativeAudioNode, nativeOfflineAudioContext);\n            if (!nativeAudioNodeIsOwnedByContext) {\n                const options = {\n                    channelCount: nativeAudioNode.channelCount,\n                    channelCountMode: nativeAudioNode.channelCountMode,\n                    channelInterpretation: nativeAudioNode.channelInterpretation,\n                    numberOfOutputs: nativeAudioNode.numberOfOutputs\n                };\n                nativeAudioNode = createNativeChannelSplitterNode(nativeOfflineAudioContext, options);\n            }\n            renderedNativeAudioNodes.set(nativeOfflineAudioContext, nativeAudioNode);\n            await renderInputsOfAudioNode(proxy, nativeOfflineAudioContext, nativeAudioNode, trace);\n            return nativeAudioNode;\n        };\n        return {\n            render(proxy, nativeOfflineAudioContext, trace) {\n                const renderedNativeAudioNode = renderedNativeAudioNodes.get(nativeOfflineAudioContext);\n                if (renderedNativeAudioNode !== undefined) {\n                    return Promise.resolve(renderedNativeAudioNode);\n                }\n                return createAudioNode(proxy, nativeOfflineAudioContext, trace);\n            }\n        };\n    };\n};\n//# sourceMappingURL=channel-splitter-node-renderer-factory.js.map","export const sanitizeChannelSplitterOptions = (options) => {\n    return { ...options, channelCount: options.numberOfOutputs };\n};\n//# sourceMappingURL=sanitize-channel-splitter-options.js.map","import { interceptConnections } from '../helpers/intercept-connections';\nexport const createNativeConstantSourceNodeFakerFactory = (addSilentConnection, createNativeAudioBufferSourceNode, createNativeGainNode, monitorConnections) => {\n    return (nativeContext, { offset, ...audioNodeOptions }) => {\n        const audioBuffer = nativeContext.createBuffer(1, 2, 44100);\n        const audioBufferSourceNode = createNativeAudioBufferSourceNode(nativeContext, {\n            buffer: null,\n            channelCount: 2,\n            channelCountMode: 'max',\n            channelInterpretation: 'speakers',\n            loop: false,\n            loopEnd: 0,\n            loopStart: 0,\n            playbackRate: 1\n        });\n        const gainNode = createNativeGainNode(nativeContext, { ...audioNodeOptions, gain: offset });\n        // Bug #5: Safari does not support copyFromChannel() and copyToChannel().\n        const channelData = audioBuffer.getChannelData(0);\n        // Bug #95: Safari does not play or loop one sample buffers.\n        channelData[0] = 1;\n        channelData[1] = 1;\n        audioBufferSourceNode.buffer = audioBuffer;\n        audioBufferSourceNode.loop = true;\n        const nativeConstantSourceNodeFaker = {\n            get bufferSize() {\n                return undefined;\n            },\n            get channelCount() {\n                return gainNode.channelCount;\n            },\n            set channelCount(value) {\n                gainNode.channelCount = value;\n            },\n            get channelCountMode() {\n                return gainNode.channelCountMode;\n            },\n            set channelCountMode(value) {\n                gainNode.channelCountMode = value;\n            },\n            get channelInterpretation() {\n                return gainNode.channelInterpretation;\n            },\n            set channelInterpretation(value) {\n                gainNode.channelInterpretation = value;\n            },\n            get context() {\n                return gainNode.context;\n            },\n            get inputs() {\n                return [];\n            },\n            get numberOfInputs() {\n                return audioBufferSourceNode.numberOfInputs;\n            },\n            get numberOfOutputs() {\n                return gainNode.numberOfOutputs;\n            },\n            get offset() {\n                return gainNode.gain;\n            },\n            get onended() {\n                return audioBufferSourceNode.onended;\n            },\n            set onended(value) {\n                audioBufferSourceNode.onended = value;\n            },\n            addEventListener(...args) {\n                return audioBufferSourceNode.addEventListener(args[0], args[1], args[2]);\n            },\n            dispatchEvent(...args) {\n                return audioBufferSourceNode.dispatchEvent(args[0]);\n            },\n            removeEventListener(...args) {\n                return audioBufferSourceNode.removeEventListener(args[0], args[1], args[2]);\n            },\n            start(when = 0) {\n                audioBufferSourceNode.start.call(audioBufferSourceNode, when);\n            },\n            stop(when = 0) {\n                audioBufferSourceNode.stop.call(audioBufferSourceNode, when);\n            }\n        };\n        const whenConnected = () => audioBufferSourceNode.connect(gainNode);\n        const whenDisconnected = () => audioBufferSourceNode.disconnect(gainNode);\n        // Bug #175: Safari will not fire an ended event if the AudioBufferSourceNode is unconnected.\n        addSilentConnection(nativeContext, audioBufferSourceNode);\n        return monitorConnections(interceptConnections(nativeConstantSourceNodeFaker, gainNode), whenConnected, whenDisconnected);\n    };\n};\n//# sourceMappingURL=native-constant-source-node-faker-factory.js.map","import { assignNativeAudioNodeAudioParamValue } from '../helpers/assign-native-audio-node-audio-param-value';\nimport { assignNativeAudioNodeOptions } from '../helpers/assign-native-audio-node-options';\nimport { wrapAudioScheduledSourceNodeStartMethodNegativeParameters } from '../helpers/wrap-audio-scheduled-source-node-start-method-negative-parameters';\nimport { wrapAudioScheduledSourceNodeStopMethodNegativeParameters } from '../helpers/wrap-audio-scheduled-source-node-stop-method-negative-parameters';\nexport const createNativeConstantSourceNodeFactory = (addSilentConnection, cacheTestResult, createNativeConstantSourceNodeFaker, testAudioScheduledSourceNodeStartMethodNegativeParametersSupport, testAudioScheduledSourceNodeStopMethodNegativeParametersSupport) => {\n    return (nativeContext, options) => {\n        // Bug #62: Safari does not support ConstantSourceNodes.\n        if (nativeContext.createConstantSource === undefined) {\n            return createNativeConstantSourceNodeFaker(nativeContext, options);\n        }\n        const nativeConstantSourceNode = nativeContext.createConstantSource();\n        assignNativeAudioNodeOptions(nativeConstantSourceNode, options);\n        assignNativeAudioNodeAudioParamValue(nativeConstantSourceNode, options, 'offset');\n        // Bug #44: Safari does not throw a RangeError yet.\n        if (!cacheTestResult(testAudioScheduledSourceNodeStartMethodNegativeParametersSupport, () => testAudioScheduledSourceNodeStartMethodNegativeParametersSupport(nativeContext))) {\n            wrapAudioScheduledSourceNodeStartMethodNegativeParameters(nativeConstantSourceNode);\n        }\n        // Bug #44: Only Firefox does not throw a RangeError yet.\n        if (!cacheTestResult(testAudioScheduledSourceNodeStopMethodNegativeParametersSupport, () => testAudioScheduledSourceNodeStopMethodNegativeParametersSupport(nativeContext))) {\n            wrapAudioScheduledSourceNodeStopMethodNegativeParameters(nativeConstantSourceNode);\n        }\n        // Bug #175: Safari will not fire an ended event if the ConstantSourceNode is unconnected.\n        addSilentConnection(nativeContext, nativeConstantSourceNode);\n        return nativeConstantSourceNode;\n    };\n};\n//# sourceMappingURL=native-constant-source-node-factory.js.map","import { isOwnedByContext } from '../helpers/is-owned-by-context';\nexport const createConstantSourceNodeRendererFactory = (connectAudioParam, createNativeConstantSourceNode, getNativeAudioNode, renderAutomation, renderInputsOfAudioNode) => {\n    return () => {\n        const renderedNativeConstantSourceNodes = new WeakMap();\n        let start = null;\n        let stop = null;\n        const createConstantSourceNode = async (proxy, nativeOfflineAudioContext, trace) => {\n            let nativeConstantSourceNode = getNativeAudioNode(proxy);\n            /*\n             * If the initially used nativeConstantSourceNode was not constructed on the same OfflineAudioContext it needs to be created\n             * again.\n             */\n            const nativeConstantSourceNodeIsOwnedByContext = isOwnedByContext(nativeConstantSourceNode, nativeOfflineAudioContext);\n            if (!nativeConstantSourceNodeIsOwnedByContext) {\n                const options = {\n                    channelCount: nativeConstantSourceNode.channelCount,\n                    channelCountMode: nativeConstantSourceNode.channelCountMode,\n                    channelInterpretation: nativeConstantSourceNode.channelInterpretation,\n                    offset: nativeConstantSourceNode.offset.value\n                };\n                nativeConstantSourceNode = createNativeConstantSourceNode(nativeOfflineAudioContext, options);\n                if (start !== null) {\n                    nativeConstantSourceNode.start(start);\n                }\n                if (stop !== null) {\n                    nativeConstantSourceNode.stop(stop);\n                }\n            }\n            renderedNativeConstantSourceNodes.set(nativeOfflineAudioContext, nativeConstantSourceNode);\n            if (!nativeConstantSourceNodeIsOwnedByContext) {\n                await renderAutomation(nativeOfflineAudioContext, proxy.offset, nativeConstantSourceNode.offset, trace);\n            }\n            else {\n                await connectAudioParam(nativeOfflineAudioContext, proxy.offset, nativeConstantSourceNode.offset, trace);\n            }\n            await renderInputsOfAudioNode(proxy, nativeOfflineAudioContext, nativeConstantSourceNode, trace);\n            return nativeConstantSourceNode;\n        };\n        return {\n            set start(value) {\n                start = value;\n            },\n            set stop(value) {\n                stop = value;\n            },\n            render(proxy, nativeOfflineAudioContext, trace) {\n                const renderedNativeConstantSourceNode = renderedNativeConstantSourceNodes.get(nativeOfflineAudioContext);\n                if (renderedNativeConstantSourceNode !== undefined) {\n                    return Promise.resolve(renderedNativeConstantSourceNode);\n                }\n                return createConstantSourceNode(proxy, nativeOfflineAudioContext, trace);\n            }\n        };\n    };\n};\n//# sourceMappingURL=constant-source-node-renderer-factory.js.map","import { assignNativeAudioNodeOption } from '../helpers/assign-native-audio-node-option';\nimport { assignNativeAudioNodeOptions } from '../helpers/assign-native-audio-node-options';\nexport const createNativeConvolverNodeFactory = (createNotSupportedError, overwriteAccessors) => {\n    return (nativeContext, options) => {\n        const nativeConvolverNode = nativeContext.createConvolver();\n        assignNativeAudioNodeOptions(nativeConvolverNode, options);\n        // The normalize property needs to be set before setting the buffer.\n        if (options.disableNormalization === nativeConvolverNode.normalize) {\n            nativeConvolverNode.normalize = !options.disableNormalization;\n        }\n        assignNativeAudioNodeOption(nativeConvolverNode, options, 'buffer');\n        // Bug #113: Safari does allow to set the channelCount to a value larger than 2.\n        if (options.channelCount > 2) {\n            throw createNotSupportedError();\n        }\n        overwriteAccessors(nativeConvolverNode, 'channelCount', (get) => () => get.call(nativeConvolverNode), (set) => (value) => {\n            if (value > 2) {\n                throw createNotSupportedError();\n            }\n            return set.call(nativeConvolverNode, value);\n        });\n        // Bug #114: Safari allows to set the channelCountMode to 'max'.\n        if (options.channelCountMode === 'max') {\n            throw createNotSupportedError();\n        }\n        overwriteAccessors(nativeConvolverNode, 'channelCountMode', (get) => () => get.call(nativeConvolverNode), (set) => (value) => {\n            if (value === 'max') {\n                throw createNotSupportedError();\n            }\n            return set.call(nativeConvolverNode, value);\n        });\n        return nativeConvolverNode;\n    };\n};\n//# sourceMappingURL=native-convolver-node-factory.js.map","import { isNativeAudioNodeFaker } from '../guards/native-audio-node-faker';\nimport { isOwnedByContext } from '../helpers/is-owned-by-context';\nexport const createConvolverNodeRendererFactory = (createNativeConvolverNode, getNativeAudioNode, renderInputsOfAudioNode) => {\n    return () => {\n        const renderedNativeConvolverNodes = new WeakMap();\n        const createConvolverNode = async (proxy, nativeOfflineAudioContext, trace) => {\n            let nativeConvolverNode = getNativeAudioNode(proxy);\n            // If the initially used nativeConvolverNode was not constructed on the same OfflineAudioContext it needs to be created again.\n            const nativeConvolverNodeIsOwnedByContext = isOwnedByContext(nativeConvolverNode, nativeOfflineAudioContext);\n            if (!nativeConvolverNodeIsOwnedByContext) {\n                const options = {\n                    buffer: nativeConvolverNode.buffer,\n                    channelCount: nativeConvolverNode.channelCount,\n                    channelCountMode: nativeConvolverNode.channelCountMode,\n                    channelInterpretation: nativeConvolverNode.channelInterpretation,\n                    disableNormalization: !nativeConvolverNode.normalize\n                };\n                nativeConvolverNode = createNativeConvolverNode(nativeOfflineAudioContext, options);\n            }\n            renderedNativeConvolverNodes.set(nativeOfflineAudioContext, nativeConvolverNode);\n            if (isNativeAudioNodeFaker(nativeConvolverNode)) {\n                await renderInputsOfAudioNode(proxy, nativeOfflineAudioContext, nativeConvolverNode.inputs[0], trace);\n            }\n            else {\n                await renderInputsOfAudioNode(proxy, nativeOfflineAudioContext, nativeConvolverNode, trace);\n            }\n            return nativeConvolverNode;\n        };\n        return {\n            render(proxy, nativeOfflineAudioContext, trace) {\n                const renderedNativeConvolverNode = renderedNativeConvolverNodes.get(nativeOfflineAudioContext);\n                if (renderedNativeConvolverNode !== undefined) {\n                    return Promise.resolve(renderedNativeConvolverNode);\n                }\n                return createConvolverNode(proxy, nativeOfflineAudioContext, trace);\n            }\n        };\n    };\n};\n//# sourceMappingURL=convolver-node-renderer-factory.js.map","import { isOwnedByContext } from '../helpers/is-owned-by-context';\nexport const createDelayNodeRendererFactory = (connectAudioParam, createNativeDelayNode, getNativeAudioNode, renderAutomation, renderInputsOfAudioNode) => {\n    return (maxDelayTime) => {\n        const renderedNativeDelayNodes = new WeakMap();\n        const createDelayNode = async (proxy, nativeOfflineAudioContext, trace) => {\n            let nativeDelayNode = getNativeAudioNode(proxy);\n            // If the initially used nativeDelayNode was not constructed on the same OfflineAudioContext it needs to be created again.\n            const nativeDelayNodeIsOwnedByContext = isOwnedByContext(nativeDelayNode, nativeOfflineAudioContext);\n            if (!nativeDelayNodeIsOwnedByContext) {\n                const options = {\n                    channelCount: nativeDelayNode.channelCount,\n                    channelCountMode: nativeDelayNode.channelCountMode,\n                    channelInterpretation: nativeDelayNode.channelInterpretation,\n                    delayTime: nativeDelayNode.delayTime.value,\n                    maxDelayTime\n                };\n                nativeDelayNode = createNativeDelayNode(nativeOfflineAudioContext, options);\n            }\n            renderedNativeDelayNodes.set(nativeOfflineAudioContext, nativeDelayNode);\n            if (!nativeDelayNodeIsOwnedByContext) {\n                await renderAutomation(nativeOfflineAudioContext, proxy.delayTime, nativeDelayNode.delayTime, trace);\n            }\n            else {\n                await connectAudioParam(nativeOfflineAudioContext, proxy.delayTime, nativeDelayNode.delayTime, trace);\n            }\n            await renderInputsOfAudioNode(proxy, nativeOfflineAudioContext, nativeDelayNode, trace);\n            return nativeDelayNode;\n        };\n        return {\n            render(proxy, nativeOfflineAudioContext, trace) {\n                const renderedNativeDelayNode = renderedNativeDelayNodes.get(nativeOfflineAudioContext);\n                if (renderedNativeDelayNode !== undefined) {\n                    return Promise.resolve(renderedNativeDelayNode);\n                }\n                return createDelayNode(proxy, nativeOfflineAudioContext, trace);\n            }\n        };\n    };\n};\n//# sourceMappingURL=delay-node-renderer-factory.js.map","import { assignNativeAudioNodeAudioParamValue } from '../helpers/assign-native-audio-node-audio-param-value';\nimport { assignNativeAudioNodeOptions } from '../helpers/assign-native-audio-node-options';\nexport const createNativeDynamicsCompressorNodeFactory = (createNotSupportedError) => {\n    return (nativeContext, options) => {\n        const nativeDynamicsCompressorNode = nativeContext.createDynamicsCompressor();\n        assignNativeAudioNodeOptions(nativeDynamicsCompressorNode, options);\n        // Bug #108: Safari allows a channelCount of three and above.\n        if (options.channelCount > 2) {\n            throw createNotSupportedError();\n        }\n        // Bug #109: Only Chrome, Firefox and Opera disallow a channelCountMode of 'max'.\n        if (options.channelCountMode === 'max') {\n            throw createNotSupportedError();\n        }\n        assignNativeAudioNodeAudioParamValue(nativeDynamicsCompressorNode, options, 'attack');\n        assignNativeAudioNodeAudioParamValue(nativeDynamicsCompressorNode, options, 'knee');\n        assignNativeAudioNodeAudioParamValue(nativeDynamicsCompressorNode, options, 'ratio');\n        assignNativeAudioNodeAudioParamValue(nativeDynamicsCompressorNode, options, 'release');\n        assignNativeAudioNodeAudioParamValue(nativeDynamicsCompressorNode, options, 'threshold');\n        return nativeDynamicsCompressorNode;\n    };\n};\n//# sourceMappingURL=native-dynamics-compressor-node-factory.js.map","import { isOwnedByContext } from '../helpers/is-owned-by-context';\nexport const createDynamicsCompressorNodeRendererFactory = (connectAudioParam, createNativeDynamicsCompressorNode, getNativeAudioNode, renderAutomation, renderInputsOfAudioNode) => {\n    return () => {\n        const renderedNativeDynamicsCompressorNodes = new WeakMap();\n        const createDynamicsCompressorNode = async (proxy, nativeOfflineAudioContext, trace) => {\n            let nativeDynamicsCompressorNode = getNativeAudioNode(proxy);\n            /*\n             * If the initially used nativeDynamicsCompressorNode was not constructed on the same OfflineAudioContext it needs to be\n             * created again.\n             */\n            const nativeDynamicsCompressorNodeIsOwnedByContext = isOwnedByContext(nativeDynamicsCompressorNode, nativeOfflineAudioContext);\n            if (!nativeDynamicsCompressorNodeIsOwnedByContext) {\n                const options = {\n                    attack: nativeDynamicsCompressorNode.attack.value,\n                    channelCount: nativeDynamicsCompressorNode.channelCount,\n                    channelCountMode: nativeDynamicsCompressorNode.channelCountMode,\n                    channelInterpretation: nativeDynamicsCompressorNode.channelInterpretation,\n                    knee: nativeDynamicsCompressorNode.knee.value,\n                    ratio: nativeDynamicsCompressorNode.ratio.value,\n                    release: nativeDynamicsCompressorNode.release.value,\n                    threshold: nativeDynamicsCompressorNode.threshold.value\n                };\n                nativeDynamicsCompressorNode = createNativeDynamicsCompressorNode(nativeOfflineAudioContext, options);\n            }\n            renderedNativeDynamicsCompressorNodes.set(nativeOfflineAudioContext, nativeDynamicsCompressorNode);\n            if (!nativeDynamicsCompressorNodeIsOwnedByContext) {\n                await renderAutomation(nativeOfflineAudioContext, proxy.attack, nativeDynamicsCompressorNode.attack, trace);\n                await renderAutomation(nativeOfflineAudioContext, proxy.knee, nativeDynamicsCompressorNode.knee, trace);\n                await renderAutomation(nativeOfflineAudioContext, proxy.ratio, nativeDynamicsCompressorNode.ratio, trace);\n                await renderAutomation(nativeOfflineAudioContext, proxy.release, nativeDynamicsCompressorNode.release, trace);\n                await renderAutomation(nativeOfflineAudioContext, proxy.threshold, nativeDynamicsCompressorNode.threshold, trace);\n            }\n            else {\n                await connectAudioParam(nativeOfflineAudioContext, proxy.attack, nativeDynamicsCompressorNode.attack, trace);\n                await connectAudioParam(nativeOfflineAudioContext, proxy.knee, nativeDynamicsCompressorNode.knee, trace);\n                await connectAudioParam(nativeOfflineAudioContext, proxy.ratio, nativeDynamicsCompressorNode.ratio, trace);\n                await connectAudioParam(nativeOfflineAudioContext, proxy.release, nativeDynamicsCompressorNode.release, trace);\n                await connectAudioParam(nativeOfflineAudioContext, proxy.threshold, nativeDynamicsCompressorNode.threshold, trace);\n            }\n            await renderInputsOfAudioNode(proxy, nativeOfflineAudioContext, nativeDynamicsCompressorNode, trace);\n            return nativeDynamicsCompressorNode;\n        };\n        return {\n            render(proxy, nativeOfflineAudioContext, trace) {\n                const renderedNativeDynamicsCompressorNode = renderedNativeDynamicsCompressorNodes.get(nativeOfflineAudioContext);\n                if (renderedNativeDynamicsCompressorNode !== undefined) {\n                    return Promise.resolve(renderedNativeDynamicsCompressorNode);\n                }\n                return createDynamicsCompressorNode(proxy, nativeOfflineAudioContext, trace);\n            }\n        };\n    };\n};\n//# sourceMappingURL=dynamics-compressor-node-renderer-factory.js.map","import { isOwnedByContext } from '../helpers/is-owned-by-context';\nexport const createGainNodeRendererFactory = (connectAudioParam, createNativeGainNode, getNativeAudioNode, renderAutomation, renderInputsOfAudioNode) => {\n    return () => {\n        const renderedNativeGainNodes = new WeakMap();\n        const createGainNode = async (proxy, nativeOfflineAudioContext, trace) => {\n            let nativeGainNode = getNativeAudioNode(proxy);\n            // If the initially used nativeGainNode was not constructed on the same OfflineAudioContext it needs to be created again.\n            const nativeGainNodeIsOwnedByContext = isOwnedByContext(nativeGainNode, nativeOfflineAudioContext);\n            if (!nativeGainNodeIsOwnedByContext) {\n                const options = {\n                    channelCount: nativeGainNode.channelCount,\n                    channelCountMode: nativeGainNode.channelCountMode,\n                    channelInterpretation: nativeGainNode.channelInterpretation,\n                    gain: nativeGainNode.gain.value\n                };\n                nativeGainNode = createNativeGainNode(nativeOfflineAudioContext, options);\n            }\n            renderedNativeGainNodes.set(nativeOfflineAudioContext, nativeGainNode);\n            if (!nativeGainNodeIsOwnedByContext) {\n                await renderAutomation(nativeOfflineAudioContext, proxy.gain, nativeGainNode.gain, trace);\n            }\n            else {\n                await connectAudioParam(nativeOfflineAudioContext, proxy.gain, nativeGainNode.gain, trace);\n            }\n            await renderInputsOfAudioNode(proxy, nativeOfflineAudioContext, nativeGainNode, trace);\n            return nativeGainNode;\n        };\n        return {\n            render(proxy, nativeOfflineAudioContext, trace) {\n                const renderedNativeGainNode = renderedNativeGainNodes.get(nativeOfflineAudioContext);\n                if (renderedNativeGainNode !== undefined) {\n                    return Promise.resolve(renderedNativeGainNode);\n                }\n                return createGainNode(proxy, nativeOfflineAudioContext, trace);\n            }\n        };\n    };\n};\n//# sourceMappingURL=gain-node-renderer-factory.js.map","import { testPromiseSupport } from '../helpers/test-promise-support';\nexport const createRenderNativeOfflineAudioContext = (cacheTestResult, createNativeGainNode, createNativeScriptProcessorNode, testOfflineAudioContextCurrentTimeSupport) => {\n    return (nativeOfflineAudioContext) => {\n        // Bug #21: Safari does not support promises yet.\n        if (cacheTestResult(testPromiseSupport, () => testPromiseSupport(nativeOfflineAudioContext))) {\n            // Bug #158: Chrome and Edge do not advance currentTime if it is not accessed while rendering the audio.\n            return Promise.resolve(cacheTestResult(testOfflineAudioContextCurrentTimeSupport, testOfflineAudioContextCurrentTimeSupport)).then((isOfflineAudioContextCurrentTimeSupported) => {\n                if (!isOfflineAudioContextCurrentTimeSupported) {\n                    const scriptProcessorNode = createNativeScriptProcessorNode(nativeOfflineAudioContext, 512, 0, 1);\n                    nativeOfflineAudioContext.oncomplete = () => {\n                        scriptProcessorNode.onaudioprocess = null; // tslint:disable-line:deprecation\n                        scriptProcessorNode.disconnect();\n                    };\n                    scriptProcessorNode.onaudioprocess = () => nativeOfflineAudioContext.currentTime; // tslint:disable-line:deprecation\n                    scriptProcessorNode.connect(nativeOfflineAudioContext.destination);\n                }\n                return nativeOfflineAudioContext.startRendering();\n            });\n        }\n        return new Promise((resolve) => {\n            // Bug #48: Safari does not render an OfflineAudioContext without any connected node.\n            const gainNode = createNativeGainNode(nativeOfflineAudioContext, {\n                channelCount: 1,\n                channelCountMode: 'explicit',\n                channelInterpretation: 'discrete',\n                gain: 0\n            });\n            nativeOfflineAudioContext.oncomplete = (event) => {\n                gainNode.disconnect();\n                resolve(event.renderedBuffer);\n            };\n            gainNode.connect(nativeOfflineAudioContext.destination);\n            nativeOfflineAudioContext.startRendering();\n        });\n    };\n};\n//# sourceMappingURL=render-native-offline-audio-context.js.map","export const createTestOfflineAudioContextCurrentTimeSupport = (createNativeGainNode, nativeOfflineAudioContextConstructor) => {\n    return () => {\n        if (nativeOfflineAudioContextConstructor === null) {\n            return Promise.resolve(false);\n        }\n        const nativeOfflineAudioContext = new nativeOfflineAudioContextConstructor(1, 1, 44100);\n        // Bug #48: Safari does not render an OfflineAudioContext without any connected node.\n        const gainNode = createNativeGainNode(nativeOfflineAudioContext, {\n            channelCount: 1,\n            channelCountMode: 'explicit',\n            channelInterpretation: 'discrete',\n            gain: 0\n        });\n        // Bug #21: Safari does not support promises yet.\n        return new Promise((resolve) => {\n            nativeOfflineAudioContext.oncomplete = () => {\n                gainNode.disconnect();\n                resolve(nativeOfflineAudioContext.currentTime !== 0);\n            };\n            nativeOfflineAudioContext.startRendering();\n        });\n    };\n};\n//# sourceMappingURL=test-offline-audio-context-current-time-support.js.map","import { filterBuffer } from '../helpers/filter-buffer';\nimport { isOwnedByContext } from '../helpers/is-owned-by-context';\nconst filterFullBuffer = (renderedBuffer, nativeOfflineAudioContext, feedback, feedforward) => {\n    const convertedFeedback = feedback instanceof Float64Array ? feedback : new Float64Array(feedback);\n    const convertedFeedforward = feedforward instanceof Float64Array ? feedforward : new Float64Array(feedforward);\n    const feedbackLength = convertedFeedback.length;\n    const feedforwardLength = convertedFeedforward.length;\n    const minLength = Math.min(feedbackLength, feedforwardLength);\n    if (convertedFeedback[0] !== 1) {\n        for (let i = 0; i < feedbackLength; i += 1) {\n            convertedFeedforward[i] /= convertedFeedback[0];\n        }\n        for (let i = 1; i < feedforwardLength; i += 1) {\n            convertedFeedback[i] /= convertedFeedback[0];\n        }\n    }\n    const bufferLength = 32;\n    const xBuffer = new Float32Array(bufferLength);\n    const yBuffer = new Float32Array(bufferLength);\n    const filteredBuffer = nativeOfflineAudioContext.createBuffer(renderedBuffer.numberOfChannels, renderedBuffer.length, renderedBuffer.sampleRate);\n    const numberOfChannels = renderedBuffer.numberOfChannels;\n    for (let i = 0; i < numberOfChannels; i += 1) {\n        const input = renderedBuffer.getChannelData(i);\n        const output = filteredBuffer.getChannelData(i);\n        xBuffer.fill(0);\n        yBuffer.fill(0);\n        filterBuffer(convertedFeedback, feedbackLength, convertedFeedforward, feedforwardLength, minLength, xBuffer, yBuffer, 0, bufferLength, input, output);\n    }\n    return filteredBuffer;\n};\nexport const createIIRFilterNodeRendererFactory = (createNativeAudioBufferSourceNode, getNativeAudioNode, nativeOfflineAudioContextConstructor, renderInputsOfAudioNode, renderNativeOfflineAudioContext) => {\n    return (feedback, feedforward) => {\n        const renderedNativeAudioNodes = new WeakMap();\n        let filteredBufferPromise = null;\n        const createAudioNode = async (proxy, nativeOfflineAudioContext, trace) => {\n            let nativeAudioBufferSourceNode = null;\n            let nativeIIRFilterNode = getNativeAudioNode(proxy);\n            // If the initially used nativeIIRFilterNode was not constructed on the same OfflineAudioContext it needs to be created again.\n            const nativeIIRFilterNodeIsOwnedByContext = isOwnedByContext(nativeIIRFilterNode, nativeOfflineAudioContext);\n            // Bug #9: Safari does not support IIRFilterNodes.\n            if (nativeOfflineAudioContext.createIIRFilter === undefined) {\n                nativeAudioBufferSourceNode = createNativeAudioBufferSourceNode(nativeOfflineAudioContext, {\n                    buffer: null,\n                    channelCount: 2,\n                    channelCountMode: 'max',\n                    channelInterpretation: 'speakers',\n                    loop: false,\n                    loopEnd: 0,\n                    loopStart: 0,\n                    playbackRate: 1\n                });\n            }\n            else if (!nativeIIRFilterNodeIsOwnedByContext) {\n                // @todo TypeScript defines the parameters of createIIRFilter() as arrays of numbers.\n                nativeIIRFilterNode = nativeOfflineAudioContext.createIIRFilter(feedforward, feedback);\n            }\n            renderedNativeAudioNodes.set(nativeOfflineAudioContext, nativeAudioBufferSourceNode === null ? nativeIIRFilterNode : nativeAudioBufferSourceNode);\n            if (nativeAudioBufferSourceNode !== null) {\n                if (filteredBufferPromise === null) {\n                    if (nativeOfflineAudioContextConstructor === null) {\n                        throw new Error('Missing the native OfflineAudioContext constructor.');\n                    }\n                    const partialOfflineAudioContext = new nativeOfflineAudioContextConstructor(\n                    // Bug #47: The AudioDestinationNode in Safari gets not initialized correctly.\n                    proxy.context.destination.channelCount, \n                    // Bug #17: Safari does not yet expose the length.\n                    proxy.context.length, nativeOfflineAudioContext.sampleRate);\n                    filteredBufferPromise = (async () => {\n                        await renderInputsOfAudioNode(proxy, partialOfflineAudioContext, partialOfflineAudioContext.destination, trace);\n                        const renderedBuffer = await renderNativeOfflineAudioContext(partialOfflineAudioContext);\n                        return filterFullBuffer(renderedBuffer, nativeOfflineAudioContext, feedback, feedforward);\n                    })();\n                }\n                const filteredBuffer = await filteredBufferPromise;\n                nativeAudioBufferSourceNode.buffer = filteredBuffer;\n                nativeAudioBufferSourceNode.start(0);\n                return nativeAudioBufferSourceNode;\n            }\n            await renderInputsOfAudioNode(proxy, nativeOfflineAudioContext, nativeIIRFilterNode, trace);\n            return nativeIIRFilterNode;\n        };\n        return {\n            render(proxy, nativeOfflineAudioContext, trace) {\n                const renderedNativeAudioNode = renderedNativeAudioNodes.get(nativeOfflineAudioContext);\n                if (renderedNativeAudioNode !== undefined) {\n                    return Promise.resolve(renderedNativeAudioNode);\n                }\n                return createAudioNode(proxy, nativeOfflineAudioContext, trace);\n            }\n        };\n    };\n};\n//# sourceMappingURL=iir-filter-node-renderer-factory.js.map","import { assignNativeAudioNodeOptions } from '../helpers/assign-native-audio-node-options';\nexport const createNativeIIRFilterNodeFactory = (createNativeIIRFilterNodeFaker) => {\n    return (nativeContext, baseLatency, options) => {\n        // Bug #9: Safari does not support IIRFilterNodes.\n        if (nativeContext.createIIRFilter === undefined) {\n            return createNativeIIRFilterNodeFaker(nativeContext, baseLatency, options);\n        }\n        // @todo TypeScript defines the parameters of createIIRFilter() as arrays of numbers.\n        const nativeIIRFilterNode = nativeContext.createIIRFilter(options.feedforward, options.feedback);\n        assignNativeAudioNodeOptions(nativeIIRFilterNode, options);\n        return nativeIIRFilterNode;\n    };\n};\n//# sourceMappingURL=native-iir-filter-node-factory.js.map","import { createInvalidAccessError } from '../factories/invalid-access-error';\nexport const wrapIIRFilterNodeGetFrequencyResponseMethod = (nativeIIRFilterNode) => {\n    nativeIIRFilterNode.getFrequencyResponse = ((getFrequencyResponse) => {\n        return (frequencyHz, magResponse, phaseResponse) => {\n            if (frequencyHz.length !== magResponse.length || magResponse.length !== phaseResponse.length) {\n                throw createInvalidAccessError();\n            }\n            return getFrequencyResponse.call(nativeIIRFilterNode, frequencyHz, magResponse, phaseResponse);\n        };\n    })(nativeIIRFilterNode.getFrequencyResponse);\n};\n//# sourceMappingURL=wrap-iir-filter-node-get-frequency-response-method.js.map","import { MOST_NEGATIVE_SINGLE_FLOAT, MOST_POSITIVE_SINGLE_FLOAT } from '../constants';\nexport const createAudioListenerFactory = (createAudioParam, createNativeChannelMergerNode, createNativeConstantSourceNode, createNativeScriptProcessorNode, createNotSupportedError, getFirstSample, isNativeOfflineAudioContext, overwriteAccessors) => {\n    return (context, nativeContext) => {\n        const nativeListener = nativeContext.listener;\n        // Bug #117: Only Chrome, Edge & Opera support the new interface already.\n        const createFakeAudioParams = () => {\n            const buffer = new Float32Array(1);\n            const channelMergerNode = createNativeChannelMergerNode(nativeContext, {\n                channelCount: 1,\n                channelCountMode: 'explicit',\n                channelInterpretation: 'speakers',\n                numberOfInputs: 9\n            });\n            const isOffline = isNativeOfflineAudioContext(nativeContext);\n            let isScriptProcessorNodeCreated = false;\n            let lastOrientation = [0, 0, -1, 0, 1, 0];\n            let lastPosition = [0, 0, 0];\n            const createScriptProcessorNode = () => {\n                if (isScriptProcessorNodeCreated) {\n                    return;\n                }\n                isScriptProcessorNodeCreated = true;\n                const scriptProcessorNode = createNativeScriptProcessorNode(nativeContext, 256, 9, 0);\n                // tslint:disable-next-line:deprecation\n                scriptProcessorNode.onaudioprocess = ({ inputBuffer }) => {\n                    const orientation = [\n                        getFirstSample(inputBuffer, buffer, 0),\n                        getFirstSample(inputBuffer, buffer, 1),\n                        getFirstSample(inputBuffer, buffer, 2),\n                        getFirstSample(inputBuffer, buffer, 3),\n                        getFirstSample(inputBuffer, buffer, 4),\n                        getFirstSample(inputBuffer, buffer, 5)\n                    ];\n                    if (orientation.some((value, index) => value !== lastOrientation[index])) {\n                        nativeListener.setOrientation(...orientation); // tslint:disable-line:deprecation\n                        lastOrientation = orientation;\n                    }\n                    const positon = [\n                        getFirstSample(inputBuffer, buffer, 6),\n                        getFirstSample(inputBuffer, buffer, 7),\n                        getFirstSample(inputBuffer, buffer, 8)\n                    ];\n                    if (positon.some((value, index) => value !== lastPosition[index])) {\n                        nativeListener.setPosition(...positon); // tslint:disable-line:deprecation\n                        lastPosition = positon;\n                    }\n                };\n                channelMergerNode.connect(scriptProcessorNode);\n            };\n            const createSetOrientation = (index) => (value) => {\n                if (value !== lastOrientation[index]) {\n                    lastOrientation[index] = value;\n                    nativeListener.setOrientation(...lastOrientation); // tslint:disable-line:deprecation\n                }\n            };\n            const createSetPosition = (index) => (value) => {\n                if (value !== lastPosition[index]) {\n                    lastPosition[index] = value;\n                    nativeListener.setPosition(...lastPosition); // tslint:disable-line:deprecation\n                }\n            };\n            const createFakeAudioParam = (input, initialValue, setValue) => {\n                const constantSourceNode = createNativeConstantSourceNode(nativeContext, {\n                    channelCount: 1,\n                    channelCountMode: 'explicit',\n                    channelInterpretation: 'discrete',\n                    offset: initialValue\n                });\n                constantSourceNode.connect(channelMergerNode, 0, input);\n                // @todo This should be stopped when the context is closed.\n                constantSourceNode.start();\n                Object.defineProperty(constantSourceNode.offset, 'defaultValue', {\n                    get() {\n                        return initialValue;\n                    }\n                });\n                /*\n                 * Bug #62 & #74: Safari does not support ConstantSourceNodes and does not export the correct values for maxValue and\n                 * minValue for GainNodes.\n                 */\n                const audioParam = createAudioParam({ context }, isOffline, constantSourceNode.offset, MOST_POSITIVE_SINGLE_FLOAT, MOST_NEGATIVE_SINGLE_FLOAT);\n                overwriteAccessors(audioParam, 'value', (get) => () => get.call(audioParam), (set) => (value) => {\n                    try {\n                        set.call(audioParam, value);\n                    }\n                    catch (err) {\n                        if (err.code !== 9) {\n                            throw err;\n                        }\n                    }\n                    createScriptProcessorNode();\n                    if (isOffline) {\n                        // Bug #117: Using setOrientation() and setPosition() doesn't work with an OfflineAudioContext.\n                        setValue(value);\n                    }\n                });\n                audioParam.cancelAndHoldAtTime = ((cancelAndHoldAtTime) => {\n                    if (isOffline) {\n                        return () => {\n                            throw createNotSupportedError();\n                        };\n                    }\n                    return (...args) => {\n                        const value = cancelAndHoldAtTime.apply(audioParam, args);\n                        createScriptProcessorNode();\n                        return value;\n                    };\n                })(audioParam.cancelAndHoldAtTime);\n                audioParam.cancelScheduledValues = ((cancelScheduledValues) => {\n                    if (isOffline) {\n                        return () => {\n                            throw createNotSupportedError();\n                        };\n                    }\n                    return (...args) => {\n                        const value = cancelScheduledValues.apply(audioParam, args);\n                        createScriptProcessorNode();\n                        return value;\n                    };\n                })(audioParam.cancelScheduledValues);\n                audioParam.exponentialRampToValueAtTime = ((exponentialRampToValueAtTime) => {\n                    if (isOffline) {\n                        return () => {\n                            throw createNotSupportedError();\n                        };\n                    }\n                    return (...args) => {\n                        const value = exponentialRampToValueAtTime.apply(audioParam, args);\n                        createScriptProcessorNode();\n                        return value;\n                    };\n                })(audioParam.exponentialRampToValueAtTime);\n                audioParam.linearRampToValueAtTime = ((linearRampToValueAtTime) => {\n                    if (isOffline) {\n                        return () => {\n                            throw createNotSupportedError();\n                        };\n                    }\n                    return (...args) => {\n                        const value = linearRampToValueAtTime.apply(audioParam, args);\n                        createScriptProcessorNode();\n                        return value;\n                    };\n                })(audioParam.linearRampToValueAtTime);\n                audioParam.setTargetAtTime = ((setTargetAtTime) => {\n                    if (isOffline) {\n                        return () => {\n                            throw createNotSupportedError();\n                        };\n                    }\n                    return (...args) => {\n                        const value = setTargetAtTime.apply(audioParam, args);\n                        createScriptProcessorNode();\n                        return value;\n                    };\n                })(audioParam.setTargetAtTime);\n                audioParam.setValueAtTime = ((setValueAtTime) => {\n                    if (isOffline) {\n                        return () => {\n                            throw createNotSupportedError();\n                        };\n                    }\n                    return (...args) => {\n                        const value = setValueAtTime.apply(audioParam, args);\n                        createScriptProcessorNode();\n                        return value;\n                    };\n                })(audioParam.setValueAtTime);\n                audioParam.setValueCurveAtTime = ((setValueCurveAtTime) => {\n                    if (isOffline) {\n                        return () => {\n                            throw createNotSupportedError();\n                        };\n                    }\n                    return (...args) => {\n                        const value = setValueCurveAtTime.apply(audioParam, args);\n                        createScriptProcessorNode();\n                        return value;\n                    };\n                })(audioParam.setValueCurveAtTime);\n                return audioParam;\n            };\n            return {\n                forwardX: createFakeAudioParam(0, 0, createSetOrientation(0)),\n                forwardY: createFakeAudioParam(1, 0, createSetOrientation(1)),\n                forwardZ: createFakeAudioParam(2, -1, createSetOrientation(2)),\n                positionX: createFakeAudioParam(6, 0, createSetPosition(0)),\n                positionY: createFakeAudioParam(7, 0, createSetPosition(1)),\n                positionZ: createFakeAudioParam(8, 0, createSetPosition(2)),\n                upX: createFakeAudioParam(3, 0, createSetOrientation(3)),\n                upY: createFakeAudioParam(4, 1, createSetOrientation(4)),\n                upZ: createFakeAudioParam(5, 0, createSetOrientation(5))\n            };\n        };\n        const { forwardX, forwardY, forwardZ, positionX, positionY, positionZ, upX, upY, upZ } = nativeListener.forwardX === undefined ? createFakeAudioParams() : nativeListener;\n        return {\n            get forwardX() {\n                return forwardX;\n            },\n            get forwardY() {\n                return forwardY;\n            },\n            get forwardZ() {\n                return forwardZ;\n            },\n            get positionX() {\n                return positionX;\n            },\n            get positionY() {\n                return positionY;\n            },\n            get positionZ() {\n                return positionZ;\n            },\n            get upX() {\n                return upX;\n            },\n            get upY() {\n                return upY;\n            },\n            get upZ() {\n                return upZ;\n            }\n        };\n    };\n};\n//# sourceMappingURL=audio-listener-factory.js.map","import { CONTEXT_STORE } from '../globals';\nexport const createMinimalBaseAudioContextConstructor = (audioDestinationNodeConstructor, createAudioListener, eventTargetConstructor, isNativeOfflineAudioContext, unrenderedAudioWorkletNodeStore, wrapEventListener) => {\n    return class MinimalBaseAudioContext extends eventTargetConstructor {\n        constructor(_nativeContext, numberOfChannels) {\n            super(_nativeContext);\n            this._nativeContext = _nativeContext;\n            CONTEXT_STORE.set(this, _nativeContext);\n            if (isNativeOfflineAudioContext(_nativeContext)) {\n                unrenderedAudioWorkletNodeStore.set(_nativeContext, new Set());\n            }\n            this._destination = new audioDestinationNodeConstructor(this, numberOfChannels);\n            this._listener = createAudioListener(this, _nativeContext);\n            this._onstatechange = null;\n        }\n        get currentTime() {\n            return this._nativeContext.currentTime;\n        }\n        get destination() {\n            return this._destination;\n        }\n        get listener() {\n            return this._listener;\n        }\n        get onstatechange() {\n            return this._onstatechange;\n        }\n        set onstatechange(value) {\n            const wrappedListener = typeof value === 'function' ? wrapEventListener(this, value) : null;\n            this._nativeContext.onstatechange = wrappedListener;\n            const nativeOnStateChange = this._nativeContext.onstatechange;\n            this._onstatechange = nativeOnStateChange !== null && nativeOnStateChange === wrappedListener ? value : nativeOnStateChange;\n        }\n        get sampleRate() {\n            return this._nativeContext.sampleRate;\n        }\n        get state() {\n            return this._nativeContext.state;\n        }\n    };\n};\n//# sourceMappingURL=minimal-base-audio-context-constructor.js.map","import { assignNativeAudioNodeAudioParamValue } from '../helpers/assign-native-audio-node-audio-param-value';\nimport { assignNativeAudioNodeOption } from '../helpers/assign-native-audio-node-option';\nimport { assignNativeAudioNodeOptions } from '../helpers/assign-native-audio-node-options';\nimport { wrapAudioScheduledSourceNodeStartMethodNegativeParameters } from '../helpers/wrap-audio-scheduled-source-node-start-method-negative-parameters';\nimport { wrapAudioScheduledSourceNodeStopMethodNegativeParameters } from '../helpers/wrap-audio-scheduled-source-node-stop-method-negative-parameters';\nexport const createNativeOscillatorNodeFactory = (addSilentConnection, cacheTestResult, testAudioScheduledSourceNodeStartMethodNegativeParametersSupport, testAudioScheduledSourceNodeStopMethodConsecutiveCallsSupport, testAudioScheduledSourceNodeStopMethodNegativeParametersSupport, wrapAudioScheduledSourceNodeStopMethodConsecutiveCalls) => {\n    return (nativeContext, options) => {\n        const nativeOscillatorNode = nativeContext.createOscillator();\n        assignNativeAudioNodeOptions(nativeOscillatorNode, options);\n        assignNativeAudioNodeAudioParamValue(nativeOscillatorNode, options, 'detune');\n        assignNativeAudioNodeAudioParamValue(nativeOscillatorNode, options, 'frequency');\n        if (options.periodicWave !== undefined) {\n            nativeOscillatorNode.setPeriodicWave(options.periodicWave);\n        }\n        else {\n            assignNativeAudioNodeOption(nativeOscillatorNode, options, 'type');\n        }\n        // Bug #44: Only Chrome, Edge & Opera throw a RangeError yet.\n        if (!cacheTestResult(testAudioScheduledSourceNodeStartMethodNegativeParametersSupport, () => testAudioScheduledSourceNodeStartMethodNegativeParametersSupport(nativeContext))) {\n            wrapAudioScheduledSourceNodeStartMethodNegativeParameters(nativeOscillatorNode);\n        }\n        // Bug #19: Safari does not ignore calls to stop() of an already stopped AudioBufferSourceNode.\n        if (!cacheTestResult(testAudioScheduledSourceNodeStopMethodConsecutiveCallsSupport, () => testAudioScheduledSourceNodeStopMethodConsecutiveCallsSupport(nativeContext))) {\n            wrapAudioScheduledSourceNodeStopMethodConsecutiveCalls(nativeOscillatorNode, nativeContext);\n        }\n        // Bug #44: Only Firefox does not throw a RangeError yet.\n        if (!cacheTestResult(testAudioScheduledSourceNodeStopMethodNegativeParametersSupport, () => testAudioScheduledSourceNodeStopMethodNegativeParametersSupport(nativeContext))) {\n            wrapAudioScheduledSourceNodeStopMethodNegativeParameters(nativeOscillatorNode);\n        }\n        // Bug #175: Safari will not fire an ended event if the OscillatorNode is unconnected.\n        addSilentConnection(nativeContext, nativeOscillatorNode);\n        return nativeOscillatorNode;\n    };\n};\n//# sourceMappingURL=native-oscillator-node-factory.js.map","import { isOwnedByContext } from '../helpers/is-owned-by-context';\nexport const createOscillatorNodeRendererFactory = (connectAudioParam, createNativeOscillatorNode, getNativeAudioNode, renderAutomation, renderInputsOfAudioNode) => {\n    return () => {\n        const renderedNativeOscillatorNodes = new WeakMap();\n        let periodicWave = null;\n        let start = null;\n        let stop = null;\n        const createOscillatorNode = async (proxy, nativeOfflineAudioContext, trace) => {\n            let nativeOscillatorNode = getNativeAudioNode(proxy);\n            // If the initially used nativeOscillatorNode was not constructed on the same OfflineAudioContext it needs to be created again.\n            const nativeOscillatorNodeIsOwnedByContext = isOwnedByContext(nativeOscillatorNode, nativeOfflineAudioContext);\n            if (!nativeOscillatorNodeIsOwnedByContext) {\n                const options = {\n                    channelCount: nativeOscillatorNode.channelCount,\n                    channelCountMode: nativeOscillatorNode.channelCountMode,\n                    channelInterpretation: nativeOscillatorNode.channelInterpretation,\n                    detune: nativeOscillatorNode.detune.value,\n                    frequency: nativeOscillatorNode.frequency.value,\n                    periodicWave: periodicWave === null ? undefined : periodicWave,\n                    type: nativeOscillatorNode.type\n                };\n                nativeOscillatorNode = createNativeOscillatorNode(nativeOfflineAudioContext, options);\n                if (start !== null) {\n                    nativeOscillatorNode.start(start);\n                }\n                if (stop !== null) {\n                    nativeOscillatorNode.stop(stop);\n                }\n            }\n            renderedNativeOscillatorNodes.set(nativeOfflineAudioContext, nativeOscillatorNode);\n            if (!nativeOscillatorNodeIsOwnedByContext) {\n                await renderAutomation(nativeOfflineAudioContext, proxy.detune, nativeOscillatorNode.detune, trace);\n                await renderAutomation(nativeOfflineAudioContext, proxy.frequency, nativeOscillatorNode.frequency, trace);\n            }\n            else {\n                await connectAudioParam(nativeOfflineAudioContext, proxy.detune, nativeOscillatorNode.detune, trace);\n                await connectAudioParam(nativeOfflineAudioContext, proxy.frequency, nativeOscillatorNode.frequency, trace);\n            }\n            await renderInputsOfAudioNode(proxy, nativeOfflineAudioContext, nativeOscillatorNode, trace);\n            return nativeOscillatorNode;\n        };\n        return {\n            set periodicWave(value) {\n                periodicWave = value;\n            },\n            set start(value) {\n                start = value;\n            },\n            set stop(value) {\n                stop = value;\n            },\n            render(proxy, nativeOfflineAudioContext, trace) {\n                const renderedNativeOscillatorNode = renderedNativeOscillatorNodes.get(nativeOfflineAudioContext);\n                if (renderedNativeOscillatorNode !== undefined) {\n                    return Promise.resolve(renderedNativeOscillatorNode);\n                }\n                return createOscillatorNode(proxy, nativeOfflineAudioContext, trace);\n            }\n        };\n    };\n};\n//# sourceMappingURL=oscillator-node-renderer-factory.js.map","export const createConnectedNativeAudioBufferSourceNodeFactory = (createNativeAudioBufferSourceNode) => {\n    return (nativeContext, nativeAudioNode) => {\n        const nativeAudioBufferSourceNode = createNativeAudioBufferSourceNode(nativeContext, {\n            buffer: null,\n            channelCount: 2,\n            channelCountMode: 'max',\n            channelInterpretation: 'speakers',\n            loop: false,\n            loopEnd: 0,\n            loopStart: 0,\n            playbackRate: 1\n        });\n        const nativeAudioBuffer = nativeContext.createBuffer(1, 2, 44100);\n        nativeAudioBufferSourceNode.buffer = nativeAudioBuffer;\n        nativeAudioBufferSourceNode.loop = true;\n        nativeAudioBufferSourceNode.connect(nativeAudioNode);\n        nativeAudioBufferSourceNode.start();\n        return () => {\n            nativeAudioBufferSourceNode.stop();\n            nativeAudioBufferSourceNode.disconnect(nativeAudioNode);\n        };\n    };\n};\n//# sourceMappingURL=connected-native-audio-buffer-source-node-factory.js.map","import { assignNativeAudioNodeOptions } from '../helpers/assign-native-audio-node-options';\nimport { interceptConnections } from '../helpers/intercept-connections';\nexport const createNativeWaveShaperNodeFakerFactory = (createConnectedNativeAudioBufferSourceNode, createInvalidStateError, createNativeGainNode, isDCCurve, monitorConnections) => {\n    return (nativeContext, { curve, oversample, ...audioNodeOptions }) => {\n        const negativeWaveShaperNode = nativeContext.createWaveShaper();\n        const positiveWaveShaperNode = nativeContext.createWaveShaper();\n        assignNativeAudioNodeOptions(negativeWaveShaperNode, audioNodeOptions);\n        assignNativeAudioNodeOptions(positiveWaveShaperNode, audioNodeOptions);\n        const inputGainNode = createNativeGainNode(nativeContext, { ...audioNodeOptions, gain: 1 });\n        const invertGainNode = createNativeGainNode(nativeContext, { ...audioNodeOptions, gain: -1 });\n        const outputGainNode = createNativeGainNode(nativeContext, { ...audioNodeOptions, gain: 1 });\n        const revertGainNode = createNativeGainNode(nativeContext, { ...audioNodeOptions, gain: -1 });\n        let disconnectNativeAudioBufferSourceNode = null;\n        let isConnected = false;\n        let unmodifiedCurve = null;\n        const nativeWaveShaperNodeFaker = {\n            get bufferSize() {\n                return undefined;\n            },\n            get channelCount() {\n                return negativeWaveShaperNode.channelCount;\n            },\n            set channelCount(value) {\n                inputGainNode.channelCount = value;\n                invertGainNode.channelCount = value;\n                negativeWaveShaperNode.channelCount = value;\n                outputGainNode.channelCount = value;\n                positiveWaveShaperNode.channelCount = value;\n                revertGainNode.channelCount = value;\n            },\n            get channelCountMode() {\n                return negativeWaveShaperNode.channelCountMode;\n            },\n            set channelCountMode(value) {\n                inputGainNode.channelCountMode = value;\n                invertGainNode.channelCountMode = value;\n                negativeWaveShaperNode.channelCountMode = value;\n                outputGainNode.channelCountMode = value;\n                positiveWaveShaperNode.channelCountMode = value;\n                revertGainNode.channelCountMode = value;\n            },\n            get channelInterpretation() {\n                return negativeWaveShaperNode.channelInterpretation;\n            },\n            set channelInterpretation(value) {\n                inputGainNode.channelInterpretation = value;\n                invertGainNode.channelInterpretation = value;\n                negativeWaveShaperNode.channelInterpretation = value;\n                outputGainNode.channelInterpretation = value;\n                positiveWaveShaperNode.channelInterpretation = value;\n                revertGainNode.channelInterpretation = value;\n            },\n            get context() {\n                return negativeWaveShaperNode.context;\n            },\n            get curve() {\n                return unmodifiedCurve;\n            },\n            set curve(value) {\n                // Bug #102: Safari does not throw an InvalidStateError when the curve has less than two samples.\n                if (value !== null && value.length < 2) {\n                    throw createInvalidStateError();\n                }\n                if (value === null) {\n                    negativeWaveShaperNode.curve = value;\n                    positiveWaveShaperNode.curve = value;\n                }\n                else {\n                    const curveLength = value.length;\n                    const negativeCurve = new Float32Array(curveLength + 2 - (curveLength % 2));\n                    const positiveCurve = new Float32Array(curveLength + 2 - (curveLength % 2));\n                    negativeCurve[0] = value[0];\n                    positiveCurve[0] = -value[curveLength - 1];\n                    const length = Math.ceil((curveLength + 1) / 2);\n                    const centerIndex = (curveLength + 1) / 2 - 1;\n                    for (let i = 1; i < length; i += 1) {\n                        const theoreticIndex = (i / length) * centerIndex;\n                        const lowerIndex = Math.floor(theoreticIndex);\n                        const upperIndex = Math.ceil(theoreticIndex);\n                        negativeCurve[i] =\n                            lowerIndex === upperIndex\n                                ? value[lowerIndex]\n                                : (1 - (theoreticIndex - lowerIndex)) * value[lowerIndex] +\n                                    (1 - (upperIndex - theoreticIndex)) * value[upperIndex];\n                        positiveCurve[i] =\n                            lowerIndex === upperIndex\n                                ? -value[curveLength - 1 - lowerIndex]\n                                : -((1 - (theoreticIndex - lowerIndex)) * value[curveLength - 1 - lowerIndex]) -\n                                    (1 - (upperIndex - theoreticIndex)) * value[curveLength - 1 - upperIndex];\n                    }\n                    negativeCurve[length] = curveLength % 2 === 1 ? value[length - 1] : (value[length - 2] + value[length - 1]) / 2;\n                    negativeWaveShaperNode.curve = negativeCurve;\n                    positiveWaveShaperNode.curve = positiveCurve;\n                }\n                unmodifiedCurve = value;\n                if (isConnected) {\n                    if (isDCCurve(unmodifiedCurve) && disconnectNativeAudioBufferSourceNode === null) {\n                        disconnectNativeAudioBufferSourceNode = createConnectedNativeAudioBufferSourceNode(nativeContext, inputGainNode);\n                    }\n                    else if (disconnectNativeAudioBufferSourceNode !== null) {\n                        disconnectNativeAudioBufferSourceNode();\n                        disconnectNativeAudioBufferSourceNode = null;\n                    }\n                }\n            },\n            get inputs() {\n                return [inputGainNode];\n            },\n            get numberOfInputs() {\n                return negativeWaveShaperNode.numberOfInputs;\n            },\n            get numberOfOutputs() {\n                return negativeWaveShaperNode.numberOfOutputs;\n            },\n            get oversample() {\n                return negativeWaveShaperNode.oversample;\n            },\n            set oversample(value) {\n                negativeWaveShaperNode.oversample = value;\n                positiveWaveShaperNode.oversample = value;\n            },\n            addEventListener(...args) {\n                return inputGainNode.addEventListener(args[0], args[1], args[2]);\n            },\n            dispatchEvent(...args) {\n                return inputGainNode.dispatchEvent(args[0]);\n            },\n            removeEventListener(...args) {\n                return inputGainNode.removeEventListener(args[0], args[1], args[2]);\n            }\n        };\n        if (curve !== null) {\n            // Only values of type Float32Array can be assigned to the curve property.\n            nativeWaveShaperNodeFaker.curve = curve instanceof Float32Array ? curve : new Float32Array(curve);\n        }\n        if (oversample !== nativeWaveShaperNodeFaker.oversample) {\n            nativeWaveShaperNodeFaker.oversample = oversample;\n        }\n        const whenConnected = () => {\n            inputGainNode.connect(negativeWaveShaperNode).connect(outputGainNode);\n            inputGainNode.connect(invertGainNode).connect(positiveWaveShaperNode).connect(revertGainNode).connect(outputGainNode);\n            isConnected = true;\n            if (isDCCurve(unmodifiedCurve)) {\n                disconnectNativeAudioBufferSourceNode = createConnectedNativeAudioBufferSourceNode(nativeContext, inputGainNode);\n            }\n        };\n        const whenDisconnected = () => {\n            inputGainNode.disconnect(negativeWaveShaperNode);\n            negativeWaveShaperNode.disconnect(outputGainNode);\n            inputGainNode.disconnect(invertGainNode);\n            invertGainNode.disconnect(positiveWaveShaperNode);\n            positiveWaveShaperNode.disconnect(revertGainNode);\n            revertGainNode.disconnect(outputGainNode);\n            isConnected = false;\n            if (disconnectNativeAudioBufferSourceNode !== null) {\n                disconnectNativeAudioBufferSourceNode();\n                disconnectNativeAudioBufferSourceNode = null;\n            }\n        };\n        return monitorConnections(interceptConnections(nativeWaveShaperNodeFaker, outputGainNode), whenConnected, whenDisconnected);\n    };\n};\n//# sourceMappingURL=native-wave-shaper-node-faker-factory.js.map","import { assignNativeAudioNodeOption } from '../helpers/assign-native-audio-node-option';\nimport { assignNativeAudioNodeOptions } from '../helpers/assign-native-audio-node-options';\nexport const createNativeWaveShaperNodeFactory = (createConnectedNativeAudioBufferSourceNode, createInvalidStateError, createNativeWaveShaperNodeFaker, isDCCurve, monitorConnections, nativeAudioContextConstructor, overwriteAccessors) => {\n    return (nativeContext, options) => {\n        const nativeWaveShaperNode = nativeContext.createWaveShaper();\n        /*\n         * Bug #119: Safari does not correctly map the values.\n         * @todo Unfortunately there is no way to test for this behavior in a synchronous fashion which is why testing for the existence of\n         * the webkitAudioContext is used as a workaround here. Testing for the automationRate property is necessary because this workaround\n         * isn't necessary anymore since v14.0.2 of Safari.\n         */\n        if (nativeAudioContextConstructor !== null &&\n            nativeAudioContextConstructor.name === 'webkitAudioContext' &&\n            nativeContext.createGain().gain.automationRate === undefined) {\n            return createNativeWaveShaperNodeFaker(nativeContext, options);\n        }\n        assignNativeAudioNodeOptions(nativeWaveShaperNode, options);\n        const curve = options.curve === null || options.curve instanceof Float32Array ? options.curve : new Float32Array(options.curve);\n        // Bug #104: Chrome, Edge and Opera will throw an InvalidAccessError when the curve has less than two samples.\n        if (curve !== null && curve.length < 2) {\n            throw createInvalidStateError();\n        }\n        // Only values of type Float32Array can be assigned to the curve property.\n        assignNativeAudioNodeOption(nativeWaveShaperNode, { curve }, 'curve');\n        assignNativeAudioNodeOption(nativeWaveShaperNode, options, 'oversample');\n        let disconnectNativeAudioBufferSourceNode = null;\n        let isConnected = false;\n        overwriteAccessors(nativeWaveShaperNode, 'curve', (get) => () => get.call(nativeWaveShaperNode), (set) => (value) => {\n            set.call(nativeWaveShaperNode, value);\n            if (isConnected) {\n                if (isDCCurve(value) && disconnectNativeAudioBufferSourceNode === null) {\n                    disconnectNativeAudioBufferSourceNode = createConnectedNativeAudioBufferSourceNode(nativeContext, nativeWaveShaperNode);\n                }\n                else if (!isDCCurve(value) && disconnectNativeAudioBufferSourceNode !== null) {\n                    disconnectNativeAudioBufferSourceNode();\n                    disconnectNativeAudioBufferSourceNode = null;\n                }\n            }\n            return value;\n        });\n        const whenConnected = () => {\n            isConnected = true;\n            if (isDCCurve(nativeWaveShaperNode.curve)) {\n                disconnectNativeAudioBufferSourceNode = createConnectedNativeAudioBufferSourceNode(nativeContext, nativeWaveShaperNode);\n            }\n        };\n        const whenDisconnected = () => {\n            isConnected = false;\n            if (disconnectNativeAudioBufferSourceNode !== null) {\n                disconnectNativeAudioBufferSourceNode();\n                disconnectNativeAudioBufferSourceNode = null;\n            }\n        };\n        return monitorConnections(nativeWaveShaperNode, whenConnected, whenDisconnected);\n    };\n};\n//# sourceMappingURL=native-wave-shaper-node-factory.js.map","import { assignNativeAudioNodeOptions } from '../helpers/assign-native-audio-node-options';\nimport { interceptConnections } from '../helpers/intercept-connections';\nexport const createNativePannerNodeFakerFactory = (connectNativeAudioNodeToNativeAudioNode, createInvalidStateError, createNativeChannelMergerNode, createNativeGainNode, createNativeScriptProcessorNode, createNativeWaveShaperNode, createNotSupportedError, disconnectNativeAudioNodeFromNativeAudioNode, getFirstSample, monitorConnections) => {\n    return (nativeContext, { coneInnerAngle, coneOuterAngle, coneOuterGain, distanceModel, maxDistance, orientationX, orientationY, orientationZ, panningModel, positionX, positionY, positionZ, refDistance, rolloffFactor, ...audioNodeOptions }) => {\n        const pannerNode = nativeContext.createPanner();\n        // Bug #125: Safari does not throw an error yet.\n        if (audioNodeOptions.channelCount > 2) {\n            throw createNotSupportedError();\n        }\n        // Bug #126: Safari does not throw an error yet.\n        if (audioNodeOptions.channelCountMode === 'max') {\n            throw createNotSupportedError();\n        }\n        assignNativeAudioNodeOptions(pannerNode, audioNodeOptions);\n        const SINGLE_CHANNEL_OPTIONS = {\n            channelCount: 1,\n            channelCountMode: 'explicit',\n            channelInterpretation: 'discrete'\n        };\n        const channelMergerNode = createNativeChannelMergerNode(nativeContext, {\n            ...SINGLE_CHANNEL_OPTIONS,\n            channelInterpretation: 'speakers',\n            numberOfInputs: 6\n        });\n        const inputGainNode = createNativeGainNode(nativeContext, { ...audioNodeOptions, gain: 1 });\n        const orientationXGainNode = createNativeGainNode(nativeContext, { ...SINGLE_CHANNEL_OPTIONS, gain: 1 });\n        const orientationYGainNode = createNativeGainNode(nativeContext, { ...SINGLE_CHANNEL_OPTIONS, gain: 0 });\n        const orientationZGainNode = createNativeGainNode(nativeContext, { ...SINGLE_CHANNEL_OPTIONS, gain: 0 });\n        const positionXGainNode = createNativeGainNode(nativeContext, { ...SINGLE_CHANNEL_OPTIONS, gain: 0 });\n        const positionYGainNode = createNativeGainNode(nativeContext, { ...SINGLE_CHANNEL_OPTIONS, gain: 0 });\n        const positionZGainNode = createNativeGainNode(nativeContext, { ...SINGLE_CHANNEL_OPTIONS, gain: 0 });\n        const scriptProcessorNode = createNativeScriptProcessorNode(nativeContext, 256, 6, 1);\n        const waveShaperNode = createNativeWaveShaperNode(nativeContext, {\n            ...SINGLE_CHANNEL_OPTIONS,\n            curve: new Float32Array([1, 1]),\n            oversample: 'none'\n        });\n        let lastOrientation = [orientationX, orientationY, orientationZ];\n        let lastPosition = [positionX, positionY, positionZ];\n        const buffer = new Float32Array(1);\n        // tslint:disable-next-line:deprecation\n        scriptProcessorNode.onaudioprocess = ({ inputBuffer }) => {\n            const orientation = [\n                getFirstSample(inputBuffer, buffer, 0),\n                getFirstSample(inputBuffer, buffer, 1),\n                getFirstSample(inputBuffer, buffer, 2)\n            ];\n            if (orientation.some((value, index) => value !== lastOrientation[index])) {\n                pannerNode.setOrientation(...orientation); // tslint:disable-line:deprecation\n                lastOrientation = orientation;\n            }\n            const positon = [\n                getFirstSample(inputBuffer, buffer, 3),\n                getFirstSample(inputBuffer, buffer, 4),\n                getFirstSample(inputBuffer, buffer, 5)\n            ];\n            if (positon.some((value, index) => value !== lastPosition[index])) {\n                pannerNode.setPosition(...positon); // tslint:disable-line:deprecation\n                lastPosition = positon;\n            }\n        };\n        Object.defineProperty(orientationYGainNode.gain, 'defaultValue', { get: () => 0 });\n        Object.defineProperty(orientationZGainNode.gain, 'defaultValue', { get: () => 0 });\n        Object.defineProperty(positionXGainNode.gain, 'defaultValue', { get: () => 0 });\n        Object.defineProperty(positionYGainNode.gain, 'defaultValue', { get: () => 0 });\n        Object.defineProperty(positionZGainNode.gain, 'defaultValue', { get: () => 0 });\n        const nativePannerNodeFaker = {\n            get bufferSize() {\n                return undefined;\n            },\n            get channelCount() {\n                return pannerNode.channelCount;\n            },\n            set channelCount(value) {\n                // Bug #125: Safari does not throw an error yet.\n                if (value > 2) {\n                    throw createNotSupportedError();\n                }\n                inputGainNode.channelCount = value;\n                pannerNode.channelCount = value;\n            },\n            get channelCountMode() {\n                return pannerNode.channelCountMode;\n            },\n            set channelCountMode(value) {\n                // Bug #126: Safari does not throw an error yet.\n                if (value === 'max') {\n                    throw createNotSupportedError();\n                }\n                inputGainNode.channelCountMode = value;\n                pannerNode.channelCountMode = value;\n            },\n            get channelInterpretation() {\n                return pannerNode.channelInterpretation;\n            },\n            set channelInterpretation(value) {\n                inputGainNode.channelInterpretation = value;\n                pannerNode.channelInterpretation = value;\n            },\n            get coneInnerAngle() {\n                return pannerNode.coneInnerAngle;\n            },\n            set coneInnerAngle(value) {\n                pannerNode.coneInnerAngle = value;\n            },\n            get coneOuterAngle() {\n                return pannerNode.coneOuterAngle;\n            },\n            set coneOuterAngle(value) {\n                pannerNode.coneOuterAngle = value;\n            },\n            get coneOuterGain() {\n                return pannerNode.coneOuterGain;\n            },\n            set coneOuterGain(value) {\n                // Bug #127: Safari does not throw an InvalidStateError yet.\n                if (value < 0 || value > 1) {\n                    throw createInvalidStateError();\n                }\n                pannerNode.coneOuterGain = value;\n            },\n            get context() {\n                return pannerNode.context;\n            },\n            get distanceModel() {\n                return pannerNode.distanceModel;\n            },\n            set distanceModel(value) {\n                pannerNode.distanceModel = value;\n            },\n            get inputs() {\n                return [inputGainNode];\n            },\n            get maxDistance() {\n                return pannerNode.maxDistance;\n            },\n            set maxDistance(value) {\n                // Bug #128: Safari does not throw an error yet.\n                if (value < 0) {\n                    throw new RangeError();\n                }\n                pannerNode.maxDistance = value;\n            },\n            get numberOfInputs() {\n                return pannerNode.numberOfInputs;\n            },\n            get numberOfOutputs() {\n                return pannerNode.numberOfOutputs;\n            },\n            get orientationX() {\n                return orientationXGainNode.gain;\n            },\n            get orientationY() {\n                return orientationYGainNode.gain;\n            },\n            get orientationZ() {\n                return orientationZGainNode.gain;\n            },\n            get panningModel() {\n                return pannerNode.panningModel;\n            },\n            set panningModel(value) {\n                pannerNode.panningModel = value;\n            },\n            get positionX() {\n                return positionXGainNode.gain;\n            },\n            get positionY() {\n                return positionYGainNode.gain;\n            },\n            get positionZ() {\n                return positionZGainNode.gain;\n            },\n            get refDistance() {\n                return pannerNode.refDistance;\n            },\n            set refDistance(value) {\n                // Bug #129: Safari does not throw an error yet.\n                if (value < 0) {\n                    throw new RangeError();\n                }\n                pannerNode.refDistance = value;\n            },\n            get rolloffFactor() {\n                return pannerNode.rolloffFactor;\n            },\n            set rolloffFactor(value) {\n                // Bug #130: Safari does not throw an error yet.\n                if (value < 0) {\n                    throw new RangeError();\n                }\n                pannerNode.rolloffFactor = value;\n            },\n            addEventListener(...args) {\n                return inputGainNode.addEventListener(args[0], args[1], args[2]);\n            },\n            dispatchEvent(...args) {\n                return inputGainNode.dispatchEvent(args[0]);\n            },\n            removeEventListener(...args) {\n                return inputGainNode.removeEventListener(args[0], args[1], args[2]);\n            }\n        };\n        if (coneInnerAngle !== nativePannerNodeFaker.coneInnerAngle) {\n            nativePannerNodeFaker.coneInnerAngle = coneInnerAngle;\n        }\n        if (coneOuterAngle !== nativePannerNodeFaker.coneOuterAngle) {\n            nativePannerNodeFaker.coneOuterAngle = coneOuterAngle;\n        }\n        if (coneOuterGain !== nativePannerNodeFaker.coneOuterGain) {\n            nativePannerNodeFaker.coneOuterGain = coneOuterGain;\n        }\n        if (distanceModel !== nativePannerNodeFaker.distanceModel) {\n            nativePannerNodeFaker.distanceModel = distanceModel;\n        }\n        if (maxDistance !== nativePannerNodeFaker.maxDistance) {\n            nativePannerNodeFaker.maxDistance = maxDistance;\n        }\n        if (orientationX !== nativePannerNodeFaker.orientationX.value) {\n            nativePannerNodeFaker.orientationX.value = orientationX;\n        }\n        if (orientationY !== nativePannerNodeFaker.orientationY.value) {\n            nativePannerNodeFaker.orientationY.value = orientationY;\n        }\n        if (orientationZ !== nativePannerNodeFaker.orientationZ.value) {\n            nativePannerNodeFaker.orientationZ.value = orientationZ;\n        }\n        if (panningModel !== nativePannerNodeFaker.panningModel) {\n            nativePannerNodeFaker.panningModel = panningModel;\n        }\n        if (positionX !== nativePannerNodeFaker.positionX.value) {\n            nativePannerNodeFaker.positionX.value = positionX;\n        }\n        if (positionY !== nativePannerNodeFaker.positionY.value) {\n            nativePannerNodeFaker.positionY.value = positionY;\n        }\n        if (positionZ !== nativePannerNodeFaker.positionZ.value) {\n            nativePannerNodeFaker.positionZ.value = positionZ;\n        }\n        if (refDistance !== nativePannerNodeFaker.refDistance) {\n            nativePannerNodeFaker.refDistance = refDistance;\n        }\n        if (rolloffFactor !== nativePannerNodeFaker.rolloffFactor) {\n            nativePannerNodeFaker.rolloffFactor = rolloffFactor;\n        }\n        if (lastOrientation[0] !== 1 || lastOrientation[1] !== 0 || lastOrientation[2] !== 0) {\n            pannerNode.setOrientation(...lastOrientation); // tslint:disable-line:deprecation\n        }\n        if (lastPosition[0] !== 0 || lastPosition[1] !== 0 || lastPosition[2] !== 0) {\n            pannerNode.setPosition(...lastPosition); // tslint:disable-line:deprecation\n        }\n        const whenConnected = () => {\n            inputGainNode.connect(pannerNode);\n            // Bug #119: Safari does not fully support the WaveShaperNode.\n            connectNativeAudioNodeToNativeAudioNode(inputGainNode, waveShaperNode, 0, 0);\n            waveShaperNode.connect(orientationXGainNode).connect(channelMergerNode, 0, 0);\n            waveShaperNode.connect(orientationYGainNode).connect(channelMergerNode, 0, 1);\n            waveShaperNode.connect(orientationZGainNode).connect(channelMergerNode, 0, 2);\n            waveShaperNode.connect(positionXGainNode).connect(channelMergerNode, 0, 3);\n            waveShaperNode.connect(positionYGainNode).connect(channelMergerNode, 0, 4);\n            waveShaperNode.connect(positionZGainNode).connect(channelMergerNode, 0, 5);\n            channelMergerNode.connect(scriptProcessorNode).connect(nativeContext.destination);\n        };\n        const whenDisconnected = () => {\n            inputGainNode.disconnect(pannerNode);\n            // Bug #119: Safari does not fully support the WaveShaperNode.\n            disconnectNativeAudioNodeFromNativeAudioNode(inputGainNode, waveShaperNode, 0, 0);\n            waveShaperNode.disconnect(orientationXGainNode);\n            orientationXGainNode.disconnect(channelMergerNode);\n            waveShaperNode.disconnect(orientationYGainNode);\n            orientationYGainNode.disconnect(channelMergerNode);\n            waveShaperNode.disconnect(orientationZGainNode);\n            orientationZGainNode.disconnect(channelMergerNode);\n            waveShaperNode.disconnect(positionXGainNode);\n            positionXGainNode.disconnect(channelMergerNode);\n            waveShaperNode.disconnect(positionYGainNode);\n            positionYGainNode.disconnect(channelMergerNode);\n            waveShaperNode.disconnect(positionZGainNode);\n            positionZGainNode.disconnect(channelMergerNode);\n            channelMergerNode.disconnect(scriptProcessorNode);\n            scriptProcessorNode.disconnect(nativeContext.destination);\n        };\n        return monitorConnections(interceptConnections(nativePannerNodeFaker, pannerNode), whenConnected, whenDisconnected);\n    };\n};\n//# sourceMappingURL=native-panner-node-faker-factory.js.map","import { assignNativeAudioNodeAudioParamValue } from '../helpers/assign-native-audio-node-audio-param-value';\nimport { assignNativeAudioNodeOption } from '../helpers/assign-native-audio-node-option';\nimport { assignNativeAudioNodeOptions } from '../helpers/assign-native-audio-node-options';\nexport const createNativePannerNodeFactory = (createNativePannerNodeFaker) => {\n    return (nativeContext, options) => {\n        const nativePannerNode = nativeContext.createPanner();\n        // Bug #124: Safari does not support modifying the orientation and the position with AudioParams.\n        if (nativePannerNode.orientationX === undefined) {\n            return createNativePannerNodeFaker(nativeContext, options);\n        }\n        assignNativeAudioNodeOptions(nativePannerNode, options);\n        assignNativeAudioNodeAudioParamValue(nativePannerNode, options, 'orientationX');\n        assignNativeAudioNodeAudioParamValue(nativePannerNode, options, 'orientationY');\n        assignNativeAudioNodeAudioParamValue(nativePannerNode, options, 'orientationZ');\n        assignNativeAudioNodeAudioParamValue(nativePannerNode, options, 'positionX');\n        assignNativeAudioNodeAudioParamValue(nativePannerNode, options, 'positionY');\n        assignNativeAudioNodeAudioParamValue(nativePannerNode, options, 'positionZ');\n        assignNativeAudioNodeOption(nativePannerNode, options, 'coneInnerAngle');\n        assignNativeAudioNodeOption(nativePannerNode, options, 'coneOuterAngle');\n        assignNativeAudioNodeOption(nativePannerNode, options, 'coneOuterGain');\n        assignNativeAudioNodeOption(nativePannerNode, options, 'distanceModel');\n        assignNativeAudioNodeOption(nativePannerNode, options, 'maxDistance');\n        assignNativeAudioNodeOption(nativePannerNode, options, 'panningModel');\n        assignNativeAudioNodeOption(nativePannerNode, options, 'refDistance');\n        assignNativeAudioNodeOption(nativePannerNode, options, 'rolloffFactor');\n        return nativePannerNode;\n    };\n};\n//# sourceMappingURL=native-panner-node-factory.js.map","import { isNativeAudioNodeFaker } from '../guards/native-audio-node-faker';\nimport { isOwnedByContext } from '../helpers/is-owned-by-context';\nexport const createPannerNodeRendererFactory = (connectAudioParam, createNativeChannelMergerNode, createNativeConstantSourceNode, createNativeGainNode, createNativePannerNode, getNativeAudioNode, nativeOfflineAudioContextConstructor, renderAutomation, renderInputsOfAudioNode, renderNativeOfflineAudioContext) => {\n    return () => {\n        const renderedNativeAudioNodes = new WeakMap();\n        let renderedBufferPromise = null;\n        const createAudioNode = async (proxy, nativeOfflineAudioContext, trace) => {\n            let nativeGainNode = null;\n            let nativePannerNode = getNativeAudioNode(proxy);\n            const commonAudioNodeOptions = {\n                channelCount: nativePannerNode.channelCount,\n                channelCountMode: nativePannerNode.channelCountMode,\n                channelInterpretation: nativePannerNode.channelInterpretation\n            };\n            const commonNativePannerNodeOptions = {\n                ...commonAudioNodeOptions,\n                coneInnerAngle: nativePannerNode.coneInnerAngle,\n                coneOuterAngle: nativePannerNode.coneOuterAngle,\n                coneOuterGain: nativePannerNode.coneOuterGain,\n                distanceModel: nativePannerNode.distanceModel,\n                maxDistance: nativePannerNode.maxDistance,\n                panningModel: nativePannerNode.panningModel,\n                refDistance: nativePannerNode.refDistance,\n                rolloffFactor: nativePannerNode.rolloffFactor\n            };\n            // If the initially used nativePannerNode was not constructed on the same OfflineAudioContext it needs to be created again.\n            const nativePannerNodeIsOwnedByContext = isOwnedByContext(nativePannerNode, nativeOfflineAudioContext);\n            // Bug #124: Safari does not support modifying the orientation and the position with AudioParams.\n            if ('bufferSize' in nativePannerNode) {\n                nativeGainNode = createNativeGainNode(nativeOfflineAudioContext, { ...commonAudioNodeOptions, gain: 1 });\n            }\n            else if (!nativePannerNodeIsOwnedByContext) {\n                const options = {\n                    ...commonNativePannerNodeOptions,\n                    orientationX: nativePannerNode.orientationX.value,\n                    orientationY: nativePannerNode.orientationY.value,\n                    orientationZ: nativePannerNode.orientationZ.value,\n                    positionX: nativePannerNode.positionX.value,\n                    positionY: nativePannerNode.positionY.value,\n                    positionZ: nativePannerNode.positionZ.value\n                };\n                nativePannerNode = createNativePannerNode(nativeOfflineAudioContext, options);\n            }\n            renderedNativeAudioNodes.set(nativeOfflineAudioContext, nativeGainNode === null ? nativePannerNode : nativeGainNode);\n            if (nativeGainNode !== null) {\n                if (renderedBufferPromise === null) {\n                    if (nativeOfflineAudioContextConstructor === null) {\n                        throw new Error('Missing the native OfflineAudioContext constructor.');\n                    }\n                    const partialOfflineAudioContext = new nativeOfflineAudioContextConstructor(6, \n                    // Bug #17: Safari does not yet expose the length.\n                    proxy.context.length, nativeOfflineAudioContext.sampleRate);\n                    const nativeChannelMergerNode = createNativeChannelMergerNode(partialOfflineAudioContext, {\n                        channelCount: 1,\n                        channelCountMode: 'explicit',\n                        channelInterpretation: 'speakers',\n                        numberOfInputs: 6\n                    });\n                    nativeChannelMergerNode.connect(partialOfflineAudioContext.destination);\n                    renderedBufferPromise = (async () => {\n                        const nativeConstantSourceNodes = await Promise.all([\n                            proxy.orientationX,\n                            proxy.orientationY,\n                            proxy.orientationZ,\n                            proxy.positionX,\n                            proxy.positionY,\n                            proxy.positionZ\n                        ].map(async (audioParam, index) => {\n                            const nativeConstantSourceNode = createNativeConstantSourceNode(partialOfflineAudioContext, {\n                                channelCount: 1,\n                                channelCountMode: 'explicit',\n                                channelInterpretation: 'discrete',\n                                offset: index === 0 ? 1 : 0\n                            });\n                            await renderAutomation(partialOfflineAudioContext, audioParam, nativeConstantSourceNode.offset, trace);\n                            return nativeConstantSourceNode;\n                        }));\n                        for (let i = 0; i < 6; i += 1) {\n                            nativeConstantSourceNodes[i].connect(nativeChannelMergerNode, 0, i);\n                            nativeConstantSourceNodes[i].start(0);\n                        }\n                        return renderNativeOfflineAudioContext(partialOfflineAudioContext);\n                    })();\n                }\n                const renderedBuffer = await renderedBufferPromise;\n                const inputGainNode = createNativeGainNode(nativeOfflineAudioContext, { ...commonAudioNodeOptions, gain: 1 });\n                await renderInputsOfAudioNode(proxy, nativeOfflineAudioContext, inputGainNode, trace);\n                const channelDatas = [];\n                for (let i = 0; i < renderedBuffer.numberOfChannels; i += 1) {\n                    channelDatas.push(renderedBuffer.getChannelData(i));\n                }\n                let lastOrientation = [channelDatas[0][0], channelDatas[1][0], channelDatas[2][0]];\n                let lastPosition = [channelDatas[3][0], channelDatas[4][0], channelDatas[5][0]];\n                let gateGainNode = createNativeGainNode(nativeOfflineAudioContext, { ...commonAudioNodeOptions, gain: 1 });\n                let partialPannerNode = createNativePannerNode(nativeOfflineAudioContext, {\n                    ...commonNativePannerNodeOptions,\n                    orientationX: lastOrientation[0],\n                    orientationY: lastOrientation[1],\n                    orientationZ: lastOrientation[2],\n                    positionX: lastPosition[0],\n                    positionY: lastPosition[1],\n                    positionZ: lastPosition[2]\n                });\n                inputGainNode.connect(gateGainNode).connect(partialPannerNode.inputs[0]);\n                partialPannerNode.connect(nativeGainNode);\n                for (let i = 128; i < renderedBuffer.length; i += 128) {\n                    const orientation = [channelDatas[0][i], channelDatas[1][i], channelDatas[2][i]];\n                    const positon = [channelDatas[3][i], channelDatas[4][i], channelDatas[5][i]];\n                    if (orientation.some((value, index) => value !== lastOrientation[index]) ||\n                        positon.some((value, index) => value !== lastPosition[index])) {\n                        lastOrientation = orientation;\n                        lastPosition = positon;\n                        const currentTime = i / nativeOfflineAudioContext.sampleRate;\n                        gateGainNode.gain.setValueAtTime(0, currentTime);\n                        gateGainNode = createNativeGainNode(nativeOfflineAudioContext, { ...commonAudioNodeOptions, gain: 0 });\n                        partialPannerNode = createNativePannerNode(nativeOfflineAudioContext, {\n                            ...commonNativePannerNodeOptions,\n                            orientationX: lastOrientation[0],\n                            orientationY: lastOrientation[1],\n                            orientationZ: lastOrientation[2],\n                            positionX: lastPosition[0],\n                            positionY: lastPosition[1],\n                            positionZ: lastPosition[2]\n                        });\n                        gateGainNode.gain.setValueAtTime(1, currentTime);\n                        inputGainNode.connect(gateGainNode).connect(partialPannerNode.inputs[0]);\n                        partialPannerNode.connect(nativeGainNode);\n                    }\n                }\n                return nativeGainNode;\n            }\n            if (!nativePannerNodeIsOwnedByContext) {\n                await renderAutomation(nativeOfflineAudioContext, proxy.orientationX, nativePannerNode.orientationX, trace);\n                await renderAutomation(nativeOfflineAudioContext, proxy.orientationY, nativePannerNode.orientationY, trace);\n                await renderAutomation(nativeOfflineAudioContext, proxy.orientationZ, nativePannerNode.orientationZ, trace);\n                await renderAutomation(nativeOfflineAudioContext, proxy.positionX, nativePannerNode.positionX, trace);\n                await renderAutomation(nativeOfflineAudioContext, proxy.positionY, nativePannerNode.positionY, trace);\n                await renderAutomation(nativeOfflineAudioContext, proxy.positionZ, nativePannerNode.positionZ, trace);\n            }\n            else {\n                await connectAudioParam(nativeOfflineAudioContext, proxy.orientationX, nativePannerNode.orientationX, trace);\n                await connectAudioParam(nativeOfflineAudioContext, proxy.orientationY, nativePannerNode.orientationY, trace);\n                await connectAudioParam(nativeOfflineAudioContext, proxy.orientationZ, nativePannerNode.orientationZ, trace);\n                await connectAudioParam(nativeOfflineAudioContext, proxy.positionX, nativePannerNode.positionX, trace);\n                await connectAudioParam(nativeOfflineAudioContext, proxy.positionY, nativePannerNode.positionY, trace);\n                await connectAudioParam(nativeOfflineAudioContext, proxy.positionZ, nativePannerNode.positionZ, trace);\n            }\n            if (isNativeAudioNodeFaker(nativePannerNode)) {\n                await renderInputsOfAudioNode(proxy, nativeOfflineAudioContext, nativePannerNode.inputs[0], trace);\n            }\n            else {\n                await renderInputsOfAudioNode(proxy, nativeOfflineAudioContext, nativePannerNode, trace);\n            }\n            return nativePannerNode;\n        };\n        return {\n            render(proxy, nativeOfflineAudioContext, trace) {\n                const renderedNativeGainNodeOrNativePannerNode = renderedNativeAudioNodes.get(nativeOfflineAudioContext);\n                if (renderedNativeGainNodeOrNativePannerNode !== undefined) {\n                    return Promise.resolve(renderedNativeGainNodeOrNativePannerNode);\n                }\n                return createAudioNode(proxy, nativeOfflineAudioContext, trace);\n            }\n        };\n    };\n};\n//# sourceMappingURL=panner-node-renderer-factory.js.map","export const createNativePeriodicWaveFactory = (createIndexSizeError) => {\n    return (nativeContext, { disableNormalization, imag, real }) => {\n        // Bug #180: Safari does not allow to use ordinary arrays.\n        const convertedImag = imag instanceof Float32Array ? imag : new Float32Array(imag);\n        const convertedReal = real instanceof Float32Array ? real : new Float32Array(real);\n        const nativePeriodicWave = nativeContext.createPeriodicWave(convertedReal, convertedImag, { disableNormalization });\n        // Bug #181: Safari does not throw an IndexSizeError so far if the given arrays have less than two values.\n        if (Array.from(imag).length < 2) {\n            throw createIndexSizeError();\n        }\n        return nativePeriodicWave;\n    };\n};\n//# sourceMappingURL=native-periodic-wave-factory.js.map","export const sanitizePeriodicWaveOptions = (options) => {\n    const { imag, real } = options;\n    if (imag === undefined) {\n        if (real === undefined) {\n            return { ...options, imag: [0, 0], real: [0, 0] };\n        }\n        return { ...options, imag: Array.from(real, () => 0), real };\n    }\n    if (real === undefined) {\n        return { ...options, imag, real: Array.from(imag, () => 0) };\n    }\n    return { ...options, imag, real };\n};\n//# sourceMappingURL=sanitize-periodic-wave-options.js.map","import { interceptConnections } from '../helpers/intercept-connections';\nexport const createNativeStereoPannerNodeFakerFactory = (createNativeChannelMergerNode, createNativeChannelSplitterNode, createNativeGainNode, createNativeWaveShaperNode, createNotSupportedError, monitorConnections) => {\n    // The curve has a size of 14bit plus 1 value to have an exact representation for zero. This value has been determined experimentally.\n    const CURVE_SIZE = 16385;\n    const DC_CURVE = new Float32Array([1, 1]);\n    const HALF_PI = Math.PI / 2;\n    const SINGLE_CHANNEL_OPTIONS = { channelCount: 1, channelCountMode: 'explicit', channelInterpretation: 'discrete' };\n    const SINGLE_CHANNEL_WAVE_SHAPER_OPTIONS = { ...SINGLE_CHANNEL_OPTIONS, oversample: 'none' };\n    const buildInternalGraphForMono = (nativeContext, inputGainNode, panGainNode, channelMergerNode) => {\n        const leftWaveShaperCurve = new Float32Array(CURVE_SIZE);\n        const rightWaveShaperCurve = new Float32Array(CURVE_SIZE);\n        for (let i = 0; i < CURVE_SIZE; i += 1) {\n            const x = (i / (CURVE_SIZE - 1)) * HALF_PI;\n            leftWaveShaperCurve[i] = Math.cos(x);\n            rightWaveShaperCurve[i] = Math.sin(x);\n        }\n        const leftGainNode = createNativeGainNode(nativeContext, { ...SINGLE_CHANNEL_OPTIONS, gain: 0 });\n        // Bug #119: Safari does not fully support the WaveShaperNode.\n        const leftWaveShaperNode = (createNativeWaveShaperNode(nativeContext, { ...SINGLE_CHANNEL_WAVE_SHAPER_OPTIONS, curve: leftWaveShaperCurve }));\n        // Bug #119: Safari does not fully support the WaveShaperNode.\n        const panWaveShaperNode = (createNativeWaveShaperNode(nativeContext, { ...SINGLE_CHANNEL_WAVE_SHAPER_OPTIONS, curve: DC_CURVE }));\n        const rightGainNode = createNativeGainNode(nativeContext, { ...SINGLE_CHANNEL_OPTIONS, gain: 0 });\n        // Bug #119: Safari does not fully support the WaveShaperNode.\n        const rightWaveShaperNode = (createNativeWaveShaperNode(nativeContext, { ...SINGLE_CHANNEL_WAVE_SHAPER_OPTIONS, curve: rightWaveShaperCurve }));\n        return {\n            connectGraph() {\n                inputGainNode.connect(leftGainNode);\n                inputGainNode.connect(panWaveShaperNode.inputs === undefined ? panWaveShaperNode : panWaveShaperNode.inputs[0]);\n                inputGainNode.connect(rightGainNode);\n                panWaveShaperNode.connect(panGainNode);\n                panGainNode.connect(leftWaveShaperNode.inputs === undefined ? leftWaveShaperNode : leftWaveShaperNode.inputs[0]);\n                panGainNode.connect(rightWaveShaperNode.inputs === undefined ? rightWaveShaperNode : rightWaveShaperNode.inputs[0]);\n                leftWaveShaperNode.connect(leftGainNode.gain);\n                rightWaveShaperNode.connect(rightGainNode.gain);\n                leftGainNode.connect(channelMergerNode, 0, 0);\n                rightGainNode.connect(channelMergerNode, 0, 1);\n            },\n            disconnectGraph() {\n                inputGainNode.disconnect(leftGainNode);\n                inputGainNode.disconnect(panWaveShaperNode.inputs === undefined ? panWaveShaperNode : panWaveShaperNode.inputs[0]);\n                inputGainNode.disconnect(rightGainNode);\n                panWaveShaperNode.disconnect(panGainNode);\n                panGainNode.disconnect(leftWaveShaperNode.inputs === undefined ? leftWaveShaperNode : leftWaveShaperNode.inputs[0]);\n                panGainNode.disconnect(rightWaveShaperNode.inputs === undefined ? rightWaveShaperNode : rightWaveShaperNode.inputs[0]);\n                leftWaveShaperNode.disconnect(leftGainNode.gain);\n                rightWaveShaperNode.disconnect(rightGainNode.gain);\n                leftGainNode.disconnect(channelMergerNode, 0, 0);\n                rightGainNode.disconnect(channelMergerNode, 0, 1);\n            }\n        };\n    };\n    const buildInternalGraphForStereo = (nativeContext, inputGainNode, panGainNode, channelMergerNode) => {\n        const leftInputForLeftOutputWaveShaperCurve = new Float32Array(CURVE_SIZE);\n        const leftInputForRightOutputWaveShaperCurve = new Float32Array(CURVE_SIZE);\n        const rightInputForLeftOutputWaveShaperCurve = new Float32Array(CURVE_SIZE);\n        const rightInputForRightOutputWaveShaperCurve = new Float32Array(CURVE_SIZE);\n        const centerIndex = Math.floor(CURVE_SIZE / 2);\n        for (let i = 0; i < CURVE_SIZE; i += 1) {\n            if (i > centerIndex) {\n                const x = ((i - centerIndex) / (CURVE_SIZE - 1 - centerIndex)) * HALF_PI;\n                leftInputForLeftOutputWaveShaperCurve[i] = Math.cos(x);\n                leftInputForRightOutputWaveShaperCurve[i] = Math.sin(x);\n                rightInputForLeftOutputWaveShaperCurve[i] = 0;\n                rightInputForRightOutputWaveShaperCurve[i] = 1;\n            }\n            else {\n                const x = (i / (CURVE_SIZE - 1 - centerIndex)) * HALF_PI;\n                leftInputForLeftOutputWaveShaperCurve[i] = 1;\n                leftInputForRightOutputWaveShaperCurve[i] = 0;\n                rightInputForLeftOutputWaveShaperCurve[i] = Math.cos(x);\n                rightInputForRightOutputWaveShaperCurve[i] = Math.sin(x);\n            }\n        }\n        const channelSplitterNode = createNativeChannelSplitterNode(nativeContext, {\n            channelCount: 2,\n            channelCountMode: 'explicit',\n            channelInterpretation: 'discrete',\n            numberOfOutputs: 2\n        });\n        const leftInputForLeftOutputGainNode = createNativeGainNode(nativeContext, { ...SINGLE_CHANNEL_OPTIONS, gain: 0 });\n        // Bug #119: Safari does not fully support the WaveShaperNode.\n        const leftInputForLeftOutputWaveShaperNode = createNativeWaveShaperNode(nativeContext, {\n            ...SINGLE_CHANNEL_WAVE_SHAPER_OPTIONS,\n            curve: leftInputForLeftOutputWaveShaperCurve\n        });\n        const leftInputForRightOutputGainNode = createNativeGainNode(nativeContext, { ...SINGLE_CHANNEL_OPTIONS, gain: 0 });\n        // Bug #119: Safari does not fully support the WaveShaperNode.\n        const leftInputForRightOutputWaveShaperNode = createNativeWaveShaperNode(nativeContext, {\n            ...SINGLE_CHANNEL_WAVE_SHAPER_OPTIONS,\n            curve: leftInputForRightOutputWaveShaperCurve\n        });\n        // Bug #119: Safari does not fully support the WaveShaperNode.\n        const panWaveShaperNode = (createNativeWaveShaperNode(nativeContext, { ...SINGLE_CHANNEL_WAVE_SHAPER_OPTIONS, curve: DC_CURVE }));\n        const rightInputForLeftOutputGainNode = createNativeGainNode(nativeContext, { ...SINGLE_CHANNEL_OPTIONS, gain: 0 });\n        // Bug #119: Safari does not fully support the WaveShaperNode.\n        const rightInputForLeftOutputWaveShaperNode = createNativeWaveShaperNode(nativeContext, {\n            ...SINGLE_CHANNEL_WAVE_SHAPER_OPTIONS,\n            curve: rightInputForLeftOutputWaveShaperCurve\n        });\n        const rightInputForRightOutputGainNode = createNativeGainNode(nativeContext, { ...SINGLE_CHANNEL_OPTIONS, gain: 0 });\n        // Bug #119: Safari does not fully support the WaveShaperNode.\n        const rightInputForRightOutputWaveShaperNode = createNativeWaveShaperNode(nativeContext, {\n            ...SINGLE_CHANNEL_WAVE_SHAPER_OPTIONS,\n            curve: rightInputForRightOutputWaveShaperCurve\n        });\n        return {\n            connectGraph() {\n                inputGainNode.connect(channelSplitterNode);\n                inputGainNode.connect(panWaveShaperNode.inputs === undefined ? panWaveShaperNode : panWaveShaperNode.inputs[0]);\n                channelSplitterNode.connect(leftInputForLeftOutputGainNode, 0);\n                channelSplitterNode.connect(leftInputForRightOutputGainNode, 0);\n                channelSplitterNode.connect(rightInputForLeftOutputGainNode, 1);\n                channelSplitterNode.connect(rightInputForRightOutputGainNode, 1);\n                panWaveShaperNode.connect(panGainNode);\n                panGainNode.connect(leftInputForLeftOutputWaveShaperNode.inputs === undefined\n                    ? leftInputForLeftOutputWaveShaperNode\n                    : leftInputForLeftOutputWaveShaperNode.inputs[0]);\n                panGainNode.connect(leftInputForRightOutputWaveShaperNode.inputs === undefined\n                    ? leftInputForRightOutputWaveShaperNode\n                    : leftInputForRightOutputWaveShaperNode.inputs[0]);\n                panGainNode.connect(rightInputForLeftOutputWaveShaperNode.inputs === undefined\n                    ? rightInputForLeftOutputWaveShaperNode\n                    : rightInputForLeftOutputWaveShaperNode.inputs[0]);\n                panGainNode.connect(rightInputForRightOutputWaveShaperNode.inputs === undefined\n                    ? rightInputForRightOutputWaveShaperNode\n                    : rightInputForRightOutputWaveShaperNode.inputs[0]);\n                leftInputForLeftOutputWaveShaperNode.connect(leftInputForLeftOutputGainNode.gain);\n                leftInputForRightOutputWaveShaperNode.connect(leftInputForRightOutputGainNode.gain);\n                rightInputForLeftOutputWaveShaperNode.connect(rightInputForLeftOutputGainNode.gain);\n                rightInputForRightOutputWaveShaperNode.connect(rightInputForRightOutputGainNode.gain);\n                leftInputForLeftOutputGainNode.connect(channelMergerNode, 0, 0);\n                rightInputForLeftOutputGainNode.connect(channelMergerNode, 0, 0);\n                leftInputForRightOutputGainNode.connect(channelMergerNode, 0, 1);\n                rightInputForRightOutputGainNode.connect(channelMergerNode, 0, 1);\n            },\n            disconnectGraph() {\n                inputGainNode.disconnect(channelSplitterNode);\n                inputGainNode.disconnect(panWaveShaperNode.inputs === undefined ? panWaveShaperNode : panWaveShaperNode.inputs[0]);\n                channelSplitterNode.disconnect(leftInputForLeftOutputGainNode, 0);\n                channelSplitterNode.disconnect(leftInputForRightOutputGainNode, 0);\n                channelSplitterNode.disconnect(rightInputForLeftOutputGainNode, 1);\n                channelSplitterNode.disconnect(rightInputForRightOutputGainNode, 1);\n                panWaveShaperNode.disconnect(panGainNode);\n                panGainNode.disconnect(leftInputForLeftOutputWaveShaperNode.inputs === undefined\n                    ? leftInputForLeftOutputWaveShaperNode\n                    : leftInputForLeftOutputWaveShaperNode.inputs[0]);\n                panGainNode.disconnect(leftInputForRightOutputWaveShaperNode.inputs === undefined\n                    ? leftInputForRightOutputWaveShaperNode\n                    : leftInputForRightOutputWaveShaperNode.inputs[0]);\n                panGainNode.disconnect(rightInputForLeftOutputWaveShaperNode.inputs === undefined\n                    ? rightInputForLeftOutputWaveShaperNode\n                    : rightInputForLeftOutputWaveShaperNode.inputs[0]);\n                panGainNode.disconnect(rightInputForRightOutputWaveShaperNode.inputs === undefined\n                    ? rightInputForRightOutputWaveShaperNode\n                    : rightInputForRightOutputWaveShaperNode.inputs[0]);\n                leftInputForLeftOutputWaveShaperNode.disconnect(leftInputForLeftOutputGainNode.gain);\n                leftInputForRightOutputWaveShaperNode.disconnect(leftInputForRightOutputGainNode.gain);\n                rightInputForLeftOutputWaveShaperNode.disconnect(rightInputForLeftOutputGainNode.gain);\n                rightInputForRightOutputWaveShaperNode.disconnect(rightInputForRightOutputGainNode.gain);\n                leftInputForLeftOutputGainNode.disconnect(channelMergerNode, 0, 0);\n                rightInputForLeftOutputGainNode.disconnect(channelMergerNode, 0, 0);\n                leftInputForRightOutputGainNode.disconnect(channelMergerNode, 0, 1);\n                rightInputForRightOutputGainNode.disconnect(channelMergerNode, 0, 1);\n            }\n        };\n    };\n    const buildInternalGraph = (nativeContext, channelCount, inputGainNode, panGainNode, channelMergerNode) => {\n        if (channelCount === 1) {\n            return buildInternalGraphForMono(nativeContext, inputGainNode, panGainNode, channelMergerNode);\n        }\n        if (channelCount === 2) {\n            return buildInternalGraphForStereo(nativeContext, inputGainNode, panGainNode, channelMergerNode);\n        }\n        throw createNotSupportedError();\n    };\n    return (nativeContext, { channelCount, channelCountMode, pan, ...audioNodeOptions }) => {\n        if (channelCountMode === 'max') {\n            throw createNotSupportedError();\n        }\n        const channelMergerNode = createNativeChannelMergerNode(nativeContext, {\n            ...audioNodeOptions,\n            channelCount: 1,\n            channelCountMode,\n            numberOfInputs: 2\n        });\n        const inputGainNode = createNativeGainNode(nativeContext, { ...audioNodeOptions, channelCount, channelCountMode, gain: 1 });\n        const panGainNode = createNativeGainNode(nativeContext, {\n            channelCount: 1,\n            channelCountMode: 'explicit',\n            channelInterpretation: 'discrete',\n            gain: pan\n        });\n        let { connectGraph, disconnectGraph } = buildInternalGraph(nativeContext, channelCount, inputGainNode, panGainNode, channelMergerNode);\n        Object.defineProperty(panGainNode.gain, 'defaultValue', { get: () => 0 });\n        Object.defineProperty(panGainNode.gain, 'maxValue', { get: () => 1 });\n        Object.defineProperty(panGainNode.gain, 'minValue', { get: () => -1 });\n        const nativeStereoPannerNodeFakerFactory = {\n            get bufferSize() {\n                return undefined;\n            },\n            get channelCount() {\n                return inputGainNode.channelCount;\n            },\n            set channelCount(value) {\n                if (inputGainNode.channelCount !== value) {\n                    if (isConnected) {\n                        disconnectGraph();\n                    }\n                    ({ connectGraph, disconnectGraph } = buildInternalGraph(nativeContext, value, inputGainNode, panGainNode, channelMergerNode));\n                    if (isConnected) {\n                        connectGraph();\n                    }\n                }\n                inputGainNode.channelCount = value;\n            },\n            get channelCountMode() {\n                return inputGainNode.channelCountMode;\n            },\n            set channelCountMode(value) {\n                if (value === 'clamped-max' || value === 'max') {\n                    throw createNotSupportedError();\n                }\n                inputGainNode.channelCountMode = value;\n            },\n            get channelInterpretation() {\n                return inputGainNode.channelInterpretation;\n            },\n            set channelInterpretation(value) {\n                inputGainNode.channelInterpretation = value;\n            },\n            get context() {\n                return inputGainNode.context;\n            },\n            get inputs() {\n                return [inputGainNode];\n            },\n            get numberOfInputs() {\n                return inputGainNode.numberOfInputs;\n            },\n            get numberOfOutputs() {\n                return inputGainNode.numberOfOutputs;\n            },\n            get pan() {\n                return panGainNode.gain;\n            },\n            addEventListener(...args) {\n                return inputGainNode.addEventListener(args[0], args[1], args[2]);\n            },\n            dispatchEvent(...args) {\n                return inputGainNode.dispatchEvent(args[0]);\n            },\n            removeEventListener(...args) {\n                return inputGainNode.removeEventListener(args[0], args[1], args[2]);\n            }\n        };\n        let isConnected = false;\n        const whenConnected = () => {\n            connectGraph();\n            isConnected = true;\n        };\n        const whenDisconnected = () => {\n            disconnectGraph();\n            isConnected = false;\n        };\n        return monitorConnections(interceptConnections(nativeStereoPannerNodeFakerFactory, channelMergerNode), whenConnected, whenDisconnected);\n    };\n};\n//# sourceMappingURL=native-stereo-panner-node-faker-factory.js.map","import { assignNativeAudioNodeAudioParamValue } from '../helpers/assign-native-audio-node-audio-param-value';\nimport { assignNativeAudioNodeOptions } from '../helpers/assign-native-audio-node-options';\nexport const createNativeStereoPannerNodeFactory = (createNativeStereoPannerNodeFaker, createNotSupportedError) => {\n    return (nativeContext, options) => {\n        const channelCountMode = options.channelCountMode;\n        /*\n         * Bug #105: The channelCountMode of 'clamped-max' should be supported. However it is not possible to write a polyfill for Safari\n         * which supports it and therefore it can't be supported at all.\n         */\n        if (channelCountMode === 'clamped-max') {\n            throw createNotSupportedError();\n        }\n        // Bug #105: Safari does not support the StereoPannerNode.\n        if (nativeContext.createStereoPanner === undefined) {\n            return createNativeStereoPannerNodeFaker(nativeContext, options);\n        }\n        const nativeStereoPannerNode = nativeContext.createStereoPanner();\n        assignNativeAudioNodeOptions(nativeStereoPannerNode, options);\n        assignNativeAudioNodeAudioParamValue(nativeStereoPannerNode, options, 'pan');\n        /*\n         * Bug #105: The channelCountMode of 'clamped-max' should be supported. However it is not possible to write a polyfill for Safari\n         * which supports it and therefore it can't be supported at all.\n         */\n        Object.defineProperty(nativeStereoPannerNode, 'channelCountMode', {\n            get: () => channelCountMode,\n            set: (value) => {\n                if (value !== channelCountMode) {\n                    throw createNotSupportedError();\n                }\n            }\n        });\n        return nativeStereoPannerNode;\n    };\n};\n//# sourceMappingURL=native-stereo-panner-node-factory.js.map","import { isNativeAudioNodeFaker } from '../guards/native-audio-node-faker';\nimport { isOwnedByContext } from '../helpers/is-owned-by-context';\nexport const createStereoPannerNodeRendererFactory = (connectAudioParam, createNativeStereoPannerNode, getNativeAudioNode, renderAutomation, renderInputsOfAudioNode) => {\n    return () => {\n        const renderedNativeStereoPannerNodes = new WeakMap();\n        const createStereoPannerNode = async (proxy, nativeOfflineAudioContext, trace) => {\n            let nativeStereoPannerNode = getNativeAudioNode(proxy);\n            /*\n             * If the initially used nativeStereoPannerNode was not constructed on the same OfflineAudioContext it needs to be created\n             * again.\n             */\n            const nativeStereoPannerNodeIsOwnedByContext = isOwnedByContext(nativeStereoPannerNode, nativeOfflineAudioContext);\n            if (!nativeStereoPannerNodeIsOwnedByContext) {\n                const options = {\n                    channelCount: nativeStereoPannerNode.channelCount,\n                    channelCountMode: nativeStereoPannerNode.channelCountMode,\n                    channelInterpretation: nativeStereoPannerNode.channelInterpretation,\n                    pan: nativeStereoPannerNode.pan.value\n                };\n                nativeStereoPannerNode = createNativeStereoPannerNode(nativeOfflineAudioContext, options);\n            }\n            renderedNativeStereoPannerNodes.set(nativeOfflineAudioContext, nativeStereoPannerNode);\n            if (!nativeStereoPannerNodeIsOwnedByContext) {\n                await renderAutomation(nativeOfflineAudioContext, proxy.pan, nativeStereoPannerNode.pan, trace);\n            }\n            else {\n                await connectAudioParam(nativeOfflineAudioContext, proxy.pan, nativeStereoPannerNode.pan, trace);\n            }\n            if (isNativeAudioNodeFaker(nativeStereoPannerNode)) {\n                await renderInputsOfAudioNode(proxy, nativeOfflineAudioContext, nativeStereoPannerNode.inputs[0], trace);\n            }\n            else {\n                await renderInputsOfAudioNode(proxy, nativeOfflineAudioContext, nativeStereoPannerNode, trace);\n            }\n            return nativeStereoPannerNode;\n        };\n        return {\n            render(proxy, nativeOfflineAudioContext, trace) {\n                const renderedNativeStereoPannerNode = renderedNativeStereoPannerNodes.get(nativeOfflineAudioContext);\n                if (renderedNativeStereoPannerNode !== undefined) {\n                    return Promise.resolve(renderedNativeStereoPannerNode);\n                }\n                return createStereoPannerNode(proxy, nativeOfflineAudioContext, trace);\n            }\n        };\n    };\n};\n//# sourceMappingURL=stereo-panner-node-renderer-factory.js.map","import { isNativeAudioNodeFaker } from '../guards/native-audio-node-faker';\nimport { isOwnedByContext } from '../helpers/is-owned-by-context';\nexport const createWaveShaperNodeRendererFactory = (createNativeWaveShaperNode, getNativeAudioNode, renderInputsOfAudioNode) => {\n    return () => {\n        const renderedNativeWaveShaperNodes = new WeakMap();\n        const createWaveShaperNode = async (proxy, nativeOfflineAudioContext, trace) => {\n            let nativeWaveShaperNode = getNativeAudioNode(proxy);\n            // If the initially used nativeWaveShaperNode was not constructed on the same OfflineAudioContext it needs to be created again.\n            const nativeWaveShaperNodeIsOwnedByContext = isOwnedByContext(nativeWaveShaperNode, nativeOfflineAudioContext);\n            if (!nativeWaveShaperNodeIsOwnedByContext) {\n                const options = {\n                    channelCount: nativeWaveShaperNode.channelCount,\n                    channelCountMode: nativeWaveShaperNode.channelCountMode,\n                    channelInterpretation: nativeWaveShaperNode.channelInterpretation,\n                    curve: nativeWaveShaperNode.curve,\n                    oversample: nativeWaveShaperNode.oversample\n                };\n                nativeWaveShaperNode = createNativeWaveShaperNode(nativeOfflineAudioContext, options);\n            }\n            renderedNativeWaveShaperNodes.set(nativeOfflineAudioContext, nativeWaveShaperNode);\n            if (isNativeAudioNodeFaker(nativeWaveShaperNode)) {\n                await renderInputsOfAudioNode(proxy, nativeOfflineAudioContext, nativeWaveShaperNode.inputs[0], trace);\n            }\n            else {\n                await renderInputsOfAudioNode(proxy, nativeOfflineAudioContext, nativeWaveShaperNode, trace);\n            }\n            return nativeWaveShaperNode;\n        };\n        return {\n            render(proxy, nativeOfflineAudioContext, trace) {\n                const renderedNativeWaveShaperNode = renderedNativeWaveShaperNodes.get(nativeOfflineAudioContext);\n                if (renderedNativeWaveShaperNode !== undefined) {\n                    return Promise.resolve(renderedNativeWaveShaperNode);\n                }\n                return createWaveShaperNode(proxy, nativeOfflineAudioContext, trace);\n            }\n        };\n    };\n};\n//# sourceMappingURL=wave-shaper-node-renderer-factory.js.map","export const createIsSecureContext = (window) => window !== null && window.isSecureContext;\n//# sourceMappingURL=is-secure-context.js.map","export const createExposeCurrentFrameAndCurrentTime = (window) => {\n    return (currentTime, sampleRate, fn) => {\n        Object.defineProperties(window, {\n            currentFrame: {\n                configurable: true,\n                get() {\n                    return Math.round(currentTime * sampleRate);\n                }\n            },\n            currentTime: {\n                configurable: true,\n                get() {\n                    return currentTime;\n                }\n            }\n        });\n        try {\n            return fn();\n        }\n        finally {\n            if (window !== null) {\n                delete window.currentFrame;\n                delete window.currentTime;\n            }\n        }\n    };\n};\n//# sourceMappingURL=expose-current-frame-and-current-time.js.map","export const createGetOrCreateBackupOfflineAudioContext = (backupOfflineAudioContextStore, nativeOfflineAudioContextConstructor) => {\n    return (nativeContext) => {\n        let backupOfflineAudioContext = backupOfflineAudioContextStore.get(nativeContext);\n        if (backupOfflineAudioContext !== undefined) {\n            return backupOfflineAudioContext;\n        }\n        if (nativeOfflineAudioContextConstructor === null) {\n            throw new Error('Missing the native OfflineAudioContext constructor.');\n        }\n        // Bug #141: Safari does not support creating an OfflineAudioContext with less than 44100 Hz.\n        backupOfflineAudioContext = new nativeOfflineAudioContextConstructor(1, 1, 44100);\n        backupOfflineAudioContextStore.set(nativeContext, backupOfflineAudioContext);\n        return backupOfflineAudioContext;\n    };\n};\n//# sourceMappingURL=get-or-create-backup-offline-audio-context.js.map","export const createEvaluateSource = (window) => {\n    return (source) => new Promise((resolve, reject) => {\n        if (window === null) {\n            // Bug #182 Chrome, Edge and Opera do throw an instance of a SyntaxError instead of a DOMException.\n            reject(new SyntaxError());\n            return;\n        }\n        const head = window.document.head;\n        if (head === null) {\n            // Bug #182 Chrome, Edge and Opera do throw an instance of a SyntaxError instead of a DOMException.\n            reject(new SyntaxError());\n        }\n        else {\n            const script = window.document.createElement('script');\n            // @todo Safari doesn't like URLs with a type of 'application/javascript; charset=utf-8'.\n            const blob = new Blob([source], { type: 'application/javascript' });\n            const url = URL.createObjectURL(blob);\n            const originalOnErrorHandler = window.onerror;\n            const removeErrorEventListenerAndRevokeUrl = () => {\n                window.onerror = originalOnErrorHandler;\n                URL.revokeObjectURL(url);\n            };\n            window.onerror = (message, src, lineno, colno, error) => {\n                // @todo Edge thinks the source is the one of the html document.\n                if (src === url || (src === window.location.href && lineno === 1 && colno === 1)) {\n                    removeErrorEventListenerAndRevokeUrl();\n                    reject(error);\n                    return false;\n                }\n                if (originalOnErrorHandler !== null) {\n                    return originalOnErrorHandler(message, src, lineno, colno, error);\n                }\n            };\n            script.onerror = () => {\n                removeErrorEventListenerAndRevokeUrl();\n                // Bug #182 Chrome, Edge and Opera do throw an instance of a SyntaxError instead of a DOMException.\n                reject(new SyntaxError());\n            };\n            script.onload = () => {\n                removeErrorEventListenerAndRevokeUrl();\n                resolve();\n            };\n            script.src = url;\n            script.type = 'module';\n            head.appendChild(script);\n        }\n    });\n};\n//# sourceMappingURL=evaluate-source.js.map","export const createFetchSource = (createAbortError) => {\n    return async (url) => {\n        try {\n            const response = await fetch(url);\n            if (response.ok) {\n                return [await response.text(), response.url];\n            }\n        }\n        catch {\n            // Ignore errors.\n        } // tslint:disable-line:no-empty\n        throw createAbortError();\n    };\n};\n//# sourceMappingURL=fetch-source.js.map","// Bug #179: Firefox does not allow to transfer any buffer which has been passed to the process() method as an argument.\nexport const createTestAudioWorkletProcessorPostMessageSupport = (nativeAudioWorkletNodeConstructor, nativeOfflineAudioContextConstructor) => {\n    return async () => {\n        // Bug #61: If there is no native AudioWorkletNode it gets faked and therefore it is no problem if the it doesn't exist.\n        if (nativeAudioWorkletNodeConstructor === null) {\n            return true;\n        }\n        if (nativeOfflineAudioContextConstructor === null) {\n            return false;\n        }\n        const blob = new Blob(['class A extends AudioWorkletProcessor{process(i){this.port.postMessage(i,[i[0][0].buffer])}}registerProcessor(\"a\",A)'], {\n            type: 'application/javascript; charset=utf-8'\n        });\n        // Bug #141: Safari does not support creating an OfflineAudioContext with less than 44100 Hz.\n        const offlineAudioContext = new nativeOfflineAudioContextConstructor(1, 128, 44100);\n        const url = URL.createObjectURL(blob);\n        let isEmittingMessageEvents = false;\n        let isEmittingProcessorErrorEvents = false;\n        try {\n            await offlineAudioContext.audioWorklet.addModule(url);\n            const audioWorkletNode = new nativeAudioWorkletNodeConstructor(offlineAudioContext, 'a', { numberOfOutputs: 0 });\n            const oscillator = offlineAudioContext.createOscillator();\n            audioWorkletNode.port.onmessage = () => (isEmittingMessageEvents = true);\n            audioWorkletNode.onprocessorerror = () => (isEmittingProcessorErrorEvents = true);\n            oscillator.connect(audioWorkletNode);\n            oscillator.start(0);\n            await offlineAudioContext.startRendering();\n        }\n        catch {\n            // Ignore errors.\n        }\n        finally {\n            URL.revokeObjectURL(url);\n        }\n        return isEmittingMessageEvents && !isEmittingProcessorErrorEvents;\n    };\n};\n//# sourceMappingURL=test-audio-worklet-processor-post-message-support.js.map","export const createIsNativeContext = (isNativeAudioContext, isNativeOfflineAudioContext) => {\n    return (anything) => {\n        return isNativeAudioContext(anything) || isNativeOfflineAudioContext(anything);\n    };\n};\n//# sourceMappingURL=is-native-context.js.map","import { detachArrayBuffer } from '../helpers/detach-array-buffer';\nimport { wrapAudioBufferGetChannelDataMethod } from '../helpers/wrap-audio-buffer-get-channel-data-method';\nexport const createDecodeAudioData = (audioBufferStore, cacheTestResult, createDataCloneError, createEncodingError, detachedArrayBuffers, getNativeContext, isNativeContext, testAudioBufferCopyChannelMethodsOutOfBoundsSupport, testPromiseSupport, wrapAudioBufferCopyChannelMethods, wrapAudioBufferCopyChannelMethodsOutOfBounds) => {\n    return (anyContext, audioData) => {\n        const nativeContext = isNativeContext(anyContext) ? anyContext : getNativeContext(anyContext);\n        // Bug #43: Only Chrome, Edge and Opera do throw a DataCloneError.\n        if (detachedArrayBuffers.has(audioData)) {\n            const err = createDataCloneError();\n            return Promise.reject(err);\n        }\n        // The audioData parameter maybe of a type which can't be added to a WeakSet.\n        try {\n            detachedArrayBuffers.add(audioData);\n        }\n        catch {\n            // Ignore errors.\n        }\n        // Bug #21: Safari does not support promises yet.\n        if (cacheTestResult(testPromiseSupport, () => testPromiseSupport(nativeContext))) {\n            return nativeContext.decodeAudioData(audioData).then((audioBuffer) => {\n                // Bug #133: Safari does neuter the ArrayBuffer.\n                detachArrayBuffer(audioData).catch(() => {\n                    // Ignore errors.\n                });\n                // Bug #157: Firefox does not allow the bufferOffset to be out-of-bounds.\n                if (!cacheTestResult(testAudioBufferCopyChannelMethodsOutOfBoundsSupport, () => testAudioBufferCopyChannelMethodsOutOfBoundsSupport(audioBuffer))) {\n                    wrapAudioBufferCopyChannelMethodsOutOfBounds(audioBuffer);\n                }\n                audioBufferStore.add(audioBuffer);\n                return audioBuffer;\n            });\n        }\n        // Bug #21: Safari does not return a Promise yet.\n        return new Promise((resolve, reject) => {\n            const complete = async () => {\n                // Bug #133: Safari does neuter the ArrayBuffer.\n                try {\n                    await detachArrayBuffer(audioData);\n                }\n                catch {\n                    // Ignore errors.\n                }\n            };\n            const fail = (err) => {\n                reject(err);\n                complete();\n            };\n            // Bug #26: Safari throws a synchronous error.\n            try {\n                // Bug #1: Safari requires a successCallback.\n                nativeContext.decodeAudioData(audioData, (audioBuffer) => {\n                    // Bug #5: Safari does not support copyFromChannel() and copyToChannel().\n                    // Bug #100: Safari does throw a wrong error when calling getChannelData() with an out-of-bounds value.\n                    if (typeof audioBuffer.copyFromChannel !== 'function') {\n                        wrapAudioBufferCopyChannelMethods(audioBuffer);\n                        wrapAudioBufferGetChannelDataMethod(audioBuffer);\n                    }\n                    audioBufferStore.add(audioBuffer);\n                    complete().then(() => resolve(audioBuffer));\n                }, (err) => {\n                    // Bug #4: Safari returns null instead of an error.\n                    if (err === null) {\n                        fail(createEncodingError());\n                    }\n                    else {\n                        fail(err);\n                    }\n                });\n            }\n            catch (err) {\n                fail(err);\n            }\n        });\n    };\n};\n//# sourceMappingURL=decode-audio-data.js.map","export const createDataCloneError = () => new DOMException('', 'DataCloneError');\n//# sourceMappingURL=data-clone-error.js.map","export const createEncodingError = () => new DOMException('', 'EncodingError');\n//# sourceMappingURL=encoding-error.js.map","export const createBaseAudioContextConstructor = (addAudioWorkletModule, analyserNodeConstructor, audioBufferConstructor, audioBufferSourceNodeConstructor, biquadFilterNodeConstructor, channelMergerNodeConstructor, channelSplitterNodeConstructor, constantSourceNodeConstructor, convolverNodeConstructor, decodeAudioData, delayNodeConstructor, dynamicsCompressorNodeConstructor, gainNodeConstructor, iIRFilterNodeConstructor, minimalBaseAudioContextConstructor, oscillatorNodeConstructor, pannerNodeConstructor, periodicWaveConstructor, stereoPannerNodeConstructor, waveShaperNodeConstructor) => {\n    return class BaseAudioContext extends minimalBaseAudioContextConstructor {\n        constructor(_nativeContext, numberOfChannels) {\n            super(_nativeContext, numberOfChannels);\n            this._nativeContext = _nativeContext;\n            this._audioWorklet =\n                addAudioWorkletModule === undefined\n                    ? undefined\n                    : {\n                        addModule: (moduleURL, options) => {\n                            return addAudioWorkletModule(this, moduleURL, options);\n                        }\n                    };\n        }\n        get audioWorklet() {\n            return this._audioWorklet;\n        }\n        createAnalyser() {\n            return new analyserNodeConstructor(this);\n        }\n        createBiquadFilter() {\n            return new biquadFilterNodeConstructor(this);\n        }\n        createBuffer(numberOfChannels, length, sampleRate) {\n            return new audioBufferConstructor({ length, numberOfChannels, sampleRate });\n        }\n        createBufferSource() {\n            return new audioBufferSourceNodeConstructor(this);\n        }\n        createChannelMerger(numberOfInputs = 6) {\n            return new channelMergerNodeConstructor(this, { numberOfInputs });\n        }\n        createChannelSplitter(numberOfOutputs = 6) {\n            return new channelSplitterNodeConstructor(this, { numberOfOutputs });\n        }\n        createConstantSource() {\n            return new constantSourceNodeConstructor(this);\n        }\n        createConvolver() {\n            return new convolverNodeConstructor(this);\n        }\n        createDelay(maxDelayTime = 1) {\n            return new delayNodeConstructor(this, { maxDelayTime });\n        }\n        createDynamicsCompressor() {\n            return new dynamicsCompressorNodeConstructor(this);\n        }\n        createGain() {\n            return new gainNodeConstructor(this);\n        }\n        createIIRFilter(feedforward, feedback) {\n            return new iIRFilterNodeConstructor(this, { feedback, feedforward });\n        }\n        createOscillator() {\n            return new oscillatorNodeConstructor(this);\n        }\n        createPanner() {\n            return new pannerNodeConstructor(this);\n        }\n        createPeriodicWave(real, imag, constraints = { disableNormalization: false }) {\n            return new periodicWaveConstructor(this, { ...constraints, imag, real });\n        }\n        createStereoPanner() {\n            return new stereoPannerNodeConstructor(this);\n        }\n        createWaveShaper() {\n            return new waveShaperNodeConstructor(this);\n        }\n        decodeAudioData(audioData, successCallback, errorCallback) {\n            return decodeAudioData(this._nativeContext, audioData).then((audioBuffer) => {\n                if (typeof successCallback === 'function') {\n                    successCallback(audioBuffer);\n                }\n                return audioBuffer;\n            }, (err) => {\n                if (typeof errorCallback === 'function') {\n                    errorCallback(err);\n                }\n                throw err;\n            });\n        }\n    };\n};\n//# sourceMappingURL=base-audio-context-constructor.js.map","export const createMediaElementAudioSourceNodeConstructor = (audioNodeConstructor, createNativeMediaElementAudioSourceNode, getNativeContext, isNativeOfflineAudioContext) => {\n    return class MediaElementAudioSourceNode extends audioNodeConstructor {\n        constructor(context, options) {\n            const nativeContext = getNativeContext(context);\n            const nativeMediaElementAudioSourceNode = createNativeMediaElementAudioSourceNode(nativeContext, options);\n            // Bug #171: Safari allows to create a MediaElementAudioSourceNode with an OfflineAudioContext.\n            if (isNativeOfflineAudioContext(nativeContext)) {\n                throw TypeError();\n            }\n            super(context, true, nativeMediaElementAudioSourceNode, null);\n            this._nativeMediaElementAudioSourceNode = nativeMediaElementAudioSourceNode;\n        }\n        get mediaElement() {\n            return this._nativeMediaElementAudioSourceNode.mediaElement;\n        }\n    };\n};\n//# sourceMappingURL=media-element-audio-source-node-constructor.js.map","export const createNativeMediaElementAudioSourceNode = (nativeAudioContext, options) => {\n    return nativeAudioContext.createMediaElementSource(options.mediaElement);\n};\n//# sourceMappingURL=native-media-element-audio-source-node.js.map","import { assignNativeAudioNodeOptions } from '../helpers/assign-native-audio-node-options';\nexport const createNativeMediaStreamAudioDestinationNode = (nativeAudioContext, options) => {\n    const nativeMediaStreamAudioDestinationNode = nativeAudioContext.createMediaStreamDestination();\n    assignNativeAudioNodeOptions(nativeMediaStreamAudioDestinationNode, options);\n    // Bug #174: Safari does expose a wrong numberOfOutputs.\n    if (nativeMediaStreamAudioDestinationNode.numberOfOutputs === 1) {\n        Object.defineProperty(nativeMediaStreamAudioDestinationNode, 'numberOfOutputs', { get: () => 0 });\n    }\n    return nativeMediaStreamAudioDestinationNode;\n};\n//# sourceMappingURL=native-media-stream-audio-destination-node.js.map","export const createMediaStreamAudioSourceNodeConstructor = (audioNodeConstructor, createNativeMediaStreamAudioSourceNode, getNativeContext, isNativeOfflineAudioContext) => {\n    return class MediaStreamAudioSourceNode extends audioNodeConstructor {\n        constructor(context, options) {\n            const nativeContext = getNativeContext(context);\n            const nativeMediaStreamAudioSourceNode = createNativeMediaStreamAudioSourceNode(nativeContext, options);\n            // Bug #172: Safari allows to create a MediaStreamAudioSourceNode with an OfflineAudioContext.\n            if (isNativeOfflineAudioContext(nativeContext)) {\n                throw new TypeError();\n            }\n            super(context, true, nativeMediaStreamAudioSourceNode, null);\n            this._nativeMediaStreamAudioSourceNode = nativeMediaStreamAudioSourceNode;\n        }\n        get mediaStream() {\n            return this._nativeMediaStreamAudioSourceNode.mediaStream;\n        }\n    };\n};\n//# sourceMappingURL=media-stream-audio-source-node-constructor.js.map","export const createNativeMediaStreamAudioSourceNode = (nativeAudioContext, { mediaStream }) => {\n    const audioStreamTracks = mediaStream.getAudioTracks();\n    /*\n     * Bug #151: Safari does not use the audio track as input anymore if it gets removed from the mediaStream after construction.\n     * Bug #159: Safari picks the first audio track if the MediaStream has more than one audio track.\n     */\n    audioStreamTracks.sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));\n    const filteredAudioStreamTracks = audioStreamTracks.slice(0, 1);\n    const nativeMediaStreamAudioSourceNode = nativeAudioContext.createMediaStreamSource(new MediaStream(filteredAudioStreamTracks));\n    /*\n     * Bug #151 & #159: The given mediaStream gets reconstructed before it gets passed to the native node which is why the accessor needs\n     * to be overwritten as it would otherwise expose the reconstructed version.\n     */\n    Object.defineProperty(nativeMediaStreamAudioSourceNode, 'mediaStream', { value: mediaStream });\n    return nativeMediaStreamAudioSourceNode;\n};\n//# sourceMappingURL=native-media-stream-audio-source-node.js.map","export const createNativeMediaStreamTrackAudioSourceNodeFactory = (createInvalidStateError, isNativeOfflineAudioContext) => {\n    return (nativeAudioContext, { mediaStreamTrack }) => {\n        // Bug #121: Only Firefox does yet support the MediaStreamTrackAudioSourceNode.\n        if (typeof nativeAudioContext.createMediaStreamTrackSource === 'function') {\n            return nativeAudioContext.createMediaStreamTrackSource(mediaStreamTrack);\n        }\n        const mediaStream = new MediaStream([mediaStreamTrack]);\n        const nativeMediaStreamAudioSourceNode = nativeAudioContext.createMediaStreamSource(mediaStream);\n        // Bug #120: Firefox does not throw an error if the mediaStream has no audio track.\n        if (mediaStreamTrack.kind !== 'audio') {\n            throw createInvalidStateError();\n        }\n        // Bug #172: Safari allows to create a MediaStreamAudioSourceNode with an OfflineAudioContext.\n        if (isNativeOfflineAudioContext(nativeAudioContext)) {\n            throw new TypeError();\n        }\n        return nativeMediaStreamAudioSourceNode;\n    };\n};\n//# sourceMappingURL=native-media-stream-track-audio-source-node-factory.js.map","export const createMediaStreamTrackAudioSourceNodeConstructor = (audioNodeConstructor, createNativeMediaStreamTrackAudioSourceNode, getNativeContext) => {\n    return class MediaStreamTrackAudioSourceNode extends audioNodeConstructor {\n        constructor(context, options) {\n            const nativeContext = getNativeContext(context);\n            const nativeMediaStreamTrackAudioSourceNode = createNativeMediaStreamTrackAudioSourceNode(nativeContext, options);\n            super(context, true, nativeMediaStreamTrackAudioSourceNode, null);\n        }\n    };\n};\n//# sourceMappingURL=media-stream-track-audio-source-node-constructor.js.map","import { deactivateAudioGraph } from '../helpers/deactivate-audio-graph';\nimport { isValidLatencyHint } from '../helpers/is-valid-latency-hint';\nexport const createAudioContextConstructor = (baseAudioContextConstructor, createInvalidStateError, createNotSupportedError, createUnknownError, mediaElementAudioSourceNodeConstructor, mediaStreamAudioDestinationNodeConstructor, mediaStreamAudioSourceNodeConstructor, mediaStreamTrackAudioSourceNodeConstructor, nativeAudioContextConstructor) => {\n    return class AudioContext extends baseAudioContextConstructor {\n        constructor(options = {}) {\n            if (nativeAudioContextConstructor === null) {\n                throw new Error('Missing the native AudioContext constructor.');\n            }\n            let nativeAudioContext;\n            try {\n                nativeAudioContext = new nativeAudioContextConstructor(options);\n            }\n            catch (err) {\n                // Bug #192 Safari does throw a SyntaxError if the sampleRate is not supported.\n                if (err.code === 12 && err.message === 'sampleRate is not in range') {\n                    throw createNotSupportedError();\n                }\n                throw err;\n            }\n            // Bug #131 Safari returns null when there are four other AudioContexts running already.\n            if (nativeAudioContext === null) {\n                throw createUnknownError();\n            }\n            // Bug #51 Only Chrome, Edge and Opera throw an error if the given latencyHint is invalid.\n            if (!isValidLatencyHint(options.latencyHint)) {\n                throw new TypeError(`The provided value '${options.latencyHint}' is not a valid enum value of type AudioContextLatencyCategory.`);\n            }\n            // Bug #150 Safari does not support setting the sampleRate.\n            if (options.sampleRate !== undefined && nativeAudioContext.sampleRate !== options.sampleRate) {\n                throw createNotSupportedError();\n            }\n            super(nativeAudioContext, 2);\n            const { latencyHint } = options;\n            const { sampleRate } = nativeAudioContext;\n            // @todo The values for 'balanced', 'interactive' and 'playback' are just copied from Chrome's implementation.\n            this._baseLatency =\n                typeof nativeAudioContext.baseLatency === 'number'\n                    ? nativeAudioContext.baseLatency\n                    : latencyHint === 'balanced'\n                        ? 512 / sampleRate\n                        : latencyHint === 'interactive' || latencyHint === undefined\n                            ? 256 / sampleRate\n                            : latencyHint === 'playback'\n                                ? 1024 / sampleRate\n                                : /*\n                                   * @todo The min (256) and max (16384) values are taken from the allowed bufferSize values of a\n                                   * ScriptProcessorNode.\n                                   */\n                                    (Math.max(2, Math.min(128, Math.round((latencyHint * sampleRate) / 128))) * 128) / sampleRate;\n            this._nativeAudioContext = nativeAudioContext;\n            // Bug #188: Safari will set the context's state to 'interrupted' in case the user switches tabs.\n            if (nativeAudioContextConstructor.name === 'webkitAudioContext') {\n                this._nativeGainNode = nativeAudioContext.createGain();\n                this._nativeOscillatorNode = nativeAudioContext.createOscillator();\n                this._nativeGainNode.gain.value = 1e-37;\n                this._nativeOscillatorNode.connect(this._nativeGainNode).connect(nativeAudioContext.destination);\n                this._nativeOscillatorNode.start();\n            }\n            else {\n                this._nativeGainNode = null;\n                this._nativeOscillatorNode = null;\n            }\n            this._state = null;\n            /*\n             * Bug #34: Chrome, Edge and Opera pretend to be running right away, but fire an onstatechange event when the state actually\n             * changes to 'running'.\n             */\n            if (nativeAudioContext.state === 'running') {\n                this._state = 'suspended';\n                const revokeState = () => {\n                    if (this._state === 'suspended') {\n                        this._state = null;\n                    }\n                    nativeAudioContext.removeEventListener('statechange', revokeState);\n                };\n                nativeAudioContext.addEventListener('statechange', revokeState);\n            }\n        }\n        get baseLatency() {\n            return this._baseLatency;\n        }\n        get state() {\n            return this._state !== null ? this._state : this._nativeAudioContext.state;\n        }\n        close() {\n            // Bug #35: Firefox does not throw an error if the AudioContext was closed before.\n            if (this.state === 'closed') {\n                return this._nativeAudioContext.close().then(() => {\n                    throw createInvalidStateError();\n                });\n            }\n            // Bug #34: If the state was set to suspended before it should be revoked now.\n            if (this._state === 'suspended') {\n                this._state = null;\n            }\n            return this._nativeAudioContext.close().then(() => {\n                if (this._nativeGainNode !== null && this._nativeOscillatorNode !== null) {\n                    this._nativeOscillatorNode.stop();\n                    this._nativeGainNode.disconnect();\n                    this._nativeOscillatorNode.disconnect();\n                }\n                deactivateAudioGraph(this);\n            });\n        }\n        createMediaElementSource(mediaElement) {\n            return new mediaElementAudioSourceNodeConstructor(this, { mediaElement });\n        }\n        createMediaStreamDestination() {\n            return new mediaStreamAudioDestinationNodeConstructor(this);\n        }\n        createMediaStreamSource(mediaStream) {\n            return new mediaStreamAudioSourceNodeConstructor(this, { mediaStream });\n        }\n        createMediaStreamTrackSource(mediaStreamTrack) {\n            return new mediaStreamTrackAudioSourceNodeConstructor(this, { mediaStreamTrack });\n        }\n        resume() {\n            if (this._state === 'suspended') {\n                return new Promise((resolve, reject) => {\n                    const resolvePromise = () => {\n                        this._nativeAudioContext.removeEventListener('statechange', resolvePromise);\n                        if (this._nativeAudioContext.state === 'running') {\n                            resolve();\n                        }\n                        else {\n                            this.resume().then(resolve, reject);\n                        }\n                    };\n                    this._nativeAudioContext.addEventListener('statechange', resolvePromise);\n                });\n            }\n            return this._nativeAudioContext.resume().catch((err) => {\n                // Bug #55: Chrome, Edge and Opera do throw an InvalidAccessError instead of an InvalidStateError.\n                // Bug #56: Safari invokes the catch handler but without an error.\n                if (err === undefined || err.code === 15) {\n                    throw createInvalidStateError();\n                }\n                throw err;\n            });\n        }\n        suspend() {\n            return this._nativeAudioContext.suspend().catch((err) => {\n                // Bug #56: Safari invokes the catch handler but without an error.\n                if (err === undefined) {\n                    throw createInvalidStateError();\n                }\n                throw err;\n            });\n        }\n    };\n};\n//# sourceMappingURL=audio-context-constructor.js.map","export const isValidLatencyHint = (latencyHint) => {\n    return (latencyHint === undefined ||\n        typeof latencyHint === 'number' ||\n        (typeof latencyHint === 'string' && (latencyHint === 'balanced' || latencyHint === 'interactive' || latencyHint === 'playback')));\n};\n//# sourceMappingURL=is-valid-latency-hint.js.map","export const createGetUnrenderedAudioWorkletNodes = (unrenderedAudioWorkletNodeStore) => {\n    return (nativeContext) => {\n        const unrenderedAudioWorkletNodes = unrenderedAudioWorkletNodeStore.get(nativeContext);\n        if (unrenderedAudioWorkletNodes === undefined) {\n            throw new Error('The context has no set of AudioWorkletNodes.');\n        }\n        return unrenderedAudioWorkletNodes;\n    };\n};\n//# sourceMappingURL=get-unrendered-audio-worklet-nodes.js.map","export const createAddUnrenderedAudioWorkletNode = (getUnrenderedAudioWorkletNodes) => {\n    return (nativeContext, audioWorkletNode) => {\n        getUnrenderedAudioWorkletNodes(nativeContext).add(audioWorkletNode);\n    };\n};\n//# sourceMappingURL=add-unrendered-audio-worklet-node.js.map","import { isNativeAudioNode } from '../guards/native-audio-node';\nexport const createConnectMultipleOutputs = (createIndexSizeError) => {\n    return (outputAudioNodes, destination, output = 0, input = 0) => {\n        const outputAudioNode = outputAudioNodes[output];\n        if (outputAudioNode === undefined) {\n            throw createIndexSizeError();\n        }\n        if (isNativeAudioNode(destination)) {\n            return outputAudioNode.connect(destination, 0, input);\n        }\n        return outputAudioNode.connect(destination, 0);\n    };\n};\n//# sourceMappingURL=connect-multiple-outputs.js.map","export const createDeleteUnrenderedAudioWorkletNode = (getUnrenderedAudioWorkletNodes) => {\n    return (nativeContext, audioWorkletNode) => {\n        getUnrenderedAudioWorkletNodes(nativeContext).delete(audioWorkletNode);\n    };\n};\n//# sourceMappingURL=delete-unrendered-audio-worklet-node.js.map","export const createGetActiveAudioWorkletNodeInputs = (activeAudioWorkletNodeInputsStore, getValueForKey) => {\n    return (nativeAudioWorkletNode) => getValueForKey(activeAudioWorkletNodeInputsStore, nativeAudioWorkletNode);\n};\n//# sourceMappingURL=get-active-audio-worklet-node-inputs.js.map","import { MOST_NEGATIVE_SINGLE_FLOAT, MOST_POSITIVE_SINGLE_FLOAT } from '../constants';\nimport { computeBufferSize } from '../helpers/compute-buffer-size';\nimport { copyFromChannel } from '../helpers/copy-from-channel';\nimport { copyToChannel } from '../helpers/copy-to-channel';\nimport { createAudioWorkletProcessor } from '../helpers/create-audio-worklet-processor';\nimport { createNestedArrays } from '../helpers/create-nested-arrays';\nimport { ReadOnlyMap } from '../read-only-map';\nexport const createNativeAudioWorkletNodeFakerFactory = (connectMultipleOutputs, createIndexSizeError, createInvalidStateError, createNativeChannelMergerNode, createNativeChannelSplitterNode, createNativeConstantSourceNode, createNativeGainNode, createNativeScriptProcessorNode, createNotSupportedError, disconnectMultipleOutputs, exposeCurrentFrameAndCurrentTime, getActiveAudioWorkletNodeInputs, monitorConnections) => {\n    return (nativeContext, baseLatency, processorConstructor, options) => {\n        if (options.numberOfInputs === 0 && options.numberOfOutputs === 0) {\n            throw createNotSupportedError();\n        }\n        const outputChannelCount = Array.isArray(options.outputChannelCount)\n            ? options.outputChannelCount\n            : Array.from(options.outputChannelCount);\n        // @todo Check if any of the channelCount values is greater than the implementation's maximum number of channels.\n        if (outputChannelCount.some((channelCount) => channelCount < 1)) {\n            throw createNotSupportedError();\n        }\n        if (outputChannelCount.length !== options.numberOfOutputs) {\n            throw createIndexSizeError();\n        }\n        // Bug #61: This is not part of the standard but required for the faker to work.\n        if (options.channelCountMode !== 'explicit') {\n            throw createNotSupportedError();\n        }\n        const numberOfInputChannels = options.channelCount * options.numberOfInputs;\n        const numberOfOutputChannels = outputChannelCount.reduce((sum, value) => sum + value, 0);\n        const numberOfParameters = processorConstructor.parameterDescriptors === undefined ? 0 : processorConstructor.parameterDescriptors.length;\n        // Bug #61: This is not part of the standard but required for the faker to work.\n        if (numberOfInputChannels + numberOfParameters > 6 || numberOfOutputChannels > 6) {\n            throw createNotSupportedError();\n        }\n        const messageChannel = new MessageChannel();\n        const gainNodes = [];\n        const inputChannelSplitterNodes = [];\n        for (let i = 0; i < options.numberOfInputs; i += 1) {\n            gainNodes.push(createNativeGainNode(nativeContext, {\n                channelCount: options.channelCount,\n                channelCountMode: options.channelCountMode,\n                channelInterpretation: options.channelInterpretation,\n                gain: 1\n            }));\n            inputChannelSplitterNodes.push(createNativeChannelSplitterNode(nativeContext, {\n                channelCount: options.channelCount,\n                channelCountMode: 'explicit',\n                channelInterpretation: 'discrete',\n                numberOfOutputs: options.channelCount\n            }));\n        }\n        const constantSourceNodes = [];\n        if (processorConstructor.parameterDescriptors !== undefined) {\n            for (const { defaultValue, maxValue, minValue, name } of processorConstructor.parameterDescriptors) {\n                const constantSourceNode = createNativeConstantSourceNode(nativeContext, {\n                    channelCount: 1,\n                    channelCountMode: 'explicit',\n                    channelInterpretation: 'discrete',\n                    offset: options.parameterData[name] !== undefined\n                        ? options.parameterData[name]\n                        : defaultValue === undefined\n                            ? 0\n                            : defaultValue\n                });\n                Object.defineProperties(constantSourceNode.offset, {\n                    defaultValue: {\n                        get: () => (defaultValue === undefined ? 0 : defaultValue)\n                    },\n                    maxValue: {\n                        get: () => (maxValue === undefined ? MOST_POSITIVE_SINGLE_FLOAT : maxValue)\n                    },\n                    minValue: {\n                        get: () => (minValue === undefined ? MOST_NEGATIVE_SINGLE_FLOAT : minValue)\n                    }\n                });\n                constantSourceNodes.push(constantSourceNode);\n            }\n        }\n        const inputChannelMergerNode = createNativeChannelMergerNode(nativeContext, {\n            channelCount: 1,\n            channelCountMode: 'explicit',\n            channelInterpretation: 'speakers',\n            numberOfInputs: Math.max(1, numberOfInputChannels + numberOfParameters)\n        });\n        const bufferSize = computeBufferSize(baseLatency, nativeContext.sampleRate);\n        const scriptProcessorNode = createNativeScriptProcessorNode(nativeContext, bufferSize, numberOfInputChannels + numberOfParameters, \n        // Bug #87: Only Firefox will fire an AudioProcessingEvent if there is no connected output.\n        Math.max(1, numberOfOutputChannels));\n        const outputChannelSplitterNode = createNativeChannelSplitterNode(nativeContext, {\n            channelCount: Math.max(1, numberOfOutputChannels),\n            channelCountMode: 'explicit',\n            channelInterpretation: 'discrete',\n            numberOfOutputs: Math.max(1, numberOfOutputChannels)\n        });\n        const outputChannelMergerNodes = [];\n        for (let i = 0; i < options.numberOfOutputs; i += 1) {\n            outputChannelMergerNodes.push(createNativeChannelMergerNode(nativeContext, {\n                channelCount: 1,\n                channelCountMode: 'explicit',\n                channelInterpretation: 'speakers',\n                numberOfInputs: outputChannelCount[i]\n            }));\n        }\n        for (let i = 0; i < options.numberOfInputs; i += 1) {\n            gainNodes[i].connect(inputChannelSplitterNodes[i]);\n            for (let j = 0; j < options.channelCount; j += 1) {\n                inputChannelSplitterNodes[i].connect(inputChannelMergerNode, j, i * options.channelCount + j);\n            }\n        }\n        const parameterMap = new ReadOnlyMap(processorConstructor.parameterDescriptors === undefined\n            ? []\n            : processorConstructor.parameterDescriptors.map(({ name }, index) => {\n                const constantSourceNode = constantSourceNodes[index];\n                constantSourceNode.connect(inputChannelMergerNode, 0, numberOfInputChannels + index);\n                constantSourceNode.start(0);\n                return [name, constantSourceNode.offset];\n            }));\n        inputChannelMergerNode.connect(scriptProcessorNode);\n        let channelInterpretation = options.channelInterpretation;\n        let onprocessorerror = null;\n        // Bug #87: Expose at least one output to make this node connectable.\n        const outputAudioNodes = options.numberOfOutputs === 0 ? [scriptProcessorNode] : outputChannelMergerNodes;\n        const nativeAudioWorkletNodeFaker = {\n            get bufferSize() {\n                return bufferSize;\n            },\n            get channelCount() {\n                return options.channelCount;\n            },\n            set channelCount(_) {\n                // Bug #61: This is not part of the standard but required for the faker to work.\n                throw createInvalidStateError();\n            },\n            get channelCountMode() {\n                return options.channelCountMode;\n            },\n            set channelCountMode(_) {\n                // Bug #61: This is not part of the standard but required for the faker to work.\n                throw createInvalidStateError();\n            },\n            get channelInterpretation() {\n                return channelInterpretation;\n            },\n            set channelInterpretation(value) {\n                for (const gainNode of gainNodes) {\n                    gainNode.channelInterpretation = value;\n                }\n                channelInterpretation = value;\n            },\n            get context() {\n                return scriptProcessorNode.context;\n            },\n            get inputs() {\n                return gainNodes;\n            },\n            get numberOfInputs() {\n                return options.numberOfInputs;\n            },\n            get numberOfOutputs() {\n                return options.numberOfOutputs;\n            },\n            get onprocessorerror() {\n                return onprocessorerror;\n            },\n            set onprocessorerror(value) {\n                if (typeof onprocessorerror === 'function') {\n                    nativeAudioWorkletNodeFaker.removeEventListener('processorerror', onprocessorerror);\n                }\n                onprocessorerror = typeof value === 'function' ? value : null;\n                if (typeof onprocessorerror === 'function') {\n                    nativeAudioWorkletNodeFaker.addEventListener('processorerror', onprocessorerror);\n                }\n            },\n            get parameters() {\n                return parameterMap;\n            },\n            get port() {\n                return messageChannel.port2;\n            },\n            addEventListener(...args) {\n                return scriptProcessorNode.addEventListener(args[0], args[1], args[2]);\n            },\n            connect: connectMultipleOutputs.bind(null, outputAudioNodes),\n            disconnect: disconnectMultipleOutputs.bind(null, outputAudioNodes),\n            dispatchEvent(...args) {\n                return scriptProcessorNode.dispatchEvent(args[0]);\n            },\n            removeEventListener(...args) {\n                return scriptProcessorNode.removeEventListener(args[0], args[1], args[2]);\n            }\n        };\n        const patchedEventListeners = new Map();\n        messageChannel.port1.addEventListener = ((addEventListener) => {\n            return (...args) => {\n                if (args[0] === 'message') {\n                    const unpatchedEventListener = typeof args[1] === 'function'\n                        ? args[1]\n                        : typeof args[1] === 'object' && args[1] !== null && typeof args[1].handleEvent === 'function'\n                            ? args[1].handleEvent\n                            : null;\n                    if (unpatchedEventListener !== null) {\n                        const patchedEventListener = patchedEventListeners.get(args[1]);\n                        if (patchedEventListener !== undefined) {\n                            args[1] = patchedEventListener;\n                        }\n                        else {\n                            args[1] = (event) => {\n                                exposeCurrentFrameAndCurrentTime(nativeContext.currentTime, nativeContext.sampleRate, () => unpatchedEventListener(event));\n                            };\n                            patchedEventListeners.set(unpatchedEventListener, args[1]);\n                        }\n                    }\n                }\n                return addEventListener.call(messageChannel.port1, args[0], args[1], args[2]);\n            };\n        })(messageChannel.port1.addEventListener);\n        messageChannel.port1.removeEventListener = ((removeEventListener) => {\n            return (...args) => {\n                if (args[0] === 'message') {\n                    const patchedEventListener = patchedEventListeners.get(args[1]);\n                    if (patchedEventListener !== undefined) {\n                        patchedEventListeners.delete(args[1]);\n                        args[1] = patchedEventListener;\n                    }\n                }\n                return removeEventListener.call(messageChannel.port1, args[0], args[1], args[2]);\n            };\n        })(messageChannel.port1.removeEventListener);\n        let onmessage = null;\n        Object.defineProperty(messageChannel.port1, 'onmessage', {\n            get: () => onmessage,\n            set: (value) => {\n                if (typeof onmessage === 'function') {\n                    messageChannel.port1.removeEventListener('message', onmessage);\n                }\n                onmessage = typeof value === 'function' ? value : null;\n                if (typeof onmessage === 'function') {\n                    messageChannel.port1.addEventListener('message', onmessage);\n                    messageChannel.port1.start();\n                }\n            }\n        });\n        processorConstructor.prototype.port = messageChannel.port1;\n        let audioWorkletProcessor = null;\n        const audioWorkletProcessorPromise = createAudioWorkletProcessor(nativeContext, nativeAudioWorkletNodeFaker, processorConstructor, options);\n        audioWorkletProcessorPromise.then((dWrkltPrcssr) => (audioWorkletProcessor = dWrkltPrcssr));\n        const inputs = createNestedArrays(options.numberOfInputs, options.channelCount);\n        const outputs = createNestedArrays(options.numberOfOutputs, outputChannelCount);\n        const parameters = processorConstructor.parameterDescriptors === undefined\n            ? []\n            : processorConstructor.parameterDescriptors.reduce((prmtrs, { name }) => ({ ...prmtrs, [name]: new Float32Array(128) }), {});\n        let isActive = true;\n        const disconnectOutputsGraph = () => {\n            if (options.numberOfOutputs > 0) {\n                scriptProcessorNode.disconnect(outputChannelSplitterNode);\n            }\n            for (let i = 0, outputChannelSplitterNodeOutput = 0; i < options.numberOfOutputs; i += 1) {\n                const outputChannelMergerNode = outputChannelMergerNodes[i];\n                for (let j = 0; j < outputChannelCount[i]; j += 1) {\n                    outputChannelSplitterNode.disconnect(outputChannelMergerNode, outputChannelSplitterNodeOutput + j, j);\n                }\n                outputChannelSplitterNodeOutput += outputChannelCount[i];\n            }\n        };\n        const activeInputIndexes = new Map();\n        // tslint:disable-next-line:deprecation\n        scriptProcessorNode.onaudioprocess = ({ inputBuffer, outputBuffer }) => {\n            if (audioWorkletProcessor !== null) {\n                const activeInputs = getActiveAudioWorkletNodeInputs(nativeAudioWorkletNodeFaker);\n                for (let i = 0; i < bufferSize; i += 128) {\n                    for (let j = 0; j < options.numberOfInputs; j += 1) {\n                        for (let k = 0; k < options.channelCount; k += 1) {\n                            copyFromChannel(inputBuffer, inputs[j], k, k, i);\n                        }\n                    }\n                    if (processorConstructor.parameterDescriptors !== undefined) {\n                        processorConstructor.parameterDescriptors.forEach(({ name }, index) => {\n                            copyFromChannel(inputBuffer, parameters, name, numberOfInputChannels + index, i);\n                        });\n                    }\n                    for (let j = 0; j < options.numberOfInputs; j += 1) {\n                        for (let k = 0; k < outputChannelCount[j]; k += 1) {\n                            // The byteLength will be 0 when the ArrayBuffer was transferred.\n                            if (outputs[j][k].byteLength === 0) {\n                                outputs[j][k] = new Float32Array(128);\n                            }\n                        }\n                    }\n                    try {\n                        const potentiallyEmptyInputs = inputs.map((input, index) => {\n                            const activeInput = activeInputs[index];\n                            if (activeInput.size > 0) {\n                                activeInputIndexes.set(index, bufferSize / 128);\n                                return input;\n                            }\n                            const count = activeInputIndexes.get(index);\n                            if (count === undefined) {\n                                return [];\n                            }\n                            if (input.every((channelData) => channelData.every((sample) => sample === 0))) {\n                                if (count === 1) {\n                                    activeInputIndexes.delete(index);\n                                }\n                                else {\n                                    activeInputIndexes.set(index, count - 1);\n                                }\n                            }\n                            return input;\n                        });\n                        const activeSourceFlag = exposeCurrentFrameAndCurrentTime(nativeContext.currentTime + i / nativeContext.sampleRate, nativeContext.sampleRate, () => audioWorkletProcessor.process(potentiallyEmptyInputs, outputs, parameters));\n                        isActive = activeSourceFlag;\n                        for (let j = 0, outputChannelSplitterNodeOutput = 0; j < options.numberOfOutputs; j += 1) {\n                            for (let k = 0; k < outputChannelCount[j]; k += 1) {\n                                copyToChannel(outputBuffer, outputs[j], k, outputChannelSplitterNodeOutput + k, i);\n                            }\n                            outputChannelSplitterNodeOutput += outputChannelCount[j];\n                        }\n                    }\n                    catch (error) {\n                        isActive = false;\n                        nativeAudioWorkletNodeFaker.dispatchEvent(new ErrorEvent('processorerror', {\n                            colno: error.colno,\n                            filename: error.filename,\n                            lineno: error.lineno,\n                            message: error.message\n                        }));\n                    }\n                    if (!isActive) {\n                        for (let j = 0; j < options.numberOfInputs; j += 1) {\n                            gainNodes[j].disconnect(inputChannelSplitterNodes[j]);\n                            for (let k = 0; k < options.channelCount; k += 1) {\n                                inputChannelSplitterNodes[i].disconnect(inputChannelMergerNode, k, j * options.channelCount + k);\n                            }\n                        }\n                        if (processorConstructor.parameterDescriptors !== undefined) {\n                            const length = processorConstructor.parameterDescriptors.length;\n                            for (let j = 0; j < length; j += 1) {\n                                const constantSourceNode = constantSourceNodes[j];\n                                constantSourceNode.disconnect(inputChannelMergerNode, 0, numberOfInputChannels + j);\n                                constantSourceNode.stop();\n                            }\n                        }\n                        inputChannelMergerNode.disconnect(scriptProcessorNode);\n                        scriptProcessorNode.onaudioprocess = null; // tslint:disable-line:deprecation\n                        if (isConnected) {\n                            disconnectOutputsGraph();\n                        }\n                        else {\n                            disconnectFakeGraph();\n                        }\n                        break;\n                    }\n                }\n            }\n        };\n        let isConnected = false;\n        // Bug #87: Only Firefox will fire an AudioProcessingEvent if there is no connected output.\n        const nativeGainNode = createNativeGainNode(nativeContext, {\n            channelCount: 1,\n            channelCountMode: 'explicit',\n            channelInterpretation: 'discrete',\n            gain: 0\n        });\n        const connectFakeGraph = () => scriptProcessorNode.connect(nativeGainNode).connect(nativeContext.destination);\n        const disconnectFakeGraph = () => {\n            scriptProcessorNode.disconnect(nativeGainNode);\n            nativeGainNode.disconnect();\n        };\n        const whenConnected = () => {\n            if (isActive) {\n                disconnectFakeGraph();\n                if (options.numberOfOutputs > 0) {\n                    scriptProcessorNode.connect(outputChannelSplitterNode);\n                }\n                for (let i = 0, outputChannelSplitterNodeOutput = 0; i < options.numberOfOutputs; i += 1) {\n                    const outputChannelMergerNode = outputChannelMergerNodes[i];\n                    for (let j = 0; j < outputChannelCount[i]; j += 1) {\n                        outputChannelSplitterNode.connect(outputChannelMergerNode, outputChannelSplitterNodeOutput + j, j);\n                    }\n                    outputChannelSplitterNodeOutput += outputChannelCount[i];\n                }\n            }\n            isConnected = true;\n        };\n        const whenDisconnected = () => {\n            if (isActive) {\n                connectFakeGraph();\n                disconnectOutputsGraph();\n            }\n            isConnected = false;\n        };\n        connectFakeGraph();\n        return monitorConnections(nativeAudioWorkletNodeFaker, whenConnected, whenDisconnected);\n    };\n};\n//# sourceMappingURL=native-audio-worklet-node-faker-factory.js.map","import { NODE_TO_PROCESSOR_MAPS } from '../globals';\nimport { createAudioWorkletProcessorPromise } from './create-audio-worklet-processor-promise';\nexport const createAudioWorkletProcessor = (nativeContext, nativeAudioWorkletNode, processorConstructor, audioWorkletNodeOptions) => {\n    let nodeToProcessorMap = NODE_TO_PROCESSOR_MAPS.get(nativeContext);\n    if (nodeToProcessorMap === undefined) {\n        nodeToProcessorMap = new WeakMap();\n        NODE_TO_PROCESSOR_MAPS.set(nativeContext, nodeToProcessorMap);\n    }\n    const audioWorkletProcessorPromise = createAudioWorkletProcessorPromise(processorConstructor, audioWorkletNodeOptions);\n    nodeToProcessorMap.set(nativeAudioWorkletNode, audioWorkletProcessorPromise);\n    return audioWorkletProcessorPromise;\n};\n//# sourceMappingURL=create-audio-worklet-processor.js.map","import { cloneAudioWorkletNodeOptions } from './clone-audio-worklet-node-options';\nexport const createAudioWorkletProcessorPromise = async (processorConstructor, audioWorkletNodeOptions) => {\n    const clonedAudioWorkletNodeOptions = await cloneAudioWorkletNodeOptions(audioWorkletNodeOptions);\n    return new processorConstructor(clonedAudioWorkletNodeOptions);\n};\n//# sourceMappingURL=create-audio-worklet-processor-promise.js.map","export const cloneAudioWorkletNodeOptions = (audioWorkletNodeOptions) => {\n    return new Promise((resolve, reject) => {\n        const { port1, port2 } = new MessageChannel();\n        port1.onmessage = ({ data }) => {\n            port1.close();\n            port2.close();\n            resolve(data);\n        };\n        port1.onmessageerror = ({ data }) => {\n            port1.close();\n            port2.close();\n            reject(data);\n        };\n        // This will throw an error if the audioWorkletNodeOptions are not clonable.\n        port2.postMessage(audioWorkletNodeOptions);\n    });\n};\n//# sourceMappingURL=clone-audio-worklet-node-options.js.map","import { testClonabilityOfAudioWorkletNodeOptions } from '../helpers/test-clonability-of-audio-worklet-node-options';\nexport const createNativeAudioWorkletNodeFactory = (createInvalidStateError, createNativeAudioWorkletNodeFaker, createNativeGainNode, createNotSupportedError, monitorConnections) => {\n    return (nativeContext, baseLatency, nativeAudioWorkletNodeConstructor, name, processorConstructor, options) => {\n        if (nativeAudioWorkletNodeConstructor !== null) {\n            try {\n                const nativeAudioWorkletNode = new nativeAudioWorkletNodeConstructor(nativeContext, name, options);\n                const patchedEventListeners = new Map();\n                let onprocessorerror = null;\n                Object.defineProperties(nativeAudioWorkletNode, {\n                    /*\n                     * Bug #61: Overwriting the property accessors for channelCount and channelCountMode is necessary as long as some\n                     * browsers have no native implementation to achieve a consistent behavior.\n                     */\n                    channelCount: {\n                        get: () => options.channelCount,\n                        set: () => {\n                            throw createInvalidStateError();\n                        }\n                    },\n                    channelCountMode: {\n                        get: () => 'explicit',\n                        set: () => {\n                            throw createInvalidStateError();\n                        }\n                    },\n                    // Bug #156: Chrome and Edge do not yet fire an ErrorEvent.\n                    onprocessorerror: {\n                        get: () => onprocessorerror,\n                        set: (value) => {\n                            if (typeof onprocessorerror === 'function') {\n                                nativeAudioWorkletNode.removeEventListener('processorerror', onprocessorerror);\n                            }\n                            onprocessorerror = typeof value === 'function' ? value : null;\n                            if (typeof onprocessorerror === 'function') {\n                                nativeAudioWorkletNode.addEventListener('processorerror', onprocessorerror);\n                            }\n                        }\n                    }\n                });\n                nativeAudioWorkletNode.addEventListener = ((addEventListener) => {\n                    return (...args) => {\n                        if (args[0] === 'processorerror') {\n                            const unpatchedEventListener = typeof args[1] === 'function'\n                                ? args[1]\n                                : typeof args[1] === 'object' && args[1] !== null && typeof args[1].handleEvent === 'function'\n                                    ? args[1].handleEvent\n                                    : null;\n                            if (unpatchedEventListener !== null) {\n                                const patchedEventListener = patchedEventListeners.get(args[1]);\n                                if (patchedEventListener !== undefined) {\n                                    args[1] = patchedEventListener;\n                                }\n                                else {\n                                    args[1] = (event) => {\n                                        // Bug #178: Chrome, Edge and Opera do fire an event of type error.\n                                        if (event.type === 'error') {\n                                            Object.defineProperties(event, {\n                                                type: { value: 'processorerror' }\n                                            });\n                                            unpatchedEventListener(event);\n                                        }\n                                        else {\n                                            unpatchedEventListener(new ErrorEvent(args[0], { ...event }));\n                                        }\n                                    };\n                                    patchedEventListeners.set(unpatchedEventListener, args[1]);\n                                }\n                            }\n                        }\n                        // Bug #178: Chrome, Edge and Opera do fire an event of type error.\n                        addEventListener.call(nativeAudioWorkletNode, 'error', args[1], args[2]);\n                        return addEventListener.call(nativeAudioWorkletNode, ...args);\n                    };\n                })(nativeAudioWorkletNode.addEventListener);\n                nativeAudioWorkletNode.removeEventListener = ((removeEventListener) => {\n                    return (...args) => {\n                        if (args[0] === 'processorerror') {\n                            const patchedEventListener = patchedEventListeners.get(args[1]);\n                            if (patchedEventListener !== undefined) {\n                                patchedEventListeners.delete(args[1]);\n                                args[1] = patchedEventListener;\n                            }\n                        }\n                        // Bug #178: Chrome, Edge and Opera do fire an event of type error.\n                        removeEventListener.call(nativeAudioWorkletNode, 'error', args[1], args[2]);\n                        return removeEventListener.call(nativeAudioWorkletNode, args[0], args[1], args[2]);\n                    };\n                })(nativeAudioWorkletNode.removeEventListener);\n                /*\n                 * Bug #86: Chrome and Edge do not invoke the process() function if the corresponding AudioWorkletNode is unconnected but\n                 * has an output.\n                 */\n                if (options.numberOfOutputs !== 0) {\n                    const nativeGainNode = createNativeGainNode(nativeContext, {\n                        channelCount: 1,\n                        channelCountMode: 'explicit',\n                        channelInterpretation: 'discrete',\n                        gain: 0\n                    });\n                    nativeAudioWorkletNode.connect(nativeGainNode).connect(nativeContext.destination);\n                    const whenConnected = () => nativeGainNode.disconnect();\n                    const whenDisconnected = () => nativeGainNode.connect(nativeContext.destination);\n                    // @todo Disconnect the connection when the process() function of the AudioWorkletNode returns false.\n                    return monitorConnections(nativeAudioWorkletNode, whenConnected, whenDisconnected);\n                }\n                return nativeAudioWorkletNode;\n            }\n            catch (err) {\n                // Bug #60: Chrome, Edge & Opera throw an InvalidStateError instead of a NotSupportedError.\n                if (err.code === 11) {\n                    throw createNotSupportedError();\n                }\n                throw err;\n            }\n        }\n        // Bug #61: Only Chrome & Opera have an implementation of the AudioWorkletNode yet.\n        if (processorConstructor === undefined) {\n            throw createNotSupportedError();\n        }\n        testClonabilityOfAudioWorkletNodeOptions(options);\n        return createNativeAudioWorkletNodeFaker(nativeContext, baseLatency, processorConstructor, options);\n    };\n};\n//# sourceMappingURL=native-audio-worklet-node-factory.js.map","export const testClonabilityOfAudioWorkletNodeOptions = (audioWorkletNodeOptions) => {\n    const { port1 } = new MessageChannel();\n    try {\n        // This will throw an error if the audioWorkletNodeOptions are not clonable.\n        port1.postMessage(audioWorkletNodeOptions);\n    }\n    finally {\n        port1.close();\n    }\n};\n//# sourceMappingURL=test-clonability-of-audio-worklet-node-options.js.map","export const createGetBackupOfflineAudioContext = (backupOfflineAudioContextStore) => {\n    return (nativeContext) => {\n        return backupOfflineAudioContextStore.get(nativeContext);\n    };\n};\n//# sourceMappingURL=get-backup-offline-audio-context.js.map","export const createSetActiveAudioWorkletNodeInputs = (activeAudioWorkletNodeInputsStore) => {\n    return (nativeAudioWorkletNode, activeInputs) => {\n        activeAudioWorkletNodeInputsStore.set(nativeAudioWorkletNode, activeInputs);\n    };\n};\n//# sourceMappingURL=set-active-audio-worklet-node-inputs.js.map","export const sanitizeAudioWorkletNodeOptions = (options) => {\n    return {\n        ...options,\n        outputChannelCount: options.outputChannelCount !== undefined\n            ? options.outputChannelCount\n            : options.numberOfInputs === 1 && options.numberOfOutputs === 1\n                ? /*\n                   * Bug #61: This should be the computedNumberOfChannels, but unfortunately that is almost impossible to fake. That's why\n                   * the channelCountMode is required to be 'explicit' as long as there is not a native implementation in every browser. That\n                   * makes sure the computedNumberOfChannels is equivilant to the channelCount which makes it much easier to compute.\n                   */\n                    [options.channelCount]\n                : Array.from({ length: options.numberOfOutputs }, () => 1)\n    };\n};\n//# sourceMappingURL=sanitize-audio-worklet-node-options.js.map","export const testAudioWorkletNodeOptionsClonability = (audioWorkletNodeOptions) => {\n    const { port1, port2 } = new MessageChannel();\n    try {\n        // This will throw an error if the audioWorkletNodeOptions are not clonable.\n        port1.postMessage(audioWorkletNodeOptions);\n    }\n    finally {\n        port1.close();\n        port2.close();\n    }\n};\n//# sourceMappingURL=test-audio-worklet-node-options-clonability.js.map","export const createCreateNativeOfflineAudioContext = (createNotSupportedError, nativeOfflineAudioContextConstructor) => {\n    return (numberOfChannels, length, sampleRate) => {\n        if (nativeOfflineAudioContextConstructor === null) {\n            throw new Error('Missing the native OfflineAudioContext constructor.');\n        }\n        try {\n            return new nativeOfflineAudioContextConstructor(numberOfChannels, length, sampleRate);\n        }\n        catch (err) {\n            // Bug #143, #144 & #146: Safari throws a SyntaxError when numberOfChannels, length or sampleRate are invalid.\n            if (err.name === 'SyntaxError') {\n                throw createNotSupportedError();\n            }\n            throw err;\n        }\n    };\n};\n//# sourceMappingURL=create-native-offline-audio-context.js.map","import { wrapAudioBufferGetChannelDataMethod } from '../helpers/wrap-audio-buffer-get-channel-data-method';\nexport const createStartRendering = (audioBufferStore, cacheTestResult, getAudioNodeRenderer, getUnrenderedAudioWorkletNodes, renderNativeOfflineAudioContext, testAudioBufferCopyChannelMethodsOutOfBoundsSupport, wrapAudioBufferCopyChannelMethods, wrapAudioBufferCopyChannelMethodsOutOfBounds) => {\n    const trace = [];\n    return (destination, nativeOfflineAudioContext) => getAudioNodeRenderer(destination)\n        .render(destination, nativeOfflineAudioContext, trace)\n        /*\n         * Bug #86 & #87: Invoking the renderer of an AudioWorkletNode might be necessary if it has no direct or indirect connection to the\n         * destination.\n         */\n        .then(() => Promise.all(Array.from(getUnrenderedAudioWorkletNodes(nativeOfflineAudioContext)).map((audioWorkletNode) => getAudioNodeRenderer(audioWorkletNode).render(audioWorkletNode, nativeOfflineAudioContext, trace))))\n        .then(() => renderNativeOfflineAudioContext(nativeOfflineAudioContext))\n        .then((audioBuffer) => {\n        // Bug #5: Safari does not support copyFromChannel() and copyToChannel().\n        // Bug #100: Safari does throw a wrong error when calling getChannelData() with an out-of-bounds value.\n        if (typeof audioBuffer.copyFromChannel !== 'function') {\n            wrapAudioBufferCopyChannelMethods(audioBuffer);\n            wrapAudioBufferGetChannelDataMethod(audioBuffer);\n            // Bug #157: Firefox does not allow the bufferOffset to be out-of-bounds.\n        }\n        else if (!cacheTestResult(testAudioBufferCopyChannelMethodsOutOfBoundsSupport, () => testAudioBufferCopyChannelMethodsOutOfBoundsSupport(audioBuffer))) {\n            wrapAudioBufferCopyChannelMethodsOutOfBounds(audioBuffer);\n        }\n        audioBufferStore.add(audioBuffer);\n        return audioBuffer;\n    });\n};\n//# sourceMappingURL=start-rendering.js.map","export const createIsAnyAudioContext = (contextStore, isNativeAudioContext) => {\n    return (anything) => {\n        const nativeContext = contextStore.get(anything);\n        return isNativeAudioContext(nativeContext) || isNativeAudioContext(anything);\n    };\n};\n//# sourceMappingURL=is-any-audio-context.js.map","export const createIsAnyAudioNode = (audioNodeStore, isNativeAudioNode) => {\n    return (anything) => audioNodeStore.has(anything) || isNativeAudioNode(anything);\n};\n//# sourceMappingURL=is-any-audio-node.js.map","export const createIsAnyAudioParam = (audioParamStore, isNativeAudioParam) => {\n    return (anything) => audioParamStore.has(anything) || isNativeAudioParam(anything);\n};\n//# sourceMappingURL=is-any-audio-param.js.map","export const createIsAnyOfflineAudioContext = (contextStore, isNativeOfflineAudioContext) => {\n    return (anything) => {\n        const nativeContext = contextStore.get(anything);\n        return isNativeOfflineAudioContext(nativeContext) || isNativeOfflineAudioContext(anything);\n    };\n};\n//# sourceMappingURL=is-any-offline-audio-context.js.map","export const createIsSupportedPromise = async (cacheTestResult, testAudioBufferCopyChannelMethodsSubarraySupport, testAudioContextCloseMethodSupport, testAudioContextDecodeAudioDataMethodTypeErrorSupport, testAudioContextOptionsSupport, testAudioNodeConnectMethodSupport, testAudioWorkletProcessorNoOutputsSupport, testChannelMergerNodeChannelCountSupport, testConstantSourceNodeAccurateSchedulingSupport, testConvolverNodeBufferReassignabilitySupport, testConvolverNodeChannelCountSupport, testDomExceptionContrucorSupport, testIsSecureContextSupport, testMediaStreamAudioSourceNodeMediaStreamWithoutAudioTrackSupport, testStereoPannerNodeDefaultValueSupport, testTransferablesSupport) => {\n    if (cacheTestResult(testAudioBufferCopyChannelMethodsSubarraySupport, testAudioBufferCopyChannelMethodsSubarraySupport) &&\n        cacheTestResult(testAudioContextCloseMethodSupport, testAudioContextCloseMethodSupport) &&\n        cacheTestResult(testAudioContextOptionsSupport, testAudioContextOptionsSupport) &&\n        cacheTestResult(testAudioNodeConnectMethodSupport, testAudioNodeConnectMethodSupport) &&\n        cacheTestResult(testChannelMergerNodeChannelCountSupport, testChannelMergerNodeChannelCountSupport) &&\n        cacheTestResult(testConstantSourceNodeAccurateSchedulingSupport, testConstantSourceNodeAccurateSchedulingSupport) &&\n        cacheTestResult(testConvolverNodeBufferReassignabilitySupport, testConvolverNodeBufferReassignabilitySupport) &&\n        cacheTestResult(testConvolverNodeChannelCountSupport, testConvolverNodeChannelCountSupport) &&\n        cacheTestResult(testDomExceptionContrucorSupport, testDomExceptionContrucorSupport) &&\n        cacheTestResult(testIsSecureContextSupport, testIsSecureContextSupport) &&\n        cacheTestResult(testMediaStreamAudioSourceNodeMediaStreamWithoutAudioTrackSupport, testMediaStreamAudioSourceNodeMediaStreamWithoutAudioTrackSupport)) {\n        const results = await Promise.all([\n            cacheTestResult(testAudioContextDecodeAudioDataMethodTypeErrorSupport, testAudioContextDecodeAudioDataMethodTypeErrorSupport),\n            cacheTestResult(testAudioWorkletProcessorNoOutputsSupport, testAudioWorkletProcessorNoOutputsSupport),\n            cacheTestResult(testStereoPannerNodeDefaultValueSupport, testStereoPannerNodeDefaultValueSupport),\n            cacheTestResult(testTransferablesSupport, testTransferablesSupport)\n        ]);\n        return results.every((result) => result);\n    }\n    return false;\n};\n//# sourceMappingURL=is-supported-promise.js.map","/*\n * Firefox up to version 67 didn't fully support the copyFromChannel() and copyToChannel() methods. Therefore testing one of those methods\n * is enough to know if the other one is supported as well.\n */\nexport const createTestAudioBufferCopyChannelMethodsSubarraySupport = (nativeOfflineAudioContextConstructor) => {\n    return () => {\n        if (nativeOfflineAudioContextConstructor === null) {\n            return false;\n        }\n        const nativeOfflineAudioContext = new nativeOfflineAudioContextConstructor(1, 1, 44100);\n        const nativeAudioBuffer = nativeOfflineAudioContext.createBuffer(1, 1, 44100);\n        // Bug #5: Safari does not support copyFromChannel() and copyToChannel().\n        if (nativeAudioBuffer.copyToChannel === undefined) {\n            return true;\n        }\n        const source = new Float32Array(2);\n        try {\n            nativeAudioBuffer.copyFromChannel(source, 0, 0);\n        }\n        catch {\n            return false;\n        }\n        return true;\n    };\n};\n//# sourceMappingURL=test-audio-buffer-copy-channel-methods-subarray-support.js.map","export const createTestAudioContextCloseMethodSupport = (nativeAudioContextConstructor) => {\n    return () => {\n        if (nativeAudioContextConstructor === null) {\n            return false;\n        }\n        // Try to check the prototype before constructing the AudioContext.\n        if (nativeAudioContextConstructor.prototype !== undefined && nativeAudioContextConstructor.prototype.close !== undefined) {\n            return true;\n        }\n        const audioContext = new nativeAudioContextConstructor();\n        const isAudioContextClosable = audioContext.close !== undefined;\n        try {\n            audioContext.close();\n        }\n        catch {\n            // Ignore errors.\n        }\n        return isAudioContextClosable;\n    };\n};\n//# sourceMappingURL=test-audio-context-close-method-support.js.map","/**\n * Edge up to version 14, Firefox up to version 52, Safari up to version 9 and maybe other browsers\n * did not refuse to decode invalid parameters with a TypeError.\n */\nexport const createTestAudioContextDecodeAudioDataMethodTypeErrorSupport = (nativeOfflineAudioContextConstructor) => {\n    return () => {\n        if (nativeOfflineAudioContextConstructor === null) {\n            return Promise.resolve(false);\n        }\n        const offlineAudioContext = new nativeOfflineAudioContextConstructor(1, 1, 44100);\n        // Bug #21: Safari does not support promises yet.\n        return new Promise((resolve) => {\n            let isPending = true;\n            const resolvePromise = (err) => {\n                if (isPending) {\n                    isPending = false;\n                    offlineAudioContext.startRendering();\n                    resolve(err instanceof TypeError);\n                }\n            };\n            let promise;\n            // Bug #26: Safari throws a synchronous error.\n            try {\n                promise = offlineAudioContext\n                    // Bug #1: Safari requires a successCallback.\n                    .decodeAudioData(null, () => {\n                    // Ignore the success callback.\n                }, resolvePromise);\n            }\n            catch (err) {\n                resolvePromise(err);\n            }\n            // Bug #21: Safari does not support promises yet.\n            if (promise !== undefined) {\n                // Bug #6: Chrome, Edge, Firefox and Opera do not call the errorCallback.\n                promise.catch(resolvePromise);\n            }\n        });\n    };\n};\n//# sourceMappingURL=test-audio-context-decode-audio-data-method-type-error-support.js.map","export const createTestAudioContextOptionsSupport = (nativeAudioContextConstructor) => {\n    return () => {\n        if (nativeAudioContextConstructor === null) {\n            return false;\n        }\n        let audioContext;\n        try {\n            audioContext = new nativeAudioContextConstructor({ latencyHint: 'balanced' });\n        }\n        catch {\n            return false;\n        }\n        audioContext.close();\n        return true;\n    };\n};\n//# sourceMappingURL=test-audio-context-options-support.js.map","// Safari up to version 12.0 (but not v12.1) didn't return the destination in case it was an AudioNode.\nexport const createTestAudioNodeConnectMethodSupport = (nativeOfflineAudioContextConstructor) => {\n    return () => {\n        if (nativeOfflineAudioContextConstructor === null) {\n            return false;\n        }\n        const nativeOfflineAudioContext = new nativeOfflineAudioContextConstructor(1, 1, 44100);\n        const nativeGainNode = nativeOfflineAudioContext.createGain();\n        const isSupported = nativeGainNode.connect(nativeGainNode) === nativeGainNode;\n        nativeGainNode.disconnect(nativeGainNode);\n        return isSupported;\n    };\n};\n//# sourceMappingURL=test-audio-node-connect-method-support.js.map","/**\n * Chrome version 66 and 67 did not call the process() function of an AudioWorkletProcessor if it had no outputs. AudioWorklet support was\n * enabled by default in version 66.\n */\nexport const createTestAudioWorkletProcessorNoOutputsSupport = (nativeAudioWorkletNodeConstructor, nativeOfflineAudioContextConstructor) => {\n    return async () => {\n        // Bug #61: If there is no native AudioWorkletNode it gets faked and therefore it is no problem if the it doesn't exist.\n        if (nativeAudioWorkletNodeConstructor === null) {\n            return true;\n        }\n        if (nativeOfflineAudioContextConstructor === null) {\n            return false;\n        }\n        const blob = new Blob([\n            'let c,p;class A extends AudioWorkletProcessor{constructor(){super();this.port.onmessage=(e)=>{p=e.data;p.onmessage=()=>{p.postMessage(c);p.close()};this.port.postMessage(0)}}process(){c=1}}registerProcessor(\"a\",A)'\n        ], {\n            type: 'application/javascript; charset=utf-8'\n        });\n        const messageChannel = new MessageChannel();\n        // Bug #141: Safari does not support creating an OfflineAudioContext with less than 44100 Hz.\n        const offlineAudioContext = new nativeOfflineAudioContextConstructor(1, 128, 44100);\n        const url = URL.createObjectURL(blob);\n        let isCallingProcess = false;\n        try {\n            await offlineAudioContext.audioWorklet.addModule(url);\n            const audioWorkletNode = new nativeAudioWorkletNodeConstructor(offlineAudioContext, 'a', { numberOfOutputs: 0 });\n            const oscillator = offlineAudioContext.createOscillator();\n            await new Promise((resolve) => {\n                audioWorkletNode.port.onmessage = () => resolve();\n                audioWorkletNode.port.postMessage(messageChannel.port2, [messageChannel.port2]);\n            });\n            audioWorkletNode.port.onmessage = () => (isCallingProcess = true);\n            oscillator.connect(audioWorkletNode);\n            oscillator.start(0);\n            await offlineAudioContext.startRendering();\n            isCallingProcess = await new Promise((resolve) => {\n                messageChannel.port1.onmessage = ({ data }) => resolve(data === 1);\n                messageChannel.port1.postMessage(0);\n            });\n        }\n        catch {\n            // Ignore errors.\n        }\n        finally {\n            messageChannel.port1.close();\n            URL.revokeObjectURL(url);\n        }\n        return isCallingProcess;\n    };\n};\n//# sourceMappingURL=test-audio-worklet-processor-no-outputs-support.js.map","/**\n * Firefox up to version 69 did not throw an error when setting a different channelCount or channelCountMode.\n */\nexport const createTestChannelMergerNodeChannelCountSupport = (nativeOfflineAudioContextConstructor) => {\n    return () => {\n        if (nativeOfflineAudioContextConstructor === null) {\n            return false;\n        }\n        const offlineAudioContext = new nativeOfflineAudioContextConstructor(1, 1, 44100);\n        const nativeChannelMergerNode = offlineAudioContext.createChannelMerger();\n        /**\n         * Bug #15: Safari does not return the default properties. It still needs to be patched. This test is supposed to test the support\n         * in other browsers.\n         */\n        if (nativeChannelMergerNode.channelCountMode === 'max') {\n            return true;\n        }\n        try {\n            nativeChannelMergerNode.channelCount = 2;\n        }\n        catch {\n            return true;\n        }\n        return false;\n    };\n};\n//# sourceMappingURL=test-channel-merger-node-channel-count-support.js.map","export const createTestConstantSourceNodeAccurateSchedulingSupport = (nativeOfflineAudioContextConstructor) => {\n    return () => {\n        if (nativeOfflineAudioContextConstructor === null) {\n            return false;\n        }\n        const nativeOfflineAudioContext = new nativeOfflineAudioContextConstructor(1, 1, 44100);\n        // Bug #62: Safari does not support ConstantSourceNodes.\n        if (nativeOfflineAudioContext.createConstantSource === undefined) {\n            return true;\n        }\n        const nativeConstantSourceNode = nativeOfflineAudioContext.createConstantSource();\n        /*\n         * @todo This is using bug #75 to detect bug #70. That works because both bugs were unique to\n         * the implementation of Firefox right now, but it could probably be done in a better way.\n         */\n        return nativeConstantSourceNode.offset.maxValue !== Number.POSITIVE_INFINITY;\n    };\n};\n//# sourceMappingURL=test-constant-source-node-accurate-scheduling-support.js.map","// Opera up to version 57 did not allow to reassign the buffer of a ConvolverNode.\nexport const createTestConvolverNodeBufferReassignabilitySupport = (nativeOfflineAudioContextConstructor) => {\n    return () => {\n        if (nativeOfflineAudioContextConstructor === null) {\n            return false;\n        }\n        const offlineAudioContext = new nativeOfflineAudioContextConstructor(1, 1, 44100);\n        const nativeConvolverNode = offlineAudioContext.createConvolver();\n        nativeConvolverNode.buffer = offlineAudioContext.createBuffer(1, 1, offlineAudioContext.sampleRate);\n        try {\n            nativeConvolverNode.buffer = offlineAudioContext.createBuffer(1, 1, offlineAudioContext.sampleRate);\n        }\n        catch {\n            return false;\n        }\n        return true;\n    };\n};\n//# sourceMappingURL=test-convolver-node-buffer-reassignability-support.js.map","// Chrome up to version v80, Edge up to version v80 and Opera up to version v67 did not allow to set the channelCount property of a ConvolverNode to 1. They also did not allow to set the channelCountMode to 'explicit'.\nexport const createTestConvolverNodeChannelCountSupport = (nativeOfflineAudioContextConstructor) => {\n    return () => {\n        if (nativeOfflineAudioContextConstructor === null) {\n            return false;\n        }\n        const offlineAudioContext = new nativeOfflineAudioContextConstructor(1, 1, 44100);\n        const nativeConvolverNode = offlineAudioContext.createConvolver();\n        try {\n            nativeConvolverNode.channelCount = 1;\n        }\n        catch {\n            return false;\n        }\n        return true;\n    };\n};\n//# sourceMappingURL=test-convolver-node-channel-count-support.js.map","export const createTestIsSecureContextSupport = (window) => {\n    return () => window !== null && window.hasOwnProperty('isSecureContext');\n};\n//# sourceMappingURL=test-is-secure-context-support.js.map","// Firefox up to version 68 did not throw an error when creating a MediaStreamAudioSourceNode with a mediaStream that had no audio track.\nexport const createTestMediaStreamAudioSourceNodeMediaStreamWithoutAudioTrackSupport = (nativeAudioContextConstructor) => {\n    return () => {\n        if (nativeAudioContextConstructor === null) {\n            return false;\n        }\n        const audioContext = new nativeAudioContextConstructor();\n        try {\n            audioContext.createMediaStreamSource(new MediaStream());\n            return false;\n        }\n        catch (err) {\n            return true;\n        }\n        finally {\n            audioContext.close();\n        }\n    };\n};\n//# sourceMappingURL=test-media-stream-audio-source-node-media-stream-without-audio-track-support.js.map","/**\n * Firefox up to version 62 did not kick off the processing of the StereoPannerNode if the value of pan was zero.\n */\nexport const createTestStereoPannerNodeDefaultValueSupport = (nativeOfflineAudioContextConstructor) => {\n    return () => {\n        if (nativeOfflineAudioContextConstructor === null) {\n            return Promise.resolve(false);\n        }\n        const nativeOfflineAudioContext = new nativeOfflineAudioContextConstructor(1, 1, 44100);\n        /*\n         * Bug #105: Safari does not support the StereoPannerNode. Therefore the returned value should normally be false but the faker does\n         * support the tested behaviour.\n         */\n        if (nativeOfflineAudioContext.createStereoPanner === undefined) {\n            return Promise.resolve(true);\n        }\n        // Bug #62: Safari does not support ConstantSourceNodes.\n        if (nativeOfflineAudioContext.createConstantSource === undefined) {\n            return Promise.resolve(true);\n        }\n        const constantSourceNode = nativeOfflineAudioContext.createConstantSource();\n        const stereoPanner = nativeOfflineAudioContext.createStereoPanner();\n        constantSourceNode.channelCount = 1;\n        constantSourceNode.offset.value = 1;\n        stereoPanner.channelCount = 1;\n        constantSourceNode.start();\n        constantSourceNode.connect(stereoPanner).connect(nativeOfflineAudioContext.destination);\n        return nativeOfflineAudioContext.startRendering().then((buffer) => buffer.getChannelData(0)[0] !== 1);\n    };\n};\n//# sourceMappingURL=test-stereo-panner-node-default-value-support.js.map","import { Note } from \"../type/Units\";\n\n/**\n * Test if the arg is undefined\n */\nexport function isUndef(arg: any): arg is undefined {\n\treturn typeof arg === \"undefined\";\n}\n\n/**\n * Test if the arg is not undefined\n */\nexport function isDefined<T>(arg: T | undefined): arg is T {\n\treturn !isUndef(arg);\n}\n\n/**\n * Test if the arg is a function\n */\nexport function isFunction(arg: any): arg is (a: any) => any {\n\treturn typeof arg === \"function\";\n}\n\n/**\n * Test if the argument is a number.\n */\nexport function isNumber(arg: any): arg is number {\n\treturn (typeof arg === \"number\");\n}\n\n/**\n * Test if the given argument is an object literal (i.e. `{}`);\n */\nexport function isObject(arg: any): arg is object {\n\treturn (Object.prototype.toString.call(arg) === \"[object Object]\" && arg.constructor === Object);\n}\n\n/**\n * Test if the argument is a boolean.\n */\nexport function isBoolean(arg: any): arg is boolean {\n\treturn (typeof arg === \"boolean\");\n}\n\n/**\n * Test if the argument is an Array\n */\nexport function isArray(arg: any): arg is any[] {\n\treturn (Array.isArray(arg));\n}\n\n/**\n * Test if the argument is a string.\n */\nexport function isString(arg: any): arg is string {\n\treturn (typeof arg === \"string\");\n}\n\n/**\n * Test if the argument is in the form of a note in scientific pitch notation.\n * e.g. \"C4\"\n */\nexport function isNote(arg: any): arg is Note {\n\treturn isString(arg) && /^([a-g]{1}(?:b|#|x|bb)?)(-?[0-9]+)/i.test(arg);\n}\n","import { isUndef } from \"./TypeCheck\";\n\n/**\n * Assert that the statement is true, otherwise invoke the error.\n * @param statement\n * @param error The message which is passed into an Error\n */\nexport function assert(statement: boolean, error: string): asserts statement {\n\tif (!statement) {\n\t\tthrow new Error(error);\n\t}\n}\n\n/**\n * Make sure that the given value is within the range\n */\nexport function assertRange(value: number, gte: number, lte = Infinity): void {\n\tif (!(gte <= value && value <= lte)) {\n\t\tthrow new RangeError(\n\t\t\t`Value must be within [${gte}, ${lte}], got: ${value}`\n\t\t);\n\t}\n}\n\n/**\n * Warn if the context is not running.\n */\nexport function assertContextRunning(\n\tcontext: import(\"../context/BaseContext\").BaseContext\n): void {\n\t// add a warning if the context is not started\n\tif (!context.isOffline && context.state !== \"running\") {\n\t\twarn(\n\t\t\t\"The AudioContext is \\\"suspended\\\". Invoke Tone.start() from a user action to start the audio.\"\n\t\t);\n\t}\n}\n\n/**\n * If it is currently inside a scheduled callback\n */\nlet isInsideScheduledCallback = false;\nlet printedScheduledWarning = false;\n\n/**\n * Notify that the following block of code is occurring inside a Transport callback.\n */\nexport function enterScheduledCallback(insideCallback: boolean): void {\n\tisInsideScheduledCallback = insideCallback;\n}\n\n/**\n * Make sure that a time was passed into\n */\nexport function assertUsedScheduleTime(\n\ttime?: import(\"../type/Units\").Time\n): void {\n\tif (isUndef(time) && isInsideScheduledCallback && !printedScheduledWarning) {\n\t\tprintedScheduledWarning = true;\n\t\twarn(\"Events scheduled inside of scheduled callbacks should use the passed in scheduling time. See https://github.com/Tonejs/Tone.js/wiki/Accurate-Timing\");\n\t}\n}\n\n/**\n * A basic logging interface\n */\ninterface Logger {\n\tlog: (args?: any[]) => void;\n\twarn: (args?: any[]) => void;\n}\n\n/**\n * The default logger is the console\n */\nlet defaultLogger: Logger = console;\n\n/**\n * Set the logging interface\n */\nexport function setLogger(logger: Logger): void {\n\tdefaultLogger = logger;\n}\n\n/**\n * Log anything\n */\nexport function log(...args: any[]): void {\n\tdefaultLogger.log(...args);\n}\n\n/**\n * Warn anything\n */\nexport function warn(...args: any[]): void {\n\tdefaultLogger.warn(...args);\n}\n","import {\n\tAudioContext as stdAudioContext,\n\tAudioWorkletNode as stdAudioWorkletNode,\n\tOfflineAudioContext as stdOfflineAudioContext\n} from \"standardized-audio-context\";\nimport { assert } from \"../util/Debug\";\nimport { isDefined } from \"../util/TypeCheck\";\n\n/**\n * Create a new AudioContext\n */\nexport function createAudioContext(options?: AudioContextOptions): AudioContext {\n\treturn new stdAudioContext(options) as unknown as AudioContext;\n}\n\n/**\n * Create a new OfflineAudioContext\n */\nexport function createOfflineAudioContext(channels: number, length: number, sampleRate: number): OfflineAudioContext {\n\treturn new stdOfflineAudioContext(channels, length, sampleRate) as unknown as OfflineAudioContext;\n}\n\n/**\n * Either the online or offline audio context\n */\nexport type AnyAudioContext = AudioContext | OfflineAudioContext;\n\n/**\n * Interface for things that Tone.js adds to the window\n */\ninterface ToneWindow extends Window {\n\tTONE_SILENCE_LOGGING?: boolean;\n\tTONE_DEBUG_CLASS?: string;\n}\n\n/**\n * A reference to the window object\n * @hidden\n */\nexport const theWindow: ToneWindow | null = typeof self === \"object\" ? self : null;\n\n/**\n * If the browser has a window object which has an AudioContext\n * @hidden\n */\nexport const hasAudioContext = theWindow &&\n\t(theWindow.hasOwnProperty(\"AudioContext\") || theWindow.hasOwnProperty(\"webkitAudioContext\"));\n\nexport function createAudioWorkletNode(context: AnyAudioContext, name: string, options?: Partial<AudioWorkletNodeOptions>): AudioWorkletNode {\n\tassert(isDefined(stdAudioWorkletNode), \"This node only works in a secure context (https or localhost)\");\n\t// @ts-ignore\n\treturn new stdAudioWorkletNode(context, name, options);\n}\n\n/**\n * This promise resolves to a boolean which indicates if the \n * functionality is supported within the currently used browse. \n * Taken from [standardized-audio-context](https://github.com/chrisguttandin/standardized-audio-context#issupported)\n */\nexport { isSupported as supported } from \"standardized-audio-context\";\n","/*! *****************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = function(d, b) {\r\n    extendStatics = Object.setPrototypeOf ||\r\n        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n        function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\r\n    return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n    extendStatics(d, b);\r\n    function __() { this.constructor = d; }\r\n    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n    __assign = Object.assign || function __assign(t) {\r\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n            s = arguments[i];\r\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n        }\r\n        return t;\r\n    }\r\n    return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n    var t = {};\r\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n        t[p] = s[p];\r\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r\n                t[p[i]] = s[p[i]];\r\n        }\r\n    return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n    if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n    return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n    return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n    if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\r\n    return new (P || (P = Promise))(function (resolve, reject) {\r\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\r\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n    });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n    function verb(n) { return function (v) { return step([n, v]); }; }\r\n    function step(op) {\r\n        if (f) throw new TypeError(\"Generator is already executing.\");\r\n        while (_) try {\r\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\r\n            if (y = 0, t) op = [op[0] & 2, t.value];\r\n            switch (op[0]) {\r\n                case 0: case 1: t = op; break;\r\n                case 4: _.label++; return { value: op[1], done: false };\r\n                case 5: _.label++; y = op[1]; op = [0]; continue;\r\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n                default:\r\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n                    if (t[2]) _.ops.pop();\r\n                    _.trys.pop(); continue;\r\n            }\r\n            op = body.call(thisArg, _);\r\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n    }\r\n}\r\n\r\nexport var __createBinding = Object.create ? (function(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });\r\n}) : (function(o, m, k, k2) {\r\n    if (k2 === undefined) k2 = k;\r\n    o[k2] = m[k];\r\n});\r\n\r\nexport function __exportStar(m, o) {\r\n    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p);\r\n}\r\n\r\nexport function __values(o) {\r\n    var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\r\n    if (m) return m.call(o);\r\n    if (o && typeof o.length === \"number\") return {\r\n        next: function () {\r\n            if (o && i >= o.length) o = void 0;\r\n            return { value: o && o[i++], done: !o };\r\n        }\r\n    };\r\n    throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\r\n}\r\n\r\nexport function __read(o, n) {\r\n    var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n    if (!m) return o;\r\n    var i = m.call(o), r, ar = [], e;\r\n    try {\r\n        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n    }\r\n    catch (error) { e = { error: error }; }\r\n    finally {\r\n        try {\r\n            if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n        }\r\n        finally { if (e) throw e.error; }\r\n    }\r\n    return ar;\r\n}\r\n\r\nexport function __spread() {\r\n    for (var ar = [], i = 0; i < arguments.length; i++)\r\n        ar = ar.concat(__read(arguments[i]));\r\n    return ar;\r\n}\r\n\r\nexport function __spreadArrays() {\r\n    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\r\n    for (var r = Array(s), k = 0, i = 0; i < il; i++)\r\n        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\r\n            r[k] = a[j];\r\n    return r;\r\n};\r\n\r\nexport function __await(v) {\r\n    return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n    return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n    function fulfill(value) { resume(\"next\", value); }\r\n    function reject(value) { resume(\"throw\", value); }\r\n    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n    var i, p;\r\n    return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === \"return\" } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n    if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n    var m = o[Symbol.asyncIterator], i;\r\n    return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n    if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n    return cooked;\r\n};\r\n\r\nvar __setModuleDefault = Object.create ? (function(o, v) {\r\n    Object.defineProperty(o, \"default\", { enumerable: true, value: v });\r\n}) : function(o, v) {\r\n    o[\"default\"] = v;\r\n};\r\n\r\nexport function __importStar(mod) {\r\n    if (mod && mod.__esModule) return mod;\r\n    var result = {};\r\n    if (mod != null) for (var k in mod) if (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\r\n    __setModuleDefault(result, mod);\r\n    return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n    return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n\r\nexport function __classPrivateFieldGet(receiver, privateMap) {\r\n    if (!privateMap.has(receiver)) {\r\n        throw new TypeError(\"attempted to get private field on non-instance\");\r\n    }\r\n    return privateMap.get(receiver);\r\n}\r\n\r\nexport function __classPrivateFieldSet(receiver, privateMap, value) {\r\n    if (!privateMap.has(receiver)) {\r\n        throw new TypeError(\"attempted to set private field on non-instance\");\r\n    }\r\n    privateMap.set(receiver, value);\r\n    return value;\r\n}\r\n","import { Seconds } from \"../type/Units\";\n\nexport type TickerClockSource = \"worker\" | \"timeout\" | \"offline\";\n\n/**\n * A class which provides a reliable callback using either\n * a Web Worker, or if that isn't supported, falls back to setTimeout.\n */\nexport class Ticker {\n\n\t/**\n\t * Either \"worker\" or \"timeout\" or \"offline\"\n\t */\n\tprivate _type: TickerClockSource;\n\n\t/**\n\t * The update interval of the worker\n\t */\n\tprivate _updateInterval: Seconds;\n\n\t/**\n\t * The callback to invoke at regular intervals\n\t */\n\tprivate _callback: () => void;\n\n\t/**\n\t * track the callback interval\n\t */\n\tprivate _timeout!: ReturnType<typeof setTimeout>;\n\n\t/**\n\t * private reference to the worker\n\t */\n\tprivate _worker!: Worker;\n\n\tconstructor(callback: () => void, type: TickerClockSource, updateInterval: Seconds) {\n\n\t\tthis._callback = callback;\n\t\tthis._type = type;\n\t\tthis._updateInterval = updateInterval;\n\n\t\t// create the clock source for the first time\n\t\tthis._createClock();\n\t}\n\n\t/**\n\t * Generate a web worker\n\t */\n\tprivate _createWorker(): void {\n\n\t\tconst blob = new Blob([\n\t\t\t/* javascript */`\n\t\t\t// the initial timeout time\n\t\t\tlet timeoutTime =  ${(this._updateInterval * 1000).toFixed(1)};\n\t\t\t// onmessage callback\n\t\t\tself.onmessage = function(msg){\n\t\t\t\ttimeoutTime = parseInt(msg.data);\n\t\t\t};\n\t\t\t// the tick function which posts a message\n\t\t\t// and schedules a new tick\n\t\t\tfunction tick(){\n\t\t\t\tsetTimeout(tick, timeoutTime);\n\t\t\t\tself.postMessage('tick');\n\t\t\t}\n\t\t\t// call tick initially\n\t\t\ttick();\n\t\t\t`\n\t\t], { type: \"text/javascript\" });\n\t\tconst blobUrl = URL.createObjectURL(blob);\n\t\tconst worker = new Worker(blobUrl);\n\n\t\tworker.onmessage = this._callback.bind(this);\n\n\t\tthis._worker = worker;\n\t}\n\n\t/**\n\t * Create a timeout loop\n\t */\n\tprivate _createTimeout(): void {\n\t\tthis._timeout = setTimeout(() => {\n\t\t\tthis._createTimeout();\n\t\t\tthis._callback();\n\t\t}, this._updateInterval * 1000);\n\t}\n\n\t/**\n\t * Create the clock source.\n\t */\n\tprivate _createClock(): void {\n\t\tif (this._type === \"worker\") {\n\t\t\ttry {\n\t\t\t\tthis._createWorker();\n\t\t\t} catch (e) {\n\t\t\t\t// workers not supported, fallback to timeout\n\t\t\t\tthis._type = \"timeout\";\n\t\t\t\tthis._createClock();\n\t\t\t}\n\t\t} else if (this._type === \"timeout\") {\n\t\t\tthis._createTimeout();\n\t\t}\n\t}\n\n\t/**\n\t * Clean up the current clock source\n\t */\n\tprivate _disposeClock(): void {\n\t\tif (this._timeout) {\n\t\t\tclearTimeout(this._timeout);\n\t\t}\n\t\tif (this._worker) {\n\t\t\tthis._worker.terminate();\n\t\t\tthis._worker.onmessage = null;\n\t\t}\n\t}\n\n\t/**\n\t * The rate in seconds the ticker will update\n\t */\n\tget updateInterval(): Seconds {\n\t\treturn this._updateInterval;\n\t}\n\tset updateInterval(interval: Seconds) {\n\t\tthis._updateInterval = Math.max(interval, 128 / 44100);\n\t\tif (this._type === \"worker\") {\n\t\t\tthis._worker.postMessage(Math.max(interval * 1000, 1));\n\t\t}\n\t}\n\n\t/**\n\t * The type of the ticker, either a worker or a timeout\n\t */\n\tget type(): TickerClockSource {\n\t\treturn this._type;\n\t}\n\tset type(type: TickerClockSource) {\n\t\tthis._disposeClock();\n\t\tthis._type = type;\n\t\tthis._createClock();\n\t}\n\n\t/**\n\t * Clean up\n\t */\n\tdispose(): void {\n\t\tthis._disposeClock();\n\t}\n}\n","import {\n\tAudioBuffer, isAnyAudioContext,\n\tisAnyAudioNode, isAnyAudioParam,\n\tisAnyOfflineAudioContext\n} from \"standardized-audio-context\";\n\n/**\n * Test if the given value is an instanceof AudioParam\n */\nexport function isAudioParam(arg: any): arg is AudioParam {\n\treturn isAnyAudioParam(arg);\n}\n\n/**\n * Test if the given value is an instanceof AudioNode\n */\nexport function isAudioNode(arg: any): arg is AudioNode {\n\treturn isAnyAudioNode(arg);\n}\n\n/**\n * Test if the arg is instanceof an OfflineAudioContext\n */\nexport function isOfflineAudioContext(arg: any): arg is OfflineAudioContext {\n\treturn isAnyOfflineAudioContext(arg);\n}\n\n/**\n * Test if the arg is an instanceof AudioContext\n */\nexport function isAudioContext(arg: any): arg is AudioContext {\n\treturn isAnyAudioContext(arg);\n}\n\n/**\n * Test if the arg is instanceof an AudioBuffer\n */\nexport function isAudioBuffer(arg: any): arg is AudioBuffer {\n\treturn arg instanceof AudioBuffer;\n}\n","import { isAudioBuffer, isAudioNode, isAudioParam } from \"./AdvancedTypeCheck\";\nimport { isDefined, isObject, isUndef } from \"./TypeCheck\";\n\ntype BaseToneOptions = import(\"../Tone\").BaseToneOptions;\n\n/**\n * Some objects should not be merged\n */\nfunction noCopy(key: string, arg: any): boolean {\n\treturn key === \"value\" || isAudioParam(arg) || isAudioNode(arg) || isAudioBuffer(arg);\n}\n\n/**\n * Recursively merge an object\n * @param target the object to merge into\n * @param sources the source objects to merge\n */\nexport function deepMerge<T>(target: T): T;\nexport function deepMerge<T, U>(target: T, source1: U): T & U;\nexport function deepMerge<T, U, V>(target: T, source1: U, source2: V): T & U & V;\nexport function deepMerge<T, U, V, W>(target: T, source1: U, source2: V, source3: W): T & U & V & W;\nexport function deepMerge(target: any, ...sources: any[]): any {\n\tif (!sources.length) {\n\t\treturn target; \n\t}\n\tconst source = sources.shift();\n\n\tif (isObject(target) && isObject(source)) {\n\t\tfor (const key in source) {\n\t\t\tif (noCopy(key, source[key])) {\n\t\t\t\ttarget[key] = source[key];\n\t\t\t} else if (isObject(source[key])) {\n\t\t\t\tif (!target[key]) {\n\t\t\t\t\tObject.assign(target, { [key]: {} }); \n\t\t\t\t}\n\t\t\t\tdeepMerge(target[key], source[key] as any);\n\t\t\t} else {\n\t\t\t\tObject.assign(target, { [key]: source[key] as any });\n\t\t\t}\n\t\t}\n\t}\n\t// @ts-ignore\n\treturn deepMerge(target, ...sources);\n}\n\n/**\n * Returns true if the two arrays have the same value for each of the elements\n */\nexport function deepEquals<T>(arrayA: T[], arrayB: T[]): boolean {\n\treturn arrayA.length === arrayB.length && arrayA.every((element, index) => arrayB[index] === element);\n}\n\n/**\n * Convert an args array into an object.\n */\nexport function optionsFromArguments<T extends object>(\n\tdefaults: T,\n\targsArray: IArguments,\n\tkeys: Array<keyof T> = [],\n\tobjKey?: keyof T,\n): T {\n\tconst opts: Partial<T> = {};\n\tconst args = Array.from(argsArray);\n\t// if the first argument is an object and has an object key\n\tif (isObject(args[0]) && objKey && !Reflect.has(args[0], objKey)) {\n\t\t// if it's not part of the defaults\n\t\tconst partOfDefaults = Object.keys(args[0]).some(key => Reflect.has(defaults, key));\n\t\tif (!partOfDefaults) {\n\t\t\t// merge that key\n\t\t\tdeepMerge(opts, { [objKey]: args[0] });\n\t\t\t// remove the obj key from the keys\n\t\t\tkeys.splice(keys.indexOf(objKey), 1);\n\t\t\t// shift the first argument off\n\t\t\targs.shift();\n\t\t}\n\t}\n\tif (args.length === 1 && isObject(args[0])) {\n\t\tdeepMerge(opts, args[0]);\n\t} else {\n\t\tfor (let i = 0; i < keys.length; i++) {\n\t\t\tif (isDefined(args[i])) {\n\t\t\t\topts[keys[i]] = args[i];\n\t\t\t}\n\t\t}\n\t}\n\treturn deepMerge(defaults, opts);\n}\n\n/**\n * Return this instances default values by calling Constructor.getDefaults()\n */\nexport function getDefaultsFromInstance<T>(instance: T): BaseToneOptions {\n\ttype ToneClass = {\n\t\tconstructor: ToneClass;\n\t\tgetDefaults: () => BaseToneOptions;\n\t} & T;\n\n\treturn (instance as ToneClass).constructor.getDefaults();\n}\n\n/**\n * Returns the fallback if the given object is undefined.\n * Take an array of arguments and return a formatted options object.\n */\nexport function defaultArg<T>(given: T, fallback: T): T {\n\tif (isUndef(given)) {\n\t\treturn fallback;\n\t} else {\n\t\treturn given;\n\t}\n}\n\n/**\n * Remove all of the properties belonging to omit from obj.\n */\nexport function omitFromObject<T extends object, O extends string[]>(obj: T, omit: O): Omit<T, keyof O> {\n\tomit.forEach(prop => {\n\t\tif (Reflect.has(obj, prop)) {\n\t\t\tdelete obj[prop];\n\t\t}\n\t});\n\treturn obj;\n}\n","/**\n * Tone.js\n * @author Yotam Mann\n * @license http://opensource.org/licenses/MIT MIT License\n * @copyright 2014-2019 Yotam Mann\n */\nimport { version } from \"../version\";\nimport { theWindow } from \"./context/AudioContext\";\nimport { log } from \"./util/Debug\";\n\n//-------------------------------------\n// \tTONE\n//-------------------------------------\n\n// eslint-disable-next-line @typescript-eslint/no-empty-interface\nexport interface BaseToneOptions { }\n\n/**\n * Tone is the base class of all other classes.\n * \n * @category Core\n * @constructor\n */\nexport abstract class Tone {\n\n\t/**\n\t * The version number semver\n\t */\n\tstatic version: string = version;\n\n\t/**\n\t * The name of the class\n\t */\n\tprotected abstract name: string;\n\n\t/**\n\t * Returns all of the default options belonging to the class.\n\t */\n\tstatic getDefaults(): BaseToneOptions {\n\t\treturn {};\n\t}\n\n\t//-------------------------------------\n\t// \tDEBUGGING\n\t//-------------------------------------\n\n\t/**\n\t * Set this debug flag to log all events that happen in this class.\n\t */\n\tdebug = false;\n\n\t/**\n\t * Prints the outputs to the console log for debugging purposes.\n\t * Prints the contents only if either the object has a property\n\t * called `debug` set to true, or a variable called TONE_DEBUG_CLASS\n\t * is set to the name of the class.\n\t * @example\n\t * const osc = new Tone.Oscillator();\n\t * // prints all logs originating from this oscillator\n\t * osc.debug = true;\n\t * // calls to start/stop will print in the console\n\t * osc.start();\n\t */\n\tprotected log(...args: any[]): void {\n\t\t// if the object is either set to debug = true\n\t\t// or if there is a string on the Tone.global.with the class name\n\t\tif (this.debug || (theWindow && this.toString() === theWindow.TONE_DEBUG_CLASS)) {\n\t\t\tlog(this, ...args);\n\t\t}\n\t}\n\n\t//-------------------------------------\n\t// \tDISPOSING\n\t//-------------------------------------\n\n\t/**\n\t * Indicates if the instance was disposed\n\t */\n\tprivate _wasDisposed = false;\n\n\t/**\n\t * disconnect and dispose.\n\t */\n\tdispose(): this {\n\t\tthis._wasDisposed = true;\n\t\treturn this;\n\t}\n\n\t/**\n\t * Indicates if the instance was disposed. 'Disposing' an\n\t * instance means that all of the Web Audio nodes that were\n\t * created for the instance are disconnected and freed for garbage collection.\n\t */\n\tget disposed(): boolean {\n\t\treturn this._wasDisposed;\n\t}\n\n\t/**\n\t * Convert the class to a string\n\t * @example\n\t * const osc = new Tone.Oscillator();\n\t * console.log(osc.toString());\n\t */\n\ttoString(): string {\n\t\treturn this.name;\n\t}\n}\n","/**\n * The threshold for correctness for operators. Less than one sample even \n * at very high sampling rates (e.g. `1e-6 < 1 / 192000`).\n */\nconst EPSILON = 1e-6;\n\n/**\n * Test if A is greater than B\n */\nexport function GT(a: number, b: number): boolean {\n\treturn a > b + EPSILON;\n}\n\n/**\n * Test if A is greater than or equal to B\n */\nexport function GTE(a: number, b: number): boolean {\n\treturn GT(a, b) || EQ(a, b);\n}\n\n/**\n * Test if A is less than B\n */\nexport function LT(a: number, b: number): boolean {\n\treturn a + EPSILON < b;\n}\n\n/**\n * Test if A is less than B\n */\nexport function EQ(a: number, b: number): boolean {\n\treturn Math.abs(a - b) < EPSILON;\n}\n\n/**\n * Clamp the value within the given range\n */\nexport function clamp(value: number, min: number, max: number): number {\n\treturn Math.max(Math.min(value, max), min);\n}\n","import { Tone } from \"../Tone\";\nimport { Seconds } from \"../type/Units\";\nimport { optionsFromArguments } from \"./Defaults\";\nimport { assert } from \"./Debug\";\nimport { EQ, GT, GTE, LT } from \"./Math\";\n\ntype TimelineSearchParam = \"ticks\" | \"time\";\n\n/**\n * The options object for Timeline\n */\ninterface TimelineOptions {\n\tmemory: number;\n\tincreasing: boolean;\n}\n\n/**\n * An event must have a time number\n */\nexport interface TimelineEvent {\n\ttime: number;\n}\n\n/**\n * A Timeline class for scheduling and maintaining state\n * along a timeline. All events must have a \"time\" property.\n * Internally, events are stored in time order for fast\n * retrieval.\n */\nexport class Timeline<GenericEvent extends TimelineEvent> extends Tone {\n\n\treadonly name: string = \"Timeline\";\n\n\t/**\n\t * The memory of the timeline, i.e.\n\t * how many events in the past it will retain\n\t */\n\tmemory: number;\n\n\t/**\n\t * The array of scheduled timeline events\n\t */\n\tprotected _timeline: GenericEvent[] = [];\n\n\t/**\n\t * If the time value must always be greater than or equal to the last \n\t * element on the list. \n\t */\n\tincreasing: boolean;\n\n\t/**\n\t * @param memory The number of previous events that are retained.\n\t */\n\tconstructor(memory?: number);\n\tconstructor(options?: Partial<TimelineOptions>);\n\tconstructor() {\n\t\tsuper();\n\t\tconst options = optionsFromArguments(Timeline.getDefaults(), arguments, [\"memory\"]);\n\n\t\tthis.memory = options.memory;\n\t\tthis.increasing = options.increasing;\n\t}\n\n\tstatic getDefaults(): TimelineOptions {\n\t\treturn {\n\t\t\tmemory: Infinity,\n\t\t\tincreasing: false,\n\t\t};\n\t}\n\n\t/**\n\t * The number of items in the timeline.\n\t */\n\tget length(): number {\n\t\treturn this._timeline.length;\n\t}\n\n\t/**\n\t * Insert an event object onto the timeline. Events must have a \"time\" attribute.\n\t * @param event  The event object to insert into the timeline.\n\t */\n\tadd(event: GenericEvent): this {\n\t\t// the event needs to have a time attribute\n\t\tassert(Reflect.has(event, \"time\"), \"Timeline: events must have a time attribute\");\n\t\tevent.time = event.time.valueOf();\n\t\tif (this.increasing && this.length) {\n\t\t\tconst lastValue = this._timeline[this.length - 1] as GenericEvent;\n\t\t\tassert(GTE(event.time, lastValue.time), \"The time must be greater than or equal to the last scheduled time\");\n\t\t\tthis._timeline.push(event);\n\t\t} else {\n\t\t\tconst index = this._search(event.time);\n\t\t\tthis._timeline.splice(index + 1, 0, event);\n\t\t}\n\t\t// if the length is more than the memory, remove the previous ones\n\t\tif (this.length > this.memory) {\n\t\t\tconst diff = this.length - this.memory;\n\t\t\tthis._timeline.splice(0, diff);\n\t\t}\n\t\treturn this;\n\t}\n\n\t/**\n\t * Remove an event from the timeline.\n\t * @param  {Object}  event  The event object to remove from the list.\n\t * @returns {Timeline} this\n\t */\n\tremove(event: GenericEvent): this {\n\t\tconst index = this._timeline.indexOf(event);\n\t\tif (index !== -1) {\n\t\t\tthis._timeline.splice(index, 1);\n\t\t}\n\t\treturn this;\n\t}\n\n\t/**\n\t * Get the nearest event whose time is less than or equal to the given time.\n\t * @param  time  The time to query.\n\t */\n\tget(time: number, param: TimelineSearchParam = \"time\"): GenericEvent | null {\n\t\tconst index = this._search(time, param);\n\t\tif (index !== -1) {\n\t\t\treturn this._timeline[index];\n\t\t} else {\n\t\t\treturn null;\n\t\t}\n\t}\n\n\t/**\n\t * Return the first event in the timeline without removing it\n\t * @returns {Object} The first event object\n\t */\n\tpeek(): GenericEvent | undefined {\n\t\treturn this._timeline[0];\n\t}\n\n\t/**\n\t * Return the first event in the timeline and remove it\n\t */\n\tshift(): GenericEvent | undefined {\n\t\treturn this._timeline.shift();\n\t}\n\n\t/**\n\t * Get the event which is scheduled after the given time.\n\t * @param  time  The time to query.\n\t */\n\tgetAfter(time: number, param: TimelineSearchParam = \"time\"): GenericEvent | null {\n\t\tconst index = this._search(time, param);\n\t\tif (index + 1 < this._timeline.length) {\n\t\t\treturn this._timeline[index + 1];\n\t\t} else {\n\t\t\treturn null;\n\t\t}\n\t}\n\n\t/**\n\t * Get the event before the event at the given time.\n\t * @param  time  The time to query.\n\t */\n\tgetBefore(time: number): GenericEvent | null {\n\t\tconst len = this._timeline.length;\n\t\t// if it's after the last item, return the last item\n\t\tif (len > 0 && this._timeline[len - 1].time < time) {\n\t\t\treturn this._timeline[len - 1];\n\t\t}\n\t\tconst index = this._search(time);\n\t\tif (index - 1 >= 0) {\n\t\t\treturn this._timeline[index - 1];\n\t\t} else {\n\t\t\treturn null;\n\t\t}\n\t}\n\n\t/**\n\t * Cancel events at and after the given time\n\t * @param  after  The time to query.\n\t */\n\tcancel(after: number): this {\n\t\tif (this._timeline.length > 1) {\n\t\t\tlet index = this._search(after);\n\t\t\tif (index >= 0) {\n\t\t\t\tif (EQ(this._timeline[index].time, after)) {\n\t\t\t\t\t// get the first item with that time\n\t\t\t\t\tfor (let i = index; i >= 0; i--) {\n\t\t\t\t\t\tif (EQ(this._timeline[i].time, after)) {\n\t\t\t\t\t\t\tindex = i;\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\tthis._timeline = this._timeline.slice(0, index);\n\t\t\t\t} else {\n\t\t\t\t\tthis._timeline = this._timeline.slice(0, index + 1);\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tthis._timeline = [];\n\t\t\t}\n\t\t} else if (this._timeline.length === 1) {\n\t\t\t// the first item's time\n\t\t\tif (GTE(this._timeline[0].time, after)) {\n\t\t\t\tthis._timeline = [];\n\t\t\t}\n\t\t}\n\t\treturn this;\n\t}\n\n\t/**\n\t * Cancel events before or equal to the given time.\n\t * @param  time  The time to cancel before.\n\t */\n\tcancelBefore(time: number): this {\n\t\tconst index = this._search(time);\n\t\tif (index >= 0) {\n\t\t\tthis._timeline = this._timeline.slice(index + 1);\n\t\t}\n\t\treturn this;\n\t}\n\n\t/**\n\t * Returns the previous event if there is one. null otherwise\n\t * @param  event The event to find the previous one of\n\t * @return The event right before the given event\n\t */\n\tpreviousEvent(event: GenericEvent): GenericEvent | null {\n\t\tconst index = this._timeline.indexOf(event);\n\t\tif (index > 0) {\n\t\t\treturn this._timeline[index - 1];\n\t\t} else {\n\t\t\treturn null;\n\t\t}\n\t}\n\n\t/**\n\t * Does a binary search on the timeline array and returns the\n\t * nearest event index whose time is after or equal to the given time.\n\t * If a time is searched before the first index in the timeline, -1 is returned.\n\t * If the time is after the end, the index of the last item is returned.\n\t */\n\tprotected _search(time: number, param: TimelineSearchParam = \"time\"): number {\n\t\tif (this._timeline.length === 0) {\n\t\t\treturn -1;\n\t\t}\n\t\tlet beginning = 0;\n\t\tconst len = this._timeline.length;\n\t\tlet end = len;\n\t\tif (len > 0 && this._timeline[len - 1][param] <= time) {\n\t\t\treturn len - 1;\n\t\t}\n\t\twhile (beginning < end) {\n\t\t\t// calculate the midpoint for roughly equal partition\n\t\t\tlet midPoint = Math.floor(beginning + (end - beginning) / 2);\n\t\t\tconst event = this._timeline[midPoint];\n\t\t\tconst nextEvent = this._timeline[midPoint + 1];\n\t\t\tif (EQ(event[param], time)) {\n\t\t\t\t// choose the last one that has the same time\n\t\t\t\tfor (let i = midPoint; i < this._timeline.length; i++) {\n\t\t\t\t\tconst testEvent = this._timeline[i];\n\t\t\t\t\tif (EQ(testEvent[param], time)) {\n\t\t\t\t\t\tmidPoint = i;\n\t\t\t\t\t} else {\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\treturn midPoint;\n\t\t\t} else if (LT(event[param], time) && GT(nextEvent[param], time)) {\n\t\t\t\treturn midPoint;\n\t\t\t} else if (GT(event[param], time)) {\n\t\t\t\t// search lower\n\t\t\t\tend = midPoint;\n\t\t\t} else {\n\t\t\t\t// search upper\n\t\t\t\tbeginning = midPoint + 1;\n\t\t\t}\n\t\t}\n\t\treturn -1;\n\t}\n\n\t/**\n\t * Internal iterator. Applies extra safety checks for\n\t * removing items from the array.\n\t */\n\tprivate _iterate(\n\t\tcallback: (event: GenericEvent) => void,\n\t\tlowerBound = 0, upperBound = this._timeline.length - 1,\n\t): void {\n\t\tthis._timeline.slice(lowerBound, upperBound + 1).forEach(callback);\n\t}\n\n\t/**\n\t * Iterate over everything in the array\n\t * @param  callback The callback to invoke with every item\n\t */\n\tforEach(callback: (event: GenericEvent) => void): this {\n\t\tthis._iterate(callback);\n\t\treturn this;\n\t}\n\n\t/**\n\t * Iterate over everything in the array at or before the given time.\n\t * @param  time The time to check if items are before\n\t * @param  callback The callback to invoke with every item\n\t */\n\tforEachBefore(time: Seconds, callback: (event: GenericEvent) => void): this {\n\t\t// iterate over the items in reverse so that removing an item doesn't break things\n\t\tconst upperBound = this._search(time);\n\t\tif (upperBound !== -1) {\n\t\t\tthis._iterate(callback, 0, upperBound);\n\t\t}\n\t\treturn this;\n\t}\n\n\t/**\n\t * Iterate over everything in the array after the given time.\n\t * @param  time The time to check if items are before\n\t * @param  callback The callback to invoke with every item\n\t */\n\tforEachAfter(time: Seconds, callback: (event: GenericEvent) => void): this {\n\t\t// iterate over the items in reverse so that removing an item doesn't break things\n\t\tconst lowerBound = this._search(time);\n\t\tthis._iterate(callback, lowerBound + 1);\n\t\treturn this;\n\t}\n\n\t/**\n\t * Iterate over everything in the array between the startTime and endTime.\n\t * The timerange is inclusive of the startTime, but exclusive of the endTime.\n\t * range = [startTime, endTime).\n\t * @param  startTime The time to check if items are before\n\t * @param  endTime The end of the test interval.\n\t * @param  callback The callback to invoke with every item\n\t */\n\tforEachBetween(startTime: number, endTime: number, callback: (event: GenericEvent) => void): this {\n\t\tlet lowerBound = this._search(startTime);\n\t\tlet upperBound = this._search(endTime);\n\t\tif (lowerBound !== -1 && upperBound !== -1) {\n\t\t\tif (this._timeline[lowerBound].time !== startTime) {\n\t\t\t\tlowerBound += 1;\n\t\t\t}\n\t\t\t// exclusive of the end time\n\t\t\tif (this._timeline[upperBound].time === endTime) {\n\t\t\t\tupperBound -= 1;\n\t\t\t}\n\t\t\tthis._iterate(callback, lowerBound, upperBound);\n\t\t} else if (lowerBound === -1) {\n\t\t\tthis._iterate(callback, 0, upperBound);\n\t\t}\n\t\treturn this;\n\t}\n\n\t/**\n\t * Iterate over everything in the array at or after the given time. Similar to\n\t * forEachAfter, but includes the item(s) at the given time.\n\t * @param  time The time to check if items are before\n\t * @param  callback The callback to invoke with every item\n\t */\n\tforEachFrom(time: number, callback: (event: GenericEvent) => void): this {\n\t\t// iterate over the items in reverse so that removing an item doesn't break things\n\t\tlet lowerBound = this._search(time);\n\t\t// work backwards until the event time is less than time\n\t\twhile (lowerBound >= 0 && this._timeline[lowerBound].time >= time) {\n\t\t\tlowerBound--;\n\t\t}\n\t\tthis._iterate(callback, lowerBound + 1);\n\t\treturn this;\n\t}\n\n\t/**\n\t * Iterate over everything in the array at the given time\n\t * @param  time The time to check if items are before\n\t * @param  callback The callback to invoke with every item\n\t */\n\tforEachAtTime(time: number, callback: (event: GenericEvent) => void): this {\n\t\t// iterate over the items in reverse so that removing an item doesn't break things\n\t\tconst upperBound = this._search(time);\n\t\tif (upperBound !== -1 && EQ(this._timeline[upperBound].time, time)) {\n\t\t\tlet lowerBound = upperBound;\n\t\t\tfor (let i = upperBound; i >= 0; i--) {\n\t\t\t\tif (EQ(this._timeline[i].time, time)) {\n\t\t\t\t\tlowerBound = i;\n\t\t\t\t} else {\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t\tthis._iterate(event => {\n\t\t\t\tcallback(event);\n\t\t\t}, lowerBound, upperBound);\n\t\t}\n\t\treturn this;\n\t}\n\n\t/**\n\t * Clean up.\n\t */\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis._timeline = [];\n\t\treturn this;\n\t}\n}\n","//-------------------------------------\n// INITIALIZING NEW CONTEXT\n//-------------------------------------\n\ntype Context = import(\"./Context\").Context;\n\n/**\n * Array of callbacks to invoke when a new context is created\n */\nconst notifyNewContext: Array<(ctx: Context) => void> = [];\n\n/**\n * Used internally to setup a new Context\n */\nexport function onContextInit(cb: (ctx: Context) => void): void {\n\tnotifyNewContext.push(cb);\n}\n\n/**\n * Invoke any classes which need to also be initialized when a new context is created.\n */\nexport function initializeContext(ctx: Context): void {\n\t// add any additional modules\n\tnotifyNewContext.forEach(cb => cb(ctx));\n}\n\n/**\n * Array of callbacks to invoke when a new context is closed\n */\nconst notifyCloseContext: Array<(ctx: Context) => void> = [];\n\n/**\n * Used internally to tear down a Context\n */\nexport function onContextClose(cb: (ctx: Context) => void): void {\n\tnotifyCloseContext.push(cb);\n}\n\nexport function closeContext(ctx: Context): void {\n\t// remove any additional modules\n\tnotifyCloseContext.forEach(cb => cb(ctx));\n}\n","import { Tone } from \"../Tone\";\nimport { isUndef } from \"./TypeCheck\";\n\nexport interface EmitterEventObject {\n\t[event: string]: Array<(...args: any[]) => void>;\n}\n\n/**\n * Emitter gives classes which extend it\n * the ability to listen for and emit events.\n * Inspiration and reference from Jerome Etienne's [MicroEvent](https://github.com/jeromeetienne/microevent.js).\n * MIT (c) 2011 Jerome Etienne.\n * @category Core\n */\nexport class Emitter<EventType extends string = string> extends Tone {\n\n\treadonly name: string = \"Emitter\";\n\n\t/**\n\t * Private container for the events\n\t */\n\tprivate _events?: EmitterEventObject;\n\n\t/**\n\t * Bind a callback to a specific event.\n\t * @param  event     The name of the event to listen for.\n\t * @param  callback  The callback to invoke when the event is emitted\n\t */\n\ton(event: EventType, callback: (...args: any[]) => void): this {\n\t\t// split the event\n\t\tconst events = event.split(/\\W+/);\n\t\tevents.forEach(eventName => {\n\t\t\tif (isUndef(this._events)) {\n\t\t\t\tthis._events = {};\n\t\t\t}\n\t\t\tif (!this._events.hasOwnProperty(eventName)) {\n\t\t\t\tthis._events[eventName] = [];\n\t\t\t}\n\t\t\tthis._events[eventName].push(callback);\n\t\t});\n\t\treturn this;\n\t}\n\n\t/**\n\t * Bind a callback which is only invoked once\n\t * @param  event     The name of the event to listen for.\n\t * @param  callback  The callback to invoke when the event is emitted\n\t */\n\tonce(event: EventType, callback: (...args: any[]) => void): this {\n\t\tconst boundCallback = (...args: any[]) => {\n\t\t\t// invoke the callback\n\t\t\tcallback(...args);\n\t\t\t// remove the event\n\t\t\tthis.off(event, boundCallback);\n\t\t};\n\t\tthis.on(event, boundCallback);\n\t\treturn this;\n\t}\n\n\t/**\n\t * Remove the event listener.\n\t * @param  event     The event to stop listening to.\n\t * @param  callback  The callback which was bound to the event with Emitter.on.\n\t *                   If no callback is given, all callbacks events are removed.\n\t */\n\toff(event: EventType, callback?: (...args: any[]) => void): this {\n\t\tconst events = event.split(/\\W+/);\n\t\tevents.forEach(eventName => {\n\t\t\tif (isUndef(this._events)) {\n\t\t\t\tthis._events = {};\n\t\t\t}\n\t\t\tif (this._events.hasOwnProperty(eventName)) {\n\t\t\t\tif (isUndef(callback)) {\n\t\t\t\t\tthis._events[eventName] = [];\n\t\t\t\t} else {\n\t\t\t\t\tconst eventList = this._events[eventName];\n\t\t\t\t\tfor (let i = eventList.length - 1; i >= 0; i--) {\n\t\t\t\t\t\tif (eventList[i] === callback) {\n\t\t\t\t\t\t\teventList.splice(i, 1);\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t});\n\t\treturn this;\n\t}\n\n\t/**\n\t * Invoke all of the callbacks bound to the event\n\t * with any arguments passed in.\n\t * @param  event  The name of the event.\n\t * @param args The arguments to pass to the functions listening.\n\t */\n\temit(event, ...args: any[]): this {\n\t\tif (this._events) {\n\t\t\tif (this._events.hasOwnProperty(event)) {\n\t\t\t\tconst eventList = this._events[event].slice(0);\n\t\t\t\tfor (let i = 0, len = eventList.length; i < len; i++) {\n\t\t\t\t\teventList[i].apply(this, args);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\treturn this;\n\t}\n\n\t/**\n\t * Add Emitter functions (on/off/emit) to the object\n\t */\n\tstatic mixin(constr: any): void {\n\t\t// instance._events = {};\n\t\t[\"on\", \"once\", \"off\", \"emit\"].forEach(name => {\n\t\t\tconst property = Object.getOwnPropertyDescriptor(Emitter.prototype, name) as PropertyDescriptor;\n\t\t\tObject.defineProperty(constr.prototype, name, property);\n\t\t});\n\t}\n\n\t/**\n\t * Clean up\n\t */\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis._events = undefined;\n\t\treturn this;\n\t}\n}\n","import { Seconds } from \"../type/Units\";\nimport { Emitter } from \"../util/Emitter\";\nimport { AnyAudioContext } from \"./AudioContext\";\n\ntype Draw = import(\"../util/Draw\").Draw;\ntype Destination = import(\"./Destination\").Destination;\ntype Transport = import(\"../clock/Transport\").Transport;\ntype Listener = import(\"./Listener\").Listener;\n\n// these are either not used in Tone.js or deprecated and not implemented.\nexport type ExcludedFromBaseAudioContext =\n\t| \"onstatechange\"\n\t| \"addEventListener\"\n\t| \"removeEventListener\"\n\t| \"listener\"\n\t| \"dispatchEvent\"\n\t| \"audioWorklet\"\n\t| \"destination\"\n\t| \"createScriptProcessor\";\n\n// the subset of the BaseAudioContext which Tone.Context implements.\nexport type BaseAudioContextSubset = Omit<\nBaseAudioContext,\nExcludedFromBaseAudioContext\n>;\n\nexport type ContextLatencyHint = AudioContextLatencyCategory;\n\nexport abstract class BaseContext\n\textends Emitter<\"statechange\" | \"tick\">\n\timplements BaseAudioContextSubset {\n\t//---------------------------\n\t// BASE AUDIO CONTEXT METHODS\n\t//---------------------------\n\tabstract createAnalyser(): AnalyserNode;\n\n\tabstract createOscillator(): OscillatorNode;\n\n\tabstract createBufferSource(): AudioBufferSourceNode;\n\n\tabstract createBiquadFilter(): BiquadFilterNode;\n\n\tabstract createBuffer(\n\t\t_numberOfChannels: number,\n\t\t_length: number,\n\t\t_sampleRate: number\n\t): AudioBuffer;\n\n\tabstract createChannelMerger(\n\t\t_numberOfInputs?: number | undefined\n\t): ChannelMergerNode;\n\n\tabstract createChannelSplitter(\n\t\t_numberOfOutputs?: number | undefined\n\t): ChannelSplitterNode;\n\n\tabstract createConstantSource(): ConstantSourceNode;\n\n\tabstract createConvolver(): ConvolverNode;\n\n\tabstract createDelay(_maxDelayTime?: number | undefined): DelayNode;\n\n\tabstract createDynamicsCompressor(): DynamicsCompressorNode;\n\n\tabstract createGain(): GainNode;\n\n\tabstract createIIRFilter(\n\t\t_feedForward: number[] | Float32Array,\n\t\t_feedback: number[] | Float32Array\n\t): IIRFilterNode;\n\n\tabstract createPanner(): PannerNode;\n\n\tabstract createPeriodicWave(\n\t\t_real: number[] | Float32Array,\n\t\t_imag: number[] | Float32Array,\n\t\t_constraints?: PeriodicWaveConstraints | undefined\n\t): PeriodicWave;\n\n\tabstract createStereoPanner(): StereoPannerNode;\n\n\tabstract createWaveShaper(): WaveShaperNode;\n\n\tabstract createMediaStreamSource(\n\t\t_stream: MediaStream\n\t): MediaStreamAudioSourceNode;\n\n\tabstract createMediaElementSource(\n\t\t_element: HTMLMediaElement\n\t): MediaElementAudioSourceNode;\n\n\tabstract createMediaStreamDestination(): MediaStreamAudioDestinationNode;\n\n\tabstract decodeAudioData(_audioData: ArrayBuffer): Promise<AudioBuffer>;\n\n\t//---------------------------\n\t// TONE AUDIO CONTEXT METHODS\n\t//---------------------------\n\n\tabstract createAudioWorkletNode(\n\t\t_name: string,\n\t\t_options?: Partial<AudioWorkletNodeOptions>\n\t): AudioWorkletNode;\n\n\tabstract get rawContext(): AnyAudioContext;\n\n\tabstract addAudioWorkletModule(\n\t\t_url: string,\n\t\t_name: string\n\t): Promise<void>;\n\n\tabstract lookAhead: number;\n\n\tabstract latencyHint: ContextLatencyHint | Seconds;\n\n\tabstract resume(): Promise<void>;\n\n\tabstract setTimeout(\n\t\t_fn: (...args: any[]) => void,\n\t\t_timeout: Seconds\n\t): number;\n\n\tabstract clearTimeout(_id: number): this;\n\n\tabstract setInterval(\n\t\t_fn: (...args: any[]) => void,\n\t\t_interval: Seconds\n\t): number;\n\n\tabstract clearInterval(_id: number): this;\n\n\tabstract getConstant(_val: number): AudioBufferSourceNode;\n\n\tabstract get currentTime(): Seconds;\n\n\tabstract get state(): AudioContextState;\n\n\tabstract get sampleRate(): number;\n\n\tabstract get listener(): Listener;\n\n\tabstract get transport(): Transport;\n\n\tabstract get draw(): Draw;\n\n\tabstract get destination(): Destination;\n\n\tabstract now(): Seconds;\n\n\tabstract immediate(): Seconds;\n\n\t/*\n\t * This is a placeholder so that JSON.stringify does not throw an error\n\t * This matches what JSON.stringify(audioContext) returns on a native\n\t * audioContext instance.\n\t */\n\ttoJSON(): Record<string, any> {\n\t\treturn {};\n\t}\n\n\treadonly isOffline: boolean = false;\n}\n","import { Ticker, TickerClockSource } from \"../clock/Ticker\";\nimport { Seconds } from \"../type/Units\";\nimport { isAudioContext } from \"../util/AdvancedTypeCheck\";\nimport { optionsFromArguments } from \"../util/Defaults\";\nimport { Timeline } from \"../util/Timeline\";\nimport { isDefined, isString } from \"../util/TypeCheck\";\nimport {\n\tAnyAudioContext,\n\tcreateAudioContext,\n\tcreateAudioWorkletNode,\n} from \"./AudioContext\";\nimport { closeContext, initializeContext } from \"./ContextInitialization\";\nimport { BaseContext, ContextLatencyHint } from \"./BaseContext\";\nimport { assert } from \"../util/Debug\";\n\ntype Transport = import(\"../clock/Transport\").Transport;\ntype Destination = import(\"./Destination\").Destination;\ntype Listener = import(\"./Listener\").Listener;\ntype Draw = import(\"../util/Draw\").Draw;\n\nexport interface ContextOptions {\n\tclockSource: TickerClockSource;\n\tlatencyHint: ContextLatencyHint;\n\tlookAhead: Seconds;\n\tupdateInterval: Seconds;\n\tcontext: AnyAudioContext;\n}\n\nexport interface ContextTimeoutEvent {\n\tcallback: (...args: any[]) => void;\n\tid: number;\n\ttime: Seconds;\n}\n\n/**\n * Wrapper around the native AudioContext.\n * @category Core\n */\nexport class Context extends BaseContext {\n\treadonly name: string = \"Context\";\n\n\t/**\n\t * The amount of time into the future events are scheduled. Giving Web Audio\n\t * a short amount of time into the future to schedule events can reduce clicks and\n\t * improve performance. This value can be set to 0 to get the lowest latency.\n\t */\n\tlookAhead: Seconds;\n\n\t/**\n\t * private reference to the BaseAudioContext\n\t */\n\tprotected readonly _context: AnyAudioContext;\n\n\t/**\n\t * A reliable callback method\n\t */\n\tprivate readonly _ticker: Ticker;\n\n\t/**\n\t * The default latency hint\n\t */\n\tprivate _latencyHint!: ContextLatencyHint | Seconds;\n\n\t/**\n\t * An object containing all of the constants AudioBufferSourceNodes\n\t */\n\tprivate _constants = new Map<number, AudioBufferSourceNode>();\n\n\t/**\n\t * All of the setTimeout events.\n\t */\n\tprivate _timeouts: Timeline<ContextTimeoutEvent> = new Timeline();\n\n\t/**\n\t * The timeout id counter\n\t */\n\tprivate _timeoutIds = 0;\n\n\t/**\n\t * A reference the Transport singleton belonging to this context\n\t */\n\tprivate _transport!: Transport;\n\n\t/**\n\t * A reference the Listener singleton belonging to this context\n\t */\n\tprivate _listener!: Listener;\n\n\t/**\n\t * A reference the Destination singleton belonging to this context\n\t */\n\tprivate _destination!: Destination;\n\n\t/**\n\t * A reference the Transport singleton belonging to this context\n\t */\n\tprivate _draw!: Draw;\n\n\t/**\n\t * Private indicator if the context has been initialized\n\t */\n\tprivate _initialized = false;\n\n\t/**\n\t * Indicates if the context is an OfflineAudioContext or an AudioContext\n\t */\n\treadonly isOffline: boolean = false;\n\n\tconstructor(context?: AnyAudioContext);\n\tconstructor(options?: Partial<ContextOptions>);\n\tconstructor() {\n\t\tsuper();\n\t\tconst options = optionsFromArguments(Context.getDefaults(), arguments, [\n\t\t\t\"context\",\n\t\t]);\n\n\t\tif (options.context) {\n\t\t\tthis._context = options.context;\n\t\t} else {\n\t\t\tthis._context = createAudioContext({\n\t\t\t\tlatencyHint: options.latencyHint,\n\t\t\t});\n\t\t}\n\n\t\tthis._ticker = new Ticker(\n\t\t\tthis.emit.bind(this, \"tick\"),\n\t\t\toptions.clockSource,\n\t\t\toptions.updateInterval\n\t\t);\n\t\tthis.on(\"tick\", this._timeoutLoop.bind(this));\n\n\t\t// fwd events from the context\n\t\tthis._context.onstatechange = () => {\n\t\t\tthis.emit(\"statechange\", this.state);\n\t\t};\n\n\t\tthis._setLatencyHint(options.latencyHint);\n\t\tthis.lookAhead = options.lookAhead;\n\t}\n\n\tstatic getDefaults(): ContextOptions {\n\t\treturn {\n\t\t\tclockSource: \"worker\",\n\t\t\tlatencyHint: \"interactive\",\n\t\t\tlookAhead: 0.1,\n\t\t\tupdateInterval: 0.05,\n\t\t} as ContextOptions;\n\t}\n\n\t/**\n\t * Finish setting up the context. **You usually do not need to do this manually.**\n\t */\n\tprivate initialize(): this {\n\t\tif (!this._initialized) {\n\t\t\t// add any additional modules\n\t\t\tinitializeContext(this);\n\t\t\tthis._initialized = true;\n\t\t}\n\t\treturn this;\n\t}\n\n\t//---------------------------\n\t// BASE AUDIO CONTEXT METHODS\n\t//---------------------------\n\n\tcreateAnalyser(): AnalyserNode {\n\t\treturn this._context.createAnalyser();\n\t}\n\tcreateOscillator(): OscillatorNode {\n\t\treturn this._context.createOscillator();\n\t}\n\tcreateBufferSource(): AudioBufferSourceNode {\n\t\treturn this._context.createBufferSource();\n\t}\n\tcreateBiquadFilter(): BiquadFilterNode {\n\t\treturn this._context.createBiquadFilter();\n\t}\n\tcreateBuffer(\n\t\tnumberOfChannels: number,\n\t\tlength: number,\n\t\tsampleRate: number\n\t): AudioBuffer {\n\t\treturn this._context.createBuffer(numberOfChannels, length, sampleRate);\n\t}\n\tcreateChannelMerger(\n\t\tnumberOfInputs?: number | undefined\n\t): ChannelMergerNode {\n\t\treturn this._context.createChannelMerger(numberOfInputs);\n\t}\n\tcreateChannelSplitter(\n\t\tnumberOfOutputs?: number | undefined\n\t): ChannelSplitterNode {\n\t\treturn this._context.createChannelSplitter(numberOfOutputs);\n\t}\n\tcreateConstantSource(): ConstantSourceNode {\n\t\treturn this._context.createConstantSource();\n\t}\n\tcreateConvolver(): ConvolverNode {\n\t\treturn this._context.createConvolver();\n\t}\n\tcreateDelay(maxDelayTime?: number | undefined): DelayNode {\n\t\treturn this._context.createDelay(maxDelayTime);\n\t}\n\tcreateDynamicsCompressor(): DynamicsCompressorNode {\n\t\treturn this._context.createDynamicsCompressor();\n\t}\n\tcreateGain(): GainNode {\n\t\treturn this._context.createGain();\n\t}\n\tcreateIIRFilter(\n\t\tfeedForward: number[] | Float32Array,\n\t\tfeedback: number[] | Float32Array\n\t): IIRFilterNode {\n\t\t// @ts-ignore\n\t\treturn this._context.createIIRFilter(feedForward, feedback);\n\t}\n\tcreatePanner(): PannerNode {\n\t\treturn this._context.createPanner();\n\t}\n\tcreatePeriodicWave(\n\t\treal: number[] | Float32Array,\n\t\timag: number[] | Float32Array,\n\t\tconstraints?: PeriodicWaveConstraints | undefined\n\t): PeriodicWave {\n\t\treturn this._context.createPeriodicWave(real, imag, constraints);\n\t}\n\tcreateStereoPanner(): StereoPannerNode {\n\t\treturn this._context.createStereoPanner();\n\t}\n\tcreateWaveShaper(): WaveShaperNode {\n\t\treturn this._context.createWaveShaper();\n\t}\n\tcreateMediaStreamSource(stream: MediaStream): MediaStreamAudioSourceNode {\n\t\tassert(\n\t\t\tisAudioContext(this._context),\n\t\t\t\"Not available if OfflineAudioContext\"\n\t\t);\n\t\tconst context = this._context as AudioContext;\n\t\treturn context.createMediaStreamSource(stream);\n\t}\n\tcreateMediaElementSource(\n\t\telement: HTMLMediaElement\n\t): MediaElementAudioSourceNode {\n\t\tassert(\n\t\t\tisAudioContext(this._context),\n\t\t\t\"Not available if OfflineAudioContext\"\n\t\t);\n\t\tconst context = this._context as AudioContext;\n\t\treturn context.createMediaElementSource(element);\n\t}\n\tcreateMediaStreamDestination(): MediaStreamAudioDestinationNode {\n\t\tassert(\n\t\t\tisAudioContext(this._context),\n\t\t\t\"Not available if OfflineAudioContext\"\n\t\t);\n\t\tconst context = this._context as AudioContext;\n\t\treturn context.createMediaStreamDestination();\n\t}\n\tdecodeAudioData(audioData: ArrayBuffer): Promise<AudioBuffer> {\n\t\treturn this._context.decodeAudioData(audioData);\n\t}\n\n\t/**\n\t * The current time in seconds of the AudioContext.\n\t */\n\tget currentTime(): Seconds {\n\t\treturn this._context.currentTime;\n\t}\n\t/**\n\t * The current time in seconds of the AudioContext.\n\t */\n\tget state(): AudioContextState {\n\t\treturn this._context.state;\n\t}\n\t/**\n\t * The current time in seconds of the AudioContext.\n\t */\n\tget sampleRate(): number {\n\t\treturn this._context.sampleRate;\n\t}\n\n\t/**\n\t * The listener\n\t */\n\tget listener(): Listener {\n\t\tthis.initialize();\n\t\treturn this._listener;\n\t}\n\tset listener(l) {\n\t\tassert(\n\t\t\t!this._initialized,\n\t\t\t\"The listener cannot be set after initialization.\"\n\t\t);\n\t\tthis._listener = l;\n\t}\n\n\t/**\n\t * There is only one Transport per Context. It is created on initialization.\n\t */\n\tget transport(): Transport {\n\t\tthis.initialize();\n\t\treturn this._transport;\n\t}\n\tset transport(t: Transport) {\n\t\tassert(\n\t\t\t!this._initialized,\n\t\t\t\"The transport cannot be set after initialization.\"\n\t\t);\n\t\tthis._transport = t;\n\t}\n\n\t/**\n\t * This is the Draw object for the context which is useful for synchronizing the draw frame with the Tone.js clock.\n\t */\n\tget draw(): Draw {\n\t\tthis.initialize();\n\t\treturn this._draw;\n\t}\n\tset draw(d) {\n\t\tassert(!this._initialized, \"Draw cannot be set after initialization.\");\n\t\tthis._draw = d;\n\t}\n\n\t/**\n\t * A reference to the Context's destination node.\n\t */\n\tget destination(): Destination {\n\t\tthis.initialize();\n\t\treturn this._destination;\n\t}\n\tset destination(d: Destination) {\n\t\tassert(\n\t\t\t!this._initialized,\n\t\t\t\"The destination cannot be set after initialization.\"\n\t\t);\n\t\tthis._destination = d;\n\t}\n\n\t//--------------------------------------------\n\t// AUDIO WORKLET\n\t//--------------------------------------------\n\n\t/**\n\t * Maps a module name to promise of the addModule method\n\t */\n\tprivate _workletModules: Map<string, Promise<void>> = new Map();\n\n\t/**\n\t * Create an audio worklet node from a name and options. The module\n\t * must first be loaded using [[addAudioWorkletModule]].\n\t */\n\tcreateAudioWorkletNode(\n\t\tname: string,\n\t\toptions?: Partial<AudioWorkletNodeOptions>\n\t): AudioWorkletNode {\n\t\treturn createAudioWorkletNode(this.rawContext, name, options);\n\t}\n\n\t/**\n\t * Add an AudioWorkletProcessor module\n\t * @param url The url of the module\n\t * @param name The name of the module\n\t */\n\tasync addAudioWorkletModule(url: string, name: string): Promise<void> {\n\t\tassert(\n\t\t\tisDefined(this.rawContext.audioWorklet),\n\t\t\t\"AudioWorkletNode is only available in a secure context (https or localhost)\"\n\t\t);\n\t\tif (!this._workletModules.has(name)) {\n\t\t\tthis._workletModules.set(\n\t\t\t\tname,\n\t\t\t\tthis.rawContext.audioWorklet.addModule(url)\n\t\t\t);\n\t\t}\n\t\tawait this._workletModules.get(name);\n\t}\n\n\t/**\n\t * Returns a promise which resolves when all of the worklets have been loaded on this context\n\t */\n\tprotected async workletsAreReady(): Promise<void> {\n\t\tconst promises: Promise<void>[] = [];\n\t\tthis._workletModules.forEach((promise) => promises.push(promise));\n\t\tawait Promise.all(promises);\n\t}\n\n\t//---------------------------\n\t// TICKER\n\t//---------------------------\n\n\t/**\n\t * How often the interval callback is invoked.\n\t * This number corresponds to how responsive the scheduling\n\t * can be. context.updateInterval + context.lookAhead gives you the\n\t * total latency between scheduling an event and hearing it.\n\t */\n\tget updateInterval(): Seconds {\n\t\treturn this._ticker.updateInterval;\n\t}\n\tset updateInterval(interval: Seconds) {\n\t\tthis._ticker.updateInterval = interval;\n\t}\n\n\t/**\n\t * What the source of the clock is, either \"worker\" (default),\n\t * \"timeout\", or \"offline\" (none).\n\t */\n\tget clockSource(): TickerClockSource {\n\t\treturn this._ticker.type;\n\t}\n\tset clockSource(type: TickerClockSource) {\n\t\tthis._ticker.type = type;\n\t}\n\n\t/**\n\t * The type of playback, which affects tradeoffs between audio\n\t * output latency and responsiveness.\n\t * In addition to setting the value in seconds, the latencyHint also\n\t * accepts the strings \"interactive\" (prioritizes low latency),\n\t * \"playback\" (prioritizes sustained playback), \"balanced\" (balances\n\t * latency and performance).\n\t * @example\n\t * // prioritize sustained playback\n\t * const context = new Tone.Context({ latencyHint: \"playback\" });\n\t * // set this context as the global Context\n\t * Tone.setContext(context);\n\t * // the global context is gettable with Tone.getContext()\n\t * console.log(Tone.getContext().latencyHint);\n\t */\n\tget latencyHint(): ContextLatencyHint | Seconds {\n\t\treturn this._latencyHint;\n\t}\n\n\t/**\n\t * Update the lookAhead and updateInterval based on the latencyHint\n\t */\n\tprivate _setLatencyHint(hint: ContextLatencyHint | Seconds): void {\n\t\tlet lookAheadValue = 0;\n\t\tthis._latencyHint = hint;\n\t\tif (isString(hint)) {\n\t\t\tswitch (hint) {\n\t\t\t\tcase \"interactive\":\n\t\t\t\t\tlookAheadValue = 0.1;\n\t\t\t\t\tbreak;\n\t\t\t\tcase \"playback\":\n\t\t\t\t\tlookAheadValue = 0.5;\n\t\t\t\t\tbreak;\n\t\t\t\tcase \"balanced\":\n\t\t\t\t\tlookAheadValue = 0.25;\n\t\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\t\tthis.lookAhead = lookAheadValue;\n\t\tthis.updateInterval = lookAheadValue / 2;\n\t}\n\n\t/**\n\t * The unwrapped AudioContext or OfflineAudioContext\n\t */\n\tget rawContext(): AnyAudioContext {\n\t\treturn this._context;\n\t}\n\n\t/**\n\t * The current audio context time plus a short [[lookAhead]].\n\t * @example\n\t * setInterval(() => {\n\t * \tconsole.log(\"now\", Tone.now());\n\t * }, 100);\n\t */\n\tnow(): Seconds {\n\t\treturn this._context.currentTime + this.lookAhead;\n\t}\n\n\t/**\n\t * The current audio context time without the [[lookAhead]].\n\t * In most cases it is better to use [[now]] instead of [[immediate]] since\n\t * with [[now]] the [[lookAhead]] is applied equally to _all_ components including internal components,\n\t * to making sure that everything is scheduled in sync. Mixing [[now]] and [[immediate]]\n\t * can cause some timing issues. If no lookAhead is desired, you can set the [[lookAhead]] to `0`.\n\t */\n\timmediate(): Seconds {\n\t\treturn this._context.currentTime;\n\t}\n\n\t/**\n\t * Starts the audio context from a suspended state. This is required\n\t * to initially start the AudioContext. See [[Tone.start]]\n\t */\n\tresume(): Promise<void> {\n\t\tif (isAudioContext(this._context)) {\n\t\t\treturn this._context.resume();\n\t\t} else {\n\t\t\treturn Promise.resolve();\n\t\t}\n\t}\n\n\t/**\n\t * Close the context. Once closed, the context can no longer be used and\n\t * any AudioNodes created from the context will be silent.\n\t */\n\tasync close(): Promise<void> {\n\t\tif (isAudioContext(this._context)) {\n\t\t\tawait this._context.close();\n\t\t}\n\t\tif (this._initialized) {\n\t\t\tcloseContext(this);\n\t\t}\n\t}\n\n\t/**\n\t * **Internal** Generate a looped buffer at some constant value.\n\t */\n\tgetConstant(val: number): AudioBufferSourceNode {\n\t\tif (this._constants.has(val)) {\n\t\t\treturn this._constants.get(val) as AudioBufferSourceNode;\n\t\t} else {\n\t\t\tconst buffer = this._context.createBuffer(\n\t\t\t\t1,\n\t\t\t\t128,\n\t\t\t\tthis._context.sampleRate\n\t\t\t);\n\t\t\tconst arr = buffer.getChannelData(0);\n\t\t\tfor (let i = 0; i < arr.length; i++) {\n\t\t\t\tarr[i] = val;\n\t\t\t}\n\t\t\tconst constant = this._context.createBufferSource();\n\t\t\tconstant.channelCount = 1;\n\t\t\tconstant.channelCountMode = \"explicit\";\n\t\t\tconstant.buffer = buffer;\n\t\t\tconstant.loop = true;\n\t\t\tconstant.start(0);\n\t\t\tthis._constants.set(val, constant);\n\t\t\treturn constant;\n\t\t}\n\t}\n\n\t/**\n\t * Clean up. Also closes the audio context.\n\t */\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis._ticker.dispose();\n\t\tthis._timeouts.dispose();\n\t\tObject.keys(this._constants).map((val) =>\n\t\t\tthis._constants[val].disconnect()\n\t\t);\n\t\treturn this;\n\t}\n\n\t//---------------------------\n\t// TIMEOUTS\n\t//---------------------------\n\n\t/**\n\t * The private loop which keeps track of the context scheduled timeouts\n\t * Is invoked from the clock source\n\t */\n\tprivate _timeoutLoop(): void {\n\t\tconst now = this.now();\n\t\tlet firstEvent = this._timeouts.peek();\n\t\twhile (this._timeouts.length && firstEvent && firstEvent.time <= now) {\n\t\t\t// invoke the callback\n\t\t\tfirstEvent.callback();\n\t\t\t// shift the first event off\n\t\t\tthis._timeouts.shift();\n\t\t\t// get the next one\n\t\t\tfirstEvent = this._timeouts.peek();\n\t\t}\n\t}\n\n\t/**\n\t * A setTimeout which is guaranteed by the clock source.\n\t * Also runs in the offline context.\n\t * @param  fn       The callback to invoke\n\t * @param  timeout  The timeout in seconds\n\t * @returns ID to use when invoking Context.clearTimeout\n\t */\n\tsetTimeout(fn: (...args: any[]) => void, timeout: Seconds): number {\n\t\tthis._timeoutIds++;\n\t\tconst now = this.now();\n\t\tthis._timeouts.add({\n\t\t\tcallback: fn,\n\t\t\tid: this._timeoutIds,\n\t\t\ttime: now + timeout,\n\t\t});\n\t\treturn this._timeoutIds;\n\t}\n\n\t/**\n\t * Clears a previously scheduled timeout with Tone.context.setTimeout\n\t * @param  id  The ID returned from setTimeout\n\t */\n\tclearTimeout(id: number): this {\n\t\tthis._timeouts.forEach((event) => {\n\t\t\tif (event.id === id) {\n\t\t\t\tthis._timeouts.remove(event);\n\t\t\t}\n\t\t});\n\t\treturn this;\n\t}\n\n\t/**\n\t * Clear the function scheduled by [[setInterval]]\n\t */\n\tclearInterval(id: number): this {\n\t\treturn this.clearTimeout(id);\n\t}\n\n\t/**\n\t * Adds a repeating event to the context's callback clock\n\t */\n\tsetInterval(fn: (...args: any[]) => void, interval: Seconds): number {\n\t\tconst id = ++this._timeoutIds;\n\t\tconst intervalFn = () => {\n\t\t\tconst now = this.now();\n\t\t\tthis._timeouts.add({\n\t\t\t\tcallback: () => {\n\t\t\t\t\t// invoke the callback\n\t\t\t\t\tfn();\n\t\t\t\t\t// invoke the event to repeat it\n\t\t\t\t\tintervalFn();\n\t\t\t\t},\n\t\t\t\tid,\n\t\t\t\ttime: now + interval,\n\t\t\t});\n\t\t};\n\t\t// kick it off\n\t\tintervalFn();\n\t\treturn id;\n\t}\n}\n","import { isArray } from \"./TypeCheck\";\n\n// return an interface which excludes certain keys\nexport type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;\n\n/**\n * Make the property not writable using `defineProperty`. Internal use only.\n */\nexport function readOnly(target: object, property: string | string[]): void {\n\tif (isArray(property)) {\n\t\tproperty.forEach(str => readOnly(target, str));\n\t} else {\n\t\tObject.defineProperty(target, property, {\n\t\t\tenumerable: true,\n\t\t\twritable: false,\n\t\t});\n\t}\n}\n\n/**\n * Make an attribute writeable. Internal use only.\n */\nexport function writable(target: object, property: string | string[]): void {\n\tif (isArray(property)) {\n\t\tproperty.forEach(str => writable(target, str));\n\t} else {\n\t\tObject.defineProperty(target, property, {\n\t\t\twritable: true,\n\t\t});\n\t}\n}\n\nexport const noOp: (...args: any[]) => any = () => {\n\t// no operation here!\n};\n\n/**\n * Recursive Partial taken from here: https://stackoverflow.com/a/51365037\n */\nexport type RecursivePartial<T> = {\n\t[P in keyof T]?:\n\tT[P] extends Array<infer U> ? Array<RecursivePartial<U>> :\n\t\tT[P] extends object ? RecursivePartial<T[P]> :\n\t\t\tT[P];\n};\n","import { getContext } from \"../Global\";\nimport { Tone } from \"../Tone\";\nimport { Samples, Seconds } from \"../type/Units\";\nimport { isAudioBuffer } from \"../util/AdvancedTypeCheck\";\nimport { optionsFromArguments } from \"../util/Defaults\";\nimport { noOp } from \"../util/Interface\";\nimport { isArray, isNumber, isString } from \"../util/TypeCheck\";\nimport { assert } from \"../util/Debug\";\n\ninterface ToneAudioBufferOptions {\n\turl?: string | AudioBuffer | ToneAudioBuffer;\n\treverse: boolean;\n\tonload: (buffer?: ToneAudioBuffer) => void;\n\tonerror: (error: Error) => void;\n}\n\n/**\n * AudioBuffer loading and storage. ToneAudioBuffer is used internally by all\n * classes that make requests for audio files such as Tone.Player,\n * Tone.Sampler and Tone.Convolver.\n * @example\n * const buffer = new Tone.ToneAudioBuffer(\"https://tonejs.github.io/audio/casio/A1.mp3\", () => {\n * \tconsole.log(\"loaded\");\n * });\n * @category Core\n */\nexport class ToneAudioBuffer extends Tone {\n\n\treadonly name: string = \"ToneAudioBuffer\";\n\n\t/**\n\t * stores the loaded AudioBuffer\n\t */\n\tprivate _buffer?: AudioBuffer;\n\n\t/**\n\t * indicates if the buffer should be reversed or not\n\t */\n\tprivate _reversed!: boolean;\n\n\t/**\n\t * Callback when the buffer is loaded.\n\t */\n\tonload: (buffer: ToneAudioBuffer) => void = noOp;\n\n\t/**\n\t *\n\t * @param url The url to load, or the audio buffer to set.\n\t * @param onload A callback which is invoked after the buffer is loaded.\n\t *                           It's recommended to use `ToneAudioBuffer.on('load', callback)` instead\n\t *                           since it will give you a callback when _all_ buffers are loaded.\n\t * @param onerror The callback to invoke if there is an error\n\t */\n\tconstructor(\n\t\turl?: string | ToneAudioBuffer | AudioBuffer,\n\t\tonload?: (buffer: ToneAudioBuffer) => void,\n\t\tonerror?: (error: Error) => void,\n\t);\n\tconstructor(options?: Partial<ToneAudioBufferOptions>);\n\tconstructor() {\n\n\t\tsuper();\n\n\t\tconst options = optionsFromArguments(ToneAudioBuffer.getDefaults(), arguments, [\"url\", \"onload\", \"onerror\"]);\n\n\t\tthis.reverse = options.reverse;\n\t\tthis.onload = options.onload;\n\n\t\tif (options.url && isAudioBuffer(options.url) || options.url instanceof ToneAudioBuffer) {\n\t\t\tthis.set(options.url);\n\t\t} else if (isString(options.url)) {\n\t\t\t// initiate the download\n\t\t\tthis.load(options.url).catch(options.onerror);\n\t\t}\n\t}\n\n\tstatic getDefaults(): ToneAudioBufferOptions {\n\t\treturn {\n\t\t\tonerror: noOp,\n\t\t\tonload: noOp,\n\t\t\treverse: false,\n\t\t};\n\t}\n\n\t/**\n\t * The sample rate of the AudioBuffer\n\t */\n\tget sampleRate(): number {\n\t\tif (this._buffer) {\n\t\t\treturn this._buffer.sampleRate;\n\t\t} else {\n\t\t\treturn getContext().sampleRate;\n\t\t}\n\t}\n\n\t/**\n\t * Pass in an AudioBuffer or ToneAudioBuffer to set the value of this buffer.\n\t */\n\tset(buffer: AudioBuffer | ToneAudioBuffer): this {\n\t\tif (buffer instanceof ToneAudioBuffer) {\n\t\t\t// if it's loaded, set it\n\t\t\tif (buffer.loaded) {\n\t\t\t\tthis._buffer = buffer.get();\n\t\t\t} else {\n\t\t\t\t// otherwise when it's loaded, invoke it's callback\n\t\t\t\tbuffer.onload = () => {\n\t\t\t\t\tthis.set(buffer);\n\t\t\t\t\tthis.onload(this);\n\t\t\t\t};\n\t\t\t}\n\t\t} else {\n\t\t\tthis._buffer = buffer;\n\t\t}\n\t\t// reverse it initially\n\t\tif (this._reversed) {\n\t\t\tthis._reverse();\n\t\t}\n\t\treturn this;\n\t}\n\n\t/**\n\t * The audio buffer stored in the object.\n\t */\n\tget(): AudioBuffer | undefined {\n\t\treturn this._buffer;\n\t}\n\n\t/**\n\t * Makes an fetch request for the selected url then decodes the file as an audio buffer.\n\t * Invokes the callback once the audio buffer loads.\n\t * @param url The url of the buffer to load. filetype support depends on the browser.\n\t * @returns A Promise which resolves with this ToneAudioBuffer\n\t */\n\tasync load(url: string): Promise<this> {\n\t\tconst doneLoading: Promise<void> = ToneAudioBuffer.load(url).then(audioBuffer => {\n\t\t\tthis.set(audioBuffer);\n\t\t\t// invoke the onload method\n\t\t\tthis.onload(this);\n\t\t});\n\t\tToneAudioBuffer.downloads.push(doneLoading);\n\t\ttry {\n\t\t\tawait doneLoading;\n\t\t} finally {\n\t\t\t// remove the downloaded file\n\t\t\tconst index = ToneAudioBuffer.downloads.indexOf(doneLoading);\n\t\t\tToneAudioBuffer.downloads.splice(index, 1);\n\t\t}\n\t\treturn this;\n\t}\n\n\t/**\n\t * clean up\n\t */\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis._buffer = undefined;\n\t\treturn this;\n\t}\n\n\t/**\n\t * Set the audio buffer from the array.\n\t * To create a multichannel AudioBuffer, pass in a multidimensional array.\n\t * @param array The array to fill the audio buffer\n\t */\n\tfromArray(array: Float32Array | Float32Array[]): this {\n\t\tconst isMultidimensional = isArray(array) && array[0].length > 0;\n\t\tconst channels = isMultidimensional ? array.length : 1;\n\t\tconst len = isMultidimensional ? (array[0] as Float32Array).length : array.length;\n\t\tconst context = getContext();\n\t\tconst buffer = context.createBuffer(channels, len, context.sampleRate);\n\t\tconst multiChannelArray: Float32Array[] = !isMultidimensional && channels === 1 ?\n\t\t\t[array as Float32Array] : array as Float32Array[];\n\n\t\tfor (let c = 0; c < channels; c++) {\n\t\t\tbuffer.copyToChannel(multiChannelArray[c], c);\n\t\t}\n\t\tthis._buffer = buffer;\n\t\treturn this;\n\t}\n\n\t/**\n\t * Sums multiple channels into 1 channel\n\t * @param chanNum Optionally only copy a single channel from the array.\n\t */\n\ttoMono(chanNum?: number): this {\n\t\tif (isNumber(chanNum)) {\n\t\t\tthis.fromArray(this.toArray(chanNum));\n\t\t} else {\n\t\t\tlet outputArray = new Float32Array(this.length as number);\n\t\t\tconst numChannels = this.numberOfChannels;\n\t\t\tfor (let channel = 0; channel < numChannels; channel++) {\n\t\t\t\tconst channelArray = this.toArray(channel) as Float32Array;\n\t\t\t\tfor (let i = 0; i < channelArray.length; i++) {\n\t\t\t\t\toutputArray[i] += channelArray[i];\n\t\t\t\t}\n\t\t\t}\n\t\t\t// divide by the number of channels\n\t\t\toutputArray = outputArray.map(sample => sample / numChannels);\n\t\t\tthis.fromArray(outputArray);\n\t\t}\n\t\treturn this;\n\t}\n\n\t/**\n\t * Get the buffer as an array. Single channel buffers will return a 1-dimensional\n\t * Float32Array, and multichannel buffers will return multidimensional arrays.\n\t * @param channel Optionally only copy a single channel from the array.\n\t */\n\ttoArray(channel?: number): Float32Array | Float32Array[] {\n\t\tif (isNumber(channel)) {\n\t\t\treturn this.getChannelData(channel);\n\t\t} else if (this.numberOfChannels === 1) {\n\t\t\treturn this.toArray(0);\n\t\t} else {\n\t\t\tconst ret: Float32Array[] = [];\n\t\t\tfor (let c = 0; c < this.numberOfChannels; c++) {\n\t\t\t\tret[c] = this.getChannelData(c);\n\t\t\t}\n\t\t\treturn ret;\n\t\t}\n\t}\n\n\t/**\n\t * Returns the Float32Array representing the PCM audio data for the specific channel.\n\t * @param  channel  The channel number to return\n\t * @return The audio as a TypedArray\n\t */\n\tgetChannelData(channel: number): Float32Array {\n\t\tif (this._buffer) {\n\t\t\treturn this._buffer.getChannelData(channel);\n\t\t} else {\n\t\t\treturn new Float32Array(0);\n\t\t}\n\t}\n\n\t/**\n\t * Cut a subsection of the array and return a buffer of the\n\t * subsection. Does not modify the original buffer\n\t * @param start The time to start the slice\n\t * @param end The end time to slice. If none is given will default to the end of the buffer\n\t */\n\tslice(start: Seconds, end: Seconds = this.duration): ToneAudioBuffer {\n\t\tassert(this.loaded, \"Buffer is not loaded\");\n\t\tconst startSamples = Math.floor(start * this.sampleRate);\n\t\tconst endSamples = Math.floor(end * this.sampleRate);\n\t\tassert(startSamples < endSamples, \"The start time must be less than the end time\");\n\t\tconst length = endSamples - startSamples;\n\t\tconst retBuffer = getContext().createBuffer(this.numberOfChannels, length, this.sampleRate);\n\t\tfor (let channel = 0; channel < this.numberOfChannels; channel++) {\n\t\t\tretBuffer.copyToChannel(this.getChannelData(channel).subarray(startSamples, endSamples), channel);\n\t\t}\n\t\treturn new ToneAudioBuffer(retBuffer);\n\t}\n\n\t/**\n\t * Reverse the buffer.\n\t */\n\tprivate _reverse(): this {\n\t\tif (this.loaded) {\n\t\t\tfor (let i = 0; i < this.numberOfChannels; i++) {\n\t\t\t\tthis.getChannelData(i).reverse();\n\t\t\t}\n\t\t}\n\t\treturn this;\n\t}\n\n\t/**\n\t * If the buffer is loaded or not\n\t */\n\tget loaded(): boolean {\n\t\treturn this.length > 0;\n\t}\n\n\t/**\n\t * The duration of the buffer in seconds.\n\t */\n\tget duration(): Seconds {\n\t\tif (this._buffer) {\n\t\t\treturn this._buffer.duration;\n\t\t} else {\n\t\t\treturn 0;\n\t\t}\n\t}\n\n\t/**\n\t * The length of the buffer in samples\n\t */\n\tget length(): Samples {\n\t\tif (this._buffer) {\n\t\t\treturn this._buffer.length;\n\t\t} else {\n\t\t\treturn 0;\n\t\t}\n\t}\n\n\t/**\n\t * The number of discrete audio channels. Returns 0 if no buffer is loaded.\n\t */\n\tget numberOfChannels(): number {\n\t\tif (this._buffer) {\n\t\t\treturn this._buffer.numberOfChannels;\n\t\t} else {\n\t\t\treturn 0;\n\t\t}\n\t}\n\n\t/**\n\t * Reverse the buffer.\n\t */\n\tget reverse(): boolean {\n\t\treturn this._reversed;\n\t}\n\tset reverse(rev: boolean) {\n\t\tif (this._reversed !== rev) {\n\t\t\tthis._reversed = rev;\n\t\t\tthis._reverse();\n\t\t}\n\t}\n\n\t//-------------------------------------\n\t// STATIC METHODS\n\t//-------------------------------------\n\n\t/**\n\t * A path which is prefixed before every url.\n\t */\n\tstatic baseUrl = \"\";\n\n\t/**\n\t * Create a ToneAudioBuffer from the array. To create a multichannel AudioBuffer,\n\t * pass in a multidimensional array.\n\t * @param array The array to fill the audio buffer\n\t * @return A ToneAudioBuffer created from the array\n\t */\n\tstatic fromArray(array: Float32Array | Float32Array[]): ToneAudioBuffer {\n\t\treturn (new ToneAudioBuffer()).fromArray(array);\n\t}\n\n\t/**\n\t * Creates a ToneAudioBuffer from a URL, returns a promise which resolves to a ToneAudioBuffer\n\t * @param  url The url to load.\n\t * @return A promise which resolves to a ToneAudioBuffer\n\t */\n\tstatic async fromUrl(url: string): Promise<ToneAudioBuffer> {\n\t\tconst buffer = new ToneAudioBuffer();\n\t\treturn await buffer.load(url);\n\t}\n\n\t/**\n\t * All of the downloads\n\t */\n\tstatic downloads: Array<Promise<void>> = [];\n\n\t/**\n\t * Loads a url using fetch and returns the AudioBuffer.\n\t */\n\tstatic async load(url: string): Promise<AudioBuffer> {\n\n\t\t// test if the url contains multiple extensions\n\t\tconst matches = url.match(/\\[([^\\]\\[]+\\|.+)\\]$/);\n\t\tif (matches) {\n\t\t\tconst extensions = matches[1].split(\"|\");\n\t\t\tlet extension = extensions[0];\n\t\t\tfor (const ext of extensions) {\n\t\t\t\tif (ToneAudioBuffer.supportsType(ext)) {\n\t\t\t\t\textension = ext;\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t\turl = url.replace(matches[0], extension);\n\t\t}\n\n\t\t// make sure there is a slash between the baseUrl and the url\n\t\tconst baseUrl = ToneAudioBuffer.baseUrl === \"\" || ToneAudioBuffer.baseUrl.endsWith(\"/\") ? ToneAudioBuffer.baseUrl : ToneAudioBuffer.baseUrl + \"/\";\n\t\t\n\t\t// encode special characters in file path\n\t\tconst location = document.createElement(\"a\");\n\t\tlocation.href = (baseUrl + url);\n\t\tlocation.pathname = (location.pathname + location.hash).split(\"/\").map(encodeURIComponent).join(\"/\");\n\n\t\tconst response = await fetch(location.href);\n\t\tif (!response.ok) {\n\t\t\tthrow new Error(`could not load url: ${url}`);\n\t\t}\n\t\tconst arrayBuffer = await response.arrayBuffer();\n\n\t\tconst audioBuffer = await getContext().decodeAudioData(arrayBuffer);\n\n\t\treturn audioBuffer;\n\t}\n\n\t/**\n\t * Checks a url's extension to see if the current browser can play that file type.\n\t * @param url The url/extension to test\n\t * @return If the file extension can be played\n\t * @static\n\t * @example\n\t * Tone.ToneAudioBuffer.supportsType(\"wav\"); // returns true\n\t * Tone.ToneAudioBuffer.supportsType(\"path/to/file.wav\"); // returns true\n\t */\n\tstatic supportsType(url: string): boolean {\n\t\tconst extensions = url.split(\".\");\n\t\tconst extension = extensions[extensions.length - 1];\n\t\tconst response = document.createElement(\"audio\").canPlayType(\"audio/\" + extension);\n\t\treturn response !== \"\";\n\t}\n\n\t/**\n\t * Returns a Promise which resolves when all of the buffers have loaded\n\t */\n\tstatic async loaded(): Promise<void> {\n\t\t// this makes sure that the function is always async\n\t\tawait Promise.resolve();\n\t\twhile (ToneAudioBuffer.downloads.length) {\n\t\t\tawait ToneAudioBuffer.downloads[0];\n\t\t}\n\t}\n}\n","import { createOfflineAudioContext } from \"../context/AudioContext\";\nimport { Context } from \"../context/Context\";\nimport { Seconds } from \"../type/Units\";\nimport { isOfflineAudioContext } from \"../util/AdvancedTypeCheck\";\nimport { ToneAudioBuffer } from \"./ToneAudioBuffer\";\n\n/**\n * Wrapper around the OfflineAudioContext\n * @category Core\n * @example\n * // generate a single channel, 0.5 second buffer\n * const context = new Tone.OfflineContext(1, 0.5, 44100);\n * const osc = new Tone.Oscillator({ context });\n * context.render().then(buffer => {\n * \tconsole.log(buffer.numberOfChannels, buffer.duration);\n * });\n */\nexport class OfflineContext extends Context {\n\n\treadonly name: string = \"OfflineContext\";\n\n\t/**\n\t * A private reference to the duration\n\t */\n\tprivate readonly _duration: Seconds;\n\n\t/**\n\t * An artificial clock source\n\t */\n\tprivate _currentTime: Seconds = 0;\n\n\t/**\n\t * Private reference to the OfflineAudioContext.\n\t */\n\tprotected _context!: OfflineAudioContext;\n\n\treadonly isOffline: boolean = true;\n\n\t/**\n\t * @param  channels  The number of channels to render\n\t * @param  duration  The duration to render in seconds\n\t * @param sampleRate the sample rate to render at\n\t */\n\tconstructor(\n\t\tchannels: number,\n\t\tduration: Seconds, \n\t\tsampleRate: number,\n\t);\n\tconstructor(context: OfflineAudioContext);\n\tconstructor() {\n\n\t\tsuper({\n\t\t\tclockSource: \"offline\",\n\t\t\tcontext: isOfflineAudioContext(arguments[0]) ?\n\t\t\t\targuments[0] : createOfflineAudioContext(arguments[0], arguments[1] * arguments[2], arguments[2]),\n\t\t\tlookAhead: 0,\n\t\t\tupdateInterval: isOfflineAudioContext(arguments[0]) ?\n\t\t\t\t128 / arguments[0].sampleRate : 128 / arguments[2],\n\t\t});\n\n\t\tthis._duration = isOfflineAudioContext(arguments[0]) ?\n\t\t\targuments[0].length / arguments[0].sampleRate : arguments[1];\n\t}\n\n\t/**\n\t * Override the now method to point to the internal clock time\n\t */\n\tnow(): Seconds {\n\t\treturn this._currentTime;\n\t}\n\n\t/**\n\t * Same as this.now()\n\t */\n\tget currentTime(): Seconds {\n\t\treturn this._currentTime;\n\t}\n\n\t/**\n\t * Render just the clock portion of the audio context.\n\t */\n\tprivate async _renderClock(asynchronous: boolean): Promise<void> {\n\t\tlet index = 0;\n\t\twhile (this._duration - this._currentTime >= 0) {\n\n\t\t\t// invoke all the callbacks on that time\n\t\t\tthis.emit(\"tick\");\n\n\t\t\t// increment the clock in block-sized chunks\n\t\t\tthis._currentTime += 128 / this.sampleRate;\n\n\t\t\t// yield once a second of audio\n\t\t\tindex++;\n\t\t\tconst yieldEvery = Math.floor(this.sampleRate / 128);\n\t\t\tif (asynchronous && index % yieldEvery === 0) {\n\t\t\t\tawait new Promise(done => setTimeout(done, 1));\n\t\t\t}\n\t\t}\n\t}\n\n\t/**\n\t * Render the output of the OfflineContext\n\t * @param asynchronous If the clock should be rendered asynchronously, which will not block the main thread, but be slightly slower.\n\t */\n\tasync render(asynchronous = true): Promise<ToneAudioBuffer> {\n\t\tawait this.workletsAreReady();\n\t\tawait this._renderClock(asynchronous);\n\t\tconst buffer = await this._context.startRendering();\n\t\treturn new ToneAudioBuffer(buffer);\n\t}\n\n\t/**\n\t * Close the context\n\t */\n\tclose(): Promise<void> {\n\t\treturn Promise.resolve();\n\t}\n}\n","import { version } from \"../version\";\nimport { AnyAudioContext, hasAudioContext, theWindow } from \"./context/AudioContext\";\nimport { Context } from \"./context/Context\";\nimport { DummyContext } from \"./context/DummyContext\";\nimport { BaseContext } from \"./context/BaseContext\";\nimport { OfflineContext } from \"./context/OfflineContext\";\nimport { isAudioContext, isOfflineAudioContext } from \"./util/AdvancedTypeCheck\";\n\n/**\n * This dummy context is used to avoid throwing immediate errors when importing in Node.js\n */\nconst dummyContext = new DummyContext();\n\n/**\n * The global audio context which is getable and assignable through\n * getContext and setContext\n */\nlet globalContext: BaseContext = dummyContext;\n\n/**\n * Returns the default system-wide [[Context]]\n * @category Core\n */\nexport function getContext(): BaseContext {\n\tif (globalContext === dummyContext && hasAudioContext) {\n\t\tsetContext(new Context());\n\t}\n\treturn globalContext;\n}\n\n/**\n * Set the default audio context\n * @param context\n * @param disposeOld Pass `true` if you don't need the old context to dispose it.\n * @category Core\n */\nexport function setContext(context: BaseContext | AnyAudioContext, disposeOld = false): void {\n\tif (disposeOld) {\n\t\tglobalContext.dispose();\n\t}\n\n\tif (isAudioContext(context)) {\n\t\tglobalContext = new Context(context);\n\t} else if (isOfflineAudioContext(context)) {\n\t\tglobalContext = new OfflineContext(context);\n\t} else {\n\t\tglobalContext = context;\n\t}\n}\n\n/**\n * Most browsers will not play _any_ audio until a user\n * clicks something (like a play button). Invoke this method\n * on a click or keypress event handler to start the audio context.\n * More about the Autoplay policy\n * [here](https://developers.google.com/web/updates/2017/09/autoplay-policy-changes#webaudio)\n * @example\n * document.querySelector(\"button\").addEventListener(\"click\", async () => {\n * \tawait Tone.start();\n * \tconsole.log(\"context started\");\n * });\n * @category Core\n */\nexport function start(): Promise<void> {\n\treturn globalContext.resume();\n}\n\n/**\n * Log Tone.js + version in the console.\n */\nif (theWindow && !theWindow.TONE_SILENCE_LOGGING) {\n\tlet prefix = \"v\";\n\tif (version === \"dev\") {\n\t\tprefix = \"\";\n\t}\n\tconst printString = ` * Tone.js ${prefix}${version} * `;\n\t// eslint-disable-next-line no-console\n\tconsole.log(`%c${printString}`, \"background: #000; color: #fff\");\n}\n","import { BaseContext } from \"./BaseContext\";\nimport { Seconds } from \"../type/Units\";\nimport { AnyAudioContext } from \"./AudioContext\";\n\ntype Draw = import(\"../util/Draw\").Draw;\ntype Destination = import(\"./Destination\").Destination;\ntype Transport = import(\"../clock/Transport\").Transport;\ntype Listener = import(\"./Listener\").Listener;\n\nexport class DummyContext extends BaseContext {\n\t//---------------------------\n\t// BASE AUDIO CONTEXT METHODS\n\t//---------------------------\n\tcreateAnalyser(): AnalyserNode {\n\t\treturn {} as AnalyserNode;\n\t}\n\n\tcreateOscillator(): OscillatorNode {\n\t\treturn {} as OscillatorNode;\n\t}\n\n\tcreateBufferSource() {\n\t\treturn {} as AudioBufferSourceNode;\n\t}\n\n\tcreateBiquadFilter(): BiquadFilterNode {\n\t\treturn {} as BiquadFilterNode;\n\t}\n\n\tcreateBuffer(\n\t\t_numberOfChannels: number,\n\t\t_length: number,\n\t\t_sampleRate: number\n\t): AudioBuffer {\n\t\treturn {} as AudioBuffer;\n\t}\n\n\tcreateChannelMerger(\n\t\t_numberOfInputs?: number | undefined\n\t): ChannelMergerNode {\n\t\treturn {} as ChannelMergerNode;\n\t}\n\n\tcreateChannelSplitter(\n\t\t_numberOfOutputs?: number | undefined\n\t): ChannelSplitterNode {\n\t\treturn {} as ChannelSplitterNode;\n\t}\n\n\tcreateConstantSource(): ConstantSourceNode {\n\t\treturn {} as ConstantSourceNode;\n\t}\n\n\tcreateConvolver(): ConvolverNode {\n\t\treturn {} as ConvolverNode;\n\t}\n\n\tcreateDelay(_maxDelayTime?: number | undefined): DelayNode {\n\t\treturn {} as DelayNode;\n\t}\n\n\tcreateDynamicsCompressor(): DynamicsCompressorNode {\n\t\treturn {} as DynamicsCompressorNode;\n\t}\n\n\tcreateGain(): GainNode {\n\t\treturn {} as GainNode;\n\t}\n\n\tcreateIIRFilter(\n\t\t_feedForward: number[] | Float32Array,\n\t\t_feedback: number[] | Float32Array\n\t): IIRFilterNode {\n\t\treturn {} as IIRFilterNode;\n\t}\n\n\tcreatePanner(): PannerNode {\n\t\treturn {} as PannerNode;\n\t}\n\n\tcreatePeriodicWave(\n\t\t_real: number[] | Float32Array,\n\t\t_imag: number[] | Float32Array,\n\t\t_constraints?: PeriodicWaveConstraints | undefined\n\t): PeriodicWave {\n\t\treturn {} as PeriodicWave;\n\t}\n\n\tcreateStereoPanner(): StereoPannerNode {\n\t\treturn {} as StereoPannerNode;\n\t}\n\n\tcreateWaveShaper(): WaveShaperNode {\n\t\treturn {} as WaveShaperNode;\n\t}\n\n\tcreateMediaStreamSource(_stream: MediaStream): MediaStreamAudioSourceNode {\n\t\treturn {} as MediaStreamAudioSourceNode;\n\t}\n\n\tcreateMediaElementSource(\n\t\t_element: HTMLMediaElement\n\t): MediaElementAudioSourceNode {\n\t\treturn {} as MediaElementAudioSourceNode;\n\t}\n\n\tcreateMediaStreamDestination(): MediaStreamAudioDestinationNode {\n\t\treturn {} as MediaStreamAudioDestinationNode;\n\t}\n\n\tdecodeAudioData(_audioData: ArrayBuffer): Promise<AudioBuffer> {\n\t\treturn Promise.resolve({} as AudioBuffer);\n\t}\n\n\t//---------------------------\n\t// TONE AUDIO CONTEXT METHODS\n\t//---------------------------\n\n\tcreateAudioWorkletNode(\n\t\t_name: string,\n\t\t_options?: Partial<AudioWorkletNodeOptions>\n\t): AudioWorkletNode {\n\t\treturn {} as AudioWorkletNode;\n\t}\n\n\tget rawContext(): AnyAudioContext {\n\t\treturn {} as AnyAudioContext;\n\t}\n\n\tasync addAudioWorkletModule(_url: string, _name: string): Promise<void> {\n\t\treturn Promise.resolve();\n\t}\n\n\tlookAhead = 0;\n\n\tlatencyHint = 0;\n\n\tresume(): Promise<void> {\n\t\treturn Promise.resolve();\n\t}\n\n\tsetTimeout(_fn: (...args: any[]) => void, _timeout: Seconds): number {\n\t\treturn 0;\n\t}\n\n\tclearTimeout(_id: number): this {\n\t\treturn this;\n\t}\n\n\tsetInterval(_fn: (...args: any[]) => void, _interval: Seconds): number {\n\t\treturn 0;\n\t}\n\n\tclearInterval(_id: number): this {\n\t\treturn this;\n\t}\n\n\tgetConstant(_val: number): AudioBufferSourceNode {\n\t\treturn {} as AudioBufferSourceNode;\n\t}\n\n\tget currentTime(): Seconds {\n\t\treturn 0;\n\t}\n\n\tget state(): AudioContextState {\n\t\treturn {} as AudioContextState;\n\t}\n\n\tget sampleRate(): number {\n\t\treturn 0;\n\t}\n\n\tget listener(): Listener {\n\t\treturn {} as Listener;\n\t}\n\n\tget transport(): Transport {\n\t\treturn {} as Transport;\n\t}\n\n\tget draw(): Draw {\n\t\treturn {} as Draw;\n\t}\n\tset draw(_d) {}\n\n\tget destination(): Destination {\n\t\treturn {} as Destination;\n\t}\n\tset destination(_d: Destination) {}\n\n\tnow() {\n\t\treturn 0;\n\t}\n\n\timmediate() {\n\t\treturn 0;\n\t}\n\n\treadonly isOffline: boolean = false;\n}\n","import { Decibels, GainFactor, Hertz, Interval, MidiNote, NormalRange } from \"./Units\";\n\n/**\n * Equal power gain scale. Good for cross-fading.\n * @param  percent (0-1)\n */\nexport function equalPowerScale(percent: NormalRange): number {\n\tconst piFactor = 0.5 * Math.PI;\n\treturn Math.sin(percent * piFactor);\n}\n\n/**\n * Convert decibels into gain.\n */\nexport function dbToGain(db: Decibels): GainFactor {\n\treturn Math.pow(10, db / 20);\n}\n\n/**\n * Convert gain to decibels.\n */\nexport function gainToDb(gain: GainFactor): Decibels {\n\treturn 20 * (Math.log(gain) / Math.LN10);\n}\n\n/**\n * Convert an interval (in semitones) to a frequency ratio.\n * @param interval the number of semitones above the base note\n * @example\n * Tone.intervalToFrequencyRatio(0); // 1\n * Tone.intervalToFrequencyRatio(12); // 2\n * Tone.intervalToFrequencyRatio(-12); // 0.5\n */\nexport function intervalToFrequencyRatio(interval: Interval): number {\n\treturn Math.pow(2, (interval / 12));\n}\n\n/**\n * The Global [concert tuning pitch](https://en.wikipedia.org/wiki/Concert_pitch) which is used\n * to generate all the other pitch values from notes. A4's values in Hertz.\n */\nlet A4: Hertz = 440;\n\nexport function getA4(): Hertz {\n\treturn A4;\n}\n\nexport function setA4(freq: Hertz): void {\n\tA4 = freq;\n}\n\n/**\n * Convert a frequency value to a MIDI note.\n * @param frequency The value to frequency value to convert.\n * @example\n * Tone.ftom(440); // returns 69\n */\nexport function ftom(frequency: Hertz): MidiNote {\n\treturn Math.round(ftomf(frequency)) as MidiNote;\n}\n\n/**\n * Convert a frequency to a floating point midi value\n */\nexport function ftomf(frequency: Hertz): number {\n\treturn 69 + 12 * Math.log2(frequency / A4);\n}\n\n/**\n * Convert a MIDI note to frequency value.\n * @param  midi The midi number to convert.\n * @return The corresponding frequency value\n * @example\n * Tone.mtof(69); // 440\n */\nexport function mtof(midi: MidiNote): Hertz {\n\treturn A4 * Math.pow(2, (midi - 69) / 12);\n}\n","import { BaseContext } from \"../context/BaseContext\";\nimport { Tone } from \"../Tone\";\nimport { isDefined, isObject, isString, isUndef } from \"../util/TypeCheck\";\nimport { BPM, Hertz, MidiNote, Milliseconds, Samples, Seconds, Ticks, Time } from \"./Units\";\n\nexport type TimeValue = Time | TimeBaseClass<any, any>;\n\n/**\n * The units that the TimeBase can accept. extended by other classes\n */\nexport type TimeBaseUnit = \"s\" | \"n\" | \"t\" | \"m\" | \"i\" | \"hz\" | \"tr\" | \"samples\" | \"number\";\n\nexport interface TypeFunction {\n\tregexp: RegExp;\n\tmethod: (value: string, ...args: string[]) => number;\n}\n\nexport interface TimeExpression<Type extends number> {\n\t[key: string]: {\n\t\tregexp: RegExp;\n\t\tmethod: (value: string, ...args: string[]) => Type;\n\t};\n}\n\n/**\n * TimeBase is a flexible encoding of time which can be evaluated to and from a string.\n */\nexport abstract class TimeBaseClass<Type extends number, Unit extends string> extends Tone {\n\n\treadonly context: BaseContext;\n\n\t/**\n\t * The value of the units\n\t */\n\tprotected _val?: TimeValue;\n\n\t/**\n\t * The units of time\n\t */\n\tprotected _units?: Unit;\n\n\t/**\n\t * All of the conversion expressions\n\t */\n\tprotected _expressions: TimeExpression<Type>;\n\n\t/**\n\t * The default units\n\t */\n\treadonly defaultUnits: Unit = \"s\" as Unit;\n\n\t/**\n\t * @param context The context associated with the time value. Used to compute\n\t * Transport and context-relative timing.\n\t * @param  value  The time value as a number, string or object\n\t * @param  units  Unit values\n\t */\n\tconstructor(context: BaseContext, value?: TimeValue, units?: Unit) {\n\t\tsuper();\n\n\t\tthis._val = value;\n\t\tthis._units = units;\n\t\tthis.context = context;\n\t\tthis._expressions = this._getExpressions();\n\t}\n\n\t/**\n\t * All of the time encoding expressions\n\t */\n\tprotected _getExpressions(): TimeExpression<Type> {\n\t\treturn {\n\t\t\thz: {\n\t\t\t\tmethod: (value) => {\n\t\t\t\t\treturn this._frequencyToUnits(parseFloat(value));\n\t\t\t\t},\n\t\t\t\tregexp: /^(\\d+(?:\\.\\d+)?)hz$/i,\n\t\t\t},\n\t\t\ti: {\n\t\t\t\tmethod: (value) => {\n\t\t\t\t\treturn this._ticksToUnits(parseInt(value, 10));\n\t\t\t\t},\n\t\t\t\tregexp: /^(\\d+)i$/i,\n\t\t\t},\n\t\t\tm: {\n\t\t\t\tmethod: (value) => {\n\t\t\t\t\treturn this._beatsToUnits(parseInt(value, 10) * this._getTimeSignature());\n\t\t\t\t},\n\t\t\t\tregexp: /^(\\d+)m$/i,\n\t\t\t},\n\t\t\tn: {\n\t\t\t\tmethod: (value, dot) => {\n\t\t\t\t\tconst numericValue = parseInt(value, 10);\n\t\t\t\t\tconst scalar = dot === \".\" ? 1.5 : 1;\n\t\t\t\t\tif (numericValue === 1) {\n\t\t\t\t\t\treturn this._beatsToUnits(this._getTimeSignature()) * scalar as Type;\n\t\t\t\t\t} else {\n\t\t\t\t\t\treturn this._beatsToUnits(4 / numericValue) * scalar as Type;\n\t\t\t\t\t}\n\t\t\t\t},\n\t\t\t\tregexp: /^(\\d+)n(\\.?)$/i,\n\t\t\t},\n\t\t\tnumber: {\n\t\t\t\tmethod: (value) => {\n\t\t\t\t\treturn this._expressions[this.defaultUnits].method.call(this, value);\n\t\t\t\t},\n\t\t\t\tregexp: /^(\\d+(?:\\.\\d+)?)$/,\n\t\t\t},\n\t\t\ts: {\n\t\t\t\tmethod: (value): Type => {\n\t\t\t\t\treturn this._secondsToUnits(parseFloat(value));\n\t\t\t\t},\n\t\t\t\tregexp: /^(\\d+(?:\\.\\d+)?)s$/,\n\t\t\t},\n\t\t\tsamples: {\n\t\t\t\tmethod: (value) => {\n\t\t\t\t\treturn parseInt(value, 10) / this.context.sampleRate as Type;\n\t\t\t\t},\n\t\t\t\tregexp: /^(\\d+)samples$/,\n\t\t\t},\n\t\t\tt: {\n\t\t\t\tmethod: (value) => {\n\t\t\t\t\tconst numericValue = parseInt(value, 10);\n\t\t\t\t\treturn this._beatsToUnits(8 / (Math.floor(numericValue) * 3));\n\t\t\t\t},\n\t\t\t\tregexp: /^(\\d+)t$/i,\n\t\t\t},\n\t\t\ttr: {\n\t\t\t\tmethod: (m, q, s) => {\n\t\t\t\t\tlet total = 0;\n\t\t\t\t\tif (m && m !== \"0\") {\n\t\t\t\t\t\ttotal += this._beatsToUnits(this._getTimeSignature() * parseFloat(m));\n\t\t\t\t\t}\n\t\t\t\t\tif (q && q !== \"0\") {\n\t\t\t\t\t\ttotal += this._beatsToUnits(parseFloat(q));\n\t\t\t\t\t}\n\t\t\t\t\tif (s && s !== \"0\") {\n\t\t\t\t\t\ttotal += this._beatsToUnits(parseFloat(s) / 4);\n\t\t\t\t\t}\n\t\t\t\t\treturn total as Type;\n\t\t\t\t},\n\t\t\t\tregexp: /^(\\d+(?:\\.\\d+)?):(\\d+(?:\\.\\d+)?):?(\\d+(?:\\.\\d+)?)?$/,\n\t\t\t},\n\t\t};\n\t}\n\n\t//-------------------------------------\n\t// \tVALUE OF\n\t//-------------------------------------\n\n\t/**\n\t * Evaluate the time value. Returns the time in seconds.\n\t */\n\tvalueOf(): Type {\n\t\tif (this._val instanceof TimeBaseClass) {\n\t\t\tthis.fromType(this._val);\n\t\t}\n\t\tif (isUndef(this._val)) {\n\t\t\treturn this._noArg();\n\t\t} else if (isString(this._val) && isUndef(this._units)) {\n\t\t\tfor (const units in this._expressions) {\n\t\t\t\tif (this._expressions[units].regexp.test(this._val.trim())) {\n\t\t\t\t\tthis._units = units as Unit;\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t} else if (isObject(this._val)) {\n\t\t\tlet total = 0;\n\t\t\tfor (const typeName in this._val) {\n\t\t\t\tif (isDefined(this._val[typeName])) {\n\t\t\t\t\tconst quantity = this._val[typeName];\n\t\t\t\t\t// @ts-ignore\n\t\t\t\t\tconst time = (new this.constructor(this.context, typeName)).valueOf() * quantity;\n\t\t\t\t\ttotal += time;\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn total as Type;\n\t\t}\n\t\tif (isDefined(this._units)) {\n\t\t\tconst expr = this._expressions[this._units];\n\t\t\tconst matching = this._val.toString().trim().match(expr.regexp);\n\t\t\tif (matching) {\n\t\t\t\treturn expr.method.apply(this, matching.slice(1));\n\t\t\t} else {\n\t\t\t\treturn expr.method.call(this, this._val);\n\t\t\t}\n\t\t} else if (isString(this._val)) {\n\t\t\treturn parseFloat(this._val) as Type;\n\t\t} else {\n\t\t\treturn this._val as Type;\n\t\t}\n\t}\n\n\t//-------------------------------------\n\t// \tUNIT CONVERSIONS\n\t//-------------------------------------\n\n\t/**\n\t * Returns the value of a frequency in the current units\n\t */\n\tprotected _frequencyToUnits(freq: Hertz): Type {\n\t\treturn 1 / freq as Type;\n\t}\n\n\t/**\n\t * Return the value of the beats in the current units\n\t */\n\tprotected _beatsToUnits(beats: number): Type {\n\t\treturn (60 / this._getBpm()) * beats as Type;\n\t}\n\n\t/**\n\t * Returns the value of a second in the current units\n\t */\n\tprotected _secondsToUnits(seconds: Seconds): Type {\n\t\treturn seconds as Type;\n\t}\n\n\t/**\n\t * Returns the value of a tick in the current time units\n\t */\n\tprotected _ticksToUnits(ticks: Ticks): Type {\n\t\treturn (ticks * (this._beatsToUnits(1)) / this._getPPQ()) as Type;\n\t}\n\n\t/**\n\t * With no arguments, return 'now'\n\t */\n\tprotected _noArg(): Type {\n\t\treturn this._now();\n\t}\n\n\t//-------------------------------------\n\t// \tTEMPO CONVERSIONS\n\t//-------------------------------------\n\n\t/**\n\t * Return the bpm\n\t */\n\tprotected _getBpm(): BPM {\n\t\treturn this.context.transport.bpm.value;\n\t}\n\n\t/**\n\t * Return the timeSignature\n\t */\n\tprotected _getTimeSignature(): number {\n\t\treturn this.context.transport.timeSignature as number;\n\t}\n\n\t/**\n\t * Return the PPQ or 192 if Transport is not available\n\t */\n\tprotected _getPPQ(): number {\n\t\treturn this.context.transport.PPQ;\n\t}\n\n\t/**\n\t * Return the current time in whichever context is relevant\n\t */\n\tprotected abstract _now(): Type;\n\n\t//-------------------------------------\n\t// \tCONVERSION INTERFACE\n\t//-------------------------------------\n\n\t/**\n\t * Coerce a time type into this units type.\n\t * @param type Any time type units\n\t */\n\tfromType(type: TimeBaseClass<any, any>): this {\n\t\tthis._units = undefined;\n\t\tswitch (this.defaultUnits) {\n\t\t\tcase \"s\":\n\t\t\t\tthis._val = type.toSeconds();\n\t\t\t\tbreak;\n\t\t\tcase \"i\":\n\t\t\t\tthis._val = type.toTicks();\n\t\t\t\tbreak;\n\t\t\tcase \"hz\":\n\t\t\t\tthis._val = type.toFrequency();\n\t\t\t\tbreak;\n\t\t\tcase \"midi\":\n\t\t\t\tthis._val = type.toMidi();\n\t\t\t\tbreak;\n\t\t}\n\t\treturn this;\n\t}\n\n\t/**\n\t * Return the value in seconds\n\t */\n\tabstract toSeconds(): Seconds;\n\n\t/**\n\t * Return the value as a Midi note\n\t */\n\tabstract toMidi(): MidiNote;\n\n\t/**\n\t * Convert the value into ticks\n\t */\n\tabstract toTicks(): Ticks;\n\n\t/**\n\t * Return the value in hertz\n\t */\n\ttoFrequency(): Hertz {\n\t\treturn 1 / this.toSeconds();\n\t}\n\n\t/**\n\t * Return the time in samples\n\t */\n\ttoSamples(): Samples {\n\t\treturn this.toSeconds() * this.context.sampleRate;\n\t}\n\n\t/**\n\t * Return the time in milliseconds.\n\t */\n\ttoMilliseconds(): Milliseconds {\n\t\treturn this.toSeconds() * 1000;\n\t}\n}\n","import { getContext } from \"../Global\";\nimport { ftom } from \"./Conversions\";\nimport { TimeBaseClass, TimeBaseUnit, TimeExpression, TimeValue } from \"./TimeBase\";\nimport { BarsBeatsSixteenths, MidiNote, Seconds, Subdivision, Ticks, Time } from \"./Units\";\n\n/**\n * TimeClass is a primitive type for encoding and decoding Time values.\n * TimeClass can be passed into the parameter of any method which takes time as an argument.\n * @param  val    The time value.\n * @param  units  The units of the value.\n * @example\n * const time = Tone.Time(\"4n\"); // a quarter note\n * @category Unit\n */\nexport class TimeClass<Type extends Seconds | Ticks = Seconds, Unit extends string = TimeBaseUnit>\n\textends TimeBaseClass<Type, Unit> {\n\n\treadonly name: string = \"TimeClass\";\n\n\tprotected _getExpressions(): TimeExpression<Type> {\n\t\treturn Object.assign(super._getExpressions(), {\n\t\t\tnow: {\n\t\t\t\tmethod: (capture: string): Type => {\n\t\t\t\t\treturn this._now() + new (this.constructor as typeof TimeClass)(this.context, capture).valueOf() as Type;\n\t\t\t\t},\n\t\t\t\tregexp: /^\\+(.+)/,\n\t\t\t},\n\t\t\tquantize: {\n\t\t\t\tmethod: (capture: string): Type => {\n\t\t\t\t\tconst quantTo = new TimeClass(this.context, capture).valueOf();\n\t\t\t\t\treturn this._secondsToUnits(this.context.transport.nextSubdivision(quantTo));\n\t\t\t\t},\n\t\t\t\tregexp: /^@(.+)/,\n\t\t\t},\n\t\t});\n\t}\n\n\t/**\n\t * Quantize the time by the given subdivision. Optionally add a\n\t * percentage which will move the time value towards the ideal\n\t * quantized value by that percentage.\n\t * @param  subdiv    The subdivision to quantize to\n\t * @param  percent  Move the time value towards the quantized value by a percentage.\n\t * @example\n\t * Tone.Time(21).quantize(2); // returns 22\n\t * Tone.Time(0.6).quantize(\"4n\", 0.5); // returns 0.55\n\t */\n\tquantize(subdiv: Time, percent = 1): Type {\n\t\tconst subdivision = new (this.constructor as typeof TimeClass)(this.context, subdiv).valueOf();\n\t\tconst value = this.valueOf();\n\t\tconst multiple = Math.round(value / subdivision);\n\t\tconst ideal = multiple * subdivision;\n\t\tconst diff = ideal - value;\n\t\treturn value + diff * percent as Type;\n\t}\n\n\t//-------------------------------------\n\t// CONVERSIONS\n\t//-------------------------------------\n\t/**\n\t * Convert a Time to Notation. The notation values are will be the\n\t * closest representation between 1m to 128th note.\n\t * @return {Notation}\n\t * @example\n\t * // if the Transport is at 120bpm:\n\t * Tone.Time(2).toNotation(); // returns \"1m\"\n\t */\n\ttoNotation(): Subdivision {\n\t\tconst time = this.toSeconds();\n\t\tconst testNotations: Subdivision[] = [\"1m\"];\n\t\tfor (let power = 1; power < 9; power++) {\n\t\t\tconst subdiv = Math.pow(2, power);\n\t\t\ttestNotations.push(subdiv + \"n.\" as Subdivision);\n\t\t\ttestNotations.push(subdiv + \"n\" as Subdivision);\n\t\t\ttestNotations.push(subdiv + \"t\" as Subdivision);\n\t\t}\n\t\ttestNotations.push(\"0\");\n\t\t// find the closets notation representation\n\t\tlet closest = testNotations[0];\n\t\tlet closestSeconds = new TimeClass(this.context, testNotations[0]).toSeconds();\n\t\ttestNotations.forEach(notation => {\n\t\t\tconst notationSeconds = new TimeClass(this.context, notation).toSeconds();\n\t\t\tif (Math.abs(notationSeconds - time) < Math.abs(closestSeconds - time)) {\n\t\t\t\tclosest = notation;\n\t\t\t\tclosestSeconds = notationSeconds;\n\t\t\t}\n\t\t});\n\t\treturn closest;\n\t}\n\n\t/**\n\t * Return the time encoded as Bars:Beats:Sixteenths.\n\t */\n\ttoBarsBeatsSixteenths(): BarsBeatsSixteenths {\n\t\tconst quarterTime = this._beatsToUnits(1);\n\t\tlet quarters = this.valueOf() / quarterTime;\n\t\tquarters = parseFloat(quarters.toFixed(4));\n\t\tconst measures = Math.floor(quarters / this._getTimeSignature());\n\t\tlet sixteenths = (quarters % 1) * 4;\n\t\tquarters = Math.floor(quarters) % this._getTimeSignature();\n\t\tconst sixteenthString = sixteenths.toString();\n\t\tif (sixteenthString.length > 3) {\n\t\t\t// the additional parseFloat removes insignificant trailing zeroes\n\t\t\tsixteenths = parseFloat(parseFloat(sixteenthString).toFixed(3));\n\t\t}\n\t\tconst progress = [measures, quarters, sixteenths];\n\t\treturn progress.join(\":\");\n\t}\n\n\t/**\n\t * Return the time in ticks.\n\t */\n\ttoTicks(): Ticks {\n\t\tconst quarterTime = this._beatsToUnits(1);\n\t\tconst quarters = this.valueOf() / quarterTime;\n\t\treturn quarters * this._getPPQ();\n\t}\n\n\t/**\n\t * Return the time in seconds.\n\t */\n\ttoSeconds(): Seconds {\n\t\treturn this.valueOf();\n\t}\n\n\t/**\n\t * Return the value as a midi note.\n\t */\n\ttoMidi(): MidiNote {\n\t\treturn ftom(this.toFrequency());\n\t}\n\n\tprotected _now(): Type {\n\t\treturn this.context.now() as Type;\n\t}\n}\n\n/**\n * Create a TimeClass from a time string or number. The time is computed against the \n * global Tone.Context. To use a specific context, use [[TimeClass]]\n * @param value A value which represents time\n * @param units The value's units if they can't be inferred by the value.\n * @category Unit\n * @example\n * const time = Tone.Time(\"4n\").toSeconds();\n * console.log(time);\n * @example\n * const note = Tone.Time(1).toNotation();\n * console.log(note);\n * @example\n * const freq = Tone.Time(0.5).toFrequency();\n * console.log(freq);\n */\nexport function Time(value?: TimeValue, units?: TimeBaseUnit): TimeClass<Seconds> {\n\treturn new TimeClass(getContext(), value, units);\n}\n","import { getContext } from \"../Global\";\nimport { intervalToFrequencyRatio, mtof } from \"./Conversions\";\nimport { ftom, getA4, setA4 } from \"./Conversions\";\nimport { TimeClass } from \"./Time\";\nimport { TimeBaseUnit, TimeExpression, TimeValue } from \"./TimeBase\";\nimport { Frequency, Hertz, Interval, MidiNote, Note, Seconds, Ticks } from \"./Units\";\n\nexport type FrequencyUnit = TimeBaseUnit | \"midi\";\n\n/**\n * Frequency is a primitive type for encoding Frequency values.\n * Eventually all time values are evaluated to hertz using the `valueOf` method.\n * @example\n * Tone.Frequency(\"C3\"); // 261\n * Tone.Frequency(38, \"midi\");\n * Tone.Frequency(\"C3\").transpose(4);\n * @category Unit\n */\nexport class FrequencyClass<Type extends number = Hertz> extends TimeClass<Type, FrequencyUnit> {\n\n\treadonly name: string = \"Frequency\";\n\n\treadonly defaultUnits: FrequencyUnit = \"hz\";\n\n\t/**\n\t * The [concert tuning pitch](https://en.wikipedia.org/wiki/Concert_pitch) which is used\n\t * to generate all the other pitch values from notes. A4's values in Hertz.\n\t */\n\tstatic get A4(): Hertz {\n\t\treturn getA4();\n\t}\n\tstatic set A4(freq: Hertz) {\n\t\tsetA4(freq);\n\t}\n\n\t//-------------------------------------\n\t// \tAUGMENT BASE EXPRESSIONS\n\t//-------------------------------------\n\n\tprotected _getExpressions(): TimeExpression<Type> {\n\t\treturn Object.assign({}, super._getExpressions(), {\n\t\t\tmidi: {\n\t\t\t\tregexp: /^(\\d+(?:\\.\\d+)?midi)/,\n\t\t\t\tmethod(value): number {\n\t\t\t\t\tif (this.defaultUnits === \"midi\") {\n\t\t\t\t\t\treturn value;\n\t\t\t\t\t} else {\n\t\t\t\t\t\treturn FrequencyClass.mtof(value);\n\t\t\t\t\t}\n\t\t\t\t},\n\t\t\t},\n\t\t\tnote: {\n\t\t\t\tregexp: /^([a-g]{1}(?:b|#|x|bb)?)(-?[0-9]+)/i,\n\t\t\t\tmethod(pitch, octave): number {\n\t\t\t\t\tconst index = noteToScaleIndex[pitch.toLowerCase()];\n\t\t\t\t\tconst noteNumber = index + (parseInt(octave, 10) + 1) * 12;\n\t\t\t\t\tif (this.defaultUnits === \"midi\") {\n\t\t\t\t\t\treturn noteNumber;\n\t\t\t\t\t} else {\n\t\t\t\t\t\treturn FrequencyClass.mtof(noteNumber);\n\t\t\t\t\t}\n\t\t\t\t},\n\t\t\t},\n\t\t\ttr: {\n\t\t\t\tregexp: /^(\\d+(?:\\.\\d+)?):(\\d+(?:\\.\\d+)?):?(\\d+(?:\\.\\d+)?)?/,\n\t\t\t\tmethod(m, q, s): number {\n\t\t\t\t\tlet total = 1;\n\t\t\t\t\tif (m && m !== \"0\") {\n\t\t\t\t\t\ttotal *= this._beatsToUnits(this._getTimeSignature() * parseFloat(m));\n\t\t\t\t\t}\n\t\t\t\t\tif (q && q !== \"0\") {\n\t\t\t\t\t\ttotal *= this._beatsToUnits(parseFloat(q));\n\t\t\t\t\t}\n\t\t\t\t\tif (s && s !== \"0\") {\n\t\t\t\t\t\ttotal *= this._beatsToUnits(parseFloat(s) / 4);\n\t\t\t\t\t}\n\t\t\t\t\treturn total;\n\t\t\t\t},\n\t\t\t},\n\t\t});\n\t}\n\n\t//-------------------------------------\n\t// \tEXPRESSIONS\n\t//-------------------------------------\n\n\t/**\n\t * Transposes the frequency by the given number of semitones.\n\t * @return  A new transposed frequency\n\t * @example\n\t * Tone.Frequency(\"A4\").transpose(3); // \"C5\"\n\t */\n\ttranspose(interval: Interval): FrequencyClass {\n\t\treturn new FrequencyClass(this.context, this.valueOf() * intervalToFrequencyRatio(interval));\n\t}\n\n\t/**\n\t * Takes an array of semitone intervals and returns\n\t * an array of frequencies transposed by those intervals.\n\t * @return  Returns an array of Frequencies\n\t * @example\n\t * Tone.Frequency(\"A4\").harmonize([0, 3, 7]); // [\"A4\", \"C5\", \"E5\"]\n\t */\n\tharmonize(intervals: Interval[]): FrequencyClass[] {\n\t\treturn intervals.map(interval => {\n\t\t\treturn this.transpose(interval);\n\t\t});\n\t}\n\n\t//-------------------------------------\n\t// \tUNIT CONVERSIONS\n\t//-------------------------------------\n\n\t/**\n\t * Return the value of the frequency as a MIDI note\n\t * @example\n\t * Tone.Frequency(\"C4\").toMidi(); // 60\n\t */\n\ttoMidi(): MidiNote {\n\t\treturn ftom(this.valueOf());\n\t}\n\n\t/**\n\t * Return the value of the frequency in Scientific Pitch Notation\n\t * @example\n\t * Tone.Frequency(69, \"midi\").toNote(); // \"A4\"\n\t */\n\ttoNote(): Note {\n\t\tconst freq = this.toFrequency();\n\t\tconst log = Math.log2(freq / FrequencyClass.A4);\n\t\tlet noteNumber = Math.round(12 * log) + 57;\n\t\tconst octave = Math.floor(noteNumber / 12);\n\t\tif (octave < 0) {\n\t\t\tnoteNumber += -12 * octave;\n\t\t}\n\t\tconst noteName = scaleIndexToNote[noteNumber % 12];\n\t\treturn noteName + octave.toString() as Note;\n\t}\n\n\t/**\n\t * Return the duration of one cycle in seconds.\n\t */\n\ttoSeconds(): Seconds {\n\t\treturn 1 / super.toSeconds();\n\t}\n\n\t/**\n\t * Return the duration of one cycle in ticks\n\t */\n\ttoTicks(): Ticks {\n\t\tconst quarterTime = this._beatsToUnits(1);\n\t\tconst quarters = this.valueOf() / quarterTime;\n\t\treturn Math.floor(quarters * this._getPPQ());\n\t}\n\n\t//-------------------------------------\n\t// \tUNIT CONVERSIONS HELPERS\n\t//-------------------------------------\n\n\t/**\n\t * With no arguments, return 0\n\t */\n\tprotected _noArg(): Type {\n\t\treturn 0 as Type;\n\t}\n\n\t/**\n\t * Returns the value of a frequency in the current units\n\t */\n\tprotected _frequencyToUnits(freq: Hertz): Type {\n\t\treturn freq as Type;\n\t}\n\n\t/**\n\t * Returns the value of a tick in the current time units\n\t */\n\tprotected _ticksToUnits(ticks: Ticks): Type {\n\t\treturn 1 / ((ticks * 60) / (this._getBpm() * this._getPPQ())) as Type;\n\t}\n\n\t/**\n\t * Return the value of the beats in the current units\n\t */\n\tprotected _beatsToUnits(beats: number): Type {\n\t\treturn 1 / super._beatsToUnits(beats) as Type;\n\t}\n\n\t/**\n\t * Returns the value of a second in the current units\n\t */\n\tprotected _secondsToUnits(seconds: Seconds): Type {\n\t\treturn 1 / seconds as Type;\n\t}\n\n\t/**\n\t * Convert a MIDI note to frequency value.\n\t * @param  midi The midi number to convert.\n\t * @return The corresponding frequency value\n\t */\n\tstatic mtof(midi: MidiNote): Hertz {\n\t\treturn mtof(midi);\n\t}\n\n\t/**\n\t * Convert a frequency value to a MIDI note.\n\t * @param frequency The value to frequency value to convert.\n\t */\n\tstatic ftom(frequency: Hertz): MidiNote {\n\t\treturn ftom(frequency);\n\t}\n}\n\n//-------------------------------------\n// \tFREQUENCY CONVERSIONS\n//-------------------------------------\n\n/**\n * Note to scale index. \n * @hidden\n */\nconst noteToScaleIndex = {\n\tcbb: -2, cb: -1, c: 0, \"c#\": 1, cx: 2,\n\tdbb: 0, db: 1, d: 2, \"d#\": 3, dx: 4,\n\tebb: 2, eb: 3, e: 4, \"e#\": 5, ex: 6,\n\tfbb: 3, fb: 4, f: 5, \"f#\": 6, fx: 7,\n\tgbb: 5, gb: 6, g: 7, \"g#\": 8, gx: 9,\n\tabb: 7, ab: 8, a: 9, \"a#\": 10, ax: 11,\n\tbbb: 9, bb: 10, b: 11, \"b#\": 12, bx: 13,\n};\n\n/**\n * scale index to note (sharps)\n * @hidden\n */\nconst scaleIndexToNote = [\"C\", \"C#\", \"D\", \"D#\", \"E\", \"F\", \"F#\", \"G\", \"G#\", \"A\", \"A#\", \"B\"];\n\n/**\n * Convert a value into a FrequencyClass object.\n * @category Unit\n * @example\n * const midi = Tone.Frequency(\"C3\").toMidi();\n * console.log(midi);\n * @example\n * const hertz = Tone.Frequency(38, \"midi\").toFrequency();\n * console.log(hertz);\n */\nexport function Frequency(value?: TimeValue | Frequency, units?: FrequencyUnit): FrequencyClass {\n\treturn new FrequencyClass(getContext(), value, units);\n}\n","import { getContext } from \"../Global\";\nimport { Seconds, Ticks } from \"../type/Units\";\nimport { TimeClass } from \"./Time\";\nimport { TimeBaseUnit, TimeValue } from \"./TimeBase\";\n\n/**\n * TransportTime is a the time along the Transport's\n * timeline. It is similar to Tone.Time, but instead of evaluating\n * against the AudioContext's clock, it is evaluated against\n * the Transport's position. See [TransportTime wiki](https://github.com/Tonejs/Tone.js/wiki/TransportTime).\n * @category Unit\n */\nexport class TransportTimeClass<Type extends Seconds | Ticks = Seconds> extends TimeClass<Type> {\n\n\treadonly name: string = \"TransportTime\";\n\n\t/**\n\t * Return the current time in whichever context is relevant\n\t */\n\tprotected _now(): Type {\n\t\treturn this.context.transport.seconds as Type;\n\t}\n}\n\n/**\n * TransportTime is a the time along the Transport's\n * timeline. It is similar to [[Time]], but instead of evaluating\n * against the AudioContext's clock, it is evaluated against\n * the Transport's position. See [TransportTime wiki](https://github.com/Tonejs/Tone.js/wiki/TransportTime).\n * @category Unit\n */\nexport function TransportTime(value?: TimeValue, units?: TimeBaseUnit): TransportTimeClass {\n\treturn new TransportTimeClass(getContext(), value, units);\n}\n","import { getContext } from \"../Global\";\nimport { Tone } from \"../Tone\";\nimport { FrequencyClass } from \"../type/Frequency\";\nimport { TimeClass } from \"../type/Time\";\nimport { TransportTimeClass } from \"../type/TransportTime\";\nimport { Frequency, Hertz, Seconds, Ticks, Time } from \"../type/Units\";\nimport { assertUsedScheduleTime } from \"../util/Debug\";\nimport { getDefaultsFromInstance, optionsFromArguments } from \"../util/Defaults\";\nimport { RecursivePartial } from \"../util/Interface\";\nimport { isArray, isBoolean, isDefined, isNumber, isString, isUndef } from \"../util/TypeCheck\";\nimport { BaseContext } from \"./BaseContext\";\n\n/**\n * A unit which process audio\n */\nexport interface ToneWithContextOptions {\n\tcontext: BaseContext;\n}\n\n/**\n * The Base class for all nodes that have an AudioContext.\n */\nexport abstract class ToneWithContext<Options extends ToneWithContextOptions> extends Tone {\n\n\t/**\n\t * The context belonging to the node.\n\t */\n\treadonly context: BaseContext;\n\n\t/**\n\t * The default context to use if no AudioContext is passed in to the constructor.\n\t * Probably should not be set manually. Used internally.\n\t * @hidden\n\t */\n\treadonly defaultContext?: BaseContext;\n\n\t/**\n\t * Pass in a constructor as the first argument\n\t */\n\tconstructor(context?: BaseContext)\n\tconstructor(options?: Partial<ToneWithContextOptions>);\n\tconstructor() {\n\t\tsuper();\n\t\tconst options = optionsFromArguments(ToneWithContext.getDefaults(), arguments, [\"context\"]);\n\t\tif (this.defaultContext) {\n\t\t\tthis.context = this.defaultContext;\n\t\t} else {\n\t\t\tthis.context = options.context;\n\t\t}\n\t}\n\n\tstatic getDefaults(): ToneWithContextOptions {\n\t\treturn {\n\t\t\tcontext: getContext(),\n\t\t};\n\t}\n\n\t/**\n\t * Return the current time of the Context clock plus the lookAhead.\n\t * @example\n\t * setInterval(() => {\n\t * \tconsole.log(Tone.now());\n\t * }, 100);\n\t */\n\tnow(): Seconds {\n\t\treturn this.context.currentTime + this.context.lookAhead;\n\t}\n\n\t/**\n\t * Return the current time of the Context clock without any lookAhead.\n\t * @example\n\t * setInterval(() => {\n\t * \tconsole.log(Tone.immediate());\n\t * }, 100);\n\t */\n\timmediate(): Seconds {\n\t\treturn this.context.currentTime;\n\t}\n\n\t/**\n\t * The duration in seconds of one sample.\n\t * @example\n\t * console.log(Tone.Transport.sampleTime);\n\t */\n\tget sampleTime(): Seconds {\n\t\treturn 1 / this.context.sampleRate;\n\t}\n\n\t/**\n\t * The number of seconds of 1 processing block (128 samples)\n\t * @example\n\t * console.log(Tone.Destination.blockTime);\n\t */\n\tget blockTime(): Seconds {\n\t\treturn 128 / this.context.sampleRate;\n\t}\n\n\t/**\n\t * Convert the incoming time to seconds. \n\t * This is calculated against the current [[Tone.Transport]] bpm\n\t * @example\n\t * const gain = new Tone.Gain();\n\t * setInterval(() => console.log(gain.toSeconds(\"4n\")), 100);\n\t * // ramp the tempo to 60 bpm over 30 seconds\n\t * Tone.getTransport().bpm.rampTo(60, 30);\n\t */\n\ttoSeconds(time?: Time): Seconds {\n\t\tassertUsedScheduleTime(time);\n\t\treturn new TimeClass(this.context, time).toSeconds();\n\t}\n\n\t/**\n\t * Convert the input to a frequency number\n\t * @example\n\t * const gain = new Tone.Gain();\n\t * console.log(gain.toFrequency(\"4n\"));\n\t */\n\ttoFrequency(freq: Frequency): Hertz {\n\t\treturn new FrequencyClass(this.context, freq).toFrequency();\n\t}\n\n\t/**\n\t * Convert the input time into ticks\n\t * @example\n\t * const gain = new Tone.Gain();\n\t * console.log(gain.toTicks(\"4n\"));\n\t */\n\ttoTicks(time?: Time | TimeClass): Ticks {\n\t\treturn new TransportTimeClass(this.context, time).toTicks();\n\t}\n\n\t//-------------------------------------\n\t// \tGET/SET\n\t//-------------------------------------\n\n\t/**\n\t * Get a subset of the properties which are in the partial props\n\t */\n\tprotected _getPartialProperties(props: Options): Partial<Options> {\n\t\tconst options = this.get();\n\t\t// remove attributes from the prop that are not in the partial\n\t\tObject.keys(options).forEach(name => {\n\t\t\tif (isUndef(props[name])) {\n\t\t\t\tdelete options[name];\n\t\t\t}\n\t\t});\n\t\treturn options;\n\t}\n\n\t/**\n\t * Get the object's attributes.\n\t * @example\n\t * const osc = new Tone.Oscillator();\n\t * console.log(osc.get());\n\t */\n\tget(): Options {\n\t\tconst defaults = getDefaultsFromInstance(this) as Options;\n\t\tObject.keys(defaults).forEach(attribute => {\n\t\t\tif (Reflect.has(this, attribute)) {\n\t\t\t\tconst member = this[attribute];\n\t\t\t\tif (isDefined(member) && isDefined(member.value) && isDefined(member.setValueAtTime)) {\n\t\t\t\t\tdefaults[attribute] = member.value;\n\t\t\t\t} else if (member instanceof ToneWithContext) {\n\t\t\t\t\tdefaults[attribute] = member._getPartialProperties(defaults[attribute]);\n\t\t\t\t\t// otherwise make sure it's a serializable type\n\t\t\t\t} else if (isArray(member) || isNumber(member) || isString(member) || isBoolean(member)) {\n\t\t\t\t\tdefaults[attribute] = member;\n\t\t\t\t} else {\n\t\t\t\t\t// remove all undefined and unserializable attributes\n\t\t\t\t\tdelete defaults[attribute];\n\t\t\t\t}\n\t\t\t}\n\t\t});\n\n\t\treturn defaults;\n\t}\n\n\t/**\n\t * Set multiple properties at once with an object.\n\t * @example\n\t * const filter = new Tone.Filter().toDestination();\n\t * // set values using an object\n\t * filter.set({\n\t * \tfrequency: \"C6\",\n\t * \ttype: \"highpass\"\n\t * });\n\t * const player = new Tone.Player(\"https://tonejs.github.io/audio/berklee/Analogsynth_octaves_highmid.mp3\").connect(filter);\n\t * player.autostart = true;\n\t */\n\tset(props: RecursivePartial<Options>): this {\n\t\tObject.keys(props).forEach(attribute => {\n\t\t\tif (Reflect.has(this, attribute) && isDefined(this[attribute])) {\n\t\t\t\tif (this[attribute] && isDefined(this[attribute].value) && isDefined(this[attribute].setValueAtTime)) {\n\t\t\t\t\t// small optimization\n\t\t\t\t\tif (this[attribute].value !== props[attribute]) {\n\t\t\t\t\t\tthis[attribute].value = props[attribute];\n\t\t\t\t\t}\n\t\t\t\t} else if (this[attribute] instanceof ToneWithContext) {\n\t\t\t\t\tthis[attribute].set(props[attribute]);\n\t\t\t\t} else {\n\t\t\t\t\tthis[attribute] = props[attribute];\n\t\t\t\t}\n\t\t\t}\n\t\t});\n\t\treturn this;\n\t}\n}\n","import { Seconds } from \"../type/Units\";\nimport { Timeline, TimelineEvent } from \"./Timeline\";\nimport { assertRange } from \"./Debug\";\n\nexport type BasicPlaybackState = \"started\" | \"stopped\";\nexport type PlaybackState = BasicPlaybackState | \"paused\";\n\nexport interface StateTimelineEvent extends TimelineEvent {\n\tstate: PlaybackState;\n}\n\n/**\n * A Timeline State. Provides the methods: `setStateAtTime(\"state\", time)` and `getValueAtTime(time)`\n * @param initial The initial state of the StateTimeline.  Defaults to `undefined`\n */\nexport class StateTimeline<AdditionalOptions extends Record<string, any> = Record<string, any>> extends Timeline<StateTimelineEvent & AdditionalOptions> {\n\n\treadonly name: string = \"StateTimeline\";\n\n\t/**\n\t * The initial state\n\t */\n\tprivate _initial: PlaybackState;\n\n\tconstructor(initial: PlaybackState = \"stopped\") {\n\t\tsuper();\n\t\tthis._initial = initial;\n\t\tthis.setStateAtTime(this._initial, 0);\n\t}\n\n\t/**\n\t * Returns the scheduled state scheduled before or at\n\t * the given time.\n\t * @param  time  The time to query.\n\t * @return  The name of the state input in setStateAtTime.\n\t */\n\tgetValueAtTime(time: Seconds): PlaybackState {\n\t\tconst event = this.get(time);\n\t\tif (event !== null) {\n\t\t\treturn event.state;\n\t\t} else {\n\t\t\treturn this._initial;\n\t\t}\n\t}\n\n\t/**\n\t * Add a state to the timeline.\n\t * @param  state The name of the state to set.\n\t * @param  time  The time to query.\n\t * @param options Any additional options that are needed in the timeline.\n\t */\n\tsetStateAtTime(state: PlaybackState, time: Seconds, options?: AdditionalOptions): this {\n\t\tassertRange(time, 0);\n\t\tthis.add(Object.assign({}, options, {\n\t\t\tstate,\n\t\t\ttime,\n\t\t}));\n\t\treturn this;\n\t}\n\n\t/**\n\t * Return the event before the time with the given state\n\t * @param  state The state to look for\n\t * @param  time  When to check before\n\t * @return  The event with the given state before the time\n\t */\n\tgetLastState(state: PlaybackState, time: number): StateTimelineEvent & AdditionalOptions | undefined {\n\t\t// time = this.toSeconds(time);\n\t\tconst index = this._search(time);\n\t\tfor (let i = index; i >= 0; i--) {\n\t\t\tconst event = this._timeline[i];\n\t\t\tif (event.state === state) {\n\t\t\t\treturn event;\n\t\t\t}\n\t\t}\n\t}\n\n\t/**\n\t * Return the event after the time with the given state\n\t * @param  state The state to look for\n\t * @param  time  When to check from\n\t * @return  The event with the given state after the time\n\t */\n\tgetNextState(state: PlaybackState, time: number): StateTimelineEvent & AdditionalOptions | undefined {\n\t\t// time = this.toSeconds(time);\n\t\tconst index = this._search(time);\n\t\tif (index !== -1) {\n\t\t\tfor (let i = index; i < this._timeline.length; i++) {\n\t\t\t\tconst event = this._timeline[i];\n\t\t\t\tif (event.state === state) {\n\t\t\t\t\treturn event;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n}\n","import { AbstractParam } from \"../context/AbstractParam\";\nimport { dbToGain, gainToDb } from \"../type/Conversions\";\nimport { Decibels, Frequency, Positive, Time, UnitMap, UnitName } from \"../type/Units\";\nimport { isAudioParam } from \"../util/AdvancedTypeCheck\";\nimport { optionsFromArguments } from \"../util/Defaults\";\nimport { Timeline } from \"../util/Timeline\";\nimport { isDefined } from \"../util/TypeCheck\";\nimport { ToneWithContext, ToneWithContextOptions } from \"./ToneWithContext\";\nimport { EQ } from \"../util/Math\";\nimport { assert, assertRange } from \"../util/Debug\";\n\nexport interface ParamOptions<TypeName extends UnitName> extends ToneWithContextOptions {\n\tunits: TypeName;\n\tvalue?: UnitMap[TypeName];\n\tparam: AudioParam | Param<TypeName>;\n\tconvert: boolean;\n\tminValue?: number;\n\tmaxValue?: number;\n\tswappable?: boolean;\n}\n\n/**\n * the possible automation types\n */\ntype AutomationType = \"linearRampToValueAtTime\" | \"exponentialRampToValueAtTime\" | \"setValueAtTime\" | \"setTargetAtTime\" | \"cancelScheduledValues\";\n\ninterface TargetAutomationEvent {\n\ttype: \"setTargetAtTime\";\n\ttime: number;\n\tvalue: number;\n\tconstant: number;\n}\n\ninterface NormalAutomationEvent {\n\ttype: Exclude<AutomationType, \"setTargetAtTime\">;\n\ttime: number;\n\tvalue: number;\n}\n/**\n * The events on the automation\n */\nexport type AutomationEvent = NormalAutomationEvent | TargetAutomationEvent;\n\n/**\n * Param wraps the native Web Audio's AudioParam to provide\n * additional unit conversion functionality. It also\n * serves as a base-class for classes which have a single,\n * automatable parameter.\n * @category Core\n */\nexport class Param<TypeName extends UnitName = \"number\">\n\textends ToneWithContext<ParamOptions<TypeName>>\n\timplements AbstractParam<TypeName> {\n\n\treadonly name: string = \"Param\";\n\n\treadonly input: GainNode | AudioParam;\n\n\treadonly units: UnitName;\n\tconvert: boolean;\n\toverridden = false;\n\n\t/**\n\t * The timeline which tracks all of the automations.\n\t */\n\tprotected _events: Timeline<AutomationEvent>;\n\n\t/**\n\t * The native parameter to control\n\t */\n\tprotected _param: AudioParam;\n\n\t/**\n\t * The default value before anything is assigned\n\t */\n\tprotected _initialValue: number;\n\n\t/**\n\t * The minimum output value\n\t */\n\tprivate _minOutput = 1e-7;\n\n\t/**\n\t * Private reference to the min and max values if passed into the constructor\n\t */\n\tprivate readonly _minValue?: number;\n\tprivate readonly _maxValue?: number;\n\n\t/**\n\t * If the underlying AudioParam can be swapped out\n\t * using the setParam method. \n\t */\n\tprotected readonly _swappable: boolean;\n\n\t/**\n\t * @param param The AudioParam to wrap\n\t * @param units The unit name\n\t * @param convert Whether or not to convert the value to the target units\n\t */\n\tconstructor(param: AudioParam, units?: TypeName, convert?: boolean);\n\tconstructor(options: Partial<ParamOptions<TypeName>>);\n\tconstructor() {\n\t\tsuper(optionsFromArguments(Param.getDefaults(), arguments, [\"param\", \"units\", \"convert\"]));\n\n\t\tconst options = optionsFromArguments(Param.getDefaults(), arguments, [\"param\", \"units\", \"convert\"]);\n\n\t\tassert(isDefined(options.param) &&\n\t\t\t(isAudioParam(options.param) || options.param instanceof Param), \"param must be an AudioParam\");\n\n\t\twhile (!isAudioParam(options.param)) {\n\t\t\toptions.param = options.param._param;\n\t\t}\n\n\t\tthis._swappable = isDefined(options.swappable) ? options.swappable : false;\n\t\tif (this._swappable) {\n\t\t\tthis.input = this.context.createGain();\n\t\t\t// initialize\n\t\t\tthis._param = options.param;\n\t\t\tthis.input.connect(this._param);\n\t\t} else {\n\t\t\tthis._param = this.input = options.param;\n\t\t}\n\t\tthis._events = new Timeline<AutomationEvent>(1000);\n\t\tthis._initialValue = this._param.defaultValue;\n\t\tthis.units = options.units;\n\t\tthis.convert = options.convert;\n\t\tthis._minValue = options.minValue;\n\t\tthis._maxValue = options.maxValue;\n\n\t\t// if the value is defined, set it immediately\n\t\tif (isDefined(options.value) && options.value !== this._toType(this._initialValue)) {\n\t\t\tthis.setValueAtTime(options.value, 0);\n\t\t}\n\t}\n\n\tstatic getDefaults(): ParamOptions<any> {\n\t\treturn Object.assign(ToneWithContext.getDefaults(), {\n\t\t\tconvert: true,\n\t\t\tunits: \"number\" as UnitName,\n\t\t} as ParamOptions<any>);\n\t}\n\n\tget value(): UnitMap[TypeName] {\n\t\tconst now = this.now();\n\t\treturn this.getValueAtTime(now);\n\t}\n\tset value(value) {\n\t\tthis.cancelScheduledValues(this.now());\n\t\tthis.setValueAtTime(value, this.now());\n\t}\n\n\tget minValue(): number {\n\t\t// if it's not the default minValue, return it\n\t\tif (isDefined(this._minValue)) {\n\t\t\treturn this._minValue;\n\t\t} else if (this.units === \"time\" || this.units === \"frequency\" ||\n\t\t\tthis.units === \"normalRange\" || this.units === \"positive\" ||\n\t\t\tthis.units === \"transportTime\" || this.units === \"ticks\" ||\n\t\t\tthis.units === \"bpm\" || this.units === \"hertz\" || this.units === \"samples\") {\n\t\t\treturn 0;\n\t\t} else if (this.units === \"audioRange\") {\n\t\t\treturn -1;\n\t\t} else if (this.units === \"decibels\") {\n\t\t\treturn -Infinity;\n\t\t} else {\n\t\t\treturn this._param.minValue;\n\t\t}\n\t}\n\n\tget maxValue(): number {\n\t\tif (isDefined(this._maxValue)) {\n\t\t\treturn this._maxValue;\n\t\t} else if (this.units === \"normalRange\" ||\n\t\t\tthis.units === \"audioRange\") {\n\t\t\treturn 1;\n\t\t} else {\n\t\t\treturn this._param.maxValue;\n\t\t}\n\t}\n\n\t/**\n\t * Type guard based on the unit name\n\t */\n\tprivate _is<T>(arg: any, type: UnitName): arg is T {\n\t\treturn this.units === type;\n\t}\n\n\t/**\n\t * Make sure the value is always in the defined range\n\t */\n\tprivate _assertRange(value: number): number {\n\t\tif (isDefined(this.maxValue) && isDefined(this.minValue)) {\n\t\t\tassertRange(value, this._fromType(this.minValue), this._fromType(this.maxValue));\n\t\t}\n\t\treturn value;\n\t}\n\n\t/**\n\t * Convert the given value from the type specified by Param.units\n\t * into the destination value (such as Gain or Frequency).\n\t */\n\tprotected _fromType(val: UnitMap[TypeName]): number {\n\t\tif (this.convert && !this.overridden) {\n\t\t\tif (this._is<Time>(val, \"time\")) {\n\t\t\t\treturn this.toSeconds(val);\n\t\t\t} else if (this._is<Decibels>(val, \"decibels\")) {\n\t\t\t\treturn dbToGain(val);\n\t\t\t} else if (this._is<Frequency>(val, \"frequency\")) {\n\t\t\t\treturn this.toFrequency(val);\n\t\t\t} else {\n\t\t\t\treturn val as number;\n\t\t\t}\n\t\t} else if (this.overridden) {\n\t\t\t// if it's overridden, should only schedule 0s\n\t\t\treturn 0;\n\t\t} else {\n\t\t\treturn val as number;\n\t\t}\n\t}\n\n\t/**\n\t * Convert the parameters value into the units specified by Param.units.\n\t */\n\tprotected _toType(val: number): UnitMap[TypeName] {\n\t\tif (this.convert && this.units === \"decibels\") {\n\t\t\treturn gainToDb(val) as UnitMap[TypeName];\n\t\t} else {\n\t\t\treturn val as UnitMap[TypeName];\n\t\t}\n\t}\n\n\t//-------------------------------------\n\t// ABSTRACT PARAM INTERFACE\n\t// all docs are generated from ParamInterface.ts\n\t//-------------------------------------\n\n\tsetValueAtTime(value: UnitMap[TypeName], time: Time): this {\n\t\tconst computedTime = this.toSeconds(time);\n\t\tconst numericValue = this._fromType(value);\n\t\tassert(isFinite(numericValue) && isFinite(computedTime),\n\t\t\t`Invalid argument(s) to setValueAtTime: ${JSON.stringify(value)}, ${JSON.stringify(time)}`);\n\t\tthis._assertRange(numericValue);\n\t\tthis.log(this.units, \"setValueAtTime\", value, computedTime);\n\t\tthis._events.add({\n\t\t\ttime: computedTime,\n\t\t\ttype: \"setValueAtTime\",\n\t\t\tvalue: numericValue,\n\t\t});\n\t\tthis._param.setValueAtTime(numericValue, computedTime);\n\t\treturn this;\n\t}\n\n\tgetValueAtTime(time: Time): UnitMap[TypeName] {\n\t\tconst computedTime = Math.max(this.toSeconds(time), 0);\n\t\tconst after = this._events.getAfter(computedTime);\n\t\tconst before = this._events.get(computedTime);\n\t\tlet value = this._initialValue;\n\t\t// if it was set by\n\t\tif (before === null) {\n\t\t\tvalue = this._initialValue;\n\t\t} else if (before.type === \"setTargetAtTime\" && (after === null || after.type === \"setValueAtTime\")) {\n\t\t\tconst previous = this._events.getBefore(before.time);\n\t\t\tlet previousVal;\n\t\t\tif (previous === null) {\n\t\t\t\tpreviousVal = this._initialValue;\n\t\t\t} else {\n\t\t\t\tpreviousVal = previous.value;\n\t\t\t}\n\t\t\tif (before.type === \"setTargetAtTime\") {\n\t\t\t\tvalue = this._exponentialApproach(before.time, previousVal, before.value, before.constant, computedTime);\n\t\t\t}\n\t\t} else if (after === null) {\n\t\t\tvalue = before.value;\n\t\t} else if (after.type === \"linearRampToValueAtTime\" || after.type === \"exponentialRampToValueAtTime\") {\n\t\t\tlet beforeValue = before.value;\n\t\t\tif (before.type === \"setTargetAtTime\") {\n\t\t\t\tconst previous = this._events.getBefore(before.time);\n\t\t\t\tif (previous === null) {\n\t\t\t\t\tbeforeValue = this._initialValue;\n\t\t\t\t} else {\n\t\t\t\t\tbeforeValue = previous.value;\n\t\t\t\t}\n\t\t\t}\n\t\t\tif (after.type === \"linearRampToValueAtTime\") {\n\t\t\t\tvalue = this._linearInterpolate(before.time, beforeValue, after.time, after.value, computedTime);\n\t\t\t} else {\n\t\t\t\tvalue = this._exponentialInterpolate(before.time, beforeValue, after.time, after.value, computedTime);\n\t\t\t}\n\t\t} else {\n\t\t\tvalue = before.value;\n\t\t}\n\t\treturn this._toType(value);\n\t}\n\n\tsetRampPoint(time: Time): this {\n\t\ttime = this.toSeconds(time);\n\t\tlet currentVal = this.getValueAtTime(time);\n\t\tthis.cancelAndHoldAtTime(time);\n\t\tif (this._fromType(currentVal) === 0) {\n\t\t\tcurrentVal = this._toType(this._minOutput);\n\t\t}\n\t\tthis.setValueAtTime(currentVal, time);\n\t\treturn this;\n\t}\n\n\tlinearRampToValueAtTime(value: UnitMap[TypeName], endTime: Time): this {\n\t\tconst numericValue = this._fromType(value);\n\t\tconst computedTime = this.toSeconds(endTime);\n\t\tassert(isFinite(numericValue) && isFinite(computedTime),\n\t\t\t`Invalid argument(s) to linearRampToValueAtTime: ${JSON.stringify(value)}, ${JSON.stringify(endTime)}`);\n\t\tthis._assertRange(numericValue);\n\t\tthis._events.add({\n\t\t\ttime: computedTime,\n\t\t\ttype: \"linearRampToValueAtTime\",\n\t\t\tvalue: numericValue,\n\t\t});\n\t\tthis.log(this.units, \"linearRampToValueAtTime\", value, computedTime);\n\t\tthis._param.linearRampToValueAtTime(numericValue, computedTime);\n\t\treturn this;\n\t}\n\n\texponentialRampToValueAtTime(value: UnitMap[TypeName], endTime: Time): this {\n\t\tlet numericValue = this._fromType(value);\n\t\t// the value can't be 0\n\t\tnumericValue = EQ(numericValue, 0) ? this._minOutput : numericValue;\n\t\tthis._assertRange(numericValue);\n\t\tconst computedTime = this.toSeconds(endTime);\n\t\tassert(isFinite(numericValue) && isFinite(computedTime),\n\t\t\t`Invalid argument(s) to exponentialRampToValueAtTime: ${JSON.stringify(value)}, ${JSON.stringify(endTime)}`);\n\t\t// store the event\n\t\tthis._events.add({\n\t\t\ttime: computedTime,\n\t\t\ttype: \"exponentialRampToValueAtTime\",\n\t\t\tvalue: numericValue,\n\t\t});\n\t\tthis.log(this.units, \"exponentialRampToValueAtTime\", value, computedTime);\n\t\tthis._param.exponentialRampToValueAtTime(numericValue, computedTime);\n\t\treturn this;\n\t}\n\n\texponentialRampTo(value: UnitMap[TypeName], rampTime: Time, startTime?: Time): this {\n\t\tstartTime = this.toSeconds(startTime);\n\t\tthis.setRampPoint(startTime);\n\t\tthis.exponentialRampToValueAtTime(value, startTime + this.toSeconds(rampTime));\n\t\treturn this;\n\t}\n\n\tlinearRampTo(value: UnitMap[TypeName], rampTime: Time, startTime?: Time): this {\n\t\tstartTime = this.toSeconds(startTime);\n\t\tthis.setRampPoint(startTime);\n\t\tthis.linearRampToValueAtTime(value, startTime + this.toSeconds(rampTime));\n\t\treturn this;\n\t}\n\n\ttargetRampTo(value: UnitMap[TypeName], rampTime: Time, startTime?: Time): this {\n\t\tstartTime = this.toSeconds(startTime);\n\t\tthis.setRampPoint(startTime);\n\t\tthis.exponentialApproachValueAtTime(value, startTime, rampTime);\n\t\treturn this;\n\t}\n\n\texponentialApproachValueAtTime(value: UnitMap[TypeName], time: Time, rampTime: Time): this {\n\t\ttime = this.toSeconds(time);\n\t\trampTime = this.toSeconds(rampTime);\n\t\tconst timeConstant = Math.log(rampTime + 1) / Math.log(200);\n\t\tthis.setTargetAtTime(value, time, timeConstant);\n\t\t// at 90% start a linear ramp to the final value\n\t\tthis.cancelAndHoldAtTime(time + rampTime * 0.9);\n\t\tthis.linearRampToValueAtTime(value, time + rampTime);\n\t\treturn this;\n\t}\n\n\tsetTargetAtTime(value: UnitMap[TypeName], startTime: Time, timeConstant: Positive): this {\n\t\tconst numericValue = this._fromType(value);\n\t\t// The value will never be able to approach without timeConstant > 0.\n\t\tassert(isFinite(timeConstant) && timeConstant > 0, \"timeConstant must be a number greater than 0\");\n\t\tconst computedTime = this.toSeconds(startTime);\n\t\tthis._assertRange(numericValue);\n\t\tassert(isFinite(numericValue) && isFinite(computedTime),\n\t\t\t`Invalid argument(s) to setTargetAtTime: ${JSON.stringify(value)}, ${JSON.stringify(startTime)}`);\n\t\tthis._events.add({\n\t\t\tconstant: timeConstant,\n\t\t\ttime: computedTime,\n\t\t\ttype: \"setTargetAtTime\",\n\t\t\tvalue: numericValue,\n\t\t});\n\t\tthis.log(this.units, \"setTargetAtTime\", value, computedTime, timeConstant);\n\t\tthis._param.setTargetAtTime(numericValue, computedTime, timeConstant);\n\t\treturn this;\n\t}\n\n\tsetValueCurveAtTime(values: UnitMap[TypeName][], startTime: Time, duration: Time, scaling = 1): this {\n\t\tduration = this.toSeconds(duration);\n\t\tstartTime = this.toSeconds(startTime);\n\t\tconst startingValue = this._fromType(values[0]) * scaling;\n\t\tthis.setValueAtTime(this._toType(startingValue), startTime);\n\t\tconst segTime = duration / (values.length - 1);\n\t\tfor (let i = 1; i < values.length; i++) {\n\t\t\tconst numericValue = this._fromType(values[i]) * scaling;\n\t\t\tthis.linearRampToValueAtTime(this._toType(numericValue), startTime + i * segTime);\n\t\t}\n\t\treturn this;\n\t}\n\n\tcancelScheduledValues(time: Time): this {\n\t\tconst computedTime = this.toSeconds(time);\n\t\tassert(isFinite(computedTime), `Invalid argument to cancelScheduledValues: ${JSON.stringify(time)}`);\n\t\tthis._events.cancel(computedTime);\n\t\tthis._param.cancelScheduledValues(computedTime);\n\t\tthis.log(this.units, \"cancelScheduledValues\", computedTime);\n\t\treturn this;\n\t}\n\n\tcancelAndHoldAtTime(time: Time): this {\n\t\tconst computedTime = this.toSeconds(time);\n\t\tconst valueAtTime = this._fromType(this.getValueAtTime(computedTime));\n\t\t// remove the schedule events\n\t\tassert(isFinite(computedTime), `Invalid argument to cancelAndHoldAtTime: ${JSON.stringify(time)}`);\n\n\t\tthis.log(this.units, \"cancelAndHoldAtTime\", computedTime, \"value=\" + valueAtTime);\n\t\t\n\t\t// if there is an event at the given computedTime\n\t\t// and that even is not a \"set\"\n\t\tconst before = this._events.get(computedTime);\n\t\tconst after = this._events.getAfter(computedTime);\n\t\tif (before && EQ(before.time, computedTime)) {\n\t\t\t// remove everything after\n\t\t\tif (after) {\n\t\t\t\tthis._param.cancelScheduledValues(after.time);\n\t\t\t\tthis._events.cancel(after.time);\n\t\t\t} else {\n\t\t\t\tthis._param.cancelAndHoldAtTime(computedTime);\n\t\t\t\tthis._events.cancel(computedTime + this.sampleTime);\n\t\t\t}\n\t\t} else if (after) {\n\t\t\tthis._param.cancelScheduledValues(after.time);\n\t\t\t// cancel the next event(s)\n\t\t\tthis._events.cancel(after.time);\n\t\t\tif (after.type === \"linearRampToValueAtTime\") {\n\t\t\t\tthis.linearRampToValueAtTime(this._toType(valueAtTime), computedTime);\n\t\t\t} else if (after.type === \"exponentialRampToValueAtTime\") {\n\t\t\t\tthis.exponentialRampToValueAtTime(this._toType(valueAtTime), computedTime);\n\t\t\t}\n\t\t}\n\n\t\t// set the value at the given time\n\t\tthis._events.add({\n\t\t\ttime: computedTime,\n\t\t\ttype: \"setValueAtTime\",\n\t\t\tvalue: valueAtTime,\n\t\t});\n\t\tthis._param.setValueAtTime(valueAtTime, computedTime);\n\t\treturn this;\n\t}\n\n\trampTo(value: UnitMap[TypeName], rampTime: Time = 0.1, startTime?: Time): this {\n\t\tif (this.units === \"frequency\" || this.units === \"bpm\" || this.units === \"decibels\") {\n\t\t\tthis.exponentialRampTo(value, rampTime, startTime);\n\t\t} else {\n\t\t\tthis.linearRampTo(value, rampTime, startTime);\n\t\t}\n\t\treturn this;\n\t}\n\n\t/**\n\t * Apply all of the previously scheduled events to the passed in Param or AudioParam.\n\t * The applied values will start at the context's current time and schedule\n\t * all of the events which are scheduled on this Param onto the passed in param.\n\t */\n\tapply(param: Param | AudioParam): this {\n\t\tconst now = this.context.currentTime;\n\t\t// set the param's value at the current time and schedule everything else\n\t\tparam.setValueAtTime(this.getValueAtTime(now) as number, now);\n\t\t// if the previous event was a curve, then set the rest of it\n\t\tconst previousEvent = this._events.get(now);\n\t\tif (previousEvent && previousEvent.type === \"setTargetAtTime\") {\n\t\t\t// approx it until the next event with linear ramps\n\t\t\tconst nextEvent = this._events.getAfter(previousEvent.time);\n\t\t\t// or for 2 seconds if there is no event\n\t\t\tconst endTime = nextEvent ? nextEvent.time : now + 2;\n\t\t\tconst subdivisions = (endTime - now) / 10;\n\t\t\tfor (let i = now; i < endTime; i += subdivisions) {\n\t\t\t\tparam.linearRampToValueAtTime(this.getValueAtTime(i) as number, i);\n\t\t\t}\n\t\t}\n\t\tthis._events.forEachAfter(this.context.currentTime, event => {\n\t\t\tif (event.type === \"cancelScheduledValues\") {\n\t\t\t\tparam.cancelScheduledValues(event.time);\n\t\t\t} else if (event.type === \"setTargetAtTime\") {\n\t\t\t\tparam.setTargetAtTime(event.value, event.time, event.constant);\n\t\t\t} else {\n\t\t\t\tparam[event.type](event.value, event.time);\n\t\t\t}\n\t\t});\n\t\treturn this;\n\t}\n\n\t/**\n\t * Replace the Param's internal AudioParam. Will apply scheduled curves \n\t * onto the parameter and replace the connections.\n\t */\n\tsetParam(param: AudioParam): this {\n\t\tassert(this._swappable, \"The Param must be assigned as 'swappable' in the constructor\");\n\t\tconst input = this.input as GainNode;\n\t\tinput.disconnect(this._param);\n\t\tthis.apply(param);\n\t\tthis._param = param;\n\t\tinput.connect(this._param);\n\t\treturn this;\n\t}\n\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis._events.dispose();\n\t\treturn this;\n\t}\n\n\tget defaultValue(): UnitMap[TypeName] {\n\t\treturn this._toType(this._param.defaultValue);\n\t}\n\n\t//-------------------------------------\n\t// \tAUTOMATION CURVE CALCULATIONS\n\t// \tMIT License, copyright (c) 2014 Jordan Santell\n\t//-------------------------------------\n\n\t// Calculates the the value along the curve produced by setTargetAtTime\n\tprotected _exponentialApproach(t0: number, v0: number, v1: number, timeConstant: number, t: number): number {\n\t\treturn v1 + (v0 - v1) * Math.exp(-(t - t0) / timeConstant);\n\t}\n\n\t// Calculates the the value along the curve produced by linearRampToValueAtTime\n\tprotected _linearInterpolate(t0: number, v0: number, t1: number, v1: number, t: number): number {\n\t\treturn v0 + (v1 - v0) * ((t - t0) / (t1 - t0));\n\t}\n\n\t// Calculates the the value along the curve produced by exponentialRampToValueAtTime\n\tprotected _exponentialInterpolate(t0: number, v0: number, t1: number, v1: number, t: number): number {\n\t\treturn v0 * Math.pow(v1 / v0, (t - t0) / (t1 - t0));\n\t}\n}\n","import { isAudioNode, isAudioParam } from \"../util/AdvancedTypeCheck\";\nimport { isDefined } from \"../util/TypeCheck\";\nimport { Param } from \"./Param\";\nimport { ToneWithContext, ToneWithContextOptions } from \"./ToneWithContext\";\nimport { assert, warn } from \"../util/Debug\";\n\nexport type InputNode = ToneAudioNode | AudioNode | Param<any> | AudioParam;\nexport type OutputNode = ToneAudioNode | AudioNode;\n\ninterface ChannelProperties {\n\tchannelCount: number;\n\tchannelCountMode: ChannelCountMode;\n\tchannelInterpretation: ChannelInterpretation;\n}\n\n/**\n * The possible options for this node\n */\nexport type ToneAudioNodeOptions = ToneWithContextOptions;\n\n/**\n * ToneAudioNode is the base class for classes which process audio.\n */\nexport abstract class ToneAudioNode<Options extends ToneAudioNodeOptions = ToneAudioNodeOptions>\n\textends ToneWithContext<Options> {\n\n\t/**\n\t * The name of the class\n\t */\n\tabstract readonly name: string;\n\n\t/**\n\t * The input node or nodes. If the object is a source,\n\t * it does not have any input and this.input is undefined.\n\t */\n\tabstract input: InputNode | undefined;\n\n\t/**\n\t * The output nodes. If the object is a sink,\n\t * it does not have any output and this.output is undefined.\n\t */\n\tabstract output: OutputNode | undefined;\n\n\t/**\n\t * The number of inputs feeding into the AudioNode.\n\t * For source nodes, this will be 0.\n\t * @example\n\t * const node = new Tone.Gain();\n\t * console.log(node.numberOfInputs);\n\t */\n\tget numberOfInputs(): number {\n\t\tif (isDefined(this.input)) {\n\t\t\tif (isAudioParam(this.input) || this.input instanceof Param) {\n\t\t\t\treturn 1;\n\t\t\t} else {\n\t\t\t\treturn this.input.numberOfInputs;\n\t\t\t}\n\t\t} else {\n\t\t\treturn 0;\n\t\t}\n\t}\n\n\t/**\n\t * The number of outputs of the AudioNode.\n\t * @example\n\t * const node = new Tone.Gain();\n\t * console.log(node.numberOfOutputs);\n\t */\n\tget numberOfOutputs(): number {\n\t\tif (isDefined(this.output)) {\n\t\t\treturn this.output.numberOfOutputs;\n\t\t} else {\n\t\t\treturn 0;\n\t\t}\n\t}\n\n\t/**\n\t * List all of the node that must be set to match the ChannelProperties\n\t */\n\tprotected _internalChannels: OutputNode[] = [];\n\n\t//-------------------------------------\n\t// AUDIO PROPERTIES\n\t//-------------------------------------\n\n\t/**\n\t * Used to decide which nodes to get/set properties on\n\t */\n\tprivate _isAudioNode(node: any): node is AudioNode | ToneAudioNode {\n\t\treturn isDefined(node) && (node instanceof ToneAudioNode || isAudioNode(node));\n\t}\n\n\t/**\n\t * Get all of the audio nodes (either internal or input/output) which together\n\t * make up how the class node responds to channel input/output\n\t */\n\tprivate _getInternalNodes(): OutputNode[] {\n\t\tconst nodeList = this._internalChannels.slice(0);\n\t\tif (this._isAudioNode(this.input)) {\n\t\t\tnodeList.push(this.input);\n\t\t}\n\t\tif (this._isAudioNode(this.output)) {\n\t\t\tif (this.input !== this.output) {\n\t\t\t\tnodeList.push(this.output);\n\t\t\t}\n\t\t}\n\t\treturn nodeList;\n\t}\n\n\t/**\n\t * Set the audio options for this node such as channelInterpretation\n\t * channelCount, etc.\n\t * @param options\n\t */\n\tprivate _setChannelProperties(options: ChannelProperties): void {\n\t\tconst nodeList = this._getInternalNodes();\n\t\tnodeList.forEach(node => {\n\t\t\tnode.channelCount = options.channelCount;\n\t\t\tnode.channelCountMode = options.channelCountMode;\n\t\t\tnode.channelInterpretation = options.channelInterpretation;\n\t\t});\n\t}\n\n\t/**\n\t * Get the current audio options for this node such as channelInterpretation\n\t * channelCount, etc.\n\t */\n\tprivate _getChannelProperties(): ChannelProperties {\n\t\tconst nodeList = this._getInternalNodes();\n\t\tassert(nodeList.length > 0, \"ToneAudioNode does not have any internal nodes\");\n\t\t// use the first node to get properties\n\t\t// they should all be the same\n\t\tconst node = nodeList[0];\n\t\treturn {\n\t\t\tchannelCount: node.channelCount,\n\t\t\tchannelCountMode: node.channelCountMode,\n\t\t\tchannelInterpretation: node.channelInterpretation,\n\t\t};\n\t}\n\n\t/**\n\t * channelCount is the number of channels used when up-mixing and down-mixing\n\t * connections to any inputs to the node. The default value is 2 except for\n\t * specific nodes where its value is specially determined.\n\t */\n\tget channelCount(): number {\n\t\treturn this._getChannelProperties().channelCount;\n\t}\n\tset channelCount(channelCount) {\n\t\tconst props = this._getChannelProperties();\n\t\t// merge it with the other properties\n\t\tthis._setChannelProperties(Object.assign(props, { channelCount }));\n\t}\n\n\t/**\n\t * channelCountMode determines how channels will be counted when up-mixing and\n\t * down-mixing connections to any inputs to the node.\n\t * The default value is \"max\". This attribute has no effect for nodes with no inputs.\n\t * * \"max\" - computedNumberOfChannels is the maximum of the number of channels of all connections to an input. In this mode channelCount is ignored.\n\t * * \"clamped-max\" - computedNumberOfChannels is determined as for \"max\" and then clamped to a maximum value of the given channelCount.\n\t * * \"explicit\" - computedNumberOfChannels is the exact value as specified by the channelCount.\n\t */\n\tget channelCountMode(): ChannelCountMode {\n\t\treturn this._getChannelProperties().channelCountMode;\n\t}\n\tset channelCountMode(channelCountMode) {\n\t\tconst props = this._getChannelProperties();\n\t\t// merge it with the other properties\n\t\tthis._setChannelProperties(Object.assign(props, { channelCountMode }));\n\t}\n\n\t/**\n\t * channelInterpretation determines how individual channels will be treated\n\t * when up-mixing and down-mixing connections to any inputs to the node.\n\t * The default value is \"speakers\".\n\t */\n\tget channelInterpretation(): ChannelInterpretation {\n\t\treturn this._getChannelProperties().channelInterpretation;\n\t}\n\tset channelInterpretation(channelInterpretation) {\n\t\tconst props = this._getChannelProperties();\n\t\t// merge it with the other properties\n\t\tthis._setChannelProperties(Object.assign(props, { channelInterpretation }));\n\t}\n\n\t//-------------------------------------\n\t// CONNECTIONS\n\t//-------------------------------------\n\n\t/**\n\t * connect the output of a ToneAudioNode to an AudioParam, AudioNode, or ToneAudioNode\n\t * @param destination The output to connect to\n\t * @param outputNum The output to connect from\n\t * @param inputNum The input to connect to\n\t */\n\tconnect(destination: InputNode, outputNum = 0, inputNum = 0): this {\n\t\tconnect(this, destination, outputNum, inputNum);\n\t\treturn this;\n\t}\n\n\t/**\n\t * Connect the output to the context's destination node.\n\t * @example\n\t * const osc = new Tone.Oscillator(\"C2\").start();\n\t * osc.toDestination();\n\t */\n\ttoDestination(): this {\n\t\tthis.connect(this.context.destination);\n\t\treturn this;\n\t}\n\n\t/**\n\t * Connect the output to the context's destination node.\n\t * See [[toDestination]]\n\t * @deprecated\n\t */\n\ttoMaster(): this {\n\t\twarn(\"toMaster() has been renamed toDestination()\");\n\t\treturn this.toDestination();\n\t}\n\n\t/**\n\t * disconnect the output\n\t */\n\tdisconnect(destination?: InputNode, outputNum = 0, inputNum = 0): this {\n\t\tdisconnect(this, destination, outputNum, inputNum);\n\t\treturn this;\n\t}\n\n\t/**\n\t * Connect the output of this node to the rest of the nodes in series.\n\t * @example\n\t * const player = new Tone.Player(\"https://tonejs.github.io/audio/drum-samples/handdrum-loop.mp3\");\n\t * player.autostart = true;\n\t * const filter = new Tone.AutoFilter(4).start();\n\t * const distortion = new Tone.Distortion(0.5);\n\t * // connect the player to the filter, distortion and then to the master output\n\t * player.chain(filter, distortion, Tone.Destination);\n\t */\n\tchain(...nodes: InputNode[]): this {\n\t\tconnectSeries(this, ...nodes);\n\t\treturn this;\n\t}\n\n\t/**\n\t * connect the output of this node to the rest of the nodes in parallel.\n\t * @example\n\t * const player = new Tone.Player(\"https://tonejs.github.io/audio/drum-samples/conga-rhythm.mp3\");\n\t * player.autostart = true;\n\t * const pitchShift = new Tone.PitchShift(4).toDestination();\n\t * const filter = new Tone.Filter(\"G5\").toDestination();\n\t * // connect a node to the pitch shift and filter in parallel\n\t * player.fan(pitchShift, filter);\n\t */\n\tfan(...nodes: InputNode[]): this {\n\t\tnodes.forEach(node => this.connect(node));\n\t\treturn this;\n\t}\n\n\t/**\n\t * Dispose and disconnect\n\t */\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tif (isDefined(this.input)) {\n\t\t\tif (this.input instanceof ToneAudioNode) {\n\t\t\t\tthis.input.dispose();\n\t\t\t} else if (isAudioNode(this.input)) {\n\t\t\t\tthis.input.disconnect();\n\t\t\t}\n\t\t}\n\t\tif (isDefined(this.output)) {\n\t\t\tif (this.output instanceof ToneAudioNode) {\n\t\t\t\tthis.output.dispose();\n\t\t\t} else if (isAudioNode(this.output)) {\n\t\t\t\tthis.output.disconnect();\n\t\t\t}\n\t\t}\n\t\tthis._internalChannels = [];\n\t\treturn this;\n\t}\n}\n\n//-------------------------------------\n// CONNECTIONS\n//-------------------------------------\n\n/**\n * connect together all of the arguments in series\n * @param nodes\n */\nexport function connectSeries(...nodes: InputNode[]): void {\n\tconst first = nodes.shift();\n\tnodes.reduce((prev, current) => {\n\t\tif (prev instanceof ToneAudioNode) {\n\t\t\tprev.connect(current);\n\t\t} else if (isAudioNode(prev)) {\n\t\t\tconnect(prev, current);\n\t\t}\n\t\treturn current;\n\t}, first);\n}\n\n/**\n * Connect two nodes together so that signal flows from the\n * first node to the second. Optionally specify the input and output channels.\n * @param srcNode The source node\n * @param dstNode The destination node\n * @param outputNumber The output channel of the srcNode\n * @param inputNumber The input channel of the dstNode\n */\nexport function connect(srcNode: OutputNode, dstNode: InputNode, outputNumber = 0, inputNumber = 0): void {\n\n\tassert(isDefined(srcNode), \"Cannot connect from undefined node\");\n\tassert(isDefined(dstNode), \"Cannot connect to undefined node\");\n\n\tif (dstNode instanceof ToneAudioNode || isAudioNode(dstNode)) {\n\t\tassert(dstNode.numberOfInputs > 0, \"Cannot connect to node with no inputs\");\n\t}\n\tassert(srcNode.numberOfOutputs > 0, \"Cannot connect from node with no outputs\");\n\n\t// resolve the input of the dstNode\n\twhile ((dstNode instanceof ToneAudioNode || dstNode instanceof Param)) {\n\t\tif (isDefined(dstNode.input)) {\n\t\t\tdstNode = dstNode.input;\n\t\t}\n\t}\n\n\twhile (srcNode instanceof ToneAudioNode) {\n\t\tif (isDefined(srcNode.output)) {\n\t\t\tsrcNode = srcNode.output;\n\t\t}\n\t}\n\n\t// make the connection\n\tif (isAudioParam(dstNode)) {\n\t\tsrcNode.connect(dstNode as AudioParam, outputNumber);\n\t} else {\n\t\tsrcNode.connect(dstNode, outputNumber, inputNumber);\n\t}\n}\n\n/**\n * Disconnect a node from all nodes or optionally include a destination node and input/output channels.\n * @param srcNode The source node\n * @param dstNode The destination node\n * @param outputNumber The output channel of the srcNode\n * @param inputNumber The input channel of the dstNode\n */\nexport function disconnect(\n\tsrcNode: OutputNode,\n\tdstNode?: InputNode,\n\toutputNumber = 0,\n\tinputNumber = 0,\n): void {\n\n\t// resolve the destination node\n\tif (isDefined(dstNode)) {\n\t\twhile (dstNode instanceof ToneAudioNode) {\n\t\t\tdstNode = dstNode.input;\n\t\t}\n\t}\n\n\t// resolve the src node\n\twhile (!(isAudioNode(srcNode))) {\n\t\tif (isDefined(srcNode.output)) {\n\t\t\tsrcNode = srcNode.output;\n\t\t}\n\t}\n\n\tif (isAudioParam(dstNode)) {\n\t\tsrcNode.disconnect(dstNode, outputNumber);\n\t} else if (isAudioNode(dstNode)) {\n\t\tsrcNode.disconnect(dstNode, outputNumber, inputNumber);\n\t} else {\n\t\tsrcNode.disconnect();\n\t}\n}\n\n/**\n * Connect the output of one or more source nodes to a single destination node\n * @param nodes One or more source nodes followed by one destination node\n * @example\n * const player = new Tone.Player(\"https://tonejs.github.io/audio/drum-samples/conga-rhythm.mp3\");\n * const player1 = new Tone.Player(\"https://tonejs.github.io/audio/drum-samples/conga-rhythm.mp3\");\n * const filter = new Tone.Filter(\"G5\").toDestination();\n * // connect nodes to a common destination\n * fanIn(player, player1, filter);\n */\nexport function fanIn(...nodes: OutputNode[]): void {\n\tconst dstNode = nodes.pop();\n\n\tif (isDefined(dstNode)) {\n\t\tnodes.forEach(node => connect(node, dstNode));\n\t}\n}\n","import { Param } from \"../context/Param\";\nimport { UnitMap, UnitName } from \"../type/Units\";\nimport { optionsFromArguments } from \"../util/Defaults\";\nimport { readOnly } from \"../util/Interface\";\nimport { ToneAudioNode, ToneAudioNodeOptions } from \"./ToneAudioNode\";\n\ninterface GainOptions<TypeName extends UnitName> extends ToneAudioNodeOptions {\n\tgain: UnitMap[TypeName];\n\tunits: TypeName;\n\tconvert: boolean;\n\tminValue?: number;\n\tmaxValue?: number;\n}\n\n/**\n * A thin wrapper around the Native Web Audio GainNode.\n * The GainNode is a basic building block of the Web Audio\n * API and is useful for routing audio and adjusting gains.\n * @category Core\n * @example\n * return Tone.Offline(() => {\n * \tconst gainNode = new Tone.Gain(0).toDestination();\n * \tconst osc = new Tone.Oscillator(30).connect(gainNode).start();\n * \tgainNode.gain.rampTo(1, 0.1);\n * \tgainNode.gain.rampTo(0, 0.4, 0.2);\n * }, 0.7, 1);\n */\nexport class Gain<TypeName extends \"gain\" | \"decibels\" | \"normalRange\" = \"gain\"> extends ToneAudioNode<GainOptions<TypeName>> {\n\n\treadonly name: string = \"Gain\";\n\n\t/**\n\t * The gain parameter of the gain node.\n\t * @example\n\t * const gainNode = new Tone.Gain(0).toDestination();\n\t * const osc = new Tone.Oscillator().connect(gainNode).start();\n\t * gainNode.gain.rampTo(1, 0.1);\n\t * gainNode.gain.rampTo(0, 2, \"+0.5\");\n\t */\n\treadonly gain: Param<TypeName>;\n\n\t/**\n\t * The wrapped GainNode.\n\t */\n\tprivate _gainNode: GainNode = this.context.createGain();\n\n\t// input = output\n\treadonly input: GainNode = this._gainNode;\n\treadonly output: GainNode = this._gainNode;\n\n\t/**\n\t * @param  gain The initial gain of the GainNode\n\t * @param units The units of the gain parameter.\n\t */\n\tconstructor(gain?: UnitMap[TypeName], units?: TypeName);\n\tconstructor(options?: Partial<GainOptions<TypeName>>);\n\tconstructor() {\n\t\tsuper(optionsFromArguments(Gain.getDefaults(), arguments, [\"gain\", \"units\"]));\n\t\tconst options = optionsFromArguments(Gain.getDefaults(), arguments, [\"gain\", \"units\"]);\n\n\t\tthis.gain = new Param({\n\t\t\tcontext: this.context,\n\t\t\tconvert: options.convert,\n\t\t\tparam: this._gainNode.gain,\n\t\t\tunits: options.units,\n\t\t\tvalue: options.gain,\n\t\t\tminValue: options.minValue,\n\t\t\tmaxValue: options.maxValue,\n\t\t});\n\t\treadOnly(this, \"gain\");\n\t}\n\n\tstatic getDefaults(): GainOptions<any> {\n\t\treturn Object.assign(ToneAudioNode.getDefaults(), {\n\t\t\tconvert: true,\n\t\t\tgain: 1,\n\t\t\tunits: \"gain\",\n\t\t});\n\t}\n\n\t/**\n\t * Clean up.\n\t */\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis._gainNode.disconnect();\n\t\tthis.gain.dispose();\n\t\treturn this;\n\t}\n}\n","import { Gain } from \"../core/context/Gain\";\nimport {\n\tToneAudioNode,\n\tToneAudioNodeOptions,\n} from \"../core/context/ToneAudioNode\";\nimport { GainFactor, Seconds, Time } from \"../core/type/Units\";\nimport { noOp } from \"../core/util/Interface\";\nimport { assert } from \"../core/util/Debug\";\nimport { BasicPlaybackState } from \"../core/util/StateTimeline\";\n\nexport type OneShotSourceCurve = \"linear\" | \"exponential\";\n\ntype onEndedCallback = (source: OneShotSource<any>) => void;\n\nexport interface OneShotSourceOptions extends ToneAudioNodeOptions {\n\tonended: onEndedCallback;\n\tfadeIn: Time;\n\tfadeOut: Time;\n\tcurve: OneShotSourceCurve;\n}\n\n/**\n * Base class for fire-and-forget nodes\n */\nexport abstract class OneShotSource<\n\tOptions extends ToneAudioNodeOptions\n> extends ToneAudioNode<Options> {\n\t/**\n\t * The callback to invoke after the\n\t * source is done playing.\n\t */\n\tonended: onEndedCallback = noOp;\n\n\t/**\n\t * Sources do not have input nodes\n\t */\n\tinput: undefined;\n\n\t/**\n\t * The start time\n\t */\n\tprotected _startTime = -1;\n\n\t/**\n\t * The stop time\n\t */\n\tprotected _stopTime = -1;\n\n\t/**\n\t * The id of the timeout\n\t */\n\tprivate _timeout = -1;\n\n\t/**\n\t * The public output node\n\t */\n\toutput: Gain = new Gain({\n\t\tcontext: this.context,\n\t\tgain: 0,\n\t});\n\n\t/**\n\t * The output gain node.\n\t */\n\tprotected _gainNode = this.output;\n\n\t/**\n\t * The fadeIn time of the amplitude envelope.\n\t */\n\tprotected _fadeIn: Time;\n\n\t/**\n\t * The fadeOut time of the amplitude envelope.\n\t */\n\tprotected _fadeOut: Time;\n\n\t/**\n\t * The curve applied to the fades, either \"linear\" or \"exponential\"\n\t */\n\tprotected _curve: OneShotSourceCurve;\n\n\tconstructor(options: OneShotSourceOptions) {\n\t\tsuper(options);\n\n\t\tthis._fadeIn = options.fadeIn;\n\t\tthis._fadeOut = options.fadeOut;\n\t\tthis._curve = options.curve;\n\t\tthis.onended = options.onended;\n\t}\n\n\tstatic getDefaults(): OneShotSourceOptions {\n\t\treturn Object.assign(ToneAudioNode.getDefaults(), {\n\t\t\tcurve: \"linear\" as OneShotSourceCurve,\n\t\t\tfadeIn: 0,\n\t\t\tfadeOut: 0,\n\t\t\tonended: noOp,\n\t\t});\n\t}\n\n\t/**\n\t * Stop the source node\n\t */\n\tprotected abstract _stopSource(time: Seconds): void;\n\n\t/**\n\t * Start the source node at the given time\n\t * @param  time When to start the node\n\t */\n\tprotected abstract start(time?: Time): this;\n\t/**\n\t * Start the source at the given time\n\t * @param  time When to start the source\n\t */\n\tprotected _startGain(time: Seconds, gain: GainFactor = 1): this {\n\t\tassert(\n\t\t\tthis._startTime === -1,\n\t\t\t\"Source cannot be started more than once\"\n\t\t);\n\t\t// apply a fade in envelope\n\t\tconst fadeInTime = this.toSeconds(this._fadeIn);\n\n\t\t// record the start time\n\t\tthis._startTime = time + fadeInTime;\n\t\tthis._startTime = Math.max(this._startTime, this.context.currentTime);\n\n\t\t// schedule the envelope\n\t\tif (fadeInTime > 0) {\n\t\t\tthis._gainNode.gain.setValueAtTime(0, time);\n\t\t\tif (this._curve === \"linear\") {\n\t\t\t\tthis._gainNode.gain.linearRampToValueAtTime(\n\t\t\t\t\tgain,\n\t\t\t\t\ttime + fadeInTime\n\t\t\t\t);\n\t\t\t} else {\n\t\t\t\tthis._gainNode.gain.exponentialApproachValueAtTime(\n\t\t\t\t\tgain,\n\t\t\t\t\ttime,\n\t\t\t\t\tfadeInTime\n\t\t\t\t);\n\t\t\t}\n\t\t} else {\n\t\t\tthis._gainNode.gain.setValueAtTime(gain, time);\n\t\t}\n\t\treturn this;\n\t}\n\n\t/**\n\t * Stop the source node at the given time.\n\t * @param time When to stop the source\n\t */\n\tstop(time?: Time): this {\n\t\tthis.log(\"stop\", time);\n\t\tthis._stopGain(this.toSeconds(time));\n\t\treturn this;\n\t}\n\n\t/**\n\t * Stop the source at the given time\n\t * @param  time When to stop the source\n\t */\n\tprotected _stopGain(time: Seconds): this {\n\t\tassert(this._startTime !== -1, \"'start' must be called before 'stop'\");\n\t\t// cancel the previous stop\n\t\tthis.cancelStop();\n\n\t\t// the fadeOut time\n\t\tconst fadeOutTime = this.toSeconds(this._fadeOut);\n\n\t\t// schedule the stop callback\n\t\tthis._stopTime = this.toSeconds(time) + fadeOutTime;\n\t\tthis._stopTime = Math.max(this._stopTime, this.context.currentTime);\n\t\tif (fadeOutTime > 0) {\n\t\t\t// start the fade out curve at the given time\n\t\t\tif (this._curve === \"linear\") {\n\t\t\t\tthis._gainNode.gain.linearRampTo(0, fadeOutTime, time);\n\t\t\t} else {\n\t\t\t\tthis._gainNode.gain.targetRampTo(0, fadeOutTime, time);\n\t\t\t}\n\t\t} else {\n\t\t\t// stop any ongoing ramps, and set the value to 0\n\t\t\tthis._gainNode.gain.cancelAndHoldAtTime(time);\n\t\t\tthis._gainNode.gain.setValueAtTime(0, time);\n\t\t}\n\t\tthis.context.clearTimeout(this._timeout);\n\t\tthis._timeout = this.context.setTimeout(() => {\n\t\t\t// allow additional time for the exponential curve to fully decay\n\t\t\tconst additionalTail =\n\t\t\t\tthis._curve === \"exponential\" ? fadeOutTime * 2 : 0;\n\t\t\tthis._stopSource(this.now() + additionalTail);\n\t\t\tthis._onended();\n\t\t}, this._stopTime - this.context.currentTime);\n\t\treturn this;\n\t}\n\n\t/**\n\t * Invoke the onended callback\n\t */\n\tprotected _onended(): void {\n\t\tif (this.onended !== noOp) {\n\t\t\tthis.onended(this);\n\t\t\t// overwrite onended to make sure it only is called once\n\t\t\tthis.onended = noOp;\n\t\t\t// dispose when it's ended to free up for garbage collection only in the online context\n\t\t\tif (!this.context.isOffline) {\n\t\t\t\tconst disposeCallback = () => this.dispose();\n\t\t\t\t// @ts-ignore\n\t\t\t\tif (typeof window.requestIdleCallback !== \"undefined\") {\n\t\t\t\t\t// @ts-ignore\n\t\t\t\t\twindow.requestIdleCallback(disposeCallback);\n\t\t\t\t} else {\n\t\t\t\t\tsetTimeout(disposeCallback, 1000);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\t/**\n\t * Get the playback state at the given time\n\t */\n\tgetStateAtTime = function(time: Time): BasicPlaybackState {\n\t\tconst computedTime = this.toSeconds(time);\n\t\tif (\n\t\t\tthis._startTime !== -1 &&\n\t\t\tcomputedTime >= this._startTime &&\n\t\t\t(this._stopTime === -1 || computedTime <= this._stopTime)\n\t\t) {\n\t\t\treturn \"started\";\n\t\t} else {\n\t\t\treturn \"stopped\";\n\t\t}\n\t};\n\n\t/**\n\t * Get the playback state at the current time\n\t */\n\tget state(): BasicPlaybackState {\n\t\treturn this.getStateAtTime(this.now());\n\t}\n\n\t/**\n\t * Cancel a scheduled stop event\n\t */\n\tcancelStop(): this {\n\t\tthis.log(\"cancelStop\");\n\t\tassert(this._startTime !== -1, \"Source is not started\");\n\t\t// cancel the stop envelope\n\t\tthis._gainNode.gain.cancelScheduledValues(\n\t\t\tthis._startTime + this.sampleTime\n\t\t);\n\t\tthis.context.clearTimeout(this._timeout);\n\t\tthis._stopTime = -1;\n\t\treturn this;\n\t}\n\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis._gainNode.dispose();\n\t\tthis.onended = noOp;\n\t\treturn this;\n\t}\n}\n","import { connect } from \"../core/context/ToneAudioNode\";\nimport { Param } from \"../core/context/Param\";\nimport { Seconds, Time, UnitMap, UnitName } from \"../core/type/Units\";\nimport { optionsFromArguments } from \"../core/util/Defaults\";\nimport { OneShotSource, OneShotSourceOptions } from \"../source/OneShotSource\";\n\nexport interface ToneConstantSourceOptions<TypeName extends UnitName> extends OneShotSourceOptions {\n\tconvert: boolean;\n\toffset: UnitMap[TypeName];\n\tunits: TypeName;\n\tminValue?: number;\n\tmaxValue?: number;\n}\n\n/**\n * Wrapper around the native fire-and-forget ConstantSource.\n * Adds the ability to reschedule the stop method.\n * @category Signal\n */\nexport class ToneConstantSource<TypeName extends UnitName = \"number\"> extends OneShotSource<ToneConstantSourceOptions<TypeName>> {\n\n\treadonly name: string = \"ToneConstantSource\";\n\n\t/**\n\t * The signal generator\n\t */\n\tprivate _source = this.context.createConstantSource();\n\n\t/**\n\t * The offset of the signal generator\n\t */\n\treadonly offset: Param<TypeName>;\n\n\t/**\n\t * @param  offset   The offset value\n\t */\n\tconstructor(offset: UnitMap[TypeName]);\n\tconstructor(options?: Partial<ToneConstantSourceOptions<TypeName>>);\n\tconstructor() {\n\n\t\tsuper(optionsFromArguments(ToneConstantSource.getDefaults(), arguments, [\"offset\"]));\n\t\tconst options = optionsFromArguments(ToneConstantSource.getDefaults(), arguments, [\"offset\"]);\n\n\t\tconnect(this._source, this._gainNode);\n\n\t\tthis.offset = new Param({\n\t\t\tcontext: this.context,\n\t\t\tconvert: options.convert,\n\t\t\tparam: this._source.offset,\n\t\t\tunits: options.units,\n\t\t\tvalue: options.offset,\n\t\t\tminValue: options.minValue,\n\t\t\tmaxValue: options.maxValue,\n\t\t});\n\t}\n\n\tstatic getDefaults(): ToneConstantSourceOptions<any> {\n\t\treturn Object.assign(OneShotSource.getDefaults(), {\n\t\t\tconvert: true,\n\t\t\toffset: 1,\n\t\t\tunits: \"number\" as UnitName,\n\t\t});\n\t}\n\n\t/**\n\t * Start the source node at the given time\n\t * @param  time When to start the source\n\t */\n\tstart(time?: Time): this {\n\t\tconst computedTime = this.toSeconds(time);\n\t\tthis.log(\"start\", computedTime);\n\t\tthis._startGain(computedTime);\n\t\tthis._source.start(computedTime);\n\t\treturn this;\n\t}\n\n\tprotected _stopSource(time?: Seconds): void {\n\t\tthis._source.stop(time);\n\t}\n\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tif (this.state === \"started\") {\n\t\t\tthis.stop();\n\t\t}\n\t\tthis._source.disconnect();\n\t\tthis.offset.dispose();\n\t\treturn this;\n\t}\n}\n","import { AbstractParam } from \"../core/context/AbstractParam\";\nimport { Param } from \"../core/context/Param\";\nimport { InputNode, OutputNode, ToneAudioNode, ToneAudioNodeOptions } from \"../core/context/ToneAudioNode\";\nimport { connect } from \"../core/context/ToneAudioNode\";\nimport { Time, UnitMap, UnitName } from \"../core/type/Units\";\nimport { isAudioParam } from \"../core/util/AdvancedTypeCheck\";\nimport { optionsFromArguments } from \"../core/util/Defaults\";\nimport { ToneConstantSource } from \"./ToneConstantSource\";\n\nexport interface SignalOptions<TypeName extends UnitName> extends ToneAudioNodeOptions {\n\tvalue: UnitMap[TypeName];\n\tunits: TypeName;\n\tconvert: boolean;\n\tminValue?: number;\n\tmaxValue?: number;\n}\n\n/**\n * A signal is an audio-rate value. Tone.Signal is a core component of the library.\n * Unlike a number, Signals can be scheduled with sample-level accuracy. Tone.Signal\n * has all of the methods available to native Web Audio\n * [AudioParam](http://webaudio.github.io/web-audio-api/#the-audioparam-interface)\n * as well as additional conveniences. Read more about working with signals\n * [here](https://github.com/Tonejs/Tone.js/wiki/Signals).\n *\n * @example\n * const osc = new Tone.Oscillator().toDestination().start();\n * // a scheduleable signal which can be connected to control an AudioParam or another Signal\n * const signal = new Tone.Signal({\n * \tvalue: \"C4\",\n * \tunits: \"frequency\"\n * }).connect(osc.frequency);\n * // the scheduled ramp controls the connected signal\n * signal.rampTo(\"C2\", 4, \"+0.5\");\n * @category Signal\n */\nexport class Signal<TypeName extends UnitName = \"number\"> extends ToneAudioNode<SignalOptions<any>>\n\timplements AbstractParam<TypeName> {\n\n\treadonly name: string = \"Signal\";\n\n\t/**\n\t * Indicates if the value should be overridden on connection.\n\t */\n\treadonly override: boolean = true;\n\n\t/**\n\t * The constant source node which generates the signal\n\t */\n\tprotected _constantSource: ToneConstantSource<TypeName>;\n\treadonly output: OutputNode;\n\tprotected _param: Param<TypeName>;\n\treadonly input: InputNode;\n\n\t/**\n\t * @param value Initial value of the signal\n\t * @param units The unit name, e.g. \"frequency\"\n\t */\n\tconstructor(value?: UnitMap[TypeName], units?: TypeName);\n\tconstructor(options?: Partial<SignalOptions<TypeName>>);\n\tconstructor() {\n\n\t\tsuper(optionsFromArguments(Signal.getDefaults(), arguments, [\"value\", \"units\"]));\n\n\t\tconst options = optionsFromArguments(Signal.getDefaults(), arguments, [\"value\", \"units\"]) as SignalOptions<TypeName>;\n\n\t\tthis.output = this._constantSource = new ToneConstantSource({\n\t\t\tcontext: this.context,\n\t\t\tconvert: options.convert,\n\t\t\toffset: options.value,\n\t\t\tunits: options.units,\n\t\t\tminValue: options.minValue,\n\t\t\tmaxValue: options.maxValue,\n\t\t});\n\t\tthis._constantSource.start(0);\n\t\tthis.input = this._param = this._constantSource.offset;\n\t}\n\n\tstatic getDefaults(): SignalOptions<any> {\n\t\treturn Object.assign(ToneAudioNode.getDefaults(), {\n\t\t\tconvert: true,\n\t\t\tunits: \"number\" as UnitName,\n\t\t\tvalue: 0,\n\t\t});\n\t}\n\n\tconnect(destination: InputNode, outputNum = 0, inputNum = 0): this {\n\t\t// start it only when connected to something\n\t\tconnectSignal(this, destination, outputNum, inputNum);\n\t\treturn this;\n\t}\n\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis._param.dispose();\n\t\tthis._constantSource.dispose();\n\t\treturn this;\n\t}\n\n\t//-------------------------------------\n\t// ABSTRACT PARAM INTERFACE\n\t// just a proxy for the ConstantSourceNode's offset AudioParam\n\t// all docs are generated from AbstractParam.ts\n\t//-------------------------------------\n\n\tsetValueAtTime(value: UnitMap[TypeName], time: Time): this {\n\t\tthis._param.setValueAtTime(value, time);\n\t\treturn this;\n\t}\n\tgetValueAtTime(time: Time): UnitMap[TypeName] {\n\t\treturn this._param.getValueAtTime(time);\n\t}\n\tsetRampPoint(time: Time): this {\n\t\tthis._param.setRampPoint(time);\n\t\treturn this;\n\t}\n\tlinearRampToValueAtTime(value: UnitMap[TypeName], time: Time): this {\n\t\tthis._param.linearRampToValueAtTime(value, time);\n\t\treturn this;\n\t}\n\texponentialRampToValueAtTime(value: UnitMap[TypeName], time: Time): this {\n\t\tthis._param.exponentialRampToValueAtTime(value, time);\n\t\treturn this;\n\t}\n\texponentialRampTo(value: UnitMap[TypeName], rampTime: Time, startTime?: Time): this {\n\t\tthis._param.exponentialRampTo(value, rampTime, startTime);\n\t\treturn this;\n\t}\n\tlinearRampTo(value: UnitMap[TypeName], rampTime: Time, startTime?: Time): this {\n\t\tthis._param.linearRampTo(value, rampTime, startTime);\n\t\treturn this;\n\t}\n\ttargetRampTo(value: UnitMap[TypeName], rampTime: Time, startTime?: Time): this {\n\t\tthis._param.targetRampTo(value, rampTime, startTime);\n\t\treturn this;\n\t}\n\texponentialApproachValueAtTime(value: UnitMap[TypeName], time: Time, rampTime: Time): this {\n\t\tthis._param.exponentialApproachValueAtTime(value, time, rampTime);\n\t\treturn this;\n\t}\n\tsetTargetAtTime(value: UnitMap[TypeName], startTime: Time, timeConstant: number): this {\n\t\tthis._param.setTargetAtTime(value, startTime, timeConstant);\n\t\treturn this;\n\t}\n\tsetValueCurveAtTime(values: UnitMap[TypeName][], startTime: Time, duration: Time, scaling?: number): this {\n\t\tthis._param.setValueCurveAtTime(values, startTime, duration, scaling);\n\t\treturn this;\n\t}\n\tcancelScheduledValues(time: Time): this {\n\t\tthis._param.cancelScheduledValues(time);\n\t\treturn this;\n\t}\n\tcancelAndHoldAtTime(time: Time): this {\n\t\tthis._param.cancelAndHoldAtTime(time);\n\t\treturn this;\n\t}\n\trampTo(value: UnitMap[TypeName], rampTime: Time, startTime?: Time): this {\n\t\tthis._param.rampTo(value, rampTime, startTime);\n\t\treturn this;\n\t}\n\n\tget value(): UnitMap[TypeName] {\n\t\treturn this._param.value;\n\t}\n\tset value(value: UnitMap[TypeName]) {\n\t\tthis._param.value = value;\n\t}\n\n\tget convert(): boolean {\n\t\treturn this._param.convert;\n\t}\n\tset convert(convert: boolean) {\n\t\tthis._param.convert = convert;\n\t}\n\n\tget units(): UnitName {\n\t\treturn this._param.units;\n\t}\n\n\tget overridden(): boolean {\n\t\treturn this._param.overridden;\n\t}\n\tset overridden(overridden: boolean) {\n\t\tthis._param.overridden = overridden;\n\t}\n\n\tget maxValue(): number {\n\t\treturn this._param.maxValue;\n\t}\n\tget minValue(): number {\n\t\treturn this._param.minValue;\n\t}\n\n\t/**\n\t * See [[Param.apply]].\n\t */\n\tapply(param: Param | AudioParam): this {\n\t\tthis._param.apply(param);\n\t\treturn this;\n\t}\n}\n\n/**\n * When connecting from a signal, it's necessary to zero out the node destination\n * node if that node is also a signal. If the destination is not 0, then the values\n * will be summed. This method insures that the output of the destination signal will\n * be the same as the source signal, making the destination signal a pass through node.\n * @param signal The output signal to connect from\n * @param destination the destination to connect to\n * @param outputNum the optional output number\n * @param inputNum the input number\n */\nexport function connectSignal(signal: OutputNode, destination: InputNode, outputNum?: number, inputNum?: number): void {\n\tif (destination instanceof Param || isAudioParam(destination) ||\n\t\t(destination instanceof Signal && destination.override)) {\n\t\t// cancel changes\n\t\tdestination.cancelScheduledValues(0);\n\t\t// reset the value\n\t\tdestination.setValueAtTime(0, 0);\n\t\t// mark the value as overridden\n\t\tif (destination instanceof Signal) {\n\t\t\tdestination.overridden = true;\n\t\t}\n\t}\n\tconnect(signal, destination, outputNum, inputNum);\n}\n","import { AutomationEvent, Param, ParamOptions } from \"../context/Param\";\nimport { Seconds, Ticks, Time, UnitMap, UnitName } from \"../type/Units\";\nimport { optionsFromArguments } from \"../util/Defaults\";\nimport { Timeline } from \"../util/Timeline\";\nimport { isUndef } from \"../util/TypeCheck\";\n\ntype TickAutomationEvent = AutomationEvent & {\n\tticks: number;\n};\n\ninterface TickParamOptions<TypeName extends UnitName> extends ParamOptions<TypeName> {\n\tmultiplier: number;\n}\n\n/**\n * A Param class just for computing ticks. Similar to the [[Param]] class,\n * but offers conversion to BPM values as well as ability to compute tick\n * duration and elapsed ticks\n */\nexport class TickParam<TypeName extends \"hertz\" | \"bpm\"> extends Param<TypeName> {\n\n\treadonly name: string = \"TickParam\";\n\n\t/**\n\t * The timeline which tracks all of the automations.\n\t */\n\tprotected _events: Timeline<TickAutomationEvent> = new Timeline(Infinity);\n\n\t/**\n\t * The internal holder for the multiplier value\n\t */\n\tprivate _multiplier = 1;\n\n\t/**\n\t * @param param The AudioParam to wrap\n\t * @param units The unit name\n\t * @param convert Whether or not to convert the value to the target units\n\t */\n\t/**\n\t * @param value The initial value of the signal\n\t */\n\tconstructor(value?: number);\n\tconstructor(options: Partial<TickParamOptions<TypeName>>);\n\tconstructor() {\n\n\t\tsuper(optionsFromArguments(TickParam.getDefaults(), arguments, [\"value\"]));\n\t\tconst options = optionsFromArguments(TickParam.getDefaults(), arguments, [\"value\"]);\n\n\t\t// set the multiplier\n\t\tthis._multiplier = options.multiplier;\n\n\t\t// clear the ticks from the beginning\n\t\tthis._events.cancel(0);\n\t\t// set an initial event\n\t\tthis._events.add({\n\t\t\tticks: 0,\n\t\t\ttime: 0,\n\t\t\ttype: \"setValueAtTime\",\n\t\t\tvalue: this._fromType(options.value),\n\t\t});\n\t\tthis.setValueAtTime(options.value, 0);\n\t}\n\n\tstatic getDefaults(): TickParamOptions<any> {\n\t\treturn Object.assign(Param.getDefaults(), {\n\t\t\tmultiplier: 1,\n\t\t\tunits: \"hertz\",\n\t\t\tvalue: 1,\n\t\t});\n\t}\n\n\tsetTargetAtTime(value: UnitMap[TypeName], time: Time, constant: number): this {\n\t\t// approximate it with multiple linear ramps\n\t\ttime = this.toSeconds(time);\n\t\tthis.setRampPoint(time);\n\t\tconst computedValue = this._fromType(value);\n\n\t\t// start from previously scheduled value\n\t\tconst prevEvent = this._events.get(time) as TickAutomationEvent;\n\t\tconst segments = Math.round(Math.max(1 / constant, 1));\n\t\tfor (let i = 0; i <= segments; i++) {\n\t\t\tconst segTime = constant * i + time;\n\t\t\tconst rampVal = this._exponentialApproach(prevEvent.time, prevEvent.value, computedValue, constant, segTime);\n\t\t\tthis.linearRampToValueAtTime(this._toType(rampVal), segTime);\n\t\t}\n\t\treturn this;\n\t}\n\n\tsetValueAtTime(value: UnitMap[TypeName], time: Time): this {\n\t\tconst computedTime = this.toSeconds(time);\n\t\tsuper.setValueAtTime(value, time);\n\t\tconst event = this._events.get(computedTime) as TickAutomationEvent;\n\t\tconst previousEvent = this._events.previousEvent(event);\n\t\tconst ticksUntilTime = this._getTicksUntilEvent(previousEvent, computedTime);\n\t\tevent.ticks = Math.max(ticksUntilTime, 0);\n\t\treturn this;\n\t}\n\n\tlinearRampToValueAtTime(value: UnitMap[TypeName], time: Time): this {\n\t\tconst computedTime = this.toSeconds(time);\n\t\tsuper.linearRampToValueAtTime(value, time);\n\t\tconst event = this._events.get(computedTime) as TickAutomationEvent;\n\t\tconst previousEvent = this._events.previousEvent(event);\n\t\tconst ticksUntilTime = this._getTicksUntilEvent(previousEvent, computedTime);\n\t\tevent.ticks = Math.max(ticksUntilTime, 0);\n\t\treturn this;\n\t}\n\n\texponentialRampToValueAtTime(value: UnitMap[TypeName], time: Time): this {\n\t\t// aproximate it with multiple linear ramps\n\t\ttime = this.toSeconds(time);\n\t\tconst computedVal = this._fromType(value);\n\n\t\t// start from previously scheduled value\n\t\tconst prevEvent = this._events.get(time) as TickAutomationEvent;\n\t\t// approx 10 segments per second\n\t\tconst segments = Math.round(Math.max((time - prevEvent.time) * 10, 1));\n\t\tconst segmentDur = ((time - prevEvent.time) / segments);\n\t\tfor (let i = 0; i <= segments; i++) {\n\t\t\tconst segTime = segmentDur * i + prevEvent.time;\n\t\t\tconst rampVal = this._exponentialInterpolate(prevEvent.time, prevEvent.value, time, computedVal, segTime);\n\t\t\tthis.linearRampToValueAtTime(this._toType(rampVal), segTime);\n\t\t}\n\t\treturn this;\n\t}\n\n\t/**\n\t * Returns the tick value at the time. Takes into account\n\t * any automation curves scheduled on the signal.\n\t * @param  event The time to get the tick count at\n\t * @return The number of ticks which have elapsed at the time given any automations.\n\t */\n\tprivate _getTicksUntilEvent(event: TickAutomationEvent | null, time: number): Ticks {\n\t\tif (event === null) {\n\t\t\tevent = {\n\t\t\t\tticks: 0,\n\t\t\t\ttime: 0,\n\t\t\t\ttype: \"setValueAtTime\",\n\t\t\t\tvalue: 0,\n\t\t\t};\n\t\t} else if (isUndef(event.ticks)) {\n\t\t\tconst previousEvent = this._events.previousEvent(event);\n\t\t\tevent.ticks = this._getTicksUntilEvent(previousEvent, event.time);\n\t\t}\n\t\tconst val0 = this._fromType(this.getValueAtTime(event.time));\n\t\tlet val1 = this._fromType(this.getValueAtTime(time));\n\t\t// if it's right on the line, take the previous value\n\t\tconst onTheLineEvent = this._events.get(time);\n\t\tif (onTheLineEvent && onTheLineEvent.time === time && onTheLineEvent.type === \"setValueAtTime\") {\n\t\t\tval1 = this._fromType(this.getValueAtTime(time - this.sampleTime));\n\t\t}\n\t\treturn 0.5 * (time - event.time) * (val0 + val1) + event.ticks;\n\t}\n\n\t/**\n\t * Returns the tick value at the time. Takes into account\n\t * any automation curves scheduled on the signal.\n\t * @param  time The time to get the tick count at\n\t * @return The number of ticks which have elapsed at the time given any automations.\n\t */\n\tgetTicksAtTime(time: Time): Ticks {\n\t\tconst computedTime = this.toSeconds(time);\n\t\tconst event = this._events.get(computedTime);\n\t\treturn Math.max(this._getTicksUntilEvent(event, computedTime), 0);\n\t}\n\n\t/**\n\t * Return the elapsed time of the number of ticks from the given time\n\t * @param ticks The number of ticks to calculate\n\t * @param  time The time to get the next tick from\n\t * @return The duration of the number of ticks from the given time in seconds\n\t */\n\tgetDurationOfTicks(ticks: Ticks, time: Time): Seconds {\n\t\tconst computedTime = this.toSeconds(time);\n\t\tconst currentTick = this.getTicksAtTime(time);\n\t\treturn this.getTimeOfTick(currentTick + ticks) - computedTime;\n\t}\n\n\t/**\n\t * Given a tick, returns the time that tick occurs at.\n\t * @return The time that the tick occurs.\n\t */\n\tgetTimeOfTick(tick: Ticks): Seconds {\n\t\tconst before = this._events.get(tick, \"ticks\");\n\t\tconst after = this._events.getAfter(tick, \"ticks\");\n\t\tif (before && before.ticks === tick) {\n\t\t\treturn before.time;\n\t\t} else if (before && after &&\n\t\t\tafter.type === \"linearRampToValueAtTime\" &&\n\t\t\tbefore.value !== after.value) {\n\t\t\tconst val0 = this._fromType(this.getValueAtTime(before.time));\n\t\t\tconst val1 = this._fromType(this.getValueAtTime(after.time));\n\t\t\tconst delta = (val1 - val0) / (after.time - before.time);\n\t\t\tconst k = Math.sqrt(Math.pow(val0, 2) - 2 * delta * (before.ticks - tick));\n\t\t\tconst sol1 = (-val0 + k) / delta;\n\t\t\tconst sol2 = (-val0 - k) / delta;\n\t\t\treturn (sol1 > 0 ? sol1 : sol2) + before.time;\n\t\t} else if (before) {\n\t\t\tif (before.value === 0) {\n\t\t\t\treturn Infinity;\n\t\t\t} else {\n\t\t\t\treturn before.time + (tick - before.ticks) / before.value;\n\t\t\t}\n\t\t} else {\n\t\t\treturn tick / this._initialValue;\n\t\t}\n\t}\n\n\t/**\n\t * Convert some number of ticks their the duration in seconds accounting\n\t * for any automation curves starting at the given time.\n\t * @param  ticks The number of ticks to convert to seconds.\n\t * @param  when  When along the automation timeline to convert the ticks.\n\t * @return The duration in seconds of the ticks.\n\t */\n\tticksToTime(ticks: Ticks, when: Time): Seconds {\n\t\treturn this.getDurationOfTicks(ticks, when);\n\t}\n\n\t/**\n\t * The inverse of [[ticksToTime]]. Convert a duration in\n\t * seconds to the corresponding number of ticks accounting for any\n\t * automation curves starting at the given time.\n\t * @param  duration The time interval to convert to ticks.\n\t * @param  when When along the automation timeline to convert the ticks.\n\t * @return The duration in ticks.\n\t */\n\ttimeToTicks(duration: Time, when: Time): Ticks {\n\t\tconst computedTime = this.toSeconds(when);\n\t\tconst computedDuration = this.toSeconds(duration);\n\t\tconst startTicks = this.getTicksAtTime(computedTime);\n\t\tconst endTicks = this.getTicksAtTime(computedTime + computedDuration);\n\t\treturn endTicks - startTicks;\n\t}\n\n\t/**\n\t * Convert from the type when the unit value is BPM\n\t */\n\tprotected _fromType(val: UnitMap[TypeName]): number {\n\t\tif (this.units === \"bpm\" && this.multiplier) {\n\t\t\treturn 1 / (60 / val / this.multiplier);\n\t\t} else {\n\t\t\treturn super._fromType(val);\n\t\t}\n\t}\n\n\t/**\n\t * Special case of type conversion where the units === \"bpm\"\n\t */\n\tprotected _toType(val: number): UnitMap[TypeName] {\n\t\tif (this.units === \"bpm\" && this.multiplier) {\n\t\t\treturn (val / this.multiplier) * 60 as UnitMap[TypeName];\n\t\t} else {\n\t\t\treturn super._toType(val);\n\t\t}\n\t}\n\t/**\n\t * A multiplier on the bpm value. Useful for setting a PPQ relative to the base frequency value.\n\t */\n\tget multiplier(): number {\n\t\treturn this._multiplier;\n\t}\n\tset multiplier(m: number) {\n\t\t// get and reset the current value with the new multiplier\n\t\t// might be necessary to clear all the previous values\n\t\tconst currentVal = this.value;\n\t\tthis._multiplier = m;\n\t\tthis.cancelScheduledValues(0);\n\t\tthis.setValueAtTime(currentVal, 0);\n\t}\n}\n","import { Signal, SignalOptions } from \"../../signal/Signal\";\nimport { InputNode } from \"../context/ToneAudioNode\";\nimport { Seconds, Ticks, Time, UnitMap, UnitName } from \"../type/Units\";\nimport { optionsFromArguments } from \"../util/Defaults\";\nimport { TickParam } from \"./TickParam\";\n\ninterface TickSignalOptions<TypeName extends UnitName> extends SignalOptions<TypeName> {\n\tvalue: UnitMap[TypeName];\n\tmultiplier: number;\n}\n\n/**\n * TickSignal extends Tone.Signal, but adds the capability\n * to calculate the number of elapsed ticks. exponential and target curves\n * are approximated with multiple linear ramps.\n *\n * Thank you Bruno Dias, H. Sofia Pinto, and David M. Matos,\n * for your [WAC paper](https://smartech.gatech.edu/bitstream/handle/1853/54588/WAC2016-49.pdf)\n * describing integrating timing functions for tempo calculations.\n */\nexport class TickSignal<TypeName extends \"hertz\" | \"bpm\"> extends Signal<TypeName> {\n\n\treadonly name: string = \"TickSignal\";\n\n\t/**\n\t * The param which controls the output signal value\n\t */\n\tprotected _param: TickParam<TypeName>;\n\treadonly input: InputNode;\n\n\t/**\n\t * @param value The initial value of the signal\n\t */\n\tconstructor(value?: UnitMap[TypeName]);\n\tconstructor(options: Partial<TickSignalOptions<TypeName>>);\n\tconstructor() {\n\n\t\tsuper(optionsFromArguments(TickSignal.getDefaults(), arguments, [\"value\"]));\n\t\tconst options = optionsFromArguments(TickSignal.getDefaults(), arguments, [\"value\"]);\n\n\t\tthis.input = this._param = new TickParam({\n\t\t\tcontext: this.context,\n\t\t\tconvert: options.convert,\n\t\t\tmultiplier: options.multiplier,\n\t\t\tparam: this._constantSource.offset,\n\t\t\tunits: options.units,\n\t\t\tvalue: options.value,\n\t\t});\n\t}\n\n\tstatic getDefaults(): TickSignalOptions<any> {\n\t\treturn Object.assign(Signal.getDefaults(), {\n\t\t\tmultiplier: 1,\n\t\t\tunits: \"hertz\",\n\t\t\tvalue: 1,\n\t\t});\n\t}\n\n\tticksToTime(ticks: Ticks, when: Time): Seconds {\n\t\treturn this._param.ticksToTime(ticks, when);\n\t}\n\n\ttimeToTicks(duration: Time, when: Time): Ticks {\n\t\treturn this._param.timeToTicks(duration, when);\n\t}\n\n\tgetTimeOfTick(tick: Ticks): Seconds {\n\t\treturn this._param.getTimeOfTick(tick);\n\t}\n\n\tgetDurationOfTicks(ticks: Ticks, time: Time): Seconds {\n\t\treturn this._param.getDurationOfTicks(ticks, time);\n\t}\n\n\tgetTicksAtTime(time: Time): Ticks {\n\t\treturn this._param.getTicksAtTime(time);\n\t}\n\n\t/**\n\t * A multiplier on the bpm value. Useful for setting a PPQ relative to the base frequency value.\n\t */\n\tget multiplier(): number {\n\t\treturn this._param.multiplier;\n\t}\n\tset multiplier(m: number) {\n\t\tthis._param.multiplier = m;\n\t}\n\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis._param.dispose();\n\t\treturn this;\n\t}\n}\n","import { ToneWithContext, ToneWithContextOptions } from \"../context/ToneWithContext\";\nimport { Seconds, Ticks, Time } from \"../type/Units\";\nimport { optionsFromArguments } from \"../util/Defaults\";\nimport { readOnly } from \"../util/Interface\";\nimport { PlaybackState, StateTimeline, StateTimelineEvent } from \"../util/StateTimeline\";\nimport { Timeline } from \"../util/Timeline\";\nimport { isDefined } from \"../util/TypeCheck\";\nimport { TickSignal } from \"./TickSignal\";\nimport { EQ } from \"../util/Math\";\n\ninterface TickSourceOptions extends ToneWithContextOptions {\n\tfrequency: number;\n\tunits: \"bpm\" | \"hertz\";\n}\n\ninterface TickSourceOffsetEvent {\n\tticks: number;\n\ttime: number;\n\tseconds: number;\n}\n\n/**\n * Uses [TickSignal](TickSignal) to track elapsed ticks with complex automation curves.\n */\nexport class TickSource<TypeName extends \"bpm\" | \"hertz\"> extends ToneWithContext<TickSourceOptions> {\n\n\treadonly name: string = \"TickSource\";\n\n\t/**\n\t * The frequency the callback function should be invoked.\n\t */\n\treadonly frequency: TickSignal<TypeName>;\n\n\t/**\n\t * The state timeline\n\t */\n\tprivate _state: StateTimeline = new StateTimeline();\n\n\t/**\n\t * The offset values of the ticks\n\t */\n\tprivate _tickOffset: Timeline<TickSourceOffsetEvent> = new Timeline();\n\n\t/**\n\t * @param frequency The initial frequency that the signal ticks at\n\t */\n\tconstructor(frequency?: number);\n\tconstructor(options?: Partial<TickSourceOptions>);\n\tconstructor() {\n\t\tsuper(optionsFromArguments(TickSource.getDefaults(), arguments, [\"frequency\"]));\n\t\tconst options = optionsFromArguments(TickSource.getDefaults(), arguments, [\"frequency\"]);\n\n\t\tthis.frequency = new TickSignal({\n\t\t\tcontext: this.context,\n\t\t\tunits: options.units as TypeName,\n\t\t\tvalue: options.frequency,\n\t\t});\n\t\treadOnly(this, \"frequency\");\n\n\t\t// set the initial state\n\t\tthis._state.setStateAtTime(\"stopped\", 0);\n\t\t// add the first event\n\t\tthis.setTicksAtTime(0, 0);\n\t}\n\n\tstatic getDefaults(): TickSourceOptions {\n\t\treturn Object.assign({\n\t\t\tfrequency: 1,\n\t\t\tunits: \"hertz\" as const,\n\t\t}, ToneWithContext.getDefaults());\n\t}\n\n\t/**\n\t * Returns the playback state of the source, either \"started\", \"stopped\" or \"paused\".\n\t */\n\tget state(): PlaybackState {\n\t\treturn this.getStateAtTime(this.now());\n\t}\n\n\t/**\n\t * Start the clock at the given time. Optionally pass in an offset\n\t * of where to start the tick counter from.\n\t * @param  time    The time the clock should start\n\t * @param offset The number of ticks to start the source at\n\t */\n\tstart(time: Time, offset?: Ticks): this {\n\t\tconst computedTime = this.toSeconds(time);\n\t\tif (this._state.getValueAtTime(computedTime) !== \"started\") {\n\t\t\tthis._state.setStateAtTime(\"started\", computedTime);\n\t\t\tif (isDefined(offset)) {\n\t\t\t\tthis.setTicksAtTime(offset, computedTime);\n\t\t\t}\n\t\t}\n\t\treturn this;\n\t}\n\n\t/**\n\t * Stop the clock. Stopping the clock resets the tick counter to 0.\n\t * @param time The time when the clock should stop.\n\t */\n\tstop(time: Time): this {\n\t\tconst computedTime = this.toSeconds(time);\n\t\t// cancel the previous stop\n\t\tif (this._state.getValueAtTime(computedTime) === \"stopped\") {\n\t\t\tconst event = this._state.get(computedTime);\n\t\t\tif (event && event.time > 0) {\n\t\t\t\tthis._tickOffset.cancel(event.time);\n\t\t\t\tthis._state.cancel(event.time);\n\t\t\t}\n\t\t}\n\t\tthis._state.cancel(computedTime);\n\t\tthis._state.setStateAtTime(\"stopped\", computedTime);\n\t\tthis.setTicksAtTime(0, computedTime);\n\t\treturn this;\n\t}\n\n\t/**\n\t * Pause the clock. Pausing does not reset the tick counter.\n\t * @param time The time when the clock should stop.\n\t */\n\tpause(time: Time): this {\n\t\tconst computedTime = this.toSeconds(time);\n\t\tif (this._state.getValueAtTime(computedTime) === \"started\") {\n\t\t\tthis._state.setStateAtTime(\"paused\", computedTime);\n\t\t}\n\t\treturn this;\n\t}\n\n\t/**\n\t * Cancel start/stop/pause and setTickAtTime events scheduled after the given time.\n\t * @param time When to clear the events after\n\t */\n\tcancel(time: Time): this {\n\t\ttime = this.toSeconds(time);\n\t\tthis._state.cancel(time);\n\t\tthis._tickOffset.cancel(time);\n\t\treturn this;\n\t}\n\n\t/**\n\t * Get the elapsed ticks at the given time\n\t * @param  time  When to get the tick value\n\t * @return The number of ticks\n\t */\n\tgetTicksAtTime(time?: Time): Ticks {\n\t\tconst computedTime = this.toSeconds(time);\n\t\tconst stopEvent = this._state.getLastState(\"stopped\", computedTime) as StateTimelineEvent;\n\t\t// this event allows forEachBetween to iterate until the current time\n\t\tconst tmpEvent: StateTimelineEvent = { state: \"paused\", time: computedTime };\n\t\tthis._state.add(tmpEvent);\n\n\t\t// keep track of the previous offset event\n\t\tlet lastState = stopEvent;\n\t\tlet elapsedTicks = 0;\n\n\t\t// iterate through all the events since the last stop\n\t\tthis._state.forEachBetween(stopEvent.time, computedTime + this.sampleTime, e => {\n\t\t\tlet periodStartTime = lastState.time;\n\t\t\t// if there is an offset event in this period use that\n\t\t\tconst offsetEvent = this._tickOffset.get(e.time);\n\t\t\tif (offsetEvent && offsetEvent.time >= lastState.time) {\n\t\t\t\telapsedTicks = offsetEvent.ticks;\n\t\t\t\tperiodStartTime = offsetEvent.time;\n\t\t\t}\n\t\t\tif (lastState.state === \"started\" && e.state !== \"started\") {\n\t\t\t\telapsedTicks += this.frequency.getTicksAtTime(e.time) - this.frequency.getTicksAtTime(periodStartTime);\n\t\t\t}\n\t\t\tlastState = e;\n\t\t});\n\n\t\t// remove the temporary event\n\t\tthis._state.remove(tmpEvent);\n\n\t\t// return the ticks\n\t\treturn elapsedTicks;\n\t}\n\n\t/**\n\t * The number of times the callback was invoked. Starts counting at 0\n\t * and increments after the callback was invoked. Returns -1 when stopped.\n\t */\n\tget ticks(): Ticks {\n\t\treturn this.getTicksAtTime(this.now());\n\t}\n\tset ticks(t: Ticks) {\n\t\tthis.setTicksAtTime(t, this.now());\n\t}\n\n\t/**\n\t * The time since ticks=0 that the TickSource has been running. Accounts\n\t * for tempo curves\n\t */\n\tget seconds(): Seconds {\n\t\treturn this.getSecondsAtTime(this.now());\n\t}\n\tset seconds(s: Seconds) {\n\t\tconst now = this.now();\n\t\tconst ticks = this.frequency.timeToTicks(s, now);\n\t\tthis.setTicksAtTime(ticks, now);\n\t}\n\n\t/**\n\t * Return the elapsed seconds at the given time.\n\t * @param  time  When to get the elapsed seconds\n\t * @return  The number of elapsed seconds\n\t */\n\tgetSecondsAtTime(time: Time): Seconds {\n\t\ttime = this.toSeconds(time);\n\t\tconst stopEvent = this._state.getLastState(\"stopped\", time) as StateTimelineEvent;\n\t\t// this event allows forEachBetween to iterate until the current time\n\t\tconst tmpEvent: StateTimelineEvent = { state: \"paused\", time };\n\t\tthis._state.add(tmpEvent);\n\n\t\t// keep track of the previous offset event\n\t\tlet lastState = stopEvent;\n\t\tlet elapsedSeconds = 0;\n\n\t\t// iterate through all the events since the last stop\n\t\tthis._state.forEachBetween(stopEvent.time, time + this.sampleTime, e => {\n\t\t\tlet periodStartTime = lastState.time;\n\t\t\t// if there is an offset event in this period use that\n\t\t\tconst offsetEvent = this._tickOffset.get(e.time);\n\t\t\tif (offsetEvent && offsetEvent.time >= lastState.time) {\n\t\t\t\telapsedSeconds = offsetEvent.seconds;\n\t\t\t\tperiodStartTime = offsetEvent.time;\n\t\t\t}\n\t\t\tif (lastState.state === \"started\" && e.state !== \"started\") {\n\t\t\t\telapsedSeconds += e.time - periodStartTime;\n\t\t\t}\n\t\t\tlastState = e;\n\t\t});\n\n\t\t// remove the temporary event\n\t\tthis._state.remove(tmpEvent);\n\n\t\t// return the ticks\n\t\treturn elapsedSeconds;\n\t}\n\n\t/**\n\t * Set the clock's ticks at the given time.\n\t * @param  ticks The tick value to set\n\t * @param  time  When to set the tick value\n\t */\n\tsetTicksAtTime(ticks: Ticks, time: Time): this {\n\t\ttime = this.toSeconds(time);\n\t\tthis._tickOffset.cancel(time);\n\t\tthis._tickOffset.add({\n\t\t\tseconds: this.frequency.getDurationOfTicks(ticks, time),\n\t\t\tticks,\n\t\t\ttime,\n\t\t});\n\t\treturn this;\n\t}\n\n\t/**\n\t * Returns the scheduled state at the given time.\n\t * @param  time  The time to query.\n\t */\n\tgetStateAtTime(time: Time): PlaybackState {\n\t\ttime = this.toSeconds(time);\n\t\treturn this._state.getValueAtTime(time);\n\t}\n\n\t/**\n\t * Get the time of the given tick. The second argument\n\t * is when to test before. Since ticks can be set (with setTicksAtTime)\n\t * there may be multiple times for a given tick value.\n\t * @param  tick The tick number.\n\t * @param  before When to measure the tick value from.\n\t * @return The time of the tick\n\t */\n\tgetTimeOfTick(tick: Ticks, before = this.now()): Seconds {\n\t\tconst offset = this._tickOffset.get(before) as TickSourceOffsetEvent;\n\t\tconst event = this._state.get(before) as StateTimelineEvent;\n\t\tconst startTime = Math.max(offset.time, event.time);\n\t\tconst absoluteTicks = this.frequency.getTicksAtTime(startTime) + tick - offset.ticks;\n\t\treturn this.frequency.getTimeOfTick(absoluteTicks);\n\t}\n\n\t/**\n\t * Invoke the callback event at all scheduled ticks between the\n\t * start time and the end time\n\t * @param  startTime  The beginning of the search range\n\t * @param  endTime    The end of the search range\n\t * @param  callback   The callback to invoke with each tick\n\t */\n\tforEachTickBetween(startTime: number, endTime: number, callback: (when: Seconds, ticks: Ticks) => void): this {\n\t\t// only iterate through the sections where it is \"started\"\n\t\tlet lastStateEvent = this._state.get(startTime);\n\t\tthis._state.forEachBetween(startTime, endTime, event => {\n\t\t\tif (lastStateEvent && lastStateEvent.state === \"started\" && event.state !== \"started\") {\n\t\t\t\tthis.forEachTickBetween(Math.max(lastStateEvent.time, startTime), event.time - this.sampleTime, callback);\n\t\t\t}\n\t\t\tlastStateEvent = event;\n\t\t});\n\n\t\tlet error: Error | null = null;\n\n\t\tif (lastStateEvent && lastStateEvent.state === \"started\") {\n\t\t\tconst maxStartTime = Math.max(lastStateEvent.time, startTime);\n\t\t\t// figure out the difference between the frequency ticks and the\n\t\t\tconst startTicks = this.frequency.getTicksAtTime(maxStartTime);\n\t\t\tconst ticksAtStart = this.frequency.getTicksAtTime(lastStateEvent.time);\n\t\t\tconst diff = startTicks - ticksAtStart;\n\t\t\tlet offset = Math.ceil(diff) - diff;\n\t\t\t// guard against floating point issues\n\t\t\toffset = EQ(offset, 1) ? 0 : offset;\n\t\t\tlet nextTickTime = this.frequency.getTimeOfTick(startTicks + offset);\n\t\t\twhile (nextTickTime < endTime) {\n\t\t\t\ttry {\n\t\t\t\t\tcallback(nextTickTime, Math.round(this.getTicksAtTime(nextTickTime)));\n\t\t\t\t} catch (e) {\n\t\t\t\t\terror = e;\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t\tnextTickTime += this.frequency.getDurationOfTicks(1, nextTickTime);\n\t\t\t}\n\t\t}\n\n\t\tif (error) {\n\t\t\tthrow error;\n\t\t}\n\n\t\treturn this;\n\t}\n\n\t/**\n\t * Clean up\n\t */\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis._state.dispose();\n\t\tthis._tickOffset.dispose();\n\t\tthis.frequency.dispose();\n\t\treturn this;\n\t}\n}\n","import { ToneWithContext, ToneWithContextOptions } from \"../context/ToneWithContext\";\nimport { Frequency, Hertz, Seconds, Ticks, Time } from \"../type/Units\";\nimport { optionsFromArguments } from \"../util/Defaults\";\nimport { Emitter } from \"../util/Emitter\";\nimport { noOp, readOnly } from \"../util/Interface\";\nimport { PlaybackState, StateTimeline } from \"../util/StateTimeline\";\nimport { TickSignal } from \"./TickSignal\";\nimport { TickSource } from \"./TickSource\";\nimport { assertContextRunning } from \"../util/Debug\";\n\ntype ClockCallback = (time: Seconds, ticks?: Ticks) => void;\n\ninterface ClockOptions extends ToneWithContextOptions {\n\tfrequency: Hertz;\n\tcallback: ClockCallback;\n\tunits: \"hertz\" | \"bpm\";\n}\n\ntype ClockEvent = \"start\" | \"stop\" | \"pause\";\n\n/**\n * A sample accurate clock which provides a callback at the given rate.\n * While the callback is not sample-accurate (it is still susceptible to\n * loose JS timing), the time passed in as the argument to the callback\n * is precise. For most applications, it is better to use Tone.Transport\n * instead of the Clock by itself since you can synchronize multiple callbacks.\n * @example\n * // the callback will be invoked approximately once a second\n * // and will print the time exactly once a second apart.\n * const clock = new Tone.Clock(time => {\n * \tconsole.log(time);\n * }, 1);\n * clock.start();\n * @category Core\n */\nexport class Clock<TypeName extends \"bpm\" | \"hertz\" = \"hertz\">\n\textends ToneWithContext<ClockOptions> implements Emitter<ClockEvent> {\n\n\treadonly name: string = \"Clock\";\n\n\t/**\n\t * The callback function to invoke at the scheduled tick.\n\t */\n\tcallback: ClockCallback = noOp;\n\n\t/**\n\t * The tick counter\n\t */\n\tprivate _tickSource: TickSource<TypeName>;\n\n\t/**\n\t * The last time the loop callback was invoked\n\t */\n\tprivate _lastUpdate = 0;\n\n\t/**\n\t * Keep track of the playback state\n\t */\n\tprivate _state: StateTimeline = new StateTimeline(\"stopped\");\n\n\t/**\n\t * Context bound reference to the _loop method\n\t * This is necessary to remove the event in the end.\n\t */\n\tprivate _boundLoop: () => void = this._loop.bind(this);\n\n\t/**\n\t * The rate the callback function should be invoked.\n\t */\n\tfrequency: TickSignal<TypeName>;\n\n\t/**\n\t * @param callback The callback to be invoked with the time of the audio event\n\t * @param frequency The rate of the callback\n\t */\n\tconstructor(callback?: ClockCallback, frequency?: Frequency);\n\tconstructor(options: Partial<ClockOptions>);\n\tconstructor() {\n\n\t\tsuper(optionsFromArguments(Clock.getDefaults(), arguments, [\"callback\", \"frequency\"]));\n\t\tconst options = optionsFromArguments(Clock.getDefaults(), arguments, [\"callback\", \"frequency\"]);\n\n\t\tthis.callback = options.callback;\n\t\tthis._tickSource = new TickSource({\n\t\t\tcontext: this.context,\n\t\t\tfrequency: options.frequency,\n\t\t\tunits: options.units,\n\t\t});\n\t\tthis._lastUpdate = 0;\n\t\tthis.frequency = this._tickSource.frequency;\n\t\treadOnly(this, \"frequency\");\n\n\t\t// add an initial state\n\t\tthis._state.setStateAtTime(\"stopped\", 0);\n\n\t\t// bind a callback to the worker thread\n\t\tthis.context.on(\"tick\", this._boundLoop);\n\t}\n\n\tstatic getDefaults(): ClockOptions {\n\t\treturn Object.assign(ToneWithContext.getDefaults(), {\n\t\t\tcallback: noOp as ClockCallback,\n\t\t\tfrequency: 1,\n\t\t\tunits: \"hertz\",\n\t\t}) as ClockOptions;\n\t}\n\n\t/**\n\t * Returns the playback state of the source, either \"started\", \"stopped\" or \"paused\".\n\t */\n\tget state(): PlaybackState {\n\t\treturn this._state.getValueAtTime(this.now());\n\t}\n\n\t/**\n\t * Start the clock at the given time. Optionally pass in an offset\n\t * of where to start the tick counter from.\n\t * @param  time    The time the clock should start\n\t * @param offset  Where the tick counter starts counting from.\n\t */\n\tstart(time?: Time, offset?: Ticks): this {\n\t\t// make sure the context is running\n\t\tassertContextRunning(this.context);\n\t\t// start the loop\n\t\tconst computedTime = this.toSeconds(time);\n\t\tthis.log(\"start\", computedTime);\n\t\tif (this._state.getValueAtTime(computedTime) !== \"started\") {\n\t\t\tthis._state.setStateAtTime(\"started\", computedTime);\n\t\t\tthis._tickSource.start(computedTime, offset);\n\t\t\tif (computedTime < this._lastUpdate) {\n\t\t\t\tthis.emit(\"start\", computedTime, offset);\n\t\t\t}\n\t\t}\n\t\treturn this;\n\t}\n\n\t/**\n\t * Stop the clock. Stopping the clock resets the tick counter to 0.\n\t * @param time The time when the clock should stop.\n\t * @example\n\t * const clock = new Tone.Clock(time => {\n\t * \tconsole.log(time);\n\t * }, 1);\n\t * clock.start();\n\t * // stop the clock after 10 seconds\n\t * clock.stop(\"+10\");\n\t */\n\tstop(time?: Time): this {\n\t\tconst computedTime = this.toSeconds(time);\n\t\tthis.log(\"stop\", computedTime);\n\t\tthis._state.cancel(computedTime);\n\t\tthis._state.setStateAtTime(\"stopped\", computedTime);\n\t\tthis._tickSource.stop(computedTime);\n\t\tif (computedTime < this._lastUpdate) {\n\t\t\tthis.emit(\"stop\", computedTime);\n\t\t}\n\t\treturn this;\n\t}\n\n\t/**\n\t * Pause the clock. Pausing does not reset the tick counter.\n\t * @param time The time when the clock should stop.\n\t */\n\tpause(time?: Time): this {\n\t\tconst computedTime = this.toSeconds(time);\n\t\tif (this._state.getValueAtTime(computedTime) === \"started\") {\n\t\t\tthis._state.setStateAtTime(\"paused\", computedTime);\n\t\t\tthis._tickSource.pause(computedTime);\n\t\t\tif (computedTime < this._lastUpdate) {\n\t\t\t\tthis.emit(\"pause\", computedTime);\n\t\t\t}\n\t\t}\n\t\treturn this;\n\t}\n\n\t/**\n\t * The number of times the callback was invoked. Starts counting at 0\n\t * and increments after the callback was invoked.\n\t */\n\tget ticks(): Ticks {\n\t\treturn Math.ceil(this.getTicksAtTime(this.now()));\n\t}\n\tset ticks(t: Ticks) {\n\t\tthis._tickSource.ticks = t;\n\t}\n\n\t/**\n\t * The time since ticks=0 that the Clock has been running. Accounts for tempo curves\n\t */\n\tget seconds(): Seconds {\n\t\treturn this._tickSource.seconds;\n\t}\n\tset seconds(s: Seconds) {\n\t\tthis._tickSource.seconds = s;\n\t}\n\n\t/**\n\t * Return the elapsed seconds at the given time.\n\t * @param  time  When to get the elapsed seconds\n\t * @return  The number of elapsed seconds\n\t */\n\tgetSecondsAtTime(time: Time): Seconds {\n\t\treturn this._tickSource.getSecondsAtTime(time);\n\t}\n\n\t/**\n\t * Set the clock's ticks at the given time.\n\t * @param  ticks The tick value to set\n\t * @param  time  When to set the tick value\n\t */\n\tsetTicksAtTime(ticks: Ticks, time: Time): this {\n\t\tthis._tickSource.setTicksAtTime(ticks, time);\n\t\treturn this;\n\t}\n\n\t/**\n\t * Get the time of the given tick. The second argument\n\t * is when to test before. Since ticks can be set (with setTicksAtTime)\n\t * there may be multiple times for a given tick value.\n\t * @param  tick The tick number.\n\t * @param  before When to measure the tick value from.\n\t * @return The time of the tick\n\t */\n\tgetTimeOfTick(tick: Ticks, before = this.now()): Seconds {\n\t\treturn this._tickSource.getTimeOfTick(tick, before);\n\t}\n\n\t/**\n\t * Get the clock's ticks at the given time.\n\t * @param  time  When to get the tick value\n\t * @return The tick value at the given time.\n\t */\n\tgetTicksAtTime(time?: Time): Ticks {\n\t\treturn this._tickSource.getTicksAtTime(time);\n\t}\n\n\t/**\n\t * Get the time of the next tick\n\t * @param  offset The tick number.\n\t */\n\tnextTickTime(offset: Ticks, when: Time): Seconds {\n\t\tconst computedTime = this.toSeconds(when);\n\t\tconst currentTick = this.getTicksAtTime(computedTime);\n\t\treturn this._tickSource.getTimeOfTick(currentTick + offset, computedTime);\n\t}\n\n\t/**\n\t * The scheduling loop.\n\t */\n\tprivate _loop(): void {\n\n\t\tconst startTime = this._lastUpdate;\n\t\tconst endTime = this.now();\n\t\tthis._lastUpdate = endTime;\n\t\tthis.log(\"loop\", startTime, endTime);\n\n\t\tif (startTime !== endTime) {\n\t\t\t// the state change events\n\t\t\tthis._state.forEachBetween(startTime, endTime, e => {\n\t\t\t\tswitch (e.state) {\n\t\t\t\t\tcase \"started\":\n\t\t\t\t\t\tconst offset = this._tickSource.getTicksAtTime(e.time);\n\t\t\t\t\t\tthis.emit(\"start\", e.time, offset);\n\t\t\t\t\t\tbreak;\n\t\t\t\t\tcase \"stopped\":\n\t\t\t\t\t\tif (e.time !== 0) {\n\t\t\t\t\t\t\tthis.emit(\"stop\", e.time);\n\t\t\t\t\t\t}\n\t\t\t\t\t\tbreak;\n\t\t\t\t\tcase \"paused\":\n\t\t\t\t\t\tthis.emit(\"pause\", e.time);\n\t\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t});\n\t\t\t// the tick callbacks\n\t\t\tthis._tickSource.forEachTickBetween(startTime, endTime, (time, ticks) => {\n\t\t\t\tthis.callback(time, ticks);\n\t\t\t});\n\t\t}\n\t}\n\n\t/**\n\t * Returns the scheduled state at the given time.\n\t * @param  time  The time to query.\n\t * @return  The name of the state input in setStateAtTime.\n\t * @example\n\t * const clock = new Tone.Clock();\n\t * clock.start(\"+0.1\");\n\t * clock.getStateAtTime(\"+0.1\"); // returns \"started\"\n\t */\n\tgetStateAtTime(time: Time): PlaybackState {\n\t\tconst computedTime = this.toSeconds(time);\n\t\treturn this._state.getValueAtTime(computedTime);\n\t}\n\n\t/**\n\t * Clean up\n\t */\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis.context.off(\"tick\", this._boundLoop);\n\t\tthis._tickSource.dispose();\n\t\tthis._state.dispose();\n\t\treturn this;\n\t}\n\n\t//-------------------------------------\n\t// EMITTER MIXIN TO SATISFY COMPILER\n\t//-------------------------------------\n\n\ton!: (event: ClockEvent, callback: (...args: any[]) => void) => this;\n\tonce!: (event: ClockEvent, callback: (...args: any[]) => void) => this;\n\toff!: (event: ClockEvent, callback?: ((...args: any[]) => void) | undefined) => this;\n\temit!: (event: any, ...args: any[]) => this;\n}\n\nEmitter.mixin(Clock);\n","import { Param } from \"../context/Param\";\nimport { Seconds, Time } from \"../type/Units\";\nimport { optionsFromArguments } from \"../util/Defaults\";\nimport { readOnly } from \"../util/Interface\";\nimport { ToneAudioNode, ToneAudioNodeOptions } from \"./ToneAudioNode\";\n\nexport interface DelayOptions extends ToneAudioNodeOptions {\n\tdelayTime: Time;\n\tmaxDelay: Time;\n}\n\n/**\n * Wrapper around Web Audio's native [DelayNode](http://webaudio.github.io/web-audio-api/#the-delaynode-interface).\n * @category Core\n * @example\n * return Tone.Offline(() => {\n * \tconst delay = new Tone.Delay(0.1).toDestination();\n * \t// connect the signal to both the delay and the destination\n * \tconst pulse = new Tone.PulseOscillator().connect(delay).toDestination();\n * \t// start and stop the pulse\n * \tpulse.start(0).stop(0.01);\n * }, 0.5, 1);\n */\nexport class Delay extends ToneAudioNode<DelayOptions> {\n\n\treadonly name: string = \"Delay\";\n\n\t/**\n\t * Private holder of the max delay time\n\t */\n\tprivate _maxDelay: Seconds;\n\n\t/**\n\t * The amount of time the incoming signal is delayed.\n\t * @example\n\t * const delay = new Tone.Delay().toDestination();\n\t * // modulate the delayTime between 0.1 and 1 seconds\n\t * const delayLFO = new Tone.LFO(0.5, 0.1, 1).start().connect(delay.delayTime);\n\t * const pulse = new Tone.PulseOscillator().connect(delay).start();\n\t * // the change in delayTime causes the pitch to go up and down\n\t */\n\treadonly delayTime: Param<\"time\">;\n\n\t/**\n\t * Private reference to the internal DelayNode\n\t */\n\tprivate _delayNode: DelayNode;\n\treadonly input: DelayNode;\n\treadonly output: DelayNode;\n\n\t/**\n\t * @param delayTime The delay applied to the incoming signal.\n\t * @param maxDelay The maximum delay time.\n\t */\n\tconstructor(delayTime?: Time, maxDelay?: Time);\n\tconstructor(options?: Partial<DelayOptions>);\n\tconstructor() {\n\t\tsuper(optionsFromArguments(Delay.getDefaults(), arguments, [\"delayTime\", \"maxDelay\"]));\n\n\t\tconst options = optionsFromArguments(Delay.getDefaults(), arguments, [\"delayTime\", \"maxDelay\"]);\n\n\t\tconst maxDelayInSeconds = this.toSeconds(options.maxDelay);\n\t\tthis._maxDelay = Math.max(maxDelayInSeconds, this.toSeconds(options.delayTime));\n\n\t\tthis._delayNode = this.input = this.output = this.context.createDelay(maxDelayInSeconds);\n\n\t\tthis.delayTime = new Param({\n\t\t\tcontext: this.context,\n\t\t\tparam: this._delayNode.delayTime,\n\t\t\tunits: \"time\",\n\t\t\tvalue: options.delayTime,\n\t\t\tminValue: 0,\n\t\t\tmaxValue: this.maxDelay,\n\t\t});\n\n\t\treadOnly(this, \"delayTime\");\n\t}\n\n\tstatic getDefaults(): DelayOptions {\n\t\treturn Object.assign(ToneAudioNode.getDefaults(), {\n\t\t\tdelayTime: 0,\n\t\t\tmaxDelay: 1,\n\t\t});\n\t}\n\n\t/**\n\t * The maximum delay time. This cannot be changed after\n\t * the value is passed into the constructor.\n\t */\n\tget maxDelay(): Seconds {\n\t\treturn this._maxDelay;\n\t}\n\n\t/**\n\t * Clean up.\n\t */\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis._delayNode.disconnect();\n\t\tthis.delayTime.dispose();\n\t\treturn this;\n\t}\n}\n","import { getContext, setContext } from \"../Global\";\nimport { Seconds } from \"../type/Units\";\nimport { OfflineContext } from \"./OfflineContext\";\nimport { ToneAudioBuffer } from \"./ToneAudioBuffer\";\n\n/**\n * Generate a buffer by rendering all of the Tone.js code within the callback using the OfflineAudioContext.\n * The OfflineAudioContext is capable of rendering much faster than real time in many cases.\n * The callback function also passes in an offline instance of [[Context]] which can be used\n * to schedule events along the Transport. \n * @param  callback  All Tone.js nodes which are created and scheduled within this callback are recorded into the output Buffer.\n * @param  duration     the amount of time to record for.\n * @return  The promise which is invoked with the ToneAudioBuffer of the recorded output.\n * @example\n * // render 2 seconds of the oscillator\n * Tone.Offline(() => {\n * \t// only nodes created in this callback will be recorded\n * \tconst oscillator = new Tone.Oscillator().toDestination().start(0);\n * }, 2).then((buffer) => {\n * \t// do something with the output buffer\n * \tconsole.log(buffer);\n * });\n * @example\n * // can also schedule events along the Transport\n * // using the passed in Offline Transport\n * Tone.Offline(({ transport }) => {\n * \tconst osc = new Tone.Oscillator().toDestination();\n * \ttransport.schedule(time => {\n * \t\tosc.start(time).stop(time + 0.1);\n * \t}, 1);\n * \t// make sure to start the transport\n * \ttransport.start(0.2);\n * }, 4).then((buffer) => {\n * \t// do something with the output buffer\n * \tconsole.log(buffer);\n * });\n * @category Core\n */\nexport async function Offline(\n\tcallback: (context: OfflineContext) => Promise<void> | void,\n\tduration: Seconds,\n\tchannels = 2,\n\tsampleRate: number = getContext().sampleRate,\n): Promise<ToneAudioBuffer> {\n\t// set the OfflineAudioContext based on the current context\n\tconst originalContext = getContext();\n\n\tconst context = new OfflineContext(channels, duration, sampleRate);\n\tsetContext(context);\n\n\t// invoke the callback/scheduling\n\tawait callback(context);\n\n\t// then render the audio\n\tconst bufferPromise = context.render();\n\n\t// return the original AudioContext\n\tsetContext(originalContext);\n\n\t// await the rendering\n\tconst buffer = await bufferPromise;\n\n\t// return the audio\n\treturn new ToneAudioBuffer(buffer);\n}\n","import { Tone } from \"../Tone\";\nimport { optionsFromArguments } from \"../util/Defaults\";\nimport { noOp } from \"../util/Interface\";\nimport { isString } from \"../util/TypeCheck\";\nimport { ToneAudioBuffer } from \"./ToneAudioBuffer\";\nimport { assert } from \"../util/Debug\";\n\nexport interface ToneAudioBuffersUrlMap {\n\t[name: string]: string | AudioBuffer | ToneAudioBuffer;\n\t[name: number]: string | AudioBuffer | ToneAudioBuffer;\n}\n\ninterface ToneAudioBuffersOptions {\n\turls: ToneAudioBuffersUrlMap;\n\tonload: () => void;\n\tonerror?: (error: Error) => void;\n\tbaseUrl: string;\n}\n\n/**\n * A data structure for holding multiple buffers in a Map-like datastructure.\n *\n * @example\n * const pianoSamples = new Tone.ToneAudioBuffers({\n * \tA1: \"https://tonejs.github.io/audio/casio/A1.mp3\",\n * \tA2: \"https://tonejs.github.io/audio/casio/A2.mp3\",\n * }, () => {\n * \tconst player = new Tone.Player().toDestination();\n * \t// play one of the samples when they all load\n * \tplayer.buffer = pianoSamples.get(\"A2\");\n * \tplayer.start();\n * });\n * @example\n * // To pass in additional parameters in the second parameter\n * const buffers = new Tone.ToneAudioBuffers({\n * \t urls: {\n * \t\t A1: \"A1.mp3\",\n * \t\t A2: \"A2.mp3\",\n * \t },\n * \t onload: () => console.log(\"loaded\"),\n * \t baseUrl: \"https://tonejs.github.io/audio/casio/\"\n * });\n * @category Core\n */\nexport class ToneAudioBuffers extends Tone {\n\n\treadonly name: string = \"ToneAudioBuffers\";\n\n\t/**\n\t * All of the buffers\n\t */\n\tprivate _buffers: Map<string, ToneAudioBuffer> = new Map();\n\n\t/**\n\t * A path which is prefixed before every url.\n\t */\n\tbaseUrl: string;\n\n\t/**\n\t * Keep track of the number of loaded buffers\n\t */\n\tprivate _loadingCount = 0;\n\n\t/**\n\t * @param  urls  An object literal or array of urls to load.\n\t * @param onload  The callback to invoke when the buffers are loaded.\n\t * @param baseUrl A prefix url to add before all the urls\n\t */\n\tconstructor(\n\t\turls?: ToneAudioBuffersUrlMap,\n\t\tonload?: () => void,\n\t\tbaseUrl?: string,\n\t);\n\tconstructor(options?: Partial<ToneAudioBuffersOptions>);\n\tconstructor() {\n\n\t\tsuper();\n\t\tconst options = optionsFromArguments(\n\t\t\tToneAudioBuffers.getDefaults(), arguments, [\"urls\", \"onload\", \"baseUrl\"], \"urls\",\n\t\t);\n\n\t\tthis.baseUrl = options.baseUrl;\n\t\t// add each one\n\t\tObject.keys(options.urls).forEach(name => {\n\t\t\tthis._loadingCount++;\n\t\t\tconst url = options.urls[name];\n\t\t\tthis.add(name, url, this._bufferLoaded.bind(this, options.onload), options.onerror);\n\t\t});\n\n\t}\n\n\tstatic getDefaults(): ToneAudioBuffersOptions {\n\t\treturn {\n\t\t\tbaseUrl: \"\",\n\t\t\tonerror: noOp,\n\t\t\tonload: noOp,\n\t\t\turls: {},\n\t\t};\n\t}\n\n\t/**\n\t * True if the buffers object has a buffer by that name.\n\t * @param  name  The key or index of the buffer.\n\t */\n\thas(name: string | number): boolean {\n\t\treturn this._buffers.has(name.toString());\n\t}\n\n\t/**\n\t * Get a buffer by name. If an array was loaded,\n\t * then use the array index.\n\t * @param  name  The key or index of the buffer.\n\t */\n\tget(name: string | number): ToneAudioBuffer {\n\t\tassert(this.has(name), `ToneAudioBuffers has no buffer named: ${name}`);\n\t\treturn this._buffers.get(name.toString()) as ToneAudioBuffer;\n\t}\n\n\t/**\n\t * A buffer was loaded. decrement the counter.\n\t */\n\tprivate _bufferLoaded(callback: () => void): void {\n\t\tthis._loadingCount--;\n\t\tif (this._loadingCount === 0 && callback) {\n\t\t\tcallback();\n\t\t}\n\t}\n\n\t/**\n\t * If the buffers are loaded or not\n\t */\n\tget loaded(): boolean {\n\t\treturn Array.from(this._buffers).every(([_, buffer]) => buffer.loaded);\n\t}\n\n\t/**\n\t * Add a buffer by name and url to the Buffers\n\t * @param  name      A unique name to give the buffer\n\t * @param  url  Either the url of the bufer, or a buffer which will be added with the given name.\n\t * @param  callback  The callback to invoke when the url is loaded.\n\t * @param  onerror  Invoked if the buffer can't be loaded\n\t */\n\tadd(\n\t\tname: string | number,\n\t\turl: string | AudioBuffer | ToneAudioBuffer,\n\t\tcallback: () => void = noOp,\n\t\tonerror: (e: Error) => void = noOp,\n\t): this {\n\t\tif (isString(url)) {\n\t\t\t// don't include the baseUrl if the url is a base64 encoded sound\n\t\t\tif (this.baseUrl && url.trim().substring(0, 11).toLowerCase() === \"data:audio/\") {\n\t\t\t\tthis.baseUrl = \"\";\n\t\t\t}\n\t\t\tthis._buffers.set(name.toString(), new ToneAudioBuffer(this.baseUrl + url, callback, onerror));\n\t\t} else {\n\t\t\tthis._buffers.set(name.toString(), new ToneAudioBuffer(url, callback, onerror));\n\t\t}\n\t\treturn this;\n\t}\n\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis._buffers.forEach(buffer => buffer.dispose());\n\t\tthis._buffers.clear();\n\t\treturn this;\n\t}\n}\n","import { getContext } from \"../Global\";\nimport { ftom, mtof } from \"./Conversions\";\nimport { FrequencyClass, FrequencyUnit } from \"./Frequency\";\nimport { TimeValue } from \"./TimeBase\";\nimport { Hertz, Interval, MidiNote, Seconds, Ticks } from \"./Units\";\n\n/**\n * Midi is a primitive type for encoding Time values.\n * Midi can be constructed with or without the `new` keyword. Midi can be passed\n * into the parameter of any method which takes time as an argument.\n * @category Unit\n */\nexport class MidiClass extends FrequencyClass<MidiNote> {\n\n\treadonly name: string = \"MidiClass\";\n\n\treadonly defaultUnits = \"midi\";\n\n\t/**\n\t * Returns the value of a frequency in the current units\n\t */\n\tprotected _frequencyToUnits(freq: Hertz): MidiNote {\n\t\treturn ftom(super._frequencyToUnits(freq));\n\t}\n\n\t/**\n\t * Returns the value of a tick in the current time units\n\t */\n\tprotected _ticksToUnits(ticks: Ticks): MidiNote {\n\t\treturn ftom(super._ticksToUnits(ticks));\n\t}\n\n\t/**\n\t * Return the value of the beats in the current units\n\t */\n\tprotected _beatsToUnits(beats: number): MidiNote {\n\t\treturn ftom(super._beatsToUnits(beats));\n\t}\n\n\t/**\n\t * Returns the value of a second in the current units\n\t */\n\tprotected _secondsToUnits(seconds: Seconds): MidiNote {\n\t\treturn ftom(super._secondsToUnits(seconds));\n\t}\n\n\t/**\n\t * Return the value of the frequency as a MIDI note\n\t * @example\n\t * Tone.Midi(60).toMidi(); // 60\n\t */\n\ttoMidi(): MidiNote {\n\t\treturn this.valueOf();\n\t}\n\n\t/**\n\t * Return the value of the frequency as a MIDI note\n\t * @example\n\t * Tone.Midi(60).toFrequency(); // 261.6255653005986\n\t */\n\ttoFrequency(): Hertz {\n\t\treturn mtof(this.toMidi());\n\t}\n\n\t/**\n\t * Transposes the frequency by the given number of semitones.\n\t * @return A new transposed MidiClass\n\t * @example\n\t * Tone.Midi(\"A4\").transpose(3); // \"C5\"\n\t */\n\ttranspose(interval: Interval): MidiClass {\n\t\treturn new MidiClass(this.context, this.toMidi() + interval);\n\t}\n}\n\n/**\n * Convert a value into a FrequencyClass object.\n * @category Unit\n */\nexport function Midi(value?: TimeValue, units?: FrequencyUnit): MidiClass {\n\treturn new MidiClass(getContext(), value, units);\n}\n","import { getContext } from \"../Global\";\nimport { TimeBaseUnit, TimeValue } from \"./TimeBase\";\nimport { TransportTimeClass } from \"./TransportTime\";\nimport { Seconds, Ticks } from \"./Units\";\n\n/**\n * Ticks is a primitive type for encoding Time values.\n * Ticks can be constructed with or without the `new` keyword. Ticks can be passed\n * into the parameter of any method which takes time as an argument.\n * @example\n * const t = Tone.Ticks(\"4n\"); // a quarter note as ticks\n * @category Unit\n */\nexport class TicksClass extends TransportTimeClass<Ticks> {\n\n\treadonly name: string = \"Ticks\";\n\n\treadonly defaultUnits: TimeBaseUnit = \"i\";\n\n\t/**\n\t * Get the current time in the given units\n\t */\n\tprotected _now(): Ticks {\n\t\treturn this.context.transport.ticks;\n\t}\n\n\t/**\n\t * Return the value of the beats in the current units\n\t */\n\tprotected _beatsToUnits(beats: number): Ticks {\n\t\treturn this._getPPQ() * beats;\n\t}\n\n\t/**\n\t * Returns the value of a second in the current units\n\t */\n\tprotected _secondsToUnits(seconds: Seconds): Ticks {\n\t\treturn Math.floor(seconds / (60 / this._getBpm()) * this._getPPQ());\n\t}\n\n\t/**\n\t * Returns the value of a tick in the current time units\n\t */\n\tprotected _ticksToUnits(ticks: Ticks): Ticks {\n\t\treturn ticks;\n\t}\n\n\t/**\n\t * Return the time in ticks\n\t */\n\ttoTicks(): Ticks {\n\t\treturn this.valueOf() as Ticks;\n\t}\n\n\t/**\n\t * Return the time in seconds\n\t */\n\ttoSeconds(): Seconds {\n\t\treturn (this.valueOf() / this._getPPQ()) * (60 / this._getBpm());\n\t}\n}\n\n/**\n * Convert a time representation to ticks\n * @category Unit\n */\nexport function Ticks(value?: TimeValue, units?: TimeBaseUnit): TicksClass {\n\treturn new TicksClass(getContext(), value, units);\n}\n","import { ToneWithContext, ToneWithContextOptions } from \"../context/ToneWithContext\";\nimport { Seconds, Time } from \"../type/Units\";\nimport { Timeline, TimelineEvent } from \"./Timeline\";\nimport { onContextClose, onContextInit } from \"../context/ContextInitialization\";\n\ninterface DrawEvent extends TimelineEvent {\n\tcallback: () => void;\n}\n\n/**\n * Draw is useful for synchronizing visuals and audio events.\n * Callbacks from Tone.Transport or any of the Tone.Event classes\n * always happen _before_ the scheduled time and are not synchronized\n * to the animation frame so they are not good for triggering tightly\n * synchronized visuals and sound. Draw makes it easy to schedule\n * callbacks using the AudioContext time and uses requestAnimationFrame.\n * @example\n * Tone.Transport.schedule((time) => {\n * \t// use the time argument to schedule a callback with Draw\n * \tTone.Draw.schedule(() => {\n * \t\t// do drawing or DOM manipulation here\n * \t\tconsole.log(time);\n * \t}, time);\n * }, \"+0.5\");\n * Tone.Transport.start();\n * @category Core\n */\nexport class Draw extends ToneWithContext<ToneWithContextOptions> {\n\n\treadonly name: string = \"Draw\";\n\n\t/**\n\t * The duration after which events are not invoked.\n\t */\n\texpiration: Seconds = 0.25;\n\n\t/**\n\t * The amount of time before the scheduled time\n\t * that the callback can be invoked. Default is\n\t * half the time of an animation frame (0.008 seconds).\n\t */\n\tanticipation: Seconds = 0.008;\n\n\t/**\n\t * All of the events.\n\t */\n\tprivate _events: Timeline<DrawEvent> = new Timeline();\n\n\t/**\n\t * The draw loop\n\t */\n\tprivate _boundDrawLoop = this._drawLoop.bind(this);\n\n\t/**\n\t * The animation frame id\n\t */\n\tprivate _animationFrame = -1;\n\n\t/**\n\t * Schedule a function at the given time to be invoked\n\t * on the nearest animation frame.\n\t * @param  callback  Callback is invoked at the given time.\n\t * @param  time      The time relative to the AudioContext time to invoke the callback.\n\t * @example\n\t * Tone.Transport.scheduleRepeat(time => {\n\t * \tTone.Draw.schedule(() => console.log(time), time);\n\t * }, 1);\n\t * Tone.Transport.start();\n\t */\n\tschedule(callback: () => void, time: Time): this {\n\t\tthis._events.add({\n\t\t\tcallback,\n\t\t\ttime: this.toSeconds(time),\n\t\t});\n\t\t// start the draw loop on the first event\n\t\tif (this._events.length === 1) {\n\t\t\tthis._animationFrame = requestAnimationFrame(this._boundDrawLoop);\n\t\t}\n\t\treturn this;\n\t}\n\n\t/**\n\t * Cancel events scheduled after the given time\n\t * @param  after  Time after which scheduled events will be removed from the scheduling timeline.\n\t */\n\tcancel(after?: Time): this {\n\t\tthis._events.cancel(this.toSeconds(after));\n\t\treturn this;\n\t}\n\n\t/**\n\t * The draw loop\n\t */\n\tprivate _drawLoop(): void {\n\t\tconst now = this.context.currentTime;\n\t\twhile (this._events.length && (this._events.peek() as DrawEvent).time - this.anticipation <= now) {\n\t\t\tconst event = this._events.shift();\n\t\t\tif (event && now - event.time <= this.expiration) {\n\t\t\t\tevent.callback();\n\t\t\t}\n\t\t}\n\t\tif (this._events.length > 0) {\n\t\t\tthis._animationFrame = requestAnimationFrame(this._boundDrawLoop);\n\t\t}\n\t}\n\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis._events.dispose();\n\t\tcancelAnimationFrame(this._animationFrame);\n\t\treturn this;\n\t}\n}\n\n//-------------------------------------\n// \tINITIALIZATION\n//-------------------------------------\n\nonContextInit(context => {\n\tcontext.draw = new Draw({ context });\n});\n\nonContextClose(context => {\n\tcontext.draw.dispose();\n});\n","import { Tone } from \"../Tone\";\nimport { isDefined } from \"./TypeCheck\";\nimport { assert } from \"./Debug\";\n\n/**\n * An IntervalTimeline event must have a time and duration\n */\nexport interface IntervalTimelineEvent {\n\ttime: number;\n\tduration: number;\n\t[propName: string]: any;\n}\n\ntype IteratorCallback = (event: IntervalTimelineEvent) => void;\n\n/**\n * Similar to Tone.Timeline, but all events represent\n * intervals with both \"time\" and \"duration\" times. The\n * events are placed in a tree structure optimized\n * for querying an intersection point with the timeline\n * events. Internally uses an [Interval Tree](https://en.wikipedia.org/wiki/Interval_tree)\n * to represent the data.\n */\nexport class IntervalTimeline extends Tone {\n\n\treadonly name: string = \"IntervalTimeline\";\n\n\t/**\n\t * The root node of the inteval tree\n\t */\n\tprivate _root: IntervalNode | null = null;\n\n\t/**\n\t * Keep track of the length of the timeline.\n\t */\n\tprivate _length = 0;\n\n\t/**\n\t * The event to add to the timeline. All events must\n\t * have a time and duration value\n\t * @param  event  The event to add to the timeline\n\t */\n\tadd(event: IntervalTimelineEvent): this {\n\t\tassert(isDefined(event.time), \"Events must have a time property\");\n\t\tassert(isDefined(event.duration), \"Events must have a duration parameter\");\n\n\t\tevent.time = event.time.valueOf();\n\t\tlet node: IntervalNode | null = new IntervalNode(event.time, event.time + event.duration, event);\n\t\tif (this._root === null) {\n\t\t\tthis._root = node;\n\t\t} else {\n\t\t\tthis._root.insert(node);\n\t\t}\n\t\tthis._length++;\n\t\t// Restructure tree to be balanced\n\t\twhile (node !== null) {\n\t\t\tnode.updateHeight();\n\t\t\tnode.updateMax();\n\t\t\tthis._rebalance(node);\n\t\t\tnode = node.parent;\n\t\t}\n\t\treturn this;\n\t}\n\n\t/**\n\t * Remove an event from the timeline.\n\t * @param  event  The event to remove from the timeline\n\t */\n\tremove(event: IntervalTimelineEvent): this {\n\t\tif (this._root !== null) {\n\t\t\tconst results: IntervalNode[] = [];\n\t\t\tthis._root.search(event.time, results);\n\t\t\tfor (const node of results) {\n\t\t\t\tif (node.event === event) {\n\t\t\t\t\tthis._removeNode(node);\n\t\t\t\t\tthis._length--;\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\treturn this;\n\t}\n\n\t/**\n\t * The number of items in the timeline.\n\t * @readOnly\n\t */\n\tget length(): number {\n\t\treturn this._length;\n\t}\n\n\t/**\n\t * Remove events whose time time is after the given time\n\t * @param  after  The time to query.\n\t */\n\tcancel(after: number): this {\n\t\tthis.forEachFrom(after, event => this.remove(event));\n\t\treturn this;\n\t}\n\n\t/**\n\t * Set the root node as the given node\n\t */\n\tprivate _setRoot(node: IntervalNode | null): void {\n\t\tthis._root = node;\n\t\tif (this._root !== null) {\n\t\t\tthis._root.parent = null;\n\t\t}\n\t}\n\n\t/**\n\t * Replace the references to the node in the node's parent\n\t * with the replacement node.\n\t */\n\tprivate _replaceNodeInParent(node: IntervalNode, replacement: IntervalNode | null): void {\n\t\tif (node.parent !== null) {\n\t\t\tif (node.isLeftChild()) {\n\t\t\t\tnode.parent.left = replacement;\n\t\t\t} else {\n\t\t\t\tnode.parent.right = replacement;\n\t\t\t}\n\t\t\tthis._rebalance(node.parent);\n\t\t} else {\n\t\t\tthis._setRoot(replacement);\n\t\t}\n\t}\n\n\t/**\n\t * Remove the node from the tree and replace it with\n\t * a successor which follows the schema.\n\t */\n\tprivate _removeNode(node: IntervalNode): void {\n\t\tif (node.left === null && node.right === null) {\n\t\t\tthis._replaceNodeInParent(node, null);\n\t\t} else if (node.right === null) {\n\t\t\tthis._replaceNodeInParent(node, node.left);\n\t\t} else if (node.left === null) {\n\t\t\tthis._replaceNodeInParent(node, node.right);\n\t\t} else {\n\t\t\tconst balance = node.getBalance();\n\t\t\tlet replacement: IntervalNode;\n\t\t\tlet temp: IntervalNode | null = null;\n\t\t\tif (balance > 0) {\n\t\t\t\tif (node.left.right === null) {\n\t\t\t\t\treplacement = node.left;\n\t\t\t\t\treplacement.right = node.right;\n\t\t\t\t\ttemp = replacement;\n\t\t\t\t} else {\n\t\t\t\t\treplacement = node.left.right;\n\t\t\t\t\twhile (replacement.right !== null) {\n\t\t\t\t\t\treplacement = replacement.right;\n\t\t\t\t\t}\n\t\t\t\t\tif (replacement.parent) {\n\t\t\t\t\t\treplacement.parent.right = replacement.left;\n\t\t\t\t\t\ttemp = replacement.parent;\n\t\t\t\t\t\treplacement.left = node.left;\n\t\t\t\t\t\treplacement.right = node.right;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t} else if (node.right.left === null) {\n\t\t\t\treplacement = node.right;\n\t\t\t\treplacement.left = node.left;\n\t\t\t\ttemp = replacement;\n\t\t\t} else {\n\t\t\t\treplacement = node.right.left;\n\t\t\t\twhile (replacement.left !== null) {\n\t\t\t\t\treplacement = replacement.left;\n\t\t\t\t}\n\t\t\t\tif (replacement.parent) {\n\t\t\t\t\treplacement.parent.left = replacement.right;\n\t\t\t\t\ttemp = replacement.parent;\n\t\t\t\t\treplacement.left = node.left;\n\t\t\t\t\treplacement.right = node.right;\n\t\t\t\t}\n\t\t\t}\n\t\t\tif (node.parent !== null) {\n\t\t\t\tif (node.isLeftChild()) {\n\t\t\t\t\tnode.parent.left = replacement;\n\t\t\t\t} else {\n\t\t\t\t\tnode.parent.right = replacement;\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tthis._setRoot(replacement);\n\t\t\t}\n\t\t\tif (temp) {\n\t\t\t\tthis._rebalance(temp);\n\t\t\t}\n\t\t}\n\t\tnode.dispose();\n\t}\n\n\t/**\n\t * Rotate the tree to the left\n\t */\n\tprivate _rotateLeft(node: IntervalNode): void {\n\t\tconst parent = node.parent;\n\t\tconst isLeftChild = node.isLeftChild();\n\n\t\t// Make node.right the new root of this sub tree (instead of node)\n\t\tconst pivotNode = node.right;\n\t\tif (pivotNode) {\n\t\t\tnode.right = pivotNode.left;\n\t\t\tpivotNode.left = node;\n\t\t}\n\n\t\tif (parent !== null) {\n\t\t\tif (isLeftChild) {\n\t\t\t\tparent.left = pivotNode;\n\t\t\t} else {\n\t\t\t\tparent.right = pivotNode;\n\t\t\t}\n\t\t} else {\n\t\t\tthis._setRoot(pivotNode);\n\t\t}\n\t}\n\n\t/**\n\t * Rotate the tree to the right\n\t */\n\tprivate _rotateRight(node: IntervalNode): void {\n\t\tconst parent = node.parent;\n\t\tconst isLeftChild = node.isLeftChild();\n\n\t\t// Make node.left the new root of this sub tree (instead of node)\n\t\tconst pivotNode = node.left;\n\t\tif (pivotNode) {\n\t\t\tnode.left = pivotNode.right;\n\t\t\tpivotNode.right = node;\n\t\t}\n\n\t\tif (parent !== null) {\n\t\t\tif (isLeftChild) {\n\t\t\t\tparent.left = pivotNode;\n\t\t\t} else {\n\t\t\t\tparent.right = pivotNode;\n\t\t\t}\n\t\t} else {\n\t\t\tthis._setRoot(pivotNode);\n\t\t}\n\t}\n\n\t/**\n\t * Balance the BST\n\t */\n\tprivate _rebalance(node: IntervalNode): void {\n\t\tconst balance = node.getBalance();\n\t\tif (balance > 1 && node.left) {\n\t\t\tif (node.left.getBalance() < 0) {\n\t\t\t\tthis._rotateLeft(node.left);\n\t\t\t} else {\n\t\t\t\tthis._rotateRight(node);\n\t\t\t}\n\t\t} else if (balance < -1 && node.right) {\n\t\t\tif (node.right.getBalance() > 0) {\n\t\t\t\tthis._rotateRight(node.right);\n\t\t\t} else {\n\t\t\t\tthis._rotateLeft(node);\n\t\t\t}\n\t\t}\n\t}\n\n\t/**\n\t * Get an event whose time and duration span the give time. Will\n\t * return the match whose \"time\" value is closest to the given time.\n\t * @return  The event which spans the desired time\n\t */\n\tget(time: number): IntervalTimelineEvent | null {\n\t\tif (this._root !== null) {\n\t\t\tconst results: IntervalNode[] = [];\n\t\t\tthis._root.search(time, results);\n\t\t\tif (results.length > 0) {\n\t\t\t\tlet max = results[0];\n\t\t\t\tfor (let i = 1; i < results.length; i++) {\n\t\t\t\t\tif (results[i].low > max.low) {\n\t\t\t\t\t\tmax = results[i];\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\treturn max.event;\n\t\t\t}\n\t\t}\n\t\treturn null;\n\t}\n\n\t/**\n\t * Iterate over everything in the timeline.\n\t * @param  callback The callback to invoke with every item\n\t */\n\tforEach(callback: IteratorCallback): this {\n\t\tif (this._root !== null) {\n\t\t\tconst allNodes: IntervalNode[] = [];\n\t\t\tthis._root.traverse(node => allNodes.push(node));\n\t\t\tallNodes.forEach(node => {\n\t\t\t\tif (node.event) {\n\t\t\t\t\tcallback(node.event);\n\t\t\t\t}\n\t\t\t});\n\t\t}\n\t\treturn this;\n\t}\n\n\t/**\n\t * Iterate over everything in the array in which the given time\n\t * overlaps with the time and duration time of the event.\n\t * @param  time The time to check if items are overlapping\n\t * @param  callback The callback to invoke with every item\n\t */\n\tforEachAtTime(time: number, callback: IteratorCallback): this {\n\t\tif (this._root !== null) {\n\t\t\tconst results: IntervalNode[] = [];\n\t\t\tthis._root.search(time, results);\n\t\t\tresults.forEach(node => {\n\t\t\t\tif (node.event) {\n\t\t\t\t\tcallback(node.event);\n\t\t\t\t}\n\t\t\t});\n\t\t}\n\t\treturn this;\n\t}\n\n\t/**\n\t * Iterate over everything in the array in which the time is greater\n\t * than or equal to the given time.\n\t * @param  time The time to check if items are before\n\t * @param  callback The callback to invoke with every item\n\t */\n\tforEachFrom(time: number, callback: IteratorCallback): this {\n\t\tif (this._root !== null) {\n\t\t\tconst results: IntervalNode[] = [];\n\t\t\tthis._root.searchAfter(time, results);\n\t\t\tresults.forEach(node => {\n\t\t\t\tif (node.event) {\n\t\t\t\t\tcallback(node.event);\n\t\t\t\t}\n\t\t\t});\n\t\t}\n\t\treturn this;\n\t}\n\n\t/**\n\t * Clean up\n\t */\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tif (this._root !== null) {\n\t\t\tthis._root.traverse(node => node.dispose());\n\t\t}\n\t\tthis._root = null;\n\t\treturn this;\n\t}\n}\n\n//-------------------------------------\n// \tINTERVAL NODE HELPER\n//-------------------------------------\n\n/**\n * Represents a node in the binary search tree, with the addition\n * of a \"high\" value which keeps track of the highest value of\n * its children.\n * References:\n * https://brooknovak.wordpress.com/2013/12/07/augmented-interval-tree-in-c/\n * http://www.mif.vu.lt/~valdas/ALGORITMAI/LITERATURA/Cormen/Cormen.pdf\n * @param low\n * @param high\n */\nclass IntervalNode {\n\n\t// the event container\n\tevent: IntervalTimelineEvent | null;\n\t// the low value\n\tlow: number;\n\t// the high value\n\thigh: number;\n\t// the high value for this and all child nodes\n\tmax: number;\n\t// the nodes to the left\n\tprivate _left: IntervalNode | null = null;\n\t// the nodes to the right\n\tprivate _right: IntervalNode | null = null;\n\t// the parent node\n\tparent: IntervalNode | null = null;\n\t// the number of child nodes\n\theight = 0;\n\n\tconstructor(low: number, high: number, event: IntervalTimelineEvent) {\n\t\tthis.event = event;\n\t\t// the low value\n\t\tthis.low = low;\n\t\t// the high value\n\t\tthis.high = high;\n\t\t// the high value for this and all child nodes\n\t\tthis.max = this.high;\n\t}\n\n\t/**\n\t * Insert a node into the correct spot in the tree\n\t */\n\tinsert(node: IntervalNode): void {\n\t\tif (node.low <= this.low) {\n\t\t\tif (this.left === null) {\n\t\t\t\tthis.left = node;\n\t\t\t} else {\n\t\t\t\tthis.left.insert(node);\n\t\t\t}\n\t\t} else if (this.right === null) {\n\t\t\tthis.right = node;\n\t\t} else {\n\t\t\tthis.right.insert(node);\n\t\t}\n\t}\n\n\t/**\n\t * Search the tree for nodes which overlap\n\t * with the given point\n\t * @param  point  The point to query\n\t * @param  results  The array to put the results\n\t */\n\tsearch(point: number, results: IntervalNode[]): void {\n\t\t// If p is to the right of the rightmost point of any interval\n\t\t// in this node and all children, there won't be any matches.\n\t\tif (point > this.max) {\n\t\t\treturn;\n\t\t}\n\t\t// Search left children\n\t\tif (this.left !== null) {\n\t\t\tthis.left.search(point, results);\n\t\t}\n\t\t// Check this node\n\t\tif (this.low <= point && this.high > point) {\n\t\t\tresults.push(this);\n\t\t}\n\t\t// If p is to the left of the time of this interval,\n\t\t// then it can't be in any child to the right.\n\t\tif (this.low > point) {\n\t\t\treturn;\n\t\t}\n\t\t// Search right children\n\t\tif (this.right !== null) {\n\t\t\tthis.right.search(point, results);\n\t\t}\n\t}\n\n\t/**\n\t * Search the tree for nodes which are less\n\t * than the given point\n\t * @param  point  The point to query\n\t * @param  results  The array to put the results\n\t */\n\tsearchAfter(point: number, results: IntervalNode[]): void {\n\t\t// Check this node\n\t\tif (this.low >= point) {\n\t\t\tresults.push(this);\n\t\t\tif (this.left !== null) {\n\t\t\t\tthis.left.searchAfter(point, results);\n\t\t\t}\n\t\t}\n\t\t// search the right side\n\t\tif (this.right !== null) {\n\t\t\tthis.right.searchAfter(point, results);\n\t\t}\n\t}\n\n\t/**\n\t * Invoke the callback on this element and both it's branches\n\t * @param  {Function}  callback\n\t */\n\ttraverse(callback: (self: IntervalNode) => void): void {\n\t\tcallback(this);\n\t\tif (this.left !== null) {\n\t\t\tthis.left.traverse(callback);\n\t\t}\n\t\tif (this.right !== null) {\n\t\t\tthis.right.traverse(callback);\n\t\t}\n\t}\n\n\t/**\n\t * Update the height of the node\n\t */\n\tupdateHeight(): void {\n\t\tif (this.left !== null && this.right !== null) {\n\t\t\tthis.height = Math.max(this.left.height, this.right.height) + 1;\n\t\t} else if (this.right !== null) {\n\t\t\tthis.height = this.right.height + 1;\n\t\t} else if (this.left !== null) {\n\t\t\tthis.height = this.left.height + 1;\n\t\t} else {\n\t\t\tthis.height = 0;\n\t\t}\n\t}\n\n\t/**\n\t * Update the height of the node\n\t */\n\tupdateMax(): void {\n\t\tthis.max = this.high;\n\t\tif (this.left !== null) {\n\t\t\tthis.max = Math.max(this.max, this.left.max);\n\t\t}\n\t\tif (this.right !== null) {\n\t\t\tthis.max = Math.max(this.max, this.right.max);\n\t\t}\n\t}\n\n\t/**\n\t * The balance is how the leafs are distributed on the node\n\t * @return  Negative numbers are balanced to the right\n\t */\n\tgetBalance(): number {\n\t\tlet balance = 0;\n\t\tif (this.left !== null && this.right !== null) {\n\t\t\tbalance = this.left.height - this.right.height;\n\t\t} else if (this.left !== null) {\n\t\t\tbalance = this.left.height + 1;\n\t\t} else if (this.right !== null) {\n\t\t\tbalance = -(this.right.height + 1);\n\t\t}\n\t\treturn balance;\n\t}\n\n\t/**\n\t * @returns true if this node is the left child of its parent\n\t */\n\tisLeftChild(): boolean {\n\t\treturn this.parent !== null && this.parent.left === this;\n\t}\n\n\t/**\n\t * get/set the left node\n\t */\n\tget left(): IntervalNode | null {\n\t\treturn this._left;\n\t}\n\n\tset left(node: IntervalNode | null) {\n\t\tthis._left = node;\n\t\tif (node !== null) {\n\t\t\tnode.parent = this;\n\t\t}\n\t\tthis.updateHeight();\n\t\tthis.updateMax();\n\t}\n\n\t/**\n\t * get/set the right node\n\t */\n\tget right(): IntervalNode | null {\n\t\treturn this._right;\n\t}\n\n\tset right(node: IntervalNode | null) {\n\t\tthis._right = node;\n\t\tif (node !== null) {\n\t\t\tnode.parent = this;\n\t\t}\n\t\tthis.updateHeight();\n\t\tthis.updateMax();\n\t}\n\n\t/**\n\t * null out references.\n\t */\n\tdispose(): void {\n\t\tthis.parent = null;\n\t\tthis._left = null;\n\t\tthis._right = null;\n\t\tthis.event = null;\n\t}\n}\n","import { Gain } from \"../../core/context/Gain\";\nimport { Param } from \"../../core/context/Param\";\nimport { ToneAudioNode, ToneAudioNodeOptions } from \"../../core/context/ToneAudioNode\";\nimport { Decibels } from \"../../core/type/Units\";\nimport { optionsFromArguments } from \"../../core/util/Defaults\";\nimport { readOnly } from \"../../core/util/Interface\";\n\ninterface VolumeOptions extends ToneAudioNodeOptions {\n\tvolume: Decibels;\n\tmute: boolean;\n}\n\n/**\n * Volume is a simple volume node, useful for creating a volume fader.\n *\n * @example\n * const vol = new Tone.Volume(-12).toDestination();\n * const osc = new Tone.Oscillator().connect(vol).start();\n * @category Component\n */\nexport class Volume extends ToneAudioNode<VolumeOptions> {\n\n\treadonly name: string = \"Volume\";\n\n\t/**\n\t * the output node\n\t */\n\toutput: Gain<\"decibels\">;\n\n\t/**\n\t * Input and output are the same\n\t */\n\tinput: Gain<\"decibels\">;\n\n\t/**\n\t * The unmuted volume\n\t */\n\tprivate _unmutedVolume: Decibels;\n\n\t/**\n\t * The volume control in decibels.\n\t * @example\n\t * const vol = new Tone.Volume().toDestination();\n\t * const osc = new Tone.Oscillator().connect(vol).start();\n\t * vol.volume.value = -20;\n\t */\n\tvolume: Param<\"decibels\">;\n\n\t/**\n\t * @param volume the initial volume in decibels\n\t */\n\tconstructor(volume?: Decibels);\n\tconstructor(options?: Partial<VolumeOptions>);\n\tconstructor() {\n\n\t\tsuper(optionsFromArguments(Volume.getDefaults(), arguments, [\"volume\"]));\n\t\tconst options = optionsFromArguments(Volume.getDefaults(), arguments, [\"volume\"]);\n\n\t\tthis.input = this.output = new Gain({\n\t\t\tcontext: this.context,\n\t\t\tgain: options.volume,\n\t\t\tunits: \"decibels\",\n\t\t});\n\t\tthis.volume = this.output.gain;\n\t\treadOnly(this, \"volume\");\n\t\tthis._unmutedVolume = options.volume;\n\n\t\t// set the mute initially\n\t\tthis.mute = options.mute;\n\t}\n\n\tstatic getDefaults(): VolumeOptions {\n\t\treturn Object.assign(ToneAudioNode.getDefaults(), {\n\t\t\tmute: false,\n\t\t\tvolume: 0,\n\t\t});\n\t}\n\n\t/**\n\t * Mute the output.\n\t * @example\n\t * const vol = new Tone.Volume(-12).toDestination();\n\t * const osc = new Tone.Oscillator().connect(vol).start();\n\t * // mute the output\n\t * vol.mute = true;\n\t */\n\tget mute(): boolean {\n\t\treturn this.volume.value === -Infinity;\n\t}\n\tset mute(mute: boolean) {\n\t\tif (!this.mute && mute) {\n\t\t\tthis._unmutedVolume = this.volume.value;\n\t\t\t// maybe it should ramp here?\n\t\t\tthis.volume.value = -Infinity;\n\t\t} else if (this.mute && !mute) {\n\t\t\tthis.volume.value = this._unmutedVolume;\n\t\t}\n\t}\n\n\t/**\n\t * clean up\n\t */\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis.input.dispose();\n\t\tthis.volume.dispose();\n\t\treturn this;\n\t}\n}\n","import { Volume } from \"../../component/channel/Volume\";\nimport { Decibels } from \"../type/Units\";\nimport { optionsFromArguments } from \"../util/Defaults\";\nimport { onContextClose, onContextInit } from \"./ContextInitialization\";\nimport { Gain } from \"./Gain\";\nimport { Param } from \"./Param\";\nimport { connectSeries, ToneAudioNode, ToneAudioNodeOptions } from \"./ToneAudioNode\";\n\ninterface DestinationOptions extends ToneAudioNodeOptions {\n\tvolume: Decibels;\n\tmute: boolean;\n}\n\n/**\n * A single master output which is connected to the\n * AudioDestinationNode (aka your speakers).\n * It provides useful conveniences such as the ability\n * to set the volume and mute the entire application.\n * It also gives you the ability to apply master effects to your application.\n *\n * @example\n * const oscillator = new Tone.Oscillator().start();\n * // the audio will go from the oscillator to the speakers\n * oscillator.connect(Tone.getDestination());\n * // a convenience for connecting to the master output is also provided:\n * oscillator.toDestination();\n * @category Core\n */\nexport class Destination extends ToneAudioNode<DestinationOptions> {\n\n\treadonly name: string = \"Destination\";\n\n\tinput: Volume = new Volume({ context: this.context });\n\toutput: Gain = new Gain({ context: this.context });\n\n\t/**\n\t * The volume of the master output in decibels. -Infinity is silent, and 0 is no change. \n\t * @example\n\t * const osc = new Tone.Oscillator().toDestination();\n\t * osc.start();\n\t * // ramp the volume down to silent over 10 seconds\n\t * Tone.getDestination().volume.rampTo(-Infinity, 10);\n\t */\n\tvolume: Param<\"decibels\"> = this.input.volume;\n\n\tconstructor(options: Partial<DestinationOptions>);\n\tconstructor() {\n\n\t\tsuper(optionsFromArguments(Destination.getDefaults(), arguments));\n\t\tconst options = optionsFromArguments(Destination.getDefaults(), arguments);\n\n\t\tconnectSeries(this.input, this.output, this.context.rawContext.destination);\n\n\t\tthis.mute = options.mute;\n\t\tthis._internalChannels = [this.input, this.context.rawContext.destination, this.output];\n\t}\n\n\tstatic getDefaults(): DestinationOptions {\n\t\treturn Object.assign(ToneAudioNode.getDefaults(), {\n\t\t\tmute: false,\n\t\t\tvolume: 0,\n\t\t});\n\t}\n\n\t/**\n\t * Mute the output.\n\t * @example\n\t * const oscillator = new Tone.Oscillator().start().toDestination();\n\t * setTimeout(() => {\n\t * \t// mute the output\n\t * \tTone.Destination.mute = true;\n\t * }, 1000);\n\t */\n\tget mute(): boolean {\n\t\treturn this.input.mute;\n\t}\n\tset mute(mute: boolean) {\n\t\tthis.input.mute = mute;\n\t}\n\n\t/**\n\t * Add a master effects chain. NOTE: this will disconnect any nodes which were previously\n\t * chained in the master effects chain.\n\t * @param args All arguments will be connected in a row and the Master will be routed through it.\n\t * @example\n\t * // route all audio through a filter and compressor\n\t * const lowpass = new Tone.Filter(800, \"lowpass\");\n\t * const compressor = new Tone.Compressor(-18);\n\t * Tone.Destination.chain(lowpass, compressor);\n\t */\n\tchain(...args: Array<AudioNode | ToneAudioNode>): this {\n\t\tthis.input.disconnect();\n\t\targs.unshift(this.input);\n\t\targs.push(this.output);\n\t\tconnectSeries(...args);\n\t\treturn this;\n\t}\n\n\t/**\n\t * The maximum number of channels the system can output\n\t * @example\n\t * console.log(Tone.Destination.maxChannelCount);\n\t */\n\tget maxChannelCount(): number {\n\t\treturn this.context.rawContext.destination.maxChannelCount;\n\t}\n\n\t/**\n\t * Clean up\n\t */\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis.volume.dispose();\n\t\treturn this;\n\t}\n}\n\n//-------------------------------------\n// \tINITIALIZATION\n//-------------------------------------\n\nonContextInit(context => {\n\tcontext.destination = new Destination({ context });\n});\n\nonContextClose(context => {\n\tcontext.destination.dispose();\n});\n","import { Timeline, TimelineEvent } from \"./Timeline\";\nimport { Tone } from \"../Tone\";\nimport { Seconds } from \"../type/Units\";\n\ninterface TimelineValueEvent<T> extends TimelineEvent {\n\tvalue: T;\n}\n\n/**\n * Represents a single value which is gettable and settable in a timed way\n */\nexport class TimelineValue<Type> extends Tone {\n\n\treadonly name: string = \"TimelineValue\";\n\n\t/**\n\t * The timeline which stores the values\n\t */\n\tprivate _timeline: Timeline<TimelineValueEvent<Type>> = new Timeline({ memory: 10 })\n\n\t/**\n\t * Hold the value to return if there is no scheduled values\n\t */\n\tprivate _initialValue: Type;\n\n\t/**\n\t * @param initialValue The value to return if there is no scheduled values\n\t */\n\tconstructor(initialValue: Type) {\n\n\t\tsuper();\n\t\tthis._initialValue = initialValue;\n\t}\n\n\t/**\n\t * Set the value at the given time\n\t */\n\tset(value: Type, time: Seconds): this {\n\t\tthis._timeline.add({\n\t\t\tvalue, time\n\t\t});\n\t\treturn this;\n\t}\n\t\n\t/**\n\t * Get the value at the given time\n\t */\n\tget(time: Seconds): Type {\n\t\tconst event = this._timeline.get(time);\n\t\tif (event) {\n\t\t\treturn event.value;\n\t\t} else {\n\t\t\treturn this._initialValue;\n\t\t}\n\t}\n}\n","import { Seconds, Ticks } from \"../type/Units\";\nimport { noOp } from \"../util/Interface\";\n\ntype Transport = import(\"../clock/Transport\").Transport;\n\nexport interface TransportEventOptions {\n\tcallback: (time: number) => void;\n\tonce: boolean;\n\ttime: Ticks;\n}\n\n/**\n * TransportEvent is an internal class used by [[Transport]]\n * to schedule events. Do no invoke this class directly, it is\n * handled from within Tone.Transport.\n */\nexport class TransportEvent {\n\n\t/**\n\t * Reference to the Transport that created it\n\t */\n\tprotected transport: Transport;\n\n\t/**\n\t * The unique id of the event\n\t */\n\tid: number = TransportEvent._eventId++;\n\n\t/**\n\t * The time the event starts\n\t */\n\ttime: Ticks;\n\n\t/**\n\t * The callback to invoke\n\t */\n\tprivate callback?: (time: Seconds) => void;\n\n\t/**\n\t * If the event should be removed after being invoked.\n\t */\n\tprivate _once: boolean;\n\n\t/**\n\t * The remaining value between the passed in time, and Math.floor(time).\n\t * This value is later added back when scheduling to get sub-tick precision. \n\t */\n\tprotected _remainderTime = 0;\n\n\t/**\n\t * @param transport The transport object which the event belongs to\n\t */\n\tconstructor(transport: Transport, opts: Partial<TransportEventOptions>) {\n\n\t\tconst options: TransportEventOptions = Object.assign(TransportEvent.getDefaults(), opts);\n\n\t\tthis.transport = transport;\n\t\tthis.callback = options.callback;\n\t\tthis._once = options.once;\n\t\tthis.time = Math.floor(options.time);\n\t\tthis._remainderTime = options.time - this.time;\n\t}\n\n\tstatic getDefaults(): TransportEventOptions {\n\t\treturn {\n\t\t\tcallback: noOp,\n\t\t\tonce: false,\n\t\t\ttime: 0,\n\t\t};\n\t}\n\n\t/**\n\t * Current ID counter\n\t */\n\tprivate static _eventId = 0;\n\n\t/**\n\t * Get the time and remainder time.\n\t */\n\tprotected get floatTime(): number {\n\t\treturn this.time + this._remainderTime;\n\t}\n\n\t/**\n\t * Invoke the event callback.\n\t * @param  time  The AudioContext time in seconds of the event\n\t */\n\tinvoke(time: Seconds): void {\n\t\tif (this.callback) {\n\t\t\tconst tickDuration = this.transport.bpm.getDurationOfTicks(1, time);\n\t\t\tthis.callback(time + this._remainderTime * tickDuration);\n\t\t\tif (this._once) {\n\t\t\t\tthis.transport.clear(this.id);\n\t\t\t}\n\t\t}\n\t}\n\n\t/**\n\t * Clean up\n\t */\n\tdispose(): this {\n\t\tthis.callback = undefined;\n\t\treturn this;\n\t}\n}\n","import { BaseContext } from \"../context/BaseContext\";\nimport { TicksClass } from \"../type/Ticks\";\nimport { Seconds, Ticks, Time } from \"../type/Units\";\nimport { TransportEvent, TransportEventOptions } from \"./TransportEvent\";\nimport { GT, LT } from \"../util/Math\";\n\ntype Transport = import(\"../clock/Transport\").Transport;\n\ninterface TransportRepeatEventOptions extends TransportEventOptions {\n\tinterval: Ticks;\n\tduration: Ticks;\n}\n\n/**\n * TransportRepeatEvent is an internal class used by Tone.Transport\n * to schedule repeat events. This class should not be instantiated directly.\n */\nexport class TransportRepeatEvent extends TransportEvent {\n\n\t/**\n\t * When the event should stop repeating\n\t */\n\tprivate duration: Ticks;\n\n\t/**\n\t * The interval of the repeated event\n\t */\n\tprivate _interval: Ticks;\n\n\t/**\n\t * The ID of the current timeline event\n\t */\n\tprivate _currentId = -1;\n\n\t/**\n\t * The ID of the next timeline event\n\t */\n\tprivate _nextId = -1;\n\n\t/**\n\t * The time of the next event\n\t */\n\tprivate _nextTick = this.time;\n\n\t/**\n\t * a reference to the bound start method\n\t */\n\tprivate _boundRestart = this._restart.bind(this);\n\n\t/**\n\t * The audio context belonging to this event\n\t */\n\tprotected context: BaseContext;\n\n\t/**\n\t * @param transport The transport object which the event belongs to\n\t */\n\tconstructor(transport: Transport, opts: Partial<TransportRepeatEventOptions>) {\n\n\t\tsuper(transport, opts);\n\n\t\tconst options = Object.assign(TransportRepeatEvent.getDefaults(), opts);\n\n\t\tthis.duration = options.duration;\n\t\tthis._interval = options.interval;\n\t\tthis._nextTick = options.time;\n\t\tthis.transport.on(\"start\", this._boundRestart);\n\t\tthis.transport.on(\"loopStart\", this._boundRestart);\n\t\tthis.transport.on(\"ticks\", this._boundRestart);\n\t\tthis.context = this.transport.context;\n\t\tthis._restart();\n\t}\n\n\tstatic getDefaults(): TransportRepeatEventOptions {\n\t\treturn Object.assign({}, TransportEvent.getDefaults(), {\n\t\t\tduration: Infinity,\n\t\t\tinterval: 1,\n\t\t\tonce: false,\n\t\t});\n\t}\n\n\t/**\n\t * Invoke the callback. Returns the tick time which\n\t * the next event should be scheduled at.\n\t * @param  time  The AudioContext time in seconds of the event\n\t */\n\tinvoke(time: Seconds): void {\n\t\t// create more events if necessary\n\t\tthis._createEvents(time);\n\t\t// call the super class\n\t\tsuper.invoke(time);\n\t}\n\n\t/**\n\t * Create an event on the transport on the nextTick\n\t */\n\tprivate _createEvent(): number {\n\t\tif (LT(this._nextTick, this.floatTime + this.duration)) {\n\t\t\treturn this.transport.scheduleOnce(this.invoke.bind(this),\n\t\t\t\tnew TicksClass(this.context, this._nextTick).toSeconds());\n\t\t}\n\t\treturn -1;\n\t}\n\n\t/**\n\t * Push more events onto the timeline to keep up with the position of the timeline\n\t */\n\tprivate _createEvents(time: Seconds): void {\n\t\t// schedule the next event\n\t\t// const ticks = this.transport.getTicksAtTime(time);\n\t\t// if the next tick is within the bounds set by \"duration\"\n\t\tif (LT(this._nextTick + this._interval, this.floatTime + this.duration)) {\n\t\t\tthis._nextTick += this._interval;\n\t\t\tthis._currentId = this._nextId;\n\t\t\tthis._nextId = this.transport.scheduleOnce(this.invoke.bind(this),\n\t\t\t\tnew TicksClass(this.context, this._nextTick).toSeconds());\n\t\t}\n\t}\n\n\t/**\n\t * Re-compute the events when the transport time has changed from a start/ticks/loopStart event\n\t */\n\tprivate _restart(time?: Time): void {\n\t\tthis.transport.clear(this._currentId);\n\t\tthis.transport.clear(this._nextId);\n\t\t// start at the first event\n\t\tthis._nextTick = this.floatTime;\n\t\tconst ticks = this.transport.getTicksAtTime(time);\n\t\tif (GT(ticks, this.time)) {\n\t\t\t// the event is not being scheduled from the beginning and should be offset\n\t\t\tthis._nextTick = this.floatTime + Math.ceil((ticks - this.floatTime) / this._interval) * this._interval;\n\t\t}\n\t\tthis._currentId = this._createEvent();\n\t\tthis._nextTick += this._interval;\n\t\tthis._nextId = this._createEvent();\n\t}\n\n\t/**\n\t * Clean up\n\t */\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis.transport.clear(this._currentId);\n\t\tthis.transport.clear(this._nextId);\n\t\tthis.transport.off(\"start\", this._boundRestart);\n\t\tthis.transport.off(\"loopStart\", this._boundRestart);\n\t\tthis.transport.off(\"ticks\", this._boundRestart);\n\t\treturn this;\n\t}\n}\n","import { TimeClass } from \"../../core/type/Time\";\nimport { PlaybackState } from \"../../core/util/StateTimeline\";\nimport { TimelineValue } from \"../../core/util/TimelineValue\";\nimport { Signal } from \"../../signal/Signal\";\nimport {\n\tonContextClose,\n\tonContextInit,\n} from \"../context/ContextInitialization\";\nimport { Gain } from \"../context/Gain\";\nimport {\n\tToneWithContext,\n\tToneWithContextOptions,\n} from \"../context/ToneWithContext\";\nimport { TicksClass } from \"../type/Ticks\";\nimport { TransportTimeClass } from \"../type/TransportTime\";\nimport {\n\tBarsBeatsSixteenths,\n\tBPM,\n\tNormalRange,\n\tSeconds,\n\tSubdivision,\n\tTicks,\n\tTime,\n\tTimeSignature,\n\tTransportTime,\n} from \"../type/Units\";\nimport { enterScheduledCallback } from \"../util/Debug\";\nimport { optionsFromArguments } from \"../util/Defaults\";\nimport { Emitter } from \"../util/Emitter\";\nimport { readOnly, writable } from \"../util/Interface\";\nimport { IntervalTimeline } from \"../util/IntervalTimeline\";\nimport { Timeline } from \"../util/Timeline\";\nimport { isArray, isDefined } from \"../util/TypeCheck\";\nimport { Clock } from \"./Clock\";\nimport { TickParam } from \"./TickParam\";\nimport { TransportEvent } from \"./TransportEvent\";\nimport { TransportRepeatEvent } from \"./TransportRepeatEvent\";\n\ninterface TransportOptions extends ToneWithContextOptions {\n\tbpm: BPM;\n\tswing: NormalRange;\n\tswingSubdivision: Subdivision;\n\ttimeSignature: number;\n\tloopStart: Time;\n\tloopEnd: Time;\n\tppq: number;\n}\n\ntype TransportEventNames =\n\t| \"start\"\n\t| \"stop\"\n\t| \"pause\"\n\t| \"loop\"\n\t| \"loopEnd\"\n\t| \"loopStart\"\n\t| \"ticks\";\n\ninterface SyncedSignalEvent {\n\tsignal: Signal;\n\tinitial: number;\n\tratio: Gain;\n}\n\ntype TransportCallback = (time: Seconds) => void;\n\n/**\n * Transport for timing musical events.\n * Supports tempo curves and time changes. Unlike browser-based timing (setInterval, requestAnimationFrame)\n * Transport timing events pass in the exact time of the scheduled event\n * in the argument of the callback function. Pass that time value to the object\n * you're scheduling. <br><br>\n * A single transport is created for you when the library is initialized.\n * <br><br>\n * The transport emits the events: \"start\", \"stop\", \"pause\", and \"loop\" which are\n * called with the time of that event as the argument.\n *\n * @example\n * const osc = new Tone.Oscillator().toDestination();\n * // repeated event every 8th note\n * Tone.Transport.scheduleRepeat((time) => {\n * \t// use the callback time to schedule events\n * \tosc.start(time).stop(time + 0.1);\n * }, \"8n\");\n * // transport must be started before it starts invoking events\n * Tone.Transport.start();\n * @category Core\n */\nexport class Transport\n\textends ToneWithContext<TransportOptions>\n\timplements Emitter<TransportEventNames> {\n\treadonly name: string = \"Transport\";\n\n\t//-------------------------------------\n\t// \tLOOPING\n\t//-------------------------------------\n\n\t/**\n\t * If the transport loops or not.\n\t */\n\tprivate _loop: TimelineValue<boolean> = new TimelineValue(false);\n\n\t/**\n\t * The loop start position in ticks\n\t */\n\tprivate _loopStart: Ticks = 0;\n\n\t/**\n\t * The loop end position in ticks\n\t */\n\tprivate _loopEnd: Ticks = 0;\n\n\t//-------------------------------------\n\t// \tCLOCK/TEMPO\n\t//-------------------------------------\n\n\t/**\n\t * Pulses per quarter is the number of ticks per quarter note.\n\t */\n\tprivate _ppq: number;\n\n\t/**\n\t * watches the main oscillator for timing ticks\n\t * initially starts at 120bpm\n\t */\n\tprivate _clock: Clock<\"bpm\">;\n\n\t/**\n\t * The Beats Per Minute of the Transport.\n\t * @example\n\t * const osc = new Tone.Oscillator().toDestination();\n\t * Tone.Transport.bpm.value = 80;\n\t * // start/stop the oscillator every quarter note\n\t * Tone.Transport.scheduleRepeat(time => {\n\t * \tosc.start(time).stop(time + 0.1);\n\t * }, \"4n\");\n\t * Tone.Transport.start();\n\t * // ramp the bpm to 120 over 10 seconds\n\t * Tone.Transport.bpm.rampTo(120, 10);\n\t */\n\tbpm: TickParam<\"bpm\">;\n\n\t/**\n\t * The time signature, or more accurately the numerator\n\t * of the time signature over a denominator of 4.\n\t */\n\tprivate _timeSignature: number;\n\n\t//-------------------------------------\n\t// \tTIMELINE EVENTS\n\t//-------------------------------------\n\n\t/**\n\t * All the events in an object to keep track by ID\n\t */\n\tprivate _scheduledEvents = {};\n\n\t/**\n\t * The scheduled events.\n\t */\n\tprivate _timeline: Timeline<TransportEvent> = new Timeline();\n\n\t/**\n\t * Repeated events\n\t */\n\tprivate _repeatedEvents: IntervalTimeline = new IntervalTimeline();\n\n\t/**\n\t * All of the synced Signals\n\t */\n\tprivate _syncedSignals: SyncedSignalEvent[] = [];\n\n\t//-------------------------------------\n\t// \tSWING\n\t//-------------------------------------\n\n\t/**\n\t * The subdivision of the swing\n\t */\n\tprivate _swingTicks: Ticks;\n\n\t/**\n\t * The swing amount\n\t */\n\tprivate _swingAmount: NormalRange = 0;\n\n\tconstructor(options?: Partial<TransportOptions>);\n\tconstructor() {\n\t\tsuper(optionsFromArguments(Transport.getDefaults(), arguments));\n\t\tconst options = optionsFromArguments(\n\t\t\tTransport.getDefaults(),\n\t\t\targuments\n\t\t);\n\n\t\t// CLOCK/TEMPO\n\t\tthis._ppq = options.ppq;\n\t\tthis._clock = new Clock({\n\t\t\tcallback: this._processTick.bind(this),\n\t\t\tcontext: this.context,\n\t\t\tfrequency: 0,\n\t\t\tunits: \"bpm\",\n\t\t});\n\t\tthis._bindClockEvents();\n\t\tthis.bpm = this._clock.frequency as unknown as TickParam<\"bpm\">;\n\t\tthis._clock.frequency.multiplier = options.ppq;\n\t\tthis.bpm.setValueAtTime(options.bpm, 0);\n\t\treadOnly(this, \"bpm\");\n\t\tthis._timeSignature = options.timeSignature;\n\n\t\t// SWING\n\t\tthis._swingTicks = options.ppq / 2; // 8n\n\t}\n\n\tstatic getDefaults(): TransportOptions {\n\t\treturn Object.assign(ToneWithContext.getDefaults(), {\n\t\t\tbpm: 120,\n\t\t\tloopEnd: \"4m\" as Subdivision,\n\t\t\tloopStart: 0,\n\t\t\tppq: 192,\n\t\t\tswing: 0,\n\t\t\tswingSubdivision: \"8n\" as Subdivision,\n\t\t\ttimeSignature: 4,\n\t\t});\n\t}\n\n\t//-------------------------------------\n\t// \tTICKS\n\t//-------------------------------------\n\n\t/**\n\t * called on every tick\n\t * @param  tickTime clock relative tick time\n\t */\n\tprivate _processTick(tickTime: Seconds, ticks: Ticks): void {\n\t\t// do the loop test\n\t\tif (this._loop.get(tickTime)) {\n\t\t\tif (ticks >= this._loopEnd) {\n\t\t\t\tthis.emit(\"loopEnd\", tickTime);\n\t\t\t\tthis._clock.setTicksAtTime(this._loopStart, tickTime);\n\t\t\t\tticks = this._loopStart;\n\t\t\t\tthis.emit(\n\t\t\t\t\t\"loopStart\",\n\t\t\t\t\ttickTime,\n\t\t\t\t\tthis._clock.getSecondsAtTime(tickTime)\n\t\t\t\t);\n\t\t\t\tthis.emit(\"loop\", tickTime);\n\t\t\t}\n\t\t}\n\t\t// handle swing\n\t\tif (\n\t\t\tthis._swingAmount > 0 &&\n\t\t\tticks % this._ppq !== 0 && // not on a downbeat\n\t\t\tticks % (this._swingTicks * 2) !== 0\n\t\t) {\n\t\t\t// add some swing\n\t\t\tconst progress =\n\t\t\t\t(ticks % (this._swingTicks * 2)) / (this._swingTicks * 2);\n\t\t\tconst amount = Math.sin(progress * Math.PI) * this._swingAmount;\n\t\t\ttickTime +=\n\t\t\t\tnew TicksClass(\n\t\t\t\t\tthis.context,\n\t\t\t\t\t(this._swingTicks * 2) / 3\n\t\t\t\t).toSeconds() * amount;\n\t\t}\n\t\t// invoke the timeline events scheduled on this tick\n\t\tenterScheduledCallback(true);\n\t\tthis._timeline.forEachAtTime(ticks, (event) => event.invoke(tickTime));\n\t\tenterScheduledCallback(false);\n\t}\n\n\t//-------------------------------------\n\t// \tSCHEDULABLE EVENTS\n\t//-------------------------------------\n\n\t/**\n\t * Schedule an event along the timeline.\n\t * @param callback The callback to be invoked at the time.\n\t * @param time The time to invoke the callback at.\n\t * @return The id of the event which can be used for canceling the event.\n\t * @example\n\t * // schedule an event on the 16th measure\n\t * Tone.Transport.schedule((time) => {\n\t * \t// invoked on measure 16\n\t * \tconsole.log(\"measure 16!\");\n\t * }, \"16:0:0\");\n\t */\n\tschedule(\n\t\tcallback: TransportCallback,\n\t\ttime: TransportTime | TransportTimeClass\n\t): number {\n\t\tconst event = new TransportEvent(this, {\n\t\t\tcallback,\n\t\t\ttime: new TransportTimeClass(this.context, time).toTicks(),\n\t\t});\n\t\treturn this._addEvent(event, this._timeline);\n\t}\n\n\t/**\n\t * Schedule a repeated event along the timeline. The event will fire\n\t * at the `interval` starting at the `startTime` and for the specified\n\t * `duration`.\n\t * @param  callback   The callback to invoke.\n\t * @param  interval   The duration between successive callbacks. Must be a positive number.\n\t * @param  startTime  When along the timeline the events should start being invoked.\n\t * @param  duration How long the event should repeat.\n\t * @return  The ID of the scheduled event. Use this to cancel the event.\n\t * @example\n\t * const osc = new Tone.Oscillator().toDestination().start();\n\t * // a callback invoked every eighth note after the first measure\n\t * Tone.Transport.scheduleRepeat((time) => {\n\t * \tosc.start(time).stop(time + 0.1);\n\t * }, \"8n\", \"1m\");\n\t */\n\tscheduleRepeat(\n\t\tcallback: TransportCallback,\n\t\tinterval: Time | TimeClass,\n\t\tstartTime?: TransportTime | TransportTimeClass,\n\t\tduration: Time = Infinity\n\t): number {\n\t\tconst event = new TransportRepeatEvent(this, {\n\t\t\tcallback,\n\t\t\tduration: new TimeClass(this.context, duration).toTicks(),\n\t\t\tinterval: new TimeClass(this.context, interval).toTicks(),\n\t\t\ttime: new TransportTimeClass(this.context, startTime).toTicks(),\n\t\t});\n\t\t// kick it off if the Transport is started\n\t\t// @ts-ignore\n\t\treturn this._addEvent(event, this._repeatedEvents);\n\t}\n\n\t/**\n\t * Schedule an event that will be removed after it is invoked.\n\t * @param callback The callback to invoke once.\n\t * @param time The time the callback should be invoked.\n\t * @returns The ID of the scheduled event.\n\t */\n\tscheduleOnce(\n\t\tcallback: TransportCallback,\n\t\ttime: TransportTime | TransportTimeClass\n\t): number {\n\t\tconst event = new TransportEvent(this, {\n\t\t\tcallback,\n\t\t\tonce: true,\n\t\t\ttime: new TransportTimeClass(this.context, time).toTicks(),\n\t\t});\n\t\treturn this._addEvent(event, this._timeline);\n\t}\n\n\t/**\n\t * Clear the passed in event id from the timeline\n\t * @param eventId The id of the event.\n\t */\n\tclear(eventId: number): this {\n\t\tif (this._scheduledEvents.hasOwnProperty(eventId)) {\n\t\t\tconst item = this._scheduledEvents[eventId.toString()];\n\t\t\titem.timeline.remove(item.event);\n\t\t\titem.event.dispose();\n\t\t\tdelete this._scheduledEvents[eventId.toString()];\n\t\t}\n\t\treturn this;\n\t}\n\n\t/**\n\t * Add an event to the correct timeline. Keep track of the\n\t * timeline it was added to.\n\t * @returns the event id which was just added\n\t */\n\tprivate _addEvent(event: TransportEvent, timeline: Timeline<TransportEvent>): number {\n\t\tthis._scheduledEvents[event.id.toString()] = {\n\t\t\tevent,\n\t\t\ttimeline,\n\t\t};\n\t\ttimeline.add(event);\n\t\treturn event.id;\n\t}\n\n\t/**\n\t * Remove scheduled events from the timeline after\n\t * the given time. Repeated events will be removed\n\t * if their startTime is after the given time\n\t * @param after Clear all events after this time.\n\t */\n\tcancel(after: TransportTime = 0): this {\n\t\tconst computedAfter = this.toTicks(after);\n\t\tthis._timeline.forEachFrom(computedAfter, (event) =>\n\t\t\tthis.clear(event.id)\n\t\t);\n\t\tthis._repeatedEvents.forEachFrom(computedAfter, (event) =>\n\t\t\tthis.clear(event.id)\n\t\t);\n\t\treturn this;\n\t}\n\n\t//-------------------------------------\n\t// \tSTART/STOP/PAUSE\n\t//-------------------------------------\n\n\t/**\n\t * Bind start/stop/pause events from the clock and emit them.\n\t */\n\tprivate _bindClockEvents(): void {\n\t\tthis._clock.on(\"start\", (time, offset) => {\n\t\t\toffset = new TicksClass(this.context, offset).toSeconds();\n\t\t\tthis.emit(\"start\", time, offset);\n\t\t});\n\n\t\tthis._clock.on(\"stop\", (time) => {\n\t\t\tthis.emit(\"stop\", time);\n\t\t});\n\n\t\tthis._clock.on(\"pause\", (time) => {\n\t\t\tthis.emit(\"pause\", time);\n\t\t});\n\t}\n\n\t/**\n\t * Returns the playback state of the source, either \"started\", \"stopped\", or \"paused\"\n\t */\n\tget state(): PlaybackState {\n\t\treturn this._clock.getStateAtTime(this.now());\n\t}\n\n\t/**\n\t * Start the transport and all sources synced to the transport.\n\t * @param  time The time when the transport should start.\n\t * @param  offset The timeline offset to start the transport.\n\t * @example\n\t * // start the transport in one second starting at beginning of the 5th measure.\n\t * Tone.Transport.start(\"+1\", \"4:0:0\");\n\t */\n\tstart(time?: Time, offset?: TransportTime): this {\n\t\t// start the context\n\t\tthis.context.resume();\n\t\tlet offsetTicks;\n\t\tif (isDefined(offset)) {\n\t\t\toffsetTicks = this.toTicks(offset);\n\t\t}\n\t\t// start the clock\n\t\tthis._clock.start(time, offsetTicks);\n\t\treturn this;\n\t}\n\n\t/**\n\t * Stop the transport and all sources synced to the transport.\n\t * @param time The time when the transport should stop.\n\t * @example\n\t * Tone.Transport.stop();\n\t */\n\tstop(time?: Time): this {\n\t\tthis._clock.stop(time);\n\t\treturn this;\n\t}\n\n\t/**\n\t * Pause the transport and all sources synced to the transport.\n\t */\n\tpause(time?: Time): this {\n\t\tthis._clock.pause(time);\n\t\treturn this;\n\t}\n\n\t/**\n\t * Toggle the current state of the transport. If it is\n\t * started, it will stop it, otherwise it will start the Transport.\n\t * @param  time The time of the event\n\t */\n\ttoggle(time?: Time): this {\n\t\ttime = this.toSeconds(time);\n\t\tif (this._clock.getStateAtTime(time) !== \"started\") {\n\t\t\tthis.start(time);\n\t\t} else {\n\t\t\tthis.stop(time);\n\t\t}\n\t\treturn this;\n\t}\n\n\t//-------------------------------------\n\t// \tSETTERS/GETTERS\n\t//-------------------------------------\n\n\t/**\n\t * The time signature as just the numerator over 4.\n\t * For example 4/4 would be just 4 and 6/8 would be 3.\n\t * @example\n\t * // common time\n\t * Tone.Transport.timeSignature = 4;\n\t * // 7/8\n\t * Tone.Transport.timeSignature = [7, 8];\n\t * // this will be reduced to a single number\n\t * Tone.Transport.timeSignature; // returns 3.5\n\t */\n\tget timeSignature(): TimeSignature {\n\t\treturn this._timeSignature;\n\t}\n\tset timeSignature(timeSig: TimeSignature) {\n\t\tif (isArray(timeSig)) {\n\t\t\ttimeSig = (timeSig[0] / timeSig[1]) * 4;\n\t\t}\n\t\tthis._timeSignature = timeSig;\n\t}\n\n\t/**\n\t * When the Transport.loop = true, this is the starting position of the loop.\n\t */\n\tget loopStart(): Time {\n\t\treturn new TimeClass(this.context, this._loopStart, \"i\").toSeconds();\n\t}\n\tset loopStart(startPosition: Time) {\n\t\tthis._loopStart = this.toTicks(startPosition);\n\t}\n\n\t/**\n\t * When the Transport.loop = true, this is the ending position of the loop.\n\t */\n\tget loopEnd(): Time {\n\t\treturn new TimeClass(this.context, this._loopEnd, \"i\").toSeconds();\n\t}\n\tset loopEnd(endPosition: Time) {\n\t\tthis._loopEnd = this.toTicks(endPosition);\n\t}\n\n\t/**\n\t * If the transport loops or not.\n\t */\n\tget loop(): boolean {\n\t\treturn this._loop.get(this.now());\n\t}\n\tset loop(loop) {\n\t\tthis._loop.set(loop, this.now());\n\t}\n\n\t/**\n\t * Set the loop start and stop at the same time.\n\t * @example\n\t * // loop over the first measure\n\t * Tone.Transport.setLoopPoints(0, \"1m\");\n\t * Tone.Transport.loop = true;\n\t */\n\tsetLoopPoints(\n\t\tstartPosition: TransportTime,\n\t\tendPosition: TransportTime\n\t): this {\n\t\tthis.loopStart = startPosition;\n\t\tthis.loopEnd = endPosition;\n\t\treturn this;\n\t}\n\n\t/**\n\t * The swing value. Between 0-1 where 1 equal to the note + half the subdivision.\n\t */\n\tget swing(): NormalRange {\n\t\treturn this._swingAmount;\n\t}\n\tset swing(amount: NormalRange) {\n\t\t// scale the values to a normal range\n\t\tthis._swingAmount = amount;\n\t}\n\n\t/**\n\t * Set the subdivision which the swing will be applied to.\n\t * The default value is an 8th note. Value must be less\n\t * than a quarter note.\n\t */\n\tget swingSubdivision(): Subdivision {\n\t\treturn new TicksClass(this.context, this._swingTicks).toNotation();\n\t}\n\tset swingSubdivision(subdivision: Subdivision) {\n\t\tthis._swingTicks = this.toTicks(subdivision);\n\t}\n\n\t/**\n\t * The Transport's position in Bars:Beats:Sixteenths.\n\t * Setting the value will jump to that position right away.\n\t */\n\tget position(): BarsBeatsSixteenths | Time {\n\t\tconst now = this.now();\n\t\tconst ticks = this._clock.getTicksAtTime(now);\n\t\treturn new TicksClass(this.context, ticks).toBarsBeatsSixteenths();\n\t}\n\tset position(progress: Time) {\n\t\tconst ticks = this.toTicks(progress);\n\t\tthis.ticks = ticks;\n\t}\n\n\t/**\n\t * The Transport's position in seconds\n\t * Setting the value will jump to that position right away.\n\t */\n\tget seconds(): Seconds {\n\t\treturn this._clock.seconds;\n\t}\n\tset seconds(s: Seconds) {\n\t\tconst now = this.now();\n\t\tconst ticks = this._clock.frequency.timeToTicks(s, now);\n\t\tthis.ticks = ticks;\n\t}\n\n\t/**\n\t * The Transport's loop position as a normalized value. Always\n\t * returns 0 if the transport if loop is not true.\n\t */\n\tget progress(): NormalRange {\n\t\tif (this.loop) {\n\t\t\tconst now = this.now();\n\t\t\tconst ticks = this._clock.getTicksAtTime(now);\n\t\t\treturn (\n\t\t\t\t(ticks - this._loopStart) / (this._loopEnd - this._loopStart)\n\t\t\t);\n\t\t} else {\n\t\t\treturn 0;\n\t\t}\n\t}\n\n\t/**\n\t * The transports current tick position.\n\t */\n\tget ticks(): Ticks {\n\t\treturn this._clock.ticks;\n\t}\n\tset ticks(t: Ticks) {\n\t\tif (this._clock.ticks !== t) {\n\t\t\tconst now = this.now();\n\t\t\t// stop everything synced to the transport\n\t\t\tif (this.state === \"started\") {\n\t\t\t\tconst ticks = this._clock.getTicksAtTime(now);\n\t\t\t\t// schedule to start on the next tick, #573\n\t\t\t\tconst remainingTick = this._clock.frequency.getDurationOfTicks(Math.ceil(ticks) - ticks, now);\n\t\t\t\tconst time = now + remainingTick;\n\t\t\t\tthis.emit(\"stop\", time);\n\t\t\t\tthis._clock.setTicksAtTime(t, time);\n\t\t\t\t// restart it with the new time\n\t\t\t\tthis.emit(\"start\", time, this._clock.getSecondsAtTime(time));\n\t\t\t} else {\n\t\t\t\tthis.emit(\"ticks\", now);\n\t\t\t\tthis._clock.setTicksAtTime(t, now);\n\t\t\t}\n\t\t}\n\t}\n\n\t/**\n\t * Get the clock's ticks at the given time.\n\t * @param  time  When to get the tick value\n\t * @return The tick value at the given time.\n\t */\n\tgetTicksAtTime(time?: Time): Ticks {\n\t\treturn this._clock.getTicksAtTime(time);\n\t}\n\n\t/**\n\t * Return the elapsed seconds at the given time.\n\t * @param  time  When to get the elapsed seconds\n\t * @return  The number of elapsed seconds\n\t */\n\tgetSecondsAtTime(time: Time): Seconds {\n\t\treturn this._clock.getSecondsAtTime(time);\n\t}\n\n\t/**\n\t * Pulses Per Quarter note. This is the smallest resolution\n\t * the Transport timing supports. This should be set once\n\t * on initialization and not set again. Changing this value\n\t * after other objects have been created can cause problems.\n\t */\n\tget PPQ(): number {\n\t\treturn this._clock.frequency.multiplier;\n\t}\n\tset PPQ(ppq: number) {\n\t\tthis._clock.frequency.multiplier = ppq;\n\t}\n\n\t//-------------------------------------\n\t// \tSYNCING\n\t//-------------------------------------\n\n\t/**\n\t * Returns the time aligned to the next subdivision\n\t * of the Transport. If the Transport is not started,\n\t * it will return 0.\n\t * Note: this will not work precisely during tempo ramps.\n\t * @param  subdivision  The subdivision to quantize to\n\t * @return  The context time of the next subdivision.\n\t * @example\n\t * // the transport must be started, otherwise returns 0\n\t * Tone.Transport.start();\n\t * Tone.Transport.nextSubdivision(\"4n\");\n\t */\n\tnextSubdivision(subdivision?: Time): Seconds {\n\t\tsubdivision = this.toTicks(subdivision);\n\t\tif (this.state !== \"started\") {\n\t\t\t// if the transport's not started, return 0\n\t\t\treturn 0;\n\t\t} else {\n\t\t\tconst now = this.now();\n\t\t\t// the remainder of the current ticks and the subdivision\n\t\t\tconst transportPos = this.getTicksAtTime(now);\n\t\t\tconst remainingTicks = subdivision - (transportPos % subdivision);\n\t\t\treturn this._clock.nextTickTime(remainingTicks, now);\n\t\t}\n\t}\n\n\t/**\n\t * Attaches the signal to the tempo control signal so that\n\t * any changes in the tempo will change the signal in the same\n\t * ratio.\n\t *\n\t * @param signal\n\t * @param ratio Optionally pass in the ratio between the two signals.\n\t * \t\t\tOtherwise it will be computed based on their current values.\n\t */\n\tsyncSignal(signal: Signal<any>, ratio?: number): this {\n\t\tif (!ratio) {\n\t\t\t// get the sync ratio\n\t\t\tconst now = this.now();\n\t\t\tif (signal.getValueAtTime(now) !== 0) {\n\t\t\t\tconst bpm = this.bpm.getValueAtTime(now);\n\t\t\t\tconst computedFreq = 1 / (60 / bpm / this.PPQ);\n\t\t\t\tratio = signal.getValueAtTime(now) / computedFreq;\n\t\t\t} else {\n\t\t\t\tratio = 0;\n\t\t\t}\n\t\t}\n\t\tconst ratioSignal = new Gain(ratio);\n\t\t// @ts-ignore\n\t\tthis.bpm.connect(ratioSignal);\n\t\t// @ts-ignore\n\t\tratioSignal.connect(signal._param);\n\t\tthis._syncedSignals.push({\n\t\t\tinitial: signal.value,\n\t\t\tratio: ratioSignal,\n\t\t\tsignal,\n\t\t});\n\t\tsignal.value = 0;\n\t\treturn this;\n\t}\n\n\t/**\n\t * Unsyncs a previously synced signal from the transport's control.\n\t * See Transport.syncSignal.\n\t */\n\tunsyncSignal(signal: Signal<any>): this {\n\t\tfor (let i = this._syncedSignals.length - 1; i >= 0; i--) {\n\t\t\tconst syncedSignal = this._syncedSignals[i];\n\t\t\tif (syncedSignal.signal === signal) {\n\t\t\t\tsyncedSignal.ratio.dispose();\n\t\t\t\tsyncedSignal.signal.value = syncedSignal.initial;\n\t\t\t\tthis._syncedSignals.splice(i, 1);\n\t\t\t}\n\t\t}\n\t\treturn this;\n\t}\n\n\t/**\n\t * Clean up.\n\t */\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis._clock.dispose();\n\t\twritable(this, \"bpm\");\n\t\tthis._timeline.dispose();\n\t\tthis._repeatedEvents.dispose();\n\t\treturn this;\n\t}\n\n\t//-------------------------------------\n\t// EMITTER MIXIN TO SATISFY COMPILER\n\t//-------------------------------------\n\n\ton!: (\n\t\tevent: TransportEventNames,\n\t\tcallback: (...args: any[]) => void\n\t) => this;\n\tonce!: (\n\t\tevent: TransportEventNames,\n\t\tcallback: (...args: any[]) => void\n\t) => this;\n\toff!: (\n\t\tevent: TransportEventNames,\n\t\tcallback?: ((...args: any[]) => void) | undefined\n\t) => this;\n\temit!: (event: any, ...args: any[]) => this;\n}\n\nEmitter.mixin(Transport);\n\n//-------------------------------------\n// \tINITIALIZATION\n//-------------------------------------\n\nonContextInit((context) => {\n\tcontext.transport = new Transport({ context });\n});\n\nonContextClose((context) => {\n\tcontext.transport.dispose();\n});\n","import { Volume } from \"../component/channel/Volume\";\nimport \"../core/context/Destination\";\nimport \"../core/clock/Transport\";\nimport { Param } from \"../core/context/Param\";\nimport { OutputNode, ToneAudioNode, ToneAudioNodeOptions } from \"../core/context/ToneAudioNode\";\nimport { Decibels, Seconds, Time } from \"../core/type/Units\";\nimport { defaultArg } from \"../core/util/Defaults\";\nimport { noOp, readOnly } from \"../core/util/Interface\";\nimport { BasicPlaybackState, StateTimeline, StateTimelineEvent } from \"../core/util/StateTimeline\";\nimport { isDefined, isUndef } from \"../core/util/TypeCheck\";\nimport { assert, assertContextRunning } from \"../core/util/Debug\";\nimport { GT } from \"../core/util/Math\";\n\ntype onStopCallback = (source: Source<any>) => void;\n\nexport interface SourceOptions extends ToneAudioNodeOptions {\n\tvolume: Decibels;\n\tmute: boolean;\n\tonstop: onStopCallback;\n}\n\n/**\n * Base class for sources. \n * start/stop of this.context.transport.\n * \n * ```\n * // Multiple state change events can be chained together,\n * // but must be set in the correct order and with ascending times\n * // OK\n * state.start().stop(\"+0.2\");\n * // OK\n * state.start().stop(\"+0.2\").start(\"+0.4\").stop(\"+0.7\")\n * // BAD\n * state.stop(\"+0.2\").start();\n * // BAD\n * state.start(\"+0.3\").stop(\"+0.2\");\n * ```\n */\nexport abstract class Source<Options extends SourceOptions> extends ToneAudioNode<Options> {\n\n\t/**\n\t * The output volume node\n\t */\n\tprivate _volume: Volume;\n\n\t/**\n\t * The output note\n\t */\n\toutput: OutputNode;\n\n\t/**\n\t * Sources have no inputs\n\t */\n\tinput = undefined;\n\n\t/**\n\t * The volume of the output in decibels.\n\t * @example\n\t * const source = new Tone.PWMOscillator().toDestination();\n\t * source.volume.value = -6;\n\t */\n\tvolume: Param<\"decibels\">;\n\n\t/**\n\t * The callback to invoke when the source is stopped.\n\t */\n\tonstop: onStopCallback;\n\n\t/**\n\t * Keep track of the scheduled state.\n\t */\n\tprotected _state: StateTimeline<{\n\t\tduration?: Seconds;\n\t\toffset?: Seconds;\n\t\t/**\n\t\t * Either the buffer is explicitly scheduled to end using the stop method,\n\t\t * or it's implicitly ended when the buffer is over.\n\t\t */\n\t\timplicitEnd?: boolean;\n\t}> = new StateTimeline(\"stopped\");\n\n\t/**\n\t * The synced `start` callback function from the transport\n\t */\n\tprotected _synced = false;\n\n\t/**\n\t * Keep track of all of the scheduled event ids\n\t */\n\tprivate _scheduled: number[] = [];\n\n\t/**\n\t * Placeholder functions for syncing/unsyncing to transport\n\t */\n\tprivate _syncedStart: (time: Seconds, offset: Seconds) => void = noOp;\n\tprivate _syncedStop: (time: Seconds) => void = noOp;\n\n\tconstructor(options: SourceOptions) {\n\t\tsuper(options);\n\t\tthis._state.memory = 100;\n\t\tthis._state.increasing = true;\n\n\t\tthis._volume = this.output = new Volume({\n\t\t\tcontext: this.context,\n\t\t\tmute: options.mute,\n\t\t\tvolume: options.volume,\n\t\t});\n\t\tthis.volume = this._volume.volume;\n\t\treadOnly(this, \"volume\");\n\t\tthis.onstop = options.onstop;\n\t}\n\n\tstatic getDefaults(): SourceOptions {\n\t\treturn Object.assign(ToneAudioNode.getDefaults(), {\n\t\t\tmute: false,\n\t\t\tonstop: noOp,\n\t\t\tvolume: 0,\n\t\t});\n\t}\n\n\t/**\n\t * Returns the playback state of the source, either \"started\" or \"stopped\".\n\t * @example\n\t * const player = new Tone.Player(\"https://tonejs.github.io/audio/berklee/ahntone_c3.mp3\", () => {\n\t * \tplayer.start();\n\t * \tconsole.log(player.state);\n\t * }).toDestination();\n\t */\n\tget state(): BasicPlaybackState {\n\t\tif (this._synced) {\n\t\t\tif (this.context.transport.state === \"started\") {\n\t\t\t\treturn this._state.getValueAtTime(this.context.transport.seconds) as BasicPlaybackState;\n\t\t\t} else {\n\t\t\t\treturn \"stopped\";\n\t\t\t}\n\t\t} else {\n\t\t\treturn this._state.getValueAtTime(this.now()) as BasicPlaybackState;\n\t\t}\n\t}\n\n\t/**\n\t * Mute the output.\n\t * @example\n\t * const osc = new Tone.Oscillator().toDestination().start();\n\t * // mute the output\n\t * osc.mute = true;\n\t */\n\tget mute(): boolean {\n\t\treturn this._volume.mute;\n\t}\n\tset mute(mute: boolean) {\n\t\tthis._volume.mute = mute;\n\t}\n\n\t// overwrite these functions\n\tprotected abstract _start(time: Time, offset?: Time, duration?: Time): void;\n\tprotected abstract _stop(time: Time): void;\n\tprotected abstract _restart(time: Seconds, offset?: Time, duration?: Time): void;\n\n\t/**\n\t * Ensure that the scheduled time is not before the current time.\n\t * Should only be used when scheduled unsynced.\n\t */\n\tprivate _clampToCurrentTime(time: Seconds): Seconds {\n\t\tif (this._synced) {\n\t\t\treturn time;\n\t\t} else {\n\t\t\treturn Math.max(time, this.context.currentTime);\n\t\t}\n\t}\n\n\t/**\n\t * Start the source at the specified time. If no time is given,\n\t * start the source now.\n\t * @param  time When the source should be started.\n\t * @example\n\t * const source = new Tone.Oscillator().toDestination();\n\t * source.start(\"+0.5\"); // starts the source 0.5 seconds from now\n\t */\n\tstart(time?: Time, offset?: Time, duration?: Time): this {\n\t\tlet computedTime = isUndef(time) && this._synced ? this.context.transport.seconds : this.toSeconds(time);\n\t\tcomputedTime = this._clampToCurrentTime(computedTime);\n\t\t// if it's started, stop it and restart it\n\t\tif (!this._synced && this._state.getValueAtTime(computedTime) === \"started\") {\n\t\t\t// time should be strictly greater than the previous start time\n\t\t\tassert(GT(computedTime, (this._state.get(computedTime) as StateTimelineEvent).time), \"Start time must be strictly greater than previous start time\");\n\t\t\tthis._state.cancel(computedTime);\n\t\t\tthis._state.setStateAtTime(\"started\", computedTime);\n\t\t\tthis.log(\"restart\", computedTime);\n\t\t\tthis.restart(computedTime, offset, duration);\n\t\t} else {\n\t\t\tthis.log(\"start\", computedTime);\n\t\t\tthis._state.setStateAtTime(\"started\", computedTime);\n\t\t\tif (this._synced) {\n\t\t\t\t// add the offset time to the event\n\t\t\t\tconst event = this._state.get(computedTime);\n\t\t\t\tif (event) {\n\t\t\t\t\tevent.offset = this.toSeconds(defaultArg(offset, 0));\n\t\t\t\t\tevent.duration = duration ? this.toSeconds(duration) : undefined;\n\t\t\t\t}\n\t\t\t\tconst sched = this.context.transport.schedule(t => {\n\t\t\t\t\tthis._start(t, offset, duration);\n\t\t\t\t}, computedTime);\n\t\t\t\tthis._scheduled.push(sched);\n\n\t\t\t\t// if the transport is already started\n\t\t\t\t// and the time is greater than where the transport is\n\t\t\t\tif (this.context.transport.state === \"started\" && \n\t\t\t\t\tthis.context.transport.getSecondsAtTime(this.immediate()) > computedTime) {\n\t\t\t\t\tthis._syncedStart(this.now(), this.context.transport.seconds);\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tassertContextRunning(this.context);\n\t\t\t\tthis._start(computedTime, offset, duration);\n\t\t\t}\n\t\t}\n\t\treturn this;\n\t}\n\n\t/**\n\t * Stop the source at the specified time. If no time is given,\n\t * stop the source now.\n\t * @param  time When the source should be stopped.\n\t * @example\n\t * const source = new Tone.Oscillator().toDestination();\n\t * source.start();\n\t * source.stop(\"+0.5\"); // stops the source 0.5 seconds from now\n\t */\n\tstop(time?: Time): this {\n\t\tlet computedTime = isUndef(time) && this._synced ? this.context.transport.seconds : this.toSeconds(time);\n\t\tcomputedTime = this._clampToCurrentTime(computedTime);\n\t\tif (this._state.getValueAtTime(computedTime) === \"started\" || isDefined(this._state.getNextState(\"started\", computedTime))) {\n\t\t\tthis.log(\"stop\", computedTime);\n\t\t\tif (!this._synced) {\n\t\t\t\tthis._stop(computedTime);\n\t\t\t} else {\n\t\t\t\tconst sched = this.context.transport.schedule(this._stop.bind(this), computedTime);\n\t\t\t\tthis._scheduled.push(sched);\n\t\t\t}\n\t\t\tthis._state.cancel(computedTime);\n\t\t\tthis._state.setStateAtTime(\"stopped\", computedTime);\n\t\t}\n\t\treturn this;\n\t}\n\n\t/**\n\t * Restart the source.\n\t */\n\trestart(time?: Time, offset?: Time, duration?: Time): this {\n\t\ttime = this.toSeconds(time);\n\t\tif (this._state.getValueAtTime(time) === \"started\") {\n\t\t\tthis._state.cancel(time);\n\t\t\tthis._restart(time, offset, duration);\n\t\t}\n\t\treturn this;\n\t}\n\n\t/**\n\t * Sync the source to the Transport so that all subsequent\n\t * calls to `start` and `stop` are synced to the TransportTime\n\t * instead of the AudioContext time.\n\t *\n\t * @example\n\t * const osc = new Tone.Oscillator().toDestination();\n\t * // sync the source so that it plays between 0 and 0.3 on the Transport's timeline\n\t * osc.sync().start(0).stop(0.3);\n\t * // start the transport.\n\t * Tone.Transport.start();\n\t * // set it to loop once a second\n\t * Tone.Transport.loop = true;\n\t * Tone.Transport.loopEnd = 1;\n\t */\n\tsync(): this {\n\t\tif (!this._synced) {\n\t\t\tthis._synced = true;\n\t\t\tthis._syncedStart = (time, offset) => {\n\t\t\t\tif (offset > 0) {\n\t\t\t\t\t// get the playback state at that time\n\t\t\t\t\tconst stateEvent = this._state.get(offset);\n\t\t\t\t\t// listen for start events which may occur in the middle of the sync'ed time\n\t\t\t\t\tif (stateEvent && stateEvent.state === \"started\" && stateEvent.time !== offset) {\n\t\t\t\t\t\t// get the offset\n\t\t\t\t\t\tconst startOffset = offset - this.toSeconds(stateEvent.time);\n\t\t\t\t\t\tlet duration: number | undefined;\n\t\t\t\t\t\tif (stateEvent.duration) {\n\t\t\t\t\t\t\tduration = this.toSeconds(stateEvent.duration) - startOffset;\n\t\t\t\t\t\t}\n\t\t\t\t\t\tthis._start(time, this.toSeconds(stateEvent.offset) + startOffset, duration);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t};\n\t\t\tthis._syncedStop = time => {\n\t\t\t\tconst seconds = this.context.transport.getSecondsAtTime(Math.max(time - this.sampleTime, 0));\n\t\t\t\tif (this._state.getValueAtTime(seconds) === \"started\") {\n\t\t\t\t\tthis._stop(time);\n\t\t\t\t}\n\t\t\t};\n\t\t\tthis.context.transport.on(\"start\", this._syncedStart);\n\t\t\tthis.context.transport.on(\"loopStart\", this._syncedStart);\n\t\t\tthis.context.transport.on(\"stop\", this._syncedStop);\n\t\t\tthis.context.transport.on(\"pause\", this._syncedStop);\n\t\t\tthis.context.transport.on(\"loopEnd\", this._syncedStop);\n\t\t}\n\t\treturn this;\n\t}\n\n\t/**\n\t * Unsync the source to the Transport. See Source.sync\n\t */\n\tunsync(): this {\n\t\tif (this._synced) {\n\t\t\tthis.context.transport.off(\"stop\", this._syncedStop);\n\t\t\tthis.context.transport.off(\"pause\", this._syncedStop);\n\t\t\tthis.context.transport.off(\"loopEnd\", this._syncedStop);\n\t\t\tthis.context.transport.off(\"start\", this._syncedStart);\n\t\t\tthis.context.transport.off(\"loopStart\", this._syncedStart);\n\t\t}\n\t\tthis._synced = false;\n\t\t// clear all of the scheduled ids\n\t\tthis._scheduled.forEach(id => this.context.transport.clear(id));\n\t\tthis._scheduled = [];\n\t\tthis._state.cancel(0);\n\t\t// stop it also\n\t\tthis._stop(0);\n\t\treturn this;\n\t}\n\n\t/**\n\t * Clean up.\n\t */\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis.onstop = noOp;\n\t\tthis.unsync();\n\t\tthis._volume.dispose();\n\t\tthis._state.dispose();\n\t\treturn this;\n\t}\n}\n","import { connect } from \"../../core/context/ToneAudioNode\";\nimport { Param } from \"../../core/context/Param\";\nimport { ToneAudioBuffer } from \"../../core/context/ToneAudioBuffer\";\nimport { GainFactor, Positive, Seconds, Time } from \"../../core/type/Units\";\nimport { defaultArg, optionsFromArguments } from \"../../core/util/Defaults\";\nimport { noOp } from \"../../core/util/Interface\";\nimport { isDefined } from \"../../core/util/TypeCheck\";\nimport { assert } from \"../../core/util/Debug\";\nimport { OneShotSource, OneShotSourceCurve, OneShotSourceOptions } from \"../OneShotSource\";\nimport { EQ, GTE, LT } from \"../../core/util/Math\";\n\nexport type ToneBufferSourceCurve = OneShotSourceCurve;\n\nexport interface ToneBufferSourceOptions extends OneShotSourceOptions {\n\turl: string | AudioBuffer | ToneAudioBuffer;\n\tcurve: ToneBufferSourceCurve;\n\tplaybackRate: Positive;\n\tfadeIn: Time;\n\tfadeOut: Time;\n\tloopStart: Time;\n\tloopEnd: Time;\n\tloop: boolean;\n\tonload: () => void;\n\tonerror: (error: Error) => void;\n}\n\n/**\n * Wrapper around the native BufferSourceNode.\n * @category Source\n */\nexport class ToneBufferSource extends OneShotSource<ToneBufferSourceOptions> {\n\n\treadonly name: string = \"ToneBufferSource\";\n\n\t/**\n\t * The oscillator\n\t */\n\tprivate _source = this.context.createBufferSource();\n\tprotected _internalChannels = [this._source];\n\n\t/**\n\t * The frequency of the oscillator\n\t */\n\treadonly playbackRate: Param<\"positive\">;\n\n\t/**\n\t * The private instance of the buffer object\n\t */\n\tprivate _buffer: ToneAudioBuffer;\n\n\t/**\n\t * indicators if the source has started/stopped\n\t */\n\tprivate _sourceStarted = false;\n\tprivate _sourceStopped = false;\n\n\t/**\n\t * @param url The buffer to play or url to load\n\t * @param onload The callback to invoke when the buffer is done playing.\n\t */\n\tconstructor(url?: ToneAudioBuffer | AudioBuffer | string, onload?: () => void);\n\tconstructor(options?: Partial<ToneBufferSourceOptions>);\n\tconstructor() {\n\n\t\tsuper(optionsFromArguments(ToneBufferSource.getDefaults(), arguments, [\"url\", \"onload\"]));\n\t\tconst options = optionsFromArguments(ToneBufferSource.getDefaults(), arguments, [\"url\", \"onload\"]);\n\n\t\tconnect(this._source, this._gainNode);\n\t\tthis._source.onended = () => this._stopSource();\n\n\t\t/**\n\t\t * The playbackRate of the buffer\n\t\t */\n\t\tthis.playbackRate = new Param({\n\t\t\tcontext: this.context,\n\t\t\tparam: this._source.playbackRate,\n\t\t\tunits: \"positive\",\n\t\t\tvalue: options.playbackRate,\n\t\t});\n\n\t\t// set some values initially\n\t\tthis.loop = options.loop;\n\t\tthis.loopStart = options.loopStart;\n\t\tthis.loopEnd = options.loopEnd;\n\t\tthis._buffer = new ToneAudioBuffer(options.url, options.onload, options.onerror);\n\n\t\tthis._internalChannels.push(this._source);\n\t}\n\n\tstatic getDefaults(): ToneBufferSourceOptions {\n\t\treturn Object.assign(OneShotSource.getDefaults(), {\n\t\t\turl: new ToneAudioBuffer(),\n\t\t\tloop: false,\n\t\t\tloopEnd: 0,\n\t\t\tloopStart: 0,\n\t\t\tonload: noOp,\n\t\t\tonerror: noOp,\n\t\t\tplaybackRate: 1,\n\t\t});\n\t}\n\n\t/**\n\t * The fadeIn time of the amplitude envelope.\n\t */\n\tget fadeIn(): Time {\n\t\treturn this._fadeIn;\n\t}\n\tset fadeIn(t: Time) {\n\t\tthis._fadeIn = t;\n\t}\n\n\t/**\n\t * The fadeOut time of the amplitude envelope.\n\t */\n\tget fadeOut(): Time {\n\t\treturn this._fadeOut;\n\t}\n\tset fadeOut(t: Time) {\n\t\tthis._fadeOut = t;\n\t}\n\n\t/**\n\t * The curve applied to the fades, either \"linear\" or \"exponential\"\n\t */\n\tget curve(): ToneBufferSourceCurve {\n\t\treturn this._curve;\n\t}\n\tset curve(t) {\n\t\tthis._curve = t;\n\t}\n\n\t/**\n\t * Start the buffer\n\t * @param  time When the player should start.\n\t * @param  offset The offset from the beginning of the sample to start at.\n\t * @param  duration How long the sample should play. If no duration is given, it will default to the full length of the sample (minus any offset)\n\t * @param  gain  The gain to play the buffer back at.\n\t */\n\tstart(time?: Time, offset?: Time, duration?: Time, gain: GainFactor = 1): this {\n\t\tassert(this.buffer.loaded, \"buffer is either not set or not loaded\");\n\t\tconst computedTime = this.toSeconds(time);\n\n\t\t// apply the gain envelope\n\t\tthis._startGain(computedTime, gain);\n\n\t\t// if it's a loop the default offset is the loopstart point\n\t\tif (this.loop) {\n\t\t\toffset = defaultArg(offset, this.loopStart);\n\t\t} else {\n\t\t\t// otherwise the default offset is 0\n\t\t\toffset = defaultArg(offset, 0);\n\t\t}\n\t\t// make sure the offset is not less than 0\n\t\tlet computedOffset = Math.max(this.toSeconds(offset), 0);\n\n\t\t// start the buffer source\n\t\tif (this.loop) {\n\t\t\t// modify the offset if it's greater than the loop time\n\t\t\tconst loopEnd = this.toSeconds(this.loopEnd) || this.buffer.duration;\n\t\t\tconst loopStart = this.toSeconds(this.loopStart);\n\t\t\tconst loopDuration = loopEnd - loopStart;\n\t\t\t// move the offset back\n\t\t\tif (GTE(computedOffset, loopEnd)) {\n\t\t\t\tcomputedOffset = ((computedOffset - loopStart) % loopDuration) + loopStart;\n\t\t\t}\n\t\t\t// when the offset is very close to the duration, set it to 0\n\t\t\tif (EQ(computedOffset, this.buffer.duration)) {\n\t\t\t\tcomputedOffset = 0;\n\t\t\t}\n\t\t}\n\t\t\n\t\t// this.buffer.loaded would have return false if the AudioBuffer was undefined\n\t\tthis._source.buffer = this.buffer.get() as AudioBuffer;\n\t\tthis._source.loopEnd = this.toSeconds(this.loopEnd) || this.buffer.duration;\n\t\tif (LT(computedOffset, this.buffer.duration)) {\n\t\t\tthis._sourceStarted = true;\n\t\t\tthis._source.start(computedTime, computedOffset);\n\t\t}\n\n\t\t// if a duration is given, schedule a stop\n\t\tif (isDefined(duration)) {\n\t\t\tlet computedDur = this.toSeconds(duration);\n\t\t\t// make sure it's never negative\n\t\t\tcomputedDur = Math.max(computedDur, 0);\n\t\t\tthis.stop(computedTime + computedDur);\n\t\t}\n\n\t\treturn this;\n\t}\n\n\tprotected _stopSource(time?: Seconds): void {\n\t\tif (!this._sourceStopped && this._sourceStarted) {\n\t\t\tthis._sourceStopped = true;\n\t\t\tthis._source.stop(this.toSeconds(time));\n\t\t\tthis._onended();\n\t\t}\n\t}\n\n\t/**\n\t * If loop is true, the loop will start at this position.\n\t */\n\tget loopStart(): Time {\n\t\treturn this._source.loopStart;\n\t}\n\tset loopStart(loopStart: Time) {\n\t\tthis._source.loopStart = this.toSeconds(loopStart);\n\t}\n\n\t/**\n\t * If loop is true, the loop will end at this position.\n\t */\n\tget loopEnd(): Time {\n\t\treturn this._source.loopEnd;\n\t}\n\tset loopEnd(loopEnd: Time) {\n\t\tthis._source.loopEnd = this.toSeconds(loopEnd);\n\t}\n\n\t/**\n\t * The audio buffer belonging to the player.\n\t */\n\tget buffer(): ToneAudioBuffer {\n\t\treturn this._buffer;\n\t}\n\tset buffer(buffer: ToneAudioBuffer) {\n\t\tthis._buffer.set(buffer);\n\t}\n\n\t/**\n\t * If the buffer should loop once it's over.\n\t */\n\tget loop(): boolean {\n\t\treturn this._source.loop;\n\t}\n\tset loop(loop: boolean) {\n\t\tthis._source.loop = loop;\n\t\tif (this._sourceStarted) {\n\t\t\tthis.cancelStop();\n\t\t}\n\t}\n\n\t/**\n\t * Clean up.\n\t */\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis._source.onended = null;\n\t\tthis._source.disconnect();\n\t\tthis._buffer.dispose();\n\t\tthis.playbackRate.dispose();\n\t\treturn this;\n\t}\n}\n","import { ToneAudioBuffer } from \"../core/context/ToneAudioBuffer\";\nimport { Positive, Time } from \"../core/type/Units\";\nimport { optionsFromArguments } from \"../core/util/Defaults\";\nimport { assert } from \"../core/util/Debug\";\nimport { Source, SourceOptions } from \"../source/Source\";\nimport { ToneBufferSource } from \"./buffer/ToneBufferSource\";\n\nexport type NoiseType = \"white\" | \"brown\" | \"pink\";\n\nexport interface NoiseOptions extends SourceOptions {\n\ttype: NoiseType;\n\tplaybackRate: Positive;\n\tfadeIn: Time;\n\tfadeOut: Time;\n}\n\n/**\n * Noise is a noise generator. It uses looped noise buffers to save on performance.\n * Noise supports the noise types: \"pink\", \"white\", and \"brown\". Read more about\n * colors of noise on [Wikipedia](https://en.wikipedia.org/wiki/Colors_of_noise).\n *\n * @example\n * // initialize the noise and start\n * const noise = new Tone.Noise(\"pink\").start();\n * // make an autofilter to shape the noise\n * const autoFilter = new Tone.AutoFilter({\n * \tfrequency: \"8n\",\n * \tbaseFrequency: 200,\n * \toctaves: 8\n * }).toDestination().start();\n * // connect the noise\n * noise.connect(autoFilter);\n * // start the autofilter LFO\n * autoFilter.start();\n * @category Source\n */\nexport class Noise extends Source<NoiseOptions> {\n\n\treadonly name: string = \"Noise\";\n\n\t/**\n\t * Private reference to the source\n\t */\n\tprivate _source: ToneBufferSource | null = null;\n\n\t/**\n\t * private reference to the type\n\t */\n\tprivate _type!: NoiseType;\n\n\t/**\n\t * The playback rate of the noise. Affects\n\t * the \"frequency\" of the noise.\n\t */\n\tprivate _playbackRate: Positive;\n\n\t/**\n\t * The fadeIn time of the amplitude envelope.\n\t */\n\tprotected _fadeIn: Time;\n\n\t/**\n\t * The fadeOut time of the amplitude envelope.\n\t */\n\tprotected _fadeOut: Time;\n\n\t/**\n\t * @param type the noise type (white|pink|brown)\n\t */\n\tconstructor(type?: NoiseType);\n\tconstructor(options?: Partial<NoiseOptions>);\n\tconstructor() {\n\t\tsuper(optionsFromArguments(Noise.getDefaults(), arguments, [\"type\"]));\n\t\tconst options = optionsFromArguments(Noise.getDefaults(), arguments, [\"type\"]);\n\n\t\tthis._playbackRate = options.playbackRate;\n\t\tthis.type = options.type;\n\t\tthis._fadeIn = options.fadeIn;\n\t\tthis._fadeOut = options.fadeOut;\n\t}\n\n\tstatic getDefaults(): NoiseOptions {\n\t\treturn Object.assign(Source.getDefaults(), {\n\t\t\tfadeIn: 0,\n\t\t\tfadeOut: 0,\n\t\t\tplaybackRate: 1,\n\t\t\ttype: \"white\" as NoiseType,\n\t\t});\n\t}\n\n\t/**\n\t * The type of the noise. Can be \"white\", \"brown\", or \"pink\".\n\t * @example\n\t * const noise = new Tone.Noise().toDestination().start();\n\t * noise.type = \"brown\";\n\t */\n\tget type(): NoiseType {\n\t\treturn this._type;\n\t}\n\tset type(type: NoiseType) {\n\t\tassert(type in _noiseBuffers, \"Noise: invalid type: \" + type);\n\t\tif (this._type !== type) {\n\t\t\tthis._type = type;\n\t\t\t// if it's playing, stop and restart it\n\t\t\tif (this.state === \"started\") {\n\t\t\t\tconst now = this.now();\n\t\t\t\tthis._stop(now);\n\t\t\t\tthis._start(now);\n\t\t\t}\n\t\t}\n\t}\n\n\t/**\n\t * The playback rate of the noise. Affects\n\t * the \"frequency\" of the noise.\n\t */\n\tget playbackRate(): Positive {\n\t\treturn this._playbackRate;\n\t}\n\tset playbackRate(rate: Positive) {\n\t\tthis._playbackRate = rate;\n\t\tif (this._source) {\n\t\t\tthis._source.playbackRate.value = rate;\n\t\t}\n\t}\n\n\t/**\n\t * internal start method\n\t */\n\tprotected _start(time?: Time): void {\n\t\tconst buffer = _noiseBuffers[this._type];\n\t\tthis._source = new ToneBufferSource({\n\t\t\turl: buffer,\n\t\t\tcontext: this.context,\n\t\t\tfadeIn: this._fadeIn,\n\t\t\tfadeOut: this._fadeOut,\n\t\t\tloop: true,\n\t\t\tonended: () => this.onstop(this),\n\t\t\tplaybackRate: this._playbackRate,\n\t\t}).connect(this.output);\n\t\tthis._source.start(this.toSeconds(time), Math.random() * (buffer.duration - 0.001));\n\t}\n\n\t/**\n\t * internal stop method\n\t */\n\tprotected _stop(time?: Time): void {\n\t\tif (this._source) {\n\t\t\tthis._source.stop(this.toSeconds(time));\n\t\t\tthis._source = null;\n\t\t}\n\t}\n\n\t/**\n\t * The fadeIn time of the amplitude envelope.\n\t */\n\tget fadeIn(): Time {\n\t\treturn this._fadeIn;\n\t}\n\tset fadeIn(time) {\n\t\tthis._fadeIn = time;\n\t\tif (this._source) {\n\t\t\tthis._source.fadeIn = this._fadeIn;\n\t\t}\n\t}\n\n\t/**\n\t * The fadeOut time of the amplitude envelope.\n\t */\n\tget fadeOut(): Time {\n\t\treturn this._fadeOut;\n\t}\n\tset fadeOut(time) {\n\t\tthis._fadeOut = time;\n\t\tif (this._source) {\n\t\t\tthis._source.fadeOut = this._fadeOut;\n\t\t}\n\t}\n\n\tprotected _restart(time?: Time): void {\n\t\t// TODO could be optimized by cancelling the buffer source 'stop'\n\t\tthis._stop(time);\n\t\tthis._start(time);\n\t}\n\n\t/**\n\t * Clean up.\n\t */\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tif (this._source) {\n\t\t\tthis._source.disconnect();\n\t\t}\n\t\treturn this;\n\t}\n}\n\n//--------------------\n// THE NOISE BUFFERS\n//--------------------\n\n// Noise buffer stats\nconst BUFFER_LENGTH = 44100 * 5;\nconst NUM_CHANNELS = 2;\n\n/**\n * The cached noise buffers\n */\ninterface NoiseCache {\n\t[key: string]: ToneAudioBuffer | null;\n}\n\n/**\n * Cache the noise buffers\n */\nconst _noiseCache: NoiseCache = {\n\tbrown: null,\n\tpink: null,\n\twhite: null,\n};\n\n/**\n * The noise arrays. Generated on initialization.\n * borrowed heavily from https://github.com/zacharydenton/noise.js\n * (c) 2013 Zach Denton (MIT)\n */\nconst _noiseBuffers = {\n\tget brown(): ToneAudioBuffer {\n\t\tif (!_noiseCache.brown) {\n\t\t\tconst buffer: Float32Array[] = [];\n\t\t\tfor (let channelNum = 0; channelNum < NUM_CHANNELS; channelNum++) {\n\t\t\t\tconst channel = new Float32Array(BUFFER_LENGTH);\n\t\t\t\tbuffer[channelNum] = channel;\n\t\t\t\tlet lastOut = 0.0;\n\t\t\t\tfor (let i = 0; i < BUFFER_LENGTH; i++) {\n\t\t\t\t\tconst white = Math.random() * 2 - 1;\n\t\t\t\t\tchannel[i] = (lastOut + (0.02 * white)) / 1.02;\n\t\t\t\t\tlastOut = channel[i];\n\t\t\t\t\tchannel[i] *= 3.5; // (roughly) compensate for gain\n\t\t\t\t}\n\t\t\t}\n\t\t\t_noiseCache.brown = new ToneAudioBuffer().fromArray(buffer);\n\t\t}\n\t\treturn _noiseCache.brown;\n\t},\n\n\tget pink(): ToneAudioBuffer {\n\t\tif (!_noiseCache.pink) {\n\t\t\tconst buffer: Float32Array[] = [];\n\t\t\tfor (let channelNum = 0; channelNum < NUM_CHANNELS; channelNum++) {\n\t\t\t\tconst channel = new Float32Array(BUFFER_LENGTH);\n\t\t\t\tbuffer[channelNum] = channel;\n\t\t\t\tlet b0, b1, b2, b3, b4, b5, b6;\n\t\t\t\tb0 = b1 = b2 = b3 = b4 = b5 = b6 = 0.0;\n\t\t\t\tfor (let i = 0; i < BUFFER_LENGTH; i++) {\n\t\t\t\t\tconst white = Math.random() * 2 - 1;\n\t\t\t\t\tb0 = 0.99886 * b0 + white * 0.0555179;\n\t\t\t\t\tb1 = 0.99332 * b1 + white * 0.0750759;\n\t\t\t\t\tb2 = 0.96900 * b2 + white * 0.1538520;\n\t\t\t\t\tb3 = 0.86650 * b3 + white * 0.3104856;\n\t\t\t\t\tb4 = 0.55000 * b4 + white * 0.5329522;\n\t\t\t\t\tb5 = -0.7616 * b5 - white * 0.0168980;\n\t\t\t\t\tchannel[i] = b0 + b1 + b2 + b3 + b4 + b5 + b6 + white * 0.5362;\n\t\t\t\t\tchannel[i] *= 0.11; // (roughly) compensate for gain\n\t\t\t\t\tb6 = white * 0.115926;\n\t\t\t\t}\n\t\t\t}\n\t\t\t_noiseCache.pink = new ToneAudioBuffer().fromArray(buffer);\n\t\t}\n\t\treturn _noiseCache.pink;\n\t},\n\n\tget white(): ToneAudioBuffer {\n\t\tif (!_noiseCache.white) {\n\t\t\tconst buffer: Float32Array[] = [];\n\t\t\tfor (let channelNum = 0; channelNum < NUM_CHANNELS; channelNum++) {\n\t\t\t\tconst channel = new Float32Array(BUFFER_LENGTH);\n\t\t\t\tbuffer[channelNum] = channel;\n\t\t\t\tfor (let i = 0; i < BUFFER_LENGTH; i++) {\n\t\t\t\t\tchannel[i] = Math.random() * 2 - 1;\n\t\t\t\t}\n\t\t\t}\n\t\t\t_noiseCache.white = new ToneAudioBuffer().fromArray(buffer);\n\t\t}\n\t\treturn _noiseCache.white;\n\t},\n};\n","import { connect, OutputNode, ToneAudioNode, ToneAudioNodeOptions } from \"../core/context/ToneAudioNode\";\nimport { Decibels } from \"../core/type/Units\";\nimport { Volume } from \"../component/channel/Volume\";\nimport { optionsFromArguments } from \"../core/util/Defaults\";\nimport { assert } from \"../core/util/Debug\";\nimport { Param } from \"../core/context/Param\";\nimport { readOnly } from \"../core/util/Interface\";\nimport { isDefined, isNumber } from \"../core/util/TypeCheck\";\n\nexport interface UserMediaOptions extends ToneAudioNodeOptions {\n\tvolume: Decibels;\n\tmute: boolean;\n}\n/**\n * UserMedia uses MediaDevices.getUserMedia to open up and external microphone or audio input. \n * Check [MediaDevices API Support](https://developer.mozilla.org/en-US/docs/Web/API/MediaDevices/getUserMedia)\n * to see which browsers are supported. Access to an external input\n * is limited to secure (HTTPS) connections.\n * @example\n * const meter = new Tone.Meter();\n * const mic = new Tone.UserMedia().connect(meter);\n * mic.open().then(() => {\n * \t// promise resolves when input is available\n * \tconsole.log(\"mic open\");\n * \t// print the incoming mic levels in decibels\n * \tsetInterval(() => console.log(meter.getValue()), 100);\n * }).catch(e => {\n * \t// promise is rejected when the user doesn't have or allow mic access\n * \tconsole.log(\"mic not open\");\n * });\n * @category Source\n */\n\nexport class UserMedia extends ToneAudioNode<UserMediaOptions> {\n\n\treadonly name: string = \"UserMedia\";\n\n\treadonly input: undefined;\n\treadonly output: OutputNode;\n\n\t/**\n\t * The MediaStreamNode\n\t */\n\tprivate _mediaStream?: MediaStreamAudioSourceNode;\n\n\t/**\n\t * The media stream created by getUserMedia.\n\t */\n\tprivate _stream?: MediaStream;\n\n\t/**\n\t * The open device\n\t */\n\tprivate _device?: MediaDeviceInfo;\n\n\t/**\n\t * The output volume node\n\t */\n\tprivate _volume: Volume;\n\n\t/**\n\t * The volume of the output in decibels.\n\t */\n\treadonly volume: Param<\"decibels\">;\n\n\t/**\n\t * @param volume The level of the input in decibels\n\t */\n\tconstructor(volume?: Decibels);\n\tconstructor(options?: Partial<UserMediaOptions>);\n\tconstructor() {\n\n\t\tsuper(optionsFromArguments(UserMedia.getDefaults(), arguments, [\"volume\"]));\n\t\tconst options = optionsFromArguments(UserMedia.getDefaults(), arguments, [\"volume\"]);\n\n\t\tthis._volume = this.output = new Volume({\n\t\t\tcontext: this.context,\n\t\t\tvolume: options.volume,\n\t\t});\n\t\tthis.volume = this._volume.volume;\n\t\treadOnly(this, \"volume\");\n\t\tthis.mute = options.mute;\n\t}\n\n\tstatic getDefaults(): UserMediaOptions {\n\t\treturn Object.assign(ToneAudioNode.getDefaults(), {\n\t\t\tmute: false,\n\t\t\tvolume: 0\n\t\t});\n\t}\n\n\t/**\n\t * Open the media stream. If a string is passed in, it is assumed\n\t * to be the label or id of the stream, if a number is passed in,\n\t * it is the input number of the stream.\n\t * @param  labelOrId The label or id of the audio input media device.\n\t *                   With no argument, the default stream is opened.\n\t * @return The promise is resolved when the stream is open.\n\t */\n\tasync open(labelOrId?: string | number): Promise<this> {\n\t\tassert(UserMedia.supported, \"UserMedia is not supported\");\n\t\t// close the previous stream\n\t\tif (this.state === \"started\") {\n\t\t\tthis.close();\n\t\t}\n\t\tconst devices = await UserMedia.enumerateDevices();\n\t\tif (isNumber(labelOrId)) {\n\t\t\tthis._device = devices[labelOrId];\n\t\t} else {\n\t\t\tthis._device = devices.find((device) => {\n\t\t\t\treturn device.label === labelOrId || device.deviceId === labelOrId;\n\t\t\t});\n\t\t\t// didn't find a matching device\n\t\t\tif (!this._device && devices.length > 0) {\n\t\t\t\tthis._device = devices[0];\n\t\t\t}\n\t\t\tassert(isDefined(this._device), `No matching device ${labelOrId}`);\n\t\t}\n\t\t// do getUserMedia\n\t\tconst constraints = {\n\t\t\taudio: {\n\t\t\t\techoCancellation: false,\n\t\t\t\tsampleRate: this.context.sampleRate,\n\t\t\t\tnoiseSuppression: false,\n\t\t\t\tmozNoiseSuppression: false,\n\t\t\t}\n\t\t};\n\t\tif (this._device) {\n\t\t\t// @ts-ignore\n\t\t\tconstraints.audio.deviceId = this._device.deviceId;\n\t\t}\n\t\tconst stream = await navigator.mediaDevices.getUserMedia(constraints);\n\t\t// start a new source only if the previous one is closed\n\t\tif (!this._stream) {\n\t\t\tthis._stream = stream;\n\t\t\t// Wrap a MediaStreamSourceNode around the live input stream.\n\t\t\tconst mediaStreamNode = this.context.createMediaStreamSource(stream);\n\t\t\t// Connect the MediaStreamSourceNode to a gate gain node\n\t\t\tconnect(mediaStreamNode, this.output);\n\t\t\tthis._mediaStream = mediaStreamNode;\n\t\t}\n\t\treturn this;\n\t}\n\n\t/**\n\t * Close the media stream\n\t */\n\tclose(): this {\n\t\tif (this._stream && this._mediaStream) {\n\t\t\tthis._stream.getAudioTracks().forEach((track) => {\n\t\t\t\ttrack.stop();\n\t\t\t});\n\t\t\tthis._stream = undefined;\n\t\t\t// remove the old media stream\n\t\t\tthis._mediaStream.disconnect();\n\t\t\tthis._mediaStream = undefined;\n\t\t}\n\t\tthis._device = undefined;\n\t\treturn this;\n\t}\n\n\t/**\n\t * Returns a promise which resolves with the list of audio input devices available.\n\t * @return The promise that is resolved with the devices\n\t * @example\n\t * Tone.UserMedia.enumerateDevices().then((devices) => {\n\t * \t// print the device labels\n\t * \tconsole.log(devices.map(device => device.label));\n\t * });\n\t */\n\tstatic async enumerateDevices(): Promise<MediaDeviceInfo[]> {\n\t\tconst allDevices = await navigator.mediaDevices.enumerateDevices();\n\t\treturn allDevices.filter(device => {\n\t\t\treturn device.kind === \"audioinput\";\n\t\t});\n\t}\n\n\t/**\n\t * Returns the playback state of the source, \"started\" when the microphone is open\n\t * and \"stopped\" when the mic is closed.\n\t */\n\tget state() {\n\t\treturn this._stream && this._stream.active ? \"started\" : \"stopped\";\n\t}\n\n\t/**\n\t * Returns an identifier for the represented device that is\n\t * persisted across sessions. It is un-guessable by other applications and\n\t * unique to the origin of the calling application. It is reset when the\n\t * user clears cookies (for Private Browsing, a different identifier is\n\t * used that is not persisted across sessions). Returns undefined when the\n\t * device is not open.\n\t */\n\tget deviceId(): string | undefined {\n\t\tif (this._device) {\n\t\t\treturn this._device.deviceId;\n\t\t} else {\n\t\t\treturn undefined;\n\t\t}\n\t}\n\n\t/**\n\t * Returns a group identifier. Two devices have the\n\t * same group identifier if they belong to the same physical device.\n\t * Returns null  when the device is not open.\n\t */\n\tget groupId(): string | undefined {\n\t\tif (this._device) {\n\t\t\treturn this._device.groupId;\n\t\t} else {\n\t\t\treturn undefined;\n\t\t}\n\t}\n\n\t/**\n\t * Returns a label describing this device (for example \"Built-in Microphone\").\n\t * Returns undefined when the device is not open or label is not available\n\t * because of permissions.\n\t */\n\tget label(): string | undefined {\n\t\tif (this._device) {\n\t\t\treturn this._device.label;\n\t\t} else {\n\t\t\treturn undefined;\n\t\t}\n\t}\n\n\t/**\n\t * Mute the output.\n\t * @example\n\t * const mic = new Tone.UserMedia();\n\t * mic.open().then(() => {\n\t * \t// promise resolves when input is available\n\t * });\n\t * // mute the output\n\t * mic.mute = true;\n\t */\n\tget mute(): boolean {\n\t\treturn this._volume.mute;\n\t}\n\tset mute(mute) {\n\t\tthis._volume.mute = mute;\n\t}\n\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis.close();\n\t\tthis._volume.dispose();\n\t\tthis.volume.dispose();\n\t\treturn this;\n\t}\n\n\t/**\n\t * If getUserMedia is supported by the browser.\n\t */\n\tstatic get supported(): boolean {\n\t\treturn isDefined(navigator.mediaDevices) &&\n\t\t\tisDefined(navigator.mediaDevices.getUserMedia);\n\t}\n}\n","import { AudioRange, Cents, Degrees, Frequency, Positive } from \"../../core/type/Units\";\nimport { Omit } from \"../../core/util/Interface\";\nimport { Signal } from \"../../signal/Signal\";\nimport { SourceOptions } from \"../Source\";\nimport { OfflineContext } from \"../../core/context/OfflineContext\";\n\n/**\n * The common interface of all Oscillators\n */\nexport interface ToneOscillatorInterface {\n\n\t/**\n\t * The oscillator type without the partialsCount appended to the end\n\t * @example\n\t * const osc = new Tone.Oscillator();\n\t * osc.type = \"sine2\";\n\t * console.log(osc.baseType); // \"sine\"\n\t */\n\tbaseType: OscillatorType | \"pulse\" | \"pwm\";\n\n\t/**\n\t * The oscillator's type. Also capable of setting the first x number of partials of the oscillator. \n\t * For example: \"sine4\" would set be the first 4 partials of the sine wave and \"triangle8\" would \n\t * set the first 8 partials of the triangle wave.\n\t * @example\n\t * return Tone.Offline(() => {\n\t * \tconst osc = new Tone.Oscillator().toDestination().start();\n\t * \tosc.type = \"sine2\";\n\t * }, 0.1, 1);\n\t */\n\ttype: ExtendedToneOscillatorType;\n\n\t/**\n\t * The frequency value of the oscillator\n\t * @example\n\t * const osc = new Tone.FMOscillator(\"Bb4\").toDestination().start();\n\t * osc.frequency.rampTo(\"D2\", 3);\n\t */\n\treadonly frequency: Signal<\"frequency\">;\n\n\t/**\n\t * The detune value in cents (100th of a semitone).\n\t * @example\n\t * const osc = new Tone.PulseOscillator(\"F3\").toDestination().start();\n\t * // pitch it 1 octave = 12 semitones = 1200 cents\n\t * osc.detune.setValueAtTime(-1200, Tone.now());\n\t * osc.detune.setValueAtTime(1200, Tone.now() + 0.5);\n\t * osc.detune.linearRampToValueAtTime(0, Tone.now() + 1);\n\t * osc.stop(Tone.now() + 1.5);\n\t */\n\treadonly detune: Signal<\"cents\">;\n\n\t/**\n\t * The phase is the starting position within the oscillator's cycle. For example\n\t * a phase of 180 would start halfway through the oscillator's cycle. \n\t * @example\n\t * return Tone.Offline(() => {\n\t * \tconst osc = new Tone.Oscillator({\n\t * \t\tfrequency: 20,\n\t * \t\tphase: 90\n\t * \t}).toDestination().start();\n\t * }, 0.1, 1);\n\t */\n\tphase: Degrees;\n\n\t/**\n\t * The partials describes the relative amplitude of each of the harmonics of the oscillator. \n\t * The first value in the array is the first harmonic (i.e. the fundamental frequency), the \n\t * second harmonic is an octave up, the third harmonic is an octave and a fifth, etc. The resulting\n\t * oscillator output is composed of a sine tone at the relative amplitude at each of the harmonic intervals. \n\t * \n\t * Setting this value will automatically set the type to \"custom\".\n\t * The value is an empty array when the type is not \"custom\".\n\t * @example\n\t * const osc = new Tone.Oscillator(\"F3\").toDestination().start();\n\t * setInterval(() => {\n\t * \t// generate 8 random partials\n\t * \tosc.partials = new Array(8).fill(0).map(() => Math.random());\n\t * }, 1000);\n\t */\n\tpartials: number[];\n\n\t/**\n\t * 'partialCount' offers an alternative way to set the number of used partials.\n\t * When partialCount is 0, the maximum number of partials are used when representing\n\t * the waveform using the periodicWave. When 'partials' is set, this value is\n\t * not settable, but equals the length of the partials array. A square wave wave\n\t * is composed of only odd harmonics up through the harmonic series. Partial count\n\t * can limit the number of harmonics which are used to generate the waveform.\n\t * @example\n\t * const osc = new Tone.Oscillator(\"C3\", \"square\").toDestination().start();\n\t * osc.partialCount = 1;\n\t * setInterval(() => {\n\t * \tosc.partialCount++;\n\t * \tconsole.log(osc.partialCount);\n\t * }, 500);\n\t */\n\tpartialCount?: number;\n\n\t/**\n\t * Returns an array of values which represents the waveform.\n\t * @param length The length of the waveform to return\n\t */\n\tasArray(length: number): Promise<Float32Array>;\n}\n\n/**\n * Render a segment of the oscillator to an offline context and return the results as an array\n */\nexport async function generateWaveform(instance: any, length: number): Promise<Float32Array> {\n\tconst duration = length / instance.context.sampleRate;\n\tconst context = new OfflineContext(1, duration, instance.context.sampleRate);\n\tconst clone = new instance.constructor(Object.assign(instance.get(), {\n\t\t// should do 2 iterations\n\t\tfrequency: 2 / duration,\n\t\t// zero out the detune\n\t\tdetune: 0,\n\t\tcontext\n\t})).toDestination();\n\tclone.start(0);\n\tconst buffer = await context.render();\n\treturn buffer.getChannelData(0);\n}\n\n/**\n * Oscillators with partials\n */\ntype SineWithPartials =\n\t\"sine1\" | \"sine2\" | \"sine3\" | \"sine4\" | \"sine5\" | \"sine6\" | \"sine7\" | \"sine8\" | \"sine9\" |\n\t\"sine10\" | \"sine11\" | \"sine12\" | \"sine13\" | \"sine14\" | \"sine15\" | \"sine16\" | \"sine17\" | \"sine18\" | \"sine19\" |\n\t\"sine20\" | \"sine21\" | \"sine22\" | \"sine23\" | \"sine24\" | \"sine25\" | \"sine26\" | \"sine27\" | \"sine28\" | \"sine29\" |\n\t\"sine30\" | \"sine31\" | \"sine32\";\n\ntype SquareWithPartials =\n\t\"square1\" | \"square2\" | \"square3\" | \"square4\" | \"square5\" | \"square6\" | \"square7\" | \"square8\" | \"square9\" |\n\t\"square10\" | \"square11\" | \"square12\" | \"square13\" | \"square14\" | \"square15\" | \"square16\" | \"square17\" | \"square18\" | \"square19\" |\n\t\"square20\" | \"square21\" | \"square22\" | \"square23\" | \"square24\" | \"square25\" | \"square26\" | \"square27\" | \"square28\" | \"square29\" |\n\t\"square30\" | \"square31\" | \"square32\";\n\ntype SawtoothWithPartials =\n\t\"sawtooth1\" | \"sawtooth2\" | \"sawtooth3\" | \"sawtooth4\" | \"sawtooth5\" | \"sawtooth6\" | \"sawtooth7\" | \"sawtooth8\" | \"sawtooth9\" |\n\t\"sawtooth10\" | \"sawtooth11\" | \"sawtooth12\" | \"sawtooth13\" | \"sawtooth14\" | \"sawtooth15\" | \"sawtooth16\" | \"sawtooth17\" | \"sawtooth18\" | \"sawtooth19\" |\n\t\"sawtooth20\" | \"sawtooth21\" | \"sawtooth22\" | \"sawtooth23\" | \"sawtooth24\" | \"sawtooth25\" | \"sawtooth26\" | \"sawtooth27\" | \"sawtooth28\" | \"sawtooth29\" |\n\t\"sawtooth30\" | \"sawtooth31\" | \"sawtooth32\";\n\ntype TriangleWithPartials =\n\t\"triangle1\" | \"triangle2\" | \"triangle3\" | \"triangle4\" | \"triangle5\" | \"triangle6\" | \"triangle7\" | \"triangle8\" | \"triangle9\" |\n\t\"triangle10\" | \"triangle11\" | \"triangle12\" | \"triangle13\" | \"triangle14\" | \"triangle15\" | \"triangle16\" | \"triangle17\" | \"triangle18\" | \"triangle19\" |\n\t\"triangle20\" | \"triangle21\" | \"triangle22\" | \"triangle23\" | \"triangle24\" | \"triangle25\" | \"triangle26\" | \"triangle27\" | \"triangle28\" | \"triangle29\" |\n\t\"triangle30\" | \"triangle31\" | \"triangle32\";\n\ntype TypeWithPartials = SineWithPartials | SquareWithPartials | TriangleWithPartials | SawtoothWithPartials;\n\ninterface BaseOscillatorOptions extends SourceOptions {\n\tfrequency: Frequency;\n\tdetune: Cents;\n\tphase: Degrees;\n}\n\nexport type NonCustomOscillatorType = Exclude<OscillatorType, \"custom\">;\n\ntype AllNonCustomOscillatorType = NonCustomOscillatorType | TypeWithPartials;\n\nexport type ToneOscillatorType = AllNonCustomOscillatorType | \"custom\";\n\nexport type ExtendedToneOscillatorType = ToneOscillatorType | \"pwm\" | \"pulse\";\n\n/**\n * Oscillator Interfaces\n */\ninterface ToneCustomOscillatorOptions extends BaseOscillatorOptions {\n\ttype: \"custom\";\n\tpartials: number[];\n}\n\ninterface ToneTypeOscillatorOptions extends BaseOscillatorOptions {\n\ttype: NonCustomOscillatorType;\n\tpartialCount?: number;\n}\n\ninterface TonePartialOscillatorOptions extends BaseOscillatorOptions {\n\ttype: TypeWithPartials;\n}\n\nexport type ToneOscillatorConstructorOptions = ToneCustomOscillatorOptions | ToneTypeOscillatorOptions | TonePartialOscillatorOptions;\n\nexport interface ToneOscillatorOptions extends BaseOscillatorOptions {\n\ttype: ToneOscillatorType;\n\tpartialCount: number;\n\tpartials: number[];\n}\n\n/**\n * FMOscillator Interface\n */\ninterface FMBaseOscillatorOptions extends BaseOscillatorOptions {\n\tharmonicity: Positive;\n\tmodulationIndex: Positive;\n\tmodulationType: AllNonCustomOscillatorType;\n}\n\ninterface FMCustomOscillatorOptions extends FMBaseOscillatorOptions {\n\ttype: \"custom\";\n\tpartials: number[];\n}\n\ninterface FMTypeOscillatorOptions extends FMBaseOscillatorOptions {\n\ttype: NonCustomOscillatorType;\n\tpartialsCount?: number;\n}\n\ninterface FMPartialsOscillatorOptions extends FMBaseOscillatorOptions {\n\ttype: TypeWithPartials;\n}\n\nexport type FMConstructorOptions = FMTypeOscillatorOptions | FMCustomOscillatorOptions | FMPartialsOscillatorOptions;\n\nexport interface FMOscillatorOptions extends ToneOscillatorOptions {\n\tharmonicity: Positive;\n\tmodulationIndex: Positive;\n\tmodulationType: AllNonCustomOscillatorType;\n}\n\n/**\n * AMOscillator Interface\n */\ninterface AMBaseOscillatorOptions extends BaseOscillatorOptions {\n\tharmonicity: Positive;\n\tmodulationType: AllNonCustomOscillatorType;\n}\n\ninterface AMCustomOscillatorOptions extends AMBaseOscillatorOptions {\n\ttype: \"custom\";\n\tpartials: number[];\n}\n\ninterface AMTypeOscillatorOptions extends AMBaseOscillatorOptions {\n\ttype: NonCustomOscillatorType;\n\tpartialsCount?: number;\n}\n\ninterface AMPartialsOscillatorOptions extends AMBaseOscillatorOptions {\n\ttype: TypeWithPartials;\n}\n\nexport type AMConstructorOptions = AMCustomOscillatorOptions | AMTypeOscillatorOptions | AMPartialsOscillatorOptions;\n\nexport interface AMOscillatorOptions extends ToneOscillatorOptions {\n\tharmonicity: Positive;\n\tmodulationType: AllNonCustomOscillatorType;\n}\n/**\n * FatOscillator\n */\ninterface FatBaseOscillatorOptions extends BaseOscillatorOptions {\n\tspread: Cents;\n\tcount: Positive;\n}\n\ninterface FatCustomOscillatorOptions extends FatBaseOscillatorOptions {\n\ttype: \"custom\";\n\tpartials: number[];\n}\n\ninterface FatTypeOscillatorOptions extends FatBaseOscillatorOptions {\n\ttype: NonCustomOscillatorType;\n\tpartialCount?: number;\n}\n\ninterface FatPartialsOscillatorOptions extends FatBaseOscillatorOptions {\n\ttype: TypeWithPartials;\n}\n\nexport type FatConstructorOptions = FatCustomOscillatorOptions | FatTypeOscillatorOptions | FatPartialsOscillatorOptions;\n\nexport interface FatOscillatorOptions extends ToneOscillatorOptions {\n\tspread: Cents;\n\tcount: Positive;\n}\n\n/**\n * Pulse Oscillator\n */\nexport interface PulseOscillatorOptions extends BaseOscillatorOptions {\n\ttype: \"pulse\";\n\twidth: AudioRange;\n}\n\n/**\n * PWM Oscillator\n */\nexport interface PWMOscillatorOptions extends BaseOscillatorOptions {\n\ttype: \"pwm\";\n\tmodulationFrequency: Frequency;\n}\n\n/**\n * OMNI OSCILLATOR\n */\n\n/**\n * FM Oscillators with partials\n */\ntype FMSineWithPartials =\n\t\"fmsine1\" | \"fmsine2\" | \"fmsine3\" | \"fmsine4\" | \"fmsine5\" | \"fmsine6\" | \"fmsine7\" | \"fmsine8\" | \"fmsine9\" |\n\t\"fmsine10\" | \"fmsine11\" | \"fmsine12\" | \"fmsine13\" | \"fmsine14\" | \"fmsine15\" | \"fmsine16\" | \"fmsine17\" | \"fmsine18\" | \"fmsine19\" |\n\t\"fmsine20\" | \"fmsine21\" | \"fmsine22\" | \"fmsine23\" | \"fmsine24\" | \"fmsine25\" | \"fmsine26\" | \"fmsine27\" | \"fmsine28\" | \"fmsine29\" |\n\t\"fmsine30\" | \"fmsine31\" | \"fmsine32\";\n\ntype FMSquareWithPartials =\n\t\"fmsquare1\" | \"fmsquare2\" | \"fmsquare3\" | \"fmsquare4\" | \"fmsquare5\" | \"fmsquare6\" | \"fmsquare7\" | \"fmsquare8\" | \"fmsquare9\" |\n\t\"fmsquare10\" | \"fmsquare11\" | \"fmsquare12\" | \"fmsquare13\" | \"fmsquare14\" | \"fmsquare15\" | \"fmsquare16\" | \"fmsquare17\" | \"fmsquare18\" | \"fmsquare19\" |\n\t\"fmsquare20\" | \"fmsquare21\" | \"fmsquare22\" | \"fmsquare23\" | \"fmsquare24\" | \"fmsquare25\" | \"fmsquare26\" | \"fmsquare27\" | \"fmsquare28\" | \"fmsquare29\" |\n\t\"fmsquare30\" | \"fmsquare31\" | \"fmsquare32\";\n\ntype FMSawtoothWithPartials =\n\t\"fmsawtooth1\" | \"fmsawtooth2\" | \"fmsawtooth3\" | \"fmsawtooth4\" | \"fmsawtooth5\" | \"fmsawtooth6\" | \"fmsawtooth7\" | \"fmsawtooth8\" | \"fmsawtooth9\" |\n\t\"fmsawtooth10\" | \"fmsawtooth11\" | \"fmsawtooth12\" | \"fmsawtooth13\" | \"fmsawtooth14\" | \"fmsawtooth15\" | \"fmsawtooth16\" | \"fmsawtooth17\" | \"fmsawtooth18\" | \"fmsawtooth19\" |\n\t\"fmsawtooth20\" | \"fmsawtooth21\" | \"fmsawtooth22\" | \"fmsawtooth23\" | \"fmsawtooth24\" | \"fmsawtooth25\" | \"fmsawtooth26\" | \"fmsawtooth27\" | \"fmsawtooth28\" | \"fmsawtooth29\" |\n\t\"fmsawtooth30\" | \"fmsawtooth31\" | \"fmsawtooth32\";\n\ntype FMTriangleWithPartials =\n\t\"fmtriangle1\" | \"fmtriangle2\" | \"fmtriangle3\" | \"fmtriangle4\" | \"fmtriangle5\" | \"fmtriangle6\" | \"fmtriangle7\" | \"fmtriangle8\" | \"fmtriangle9\" |\n\t\"fmtriangle10\" | \"fmtriangle11\" | \"fmtriangle12\" | \"fmtriangle13\" | \"fmtriangle14\" | \"fmtriangle15\" | \"fmtriangle16\" | \"fmtriangle17\" | \"fmtriangle18\" | \"fmtriangle19\" |\n\t\"fmtriangle20\" | \"fmtriangle21\" | \"fmtriangle22\" | \"fmtriangle23\" | \"fmtriangle24\" | \"fmtriangle25\" | \"fmtriangle26\" | \"fmtriangle27\" | \"fmtriangle28\" | \"fmtriangle29\" |\n\t\"fmtriangle30\" | \"fmtriangle31\" | \"fmtriangle32\";\n\ntype FMTypeWithPartials = FMSineWithPartials | FMSquareWithPartials | FMSawtoothWithPartials | FMTriangleWithPartials;\n\n/**\n * AM Oscillators with partials\n */\ntype AMSineWithPartials =\n\t\"amsine1\" | \"amsine2\" | \"amsine3\" | \"amsine4\" | \"amsine5\" | \"amsine6\" | \"amsine7\" | \"amsine8\" | \"amsine9\" |\n\t\"amsine10\" | \"amsine11\" | \"amsine12\" | \"amsine13\" | \"amsine14\" | \"amsine15\" | \"amsine16\" | \"amsine17\" | \"amsine18\" | \"amsine19\" |\n\t\"amsine20\" | \"amsine21\" | \"amsine22\" | \"amsine23\" | \"amsine24\" | \"amsine25\" | \"amsine26\" | \"amsine27\" | \"amsine28\" | \"amsine29\" |\n\t\"amsine30\" | \"amsine31\" | \"amsine32\";\n\ntype AMSquareWithPartials =\n\t\"amsquare1\" | \"amsquare2\" | \"amsquare3\" | \"amsquare4\" | \"amsquare5\" | \"amsquare6\" | \"amsquare7\" | \"amsquare8\" | \"amsquare9\" |\n\t\"amsquare10\" | \"amsquare11\" | \"amsquare12\" | \"amsquare13\" | \"amsquare14\" | \"amsquare15\" | \"amsquare16\" | \"amsquare17\" | \"amsquare18\" | \"amsquare19\" |\n\t\"amsquare20\" | \"amsquare21\" | \"amsquare22\" | \"amsquare23\" | \"amsquare24\" | \"amsquare25\" | \"amsquare26\" | \"amsquare27\" | \"amsquare28\" | \"amsquare29\" |\n\t\"amsquare30\" | \"amsquare31\" | \"amsquare32\";\n\ntype AMSawtoothWithPartials =\n\t\"amsawtooth1\" | \"amsawtooth2\" | \"amsawtooth3\" | \"amsawtooth4\" | \"amsawtooth5\" | \"amsawtooth6\" | \"amsawtooth7\" | \"amsawtooth8\" | \"amsawtooth9\" |\n\t\"amsawtooth10\" | \"amsawtooth11\" | \"amsawtooth12\" | \"amsawtooth13\" | \"amsawtooth14\" | \"amsawtooth15\" | \"amsawtooth16\" | \"amsawtooth17\" | \"amsawtooth18\" | \"amsawtooth19\" |\n\t\"amsawtooth20\" | \"amsawtooth21\" | \"amsawtooth22\" | \"amsawtooth23\" | \"amsawtooth24\" | \"amsawtooth25\" | \"amsawtooth26\" | \"amsawtooth27\" | \"amsawtooth28\" | \"amsawtooth29\" |\n\t\"amsawtooth30\" | \"amsawtooth31\" | \"amsawtooth32\";\n\ntype AMTriangleWithPartials =\n\t\"amtriangle1\" | \"amtriangle2\" | \"amtriangle3\" | \"amtriangle4\" | \"amtriangle5\" | \"amtriangle6\" | \"amtriangle7\" | \"amtriangle8\" | \"amtriangle9\" |\n\t\"amtriangle10\" | \"amtriangle11\" | \"amtriangle12\" | \"amtriangle13\" | \"amtriangle14\" | \"amtriangle15\" | \"amtriangle16\" | \"amtriangle17\" | \"amtriangle18\" | \"amtriangle19\" |\n\t\"amtriangle20\" | \"amtriangle21\" | \"amtriangle22\" | \"amtriangle23\" | \"amtriangle24\" | \"amtriangle25\" | \"amtriangle26\" | \"amtriangle27\" | \"amtriangle28\" | \"amtriangle29\" |\n\t\"amtriangle30\" | \"amtriangle31\" | \"amtriangle32\";\n\ntype AMTypeWithPartials = AMSineWithPartials | AMSquareWithPartials | AMSawtoothWithPartials | AMTriangleWithPartials;\n\n/**\n * Fat Oscillators with partials\n */\ntype FatSineWithPartials =\n\t\"fatsine1\" | \"fatsine2\" | \"fatsine3\" | \"fatsine4\" | \"fatsine5\" | \"fatsine6\" | \"fatsine7\" | \"fatsine8\" | \"fatsine9\" |\n\t\"fatsine10\" | \"fatsine11\" | \"fatsine12\" | \"fatsine13\" | \"fatsine14\" | \"fatsine15\" | \"fatsine16\" | \"fatsine17\" | \"fatsine18\" | \"fatsine19\" |\n\t\"fatsine20\" | \"fatsine21\" | \"fatsine22\" | \"fatsine23\" | \"fatsine24\" | \"fatsine25\" | \"fatsine26\" | \"fatsine27\" | \"fatsine28\" | \"fatsine29\" |\n\t\"fatsine30\" | \"fatsine31\" | \"fatsine32\";\n\ntype FatSquareWithPartials =\n\t\"fatsquare1\" | \"fatsquare2\" | \"fatsquare3\" | \"fatsquare4\" | \"fatsquare5\" | \"fatsquare6\" | \"fatsquare7\" | \"fatsquare8\" | \"fatsquare9\" |\n\t\"fatsquare10\" | \"fatsquare11\" | \"fatsquare12\" | \"fatsquare13\" | \"fatsquare14\" | \"fatsquare15\" | \"fatsquare16\" | \"fatsquare17\" | \"fatsquare18\" | \"fatsquare19\" |\n\t\"fatsquare20\" | \"fatsquare21\" | \"fatsquare22\" | \"fatsquare23\" | \"fatsquare24\" | \"fatsquare25\" | \"fatsquare26\" | \"fatsquare27\" | \"fatsquare28\" | \"fatsquare29\" |\n\t\"fatsquare30\" | \"fatsquare31\" | \"fatsquare32\";\n\ntype FatSawtoothWithPartials =\n\t\"fatsawtooth1\" | \"fatsawtooth2\" | \"fatsawtooth3\" | \"fatsawtooth4\" | \"fatsawtooth5\" | \"fatsawtooth6\" | \"fatsawtooth7\" | \"fatsawtooth8\" | \"fatsawtooth9\" |\n\t\"fatsawtooth10\" | \"fatsawtooth11\" | \"fatsawtooth12\" | \"fatsawtooth13\" | \"fatsawtooth14\" | \"fatsawtooth15\" | \"fatsawtooth16\" | \"fatsawtooth17\" | \"fatsawtooth18\" | \"fatsawtooth19\" |\n\t\"fatsawtooth20\" | \"fatsawtooth21\" | \"fatsawtooth22\" | \"fatsawtooth23\" | \"fatsawtooth24\" | \"fatsawtooth25\" | \"fatsawtooth26\" | \"fatsawtooth27\" | \"fatsawtooth28\" | \"fatsawtooth29\" |\n\t\"fatsawtooth30\" | \"fatsawtooth31\" | \"fatsawtooth32\";\n\ntype FatTriangleWithPartials =\n\t\"fattriangle1\" | \"fattriangle2\" | \"fattriangle3\" | \"fattriangle4\" | \"fattriangle5\" | \"fattriangle6\" | \"fattriangle7\" | \"fattriangle8\" | \"fattriangle9\" |\n\t\"fattriangle10\" | \"fattriangle11\" | \"fattriangle12\" | \"fattriangle13\" | \"fattriangle14\" | \"fattriangle15\" | \"fattriangle16\" | \"fattriangle17\" | \"fattriangle18\" | \"fattriangle19\" |\n\t\"fattriangle20\" | \"fattriangle21\" | \"fattriangle22\" | \"fattriangle23\" | \"fattriangle24\" | \"fattriangle25\" | \"fattriangle26\" | \"fattriangle27\" | \"fattriangle28\" | \"fattriangle29\" |\n\t\"fattriangle30\" | \"fattriangle31\" | \"fattriangle32\";\n\ntype FatTypeWithPartials = FatSineWithPartials | FatSquareWithPartials | FatSawtoothWithPartials | FatTriangleWithPartials;\n\n/**\n * Omni FM\n */\ninterface OmniFMCustomOscillatorOptions extends FMBaseOscillatorOptions {\n\ttype: \"fmcustom\";\n\tpartials: number[];\n}\n\ninterface OmniFMTypeOscillatorOptions extends FMBaseOscillatorOptions {\n\ttype: \"fmsine\" | \"fmsquare\" | \"fmsawtooth\" | \"fmtriangle\";\n\tpartialsCount?: number;\n}\n\ninterface OmniFMPartialsOscillatorOptions extends FMBaseOscillatorOptions {\n\ttype: FMTypeWithPartials;\n}\n\n/**\n * Omni AM\n */\ninterface OmniAMCustomOscillatorOptions extends AMBaseOscillatorOptions {\n\ttype: \"amcustom\";\n\tpartials: number[];\n}\n\ninterface OmniAMTypeOscillatorOptions extends AMBaseOscillatorOptions {\n\ttype: \"amsine\" | \"amsquare\" | \"amsawtooth\" | \"amtriangle\";\n\tpartialsCount?: number;\n}\n\ninterface OmniAMPartialsOscillatorOptions extends AMBaseOscillatorOptions {\n\ttype: AMTypeWithPartials;\n}\n\n/**\n * Omni Fat\n */\ninterface OmniFatCustomOscillatorOptions extends FatBaseOscillatorOptions {\n\ttype: \"fatcustom\";\n\tpartials: number[];\n}\n\ninterface OmniFatTypeOscillatorOptions extends FatBaseOscillatorOptions {\n\ttype: \"fatsine\" | \"fatsquare\" | \"fatsawtooth\" | \"fattriangle\";\n\tpartialsCount?: number;\n}\n\ninterface OmniFatPartialsOscillatorOptions extends FatBaseOscillatorOptions {\n\ttype: FatTypeWithPartials;\n}\n\nexport type OmniOscillatorType =\n\t\"fatsine\" | \"fatsquare\" | \"fatsawtooth\" | \"fattriangle\" | \"fatcustom\" | FatTypeWithPartials |\n\t\"fmsine\" | \"fmsquare\" | \"fmsawtooth\" | \"fmtriangle\" | \"fmcustom\" | FMTypeWithPartials |\n\t\"amsine\" | \"amsquare\" | \"amsawtooth\" | \"amtriangle\" | \"amcustom\" | AMTypeWithPartials |\n\tTypeWithPartials | OscillatorType | \"pulse\" | \"pwm\";\n\nexport type OmniOscillatorOptions =\n\tPulseOscillatorOptions | PWMOscillatorOptions |\n\tOmniFatCustomOscillatorOptions | OmniFatTypeOscillatorOptions | OmniFatPartialsOscillatorOptions |\n\tOmniFMCustomOscillatorOptions | OmniFMTypeOscillatorOptions | OmniFMPartialsOscillatorOptions |\n\tOmniAMCustomOscillatorOptions | OmniAMTypeOscillatorOptions | OmniAMPartialsOscillatorOptions |\n\tToneOscillatorConstructorOptions;\n\ntype OmitSourceOptions<T extends BaseOscillatorOptions> = Omit<T, \"frequency\" | \"detune\" | \"context\">;\n\n/**\n * The settable options for the omni oscillator inside of the source which excludes certain attributes that are defined by the parent class\n */\nexport type OmniOscillatorSynthOptions =\n\tOmitSourceOptions<PulseOscillatorOptions> | OmitSourceOptions<PWMOscillatorOptions> |\n\tOmitSourceOptions<OmniFatCustomOscillatorOptions> | OmitSourceOptions<OmniFatTypeOscillatorOptions> | OmitSourceOptions<OmniFatPartialsOscillatorOptions> |\n\tOmitSourceOptions<OmniFMCustomOscillatorOptions> | OmitSourceOptions<OmniFMTypeOscillatorOptions> | OmitSourceOptions<OmniFMPartialsOscillatorOptions> |\n\tOmitSourceOptions<OmniAMCustomOscillatorOptions> | OmitSourceOptions<OmniAMTypeOscillatorOptions> | OmitSourceOptions<OmniAMPartialsOscillatorOptions> |\n\tOmitSourceOptions<ToneCustomOscillatorOptions> | OmitSourceOptions<ToneTypeOscillatorOptions> | OmitSourceOptions<TonePartialOscillatorOptions>\n","import { connect } from \"../../core/context/ToneAudioNode\";\nimport { Param } from \"../../core/context/Param\";\nimport { Cents, Frequency, Seconds, Time } from \"../../core/type/Units\";\nimport { optionsFromArguments } from \"../../core/util/Defaults\";\nimport { OneShotSource, OneShotSourceOptions } from \"../OneShotSource\";\nimport { readOnly } from \"../../core/util/Interface\";\n\nexport interface ToneOscillatorNodeOptions extends OneShotSourceOptions {\n\tfrequency: Frequency;\n\tdetune: Cents;\n\ttype: OscillatorType;\n}\n\n/**\n * Wrapper around the native fire-and-forget OscillatorNode.\n * Adds the ability to reschedule the stop method.\n * ***[[Oscillator]] is better for most use-cases***\n * @category Source\n */\nexport class ToneOscillatorNode extends OneShotSource<ToneOscillatorNodeOptions> {\n\n\treadonly name: string = \"ToneOscillatorNode\";\n\n\t/**\n\t * The oscillator\n\t */\n\tprivate _oscillator = this.context.createOscillator();\n\tprotected _internalChannels = [this._oscillator];\n\n\t/**\n\t * The frequency of the oscillator\n\t */\n\treadonly frequency: Param<\"frequency\">;\n\n\t/**\n\t * The detune of the oscillator\n\t */\n\treadonly detune: Param<\"cents\">;\n\n\t/**\n\t * @param  frequency   The frequency value\n\t * @param  type  The basic oscillator type\n\t */\n\tconstructor(\n\t\tfrequency: Frequency,\n\t\ttype: OscillatorType,\n\t);\n\tconstructor(options?: Partial<ToneOscillatorNodeOptions>);\n\tconstructor() {\n\n\t\tsuper(optionsFromArguments(ToneOscillatorNode.getDefaults(), arguments, [\"frequency\", \"type\"]));\n\t\tconst options = optionsFromArguments(ToneOscillatorNode.getDefaults(), arguments, [\"frequency\", \"type\"]);\n\n\t\tconnect(this._oscillator, this._gainNode);\n\n\t\tthis.type = options.type;\n\n\t\tthis.frequency = new Param({\n\t\t\tcontext: this.context,\n\t\t\tparam: this._oscillator.frequency,\n\t\t\tunits: \"frequency\",\n\t\t\tvalue: options.frequency,\n\t\t});\n\n\t\tthis.detune = new Param({\n\t\t\tcontext: this.context,\n\t\t\tparam: this._oscillator.detune,\n\t\t\tunits: \"cents\",\n\t\t\tvalue: options.detune,\n\t\t});\n\n\t\treadOnly(this, [\"frequency\", \"detune\"]);\n\t}\n\n\tstatic getDefaults(): ToneOscillatorNodeOptions {\n\t\treturn Object.assign(OneShotSource.getDefaults(), {\n\t\t\tdetune: 0,\n\t\t\tfrequency: 440,\n\t\t\ttype: \"sine\" as OscillatorType,\n\t\t});\n\t}\n\n\t/**\n\t * Start the oscillator node at the given time\n\t * @param  time When to start the oscillator\n\t */\n\tstart(time?: Time): this {\n\t\tconst computedTime = this.toSeconds(time);\n\t\tthis.log(\"start\", computedTime);\n\t\tthis._startGain(computedTime);\n\t\tthis._oscillator.start(computedTime);\n\t\treturn this;\n\t}\n\n\tprotected _stopSource(time?: Seconds): void {\n\t\tthis._oscillator.stop(time);\n\t}\n\n\t/**\n\t * Sets an arbitrary custom periodic waveform given a PeriodicWave.\n\t * @param  periodicWave PeriodicWave should be created with context.createPeriodicWave\n\t */\n\tsetPeriodicWave(periodicWave: PeriodicWave): this {\n\t\tthis._oscillator.setPeriodicWave(periodicWave);\n\t\treturn this;\n\t}\n\n\t/**\n\t * The oscillator type. Either 'sine', 'sawtooth', 'square', or 'triangle'\n\t */\n\tget type(): OscillatorType {\n\t\treturn this._oscillator.type;\n\t}\n\tset type(type: OscillatorType) {\n\t\tthis._oscillator.type = type;\n\t}\n\n\t/**\n\t * Clean up.\n\t */\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tif (this.state === \"started\") {\n\t\t\tthis.stop();\n\t\t}\n\t\tthis._oscillator.disconnect();\n\t\tthis.frequency.dispose();\n\t\tthis.detune.dispose();\n\t\treturn this;\n\t}\n}\n","import { AudioRange, Degrees, Frequency, Radians, Time } from \"../../core/type/Units\";\nimport { deepEquals, optionsFromArguments } from \"../../core/util/Defaults\";\nimport { readOnly } from \"../../core/util/Interface\";\nimport { isDefined } from \"../../core/util/TypeCheck\";\nimport { Signal } from \"../../signal/Signal\";\nimport { Source } from \"../Source\";\nimport {\n\tgenerateWaveform, ToneOscillatorConstructorOptions, ToneOscillatorInterface,\n\tToneOscillatorOptions, ToneOscillatorType\n} from \"./OscillatorInterface\";\nimport { ToneOscillatorNode } from \"./ToneOscillatorNode\";\nimport { assertRange } from \"../../core/util/Debug\";\nimport { clamp } from \"../../core/util/Math\";\nexport { ToneOscillatorOptions, ToneOscillatorType } from \"./OscillatorInterface\";\n/**\n * Oscillator supports a number of features including\n * phase rotation, multiple oscillator types (see Oscillator.type),\n * and Transport syncing (see Oscillator.syncFrequency).\n *\n * @example\n * // make and start a 440hz sine tone\n * const osc = new Tone.Oscillator(440, \"sine\").toDestination().start();\n * @category Source\n */\nexport class Oscillator extends Source<ToneOscillatorOptions> implements ToneOscillatorInterface {\n\n\treadonly name: string = \"Oscillator\";\n\n\t/**\n\t * the main oscillator\n\t */\n\tprivate _oscillator: ToneOscillatorNode | null = null;\n\n\t/**\n\t * The frequency control.\n\t */\n\tfrequency: Signal<\"frequency\">;\n\n\t/**\n\t * The detune control signal.\n\t */\n\tdetune: Signal<\"cents\">;\n\n\t/**\n\t * the periodic wave\n\t */\n\tprivate _wave?: PeriodicWave;\n\n\t/**\n\t * The partials of the oscillator\n\t */\n\tprivate _partials: number[];\n\n\t/**\n\t * The number of partials to limit or extend the periodic wave by\n\t */\n\tprivate _partialCount: number;\n\n\t/**\n\t * the phase of the oscillator between 0 - 360\n\t */\n\tprivate _phase!: Radians;\n\n\t/**\n\t * the type of the oscillator\n\t */\n\tprivate _type: ToneOscillatorType;\n\n\t/**\n\t * @param frequency Starting frequency\n\t * @param type The oscillator type. Read more about type below.\n\t */\n\tconstructor(frequency?: Frequency, type?: ToneOscillatorType);\n\tconstructor(options?: Partial<ToneOscillatorConstructorOptions>)\n\tconstructor() {\n\n\t\tsuper(optionsFromArguments(Oscillator.getDefaults(), arguments, [\"frequency\", \"type\"]));\n\t\tconst options = optionsFromArguments(Oscillator.getDefaults(), arguments, [\"frequency\", \"type\"]);\n\n\t\tthis.frequency = new Signal<\"frequency\">({\n\t\t\tcontext: this.context,\n\t\t\tunits: \"frequency\",\n\t\t\tvalue: options.frequency,\n\t\t});\n\t\treadOnly(this, \"frequency\");\n\n\t\tthis.detune = new Signal<\"cents\">({\n\t\t\tcontext: this.context,\n\t\t\tunits: \"cents\",\n\t\t\tvalue: options.detune,\n\t\t});\n\t\treadOnly(this, \"detune\");\n\n\t\tthis._partials = options.partials;\n\t\tthis._partialCount = options.partialCount;\n\t\tthis._type = options.type;\n\n\t\tif (options.partialCount && options.type !== \"custom\") {\n\t\t\tthis._type = this.baseType + options.partialCount.toString() as ToneOscillatorType;\n\t\t}\n\t\tthis.phase = options.phase;\n\t}\n\n\tstatic getDefaults(): ToneOscillatorOptions {\n\t\treturn Object.assign(Source.getDefaults(), {\n\t\t\tdetune: 0,\n\t\t\tfrequency: 440,\n\t\t\tpartialCount: 0,\n\t\t\tpartials: [],\n\t\t\tphase: 0,\n\t\t\ttype: \"sine\" as const,\n\t\t});\n\t}\n\n\t/**\n\t * start the oscillator\n\t */\n\tprotected _start(time?: Time): void {\n\t\tconst computedTime = this.toSeconds(time);\n\t\t// new oscillator with previous values\n\t\tconst oscillator = new ToneOscillatorNode({\n\t\t\tcontext: this.context,\n\t\t\tonended: () => this.onstop(this),\n\t\t});\n\t\tthis._oscillator = oscillator;\n\t\tif (this._wave) {\n\t\t\tthis._oscillator.setPeriodicWave(this._wave);\n\t\t} else {\n\t\t\tthis._oscillator.type = this._type as OscillatorType;\n\t\t}\n\t\t// connect the control signal to the oscillator frequency & detune\n\t\tthis._oscillator.connect(this.output);\n\t\tthis.frequency.connect(this._oscillator.frequency);\n\t\tthis.detune.connect(this._oscillator.detune);\n\n\t\t// start the oscillator\n\t\tthis._oscillator.start(computedTime);\n\t}\n\n\t/**\n\t * stop the oscillator\n\t */\n\tprotected _stop(time?: Time): void {\n\t\tconst computedTime = this.toSeconds(time);\n\t\tif (this._oscillator) {\n\t\t\tthis._oscillator.stop(computedTime);\n\t\t}\n\t}\n\n\t/**\n\t * Restart the oscillator. Does not stop the oscillator, but instead\n\t * just cancels any scheduled 'stop' from being invoked.\n\t */\n\tprotected _restart(time?: Time): this {\n\t\tconst computedTime = this.toSeconds(time);\n\t\tthis.log(\"restart\", computedTime);\n\t\tif (this._oscillator) {\n\t\t\tthis._oscillator.cancelStop();\n\t\t}\n\t\tthis._state.cancel(computedTime);\n\t\treturn this;\n\t}\n\n\t/**\n\t * Sync the signal to the Transport's bpm. Any changes to the transports bpm,\n\t * will also affect the oscillators frequency.\n\t * @example\n\t * const osc = new Tone.Oscillator().toDestination().start();\n\t * osc.frequency.value = 440;\n\t * // the ratio between the bpm and the frequency will be maintained\n\t * osc.syncFrequency();\n\t * // double the tempo\n\t * Tone.Transport.bpm.value *= 2;\n\t * // the frequency of the oscillator is doubled to 880\n\t */\n\tsyncFrequency(): this {\n\t\tthis.context.transport.syncSignal(this.frequency);\n\t\treturn this;\n\t}\n\n\t/**\n\t * Unsync the oscillator's frequency from the Transport.\n\t * See Oscillator.syncFrequency\n\t */\n\tunsyncFrequency(): this {\n\t\tthis.context.transport.unsyncSignal(this.frequency);\n\t\treturn this;\n\t}\n\n\t/**\n\t * Cache the periodic waves to avoid having to redo computations\n\t */\n\tprivate static _periodicWaveCache: Array<{\n\t\tpartials: number[];\n\t\tphase: number;\n\t\ttype: string;\n\t\tpartialCount: number;\n\t\treal: Float32Array;\n\t\timag: Float32Array;\n\t\twave: PeriodicWave;\n\t}> = [];\n\n\t/**\n\t * Get a cached periodic wave. Avoids having to recompute\n\t * the oscillator values when they have already been computed\n\t * with the same values.\n\t */\n\tprivate _getCachedPeriodicWave(): { real: Float32Array; imag: Float32Array; partials: number[]; wave: PeriodicWave } | undefined {\n\t\tif (this._type === \"custom\") {\n\t\t\tconst oscProps = Oscillator._periodicWaveCache.find(description => {\n\t\t\t\treturn description.phase === this._phase &&\n\t\t\t\t\tdeepEquals(description.partials, this._partials);\n\t\t\t});\n\t\t\treturn oscProps;\n\t\t} else {\n\t\t\tconst oscProps = Oscillator._periodicWaveCache.find(description => {\n\t\t\t\treturn description.type === this._type &&\n\t\t\t\t\tdescription.phase === this._phase;\n\t\t\t});\n\t\t\tthis._partialCount = oscProps ? oscProps.partialCount : this._partialCount;\n\t\t\treturn oscProps;\n\t\t}\n\t}\n\n\tget type(): ToneOscillatorType {\n\t\treturn this._type;\n\t}\n\tset type(type) {\n\t\tthis._type = type;\n\t\tconst isBasicType = [\"sine\", \"square\", \"sawtooth\", \"triangle\"].indexOf(type) !== -1;\n\t\tif (this._phase === 0 && isBasicType) {\n\t\t\tthis._wave = undefined;\n\t\t\tthis._partialCount = 0;\n\t\t\t// just go with the basic approach\n\t\t\tif (this._oscillator !== null) {\n\t\t\t\t// already tested that it's a basic type\n\t\t\t\tthis._oscillator.type = type as OscillatorType;\n\t\t\t}\n\t\t} else {\n\t\t\t// first check if the value is cached\n\t\t\tconst cache = this._getCachedPeriodicWave();\n\t\t\tif (isDefined(cache)) {\n\t\t\t\tconst { partials, wave } = cache;\n\t\t\t\tthis._wave = wave;\n\t\t\t\tthis._partials = partials;\n\t\t\t\tif (this._oscillator !== null) {\n\t\t\t\t\tthis._oscillator.setPeriodicWave(this._wave);\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tconst [real, imag] = this._getRealImaginary(type, this._phase);\n\t\t\t\tconst periodicWave = this.context.createPeriodicWave(real, imag);\n\t\t\t\tthis._wave = periodicWave;\n\t\t\t\tif (this._oscillator !== null) {\n\t\t\t\t\tthis._oscillator.setPeriodicWave(this._wave);\n\t\t\t\t}\n\t\t\t\t// set the cache\n\t\t\t\tOscillator._periodicWaveCache.push({\n\t\t\t\t\timag,\n\t\t\t\t\tpartialCount: this._partialCount,\n\t\t\t\t\tpartials: this._partials,\n\t\t\t\t\tphase: this._phase,\n\t\t\t\t\treal,\n\t\t\t\t\ttype: this._type,\n\t\t\t\t\twave: this._wave,\n\t\t\t\t});\n\t\t\t\tif (Oscillator._periodicWaveCache.length > 100) {\n\t\t\t\t\tOscillator._periodicWaveCache.shift();\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\tget baseType(): OscillatorType {\n\t\treturn (this._type as string).replace(this.partialCount.toString(), \"\") as OscillatorType;\n\t}\n\tset baseType(baseType) {\n\t\tif (this.partialCount && this._type !== \"custom\" && baseType !== \"custom\") {\n\t\t\tthis.type = baseType + this.partialCount as ToneOscillatorType;\n\t\t} else {\n\t\t\tthis.type = baseType;\n\t\t}\n\t}\n\n\tget partialCount(): number {\n\t\treturn this._partialCount;\n\t}\n\tset partialCount(p) {\n\t\tassertRange(p, 0);\n\t\tlet type = this._type;\n\t\tconst partial = /^(sine|triangle|square|sawtooth)(\\d+)$/.exec(this._type);\n\t\tif (partial) {\n\t\t\ttype = partial[1] as OscillatorType;\n\t\t}\n\t\tif (this._type !== \"custom\") {\n\t\t\tif (p === 0) {\n\t\t\t\tthis.type = type;\n\t\t\t} else {\n\t\t\t\tthis.type = type + p.toString() as ToneOscillatorType;\n\t\t\t}\n\t\t} else {\n\t\t\t// extend or shorten the partials array\n\t\t\tconst fullPartials = new Float32Array(p);\n\t\t\t// copy over the partials array\n\t\t\tthis._partials.forEach((v, i) => fullPartials[i] = v);\n\t\t\tthis._partials = Array.from(fullPartials);\n\t\t\tthis.type = this._type;\n\t\t}\n\t}\n\n\t/**\n\t * Returns the real and imaginary components based\n\t * on the oscillator type.\n\t * @returns [real: Float32Array, imaginary: Float32Array]\n\t */\n\tprivate _getRealImaginary(type: ToneOscillatorType, phase: Radians): Float32Array[] {\n\t\tconst fftSize = 4096;\n\t\tlet periodicWaveSize = fftSize / 2;\n\n\t\tconst real = new Float32Array(periodicWaveSize);\n\t\tconst imag = new Float32Array(periodicWaveSize);\n\n\t\tlet partialCount = 1;\n\t\tif (type === \"custom\") {\n\t\t\tpartialCount = this._partials.length + 1;\n\t\t\tthis._partialCount = this._partials.length;\n\t\t\tperiodicWaveSize = partialCount;\n\t\t\t// if the partial count is 0, don't bother doing any computation\n\t\t\tif (this._partials.length === 0) {\n\t\t\t\treturn [real, imag];\n\t\t\t}\n\t\t} else {\n\t\t\tconst partial = /^(sine|triangle|square|sawtooth)(\\d+)$/.exec(type);\n\t\t\tif (partial) {\n\t\t\t\tpartialCount = parseInt(partial[2], 10) + 1;\n\t\t\t\tthis._partialCount = parseInt(partial[2], 10);\n\t\t\t\ttype = partial[1] as ToneOscillatorType;\n\t\t\t\tpartialCount = Math.max(partialCount, 2);\n\t\t\t\tperiodicWaveSize = partialCount;\n\t\t\t} else {\n\t\t\t\tthis._partialCount = 0;\n\t\t\t}\n\t\t\tthis._partials = [];\n\t\t}\n\n\t\tfor (let n = 1; n < periodicWaveSize; ++n) {\n\t\t\tconst piFactor = 2 / (n * Math.PI);\n\t\t\tlet b;\n\t\t\tswitch (type) {\n\t\t\t\tcase \"sine\":\n\t\t\t\t\tb = (n <= partialCount) ? 1 : 0;\n\t\t\t\t\tthis._partials[n - 1] = b;\n\t\t\t\t\tbreak;\n\t\t\t\tcase \"square\":\n\t\t\t\t\tb = (n & 1) ? 2 * piFactor : 0;\n\t\t\t\t\tthis._partials[n - 1] = b;\n\t\t\t\t\tbreak;\n\t\t\t\tcase \"sawtooth\":\n\t\t\t\t\tb = piFactor * ((n & 1) ? 1 : -1);\n\t\t\t\t\tthis._partials[n - 1] = b;\n\t\t\t\t\tbreak;\n\t\t\t\tcase \"triangle\":\n\t\t\t\t\tif (n & 1) {\n\t\t\t\t\t\tb = 2 * (piFactor * piFactor) * ((((n - 1) >> 1) & 1) ? -1 : 1);\n\t\t\t\t\t} else {\n\t\t\t\t\t\tb = 0;\n\t\t\t\t\t}\n\t\t\t\t\tthis._partials[n - 1] = b;\n\t\t\t\t\tbreak;\n\t\t\t\tcase \"custom\":\n\t\t\t\t\tb = this._partials[n - 1];\n\t\t\t\t\tbreak;\n\t\t\t\tdefault:\n\t\t\t\t\tthrow new TypeError(\"Oscillator: invalid type: \" + type);\n\t\t\t}\n\t\t\tif (b !== 0) {\n\t\t\t\treal[n] = -b * Math.sin(phase * n);\n\t\t\t\timag[n] = b * Math.cos(phase * n);\n\t\t\t} else {\n\t\t\t\treal[n] = 0;\n\t\t\t\timag[n] = 0;\n\t\t\t}\n\t\t}\n\t\treturn [real, imag];\n\t}\n\n\t/**\n\t * Compute the inverse FFT for a given phase.\n\t */\n\tprivate _inverseFFT(real: Float32Array, imag: Float32Array, phase: Radians): number {\n\t\tlet sum = 0;\n\t\tconst len = real.length;\n\t\tfor (let i = 0; i < len; i++) {\n\t\t\tsum += real[i] * Math.cos(i * phase) + imag[i] * Math.sin(i * phase);\n\t\t}\n\t\treturn sum;\n\t}\n\n\t/**\n\t * Returns the initial value of the oscillator when stopped.\n\t * E.g. a \"sine\" oscillator with phase = 90 would return an initial value of -1.\n\t */\n\tgetInitialValue(): AudioRange {\n\t\tconst [real, imag] = this._getRealImaginary(this._type, 0);\n\t\tlet maxValue = 0;\n\t\tconst twoPi = Math.PI * 2;\n\t\tconst testPositions = 32;\n\t\t// check for peaks in 16 places\n\t\tfor (let i = 0; i < testPositions; i++) {\n\t\t\tmaxValue = Math.max(this._inverseFFT(real, imag, (i / testPositions) * twoPi), maxValue);\n\t\t}\n\t\treturn clamp(-this._inverseFFT(real, imag, this._phase) / maxValue, -1, 1);\n\t}\n\n\tget partials(): number[] {\n\t\treturn this._partials.slice(0, this.partialCount);\n\t}\n\tset partials(partials) {\n\t\tthis._partials = partials;\n\t\tthis._partialCount = this._partials.length;\n\t\tif (partials.length) {\n\t\t\tthis.type = \"custom\";\n\t\t}\n\t}\n\n\tget phase(): Degrees {\n\t\treturn this._phase * (180 / Math.PI);\n\t}\n\tset phase(phase) {\n\t\tthis._phase = phase * Math.PI / 180;\n\t\t// reset the type\n\t\tthis.type = this._type;\n\t}\n\n\tasync asArray(length = 1024): Promise<Float32Array> {\n\t\treturn generateWaveform(this, length);\n\t}\n\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tif (this._oscillator !== null) {\n\t\t\tthis._oscillator.dispose();\n\t\t}\n\t\tthis._wave = undefined;\n\t\tthis.frequency.dispose();\n\t\tthis.detune.dispose();\n\t\treturn this;\n\t}\n}\n","import { optionsFromArguments } from \"../core/util/Defaults\";\nimport { InputNode, ToneAudioNode, ToneAudioNodeOptions } from \"../core/context/ToneAudioNode\";\nimport { connectSignal } from \"./Signal\";\n\nexport type SignalOperatorOptions = ToneAudioNodeOptions;\n\n/**\n * A signal operator has an input and output and modifies the signal.\n */\nexport abstract class SignalOperator<Options extends SignalOperatorOptions> extends ToneAudioNode<Options> {\n\n\tconstructor(options?: Partial<Options>);\n\tconstructor() {\n\t\tsuper(Object.assign(optionsFromArguments(SignalOperator.getDefaults(), arguments, [\"context\"])));\n\t}\n\n\tconnect(destination: InputNode, outputNum = 0, inputNum = 0): this {\n\t\tconnectSignal(this, destination, outputNum, inputNum);\n\t\treturn this;\n\t}\n}\n","import { ToneAudioNodeOptions } from \"../core/context/ToneAudioNode\";\nimport { optionsFromArguments } from \"../core/util/Defaults\";\nimport { isArray, isFunction } from \"../core/util/TypeCheck\";\nimport { assert } from \"../core/util/Debug\";\nimport { Signal } from \"./Signal\";\nimport { SignalOperator } from \"./SignalOperator\";\n\nexport type WaveShaperMappingFn = (value: number, index?: number) => number;\n\ntype WaveShaperMapping = WaveShaperMappingFn | number[] | Float32Array;\n\ninterface WaveShaperOptions extends ToneAudioNodeOptions {\n\tmapping?: WaveShaperMapping;\n\tlength: number;\n\tcurve?: number[] | Float32Array;\n}\n\n/**\n * Wraps the native Web Audio API\n * [WaveShaperNode](http://webaudio.github.io/web-audio-api/#the-waveshapernode-interface).\n *\n * @example\n * const osc = new Tone.Oscillator().toDestination().start();\n * // multiply the output of the signal by 2 using the waveshaper's function\n * const timesTwo = new Tone.WaveShaper((val) => val * 2, 2048).connect(osc.frequency);\n * const signal = new Tone.Signal(440).connect(timesTwo);\n * @category Signal\n */\nexport class WaveShaper extends SignalOperator<WaveShaperOptions> {\n\n\treadonly name: string = \"WaveShaper\";\n\n\t/**\n\t * the waveshaper node\n\t */\n\tprivate _shaper: WaveShaperNode = this.context.createWaveShaper();\n\n\t/**\n\t * The input to the waveshaper node.\n\t */\n\tinput = this._shaper;\n\n\t/**\n\t * The output from the waveshaper node\n\t */\n\toutput = this._shaper;\n\n\t/**\n\t * @param mapping The function used to define the values.\n\t *                The mapping function should take two arguments:\n\t *                the first is the value at the current position\n\t *                and the second is the array position.\n\t *                If the argument is an array, that array will be\n\t *                set as the wave shaping function. The input\n\t *                signal is an AudioRange [-1, 1] value and the output\n\t *                signal can take on any numerical values.\n\t *\n\t * @param bufferLen The length of the WaveShaperNode buffer.\n\t */\n\tconstructor(mapping?: WaveShaperMapping, length?: number);\n\tconstructor(options?: Partial<WaveShaperOptions>);\n\tconstructor() {\n\t\tsuper(Object.assign(optionsFromArguments(WaveShaper.getDefaults(), arguments, [\"mapping\", \"length\"])));\n\t\tconst options = optionsFromArguments(WaveShaper.getDefaults(), arguments, [\"mapping\", \"length\"]);\n\n\t\tif (isArray(options.mapping) || options.mapping instanceof Float32Array) {\n\t\t\tthis.curve = Float32Array.from(options.mapping);\n\t\t} else if (isFunction(options.mapping)) {\n\t\t\tthis.setMap(options.mapping, options.length);\n\t\t}\n\t}\n\n\tstatic getDefaults(): WaveShaperOptions {\n\t\treturn Object.assign(Signal.getDefaults(), {\n\t\t\tlength: 1024,\n\t\t});\n\t}\n\n\t/**\n\t * Uses a mapping function to set the value of the curve.\n\t * @param mapping The function used to define the values.\n\t *                The mapping function take two arguments:\n\t *                the first is the value at the current position\n\t *                which goes from -1 to 1 over the number of elements\n\t *                in the curve array. The second argument is the array position.\n\t * @example\n\t * const shaper = new Tone.WaveShaper();\n\t * // map the input signal from [-1, 1] to [0, 10]\n\t * shaper.setMap((val, index) => (val + 1) * 5);\n\t */\n\tsetMap(mapping: WaveShaperMappingFn, length = 1024): this {\n\t\tconst array = new Float32Array(length);\n\t\tfor (let i = 0, len = length; i < len; i++) {\n\t\t\tconst normalized = (i / (len - 1)) * 2 - 1;\n\t\t\tarray[i] = mapping(normalized, i);\n\t\t}\n\t\tthis.curve = array;\n\t\treturn this;\n\t}\n\n\t/**\n\t * The array to set as the waveshaper curve. For linear curves\n\t * array length does not make much difference, but for complex curves\n\t * longer arrays will provide smoother interpolation.\n\t */\n\tget curve(): Float32Array | null {\n\t\treturn this._shaper.curve;\n\t}\n\n\tset curve(mapping: Float32Array | null) {\n\t\tthis._shaper.curve = mapping;\n\t}\n\n\t/**\n\t * Specifies what type of oversampling (if any) should be used when\n\t * applying the shaping curve. Can either be \"none\", \"2x\" or \"4x\".\n\t */\n\tget oversample(): OverSampleType {\n\t\treturn this._shaper.oversample;\n\t}\n\n\tset oversample(oversampling: OverSampleType) {\n\t\tconst isOverSampleType = [\"none\", \"2x\", \"4x\"].some(str => str.includes(oversampling));\n\t\tassert(isOverSampleType, \"oversampling must be either 'none', '2x', or '4x'\");\n\t\tthis._shaper.oversample = oversampling;\n\t}\n\n\t/**\n\t * Clean up.\n\t */\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis._shaper.disconnect();\n\t\treturn this;\n\t}\n}\n","import { ToneAudioNodeOptions } from \"../core/context/ToneAudioNode\";\nimport { SignalOperator } from \"./SignalOperator\";\nimport { WaveShaper } from \"./WaveShaper\";\n\n/**\n * AudioToGain converts an input in AudioRange [-1,1] to NormalRange [0,1].\n * See [[GainToAudio]].\n * @category Signal\n */\nexport class AudioToGain extends SignalOperator<ToneAudioNodeOptions> {\n\n\treadonly name: string = \"AudioToGain\";\n\n\t/**\n\t * The node which converts the audio ranges\n\t */\n\tprivate _norm = new WaveShaper({\n\t\tcontext: this.context,\n\t\tmapping: x => (x + 1) / 2,\n\t});\n\n\t/**\n\t * The AudioRange input [-1, 1]\n\t */\n\tinput = this._norm;\n\n\t/**\n\t * The GainRange output [0, 1]\n\t */\n\toutput = this._norm;\n\n\t/**\n\t * clean up\n\t */\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis._norm.dispose();\n\t\treturn this;\n\t}\n}\n","import { Gain } from \"../core/context/Gain\";\nimport { Param } from \"../core/context/Param\";\nimport { optionsFromArguments } from \"../core/util/Defaults\";\nimport { Signal, SignalOptions } from \"./Signal\";\nimport { InputNode, OutputNode } from \"../core/context/ToneAudioNode\";\n\n/**\n * Multiply two incoming signals. Or, if a number is given in the constructor,\n * multiplies the incoming signal by that value.\n *\n * @example\n * // multiply two signals\n * const mult = new Tone.Multiply();\n * const sigA = new Tone.Signal(3);\n * const sigB = new Tone.Signal(4);\n * sigA.connect(mult);\n * sigB.connect(mult.factor);\n * // output of mult is 12.\n * @example\n * // multiply a signal and a number\n * const mult = new Tone.Multiply(10);\n * const sig = new Tone.Signal(2).connect(mult);\n * // the output of mult is 20.\n * @category Signal\n */\nexport class Multiply<TypeName extends \"number\" | \"positive\" = \"number\"> extends Signal<TypeName> {\n\n\treadonly name: string = \"Multiply\";\n\n\t/**\n\t * Indicates if the value should be overridden on connection\n\t */\n\treadonly override = false;\n\n\t/**\n\t * the input gain node\n\t */\n\tprivate _mult: Gain;\n\n\t/**\n\t * The multiplicand input.\n\t */\n\tinput: InputNode;\n\n\t/**\n\t * The product of the input and [[factor]]\n\t */\n\toutput: OutputNode;\n\n\t/**\n\t * The multiplication factor. Can be set directly or a signal can be connected to it.\n\t */\n\tfactor: Param<TypeName>;\n\n\t/**\n\t * @param value Constant value to multiple\n\t */\n\tconstructor(value?: number);\n\tconstructor(options?: Partial<SignalOptions<TypeName>>);\n\tconstructor() {\n\t\tsuper(Object.assign(optionsFromArguments(Multiply.getDefaults(), arguments, [\"value\"])));\n\t\tconst options = optionsFromArguments(Multiply.getDefaults(), arguments, [\"value\"]);\n\n\t\tthis._mult = this.input = this.output = new Gain({\n\t\t\tcontext: this.context,\n\t\t\tminValue: options.minValue,\n\t\t\tmaxValue: options.maxValue,\n\t\t});\n\n\t\tthis.factor = this._param = this._mult.gain as unknown as Param<TypeName>;\n\t\tthis.factor.setValueAtTime(options.value, 0);\n\t}\n\n\tstatic getDefaults(): SignalOptions<any> {\n\t\treturn Object.assign(Signal.getDefaults(), {\n\t\t\tvalue: 0,\n\t\t});\n\t}\n\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis._mult.dispose();\n\t\treturn this;\n\t}\n}\n","import { Gain } from \"../../core/context/Gain\";\nimport { Degrees, Frequency, Seconds } from \"../../core/type/Units\";\nimport { optionsFromArguments } from \"../../core/util/Defaults\";\nimport { readOnly } from \"../../core/util/Interface\";\nimport { AudioToGain } from \"../../signal/AudioToGain\";\nimport { Multiply } from \"../../signal/Multiply\";\nimport { Signal } from \"../../signal/Signal\";\nimport { Source } from \"../Source\";\nimport { Oscillator } from \"./Oscillator\";\nimport {\n\tAMConstructorOptions, AMOscillatorOptions,\n\tgenerateWaveform, NonCustomOscillatorType,\n\tToneOscillatorInterface,\n\tToneOscillatorType\n} from \"./OscillatorInterface\";\n\nexport { AMOscillatorOptions } from \"./OscillatorInterface\";\n\n/**\n * An amplitude modulated oscillator node. It is implemented with\n * two oscillators, one which modulators the other's amplitude\n * through a gain node.\n * ```\n *    +-------------+       +----------+\n *    | Carrier Osc +>------> GainNode |\n *    +-------------+       |          +--->Output\n *                      +---> gain     |\n * +---------------+    |   +----------+\n * | Modulator Osc +>---+\n * +---------------+\n * ```\n * @example\n * return Tone.Offline(() => {\n * \tconst amOsc = new Tone.AMOscillator(30, \"sine\", \"square\").toDestination().start();\n * }, 0.2, 1);\n * @category Source\n */\nexport class AMOscillator extends Source<AMOscillatorOptions> implements ToneOscillatorInterface {\n\n\treadonly name: string = \"AMOscillator\";\n\n\t/**\n\t * The carrier oscillator\n\t */\n\tprivate _carrier: Oscillator;\n\n\treadonly frequency: Signal<\"frequency\">;\n\treadonly detune: Signal<\"cents\">;\n\n\t/**\n\t * The modulating oscillator\n\t */\n\tprivate _modulator: Oscillator;\n\n\t/**\n\t * convert the -1,1 output to 0,1\n\t */\n\tprivate _modulationScale = new AudioToGain({ context: this.context });\n\n\t/**\n\t * Harmonicity is the frequency ratio between the carrier and the modulator oscillators.\n\t * A harmonicity of 1 gives both oscillators the same frequency.\n\t * Harmonicity = 2 means a change of an octave.\n\t * @example\n\t * const amOsc = new Tone.AMOscillator(\"D2\").toDestination().start();\n\t * Tone.Transport.scheduleRepeat(time => {\n\t * \tamOsc.harmonicity.setValueAtTime(1, time);\n\t * \tamOsc.harmonicity.setValueAtTime(0.5, time + 0.5);\n\t * \tamOsc.harmonicity.setValueAtTime(1.5, time + 1);\n\t * \tamOsc.harmonicity.setValueAtTime(1, time + 2);\n\t * \tamOsc.harmonicity.linearRampToValueAtTime(2, time + 4);\n\t * }, 4);\n\t * Tone.Transport.start();\n\t */\n\treadonly harmonicity: Signal<\"positive\">;\n\n\t/**\n\t * the node where the modulation happens\n\t */\n\tprivate _modulationNode = new Gain({\n\t\tcontext: this.context,\n\t});\n\n\t/**\n\t * @param frequency The starting frequency of the oscillator.\n\t * @param type The type of the carrier oscillator.\n\t * @param modulationType The type of the modulator oscillator.\n\t */\n\tconstructor(frequency?: Frequency, type?: ToneOscillatorType, modulationType?: ToneOscillatorType);\n\tconstructor(options?: Partial<AMConstructorOptions>);\n\tconstructor() {\n\n\t\tsuper(optionsFromArguments(AMOscillator.getDefaults(), arguments, [\"frequency\", \"type\", \"modulationType\"]));\n\t\tconst options = optionsFromArguments(AMOscillator.getDefaults(), arguments, [\"frequency\", \"type\", \"modulationType\"]);\n\n\t\tthis._carrier = new Oscillator({\n\t\t\tcontext: this.context,\n\t\t\tdetune: options.detune,\n\t\t\tfrequency: options.frequency,\n\t\t\tonstop: () => this.onstop(this),\n\t\t\tphase: options.phase,\n\t\t\ttype: options.type,\n\t\t} as OscillatorOptions);\n\t\tthis.frequency = this._carrier.frequency,\n\t\tthis.detune = this._carrier.detune;\n\n\t\tthis._modulator = new Oscillator({\n\t\t\tcontext: this.context,\n\t\t\tphase: options.phase,\n\t\t\ttype: options.modulationType,\n\t\t} as OscillatorOptions);\n\n\t\tthis.harmonicity = new Multiply({\n\t\t\tcontext: this.context,\n\t\t\tunits: \"positive\",\n\t\t\tvalue: options.harmonicity,\n\t\t});\n\n\t\t// connections\n\t\tthis.frequency.chain(this.harmonicity, this._modulator.frequency);\n\t\tthis._modulator.chain(this._modulationScale, this._modulationNode.gain);\n\t\tthis._carrier.chain(this._modulationNode, this.output);\n\n\t\treadOnly(this, [\"frequency\", \"detune\", \"harmonicity\"]);\n\t}\n\n\tstatic getDefaults(): AMOscillatorOptions {\n\t\treturn Object.assign(Oscillator.getDefaults(), {\n\t\t\tharmonicity: 1,\n\t\t\tmodulationType: \"square\" as NonCustomOscillatorType,\n\t\t});\n\t}\n\n\t/**\n\t * start the oscillator\n\t */\n\tprotected _start(time: Seconds): void {\n\t\tthis._modulator.start(time);\n\t\tthis._carrier.start(time);\n\t}\n\n\t/**\n\t * stop the oscillator\n\t */\n\tprotected _stop(time: Seconds): void {\n\t\tthis._modulator.stop(time);\n\t\tthis._carrier.stop(time);\n\t}\n\n\tprotected _restart(time: Seconds): void {\n\t\tthis._modulator.restart(time);\n\t\tthis._carrier.restart(time);\n\t}\n\n\t/**\n\t * The type of the carrier oscillator\n\t */\n\tget type(): ToneOscillatorType {\n\t\treturn this._carrier.type;\n\t}\n\tset type(type: ToneOscillatorType) {\n\t\tthis._carrier.type = type;\n\t}\n\n\tget baseType(): OscillatorType {\n\t\treturn this._carrier.baseType;\n\t}\n\tset baseType(baseType: OscillatorType) {\n\t\tthis._carrier.baseType = baseType;\n\t}\n\n\tget partialCount(): number {\n\t\treturn this._carrier.partialCount;\n\t}\n\tset partialCount(partialCount: number) {\n\t\tthis._carrier.partialCount = partialCount;\n\t}\n\n\t/**\n\t * The type of the modulator oscillator\n\t */\n\tget modulationType(): ToneOscillatorType {\n\t\treturn this._modulator.type;\n\t}\n\tset modulationType(type: ToneOscillatorType) {\n\t\tthis._modulator.type = type;\n\t}\n\n\tget phase(): Degrees {\n\t\treturn this._carrier.phase;\n\t}\n\tset phase(phase: Degrees) {\n\t\tthis._carrier.phase = phase;\n\t\tthis._modulator.phase = phase;\n\t}\n\n\tget partials(): number[] {\n\t\treturn this._carrier.partials;\n\t}\n\tset partials(partials: number[]) {\n\t\tthis._carrier.partials = partials;\n\t}\n\n\tasync asArray(length = 1024): Promise<Float32Array> {\n\t\treturn generateWaveform(this, length);\n\t}\n\n\t/**\n\t * Clean up.\n\t */\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis.frequency.dispose();\n\t\tthis.detune.dispose();\n\t\tthis.harmonicity.dispose();\n\t\tthis._carrier.dispose();\n\t\tthis._modulator.dispose();\n\t\tthis._modulationNode.dispose();\n\t\tthis._modulationScale.dispose();\n\t\treturn this;\n\t}\n}\n","import { Gain } from \"../../core/context/Gain\";\nimport { Degrees, Frequency, Seconds, Time } from \"../../core/type/Units\";\nimport { optionsFromArguments } from \"../../core/util/Defaults\";\nimport { readOnly } from \"../../core/util/Interface\";\nimport { Multiply } from \"../../signal/Multiply\";\nimport { Signal } from \"../../signal/Signal\";\nimport { Source } from \"../Source\";\nimport { Oscillator } from \"./Oscillator\";\nimport {\n\tFMConstructorOptions, FMOscillatorOptions,\n\tgenerateWaveform, NonCustomOscillatorType, ToneOscillatorInterface, ToneOscillatorType\n} from \"./OscillatorInterface\";\n\nexport { FMOscillatorOptions } from \"./OscillatorInterface\";\n/**\n * FMOscillator implements a frequency modulation synthesis\n * ```\n *                                              +-------------+\n * +---------------+        +-------------+     | Carrier Osc |\n * | Modulator Osc +>-------> GainNode    |     |             +--->Output\n * +---------------+        |             +>----> frequency   |\n *                       +--> gain        |     +-------------+\n *                       |  +-------------+\n * +-----------------+   |\n * | modulationIndex +>--+\n * +-----------------+\n * ```\n *\n * @example\n * return Tone.Offline(() => {\n * \tconst fmOsc = new Tone.FMOscillator({\n * \t\tfrequency: 200,\n * \t\ttype: \"square\",\n * \t\tmodulationType: \"triangle\",\n * \t\tharmonicity: 0.2,\n * \t\tmodulationIndex: 3\n * \t}).toDestination().start();\n * }, 0.1, 1);\n * @category Source\n */\nexport class FMOscillator extends Source<FMOscillatorOptions> implements ToneOscillatorInterface {\n\n\treadonly name: string = \"FMOscillator\";\n\n\t/**\n\t * The carrier oscillator\n\t */\n\tprivate _carrier: Oscillator;\n\n\treadonly frequency: Signal<\"frequency\">;\n\treadonly detune: Signal<\"cents\">;\n\n\t/**\n\t * The modulating oscillator\n\t */\n\tprivate _modulator: Oscillator;\n\n\t/**\n\t * Harmonicity is the frequency ratio between the carrier and the modulator oscillators.\n\t * A harmonicity of 1 gives both oscillators the same frequency.\n\t * Harmonicity = 2 means a change of an octave.\n\t * @example\n\t * const fmOsc = new Tone.FMOscillator(\"D2\").toDestination().start();\n\t * // pitch the modulator an octave below carrier\n\t * fmOsc.harmonicity.value = 0.5;\n\t */\n\treadonly harmonicity: Signal<\"positive\">;\n\n\t/**\n\t * The modulation index which is in essence the depth or amount of the modulation. In other terms it is the\n\t * ratio of the frequency of the modulating signal (mf) to the amplitude of the\n\t * modulating signal (ma) -- as in ma/mf.\n\t */\n\treadonly modulationIndex: Signal<\"positive\">;\n\n\t/**\n\t * the node where the modulation happens\n\t */\n\tprivate _modulationNode: Gain = new Gain({\n\t\tcontext: this.context,\n\t\tgain: 0,\n\t});\n\n\t/**\n\t * @param frequency The starting frequency of the oscillator.\n\t * @param type The type of the carrier oscillator.\n\t * @param modulationType The type of the modulator oscillator.\n\t */\n\tconstructor(frequency?: Frequency, type?: ToneOscillatorType, modulationType?: ToneOscillatorType);\n\tconstructor(options?: Partial<FMConstructorOptions>);\n\tconstructor() {\n\n\t\tsuper(optionsFromArguments(FMOscillator.getDefaults(), arguments, [\"frequency\", \"type\", \"modulationType\"]));\n\t\tconst options = optionsFromArguments(FMOscillator.getDefaults(), arguments, [\"frequency\", \"type\", \"modulationType\"]);\n\n\t\tthis._carrier = new Oscillator({\n\t\t\tcontext: this.context,\n\t\t\tdetune: options.detune,\n\t\t\tfrequency: 0,\n\t\t\tonstop: () => this.onstop(this),\n\t\t\tphase: options.phase,\n\t\t\ttype: options.type,\n\t\t} as OscillatorOptions);\n\n\t\tthis.detune = this._carrier.detune;\n\n\t\tthis.frequency = new Signal({\n\t\t\tcontext: this.context,\n\t\t\tunits: \"frequency\",\n\t\t\tvalue: options.frequency,\n\t\t});\n\n\t\tthis._modulator = new Oscillator({\n\t\t\tcontext: this.context,\n\t\t\tphase: options.phase,\n\t\t\ttype: options.modulationType,\n\t\t} as OscillatorOptions);\n\n\t\tthis.harmonicity = new Multiply({\n\t\t\tcontext: this.context,\n\t\t\tunits: \"positive\",\n\t\t\tvalue: options.harmonicity,\n\t\t});\n\n\t\tthis.modulationIndex = new Multiply({\n\t\t\tcontext: this.context,\n\t\t\tunits: \"positive\",\n\t\t\tvalue: options.modulationIndex,\n\t\t});\n\n\t\t// connections\n\t\tthis.frequency.connect(this._carrier.frequency);\n\t\tthis.frequency.chain(this.harmonicity, this._modulator.frequency);\n\t\tthis.frequency.chain(this.modulationIndex, this._modulationNode);\n\t\tthis._modulator.connect(this._modulationNode.gain);\n\t\tthis._modulationNode.connect(this._carrier.frequency);\n\t\tthis._carrier.connect(this.output);\n\t\tthis.detune.connect(this._modulator.detune);\n\n\t\treadOnly(this, [\"modulationIndex\", \"frequency\", \"detune\", \"harmonicity\"]);\n\t}\n\n\tstatic getDefaults(): FMOscillatorOptions {\n\t\treturn Object.assign(Oscillator.getDefaults(), {\n\t\t\tharmonicity: 1,\n\t\t\tmodulationIndex: 2,\n\t\t\tmodulationType: \"square\" as NonCustomOscillatorType,\n\t\t});\n\t}\n\n\t/**\n\t * start the oscillator\n\t */\n\tprotected _start(time: Time): void {\n\t\tthis._modulator.start(time);\n\t\tthis._carrier.start(time);\n\t}\n\n\t/**\n\t * stop the oscillator\n\t */\n\tprotected _stop(time: Time): void {\n\t\tthis._modulator.stop(time);\n\t\tthis._carrier.stop(time);\n\t}\n\n\tprotected _restart(time: Seconds): this {\n\t\tthis._modulator.restart(time);\n\t\tthis._carrier.restart(time);\n\t\treturn this;\n\t}\n\n\tget type(): ToneOscillatorType {\n\t\treturn this._carrier.type;\n\t}\n\tset type(type: ToneOscillatorType) {\n\t\tthis._carrier.type = type;\n\t}\n\n\tget baseType(): OscillatorType {\n\t\treturn this._carrier.baseType;\n\t}\n\tset baseType(baseType: OscillatorType) {\n\t\tthis._carrier.baseType = baseType;\n\t}\n\n\tget partialCount(): number {\n\t\treturn this._carrier.partialCount;\n\t}\n\tset partialCount(partialCount: number) {\n\t\tthis._carrier.partialCount = partialCount;\n\t}\n\n\t/**\n\t * The type of the modulator oscillator\n\t */\n\tget modulationType(): ToneOscillatorType {\n\t\treturn this._modulator.type;\n\t}\n\tset modulationType(type: ToneOscillatorType) {\n\t\tthis._modulator.type = type;\n\t}\n\n\tget phase(): Degrees {\n\t\treturn this._carrier.phase;\n\t}\n\tset phase(phase: Degrees) {\n\t\tthis._carrier.phase = phase;\n\t\tthis._modulator.phase = phase;\n\t}\n\n\tget partials(): number[] {\n\t\treturn this._carrier.partials;\n\t}\n\tset partials(partials: number[]) {\n\t\tthis._carrier.partials = partials;\n\t}\n\n\tasync asArray(length = 1024): Promise<Float32Array> {\n\t\treturn generateWaveform(this, length);\n\t}\n\n\t/**\n\t * Clean up.\n\t */\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis.frequency.dispose();\n\t\tthis.harmonicity.dispose();\n\t\tthis._carrier.dispose();\n\t\tthis._modulator.dispose();\n\t\tthis._modulationNode.dispose();\n\t\tthis.modulationIndex.dispose();\n\t\treturn this;\n\t}\n}\n","import { Gain } from \"../../core/context/Gain\";\nimport { AudioRange, Degrees, Frequency, Seconds, Time } from \"../../core/type/Units\";\nimport { optionsFromArguments } from \"../../core/util/Defaults\";\nimport { readOnly } from \"../../core/util/Interface\";\nimport { Signal } from \"../../signal/Signal\";\nimport { WaveShaper } from \"../../signal/WaveShaper\";\nimport { Source } from \"../Source\";\nimport { Oscillator } from \"./Oscillator\";\nimport { generateWaveform, PulseOscillatorOptions, ToneOscillatorInterface } from \"./OscillatorInterface\";\n\nexport { PulseOscillatorOptions } from \"./OscillatorInterface\";\n\n/**\n * PulseOscillator is an oscillator with control over pulse width,\n * also known as the duty cycle. At 50% duty cycle (width = 0) the wave is\n * a square wave.\n * [Read more](https://wigglewave.wordpress.com/2014/08/16/pulse-waveforms-and-harmonics/).\n * ```\n *    width = -0.25        width = 0.0          width = 0.25\n *\n *   +-----+            +-------+       +    +-------+     +-+\n *   |     |            |       |       |            |     |\n *   |     |            |       |       |            |     |\n * +-+     +-------+    +       +-------+            +-----+\n *\n *\n *    width = -0.5                              width = 0.5\n *\n *     +---+                                 +-------+   +---+\n *     |   |                                         |   |\n *     |   |                                         |   |\n * +---+   +-------+                                 +---+\n *\n *\n *    width = -0.75                             width = 0.75\n *\n *       +-+                                 +-------+ +-----+\n *       | |                                         | |\n *       | |                                         | |\n * +-----+ +-------+                                 +-+\n * ```\n * @example\n * return Tone.Offline(() => {\n * \tconst pulse = new Tone.PulseOscillator(50, 0.4).toDestination().start();\n * }, 0.1, 1);\n * @category Source\n */\nexport class PulseOscillator extends Source<PulseOscillatorOptions> implements ToneOscillatorInterface {\n\n\treadonly name: string = \"PulseOscillator\";\n\n\t/**\n\t * The width of the pulse.\n\t * @example\n\t * return Tone.Offline(() => {\n\t * \tconst pulse = new Tone.PulseOscillator(20, 0.8).toDestination().start();\n\t * }, 0.1, 1);\n\t */\n\treadonly width: Signal<\"audioRange\">;\n\n\t/**\n\t * gate the width amount\n\t */\n\tprivate _widthGate: Gain = new Gain({\n\t\tcontext: this.context,\n\t\tgain: 0,\n\t});\n\n\t/**\n\t * the sawtooth oscillator\n\t */\n\tprivate _triangle: Oscillator;\n\n\t/**\n\t * The frequency control.\n\t */\n\treadonly frequency: Signal<\"frequency\">;\n\n\t/**\n\t * The detune in cents.\n\t */\n\treadonly detune: Signal<\"cents\">;\n\n\t/**\n\t * Threshold the signal to turn it into a square\n\t */\n\tprivate _thresh = new WaveShaper({\n\t\tcontext: this.context,\n\t\tmapping: val => val <= 0 ? -1 : 1,\n\t});\n\n\t/**\n\t * @param frequency The frequency of the oscillator\n\t * @param width The width of the pulse\n\t */\n\tconstructor(frequency?: Frequency, width?: AudioRange);\n\tconstructor(options?: Partial<PulseOscillatorOptions>);\n\tconstructor() {\n\n\t\tsuper(optionsFromArguments(PulseOscillator.getDefaults(), arguments, [\"frequency\", \"width\"]));\n\t\tconst options = optionsFromArguments(PulseOscillator.getDefaults(), arguments, [\"frequency\", \"width\"]);\n\n\t\tthis.width = new Signal({\n\t\t\tcontext: this.context,\n\t\t\tunits: \"audioRange\",\n\t\t\tvalue: options.width,\n\t\t});\n\n\t\tthis._triangle = new Oscillator({\n\t\t\tcontext: this.context,\n\t\t\tdetune: options.detune,\n\t\t\tfrequency: options.frequency,\n\t\t\tonstop: () => this.onstop(this),\n\t\t\tphase: options.phase,\n\t\t\ttype: \"triangle\",\n\t\t});\n\t\tthis.frequency = this._triangle.frequency;\n\t\tthis.detune = this._triangle.detune;\n\n\t\t// connections\n\t\tthis._triangle.chain(this._thresh, this.output);\n\t\tthis.width.chain(this._widthGate, this._thresh);\n\t\treadOnly(this, [\"width\", \"frequency\", \"detune\"]);\n\t}\n\n\tstatic getDefaults(): PulseOscillatorOptions {\n\t\treturn Object.assign(Source.getDefaults(), {\n\t\t\tdetune: 0,\n\t\t\tfrequency: 440,\n\t\t\tphase: 0,\n\t\t\ttype: \"pulse\" as const,\n\t\t\twidth: 0.2,\n\t\t});\n\t}\n\n\t/**\n\t * start the oscillator\n\t */\n\tprotected _start(time: Time): void {\n\t\ttime = this.toSeconds(time);\n\t\tthis._triangle.start(time);\n\t\tthis._widthGate.gain.setValueAtTime(1, time);\n\t}\n\n\t/**\n\t * stop the oscillator\n\t */\n\tprotected _stop(time: Time): void {\n\t\ttime = this.toSeconds(time);\n\t\tthis._triangle.stop(time);\n\t\t// the width is still connected to the output.\n\t\t// that needs to be stopped also\n\t\tthis._widthGate.gain.cancelScheduledValues(time);\n\t\tthis._widthGate.gain.setValueAtTime(0, time);\n\t}\n\n\tprotected _restart(time: Seconds): void {\n\t\tthis._triangle.restart(time);\n\t\tthis._widthGate.gain.cancelScheduledValues(time);\n\t\tthis._widthGate.gain.setValueAtTime(1, time);\n\t}\n\n\t/**\n\t * The phase of the oscillator in degrees.\n\t */\n\tget phase(): Degrees {\n\t\treturn this._triangle.phase;\n\t}\n\tset phase(phase: Degrees) {\n\t\tthis._triangle.phase = phase;\n\t}\n\n\t/**\n\t * The type of the oscillator. Always returns \"pulse\".\n\t */\n\tget type(): \"pulse\" {\n\t\treturn \"pulse\";\n\t}\n\n\t/**\n\t * The baseType of the oscillator. Always returns \"pulse\".\n\t */\n\tget baseType(): \"pulse\" {\n\t\treturn \"pulse\";\n\t}\n\n\t/**\n\t * The partials of the waveform. Cannot set partials for this waveform type\n\t */\n\tget partials(): number[] {\n\t\treturn [];\n\t}\n\n\t/**\n\t * No partials for this waveform type.\n\t */\n\tget partialCount(): number {\n\t\treturn 0;\n\t}\n\n\t/**\n\t * *Internal use* The carrier oscillator type is fed through the \n\t * waveshaper node to create the pulse. Using different carrier oscillators\n\t * changes oscillator's behavior. \n\t */\n\tset carrierType(type: \"triangle\" | \"sine\") {\n\t\tthis._triangle.type = type;\n\t}\n\n\tasync asArray(length = 1024): Promise<Float32Array> {\n\t\treturn generateWaveform(this, length);\n\t}\n\n\t/**\n\t * Clean up method.\n\t */\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis._triangle.dispose();\n\t\tthis.width.dispose();\n\t\tthis._widthGate.dispose();\n\t\tthis._thresh.dispose();\n\t\treturn this;\n\t}\n}\n","import { Cents, Degrees, Frequency, Seconds, Time } from \"../../core/type/Units\";\nimport { optionsFromArguments } from \"../../core/util/Defaults\";\nimport { noOp, readOnly } from \"../../core/util/Interface\";\nimport { Signal } from \"../../signal/Signal\";\nimport { Source } from \"../Source\";\nimport { Oscillator } from \"./Oscillator\";\nimport {\n\tFatConstructorOptions, FatOscillatorOptions,\n\tgenerateWaveform, NonCustomOscillatorType, ToneOscillatorInterface, ToneOscillatorType\n} from \"./OscillatorInterface\";\nimport { assertRange } from \"../../core/util/Debug\";\n\nexport { FatOscillatorOptions } from \"./OscillatorInterface\";\n\n/**\n * FatOscillator is an array of oscillators with detune spread between the oscillators\n * @example\n * const fatOsc = new Tone.FatOscillator(\"Ab3\", \"sawtooth\", 40).toDestination().start();\n * @category Source\n */\nexport class FatOscillator extends Source<FatOscillatorOptions> implements ToneOscillatorInterface {\n\n\treadonly name: string = \"FatOscillator\";\n\n\treadonly frequency: Signal<\"frequency\">;\n\treadonly detune: Signal<\"cents\">;\n\n\t/**\n\t * The array of oscillators\n\t */\n\tprivate _oscillators: Oscillator[] = [];\n\n\t/**\n\t * The total spread of the oscillators\n\t */\n\tprivate _spread: Cents;\n\n\t/**\n\t * The type of the oscillator\n\t */\n\tprivate _type: ToneOscillatorType;\n\n\t/**\n\t * The phase of the oscillators\n\t */\n\tprivate _phase: Degrees;\n\n\t/**\n\t * The partials array\n\t */\n\tprivate _partials: number[];\n\n\t/**\n\t * The number of partials to use\n\t */\n\tprivate _partialCount: number;\n\n\t/**\n\t * @param frequency The oscillator's frequency.\n\t * @param type The type of the oscillator.\n\t * @param spread The detune spread between the oscillators.\n\t */\n\tconstructor(frequency?: Frequency, type?: ToneOscillatorType, spread?: Cents);\n\tconstructor(options?: Partial<FatConstructorOptions>);\n\tconstructor() {\n\n\t\tsuper(optionsFromArguments(FatOscillator.getDefaults(), arguments, [\"frequency\", \"type\", \"spread\"]));\n\t\tconst options = optionsFromArguments(FatOscillator.getDefaults(), arguments, [\"frequency\", \"type\", \"spread\"]);\n\n\t\tthis.frequency = new Signal({\n\t\t\tcontext: this.context,\n\t\t\tunits: \"frequency\",\n\t\t\tvalue: options.frequency,\n\t\t});\n\t\tthis.detune = new Signal({\n\t\t\tcontext: this.context,\n\t\t\tunits: \"cents\",\n\t\t\tvalue: options.detune,\n\t\t});\n\n\t\tthis._spread = options.spread;\n\t\tthis._type = options.type;\n\t\tthis._phase = options.phase;\n\t\tthis._partials = options.partials;\n\t\tthis._partialCount = options.partialCount;\n\n\t\t// set the count initially\n\t\tthis.count = options.count;\n\n\t\treadOnly(this, [\"frequency\", \"detune\"]);\n\t}\n\n\tstatic getDefaults(): FatOscillatorOptions {\n\t\treturn Object.assign(Oscillator.getDefaults(), {\n\t\t\tcount: 3,\n\t\t\tspread: 20,\n\t\t\ttype: \"sawtooth\",\n\t\t});\n\t}\n\n\t/**\n\t * start the oscillator\n\t */\n\tprotected _start(time: Time): void {\n\t\ttime = this.toSeconds(time);\n\t\tthis._forEach(osc => osc.start(time));\n\t}\n\n\t/**\n\t * stop the oscillator\n\t */\n\tprotected _stop(time: Time): void {\n\t\ttime = this.toSeconds(time);\n\t\tthis._forEach(osc => osc.stop(time));\n\t}\n\n\tprotected _restart(time: Seconds): void {\n\t\tthis._forEach(osc => osc.restart(time));\n\t}\n\n\t/**\n\t * Iterate over all of the oscillators\n\t */\n\tprivate _forEach(iterator: (osc: Oscillator, index: number) => void): void {\n\t\tfor (let i = 0; i < this._oscillators.length; i++) {\n\t\t\titerator(this._oscillators[i], i);\n\t\t}\n\t}\n\n\t/**\n\t * The type of the oscillator\n\t */\n\tget type(): ToneOscillatorType {\n\t\treturn this._type;\n\t}\n\tset type(type: ToneOscillatorType) {\n\t\tthis._type = type;\n\t\tthis._forEach(osc => osc.type = type);\n\t}\n\n\t/**\n\t * The detune spread between the oscillators. If \"count\" is\n\t * set to 3 oscillators and the \"spread\" is set to 40,\n\t * the three oscillators would be detuned like this: [-20, 0, 20]\n\t * for a total detune spread of 40 cents.\n\t * @example\n\t * const fatOsc = new Tone.FatOscillator().toDestination().start();\n\t * fatOsc.spread = 70;\n\t */\n\tget spread(): Cents {\n\t\treturn this._spread;\n\t}\n\tset spread(spread: Cents) {\n\t\tthis._spread = spread;\n\t\tif (this._oscillators.length > 1) {\n\t\t\tconst start = -spread / 2;\n\t\t\tconst step = spread / (this._oscillators.length - 1);\n\t\t\tthis._forEach((osc, i) => osc.detune.value = start + step * i);\n\t\t}\n\t}\n\n\t/**\n\t * The number of detuned oscillators. Must be an integer greater than 1.\n\t * @example\n\t * const fatOsc = new Tone.FatOscillator(\"C#3\", \"sawtooth\").toDestination().start();\n\t * // use 4 sawtooth oscillators\n\t * fatOsc.count = 4;\n\t */\n\tget count(): number {\n\t\treturn this._oscillators.length;\n\t}\n\tset count(count: number) {\n\t\tassertRange(count, 1);\n\t\tif (this._oscillators.length !== count) {\n\t\t\t// dispose the previous oscillators\n\t\t\tthis._forEach(osc => osc.dispose());\n\t\t\tthis._oscillators = [];\n\t\t\tfor (let i = 0; i < count; i++) {\n\t\t\t\tconst osc = new Oscillator({\n\t\t\t\t\tcontext: this.context,\n\t\t\t\t\tvolume: -6 - count * 1.1,\n\t\t\t\t\ttype: this._type as NonCustomOscillatorType,\n\t\t\t\t\tphase: this._phase + (i / count) * 360,\n\t\t\t\t\tpartialCount: this._partialCount,\n\t\t\t\t\tonstop: i === 0 ? () => this.onstop(this) : noOp,\n\t\t\t\t});\n\t\t\t\tif (this.type === \"custom\") {\n\t\t\t\t\tosc.partials = this._partials;\n\t\t\t\t}\n\t\t\t\tthis.frequency.connect(osc.frequency);\n\t\t\t\tthis.detune.connect(osc.detune);\n\t\t\t\tosc.detune.overridden = false;\n\t\t\t\tosc.connect(this.output);\n\t\t\t\tthis._oscillators[i] = osc;\n\t\t\t}\n\t\t\t// set the spread\n\t\t\tthis.spread = this._spread;\n\t\t\tif (this.state === \"started\") {\n\t\t\t\tthis._forEach(osc => osc.start());\n\t\t\t}\n\t\t}\n\t}\n\n\tget phase(): Degrees {\n\t\treturn this._phase;\n\t}\n\tset phase(phase: Degrees) {\n\t\tthis._phase = phase;\n\t\tthis._forEach((osc, i) => osc.phase = this._phase + (i / this.count) * 360);\n\t}\n\n\tget baseType(): OscillatorType {\n\t\treturn this._oscillators[0].baseType;\n\t}\n\tset baseType(baseType: OscillatorType) {\n\t\tthis._forEach(osc => osc.baseType = baseType);\n\t\tthis._type = this._oscillators[0].type;\n\t}\n\n\tget partials(): number[] {\n\t\treturn this._oscillators[0].partials;\n\t}\n\tset partials(partials: number[]) {\n\t\tthis._partials = partials;\n\t\tthis._partialCount = this._partials.length;\n\t\tif (partials.length) {\n\t\t\tthis._type = \"custom\";\n\t\t\tthis._forEach(osc => osc.partials = partials);\n\t\t}\n\t}\n\n\tget partialCount(): number {\n\t\treturn this._oscillators[0].partialCount;\n\t}\n\tset partialCount(partialCount: number) {\n\t\tthis._partialCount = partialCount;\n\t\tthis._forEach(osc => osc.partialCount = partialCount);\n\t\tthis._type = this._oscillators[0].type;\n\t}\n\n\tasync asArray(length = 1024): Promise<Float32Array> {\n\t\treturn generateWaveform(this, length);\n\t}\n\n\t/**\n\t * Clean up.\n\t */\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis.frequency.dispose();\n\t\tthis.detune.dispose();\n\t\tthis._forEach(osc => osc.dispose());\n\t\treturn this;\n\t}\n}\n","import { Degrees, Frequency, Seconds, Time } from \"../../core/type/Units\";\nimport { optionsFromArguments } from \"../../core/util/Defaults\";\nimport { readOnly } from \"../../core/util/Interface\";\nimport { Multiply } from \"../../signal/Multiply\";\nimport { Signal } from \"../../signal/Signal\";\nimport { Source } from \"../Source\";\nimport { Oscillator } from \"./Oscillator\";\nimport { generateWaveform, PWMOscillatorOptions, ToneOscillatorInterface } from \"./OscillatorInterface\";\nimport { PulseOscillator } from \"./PulseOscillator\";\n\nexport { PWMOscillatorOptions } from \"./OscillatorInterface\";\n\n/**\n * PWMOscillator modulates the width of a Tone.PulseOscillator\n * at the modulationFrequency. This has the effect of continuously\n * changing the timbre of the oscillator by altering the harmonics\n * generated.\n * @example\n * return Tone.Offline(() => {\n * \tconst pwm = new Tone.PWMOscillator(60, 0.3).toDestination().start();\n * }, 0.1, 1);\n * @category Source\n */\nexport class PWMOscillator extends Source<PWMOscillatorOptions> implements ToneOscillatorInterface {\n\n\treadonly name: string = \"PWMOscillator\";\n\n\treadonly sourceType = \"pwm\";\n\n\t/**\n\t * the pulse oscillator\n\t */\n\tprivate _pulse: PulseOscillator;\n\t/**\n\t * the modulator\n\t */\n\tprivate _modulator: Oscillator;\n\n\t/**\n\t * Scale the oscillator so it doesn't go silent\n\t * at the extreme values.\n\t */\n\tprivate _scale: Multiply = new Multiply({\n\t\tcontext: this.context,\n\t\tvalue: 2,\n\t});\n\n\t/**\n\t * The frequency control.\n\t */\n\treadonly frequency: Signal<\"frequency\">;\n\n\t/**\n\t * The detune of the oscillator.\n\t */\n\treadonly detune: Signal<\"cents\">;\n\n\t/**\n\t * The width modulation rate of the oscillator.\n\t * @example\n\t * return Tone.Offline(() => {\n\t * \tconst osc = new Tone.PWMOscillator(20, 2).toDestination().start();\n\t * }, 0.1, 1);\n\t */\n\treadonly modulationFrequency: Signal<\"frequency\">;\n\n\t/**\n\t * @param {Frequency} frequency The starting frequency of the oscillator.\n\t * @param {Frequency} modulationFrequency The modulation frequency of the width of the pulse.\n\t */\n\tconstructor(frequency?: Frequency, modulationFrequency?: Frequency);\n\tconstructor(options?: Partial<PWMOscillatorOptions>);\n\tconstructor() {\n\t\tsuper(optionsFromArguments(PWMOscillator.getDefaults(), arguments, [\"frequency\", \"modulationFrequency\"]));\n\t\tconst options = optionsFromArguments(PWMOscillator.getDefaults(), arguments, [\"frequency\", \"modulationFrequency\"]);\n\n\t\tthis._pulse = new PulseOscillator({\n\t\t\tcontext: this.context,\n\t\t\tfrequency: options.modulationFrequency,\n\t\t});\n\t\t// change the pulse oscillator type\n\t\tthis._pulse.carrierType = \"sine\";\n\n\t\tthis.modulationFrequency = this._pulse.frequency;\n\n\t\tthis._modulator = new Oscillator({\n\t\t\tcontext: this.context,\n\t\t\tdetune: options.detune,\n\t\t\tfrequency: options.frequency,\n\t\t\tonstop: () => this.onstop(this),\n\t\t\tphase: options.phase,\n\t\t});\n\n\t\tthis.frequency = this._modulator.frequency;\n\t\tthis.detune = this._modulator.detune;\n\n\t\t// connections\n\t\tthis._modulator.chain(this._scale, this._pulse.width);\n\t\tthis._pulse.connect(this.output);\n\t\treadOnly(this, [\"modulationFrequency\", \"frequency\", \"detune\"]);\n\t}\n\n\tstatic getDefaults(): PWMOscillatorOptions {\n\t\treturn Object.assign(Source.getDefaults(), {\n\t\t\tdetune: 0,\n\t\t\tfrequency: 440,\n\t\t\tmodulationFrequency: 0.4,\n\t\t\tphase: 0,\n\t\t\ttype: \"pwm\" as const,\n\t\t});\n\t}\n\t/**\n\t * start the oscillator\n\t */\n\tprotected _start(time: Time): void {\n\t\ttime = this.toSeconds(time);\n\t\tthis._modulator.start(time);\n\t\tthis._pulse.start(time);\n\t}\n\n\t/**\n\t * stop the oscillator\n\t */\n\tprotected _stop(time: Time): void {\n\t\ttime = this.toSeconds(time);\n\t\tthis._modulator.stop(time);\n\t\tthis._pulse.stop(time);\n\t}\n\n\t/**\n\t * restart the oscillator\n\t */\n\tprotected _restart(time: Seconds): void {\n\t\tthis._modulator.restart(time);\n\t\tthis._pulse.restart(time);\n\t}\n\n\t/**\n\t * The type of the oscillator. Always returns \"pwm\".\n\t */\n\tget type(): \"pwm\" {\n\t\treturn \"pwm\";\n\t}\n\n\t/**\n\t * The baseType of the oscillator. Always returns \"pwm\".\n\t */\n\tget baseType(): \"pwm\" {\n\t\treturn \"pwm\";\n\t}\n\n\t/**\n\t * The partials of the waveform. Cannot set partials for this waveform type\n\t */\n\tget partials(): number[] {\n\t\treturn [];\n\t}\n\n\t/**\n\t * No partials for this waveform type.\n\t */\n\tget partialCount(): number {\n\t\treturn 0;\n\t}\n\n\t/**\n\t * The phase of the oscillator in degrees.\n\t */\n\tget phase(): Degrees {\n\t\treturn this._modulator.phase;\n\t}\n\tset phase(phase: Degrees) {\n\t\tthis._modulator.phase = phase;\n\t}\n\n\tasync asArray(length = 1024): Promise<Float32Array> {\n\t\treturn generateWaveform(this, length);\n\t}\n\n\t/**\n\t * Clean up.\n\t */\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis._pulse.dispose();\n\t\tthis._scale.dispose();\n\t\tthis._modulator.dispose();\n\t\treturn this;\n\t}\n}\n","import { Cents, Degrees, Frequency, Seconds, Time } from \"../../core/type/Units\";\nimport { optionsFromArguments } from \"../../core/util/Defaults\";\nimport { readOnly } from \"../../core/util/Interface\";\nimport { isNumber, isString } from \"../../core/util/TypeCheck\";\nimport { Signal } from \"../../signal/Signal\";\nimport { Source } from \"../Source\";\nimport { AMOscillator } from \"./AMOscillator\";\nimport { FatOscillator } from \"./FatOscillator\";\nimport { FMOscillator } from \"./FMOscillator\";\nimport { Oscillator } from \"./Oscillator\";\nimport {\n\tgenerateWaveform,\n\tOmniOscillatorOptions, \n\tOmniOscillatorType, ToneOscillatorInterface, ToneOscillatorType\n} from \"./OscillatorInterface\";\nimport { PulseOscillator } from \"./PulseOscillator\";\nimport { PWMOscillator } from \"./PWMOscillator\";\n\nexport { OmniOscillatorOptions } from \"./OscillatorInterface\";\n\n/**\n * All of the oscillator types that OmniOscillator can take on\n */\ntype AnyOscillator = Oscillator | PWMOscillator | PulseOscillator | FatOscillator | AMOscillator | FMOscillator;\n\n/**\n * All of the Oscillator constructor types mapped to their name.\n */\ninterface OmniOscillatorSource {\n\t\"fm\": FMOscillator;\n\t\"am\": AMOscillator;\n\t\"pwm\": PWMOscillator;\n\t\"pulse\": PulseOscillator;\n\t\"oscillator\": Oscillator;\n\t\"fat\": FatOscillator;\n}\n\n/**\n * The available oscillator types.\n */\nexport type OmniOscSourceType = keyof OmniOscillatorSource;\n\n// Conditional Types\ntype IsAmOrFmOscillator<Osc, Ret> = Osc extends AMOscillator ? Ret : Osc extends FMOscillator ? Ret : undefined;\ntype IsFatOscillator<Osc, Ret> = Osc extends FatOscillator ? Ret : undefined;\ntype IsPWMOscillator<Osc, Ret> = Osc extends PWMOscillator ? Ret : undefined;\ntype IsPulseOscillator<Osc, Ret> = Osc extends PulseOscillator ? Ret : undefined;\ntype IsFMOscillator<Osc, Ret> = Osc extends FMOscillator ? Ret : undefined;\n\ntype AnyOscillatorConstructor = new (...args: any[]) => AnyOscillator;\n\nconst OmniOscillatorSourceMap: {\n\t[key in OmniOscSourceType]: AnyOscillatorConstructor\n} = {\n\tam: AMOscillator,\n\tfat: FatOscillator,\n\tfm: FMOscillator,\n\toscillator: Oscillator,\n\tpulse: PulseOscillator,\n\tpwm: PWMOscillator,\n};\n\n/**\n * OmniOscillator aggregates all of the oscillator types into one. \n * @example\n * return Tone.Offline(() => {\n * \tconst omniOsc = new Tone.OmniOscillator(\"C#4\", \"pwm\").toDestination().start();\n * }, 0.1, 1);\n * @category Source\n */\nexport class OmniOscillator<OscType extends AnyOscillator>\n\textends Source<OmniOscillatorOptions>\n\timplements Omit<ToneOscillatorInterface, \"type\"> {\n\n\treadonly name: string = \"OmniOscillator\";\n\n\treadonly frequency: Signal<\"frequency\">;\n\treadonly detune: Signal<\"cents\">;\n\n\t/**\n\t * The oscillator that can switch types\n\t */\n\tprivate _oscillator!: AnyOscillator;\n\n\t/**\n\t * the type of the oscillator source\n\t */\n\tprivate _sourceType!: OmniOscSourceType;\n\n\t/**\n\t * @param frequency The initial frequency of the oscillator.\n\t * @param type The type of the oscillator.\n\t */\n\tconstructor(frequency?: Frequency, type?: OmniOscillatorType);\n\tconstructor(options?: Partial<OmniOscillatorOptions>);\n\tconstructor() {\n\n\t\tsuper(optionsFromArguments(OmniOscillator.getDefaults(), arguments, [\"frequency\", \"type\"]));\n\t\tconst options = optionsFromArguments(OmniOscillator.getDefaults(), arguments, [\"frequency\", \"type\"]);\n\n\t\tthis.frequency = new Signal({\n\t\t\tcontext: this.context,\n\t\t\tunits: \"frequency\",\n\t\t\tvalue: options.frequency,\n\t\t});\n\t\tthis.detune = new Signal({\n\t\t\tcontext: this.context,\n\t\t\tunits: \"cents\",\n\t\t\tvalue: options.detune,\n\t\t});\n\t\treadOnly(this, [\"frequency\", \"detune\"]);\n\n\t\t// set the options\n\t\tthis.set(options);\n\t}\n\n\tstatic getDefaults(): OmniOscillatorOptions {\n\t\treturn Object.assign(\n\t\t\tOscillator.getDefaults(),\n\t\t\tFMOscillator.getDefaults(),\n\t\t\tAMOscillator.getDefaults(),\n\t\t\tFatOscillator.getDefaults(),\n\t\t\tPulseOscillator.getDefaults(),\n\t\t\tPWMOscillator.getDefaults(),\n\t\t);\n\t}\n\n\t/**\n\t * start the oscillator\n\t */\n\tprotected _start(time: Time): void {\n\t\tthis._oscillator.start(time);\n\t}\n\n\t/**\n\t * start the oscillator\n\t */\n\tprotected _stop(time: Time): void {\n\t\tthis._oscillator.stop(time);\n\t}\n\n\tprotected _restart(time: Seconds): this {\n\t\tthis._oscillator.restart(time);\n\t\treturn this;\n\t}\n\n\t/**\n\t * The type of the oscillator. Can be any of the basic types: sine, square, triangle, sawtooth. Or\n\t * prefix the basic types with \"fm\", \"am\", or \"fat\" to use the FMOscillator, AMOscillator or FatOscillator\n\t * types. The oscillator could also be set to \"pwm\" or \"pulse\". All of the parameters of the\n\t * oscillator's class are accessible when the oscillator is set to that type, but throws an error\n\t * when it's not. \n\t * @example\n\t * const omniOsc = new Tone.OmniOscillator().toDestination().start();\n\t * omniOsc.type = \"pwm\";\n\t * // modulationFrequency is parameter which is available\n\t * // only when the type is \"pwm\".\n\t * omniOsc.modulationFrequency.value = 0.5;\n\t */\n\tget type(): OmniOscillatorType {\n\t\tlet prefix = \"\";\n\t\tif ([\"am\", \"fm\", \"fat\"].some(p => this._sourceType === p)) {\n\t\t\tprefix = this._sourceType;\n\t\t}\n\t\treturn prefix + this._oscillator.type as OmniOscillatorType;\n\t}\n\tset type(type) {\n\t\tif (type.substr(0, 2) === \"fm\") {\n\t\t\tthis._createNewOscillator(\"fm\");\n\t\t\tthis._oscillator = this._oscillator as FMOscillator;\n\t\t\tthis._oscillator.type = type.substr(2) as ToneOscillatorType;\n\t\t} else if (type.substr(0, 2) === \"am\") {\n\t\t\tthis._createNewOscillator(\"am\");\n\t\t\tthis._oscillator = this._oscillator as AMOscillator;\n\t\t\tthis._oscillator.type = type.substr(2) as ToneOscillatorType;\n\t\t} else if (type.substr(0, 3) === \"fat\") {\n\t\t\tthis._createNewOscillator(\"fat\");\n\t\t\tthis._oscillator = this._oscillator as FatOscillator;\n\t\t\tthis._oscillator.type = type.substr(3) as ToneOscillatorType;\n\t\t} else if (type === \"pwm\") {\n\t\t\tthis._createNewOscillator(\"pwm\");\n\t\t\tthis._oscillator = this._oscillator as PWMOscillator;\n\t\t} else if (type === \"pulse\") {\n\t\t\tthis._createNewOscillator(\"pulse\");\n\t\t} else {\n\t\t\tthis._createNewOscillator(\"oscillator\");\n\t\t\tthis._oscillator = this._oscillator as Oscillator;\n\t\t\tthis._oscillator.type = (type as ToneOscillatorType);\n\t\t}\n\t}\n\n\t/**\n\t * The value is an empty array when the type is not \"custom\".\n\t * This is not available on \"pwm\" and \"pulse\" oscillator types.\n\t * See [[Oscillator.partials]]\n\t */\n\tget partials(): number[] {\n\t\treturn this._oscillator.partials;\n\t}\n\tset partials(partials) {\n\t\tif (!this._getOscType(this._oscillator, \"pulse\") && !this._getOscType(this._oscillator, \"pwm\")) {\n\t\t\tthis._oscillator.partials = partials;\n\t\t}\n\t}\n\n\tget partialCount(): number {\n\t\treturn this._oscillator.partialCount;\n\t}\n\tset partialCount(partialCount) {\n\t\tif (!this._getOscType(this._oscillator, \"pulse\") && !this._getOscType(this._oscillator, \"pwm\")) {\n\t\t\tthis._oscillator.partialCount = partialCount;\n\t\t}\n\t}\n\n\tset(props: Partial<OmniOscillatorOptions>): this {\n\t\t// make sure the type is set first\n\t\tif (Reflect.has(props, \"type\") && props.type) {\n\t\t\tthis.type = props.type;\n\t\t}\n\t\t// then set the rest\n\t\tsuper.set(props);\n\t\treturn this;\n\t}\n\n\t/**\n\t * connect the oscillator to the frequency and detune signals\n\t */\n\tprivate _createNewOscillator(oscType: OmniOscSourceType): void {\n\t\tif (oscType !== this._sourceType) {\n\t\t\tthis._sourceType = oscType;\n\t\t\tconst OscConstructor = OmniOscillatorSourceMap[oscType];\n\t\t\t// short delay to avoid clicks on the change\n\t\t\tconst now = this.now();\n\t\t\tif (this._oscillator) {\n\t\t\t\tconst oldOsc = this._oscillator;\n\t\t\t\toldOsc.stop(now);\n\t\t\t\t// dispose the old one\n\t\t\t\tthis.context.setTimeout(() => oldOsc.dispose(), this.blockTime);\n\t\t\t}\n\t\t\tthis._oscillator = new OscConstructor({\n\t\t\t\tcontext: this.context,\n\t\t\t});\n\t\t\tthis.frequency.connect(this._oscillator.frequency);\n\t\t\tthis.detune.connect(this._oscillator.detune);\n\t\t\tthis._oscillator.connect(this.output);\n\t\t\tthis._oscillator.onstop = () => this.onstop(this);\n\t\t\tif (this.state === \"started\") {\n\t\t\t\tthis._oscillator.start(now);\n\t\t\t}\n\t\t}\n\t}\n\n\tget phase(): Degrees {\n\t\treturn this._oscillator.phase;\n\t}\n\tset phase(phase) {\n\t\tthis._oscillator.phase = phase;\n\t}\n\n\t/**\n\t * The source type of the oscillator.\n\t * @example\n\t * const omniOsc = new Tone.OmniOscillator(440, \"fmsquare\");\n\t * console.log(omniOsc.sourceType); // 'fm'\n\t */\n\tget sourceType(): OmniOscSourceType {\n\t\treturn this._sourceType;\n\t}\n\tset sourceType(sType) {\n\t\t// the basetype defaults to sine\n\t\tlet baseType = \"sine\";\n\t\tif (this._oscillator.type !== \"pwm\" && this._oscillator.type !== \"pulse\") {\n\t\t\tbaseType = this._oscillator.type;\n\t\t}\n\n\t\t// set the type\n\t\tif (sType === \"fm\") {\n\t\t\tthis.type = \"fm\" + baseType as OmniOscillatorType;\n\t\t} else if (sType === \"am\") {\n\t\t\tthis.type = \"am\" + baseType as OmniOscillatorType;\n\t\t} else if (sType === \"fat\") {\n\t\t\tthis.type = \"fat\" + baseType as OmniOscillatorType;\n\t\t} else if (sType === \"oscillator\") {\n\t\t\tthis.type = baseType as OmniOscillatorType;\n\t\t} else if (sType === \"pulse\") {\n\t\t\tthis.type = \"pulse\";\n\t\t} else if (sType === \"pwm\") {\n\t\t\tthis.type = \"pwm\";\n\t\t}\n\t}\n\n\tprivate _getOscType<SourceType extends OmniOscSourceType>(\n\t\tosc: AnyOscillator,\n\t\tsourceType: SourceType,\n\t): osc is OmniOscillatorSource[SourceType] {\n\t\treturn osc instanceof OmniOscillatorSourceMap[sourceType];\n\t}\n\n\t/**\n\t * The base type of the oscillator. See [[Oscillator.baseType]]\n\t * @example\n\t * const omniOsc = new Tone.OmniOscillator(440, \"fmsquare4\");\n\t * console.log(omniOsc.sourceType, omniOsc.baseType, omniOsc.partialCount);\n\t */\n\tget baseType(): OscillatorType | \"pwm\" | \"pulse\" {\n\t\treturn this._oscillator.baseType;\n\t}\n\tset baseType(baseType) {\n\t\tif (!this._getOscType(this._oscillator, \"pulse\") &&\n\t\t\t!this._getOscType(this._oscillator, \"pwm\") &&\n\t\t\tbaseType !== \"pulse\" && baseType !== \"pwm\") {\n\t\t\tthis._oscillator.baseType = baseType;\n\t\t}\n\t}\n\n\t/**\n\t * The width of the oscillator when sourceType === \"pulse\".\n\t * See [[PWMOscillator.width]]\n\t */\n\tget width(): IsPulseOscillator<OscType, Signal<\"audioRange\">> {\n\t\tif (this._getOscType(this._oscillator, \"pulse\")) {\n\t\t\treturn this._oscillator.width as IsPulseOscillator<OscType, Signal<\"audioRange\">>;\n\t\t} else {\n\t\t\treturn undefined as IsPulseOscillator<OscType, Signal<\"audioRange\">>;\n\t\t}\n\t}\n\n\t/**\n\t * The number of detuned oscillators when sourceType === \"fat\".\n\t * See [[FatOscillator.count]]\n\t */\n\tget count(): IsFatOscillator<OscType, number> {\n\t\tif (this._getOscType(this._oscillator, \"fat\")) {\n\t\t\treturn this._oscillator.count as IsFatOscillator<OscType, number>;\n\t\t} else {\n\t\t\treturn undefined as IsFatOscillator<OscType, number>;\n\t\t}\n\t}\n\tset count(count) {\n\t\tif (this._getOscType(this._oscillator, \"fat\") && isNumber(count)) {\n\t\t\tthis._oscillator.count = count;\n\t\t}\n\t}\n\n\t/**\n\t * The detune spread between the oscillators when sourceType === \"fat\".\n\t * See [[FatOscillator.count]]\n\t */\n\tget spread(): IsFatOscillator<OscType, Cents> {\n\t\tif (this._getOscType(this._oscillator, \"fat\")) {\n\t\t\treturn this._oscillator.spread as IsFatOscillator<OscType, Cents>;\n\t\t} else {\n\t\t\treturn undefined as IsFatOscillator<OscType, Cents>;\n\t\t}\n\t}\n\tset spread(spread) {\n\t\tif (this._getOscType(this._oscillator, \"fat\") && isNumber(spread)) {\n\t\t\tthis._oscillator.spread = spread;\n\t\t}\n\t}\n\n\t/**\n\t * The type of the modulator oscillator. Only if the oscillator is set to \"am\" or \"fm\" types. \n\t * See [[AMOscillator]] or [[FMOscillator]]\n\t */\n\tget modulationType(): IsAmOrFmOscillator<OscType, ToneOscillatorType> {\n\t\tif (this._getOscType(this._oscillator, \"fm\") || this._getOscType(this._oscillator, \"am\")) {\n\t\t\treturn this._oscillator.modulationType as IsAmOrFmOscillator<OscType, ToneOscillatorType>;\n\t\t} else {\n\t\t\treturn undefined as IsAmOrFmOscillator<OscType, ToneOscillatorType>;\n\t\t}\n\t}\n\tset modulationType(mType) {\n\t\tif ((this._getOscType(this._oscillator, \"fm\") || this._getOscType(this._oscillator, \"am\")) && isString(mType)) {\n\t\t\tthis._oscillator.modulationType = mType;\n\t\t}\n\t}\n\n\t/**\n\t * The modulation index when the sourceType === \"fm\"\n\t * See [[FMOscillator]].\n\t */\n\tget modulationIndex(): IsFMOscillator<OscType, Signal<\"positive\">> {\n\t\tif (this._getOscType(this._oscillator, \"fm\")) {\n\t\t\treturn this._oscillator.modulationIndex as IsFMOscillator<OscType, Signal<\"positive\">>;\n\t\t} else {\n\t\t\treturn undefined as IsFMOscillator<OscType, Signal<\"positive\">>;\n\t\t}\n\t}\n\n\t/**\n\t * Harmonicity is the frequency ratio between the carrier and the modulator oscillators.\n\t * See [[AMOscillator]] or [[FMOscillator]]\n\t */\n\tget harmonicity(): IsAmOrFmOscillator<OscType, Signal<\"positive\">> {\n\t\tif (this._getOscType(this._oscillator, \"fm\") || this._getOscType(this._oscillator, \"am\")) {\n\t\t\treturn this._oscillator.harmonicity as IsAmOrFmOscillator<OscType, Signal<\"positive\">>;\n\t\t} else {\n\t\t\treturn undefined as IsAmOrFmOscillator<OscType, Signal<\"positive\">>;\n\t\t}\n\t}\n\n\t/**\n\t * The modulationFrequency Signal of the oscillator when sourceType === \"pwm\"\n\t * see [[PWMOscillator]]\n\t * @min 0.1\n\t * @max 5\n\t */\n\tget modulationFrequency(): IsPWMOscillator<OscType, Signal<\"frequency\">> {\n\t\tif (this._getOscType(this._oscillator, \"pwm\")) {\n\t\t\treturn this._oscillator.modulationFrequency as IsPWMOscillator<OscType, Signal<\"frequency\">>;\n\t\t} else {\n\t\t\treturn undefined as IsPWMOscillator<OscType, Signal<\"frequency\">>;\n\t\t}\n\t}\n\n\tasync asArray(length = 1024): Promise<Float32Array> {\n\t\treturn generateWaveform(this, length);\n\t}\n\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis.detune.dispose();\n\t\tthis.frequency.dispose();\n\t\tthis._oscillator.dispose();\n\t\treturn this;\n\t}\n}\n","import { connectSeries } from \"../core/context/ToneAudioNode\";\nimport { Gain } from \"../core/context/Gain\";\nimport { Param } from \"../core/context/Param\";\nimport { optionsFromArguments } from \"../core/util/Defaults\";\nimport { Signal, SignalOptions } from \"./Signal\";\n\n/**\n * Add a signal and a number or two signals. When no value is\n * passed into the constructor, Tone.Add will sum input and `addend`\n * If a value is passed into the constructor, the it will be added to the input.\n *\n * @example\n * return Tone.Offline(() => {\n * \tconst add = new Tone.Add(2).toDestination();\n * \tadd.addend.setValueAtTime(1, 0.2);\n * \tconst signal = new Tone.Signal(2);\n * \t// add a signal and a scalar\n * \tsignal.connect(add);\n * \tsignal.setValueAtTime(1, 0.1);\n * }, 0.5, 1);\n * @category Signal\n */\nexport class Add extends Signal {\n\n\toverride = false;\n\n\treadonly name: string = \"Add\";\n\n\t/**\n\t * the summing node\n\t */\n\tprivate _sum: Gain = new Gain({ context: this.context });\n\treadonly input = this._sum;\n\treadonly output = this._sum;\n\n\t/**\n\t * The value which is added to the input signal\n\t */\n\treadonly addend: Param<\"number\"> = this._param;\n\n\t/**\n\t * @param value If no value is provided, will sum the input and [[addend]].\n\t */\n\tconstructor(value?: number);\n\tconstructor(options?: Partial<SignalOptions<\"number\">>);\n\tconstructor() {\n\t\tsuper(Object.assign(optionsFromArguments(Add.getDefaults(), arguments, [\"value\"])));\n\n\t\tconnectSeries(this._constantSource, this._sum);\n\t}\n\n\tstatic getDefaults(): SignalOptions<\"number\"> {\n\t\treturn Object.assign(Signal.getDefaults(), {\n\t\t\tvalue: 0,\n\t\t});\n\t}\n\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis._sum.dispose();\n\t\treturn this;\n\t}\n}\n","import { InputNode, OutputNode, ToneAudioNodeOptions } from \"../core/context/ToneAudioNode\";\nimport { optionsFromArguments } from \"../core/util/Defaults\";\nimport { Add } from \"./Add\";\nimport { Multiply } from \"./Multiply\";\nimport { SignalOperator } from \"./SignalOperator\";\n\nexport interface ScaleOptions extends ToneAudioNodeOptions {\n\tmin: number;\n\tmax: number;\n}\n\n/**\n * Performs a linear scaling on an input signal.\n * Scales a NormalRange input to between\n * outputMin and outputMax.\n *\n * @example\n * const scale = new Tone.Scale(50, 100);\n * const signal = new Tone.Signal(0.5).connect(scale);\n * // the output of scale equals 75\n * @category Signal\n */\nexport class Scale<Options extends ScaleOptions = ScaleOptions> extends SignalOperator<Options> {\n\n\treadonly name: string = \"Scale\";\n\n\tinput: InputNode;\n\toutput: OutputNode;\n\n\t/**\n\t * Hold the multiple\n\t */\n\tprotected _mult: Multiply;\n\n\t/**\n\t * Hold the adder\n\t */\n\tprotected _add: Add;\n\n\t/**\n\t * Private reference to the min value\n\t */\n\tprivate _min: number;\n\n\t/**\n\t * Private reference to the max value\n\t */\n\tprivate _max: number;\n\n\t/**\n\t * @param min The output value when the input is 0.\n\t * @param max The output value when the input is 1.\n\t */\n\tconstructor(min?: number, max?: number);\n\tconstructor(options?: Partial<ScaleOptions>);\n\tconstructor() {\n\t\tsuper(Object.assign(optionsFromArguments(Scale.getDefaults(), arguments, [\"min\", \"max\"])));\n\t\tconst options = optionsFromArguments(Scale.getDefaults(), arguments, [\"min\", \"max\"]);\n\n\t\tthis._mult = this.input = new Multiply({\n\t\t\tcontext: this.context,\n\t\t\tvalue: options.max - options.min,\n\t\t});\n\n\t\tthis._add = this.output = new Add({\n\t\t\tcontext: this.context,\n\t\t\tvalue: options.min,\n\t\t});\n\n\t\tthis._min = options.min;\n\t\tthis._max = options.max;\n\n\t\tthis.input.connect(this.output);\n\t}\n\n\tstatic getDefaults(): ScaleOptions {\n\t\treturn Object.assign(SignalOperator.getDefaults(), {\n\t\t\tmax: 1,\n\t\t\tmin: 0,\n\t\t});\n\t}\n\n\t/**\n\t * The minimum output value. This number is output when the value input value is 0.\n\t */\n\tget min(): number {\n\t\treturn this._min;\n\t}\n\tset min(min) {\n\t\tthis._min = min;\n\t\tthis._setRange();\n\t}\n\n\t/**\n\t * The maximum output value. This number is output when the value input value is 1.\n\t */\n\tget max(): number {\n\t\treturn this._max;\n\t}\n\tset max(max) {\n\t\tthis._max = max;\n\t\tthis._setRange();\n\t}\n\n\t/**\n\t * set the values\n\t */\n\tprivate _setRange(): void {\n\t\tthis._add.value = this._min;\n\t\tthis._mult.value = this._max - this._min;\n\t}\n\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis._add.dispose();\n\t\tthis._mult.dispose();\n\t\treturn this;\n\t}\n}\n","import { Gain } from \"../core/context/Gain\";\nimport { connect, disconnect, ToneAudioNodeOptions } from \"../core/context/ToneAudioNode\";\nimport { optionsFromArguments } from \"../core/util/Defaults\";\nimport { SignalOperator } from \"./SignalOperator\";\n\n/**\n * Tone.Zero outputs 0's at audio-rate. The reason this has to be\n * it's own class is that many browsers optimize out Tone.Signal\n * with a value of 0 and will not process nodes further down the graph.\n * @category Signal\n */\nexport class Zero extends SignalOperator<ToneAudioNodeOptions> {\n\n\treadonly name: string = \"Zero\";\n\n\t/**\n\t * The gain node which connects the constant source to the output\n\t */\n\tprivate _gain = new Gain({ context: this.context });\n\n\t/**\n\t * Only outputs 0\n\t */\n\toutput = this._gain;\n\n\t/**\n\t * no input node\n\t */\n\tinput = undefined;\n\n\tconstructor(options?: Partial<ToneAudioNodeOptions>);\n\tconstructor() {\n\t\tsuper(Object.assign(optionsFromArguments(Zero.getDefaults(), arguments)));\n\t\tconnect(this.context.getConstant(0), this._gain);\n\t}\n\n\t/**\n\t * clean up\n\t */\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tdisconnect(this.context.getConstant(0), this._gain);\n\t\treturn this;\n\t}\n}\n","import { Gain } from \"../../core/context/Gain\";\nimport { Param } from \"../../core/context/Param\";\nimport { InputNode, OutputNode, ToneAudioNode } from \"../../core/context/ToneAudioNode\";\nimport { Degrees, Frequency, NormalRange, Time, UnitName } from \"../../core/type/Units\";\nimport { optionsFromArguments } from \"../../core/util/Defaults\";\nimport { readOnly } from \"../../core/util/Interface\";\nimport { BasicPlaybackState } from \"../../core/util/StateTimeline\";\nimport { AudioToGain } from \"../../signal/AudioToGain\";\nimport { Scale } from \"../../signal/Scale\";\nimport { connectSignal, Signal } from \"../../signal/Signal\";\nimport { Zero } from \"../../signal/Zero\";\nimport { Oscillator, ToneOscillatorType } from \"./Oscillator\";\nimport { ToneOscillatorConstructorOptions, ToneOscillatorOptions } from \"./OscillatorInterface\";\n\nexport type LFOOptions = {\n\tmin: number;\n\tmax: number;\n\tamplitude: NormalRange;\n\tunits: UnitName;\n} & ToneOscillatorOptions;\n\n/**\n * LFO stands for low frequency oscillator. LFO produces an output signal\n * which can be attached to an AudioParam or Tone.Signal\n * in order to modulate that parameter with an oscillator. The LFO can\n * also be synced to the transport to start/stop and change when the tempo changes.\n * @example\n * return Tone.Offline(() => {\n * \tconst lfo = new Tone.LFO(\"4n\", 400, 4000).start().toDestination();\n * }, 0.5, 1);\n * @category Source\n */\nexport class LFO extends ToneAudioNode<LFOOptions> {\n\n\treadonly name: string = \"LFO\";\n\n\t/**\n\t * The oscillator.\n\t */\n\tprivate _oscillator: Oscillator;\n\n\t/**\n\t * The gain of the output\n\t */\n\tprivate _amplitudeGain: Gain<\"normalRange\">;\n\n\t/**\n\t * The amplitude of the LFO, which controls the output range between\n\t * the min and max output. For example if the min is -10 and the max\n\t * is 10, setting the amplitude to 0.5 would make the LFO modulate\n\t * between -5 and 5.\n\t */\n\treadonly amplitude: Param<\"normalRange\">;\n\n\t/**\n\t * The signal which is output when the LFO is stopped\n\t */\n\tprivate _stoppedSignal: Signal<\"audioRange\">;\n\n\t/**\n\t * Just outputs zeros. This is used so that scaled signal is not\n\t * optimized to silence.\n\t */\n\tprivate _zeros: Zero;\n\n\t/**\n\t * The value that the LFO outputs when it's stopped\n\t */\n\tprivate _stoppedValue = 0;\n\n\t/**\n\t * Convert the oscillators audio range to an output between 0-1 so it can be scaled\n\t */\n\tprivate _a2g: AudioToGain;\n\n\t/**\n\t * Scales the final output to the min and max value\n\t */\n\tprivate _scaler: Scale;\n\n\t/**\n\t * The output of the LFO\n\t */\n\treadonly output: OutputNode;\n\n\t/**\n\t * There is no input node\n\t */\n\treadonly input: undefined;\n\n\t/**\n\t * A private placeholder for the units\n\t */\n\tprivate _units: UnitName = \"number\";\n\n\t/**\n\t * If the input value is converted using the [[units]]\n\t */\n\tconvert = true;\n\n\t/**\n\t * The frequency value of the LFO\n\t */\n\treadonly frequency: Signal<\"frequency\">;\n\n\t/**\n\t * @param frequency The frequency of the oscillation.\n\t * Typically, LFOs will be in the frequency range of 0.1 to 10 hertz.\n\t * @param min The minimum output value of the LFO.\n\t * @param max The maximum value of the LFO.\n\t */\n\tconstructor(frequency?: Frequency, min?: number, max?: number);\n\tconstructor(options?: Partial<LFOOptions>);\n\tconstructor() {\n\n\t\tsuper(optionsFromArguments(LFO.getDefaults(), arguments, [\"frequency\", \"min\", \"max\"]));\n\t\tconst options = optionsFromArguments(LFO.getDefaults(), arguments, [\"frequency\", \"min\", \"max\"]);\n\n\t\tthis._oscillator = new Oscillator(options as ToneOscillatorConstructorOptions);\n\n\t\tthis.frequency = this._oscillator.frequency;\n\n\t\tthis._amplitudeGain = new Gain({\n\t\t\tcontext: this.context,\n\t\t\tgain: options.amplitude,\n\t\t\tunits: \"normalRange\",\n\t\t});\n\t\tthis.amplitude = this._amplitudeGain.gain;\n\t\tthis._stoppedSignal = new Signal({\n\t\t\tcontext: this.context,\n\t\t\tunits: \"audioRange\",\n\t\t\tvalue: 0,\n\t\t});\n\t\tthis._zeros = new Zero({ context: this.context });\n\t\tthis._a2g = new AudioToGain({ context: this.context });\n\t\tthis._scaler = this.output = new Scale({\n\t\t\tcontext: this.context,\n\t\t\tmax: options.max,\n\t\t\tmin: options.min,\n\t\t});\n\n\t\tthis.units = options.units;\n\t\tthis.min = options.min;\n\t\tthis.max = options.max;\n\n\t\t// connect it up\n\t\tthis._oscillator.chain(this._amplitudeGain, this._a2g, this._scaler);\n\t\tthis._zeros.connect(this._a2g);\n\t\tthis._stoppedSignal.connect(this._a2g);\n\t\treadOnly(this, [\"amplitude\", \"frequency\"]);\n\t\tthis.phase = options.phase;\n\t}\n\n\tstatic getDefaults(): LFOOptions {\n\t\treturn Object.assign(Oscillator.getDefaults(), {\n\t\t\tamplitude: 1,\n\t\t\tfrequency: \"4n\",\n\t\t\tmax: 1,\n\t\t\tmin: 0,\n\t\t\ttype: \"sine\",\n\t\t\tunits: \"number\" as UnitName,\n\t\t});\n\t}\n\n\t/**\n\t * Start the LFO.\n\t * @param time The time the LFO will start\n\t */\n\tstart(time?: Time): this {\n\t\ttime = this.toSeconds(time);\n\t\tthis._stoppedSignal.setValueAtTime(0, time);\n\t\tthis._oscillator.start(time);\n\t\treturn this;\n\t}\n\n\t/**\n\t * Stop the LFO.\n\t * @param  time The time the LFO will stop\n\t */\n\tstop(time?: Time): this {\n\t\ttime = this.toSeconds(time);\n\t\tthis._stoppedSignal.setValueAtTime(this._stoppedValue, time);\n\t\tthis._oscillator.stop(time);\n\t\treturn this;\n\t}\n\n\t/**\n\t * Sync the start/stop/pause to the transport\n\t * and the frequency to the bpm of the transport\n\t * @example\n\t * const lfo = new Tone.LFO(\"8n\");\n\t * lfo.sync().start(0);\n\t * // the rate of the LFO will always be an eighth note, even as the tempo changes\n\t */\n\tsync(): this {\n\t\tthis._oscillator.sync();\n\t\tthis._oscillator.syncFrequency();\n\t\treturn this;\n\t}\n\n\t/**\n\t * unsync the LFO from transport control\n\t */\n\tunsync(): this {\n\t\tthis._oscillator.unsync();\n\t\tthis._oscillator.unsyncFrequency();\n\t\treturn this;\n\t}\n\n\t/**\n\t * After the oscillator waveform is updated, reset the `_stoppedSignal` value to match the updated waveform\n\t */\n\tprivate _setStoppedValue() {\n\t\tthis._stoppedValue = this._oscillator.getInitialValue();\n\t\tthis._stoppedSignal.value = this._stoppedValue;\n\t}\n\n\t/**\n\t * The minimum output of the LFO.\n\t */\n\tget min(): number {\n\t\treturn this._toType(this._scaler.min);\n\t}\n\tset min(min) {\n\t\tmin = this._fromType(min);\n\t\tthis._scaler.min = min;\n\t}\n\n\t/**\n\t * The maximum output of the LFO.\n\t */\n\tget max(): number {\n\t\treturn this._toType(this._scaler.max);\n\t}\n\tset max(max) {\n\t\tmax = this._fromType(max);\n\t\tthis._scaler.max = max;\n\t}\n\n\t/**\n\t * The type of the oscillator: See [[Oscillator.type]]\n\t */\n\tget type(): ToneOscillatorType {\n\t\treturn this._oscillator.type;\n\t}\n\tset type(type) {\n\t\tthis._oscillator.type = type;\n\t\tthis._setStoppedValue();\n\t}\n\n\t/**\n\t * The oscillator's partials array: See [[Oscillator.partials]]\n\t */\n\tget partials(): number[] {\n\t\treturn this._oscillator.partials;\n\t}\n\tset partials(partials) {\n\t\tthis._oscillator.partials = partials;\n\t\tthis._setStoppedValue();\n\t}\n\n\t/**\n\t * The phase of the LFO.\n\t */\n\tget phase(): Degrees {\n\t\treturn this._oscillator.phase;\n\t}\n\tset phase(phase) {\n\t\tthis._oscillator.phase = phase;\n\t\tthis._setStoppedValue();\n\t}\n\n\t/**\n\t * The output units of the LFO.\n\t */\n\tget units(): UnitName {\n\t\treturn this._units;\n\t}\n\tset units(val) {\n\t\tconst currentMin = this.min;\n\t\tconst currentMax = this.max;\n\t\t// convert the min and the max\n\t\tthis._units = val;\n\t\tthis.min = currentMin;\n\t\tthis.max = currentMax;\n\t}\n\n\t/**\n\t * Returns the playback state of the source, either \"started\" or \"stopped\".\n\t */\n\tget state(): BasicPlaybackState {\n\t\treturn this._oscillator.state;\n\t}\n\n\t/**\n\t * @param node the destination to connect to\n\t * @param outputNum the optional output number\n\t * @param inputNum the input number\n\t */\n\tconnect(node: InputNode, outputNum?: number, inputNum?: number): this {\n\t\tif (node instanceof Param || node instanceof Signal) {\n\t\t\tthis.convert = node.convert;\n\t\t\tthis.units = node.units;\n\t\t}\n\t\tconnectSignal(this, node, outputNum, inputNum);\n\t\treturn this;\n\t}\n\n\t/**\n\t * Private methods borrowed from Param\n\t */\n\t// @ts-ignore\n\tprivate _fromType = Param.prototype._fromType;\n\t// @ts-ignore\n\tprivate _toType = Param.prototype._toType;\n\t// @ts-ignore\n\tprivate _is = Param.prototype._is;\n\t// @ts-ignore\n\tprivate _clampValue = Param.prototype._clampValue;\n\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis._oscillator.dispose();\n\t\tthis._stoppedSignal.dispose();\n\t\tthis._zeros.dispose();\n\t\tthis._scaler.dispose();\n\t\tthis._a2g.dispose();\n\t\tthis._amplitudeGain.dispose();\n\t\tthis.amplitude.dispose();\n\t\treturn this;\n\t}\n}\n","import { assertRange } from \"./Debug\";\nimport { Time } from \"../type/Units\";\n\n/**\n * Assert that the number is in the given range.\n */\nexport function range(min: number, max = Infinity) {\n\tconst valueMap: WeakMap<any, number> = new WeakMap();\n\treturn function(target: any, propertyKey: string | symbol) {\n\t\tReflect.defineProperty(\n\t\t\ttarget,\n\t\t\tpropertyKey,\n\t\t\t{\n\t\t\t\tconfigurable: true,\n\t\t\t\tenumerable: true,\n\t\t\t\tget: function() {\n\t\t\t\t\treturn valueMap.get(this);\n\t\t\t\t},\n\t\t\t\tset: function(newValue: number) {\n\t\t\t\t\tassertRange(newValue, min, max);\n\t\t\t\t\tvalueMap.set(this, newValue);\n\t\t\t\t}\n\t\t\t},\n\t\t);\n\t};\n}\n\n/**\n * Convert the time to seconds and assert that the time is in between the two\n * values when being set.\n */\nexport function timeRange(min: number, max = Infinity) {\n\tconst valueMap: WeakMap<any, Time> = new WeakMap();\n\treturn function(target: any, propertyKey: string) {\n\t\tReflect.defineProperty(\n\t\t\ttarget,\n\t\t\tpropertyKey,\n\t\t\t{\n\t\t\t\tconfigurable: true,\n\t\t\t\tenumerable: true,\n\t\t\t\tget: function() {\n\t\t\t\t\treturn valueMap.get(this);\n\t\t\t\t},\n\t\t\t\tset: function(newValue: Time) {\n\t\t\t\t\tassertRange(this.toSeconds(newValue), min, max);\n\t\t\t\t\tvalueMap.set(this, newValue);\n\t\t\t\t}\n\t\t\t},\n\t\t);\n\t};\n}\n","import { ToneAudioBuffer } from \"../../core/context/ToneAudioBuffer\";\nimport { Positive, Seconds, Time } from \"../../core/type/Units\";\nimport { defaultArg, optionsFromArguments } from \"../../core/util/Defaults\";\nimport { noOp } from \"../../core/util/Interface\";\nimport { isUndef } from \"../../core/util/TypeCheck\";\nimport { Source, SourceOptions } from \"../Source\";\nimport { ToneBufferSource } from \"./ToneBufferSource\";\nimport { assertRange } from \"../../core/util/Debug\";\nimport { timeRange } from \"../../core/util/Decorator\";\n\nexport interface PlayerOptions extends SourceOptions {\n\tonload: () => void;\n\tonerror: (error: Error) => void;\n\tplaybackRate: Positive;\n\tloop: boolean;\n\tautostart: boolean;\n\tloopStart: Time;\n\tloopEnd: Time;\n\treverse: boolean;\n\tfadeIn: Time;\n\tfadeOut: Time;\n\turl?: ToneAudioBuffer | string | AudioBuffer;\n}\n\n/**\n * Player is an audio file player with start, loop, and stop functions.\n * @example\n * const player = new Tone.Player(\"https://tonejs.github.io/audio/berklee/gong_1.mp3\").toDestination();\n * // play as soon as the buffer is loaded\n * player.autostart = true;\n * @category Source\n */\nexport class Player extends Source<PlayerOptions> {\n\n\treadonly name: string = \"Player\";\n\n\t/**\n\t * If the file should play as soon\n\t * as the buffer is loaded.\n\t */\n\tautostart: boolean;\n\n\t/**\n\t * The buffer\n\t */\n\tprivate _buffer: ToneAudioBuffer;\n\n\t/**\n\t * if the buffer should loop once it's over\n\t */\n\tprivate _loop: boolean;\n\n\t/**\n\t * if 'loop' is true, the loop will start at this position\n\t */\n\tprivate _loopStart: Time;\n\n\t/**\n\t * if 'loop' is true, the loop will end at this position\n\t */\n\tprivate _loopEnd: Time;\n\n\t/**\n\t * the playback rate\n\t */\n\tprivate _playbackRate: Positive;\n\n\t/**\n\t * All of the active buffer source nodes\n\t */\n\tprivate _activeSources: Set<ToneBufferSource> = new Set();\n\n\t/**\n\t * The fadeIn time of the amplitude envelope.\n\t */\n\t@timeRange(0)\n\tfadeIn: Time;\n\n\t/**\n\t * The fadeOut time of the amplitude envelope.\n\t */\n\t@timeRange(0)\n\tfadeOut: Time;\n\n\t/**\n\t * @param url Either the AudioBuffer or the url from which to load the AudioBuffer\n\t * @param onload The function to invoke when the buffer is loaded.\n\t */\n\tconstructor(url?: string | AudioBuffer | ToneAudioBuffer, onload?: () => void);\n\tconstructor(options?: Partial<PlayerOptions>);\n\tconstructor() {\n\n\t\tsuper(optionsFromArguments(Player.getDefaults(), arguments, [\"url\", \"onload\"]));\n\t\tconst options = optionsFromArguments(Player.getDefaults(), arguments, [\"url\", \"onload\"]);\n\n\t\tthis._buffer = new ToneAudioBuffer({\n\t\t\tonload: this._onload.bind(this, options.onload),\n\t\t\tonerror: options.onerror,\n\t\t\treverse: options.reverse,\n\t\t\turl: options.url,\n\t\t});\n\t\tthis.autostart = options.autostart;\n\t\tthis._loop = options.loop;\n\t\tthis._loopStart = options.loopStart;\n\t\tthis._loopEnd = options.loopEnd;\n\t\tthis._playbackRate = options.playbackRate;\n\t\tthis.fadeIn = options.fadeIn;\n\t\tthis.fadeOut = options.fadeOut;\n\t}\n\n\tstatic getDefaults(): PlayerOptions {\n\t\treturn Object.assign(Source.getDefaults(), {\n\t\t\tautostart: false,\n\t\t\tfadeIn: 0,\n\t\t\tfadeOut: 0,\n\t\t\tloop: false,\n\t\t\tloopEnd: 0,\n\t\t\tloopStart: 0,\n\t\t\tonload: noOp,\n\t\t\tonerror: noOp,\n\t\t\tplaybackRate: 1,\n\t\t\treverse: false,\n\t\t});\n\t}\n\n\t/**\n\t * Load the audio file as an audio buffer.\n\t * Decodes the audio asynchronously and invokes\n\t * the callback once the audio buffer loads.\n\t * Note: this does not need to be called if a url\n\t * was passed in to the constructor. Only use this\n\t * if you want to manually load a new url.\n\t * @param url The url of the buffer to load. Filetype support depends on the browser.\n\t */\n\tasync load(url: string): Promise<this> {\n\t\tawait this._buffer.load(url);\n\t\tthis._onload();\n\t\treturn this;\n\t}\n\n\t/**\n\t * Internal callback when the buffer is loaded.\n\t */\n\tprivate _onload(callback: () => void = noOp): void {\n\t\tcallback();\n\t\tif (this.autostart) {\n\t\t\tthis.start();\n\t\t}\n\t}\n\n\t/**\n\t * Internal callback when the buffer is done playing.\n\t */\n\tprivate _onSourceEnd(source: ToneBufferSource): void {\n\t\t// invoke the onstop function\n\t\tthis.onstop(this);\n\n\t\t// delete the source from the active sources\n\t\tthis._activeSources.delete(source);\n\t\tif (this._activeSources.size === 0 && !this._synced &&\n\t\t\tthis._state.getValueAtTime(this.now()) === \"started\") {\n\t\t\t// remove the 'implicitEnd' event and replace with an explicit end\n\t\t\tthis._state.cancel(this.now());\n\t\t\tthis._state.setStateAtTime(\"stopped\", this.now());\n\t\t}\n\t}\n\n\t/**\n\t * Play the buffer at the given startTime. Optionally add an offset\n\t * and/or duration which will play the buffer from a position\n\t * within the buffer for the given duration.\n\t *\n\t * @param  time When the player should start.\n\t * @param  offset The offset from the beginning of the sample to start at.\n\t * @param  duration How long the sample should play. If no duration is given, it will default to the full length of the sample (minus any offset)\n\t */\n\tstart(time?: Time, offset?: Time, duration?: Time): this {\n\t\tsuper.start(time, offset, duration);\n\t\treturn this;\n\t}\n\n\t/**\n\t * Internal start method\n\t */\n\tprotected _start(startTime?: Time, offset?: Time, duration?: Time): void {\n\t\t// if it's a loop the default offset is the loopStart point\n\t\tif (this._loop) {\n\t\t\toffset = defaultArg(offset, this._loopStart);\n\t\t} else {\n\t\t\t// otherwise the default offset is 0\n\t\t\toffset = defaultArg(offset, 0);\n\t\t}\n\n\t\t// compute the values in seconds\n\t\tconst computedOffset = this.toSeconds(offset);\n\n\t\t// compute the duration which is either the passed in duration of the buffer.duration - offset\n\t\tconst origDuration = duration;\n\t\tduration = defaultArg(duration, Math.max(this._buffer.duration - computedOffset, 0));\n\t\tlet computedDuration = this.toSeconds(duration);\n\n\t\t// scale it by the playback rate\n\t\tcomputedDuration = computedDuration / this._playbackRate;\n\n\t\t// get the start time\n\t\tstartTime = this.toSeconds(startTime);\n\n\t\t// make the source\n\t\tconst source = new ToneBufferSource({\n\t\t\turl: this._buffer,\n\t\t\tcontext: this.context,\n\t\t\tfadeIn: this.fadeIn,\n\t\t\tfadeOut: this.fadeOut,\n\t\t\tloop: this._loop,\n\t\t\tloopEnd: this._loopEnd,\n\t\t\tloopStart: this._loopStart,\n\t\t\tonended: this._onSourceEnd.bind(this),\n\t\t\tplaybackRate: this._playbackRate,\n\t\t}).connect(this.output);\n\n\t\t// set the looping properties\n\t\tif (!this._loop && !this._synced) {\n\t\t\t// cancel the previous stop\n\t\t\tthis._state.cancel(startTime + computedDuration);\n\t\t\t// if it's not looping, set the state change at the end of the sample\n\t\t\tthis._state.setStateAtTime(\"stopped\", startTime + computedDuration, {\n\t\t\t\timplicitEnd: true,\n\t\t\t});\n\t\t}\n\n\t\t// add it to the array of active sources\n\t\tthis._activeSources.add(source);\n\n\t\t// start it\n\t\tif (this._loop && isUndef(origDuration)) {\n\t\t\tsource.start(startTime, computedOffset);\n\t\t} else {\n\t\t\t// subtract the fade out time\n\t\t\tsource.start(startTime, computedOffset, computedDuration - this.toSeconds(this.fadeOut));\n\t\t}\n\t}\n\n\t/**\n\t * Stop playback.\n\t */\n\tprotected _stop(time?: Time): void {\n\t\tconst computedTime = this.toSeconds(time);\n\t\tthis._activeSources.forEach(source => source.stop(computedTime));\n\t}\n\n\t/**\n\t * Stop and then restart the player from the beginning (or offset)\n\t * @param  time When the player should start.\n\t * @param  offset The offset from the beginning of the sample to start at.\n\t * @param  duration How long the sample should play. If no duration is given, \n\t * \t\t\t\t\tit will default to the full length of the sample (minus any offset)\n\t */\n\trestart(time?: Seconds, offset?: Time, duration?: Time): this {\n\t\tsuper.restart(time, offset, duration);\n\t\treturn this;\n\t}\n\n\tprotected _restart(time?: Seconds, offset?: Time, duration?: Time): void {\n\t\tthis._stop(time);\n\t\tthis._start(time, offset, duration);\n\t}\n\n\t/**\n\t * Seek to a specific time in the player's buffer. If the\n\t * source is no longer playing at that time, it will stop.\n\t * @param offset The time to seek to.\n\t * @param when The time for the seek event to occur.\n\t * @example\n\t * const player = new Tone.Player(\"https://tonejs.github.io/audio/berklee/gurgling_theremin_1.mp3\", () => {\n\t * \tplayer.start();\n\t * \t// seek to the offset in 1 second from now\n\t * \tplayer.seek(0.4, \"+1\");\n\t * }).toDestination();\n\t */\n\tseek(offset: Time, when?: Time): this {\n\t\tconst computedTime = this.toSeconds(when);\n\t\tif (this._state.getValueAtTime(computedTime) === \"started\") {\n\t\t\tconst computedOffset = this.toSeconds(offset);\n\t\t\t// if it's currently playing, stop it\n\t\t\tthis._stop(computedTime);\n\t\t\t// restart it at the given time\n\t\t\tthis._start(computedTime, computedOffset);\n\t\t}\n\t\treturn this;\n\t}\n\n\t/**\n\t * Set the loop start and end. Will only loop if loop is set to true.\n\t * @param loopStart The loop start time\n\t * @param loopEnd The loop end time\n\t * @example\n\t * const player = new Tone.Player(\"https://tonejs.github.io/audio/berklee/malevoices_aa2_F3.mp3\").toDestination();\n\t * // loop between the given points\n\t * player.setLoopPoints(0.2, 0.3);\n\t * player.loop = true;\n\t * player.autostart = true;\n\t */\n\tsetLoopPoints(loopStart: Time, loopEnd: Time): this {\n\t\tthis.loopStart = loopStart;\n\t\tthis.loopEnd = loopEnd;\n\t\treturn this;\n\t}\n\n\t/**\n\t * If loop is true, the loop will start at this position.\n\t */\n\tget loopStart(): Time {\n\t\treturn this._loopStart;\n\t}\n\tset loopStart(loopStart) {\n\t\tthis._loopStart = loopStart;\n\t\tif (this.buffer.loaded) {\n\t\t\tassertRange(this.toSeconds(loopStart), 0, this.buffer.duration);\n\t\t}\n\t\t// get the current source\n\t\tthis._activeSources.forEach(source => {\n\t\t\tsource.loopStart = loopStart;\n\t\t});\n\t}\n\n\t/**\n\t * If loop is true, the loop will end at this position.\n\t */\n\tget loopEnd(): Time {\n\t\treturn this._loopEnd;\n\t}\n\tset loopEnd(loopEnd) {\n\t\tthis._loopEnd = loopEnd;\n\t\tif (this.buffer.loaded) {\n\t\t\tassertRange(this.toSeconds(loopEnd), 0, this.buffer.duration);\n\t\t}\n\t\t// get the current source\n\t\tthis._activeSources.forEach(source => {\n\t\t\tsource.loopEnd = loopEnd;\n\t\t});\n\t}\n\n\t/**\n\t * The audio buffer belonging to the player.\n\t */\n\tget buffer(): ToneAudioBuffer {\n\t\treturn this._buffer;\n\t}\n\tset buffer(buffer) {\n\t\tthis._buffer.set(buffer);\n\t}\n\n\t/**\n\t * If the buffer should loop once it's over.\n\t * @example\n\t * const player = new Tone.Player(\"https://tonejs.github.io/audio/drum-samples/breakbeat.mp3\").toDestination();\n\t * player.loop = true;\n\t * player.autostart = true;\n\t */\n\tget loop(): boolean {\n\t\treturn this._loop;\n\t}\n\tset loop(loop) {\n\t\t// if no change, do nothing\n\t\tif (this._loop === loop) {\n\t\t\treturn;\n\t\t}\n\t\tthis._loop = loop;\n\t\t// set the loop of all of the sources\n\t\tthis._activeSources.forEach(source => {\n\t\t\tsource.loop = loop;\n\t\t});\n\t\tif (loop) {\n\t\t\t// remove the next stopEvent\n\t\t\tconst stopEvent = this._state.getNextState(\"stopped\", this.now());\n\t\t\tif (stopEvent) {\n\t\t\t\tthis._state.cancel(stopEvent.time);\n\t\t\t}\n\t\t}\n\t}\n\n\t/**\n\t * Normal speed is 1. The pitch will change with the playback rate.\n\t * @example\n\t * const player = new Tone.Player(\"https://tonejs.github.io/audio/berklee/femalevoices_aa2_A5.mp3\").toDestination();\n\t * // play at 1/4 speed\n\t * player.playbackRate = 0.25;\n\t * // play as soon as the buffer is loaded\n\t * player.autostart = true;\n\t */\n\tget playbackRate(): Positive {\n\t\treturn this._playbackRate;\n\t}\n\tset playbackRate(rate) {\n\t\tthis._playbackRate = rate;\n\t\tconst now = this.now();\n\n\t\t// cancel the stop event since it's at a different time now\n\t\tconst stopEvent = this._state.getNextState(\"stopped\", now);\n\t\tif (stopEvent && stopEvent.implicitEnd) {\n\t\t\tthis._state.cancel(stopEvent.time);\n\t\t\tthis._activeSources.forEach(source => source.cancelStop());\n\t\t}\n\n\t\t// set all the sources\n\t\tthis._activeSources.forEach(source => {\n\t\t\tsource.playbackRate.setValueAtTime(rate, now);\n\t\t});\n\t}\n\n\t/**\n\t * If the buffer should be reversed\n\t * @example\n\t * const player = new Tone.Player(\"https://tonejs.github.io/audio/berklee/chime_1.mp3\").toDestination();\n\t * player.autostart = true;\n\t * player.reverse = true;\n\t */\n\tget reverse(): boolean {\n\t\treturn this._buffer.reverse;\n\t}\n\tset reverse(rev) {\n\t\tthis._buffer.reverse = rev;\n\t}\n\n\t/**\n\t * If the buffer is loaded\n\t */\n\tget loaded(): boolean {\n\t\treturn this._buffer.loaded;\n\t}\n\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\t// disconnect all of the players\n\t\tthis._activeSources.forEach(source => source.dispose());\n\t\tthis._activeSources.clear();\n\t\tthis._buffer.dispose();\n\t\treturn this;\n\t}\n}\n","import { Volume } from \"../../component/channel/Volume\";\nimport { Param } from \"../../core/context/Param\";\nimport { ToneAudioBuffer } from \"../../core/context/ToneAudioBuffer\";\nimport { ToneAudioBuffers, ToneAudioBuffersUrlMap } from \"../../core/context/ToneAudioBuffers\";\nimport { OutputNode, ToneAudioNode } from \"../../core/context/ToneAudioNode\";\nimport { Decibels, Time } from \"../../core/type/Units\";\nimport { optionsFromArguments } from \"../../core/util/Defaults\";\nimport { assert } from \"../../core/util/Debug\";\nimport { noOp, readOnly } from \"../../core/util/Interface\";\nimport { BasicPlaybackState } from \"../../core/util/StateTimeline\";\nimport { Source, SourceOptions } from \"../Source\";\nimport { Player } from \"./Player\";\n\nexport interface PlayersOptions extends SourceOptions {\n\turls: ToneAudioBuffersUrlMap;\n\tvolume: Decibels;\n\tmute: boolean;\n\tonload: () => void;\n\tonerror: (error: Error) => void;\n\tbaseUrl: string;\n\tfadeIn: Time;\n\tfadeOut: Time;\n}\n\n/**\n * Players combines multiple [[Player]] objects.\n * @category Source\n */\nexport class Players extends ToneAudioNode<PlayersOptions> {\n\n\treadonly name: string = \"Players\";\n\n\t/**\n\t * The output volume node\n\t */\n\tprivate _volume: Volume;\n\n\t/**\n\t * The volume of the output in decibels.\n\t */\n\treadonly volume: Param<\"decibels\">;\n\n\t/**\n\t * The combined output of all of the players\n\t */\n\treadonly output: OutputNode;\n\n\t/**\n\t * Players has no input.\n\t */\n\treadonly input = undefined;\n\n\t/**\n\t * The container of all of the players\n\t */\n\tprivate _players: Map<string, Player> = new Map();\n\n\t/**\n\t * The container of all the buffers\n\t */\n\tprivate _buffers: ToneAudioBuffers;\n\n\t/**\n\t * private holder of the fadeIn time\n\t */\n\tprivate _fadeIn: Time;\n\n\t/**\n\t * private holder of the fadeOut time\n\t */\n\tprivate _fadeOut: Time;\n\n\t/**\n\t * @param urls An object mapping a name to a url.\n\t * @param onload The function to invoke when all buffers are loaded.\n\t */\n\tconstructor(urls?: ToneAudioBuffersUrlMap, onload?: () => void);\n\t/**\n\t * @param urls An object mapping a name to a url.\n\t * @param options The remaining options associated with the players\n\t */\n\tconstructor(urls?: ToneAudioBuffersUrlMap, options?: Partial<Omit<PlayersOptions, \"urls\">>);\n\tconstructor(options?: Partial<PlayersOptions>);\n\tconstructor() {\n\t\tsuper(optionsFromArguments(Players.getDefaults(), arguments, [\"urls\", \"onload\"], \"urls\"));\n\t\tconst options = optionsFromArguments(Players.getDefaults(), arguments, [\"urls\", \"onload\"], \"urls\");\n\n\t\t/**\n\t\t * The output volume node\n\t\t */\n\t\tthis._volume = this.output = new Volume({\n\t\t\tcontext: this.context,\n\t\t\tvolume: options.volume,\n\t\t});\n\n\t\tthis.volume = this._volume.volume;\n\t\treadOnly(this, \"volume\");\n\t\tthis._buffers = new ToneAudioBuffers({\n\t\t\turls: options.urls, \n\t\t\tonload: options.onload, \n\t\t\tbaseUrl: options.baseUrl,\n\t\t\tonerror: options.onerror\n\t\t});\n\t\t// mute initially\n\t\tthis.mute = options.mute;\n\t\tthis._fadeIn = options.fadeIn;\n\t\tthis._fadeOut = options.fadeOut;\n\t}\n\n\tstatic getDefaults(): PlayersOptions {\n\t\treturn Object.assign(Source.getDefaults(), {\n\t\t\tbaseUrl: \"\",\n\t\t\tfadeIn: 0,\n\t\t\tfadeOut: 0,\n\t\t\tmute: false,\n\t\t\tonload: noOp,\n\t\t\tonerror: noOp,\n\t\t\turls: {},\n\t\t\tvolume: 0,\n\t\t});\n\t}\n\n\t/**\n\t * Mute the output.\n\t */\n\tget mute(): boolean {\n\t\treturn this._volume.mute;\n\t}\n\tset mute(mute) {\n\t\tthis._volume.mute = mute;\n\t}\n\n\t/**\n\t * The fadeIn time of the envelope applied to the source.\n\t */\n\tget fadeIn(): Time {\n\t\treturn this._fadeIn;\n\t}\n\tset fadeIn(fadeIn) {\n\t\tthis._fadeIn = fadeIn;\n\t\tthis._players.forEach(player => {\n\t\t\tplayer.fadeIn = fadeIn;\n\t\t});\n\t}\n\n\t/**\n\t * The fadeOut time of the each of the sources.\n\t */\n\tget fadeOut(): Time {\n\t\treturn this._fadeOut;\n\t}\n\tset fadeOut(fadeOut) {\n\t\tthis._fadeOut = fadeOut;\n\t\tthis._players.forEach(player => {\n\t\t\tplayer.fadeOut = fadeOut;\n\t\t});\n\t}\n\n\t/**\n\t * The state of the players object. Returns \"started\" if any of the players are playing.\n\t */\n\tget state(): BasicPlaybackState {\n\t\tconst playing = Array.from(this._players).some(([_, player]) => player.state === \"started\");\n\t\treturn playing ? \"started\" : \"stopped\";\n\t}\n\n\t/**\n\t * True if the buffers object has a buffer by that name.\n\t * @param name  The key or index of the buffer.\n\t */\n\thas(name: string): boolean {\n\t\treturn this._buffers.has(name);\n\t}\n\n\t/**\n\t * Get a player by name.\n\t * @param  name  The players name as defined in the constructor object or `add` method.\n\t */\n\tplayer(name: string): Player {\n\t\tassert(this.has(name), `No Player with the name ${name} exists on this object`);\n\t\tif (!this._players.has(name)) {\n\t\t\tconst player = new Player({\n\t\t\t\tcontext: this.context,\n\t\t\t\tfadeIn: this._fadeIn,\n\t\t\t\tfadeOut: this._fadeOut,\n\t\t\t\turl: this._buffers.get(name),\n\t\t\t}).connect(this.output);\n\t\t\tthis._players.set(name, player);\n\t\t}\n\t\treturn this._players.get(name) as Player;\n\t}\n\n\t/**\n\t * If all the buffers are loaded or not\n\t */\n\tget loaded(): boolean {\n\t\treturn this._buffers.loaded;\n\t}\n\n\t/**\n\t * Add a player by name and url to the Players\n\t * @param  name A unique name to give the player\n\t * @param  url  Either the url of the bufer or a buffer which will be added with the given name.\n\t * @param callback  The callback to invoke when the url is loaded.\n\t * @example\n\t * const players = new Tone.Players();\n\t * players.add(\"gong\", \"https://tonejs.github.io/audio/berklee/gong_1.mp3\", () => {\n\t * \tconsole.log(\"gong loaded\");\n\t * \tplayers.get(\"gong\").start();\n\t * });\n\t */\n\tadd(name: string, url: string | ToneAudioBuffer | AudioBuffer, callback?: () => void): this {\n\t\tassert(!this._buffers.has(name), \"A buffer with that name already exists on this object\");\n\t\tthis._buffers.add(name, url, callback);\n\t\treturn this;\n\t}\n\n\t/**\n\t * Stop all of the players at the given time\n\t * @param time The time to stop all of the players.\n\t */\n\tstopAll(time?: Time): this {\n\t\tthis._players.forEach(player => player.stop(time));\n\t\treturn this;\n\t}\n\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis._volume.dispose();\n\t\tthis.volume.dispose();\n\t\tthis._players.forEach(player => player.dispose());\n\t\tthis._buffers.dispose();\n\t\treturn this;\n\t}\n}\n","import { Source, SourceOptions } from \"../Source\";\nimport { noOp } from \"../../core/util/Interface\";\nimport { ToneAudioBuffer } from \"../../core/context/ToneAudioBuffer\";\nimport { defaultArg, optionsFromArguments } from \"../../core/util/Defaults\";\nimport { Clock } from \"../../core/clock/Clock\";\nimport { Cents, Positive, Seconds, Time } from \"../../core/type/Units\";\nimport { ToneBufferSource } from \"./ToneBufferSource\";\nimport { intervalToFrequencyRatio } from \"../../core/type/Conversions\";\nimport { assertRange } from \"../../core/util/Debug\";\n\ninterface GrainPlayerOptions extends SourceOptions {\n\tonload: () => void;\n\tonerror: (error: Error) => void;\n\treverse: boolean;\n\turl?: ToneAudioBuffer | string | AudioBuffer;\n\toverlap: Seconds;\n\tgrainSize: Seconds;\n\tplaybackRate: Positive;\n\tdetune: Cents;\n\tloop: boolean;\n\tloopStart: Time;\n\tloopEnd: Time;\n}\n\n/**\n * GrainPlayer implements [granular synthesis](https://en.wikipedia.org/wiki/Granular_synthesis).\n * Granular Synthesis enables you to adjust pitch and playback rate independently. The grainSize is the\n * amount of time each small chunk of audio is played for and the overlap is the\n * amount of crossfading transition time between successive grains.\n * @category Source\n */\nexport class GrainPlayer extends Source<GrainPlayerOptions> {\n\n\treadonly name: string = \"GrainPlayer\";\n\n\t/**\n\t * The audio buffer belonging to the player.\n\t */\n\tbuffer: ToneAudioBuffer;\n\n\t/**\n\t * Create a repeating tick to schedule the grains.\n\t */\n\tprivate _clock: Clock;\n\n\t/**\n\t * Internal loopStart value\n\t */\n\tprivate _loopStart = 0;\n\n\t/**\n\t * Internal loopStart value\n\t */\n\tprivate _loopEnd = 0;\n\n\t/**\n\t * All of the currently playing BufferSources\n\t */\n\tprivate _activeSources: ToneBufferSource[] = [];\n\n\t/**\n\t * Internal reference to the playback rate\n\t */\n\tprivate _playbackRate: Positive;\n\n\t/**\n\t * Internal grain size reference;\n\t */\n\tprivate _grainSize: Seconds;\n\n\t/**\n\t * Internal overlap reference;\n\t */\n\tprivate _overlap: Seconds;\n\n\t/**\n\t * Adjust the pitch independently of the playbackRate.\n\t */\n\tdetune: Cents;\n\n\t/**\n\t * If the buffer should loop back to the loopStart when completed\n\t */\n\tloop: boolean;\n\n\t/**\n\t * @param url Either the AudioBuffer or the url from which to load the AudioBuffer\n\t * @param onload The function to invoke when the buffer is loaded.\n\t */\n\tconstructor(url?: string | AudioBuffer | ToneAudioBuffer, onload?: () => void);\n\tconstructor(options?: Partial<GrainPlayerOptions>);\n\tconstructor() {\n\n\t\tsuper(optionsFromArguments(GrainPlayer.getDefaults(), arguments, [\"url\", \"onload\"]));\n\t\tconst options = optionsFromArguments(GrainPlayer.getDefaults(), arguments, [\"url\", \"onload\"]);\n\n\t\tthis.buffer = new ToneAudioBuffer({\n\t\t\tonload: options.onload,\n\t\t\tonerror: options.onerror,\n\t\t\treverse: options.reverse,\n\t\t\turl: options.url,\n\t\t});\n\t\tthis._clock = new Clock({\n\t\t\tcontext: this.context,\n\t\t\tcallback: this._tick.bind(this),\n\t\t\tfrequency: 1 / options.grainSize\n\t\t});\n\t\tthis._playbackRate = options.playbackRate;\n\t\tthis._grainSize = options.grainSize;\n\t\tthis._overlap = options.overlap;\n\t\tthis.detune = options.detune;\n\n\t\t// setup\n\t\tthis.overlap = options.overlap;\n\t\tthis.loop = options.loop;\n\t\tthis.playbackRate = options.playbackRate;\n\t\tthis.grainSize = options.grainSize;\n\t\tthis.loopStart = options.loopStart;\n\t\tthis.loopEnd = options.loopEnd;\n\t\tthis.reverse = options.reverse;\n\t\tthis._clock.on(\"stop\", this._onstop.bind(this));\n\t}\n\n\tstatic getDefaults(): GrainPlayerOptions {\n\t\treturn Object.assign(Source.getDefaults(), {\n\t\t\tonload: noOp,\n\t\t\tonerror: noOp,\n\t\t\toverlap: 0.1,\n\t\t\tgrainSize: 0.2,\n\t\t\tplaybackRate: 1,\n\t\t\tdetune: 0,\n\t\t\tloop: false,\n\t\t\tloopStart: 0,\n\t\t\tloopEnd: 0,\n\t\t\treverse: false\n\t\t});\n\t}\n\n\t/**\n\t * Internal start method\n\t */\n\tprotected _start(time?: Time, offset?: Time, duration?: Time): void {\n\t\toffset = defaultArg(offset, 0);\n\t\toffset = this.toSeconds(offset);\n\t\ttime = this.toSeconds(time);\n\n\t\tconst grainSize = 1 / this._clock.frequency.getValueAtTime(time);\n\t\tthis._clock.start(time, offset / grainSize);\n\n\t\tif (duration) {\n\t\t\tthis.stop(time + this.toSeconds(duration));\n\t\t}\n\t}\n\n\t/**\n\t * Stop and then restart the player from the beginning (or offset)\n\t * @param  time When the player should start.\n\t * @param  offset The offset from the beginning of the sample to start at.\n\t * @param  duration How long the sample should play. If no duration is given, \n\t * \t\t\t\t\tit will default to the full length of the sample (minus any offset)\n\t */\n\trestart(time?: Seconds, offset?: Time, duration?: Time): this {\n\t\tsuper.restart(time, offset, duration);\n\t\treturn this;\n\t}\n\n\tprotected _restart(time?: Seconds, offset?: Time, duration?: Time): void {\n\t\tthis._stop(time);\n\t\tthis._start(time, offset, duration);\n\t}\n\n\t/**\n\t * Internal stop method\n\t */\n\tprotected _stop(time?: Time): void {\n\t\tthis._clock.stop(time);\n\t}\n\n\t/**\n\t * Invoked when the clock is stopped\n\t */\n\tprivate _onstop(time: Seconds): void {\n\t\t// stop the players\n\t\tthis._activeSources.forEach((source) => {\n\t\t\tsource.fadeOut = 0;\n\t\t\tsource.stop(time);\n\t\t});\n\t\tthis.onstop(this);\n\t}\n\n\t/**\n\t * Invoked on each clock tick. scheduled a new grain at this time.\n\t */\n\tprivate _tick(time: Seconds): void {\n\t\t// check if it should stop looping\n\t\tconst ticks = this._clock.getTicksAtTime(time);\n\t\tconst offset = ticks * this._grainSize;\n\t\tthis.log(\"offset\", offset);\n\n\t\tif (!this.loop && offset > this.buffer.duration) {\n\t\t\tthis.stop(time);\n\t\t\treturn;\n\t\t}\n\n\t\t// at the beginning of the file, the fade in should be 0\n\t\tconst fadeIn = offset < this._overlap ? 0 : this._overlap;\n\n\t\t// create a buffer source\n\t\tconst source = new ToneBufferSource({\n\t\t\tcontext: this.context,\n\t\t\turl: this.buffer,\n\t\t\tfadeIn: fadeIn,\n\t\t\tfadeOut: this._overlap,\n\t\t\tloop: this.loop,\n\t\t\tloopStart: this._loopStart,\n\t\t\tloopEnd: this._loopEnd,\n\t\t\t// compute the playbackRate based on the detune\n\t\t\tplaybackRate: intervalToFrequencyRatio(this.detune / 100)\n\t\t}).connect(this.output);\n\n\t\tsource.start(time, this._grainSize * ticks);\n\t\tsource.stop(time + this._grainSize / this.playbackRate);\n\n\t\t// add it to the active sources\n\t\tthis._activeSources.push(source);\n\t\t// remove it when it's done\n\t\tsource.onended = () => {\n\t\t\tconst index = this._activeSources.indexOf(source);\n\t\t\tif (index !== -1) {\n\t\t\t\tthis._activeSources.splice(index, 1);\n\t\t\t}\n\t\t};\n\t}\n\n\t/**\n\t * The playback rate of the sample\n\t */\n\tget playbackRate(): Positive {\n\t\treturn this._playbackRate;\n\t}\n\tset playbackRate(rate) {\n\t\tassertRange(rate, 0.001);\n\t\tthis._playbackRate = rate;\n\t\tthis.grainSize = this._grainSize;\n\t}\n\n\t/**\n\t * The loop start time.\n\t */\n\tget loopStart(): Time {\n\t\treturn this._loopStart;\n\t}\n\tset loopStart(time) {\n\t\tif (this.buffer.loaded) {\n\t\t\tassertRange(this.toSeconds(time), 0, this.buffer.duration);\n\t\t}\n\t\tthis._loopStart = this.toSeconds(time);\n\t}\n\n\t/**\n\t * The loop end time.\n\t */\n\tget loopEnd(): Time {\n\t\treturn this._loopEnd;\n\t}\n\tset loopEnd(time) {\n\t\tif (this.buffer.loaded) {\n\t\t\tassertRange(this.toSeconds(time), 0, this.buffer.duration);\n\t\t}\n\t\tthis._loopEnd = this.toSeconds(time);\n\t}\n\n\t/**\n\t * The direction the buffer should play in\n\t */\n\tget reverse() {\n\t\treturn this.buffer.reverse;\n\t}\n\n\tset reverse(rev) {\n\t\tthis.buffer.reverse = rev;\n\t}\n\n\t/**\n\t * The size of each chunk of audio that the\n\t * buffer is chopped into and played back at.\n\t */\n\tget grainSize(): Time {\n\t\treturn this._grainSize;\n\t}\n\tset grainSize(size) {\n\t\tthis._grainSize = this.toSeconds(size);\n\t\tthis._clock.frequency.setValueAtTime(this._playbackRate / this._grainSize, this.now());\n\t}\n\n\t/**\n\t * The duration of the cross-fade between successive grains.\n\t */\n\tget overlap(): Time {\n\t\treturn this._overlap;\n\t}\n\tset overlap(time) {\n\t\tconst computedTime = this.toSeconds(time);\n\t\tassertRange(computedTime, 0);\n\t\tthis._overlap = computedTime;\n\t}\n\n\t/**\n\t * If all the buffer is loaded\n\t */\n\tget loaded(): boolean {\n\t\treturn this.buffer.loaded;\n\t}\n\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis.buffer.dispose();\n\t\tthis._clock.dispose();\n\t\tthis._activeSources.forEach((source) => source.dispose());\n\t\treturn this;\n\t}\n}\n","import { ToneAudioNodeOptions } from \"../core/context/ToneAudioNode\";\nimport { SignalOperator } from \"./SignalOperator\";\nimport { WaveShaper } from \"./WaveShaper\";\n\n/**\n * Return the absolute value of an incoming signal.\n *\n * @example\n * return Tone.Offline(() => {\n * \tconst abs = new Tone.Abs().toDestination();\n * \tconst signal = new Tone.Signal(1);\n * \tsignal.rampTo(-1, 0.5);\n * \tsignal.connect(abs);\n * }, 0.5, 1);\n * @category Signal\n */\nexport class Abs extends SignalOperator<ToneAudioNodeOptions> {\n\n\treadonly name: string = \"Abs\";\n\n\t/**\n\t * The node which converts the audio ranges\n\t */\n\tprivate _abs = new WaveShaper({\n\t\tcontext: this.context,\n\t\tmapping: val => {\n\t\t\tif (Math.abs(val) < 0.001) {\n\t\t\t\treturn 0;\n\t\t\t} else {\n\t\t\t\treturn Math.abs(val);\n\t\t\t}\n\t\t},\n\t});\n\n\t/**\n\t * The AudioRange input [-1, 1]\n\t */\n\tinput = this._abs;\n\n\t/**\n\t * The output range [0, 1]\n\t */\n\toutput = this._abs;\n\n\t/**\n\t * clean up\n\t */\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis._abs.dispose();\n\t\treturn this;\n\t}\n}\n","import { ToneAudioNodeOptions } from \"../core/context/ToneAudioNode\";\nimport { SignalOperator } from \"./SignalOperator\";\nimport { WaveShaper } from \"./WaveShaper\";\n\n/**\n * GainToAudio converts an input in NormalRange [0,1] to AudioRange [-1,1].\n * See [[AudioToGain]].\n * @category Signal\n */\nexport class GainToAudio extends SignalOperator<ToneAudioNodeOptions> {\n\n\treadonly name: string = \"GainToAudio\";\n\n\t/**\n\t * The node which converts the audio ranges\n\t */\n\tprivate _norm = new WaveShaper({\n\t\tcontext: this.context,\n\t\tmapping: x => Math.abs(x) * 2 - 1,\n\t});\n\n\t/**\n\t * The NormalRange input [0, 1]\n\t */\n\tinput = this._norm;\n\n\t/**\n\t * The AudioRange output [-1, 1]\n\t */\n\toutput = this._norm;\n\n\t/**\n\t * clean up\n\t */\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis._norm.dispose();\n\t\treturn this;\n\t}\n}\n","import { ToneAudioNodeOptions } from \"../core/context/ToneAudioNode\";\nimport { Multiply } from \"./Multiply\";\nimport { SignalOperator } from \"./SignalOperator\";\n\n/**\n * Negate the incoming signal. i.e. an input signal of 10 will output -10\n *\n * @example\n * const neg = new Tone.Negate();\n * const sig = new Tone.Signal(-2).connect(neg);\n * // output of neg is positive 2.\n * @category Signal\n */\nexport class Negate extends SignalOperator<ToneAudioNodeOptions> {\n\n\treadonly name: string = \"Negate\";\n\n\t/**\n\t * negation is done by multiplying by -1\n\t */\n\tprivate _multiply: Multiply = new Multiply({\n\t\tcontext: this.context,\n\t\tvalue: -1,\n\t});\n\n\t/**\n\t * The input and output are equal to the multiply node\n\t */\n\tinput = this._multiply;\n\toutput = this._multiply;\n\n\t/**\n\t * clean up\n\t * @returns {Negate} this\n\t */\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis._multiply.dispose();\n\t\treturn this;\n\t}\n}\n","import { connectSeries } from \"../core/context/ToneAudioNode\";\nimport { Gain } from \"../core/context/Gain\";\nimport { Param } from \"../core/context/Param\";\nimport { optionsFromArguments } from \"../core/util/Defaults\";\nimport { Negate } from \"../signal/Negate\";\nimport { Signal, SignalOptions } from \"../signal/Signal\";\n\n/**\n * Subtract the signal connected to the input is subtracted from the signal connected\n * The subtrahend.\n *\n * @example\n * // subtract a scalar from a signal\n * const sub = new Tone.Subtract(1);\n * const sig = new Tone.Signal(4).connect(sub);\n * // the output of sub is 3.\n * @example\n * // subtract two signals\n * const sub = new Tone.Subtract();\n * const sigA = new Tone.Signal(10);\n * const sigB = new Tone.Signal(2.5);\n * sigA.connect(sub);\n * sigB.connect(sub.subtrahend);\n * // output of sub is 7.5\n * @category Signal\n */\nexport class Subtract extends Signal {\n\n\toverride = false;\n\n\treadonly name: string = \"Subtract\";\n\n\t/**\n\t * the summing node\n\t */\n\tprivate _sum: Gain = new Gain({ context: this.context });\n\treadonly input: Gain = this._sum;\n\treadonly output: Gain = this._sum;\n\n\t/**\n\t * Negate the input of the second input before connecting it to the summing node.\n\t */\n\tprivate _neg: Negate = new Negate({ context: this.context });\n\n\t/**\n\t * The value which is subtracted from the main signal\n\t */\n\tsubtrahend: Param<\"number\"> = this._param;\n\n\t/**\n\t * @param value The value to subtract from the incoming signal. If the value\n\t *             is omitted, it will subtract the second signal from the first.\n\t */\n\tconstructor(value?: number);\n\tconstructor(options?: Partial<SignalOptions<\"number\">>);\n\tconstructor() {\n\t\tsuper(Object.assign(optionsFromArguments(Subtract.getDefaults(), arguments, [\"value\"])));\n\n\t\tconnectSeries(this._constantSource, this._neg, this._sum);\n\t}\n\n\tstatic getDefaults(): SignalOptions<\"number\"> {\n\t\treturn Object.assign(Signal.getDefaults(), {\n\t\t\tvalue: 0,\n\t\t});\n\t}\n\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis._neg.dispose();\n\t\tthis._sum.dispose();\n\t\treturn this;\n\t}\n}\n","import { SignalOperator, SignalOperatorOptions } from \"./SignalOperator\";\nimport { Multiply } from \"./Multiply\";\nimport { ToneAudioNode } from \"../core/context/ToneAudioNode\";\nimport { WaveShaper } from \"./WaveShaper\";\nimport { optionsFromArguments } from \"../core/util/Defaults\";\n\nexport type GreaterThanZeroOptions = SignalOperatorOptions\n\n/**\n * GreaterThanZero outputs 1 when the input is strictly greater than zero\n * @example\n * return Tone.Offline(() => {\n * \tconst gt0 = new Tone.GreaterThanZero().toDestination();\n * \tconst sig = new Tone.Signal(0.5).connect(gt0);\n * \tsig.setValueAtTime(-1, 0.05);\n * }, 0.1, 1);\n * @category Signal\n */\nexport class GreaterThanZero extends SignalOperator<GreaterThanZeroOptions> {\n\n\treadonly name: string = \"GreaterThanZero\";\n\n\t/**\n\t * The waveshaper\n\t */\n\tprivate _thresh: WaveShaper;\n\n\t/**\n\t * Scale the first thresholded signal by a large value.\n\t * this will help with values which are very close to 0\n\t */\n\tprivate _scale: Multiply;\n\n\treadonly output: ToneAudioNode;\n\treadonly input: ToneAudioNode;\n\n\tconstructor(options?: Partial<GreaterThanZeroOptions>);\n\tconstructor() {\n\t\tsuper(Object.assign(optionsFromArguments(GreaterThanZero.getDefaults(), arguments)));\n\n\t\tthis._thresh = this.output = new WaveShaper({\n\t\t\tcontext: this.context,\n\t\t\tlength: 127,\n\t\t\tmapping: (val) => {\n\t\t\t\tif (val <= 0) {\n\t\t\t\t\treturn 0;\n\t\t\t\t} else {\n\t\t\t\t\treturn 1;\n\t\t\t\t}\n\t\t\t},\n\t\t});\n\t\tthis._scale = this.input = new Multiply({\n\t\t\tcontext: this.context,\n\t\t\tvalue: 10000\n\t\t});\n\n\t\t// connections\n\t\tthis._scale.connect(this._thresh);\n\t}\n\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis._scale.dispose();\n\t\tthis._thresh.dispose();\n\t\treturn this;\n\t}\n}\n","import { ToneAudioNode } from \"../core/context/ToneAudioNode\";\nimport { optionsFromArguments } from \"../core/util/Defaults\";\nimport { Subtract } from \"./Subtract\";\nimport { Signal, SignalOptions } from \"./Signal\";\nimport { GreaterThanZero } from \"./GreaterThanZero\";\nimport { readOnly } from \"../core/util/Interface\";\nimport { Param } from \"../core/context/Param\";\n\nexport type GreaterThanOptions = SignalOptions<\"number\">;\n\n/**\n * Output 1 if the signal is greater than the value, otherwise outputs 0.\n * can compare two signals or a signal and a number.\n * \n * @example\n * return Tone.Offline(() => {\n * \tconst gt = new Tone.GreaterThan(2).toDestination();\n * \tconst sig = new Tone.Signal(4).connect(gt);\n * }, 0.1, 1);\n * @category Signal\n */\nexport class GreaterThan extends Signal<\"number\"> {\n\n\treadonly name: string = \"GreaterThan\"\n\n\treadonly override: boolean = false;\n\n\treadonly input: ToneAudioNode;\n\treadonly output: ToneAudioNode;\n\n\t/**\n\t * compare that amount to zero after subtracting\n\t */\n\tprivate _gtz: GreaterThanZero;\n\n\t/**\n\t * Subtract the value from the input node\n\t */\n\tprivate _subtract: Subtract;\n\n\t/**\n\t * The signal to compare to the incoming signal against.\n\t * @example\n\t * return Tone.Offline(() => {\n\t * \t// change the comparison value\n\t * \tconst gt = new Tone.GreaterThan(1.5).toDestination();\n\t * \tconst signal = new Tone.Signal(1).connect(gt);\n\t * \tgt.comparator.setValueAtTime(0.5, 0.1);\n\t * }, 0.5, 1);\n\t */\n\treadonly comparator: Param<\"number\">\n\n\t/**\n\t * @param value The value to compare to\n\t */\n\tconstructor(value?: number);\n\tconstructor(options?: Partial<GreaterThanOptions>);\n\tconstructor() {\n\t\tsuper(Object.assign(optionsFromArguments(GreaterThan.getDefaults(), arguments, [\"value\"])));\n\t\tconst options = optionsFromArguments(GreaterThan.getDefaults(), arguments, [\"value\"]);\n\n\t\tthis._subtract = this.input = new Subtract({\n\t\t\tcontext: this.context,\n\t\t\tvalue: options.value\n\t\t});\n\t\tthis._gtz = this.output = new GreaterThanZero({ context: this.context });\n\n\t\tthis.comparator = this._param = this._subtract.subtrahend;\n\t\treadOnly(this, \"comparator\");\n\n\t\t// connect\n\t\tthis._subtract.connect(this._gtz);\n\t}\n\n\tstatic getDefaults(): GreaterThanOptions {\n\t\treturn Object.assign(Signal.getDefaults(), {\n\t\t\tvalue: 0,\n\t\t});\n\t}\n\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis._gtz.dispose();\n\t\tthis._subtract.dispose();\n\t\tthis.comparator.dispose();\n\t\treturn this;\n\t}\n}\n","import { WaveShaper, WaveShaperMappingFn } from \"./WaveShaper\";\nimport { optionsFromArguments } from \"../core/util/Defaults\";\nimport { SignalOperator } from \"./SignalOperator\";\nimport { ToneAudioNodeOptions } from \"../core/context/ToneAudioNode\";\n\nexport interface PowOptions extends ToneAudioNodeOptions {\n\tvalue: number;\n}\n\n/**\n * Pow applies an exponent to the incoming signal. The incoming signal must be AudioRange [-1, 1]\n *\n * @example\n * const pow = new Tone.Pow(2);\n * const sig = new Tone.Signal(0.5).connect(pow);\n * // output of pow is 0.25. \n * @category Signal\n */\nexport class Pow extends SignalOperator<PowOptions> {\n\n\treadonly name: string = \"Pow\";\n\n\tprivate _exponent: number;\n\n\tprivate _exponentScaler: WaveShaper;\n\n\tinput: WaveShaper;\n\n\toutput: WaveShaper;\n\n\t/**\n\t * @param value Constant exponent value to use\n\t */\n\tconstructor(value?: number);\n\tconstructor(options?: Partial<PowOptions>);\n\tconstructor() {\n\t\tsuper(Object.assign(optionsFromArguments(Pow.getDefaults(), arguments, [\"value\"])));\n\t\tconst options = optionsFromArguments(Pow.getDefaults(), arguments, [\"value\"]);\n\n\t\tthis._exponentScaler = this.input = this.output = new WaveShaper({\n\t\t\tcontext: this.context,\n\t\t\tmapping: this._expFunc(options.value),\n\t\t\tlength: 8192,\n\t\t});\n\n\t\tthis._exponent = options.value;\n\t}\n\n\tstatic getDefaults(): PowOptions {\n\t\treturn Object.assign(SignalOperator.getDefaults(), {\n\t\t\tvalue: 1,\n\t\t});\n\t}\n\n\t/**\n\t * the function which maps the waveshaper\n\t * @param exponent exponent value\n\t */\n\tprivate _expFunc(exponent: number): WaveShaperMappingFn {\n\t\treturn (val: number) => {\n\t\t\treturn Math.pow(Math.abs(val), exponent);\n\t\t};\n\t}\n\n\t/**\n\t * The value of the exponent.\n\t */\n\tget value(): number {\n\t\treturn this._exponent;\n\t}\n\tset value(exponent: number) {\n\t\tthis._exponent = exponent;\n\t\tthis._exponentScaler.setMap(this._expFunc(this._exponent));\n\t}\n\n\t/**\n\t * Clean up.\n\t */\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis._exponentScaler.dispose();\n\t\treturn this;\n\t}\n}\n","import { Scale, ScaleOptions } from \"./Scale\";\nimport { Positive } from \"../core/type/Units\";\nimport { optionsFromArguments } from \"../core/util/Defaults\";\nimport { Pow } from \"./Pow\";\n\nexport interface ScaleExpOptions extends ScaleOptions {\n\texponent: Positive;\n}\n\n/**\n * Performs an exponential scaling on an input signal.\n * Scales a NormalRange value [0,1] exponentially\n * to the output range of outputMin to outputMax.\n * @example\n * const scaleExp = new Tone.ScaleExp(0, 100, 2);\n * const signal = new Tone.Signal(0.5).connect(scaleExp);\n * @category Signal\n */\nexport class ScaleExp extends Scale<ScaleExpOptions> {\n\n\treadonly name: string = \"ScaleExp\";\n\n\t/**\n\t * The exponent scaler\n\t */\n\tprivate _exp: Pow;\n\n\t/**\n\t * @param min The output value when the input is 0.\n\t * @param max The output value when the input is 1.\n\t * @param exponent The exponent which scales the incoming signal.\n\t */\n\tconstructor(min?: number, max?: number, exponent?: number);\n\tconstructor(options?: Partial<ScaleExpOptions>);\n\tconstructor() {\n\t\tsuper(Object.assign(optionsFromArguments(ScaleExp.getDefaults(), arguments, [\"min\", \"max\", \"exponent\"])));\n\t\tconst options = optionsFromArguments(ScaleExp.getDefaults(), arguments, [\"min\", \"max\", \"exponent\"]);\n\n\t\tthis.input = this._exp = new Pow({\n\t\t\tcontext: this.context,\n\t\t\tvalue: options.exponent,\n\t\t});\n\t\tthis._exp.connect(this._mult);\n\t}\n\n\tstatic getDefaults(): ScaleExpOptions {\n\t\treturn Object.assign(Scale.getDefaults(), {\n\t\t\texponent: 1,\n\t\t});\n\t}\n\n\t/**\n\t * Instead of interpolating linearly between the [[min]] and\n\t * [[max]] values, setting the exponent will interpolate between\n\t * the two values with an exponential curve.\n\t */\n\tget exponent(): Positive {\n\t\treturn this._exp.value;\n\t}\n\tset exponent(exp) {\n\t\tthis._exp.value = exp;\n\t}\n\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis._exp.dispose();\n\t\treturn this;\n\t}\n}\n","import { Signal, SignalOptions } from \"./Signal\";\nimport { NormalRange, Seconds, Time, TransportTime, UnitMap, UnitName } from \"../core/type/Units\";\nimport { optionsFromArguments } from \"../core/util/Defaults\";\nimport { TransportTimeClass } from \"../core/type/TransportTime\";\nimport { ToneConstantSource } from \"./ToneConstantSource\";\nimport { OutputNode } from \"../core/context/ToneAudioNode\";\n\n/**\n * Adds the ability to synchronize the signal to the [[Transport]]\n */\nexport class SyncedSignal<TypeName extends UnitName = \"number\"> extends Signal<TypeName> {\n\n\treadonly name: string = \"SyncedSignal\";\n\t\n\t/**\n\t * Don't override when something is connected to the input\n\t */\n\treadonly override = false;\n\n\treadonly output: OutputNode;\n\n\t/**\n\t * Keep track of the last value as an optimization.\n\t */\n\tprivate _lastVal: UnitMap[TypeName];\n\n\t/**\n\t * The ID returned from scheduleRepeat\n\t */\n\tprivate _synced: number;\n\n\t/**\n\t * Remember the callback value\n\t */\n\tprivate _syncedCallback: () => void;\n\n\t/**\n\t * @param value Initial value of the signal\n\t * @param units The unit name, e.g. \"frequency\"\n\t */\n\tconstructor(value?: UnitMap[TypeName], units?: TypeName);\n\tconstructor(options?: Partial<SignalOptions<TypeName>>);\n\tconstructor() {\n\n\t\tsuper(optionsFromArguments(Signal.getDefaults(), arguments, [\"value\", \"units\"]));\n\t\tconst options = optionsFromArguments(Signal.getDefaults(), arguments, [\"value\", \"units\"]) as SignalOptions<TypeName>;\n\n\t\tthis._lastVal = options.value;\n\t\tthis._synced = this.context.transport.scheduleRepeat(this._onTick.bind(this), \"1i\");\n\n\t\tthis._syncedCallback = this._anchorValue.bind(this);\n\t\tthis.context.transport.on(\"start\", this._syncedCallback);\n\t\tthis.context.transport.on(\"pause\", this._syncedCallback);\n\t\tthis.context.transport.on(\"stop\", this._syncedCallback);\n\n\t\t// disconnect the constant source from the output and replace it with another one\n\t\tthis._constantSource.disconnect();\n\t\tthis._constantSource.stop(0);\n\n\t\t// create a new one\n\t\tthis._constantSource = this.output = new ToneConstantSource<TypeName>({ \n\t\t\tcontext: this.context,\n\t\t\toffset: options.value,\n\t\t\tunits: options.units,\n\t\t}).start(0);\n\t\tthis.setValueAtTime(options.value, 0);\n\t}\n\n\t/**\n\t * Callback which is invoked every tick.\n\t */\n\tprivate _onTick(time: Seconds): void {\n\t\tconst val = super.getValueAtTime(this.context.transport.seconds);\n\t\t// approximate ramp curves with linear ramps\n\t\tif (this._lastVal !== val) {\n\t\t\tthis._lastVal = val;\n\t\t\tthis._constantSource.offset.setValueAtTime(val, time);\n\t\t}\n\t}\n\n\t/**\n\t * Anchor the value at the start and stop of the Transport\n\t */\n\tprivate _anchorValue(time: Seconds): void {\n\t\tconst val = super.getValueAtTime(this.context.transport.seconds);\n\t\tthis._lastVal = val;\n\t\tthis._constantSource.offset.cancelAndHoldAtTime(time);\n\t\tthis._constantSource.offset.setValueAtTime(val, time);\n\t}\n\n\tgetValueAtTime(time: TransportTime): UnitMap[TypeName] {\n\t\tconst computedTime = new TransportTimeClass(this.context, time).toSeconds();\n\t\treturn super.getValueAtTime(computedTime);\n\t}\n\t\n\tsetValueAtTime(value: UnitMap[TypeName], time: TransportTime) {\n\t\tconst computedTime = new TransportTimeClass(this.context, time).toSeconds();\n\t\tsuper.setValueAtTime(value, computedTime);\n\t\treturn this;\n\t}\n\n\tlinearRampToValueAtTime(value: UnitMap[TypeName], time: TransportTime) {\n\t\tconst computedTime = new TransportTimeClass(this.context, time).toSeconds();\n\t\tsuper.linearRampToValueAtTime(value, computedTime);\n\t\treturn this;\n\t}\n\n\texponentialRampToValueAtTime(value: UnitMap[TypeName], time: TransportTime) {\n\t\tconst computedTime = new TransportTimeClass(this.context, time).toSeconds();\n\t\tsuper.exponentialRampToValueAtTime(value, computedTime);\n\t\treturn this;\n\t}\n\n\tsetTargetAtTime(value, startTime: TransportTime, timeConstant: number): this {\n\t\tconst computedTime = new TransportTimeClass(this.context, startTime).toSeconds();\n\t\tsuper.setTargetAtTime(value, computedTime, timeConstant);\n\t\treturn this;\n\t}\n\n\tcancelScheduledValues(startTime: TransportTime): this {\n\t\tconst computedTime = new TransportTimeClass(this.context, startTime).toSeconds();\n\t\tsuper.cancelScheduledValues(computedTime);\n\t\treturn this;\n\t}\n\n\tsetValueCurveAtTime(values: UnitMap[TypeName][], startTime: TransportTime, duration: Time, scaling: NormalRange): this {\n\t\tconst computedTime = new TransportTimeClass(this.context, startTime).toSeconds();\n\t\tduration = this.toSeconds(duration);\n\t\tsuper.setValueCurveAtTime(values, computedTime, duration, scaling);\n\t\treturn this;\n\t}\n\n\tcancelAndHoldAtTime(time: TransportTime): this {\n\t\tconst computedTime = new TransportTimeClass(this.context, time).toSeconds();\n\t\tsuper.cancelAndHoldAtTime(computedTime);\n\t\treturn this;\n\t}\n\t\n\tsetRampPoint(time: TransportTime): this {\n\t\tconst computedTime = new TransportTimeClass(this.context, time).toSeconds();\n\t\tsuper.setRampPoint(computedTime);\n\t\treturn this;\n\t}\n\t\n\texponentialRampTo(value: UnitMap[TypeName], rampTime: Time, startTime?: TransportTime): this {\n\t\tconst computedTime = new TransportTimeClass(this.context, startTime).toSeconds();\n\t\tsuper.exponentialRampTo(value, rampTime, computedTime);\n\t\treturn this;\n\t}\n\t\n\tlinearRampTo(value: UnitMap[TypeName], rampTime: Time, startTime?: TransportTime): this {\n\t\tconst computedTime = new TransportTimeClass(this.context, startTime).toSeconds();\n\t\tsuper.linearRampTo(value, rampTime, computedTime);\n\t\treturn this;\n\t}\n\n\ttargetRampTo(value: UnitMap[TypeName], rampTime: Time, startTime?: TransportTime): this {\n\t\tconst computedTime = new TransportTimeClass(this.context, startTime).toSeconds();\n\t\tsuper.targetRampTo(value, rampTime, computedTime);\n\t\treturn this;\n\t}\n\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis.context.transport.clear(this._synced);\n\t\tthis.context.transport.off(\"start\", this._syncedCallback);\n\t\tthis.context.transport.off(\"pause\", this._syncedCallback);\n\t\tthis.context.transport.off(\"stop\", this._syncedCallback);\n\t\tthis._constantSource.dispose();\n\t\treturn this;\n\t}\n}\n","import { InputNode, OutputNode } from \"../../core/context/ToneAudioNode\";\nimport { ToneAudioNode, ToneAudioNodeOptions } from \"../../core/context/ToneAudioNode\";\nimport { NormalRange, Time } from \"../../core/type/Units\";\nimport { optionsFromArguments } from \"../../core/util/Defaults\";\nimport { isArray, isObject, isString } from \"../../core/util/TypeCheck\";\nimport { connectSignal, Signal } from \"../../signal/Signal\";\nimport { OfflineContext } from \"../../core/context/OfflineContext\";\nimport { assert } from \"../../core/util/Debug\";\nimport { range, timeRange } from \"../../core/util/Decorator\";\n\ntype BasicEnvelopeCurve = \"linear\" | \"exponential\";\ntype InternalEnvelopeCurve = BasicEnvelopeCurve | number[];\nexport type EnvelopeCurve = EnvelopeCurveName | number[];\n\nexport interface EnvelopeOptions extends ToneAudioNodeOptions {\n\tattack: Time;\n\tdecay: Time;\n\tsustain: NormalRange;\n\trelease: Time;\n\tattackCurve: EnvelopeCurve;\n\treleaseCurve: EnvelopeCurve;\n\tdecayCurve: BasicEnvelopeCurve;\n}\n\n/**\n * Envelope is an [ADSR](https://en.wikipedia.org/wiki/Synthesizer#ADSR_envelope)\n * envelope generator. Envelope outputs a signal which\n * can be connected to an AudioParam or Tone.Signal.\n * ```\n *           /\\\n *          /  \\\n *         /    \\\n *        /      \\\n *       /        \\___________\n *      /                     \\\n *     /                       \\\n *    /                         \\\n *   /                           \\\n * ```\n * @example\n * return Tone.Offline(() => {\n * \tconst env = new Tone.Envelope({\n * \t\tattack: 0.1,\n * \t\tdecay: 0.2,\n * \t\tsustain: 0.5,\n * \t\trelease: 0.8,\n * \t}).toDestination();\n * \tenv.triggerAttackRelease(0.5);\n * }, 1.5, 1);\n * @category Component\n */\nexport class Envelope extends ToneAudioNode<EnvelopeOptions> {\n\n\treadonly name: string = \"Envelope\";\n\n\t/**\n\t * When triggerAttack is called, the attack time is the amount of\n\t * time it takes for the envelope to reach it's maximum value.\n\t * ```\n\t *           /\\\n\t *          /X \\\n\t *         /XX  \\\n\t *        /XXX   \\\n\t *       /XXXX    \\___________\n\t *      /XXXXX                \\\n\t *     /XXXXXX                 \\\n\t *    /XXXXXXX                  \\\n\t *   /XXXXXXXX                   \\\n\t * ```\n\t * @min 0\n\t * @max 2\n\t */\n\t@timeRange(0)\n\tattack: Time;\n\n\t/**\n\t * After the attack portion of the envelope, the value will fall\n\t * over the duration of the decay time to it's sustain value.\n\t * ```\n\t *           /\\\n\t *          / X\\\n\t *         /  XX\\\n\t *        /   XXX\\\n\t *       /    XXXX\\___________\n\t *      /     XXXXX           \\\n\t *     /      XXXXX            \\\n\t *    /       XXXXX             \\\n\t *   /        XXXXX              \\\n\t * ```\n\t * @min 0\n\t * @max 2\n\t */\n\t@timeRange(0)\n\tdecay: Time;\n\n\t/**\n\t * The sustain value is the value\n\t * which the envelope rests at after triggerAttack is\n\t * called, but before triggerRelease is invoked.\n\t * ```\n\t *           /\\\n\t *          /  \\\n\t *         /    \\\n\t *        /      \\\n\t *       /        \\___________\n\t *      /          XXXXXXXXXXX\\\n\t *     /           XXXXXXXXXXX \\\n\t *    /            XXXXXXXXXXX  \\\n\t *   /             XXXXXXXXXXX   \\\n\t * ```\n\t */\n\t@range(0, 1)\n\tsustain: NormalRange;\n\n\t/**\n\t * After triggerRelease is called, the envelope's\n\t * value will fall to it's miminum value over the\n\t * duration of the release time.\n\t * ```\n\t *           /\\\n\t *          /  \\\n\t *         /    \\\n\t *        /      \\\n\t *       /        \\___________\n\t *      /                    X\\\n\t *     /                     XX\\\n\t *    /                      XXX\\\n\t *   /                       XXXX\\\n\t * ```\n\t * @min 0\n\t * @max 5\n\t */\n\t@timeRange(0)\n\trelease: Time;\n\n\t/**\n\t * The automation curve type for the attack\n\t */\n\tprivate _attackCurve!: InternalEnvelopeCurve;\n\n\t/**\n\t * The automation curve type for the decay\n\t */\n\tprivate _decayCurve!: BasicEnvelopeCurve;\n\n\t/**\n\t * The automation curve type for the release\n\t */\n\tprivate _releaseCurve!: InternalEnvelopeCurve;\n\n\t/**\n\t * the signal which is output.\n\t */\n\tprotected _sig: Signal<\"normalRange\"> = new Signal({\n\t\tcontext: this.context,\n\t\tvalue: 0,\n\t});\n\n\t/**\n\t * The output signal of the envelope\n\t */\n\toutput: OutputNode = this._sig;\n\n\t/**\n\t * Envelope has no input\n\t */\n\tinput: InputNode | undefined = undefined;\n\n\t/**\n\t * @param attack The amount of time it takes for the envelope to go from\n\t *                        0 to it's maximum value.\n\t * @param decay\tThe period of time after the attack that it takes for the envelope\n\t *                      \tto fall to the sustain value. Value must be greater than 0.\n\t * @param sustain\tThe percent of the maximum value that the envelope rests at until\n\t *                               \tthe release is triggered.\n\t * @param release\tThe amount of time after the release is triggered it takes to reach 0.\n\t *                        \tValue must be greater than 0.\n\t */\n\tconstructor(attack?: Time, decay?: Time, sustain?: NormalRange, release?: Time);\n\tconstructor(options?: Partial<EnvelopeOptions>)\n\tconstructor() {\n\n\t\tsuper(optionsFromArguments(Envelope.getDefaults(), arguments, [\"attack\", \"decay\", \"sustain\", \"release\"]));\n\t\tconst options = optionsFromArguments(Envelope.getDefaults(), arguments, [\"attack\", \"decay\", \"sustain\", \"release\"]);\n\n\t\tthis.attack = options.attack;\n\t\tthis.decay = options.decay;\n\t\tthis.sustain = options.sustain;\n\t\tthis.release = options.release;\n\t\tthis.attackCurve = options.attackCurve;\n\t\tthis.releaseCurve = options.releaseCurve;\n\t\tthis.decayCurve = options.decayCurve;\n\t}\n\n\tstatic getDefaults(): EnvelopeOptions {\n\t\treturn Object.assign(ToneAudioNode.getDefaults(), {\n\t\t\tattack: 0.01,\n\t\t\tattackCurve: \"linear\" as EnvelopeCurveName,\n\t\t\tdecay: 0.1,\n\t\t\tdecayCurve: \"exponential\" as BasicEnvelopeCurve,\n\t\t\trelease: 1,\n\t\t\treleaseCurve: \"exponential\" as EnvelopeCurveName,\n\t\t\tsustain: 0.5,\n\t\t});\n\t}\n\n\t/**\n\t * Read the current value of the envelope. Useful for\n\t * synchronizing visual output to the envelope.\n\t */\n\tget value(): NormalRange {\n\t\treturn this.getValueAtTime(this.now());\n\t}\n\n\t/**\n\t * Get the curve\n\t * @param  curve\n\t * @param  direction  In/Out\n\t * @return The curve name\n\t */\n\tprivate _getCurve(curve: InternalEnvelopeCurve, direction: EnvelopeDirection): EnvelopeCurve {\n\t\tif (isString(curve)) {\n\t\t\treturn curve;\n\t\t} else {\n\t\t\t// look up the name in the curves array\n\t\t\tlet curveName: EnvelopeCurveName;\n\t\t\tfor (curveName in EnvelopeCurves) {\n\t\t\t\tif (EnvelopeCurves[curveName][direction] === curve) {\n\t\t\t\t\treturn curveName;\n\t\t\t\t}\n\t\t\t}\n\t\t\t// return the custom curve\n\t\t\treturn curve;\n\t\t}\n\t}\n\n\t/**\n\t * Assign a the curve to the given name using the direction\n\t * @param  name\n\t * @param  direction In/Out\n\t * @param  curve\n\t */\n\tprivate _setCurve(\n\t\tname: \"_attackCurve\" | \"_decayCurve\" | \"_releaseCurve\",\n\t\tdirection: EnvelopeDirection,\n\t\tcurve: EnvelopeCurve,\n\t): void {\n\t\t// check if it's a valid type\n\t\tif (isString(curve) && Reflect.has(EnvelopeCurves, curve)) {\n\t\t\tconst curveDef = EnvelopeCurves[curve];\n\t\t\tif (isObject(curveDef)) {\n\t\t\t\tif (name !== \"_decayCurve\") {\n\t\t\t\t\tthis[name] = curveDef[direction];\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tthis[name] = curveDef;\n\t\t\t}\n\t\t} else if (isArray(curve) && name !== \"_decayCurve\") {\n\t\t\tthis[name] = curve;\n\t\t} else {\n\t\t\tthrow new Error(\"Envelope: invalid curve: \" + curve);\n\t\t}\n\t}\n\n\t/**\n\t * The shape of the attack.\n\t * Can be any of these strings:\n\t * * \"linear\"\n\t * * \"exponential\"\n\t * * \"sine\"\n\t * * \"cosine\"\n\t * * \"bounce\"\n\t * * \"ripple\"\n\t * * \"step\"\n\t *\n\t * Can also be an array which describes the curve. Values\n\t * in the array are evenly subdivided and linearly\n\t * interpolated over the duration of the attack.\n\t * @example\n\t * return Tone.Offline(() => {\n\t * \tconst env = new Tone.Envelope(0.4).toDestination();\n\t * \tenv.attackCurve = \"linear\";\n\t * \tenv.triggerAttack();\n\t * }, 1, 1);\n\t */\n\tget attackCurve(): EnvelopeCurve {\n\t\treturn this._getCurve(this._attackCurve, \"In\");\n\t}\n\tset attackCurve(curve) {\n\t\tthis._setCurve(\"_attackCurve\", \"In\", curve);\n\t}\n\n\t/**\n\t * The shape of the release. See the attack curve types.\n\t * @example\n\t * return Tone.Offline(() => {\n\t * \tconst env = new Tone.Envelope({\n\t * \t\trelease: 0.8\n\t * \t}).toDestination();\n\t * \tenv.triggerAttack();\n\t * \t// release curve could also be defined by an array\n\t * \tenv.releaseCurve = [1, 0.3, 0.4, 0.2, 0.7, 0];\n\t * \tenv.triggerRelease(0.2);\n\t * }, 1, 1);\n\t */\n\tget releaseCurve(): EnvelopeCurve {\n\t\treturn this._getCurve(this._releaseCurve, \"Out\");\n\t}\n\tset releaseCurve(curve) {\n\t\tthis._setCurve(\"_releaseCurve\", \"Out\", curve);\n\t}\n\n\t/**\n\t * The shape of the decay either \"linear\" or \"exponential\"\n\t * @example\n\t * return Tone.Offline(() => {\n\t * \tconst env = new Tone.Envelope({\n\t * \t\tsustain: 0.1,\n\t * \t\tdecay: 0.5\n\t * \t}).toDestination();\n\t * \tenv.decayCurve = \"linear\";\n\t * \tenv.triggerAttack();\n\t * }, 1, 1);\n\t */\n\tget decayCurve(): BasicEnvelopeCurve {\n\t\treturn this._decayCurve;\n\t}\n\tset decayCurve(curve) {\n\t\tassert([\"linear\", \"exponential\"].some(c => c === curve), `Invalid envelope curve: ${curve}`);\n\t\tthis._decayCurve = curve;\n\t}\n\n\t/**\n\t * Trigger the attack/decay portion of the ADSR envelope.\n\t * @param  time When the attack should start.\n\t * @param velocity The velocity of the envelope scales the vales.\n\t *                             number between 0-1\n\t * @example\n\t * const env = new Tone.AmplitudeEnvelope().toDestination();\n\t * const osc = new Tone.Oscillator().connect(env).start();\n\t * // trigger the attack 0.5 seconds from now with a velocity of 0.2\n\t * env.triggerAttack(\"+0.5\", 0.2);\n\t */\n\ttriggerAttack(time?: Time, velocity: NormalRange = 1): this {\n\t\tthis.log(\"triggerAttack\", time, velocity);\n\t\ttime = this.toSeconds(time);\n\t\tconst originalAttack = this.toSeconds(this.attack);\n\t\tlet attack = originalAttack;\n\t\tconst decay = this.toSeconds(this.decay);\n\t\t// check if it's not a complete attack\n\t\tconst currentValue = this.getValueAtTime(time);\n\t\tif (currentValue > 0) {\n\t\t\t// subtract the current value from the attack time\n\t\t\tconst attackRate = 1 / attack;\n\t\t\tconst remainingDistance = 1 - currentValue;\n\t\t\t// the attack is now the remaining time\n\t\t\tattack = remainingDistance / attackRate;\n\t\t}\n\t\t// attack\n\t\tif (attack < this.sampleTime) {\n\t\t\tthis._sig.cancelScheduledValues(time);\n\t\t\t// case where the attack time is 0 should set instantly\n\t\t\tthis._sig.setValueAtTime(velocity, time);\n\t\t} else if (this._attackCurve === \"linear\") {\n\t\t\tthis._sig.linearRampTo(velocity, attack, time);\n\t\t} else if (this._attackCurve === \"exponential\") {\n\t\t\tthis._sig.targetRampTo(velocity, attack, time);\n\t\t} else {\n\t\t\tthis._sig.cancelAndHoldAtTime(time);\n\t\t\tlet curve = this._attackCurve;\n\t\t\t// find the starting position in the curve\n\t\t\tfor (let i = 1; i < curve.length; i++) {\n\t\t\t\t// the starting index is between the two values\n\t\t\t\tif (curve[i - 1] <= currentValue && currentValue <= curve[i]) {\n\t\t\t\t\tcurve = this._attackCurve.slice(i);\n\t\t\t\t\t// the first index is the current value\n\t\t\t\t\tcurve[0] = currentValue;\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t\tthis._sig.setValueCurveAtTime(curve, time, attack, velocity);\n\t\t}\n\t\t// decay\n\t\tif (decay && this.sustain < 1) {\n\t\t\tconst decayValue = velocity * this.sustain;\n\t\t\tconst decayStart = time + attack;\n\t\t\tthis.log(\"decay\", decayStart);\n\t\t\tif (this._decayCurve === \"linear\") {\n\t\t\t\tthis._sig.linearRampToValueAtTime(decayValue, decay + decayStart);\n\t\t\t} else {\n\t\t\t\tthis._sig.exponentialApproachValueAtTime(decayValue, decayStart, decay);\n\t\t\t}\n\t\t}\n\t\treturn this;\n\t}\n\n\t/**\n\t * Triggers the release of the envelope.\n\t * @param  time When the release portion of the envelope should start.\n\t * @example\n\t * const env = new Tone.AmplitudeEnvelope().toDestination();\n\t * const osc = new Tone.Oscillator({\n\t * \ttype: \"sawtooth\"\n\t * }).connect(env).start();\n\t * env.triggerAttack();\n\t * // trigger the release half a second after the attack\n\t * env.triggerRelease(\"+0.5\");\n\t */\n\ttriggerRelease(time?: Time): this {\n\t\tthis.log(\"triggerRelease\", time);\n\t\ttime = this.toSeconds(time);\n\t\tconst currentValue = this.getValueAtTime(time);\n\t\tif (currentValue > 0) {\n\t\t\tconst release = this.toSeconds(this.release);\n\t\t\tif (release < this.sampleTime) {\n\t\t\t\tthis._sig.setValueAtTime(0, time);\n\t\t\t} else if (this._releaseCurve === \"linear\") {\n\t\t\t\tthis._sig.linearRampTo(0, release, time);\n\t\t\t} else if (this._releaseCurve === \"exponential\") {\n\t\t\t\tthis._sig.targetRampTo(0, release, time);\n\t\t\t} else {\n\t\t\t\tassert(isArray(this._releaseCurve), \"releaseCurve must be either 'linear', 'exponential' or an array\");\n\t\t\t\tthis._sig.cancelAndHoldAtTime(time);\n\t\t\t\tthis._sig.setValueCurveAtTime(this._releaseCurve, time, release, currentValue);\n\t\t\t}\n\t\t}\n\t\treturn this;\n\t}\n\n\t/**\n\t * Get the scheduled value at the given time. This will\n\t * return the unconverted (raw) value.\n\t * @example\n\t * const env = new Tone.Envelope(0.5, 1, 0.4, 2);\n\t * env.triggerAttackRelease(2);\n\t * setInterval(() => console.log(env.getValueAtTime(Tone.now())), 100);\n\t */\n\tgetValueAtTime(time: Time): NormalRange {\n\t\treturn this._sig.getValueAtTime(time);\n\t}\n\n\t/**\n\t * triggerAttackRelease is shorthand for triggerAttack, then waiting\n\t * some duration, then triggerRelease.\n\t * @param duration The duration of the sustain.\n\t * @param time When the attack should be triggered.\n\t * @param velocity The velocity of the envelope.\n\t * @example\n\t * const env = new Tone.AmplitudeEnvelope().toDestination();\n\t * const osc = new Tone.Oscillator().connect(env).start();\n\t * // trigger the release 0.5 seconds after the attack\n\t * env.triggerAttackRelease(0.5);\n\t */\n\ttriggerAttackRelease(duration: Time, time?: Time, velocity: NormalRange = 1): this {\n\t\ttime = this.toSeconds(time);\n\t\tthis.triggerAttack(time, velocity);\n\t\tthis.triggerRelease(time + this.toSeconds(duration));\n\t\treturn this;\n\t}\n\n\t/**\n\t * Cancels all scheduled envelope changes after the given time.\n\t */\n\tcancel(after?: Time): this {\n\t\tthis._sig.cancelScheduledValues(this.toSeconds(after));\n\t\treturn this;\n\t}\n\n\t/**\n\t * Connect the envelope to a destination node.\n\t */\n\tconnect(destination: InputNode, outputNumber = 0, inputNumber = 0): this {\n\t\tconnectSignal(this, destination, outputNumber, inputNumber);\n\t\treturn this;\n\t}\n\n\t/**\n\t * Render the envelope curve to an array of the given length. \n\t * Good for visualizing the envelope curve. Rescales the duration of the\n\t * envelope to fit the length.\n\t */\n\tasync asArray(length = 1024): Promise<Float32Array> {\n\t\tconst duration = length / this.context.sampleRate;\n\t\tconst context = new OfflineContext(1, duration, this.context.sampleRate);\n\t\t// normalize the ADSR for the given duration with 20% sustain time\n\t\tconst attackPortion = this.toSeconds(this.attack) + this.toSeconds(this.decay);\n\t\tconst envelopeDuration = attackPortion + this.toSeconds(this.release);\n\t\tconst sustainTime = envelopeDuration * 0.1;\n\t\tconst totalDuration = envelopeDuration + sustainTime;\n\t\t// @ts-ignore\n\t\tconst clone = new this.constructor(Object.assign(this.get(), {\n\t\t\tattack: duration * this.toSeconds(this.attack) / totalDuration,\n\t\t\tdecay: duration * this.toSeconds(this.decay) / totalDuration,\n\t\t\trelease: duration * this.toSeconds(this.release) / totalDuration,\n\t\t\tcontext\n\t\t})) as Envelope;\n\t\tclone._sig.toDestination();\n\t\tclone.triggerAttackRelease(duration * (attackPortion + sustainTime) / totalDuration, 0);\n\t\tconst buffer = await context.render();\n\t\treturn buffer.getChannelData(0);\n\t}\n\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis._sig.dispose();\n\t\treturn this;\n\t}\n}\n\ninterface EnvelopeCurveObject {\n\tIn: number[];\n\tOut: number[];\n}\n\ntype EnvelopeDirection = keyof EnvelopeCurveObject;\n\ninterface EnvelopeCurveMap {\n\tlinear: \"linear\";\n\texponential: \"exponential\";\n\tbounce: EnvelopeCurveObject;\n\tcosine: EnvelopeCurveObject;\n\tsine: EnvelopeCurveObject;\n\tripple: EnvelopeCurveObject;\n\tstep: EnvelopeCurveObject;\n}\n\ntype EnvelopeCurveName = keyof EnvelopeCurveMap;\n\n/**\n * Generate some complex envelope curves.\n */\nconst EnvelopeCurves: EnvelopeCurveMap = (() => {\n\n\tconst curveLen = 128;\n\n\tlet i: number;\n\tlet k: number;\n\n\t// cosine curve\n\tconst cosineCurve: number[] = [];\n\tfor (i = 0; i < curveLen; i++) {\n\t\tcosineCurve[i] = Math.sin((i / (curveLen - 1)) * (Math.PI / 2));\n\t}\n\n\t// ripple curve\n\tconst rippleCurve: number[] = [];\n\tconst rippleCurveFreq = 6.4;\n\tfor (i = 0; i < curveLen - 1; i++) {\n\t\tk = (i / (curveLen - 1));\n\t\tconst sineWave = Math.sin(k * (Math.PI * 2) * rippleCurveFreq - Math.PI / 2) + 1;\n\t\trippleCurve[i] = sineWave / 10 + k * 0.83;\n\t}\n\trippleCurve[curveLen - 1] = 1;\n\n\t// stairs curve\n\tconst stairsCurve: number[] = [];\n\tconst steps = 5;\n\tfor (i = 0; i < curveLen; i++) {\n\t\tstairsCurve[i] = Math.ceil((i / (curveLen - 1)) * steps) / steps;\n\t}\n\n\t// in-out easing curve\n\tconst sineCurve: number[] = [];\n\tfor (i = 0; i < curveLen; i++) {\n\t\tk = i / (curveLen - 1);\n\t\tsineCurve[i] = 0.5 * (1 - Math.cos(Math.PI * k));\n\t}\n\n\t// a bounce curve\n\tconst bounceCurve: number[] = [];\n\tfor (i = 0; i < curveLen; i++) {\n\t\tk = i / (curveLen - 1);\n\t\tconst freq = Math.pow(k, 3) * 4 + 0.2;\n\t\tconst val = Math.cos(freq * Math.PI * 2 * k);\n\t\tbounceCurve[i] = Math.abs(val * (1 - k));\n\t}\n\n\t/**\n\t * Invert a value curve to make it work for the release\n\t */\n\tfunction invertCurve(curve: number[]): number[] {\n\t\tconst out = new Array(curve.length);\n\t\tfor (let j = 0; j < curve.length; j++) {\n\t\t\tout[j] = 1 - curve[j];\n\t\t}\n\t\treturn out;\n\t}\n\n\t/**\n\t * reverse the curve\n\t */\n\tfunction reverseCurve(curve: number[]): number[] {\n\t\treturn curve.slice(0).reverse();\n\t}\n\n\t/**\n\t * attack and release curve arrays\n\t */\n\treturn {\n\t\tbounce: {\n\t\t\tIn: invertCurve(bounceCurve),\n\t\t\tOut: bounceCurve,\n\t\t},\n\t\tcosine: {\n\t\t\tIn: cosineCurve,\n\t\t\tOut: reverseCurve(cosineCurve),\n\t\t},\n\t\texponential: \"exponential\" as const,\n\t\tlinear: \"linear\" as const,\n\t\tripple: {\n\t\t\tIn: rippleCurve,\n\t\t\tOut: invertCurve(rippleCurve),\n\t\t},\n\t\tsine: {\n\t\t\tIn: sineCurve,\n\t\t\tOut: invertCurve(sineCurve),\n\t\t},\n\t\tstep: {\n\t\t\tIn: stairsCurve,\n\t\t\tOut: invertCurve(stairsCurve),\n\t\t},\n\t};\n})();\n","import { Volume } from \"../component/channel/Volume\";\nimport { Param } from \"../core/context/Param\";\nimport { OutputNode, ToneAudioNode, ToneAudioNodeOptions } from \"../core/context/ToneAudioNode\";\nimport { Decibels, Frequency, NormalRange, Time } from \"../core/type/Units\";\nimport { optionsFromArguments } from \"../core/util/Defaults\";\nimport { readOnly } from \"../core/util/Interface\";\n\nexport interface InstrumentOptions extends ToneAudioNodeOptions {\n\tvolume: Decibels;\n}\n\n/**\n * Base-class for all instruments\n */\nexport abstract class Instrument<Options extends InstrumentOptions> extends ToneAudioNode<Options> {\n\n\t/**\n\t * The output and volume triming node\n\t */\n\tprivate _volume: Volume;\n\toutput: OutputNode;\n\n\t/**\n\t * The instrument only has an output\n\t */\n\tinput: undefined;\n\n\t/**\n\t * The volume of the output in decibels.\n\t * @example\n\t * const amSynth = new Tone.AMSynth().toDestination();\n\t * amSynth.volume.value = -6;\n\t * amSynth.triggerAttackRelease(\"G#3\", 0.2);\n\t */\n\tvolume: Param<\"decibels\">;\n\n\t/**\n\t * Keep track of all events scheduled to the transport\n\t * when the instrument is 'synced'\n\t */\n\tprivate _scheduledEvents: number[] = [];\n\n\t/**\n\t * If the instrument is currently synced\n\t */\n\tprivate _synced = false;\n\n\tconstructor(options?: Partial<InstrumentOptions>);\n\tconstructor() {\n\n\t\tsuper(optionsFromArguments(Instrument.getDefaults(), arguments));\n\t\tconst options = optionsFromArguments(Instrument.getDefaults(), arguments);\n\n\t\tthis._volume = this.output = new Volume({\n\t\t\tcontext: this.context,\n\t\t\tvolume: options.volume,\n\t\t});\n\t\tthis.volume = this._volume.volume;\n\t\treadOnly(this, \"volume\");\n\t}\n\n\tstatic getDefaults(): InstrumentOptions {\n\t\treturn Object.assign(ToneAudioNode.getDefaults(), {\n\t\t\tvolume: 0,\n\t\t});\n\t}\n\n\t/**\n\t * Sync the instrument to the Transport. All subsequent calls of\n\t * [[triggerAttack]] and [[triggerRelease]] will be scheduled along the transport.\n\t * @example\n\t * const fmSynth = new Tone.FMSynth().toDestination();\n\t * fmSynth.volume.value = -6;\n\t * fmSynth.sync();\n\t * // schedule 3 notes when the transport first starts\n\t * fmSynth.triggerAttackRelease(\"C4\", \"8n\", 0);\n\t * fmSynth.triggerAttackRelease(\"E4\", \"8n\", \"8n\");\n\t * fmSynth.triggerAttackRelease(\"G4\", \"8n\", \"4n\");\n\t * // start the transport to hear the notes\n\t * Tone.Transport.start();\n\t */\n\tsync(): this {\n\t\tif (this._syncState()) {\n\t\t\tthis._syncMethod(\"triggerAttack\", 1);\n\t\t\tthis._syncMethod(\"triggerRelease\", 0);\n\n\t\t\tthis.context.transport.on(\"stop\", this._syncedRelease);\n\t\t\tthis.context.transport.on(\"pause\", this._syncedRelease);\n\t\t\tthis.context.transport.on(\"loopEnd\", this._syncedRelease);\n\t\t}\n\t\treturn this;\n\t}\n\n\t/**\n\t * set _sync\n\t */\n\tprotected _syncState(): boolean {\n\t\tlet changed = false;\n\t\tif (!this._synced) {\n\t\t\tthis._synced = true;\n\t\t\tchanged = true;\n\t\t}\n\t\treturn changed;\n\t}\n\n\t/**\n\t * Wrap the given method so that it can be synchronized\n\t * @param method Which method to wrap and sync\n\t * @param  timePosition What position the time argument appears in\n\t */\n\tprotected _syncMethod(method: string, timePosition: number): void {\n\t\tconst originalMethod = this[\"_original_\" + method] = this[method];\n\t\tthis[method] = (...args: any[]) => {\n\t\t\tconst time = args[timePosition];\n\t\t\tconst id = this.context.transport.schedule((t) => {\n\t\t\t\targs[timePosition] = t;\n\t\t\t\toriginalMethod.apply(this, args);\n\t\t\t}, time);\n\t\t\tthis._scheduledEvents.push(id);\n\t\t};\n\t}\n\n\t/**\n\t * Unsync the instrument from the Transport\n\t */\n\tunsync(): this {\n\t\tthis._scheduledEvents.forEach(id => this.context.transport.clear(id));\n\t\tthis._scheduledEvents = [];\n\t\tif (this._synced) {\n\t\t\tthis._synced = false;\n\t\t\tthis.triggerAttack = this._original_triggerAttack;\n\t\t\tthis.triggerRelease = this._original_triggerRelease;\n\n\t\t\tthis.context.transport.off(\"stop\", this._syncedRelease);\n\t\t\tthis.context.transport.off(\"pause\", this._syncedRelease);\n\t\t\tthis.context.transport.off(\"loopEnd\", this._syncedRelease);\n\t\t}\n\t\treturn this;\n\t}\n\n\t/**\n\t * Trigger the attack and then the release after the duration.\n\t * @param  note     The note to trigger.\n\t * @param  duration How long the note should be held for before\n\t *                         triggering the release. This value must be greater than 0.\n\t * @param time  When the note should be triggered.\n\t * @param  velocity The velocity the note should be triggered at.\n\t * @example\n\t * const synth = new Tone.Synth().toDestination();\n\t * // trigger \"C4\" for the duration of an 8th note\n\t * synth.triggerAttackRelease(\"C4\", \"8n\");\n\t */\n\ttriggerAttackRelease(note: Frequency, duration: Time, time?: Time, velocity?: NormalRange): this {\n\t\tconst computedTime = this.toSeconds(time);\n\t\tconst computedDuration = this.toSeconds(duration);\n\t\tthis.triggerAttack(note, computedTime, velocity);\n\t\tthis.triggerRelease(computedTime + computedDuration);\n\t\treturn this;\n\t}\n\n\t/**\n\t * Start the instrument's note.\n\t * @param note the note to trigger\n\t * @param time the time to trigger the note\n\t * @param velocity the velocity to trigger the note (between 0-1)\n\t */\n\tabstract triggerAttack(note: Frequency, time?: Time, velocity?: NormalRange): this;\n\tprivate _original_triggerAttack = this.triggerAttack;\n\n\t/**\n\t * Trigger the release phase of the current note.\n\t * @param time when to trigger the release\n\t */\n\tabstract triggerRelease(...args: any[]): this;\n\tprivate _original_triggerRelease = this.triggerRelease;\n\n\t/**\n\t * The release which is scheduled to the timeline. \n\t */\n\tprotected _syncedRelease = (time: number) => this._original_triggerRelease(time);\n\n\t/**\n\t * clean up\n\t * @returns {Instrument} this\n\t */\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis._volume.dispose();\n\t\tthis.unsync();\n\t\tthis._scheduledEvents = [];\n\t\treturn this;\n\t}\n}\n","import { FrequencyClass } from \"../core/type/Frequency\";\nimport { Cents, Frequency, NormalRange, Seconds, Time } from \"../core/type/Units\";\nimport { optionsFromArguments } from \"../core/util/Defaults\";\nimport { noOp } from \"../core/util/Interface\";\nimport { Instrument, InstrumentOptions } from \"../instrument/Instrument\";\nimport { Signal } from \"../signal/Signal\";\nimport { timeRange } from \"../core/util/Decorator\";\n\ntype onSilenceCallback = (instrument: Monophonic<any>) => void;\n\nexport interface MonophonicOptions extends InstrumentOptions {\n\tportamento: Seconds;\n\tonsilence: onSilenceCallback;\n\tdetune: Cents;\n}\n\n/**\n * Abstract base class for other monophonic instruments to extend.\n */\nexport abstract class Monophonic<Options extends MonophonicOptions> extends Instrument<Options> {\n\n\t/**\n\t * The glide time between notes.\n\t */\n\t@timeRange(0)\n\tportamento: Seconds;\n\n\t/**\n\t * Invoked when the release has finished and the output is silent.\n\t */\n\tonsilence: onSilenceCallback;\n\n\t/**\n\t * The instrument's frequency signal.\n\t */\n\tabstract readonly frequency: Signal<\"frequency\">;\n\n\t/**\n\t * The instrument's detune control signal.\n\t */\n\tabstract readonly detune: Signal<\"cents\">;\n\n\tconstructor(options?: Partial<MonophonicOptions>);\n\tconstructor() {\n\n\t\tsuper(optionsFromArguments(Monophonic.getDefaults(), arguments));\n\t\tconst options = optionsFromArguments(Monophonic.getDefaults(), arguments);\n\n\t\tthis.portamento = options.portamento;\n\t\tthis.onsilence = options.onsilence;\n\t}\n\n\tstatic getDefaults(): MonophonicOptions {\n\t\treturn Object.assign(Instrument.getDefaults(), {\n\t\t\tdetune: 0,\n\t\t\tonsilence: noOp,\n\t\t\tportamento: 0,\n\t\t});\n\t}\n\n\t/**\n\t * Trigger the attack of the note optionally with a given velocity.\n\t * @param  note The note to trigger.\n\t * @param  time When the note should start.\n\t * @param  velocity The velocity determines how \"loud\" the note will be.\n\t * @example\n\t * const synth = new Tone.Synth().toDestination();\n\t * // trigger the note a half second from now at half velocity\n\t * synth.triggerAttack(\"C4\", \"+0.5\", 0.5);\n\t */\n\ttriggerAttack(note: Frequency | FrequencyClass, time?: Time, velocity: NormalRange = 1): this {\n\t\tthis.log(\"triggerAttack\", note, time, velocity);\n\t\tconst seconds = this.toSeconds(time);\n\t\tthis._triggerEnvelopeAttack(seconds, velocity);\n\t\tthis.setNote(note, seconds);\n\t\treturn this;\n\t}\n\n\t/**\n\t * Trigger the release portion of the envelope.\n\t * @param  time If no time is given, the release happens immediately.\n\t * @example\n\t * const synth = new Tone.Synth().toDestination();\n\t * synth.triggerAttack(\"C4\");\n\t * // trigger the release a second from now\n\t * synth.triggerRelease(\"+1\");\n\t */\n\ttriggerRelease(time?: Time): this {\n\t\tthis.log(\"triggerRelease\", time);\n\t\tconst seconds = this.toSeconds(time);\n\t\tthis._triggerEnvelopeRelease(seconds);\n\t\treturn this;\n\t}\n\n\t/**\n\t * Internal method which starts the envelope attack\n\t */\n\tprotected abstract _triggerEnvelopeAttack(time: Seconds, velocity: NormalRange): void;\n\n\t/**\n\t * Internal method which starts the envelope release\n\t */\n\tprotected abstract _triggerEnvelopeRelease(time: Seconds): void;\n\n\t/**\n\t * Get the level of the output at the given time. Measures\n\t * the envelope(s) value at the time.\n\t * @param time The time to query the envelope value\n\t * @return The output level between 0-1\n\t */\n\tabstract getLevelAtTime(time: Time): NormalRange;\n\n\t/**\n\t * Set the note at the given time. If no time is given, the note\n\t * will set immediately.\n\t * @param note The note to change to.\n\t * @param  time The time when the note should be set.\n\t * @example\n\t * const synth = new Tone.Synth().toDestination();\n\t * synth.triggerAttack(\"C4\");\n\t * // change to F#6 in one quarter note from now.\n\t * synth.setNote(\"F#6\", \"+4n\");\n\t */\n\tsetNote(note: Frequency | FrequencyClass, time?: Time): this {\n\t\tconst computedTime = this.toSeconds(time);\n\t\tconst computedFrequency = note instanceof FrequencyClass ? note.toFrequency() : note;\n\t\tif (this.portamento > 0 && this.getLevelAtTime(computedTime) > 0.05) {\n\t\t\tconst portTime = this.toSeconds(this.portamento);\n\t\t\tthis.frequency.exponentialRampTo(computedFrequency, portTime, computedTime);\n\t\t} else {\n\t\t\tthis.frequency.setValueAtTime(computedFrequency, computedTime);\n\t\t}\n\t\treturn this;\n\t}\n}\n","import { Gain } from \"../../core/context/Gain\";\nimport { NormalRange, Time } from \"../../core/type/Units\";\nimport { optionsFromArguments } from \"../../core/util/Defaults\";\nimport { Envelope, EnvelopeOptions } from \"./Envelope\";\n\n/**\n * AmplitudeEnvelope is a Tone.Envelope connected to a gain node.\n * Unlike Tone.Envelope, which outputs the envelope's value, AmplitudeEnvelope accepts\n * an audio signal as the input and will apply the envelope to the amplitude\n * of the signal.\n * Read more about ADSR Envelopes on [Wikipedia](https://en.wikipedia.org/wiki/Synthesizer#ADSR_envelope).\n *\n * @example\n * return Tone.Offline(() => {\n * \tconst ampEnv = new Tone.AmplitudeEnvelope({\n * \t\tattack: 0.1,\n * \t\tdecay: 0.2,\n * \t\tsustain: 1.0,\n * \t\trelease: 0.8\n * \t}).toDestination();\n * \t// create an oscillator and connect it\n * \tconst osc = new Tone.Oscillator().connect(ampEnv).start();\n * \t// trigger the envelopes attack and release \"8t\" apart\n * \tampEnv.triggerAttackRelease(\"8t\");\n * }, 1.5, 1);\n * @category Component\n */\nexport class AmplitudeEnvelope extends Envelope {\n\n\treadonly name: string = \"AmplitudeEnvelope\";\n\n\tprivate _gainNode: Gain = new Gain({\n\t\tcontext: this.context,\n\t\tgain: 0,\n\t});\n\toutput: Gain = this._gainNode;\n\tinput: Gain = this._gainNode;\n\n\t/**\n\t * @param attack The amount of time it takes for the envelope to go from 0 to it's maximum value.\n\t * @param decay\tThe period of time after the attack that it takes for the envelope\n\t *                      \tto fall to the sustain value. Value must be greater than 0.\n\t * @param sustain\tThe percent of the maximum value that the envelope rests at until\n\t *                               \tthe release is triggered.\n\t * @param release\tThe amount of time after the release is triggered it takes to reach 0.\n\t *                        \tValue must be greater than 0.\n\t */\n\tconstructor(attack?: Time, decay?: Time, sustain?: NormalRange, release?: Time);\n\tconstructor(options?: Partial<EnvelopeOptions>)\n\tconstructor() {\n\t\tsuper(optionsFromArguments(AmplitudeEnvelope.getDefaults(), arguments, [\"attack\", \"decay\", \"sustain\", \"release\"]));\n\t\tthis._sig.connect(this._gainNode.gain);\n\t\tthis.output = this._gainNode;\n\t\tthis.input = this._gainNode;\n\t}\n\n\t/**\n\t * Clean up\n\t */\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis._gainNode.dispose();\n\t\treturn this;\n\t}\n}\n","import { AmplitudeEnvelope } from \"../component/envelope/AmplitudeEnvelope\";\nimport { Envelope, EnvelopeOptions } from \"../component/envelope/Envelope\";\nimport { ToneAudioNode, ToneAudioNodeOptions } from \"../core/context/ToneAudioNode\";\nimport { NormalRange, Seconds, Time } from \"../core/type/Units\";\nimport { omitFromObject, optionsFromArguments } from \"../core/util/Defaults\";\nimport { readOnly } from \"../core/util/Interface\";\nimport { RecursivePartial } from \"../core/util/Interface\";\nimport { Signal } from \"../signal/Signal\";\nimport { OmniOscillator } from \"../source/oscillator/OmniOscillator\";\nimport { OmniOscillatorOptions, OmniOscillatorSynthOptions } from \"../source/oscillator/OscillatorInterface\";\nimport { Source } from \"../source/Source\";\nimport { Monophonic, MonophonicOptions } from \"./Monophonic\";\n\nexport interface SynthOptions extends MonophonicOptions {\n\toscillator: OmniOscillatorSynthOptions;\n\tenvelope: Omit<EnvelopeOptions, keyof ToneAudioNodeOptions>;\n}\n\n/**\n * Synth is composed simply of a [[OmniOscillator]] routed through an [[AmplitudeEnvelope]].\n * ```\n * +----------------+   +-------------------+\n * | OmniOscillator +>--> AmplitudeEnvelope +>--> Output\n * +----------------+   +-------------------+\n * ```\n * @example\n * const synth = new Tone.Synth().toDestination();\n * synth.triggerAttackRelease(\"C4\", \"8n\");\n * @category Instrument\n */\nexport class Synth<Options extends SynthOptions = SynthOptions> extends Monophonic<Options> {\n\n\treadonly name: string = \"Synth\";\n\n\t/**\n\t * The oscillator.\n\t */\n\treadonly oscillator: OmniOscillator<any>;\n\n\t/**\n\t * The frequency signal\n\t */\n\treadonly frequency: Signal<\"frequency\">;\n\n\t/**\n\t * The detune signal\n\t */\n\treadonly detune: Signal<\"cents\">;\n\n\t/**\n\t * The envelope\n\t */\n\treadonly envelope: AmplitudeEnvelope;\n\n\t/**\n\t * @param options the options available for the synth.\n\t */\n\tconstructor(options?: RecursivePartial<SynthOptions>);\n\tconstructor() {\n\t\tsuper(optionsFromArguments(Synth.getDefaults(), arguments));\n\t\tconst options = optionsFromArguments(Synth.getDefaults(), arguments);\n\n\t\tthis.oscillator = new OmniOscillator(Object.assign({\n\t\t\tcontext: this.context,\n\t\t\tdetune: options.detune,\n\t\t\tonstop: () => this.onsilence(this),\n\t\t}, options.oscillator));\n\n\t\tthis.frequency = this.oscillator.frequency;\n\t\tthis.detune = this.oscillator.detune;\n\n\t\tthis.envelope = new AmplitudeEnvelope(Object.assign({\n\t\t\tcontext: this.context,\n\t\t}, options.envelope));\n\n\t\t// connect the oscillators to the output\n\t\tthis.oscillator.chain(this.envelope, this.output);\n\t\treadOnly(this, [\"oscillator\", \"frequency\", \"detune\", \"envelope\"]);\n\t}\n\n\tstatic getDefaults(): SynthOptions {\n\t\treturn Object.assign(Monophonic.getDefaults(), {\n\t\t\tenvelope: Object.assign(\n\t\t\t\tomitFromObject(Envelope.getDefaults(), Object.keys(ToneAudioNode.getDefaults())),\n\t\t\t\t{\n\t\t\t\t\tattack: 0.005,\n\t\t\t\t\tdecay: 0.1,\n\t\t\t\t\trelease: 1,\n\t\t\t\t\tsustain: 0.3,\n\t\t\t\t},\n\t\t\t),\n\t\t\toscillator: Object.assign(\n\t\t\t\tomitFromObject(OmniOscillator.getDefaults(), [...Object.keys(Source.getDefaults()), \"frequency\", \"detune\"]),\n\t\t\t\t{\n\t\t\t\t\ttype: \"triangle\",\n\t\t\t\t},\n\t\t\t) as OmniOscillatorOptions,\n\t\t});\n\t}\n\n\t/**\n\t * start the attack portion of the envelope\n\t * @param time the time the attack should start\n\t * @param velocity the velocity of the note (0-1)\n\t */\n\tprotected _triggerEnvelopeAttack(time: Seconds, velocity: number): void {\n\t\t// the envelopes\n\t\tthis.envelope.triggerAttack(time, velocity);\n\t\tthis.oscillator.start(time);\n\t\t// if there is no release portion, stop the oscillator\n\t\tif (this.envelope.sustain === 0) {\n\t\t\tconst computedAttack = this.toSeconds(this.envelope.attack);\n\t\t\tconst computedDecay = this.toSeconds(this.envelope.decay);\n\t\t\tthis.oscillator.stop(time + computedAttack + computedDecay);\n\t\t}\n\t}\n\n\t/**\n\t * start the release portion of the envelope\n\t * @param time the time the release should start\n\t */\n\tprotected _triggerEnvelopeRelease(time: Seconds): void {\n\t\tthis.envelope.triggerRelease(time);\n\t\tthis.oscillator.stop(time + this.toSeconds(this.envelope.release));\n\t}\n\n\tgetLevelAtTime(time: Time): NormalRange {\n\t\ttime = this.toSeconds(time);\n\t\treturn this.envelope.getValueAtTime(time);\n\t}\n\n\t/**\n\t * clean up\n\t */\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis.oscillator.dispose();\n\t\tthis.envelope.dispose();\n\t\treturn this;\n\t}\n}\n","import { Signal } from \"../signal/Signal\";\nimport { Multiply } from \"../signal/Multiply\";\nimport { Gain } from \"../core/context/Gain\";\nimport { NormalRange, Positive, Seconds, Time } from \"../core/type/Units\";\nimport { Envelope, EnvelopeOptions } from \"../component/envelope/Envelope\";\nimport { ToneAudioNode, ToneAudioNodeOptions } from \"../core/context/ToneAudioNode\";\nimport { Monophonic } from \"./Monophonic\";\nimport { OmniOscillator } from \"../source/oscillator/OmniOscillator\";\nimport { OmniOscillatorSynthOptions } from \"../source/oscillator/OscillatorInterface\";\nimport { Source } from \"../source/Source\";\nimport { Synth, SynthOptions } from \"./Synth\";\nimport { AmplitudeEnvelope } from \"../component/envelope/AmplitudeEnvelope\";\nimport { readOnly, RecursivePartial } from \"../core/util/Interface\";\nimport { omitFromObject, optionsFromArguments } from \"../core/util/Defaults\";\n\nexport interface ModulationSynthOptions extends SynthOptions {\n\tharmonicity: Positive;\n\tmodulationEnvelope: Omit<EnvelopeOptions, keyof ToneAudioNodeOptions>;\n\tmodulation: OmniOscillatorSynthOptions;\n}\n/**\n * Base class for both AM and FM synths\n */\nexport abstract class ModulationSynth<Options extends ModulationSynthOptions> extends Monophonic<Options> {\n\n\treadonly name: string = \"ModulationSynth\";\n\n\t/**\n\t * The carrier voice.\n\t */\n\tprotected _carrier: Synth;\n\n\t/**\n\t * The modulator voice.\n\t */\n\n\tprotected _modulator: Synth;\n\n\t/**\n\t * The carrier's oscillator\n\t */\n\treadonly oscillator: OmniOscillator<any>;\n\n\t/**\n\t * The carrier's envelope\n\t */\n\treadonly envelope: AmplitudeEnvelope;\n\n\t/**\n\t * The modulator's oscillator which is applied to the amplitude of the oscillator\n\t */\n\treadonly modulation: OmniOscillator<any>;\n\n\t/**\n\t * The modulator's envelope\n\t */\n\treadonly modulationEnvelope: AmplitudeEnvelope;\n\n\t/**\n\t * The frequency control\n\t */\n\treadonly frequency: Signal<\"frequency\">;\n\n\t/**\n\t * The detune in cents\n\t */\n\treadonly detune: Signal<\"cents\">;\n\n\t/**\n\t * Harmonicity is the ratio between the two voices. A harmonicity of\n\t * 1 is no change. Harmonicity = 2 means a change of an octave.\n\t * @example\n\t * const amSynth = new Tone.AMSynth().toDestination();\n\t * // pitch the modulator an octave below oscillator\n\t * amSynth.harmonicity.value = 0.5;\n\t * amSynth.triggerAttackRelease(\"C5\", \"4n\");\n\t */\n\treadonly harmonicity: Multiply;\n\n\t/**\n\t * The node where the modulation happens\n\t */\n\tprotected _modulationNode: Gain;\n\n\tconstructor(options?: RecursivePartial<ModulationSynthOptions>);\n\tconstructor() {\n\t\tsuper(optionsFromArguments(ModulationSynth.getDefaults(), arguments));\n\t\tconst options = optionsFromArguments(ModulationSynth.getDefaults(), arguments);\n\n\t\tthis._carrier = new Synth({\n\t\t\tcontext: this.context,\n\t\t\toscillator: options.oscillator,\n\t\t\tenvelope: options.envelope,\n\t\t\tonsilence: () => this.onsilence(this),\n\t\t\tvolume: -10,\n\t\t});\n\t\tthis._modulator = new Synth({\n\t\t\tcontext: this.context,\n\t\t\toscillator: options.modulation,\n\t\t\tenvelope: options.modulationEnvelope,\n\t\t\tvolume: -10,\n\t\t});\n\n\t\tthis.oscillator = this._carrier.oscillator;\n\t\tthis.envelope = this._carrier.envelope;\n\t\tthis.modulation = this._modulator.oscillator;\n\t\tthis.modulationEnvelope = this._modulator.envelope;\n\n\t\tthis.frequency = new Signal({\n\t\t\tcontext: this.context,\n\t\t\tunits: \"frequency\",\n\t\t});\n\t\tthis.detune = new Signal({\n\t\t\tcontext: this.context,\n\t\t\tvalue: options.detune,\n\t\t\tunits: \"cents\"\n\t\t});\n\t\tthis.harmonicity = new Multiply({\n\t\t\tcontext: this.context,\n\t\t\tvalue: options.harmonicity,\n\t\t\tminValue: 0,\n\t\t});\n\t\tthis._modulationNode = new Gain({\n\t\t\tcontext: this.context,\n\t\t\tgain: 0,\n\t\t});\n\n\t\treadOnly(this, [\"frequency\", \"harmonicity\", \"oscillator\", \"envelope\", \"modulation\", \"modulationEnvelope\", \"detune\"]);\n\t}\n\n\tstatic getDefaults(): ModulationSynthOptions {\n\t\treturn Object.assign(Monophonic.getDefaults(), {\n\t\t\tharmonicity: 3,\n\t\t\toscillator: Object.assign(\n\t\t\t\tomitFromObject(OmniOscillator.getDefaults(), [\n\t\t\t\t\t...Object.keys(Source.getDefaults()),\n\t\t\t\t\t\"frequency\",\n\t\t\t\t\t\"detune\"\n\t\t\t\t]),\n\t\t\t\t{\n\t\t\t\t\ttype: \"sine\"\n\t\t\t\t}\n\t\t\t) as OmniOscillatorSynthOptions,\n\t\t\tenvelope: Object.assign(\n\t\t\t\tomitFromObject(\n\t\t\t\t\tEnvelope.getDefaults(),\n\t\t\t\t\tObject.keys(ToneAudioNode.getDefaults())\n\t\t\t\t),\n\t\t\t\t{\n\t\t\t\t\tattack: 0.01,\n\t\t\t\t\tdecay: 0.01,\n\t\t\t\t\tsustain: 1,\n\t\t\t\t\trelease: 0.5\n\t\t\t\t}\n\t\t\t),\n\t\t\tmodulation: Object.assign(\n\t\t\t\tomitFromObject(OmniOscillator.getDefaults(), [\n\t\t\t\t\t...Object.keys(Source.getDefaults()),\n\t\t\t\t\t\"frequency\",\n\t\t\t\t\t\"detune\"\n\t\t\t\t]),\n\t\t\t\t{\n\t\t\t\t\ttype: \"square\"\n\t\t\t\t}\n\t\t\t) as OmniOscillatorSynthOptions,\n\t\t\tmodulationEnvelope: Object.assign(\n\t\t\t\tomitFromObject(\n\t\t\t\t\tEnvelope.getDefaults(),\n\t\t\t\t\tObject.keys(ToneAudioNode.getDefaults())\n\t\t\t\t),\n\t\t\t\t{\n\t\t\t\t\tattack: 0.5,\n\t\t\t\t\tdecay: 0.0,\n\t\t\t\t\tsustain: 1,\n\t\t\t\t\trelease: 0.5\n\t\t\t\t}\n\t\t\t)\n\t\t});\n\t}\n\n\t/**\n\t * Trigger the attack portion of the note\n\t */\n\tprotected _triggerEnvelopeAttack(time: Seconds, velocity: number): void {\n\t\t// @ts-ignore\n\t\tthis._carrier._triggerEnvelopeAttack(time, velocity);\n\t\t// @ts-ignore\n\t\tthis._modulator._triggerEnvelopeAttack(time, velocity);\n\t}\n\n\t/**\n\t * Trigger the release portion of the note\n\t */\n\tprotected _triggerEnvelopeRelease(time: Seconds) {\n\t\t// @ts-ignore\n\t\tthis._carrier._triggerEnvelopeRelease(time);\n\t\t// @ts-ignore\n\t\tthis._modulator._triggerEnvelopeRelease(time);\n\t\treturn this;\n\t}\n\n\tgetLevelAtTime(time: Time): NormalRange {\n\t\ttime = this.toSeconds(time);\n\t\treturn this.envelope.getValueAtTime(time);\n\t}\n\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis._carrier.dispose();\n\t\tthis._modulator.dispose();\n\t\tthis.frequency.dispose();\n\t\tthis.detune.dispose();\n\t\tthis.harmonicity.dispose();\n\t\tthis._modulationNode.dispose();\n\t\treturn this;\n\t}\n}\n","import { AudioToGain } from \"../signal/AudioToGain\";\nimport { RecursivePartial } from \"../core/util/Interface\";\nimport { optionsFromArguments } from \"../core/util/Defaults\";\nimport { ModulationSynth, ModulationSynthOptions } from \"./ModulationSynth\";\n\nexport type AMSynthOptions = ModulationSynthOptions;\n\n/**\n * AMSynth uses the output of one Tone.Synth to modulate the\n * amplitude of another Tone.Synth. The harmonicity (the ratio between\n * the two signals) affects the timbre of the output signal greatly.\n * Read more about Amplitude Modulation Synthesis on\n * [SoundOnSound](https://web.archive.org/web/20160404103653/http://www.soundonsound.com:80/sos/mar00/articles/synthsecrets.htm).\n *\n * @example\n * const synth = new Tone.AMSynth().toDestination();\n * synth.triggerAttackRelease(\"C4\", \"4n\");\n * \n * @category Instrument\n */\nexport class AMSynth extends ModulationSynth<AMSynthOptions> {\n\n\treadonly name: string = \"AMSynth\";\n\n\t/**\n\t * Scale the oscillator from -1,1 to 0-1\n\t */\n\tprivate _modulationScale: AudioToGain;\n\n\tconstructor(options?: RecursivePartial<AMSynthOptions>);\n\tconstructor() {\n\t\tsuper(optionsFromArguments(AMSynth.getDefaults(), arguments));\n\n\t\tthis._modulationScale = new AudioToGain({\n\t\t\tcontext: this.context,\n\t\t});\n\n\t\t// control the two voices frequency\n\t\tthis.frequency.connect(this._carrier.frequency);\n\t\tthis.frequency.chain(this.harmonicity, this._modulator.frequency);\n\t\tthis.detune.fan(this._carrier.detune, this._modulator.detune);\n\t\tthis._modulator.chain(this._modulationScale, this._modulationNode.gain);\n\t\tthis._carrier.chain(this._modulationNode, this.output);\n\t}\n\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis._modulationScale.dispose();\n\t\treturn this;\n\t}\n}\n","import { ToneAudioNode, ToneAudioNodeOptions } from \"../../core/context/ToneAudioNode\";\nimport { Cents, Frequency, GainFactor } from \"../../core/type/Units\";\nimport { optionsFromArguments } from \"../../core/util/Defaults\";\nimport { Param } from \"../../core/context/Param\";\nimport { assert } from \"../../core/util/Debug\";\n\nexport interface BiquadFilterOptions extends ToneAudioNodeOptions {\n\tfrequency: Frequency;\n\tdetune: Cents;\n\tQ: number;\n\ttype: BiquadFilterType;\n\tgain: GainFactor;\n}\n\n/**\n * Thin wrapper around the native Web Audio [BiquadFilterNode](https://webaudio.github.io/web-audio-api/#biquadfilternode). \n * BiquadFilter is similar to [[Filter]] but doesn't have the option to set the \"rolloff\" value. \n * @category Component\n */\nexport class BiquadFilter extends ToneAudioNode<BiquadFilterOptions> {\n\treadonly name: string = \"BiquadFilter\";\n\n\treadonly input: BiquadFilterNode;\n\treadonly output: BiquadFilterNode;\n\n\t/**\n\t * The frequency of the filter\n\t */\n\treadonly frequency: Param<\"frequency\">;\n\n\t/**\n\t * A detune value, in cents, for the frequency.\n\t */\n\treadonly detune: Param<\"cents\">;\n\t\n\t/**\n\t * The Q factor of the filter.\n\t * For lowpass and highpass filters the Q value is interpreted to be in dB. \n\t * For these filters the nominal range is [−𝑄𝑙𝑖𝑚,𝑄𝑙𝑖𝑚] where 𝑄𝑙𝑖𝑚 is the largest value for which 10𝑄/20 does not overflow. This is approximately 770.63678.\n\t * For the bandpass, notch, allpass, and peaking filters, this value is a linear value. \n\t * The value is related to the bandwidth of the filter and hence should be a positive value. The nominal range is \n\t * [0,3.4028235𝑒38], the upper limit being the most-positive-single-float.\n\t * This is not used for the lowshelf and highshelf filters.\n\t */\n\treadonly Q: Param<\"number\">;\n\n\t/**\n\t * The gain of the filter. Its value is in dB units. The gain is only used for lowshelf, highshelf, and peaking filters.\n\t */\n\treadonly gain: Param<\"decibels\">;\n\n\tprivate readonly _filter: BiquadFilterNode;\n\n\t/**\n\t * @param frequency The cutoff frequency of the filter.\n\t * @param type The type of filter.\n\t */\n\tconstructor(frequency?: Frequency, type?: BiquadFilterType);\n\tconstructor(options?: Partial<BiquadFilterOptions>);\n\tconstructor() {\n\t\tsuper(optionsFromArguments(BiquadFilter.getDefaults(), arguments, [\"frequency\", \"type\"]));\n\t\tconst options = optionsFromArguments(BiquadFilter.getDefaults(), arguments, [\"frequency\", \"type\"]);\n\n\t\tthis._filter = this.context.createBiquadFilter();\n\t\tthis.input = this.output = this._filter;\n\n\t\tthis.Q = new Param({\n\t\t\tcontext: this.context,\n\t\t\tunits: \"number\",\n\t\t\tvalue: options.Q,\n\t\t\tparam: this._filter.Q,\n\t\t});\n\t\t\n\t\tthis.frequency = new Param({\n\t\t\tcontext: this.context,\n\t\t\tunits: \"frequency\",\n\t\t\tvalue: options.frequency,\n\t\t\tparam: this._filter.frequency,\n\t\t});\n\t\t\n\t\tthis.detune = new Param({\n\t\t\tcontext: this.context,\n\t\t\tunits: \"cents\",\n\t\t\tvalue: options.detune,\n\t\t\tparam: this._filter.detune,\n\t\t});\n\t\t\n\t\tthis.gain = new Param({\n\t\t\tcontext: this.context,\n\t\t\tunits: \"decibels\",\n\t\t\tconvert: false,\n\t\t\tvalue: options.gain,\n\t\t\tparam: this._filter.gain,\n\t\t});\n\n\t\tthis.type = options.type;\n\t}\n\n\tstatic getDefaults(): BiquadFilterOptions {\n\t\treturn Object.assign(ToneAudioNode.getDefaults(), {\n\t\t\tQ: 1,\n\t\t\ttype: \"lowpass\" as const,\n\t\t\tfrequency: 350,\n\t\t\tdetune: 0,\n\t\t\tgain: 0,\n\t\t});\n\t}\n\n\t/**\n\t * The type of this BiquadFilterNode. For a complete list of types and their attributes, see the\n\t * [Web Audio API](https://webaudio.github.io/web-audio-api/#dom-biquadfiltertype-lowpass)\n\t */\n\tget type(): BiquadFilterType {\n\t\treturn this._filter.type;\n\t}\n\tset type(type) {\n\t\tconst types: BiquadFilterType[] = [\"lowpass\", \"highpass\", \"bandpass\",\n\t\t\t\"lowshelf\", \"highshelf\", \"notch\", \"allpass\", \"peaking\"];\n\t\tassert(types.indexOf(type) !== -1, `Invalid filter type: ${type}`);\n\t\tthis._filter.type = type;\n\t}\n\n\t/**\n\t * Get the frequency response curve. This curve represents how the filter\n\t * responses to frequencies between 20hz-20khz.\n\t * @param  len The number of values to return\n\t * @return The frequency response curve between 20-20kHz\n\t */\n\tgetFrequencyResponse(len = 128): Float32Array {\n\t\t// start with all 1s\n\t\tconst freqValues = new Float32Array(len);\n\t\tfor (let i = 0; i < len; i++) {\n\t\t\tconst norm = Math.pow(i / len, 2);\n\t\t\tconst freq = norm * (20000 - 20) + 20;\n\t\t\tfreqValues[i] = freq;\n\t\t}\n\t\tconst magValues = new Float32Array(len);\n\t\tconst phaseValues = new Float32Array(len);\n\t\t// clone the filter to remove any connections which may be changing the value\n\t\tconst filterClone = this.context.createBiquadFilter();\n\t\tfilterClone.type = this.type;\n\t\tfilterClone.Q.value = this.Q.value;\n\t\tfilterClone.frequency.value = this.frequency.value as number;\n\t\tfilterClone.gain.value = this.gain.value as number;\n\t\tfilterClone.getFrequencyResponse(freqValues, magValues, phaseValues);\n\t\treturn magValues;\n\t}\n\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis._filter.disconnect();\n\t\tthis.Q.dispose();\n\t\tthis.frequency.dispose();\n\t\tthis.gain.dispose();\n\t\tthis.detune.dispose();\n\t\treturn this;\n\t}\n}\n","import { Gain } from \"../../core/context/Gain\";\nimport { connectSeries, ToneAudioNode } from \"../../core/context/ToneAudioNode\";\nimport { Frequency } from \"../../core/type/Units\";\nimport { optionsFromArguments } from \"../../core/util/Defaults\";\nimport { readOnly, writable } from \"../../core/util/Interface\";\nimport { isNumber } from \"../../core/util/TypeCheck\";\nimport { Signal } from \"../../signal/Signal\";\nimport { assert } from \"../../core/util/Debug\";\nimport { BiquadFilter, BiquadFilterOptions } from \"./BiquadFilter\";\n\nexport type FilterRollOff = -12 | -24 | -48 | -96;\n\nexport type FilterOptions = BiquadFilterOptions & {\n\trolloff: FilterRollOff;\n}\n\n/**\n * Tone.Filter is a filter which allows for all of the same native methods\n * as the [BiquadFilterNode](http://webaudio.github.io/web-audio-api/#the-biquadfilternode-interface).\n * Tone.Filter has the added ability to set the filter rolloff at -12\n * (default), -24 and -48.\n * @example\n * const filter = new Tone.Filter(1500, \"highpass\").toDestination();\n * filter.frequency.rampTo(20000, 10);\n * const noise = new Tone.Noise().connect(filter).start();\n * @category Component\n */\nexport class Filter extends ToneAudioNode<FilterOptions> {\n\n\treadonly name: string = \"Filter\";\n\n\treadonly input = new Gain({ context: this.context });\n\treadonly output = new Gain({ context: this.context });\n\tprivate _filters: BiquadFilter[] = [];\n\n\t/**\n\t * the rolloff value of the filter\n\t */\n\tprivate _rolloff!: FilterRollOff;\n\tprivate _type: BiquadFilterType;\n\n\t/**\n\t * The Q or Quality of the filter\n\t */\n\treadonly Q: Signal<\"positive\">;\n\n\t/**\n\t * The cutoff frequency of the filter.\n\t */\n\treadonly frequency: Signal<\"frequency\">;\n\n\t/**\n\t * The detune parameter\n\t */\n\treadonly detune: Signal<\"cents\">;\n\n\t/**\n\t * The gain of the filter, only used in certain filter types\n\t */\n\treadonly gain: Signal<\"decibels\">;\n\n\t/**\n\t * @param frequency The cutoff frequency of the filter.\n\t * @param type The type of filter.\n\t * @param rolloff The drop in decibels per octave after the cutoff frequency\n\t */\n\tconstructor(frequency?: Frequency, type?: BiquadFilterType, rolloff?: FilterRollOff);\n\tconstructor(options?: Partial<FilterOptions>);\n\tconstructor() {\n\t\tsuper(optionsFromArguments(Filter.getDefaults(), arguments, [\"frequency\", \"type\", \"rolloff\"]));\n\t\tconst options = optionsFromArguments(Filter.getDefaults(), arguments, [\"frequency\", \"type\", \"rolloff\"]);\n\n\t\tthis._filters = [];\n\n\t\tthis.Q = new Signal({\n\t\t\tcontext: this.context,\n\t\t\tunits: \"positive\",\n\t\t\tvalue: options.Q,\n\t\t});\n\t\tthis.frequency = new Signal({\n\t\t\tcontext: this.context,\n\t\t\tunits: \"frequency\",\n\t\t\tvalue: options.frequency,\n\t\t});\n\t\tthis.detune = new Signal({\n\t\t\tcontext: this.context,\n\t\t\tunits: \"cents\",\n\t\t\tvalue: options.detune,\n\t\t});\n\t\tthis.gain = new Signal({\n\t\t\tcontext: this.context,\n\t\t\tunits: \"decibels\",\n\t\t\tconvert: false,\n\t\t\tvalue: options.gain,\n\t\t});\n\t\tthis._type = options.type;\n\t\tthis.rolloff = options.rolloff;\n\t\treadOnly(this, [\"detune\", \"frequency\", \"gain\", \"Q\"]);\n\t}\n\n\tstatic getDefaults(): FilterOptions {\n\t\treturn Object.assign(ToneAudioNode.getDefaults(), {\n\t\t\tQ: 1,\n\t\t\tdetune: 0,\n\t\t\tfrequency: 350,\n\t\t\tgain: 0,\n\t\t\trolloff: -12 as FilterRollOff,\n\t\t\ttype: \"lowpass\" as BiquadFilterType,\n\t\t});\n\t}\n\n\t/**\n\t * The type of the filter. Types: \"lowpass\", \"highpass\",\n\t * \"bandpass\", \"lowshelf\", \"highshelf\", \"notch\", \"allpass\", or \"peaking\".\n\t */\n\tget type(): BiquadFilterType {\n\t\treturn this._type;\n\t}\n\tset type(type: BiquadFilterType) {\n\t\tconst types: BiquadFilterType[] = [\"lowpass\", \"highpass\", \"bandpass\",\n\t\t\t\"lowshelf\", \"highshelf\", \"notch\", \"allpass\", \"peaking\"];\n\t\tassert(types.indexOf(type) !== -1, `Invalid filter type: ${type}`);\n\t\tthis._type = type;\n\t\tthis._filters.forEach(filter => filter.type = type);\n\t}\n\n\t/**\n\t * The rolloff of the filter which is the drop in db\n\t * per octave. Implemented internally by cascading filters.\n\t * Only accepts the values -12, -24, -48 and -96.\n\t */\n\tget rolloff(): FilterRollOff {\n\t\treturn this._rolloff;\n\t}\n\tset rolloff(rolloff) {\n\t\tconst rolloffNum = isNumber(rolloff) ? rolloff : parseInt(rolloff, 10) as FilterRollOff;\n\t\tconst possibilities = [-12, -24, -48, -96];\n\t\tlet cascadingCount = possibilities.indexOf(rolloffNum);\n\t\t// check the rolloff is valid\n\t\tassert(cascadingCount !== -1, `rolloff can only be ${possibilities.join(\", \")}`);\n\t\tcascadingCount += 1;\n\n\t\tthis._rolloff = rolloffNum;\n\t\tthis.input.disconnect();\n\t\tthis._filters.forEach(filter => filter.disconnect());\n\n\t\tthis._filters = new Array(cascadingCount);\n\t\tfor (let count = 0; count < cascadingCount; count++) {\n\t\t\tconst filter = new BiquadFilter({\n\t\t\t\tcontext: this.context,\n\t\t\t});\n\t\t\tfilter.type = this._type;\n\t\t\tthis.frequency.connect(filter.frequency);\n\t\t\tthis.detune.connect(filter.detune);\n\t\t\tthis.Q.connect(filter.Q);\n\t\t\tthis.gain.connect(filter.gain);\n\t\t\tthis._filters[count] = filter;\n\t\t}\n\t\tthis._internalChannels = this._filters;\n\t\tconnectSeries(this.input, ...this._internalChannels, this.output);\n\t}\n\n\t/**\n\t * Get the frequency response curve. This curve represents how the filter\n\t * responses to frequencies between 20hz-20khz.\n\t * @param  len The number of values to return\n\t * @return The frequency response curve between 20-20kHz\n\t */\n\tgetFrequencyResponse(len = 128): Float32Array {\n\t\tconst filterClone = new BiquadFilter({\n\t\t\tfrequency: this.frequency.value,\n\t\t\tgain: this.gain.value,\n\t\t\tQ: this.Q.value,\n\t\t\ttype: this._type,\n\t\t\tdetune: this.detune.value,\n\t\t});\n\t\t// start with all 1s\n\t\tconst totalResponse = new Float32Array(len).map(() => 1);\n\t\tthis._filters.forEach(() => {\n\t\t\tconst response = filterClone.getFrequencyResponse(len);\n\t\t\tresponse.forEach((val, i) => totalResponse[i] *= val);\n\t\t});\n\t\tfilterClone.dispose();\n\t\treturn totalResponse;\n\t}\n\n\t/**\n\t * Clean up.\n\t */\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis._filters.forEach(filter => {\n\t\t\tfilter.dispose();\n\t\t});\n\t\twritable(this, [\"detune\", \"frequency\", \"gain\", \"Q\"]);\n\t\tthis.frequency.dispose();\n\t\tthis.Q.dispose();\n\t\tthis.detune.dispose();\n\t\tthis.gain.dispose();\n\t\treturn this;\n\t}\n}\n","import { optionsFromArguments } from \"../../core/util/Defaults\";\nimport { Frequency, Hertz, NormalRange, Time } from \"../../core/type/Units\";\nimport { Envelope, EnvelopeOptions } from \"./Envelope\";\nimport { Scale } from \"../../signal/Scale\";\nimport { Pow } from \"../../signal/Pow\";\nimport { assertRange } from \"../../core/util/Debug\";\n\nexport interface FrequencyEnvelopeOptions extends EnvelopeOptions {\n\tbaseFrequency: Frequency;\n\toctaves: number;\n\texponent: number;\n}\n/**\n * FrequencyEnvelope is an [[Envelope]] which ramps between [[baseFrequency]]\n * and [[octaves]]. It can also have an optional [[exponent]] to adjust the curve\n * which it ramps. \n * @example\n * const oscillator = new Tone.Oscillator().toDestination().start();\n * const freqEnv = new Tone.FrequencyEnvelope({\n * \tattack: 0.2,\n * \tbaseFrequency: \"C2\",\n * \toctaves: 4\n * });\n * freqEnv.connect(oscillator.frequency);\n * freqEnv.triggerAttack();\n * @category Component\n */\nexport class FrequencyEnvelope extends Envelope {\n\n\treadonly name: string = \"FrequencyEnvelope\";\n\n\t/**\n\t * Private reference to the base frequency as a number\n\t */\n\tprivate _baseFrequency: Hertz;\n\n\t/**\n\t * The number of octaves\n\t */\n\tprivate _octaves: number;\n\n\t/**\n\t * Internal scaler from 0-1 to the final output range\n\t */\n\tprivate _scale: Scale;\n\n\t/**\n\t * Apply a power curve to the output\n\t */\n\tprivate _exponent: Pow;\n\n\t/**\n\t * @param attack\tthe attack time in seconds\n\t * @param decay\t\tthe decay time in seconds\n\t * @param sustain \ta percentage (0-1) of the full amplitude\n\t * @param release\tthe release time in seconds\n\t */\n\tconstructor(attack?: Time, decay?: Time, sustain?: NormalRange, release?: Time);\n\tconstructor(options?: Partial<FrequencyEnvelopeOptions>)\n\tconstructor() {\n\t\tsuper(optionsFromArguments(FrequencyEnvelope.getDefaults(), arguments, [\"attack\", \"decay\", \"sustain\", \"release\"]));\n\t\tconst options = optionsFromArguments(FrequencyEnvelope.getDefaults(), arguments, [\"attack\", \"decay\", \"sustain\", \"release\"]);\n\n\t\tthis._octaves = options.octaves;\n\t\tthis._baseFrequency = this.toFrequency(options.baseFrequency);\n\n\t\tthis._exponent = this.input = new Pow({\n\t\t\tcontext: this.context,\n\t\t\tvalue: options.exponent\n\t\t});\n\t\tthis._scale = this.output = new Scale({\n\t\t\tcontext: this.context,\n\t\t\tmin: this._baseFrequency,\n\t\t\tmax: this._baseFrequency * Math.pow(2, this._octaves),\n\t\t});\n\t\tthis._sig.chain(this._exponent, this._scale);\n\t}\n\n\tstatic getDefaults(): FrequencyEnvelopeOptions {\n\t\treturn Object.assign(Envelope.getDefaults(), {\n\t\t\tbaseFrequency: 200,\n\t\t\texponent: 1,\n\t\t\toctaves: 4,\n\t\t});\n\t}\n\n\t/**\n\t * The envelope's minimum output value. This is the value which it\n\t * starts at.\n\t */\n\tget baseFrequency(): Frequency {\n\t\treturn this._baseFrequency;\n\t}\n\tset baseFrequency(min) {\n\t\tconst freq = this.toFrequency(min);\n\t\tassertRange(freq, 0);\n\t\tthis._baseFrequency = freq;\n\t\tthis._scale.min = this._baseFrequency;\n\t\t// update the max value when the min changes\n\t\tthis.octaves = this._octaves;\n\t}\n\n\t/**\n\t * The number of octaves above the baseFrequency that the\n\t * envelope will scale to.\n\t */\n\tget octaves(): number {\n\t\treturn this._octaves;\n\t}\n\tset octaves(octaves: number) {\n\t\tthis._octaves = octaves;\n\t\tthis._scale.max = this._baseFrequency * Math.pow(2, octaves);\n\t}\n\n\t/**\n\t * The envelope's exponent value.\n\t */\n\tget exponent(): number {\n\t\treturn this._exponent.value;\n\t}\n\tset exponent(exponent) {\n\t\tthis._exponent.value = exponent;\n\t}\n\n\t/**\n\t * Clean up\n\t */\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis._exponent.dispose();\n\t\tthis._scale.dispose();\n\t\treturn this;\n\t}\n}\n","import { AmplitudeEnvelope } from \"../component/envelope/AmplitudeEnvelope\";\nimport { Envelope, EnvelopeOptions } from \"../component/envelope/Envelope\";\nimport { Filter, FilterOptions } from \"../component/filter/Filter\";\nimport { omitFromObject, optionsFromArguments } from \"../core/util/Defaults\";\nimport { readOnly, RecursivePartial } from \"../core/util/Interface\";\nimport { Monophonic, MonophonicOptions } from \"../instrument/Monophonic\";\nimport { OmniOscillator } from \"../source/oscillator/OmniOscillator\";\nimport { Source } from \"../source/Source\";\nimport { FrequencyEnvelope, FrequencyEnvelopeOptions } from \"../component/envelope/FrequencyEnvelope\";\nimport { NormalRange, Seconds, Time } from \"../core/type/Units\";\nimport { Signal } from \"../signal/Signal\";\nimport { ToneAudioNode, ToneAudioNodeOptions } from \"../core/context/ToneAudioNode\";\nimport { OmniOscillatorSynthOptions } from \"../source/oscillator/OscillatorInterface\";\n\nexport interface MonoSynthOptions extends MonophonicOptions {\n\toscillator: OmniOscillatorSynthOptions;\n\tenvelope: Omit<EnvelopeOptions, keyof ToneAudioNodeOptions>;\n\tfilterEnvelope: Omit<FrequencyEnvelopeOptions, keyof ToneAudioNodeOptions>;\n\tfilter: Omit<FilterOptions, keyof ToneAudioNodeOptions>;\n}\n\n/**\n * MonoSynth is composed of one `oscillator`, one `filter`, and two `envelopes`.\n * The amplitude of the Oscillator and the cutoff frequency of the\n * Filter are controlled by Envelopes.\n * <img src=\"https://docs.google.com/drawings/d/1gaY1DF9_Hzkodqf8JI1Cg2VZfwSElpFQfI94IQwad38/pub?w=924&h=240\">\n * @example\n * const synth = new Tone.MonoSynth({\n * \toscillator: {\n * \t\ttype: \"square\"\n * \t},\n * \tenvelope: {\n * \t\tattack: 0.1\n * \t}\n * }).toDestination();\n * synth.triggerAttackRelease(\"C4\", \"8n\");\n * @category Instrument\n */\nexport class MonoSynth extends Monophonic<MonoSynthOptions> {\n\n\treadonly name = \"MonoSynth\";\n\n\t/**\n\t * The oscillator.\n\t */\n\treadonly oscillator: OmniOscillator<any>;\n\n\t/**\n\t * The frequency control.\n\t */\n\treadonly frequency: Signal<\"frequency\">;\n\n\t/**\n\t * The detune control.\n\t */\n\treadonly detune: Signal<\"cents\">;\n\n\t/**\n\t * The filter.\n\t */\n\treadonly filter: Filter;\n\n\t/**\n\t * The filter envelope.\n\t */\n\treadonly filterEnvelope: FrequencyEnvelope;\n\n\t/**\n\t * The amplitude envelope.\n\t */\n\treadonly envelope: AmplitudeEnvelope;\n\n\tconstructor(options?: RecursivePartial<MonoSynthOptions>);\n\tconstructor() {\n\t\tsuper(optionsFromArguments(MonoSynth.getDefaults(), arguments));\n\t\tconst options = optionsFromArguments(MonoSynth.getDefaults(), arguments);\n\n\t\tthis.oscillator = new OmniOscillator(Object.assign(options.oscillator, {\n\t\t\tcontext: this.context,\n\t\t\tdetune: options.detune,\n\t\t\tonstop: () => this.onsilence(this),\n\t\t}));\n\t\tthis.frequency = this.oscillator.frequency;\n\t\tthis.detune = this.oscillator.detune;\n\t\tthis.filter = new Filter(Object.assign(options.filter, { context: this.context }));\n\t\tthis.filterEnvelope = new FrequencyEnvelope(Object.assign(options.filterEnvelope, { context: this.context }));\n\t\tthis.envelope = new AmplitudeEnvelope(Object.assign(options.envelope, { context: this.context }));\n\n\t\t// connect the oscillators to the output\n\t\tthis.oscillator.chain(this.filter, this.envelope, this.output);\n\n\t\t// connect the filter envelope\n\t\tthis.filterEnvelope.connect(this.filter.frequency);\n\n\t\treadOnly(this, [\"oscillator\", \"frequency\", \"detune\", \"filter\", \"filterEnvelope\", \"envelope\"]);\n\t}\n\n\tstatic getDefaults(): MonoSynthOptions {\n\t\treturn Object.assign(Monophonic.getDefaults(), {\n\t\t\tenvelope: Object.assign(\n\t\t\t\tomitFromObject(Envelope.getDefaults(), Object.keys(ToneAudioNode.getDefaults())),\n\t\t\t\t{\n\t\t\t\t\tattack: 0.005,\n\t\t\t\t\tdecay: 0.1,\n\t\t\t\t\trelease: 1,\n\t\t\t\t\tsustain: 0.9,\n\t\t\t\t},\n\t\t\t),\n\t\t\tfilter: Object.assign(\n\t\t\t\tomitFromObject(Filter.getDefaults(), Object.keys(ToneAudioNode.getDefaults())),\n\t\t\t\t{\n\t\t\t\t\tQ: 1,\n\t\t\t\t\trolloff: -12,\n\t\t\t\t\ttype: \"lowpass\",\n\t\t\t\t},\n\t\t\t),\n\t\t\tfilterEnvelope: Object.assign(\n\t\t\t\tomitFromObject(FrequencyEnvelope.getDefaults(), Object.keys(ToneAudioNode.getDefaults())),\n\t\t\t\t{\n\t\t\t\t\tattack: 0.6,\n\t\t\t\t\tbaseFrequency: 200,\n\t\t\t\t\tdecay: 0.2,\n\t\t\t\t\texponent: 2,\n\t\t\t\t\toctaves: 3,\n\t\t\t\t\trelease: 2,\n\t\t\t\t\tsustain: 0.5,\n\t\t\t\t}\n\t\t\t),\n\t\t\toscillator: Object.assign(\n\t\t\t\tomitFromObject(OmniOscillator.getDefaults(), Object.keys(Source.getDefaults())),\n\t\t\t\t{\n\t\t\t\t\ttype: \"sawtooth\",\n\t\t\t\t},\n\t\t\t) as OmniOscillatorSynthOptions,\n\t\t});\n\t}\n\n\t/**\n\t * start the attack portion of the envelope\n\t * @param time the time the attack should start\n\t * @param velocity the velocity of the note (0-1)\n\t */\n\tprotected _triggerEnvelopeAttack(time: Seconds, velocity = 1): void {\n\t\tthis.envelope.triggerAttack(time, velocity);\n\t\tthis.filterEnvelope.triggerAttack(time);\n\t\tthis.oscillator.start(time);\n\t\tif (this.envelope.sustain === 0) {\n\t\t\tconst computedAttack = this.toSeconds(this.envelope.attack);\n\t\t\tconst computedDecay = this.toSeconds(this.envelope.decay);\n\t\t\tthis.oscillator.stop(time + computedAttack + computedDecay);\n\t\t}\n\t}\n\n\t/**\n\t * start the release portion of the envelope\n\t * @param time the time the release should start\n\t */\n\tprotected _triggerEnvelopeRelease(time: Seconds): void {\n\t\tthis.envelope.triggerRelease(time);\n\t\tthis.filterEnvelope.triggerRelease(time);\n\t\tthis.oscillator.stop(time + this.toSeconds(this.envelope.release));\n\t}\n\n\tgetLevelAtTime(time: Time): NormalRange {\n\t\ttime = this.toSeconds(time);\n\t\treturn this.envelope.getValueAtTime(time);\n\t}\n\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis.oscillator.dispose();\n\t\tthis.envelope.dispose();\n\t\tthis.filterEnvelope.dispose();\n\t\tthis.filter.dispose();\n\t\treturn this;\n\t}\n}\n","import { Monophonic, MonophonicOptions } from \"./Monophonic\";\nimport { MonoSynth, MonoSynthOptions } from \"./MonoSynth\";\nimport { Signal } from \"../signal/Signal\";\nimport { readOnly, RecursivePartial } from \"../core/util/Interface\";\nimport { LFO } from \"../source/oscillator/LFO\";\nimport { Gain, } from \"../core/context/Gain\";\nimport { Multiply } from \"../signal/Multiply\";\nimport { Frequency, NormalRange, Positive, Seconds, Time } from \"../core/type/Units\";\nimport { deepMerge, omitFromObject, optionsFromArguments } from \"../core/util/Defaults\";\nimport { Param } from \"../core/context/Param\";\n\nexport interface DuoSynthOptions extends MonophonicOptions {\n\tvoice0: Omit<MonoSynthOptions, keyof MonophonicOptions>;\n\tvoice1: Omit<MonoSynthOptions, keyof MonophonicOptions>;\n\tharmonicity: Positive;\n\tvibratoRate: Frequency;\n\tvibratoAmount: Positive;\n}\n\n/**\n * DuoSynth is a monophonic synth composed of two [[MonoSynths]] run in parallel with control over the\n * frequency ratio between the two voices and vibrato effect.\n * @example\n * const duoSynth = new Tone.DuoSynth().toDestination();\n * duoSynth.triggerAttackRelease(\"C4\", \"2n\");\n * @category Instrument\n */\nexport class DuoSynth extends Monophonic<DuoSynthOptions> {\n\n\treadonly name: string = \"DuoSynth\";\n\n\treadonly frequency: Signal<\"frequency\">;\n\treadonly detune: Signal<\"cents\">;\n\n\t/**\n\t * the first voice\n\t */\n\treadonly voice0: MonoSynth;\n\n\t/**\n\t * the second voice\n\t */\n\treadonly voice1: MonoSynth;\n\n\t/**\n\t * The amount of vibrato\n\t */\n\tpublic vibratoAmount: Param<\"normalRange\">;\n\n\t/**\n\t * the vibrato frequency\n\t */\n\tpublic vibratoRate: Signal<\"frequency\">;\n\n\t/**\n\t * Harmonicity is the ratio between the two voices. A harmonicity of\n\t * 1 is no change. Harmonicity = 2 means a change of an octave.\n\t * @example\n\t * const duoSynth = new Tone.DuoSynth().toDestination();\n\t * duoSynth.triggerAttackRelease(\"C4\", \"2n\");\n\t * // pitch voice1 an octave below voice0\n\t * duoSynth.harmonicity.value = 0.5;\n\t */\n\tpublic harmonicity: Signal<\"positive\">;\n\n\t/**\n\t * The vibrato LFO.\n\t */\n\tprivate _vibrato: LFO;\n\n\t/**\n\t * the vibrato gain\n\t */\n\tprivate _vibratoGain: Gain<\"normalRange\">;\n\n\tconstructor(options?: RecursivePartial<DuoSynthOptions>);\n\tconstructor() {\n\t\tsuper(optionsFromArguments(DuoSynth.getDefaults(), arguments));\n\t\tconst options = optionsFromArguments(DuoSynth.getDefaults(), arguments);\n\n\t\tthis.voice0 = new MonoSynth(Object.assign(options.voice0, {\n\t\t\tcontext: this.context,\n\t\t\tonsilence: () => this.onsilence(this)\n\t\t}));\n\t\tthis.voice1 = new MonoSynth(Object.assign(options.voice1, {\n\t\t\tcontext: this.context,\n\t\t}));\n\n\t\tthis.harmonicity = new Multiply({\n\t\t\tcontext: this.context,\n\t\t\tunits: \"positive\",\n\t\t\tvalue: options.harmonicity,\n\t\t});\n\n\t\tthis._vibrato = new LFO({\n\t\t\tfrequency: options.vibratoRate,\n\t\t\tcontext: this.context,\n\t\t\tmin: -50,\n\t\t\tmax: 50\n\t\t});\n\t\t// start the vibrato immediately\n\t\tthis._vibrato.start();\n\t\tthis.vibratoRate = this._vibrato.frequency;\n\t\tthis._vibratoGain = new Gain({\n\t\t\tcontext: this.context,\n\t\t\tunits: \"normalRange\",\n\t\t\tgain: options.vibratoAmount\n\t\t});\n\t\tthis.vibratoAmount = this._vibratoGain.gain;\n\n\t\tthis.frequency = new Signal({\n\t\t\tcontext: this.context,\n\t\t\tunits: \"frequency\",\n\t\t\tvalue: 440\n\t\t});\n\t\tthis.detune = new Signal({\n\t\t\tcontext: this.context,\n\t\t\tunits: \"cents\",\n\t\t\tvalue: options.detune\n\t\t});\n\n\t\t// control the two voices frequency\n\t\tthis.frequency.connect(this.voice0.frequency);\n\t\tthis.frequency.chain(this.harmonicity, this.voice1.frequency);\n\n\t\tthis._vibrato.connect(this._vibratoGain);\n\t\tthis._vibratoGain.fan(this.voice0.detune, this.voice1.detune);\n\n\t\tthis.detune.fan(this.voice0.detune, this.voice1.detune);\n\n\t\tthis.voice0.connect(this.output);\n\t\tthis.voice1.connect(this.output);\n\n\t\treadOnly(this, [\"voice0\", \"voice1\", \"frequency\", \"vibratoAmount\", \"vibratoRate\"]);\n\t}\n\n\tgetLevelAtTime(time: Time): NormalRange {\n\t\ttime = this.toSeconds(time);\n\t\treturn this.voice0.envelope.getValueAtTime(time) + this.voice1.envelope.getValueAtTime(time);\n\t}\n\n\tstatic getDefaults(): DuoSynthOptions {\n\t\treturn deepMerge(Monophonic.getDefaults(), {\n\t\t\tvibratoAmount: 0.5,\n\t\t\tvibratoRate: 5,\n\t\t\tharmonicity: 1.5,\n\t\t\tvoice0: deepMerge(\n\t\t\t\tomitFromObject(MonoSynth.getDefaults(), Object.keys(Monophonic.getDefaults())),\n\t\t\t\t{\n\t\t\t\t\tfilterEnvelope: {\n\t\t\t\t\t\tattack: 0.01,\n\t\t\t\t\t\tdecay: 0.0,\n\t\t\t\t\t\tsustain: 1,\n\t\t\t\t\t\trelease: 0.5\n\t\t\t\t\t},\n\t\t\t\t\tenvelope: {\n\t\t\t\t\t\tattack: 0.01,\n\t\t\t\t\t\tdecay: 0.0,\n\t\t\t\t\t\tsustain: 1,\n\t\t\t\t\t\trelease: 0.5\n\t\t\t\t\t}\n\t\t\t\t}),\n\t\t\tvoice1: deepMerge(\n\t\t\t\tomitFromObject(MonoSynth.getDefaults(), Object.keys(Monophonic.getDefaults())),\n\t\t\t\t{\n\n\t\t\t\t\tfilterEnvelope: {\n\t\t\t\t\t\tattack: 0.01,\n\t\t\t\t\t\tdecay: 0.0,\n\t\t\t\t\t\tsustain: 1,\n\t\t\t\t\t\trelease: 0.5\n\t\t\t\t\t},\n\t\t\t\t\tenvelope: {\n\t\t\t\t\t\tattack: 0.01,\n\t\t\t\t\t\tdecay: 0.0,\n\t\t\t\t\t\tsustain: 1,\n\t\t\t\t\t\trelease: 0.5\n\t\t\t\t\t}\n\t\t\t\t}),\n\t\t}) as unknown as DuoSynthOptions;\n\t}\n\t/**\n\t * Trigger the attack portion of the note\n\t */\n\tprotected _triggerEnvelopeAttack(time: Seconds, velocity: number): void {\n\t\t// @ts-ignore\n\t\tthis.voice0._triggerEnvelopeAttack(time, velocity);\n\t\t// @ts-ignore\n\t\tthis.voice1._triggerEnvelopeAttack(time, velocity);\n\t}\n\n\t/**\n\t * Trigger the release portion of the note\n\t */\n\tprotected _triggerEnvelopeRelease(time: Seconds) {\n\t\t// @ts-ignore\n\t\tthis.voice0._triggerEnvelopeRelease(time);\n\t\t// @ts-ignore\n\t\tthis.voice1._triggerEnvelopeRelease(time);\n\t\treturn this;\n\t}\n\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis.voice0.dispose();\n\t\tthis.voice1.dispose();\n\t\tthis.frequency.dispose();\n\t\tthis.detune.dispose();\n\t\tthis._vibrato.dispose();\n\t\tthis.vibratoRate.dispose();\n\t\tthis._vibratoGain.dispose();\n\t\tthis.harmonicity.dispose();\n\t\treturn this;\n\t}\n}\n\n","import { Positive } from \"../core/type/Units\";\nimport { optionsFromArguments } from \"../core/util/Defaults\";\nimport { RecursivePartial } from \"../core/util/Interface\";\nimport { Multiply } from \"../signal/Multiply\";\nimport { ModulationSynth, ModulationSynthOptions } from \"./ModulationSynth\";\n\nexport interface FMSynthOptions extends ModulationSynthOptions {\n\tmodulationIndex: Positive;\n}\n\n/**\n * FMSynth is composed of two Tone.Synths where one Tone.Synth modulates\n * the frequency of a second Tone.Synth. A lot of spectral content\n * can be explored using the modulationIndex parameter. Read more about\n * frequency modulation synthesis on Sound On Sound: [Part 1](https://web.archive.org/web/20160403123704/http://www.soundonsound.com/sos/apr00/articles/synthsecrets.htm), [Part 2](https://web.archive.org/web/20160403115835/http://www.soundonsound.com/sos/may00/articles/synth.htm).\n *\n * @example\n * const fmSynth = new Tone.FMSynth().toDestination();\n * fmSynth.triggerAttackRelease(\"C5\", \"4n\");\n * \n * @category Instrument\n */\n\nexport class FMSynth extends ModulationSynth<FMSynthOptions> {\n\treadonly name: string = \"FMSynth\";\n\n\t/**\n\t * The modulation index which essentially the depth or amount of the modulation. It is the\n\t * ratio of the frequency of the modulating signal (mf) to the amplitude of the\n\t * modulating signal (ma) -- as in ma/mf.\n\t */\n\treadonly modulationIndex: Multiply;\n\n\tconstructor(options?: RecursivePartial<FMSynthOptions>);\n\tconstructor() {\n\t\tsuper(optionsFromArguments(FMSynth.getDefaults(), arguments));\n\t\tconst options = optionsFromArguments(FMSynth.getDefaults(), arguments);\n\n\t\tthis.modulationIndex = new Multiply({\n\t\t\tcontext: this.context,\n\t\t\tvalue: options.modulationIndex,\n\t\t});\n\n\t\t// control the two voices frequency\n\t\tthis.frequency.connect(this._carrier.frequency);\n\t\tthis.frequency.chain(this.harmonicity, this._modulator.frequency);\n\t\tthis.frequency.chain(this.modulationIndex, this._modulationNode);\n\t\tthis.detune.fan(this._carrier.detune, this._modulator.detune);\n\t\tthis._modulator.connect(this._modulationNode.gain);\n\t\tthis._modulationNode.connect(this._carrier.frequency);\n\t\tthis._carrier.connect(this.output);\n\t}\n\n\tstatic getDefaults(): FMSynthOptions {\n\t\treturn Object.assign(ModulationSynth.getDefaults(), {\n\t\t\tmodulationIndex: 10,\n\t\t});\n\t}\n\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis.modulationIndex.dispose();\n\t\treturn this;\n\t}\n}\n","import { Envelope, EnvelopeOptions } from \"../component/envelope/Envelope\";\nimport { Filter } from \"../component/filter/Filter\";\nimport { Gain } from \"../core/context/Gain\";\nimport { ToneAudioNode, ToneAudioNodeOptions } from \"../core/context/ToneAudioNode\";\nimport { Frequency, NormalRange, Positive, Seconds, Time } from \"../core/type/Units\";\nimport { deepMerge, omitFromObject, optionsFromArguments } from \"../core/util/Defaults\";\nimport { noOp, RecursivePartial } from \"../core/util/Interface\";\nimport { Multiply } from \"../signal/Multiply\";\nimport { Scale } from \"../signal/Scale\";\nimport { Signal } from \"../signal/Signal\";\nimport { FMOscillator } from \"../source/oscillator/FMOscillator\";\nimport { Monophonic, MonophonicOptions } from \"./Monophonic\";\n\nexport interface MetalSynthOptions extends MonophonicOptions {\n\tharmonicity: Positive;\n\tmodulationIndex: Positive;\n\toctaves: number;\n\tresonance: Frequency;\n\tenvelope: Omit<EnvelopeOptions, keyof ToneAudioNodeOptions>;\n}\n\n/**\n * Inharmonic ratio of frequencies based on the Roland TR-808\n * Taken from https://ccrma.stanford.edu/papers/tr-808-cymbal-physically-informed-circuit-bendable-digital-model\n */\nconst inharmRatios: number[] = [1.0, 1.483, 1.932, 2.546, 2.630, 3.897];\n\n/**\n * A highly inharmonic and spectrally complex source with a highpass filter\n * and amplitude envelope which is good for making metallophone sounds.\n * Based on CymbalSynth by [@polyrhythmatic](https://github.com/polyrhythmatic).\n * Inspiration from [Sound on Sound](https://shorturl.at/rSZ12).\n * @category Instrument\n */\nexport class MetalSynth extends Monophonic<MetalSynthOptions> {\n\n\treadonly name: string = \"MetalSynth\";\n\n\t/**\n\t * The frequency of the cymbal\n\t */\n\treadonly frequency: Signal<\"frequency\">;\n\n\t/**\n\t * The detune applied to the oscillators\n\t */\n\treadonly detune: Signal<\"cents\">;\n\n\t/**\n\t * The array of FMOscillators\n\t */\n\tprivate _oscillators: FMOscillator[] = [];\n\n\t/**\n\t * The frequency multipliers\n\t */\n\tprivate _freqMultipliers: Multiply[] = [];\n\n\t/**\n\t * The gain node for the envelope.\n\t */\n\tprivate _amplitude: Gain;\n\n\t/**\n\t * Highpass the output\n\t */\n\tprivate _highpass: Filter;\n\n\t/**\n\t * The number of octaves the highpass\n\t * filter frequency ramps\n\t */\n\tprivate _octaves: number;\n\n\t/**\n\t * Scale the body envelope for the highpass filter\n\t */\n\tprivate _filterFreqScaler: Scale;\n\n\t/**\n\t * The envelope which is connected both to the\n\t * amplitude and a highpass filter's cutoff frequency.\n\t * The lower-limit of the filter is controlled by the [[resonance]]\n\t */\n\treadonly envelope: Envelope;\n\n\tconstructor(options?: RecursivePartial<MetalSynthOptions>)\n\tconstructor() {\n\t\tsuper(optionsFromArguments(MetalSynth.getDefaults(), arguments));\n\t\tconst options = optionsFromArguments(MetalSynth.getDefaults(), arguments);\n\n\t\tthis.detune = new Signal({\n\t\t\tcontext: this.context,\n\t\t\tunits: \"cents\",\n\t\t\tvalue: options.detune,\n\t\t});\n\n\t\tthis.frequency = new Signal({\n\t\t\tcontext: this.context,\n\t\t\tunits: \"frequency\",\n\t\t});\n\n\t\tthis._amplitude = new Gain({\n\t\t\tcontext: this.context,\n\t\t\tgain: 0,\n\t\t}).connect(this.output);\n\n\t\tthis._highpass = new Filter({\n\t\t\t// Q: -3.0102999566398125,\n\t\t\tQ: 0,\n\t\t\tcontext: this.context,\n\t\t\ttype: \"highpass\",\n\t\t}).connect(this._amplitude);\n\n\t\tfor (let i = 0; i < inharmRatios.length; i++) {\n\t\t\tconst osc = new FMOscillator({\n\t\t\t\tcontext: this.context,\n\t\t\t\tharmonicity: options.harmonicity,\n\t\t\t\tmodulationIndex: options.modulationIndex,\n\t\t\t\tmodulationType: \"square\",\n\t\t\t\tonstop: i === 0 ? () => this.onsilence(this) : noOp,\n\t\t\t\ttype: \"square\",\n\t\t\t});\n\t\t\tosc.connect(this._highpass);\n\t\t\tthis._oscillators[i] = osc;\n\n\t\t\tconst mult = new Multiply({\n\t\t\t\tcontext: this.context,\n\t\t\t\tvalue: inharmRatios[i],\n\t\t\t});\n\t\t\tthis._freqMultipliers[i] = mult;\n\t\t\tthis.frequency.chain(mult, osc.frequency);\n\t\t\tthis.detune.connect(osc.detune);\n\t\t}\n\n\t\tthis._filterFreqScaler = new Scale({\n\t\t\tcontext: this.context,\n\t\t\tmax: 7000,\n\t\t\tmin: this.toFrequency(options.resonance),\n\t\t});\n\n\t\tthis.envelope = new Envelope({\n\t\t\tattack: options.envelope.attack,\n\t\t\tattackCurve: \"linear\",\n\t\t\tcontext: this.context,\n\t\t\tdecay: options.envelope.decay,\n\t\t\trelease: options.envelope.release,\n\t\t\tsustain: 0,\n\t\t});\n\n\t\tthis.envelope.chain(this._filterFreqScaler, this._highpass.frequency);\n\t\tthis.envelope.connect(this._amplitude.gain);\n\t\t// set the octaves\n\t\tthis._octaves = options.octaves;\n\t\tthis.octaves = options.octaves;\n\t}\n\n\tstatic getDefaults(): MetalSynthOptions {\n\t\treturn deepMerge(Monophonic.getDefaults(), {\n\t\t\tenvelope: Object.assign(\n\t\t\t\tomitFromObject(Envelope.getDefaults(), Object.keys(ToneAudioNode.getDefaults())),\n\t\t\t\t{\n\t\t\t\t\tattack: 0.001,\n\t\t\t\t\tdecay: 1.4,\n\t\t\t\t\trelease: 0.2,\n\t\t\t\t},\n\t\t\t),\n\t\t\tharmonicity: 5.1,\n\t\t\tmodulationIndex: 32,\n\t\t\toctaves: 1.5,\n\t\t\tresonance: 4000,\n\t\t});\n\t}\n\n\t/**\n\t * Trigger the attack.\n\t * @param time When the attack should be triggered.\n\t * @param velocity The velocity that the envelope should be triggered at.\n\t */\n\tprotected _triggerEnvelopeAttack(time: Seconds, velocity: NormalRange = 1): this {\n\t\tthis.envelope.triggerAttack(time, velocity);\n\t\tthis._oscillators.forEach(osc => osc.start(time));\n\t\tif (this.envelope.sustain === 0) {\n\t\t\tthis._oscillators.forEach(osc => {\n\t\t\t\tosc.stop(time + this.toSeconds(this.envelope.attack) + this.toSeconds(this.envelope.decay));\n\t\t\t});\n\t\t}\n\t\treturn this;\n\t}\n\t\n\t/**\n\t * Trigger the release of the envelope.\n\t * @param time When the release should be triggered.\n\t */\n\tprotected _triggerEnvelopeRelease(time: Seconds): this {\n\t\tthis.envelope.triggerRelease(time);\n\t\tthis._oscillators.forEach(osc => osc.stop(time + this.toSeconds(this.envelope.release)));\n\t\treturn this;\n\t}\n\n\tgetLevelAtTime(time: Time): NormalRange {\n\t\ttime = this.toSeconds(time);\n\t\treturn this.envelope.getValueAtTime(time);\n\t}\n\n\t/**\n\t * The modulationIndex of the oscillators which make up the source.\n\t * see [[FMOscillator.modulationIndex]]\n\t * @min 1\n\t * @max 100\n\t */\n\tget modulationIndex(): number {\n\t\treturn this._oscillators[0].modulationIndex.value;\n\t}\n\tset modulationIndex(val) {\n\t\tthis._oscillators.forEach(osc => (osc.modulationIndex.value = val));\n\t}\n\n\t/**\n\t * The harmonicity of the oscillators which make up the source.\n\t * see Tone.FMOscillator.harmonicity\n\t * @min 0.1\n\t * @max 10\n\t */\n\tget harmonicity(): number {\n\t\treturn this._oscillators[0].harmonicity.value;\n\t}\n\tset harmonicity(val) {\n\t\tthis._oscillators.forEach(osc => (osc.harmonicity.value = val));\n\t}\n\n\t/**\n\t * The lower level of the highpass filter which is attached to the envelope.\n\t * This value should be between [0, 7000]\n\t * @min 0\n\t * @max 7000\n\t */\n\tget resonance(): Frequency {\n\t\treturn this._filterFreqScaler.min;\n\t}\n\tset resonance(val) {\n\t\tthis._filterFreqScaler.min = this.toFrequency(val);\n\t\tthis.octaves = this._octaves;\n\t}\n\n\t/**\n\t * The number of octaves above the \"resonance\" frequency\n\t * that the filter ramps during the attack/decay envelope\n\t * @min 0\n\t * @max 8\n\t */\n\tget octaves(): number {\n\t\treturn this._octaves;\n\t}\n\tset octaves(val) {\n\t\tthis._octaves = val;\n\t\tthis._filterFreqScaler.max = this._filterFreqScaler.min * Math.pow(2, val);\n\t}\n\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis._oscillators.forEach(osc => osc.dispose());\n\t\tthis._freqMultipliers.forEach(freqMult => freqMult.dispose());\n\t\tthis.frequency.dispose();\n\t\tthis.detune.dispose();\n\t\tthis._filterFreqScaler.dispose();\n\t\tthis._amplitude.dispose();\n\t\tthis.envelope.dispose();\n\t\tthis._highpass.dispose();\n\t\treturn this;\n\t}\n}\n","import { FrequencyClass } from \"../core/type/Frequency\";\nimport { Frequency, Positive, Time } from \"../core/type/Units\";\nimport { deepMerge, optionsFromArguments } from \"../core/util/Defaults\";\nimport { readOnly, RecursivePartial } from \"../core/util/Interface\";\nimport { Monophonic } from \"./Monophonic\";\nimport { Synth, SynthOptions } from \"./Synth\";\nimport { range, timeRange } from \"../core/util/Decorator\";\n\nexport interface MembraneSynthOptions extends SynthOptions {\n\tpitchDecay: Time;\n\toctaves: Positive;\n}\n\n/**\n * MembraneSynth makes kick and tom sounds using a single oscillator\n * with an amplitude envelope and frequency ramp. A Tone.OmniOscillator\n * is routed through a Tone.AmplitudeEnvelope to the output. The drum\n * quality of the sound comes from the frequency envelope applied\n * during MembraneSynth.triggerAttack(note). The frequency envelope\n * starts at <code>note * .octaves</code> and ramps to <code>note</code>\n * over the duration of <code>.pitchDecay</code>.\n * @example\n * const synth = new Tone.MembraneSynth().toDestination();\n * synth.triggerAttackRelease(\"C2\", \"8n\");\n * @category Instrument\n */\nexport class MembraneSynth extends Synth<MembraneSynthOptions> {\n\n\treadonly name: string = \"MembraneSynth\";\n\n\t/**\n\t * The number of octaves the pitch envelope ramps.\n\t * @min 0.5\n\t * @max 8\n\t */\n\t@range(0)\n\toctaves: Positive;\n\n\t/**\n\t * The amount of time the frequency envelope takes.\n\t * @min 0\n\t * @max 0.5\n\t */\n\t@timeRange(0)\n\tpitchDecay: Time;\n\n\t/**\n\t * Portamento is ignored in this synth. use pitch decay instead.\n\t */\n\treadonly portamento = 0;\n\n\t/**\n\t * @param options the options available for the synth see defaults\n\t */\n\tconstructor(options?: RecursivePartial<MembraneSynthOptions>)\n\tconstructor() {\n\n\t\tsuper(optionsFromArguments(MembraneSynth.getDefaults(), arguments));\n\t\tconst options = optionsFromArguments(MembraneSynth.getDefaults(), arguments);\n\n\t\tthis.pitchDecay = options.pitchDecay;\n\t\tthis.octaves = options.octaves;\n\t\treadOnly(this, [\"oscillator\", \"envelope\"]);\n\t}\n\n\tstatic getDefaults(): MembraneSynthOptions {\n\t\treturn deepMerge(Monophonic.getDefaults(), Synth.getDefaults(), {\n\t\t\tenvelope: {\n\t\t\t\tattack: 0.001,\n\t\t\t\tattackCurve: \"exponential\",\n\t\t\t\tdecay: 0.4,\n\t\t\t\trelease: 1.4,\n\t\t\t\tsustain: 0.01,\n\t\t\t},\n\t\t\toctaves: 10,\n\t\t\toscillator: {\n\t\t\t\ttype: \"sine\",\n\t\t\t},\n\t\t\tpitchDecay: 0.05,\n\t\t});\n\t}\n\n\tsetNote(note: Frequency | FrequencyClass, time?: Time): this {\n\t\tconst seconds = this.toSeconds(time);\n\t\tconst hertz = this.toFrequency(note instanceof FrequencyClass ? note.toFrequency() : note);\n\t\tconst maxNote = hertz * this.octaves;\n\t\tthis.oscillator.frequency.setValueAtTime(maxNote, seconds);\n\t\tthis.oscillator.frequency.exponentialRampToValueAtTime(hertz, seconds + this.toSeconds(this.pitchDecay));\n\t\treturn this;\n\t}\n\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\treturn this;\n\t}\n}\n","import { AmplitudeEnvelope } from \"../component/envelope/AmplitudeEnvelope\";\nimport { NormalRange, Time } from \"../core/type/Units\";\nimport { omitFromObject, optionsFromArguments } from \"../core/util/Defaults\";\nimport { RecursivePartial } from \"../core/util/Interface\";\nimport { Noise, NoiseOptions } from \"../source/Noise\";\nimport { Instrument, InstrumentOptions } from \"./Instrument\";\nimport { ToneAudioNode, ToneAudioNodeOptions } from \"../core/context/ToneAudioNode\";\nimport { Envelope, EnvelopeOptions } from \"../component/envelope/Envelope\";\nimport { Source } from \"../source/Source\";\n\nexport interface NoiseSynthOptions extends InstrumentOptions {\n\tenvelope: Omit<EnvelopeOptions, keyof ToneAudioNodeOptions>;\n\tnoise: Omit<NoiseOptions, keyof ToneAudioNodeOptions>;\n}\n\n/**\n * Tone.NoiseSynth is composed of [[Noise]] through an [[AmplitudeEnvelope]]. \n * ```\n * +-------+   +-------------------+\n * | Noise +>--> AmplitudeEnvelope +>--> Output\n * +-------+   +-------------------+\n * ```\n * @example\n * const noiseSynth = new Tone.NoiseSynth().toDestination();\n * noiseSynth.triggerAttackRelease(\"8n\", 0.05);\n * @category Instrument\n */\nexport class NoiseSynth extends Instrument<NoiseSynthOptions> {\n\n\treadonly name = \"NoiseSynth\";\n\n\t/**\n\t * The noise source.\n\t */\n\treadonly noise: Noise;\n\n\t/**\n\t * The amplitude envelope.\n\t */\n\treadonly envelope: AmplitudeEnvelope;\n\n\tconstructor(options?: RecursivePartial<NoiseSynthOptions>)\n\tconstructor() {\n\t\tsuper(optionsFromArguments(NoiseSynth.getDefaults(), arguments));\n\t\tconst options = optionsFromArguments(NoiseSynth.getDefaults(), arguments);\n\t\tthis.noise = new Noise(Object.assign({\n\t\t\tcontext: this.context,\n\t\t}, options.noise));\n\n\t\tthis.envelope = new AmplitudeEnvelope(Object.assign({\n\t\t\tcontext: this.context,\n\t\t}, options.envelope));\n\n\t\t// connect the noise to the output\n\t\tthis.noise.chain(this.envelope, this.output);\n\t}\n\n\tstatic getDefaults(): NoiseSynthOptions {\n\t\treturn Object.assign(Instrument.getDefaults(), {\n\t\t\tenvelope: Object.assign(\n\t\t\t\tomitFromObject(Envelope.getDefaults(), Object.keys(ToneAudioNode.getDefaults())),\n\t\t\t\t{\n\t\t\t\t\tdecay: 0.1,\n\t\t\t\t\tsustain: 0.0,\n\t\t\t\t},\n\t\t\t),\n\t\t\tnoise: Object.assign(\n\t\t\t\tomitFromObject(Noise.getDefaults(), Object.keys(Source.getDefaults())),\n\t\t\t\t{\n\t\t\t\t\ttype: \"white\",\n\t\t\t\t},\n\t\t\t),\n\t\t});\n\t}\n\n\t/**\n\t * Start the attack portion of the envelopes. Unlike other\n\t * instruments, Tone.NoiseSynth doesn't have a note.\n\t * @example\n\t * const noiseSynth = new Tone.NoiseSynth().toDestination();\n\t * noiseSynth.triggerAttack();\n\t */\n\ttriggerAttack(time?: Time, velocity: NormalRange = 1): this {\n\t\ttime = this.toSeconds(time);\n\t\t// the envelopes\n\t\tthis.envelope.triggerAttack(time, velocity);\n\t\t// start the noise\n\t\tthis.noise.start(time);\n\t\tif (this.envelope.sustain === 0) {\n\t\t\tthis.noise.stop(time + this.toSeconds(this.envelope.attack) + this.toSeconds(this.envelope.decay));\n\t\t}\n\t\treturn this;\n\t}\n\n\t/**\n\t * Start the release portion of the envelopes.\n\t */\n\ttriggerRelease(time?: Time): this {\n\t\ttime = this.toSeconds(time);\n\t\tthis.envelope.triggerRelease(time);\n\t\tthis.noise.stop(time + this.toSeconds(this.envelope.release));\n\t\treturn this;\n\t}\n\n\tsync(): this {\n\t\tif (this._syncState()) {\n\t\t\tthis._syncMethod(\"triggerAttack\", 0);\n\t\t\tthis._syncMethod(\"triggerRelease\", 0);\n\t\t}\n\t\treturn this;\n\t}\n\n\ttriggerAttackRelease(duration: Time, time?: Time, velocity: NormalRange = 1): this {\n\t\ttime = this.toSeconds(time);\n\t\tduration = this.toSeconds(duration);\n\t\tthis.triggerAttack(time, velocity);\n\t\tthis.triggerRelease(time + duration);\n\t\treturn this;\n\t}\n\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis.noise.dispose();\n\t\tthis.envelope.dispose();\n\t\treturn this;\n\t}\n}\n","/**\n * All of the classes or functions which are loaded into the AudioWorkletGlobalScope\n */\nconst workletContext: Set<string> = new Set();\n\n/**\n * Add a class to the AudioWorkletGlobalScope\n */\nexport function addToWorklet(classOrFunction: string) {\n\tworkletContext.add(classOrFunction);\n}\n\n/**\n * Register a processor in the AudioWorkletGlobalScope with the given name\n */\nexport function registerProcessor(name: string, classDesc: string) {\n\tconst processor = /* javascript */`registerProcessor(\"${name}\", ${classDesc})`;\n\tworkletContext.add(processor);\n}\n\n/**\n * Get all of the modules which have been registered to the AudioWorkletGlobalScope\n */\nexport function getWorkletGlobalScope(): string {\n\treturn Array.from(workletContext).join(\"\\n\");\n}\n","import { ToneAudioNode, ToneAudioNodeOptions } from \"../context/ToneAudioNode\";\nimport { noOp } from \"../util/Interface\";\nimport { getWorkletGlobalScope } from \"./WorkletGlobalScope\";\n\nexport type ToneAudioWorkletOptions = ToneAudioNodeOptions;\n\nexport abstract class ToneAudioWorklet<Options extends ToneAudioWorkletOptions> extends ToneAudioNode<Options> {\n\n\treadonly name: string = \"ToneAudioWorklet\";\n\n\t/**\n\t * The processing node\n\t */\n\tprotected _worklet!: AudioWorkletNode;\n\n\t/**\n\t * A dummy gain node to create a dummy audio param from\n\t */\n\tprivate _dummyGain: GainNode;\n\n\t/**\n\t * A dummy audio param to use when creating Params\n\t */\n\tprotected _dummyParam: AudioParam;\n\n\t/**\n\t * The constructor options for the node\n\t */\n\tprotected workletOptions: Partial<AudioWorkletNodeOptions> = {};\n\n\t/**\n\t * Get the name of the audio worklet\n\t */\n\tprotected abstract _audioWorkletName(): string;\n\n\t/**\n\t * Invoked when the module is loaded and the node is created\n\t */\n\tprotected abstract onReady(node: AudioWorkletNode): void;\n\n\t/**\n\t * Callback which is invoked when there is an error in the processing\n\t */\n\tonprocessorerror: (e: string) => void = noOp;\n\n\tconstructor(options: Options) {\n\t\tsuper(options);\n\n\t\tconst blobUrl = URL.createObjectURL(new Blob([getWorkletGlobalScope()], { type: \"text/javascript\" }));\n\t\tconst name = this._audioWorkletName();\n\n\t\tthis._dummyGain = this.context.createGain();\n\t\tthis._dummyParam = this._dummyGain.gain;\n\n\t\t// Register the processor\n\t\tthis.context.addAudioWorkletModule(blobUrl, name).then(() => {\n\t\t\t// create the worklet when it's read\n\t\t\tif (!this.disposed) {\n\t\t\t\tthis._worklet = this.context.createAudioWorkletNode(name, this.workletOptions);\n\t\t\t\tthis._worklet.onprocessorerror = this.onprocessorerror.bind(this);\n\t\t\t\tthis.onReady(this._worklet);\n\t\t\t}\n\t\t});\n\t}\n\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis._dummyGain.disconnect();\n\t\tif (this._worklet) {\n\t\t\tthis._worklet.port.postMessage(\"dispose\");\n\t\t\tthis._worklet.disconnect();\n\t\t}\n\t\treturn this;\n\t}\n\n}\n","import { addToWorklet } from \"./WorkletGlobalScope\";\n\nconst toneAudioWorkletProcessor = /* javascript */ `\n\t/**\n\t * The base AudioWorkletProcessor for use in Tone.js. Works with the [[ToneAudioWorklet]]. \n\t */\n\tclass ToneAudioWorkletProcessor extends AudioWorkletProcessor {\n\n\t\tconstructor(options) {\n\t\t\t\n\t\t\tsuper(options);\n\t\t\t/**\n\t\t\t * If the processor was disposed or not. Keep alive until it's disposed.\n\t\t\t */\n\t\t\tthis.disposed = false;\n\t\t   \t/** \n\t\t\t * The number of samples in the processing block\n\t\t\t */\n\t\t\tthis.blockSize = 128;\n\t\t\t/**\n\t\t\t * the sample rate\n\t\t\t */\n\t\t\tthis.sampleRate = sampleRate;\n\n\t\t\tthis.port.onmessage = (event) => {\n\t\t\t\t// when it receives a dispose \n\t\t\t\tif (event.data === \"dispose\") {\n\t\t\t\t\tthis.disposed = true;\n\t\t\t\t}\n\t\t\t};\n\t\t}\n\t}\n`;\n\naddToWorklet(toneAudioWorkletProcessor);\n","import \"./ToneAudioWorkletProcessor.worklet\";\nimport { addToWorklet } from \"./WorkletGlobalScope\";\n\nexport const singleIOProcess = /* javascript */ `\n\t/**\n\t * Abstract class for a single input/output processor. \n\t * has a 'generate' function which processes one sample at a time\n\t */\n\tclass SingleIOProcessor extends ToneAudioWorkletProcessor {\n\n\t\tconstructor(options) {\n\t\t\tsuper(Object.assign(options, {\n\t\t\t\tnumberOfInputs: 1,\n\t\t\t\tnumberOfOutputs: 1\n\t\t\t}));\n\t\t\t/**\n\t\t\t * Holds the name of the parameter and a single value of that\n\t\t\t * parameter at the current sample\n\t\t\t * @type { [name: string]: number }\n\t\t\t */\n\t\t\tthis.params = {}\n\t\t}\n\n\t\t/**\n\t\t * Generate an output sample from the input sample and parameters\n\t\t * @abstract\n\t\t * @param input number\n\t\t * @param channel number\n\t\t * @param parameters { [name: string]: number }\n\t\t * @returns number\n\t\t */\n\t\tgenerate(){}\n\n\t\t/**\n\t\t * Update the private params object with the \n\t\t * values of the parameters at the given index\n\t\t * @param parameters { [name: string]: Float32Array },\n\t\t * @param index number\n\t\t */\n\t\tupdateParams(parameters, index) {\n\t\t\tfor (const paramName in parameters) {\n\t\t\t\tconst param = parameters[paramName];\n\t\t\t\tif (param.length > 1) {\n\t\t\t\t\tthis.params[paramName] = parameters[paramName][index];\n\t\t\t\t} else {\n\t\t\t\t\tthis.params[paramName] = parameters[paramName][0];\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\t/**\n\t\t * Process a single frame of the audio\n\t\t * @param inputs Float32Array[][]\n\t\t * @param outputs Float32Array[][]\n\t\t */\n\t\tprocess(inputs, outputs, parameters) {\n\t\t\tconst input = inputs[0];\n\t\t\tconst output = outputs[0];\n\t\t\t// get the parameter values\n\t\t\tconst channelCount = Math.max(input && input.length || 0, output.length);\n\t\t\tfor (let sample = 0; sample < this.blockSize; sample++) {\n\t\t\t\tthis.updateParams(parameters, sample);\n\t\t\t\tfor (let channel = 0; channel < channelCount; channel++) {\n\t\t\t\t\tconst inputSample = input && input.length ? input[channel][sample] : 0;\n\t\t\t\t\toutput[channel][sample] = this.generate(inputSample, channel, this.params);\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn !this.disposed;\n\t\t}\n\t};\n`;\n\naddToWorklet(singleIOProcess);\n","import { addToWorklet } from \"./WorkletGlobalScope\";\n\nconst delayLine = /* javascript */ `\n\t/**\n\t * A multichannel buffer for use within an AudioWorkletProcessor as a delay line\n\t */\n\tclass DelayLine {\n\t\t\n\t\tconstructor(size, channels) {\n\t\t\tthis.buffer = [];\n\t\t\tthis.writeHead = []\n\t\t\tthis.size = size;\n\n\t\t\t// create the empty channels\n\t\t\tfor (let i = 0; i < channels; i++) {\n\t\t\t\tthis.buffer[i] = new Float32Array(this.size);\n\t\t\t\tthis.writeHead[i] = 0;\n\t\t\t}\n\t\t}\n\n\t\t/**\n\t\t * Push a value onto the end\n\t\t * @param channel number\n\t\t * @param value number\n\t\t */\n\t\tpush(channel, value) {\n\t\t\tthis.writeHead[channel] += 1;\n\t\t\tif (this.writeHead[channel] > this.size) {\n\t\t\t\tthis.writeHead[channel] = 0;\n\t\t\t}\n\t\t\tthis.buffer[channel][this.writeHead[channel]] = value;\n\t\t}\n\n\t\t/**\n\t\t * Get the recorded value of the channel given the delay\n\t\t * @param channel number\n\t\t * @param delay number delay samples\n\t\t */\n\t\tget(channel, delay) {\n\t\t\tlet readHead = this.writeHead[channel] - Math.floor(delay);\n\t\t\tif (readHead < 0) {\n\t\t\t\treadHead += this.size;\n\t\t\t}\n\t\t\treturn this.buffer[channel][readHead];\n\t\t}\n\t}\n`;\n\naddToWorklet(delayLine);\n","import \"../../core/worklet/SingleIOProcessor.worklet\";\nimport \"../../core/worklet/DelayLine.worklet\";\nimport { registerProcessor } from \"../../core/worklet/WorkletGlobalScope\";\n\nexport const workletName = \"feedback-comb-filter\";\n\nconst feedbackCombFilter = /* javascript */`\n\tclass FeedbackCombFilterWorklet extends SingleIOProcessor {\n\n\t\tconstructor(options) {\n\t\t\tsuper(options);\n\t\t\tthis.delayLine = new DelayLine(this.sampleRate, options.channelCount || 2);\n\t\t}\n\n\t\tstatic get parameterDescriptors() {\n\t\t\treturn [{\n\t\t\t\tname: \"delayTime\",\n\t\t\t\tdefaultValue: 0.1,\n\t\t\t\tminValue: 0,\n\t\t\t\tmaxValue: 1,\n\t\t\t\tautomationRate: \"k-rate\"\n\t\t\t}, {\n\t\t\t\tname: \"feedback\",\n\t\t\t\tdefaultValue: 0.5,\n\t\t\t\tminValue: 0,\n\t\t\t\tmaxValue: 0.9999,\n\t\t\t\tautomationRate: \"k-rate\"\n\t\t\t}];\n\t\t}\n\n\t\tgenerate(input, channel, parameters) {\n\t\t\tconst delayedSample = this.delayLine.get(channel, parameters.delayTime * this.sampleRate);\n\t\t\tthis.delayLine.push(channel, input + delayedSample * parameters.feedback);\n\t\t\treturn delayedSample;\n\t\t}\n\t}\n`;\n\nregisterProcessor(workletName, feedbackCombFilter);\n","import { Gain } from \"../../core/context/Gain\";\nimport { Param } from \"../../core/context/Param\";\nimport { connectSeries, ToneAudioNode, ToneAudioNodeOptions } from \"../../core/context/ToneAudioNode\";\nimport { NormalRange, Time } from \"../../core/type/Units\";\nimport { optionsFromArguments } from \"../../core/util/Defaults\";\nimport { readOnly, RecursivePartial } from \"../../core/util/Interface\";\nimport { ToneAudioWorklet } from \"../../core/worklet/ToneAudioWorklet\";\nimport { workletName } from \"./FeedbackCombFilter.worklet\";\n\nexport interface FeedbackCombFilterOptions extends ToneAudioNodeOptions {\n\tdelayTime: Time;\n\tresonance: NormalRange;\n}\n\n/**\n * Comb filters are basic building blocks for physical modeling. Read more\n * about comb filters on [CCRMA's website](https://ccrma.stanford.edu/~jos/pasp/Feedback_Comb_Filters.html).\n * \n * This comb filter is implemented with the AudioWorkletNode which allows it to have feedback delays less than the \n * Web Audio processing block of 128 samples. There is a polyfill for browsers that don't yet support the \n * AudioWorkletNode, but it will add some latency and have slower performance than the AudioWorkletNode. \n * @category Component\n */\nexport class FeedbackCombFilter extends ToneAudioWorklet<FeedbackCombFilterOptions> {\n\n\treadonly name = \"FeedbackCombFilter\";\n\n\t/**\n\t * The amount of delay of the comb filter.\n\t */\n\treadonly delayTime: Param<\"time\">;\n\n\t/**\n\t * The amount of feedback of the delayed signal.\n\t */\n\treadonly resonance: Param<\"normalRange\">;\n\n\treadonly input: Gain;\n\treadonly output: Gain;\n\n\t/**\n\t * @param delayTime The delay time of the filter.\n\t * @param resonance The amount of feedback the filter has.\n\t */\n\tconstructor(delayTime?: Time, resonance?: NormalRange);\n\tconstructor(options?: RecursivePartial<FeedbackCombFilterOptions>);\n\tconstructor() {\n\t\tsuper(optionsFromArguments(FeedbackCombFilter.getDefaults(), arguments, [\"delayTime\", \"resonance\"]));\n\t\tconst options = optionsFromArguments(FeedbackCombFilter.getDefaults(), arguments, [\"delayTime\", \"resonance\"]);\n\n\t\tthis.input = new Gain({ context: this.context });\n\t\tthis.output = new Gain({ context: this.context });\n\n\t\tthis.delayTime = new Param<\"time\">({\n\t\t\tcontext: this.context,\n\t\t\tvalue: options.delayTime,\n\t\t\tunits: \"time\",\n\t\t\tminValue: 0,\n\t\t\tmaxValue: 1,\n\t\t\tparam: this._dummyParam,\n\t\t\tswappable: true,\n\t\t});\n\n\t\tthis.resonance = new Param<\"normalRange\">({\n\t\t\tcontext: this.context,\n\t\t\tvalue: options.resonance,\n\t\t\tunits: \"normalRange\",\n\t\t\tparam: this._dummyParam,\n\t\t\tswappable: true,\n\t\t});\n\n\t\treadOnly(this, [\"resonance\", \"delayTime\"]);\n\t}\n\n\tprotected _audioWorkletName(): string {\n\t\treturn workletName;\n\t}\n\n\t/**\n\t * The default parameters\n\t */\n\tstatic getDefaults(): FeedbackCombFilterOptions {\n\t\treturn Object.assign(ToneAudioNode.getDefaults(), {\n\t\t\tdelayTime: 0.1,\n\t\t\tresonance: 0.5,\n\t\t});\n\t}\n\n\tonReady(node: AudioWorkletNode) {\n\t\tconnectSeries(this.input, node, this.output);\n\t\tconst delayTime = node.parameters.get(\"delayTime\") as AudioParam;\n\t\tthis.delayTime.setParam(delayTime);\n\t\tconst feedback = node.parameters.get(\"feedback\") as AudioParam;\n\t\tthis.resonance.setParam(feedback);\n\t}\n\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis.input.dispose();\n\t\tthis.output.dispose();\n\t\tthis.delayTime.dispose();\n\t\tthis.resonance.dispose();\n\t\treturn this;\n\t}\n}\n","import { ToneAudioNode, ToneAudioNodeOptions } from \"../../core/context/ToneAudioNode\";\nimport { Frequency } from \"../../core/type/Units\";\nimport { optionsFromArguments } from \"../../core/util/Defaults\";\nimport { Gain } from \"../../core/context/Gain\";\n\nexport type OnePoleFilterType = \"highpass\" | \"lowpass\";\n\nexport interface OnePoleFilterOptions extends ToneAudioNodeOptions {\n\tfrequency: Frequency;\n\ttype: OnePoleFilterType;\n}\n\n/**\n * A one pole filter with 6db-per-octave rolloff. Either \"highpass\" or \"lowpass\". \n * Note that changing the type or frequency may result in a discontinuity which\n * can sound like a click or pop. \n * References: \n * * http://www.earlevel.com/main/2012/12/15/a-one-pole-filter/  \n * * http://www.dspguide.com/ch19/2.htm\n * * https://github.com/vitaliy-bobrov/js-rocks/blob/master/src/app/audio/effects/one-pole-filters.ts\n * @category Component\n */\nexport class OnePoleFilter extends ToneAudioNode<OnePoleFilterOptions> {\n\t\n\treadonly name: string = \"OnePoleFilter\";\n\n\t/**\n\t * Hold the current frequency\n\t */\n\tprivate _frequency: Frequency;\n\n\t/**\n\t * the current one pole type\n\t */\n\tprivate _type: OnePoleFilterType;\n\n\t/**\n\t * the current one pole filter\n\t */\n\tprivate _filter!: IIRFilterNode;\n\n\treadonly input: Gain;\n\treadonly output: Gain;\n\n\t/**\n\t * @param frequency The frequency\n\t * @param type The  filter type, either \"lowpass\" or \"highpass\"\n\t */\n\tconstructor(frequency?: Frequency, type?: OnePoleFilterType);\n\tconstructor(options?: Partial<OnePoleFilterOptions>)\n\tconstructor() {\n\n\t\tsuper(optionsFromArguments(OnePoleFilter.getDefaults(), arguments, [\"frequency\", \"type\"]));\n\t\tconst options = optionsFromArguments(OnePoleFilter.getDefaults(), arguments, [\"frequency\", \"type\"]);\n\n\t\tthis._frequency = options.frequency;\n\t\tthis._type = options.type;\n\t\tthis.input = new Gain({ context: this.context });\n\t\tthis.output = new Gain({ context: this.context });\n\t\tthis._createFilter();\n\t}\n\n\tstatic getDefaults(): OnePoleFilterOptions {\n\t\treturn Object.assign(ToneAudioNode.getDefaults(), {\n\t\t\tfrequency: 880,\n\t\t\ttype: \"lowpass\" as OnePoleFilterType\n\t\t});\n\t}\n\n\t/**\n\t * Create a filter and dispose the old one\n\t */\n\tprivate _createFilter() {\n\t\tconst oldFilter = this._filter;\n\t\tconst freq = this.toFrequency(this._frequency);\n\t\tconst t = 1 / (2 * Math.PI * freq);\n\t\tif (this._type === \"lowpass\") {\n\t\t\tconst a0 = 1 / (t * this.context.sampleRate);\n\t\t\tconst b1 = a0 - 1;\n\t\t\tthis._filter = this.context.createIIRFilter([a0, 0], [1, b1]);\n\t\t} else {\n\t\t\tconst b1 = 1 / (t * this.context.sampleRate) - 1;\n\t\t\tthis._filter = this.context.createIIRFilter([1, -1], [1, b1]);\n\t\t}\n\t\t\n\t\tthis.input.chain(this._filter, this.output);\n\t\tif (oldFilter) {\n\t\t\t// dispose it on the next block\n\t\t\tthis.context.setTimeout(() => {\n\t\t\t\tif (!this.disposed) {\n\t\t\t\t\tthis.input.disconnect(oldFilter);\n\t\t\t\t\toldFilter.disconnect();\n\t\t\t\t}\n\t\t\t}, this.blockTime);\n\t\t}\n\t}\n\n\t/**\n\t * The frequency value. \n\t */\n\tget frequency(): Frequency {\n\t\treturn this._frequency;\n\t}\n\tset frequency(fq) {\n\t\tthis._frequency = fq;\n\t\tthis._createFilter();\n\t}\n\t\n\t/**\n\t * The OnePole Filter type, either \"highpass\" or \"lowpass\"\n\t */\n\tget type(): OnePoleFilterType {\n\t\treturn this._type;\n\t}\n\tset type(t) {\n\t\tthis._type = t;\n\t\tthis._createFilter();\n\t}\n\n\t/**\n\t * Get the frequency response curve. This curve represents how the filter\n\t * responses to frequencies between 20hz-20khz.\n\t * @param  len The number of values to return\n\t * @return The frequency response curve between 20-20kHz\n\t */\n\tgetFrequencyResponse(len = 128): Float32Array {\n\t\tconst freqValues = new Float32Array(len);\n\t\tfor (let i = 0; i < len; i++) {\n\t\t\tconst norm = Math.pow(i / len, 2);\n\t\t\tconst freq = norm * (20000 - 20) + 20;\n\t\t\tfreqValues[i] = freq;\n\t\t}\n\t\tconst magValues = new Float32Array(len);\n\t\tconst phaseValues = new Float32Array(len);\n\t\tthis._filter.getFrequencyResponse(freqValues, magValues, phaseValues);\n\t\treturn magValues;\n\t}\n\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis.input.dispose();\n\t\tthis.output.dispose();\n\t\tthis._filter.disconnect();\n\t\treturn this;\n\t}\n}\n","import { Param } from \"../../core/context/Param\";\nimport { InputNode, OutputNode, ToneAudioNode, ToneAudioNodeOptions } from \"../../core/context/ToneAudioNode\";\nimport { Frequency, NormalRange, Time } from \"../../core/type/Units\";\nimport { optionsFromArguments } from \"../../core/util/Defaults\";\nimport { RecursivePartial } from \"../../core/util/Interface\";\nimport { FeedbackCombFilter } from \"./FeedbackCombFilter\";\nimport { OnePoleFilter } from \"./OnePoleFilter\";\n\ninterface LowpassCombFilterOptions extends ToneAudioNodeOptions {\n\tdelayTime: Time;\n\tresonance: NormalRange;\n\tdampening: Frequency;\n}\n\n/**\n * A lowpass feedback comb filter. It is similar to\n * [[FeedbackCombFilter]], but includes a lowpass filter.\n * @category Component\n */\nexport class LowpassCombFilter extends ToneAudioNode<LowpassCombFilterOptions> {\n\n\treadonly name = \"LowpassCombFilter\";\n\n\t/**\n\t * The delay node\n\t */\n\tprivate _combFilter: FeedbackCombFilter;\n\n\t/**\n\t * The lowpass filter\n\t */\n\tprivate _lowpass: OnePoleFilter;\n\n\t/**\n\t * The delayTime of the comb filter.\n\t */\n\treadonly delayTime: Param<\"time\">;\n\n\t/**\n\t * The amount of feedback of the delayed signal.\n\t */\n\treadonly resonance: Param<\"normalRange\">;\n\n\treadonly input: InputNode;\n\treadonly output: OutputNode;\n\n\t/**\n\t * @param delayTime The delay time of the comb filter\n\t * @param resonance The resonance (feedback) of the comb filter\n\t * @param dampening The cutoff of the lowpass filter dampens the signal as it is fedback.\n\t */\n\tconstructor(delayTime?: Time, resonance?: NormalRange, dampening?: Frequency);\n\tconstructor(options?: RecursivePartial<LowpassCombFilterOptions>);\n\tconstructor() {\n\t\tsuper(optionsFromArguments(LowpassCombFilter.getDefaults(), arguments, [\"delayTime\", \"resonance\", \"dampening\"]));\n\t\tconst options = optionsFromArguments(LowpassCombFilter.getDefaults(), arguments, [\"delayTime\", \"resonance\", \"dampening\"]);\n\n\t\tthis._combFilter = this.output = new FeedbackCombFilter({\n\t\t\tcontext: this.context,\n\t\t\tdelayTime: options.delayTime,\n\t\t\tresonance: options.resonance,\n\t\t});\n\t\tthis.delayTime = this._combFilter.delayTime;\n\t\tthis.resonance = this._combFilter.resonance;\n\n\t\tthis._lowpass = this.input = new OnePoleFilter({\n\t\t\tcontext: this.context,\n\t\t\tfrequency: options.dampening,\n\t\t\ttype: \"lowpass\",\n\t\t});\n\n\t\t// connections\n\t\tthis._lowpass.connect(this._combFilter);\n\t}\n\n\tstatic getDefaults(): LowpassCombFilterOptions {\n\t\treturn Object.assign(ToneAudioNode.getDefaults(), {\n\t\t\tdampening: 3000,\n\t\t\tdelayTime: 0.1,\n\t\t\tresonance: 0.5,\n\t\t});\n\t}\n\t\n\t/**\n\t * The dampening control of the feedback\n\t */\n\tget dampening(): Frequency {\n\t\treturn this._lowpass.frequency;\n\t}\n\tset dampening(fq) {\n\t\tthis._lowpass.frequency = fq;\n\t}\n\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis._combFilter.dispose();\n\t\tthis._lowpass.dispose();\n\t\treturn this;\n\t}\n}\n","import { Frequency, NormalRange, Time } from \"../core/type/Units\";\nimport { LowpassCombFilter } from \"../component/filter/LowpassCombFilter\";\nimport { deepMerge } from \"../core/util/Defaults\";\nimport { optionsFromArguments } from \"../core/util/Defaults\";\nimport { RecursivePartial } from \"../core/util/Interface\";\nimport { Noise } from \"../source/Noise\";\nimport { Instrument, InstrumentOptions } from \"./Instrument\";\n\nexport interface PluckSynthOptions extends InstrumentOptions {\n\tattackNoise: number;\n\tdampening: Frequency;\n\tresonance: NormalRange;\n\trelease: Time;\n}\n\n/**\n * Karplus-Strong string synthesis.\n * @example\n * const plucky = new Tone.PluckSynth().toDestination();\n * plucky.triggerAttack(\"C4\", \"+0.5\");\n * plucky.triggerAttack(\"C3\", \"+1\");\n * plucky.triggerAttack(\"C2\", \"+1.5\");\n * plucky.triggerAttack(\"C1\", \"+2\");\n * @category Instrument\n */\nexport class PluckSynth extends Instrument<PluckSynthOptions> {\n\n\treadonly name = \"PluckSynth\";\n\n\t/**\n\t * Noise burst at the beginning\n\t */\n\tprivate _noise: Noise;\n\tprivate _lfcf: LowpassCombFilter;\n\n\t/**\n\t * The amount of noise at the attack.\n\t * Nominal range of [0.1, 20]\n\t * @min 0.1\n\t * @max 20\n\t */\n\tattackNoise: number;\n\n\t/**\n\t * The amount of resonance of the pluck. Also correlates to the sustain duration.\n\t */\n\tresonance: NormalRange;\n\n\t/**\n\t * The release time which corresponds to a resonance ramp down to 0\n\t */\n\trelease: Time;\n\n\tconstructor(options?: RecursivePartial<PluckSynthOptions>)\n\tconstructor() {\n\n\t\tsuper(optionsFromArguments(PluckSynth.getDefaults(), arguments));\n\t\tconst options = optionsFromArguments(PluckSynth.getDefaults(), arguments);\n\n\t\tthis._noise = new Noise({\n\t\t\tcontext: this.context,\n\t\t\ttype: \"pink\"\n\t\t});\n\n\t\tthis.attackNoise = options.attackNoise;\n\n\t\tthis._lfcf = new LowpassCombFilter({\n\t\t\tcontext: this.context,\n\t\t\tdampening: options.dampening,\n\t\t\tresonance: options.resonance,\n\t\t});\n\n\t\tthis.resonance = options.resonance;\n\t\tthis.release = options.release;\n\n\t\tthis._noise.connect(this._lfcf);\n\t\tthis._lfcf.connect(this.output);\n\t}\n\n\tstatic getDefaults(): PluckSynthOptions {\n\t\treturn deepMerge(Instrument.getDefaults(), {\n\t\t\tattackNoise: 1,\n\t\t\tdampening: 4000,\n\t\t\tresonance: 0.7,\n\t\t\trelease: 1,\n\t\t});\n\t}\n\n\t/**\n\t * The dampening control. i.e. the lowpass filter frequency of the comb filter\n\t * @min 0\n\t * @max 7000\n\t */\n\tget dampening(): Frequency {\n\t\treturn this._lfcf.dampening;\n\t}\n\tset dampening(fq) {\n\t\tthis._lfcf.dampening = fq;\n\t}\n\n\ttriggerAttack(note: Frequency, time?: Time): this {\n\t\tconst freq = this.toFrequency(note);\n\t\ttime = this.toSeconds(time);\n\t\tconst delayAmount = 1 / freq;\n\t\tthis._lfcf.delayTime.setValueAtTime(delayAmount, time);\n\t\tthis._noise.start(time);\n\t\tthis._noise.stop(time + delayAmount * this.attackNoise);\n\t\tthis._lfcf.resonance.cancelScheduledValues(time);\n\t\tthis._lfcf.resonance.setValueAtTime(this.resonance, time);\n\t\treturn this;\n\t}\n\n\t/**\n\t * Ramp down the [[resonance]] to 0 over the duration of the release time.\n\t */\n\ttriggerRelease(time?: Time): this {\n\t\tthis._lfcf.resonance.linearRampTo(0, this.release, time);\n\t\treturn this;\n\t}\n\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis._noise.dispose();\n\t\tthis._lfcf.dispose();\n\t\treturn this;\n\t}\n}\n","import { MidiClass } from \"../core/type/Midi\";\nimport { Frequency, MidiNote, NormalRange, Seconds, Time } from \"../core/type/Units\";\nimport { deepMerge, omitFromObject, optionsFromArguments } from \"../core/util/Defaults\";\nimport { RecursivePartial } from \"../core/util/Interface\";\nimport { isArray, isNumber } from \"../core/util/TypeCheck\";\nimport { Instrument, InstrumentOptions } from \"./Instrument\";\nimport { MembraneSynth, MembraneSynthOptions } from \"./MembraneSynth\";\nimport { FMSynth, FMSynthOptions } from \"./FMSynth\";\nimport { AMSynth, AMSynthOptions } from \"./AMSynth\";\nimport { MonoSynth, MonoSynthOptions } from \"./MonoSynth\";\nimport { MetalSynth, MetalSynthOptions } from \"./MetalSynth\";\nimport { Monophonic } from \"./Monophonic\";\nimport { Synth, SynthOptions } from \"./Synth\";\nimport { assert, warn } from \"../core/util/Debug\";\n\ntype VoiceConstructor<V> = {\n\tgetDefaults: () => VoiceOptions<V>;\n} & (new (...args: any[]) => V);\n\ntype OmitMonophonicOptions<T> = Omit<T, \"context\" | \"onsilence\">;\n\ntype VoiceOptions<T> =\n\tT extends MembraneSynth ? MembraneSynthOptions :\n\t\tT extends MetalSynth ? MetalSynthOptions :\n\t\t\tT extends FMSynth ? FMSynthOptions :\n\t\t\t\tT extends MonoSynth ? MonoSynthOptions :\n\t\t\t\t\tT extends AMSynth ? AMSynthOptions :\n\t\t\t\t\t\tT extends Synth ? SynthOptions :\n\t\t\t\t\t\t\tT extends Monophonic<infer U> ? U :\n\t\t\t\t\t\t\t\tnever;\n\n/**\n * The settable synth options. excludes monophonic options.\n */\ntype PartialVoiceOptions<T> = RecursivePartial<OmitMonophonicOptions<VoiceOptions<T>>>;\n\nexport interface PolySynthOptions<Voice> extends InstrumentOptions {\n\tmaxPolyphony: number;\n\tvoice: VoiceConstructor<Voice>;\n\toptions: PartialVoiceOptions<Voice>;\n}\n\n/**\n * PolySynth handles voice creation and allocation for any\n * instruments passed in as the second paramter. PolySynth is\n * not a synthesizer by itself, it merely manages voices of\n * one of the other types of synths, allowing any of the\n * monophonic synthesizers to be polyphonic.\n *\n * @example\n * const synth = new Tone.PolySynth().toDestination();\n * // set the attributes across all the voices using 'set'\n * synth.set({ detune: -1200 });\n * // play a chord\n * synth.triggerAttackRelease([\"C4\", \"E4\", \"A4\"], 1);\n * @category Instrument\n */\nexport class PolySynth<Voice extends Monophonic<any> = Synth> extends Instrument<VoiceOptions<Voice>> {\n\n\treadonly name: string = \"PolySynth\";\n\n\t/**\n\t * The voices which are not currently in use\n\t */\n\tprivate _availableVoices: Voice[] = [];\n\n\t/**\n\t * The currently active voices\n\t */\n\tprivate _activeVoices: Array<{ midi: MidiNote; voice: Voice; released: boolean }> = [];\n\n\t/**\n\t * All of the allocated voices for this synth.\n\t */\n\tprivate _voices: Voice[] = [];\n\n\t/**\n\t * The options that are set on the synth.\n\t */\n\tprivate options: VoiceOptions<Voice>;\n\n\t/**\n\t * The polyphony limit.\n\t */\n\tmaxPolyphony: number;\n\n\t/**\n\t * The voice constructor\n\t */\n\tprivate readonly voice: VoiceConstructor<Voice>;\n\n\t/**\n\t * A voice used for holding the get/set values\n\t */\n\tprivate _dummyVoice: Voice;\n\n\t/**\n\t * The GC timeout. Held so that it could be cancelled when the node is disposed.\n\t */\n\tprivate _gcTimeout = -1;\n\n\t/**\n\t * A moving average of the number of active voices\n\t */\n\tprivate _averageActiveVoices = 0;\n\n\t/**\n\t * @param voice The constructor of the voices\n\t * @param options\tThe options object to set the synth voice\n\t */\n\tconstructor(\n\t\tvoice?: VoiceConstructor<Voice>,\n\t\toptions?: PartialVoiceOptions<Voice>,\n\t);\n\tconstructor(options?: Partial<PolySynthOptions<Voice>>);\n\tconstructor() {\n\n\t\tsuper(optionsFromArguments(PolySynth.getDefaults(), arguments, [\"voice\", \"options\"]));\n\t\tconst options = optionsFromArguments(PolySynth.getDefaults(), arguments, [\"voice\", \"options\"]);\n\n\t\t// check against the old API (pre 14.3.0)\n\t\tassert(!isNumber(options.voice), \"DEPRECATED: The polyphony count is no longer the first argument.\");\n\n\t\tconst defaults = options.voice.getDefaults();\n\t\tthis.options = Object.assign(defaults, options.options) as VoiceOptions<Voice>;\n\t\tthis.voice = options.voice as unknown as VoiceConstructor<Voice>;\n\t\tthis.maxPolyphony = options.maxPolyphony;\n\n\t\t// create the first voice\n\t\tthis._dummyVoice = this._getNextAvailableVoice() as Voice;\n\t\t// remove it from the voices list\n\t\tconst index = this._voices.indexOf(this._dummyVoice);\n\t\tthis._voices.splice(index, 1);\n\t\t// kick off the GC interval\n\t\tthis._gcTimeout = this.context.setInterval(this._collectGarbage.bind(this), 1);\n\t}\n\n\tstatic getDefaults(): PolySynthOptions<Synth> {\n\t\treturn Object.assign(Instrument.getDefaults(), {\n\t\t\tmaxPolyphony: 32,\n\t\t\toptions: {},\n\t\t\tvoice: Synth,\n\t\t});\n\t}\n\n\t/**\n\t * The number of active voices.\n\t */\n\tget activeVoices(): number {\n\t\treturn this._activeVoices.length;\n\t}\n\n\t/**\n\t * Invoked when the source is done making sound, so that it can be\n\t * readded to the pool of available voices\n\t */\n\tprivate _makeVoiceAvailable(voice: Voice): void {\n\t\tthis._availableVoices.push(voice);\n\t\t// remove the midi note from 'active voices'\n\t\tconst activeVoiceIndex = this._activeVoices.findIndex((e) => e.voice === voice);\n\t\tthis._activeVoices.splice(activeVoiceIndex, 1);\n\t}\n\n\t/**\n\t * Get an available voice from the pool of available voices.\n\t * If one is not available and the maxPolyphony limit is reached,\n\t * steal a voice, otherwise return null.\n\t */\n\tprivate _getNextAvailableVoice(): Voice | undefined {\n\t\t// if there are available voices, return the first one\n\t\tif (this._availableVoices.length) {\n\t\t\treturn this._availableVoices.shift();\n\t\t} else if (this._voices.length < this.maxPolyphony) {\n\t\t\t// otherwise if there is still more maxPolyphony, make a new voice\n\t\t\tconst voice = new this.voice(Object.assign(this.options, {\n\t\t\t\tcontext: this.context,\n\t\t\t\tonsilence: this._makeVoiceAvailable.bind(this),\n\t\t\t}));\n\t\t\tassert(voice instanceof Monophonic, \"Voice must extend Monophonic class\");\n\t\t\tvoice.connect(this.output);\n\t\t\tthis._voices.push(voice);\n\t\t\treturn voice;\n\t\t} else {\n\t\t\twarn(\"Max polyphony exceeded. Note dropped.\");\n\t\t}\n\t}\n\n\t/**\n\t * Occasionally check if there are any allocated voices which can be cleaned up.\n\t */\n\tprivate _collectGarbage(): void {\n\t\tthis._averageActiveVoices = Math.max(this._averageActiveVoices * 0.95, this.activeVoices);\n\t\tif (this._availableVoices.length && this._voices.length > Math.ceil(this._averageActiveVoices + 1)) {\n\t\t\t// take off an available note\n\t\t\tconst firstAvail = this._availableVoices.shift() as Voice;\n\t\t\tconst index = this._voices.indexOf(firstAvail);\n\t\t\tthis._voices.splice(index, 1);\n\t\t\tif (!this.context.isOffline) {\n\t\t\t\tfirstAvail.dispose();\n\t\t\t}\n\t\t}\n\t}\n\n\t/**\n\t * Internal method which triggers the attack\n\t */\n\tprivate _triggerAttack(notes: Frequency[], time: Seconds, velocity?: NormalRange): void {\n\t\tnotes.forEach(note => {\n\t\t\tconst midiNote = new MidiClass(this.context, note).toMidi();\n\t\t\tconst voice = this._getNextAvailableVoice();\n\t\t\tif (voice) {\n\t\t\t\tvoice.triggerAttack(note, time, velocity);\n\t\t\t\tthis._activeVoices.push({\n\t\t\t\t\tmidi: midiNote, voice, released: false,\n\t\t\t\t});\n\t\t\t\tthis.log(\"triggerAttack\", note, time);\n\t\t\t}\n\t\t});\n\t}\n\n\t/**\n\t * Internal method which triggers the release\n\t */\n\tprivate _triggerRelease(notes: Frequency[], time: Seconds): void {\n\t\tnotes.forEach(note => {\n\t\t\tconst midiNote = new MidiClass(this.context, note).toMidi();\n\t\t\tconst event = this._activeVoices.find(({ midi, released }) => midi === midiNote && !released);\n\t\t\tif (event) {\n\t\t\t\t// trigger release on that note\n\t\t\t\tevent.voice.triggerRelease(time);\n\t\t\t\t// mark it as released\n\t\t\t\tevent.released = true;\n\t\t\t\tthis.log(\"triggerRelease\", note, time);\n\t\t\t}\n\t\t});\n\t}\n\n\t/**\n\t * Schedule the attack/release events. If the time is in the future, then it should set a timeout\n\t * to wait for just-in-time scheduling\n\t */\n\tprivate _scheduleEvent(type: \"attack\" | \"release\", notes: Frequency[], time: Seconds, velocity?: NormalRange): void {\n\t\tassert(!this.disposed, \"Synth was already disposed\");\n\t\t// if the notes are greater than this amount of time in the future, they should be scheduled with setTimeout\n\t\tif (time <= this.now()) {\n\t\t\t// do it immediately\n\t\t\tif (type === \"attack\") {\n\t\t\t\tthis._triggerAttack(notes, time, velocity);\n\t\t\t} else {\n\t\t\t\tthis._triggerRelease(notes, time);\n\t\t\t}\n\t\t} else {\n\t\t\t// schedule it to start in the future\n\t\t\tthis.context.setTimeout(() => {\n\t\t\t\tif (!this.disposed) {\n\t\t\t\t\tthis._scheduleEvent(type, notes, time, velocity);\n\t\t\t\t}\n\t\t\t}, time - this.now());\n\t\t}\n\t}\n\n\t/**\n\t * Trigger the attack portion of the note\n\t * @param  notes The notes to play. Accepts a single Frequency or an array of frequencies.\n\t * @param  time  The start time of the note.\n\t * @param velocity The velocity of the note.\n\t * @example\n\t * const synth = new Tone.PolySynth(Tone.FMSynth).toDestination();\n\t * // trigger a chord immediately with a velocity of 0.2\n\t * synth.triggerAttack([\"Ab3\", \"C4\", \"F5\"], Tone.now(), 0.2);\n\t */\n\ttriggerAttack(notes: Frequency | Frequency[], time?: Time, velocity?: NormalRange): this {\n\n\t\tif (!Array.isArray(notes)) {\n\t\t\tnotes = [notes];\n\t\t}\n\t\tconst computedTime = this.toSeconds(time);\n\t\tthis._scheduleEvent(\"attack\", notes, computedTime, velocity);\n\t\treturn this;\n\t}\n\n\t/**\n\t * Trigger the release of the note. Unlike monophonic instruments,\n\t * a note (or array of notes) needs to be passed in as the first argument.\n\t * @param  notes The notes to play. Accepts a single Frequency or an array of frequencies.\n\t * @param  time  When the release will be triggered.\n\t * @example\n\t * @example\n\t * const poly = new Tone.PolySynth(Tone.AMSynth).toDestination();\n\t * poly.triggerAttack([\"Ab3\", \"C4\", \"F5\"]);\n\t * // trigger the release of the given notes.\n\t * poly.triggerRelease([\"Ab3\", \"C4\"], \"+1\");\n\t * poly.triggerRelease(\"F5\", \"+3\");\n\t */\n\ttriggerRelease(notes: Frequency | Frequency[], time?: Time): this {\n\t\tif (!Array.isArray(notes)) {\n\t\t\tnotes = [notes];\n\t\t}\n\t\tconst computedTime = this.toSeconds(time);\n\t\tthis._scheduleEvent(\"release\", notes, computedTime);\n\t\treturn this;\n\t}\n\n\t/**\n\t * Trigger the attack and release after the specified duration\n\t * @param  notes The notes to play. Accepts a single  Frequency or an array of frequencies.\n\t * @param  duration the duration of the note\n\t * @param  time  if no time is given, defaults to now\n\t * @param  velocity the velocity of the attack (0-1)\n\t * @example\n\t * const poly = new Tone.PolySynth(Tone.AMSynth).toDestination();\n\t * // can pass in an array of durations as well\n\t * poly.triggerAttackRelease([\"Eb3\", \"G4\", \"Bb4\", \"D5\"], [4, 3, 2, 1]);\n\t */\n\ttriggerAttackRelease(\n\t\tnotes: Frequency | Frequency[],\n\t\tduration: Time | Time[],\n\t\ttime?: Time,\n\t\tvelocity?: NormalRange,\n\t): this {\n\t\tconst computedTime = this.toSeconds(time);\n\t\tthis.triggerAttack(notes, computedTime, velocity);\n\t\tif (isArray(duration)) {\n\t\t\tassert(isArray(notes), \"If the duration is an array, the notes must also be an array\");\n\t\t\tnotes = notes as Frequency[];\n\t\t\tfor (let i = 0; i < notes.length; i++) {\n\t\t\t\tconst d = duration[Math.min(i, duration.length - 1)];\n\t\t\t\tconst durationSeconds = this.toSeconds(d);\n\t\t\t\tassert(durationSeconds > 0, \"The duration must be greater than 0\");\n\t\t\t\tthis.triggerRelease(notes[i], computedTime + durationSeconds);\n\t\t\t}\n\t\t} else {\n\t\t\tconst durationSeconds = this.toSeconds(duration);\n\t\t\tassert(durationSeconds > 0, \"The duration must be greater than 0\");\n\t\t\tthis.triggerRelease(notes, computedTime + durationSeconds);\n\t\t}\n\t\treturn this;\n\t}\n\n\tsync(): this {\n\t\tif (this._syncState()) {\n\t\t\tthis._syncMethod(\"triggerAttack\", 1);\n\t\t\tthis._syncMethod(\"triggerRelease\", 1);\n\n\t\t\t// make sure that the sound doesn't play after its been stopped\n\t\t\tthis.context.transport.on(\"stop\", this._syncedRelease);\n\t\t\tthis.context.transport.on(\"pause\", this._syncedRelease);\n\t\t\tthis.context.transport.on(\"loopEnd\", this._syncedRelease);\n\t\t}\n\t\treturn this;\n\t}\n\n\t/**\n\t * The release which is scheduled to the timeline. \n\t */\n\t protected _syncedRelease = (time: number) => this.releaseAll(time);\n\n\t/**\n\t * Set a member/attribute of the voices\n\t * @example\n\t * const poly = new Tone.PolySynth().toDestination();\n\t * // set all of the voices using an options object for the synth type\n\t * poly.set({\n\t * \tenvelope: {\n\t * \t\tattack: 0.25\n\t * \t}\n\t * });\n\t * poly.triggerAttackRelease(\"Bb3\", 0.2);\n\t */\n\tset(options: RecursivePartial<VoiceOptions<Voice>>): this {\n\t\t// remove options which are controlled by the PolySynth\n\t\tconst sanitizedOptions = omitFromObject(options, [\"onsilence\", \"context\"]);\n\t\t// store all of the options\n\t\tthis.options = deepMerge(this.options, sanitizedOptions);\n\t\tthis._voices.forEach(voice => voice.set(sanitizedOptions));\n\t\tthis._dummyVoice.set(sanitizedOptions);\n\t\treturn this;\n\t}\n\n\tget(): VoiceOptions<Voice> {\n\t\treturn this._dummyVoice.get();\n\t}\n\n\t/**\n\t * Trigger the release portion of all the currently active voices immediately.\n\t * Useful for silencing the synth.\n\t */\n\treleaseAll(time?: Time): this {\n\t\tconst computedTime = this.toSeconds(time);\n\t\tthis._activeVoices.forEach(({ voice }) => {\n\t\t\tvoice.triggerRelease(computedTime);\n\t\t});\n\t\treturn this;\n\t}\n\t\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis._dummyVoice.dispose();\n\t\tthis._voices.forEach(v => v.dispose());\n\t\tthis._activeVoices = [];\n\t\tthis._availableVoices = [];\n\t\tthis.context.clearInterval(this._gcTimeout);\n\t\treturn this;\n\t}\n}\n","import { ToneAudioBuffer } from \"../core/context/ToneAudioBuffer\";\nimport { ToneAudioBuffers } from \"../core/context/ToneAudioBuffers\";\nimport { ftomf, intervalToFrequencyRatio } from \"../core/type/Conversions\";\nimport { FrequencyClass } from \"../core/type/Frequency\";\nimport { Frequency, Interval, MidiNote, NormalRange, Note, Time } from \"../core/type/Units\";\nimport { optionsFromArguments } from \"../core/util/Defaults\";\nimport { noOp } from \"../core/util/Interface\";\nimport { isArray, isNote, isNumber } from \"../core/util/TypeCheck\";\nimport { Instrument, InstrumentOptions } from \"../instrument/Instrument\";\nimport { ToneBufferSource, ToneBufferSourceCurve } from \"../source/buffer/ToneBufferSource\";\nimport { timeRange } from \"../core/util/Decorator\";\nimport { assert } from \"../core/util/Debug\";\n\ninterface SamplesMap {\n\t[note: string]: ToneAudioBuffer | AudioBuffer | string;\n\t[midi: number]: ToneAudioBuffer | AudioBuffer | string;\n}\n\nexport interface SamplerOptions extends InstrumentOptions {\n\tattack: Time;\n\trelease: Time;\n\tonload: () => void;\n\tonerror: (error: Error) => void;\n\tbaseUrl: string;\n\tcurve: ToneBufferSourceCurve;\n\turls: SamplesMap;\n}\n\n/**\n * Pass in an object which maps the note's pitch or midi value to the url,\n * then you can trigger the attack and release of that note like other instruments.\n * By automatically repitching the samples, it is possible to play pitches which\n * were not explicitly included which can save loading time.\n *\n * For sample or buffer playback where repitching is not necessary,\n * use [[Player]].\n * @example\n * const sampler = new Tone.Sampler({\n * \turls: {\n * \t\tA1: \"A1.mp3\",\n * \t\tA2: \"A2.mp3\",\n * \t},\n * \tbaseUrl: \"https://tonejs.github.io/audio/casio/\",\n * \tonload: () => {\n * \t\tsampler.triggerAttackRelease([\"C1\", \"E1\", \"G1\", \"B1\"], 0.5);\n * \t}\n * }).toDestination();\n * @category Instrument\n */\nexport class Sampler extends Instrument<SamplerOptions> {\n\n\treadonly name: string = \"Sampler\";\n\n\t/**\n\t * The stored and loaded buffers\n\t */\n\tprivate _buffers: ToneAudioBuffers;\n\n\t/**\n\t * The object of all currently playing BufferSources\n\t */\n\tprivate _activeSources: Map<MidiNote, ToneBufferSource[]> = new Map();\n\n\t/**\n\t * The envelope applied to the beginning of the sample.\n\t * @min 0\n\t * @max 1\n\t */\n\t@timeRange(0)\n\tattack: Time;\n\n\t/**\n\t * The envelope applied to the end of the envelope.\n\t * @min 0\n\t * @max 1\n\t */\n\t@timeRange(0)\n\trelease: Time;\n\n\t/**\n\t * The shape of the attack/release curve.\n\t * Either \"linear\" or \"exponential\"\n\t */\n\tcurve: ToneBufferSourceCurve;\n\n\t/**\n\t * @param samples An object of samples mapping either Midi Note Numbers or\n\t * \t\t\tScientific Pitch Notation to the url of that sample.\n\t * @param onload The callback to invoke when all of the samples are loaded.\n\t * @param baseUrl The root URL of all of the samples, which is prepended to all the URLs.\n\t */\n\tconstructor(samples?: SamplesMap, onload?: () => void, baseUrl?: string);\n\t/**\n\t * @param samples An object of samples mapping either Midi Note Numbers or\n\t * \t\t\tScientific Pitch Notation to the url of that sample.\n\t * @param options The remaining options associated with the sampler\n\t */\n\tconstructor(samples?: SamplesMap, options?: Partial<Omit<SamplerOptions, \"urls\">>);\n\tconstructor(options?: Partial<SamplerOptions>);\n\tconstructor() {\n\n\t\tsuper(optionsFromArguments(Sampler.getDefaults(), arguments, [\"urls\", \"onload\", \"baseUrl\"], \"urls\"));\n\t\tconst options = optionsFromArguments(Sampler.getDefaults(), arguments, [\"urls\", \"onload\", \"baseUrl\"], \"urls\");\n\n\t\tconst urlMap = {};\n\t\tObject.keys(options.urls).forEach((note) => {\n\t\t\tconst noteNumber = parseInt(note, 10);\n\t\t\tassert(isNote(note)\n\t\t\t\t|| (isNumber(noteNumber) && isFinite(noteNumber)), `url key is neither a note or midi pitch: ${note}`);\n\t\t\tif (isNote(note)) {\n\t\t\t\t// convert the note name to MIDI\n\t\t\t\tconst mid = new FrequencyClass(this.context, note).toMidi();\n\t\t\t\turlMap[mid] = options.urls[note];\n\t\t\t} else if (isNumber(noteNumber) && isFinite(noteNumber)) {\n\t\t\t\t// otherwise if it's numbers assume it's midi\n\t\t\t\turlMap[noteNumber] = options.urls[noteNumber];\n\t\t\t}\n\t\t});\n\n\t\tthis._buffers = new ToneAudioBuffers({\n\t\t\turls: urlMap,\n\t\t\tonload: options.onload,\n\t\t\tbaseUrl: options.baseUrl,\n\t\t\tonerror: options.onerror,\n\t\t});\n\t\tthis.attack = options.attack;\n\t\tthis.release = options.release;\n\t\tthis.curve = options.curve;\n\n\t\t// invoke the callback if it's already loaded\n\t\tif (this._buffers.loaded) {\n\t\t\t// invoke onload deferred\n\t\t\tPromise.resolve().then(options.onload);\n\t\t}\n\t}\n\n\tstatic getDefaults(): SamplerOptions {\n\t\treturn Object.assign(Instrument.getDefaults(), {\n\t\t\tattack: 0,\n\t\t\tbaseUrl: \"\",\n\t\t\tcurve: \"exponential\" as const,\n\t\t\tonload: noOp,\n\t\t\tonerror: noOp,\n\t\t\trelease: 0.1,\n\t\t\turls: {},\n\t\t});\n\t}\n\n\t/**\n\t * Returns the difference in steps between the given midi note at the closets sample.\n\t */\n\tprivate _findClosest(midi: MidiNote): Interval {\n\t\t// searches within 8 octaves of the given midi note\n\t\tconst MAX_INTERVAL = 96;\n\t\tlet interval = 0;\n\t\twhile (interval < MAX_INTERVAL) {\n\t\t\t// check above and below\n\t\t\tif (this._buffers.has(midi + interval)) {\n\t\t\t\treturn -interval;\n\t\t\t} else if (this._buffers.has(midi - interval)) {\n\t\t\t\treturn interval;\n\t\t\t}\n\t\t\tinterval++;\n\t\t}\n\t\tthrow new Error(`No available buffers for note: ${midi}`);\n\t}\n\n\t/**\n\t * @param  notes\tThe note to play, or an array of notes.\n\t * @param  time     When to play the note\n\t * @param  velocity The velocity to play the sample back.\n\t */\n\ttriggerAttack(notes: Frequency | Frequency[], time?: Time, velocity: NormalRange = 1): this {\n\t\tthis.log(\"triggerAttack\", notes, time, velocity);\n\t\tif (!Array.isArray(notes)) {\n\t\t\tnotes = [notes];\n\t\t}\n\t\tnotes.forEach(note => {\n\t\t\tconst midiFloat = ftomf(new FrequencyClass(this.context, note).toFrequency());\n\t\t\tconst midi = Math.round(midiFloat) as MidiNote;\n\t\t\tconst remainder = midiFloat - midi;\n\t\t\t// find the closest note pitch\n\t\t\tconst difference = this._findClosest(midi);\n\t\t\tconst closestNote = midi - difference;\n\t\t\tconst buffer = this._buffers.get(closestNote);\n\t\t\tconst playbackRate = intervalToFrequencyRatio(difference + remainder);\n\t\t\t// play that note\n\t\t\tconst source = new ToneBufferSource({\n\t\t\t\turl: buffer,\n\t\t\t\tcontext: this.context,\n\t\t\t\tcurve: this.curve,\n\t\t\t\tfadeIn: this.attack,\n\t\t\t\tfadeOut: this.release,\n\t\t\t\tplaybackRate,\n\t\t\t}).connect(this.output);\n\t\t\tsource.start(time, 0, buffer.duration / playbackRate, velocity);\n\t\t\t// add it to the active sources\n\t\t\tif (!isArray(this._activeSources.get(midi))) {\n\t\t\t\tthis._activeSources.set(midi, []);\n\t\t\t}\n\t\t\t(this._activeSources.get(midi) as ToneBufferSource[]).push(source);\n\n\t\t\t// remove it when it's done\n\t\t\tsource.onended = () => {\n\t\t\t\tif (this._activeSources && this._activeSources.has(midi)) {\n\t\t\t\t\tconst sources = this._activeSources.get(midi) as ToneBufferSource[];\n\t\t\t\t\tconst index = sources.indexOf(source);\n\t\t\t\t\tif (index !== -1) {\n\t\t\t\t\t\tsources.splice(index, 1);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t};\n\t\t});\n\t\treturn this;\n\t}\n\n\t/**\n\t * @param  notes\tThe note to release, or an array of notes.\n\t * @param  time     \tWhen to release the note.\n\t */\n\ttriggerRelease(notes: Frequency | Frequency[], time?: Time): this {\n\t\tthis.log(\"triggerRelease\", notes, time);\n\t\tif (!Array.isArray(notes)) {\n\t\t\tnotes = [notes];\n\t\t}\n\t\tnotes.forEach(note => {\n\t\t\tconst midi = new FrequencyClass(this.context, note).toMidi();\n\t\t\t// find the note\n\t\t\tif (this._activeSources.has(midi) && (this._activeSources.get(midi) as ToneBufferSource[]).length) {\n\t\t\t\tconst sources = this._activeSources.get(midi) as ToneBufferSource[];\n\t\t\t\ttime = this.toSeconds(time);\n\t\t\t\tsources.forEach(source => {\n\t\t\t\t\tsource.stop(time);\n\t\t\t\t});\n\t\t\t\tthis._activeSources.set(midi, []);\n\t\t\t}\n\t\t});\n\t\treturn this;\n\t}\n\n\t/**\n\t * Release all currently active notes.\n\t * @param  time     \tWhen to release the notes.\n\t */\n\treleaseAll(time?: Time): this {\n\t\tconst computedTime = this.toSeconds(time);\n\t\tthis._activeSources.forEach(sources => {\n\t\t\twhile (sources.length) {\n\t\t\t\tconst source = sources.shift() as ToneBufferSource;\n\t\t\t\tsource.stop(computedTime);\n\t\t\t}\n\t\t});\n\t\treturn this;\n\t}\n\n\tsync(): this {\n\t\tif (this._syncState()) {\n\t\t\tthis._syncMethod(\"triggerAttack\", 1);\n\t\t\tthis._syncMethod(\"triggerRelease\", 1);\n\t\t}\n\t\treturn this;\n\t}\n\n\t/**\n\t * Invoke the attack phase, then after the duration, invoke the release.\n\t * @param  notes\tThe note to play and release, or an array of notes.\n\t * @param  duration The time the note should be held\n\t * @param  time     When to start the attack\n\t * @param  velocity The velocity of the attack\n\t */\n\ttriggerAttackRelease(\n\t\tnotes: Frequency[] | Frequency,\n\t\tduration: Time | Time[],\n\t\ttime?: Time,\n\t\tvelocity: NormalRange = 1,\n\t): this {\n\t\tconst computedTime = this.toSeconds(time);\n\t\tthis.triggerAttack(notes, computedTime, velocity);\n\t\tif (isArray(duration)) {\n\t\t\tassert(isArray(notes), \"notes must be an array when duration is array\");\n\t\t\t(notes as Frequency[]).forEach((note, index) => {\n\t\t\t\tconst d = duration[Math.min(index, duration.length - 1)];\n\t\t\t\tthis.triggerRelease(note, computedTime + this.toSeconds(d));\n\t\t\t});\n\t\t} else {\n\t\t\tthis.triggerRelease(notes, computedTime + this.toSeconds(duration));\n\t\t}\n\t\treturn this;\n\t}\n\n\t/**\n\t * Add a note to the sampler.\n\t * @param  note      The buffer's pitch.\n\t * @param  url  Either the url of the buffer, or a buffer which will be added with the given name.\n\t * @param  callback  The callback to invoke when the url is loaded.\n\t */\n\tadd(note: Note | MidiNote, url: string | ToneAudioBuffer | AudioBuffer, callback?: () => void): this {\n\t\tassert(isNote(note) || isFinite(note), `note must be a pitch or midi: ${note}`);\n\t\tif (isNote(note)) {\n\t\t\t// convert the note name to MIDI\n\t\t\tconst mid = new FrequencyClass(this.context, note).toMidi();\n\t\t\tthis._buffers.add(mid, url, callback);\n\t\t} else {\n\t\t\t// otherwise if it's numbers assume it's midi\n\t\t\tthis._buffers.add(note, url, callback);\n\t\t}\n\t\treturn this;\n\t}\n\n\t/**\n\t * If the buffers are loaded or not\n\t */\n\tget loaded(): boolean {\n\t\treturn this._buffers.loaded;\n\t}\n\n\t/**\n\t * Clean up\n\t */\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis._buffers.dispose();\n\t\tthis._activeSources.forEach(sources => {\n\t\t\tsources.forEach(source => source.dispose());\n\t\t});\n\t\tthis._activeSources.clear();\n\t\treturn this;\n\t}\n}\n","import \"../core/clock/Transport\";\nimport { ToneWithContext, ToneWithContextOptions } from \"../core/context/ToneWithContext\";\nimport { TicksClass } from \"../core/type/Ticks\";\nimport { TransportTimeClass } from \"../core/type/TransportTime\";\nimport { NormalRange, Positive, Seconds, Ticks, Time, TransportTime } from \"../core/type/Units\";\nimport { defaultArg, optionsFromArguments } from \"../core/util/Defaults\";\nimport { noOp } from \"../core/util/Interface\";\nimport { BasicPlaybackState, StateTimeline } from \"../core/util/StateTimeline\";\nimport { isBoolean, isNumber } from \"../core/util/TypeCheck\";\n\nexport type ToneEventCallback<T> = (time: Seconds, value: T) => void;\n\nexport interface ToneEventOptions<T> extends ToneWithContextOptions {\n\tcallback: ToneEventCallback<T>;\n\tloop: boolean | number;\n\tloopEnd: Time;\n\tloopStart: Time;\n\tplaybackRate: Positive;\n\tvalue?: T;\n\tprobability: NormalRange;\n\tmute: boolean;\n\thumanize: boolean | Time;\n}\n\n/**\n * ToneEvent abstracts away this.context.transport.schedule and provides a schedulable\n * callback for a single or repeatable events along the timeline.\n *\n * @example\n * const synth = new Tone.PolySynth().toDestination();\n * const chordEvent = new Tone.ToneEvent(((time, chord) => {\n * \t// the chord as well as the exact time of the event\n * \t// are passed in as arguments to the callback function\n * \tsynth.triggerAttackRelease(chord, 0.5, time);\n * }), [\"D4\", \"E4\", \"F4\"]);\n * // start the chord at the beginning of the transport timeline\n * chordEvent.start();\n * // loop it every measure for 8 measures\n * chordEvent.loop = 8;\n * chordEvent.loopEnd = \"1m\";\n * @category Event\n */\nexport class ToneEvent<ValueType = any> extends ToneWithContext<ToneEventOptions<ValueType>> {\n\n\treadonly name: string = \"ToneEvent\";\n\n\t/**\n\t * Loop value\n\t */\n\tprotected _loop: boolean | number;\n\n\t/**\n\t * The callback to invoke.\n\t */\n\tcallback: ToneEventCallback<ValueType>;\n\n\t/**\n\t * The value which is passed to the\n\t * callback function.\n\t */\n\tvalue: ValueType;\n\n\t/**\n\t * When the note is scheduled to start.\n\t */\n\tprotected _loopStart: Ticks;\n\n\t/**\n\t * When the note is scheduled to start.\n\t */\n\tprotected _loopEnd: Ticks;\n\n\t/**\n\t * Tracks the scheduled events\n\t */\n\tprotected _state: StateTimeline<{\n\t\tid: number;\n\t}> = new StateTimeline(\"stopped\");\n\n\t/**\n\t * The playback speed of the note. A speed of 1\n\t * is no change.\n\t */\n\tprotected _playbackRate: Positive;\n\n\t/**\n\t * A delay time from when the event is scheduled to start\n\t */\n\tprotected _startOffset: Ticks = 0;\n\n\t/**\n\t * private holder of probability value\n\t */\n\tprotected _probability: NormalRange;\n\n\t/**\n\t * the amount of variation from the given time.\n\t */\n\tprotected _humanize: boolean | Time;\n\n\t/**\n\t * If mute is true, the callback won't be invoked.\n\t */\n\tmute: boolean;\n\n\t/**\n\t * @param callback The callback to invoke at the time.\n\t * @param value The value or values which should be passed to the callback function on invocation.\n\t */\n\tconstructor(callback?: ToneEventCallback<ValueType>, value?: ValueType);\n\tconstructor(options?: Partial<ToneEventOptions<ValueType>>);\n\tconstructor() {\n\n\t\tsuper(optionsFromArguments(ToneEvent.getDefaults(), arguments, [\"callback\", \"value\"]));\n\t\tconst options = optionsFromArguments(ToneEvent.getDefaults(), arguments, [\"callback\", \"value\"]);\n\n\t\tthis._loop = options.loop;\n\t\tthis.callback = options.callback;\n\t\tthis.value = options.value;\n\t\tthis._loopStart = this.toTicks(options.loopStart);\n\t\tthis._loopEnd = this.toTicks(options.loopEnd);\n\t\tthis._playbackRate = options.playbackRate;\n\t\tthis._probability = options.probability;\n\t\tthis._humanize = options.humanize;\n\t\tthis.mute = options.mute;\n\t\tthis._playbackRate = options.playbackRate;\n\t\tthis._state.increasing = true;\n\t\t// schedule the events for the first time\n\t\tthis._rescheduleEvents();\n\t}\n\n\tstatic getDefaults(): ToneEventOptions<any> {\n\t\treturn Object.assign(ToneWithContext.getDefaults(), {\n\t\t\tcallback: noOp,\n\t\t\thumanize: false,\n\t\t\tloop: false,\n\t\t\tloopEnd: \"1m\",\n\t\t\tloopStart: 0,\n\t\t\tmute: false,\n\t\t\tplaybackRate: 1,\n\t\t\tprobability: 1,\n\t\t\tvalue: null,\n\t\t});\n\t}\n\n\t/**\n\t * Reschedule all of the events along the timeline\n\t * with the updated values.\n\t * @param after Only reschedules events after the given time.\n\t */\n\tprivate _rescheduleEvents(after: Ticks = -1): void {\n\t\t// if no argument is given, schedules all of the events\n\t\tthis._state.forEachFrom(after, event => {\n\t\t\tlet duration;\n\t\t\tif (event.state === \"started\") {\n\t\t\t\tif (event.id !== -1) {\n\t\t\t\t\tthis.context.transport.clear(event.id);\n\t\t\t\t}\n\t\t\t\tconst startTick = event.time + Math.round(this.startOffset / this._playbackRate);\n\t\t\t\tif (this._loop === true || isNumber(this._loop) && this._loop > 1) {\n\t\t\t\t\tduration = Infinity;\n\t\t\t\t\tif (isNumber(this._loop)) {\n\t\t\t\t\t\tduration = (this._loop) * this._getLoopDuration();\n\t\t\t\t\t}\n\t\t\t\t\tconst nextEvent = this._state.getAfter(startTick);\n\t\t\t\t\tif (nextEvent !== null) {\n\t\t\t\t\t\tduration = Math.min(duration, nextEvent.time - startTick);\n\t\t\t\t\t}\n\t\t\t\t\tif (duration !== Infinity) {\n\t\t\t\t\t\tduration = new TicksClass(this.context, duration);\n\t\t\t\t\t}\n\t\t\t\t\tconst interval = new TicksClass(this.context, this._getLoopDuration());\n\t\t\t\t\tevent.id = this.context.transport.scheduleRepeat(\n\t\t\t\t\t\tthis._tick.bind(this), interval, new TicksClass(this.context, startTick), duration);\n\t\t\t\t} else {\n\t\t\t\t\tevent.id = this.context.transport.schedule(this._tick.bind(this), new TicksClass(this.context, startTick));\n\t\t\t\t}\n\t\t\t}\n\t\t});\n\t}\n\n\t/**\n\t * Returns the playback state of the note, either \"started\" or \"stopped\".\n\t */\n\tget state(): BasicPlaybackState {\n\t\treturn this._state.getValueAtTime(this.context.transport.ticks) as BasicPlaybackState;\n\t}\n\n\t/**\n\t * The start from the scheduled start time.\n\t */\n\tget startOffset(): Ticks {\n\t\treturn this._startOffset;\n\t}\n\tset startOffset(offset) {\n\t\tthis._startOffset = offset;\n\t}\n\n\t/**\n\t * The probability of the notes being triggered.\n\t */\n\tget probability(): NormalRange {\n\t\treturn this._probability;\n\t}\n\tset probability(prob) {\n\t\tthis._probability = prob;\n\t}\n\n\t/**\n\t * If set to true, will apply small random variation\n\t * to the callback time. If the value is given as a time, it will randomize\n\t * by that amount.\n\t * @example\n\t * const event = new Tone.ToneEvent();\n\t * event.humanize = true;\n\t */\n\tget humanize(): Time | boolean {\n\t\treturn this._humanize;\n\t}\n\n\tset humanize(variation) {\n\t\tthis._humanize = variation;\n\t}\n\n\t/**\n\t * Start the note at the given time.\n\t * @param  time  When the event should start.\n\t */\n\tstart(time?: TransportTime | TransportTimeClass): this {\n\t\tconst ticks = this.toTicks(time);\n\t\tif (this._state.getValueAtTime(ticks) === \"stopped\") {\n\t\t\tthis._state.add({\n\t\t\t\tid: -1,\n\t\t\t\tstate: \"started\",\n\t\t\t\ttime: ticks,\n\t\t\t});\n\t\t\tthis._rescheduleEvents(ticks);\n\t\t}\n\t\treturn this;\n\t}\n\n\t/**\n\t * Stop the Event at the given time.\n\t * @param  time  When the event should stop.\n\t */\n\tstop(time?: TransportTime | TransportTimeClass): this {\n\t\tthis.cancel(time);\n\t\tconst ticks = this.toTicks(time);\n\t\tif (this._state.getValueAtTime(ticks) === \"started\") {\n\t\t\tthis._state.setStateAtTime(\"stopped\", ticks, { id: -1 });\n\t\t\tconst previousEvent = this._state.getBefore(ticks);\n\t\t\tlet rescheduleTime = ticks;\n\t\t\tif (previousEvent !== null) {\n\t\t\t\trescheduleTime = previousEvent.time;\n\t\t\t}\n\t\t\tthis._rescheduleEvents(rescheduleTime);\n\t\t}\n\t\treturn this;\n\t}\n\n\t/**\n\t * Cancel all scheduled events greater than or equal to the given time\n\t * @param  time  The time after which events will be cancel.\n\t */\n\tcancel(time?: TransportTime | TransportTimeClass): this {\n\t\ttime = defaultArg(time, -Infinity);\n\t\tconst ticks = this.toTicks(time);\n\t\tthis._state.forEachFrom(ticks, event => {\n\t\t\tthis.context.transport.clear(event.id);\n\t\t});\n\t\tthis._state.cancel(ticks);\n\t\treturn this;\n\t}\n\n\t/**\n\t * The callback function invoker. Also\n\t * checks if the Event is done playing\n\t * @param  time  The time of the event in seconds\n\t */\n\tprotected _tick(time: Seconds): void {\n\t\tconst ticks = this.context.transport.getTicksAtTime(time);\n\t\tif (!this.mute && this._state.getValueAtTime(ticks) === \"started\") {\n\t\t\tif (this.probability < 1 && Math.random() > this.probability) {\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tif (this.humanize) {\n\t\t\t\tlet variation = 0.02;\n\t\t\t\tif (!isBoolean(this.humanize)) {\n\t\t\t\t\tvariation = this.toSeconds(this.humanize);\n\t\t\t\t}\n\t\t\t\ttime += (Math.random() * 2 - 1) * variation;\n\t\t\t}\n\t\t\tthis.callback(time, this.value);\n\t\t}\n\t}\n\n\t/**\n\t * Get the duration of the loop.\n\t */\n\tprotected _getLoopDuration(): Ticks {\n\t\treturn (this._loopEnd - this._loopStart) / this._playbackRate;\n\t}\n\n\t/**\n\t * If the note should loop or not\n\t * between ToneEvent.loopStart and\n\t * ToneEvent.loopEnd. If set to true,\n\t * the event will loop indefinitely,\n\t * if set to a number greater than 1\n\t * it will play a specific number of\n\t * times, if set to false, 0 or 1, the\n\t * part will only play once.\n\t */\n\tget loop(): boolean | number {\n\t\treturn this._loop;\n\t}\n\tset loop(loop) {\n\t\tthis._loop = loop;\n\t\tthis._rescheduleEvents();\n\t}\n\n\t/**\n\t * The playback rate of the event. Defaults to 1.\n\t * @example\n\t * const note = new Tone.ToneEvent();\n\t * note.loop = true;\n\t * // repeat the note twice as fast\n\t * note.playbackRate = 2;\n\t */\n\tget playbackRate(): Positive {\n\t\treturn this._playbackRate;\n\t}\n\tset playbackRate(rate) {\n\t\tthis._playbackRate = rate;\n\t\tthis._rescheduleEvents();\n\t}\n\n\t/**\n\t * The loopEnd point is the time the event will loop\n\t * if ToneEvent.loop is true.\n\t */\n\tget loopEnd(): Time {\n\t\treturn new TicksClass(this.context, this._loopEnd).toSeconds();\n\t}\n\tset loopEnd(loopEnd) {\n\t\tthis._loopEnd = this.toTicks(loopEnd);\n\t\tif (this._loop) {\n\t\t\tthis._rescheduleEvents();\n\t\t}\n\t}\n\n\t/**\n\t * The time when the loop should start.\n\t */\n\tget loopStart(): Time {\n\t\treturn new TicksClass(this.context, this._loopStart).toSeconds();\n\t}\n\tset loopStart(loopStart) {\n\t\tthis._loopStart = this.toTicks(loopStart);\n\t\tif (this._loop) {\n\t\t\tthis._rescheduleEvents();\n\t\t}\n\t}\n\n\t/**\n\t * The current progress of the loop interval.\n\t * Returns 0 if the event is not started yet or\n\t * it is not set to loop.\n\t */\n\tget progress(): NormalRange {\n\t\tif (this._loop) {\n\t\t\tconst ticks = this.context.transport.ticks;\n\t\t\tconst lastEvent = this._state.get(ticks);\n\t\t\tif (lastEvent !== null && lastEvent.state === \"started\") {\n\t\t\t\tconst loopDuration = this._getLoopDuration();\n\t\t\t\tconst progress = (ticks - lastEvent.time) % loopDuration;\n\t\t\t\treturn progress / loopDuration;\n\t\t\t} else {\n\t\t\t\treturn 0;\n\t\t\t}\n\t\t} else {\n\t\t\treturn 0;\n\t\t}\n\t}\n\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis.cancel();\n\t\tthis._state.dispose();\n\t\treturn this;\n\t}\n}\n","import { ToneEvent } from \"./ToneEvent\";\nimport { NormalRange, Positive, Seconds, Time, TransportTime } from \"../core/type/Units\";\nimport { ToneWithContext, ToneWithContextOptions } from \"../core/context/ToneWithContext\";\nimport { optionsFromArguments } from \"../core/util/Defaults\";\nimport { noOp } from \"../core/util/Interface\";\nimport { BasicPlaybackState } from \"../core/util/StateTimeline\";\n\nexport interface LoopOptions extends ToneWithContextOptions {\n\tcallback: (time: Seconds) => void;\n\tinterval: Time;\n\tplaybackRate: Positive;\n\titerations: number;\n\tprobability: NormalRange;\n\tmute: boolean;\n\thumanize: boolean | Time;\n}\n\n/**\n * Loop creates a looped callback at the \n * specified interval. The callback can be \n * started, stopped and scheduled along\n * the Transport's timeline. \n * @example\n * const loop = new Tone.Loop((time) => {\n * \t// triggered every eighth note. \n * \tconsole.log(time);\n * }, \"8n\").start(0);\n * Tone.Transport.start();\n * @category Event\n */\nexport class Loop<Options extends LoopOptions = LoopOptions> extends ToneWithContext<Options> {\n\n\treadonly name: string = \"Loop\";\n\n\t/**\n\t * The event which produces the callbacks\n\t */\n\tprivate _event: ToneEvent;\n\n\t/**\n\t * The callback to invoke with the next event in the pattern\n\t */\n\tcallback: (time: Seconds) => void\n\n\t/**\n\t * @param callback The callback to invoke at the time.\n\t * @param interval The time between successive callback calls. \n\t */\n\tconstructor(callback?: (time: Seconds) => void, interval?: Time);\n\tconstructor(options?: Partial<LoopOptions>);\n\tconstructor() {\n\t\tsuper(optionsFromArguments(Loop.getDefaults(), arguments, [\"callback\", \"interval\"]));\n\t\tconst options = optionsFromArguments(Loop.getDefaults(), arguments, [\"callback\", \"interval\"]);\n\n\t\tthis._event = new ToneEvent({\n\t\t\tcontext: this.context,\n\t\t\tcallback: this._tick.bind(this),\n\t\t\tloop: true,\n\t\t\tloopEnd: options.interval,\n\t\t\tplaybackRate: options.playbackRate,\n\t\t\tprobability: options.probability\n\t\t});\n\n\t\tthis.callback = options.callback;\n\t\t// set the iterations\n\t\tthis.iterations = options.iterations;\n\t}\n\n\tstatic getDefaults(): LoopOptions {\n\t\treturn Object.assign(ToneWithContext.getDefaults(), {\n\t\t\tinterval: \"4n\",\n\t\t\tcallback: noOp,\n\t\t\tplaybackRate: 1,\n\t\t\titerations: Infinity,\n\t\t\tprobability: 1,\n\t\t\tmute: false,\n\t\t\thumanize: false\n\t\t});\n\t}\n\n\t/**\n\t * Start the loop at the specified time along the Transport's timeline.\n\t * @param  time  When to start the Loop.\n\t */\n\tstart(time?: TransportTime): this {\n\t\tthis._event.start(time);\n\t\treturn this;\n\t}\n\n\t/**\n\t * Stop the loop at the given time.\n\t * @param  time  When to stop the Loop.\n\t */\n\tstop(time?: TransportTime): this {\n\t\tthis._event.stop(time);\n\t\treturn this;\n\t}\n\n\t/**\n\t * Cancel all scheduled events greater than or equal to the given time\n\t * @param  time  The time after which events will be cancel.\n\t */\n\tcancel(time?: TransportTime): this {\n\t\tthis._event.cancel(time);\n\t\treturn this;\n\t}\n\n\t/**\n\t * Internal function called when the notes should be called\n\t * @param time  The time the event occurs\n\t */\n\tprotected _tick(time: Seconds): void {\n\t\tthis.callback(time);\n\t}\n\n\t/**\n\t * The state of the Loop, either started or stopped.\n\t */\n\tget state(): BasicPlaybackState {\n\t\treturn this._event.state;\n\t}\n\n\t/**\n\t * The progress of the loop as a value between 0-1. 0, when the loop is stopped or done iterating. \n\t */\n\tget progress(): NormalRange {\n\t\treturn this._event.progress;\n\t}\n\n\t/**\n\t * The time between successive callbacks. \n\t * @example\n\t * const loop = new Tone.Loop();\n\t * loop.interval = \"8n\"; // loop every 8n\n\t */\n\tget interval(): Time {\n\t\treturn this._event.loopEnd;\n\t}\n\tset interval(interval) {\n\t\tthis._event.loopEnd = interval;\n\t}\n\n\t/**\n\t * The playback rate of the loop. The normal playback rate is 1 (no change). \n\t * A `playbackRate` of 2 would be twice as fast. \n\t */\n\tget playbackRate(): Positive {\n\t\treturn this._event.playbackRate;\n\t}\n\tset playbackRate(rate) {\n\t\tthis._event.playbackRate = rate;\n\t}\n\n\t/**\n\t * Random variation +/-0.01s to the scheduled time. \n\t * Or give it a time value which it will randomize by.\n\t */\n\tget humanize(): boolean | Time {\n\t\treturn this._event.humanize;\n\t}\n\tset humanize(variation) {\n\t\tthis._event.humanize = variation;\n\t}\n\n\t/**\n\t * The probably of the callback being invoked.\n\t */\n\tget probability(): NormalRange {\n\t\treturn this._event.probability;\n\t}\n\n\tset probability(prob) {\n\t\tthis._event.probability = prob;\n\t}\n\n\t/**\n\t * Muting the Loop means that no callbacks are invoked.\n\t */\n\tget mute(): boolean {\n\t\treturn this._event.mute;\n\t}\n\n\tset mute(mute) {\n\t\tthis._event.mute = mute;\n\t}\n\n\t/**\n\t * The number of iterations of the loop. The default value is `Infinity` (loop forever).\n\t */\n\tget iterations(): number {\n\t\tif (this._event.loop === true) {\n\t\t\treturn Infinity;\n\t\t} else {\n\t\t\treturn this._event.loop as number;\n\t\t}\n\t}\n\tset iterations(iters) {\n\t\tif (iters === Infinity) {\n\t\t\tthis._event.loop = true;\n\t\t} else {\n\t\t\tthis._event.loop = iters;\n\t\t}\n\t}\n\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis._event.dispose();\n\t\treturn this;\n\t}\n}\n","import { TicksClass } from \"../core/type/Ticks\";\nimport { TransportTimeClass } from \"../core/type/TransportTime\";\nimport { NormalRange, Positive, Seconds, Ticks, Time, TransportTime } from \"../core/type/Units\";\nimport { defaultArg, optionsFromArguments } from \"../core/util/Defaults\";\nimport { StateTimeline } from \"../core/util/StateTimeline\";\nimport { isArray, isDefined, isObject, isUndef } from \"../core/util/TypeCheck\";\nimport { ToneEvent, ToneEventCallback, ToneEventOptions } from \"./ToneEvent\";\n\ntype CallbackType<T> =\n\tT extends {\n\t\ttime: Time;\n\t\t[key: string]: any;\n\t} ? T :\n\t\tT extends ArrayLike<any> ? T[1] :\n\t\t\tT extends Time ? null : never;\n\ninterface PartOptions<T> extends Omit<ToneEventOptions<CallbackType<T>>, \"value\"> {\n\tevents: T[];\n}\n\n/**\n * Part is a collection ToneEvents which can be started/stopped and looped as a single unit.\n *\n * @example\n * const synth = new Tone.Synth().toDestination();\n * const part = new Tone.Part(((time, note) => {\n * \t// the notes given as the second element in the array\n * \t// will be passed in as the second argument\n * \tsynth.triggerAttackRelease(note, \"8n\", time);\n * }), [[0, \"C2\"], [\"0:2\", \"C3\"], [\"0:3:2\", \"G2\"]]).start(0);\n * Tone.Transport.start();\n * @example\n * const synth = new Tone.Synth().toDestination();\n * // use an array of objects as long as the object has a \"time\" attribute\n * const part = new Tone.Part(((time, value) => {\n * \t// the value is an object which contains both the note and the velocity\n * \tsynth.triggerAttackRelease(value.note, \"8n\", time, value.velocity);\n * }), [{ time: 0, note: \"C3\", velocity: 0.9 },\n * \t{ time: \"0:2\", note: \"C4\", velocity: 0.5 }\n * ]).start(0);\n * Tone.Transport.start();\n * @category Event\n */\nexport class Part<ValueType = any> extends ToneEvent<ValueType> {\n\n\treadonly name: string = \"Part\";\n\n\t/**\n\t * Tracks the scheduled events\n\t */\n\tprotected _state: StateTimeline<{\n\t\tid: number;\n\t\toffset: number;\n\t}> = new StateTimeline(\"stopped\");\n\n\t/**\n\t * The events that belong to this part\n\t */\n\tprivate _events: Set<ToneEvent> = new Set();\n\n\t/**\n\t * @param callback The callback to invoke on each event\n\t * @param events the array of events\n\t */\n\tconstructor(callback?: ToneEventCallback<CallbackType<ValueType>>, value?: ValueType[]);\n\tconstructor(options?: Partial<PartOptions<ValueType>>);\n\tconstructor() {\n\n\t\tsuper(optionsFromArguments(Part.getDefaults(), arguments, [\"callback\", \"events\"]));\n\t\tconst options = optionsFromArguments(Part.getDefaults(), arguments, [\"callback\", \"events\"]);\n\n\t\t// make sure things are assigned in the right order\n\t\tthis._state.increasing = true;\n\n\t\t// add the events\n\t\toptions.events.forEach(event => {\n\t\t\tif (isArray(event)) {\n\t\t\t\tthis.add(event[0], event[1]);\n\t\t\t} else {\n\t\t\t\tthis.add(event);\n\t\t\t}\n\t\t});\n\t}\n\n\tstatic getDefaults(): PartOptions<any> {\n\t\treturn Object.assign(ToneEvent.getDefaults(), {\n\t\t\tevents: [],\n\t\t});\n\t}\n\n\t/**\n\t * Start the part at the given time.\n\t * @param  time    When to start the part.\n\t * @param  offset  The offset from the start of the part to begin playing at.\n\t */\n\tstart(time?: TransportTime, offset?: Time): this {\n\t\tconst ticks = this.toTicks(time);\n\t\tif (this._state.getValueAtTime(ticks) !== \"started\") {\n\t\t\toffset = defaultArg(offset, this._loop ? this._loopStart : 0);\n\t\t\tif (this._loop) {\n\t\t\t\toffset = defaultArg(offset, this._loopStart);\n\t\t\t} else {\n\t\t\t\toffset = defaultArg(offset, 0);\n\t\t\t}\n\t\t\tconst computedOffset = this.toTicks(offset);\n\t\t\tthis._state.add({\n\t\t\t\tid: -1,\n\t\t\t\toffset: computedOffset,\n\t\t\t\tstate: \"started\",\n\t\t\t\ttime: ticks,\n\t\t\t});\n\t\t\tthis._forEach(event => {\n\t\t\t\tthis._startNote(event, ticks, computedOffset);\n\t\t\t});\n\t\t}\n\t\treturn this;\n\t}\n\n\t/**\n\t * Start the event in the given event at the correct time given\n\t * the ticks and offset and looping.\n\t * @param  event\n\t * @param  ticks\n\t * @param  offset\n\t */\n\tprivate _startNote(event: ToneEvent, ticks: Ticks, offset: Ticks): void {\n\t\tticks -= offset;\n\t\tif (this._loop) {\n\t\t\tif (event.startOffset >= this._loopStart && event.startOffset < this._loopEnd) {\n\t\t\t\tif (event.startOffset < offset) {\n\t\t\t\t\t// start it on the next loop\n\t\t\t\t\tticks += this._getLoopDuration();\n\t\t\t\t}\n\t\t\t\tevent.start(new TicksClass(this.context, ticks));\n\t\t\t} else if (event.startOffset < this._loopStart && event.startOffset >= offset) {\n\t\t\t\tevent.loop = false;\n\t\t\t\tevent.start(new TicksClass(this.context, ticks));\n\t\t\t}\n\t\t} else if (event.startOffset >= offset) {\n\t\t\tevent.start(new TicksClass(this.context, ticks));\n\t\t}\n\t}\n\n\tget startOffset(): Ticks {\n\t\treturn this._startOffset;\n\t}\n\tset startOffset(offset) {\n\t\tthis._startOffset = offset;\n\t\tthis._forEach(event => {\n\t\t\tevent.startOffset += this._startOffset;\n\t\t});\n\t}\n\n\t/**\n\t * Stop the part at the given time.\n\t * @param  time  When to stop the part.\n\t */\n\tstop(time?: TransportTime): this {\n\t\tconst ticks = this.toTicks(time);\n\t\tthis._state.cancel(ticks);\n\t\tthis._state.setStateAtTime(\"stopped\", ticks);\n\t\tthis._forEach(event => {\n\t\t\tevent.stop(time);\n\t\t});\n\t\treturn this;\n\t}\n\n\t/**\n\t * Get/Set an Event's value at the given time.\n\t * If a value is passed in and no event exists at\n\t * the given time, one will be created with that value.\n\t * If two events are at the same time, the first one will\n\t * be returned.\n\t * @example\n\t * const part = new Tone.Part();\n\t * part.at(\"1m\"); // returns the part at the first measure\n\t * part.at(\"2m\", \"C2\"); // set the value at \"2m\" to C2.\n\t * // if an event didn't exist at that time, it will be created.\n\t * @param time The time of the event to get or set.\n\t * @param value If a value is passed in, the value of the event at the given time will be set to it.\n\t */\n\tat(time: Time, value?: any): ToneEvent | null {\n\t\tconst timeInTicks = new TransportTimeClass(this.context, time).toTicks();\n\t\tconst tickTime = new TicksClass(this.context, 1).toSeconds();\n\n\t\tconst iterator = this._events.values();\n\t\tlet result = iterator.next();\n\t\twhile (!result.done) {\n\t\t\tconst event = result.value;\n\t\t\tif (Math.abs(timeInTicks - event.startOffset) < tickTime) {\n\t\t\t\tif (isDefined(value)) {\n\t\t\t\t\tevent.value = value;\n\t\t\t\t}\n\t\t\t\treturn event;\n\t\t\t}\n\t\t\tresult = iterator.next();\n\t\t}\n\t\t// if there was no event at that time, create one\n\t\tif (isDefined(value)) {\n\t\t\tthis.add(time, value);\n\t\t\t// return the new event\n\t\t\treturn this.at(time);\n\t\t} else {\n\t\t\treturn null;\n\t\t}\n\t}\n\n\t/**\n\t * Add a an event to the part.\n\t * @param time The time the note should start. If an object is passed in, it should\n\t * \t\thave a 'time' attribute and the rest of the object will be used as the 'value'.\n\t * @param  value\n\t * @example\n\t * const part = new Tone.Part();\n\t * part.add(\"1m\", \"C#+11\");\n\t */\n\tadd(obj: {\n\t\ttime: Time;\n\t\t[key: string]: any;\n\t}): this;\n\tadd(time: Time, value?: any): this;\n\tadd(time: Time | object, value?: any): this {\n\t\t// extract the parameters\n\t\tif (time instanceof Object && Reflect.has(time, \"time\")) {\n\t\t\tvalue = time;\n\t\t\ttime = value.time;\n\t\t}\n\t\tconst ticks = this.toTicks(time);\n\t\tlet event: ToneEvent;\n\t\tif (value instanceof ToneEvent) {\n\t\t\tevent = value;\n\t\t\tevent.callback = this._tick.bind(this);\n\t\t} else {\n\t\t\tevent = new ToneEvent({\n\t\t\t\tcallback: this._tick.bind(this),\n\t\t\t\tcontext: this.context,\n\t\t\t\tvalue,\n\t\t\t});\n\t\t}\n\t\t// the start offset\n\t\tevent.startOffset = ticks;\n\n\t\t// initialize the values\n\t\tevent.set({\n\t\t\thumanize: this.humanize,\n\t\t\tloop: this.loop,\n\t\t\tloopEnd: this.loopEnd,\n\t\t\tloopStart: this.loopStart,\n\t\t\tplaybackRate: this.playbackRate,\n\t\t\tprobability: this.probability,\n\t\t});\n\n\t\tthis._events.add(event);\n\n\t\t// start the note if it should be played right now\n\t\tthis._restartEvent(event);\n\t\treturn this;\n\t}\n\n\t/**\n\t * Restart the given event\n\t */\n\tprivate _restartEvent(event: ToneEvent): void {\n\t\tthis._state.forEach((stateEvent) => {\n\t\t\tif (stateEvent.state === \"started\") {\n\t\t\t\tthis._startNote(event, stateEvent.time, stateEvent.offset);\n\t\t\t} else {\n\t\t\t\t// stop the note\n\t\t\t\tevent.stop(new TicksClass(this.context, stateEvent.time));\n\t\t\t}\n\t\t});\n\t}\n\n\t/**\n\t * Remove an event from the part. If the event at that time is a Part,\n\t * it will remove the entire part.\n\t * @param time The time of the event\n\t * @param value Optionally select only a specific event value\n\t */\n\tremove(obj: {\n\t\ttime: Time;\n\t\t[key: string]: any;\n\t}): this;\n\tremove(time: Time, value?: any): this;\n\tremove(time: Time | object, value?: any): this {\n\t\t// extract the parameters\n\t\tif (isObject(time) && time.hasOwnProperty(\"time\")) {\n\t\t\tvalue = time;\n\t\t\ttime = value.time;\n\t\t}\n\t\ttime = this.toTicks(time);\n\t\tthis._events.forEach(event => {\n\t\t\tif (event.startOffset === time) {\n\t\t\t\tif (isUndef(value) || (isDefined(value) && event.value === value)) {\n\t\t\t\t\tthis._events.delete(event);\n\t\t\t\t\tevent.dispose();\n\t\t\t\t}\n\t\t\t}\n\t\t});\n\t\treturn this;\n\t}\n\n\t/**\n\t * Remove all of the notes from the group.\n\t */\n\tclear(): this {\n\t\tthis._forEach(event => event.dispose());\n\t\tthis._events.clear();\n\t\treturn this;\n\t}\n\n\t/**\n\t * Cancel scheduled state change events: i.e. \"start\" and \"stop\".\n\t * @param after The time after which to cancel the scheduled events.\n\t */\n\tcancel(after?: TransportTime | TransportTimeClass): this {\n\t\tthis._forEach(event => event.cancel(after));\n\t\tthis._state.cancel(this.toTicks(after));\n\t\treturn this;\n\t}\n\n\t/**\n\t * Iterate over all of the events\n\t */\n\tprivate _forEach(callback: (event: ToneEvent) => void): this {\n\t\tif (this._events) {\n\t\t\tthis._events.forEach(event => {\n\t\t\t\tif (event instanceof Part) {\n\t\t\t\t\tevent._forEach(callback);\n\t\t\t\t} else {\n\t\t\t\t\tcallback(event);\n\t\t\t\t}\n\t\t\t});\n\t\t}\n\t\treturn this;\n\t}\n\n\t/**\n\t * Set the attribute of all of the events\n\t * @param  attr  the attribute to set\n\t * @param  value      The value to set it to\n\t */\n\tprivate _setAll(attr: string, value: any): void {\n\t\tthis._forEach(event => {\n\t\t\tevent[attr] = value;\n\t\t});\n\t}\n\n\t/**\n\t * Internal tick method\n\t * @param  time  The time of the event in seconds\n\t */\n\tprotected _tick(time: Seconds, value?: any): void {\n\t\tif (!this.mute) {\n\t\t\tthis.callback(time, value);\n\t\t}\n\t}\n\n\t/**\n\t * Determine if the event should be currently looping\n\t * given the loop boundries of this Part.\n\t * @param  event  The event to test\n\t */\n\tprivate _testLoopBoundries(event: ToneEvent): void {\n\t\tif (this._loop && (event.startOffset < this._loopStart || event.startOffset >= this._loopEnd)) {\n\t\t\tevent.cancel(0);\n\t\t} else if (event.state === \"stopped\") {\n\t\t\t// reschedule it if it's stopped\n\t\t\tthis._restartEvent(event);\n\t\t}\n\t}\n\n\tget probability(): NormalRange {\n\t\treturn this._probability;\n\t}\n\tset probability(prob) {\n\t\tthis._probability = prob;\n\t\tthis._setAll(\"probability\", prob);\n\t}\n\n\tget humanize(): boolean | Time {\n\t\treturn this._humanize;\n\t}\n\tset humanize(variation) {\n\t\tthis._humanize = variation;\n\t\tthis._setAll(\"humanize\", variation);\n\t}\n\n\t/**\n\t * If the part should loop or not\n\t * between Part.loopStart and\n\t * Part.loopEnd. If set to true,\n\t * the part will loop indefinitely,\n\t * if set to a number greater than 1\n\t * it will play a specific number of\n\t * times, if set to false, 0 or 1, the\n\t * part will only play once.\n\t * @example\n\t * const part = new Tone.Part();\n\t * // loop the part 8 times\n\t * part.loop = 8;\n\t */\n\tget loop(): boolean | number {\n\t\treturn this._loop;\n\t}\n\tset loop(loop) {\n\t\tthis._loop = loop;\n\t\tthis._forEach(event => {\n\t\t\tevent.loopStart = this.loopStart;\n\t\t\tevent.loopEnd = this.loopEnd;\n\t\t\tevent.loop = loop;\n\t\t\tthis._testLoopBoundries(event);\n\t\t});\n\t}\n\n\t/**\n\t * The loopEnd point determines when it will\n\t * loop if Part.loop is true.\n\t */\n\tget loopEnd(): Time {\n\t\treturn new TicksClass(this.context, this._loopEnd).toSeconds();\n\t}\n\tset loopEnd(loopEnd) {\n\t\tthis._loopEnd = this.toTicks(loopEnd);\n\t\tif (this._loop) {\n\t\t\tthis._forEach(event => {\n\t\t\t\tevent.loopEnd = loopEnd;\n\t\t\t\tthis._testLoopBoundries(event);\n\t\t\t});\n\t\t}\n\t}\n\n\t/**\n\t * The loopStart point determines when it will\n\t * loop if Part.loop is true.\n\t */\n\tget loopStart(): Time {\n\t\treturn new TicksClass(this.context, this._loopStart).toSeconds();\n\t}\n\tset loopStart(loopStart) {\n\t\tthis._loopStart = this.toTicks(loopStart);\n\t\tif (this._loop) {\n\t\t\tthis._forEach(event => {\n\t\t\t\tevent.loopStart = this.loopStart;\n\t\t\t\tthis._testLoopBoundries(event);\n\t\t\t});\n\t\t}\n\t}\n\n\t/**\n\t * The playback rate of the part\n\t */\n\tget playbackRate(): Positive {\n\t\treturn this._playbackRate;\n\t}\n\tset playbackRate(rate) {\n\t\tthis._playbackRate = rate;\n\t\tthis._setAll(\"playbackRate\", rate);\n\t}\n\n\t/**\n\t * The number of scheduled notes in the part.\n\t */\n\tget length(): number {\n\t\treturn this._events.size;\n\t}\n\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis.clear();\n\t\treturn this;\n\t}\n}\n","import { assert } from \"../core/util/Debug\";\nimport { clamp } from \"../core/util/Math\";\n\n/**\n * The name of the patterns\n */\nexport type PatternName = \"up\" | \"down\" | \"upDown\" | \"downUp\" | \"alternateUp\" | \"alternateDown\" | \"random\" | \"randomOnce\" | \"randomWalk\";\n\n/**\n * Start at the first value and go up to the last\n */\nfunction* upPatternGen<T>(values: T[]): IterableIterator<T> {\n\tlet index = 0;\n\twhile (index < values.length) {\n\t\tindex = clampToArraySize(index, values);\n\t\tyield values[index];\n\t\tindex++;\n\t}\n}\n\n/**\n * Start at the last value and go down to 0\n */\nfunction* downPatternGen<T>(values: T[]): IterableIterator<T> {\n\tlet index = values.length - 1;\n\twhile (index >= 0) {\n\t\tindex = clampToArraySize(index, values);\n\t\tyield values[index];\n\t\tindex--;\n\t}\n}\n\n/**\n * Infinitely yield the generator\n */\nfunction* infiniteGen<T>(values: T[], gen: typeof upPatternGen): IterableIterator<T> {\n\twhile (true) {\n\t\tyield* gen(values);\n\t}\n}\n\n/**\n * Make sure that the index is in the given range\n */\nfunction clampToArraySize(index: number, values: any[]): number {\n\treturn clamp(index, 0, values.length - 1);\n}\n\n/**\n * Alternate between two generators\n */\nfunction* alternatingGenerator<T>(values: T[], directionUp: boolean): IterableIterator<T> {\n\tlet index = directionUp ? 0 : values.length - 1;\n\twhile (true) {\n\t\tindex = clampToArraySize(index, values);\n\t\tyield values[index];\n\t\tif (directionUp) {\n\t\t\tindex++;\n\t\t\tif (index >= values.length - 1) {\n\t\t\t\tdirectionUp = false;\n\t\t\t}\n\t\t} else {\n\t\t\tindex--;\n\t\t\tif (index <= 0) {\n\t\t\t\tdirectionUp = true;\n\t\t\t}\n\t\t}\n\t}\n}\n\n/**\n * Starting from the bottom move up 2, down 1\n */\nfunction* jumpUp<T>(values: T[]): IterableIterator<T> {\n\tlet index = 0;\n\tlet stepIndex = 0;\n\twhile (index < values.length) {\n\t\tindex = clampToArraySize(index, values);\n\t\tyield values[index];\n\t\tstepIndex++;\n\t\tindex += (stepIndex % 2 ? 2 : -1);\n\t}\n}\n\n/**\n * Starting from the top move down 2, up 1\n */\nfunction* jumpDown<T>(values: T[]): IterableIterator<T> {\n\tlet index = values.length - 1;\n\tlet stepIndex = 0;\n\twhile (index >= 0) {\n\t\tindex = clampToArraySize(index, values);\n\t\tyield values[index];\n\t\tstepIndex++;\n\t\tindex += (stepIndex % 2 ? -2 : 1);\n\t}\n}\n\n/**\n * Choose a random index each time\n */\nfunction* randomGen<T>(values: T[]): IterableIterator<T> {\n\twhile (true) {\n\t\tconst randomIndex = Math.floor(Math.random() * values.length);\n\t\tyield values[randomIndex];\n\t}\n}\n\n/**\n * Randomly go through all of the values once before choosing a new random order\n */\nfunction* randomOnce<T>(values: T[]): IterableIterator<T> {\n\t// create an array of indices\n\tconst copy: number[] = [];\n\tfor (let i = 0; i < values.length; i++) {\n\t\tcopy.push(i);\n\t}\n\twhile (copy.length > 0) {\n\t\t// random choose an index, and then remove it so it's not chosen again\n\t\tconst randVal = copy.splice(Math.floor(copy.length * Math.random()), 1);\n\t\tconst index = clampToArraySize(randVal[0], values);\n\t\tyield values[index];\n\t}\n}\n\n/**\n * Randomly choose to walk up or down 1 index in the values array\n */\nfunction* randomWalk<T>(values: T[]): IterableIterator<T> {\n\t// randomly choose a starting index in the values array\n\tlet index = Math.floor(Math.random() * values.length);\n\twhile (true) {\n\t\tif (index === 0) {\n\t\t\tindex++; // at bottom of array, so force upward step\n\t\t} else if (index === values.length - 1) {\n\t\t\tindex--; // at top of array, so force downward step\n\t\t} else if (Math.random() < 0.5) { // else choose random downward or upward step\n\t\t\tindex--;\n\t\t} else {\n\t\t\tindex++;\n\t\t}\n\t\tyield values[index];\n\t}\n}\n\n/**\n * PatternGenerator returns a generator which will iterate over the given array\n * of values and yield the items according to the passed in pattern\n * @param values An array of values to iterate over\n * @param pattern The name of the pattern use when iterating over\n * @param index Where to start in the offset of the values array\n */\nexport function* PatternGenerator<T>(values: T[], pattern: PatternName = \"up\", index = 0): Iterator<T> {\n\t// safeguards\n\tassert(values.length > 0, \"The array must have more than one value in it\");\n\tswitch (pattern) {\n\t\tcase \"up\" :\n\t\t\tyield* infiniteGen(values, upPatternGen);\n\t\tcase \"down\" :\n\t\t\tyield* infiniteGen(values, downPatternGen);\n\t\tcase \"upDown\" :\n\t\t\tyield* alternatingGenerator(values, true);\n\t\tcase \"downUp\" :\n\t\t\tyield* alternatingGenerator(values, false);\n\t\tcase \"alternateUp\":\n\t\t\tyield* infiniteGen(values, jumpUp);\n\t\tcase \"alternateDown\":\n\t\t\tyield* infiniteGen(values, jumpDown);\n\t\tcase \"random\":\n\t\t\tyield* randomGen(values);\n\t\tcase \"randomOnce\":\n\t\t\tyield* infiniteGen(values, randomOnce);\n\t\tcase \"randomWalk\":\n\t\t\tyield* randomWalk(values);\n\t}\n}\n","import { Loop, LoopOptions } from \"./Loop\";\nimport { PatternGenerator, PatternName } from \"./PatternGenerator\";\nimport { ToneEventCallback } from \"./ToneEvent\";\nimport { optionsFromArguments } from \"../core/util/Defaults\";\nimport { Seconds } from \"../core/type/Units\";\nimport { noOp } from \"../core/util/Interface\";\n\nexport interface PatternOptions<ValueType> extends LoopOptions {\n\tpattern: PatternName;\n\tvalues: ValueType[];\n\tcallback: (time: Seconds, value?: ValueType) => void;\n}\n\n/**\n * Pattern arpeggiates between the given notes\n * in a number of patterns. \n * @example\n * const pattern = new Tone.Pattern((time, note) => {\n * \t// the order of the notes passed in depends on the pattern\n * }, [\"C2\", \"D4\", \"E5\", \"A6\"], \"upDown\");\n * @category Event\n */\nexport class Pattern<ValueType> extends Loop<PatternOptions<ValueType>> {\n\n\treadonly name: string = \"Pattern\";\n\n\t/**\n\t * The pattern generator function\n\t */\n\tprivate _pattern: Iterator<ValueType>;\n\n\t/**\n\t * The current value\n\t */\n\tprivate _value?: ValueType;\n\n\t/**\n\t * Hold the pattern type\n\t */\n\tprivate _type: PatternName;\n\n\t/**\n\t * Hold the values\n\t */\n\tprivate _values: ValueType[];\n\n\t/**\n\t * The callback to be invoked at a regular interval\n\t */\n\tcallback: (time: Seconds, value?: ValueType) => void;\n\n\t/**\n\t * @param  callback The callback to invoke with the event.\n\t * @param  values The values to arpeggiate over.\n\t * @param  pattern  The name of the pattern\n\t */\n\tconstructor(\n\t\tcallback?: ToneEventCallback<ValueType>,\n\t\tvalues?: ValueType[],\n\t\tpattern?: PatternName,\n\t);\n\tconstructor(options?: Partial<PatternOptions<ValueType>>);\n\tconstructor() {\n\n\t\tsuper(optionsFromArguments(Pattern.getDefaults(), arguments, [\"callback\", \"values\", \"pattern\"]));\n\t\tconst options = optionsFromArguments(Pattern.getDefaults(), arguments, [\"callback\", \"values\", \"pattern\"]);\n\n\t\tthis.callback = options.callback;\n\t\tthis._values = options.values;\n\t\tthis._pattern = PatternGenerator(options.values, options.pattern);\n\t\tthis._type = options.pattern;\n\t}\n\n\tstatic getDefaults(): PatternOptions<any> {\n\t\treturn Object.assign(Loop.getDefaults(), {\n\t\t\tpattern: \"up\" as const,\n\t\t\tvalues: [],\n\t\t\tcallback: noOp,\n\t\t});\n\t}\n\n\t/**\n\t * Internal function called when the notes should be called\n\t */\n\tprotected _tick(time: Seconds): void {\n\t\tconst value = this._pattern.next() as IteratorResult<ValueType>;\n\t\tthis._value = value.value;\n\t\tthis.callback(time, this._value);\n\t}\n\n\t/**\n\t * The array of events.\n\t */\n\tget values(): ValueType[] {\n\t\treturn this._values;\n\t}\n\tset values(val) {\n\t\tthis._values = val;\n\t\t// reset the pattern\n\t\tthis.pattern = this._type;\n\t}\n\n\t/**\n\t * The current value of the pattern.\n\t */\n\tget value(): ValueType | undefined {\n\t\treturn this._value;\n\t}\n\n\t/**\n\t * The pattern type. See Tone.CtrlPattern for the full list of patterns.\n\t */\n\tget pattern(): PatternName {\n\t\treturn this._type;\n\t}\n\tset pattern(pattern) {\n\t\tthis._type = pattern;\n\t\tthis._pattern = PatternGenerator(this._values, this._type);\n\t}\n}\n\n","import { TicksClass } from \"../core/type/Ticks\";\nimport { NormalRange, Positive, Seconds, Ticks, Time, TransportTime } from \"../core/type/Units\";\nimport { omitFromObject, optionsFromArguments } from \"../core/util/Defaults\";\nimport { isArray, isString } from \"../core/util/TypeCheck\";\nimport { Part } from \"./Part\";\nimport { ToneEvent, ToneEventCallback, ToneEventOptions } from \"./ToneEvent\";\n\ntype SequenceEventDescription<T> = Array<T | Array<T | Array<T | Array<T | Array<T | T[]>>>>>;\n\ninterface SequenceOptions<T> extends Omit<ToneEventOptions<T>, \"value\"> {\n\tloopStart: number;\n\tloopEnd: number;\n\tsubdivision: Time;\n\tevents: SequenceEventDescription<T>;\n}\n\n/**\n * A sequence is an alternate notation of a part. Instead\n * of passing in an array of [time, event] pairs, pass\n * in an array of events which will be spaced at the\n * given subdivision. Sub-arrays will subdivide that beat\n * by the number of items are in the array.\n * Sequence notation inspiration from [Tidal](http://yaxu.org/tidal/)\n * @example\n * const synth = new Tone.Synth().toDestination();\n * const seq = new Tone.Sequence((time, note) => {\n * \tsynth.triggerAttackRelease(note, 0.1, time);\n * \t// subdivisions are given as subarrays\n * }, [\"C4\", [\"E4\", \"D4\", \"E4\"], \"G4\", [\"A4\", \"G4\"]]).start(0);\n * Tone.Transport.start();\n * @category Event\n */\nexport class Sequence<ValueType = any> extends ToneEvent<ValueType> {\n\n\treadonly name: string = \"Sequence\";\n\n\t/**\n\t * The subdivison of each note\n\t */\n\tprivate _subdivision: Ticks;\n\n\t/**\n\t * The object responsible for scheduling all of the events\n\t */\n\tprivate _part: Part = new Part({\n\t\tcallback: this._seqCallback.bind(this),\n\t\tcontext: this.context,\n\t});\n\n\t/**\n\t * private reference to all of the sequence proxies\n\t */\n\tprivate _events: SequenceEventDescription<ValueType> = [];\n\n\t/**\n\t * The proxied array\n\t */\n\tprivate _eventsArray: SequenceEventDescription<ValueType> = [];\n\n\t/**\n\t * @param  callback  The callback to invoke with every note\n\t * @param  sequence  The sequence\n\t * @param  subdivision  The subdivision between which events are placed.\n\t */\n\tconstructor(\n\t\tcallback?: ToneEventCallback<ValueType>,\n\t\tevents?: SequenceEventDescription<ValueType>,\n\t\tsubdivision?: Time,\n\t);\n\tconstructor(options?: Partial<SequenceOptions<ValueType>>);\n\tconstructor() {\n\n\t\tsuper(optionsFromArguments(Sequence.getDefaults(), arguments, [\"callback\", \"events\", \"subdivision\"]));\n\t\tconst options = optionsFromArguments(Sequence.getDefaults(), arguments, [\"callback\", \"events\", \"subdivision\"]);\n\n\t\tthis._subdivision = this.toTicks(options.subdivision);\n\n\t\tthis.events = options.events;\n\n\t\t// set all of the values\n\t\tthis.loop = options.loop;\n\t\tthis.loopStart = options.loopStart;\n\t\tthis.loopEnd = options.loopEnd;\n\t\tthis.playbackRate = options.playbackRate;\n\t\tthis.probability = options.probability;\n\t\tthis.humanize = options.humanize;\n\t\tthis.mute = options.mute;\n\t\tthis.playbackRate = options.playbackRate;\n\t}\n\n\tstatic getDefaults(): SequenceOptions<any> {\n\t\treturn Object.assign(omitFromObject(ToneEvent.getDefaults(), [\"value\"]), {\n\t\t\tevents: [],\n\t\t\tloop: true,\n\t\t\tloopEnd: 0,\n\t\t\tloopStart: 0,\n\t\t\tsubdivision: \"8n\",\n\t\t});\n\t}\n\n\t/**\n\t * The internal callback for when an event is invoked\n\t */\n\tprivate _seqCallback(time: Seconds, value: any): void {\n\t\tif (value !== null && !this.mute) {\n\t\t\tthis.callback(time, value);\n\t\t}\n\t}\n\n\t/**\n\t * The sequence\n\t */\n\tget events(): any[] {\n\t\treturn this._events;\n\t}\n\tset events(s) {\n\t\tthis.clear();\n\t\tthis._eventsArray = s;\n\t\tthis._events = this._createSequence(this._eventsArray);\n\t\tthis._eventsUpdated();\n\t}\n\n\t/**\n\t * Start the part at the given time.\n\t * @param  time    When to start the part.\n\t * @param  offset  The offset index to start at\n\t */\n\tstart(time?: TransportTime, offset?: number): this {\n\t\tthis._part.start(time, offset ? this._indexTime(offset) : offset);\n\t\treturn this;\n\t}\n\n\t/**\n\t * Stop the part at the given time.\n\t * @param  time  When to stop the part.\n\t */\n\tstop(time?: TransportTime): this {\n\t\tthis._part.stop(time);\n\t\treturn this;\n\t}\n\n\t/**\n\t * The subdivision of the sequence. This can only be\n\t * set in the constructor. The subdivision is the\n\t * interval between successive steps.\n\t */\n\tget subdivision(): Seconds {\n\t\treturn new TicksClass(this.context, this._subdivision).toSeconds();\n\t}\n\n\t/**\n\t * Create a sequence proxy which can be monitored to create subsequences\n\t */\n\tprivate _createSequence(array: any[]): any[] {\n\t\treturn new Proxy(array, {\n\t\t\tget: (target: any[], property: PropertyKey): any => {\n\t\t\t\t// property is index in this case\n\t\t\t\treturn target[property];\n\t\t\t},\n\t\t\tset: (target: any[], property: PropertyKey, value: any): boolean => {\n\t\t\t\tif (isString(property) && isFinite(parseInt(property, 10))) {\n\t\t\t\t\tif (isArray(value)) {\n\t\t\t\t\t\ttarget[property] = this._createSequence(value);\n\t\t\t\t\t} else {\n\t\t\t\t\t\ttarget[property] = value;\n\t\t\t\t\t}\n\t\t\t\t} else {\n\t\t\t\t\ttarget[property] = value;\n\t\t\t\t}\n\t\t\t\tthis._eventsUpdated();\n\t\t\t\t// return true to accept the changes\n\t\t\t\treturn true;\n\t\t\t},\n\t\t});\n\t}\n\n\t/**\n\t * When the sequence has changed, all of the events need to be recreated\n\t */\n\tprivate _eventsUpdated(): void {\n\t\tthis._part.clear();\n\t\tthis._rescheduleSequence(this._eventsArray, this._subdivision, this.startOffset);\n\t\t// update the loopEnd\n\t\tthis.loopEnd = this.loopEnd;\n\t}\n\n\t/**\n\t * reschedule all of the events that need to be rescheduled\n\t */\n\tprivate _rescheduleSequence(sequence: any[], subdivision: Ticks, startOffset: Ticks): void {\n\t\tsequence.forEach((value, index) => {\n\t\t\tconst eventOffset = index * (subdivision) + startOffset;\n\t\t\tif (isArray(value)) {\n\t\t\t\tthis._rescheduleSequence(value, subdivision / value.length, eventOffset);\n\t\t\t} else {\n\t\t\t\tconst startTime = new TicksClass(this.context, eventOffset, \"i\").toSeconds();\n\t\t\t\tthis._part.add(startTime, value);\n\t\t\t}\n\t\t});\n\t}\n\n\t/**\n\t * Get the time of the index given the Sequence's subdivision\n\t * @param  index\n\t * @return The time of that index\n\t */\n\tprivate _indexTime(index: number): Seconds {\n\t\treturn new TicksClass(this.context, index * (this._subdivision) + this.startOffset).toSeconds();\n\t}\n\n\t/**\n\t * Clear all of the events\n\t */\n\tclear(): this {\n\t\tthis._part.clear();\n\t\treturn this;\n\t}\n\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis._part.dispose();\n\t\treturn this;\n\t}\n\n\t//-------------------------------------\n\t// PROXY CALLS\n\t//-------------------------------------\n\n\tget loop(): boolean | number {\n\t\treturn this._part.loop;\n\t}\n\tset loop(l) {\n\t\tthis._part.loop = l;\n\t}\n\n\t/**\n\t * The index at which the sequence should start looping\n\t */\n\tget loopStart(): number {\n\t\treturn this._loopStart;\n\t}\n\tset loopStart(index) {\n\t\tthis._loopStart = index;\n\t\tthis._part.loopStart = this._indexTime(index);\n\t}\n\n\t/**\n\t * The index at which the sequence should end looping\n\t */\n\tget loopEnd(): number {\n\t\treturn this._loopEnd;\n\t}\n\tset loopEnd(index) {\n\t\tthis._loopEnd = index;\n\t\tif (index === 0) {\n\t\t\tthis._part.loopEnd = this._indexTime(this._eventsArray.length);\n\t\t} else {\n\t\t\tthis._part.loopEnd = this._indexTime(index);\n\t\t}\n\t}\n\n\tget startOffset(): Ticks {\n\t\treturn this._part.startOffset;\n\t}\n\tset startOffset(start) {\n\t\tthis._part.startOffset = start;\n\t}\n\n\tget playbackRate(): Positive {\n\t\treturn this._part.playbackRate;\n\t}\n\tset playbackRate(rate) {\n\t\tthis._part.playbackRate = rate;\n\t}\n\n\tget probability(): NormalRange {\n\t\treturn this._part.probability;\n\t}\n\tset probability(prob) {\n\t\tthis._part.probability = prob;\n\t}\n\n\tget progress(): NormalRange {\n\t\treturn this._part.progress;\n\t}\n\n\tget humanize(): boolean | Time {\n\t\treturn this._part.humanize;\n\t}\n\tset humanize(variation) {\n\t\tthis._part.humanize = variation;\n\t}\n\n\t/**\n\t * The number of scheduled events\n\t */\n\tget length(): number {\n\t\treturn this._part.length;\n\t}\n}\n","import { Gain } from \"../../core/context/Gain\";\nimport { connect, ToneAudioNode, ToneAudioNodeOptions } from \"../../core/context/ToneAudioNode\";\nimport { NormalRange } from \"../../core/type/Units\";\nimport { optionsFromArguments } from \"../../core/util/Defaults\";\nimport { readOnly } from \"../../core/util/Interface\";\nimport { GainToAudio } from \"../../signal/GainToAudio\";\nimport { Signal } from \"../../signal/Signal\";\n\ninterface CrossFadeOptions extends ToneAudioNodeOptions {\n\tfade: NormalRange;\n}\n\n/**\n * Tone.Crossfade provides equal power fading between two inputs.\n * More on crossfading technique [here](https://en.wikipedia.org/wiki/Fade_(audio_engineering)#Crossfading).\n * ```\n *                                             +---------+\n *                                            +> input a +>--+\n * +-----------+   +---------------------+     |         |   |\n * | 1s signal +>--> stereoPannerNode  L +>----> gain    |   |\n * +-----------+   |                     |     +---------+   |\n *               +-> pan               R +>-+                |   +--------+\n *               | +---------------------+  |                +---> output +>\n *  +------+     |                          |  +---------+   |   +--------+\n *  | fade +>----+                          | +> input b +>--+\n *  +------+                                |  |         |\n *                                          +--> gain    |\n *                                             +---------+\n * ```\n * @example\n * const crossFade = new Tone.CrossFade().toDestination();\n * // connect two inputs Tone.to a/b\n * const inputA = new Tone.Oscillator(440, \"square\").connect(crossFade.a).start();\n * const inputB = new Tone.Oscillator(440, \"sine\").connect(crossFade.b).start();\n * // use the fade to control the mix between the two\n * crossFade.fade.value = 0.5;\n * @category Component\n */\nexport class CrossFade extends ToneAudioNode<CrossFadeOptions> {\n\n\treadonly name: string = \"CrossFade\";\n\n\t/**\n\t * The crossfading is done by a StereoPannerNode\n\t */\n\tprivate _panner: StereoPannerNode = this.context.createStereoPanner();\n\n\t/**\n\t * Split the output of the panner node into two values used to control the gains.\n\t */\n\tprivate _split: ChannelSplitterNode = this.context.createChannelSplitter(2);\n\n\t/**\n\t * Convert the fade value into an audio range value so it can be connected\n\t * to the panner.pan AudioParam\n\t */\n\tprivate _g2a: GainToAudio = new GainToAudio({ context: this.context });\n\n\t/**\n\t * The input which is at full level when fade = 0\n\t */\n\treadonly a: Gain = new Gain({\n\t\tcontext: this.context,\n\t\tgain: 0,\n\t});\n\n\t/**\n\t * The input which is at full level when fade = 1\n\t */\n\treadonly b: Gain = new Gain({\n\t\tcontext: this.context,\n\t\tgain: 0,\n\t});\n\n\t/**\n\t * The output is a mix between `a` and `b` at the ratio of `fade`\n\t */\n\treadonly output: Gain = new Gain({ context: this.context });\n\n\t/**\n\t * CrossFade has no input, you must choose either `a` or `b`\n\t */\n\treadonly input: undefined;\n\n\t/**\n\t * The mix between the two inputs. A fade value of 0\n\t * will output 100% crossFade.a and\n\t * a value of 1 will output 100% crossFade.b.\n\t */\n\treadonly fade: Signal<\"normalRange\">;\n\n\tprotected _internalChannels = [this.a, this.b];\n\n\t/**\n\t * @param fade The initial fade value [0, 1].\n\t */\n\tconstructor(fade?: NormalRange);\n\tconstructor(options?: Partial<CrossFadeOptions>);\n\tconstructor() {\n\t\tsuper(Object.assign(optionsFromArguments(CrossFade.getDefaults(), arguments, [\"fade\"])));\n\t\tconst options = optionsFromArguments(CrossFade.getDefaults(), arguments, [\"fade\"]);\n\n\t\tthis.fade = new Signal({\n\t\t\tcontext: this.context,\n\t\t\tunits: \"normalRange\",\n\t\t\tvalue: options.fade,\n\t\t});\n\t\treadOnly(this, \"fade\");\n\n\t\tthis.context.getConstant(1).connect(this._panner);\n\t\tthis._panner.connect(this._split);\n\t\t// this is necessary for standardized-audio-context\n\t\t// doesn't make any difference for the native AudioContext\n\t\t// https://github.com/chrisguttandin/standardized-audio-context/issues/647\n\t\tthis._panner.channelCount = 1;\n\t\tthis._panner.channelCountMode = \"explicit\";\n\t\tconnect(this._split, this.a.gain, 0);\n\t\tconnect(this._split, this.b.gain, 1);\n\n\t\tthis.fade.chain(this._g2a, this._panner.pan);\n\n\t\tthis.a.connect(this.output);\n\t\tthis.b.connect(this.output);\n\t}\n\n\tstatic getDefaults(): CrossFadeOptions {\n\t\treturn Object.assign(ToneAudioNode.getDefaults(), {\n\t\t\tfade: 0.5,\n\t\t});\n\t}\n\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis.a.dispose();\n\t\tthis.b.dispose();\n\t\tthis.output.dispose();\n\t\tthis.fade.dispose();\n\t\tthis._g2a.dispose();\n\t\tthis._panner.disconnect();\n\t\tthis._split.disconnect();\n\t\treturn this;\n\t}\n}\n","import { CrossFade } from \"../component/channel/CrossFade\";\nimport { Gain } from \"../core/context/Gain\";\nimport { ToneAudioNode, ToneAudioNodeOptions } from \"../core/context/ToneAudioNode\";\nimport { NormalRange } from \"../core/type/Units\";\nimport { readOnly } from \"../core/util/Interface\";\nimport { Signal } from \"../signal/Signal\";\n\nexport interface EffectOptions extends ToneAudioNodeOptions {\n\twet: NormalRange;\n}\n/**\n * Effect is the base class for effects. Connect the effect between\n * the effectSend and effectReturn GainNodes, then control the amount of\n * effect which goes to the output using the wet control.\n */\nexport abstract class Effect<Options extends EffectOptions>\n\textends ToneAudioNode<Options> {\n\n\treadonly name: string = \"Effect\";\n\n\t/**\n\t * the drywet knob to control the amount of effect\n\t */\n\tprivate _dryWet: CrossFade = new CrossFade({ context: this.context });\n\n\t/**\n\t * The wet control is how much of the effected\n\t * will pass through to the output. 1 = 100% effected\n\t * signal, 0 = 100% dry signal.\n\t */\n\twet: Signal<\"normalRange\"> = this._dryWet.fade;\n\n\t/**\n\t * connect the effectSend to the input of hte effect\n\t */\n\tprotected effectSend: Gain = new Gain({ context: this.context });\n\n\t/**\n\t * connect the output of the effect to the effectReturn\n\t */\n\tprotected effectReturn: Gain = new Gain({ context: this.context });\n\n\t/**\n\t * The effect input node\n\t */\n\tinput: Gain = new Gain({ context: this.context });\n\n\t/**\n\t * The effect output\n\t */\n\toutput = this._dryWet;\n\n\tconstructor(options: EffectOptions) {\n\t\tsuper(options);\n\n\t\t// connections\n\t\tthis.input.fan(this._dryWet.a, this.effectSend);\n\t\tthis.effectReturn.connect(this._dryWet.b);\n\t\tthis.wet.setValueAtTime(options.wet, 0);\n\t\tthis._internalChannels = [this.effectReturn, this.effectSend];\n\t\treadOnly(this, \"wet\");\n\t}\n\n\tstatic getDefaults(): EffectOptions {\n\t\treturn Object.assign(ToneAudioNode.getDefaults(), {\n\t\t\twet: 1,\n\t\t});\n\t}\n\n\t/**\n\t * chains the effect in between the effectSend and effectReturn\n\t */\n\tprotected connectEffect(effect: ToneAudioNode | AudioNode): this {\n\t\t// add it to the internal channels\n\t\tthis._internalChannels.push(effect);\n\t\tthis.effectSend.chain(effect, this.effectReturn);\n\t\treturn this;\n\t}\n\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis._dryWet.dispose();\n\t\tthis.effectSend.dispose();\n\t\tthis.effectReturn.dispose();\n\t\tthis.wet.dispose();\n\t\treturn this;\n\t}\n}\n","import { Effect, EffectOptions } from \"../effect/Effect\";\nimport { Frequency, NormalRange, Time } from \"../core/type/Units\";\nimport { LFO } from \"../source/oscillator/LFO\";\nimport { ToneOscillatorType } from \"../source/oscillator/OscillatorInterface\";\nimport { Signal } from \"../signal/Signal\";\nimport { readOnly } from \"../core/util/Interface\";\nimport { Param } from \"../core/context/Param\";\n\nexport interface LFOEffectOptions extends EffectOptions {\n\tfrequency: Frequency;\n\ttype: ToneOscillatorType;\n\tdepth: NormalRange;\n}\n\n/**\n * Base class for LFO-based effects.\n */\nexport abstract class LFOEffect<Options extends LFOEffectOptions> extends Effect<Options> {\n\n\treadonly name: string = \"LFOEffect\";\n\n\t/**\n\t * the lfo which drives the filter cutoff\n\t */\n\tprotected _lfo: LFO;\n\n\t/**\n\t * The range of the filter modulating between the min and max frequency. \n\t * 0 = no modulation. 1 = full modulation.\n\t */\n\treadonly depth: Param<\"normalRange\">;\n\n\t/**\n\t * How fast the filter modulates between min and max. \n\t */\n\treadonly frequency: Signal<\"frequency\">;\n\n\tconstructor(options: LFOEffectOptions) {\n\n\t\tsuper(options);\n\n\t\tthis._lfo = new LFO({\n\t\t\tcontext: this.context,\n\t\t\tfrequency: options.frequency,\n\t\t\tamplitude: options.depth,\n\t\t});\n\t\tthis.depth = this._lfo.amplitude;\n\t\tthis.frequency = this._lfo.frequency;\n\n\t\tthis.type = options.type;\n\t\treadOnly(this, [\"frequency\", \"depth\"]);\n\t}\n\n\tstatic getDefaults(): LFOEffectOptions {\n\t\treturn Object.assign(Effect.getDefaults(), {\n\t\t\tfrequency: 1,\n\t\t\ttype: \"sine\" as ToneOscillatorType,\n\t\t\tdepth: 1,\n\t\t});\n\t}\n\n\t/**\n\t * Start the effect.\n\t */\n\tstart(time?: Time): this {\n\t\tthis._lfo.start(time);\n\t\treturn this;\n\t}\n\n\t/**\n\t * Stop the lfo\n\t */\n\tstop(time?: Time): this {\n\t\tthis._lfo.stop(time);\n\t\treturn this;\n\t}\n\n\t/**\n\t * Sync the filter to the transport. See [[LFO.sync]]\n\t */\n\tsync(): this {\n\t\tthis._lfo.sync();\n\t\treturn this;\n\t}\n\n\t/**\n\t * Unsync the filter from the transport.\n\t */\n\tunsync(): this {\n\t\tthis._lfo.unsync();\n\t\treturn this;\n\t}\n\n\t/**\n\t * The type of the LFO's oscillator: See [[Oscillator.type]]\n\t * @example\n\t * const autoFilter = new Tone.AutoFilter().start().toDestination();\n\t * const noise = new Tone.Noise().start().connect(autoFilter);\n\t * autoFilter.type = \"square\";\n\t */\n\tget type() {\n\t\treturn this._lfo.type;\n\t}\n\tset type(type) {\n\t\tthis._lfo.type = type;\n\t}\n\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis._lfo.dispose();\n\t\tthis.frequency.dispose();\n\t\tthis.depth.dispose();\n\t\treturn this;\n\t}\n}\n","import { Frequency, Positive } from \"../core/type/Units\";\nimport { Filter, FilterOptions } from \"../component/filter/Filter\";\nimport { SourceOptions } from \"../source/Source\";\nimport { optionsFromArguments } from \"../core/util/Defaults\";\nimport { LFOEffect, LFOEffectOptions } from \"./LFOEffect\";\n\nexport interface AutoFilterOptions extends LFOEffectOptions {\n\tbaseFrequency: Frequency;\n\toctaves: Positive;\n\tfilter: Omit<FilterOptions, keyof SourceOptions | \"frequency\" | \"detune\" | \"gain\">;\n}\n\n/**\n * AutoFilter is a Tone.Filter with a Tone.LFO connected to the filter cutoff frequency.\n * Setting the LFO rate and depth allows for control over the filter modulation rate \n * and depth.\n *\n * @example\n * // create an autofilter and start it's LFO\n * const autoFilter = new Tone.AutoFilter(\"4n\").toDestination().start();\n * // route an oscillator through the filter and start it\n * const oscillator = new Tone.Oscillator().connect(autoFilter).start();\n * @category Effect\n */\nexport class AutoFilter extends LFOEffect<AutoFilterOptions> {\n\n\treadonly name: string = \"AutoFilter\";\n\n\t/**\n\t * The filter node\n\t */\n\treadonly filter: Filter;\n\n\t/**\n\t * The octaves placeholder\n\t */\n\tprivate _octaves!: Positive;\n\n\t/**\n\t * @param frequency The rate of the LFO.\n\t * @param baseFrequency The lower value of the LFOs oscillation\n\t * @param octaves The number of octaves above the baseFrequency\n\t */\n\tconstructor(frequency?: Frequency, baseFrequency?: Frequency, octaves?: Positive);\n\tconstructor(options?: Partial<AutoFilterOptions>);\n\tconstructor() {\n\n\t\tsuper(optionsFromArguments(AutoFilter.getDefaults(), arguments, [\"frequency\", \"baseFrequency\", \"octaves\"]));\n\t\tconst options = optionsFromArguments(AutoFilter.getDefaults(), arguments, [\"frequency\", \"baseFrequency\", \"octaves\"]);\n\n\t\tthis.filter = new Filter(Object.assign(options.filter, {\n\t\t\tcontext: this.context,\n\t\t}));\n\n\t\t// connections\n\t\tthis.connectEffect(this.filter);\n\t\tthis._lfo.connect(this.filter.frequency);\n\t\tthis.octaves = options.octaves;\n\t\tthis.baseFrequency = options.baseFrequency;\n\t}\n\n\tstatic getDefaults(): AutoFilterOptions {\n\t\treturn Object.assign(LFOEffect.getDefaults(), {\n\t\t\tbaseFrequency: 200,\n\t\t\toctaves: 2.6,\n\t\t\tfilter: {\n\t\t\t\ttype: \"lowpass\" as const,\n\t\t\t\trolloff: -12 as -12,\n\t\t\t\tQ: 1,\n\t\t\t}\n\t\t});\n\t}\n\n\t/**\n\t * The minimum value of the filter's cutoff frequency.\n\t */\n\tget baseFrequency(): Frequency {\n\t\treturn this._lfo.min;\n\t}\n\tset baseFrequency(freq) {\n\t\tthis._lfo.min = this.toFrequency(freq);\n\t\t// and set the max\n\t\tthis.octaves = this._octaves;\n\t}\n\n\t/**\n\t * The maximum value of the filter's cutoff frequency. \n\t */\n\tget octaves(): Positive {\n\t\treturn this._octaves;\n\t}\n\tset octaves(oct) {\n\t\tthis._octaves = oct;\n\t\tthis._lfo.max = this._lfo.min * Math.pow(2, oct);\n\t}\n\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis.filter.dispose();\n\t\treturn this;\n\t}\n}\n","import { Param } from \"../../core/context/Param\";\nimport { ToneAudioNode, ToneAudioNodeOptions } from \"../../core/context/ToneAudioNode\";\nimport { AudioRange } from \"../../core/type/Units\";\nimport { optionsFromArguments } from \"../../core/util/Defaults\";\nimport { readOnly } from \"../../core/util/Interface\";\n\ninterface TonePannerOptions extends ToneAudioNodeOptions {\n\tpan: AudioRange;\n\tchannelCount: number;\n}\n\n/**\n * Panner is an equal power Left/Right Panner. It is a wrapper around the StereoPannerNode.\n * @example\n * return Tone.Offline(() => {\n * // move the input signal from right to left\n * \tconst panner = new Tone.Panner(1).toDestination();\n * \tpanner.pan.rampTo(-1, 0.5);\n * \tconst osc = new Tone.Oscillator(100).connect(panner).start();\n * }, 0.5, 2);\n * @category Component\n */\nexport class Panner extends ToneAudioNode<TonePannerOptions> {\n\n\treadonly name: string = \"Panner\";\n\n\t/**\n\t * the panner node\n\t */\n\tprivate _panner: StereoPannerNode = this.context.createStereoPanner();\n\treadonly input: StereoPannerNode = this._panner;\n\treadonly output: StereoPannerNode = this._panner;\n\n\t/**\n\t * The pan control. -1 = hard left, 1 = hard right.\n\t * @min -1\n\t * @max 1\n\t * @example\n\t * return Tone.Offline(() => {\n\t * \t// pan hard right\n\t * \tconst panner = new Tone.Panner(1).toDestination();\n\t * \t// pan hard left\n\t * \tpanner.pan.setValueAtTime(-1, 0.25);\n\t * \tconst osc = new Tone.Oscillator(50, \"triangle\").connect(panner).start();\n\t * }, 0.5, 2);\n\t */\n\treadonly pan: Param<\"audioRange\">;\n\n\tconstructor(options?: Partial<TonePannerOptions>);\n\t/**\n\t * @param pan The initial panner value (Defaults to 0 = \"center\").\n\t */\n\tconstructor(pan?: AudioRange);\n\tconstructor() {\n\t\tsuper(Object.assign(optionsFromArguments(Panner.getDefaults(), arguments, [\"pan\"])));\n\t\tconst options = optionsFromArguments(Panner.getDefaults(), arguments, [\"pan\"]);\n\n\t\tthis.pan = new Param({\n\t\t\tcontext: this.context,\n\t\t\tparam: this._panner.pan,\n\t\t\tvalue: options.pan,\n\t\t\tminValue: -1,\n\t\t\tmaxValue: 1,\n\t\t});\n\n\t\t// this is necessary for standardized-audio-context\n\t\t// doesn't make any difference for the native AudioContext\n\t\t// https://github.com/chrisguttandin/standardized-audio-context/issues/647\n\t\tthis._panner.channelCount = options.channelCount;\n\t\tthis._panner.channelCountMode = \"explicit\";\n\n\t\t// initial value\n\t\treadOnly(this, \"pan\");\n\t}\n\n\tstatic getDefaults(): TonePannerOptions {\n\t\treturn Object.assign(ToneAudioNode.getDefaults(), {\n\t\t\tpan: 0,\n\t\t\tchannelCount: 1,\n\t\t});\n\t}\n\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis._panner.disconnect();\n\t\tthis.pan.dispose();\n\t\treturn this;\n\t}\n}\n","import { Panner } from \"../component/channel/Panner\";\nimport { optionsFromArguments } from \"../core/util/Defaults\";\nimport { LFOEffect, LFOEffectOptions } from \"./LFOEffect\";\nimport { Frequency } from \"../core/type/Units\";\n\nexport interface AutoPannerOptions extends LFOEffectOptions {\n\tchannelCount: number;\n}\n\n/**\n * AutoPanner is a [[Panner]] with an [[LFO]] connected to the pan amount. \n * [Related Reading](https://www.ableton.com/en/blog/autopan-chopper-effect-and-more-liveschool/).\n *\n * @example\n * // create an autopanner and start it\n * const autoPanner = new Tone.AutoPanner(\"4n\").toDestination().start();\n * // route an oscillator through the panner and start it\n * const oscillator = new Tone.Oscillator().connect(autoPanner).start();\n * @category Effect\n */\nexport class AutoPanner extends LFOEffect<AutoPannerOptions> {\n\n\treadonly name: string = \"AutoPanner\";\n\n\t/**\n\t * The filter node\n\t */\n\treadonly _panner: Panner;\n\n\t/**\n\t * @param frequency Rate of left-right oscillation. \n\t */\n\tconstructor(frequency?: Frequency);\n\tconstructor(options?: Partial<AutoPannerOptions>);\n\tconstructor() {\n\n\t\tsuper(optionsFromArguments(AutoPanner.getDefaults(), arguments, [\"frequency\"]));\n\t\tconst options = optionsFromArguments(AutoPanner.getDefaults(), arguments, [\"frequency\"]);\n\n\t\tthis._panner = new Panner({\n\t\t\tcontext: this.context,\n\t\t\tchannelCount: options.channelCount\n\t\t});\n\t\t// connections\n\t\tthis.connectEffect(this._panner);\n\t\tthis._lfo.connect(this._panner.pan);\n\t\tthis._lfo.min = -1;\n\t\tthis._lfo.max = 1;\n\t}\n\n\tstatic getDefaults(): AutoPannerOptions {\n\t\treturn Object.assign(LFOEffect.getDefaults(), {\n\t\t\tchannelCount: 1\n\t\t});\n\t}\n\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis._panner.dispose();\n\t\treturn this;\n\t}\n}\n\n","import { Time } from \"../../core/type/Units\";\nimport { InputNode, OutputNode, ToneAudioNode, ToneAudioNodeOptions } from \"../../core/context/ToneAudioNode\";\nimport { optionsFromArguments } from \"../../core/util/Defaults\";\nimport { OnePoleFilter } from \"../filter/OnePoleFilter\";\nimport { Abs } from \"../../signal/Abs\";\n\nexport interface FollowerOptions extends ToneAudioNodeOptions {\n\tsmoothing: Time;\n}\n\n/**\n * Follower is a simple envelope follower. \n * It's implemented by applying a lowpass filter to the absolute value of the incoming signal. \n * ```\n *          +-----+    +---------------+\n * Input +--> Abs +----> OnePoleFilter +--> Output\n *          +-----+    +---------------+\n * ```\n * @category Component\n */\nexport class Follower extends ToneAudioNode<FollowerOptions> {\n\n\treadonly name: string = \"Follower\";\n\n\treadonly input: InputNode;\n\treadonly output: OutputNode;\n\n\t/**\n\t * Private reference to the smoothing parameter\n\t */\n\tprivate _smoothing: Time;\n\n\t/**\n\t * The lowpass filter\n\t */\n\tprivate _lowpass: OnePoleFilter;\n\n\t/**\n\t * The absolute value\n\t */\n\tprivate _abs: Abs;\n\n\t/**\n\t * @param smoothing The rate of change of the follower.\n\t */\n\tconstructor(smoothing?: Time);\n\tconstructor(options?: Partial<FollowerOptions>);\n\tconstructor() {\n\t\tsuper(optionsFromArguments(Follower.getDefaults(), arguments, [\"smoothing\"]));\n\t\tconst options = optionsFromArguments(Follower.getDefaults(), arguments, [\"smoothing\"]);\n\n\t\tthis._abs = this.input = new Abs({ context: this.context });\n\t\tthis._lowpass = this.output = new OnePoleFilter({\n\t\t\tcontext: this.context,\n\t\t\tfrequency: 1 / this.toSeconds(options.smoothing),\n\t\t\ttype: \"lowpass\"\n\t\t});\n\t\tthis._abs.connect(this._lowpass);\n\t\tthis._smoothing = options.smoothing;\n\t}\n\n\tstatic getDefaults(): FollowerOptions {\n\t\treturn Object.assign(ToneAudioNode.getDefaults(), {\n\t\t\tsmoothing: 0.05\n\t\t});\n\t}\n\n\t/**\n\t * The amount of time it takes a value change to arrive at the updated value. \n\t */\n\tget smoothing(): Time {\n\t\treturn this._smoothing;\n\t}\n\tset smoothing(smoothing) {\n\t\tthis._smoothing = smoothing;\n\t\tthis._lowpass.frequency = 1 / this.toSeconds(this.smoothing);\n\t}\n\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis._abs.dispose();\n\t\tthis._lowpass.dispose();\n\t\treturn this;\n\t}\n}\n","import { Effect, EffectOptions } from \"./Effect\";\nimport { Filter } from \"../component/filter/Filter\";\nimport { Follower } from \"../component/analysis/Follower\";\nimport { Decibels, Frequency, GainFactor, Hertz, Positive, Time } from \"../core/type/Units\";\nimport { optionsFromArguments } from \"../core/util/Defaults\";\nimport { Gain } from \"../core/context/Gain\";\nimport { dbToGain, gainToDb } from \"../core/type/Conversions\";\nimport { ScaleExp } from \"../signal/ScaleExp\";\nimport { Signal } from \"../signal/Signal\";\nimport { readOnly } from \"../core/util/Interface\";\n\nexport interface AutoWahOptions extends EffectOptions {\n\tbaseFrequency: Frequency;\n\toctaves: Positive;\n\tsensitivity: Decibels;\n\tQ: Positive;\n\tgain: GainFactor;\n\tfollower: Time;\n}\n\n/**\n * AutoWah connects a [[Follower]] to a [[Filter]]. \n * The frequency of the filter, follows the input amplitude curve. \n * Inspiration from [Tuna.js](https://github.com/Dinahmoe/tuna).\n * \n * @example\n * const autoWah = new Tone.AutoWah(50, 6, -30).toDestination();\n * // initialize the synth and connect to autowah\n * const synth = new Tone.Synth().connect(autoWah);\n * // Q value influences the effect of the wah - default is 2\n * autoWah.Q.value = 6;\n * // more audible on higher notes\n * synth.triggerAttackRelease(\"C4\", \"8n\");\n * @category Effect\n */\nexport class AutoWah extends Effect<AutoWahOptions> {\n\n\treadonly name: string = \"AutoWah\";\n\n\t/**\n\t * The envelope follower. Set the attack/release\n\t * timing to adjust how the envelope is followed.\n\t */\n\tprivate _follower: Follower;\n\n\t/**\n\t * scales the follower value to the frequency domain\n\t */\n\tprivate _sweepRange: ScaleExp;\n\n\t/**\n\t * Hold the base frequency value\n\t */\n\tprivate _baseFrequency: Hertz;\n\n\t/**\n\t * Private holder for the octave count\n\t */\n\tprivate _octaves: Positive;\n\n\t/**\n\t * the input gain to adjust the sensitivity\n\t */\n\tprivate _inputBoost: Gain;\n\n\t/**\n\t * Private holder for the filter\n\t */\n\tprivate _bandpass: Filter;\n\n\t/**\n\t * The peaking fitler\n\t */\n\tprivate _peaking: Filter;\n\n\t/**\n\t * The gain of the filter.\n\t */\n\treadonly gain: Signal<\"decibels\">;\n\n\t/**\n\t * The quality of the filter.\n\t */\n\treadonly Q: Signal<\"positive\">;\n\n\t/**\n\t * @param baseFrequency The frequency the filter is set to at the low point of the wah\n\t * @param octaves The number of octaves above the baseFrequency the filter will sweep to when fully open. \n\t * @param sensitivity The decibel threshold sensitivity for the incoming signal. Normal range of -40 to 0.\n\t */\n\tconstructor(baseFrequency?: Frequency, octaves?: Positive, sensitivity?: Decibels);\n\tconstructor(options?: Partial<AutoWahOptions>);\n\tconstructor() {\n\n\t\tsuper(optionsFromArguments(AutoWah.getDefaults(), arguments, [\"baseFrequency\", \"octaves\", \"sensitivity\"]));\n\t\tconst options = optionsFromArguments(AutoWah.getDefaults(), arguments, [\"baseFrequency\", \"octaves\", \"sensitivity\"]);\n\n\t\tthis._follower = new Follower({\n\t\t\tcontext: this.context,\n\t\t\tsmoothing: options.follower,\n\t\t});\n\t\tthis._sweepRange = new ScaleExp({\n\t\t\tcontext: this.context,\n\t\t\tmin: 0,\n\t\t\tmax: 1,\n\t\t\texponent: 0.5,\n\t\t});\n\t\tthis._baseFrequency = this.toFrequency(options.baseFrequency);\n\t\tthis._octaves = options.octaves;\n\t\tthis._inputBoost = new Gain({ context: this.context });\n\t\tthis._bandpass = new Filter({\n\t\t\tcontext: this.context,\n\t\t\trolloff: -48,\n\t\t\tfrequency: 0,\n\t\t\tQ: options.Q,\n\t\t});\n\t\tthis._peaking = new Filter({\n\t\t\tcontext: this.context,\n\t\t\ttype: \"peaking\"\n\t\t});\n\t\tthis._peaking.gain.value = options.gain;\n\t\tthis.gain = this._peaking.gain;\n\t\tthis.Q = this._bandpass.Q;\n\n\t\t// the control signal path\n\t\tthis.effectSend.chain(this._inputBoost, this._follower, this._sweepRange);\n\t\tthis._sweepRange.connect(this._bandpass.frequency);\n\t\tthis._sweepRange.connect(this._peaking.frequency);\n\t\t// the filtered path\n\t\tthis.effectSend.chain(this._bandpass, this._peaking, this.effectReturn);\n\t\t// set the initial value\n\t\tthis._setSweepRange();\n\t\tthis.sensitivity = options.sensitivity;\n\n\t\treadOnly(this, [\"gain\", \"Q\"]);\n\t}\n\n\tstatic getDefaults(): AutoWahOptions {\n\t\treturn Object.assign(Effect.getDefaults(), {\n\t\t\tbaseFrequency: 100,\n\t\t\toctaves: 6,\n\t\t\tsensitivity: 0,\n\t\t\tQ: 2,\n\t\t\tgain: 2,\n\t\t\tfollower: 0.2,\n\t\t});\n\t}\n\n\t/**\n\t * The number of octaves that the filter will sweep above the baseFrequency.\n\t */\n\tget octaves() {\n\t\treturn this._octaves;\n\t}\n\tset octaves(octaves) {\n\t\tthis._octaves = octaves;\n\t\tthis._setSweepRange();\n\t}\n\n\t/**\n\t * The follower's smoothing time\n\t */\n\tget follower(): Time {\n\t\treturn this._follower.smoothing;\n\t}\n\tset follower(follower) {\n\t\tthis._follower.smoothing = follower;\n\t}\n\n\t/**\n\t * The base frequency from which the sweep will start from.\n\t */\n\tget baseFrequency(): Frequency {\n\t\treturn this._baseFrequency;\n\t}\n\tset baseFrequency(baseFreq) {\n\t\tthis._baseFrequency = this.toFrequency(baseFreq);\n\t\tthis._setSweepRange();\n\t}\n\n\t/**\n\t * The sensitivity to control how responsive to the input signal the filter is.\n\t */\n\tget sensitivity(): Decibels {\n\t\treturn gainToDb(1 / this._inputBoost.gain.value);\n\t}\n\tset sensitivity(sensitivity) {\n\t\tthis._inputBoost.gain.value = 1 / dbToGain(sensitivity);\n\t}\n\n\t/**\n\t * sets the sweep range of the scaler\n\t */\n\tprivate _setSweepRange() {\n\t\tthis._sweepRange.min = this._baseFrequency;\n\t\tthis._sweepRange.max = Math.min(this._baseFrequency * Math.pow(2, this._octaves), this.context.sampleRate / 2);\n\t}\n\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis._follower.dispose();\n\t\tthis._sweepRange.dispose();\n\t\tthis._bandpass.dispose();\n\t\tthis._peaking.dispose();\n\t\tthis._inputBoost.dispose();\n\t\treturn this;\n\t}\n}\n","import \"../core/worklet/SingleIOProcessor.worklet\";\nimport { registerProcessor } from \"../core/worklet/WorkletGlobalScope\";\n\nexport const workletName = \"bit-crusher\";\n\nexport const bitCrusherWorklet = /* javascript */`\n\tclass BitCrusherWorklet extends SingleIOProcessor {\n\n\t\tstatic get parameterDescriptors() {\n\t\t\treturn [{\n\t\t\t\tname: \"bits\",\n\t\t\t\tdefaultValue: 12,\n\t\t\t\tminValue: 1,\n\t\t\t\tmaxValue: 16,\n\t\t\t\tautomationRate: 'k-rate'\n\t\t\t}];\n\t\t}\n\n\t\tgenerate(input, _channel, parameters) {\n\t\t\tconst step = Math.pow(0.5, parameters.bits - 1);\n\t\t\tconst val = step * Math.floor(input / step + 0.5);\n\t\t\treturn val;\n\t\t}\n\t}\n`;\n\nregisterProcessor(workletName, bitCrusherWorklet);\n","import { ToneAudioWorklet, ToneAudioWorkletOptions } from \"../core/worklet/ToneAudioWorklet\";\nimport { Effect, EffectOptions } from \"./Effect\";\nimport { Positive } from \"../core/type/Units\";\nimport { Gain } from \"../core/context/Gain\";\nimport { optionsFromArguments } from \"../core/util/Defaults\";\nimport { connectSeries } from \"../core/context/ToneAudioNode\";\nimport { Param } from \"../core/context/Param\";\nimport { workletName } from \"./BitCrusher.worklet\";\n\nexport interface BitCrusherOptions extends EffectOptions {\n\tbits: Positive;\n}\n\n/**\n * BitCrusher down-samples the incoming signal to a different bit depth.\n * Lowering the bit depth of the signal creates distortion. Read more about BitCrushing\n * on [Wikipedia](https://en.wikipedia.org/wiki/Bitcrusher).\n * @example\n * // initialize crusher and route a synth through it\n * const crusher = new Tone.BitCrusher(4).toDestination();\n * const synth = new Tone.Synth().connect(crusher);\n * synth.triggerAttackRelease(\"C2\", 2);\n * \n * @category Effect\n */\nexport class BitCrusher extends Effect<BitCrusherOptions> {\n\n\treadonly name: string = \"BitCrusher\";\n\n\t/**\n\t * The bit depth of the effect\n\t * @min 1\n\t * @max 16\n\t */\n\treadonly bits: Param<\"positive\">;\n\n\t/**\n\t * The node which does the bit crushing effect. Runs in an AudioWorklet when possible.\n\t */\n\tprivate _bitCrusherWorklet: BitCrusherWorklet;\n\n\tconstructor(bits?: Positive);\n\tconstructor(options?: Partial<BitCrusherWorkletOptions>);\n\tconstructor() {\n\t\tsuper(optionsFromArguments(BitCrusher.getDefaults(), arguments, [\"bits\"]));\n\t\tconst options = optionsFromArguments(BitCrusher.getDefaults(), arguments, [\"bits\"]);\n\n\t\tthis._bitCrusherWorklet = new BitCrusherWorklet({\n\t\t\tcontext: this.context,\n\t\t\tbits: options.bits,\n\t\t});\n\t\t// connect it up\n\t\tthis.connectEffect(this._bitCrusherWorklet);\n\n\t\tthis.bits = this._bitCrusherWorklet.bits;\n\t}\n\n\tstatic getDefaults(): BitCrusherOptions {\n\t\treturn Object.assign(Effect.getDefaults(), {\n\t\t\tbits: 4,\n\t\t});\n\t}\n\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis._bitCrusherWorklet.dispose();\n\t\treturn this;\n\t}\n}\n\ninterface BitCrusherWorkletOptions extends ToneAudioWorkletOptions {\n\tbits: number;\n}\n\n/**\n * Internal class which creates an AudioWorklet to do the bit crushing\n */\nclass BitCrusherWorklet extends ToneAudioWorklet<BitCrusherWorkletOptions> {\n\n\treadonly name: string = \"BitCrusherWorklet\";\n\n\treadonly input: Gain;\n\treadonly output: Gain;\n\n\treadonly bits: Param<\"positive\">;\n\n\tconstructor(options?: Partial<BitCrusherWorkletOptions>);\n\tconstructor() {\n\t\tsuper(optionsFromArguments(BitCrusherWorklet.getDefaults(), arguments));\n\t\tconst options = optionsFromArguments(BitCrusherWorklet.getDefaults(), arguments);\n\n\t\tthis.input = new Gain({ context: this.context });\n\t\tthis.output = new Gain({ context: this.context });\n\n\t\tthis.bits = new Param<\"positive\">({\n\t\t\tcontext: this.context,\n\t\t\tvalue: options.bits,\n\t\t\tunits: \"positive\",\n\t\t\tminValue: 1,\n\t\t\tmaxValue: 16,\n\t\t\tparam: this._dummyParam,\n\t\t\tswappable: true,\n\t\t});\n\t}\n\n\tstatic getDefaults(): BitCrusherWorkletOptions {\n\t\treturn Object.assign(ToneAudioWorklet.getDefaults(), {\n\t\t\tbits: 12,\n\t\t});\n\t}\n\n\tprotected _audioWorkletName(): string {\n\t\treturn workletName;\n\t}\n\n\tonReady(node: AudioWorkletNode) {\n\t\tconnectSeries(this.input, node, this.output);\n\t\tconst bits = node.parameters.get(\"bits\") as AudioParam;\n\t\tthis.bits.setParam(bits);\n\t}\n\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis.input.dispose();\n\t\tthis.output.dispose();\n\t\tthis.bits.dispose();\n\t\treturn this;\n\t}\n}\n","import { Effect, EffectOptions } from \"./Effect\";\nimport { Positive } from \"../core/type/Units\";\nimport { optionsFromArguments } from \"../core/util/Defaults\";\nimport { WaveShaper } from \"../signal/WaveShaper\";\nimport { assert } from \"../core/util/Debug\";\n\nexport interface ChebyshevOptions extends EffectOptions {\n\torder: Positive;\n\toversample: OverSampleType;\n}\n\n/**\n * Chebyshev is a waveshaper which is good \n * for making different types of distortion sounds.\n * Note that odd orders sound very different from even ones, \n * and order = 1 is no change. \n * Read more at [music.columbia.edu](http://music.columbia.edu/cmc/musicandcomputers/chapter4/04_06.php).\n * @example\n * // create a new cheby\n * const cheby = new Tone.Chebyshev(50).toDestination();\n * // create a monosynth connected to our cheby\n * const synth = new Tone.MonoSynth().connect(cheby);\n * synth.triggerAttackRelease(\"C2\", 0.4);\n * @category Effect\n */\nexport class Chebyshev extends Effect<ChebyshevOptions> {\n\n\treadonly name: string = \"Chebyshev\";\n\n\t/**\n\t * The private waveshaper node\n\t */\n\tprivate _shaper: WaveShaper;\n\n\t/**\n\t * holds onto the order of the filter\n\t */\n\tprivate _order: number;\n\n\t/**\n\t * @param order The order of the chebyshev polynomial. Normal range between 1-100. \n\t */\n\tconstructor(order?: Positive);\n\tconstructor(options?: Partial<ChebyshevOptions>);\n\tconstructor() {\n\n\t\tsuper(optionsFromArguments(Chebyshev.getDefaults(), arguments, [\"order\"]));\n\t\tconst options = optionsFromArguments(Chebyshev.getDefaults(), arguments, [\"order\"]);\n\n\t\tthis._shaper = new WaveShaper({\n\t\t\tcontext: this.context,\n\t\t\tlength: 4096\n\t\t});\n\t\tthis._order = options.order;\n\n\t\tthis.connectEffect(this._shaper);\n\t\tthis.order = options.order;\n\t\tthis.oversample = options.oversample;\n\t}\n\n\tstatic getDefaults(): ChebyshevOptions {\n\t\treturn Object.assign(Effect.getDefaults(), {\n\t\t\torder: 1,\n\t\t\toversample: \"none\" as const\n\t\t});\n\t}\n\n\t/**\n\t * get the coefficient for that degree\n\t * @param  x the x value\n\t * @param  degree \n\t * @param  memo memoize the computed value. this speeds up computation greatly. \n\t */\n\tprivate _getCoefficient(x: number, degree: number, memo: Map<number, number>): number {\n\t\tif (memo.has(degree)) {\n\t\t\treturn memo.get(degree) as number;\n\t\t} else if (degree === 0) {\n\t\t\tmemo.set(degree, 0);\n\t\t} else if (degree === 1) {\n\t\t\tmemo.set(degree, x);\n\t\t} else {\n\t\t\tmemo.set(degree, 2 * x * this._getCoefficient(x, degree - 1, memo) - this._getCoefficient(x, degree - 2, memo));\n\t\t}\n\t\treturn memo.get(degree) as number;\n\t}\n\n\t/**\n\t * The order of the Chebyshev polynomial which creates the equation which is applied to the incoming \n\t * signal through a Tone.WaveShaper. Must be an integer. The equations are in the form:\n\t * ```\n\t * order 2: 2x^2 + 1\n\t * order 3: 4x^3 + 3x \n\t * ```\n\t * @min 1\n\t * @max 100\n\t */\n\tget order(): Positive {\n\t\treturn this._order;\n\t}\n\tset order(order) {\n\t\tassert(Number.isInteger(order), \"'order' must be an integer\");\n\t\tthis._order = order;\n\t\tthis._shaper.setMap((x => {\n\t\t\treturn this._getCoefficient(x, order, new Map());\n\t\t}));\n\t}\n\n\t/**\n\t * The oversampling of the effect. Can either be \"none\", \"2x\" or \"4x\".\n\t */\n\tget oversample(): OverSampleType {\n\t\treturn this._shaper.oversample;\n\t}\n\tset oversample(oversampling) {\n\t\tthis._shaper.oversample = oversampling;\n\t}\n\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis._shaper.dispose();\n\t\treturn this;\n\t}\n}\n","import { ToneAudioNode, ToneAudioNodeOptions } from \"../../core/context/ToneAudioNode\";\nimport { optionsFromArguments } from \"../../core/util/Defaults\";\n\ninterface SplitOptions extends ToneAudioNodeOptions {\n\tchannels: number;\n}\n\n/**\n * Split splits an incoming signal into the number of given channels.\n *\n * @example\n * const split = new Tone.Split();\n * // stereoSignal.connect(split);\n * @category Component\n */\nexport class Split extends ToneAudioNode<SplitOptions> {\n\treadonly name: string = \"Split\";\n\n\t/**\n\t * The splitting node\n\t */\n\tprivate _splitter: ChannelSplitterNode;\n\n\treadonly input: ChannelSplitterNode;\n\treadonly output: ChannelSplitterNode;\n\n\t/**\n\t * @param channels The number of channels to merge.\n\t */\n\tconstructor(channels?: number);\n\tconstructor(options?: Partial<SplitOptions>);\n\tconstructor() {\n\t\tsuper(optionsFromArguments(Split.getDefaults(), arguments, [\"channels\"]));\n\t\tconst options = optionsFromArguments(Split.getDefaults(), arguments, [\"channels\"]);\n\n\t\tthis._splitter = this.input = this.output = this.context.createChannelSplitter(options.channels);\n\t\tthis._internalChannels = [this._splitter];\n\t}\n\n\tstatic getDefaults(): SplitOptions {\n\t\treturn Object.assign(ToneAudioNode.getDefaults(), {\n\t\t\tchannels: 2,\n\t\t});\n\t}\n\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis._splitter.disconnect();\n\t\treturn this;\n\t}\n}\n","import { ToneAudioNode, ToneAudioNodeOptions } from \"../../core/context/ToneAudioNode\";\nimport { Positive } from \"../../core/type/Units\";\nimport { optionsFromArguments } from \"../../core/util/Defaults\";\n\ninterface MergeOptions extends ToneAudioNodeOptions {\n\tchannels: Positive;\n}\n\n/**\n * Merge brings multiple mono input channels into a single multichannel output channel.\n *\n * @example\n * const merge = new Tone.Merge().toDestination();\n * // routing a sine tone in the left channel\n * const osc = new Tone.Oscillator().connect(merge, 0, 0).start();\n * // and noise in the right channel\n * const noise = new Tone.Noise().connect(merge, 0, 1).start();;\n * @category Component\n */\nexport class Merge extends ToneAudioNode<MergeOptions> {\n\n\treadonly name: string = \"Merge\";\n\n\t/**\n\t * The merger node for the channels.\n\t */\n\tprivate _merger: ChannelMergerNode;\n\n\t/**\n\t * The output is the input channels combined into a single (multichannel) output\n\t */\n\treadonly output: ChannelMergerNode;\n\n\t/**\n\t * Multiple input connections combine into a single output.\n\t */\n\treadonly input: ChannelMergerNode;\n\n\t/**\n\t * @param channels The number of channels to merge.\n\t */\n\tconstructor(channels?: Positive);\n\tconstructor(options?: Partial<MergeOptions>);\n\tconstructor() {\n\t\tsuper(optionsFromArguments(Merge.getDefaults(), arguments, [\"channels\"]));\n\t\tconst options = optionsFromArguments(Merge.getDefaults(), arguments, [\"channels\"]);\n\n\t\tthis._merger = this.output = this.input = this.context.createChannelMerger(options.channels);\n\t}\n\n\tstatic getDefaults(): MergeOptions {\n\t\treturn Object.assign(ToneAudioNode.getDefaults(), {\n\t\t\tchannels: 2,\n\t\t});\n\t}\n\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis._merger.disconnect();\n\t\treturn this;\n\t}\n}\n","import { EffectOptions } from \"./Effect\";\nimport { connect, connectSeries, OutputNode, ToneAudioNode } from \"../core/context/ToneAudioNode\";\nimport { CrossFade } from \"../component/channel/CrossFade\";\nimport { Signal } from \"../signal/Signal\";\nimport { Split } from \"../component/channel/Split\";\nimport { Gain } from \"../core/context/Gain\";\nimport { Merge } from \"../component/channel/Merge\";\nimport { readOnly } from \"../core/util/Interface\";\n\nexport type StereoEffectOptions = EffectOptions;\n\n/**\n * Base class for Stereo effects.\n */\nexport class StereoEffect<Options extends StereoEffectOptions> extends ToneAudioNode<Options> {\n\n\treadonly name: string = \"StereoEffect\";\n\n\treadonly input: Gain;\n\treadonly output: CrossFade;\n\n\t/**\n\t * the drywet knob to control the amount of effect\n\t */\n\tprivate _dryWet: CrossFade;\n\t\n\t/**\n\t * The wet control, i.e. how much of the effected\n\t * will pass through to the output.\n\t */\n\treadonly wet: Signal<\"normalRange\">;\n\t\n\t/**\n\t * Split it\n\t */\n\tprotected _split: Split;\n\t\n\t/**\n\t * the stereo effect merger\n\t */\n\tprotected _merge: Merge;\n\n\tconstructor(options: StereoEffectOptions) {\n\n\t\tsuper(options);\n\n\t\tthis.input = new Gain({ context: this.context });\n\t\t// force mono sources to be stereo\n\t\tthis.input.channelCount = 2;\n\t\tthis.input.channelCountMode = \"explicit\";\n\n\t\tthis._dryWet = this.output = new CrossFade({\n\t\t\tcontext: this.context,\n\t\t\tfade: options.wet\n\t\t});\n\t\tthis.wet = this._dryWet.fade;\n\t\tthis._split = new Split({ context: this.context, channels: 2 });\n\t\tthis._merge = new Merge({ context: this.context, channels: 2 });\n\n\t\t// connections\n\t\tthis.input.connect(this._split);\n\t\t// dry wet connections\n\t\tthis.input.connect(this._dryWet.a);\n\t\tthis._merge.connect(this._dryWet.b);\n\t\treadOnly(this, [\"wet\"]);\n\t}\n\t\n\t/**\n\t * Connect the left part of the effect\n\t */\n\tprotected connectEffectLeft(...nodes: OutputNode[]): void {\n\t\tthis._split.connect(nodes[0], 0, 0);\n\t\tconnectSeries(...nodes);\n\t\tconnect(nodes[nodes.length-1], this._merge, 0, 0);\n\t}\n\t\n\t/**\n\t * Connect the right part of the effect\n\t */\n\tprotected connectEffectRight(...nodes: OutputNode[]): void {\n\t\tthis._split.connect(nodes[0], 1, 0);\n\t\tconnectSeries(...nodes);\n\t\tconnect(nodes[nodes.length-1], this._merge, 0, 1);\n\t}\n\n\tstatic getDefaults(): StereoEffectOptions {\n\t\treturn Object.assign(ToneAudioNode.getDefaults(), {\n\t\t\twet: 1,\n\t\t});\n\t}\n\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis._dryWet.dispose();\n\t\tthis._split.dispose();\n\t\tthis._merge.dispose();\n\t\treturn this;\n\t}\n}\n","import { StereoEffect, StereoEffectOptions } from \"./StereoEffect\";\nimport { NormalRange } from \"../core/type/Units\";\nimport { Signal } from \"../signal/Signal\";\nimport { Gain } from \"../core/context/Gain\";\nimport { readOnly } from \"../core/util/Interface\";\nimport { Split } from \"../component/channel/Split\";\nimport { Merge } from \"../component/channel/Merge\";\n\nexport interface StereoFeedbackEffectOptions extends StereoEffectOptions {\n\tfeedback: NormalRange;\n}\n\n/**\n * Base class for stereo feedback effects where the effectReturn is fed back into the same channel.\n */\nexport class StereoFeedbackEffect<Options extends StereoFeedbackEffectOptions> extends StereoEffect<Options> {\n\t\n\t/**\n\t * The amount of feedback from the output\n\t * back into the input of the effect (routed\n\t * across left and right channels).\n\t */\n\treadonly feedback: Signal<\"normalRange\">;\n\n\t/**\n\t * the left side feedback\n\t */\n\tprotected _feedbackL: Gain;\n\n\t/**\n\t * the right side feedback\n\t */\n\tprotected _feedbackR: Gain;\n\n\t/**\n\t * Split the channels for feedback\n\t */\n\tprotected _feedbackSplit: Split;\n\n\t/**\n\t * Merge the channels for feedback\n\t */\n\tprotected _feedbackMerge: Merge;\n\n\tconstructor(options: StereoFeedbackEffectOptions) {\n\n\t\tsuper(options);\n\n\t\tthis.feedback = new Signal({\n\t\t\tcontext: this.context,\n\t\t\tvalue: options.feedback, \n\t\t\tunits: \"normalRange\"\n\t\t});\n\t\tthis._feedbackL = new Gain({ context: this.context });\n\t\tthis._feedbackR = new Gain({ context: this.context });\n\n\t\tthis._feedbackSplit = new Split({ context: this.context, channels: 2 });\n\t\tthis._feedbackMerge = new Merge({ context: this.context, channels: 2 });\n\n\t\tthis._merge.connect(this._feedbackSplit);\n\t\tthis._feedbackMerge.connect(this._split);\n\t\t\n\t\t// the left output connected to the left input\n\t\tthis._feedbackSplit.connect(this._feedbackL, 0, 0);\n\t\tthis._feedbackL.connect(this._feedbackMerge, 0, 0);\n\n\t\t// the right output connected to the right input\n\t\tthis._feedbackSplit.connect(this._feedbackR, 1, 0);\n\t\tthis._feedbackR.connect(this._feedbackMerge, 0, 1);\n\t\t\n\t\t// the feedback control\n\t\tthis.feedback.fan(this._feedbackL.gain, this._feedbackR.gain);\n\t\treadOnly(this, [\"feedback\"]);\n\t}\n\n\tstatic getDefaults(): StereoFeedbackEffectOptions {\n\t\treturn Object.assign(StereoEffect.getDefaults(), {\n\t\t\tfeedback: 0.5,\n\t\t});\n\t}\n\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis.feedback.dispose();\n\t\tthis._feedbackL.dispose();\n\t\tthis._feedbackR.dispose();\n\t\tthis._feedbackSplit.dispose();\n\t\tthis._feedbackMerge.dispose();\n\t\treturn this;\n\t}\n}\n","import { StereoFeedbackEffect, StereoFeedbackEffectOptions } from \"../effect/StereoFeedbackEffect\";\nimport { Degrees, Frequency, Milliseconds, NormalRange, Seconds, Time } from \"../core/type/Units\";\nimport { ToneOscillatorType } from \"../source/oscillator/OscillatorInterface\";\nimport { optionsFromArguments } from \"../core/util/Defaults\";\nimport { LFO } from \"../source/oscillator/LFO\";\nimport { Delay } from \"../core/context/Delay\";\nimport { Signal } from \"../signal/Signal\";\nimport { readOnly } from \"../core/util/Interface\";\n\nexport interface ChorusOptions extends StereoFeedbackEffectOptions {\n\tfrequency: Frequency;\n\tdelayTime: Milliseconds;\n\tdepth: NormalRange;\n\ttype: ToneOscillatorType;\n\tspread: Degrees;\n}\n\n/**\n * Chorus is a stereo chorus effect composed of a left and right delay with an [[LFO]] applied to the delayTime of each channel.\n * When [[feedback]] is set to a value larger than 0, you also get Flanger-type effects. \n * Inspiration from [Tuna.js](https://github.com/Dinahmoe/tuna/blob/master/tuna.js).\n * Read more on the chorus effect on [SoundOnSound](http://www.soundonsound.com/sos/jun04/articles/synthsecrets.htm).\n *\n * @example\n * const chorus = new Tone.Chorus(4, 2.5, 0.5).toDestination().start();\n * const synth = new Tone.PolySynth().connect(chorus);\n * synth.triggerAttackRelease([\"C3\", \"E3\", \"G3\"], \"8n\");\n * \n * @category Effect\n */\nexport class Chorus extends StereoFeedbackEffect<ChorusOptions> {\n\n\treadonly name: string = \"Chorus\";\n\n\t/**\n\t * the depth of the chorus\n\t */\n\tprivate _depth: NormalRange;\n\n\t/**\n\t * the delayTime in seconds.\n\t */\n\tprivate _delayTime: Seconds;\n\n\t/**\n\t * the lfo which controls the delayTime\n\t */\n\tprivate _lfoL: LFO\n\n\t/**\n\t * another LFO for the right side with a 180 degree phase diff\n\t */\n\tprivate _lfoR: LFO\n\n\t/**\n\t * delay for left\n\t */\n\tprivate _delayNodeL: Delay;\n\n\t/**\n\t * delay for right\n\t */\n\tprivate _delayNodeR: Delay;\n\n\t/**\n\t * The frequency of the LFO which modulates the delayTime.\n\t */\n\treadonly frequency: Signal<\"frequency\">\n\n\t/**\n\t * @param frequency The frequency of the LFO.\n\t * @param delayTime The delay of the chorus effect in ms.\n\t * @param depth The depth of the chorus.\n\t */\n\tconstructor(frequency?: Frequency, delayTime?: Milliseconds, depth?: NormalRange);\n\tconstructor(options?: Partial<ChorusOptions>);\n\tconstructor() {\n\n\t\tsuper(optionsFromArguments(Chorus.getDefaults(), arguments, [\"frequency\", \"delayTime\", \"depth\"]));\n\t\tconst options = optionsFromArguments(Chorus.getDefaults(), arguments, [\"frequency\", \"delayTime\", \"depth\"]);\n\n\t\tthis._depth = options.depth;\n\t\tthis._delayTime = options.delayTime / 1000;\n\t\tthis._lfoL = new LFO({\n\t\t\tcontext: this.context,\n\t\t\tfrequency: options.frequency,\n\t\t\tmin: 0,\n\t\t\tmax: 1,\n\t\t});\n\t\tthis._lfoR = new LFO({\n\t\t\tcontext: this.context,\n\t\t\tfrequency: options.frequency,\n\t\t\tmin: 0,\n\t\t\tmax: 1,\n\t\t\tphase: 180\n\t\t});\n\t\tthis._delayNodeL = new Delay({ context: this.context });\n\t\tthis._delayNodeR = new Delay({ context: this.context });\n\t\tthis.frequency = this._lfoL.frequency;\n\t\treadOnly(this, [\"frequency\"]);\n\t\t// have one LFO frequency control the other\n\t\tthis._lfoL.frequency.connect(this._lfoR.frequency);\n\n\t\t// connections\n\t\tthis.connectEffectLeft(this._delayNodeL);\n\t\tthis.connectEffectRight(this._delayNodeR);\n\t\t// lfo setup\n\t\tthis._lfoL.connect(this._delayNodeL.delayTime);\n\t\tthis._lfoR.connect(this._delayNodeR.delayTime);\n\t\t// set the initial values\n\t\tthis.depth = this._depth;\n\t\tthis.type = options.type;\n\t\tthis.spread = options.spread;\n\t}\n\n\tstatic getDefaults(): ChorusOptions {\n\t\treturn Object.assign(StereoFeedbackEffect.getDefaults(), {\n\t\t\tfrequency: 1.5,\n\t\t\tdelayTime: 3.5,\n\t\t\tdepth: 0.7,\n\t\t\ttype: \"sine\" as const,\n\t\t\tspread: 180,\n\t\t\tfeedback: 0,\n\t\t\twet: 0.5,\n\t\t});\n\t}\n\n\t/**\n\t * The depth of the effect. A depth of 1 makes the delayTime\n\t * modulate between 0 and 2*delayTime (centered around the delayTime).\n\t */\n\tget depth(): NormalRange {\n\t\treturn this._depth;\n\t}\n\tset depth(depth) {\n\t\tthis._depth = depth;\n\t\tconst deviation = this._delayTime * depth;\n\t\tthis._lfoL.min = Math.max(this._delayTime - deviation, 0);\n\t\tthis._lfoL.max = this._delayTime + deviation;\n\t\tthis._lfoR.min = Math.max(this._delayTime - deviation, 0);\n\t\tthis._lfoR.max = this._delayTime + deviation;\n\t}\n\n\t/**\n\t * The delayTime in milliseconds of the chorus. A larger delayTime\n\t * will give a more pronounced effect. Nominal range a delayTime\n\t * is between 2 and 20ms.\n\t */\n\tget delayTime(): Milliseconds {\n\t\treturn this._delayTime * 1000;\n\t}\n\tset delayTime(delayTime) {\n\t\tthis._delayTime = delayTime / 1000;\n\t\tthis.depth = this._depth;\n\t}\n\n\t/**\n\t * The oscillator type of the LFO.\n\t */\n\tget type(): ToneOscillatorType {\n\t\treturn this._lfoL.type;\n\t}\n\tset type(type) {\n\t\tthis._lfoL.type = type;\n\t\tthis._lfoR.type = type;\n\t}\n\n\t/**\n\t * Amount of stereo spread. When set to 0, both LFO's will be panned centrally.\n\t * When set to 180, LFO's will be panned hard left and right respectively.\n\t */\n\tget spread(): Degrees {\n\t\treturn this._lfoR.phase - this._lfoL.phase;\n\t}\n\tset spread(spread) {\n\t\tthis._lfoL.phase = 90 - (spread / 2);\n\t\tthis._lfoR.phase = (spread / 2) + 90;\n\t}\n\n\t/**\n\t * Start the effect.\n\t */\n\tstart(time?: Time): this {\n\t\tthis._lfoL.start(time);\n\t\tthis._lfoR.start(time);\n\t\treturn this;\n\t}\n\n\t/**\n\t * Stop the lfo\n\t */\n\tstop(time?: Time): this {\n\t\tthis._lfoL.stop(time);\n\t\tthis._lfoR.stop(time);\n\t\treturn this;\n\t}\n\n\t/**\n\t * Sync the filter to the transport. See [[LFO.sync]]\n\t */\n\tsync(): this {\n\t\tthis._lfoL.sync();\n\t\tthis._lfoR.sync();\n\t\treturn this;\n\t}\n\n\t/**\n\t * Unsync the filter from the transport.\n\t */\n\tunsync(): this {\n\t\tthis._lfoL.unsync();\n\t\tthis._lfoR.unsync();\n\t\treturn this;\n\t}\n\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis._lfoL.dispose();\n\t\tthis._lfoR.dispose();\n\t\tthis._delayNodeL.dispose();\n\t\tthis._delayNodeR.dispose();\n\t\tthis.frequency.dispose();\n\t\treturn this;\n\t}\n}\n","import { optionsFromArguments } from \"../core/util/Defaults\";\nimport { WaveShaper } from \"../signal/WaveShaper\";\nimport { Effect, EffectOptions } from \"./Effect\";\n\nexport interface DistortionOptions extends EffectOptions {\n\tdistortion: number;\n\toversample: OverSampleType;\n}\n\n/**\n * A simple distortion effect using Tone.WaveShaper.\n * Algorithm from [this stackoverflow answer](http://stackoverflow.com/a/22313408).\n *\n * @example\n * const dist = new Tone.Distortion(0.8).toDestination();\n * const fm = new Tone.FMSynth().connect(dist);\n * fm.triggerAttackRelease(\"A1\", \"8n\");\n * @category Effect\n */\nexport class Distortion extends Effect<DistortionOptions> {\n\n\treadonly name: string = \"Distortion\";\n\n\t/**\n\t * The waveshaper which does the distortion\n\t */\n\tprivate _shaper: WaveShaper;\n\n\t/**\n\t * Stores the distortion value\n\t */\n\tprivate _distortion: number;\n\n\t/**\n\t * @param distortion The amount of distortion (nominal range of 0-1)\n\t */\n\tconstructor(distortion?: number);\n\tconstructor(options?: Partial<DistortionOptions>);\n\tconstructor() {\n\n\t\tsuper(optionsFromArguments(Distortion.getDefaults(), arguments, [\"distortion\"]));\n\t\tconst options = optionsFromArguments(Distortion.getDefaults(), arguments, [\"distortion\"]);\n\n\t\tthis._shaper = new WaveShaper({\n\t\t\tcontext: this.context,\n\t\t\tlength: 4096,\n\t\t});\n\n\t\tthis._distortion = options.distortion;\n\n\t\tthis.connectEffect(this._shaper);\n\t\tthis.distortion = options.distortion;\n\t\tthis.oversample = options.oversample;\n\t}\n\n\tstatic getDefaults(): DistortionOptions {\n\t\treturn Object.assign(Effect.getDefaults(), {\n\t\t\tdistortion: 0.4,\n\t\t\toversample: \"none\" as OverSampleType,\n\t\t});\n\t}\n\n\t/**\n\t * The amount of distortion. Nominal range is between 0 and 1.\n\t */\n\tget distortion(): number {\n\t\treturn this._distortion;\n\t}\n\tset distortion(amount) {\n\t\tthis._distortion = amount;\n\t\tconst k = amount * 100;\n\t\tconst deg = Math.PI / 180;\n\t\tthis._shaper.setMap((x) => {\n\t\t\tif (Math.abs(x) < 0.001) {\n\t\t\t\t// should output 0 when input is 0\n\t\t\t\treturn 0;\n\t\t\t} else {\n\t\t\t\treturn (3 + k) * x * 20 * deg / (Math.PI + k * Math.abs(x));\n\t\t\t}\n\t\t});\n\t}\n\n\t/**\n\t * The oversampling of the effect. Can either be \"none\", \"2x\" or \"4x\".\n\t */\n\tget oversample(): OverSampleType {\n\t\treturn this._shaper.oversample;\n\t}\n\tset oversample(oversampling) {\n\t\tthis._shaper.oversample = oversampling;\n\t}\n\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis._shaper.dispose();\n\t\treturn this;\n\t}\n}\n","import { Gain } from \"../core/context/Gain\";\nimport { Param } from \"../core/context/Param\";\nimport { NormalRange } from \"../core/type/Units\";\nimport { readOnly } from \"../core/util/Interface\";\nimport { Effect, EffectOptions } from \"./Effect\";\n\nexport interface FeedbackEffectOptions extends EffectOptions {\n\t/**\n\t * The feedback from the output back to the input\n\t * ```\n\t * +---<--------<---+\n\t * |                |\n\t * |  +----------+  |\n\t * +--> feedback +>-+\n\t *    +----------+\n\t * ```\n\t */\n\tfeedback: NormalRange;\n}\n\n/**\n * FeedbackEffect provides a loop between an audio source and its own output.\n * This is a base-class for feedback effects.\n */\nexport abstract class FeedbackEffect<Options extends FeedbackEffectOptions> extends Effect<Options> {\n\n\treadonly name: string = \"FeedbackEffect\";\n\n\t/**\n\t * the gain which controls the feedback\n\t */\n\tprivate _feedbackGain: Gain<\"normalRange\">;\n\n\t/**\n\t * The amount of signal which is fed back into the effect input.\n\t */\n\tfeedback: Param<\"normalRange\">;\n\n\tconstructor(options: FeedbackEffectOptions) {\n\n\t\tsuper(options);\n\n\t\tthis._feedbackGain = new Gain({\n\t\t\tcontext: this.context,\n\t\t\tgain: options.feedback,\n\t\t\tunits: \"normalRange\",\n\t\t});\n\n\t\tthis.feedback = this._feedbackGain.gain;\n\t\treadOnly(this, \"feedback\");\n\n\t\t// the feedback loop\n\t\tthis.effectReturn.chain(this._feedbackGain, this.effectSend);\n\t}\n\n\tstatic getDefaults(): FeedbackEffectOptions {\n\t\treturn Object.assign(Effect.getDefaults(), {\n\t\t\tfeedback: 0.125,\n\t\t});\n\t}\n\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis._feedbackGain.dispose();\n\t\tthis.feedback.dispose();\n\t\treturn this;\n\t}\n}\n","import { Delay } from \"../core/context/Delay\";\nimport { Param } from \"../core/context/Param\";\nimport { NormalRange, Time } from \"../core/type/Units\";\nimport { optionsFromArguments } from \"../core/util/Defaults\";\nimport { readOnly } from \"../core/util/Interface\";\nimport { FeedbackEffect, FeedbackEffectOptions } from \"./FeedbackEffect\";\n\ninterface FeedbackDelayOptions extends FeedbackEffectOptions {\n\tdelayTime: Time;\n\tmaxDelay: Time;\n}\n\n/**\n * FeedbackDelay is a DelayNode in which part of output signal is fed back into the delay.\n *\n * @param delayTime The delay applied to the incoming signal.\n * @param feedback The amount of the effected signal which is fed back through the delay.\n * @example\n * const feedbackDelay = new Tone.FeedbackDelay(\"8n\", 0.5).toDestination();\n * const tom = new Tone.MembraneSynth({\n * \toctaves: 4,\n * \tpitchDecay: 0.1\n * }).connect(feedbackDelay);\n * tom.triggerAttackRelease(\"A2\", \"32n\");\n * @category Effect\n */\nexport class FeedbackDelay extends FeedbackEffect<FeedbackDelayOptions> {\n\n\treadonly name: string = \"FeedbackDelay\";\n\n\t/**\n\t * the delay node\n\t */\n\tprivate _delayNode: Delay;\n\n\t/**\n\t * The delayTime of the FeedbackDelay.\n\t */\n\treadonly delayTime: Param<\"time\">;\n\n\tconstructor(delayTime?: Time, feedback?: NormalRange);\n\tconstructor(options?: Partial<FeedbackDelayOptions>);\n\tconstructor() {\n\n\t\tsuper(optionsFromArguments(FeedbackDelay.getDefaults(), arguments, [\"delayTime\", \"feedback\"]));\n\t\tconst options = optionsFromArguments(FeedbackDelay.getDefaults(), arguments, [\"delayTime\", \"feedback\"]);\n\n\t\tthis._delayNode = new Delay({\n\t\t\tcontext: this.context,\n\t\t\tdelayTime: options.delayTime,\n\t\t\tmaxDelay: options.maxDelay,\n\t\t});\n\t\tthis.delayTime = this._delayNode.delayTime;\n\n\t\t// connect it up\n\t\tthis.connectEffect(this._delayNode);\n\t\treadOnly(this, \"delayTime\");\n\t}\n\n\tstatic getDefaults(): FeedbackDelayOptions {\n\t\treturn Object.assign(FeedbackEffect.getDefaults(), {\n\t\t\tdelayTime: 0.25,\n\t\t\tmaxDelay: 1,\n\t\t});\n\t}\n\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis._delayNode.dispose();\n\t\tthis.delayTime.dispose();\n\t\treturn this;\n\t}\n}\n","import { Gain } from \"../../core/context/Gain\";\nimport { connectSeries, ToneAudioNode, ToneAudioNodeOptions } from \"../../core/context/ToneAudioNode\";\n\n/**\n * PhaseShiftAllpass is an very efficient implementation of a Hilbert Transform\n * using two Allpass filter banks whose outputs have a phase difference of 90°.\n * Here the `offset90` phase is offset by +90° in relation to `output`.\n * Coefficients and structure was developed by Olli Niemitalo.\n * For more details see: http://yehar.com/blog/?p=368\n * @category Component\n */\nexport class PhaseShiftAllpass extends ToneAudioNode<ToneAudioNodeOptions> {\n\n\treadonly name: string = \"PhaseShiftAllpass\";\n\n\treadonly input = new Gain({ context: this.context });\n\n\t/**\n\t * The Allpass filter in the first bank\n\t */\n\tprivate _bank0: IIRFilterNode[];\n\n\t/**\n\t * The Allpass filter in the seconds bank\n\t */\n\tprivate _bank1: IIRFilterNode[];\n\n\t/**\n\t * A IIR filter implementing a delay by one sample used by the first bank\n\t */\n\tprivate _oneSampleDelay: IIRFilterNode;\n\n\t/**\n\t * The phase shifted output\n\t */\n\treadonly output = new Gain({ context: this.context });\n\n\t/**\n\t * The PhaseShifted allpass output\n\t */\n\treadonly offset90 = new Gain({ context: this.context });\n\n\tconstructor(options?: Partial<ToneAudioNodeOptions>) {\n\n\t\tsuper(options);\n\n\t\tconst allpassBank1Values = [0.6923878, 0.9360654322959, 0.9882295226860, 0.9987488452737];\n\t\tconst allpassBank2Values = [0.4021921162426, 0.8561710882420, 0.9722909545651, 0.9952884791278];\n\n\t\tthis._bank0 = this._createAllPassFilterBank(allpassBank1Values);\n\t\tthis._bank1 = this._createAllPassFilterBank(allpassBank2Values);\n\t\tthis._oneSampleDelay = this.context.createIIRFilter([0.0, 1.0], [1.0, 0.0]);\n\n\t\t// connect Allpass filter banks\n\t\tconnectSeries(this.input, ...this._bank0, this._oneSampleDelay, this.output);\n\t\tconnectSeries(this.input, ...this._bank1, this.offset90);\n\t}\n\n\t/**\n\t * Create all of the IIR filters from an array of values using the coefficient calculation.\n\t */\n\tprivate _createAllPassFilterBank(bankValues: number[]): IIRFilterNode[] {\n\t\tconst nodes: IIRFilterNode[] = bankValues.map(value => {\n\t\t\tconst coefficients = [[value * value, 0, -1], [1, 0, -(value * value)]];\n\t\t\treturn this.context.createIIRFilter(coefficients[0], coefficients[1]);\n\t\t});\n\n\t\treturn nodes;\n\t}\n\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis.input.dispose();\n\t\tthis.output.dispose();\n\t\tthis.offset90.dispose();\n\t\tthis._bank0.forEach(f => f.disconnect());\n\t\tthis._bank1.forEach(f => f.disconnect());\n\t\tthis._oneSampleDelay.disconnect();\n\t\treturn this;\n\t}\n}\n","import { PhaseShiftAllpass } from \"../component/filter/PhaseShiftAllpass\";\nimport { Frequency } from \"../core/type/Units\";\nimport { optionsFromArguments } from \"../core/util/Defaults\";\nimport { Effect, EffectOptions } from \"../effect/Effect\";\nimport { Add } from \"../signal/Add\";\nimport { Multiply } from \"../signal/Multiply\";\nimport { Negate } from \"../signal/Negate\";\nimport { Signal } from \"../signal/Signal\";\nimport { Oscillator } from \"../source/oscillator/Oscillator\";\nimport { ToneOscillatorNode } from \"../source/oscillator/ToneOscillatorNode\";\n\ninterface FrequencyShifterOptions extends EffectOptions {\n\tfrequency: Frequency;\n}\n\n/**\n * FrequencyShifter can be used to shift all frequencies of a signal by a fixed amount.\n * The amount can be changed at audio rate and the effect is applied in real time.\n * The frequency shifting is implemented with a technique called single side band modulation using a ring modulator.\n * Note: Contrary to pitch shifting, all frequencies are shifted by the same amount,\n * destroying the harmonic relationship between them. This leads to the classic ring modulator timbre distortion.\n * The algorithm will produces some aliasing towards the high end, especially if your source material\n * contains a lot of high frequencies. Unfortunatelly the webaudio API does not support resampling\n * buffers in real time, so it is not possible to fix it properly. Depending on the use case it might\n * be an option to low pass filter your input before frequency shifting it to get ride of the aliasing.\n * You can find a very detailed description of the algorithm here: https://larzeitlin.github.io/RMFS/\n *\n * @example\n * const input = new Tone.Oscillator(230, \"sawtooth\").start();\n * const shift = new Tone.FrequencyShifter(42).toDestination();\n * input.connect(shift);\n * @category Effect\n */\nexport class FrequencyShifter extends Effect<FrequencyShifterOptions> {\n\n\treadonly name: string = \"FrequencyShifter\";\n\n\t/**\n\t * The ring modulators carrier frequency. This frequency determines\n\t * by how many Hertz the input signal will be shifted up or down. Default is 0.\n\t */\n\treadonly frequency: Signal<\"frequency\">;\n\n\t/**\n\t * The ring modulators sine carrier\n\t */\n\tprivate _sine: ToneOscillatorNode;\n\n\t/**\n\t * The ring modulators cosine carrier\n\t */\n\tprivate _cosine: Oscillator;\n\n\t/**\n\t * The sine multiply operator\n\t */\n\tprivate _sineMultiply: Multiply;\n\n\t/**\n\t * The cosine multiply operator\n\t */\n\tprivate _cosineMultiply: Multiply;\n\n\t/**\n\t * The negate operator\n\t */\n\tprivate _negate: Negate;\n\n\t/**\n\t * The final add operator\n\t */\n\tprivate _add: Add;\n\n\t/**\n\t * The phase shifter to create the initial 90° phase offset\n\t */\n\tprivate _phaseShifter: PhaseShiftAllpass;\n\n\t/**\n\t * @param frequency The incoming signal is shifted by this frequency value.\n\t */\n\tconstructor(frequency?: Frequency);\n\tconstructor(options?: Partial<FrequencyShifterOptions>);\n\tconstructor() {\n\n\t\tsuper(optionsFromArguments(FrequencyShifter.getDefaults(), arguments, [\"frequency\"]));\n\t\tconst options = optionsFromArguments(FrequencyShifter.getDefaults(), arguments, [\"frequency\"]);\n\n\t\tthis.frequency = new Signal({\n\t\t\tcontext: this.context,\n\t\t\tunits: \"frequency\",\n\t\t\tvalue: options.frequency,\n\t\t\tminValue: -this.context.sampleRate / 2,\n\t\t\tmaxValue: this.context.sampleRate / 2,\n\t\t});\n\n\t\tthis._sine = new ToneOscillatorNode({\n\t\t\tcontext: this.context,\n\t\t\ttype: \"sine\",\n\t\t});\n\n\t\tthis._cosine = new Oscillator({\n\t\t\tcontext: this.context,\n\t\t\tphase: -90,\n\t\t\ttype: \"sine\",\n\t\t});\n\n\t\tthis._sineMultiply = new Multiply({ context: this.context });\n\t\tthis._cosineMultiply = new Multiply({ context: this.context });\n\t\tthis._negate = new Negate({ context: this.context });\n\t\tthis._add = new Add({ context: this.context });\n\n\t\tthis._phaseShifter = new PhaseShiftAllpass({ context: this.context });\n\t\tthis.effectSend.connect(this._phaseShifter);\n\n\t\t// connect the carrier frequency signal to the two oscillators\n\t\tthis.frequency.fan(this._sine.frequency, this._cosine.frequency);\n\n\t\tthis._phaseShifter.offset90.connect(this._cosineMultiply);\n\t\tthis._cosine.connect(this._cosineMultiply.factor);\n\n\t\tthis._phaseShifter.connect(this._sineMultiply);\n\t\tthis._sine.connect(this._sineMultiply.factor);\n\t\tthis._sineMultiply.connect(this._negate);\n\n\t\tthis._cosineMultiply.connect(this._add);\n\t\tthis._negate.connect(this._add.addend);\n\n\t\tthis._add.connect(this.effectReturn);\n\n\t\t// start the oscillators at the same time\n\t\tconst now = this.immediate();\n\t\tthis._sine.start(now);\n\t\tthis._cosine.start(now);\n\t}\n\n\tstatic getDefaults(): FrequencyShifterOptions {\n\t\treturn Object.assign(Effect.getDefaults(), {\n\t\t\tfrequency: 0,\n\t\t});\n\t}\n\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis.frequency.dispose();\n\t\tthis._add.dispose();\n\t\tthis._cosine.dispose();\n\t\tthis._cosineMultiply.dispose();\n\t\tthis._negate.dispose();\n\t\tthis._phaseShifter.dispose();\n\t\tthis._sine.dispose();\n\t\tthis._sineMultiply.dispose();\n\t\treturn this;\n\t}\n}\n","import { StereoEffect, StereoEffectOptions } from \"./StereoEffect\";\nimport { Frequency, NormalRange } from \"../core/type/Units\";\nimport { optionsFromArguments } from \"../core/util/Defaults\";\nimport { readOnly } from \"../core/util/Interface\";\nimport { Signal } from \"../signal/Signal\";\nimport { LowpassCombFilter } from \"../component/filter/LowpassCombFilter\";\n\nexport interface FreeverbOptions extends StereoEffectOptions {\n\tdampening: Frequency;\n\troomSize: NormalRange;\n}\n\n/**\n * An array of comb filter delay values from Freeverb implementation\n */\nconst combFilterTunings = [1557 / 44100, 1617 / 44100, 1491 / 44100, 1422 / 44100, 1277 / 44100, 1356 / 44100, 1188 / 44100, 1116 / 44100];\n\n/**\n * An array of allpass filter frequency values from Freeverb implementation\n */\nconst allpassFilterFrequencies = [225, 556, 441, 341];\n\n/**\n * Freeverb is a reverb based on [Freeverb](https://ccrma.stanford.edu/~jos/pasp/Freeverb.html).\n * Read more on reverb on [Sound On Sound](https://web.archive.org/web/20160404083902/http://www.soundonsound.com:80/sos/feb01/articles/synthsecrets.asp).\n * Freeverb is now implemented with an AudioWorkletNode which may result on performance degradation on some platforms. Consider using [[Reverb]].\n * @example\n * const freeverb = new Tone.Freeverb().toDestination();\n * freeverb.dampening = 1000;\n * // routing synth through the reverb\n * const synth = new Tone.NoiseSynth().connect(freeverb);\n * synth.triggerAttackRelease(0.05);\n * @category Effect\n */\nexport class Freeverb extends StereoEffect<FreeverbOptions> {\n\n\treadonly name: string = \"Freeverb\";\n\n\t/**\n\t * The roomSize value between 0 and 1. A larger roomSize will result in a longer decay.\n\t */\n\treadonly roomSize: Signal<\"normalRange\">;\n\n\t/**\n\t * the comb filters\n\t */\n\tprivate _combFilters: LowpassCombFilter[] = [];\n\n\t/**\n\t * the allpass filters on the left\n\t */\n\tprivate _allpassFiltersL: BiquadFilterNode[] = [];\n\n\t/**\n\t * the allpass filters on the right\n\t */\n\tprivate _allpassFiltersR: BiquadFilterNode[] = [];\n\n\t/**\n\t * @param roomSize Correlated to the decay time.\n\t * @param dampening The cutoff frequency of a lowpass filter as part of the reverb.\n\t */\n\tconstructor(roomSize?: NormalRange, dampening?: Frequency);\n\tconstructor(options?: Partial<FreeverbOptions>);\n\tconstructor() {\n\n\t\tsuper(optionsFromArguments(Freeverb.getDefaults(), arguments, [\"roomSize\", \"dampening\"]));\n\t\tconst options = optionsFromArguments(Freeverb.getDefaults(), arguments, [\"roomSize\", \"dampening\"]);\n\n\t\tthis.roomSize = new Signal({\n\t\t\tcontext: this.context,\n\t\t\tvalue: options.roomSize,\n\t\t\tunits: \"normalRange\",\n\t\t});\n\n\t\t// make the allpass filters on the right\n\t\tthis._allpassFiltersL = allpassFilterFrequencies.map(freq => {\n\t\t\tconst allpassL = this.context.createBiquadFilter();\n\t\t\tallpassL.type = \"allpass\";\n\t\t\tallpassL.frequency.value = freq;\n\t\t\treturn allpassL;\n\t\t});\n\n\t\t// make the allpass filters on the left\n\t\tthis._allpassFiltersR = allpassFilterFrequencies.map(freq => {\n\t\t\tconst allpassR = this.context.createBiquadFilter();\n\t\t\tallpassR.type = \"allpass\";\n\t\t\tallpassR.frequency.value = freq;\n\t\t\treturn allpassR;\n\t\t});\n\n\t\t// make the comb filters\n\t\tthis._combFilters = combFilterTunings.map((delayTime, index) => {\n\t\t\tconst lfpf = new LowpassCombFilter({\n\t\t\t\tcontext: this.context,\n\t\t\t\tdampening: options.dampening,\n\t\t\t\tdelayTime,\n\t\t\t});\n\t\t\tif (index < combFilterTunings.length / 2) {\n\t\t\t\tthis.connectEffectLeft(lfpf, ...this._allpassFiltersL);\n\t\t\t} else {\n\t\t\t\tthis.connectEffectRight(lfpf, ...this._allpassFiltersR);\n\t\t\t}\n\t\t\tthis.roomSize.connect(lfpf.resonance);\n\t\t\treturn lfpf;\n\t\t});\n\n\t\treadOnly(this, [\"roomSize\"]);\n\t}\n\n\tstatic getDefaults(): FreeverbOptions {\n\t\treturn Object.assign(StereoEffect.getDefaults(), {\n\t\t\troomSize: 0.7,\n\t\t\tdampening: 3000\n\t\t});\n\t}\n\n\t/**\n\t * The amount of dampening of the reverberant signal.\n\t */\n\n\tget dampening(): Frequency {\n\t\treturn this._combFilters[0].dampening;\n\t}\n\tset dampening(d) {\n\t\tthis._combFilters.forEach(c => c.dampening = d);\n\t}\n\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis._allpassFiltersL.forEach(al => al.disconnect());\n\t\tthis._allpassFiltersR.forEach(ar => ar.disconnect());\n\t\tthis._combFilters.forEach(cf => cf.dispose());\n\t\tthis.roomSize.dispose();\n\t\treturn this;\n\t}\n}\n","import { NormalRange } from \"../core/type/Units\";\nimport { StereoEffect, StereoEffectOptions } from \"./StereoEffect\";\nimport { optionsFromArguments } from \"../core/util/Defaults\";\nimport { Scale } from \"../signal/Scale\";\nimport { Signal } from \"../signal/Signal\";\nimport { FeedbackCombFilter } from \"../component/filter/FeedbackCombFilter\";\nimport { readOnly } from \"../core/util/Interface\";\n\nexport interface JCReverbOptions extends StereoEffectOptions {\n\troomSize: NormalRange;\n}\n\n/**\n * an array of the comb filter delay time values\n */\nconst combFilterDelayTimes = [1687 / 25000, 1601 / 25000, 2053 / 25000, 2251 / 25000];\n\n/**\n * the resonances of each of the comb filters\n */\nconst combFilterResonances = [0.773, 0.802, 0.753, 0.733];\n\n/**\n * the allpass filter frequencies\n */\nconst allpassFilterFreqs = [347, 113, 37];\n\n/**\n * JCReverb is a simple [Schroeder Reverberator](https://ccrma.stanford.edu/~jos/pasp/Schroeder_Reverberators.html)\n * tuned by John Chowning in 1970.\n * It is made up of three allpass filters and four [[FeedbackCombFilter]].\n * JCReverb is now implemented with an AudioWorkletNode which may result on performance degradation on some platforms. Consider using [[Reverb]].\n * @example\n * const reverb = new Tone.JCReverb(0.4).toDestination();\n * const delay = new Tone.FeedbackDelay(0.5);\n * // connecting the synth to reverb through delay\n * const synth = new Tone.DuoSynth().chain(delay, reverb);\n * synth.triggerAttackRelease(\"A4\", \"8n\");\n * \n * @category Effect\n */\nexport class JCReverb extends StereoEffect<JCReverbOptions> {\n\n\treadonly name: string = \"JCReverb\";\n\n\t/**\n\t * Room size control values. \n\t */\n\treadonly roomSize: Signal<\"normalRange\">\n\n\t/**\n\t * Scale the room size\n\t */\n\tprivate _scaleRoomSize: Scale;\n\n\t/**\n\t * a series of allpass filters\n\t */\n\tprivate _allpassFilters: BiquadFilterNode[] = [];\n\n\t/**\n\t * parallel feedback comb filters\n\t */\n\tprivate _feedbackCombFilters: FeedbackCombFilter[] = [];\n\n\t/**\n\t * @param roomSize Correlated to the decay time.\n\t */\n\tconstructor(roomSize?: NormalRange);\n\tconstructor(options?: Partial<JCReverbOptions>);\n\tconstructor() {\n\n\t\tsuper(optionsFromArguments(JCReverb.getDefaults(), arguments, [\"roomSize\"]));\n\t\tconst options = optionsFromArguments(JCReverb.getDefaults(), arguments, [\"roomSize\"]);\n\n\t\tthis.roomSize = new Signal({\n\t\t\tcontext: this.context,\n\t\t\tvalue: options.roomSize,\n\t\t\tunits: \"normalRange\",\n\t\t});\n\t\tthis._scaleRoomSize = new Scale({\n\t\t\tcontext: this.context,\n\t\t\tmin: -0.733,\n\t\t\tmax: 0.197,\n\t\t});\n\n\t\t// make the allpass filters\n\t\tthis._allpassFilters = allpassFilterFreqs.map(freq => {\n\t\t\tconst allpass = this.context.createBiquadFilter();\n\t\t\tallpass.type = \"allpass\";\n\t\t\tallpass.frequency.value = freq;\n\t\t\treturn allpass;\n\t\t});\n\n\t\t// and the comb filters\n\t\tthis._feedbackCombFilters = combFilterDelayTimes.map((delayTime, index) => {\n\t\t\tconst fbcf = new FeedbackCombFilter({\n\t\t\t\tcontext: this.context,\n\t\t\t\tdelayTime,\n\t\t\t});\n\t\t\tthis._scaleRoomSize.connect(fbcf.resonance);\n\t\t\tfbcf.resonance.value = combFilterResonances[index];\n\t\t\tif (index < combFilterDelayTimes.length / 2) {\n\t\t\t\tthis.connectEffectLeft(...this._allpassFilters, fbcf);\n\t\t\t} else {\n\t\t\t\tthis.connectEffectRight(...this._allpassFilters, fbcf);\n\t\t\t}\n\t\t\treturn fbcf;\n\t\t});\n\n\t\t// chain the allpass filters together\n\t\tthis.roomSize.connect(this._scaleRoomSize);\n\t\treadOnly(this, [\"roomSize\"]);\n\t}\n\n\tstatic getDefaults(): JCReverbOptions {\n\t\treturn Object.assign(StereoEffect.getDefaults(), {\n\t\t\troomSize: 0.5,\n\t\t});\n\t}\n\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis._allpassFilters.forEach(apf => apf.disconnect());\n\t\tthis._feedbackCombFilters.forEach(fbcf => fbcf.dispose());\n\t\tthis.roomSize.dispose();\n\t\tthis._scaleRoomSize.dispose();\n\t\treturn this;\n\t}\n}\n","import { StereoFeedbackEffect, StereoFeedbackEffectOptions } from \"./StereoFeedbackEffect\";\nimport { NormalRange } from \"../core/type/Units\";\nimport { readOnly } from \"../core/util/Interface\";\n\nexport interface StereoXFeedbackEffectOptions extends StereoFeedbackEffectOptions {\n\tfeedback: NormalRange;\n}\n\n/**\n * Just like a [[StereoFeedbackEffect]], but the feedback is routed from left to right\n * and right to left instead of on the same channel.\n * ```\n * +--------------------------------+ feedbackL <-----------------------------------+\n * |                                                                                |\n * +-->                          +----->        +---->                          +-----+\n *      feedbackMerge +--> split        (EFFECT)       merge +--> feedbackSplit     | |\n * +-->                          +----->        +---->                          +---+ |\n * |                                                                                  |\n * +--------------------------------+ feedbackR <-------------------------------------+\n * ```\n */\nexport class StereoXFeedbackEffect<Options extends StereoXFeedbackEffectOptions> extends StereoFeedbackEffect<Options> {\n\t\n\tconstructor(options: StereoXFeedbackEffectOptions) {\n\n\t\tsuper(options);\n\t\t// the left output connected to the right input\n\t\tthis._feedbackL.disconnect();\n\t\tthis._feedbackL.connect(this._feedbackMerge, 0, 1);\n\n\t\t// the left output connected to the right input\n\t\tthis._feedbackR.disconnect();\n\t\tthis._feedbackR.connect(this._feedbackMerge, 0, 0);\n\t\t\n\t\treadOnly(this, [\"feedback\"]);\n\t}\n}\n","import { StereoXFeedbackEffect, StereoXFeedbackEffectOptions } from \"./StereoXFeedbackEffect\";\nimport { NormalRange, Seconds, Time } from \"../core/type/Units\";\nimport { optionsFromArguments } from \"../core/util/Defaults\";\nimport { Delay } from \"../core/context/Delay\";\nimport { Signal } from \"../signal/Signal\";\nimport { readOnly } from \"../core/util/Interface\";\n\nexport interface PingPongDelayOptions extends StereoXFeedbackEffectOptions {\n\tdelayTime: Time;\n\tmaxDelay: Seconds;\n}\n\n/**\n * PingPongDelay is a feedback delay effect where the echo is heard\n * first in one channel and next in the opposite channel. In a stereo\n * system these are the right and left channels.\n * PingPongDelay in more simplified terms is two Tone.FeedbackDelays\n * with independent delay values. Each delay is routed to one channel\n * (left or right), and the channel triggered second will always\n * trigger at the same interval after the first.\n * @example\n * const pingPong = new Tone.PingPongDelay(\"4n\", 0.2).toDestination();\n * const drum = new Tone.MembraneSynth().connect(pingPong);\n * drum.triggerAttackRelease(\"C4\", \"32n\");\n * @category Effect\n */\nexport class PingPongDelay extends StereoXFeedbackEffect<PingPongDelayOptions> {\n\n\treadonly name: string = \"PingPongDelay\";\n\n\t/**\n\t * the delay node on the left side\n\t */\n\tprivate _leftDelay: Delay;\n\n\t/**\n\t * the delay node on the right side\n\t */\n\tprivate _rightDelay: Delay;\n\n\t/**\n\t * the predelay on the right side\n\t */\n\tprivate _rightPreDelay: Delay;\n\n\t/**\n\t * the delay time signal\n\t */\n\treadonly delayTime: Signal<\"time\">;\n\n\t/**\n\t * @param delayTime The delayTime between consecutive echos.\n\t * @param feedback The amount of the effected signal which is fed back through the delay.\n\t */\n\tconstructor(delayTime?: Time, feedback?: NormalRange);\n\tconstructor(options?: Partial<PingPongDelayOptions>);\n\tconstructor() {\n\n\t\tsuper(optionsFromArguments(PingPongDelay.getDefaults(), arguments, [\"delayTime\", \"feedback\"]));\n\t\tconst options = optionsFromArguments(PingPongDelay.getDefaults(), arguments, [\"delayTime\", \"feedback\"]);\n\n\t\tthis._leftDelay = new Delay({\n\t\t\tcontext: this.context,\n\t\t\tmaxDelay: options.maxDelay,\n\t\t});\n\t\tthis._rightDelay = new Delay({\n\t\t\tcontext: this.context,\n\t\t\tmaxDelay: options.maxDelay\n\t\t});\n\t\tthis._rightPreDelay = new Delay({\n\t\t\tcontext: this.context,\n\t\t\tmaxDelay: options.maxDelay\n\t\t});\n\t\tthis.delayTime = new Signal({\n\t\t\tcontext: this.context,\n\t\t\tunits: \"time\",\n\t\t\tvalue: options.delayTime,\n\t\t});\n\n\t\t// connect it up\n\t\tthis.connectEffectLeft(this._leftDelay);\n\t\tthis.connectEffectRight(this._rightPreDelay, this._rightDelay);\n\t\tthis.delayTime.fan(this._leftDelay.delayTime, this._rightDelay.delayTime, this._rightPreDelay.delayTime);\n\t\t// rearranged the feedback to be after the rightPreDelay\n\t\tthis._feedbackL.disconnect();\n\t\tthis._feedbackL.connect(this._rightDelay);\n\t\treadOnly(this, [\"delayTime\"]);\n\t}\n\n\tstatic getDefaults(): PingPongDelayOptions {\n\t\treturn Object.assign(StereoXFeedbackEffect.getDefaults(), {\n\t\t\tdelayTime: 0.25,\n\t\t\tmaxDelay: 1\n\t\t});\n\t}\n\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis._leftDelay.dispose();\n\t\tthis._rightDelay.dispose();\n\t\tthis._rightPreDelay.dispose();\n\t\tthis.delayTime.dispose();\n\t\treturn this;\n\t}\n}\n","import { Interval, Seconds, Time } from \"../core/type/Units\";\nimport { FeedbackEffect, FeedbackEffectOptions } from \"./FeedbackEffect\";\nimport { optionsFromArguments } from \"../core/util/Defaults\";\nimport { LFO } from \"../source/oscillator/LFO\";\nimport { Delay } from \"../core/context/Delay\";\nimport { CrossFade } from \"../component/channel/CrossFade\";\nimport { Signal } from \"../signal/Signal\";\nimport { readOnly } from \"../core/util/Interface\";\nimport { Param } from \"../core/context/Param\";\nimport { intervalToFrequencyRatio } from \"../core/type/Conversions\";\n\nexport interface PitchShiftOptions extends FeedbackEffectOptions {\n\tpitch: Interval;\n\twindowSize: Seconds;\n\tdelayTime: Time;\n}\n\n/**\n * PitchShift does near-realtime pitch shifting to the incoming signal.\n * The effect is achieved by speeding up or slowing down the delayTime\n * of a DelayNode using a sawtooth wave.\n * Algorithm found in [this pdf](http://dsp-book.narod.ru/soundproc.pdf).\n * Additional reference by [Miller Pucket](http://msp.ucsd.edu/techniques/v0.11/book-html/node115.html).\n * @category Effect\n */\nexport class PitchShift extends FeedbackEffect<PitchShiftOptions> {\n\n\treadonly name: string = \"PitchShift\";\n\n\t/**\n\t * The pitch signal\n\t */\n\tprivate _frequency: Signal<\"frequency\">;\n\n\t/**\n\t * Uses two DelayNodes to cover up the jump in the sawtooth wave.\n\t */\n\tprivate _delayA: Delay;\n\n\t/**\n\t * The first LFO.\n\t */\n\tprivate _lfoA: LFO;\n\n\t/**\n\t * The second DelayNode\n\t */\n\tprivate _delayB: Delay;\n\n\t/**\n\t * The second LFO.\n\t */\n\tprivate _lfoB: LFO;\n\n\t/**\n\t * Cross fade quickly between the two delay lines to cover up the jump in the sawtooth wave\n\t */\n\tprivate _crossFade: CrossFade;\n\n\t/**\n\t * LFO which alternates between the two delay lines to cover up the disparity in the\n\t * sawtooth wave.\n\t */\n\tprivate _crossFadeLFO: LFO;\n\n\t/**\n\t * The delay node\n\t */\n\tprivate _feedbackDelay: Delay;\n\n\t/**\n\t * The amount of delay on the input signal\n\t */\n\treadonly delayTime: Param<\"time\">;\n\n\t/**\n\t * Hold the current pitch\n\t */\n\tprivate _pitch: Interval;\n\n\t/**\n\t * Hold the current windowSize\n\t */\n\tprivate _windowSize;\n\n\t/**\n\t * @param pitch The interval to transpose the incoming signal by.\n\t */\n\tconstructor(pitch?: Interval);\n\tconstructor(options?: Partial<PitchShiftOptions>);\n\tconstructor() {\n\n\t\tsuper(optionsFromArguments(PitchShift.getDefaults(), arguments, [\"pitch\"]));\n\t\tconst options = optionsFromArguments(PitchShift.getDefaults(), arguments, [\"pitch\"]);\n\n\t\tthis._frequency = new Signal({ context: this.context });\n\t\tthis._delayA = new Delay({\n\t\t\tmaxDelay: 1,\n\t\t\tcontext: this.context\n\t\t});\n\t\tthis._lfoA = new LFO({\n\t\t\tcontext: this.context,\n\t\t\tmin: 0,\n\t\t\tmax: 0.1,\n\t\t\ttype: \"sawtooth\"\n\t\t}).connect(this._delayA.delayTime);\n\t\tthis._delayB = new Delay({\n\t\t\tmaxDelay: 1,\n\t\t\tcontext: this.context\n\t\t});\n\t\tthis._lfoB = new LFO({\n\t\t\tcontext: this.context,\n\t\t\tmin: 0,\n\t\t\tmax: 0.1,\n\t\t\ttype: \"sawtooth\",\n\t\t\tphase: 180\n\t\t}).connect(this._delayB.delayTime);\n\t\tthis._crossFade = new CrossFade({ context: this.context });\n\t\tthis._crossFadeLFO = new LFO({\n\t\t\tcontext: this.context,\n\t\t\tmin: 0,\n\t\t\tmax: 1,\n\t\t\ttype: \"triangle\",\n\t\t\tphase: 90\n\t\t}).connect(this._crossFade.fade);\n\t\tthis._feedbackDelay = new Delay({\n\t\t\tdelayTime: options.delayTime,\n\t\t\tcontext: this.context,\n\t\t});\n\t\tthis.delayTime = this._feedbackDelay.delayTime;\n\t\treadOnly(this, \"delayTime\");\n\t\tthis._pitch = options.pitch;\n\n\t\tthis._windowSize = options.windowSize;\n\n\t\t// connect the two delay lines up\n\t\tthis._delayA.connect(this._crossFade.a);\n\t\tthis._delayB.connect(this._crossFade.b);\n\t\t// connect the frequency\n\t\tthis._frequency.fan(this._lfoA.frequency, this._lfoB.frequency, this._crossFadeLFO.frequency);\n\t\t// route the input\n\t\tthis.effectSend.fan(this._delayA, this._delayB);\n\t\tthis._crossFade.chain(this._feedbackDelay, this.effectReturn);\n\t\t// start the LFOs at the same time\n\t\tconst now = this.now();\n\t\tthis._lfoA.start(now);\n\t\tthis._lfoB.start(now);\n\t\tthis._crossFadeLFO.start(now);\n\t\t// set the initial value\n\t\tthis.windowSize = this._windowSize;\n\t}\n\n\tstatic getDefaults(): PitchShiftOptions {\n\t\treturn Object.assign(FeedbackEffect.getDefaults(), {\n\t\t\tpitch: 0,\n\t\t\twindowSize: 0.1,\n\t\t\tdelayTime: 0,\n\t\t\tfeedback: 0\n\t\t});\n\t}\n\n\t/**\n\t * Repitch the incoming signal by some interval (measured in semi-tones).\n\t * @example\n\t * const pitchShift = new Tone.PitchShift().toDestination();\n\t * const osc = new Tone.Oscillator().connect(pitchShift).start().toDestination();\n\t * pitchShift.pitch = -12; // down one octave\n\t * pitchShift.pitch = 7; // up a fifth\n\t */\n\tget pitch() {\n\t\treturn this._pitch;\n\t}\n\tset pitch(interval) {\n\t\tthis._pitch = interval;\n\t\tlet factor = 0;\n\t\tif (interval < 0) {\n\t\t\tthis._lfoA.min = 0;\n\t\t\tthis._lfoA.max = this._windowSize;\n\t\t\tthis._lfoB.min = 0;\n\t\t\tthis._lfoB.max = this._windowSize;\n\t\t\tfactor = intervalToFrequencyRatio(interval - 1) + 1;\n\t\t} else {\n\t\t\tthis._lfoA.min = this._windowSize;\n\t\t\tthis._lfoA.max = 0;\n\t\t\tthis._lfoB.min = this._windowSize;\n\t\t\tthis._lfoB.max = 0;\n\t\t\tfactor = intervalToFrequencyRatio(interval) - 1;\n\t\t}\n\t\tthis._frequency.value = factor * (1.2 / this._windowSize);\n\t}\n\n\t/**\n\t * The window size corresponds roughly to the sample length in a looping sampler.\n\t * Smaller values are desirable for a less noticeable delay time of the pitch shifted\n\t * signal, but larger values will result in smoother pitch shifting for larger intervals.\n\t * A nominal range of 0.03 to 0.1 is recommended.\n\t */\n\tget windowSize(): Seconds {\n\t\treturn this._windowSize;\n\t}\n\tset windowSize(size) {\n\t\tthis._windowSize = this.toSeconds(size);\n\t\tthis.pitch = this._pitch;\n\t}\n\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis._frequency.dispose();\n\t\tthis._delayA.dispose();\n\t\tthis._delayB.dispose();\n\t\tthis._lfoA.dispose();\n\t\tthis._lfoB.dispose();\n\t\tthis._crossFade.dispose();\n\t\tthis._crossFadeLFO.dispose();\n\t\tthis._feedbackDelay.dispose();\n\t\treturn this;\n\t}\n}\n","import { StereoEffect, StereoEffectOptions } from \"./StereoEffect\";\nimport { Frequency, Hertz, Positive } from \"../core/type/Units\";\nimport { optionsFromArguments } from \"../core/util/Defaults\";\nimport { LFO } from \"../source/oscillator/LFO\";\nimport { Signal } from \"../signal/Signal\";\nimport { readOnly } from \"../core/util/Interface\";\n\nexport interface PhaserOptions extends StereoEffectOptions {\n\tfrequency: Frequency;\n\toctaves: Positive;\n\tstages: Positive;\n\tQ: Positive;\n\tbaseFrequency: Frequency;\n}\n\n/**\n * Phaser is a phaser effect. Phasers work by changing the phase\n * of different frequency components of an incoming signal. Read more on\n * [Wikipedia](https://en.wikipedia.org/wiki/Phaser_(effect)).\n * Inspiration for this phaser comes from [Tuna.js](https://github.com/Dinahmoe/tuna/).\n * @example\n * const phaser = new Tone.Phaser({\n * \tfrequency: 15,\n * \toctaves: 5,\n * \tbaseFrequency: 1000\n * }).toDestination();\n * const synth = new Tone.FMSynth().connect(phaser);\n * synth.triggerAttackRelease(\"E3\", \"2n\");\n * @category Effect\n */\nexport class Phaser extends StereoEffect<PhaserOptions> {\n\n\treadonly name: string = \"Phaser\";\n\n\t/**\n\t * the lfo which controls the frequency on the left side\n\t */\n\tprivate _lfoL: LFO;\n\n\t/**\n\t * the lfo which controls the frequency on the right side\n\t */\n\tprivate _lfoR: LFO;\n\n\t/**\n\t * the base modulation frequency\n\t */\n\tprivate _baseFrequency: Hertz;\n\n\t/**\n\t * the octaves of the phasing\n\t */\n\tprivate _octaves: Positive;\n\n\t/**\n\t * The quality factor of the filters\n\t */\n\treadonly Q: Signal<\"positive\">;\n\n\t/**\n\t * the array of filters for the left side\n\t */\n\tprivate _filtersL: BiquadFilterNode[];\n\n\t/**\n\t * the array of filters for the left side\n\t */\n\tprivate _filtersR: BiquadFilterNode[];\n\n\t/**\n\t * the frequency of the effect\n\t */\n\treadonly frequency: Signal<\"frequency\">;\n\n\t/**\n\t * @param frequency The speed of the phasing.\n\t * @param octaves The octaves of the effect.\n\t * @param baseFrequency The base frequency of the filters.\n\t */\n\tconstructor(frequency?: Frequency, octaves?: Positive, baseFrequency?: Frequency);\n\tconstructor(options?: Partial<PhaserOptions>);\n\tconstructor() {\n\n\t\tsuper(optionsFromArguments(Phaser.getDefaults(), arguments, [\"frequency\", \"octaves\", \"baseFrequency\"]));\n\t\tconst options = optionsFromArguments(Phaser.getDefaults(), arguments, [\"frequency\", \"octaves\", \"baseFrequency\"]);\n\n\t\tthis._lfoL = new LFO({\n\t\t\tcontext: this.context,\n\t\t\tfrequency: options.frequency,\n\t\t\tmin: 0,\n\t\t\tmax: 1\n\t\t});\n\t\tthis._lfoR = new LFO({\n\t\t\tcontext: this.context,\n\t\t\tfrequency: options.frequency,\n\t\t\tmin: 0,\n\t\t\tmax: 1,\n\t\t\tphase: 180,\n\t\t});\n\t\tthis._baseFrequency = this.toFrequency(options.baseFrequency);\n\t\tthis._octaves = options.octaves;\n\t\tthis.Q = new Signal({\n\t\t\tcontext: this.context,\n\t\t\tvalue: options.Q,\n\t\t\tunits: \"positive\",\n\t\t});\n\t\tthis._filtersL = this._makeFilters(options.stages, this._lfoL);\n\t\tthis._filtersR = this._makeFilters(options.stages, this._lfoR);\n\n\t\tthis.frequency = this._lfoL.frequency;\n\t\tthis.frequency.value = options.frequency;\n\n\t\t// connect them up\n\t\tthis.connectEffectLeft(...this._filtersL);\n\t\tthis.connectEffectRight(...this._filtersR);\n\t\t// control the frequency with one LFO\n\t\tthis._lfoL.frequency.connect(this._lfoR.frequency);\n\t\t// set the options\n\t\tthis.baseFrequency = options.baseFrequency;\n\t\tthis.octaves = options.octaves;\n\t\t// start the lfo\n\t\tthis._lfoL.start();\n\t\tthis._lfoR.start();\n\t\treadOnly(this, [\"frequency\", \"Q\"]);\n\t}\n\n\tstatic getDefaults(): PhaserOptions {\n\t\treturn Object.assign(StereoEffect.getDefaults(), {\n\t\t\tfrequency: 0.5,\n\t\t\toctaves: 3,\n\t\t\tstages: 10,\n\t\t\tQ: 10,\n\t\t\tbaseFrequency: 350,\n\t\t});\n\t}\n\n\tprivate _makeFilters(stages: number, connectToFreq: LFO): BiquadFilterNode[] {\n\t\tconst filters: BiquadFilterNode[] = [];\n\t\t// make all the filters\n\t\tfor (let i = 0; i < stages; i++) {\n\t\t\tconst filter = this.context.createBiquadFilter();\n\t\t\tfilter.type = \"allpass\";\n\t\t\tthis.Q.connect(filter.Q);\n\t\t\tconnectToFreq.connect(filter.frequency);\n\t\t\tfilters.push(filter);\n\t\t}\n\t\treturn filters;\n\t}\n\n\t/**\n\t * The number of octaves the phase goes above the baseFrequency\n\t */\n\tget octaves() {\n\t\treturn this._octaves;\n\t}\n\tset octaves(octaves) {\n\t\tthis._octaves = octaves;\n\t\tconst max = this._baseFrequency * Math.pow(2, octaves);\n\t\tthis._lfoL.max = max;\n\t\tthis._lfoR.max = max;\n\t}\n\n\t/**\n\t * The the base frequency of the filters.\n\t */\n\tget baseFrequency(): Frequency {\n\t\treturn this._baseFrequency;\n\t}\n\tset baseFrequency(freq) {\n\t\tthis._baseFrequency = this.toFrequency(freq);\n\t\tthis._lfoL.min = this._baseFrequency;\n\t\tthis._lfoR.min = this._baseFrequency;\n\t\tthis.octaves = this._octaves;\n\t}\n\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis.Q.dispose();\n\t\tthis._lfoL.dispose();\n\t\tthis._lfoR.dispose();\n\t\tthis._filtersL.forEach(f => f.disconnect());\n\t\tthis._filtersR.forEach(f => f.disconnect());\n\t\tthis.frequency.dispose();\n\t\treturn this;\n\t}\n}\n\n","import { Merge } from \"../component/channel/Merge\";\nimport { Gain } from \"../core/context/Gain\";\nimport { Seconds, Time } from \"../core/type/Units\";\nimport { optionsFromArguments } from \"../core/util/Defaults\";\nimport { Noise } from \"../source/Noise\";\nimport { Effect, EffectOptions } from \"./Effect\";\nimport { OfflineContext } from \"../core/context/OfflineContext\";\nimport { noOp } from \"../core/util/Interface\";\nimport { assertRange } from \"../core/util/Debug\";\n\ninterface ReverbOptions extends EffectOptions {\n\tdecay: Seconds;\n\tpreDelay: Seconds;\n}\n\n/**\n * Simple convolution created with decaying noise.\n * Generates an Impulse Response Buffer\n * with Tone.Offline then feeds the IR into ConvolverNode.\n * The impulse response generation is async, so you have\n * to wait until [[ready]] resolves before it will make a sound. \n *\n * Inspiration from [ReverbGen](https://github.com/adelespinasse/reverbGen).\n * Copyright (c) 2014 Alan deLespinasse Apache 2.0 License.\n * \n * @category Effect\n */\nexport class Reverb extends Effect<ReverbOptions> {\n\n\treadonly name: string = \"Reverb\";\n\n\t/**\n\t * Convolver node\n\t */\n\tprivate _convolver: ConvolverNode = this.context.createConvolver();\n\n\t/**\n\t * The duration of the reverb.\n\t */\n\tprivate _decay: Seconds;\n\t\n\t/**\n\t * The amount of time before the reverb is fully ramped in.\n\t */\n\tprivate _preDelay: Seconds;\n\n\t/**\n\t * Resolves when the reverb buffer is generated. Whenever either [[decay]]\n\t * or [[preDelay]] are set, you have to wait until [[ready]] resolves\n\t * before the IR is generated with the latest values. \n\t */\n\tready: Promise<void> = Promise.resolve();\n\n\t/**\n\t * @param decay The amount of time it will reverberate for.\n\t */\n\tconstructor(decay?: Seconds);\n\tconstructor(options?: Partial<ReverbOptions>);\n\tconstructor() {\n\n\t\tsuper(optionsFromArguments(Reverb.getDefaults(), arguments, [\"decay\"]));\n\t\tconst options = optionsFromArguments(Reverb.getDefaults(), arguments, [\"decay\"]);\n\n\t\tthis._decay = options.decay;\n\t\tthis._preDelay = options.preDelay;\n\t\tthis.generate();\n\n\t\tthis.connectEffect(this._convolver);\n\t}\n\n\tstatic getDefaults(): ReverbOptions {\n\t\treturn Object.assign(Effect.getDefaults(), {\n\t\t\tdecay: 1.5,\n\t\t\tpreDelay: 0.01,\n\t\t});\n\t}\n\n\t/**\n\t * The duration of the reverb.\n\t */\n\tget decay(): Time {\n\t\treturn this._decay;\n\t}\n\tset decay(time) {\n\t\ttime = this.toSeconds(time);\n\t\tassertRange(time, 0.001);\n\t\tthis._decay = time;\n\t\tthis.generate();\n\t}\n\n\t/**\n\t * The amount of time before the reverb is fully ramped in.\n\t */\n\tget preDelay(): Time {\n\t\treturn this._preDelay;\n\t}\n\tset preDelay(time) {\n\t\ttime = this.toSeconds(time);\n\t\tassertRange(time, 0);\n\t\tthis._preDelay = time;\n\t\tthis.generate();\n\t}\n\n\t/**\n\t * Generate the Impulse Response. Returns a promise while the IR is being generated.\n\t * @return Promise which returns this object.\n\t */\n\tasync generate(): Promise<this> {\n\t\tconst previousReady = this.ready;\n\n\t\t// create a noise burst which decays over the duration in each channel\n\t\tconst context = new OfflineContext(2, this._decay + this._preDelay, this.context.sampleRate);\n\t\tconst noiseL = new Noise({ context });\n\t\tconst noiseR = new Noise({ context });\n\t\tconst merge = new Merge({ context });\n\t\tnoiseL.connect(merge, 0, 0);\n\t\tnoiseR.connect(merge, 0, 1);\n\t\tconst gainNode = new Gain({ context }).toDestination();\n\t\tmerge.connect(gainNode);\n\t\tnoiseL.start(0);\n\t\tnoiseR.start(0);\n\t\t// predelay\n\t\tgainNode.gain.setValueAtTime(0, 0);\n\t\tgainNode.gain.setValueAtTime(1, this._preDelay);\n\t\t// decay\n\t\tgainNode.gain.exponentialApproachValueAtTime(0, this._preDelay, this.decay);\n\t\t\n\t\t// render the buffer\n\t\tconst renderPromise = context.render();\n\t\tthis.ready = renderPromise.then(noOp);\n\t\t\n\t\t// wait for the previous `ready` to resolve\n\t\tawait previousReady;\n\t\t// set the buffer\n\t\tthis._convolver.buffer = (await renderPromise).get() as AudioBuffer;\n\n\t\treturn this;\n\t}\n\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis._convolver.disconnect();\n\t\treturn this;\n\t}\n}\n","import { ToneAudioNode, ToneAudioNodeOptions } from \"../../core/context/ToneAudioNode\";\nimport { Split } from \"./Split\";\nimport { Add } from \"../../signal/Add\";\nimport { Multiply } from \"../../signal/Multiply\";\nimport { Subtract } from \"../../signal/Subtract\";\nimport { optionsFromArguments } from \"../../core/util/Defaults\";\n\nexport type MidSideSplitOptions = ToneAudioNodeOptions;\n\n/**\n * Mid/Side processing separates the the 'mid' signal (which comes out of both the left and the right channel)\n * and the 'side' (which only comes out of the the side channels).\n * ```\n * Mid = (Left+Right)/sqrt(2);   // obtain mid-signal from left and right\n * Side = (Left-Right)/sqrt(2);   // obtain side-signal from left and right\n * ```\n * @category Component\n */\nexport class MidSideSplit extends ToneAudioNode<MidSideSplitOptions> {\n\t\n\treadonly name: string = \"MidSideSplit\";\n\n\treadonly input: Split;\n\n\t/**\n\t * There is no output node, use either [[mid]] or [[side]] outputs.\n\t */\n\treadonly output: undefined;\n\t/**\n\t * Split the incoming signal into left and right channels\n\t */\n\tprivate _split: Split;\n\n\t/**\n\t * Sums the left and right channels\n\t */\n\tprivate _midAdd: Add;\n\n\t/**\n\t * Subtract left and right channels. \n\t */\n\tprivate _sideSubtract: Subtract;\n\n\t/**\n\t * The \"mid\" output. `(Left+Right)/sqrt(2)`\n\t */\n\treadonly mid: ToneAudioNode;\n\n\t/**\n\t * The \"side\" output. `(Left-Right)/sqrt(2)`\n\t */\n\treadonly side: ToneAudioNode;\n\t\n\tconstructor(options?: Partial<MidSideSplitOptions>);\n\tconstructor() {\n\t\tsuper(optionsFromArguments(MidSideSplit.getDefaults(), arguments));\n\n\t\tthis._split = this.input = new Split({\n\t\t\tchannels: 2,\n\t\t\tcontext: this.context\n\t\t});\n\t\tthis._midAdd = new Add({ context: this.context });\n\t\tthis.mid = new Multiply({\n\t\t\tcontext: this.context,\n\t\t\tvalue: Math.SQRT1_2,\n\t\t});\n\t\tthis._sideSubtract = new Subtract({ context: this.context });\n\t\tthis.side = new Multiply({\n\t\t\tcontext: this.context,\n\t\t\tvalue: Math.SQRT1_2,\n\t\t});\n\n\t\tthis._split.connect(this._midAdd, 0);\n\t\tthis._split.connect(this._midAdd.addend, 1);\n\t\tthis._split.connect(this._sideSubtract, 0);\n\t\tthis._split.connect(this._sideSubtract.subtrahend, 1);\n\t\tthis._midAdd.connect(this.mid);\n\t\tthis._sideSubtract.connect(this.side);\n\t}\n\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis.mid.dispose();\n\t\tthis.side.dispose();\n\t\tthis._midAdd.dispose();\n\t\tthis._sideSubtract.dispose();\n\t\tthis._split.dispose();\n\t\treturn this;\n\t}\n}\n","import { ToneAudioNode, ToneAudioNodeOptions } from \"../../core/context/ToneAudioNode\";\nimport { Merge } from \"./Merge\";\nimport { Add } from \"../../signal/Add\";\nimport { Multiply } from \"../../signal/Multiply\";\nimport { Subtract } from \"../../signal/Subtract\";\nimport { Gain } from \"../../core/context/Gain\";\nimport { optionsFromArguments } from \"../../core/util/Defaults\";\n\nexport type MidSideMergeOptions = ToneAudioNodeOptions;\n\n/**\n * MidSideMerge merges the mid and side signal after they've been separated by [[MidSideSplit]]\n * ```\n * Mid = (Left+Right)/sqrt(2);   // obtain mid-signal from left and right\n * Side = (Left-Right)/sqrt(2);   // obtain side-signal from left and right\n * ```\n * @category Component\n */\nexport class MidSideMerge extends ToneAudioNode<MidSideMergeOptions> {\n\t\n\treadonly name: string = \"MidSideMerge\";\n\n\t/**\n\t * There is no input, connect sources to either [[mid]] or [[side]] inputs.\n\t */\n\treadonly input: undefined;\n\n\t/**\n\t * The merged signal\n\t */\n\treadonly output: Merge;\n\n\t/**\n\t * Merge the incoming signal into left and right channels\n\t */\n\tprivate _merge: Merge;\n\n\t/**\n\t * The \"mid\" input.\n\t */\n\treadonly mid: ToneAudioNode;\n\n\t/**\n\t * The \"side\" input.\n\t */\n\treadonly side: ToneAudioNode;\n\n\t/**\n\t * Recombine the mid/side into Left\n\t */\n\tprivate _left: Add;\n\n\t/**\n\t * Recombine the mid/side into Right\n\t */\n\tprivate _right: Subtract;\n\n\t/**\n\t * Multiply the right by sqrt(1/2)\n\t */\n\tprivate _leftMult: Multiply;\n\n\t/**\n\t * Multiply the left by sqrt(1/2)\n\t */\n\tprivate _rightMult: Multiply;\n\t\n\tconstructor(options?: Partial<MidSideMergeOptions>);\n\tconstructor() {\n\t\tsuper(optionsFromArguments(MidSideMerge.getDefaults(), arguments));\n\t\tthis.mid = new Gain({ context: this.context });\n\t\tthis.side = new Gain({ context: this.context });\n\t\tthis._left = new Add({ context: this.context });\n\t\tthis._leftMult = new Multiply({\n\t\t\tcontext: this.context, \n\t\t\tvalue: Math.SQRT1_2\n\t\t});\n\t\tthis._right = new Subtract({ context: this.context });\n\t\tthis._rightMult = new Multiply({\n\t\t\tcontext: this.context, \n\t\t\tvalue: Math.SQRT1_2\n\t\t});\n\t\tthis._merge = this.output = new Merge({ context: this.context });\n\n\t\tthis.mid.fan(this._left);\n\t\tthis.side.connect(this._left.addend);\n\t\tthis.mid.connect(this._right);\n\t\tthis.side.connect(this._right.subtrahend);\n\t\tthis._left.connect(this._leftMult);\n\t\tthis._right.connect(this._rightMult);\n\t\tthis._leftMult.connect(this._merge, 0, 0);\n\t\tthis._rightMult.connect(this._merge, 0, 1);\n\t}\n\t\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis.mid.dispose();\n\t\tthis.side.dispose();\n\t\tthis._leftMult.dispose();\n\t\tthis._rightMult.dispose();\n\t\tthis._left.dispose();\n\t\tthis._right.dispose();\n\t\treturn this;\n\t}\n}\n","import { Effect, EffectOptions } from \"./Effect\";\nimport { MidSideSplit } from \"../component/channel/MidSideSplit\";\nimport { MidSideMerge } from \"../component/channel/MidSideMerge\";\nimport { OutputNode, ToneAudioNode } from \"../core/context/ToneAudioNode\";\n\nexport type MidSideEffectOptions = EffectOptions;\n\n/**\n * Mid/Side processing separates the the 'mid' signal\n * (which comes out of both the left and the right channel)\n * and the 'side' (which only comes out of the the side channels)\n * and effects them separately before being recombined.\n * Applies a Mid/Side seperation and recombination.\n * Algorithm found in [kvraudio forums](http://www.kvraudio.com/forum/viewtopic.php?t=212587).\n * This is a base-class for Mid/Side Effects.\n * @category Effect\n */\nexport abstract class MidSideEffect<Options extends MidSideEffectOptions> extends Effect<Options> {\n\n\treadonly name: string = \"MidSideEffect\";\n\n\t/**\n\t * The mid/side split\n\t */\n\tprivate _midSideSplit: MidSideSplit;\n\t\n\t/**\n\t * The mid/side merge\n\t */\n\tprivate _midSideMerge: MidSideMerge;\n\t\n\t/**\n\t * The mid send. Connect to mid processing\n\t */\n\tprotected _midSend: ToneAudioNode;\n\t\n\t/**\n\t * The side send. Connect to side processing\n\t */\n\tprotected _sideSend: ToneAudioNode;\n\t\n\t/**\n\t * The mid return connection\n\t */\n\tprotected _midReturn: ToneAudioNode;\n\t\n\t/**\n\t * The side return connection\n\t */\n\tprotected _sideReturn: ToneAudioNode;\n\n\tconstructor(options: MidSideEffectOptions) {\n\n\t\tsuper(options);\n\n\t\tthis._midSideMerge = new MidSideMerge({ context: this.context });\n\t\tthis._midSideSplit = new MidSideSplit({ context: this.context });\n\t\tthis._midSend = this._midSideSplit.mid;\n\t\tthis._sideSend = this._midSideSplit.side;\n\t\tthis._midReturn = this._midSideMerge.mid;\n\t\tthis._sideReturn = this._midSideMerge.side;\n\n\t\t// the connections\n\t\tthis.effectSend.connect(this._midSideSplit);\n\t\tthis._midSideMerge.connect(this.effectReturn);\n\t}\n\n\t/**\n\t * Connect the mid chain of the effect\n\t */\n\tprotected connectEffectMid(...nodes: OutputNode[]): void {\n\t\tthis._midSend.chain(...nodes, this._midReturn);\n\t}\n\t\n\t/**\n\t * Connect the side chain of the effect\n\t */\n\tprotected connectEffectSide(...nodes: OutputNode[]): void {\n\t\tthis._sideSend.chain(...nodes, this._sideReturn);\n\t}\n\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis._midSideSplit.dispose();\n\t\tthis._midSideMerge.dispose();\n\t\tthis._midSend.dispose();\n\t\tthis._sideSend.dispose();\n\t\tthis._midReturn.dispose();\n\t\tthis._sideReturn.dispose();\n\t\treturn this;\n\t}\n}\n\n","import { MidSideEffect, MidSideEffectOptions } from \"../effect/MidSideEffect\";\nimport { Signal } from \"../signal/Signal\";\nimport { Multiply } from \"../signal/Multiply\";\nimport { Subtract } from \"../signal/Subtract\";\nimport { NormalRange } from \"../core/type/Units\";\nimport { optionsFromArguments } from \"../core/util/Defaults\";\nimport { readOnly } from \"../core/util/Interface\";\nimport { connect } from \"../core/context/ToneAudioNode\";\n\nexport interface StereoWidenerOptions extends MidSideEffectOptions {\n\twidth: NormalRange;\n}\n\n/**\n * Applies a width factor to the mid/side seperation.\n * 0 is all mid and 1 is all side.\n * Algorithm found in [kvraudio forums](http://www.kvraudio.com/forum/viewtopic.php?t=212587).\n * ```\n * Mid *= 2*(1-width)<br>\n * Side *= 2*width\n * ```\n * @category Effect\n */\nexport class StereoWidener extends MidSideEffect<StereoWidenerOptions> {\n\n\treadonly name: string = \"StereoWidener\";\n\n\t/**\n\t * The width control. 0 = 100% mid. 1 = 100% side. 0.5 = no change.\n\t */\n\treadonly width: Signal<\"normalRange\">;\n\t\n\t/**\n\t * Two times the (1-width) for the mid channel\n\t */\n\tprivate _twoTimesWidthMid: Multiply;\n\t\n\t/**\n\t * Two times the width for the side channel\n\t */\n\tprivate _twoTimesWidthSide: Multiply;\n\t\n\t/**\n\t * Mid multiplier\n\t */\n\tprivate _midMult: Multiply;\n\t\n\t/**\n\t * 1 - width\n\t */\n\tprivate _oneMinusWidth: Subtract;\n\t\n\t/**\n\t * Side multiplier\n\t */\n\tprivate _sideMult: Multiply;\n\n\t/**\n\t * @param width The stereo width. A width of 0 is mono and 1 is stereo. 0.5 is no change.\n\t */\n\tconstructor(width?: NormalRange);\n\tconstructor(options?: Partial<StereoWidenerOptions>);\n\tconstructor() {\n\n\t\tsuper(optionsFromArguments(StereoWidener.getDefaults(), arguments, [\"width\"]));\n\t\tconst options = optionsFromArguments(StereoWidener.getDefaults(), arguments, [\"width\"]);\n\t\tthis.width = new Signal({\n\t\t\tcontext: this.context,\n\t\t\tvalue: options.width,\n\t\t\tunits: \"normalRange\",\n\t\t});\n\t\treadOnly(this, [\"width\"]);\n\t\tthis._twoTimesWidthMid = new Multiply({\n\t\t\tcontext: this.context,\n\t\t\tvalue: 2,\n\t\t});\n\t\tthis._twoTimesWidthSide = new Multiply({\n\t\t\tcontext: this.context,\n\t\t\tvalue: 2,\n\t\t});\n\t\tthis._midMult = new Multiply({ context: this.context });\n\t\tthis._twoTimesWidthMid.connect(this._midMult.factor);\n\t\tthis.connectEffectMid(this._midMult);\n\n\t\tthis._oneMinusWidth = new Subtract({ context: this.context });\n\t\tthis._oneMinusWidth.connect(this._twoTimesWidthMid);\n\t\tconnect(this.context.getConstant(1), this._oneMinusWidth);\n\t\tthis.width.connect(this._oneMinusWidth.subtrahend);\n\n\t\tthis._sideMult = new Multiply({ context: this.context });\n\t\tthis.width.connect(this._twoTimesWidthSide);\n\t\tthis._twoTimesWidthSide.connect(this._sideMult.factor);\n\t\tthis.connectEffectSide(this._sideMult);\n\t}\n\n\tstatic getDefaults(): StereoWidenerOptions {\n\t\treturn Object.assign(MidSideEffect.getDefaults(), {\n\t\t\twidth: 0.5,\n\t\t});\n\t}\n\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis.width.dispose();\n\t\tthis._midMult.dispose();\n\t\tthis._sideMult.dispose();\n\t\tthis._twoTimesWidthMid.dispose();\n\t\tthis._twoTimesWidthSide.dispose();\n\t\tthis._oneMinusWidth.dispose();\n\t\treturn this;\n\t}\n}\n","import { StereoEffect, StereoEffectOptions } from \"./StereoEffect\";\nimport { LFO } from \"../source/oscillator/LFO\";\nimport { Gain } from \"../core/context/Gain\";\nimport { Signal } from \"../signal/Signal\";\nimport { Degrees, Frequency, NormalRange, Time } from \"../core/type/Units\";\nimport { ToneOscillatorType } from \"../source/oscillator/OscillatorInterface\";\nimport { optionsFromArguments } from \"../core/util/Defaults\";\nimport { readOnly } from \"../core/util/Interface\";\n\nexport interface TremoloOptions extends StereoEffectOptions {\n\tfrequency: Frequency;\n\ttype: ToneOscillatorType;\n\tdepth: NormalRange;\n\tspread: Degrees;\n}\n\n/**\n * Tremolo modulates the amplitude of an incoming signal using an [[LFO]].\n * The effect is a stereo effect where the modulation phase is inverted in each channel.\n *\n * @example\n * // create a tremolo and start it's LFO\n * const tremolo = new Tone.Tremolo(9, 0.75).toDestination().start();\n * // route an oscillator through the tremolo and start it\n * const oscillator = new Tone.Oscillator().connect(tremolo).start();\n * \n * @category Effect\n */\nexport class Tremolo extends StereoEffect<TremoloOptions> {\n\n\treadonly name: string = \"Tremolo\";\n\n\t/**\n\t * The tremolo LFO in the left channel\n\t */\n\tprivate _lfoL: LFO;\n\n\t/**\n\t * The tremolo LFO in the left channel\n\t */\n\tprivate _lfoR: LFO;\n\n\t/**\n\t * Where the gain is multiplied\n\t */\n\tprivate _amplitudeL: Gain;\n\n\t/**\n\t * Where the gain is multiplied\n\t */\n\tprivate _amplitudeR: Gain;\n\n\t/**\n\t * The frequency of the tremolo.\n\t */\n\treadonly frequency: Signal<\"frequency\">;\n\n\t/**\n\t * The depth of the effect. A depth of 0, has no effect\n\t * on the amplitude, and a depth of 1 makes the amplitude\n\t * modulate fully between 0 and 1.\n\t */\n\treadonly depth: Signal<\"normalRange\">;\n\n\t/**\n\t * @param frequency The rate of the effect.\n\t * @param depth The depth of the effect.\n\t */\n\tconstructor(frequency?: Frequency, depth?: NormalRange);\n\tconstructor(options?: Partial<TremoloOptions>);\n\tconstructor() {\n\n\t\tsuper(optionsFromArguments(Tremolo.getDefaults(), arguments, [\"frequency\", \"depth\"]));\n\t\tconst options = optionsFromArguments(Tremolo.getDefaults(), arguments, [\"frequency\", \"depth\"]);\n\n\t\tthis._lfoL = new LFO({\n\t\t\tcontext: this.context,\n\t\t\ttype: options.type,\n\t\t\tmin: 1,\n\t\t\tmax: 0,\n\t\t});\n\t\tthis._lfoR = new LFO({\n\t\t\tcontext: this.context,\n\t\t\ttype: options.type,\n\t\t\tmin: 1,\n\t\t\tmax: 0,\n\t\t});\n\t\tthis._amplitudeL = new Gain({ context: this.context });\n\t\tthis._amplitudeR = new Gain({ context: this.context });\n\t\tthis.frequency = new Signal({\n\t\t\tcontext: this.context,\n\t\t\tvalue: options.frequency,\n\t\t\tunits: \"frequency\",\n\t\t});\n\t\tthis.depth = new Signal({\n\t\t\tcontext: this.context,\n\t\t\tvalue: options.depth,\n\t\t\tunits: \"normalRange\",\n\t\t});\n\n\t\treadOnly(this, [\"frequency\", \"depth\"]);\n\t\tthis.connectEffectLeft(this._amplitudeL);\n\t\tthis.connectEffectRight(this._amplitudeR);\n\t\tthis._lfoL.connect(this._amplitudeL.gain);\n\t\tthis._lfoR.connect(this._amplitudeR.gain);\n\t\tthis.frequency.fan(this._lfoL.frequency, this._lfoR.frequency);\n\t\tthis.depth.fan(this._lfoR.amplitude, this._lfoL.amplitude);\n\t\tthis.spread = options.spread;\n\t}\n\n\tstatic getDefaults(): TremoloOptions {\n\t\treturn Object.assign(StereoEffect.getDefaults(), {\n\t\t\tfrequency: 10,\n\t\t\ttype: \"sine\" as const,\n\t\t\tdepth: 0.5,\n\t\t\tspread: 180,\n\t\t});\n\t}\n\n\t/**\n\t * Start the tremolo.\n\t */\n\tstart(time?: Time): this {\n\t\tthis._lfoL.start(time);\n\t\tthis._lfoR.start(time);\n\t\treturn this;\n\t}\n\n\t/**\n\t * Stop the tremolo.\n\t */\n\tstop(time?: Time): this {\n\t\tthis._lfoL.stop(time);\n\t\tthis._lfoR.stop(time);\n\t\treturn this;\n\t}\n\n\t/**\n\t * Sync the effect to the transport.\n\t */\n\tsync(): this {\n\t\tthis._lfoL.sync();\n\t\tthis._lfoR.sync();\n\t\tthis.context.transport.syncSignal(this.frequency);\n\t\treturn this;\n\t}\n\n\t/**\n\t * Unsync the filter from the transport\n\t */\n\tunsync(): this {\n\t\tthis._lfoL.unsync();\n\t\tthis._lfoR.unsync();\n\t\tthis.context.transport.unsyncSignal(this.frequency);\n\t\treturn this;\n\t}\n\n\t/**\n\t * The oscillator type.\n\t */\n\tget type(): ToneOscillatorType {\n\t\treturn this._lfoL.type;\n\t}\n\tset type(type) {\n\t\tthis._lfoL.type = type;\n\t\tthis._lfoR.type = type;\n\t}\n\n\t/**\n\t * Amount of stereo spread. When set to 0, both LFO's will be panned centrally.\n\t * When set to 180, LFO's will be panned hard left and right respectively.\n\t */\n\tget spread(): Degrees {\n\t\treturn this._lfoR.phase - this._lfoL.phase; // 180\n\t}\n\tset spread(spread) {\n\t\tthis._lfoL.phase = 90 - (spread / 2);\n\t\tthis._lfoR.phase = (spread / 2) + 90;\n\t}\n\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis._lfoL.dispose();\n\t\tthis._lfoR.dispose();\n\t\tthis._amplitudeL.dispose();\n\t\tthis._amplitudeR.dispose();\n\t\tthis.frequency.dispose();\n\t\tthis.depth.dispose();\n\t\treturn this;\n\t}\n}\n","import { Effect, EffectOptions } from \"./Effect\";\nimport { ToneOscillatorType } from \"../source/oscillator/OscillatorInterface\";\nimport { Frequency, NormalRange, Seconds } from \"../core/type/Units\";\nimport { optionsFromArguments } from \"../core/util/Defaults\";\nimport { LFO } from \"../source/oscillator/LFO\";\nimport { Delay } from \"../core/context/Delay\";\nimport { Signal } from \"../signal/Signal\";\nimport { Param } from \"../core/context/Param\";\nimport { readOnly } from \"../core/util/Interface\";\n\nexport interface VibratoOptions extends EffectOptions {\n\tmaxDelay: Seconds;\n\tfrequency: Frequency;\n\tdepth: NormalRange;\n\ttype: ToneOscillatorType;\n}\n/**\n * A Vibrato effect composed of a Tone.Delay and a Tone.LFO. The LFO\n * modulates the delayTime of the delay, causing the pitch to rise and fall. \n * @category Effect\n */\nexport class Vibrato extends Effect<VibratoOptions> {\n\n\treadonly name: string = \"Vibrato\";\n\t/**\n\t * The delay node used for the vibrato effect\n\t */\n\tprivate _delayNode: Delay;\n\t\n\t/**\n\t * The LFO used to control the vibrato\n\t */\n\tprivate _lfo: LFO;\n\t\n\t/**\n\t * The frequency of the vibrato\n\t */\n\treadonly frequency: Signal<\"frequency\">;\n\t\n\t/**\n\t * The depth of the vibrato. \n\t */\n\treadonly depth: Param<\"normalRange\">;\n\n\t/**\n\t * @param frequency The frequency of the vibrato.\n\t * @param depth The amount the pitch is modulated.\n\t */\n\tconstructor(frequency?: Frequency, depth?: NormalRange);\n\tconstructor(options?: Partial<VibratoOptions>);\n\tconstructor() {\n\n\t\tsuper(optionsFromArguments(Vibrato.getDefaults(), arguments, [\"frequency\", \"depth\"]));\n\t\tconst options = optionsFromArguments(Vibrato.getDefaults(), arguments, [\"frequency\", \"depth\"]);\n\n\t\tthis._delayNode = new Delay({\n\t\t\tcontext: this.context,\n\t\t\tdelayTime: 0,\n\t\t\tmaxDelay: options.maxDelay,\n\t\t});\n\t\tthis._lfo = new LFO({\n\t\t\tcontext: this.context,\n\t\t\ttype: options.type,\n\t\t\tmin: 0,\n\t\t\tmax: options.maxDelay, \n\t\t\tfrequency: options.frequency,\n\t\t\tphase: -90 // offse the phase so the resting position is in the center\n\t\t}).start().connect(this._delayNode.delayTime);\n\t\tthis.frequency = this._lfo.frequency;\n\t\tthis.depth = this._lfo.amplitude;\n\n\t\tthis.depth.value = options.depth;\n\t\treadOnly(this, [\"frequency\", \"depth\"]);\n\t\tthis.effectSend.chain(this._delayNode, this.effectReturn);\n\t}\n\n\tstatic getDefaults(): VibratoOptions {\n\t\treturn Object.assign(Effect.getDefaults(), {\n\t\t\tmaxDelay: 0.005,\n\t\t\tfrequency: 5,\n\t\t\tdepth: 0.1,\n\t\t\ttype: \"sine\" as const\n\t\t});\n\t}\n\n\t/**\n\t * Type of oscillator attached to the Vibrato.\n\t */\n\tget type(): ToneOscillatorType {\n\t\treturn this._lfo.type;\n\t}\n\tset type(type) {\n\t\tthis._lfo.type = type;\n\t}\n\t\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis._delayNode.dispose();\n\t\tthis._lfo.dispose();\n\t\tthis.frequency.dispose();\n\t\tthis.depth.dispose();\n\t\treturn this;\n\t}\n}\n","import { InputNode, OutputNode, ToneAudioNode, ToneAudioNodeOptions } from \"../../core/context/ToneAudioNode\";\nimport { NormalRange, PowerOfTwo } from \"../../core/type/Units\";\nimport { optionsFromArguments } from \"../../core/util/Defaults\";\nimport { Split } from \"../channel/Split\";\nimport { Gain } from \"../../core/context/Gain\";\nimport { assert, assertRange } from \"../../core/util/Debug\";\n\nexport type AnalyserType = \"fft\" | \"waveform\";\n\nexport interface AnalyserOptions extends ToneAudioNodeOptions {\n\tsize: PowerOfTwo;\n\ttype: AnalyserType;\n\tsmoothing: NormalRange;\n\tchannels: number;\n}\n\n/**\n * Wrapper around the native Web Audio's [AnalyserNode](http://webaudio.github.io/web-audio-api/#idl-def-AnalyserNode).\n * Extracts FFT or Waveform data from the incoming signal.\n * @category Component\n */\nexport class Analyser extends ToneAudioNode<AnalyserOptions> {\n\n\treadonly name: string = \"Analyser\";\n\n\treadonly input: InputNode;\n\treadonly output: OutputNode;\n\n\t/**\n\t * The analyser node.\n\t */\n\tprivate _analysers: AnalyserNode[] = [];\n\n\t/**\n\t * Input and output are a gain node\n\t */\n\tprivate _gain: Gain;\n\n\t/**\n\t * The channel splitter node\n\t */\n\tprivate _split: Split;\n\n\t/**\n\t * The analysis type\n\t */\n\tprivate _type!: AnalyserType;\n\n\t/**\n\t * The buffer that the FFT data is written to\n\t */\n\tprivate _buffers: Float32Array[] = [];\n\n\t/**\n\t * @param type The return type of the analysis, either \"fft\", or \"waveform\".\n\t * @param size The size of the FFT. This must be a power of two in the range 16 to 16384.\n\t */\n\tconstructor(type?: AnalyserType, size?: number);\n\tconstructor(options?: Partial<AnalyserOptions>);\n\tconstructor() {\n\t\tsuper(optionsFromArguments(Analyser.getDefaults(), arguments, [\"type\", \"size\"]));\n\t\tconst options = optionsFromArguments(Analyser.getDefaults(), arguments, [\"type\", \"size\"]);\n\n\t\tthis.input = this.output = this._gain = new Gain({ context: this.context });\n\t\tthis._split = new Split({\n\t\t\tcontext: this.context,\n\t\t\tchannels: options.channels,\n\t\t});\n\t\tthis.input.connect(this._split);\n\t\t\n\t\tassertRange(options.channels, 1);\n\t\t\n\t\t// create the analysers\n\t\tfor (let channel = 0; channel < options.channels; channel++) {\n\t\t\tthis._analysers[channel] = this.context.createAnalyser();\n\t\t\tthis._split.connect(this._analysers[channel], channel, 0);\n\t\t}\n\n\t\t// set the values initially\n\t\tthis.size = options.size;\n\t\tthis.type = options.type;\n\t\tthis.smoothing = options.smoothing;\n\t}\n\n\tstatic getDefaults(): AnalyserOptions {\n\t\treturn Object.assign(ToneAudioNode.getDefaults(), {\n\t\t\tsize: 1024,\n\t\t\tsmoothing: 0.8,\n\t\t\ttype: \"fft\" as AnalyserType,\n\t\t\tchannels: 1,\n\t\t});\n\t}\n\n\t/**\n\t * Run the analysis given the current settings. If [[channels]] = 1,\n\t * it will return a Float32Array. If [[channels]] > 1, it will\n\t * return an array of Float32Arrays where each index in the array\n\t * represents the analysis done on a channel.\n\t */\n\tgetValue(): Float32Array | Float32Array[] {\n\t\tthis._analysers.forEach((analyser, index) => {\n\t\t\tconst buffer = this._buffers[index];\n\t\t\tif (this._type === \"fft\") {\n\t\t\t\tanalyser.getFloatFrequencyData(buffer);\n\t\t\t} else if (this._type === \"waveform\") {\n\t\t\t\tanalyser.getFloatTimeDomainData(buffer);\n\t\t\t}\n\t\t});\n\t\tif (this.channels === 1) {\n\t\t\treturn this._buffers[0];\n\t\t} else {\n\t\t\treturn this._buffers;\n\t\t}\n\t}\n\n\t/**\n\t * The size of analysis. This must be a power of two in the range 16 to 16384.\n\t */\n\tget size(): PowerOfTwo {\n\t\treturn this._analysers[0].frequencyBinCount;\n\t}\n\tset size(size: PowerOfTwo) {\n\t\tthis._analysers.forEach((analyser, index) => {\n\t\t\tanalyser.fftSize = size * 2;\n\t\t\tthis._buffers[index] = new Float32Array(size);\n\t\t});\n\t}\n\n\t/**\n\t * The number of channels the analyser does the analysis on. Channel\n\t * separation is done using [[Split]]\n\t */\n\tget channels(): number {\n\t\treturn this._analysers.length;\n\t}\n\n\t/**\n\t * The analysis function returned by analyser.getValue(), either \"fft\" or \"waveform\".\n\t */\n\tget type(): AnalyserType {\n\t\treturn this._type;\n\t}\n\tset type(type: AnalyserType) {\n\t\tassert(type === \"waveform\" || type === \"fft\", `Analyser: invalid type: ${type}`);\n\t\tthis._type = type;\n\t}\n\n\t/**\n\t * 0 represents no time averaging with the last analysis frame.\n\t */\n\tget smoothing(): NormalRange {\n\t\treturn this._analysers[0].smoothingTimeConstant;\n\t}\n\tset smoothing(val: NormalRange) {\n\t\tthis._analysers.forEach(a => a.smoothingTimeConstant = val);\n\t}\n\n\t/**\n\t * Clean up.\n\t */\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis._analysers.forEach(a => a.disconnect());\n\t\tthis._split.dispose();\n\t\tthis._gain.dispose();\n\t\treturn this;\n\t}\n}\n","import { InputNode, OutputNode, ToneAudioNode, ToneAudioNodeOptions } from \"../../core/context/ToneAudioNode\";\nimport { optionsFromArguments } from \"../../core/util/Defaults\";\nimport { Analyser } from \"./Analyser\";\n\nexport type MeterBaseOptions = ToneAudioNodeOptions;\n\n/**\n * The base class for Metering classes.\n */\nexport class MeterBase<Options extends MeterBaseOptions> extends ToneAudioNode<Options> {\n\n\treadonly name: string = \"MeterBase\";\n\n\t/**\n\t * The signal to be analysed\n\t */\n\tinput: InputNode;\n\n\t/**\n\t * The output is just a pass through of the input\n\t */\n\toutput: OutputNode;\n\n\t/**\n\t * The analyser node for the incoming signal\n\t */\n\tprotected _analyser: Analyser;\n\n\tconstructor(options?: Partial<MeterBaseOptions>);\n\tconstructor() {\n\t\tsuper(optionsFromArguments(MeterBase.getDefaults(), arguments));\n\n\t\tthis.input = this.output = this._analyser = new Analyser({\n\t\t\tcontext: this.context,\n\t\t\tsize: 256,\n\t\t\ttype: \"waveform\",\n\t\t});\n\t}\n\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis._analyser.dispose();\n\t\treturn this;\n\t}\n}\n","import { gainToDb } from \"../../core/type/Conversions\";\nimport { NormalRange } from \"../../core/type/Units\";\nimport { optionsFromArguments } from \"../../core/util/Defaults\";\nimport { MeterBase, MeterBaseOptions } from \"./MeterBase\";\nimport { warn } from \"../../core/util/Debug\";\nimport { Analyser } from \"./Analyser\";\n\nexport interface MeterOptions extends MeterBaseOptions {\n\tsmoothing: NormalRange;\n\tnormalRange: boolean;\n\tchannelCount: number;\n}\n\n/**\n * Meter gets the [RMS](https://en.wikipedia.org/wiki/Root_mean_square)\n * of an input signal. It can also get the raw value of the input signal.\n *\n * @example\n * const meter = new Tone.Meter();\n * const mic = new Tone.UserMedia();\n * mic.open();\n * // connect mic to the meter\n * mic.connect(meter);\n * // the current level of the mic\n * setInterval(() => console.log(meter.getValue()), 100);\n * @category Component\n */\nexport class Meter extends MeterBase<MeterOptions> {\n\n\treadonly name: string = \"Meter\";\n\n\t/**\n\t * If the output should be in decibels or normal range between 0-1. If `normalRange` is false,\n\t * the output range will be the measured decibel value, otherwise the decibel value will be converted to\n\t * the range of 0-1\n\t */\n\tnormalRange: boolean;\n\n\t/**\n\t * A value from between 0 and 1 where 0 represents no time averaging with the last analysis frame.\n\t */\n\tsmoothing: number;\n\n\t/**\n\t * The previous frame's value\n\t */\n\tprivate _rms = 0;\n\n\t/**\n\t * @param smoothing The amount of smoothing applied between frames.\n\t */\n\tconstructor(smoothing?: NormalRange);\n\tconstructor(options?: Partial<MeterOptions>);\n\tconstructor() {\n\t\tsuper(optionsFromArguments(Meter.getDefaults(), arguments, [\"smoothing\"]));\n\t\tconst options = optionsFromArguments(Meter.getDefaults(), arguments, [\"smoothing\"]);\n\n\t\tthis.input = this.output = this._analyser = new Analyser({\n\t\t\tcontext: this.context,\n\t\t\tsize: 256,\n\t\t\ttype: \"waveform\",\n\t\t\tchannels: options.channelCount,\n\t\t});\n\n\t\tthis.smoothing = options.smoothing,\n\t\tthis.normalRange = options.normalRange;\n\t}\n\n\tstatic getDefaults(): MeterOptions {\n\t\treturn Object.assign(MeterBase.getDefaults(), {\n\t\t\tsmoothing: 0.8,\n\t\t\tnormalRange: false,\n\t\t\tchannelCount: 1,\n\t\t});\n\t}\n\n\t/**\n\t * Use [[getValue]] instead. For the previous getValue behavior, use DCMeter.\n\t * @deprecated\n\t */\n\tgetLevel(): number | number[] {\n\t\twarn(\"'getLevel' has been changed to 'getValue'\");\n\t\treturn this.getValue();\n\t}\n\n\t/**\n\t * Get the current value of the incoming signal. \n\t * Output is in decibels when [[normalRange]] is `false`.\n\t * If [[channels]] = 1, then the output is a single number\n\t * representing the value of the input signal. When [[channels]] > 1,\n\t * then each channel is returned as a value in a number array. \n\t */\n\tgetValue(): number | number[] {\n\t\tconst aValues = this._analyser.getValue();\n\t\tconst channelValues = this.channels === 1 ? [aValues as Float32Array] : aValues as Float32Array[];\n\t\tconst vals = channelValues.map(values => {\n\t\t\tconst totalSquared = values.reduce((total, current) => total + current * current, 0);\n\t\t\tconst rms = Math.sqrt(totalSquared / values.length);\n\t\t\t// the rms can only fall at the rate of the smoothing\n\t\t\t// but can jump up instantly\n\t\t\tthis._rms = Math.max(rms, this._rms * this.smoothing);\n\t\t\treturn this.normalRange ? this._rms : gainToDb(this._rms);\n\t\t});\n\t\tif (this.channels === 1) {\n\t\t\treturn vals[0];\n\t\t} else {\n\t\t\treturn vals;\n\t\t}\n\t}\n\n\t/**\n\t * The number of channels of analysis.\n\t */\n\tget channels(): number {\n\t\treturn this._analyser.channels;\n\t}\n\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis._analyser.dispose();\n\t\treturn this;\n\t}\n}\n","import { ToneAudioNode } from \"../../core/context/ToneAudioNode\";\nimport { dbToGain } from \"../../core/type/Conversions\";\nimport { Hertz, NormalRange, PowerOfTwo } from \"../../core/type/Units\";\nimport { optionsFromArguments } from \"../../core/util/Defaults\";\nimport { MeterBase, MeterBaseOptions } from \"./MeterBase\";\nimport { assert } from \"../../core/util/Debug\";\n\nexport interface FFTOptions extends MeterBaseOptions {\n\tsize: PowerOfTwo;\n\tsmoothing: NormalRange;\n\tnormalRange: boolean;\n}\n\n/**\n * Get the current frequency data of the connected audio source using a fast Fourier transform.\n * @category Component\n */\nexport class FFT extends MeterBase<FFTOptions> {\n\n\treadonly name: string = \"FFT\";\n\n\t/**\n\t * If the output should be in decibels or normal range between 0-1. If `normalRange` is false,\n\t * the output range will be the measured decibel value, otherwise the decibel value will be converted to\n\t * the range of 0-1\n\t */\n\tnormalRange: boolean;\n\n\t/**\n\t * @param size The size of the FFT. Value must be a power of two in the range 16 to 16384.\n\t */\n\tconstructor(size?: PowerOfTwo);\n\tconstructor(options?: Partial<FFTOptions>);\n\tconstructor() {\n\t\tsuper(optionsFromArguments(FFT.getDefaults(), arguments, [\"size\"]));\n\t\tconst options = optionsFromArguments(FFT.getDefaults(), arguments, [\"size\"]);\n\n\t\tthis.normalRange = options.normalRange;\n\t\tthis._analyser.type = \"fft\";\n\t\tthis.size = options.size;\n\t}\n\n\tstatic getDefaults(): FFTOptions {\n\t\treturn Object.assign(ToneAudioNode.getDefaults(), {\n\t\t\tnormalRange: false,\n\t\t\tsize: 1024,\n\t\t\tsmoothing: 0.8,\n\t\t});\n\t}\n\n\t/**\n\t * Gets the current frequency data from the connected audio source.\n\t * Returns the frequency data of length [[size]] as a Float32Array of decibel values.\n\t */\n\tgetValue(): Float32Array {\n\t\tconst values = this._analyser.getValue() as Float32Array;\n\t\treturn values.map(v => this.normalRange ? dbToGain(v) : v);\n\t}\n\n\t/**\n\t * The size of analysis. This must be a power of two in the range 16 to 16384.\n\t * Determines the size of the array returned by [[getValue]] (i.e. the number of\n\t * frequency bins). Large FFT sizes may be costly to compute.\n\t */\n\tget size(): PowerOfTwo {\n\t\treturn this._analyser.size;\n\t}\n\tset size(size) {\n\t\tthis._analyser.size = size;\n\t}\n\n\t/**\n\t * 0 represents no time averaging with the last analysis frame.\n\t */\n\tget smoothing(): NormalRange {\n\t\treturn this._analyser.smoothing;\n\t}\n\tset smoothing(val) {\n\t\tthis._analyser.smoothing = val;\n\t}\n\n\t/**\n\t * Returns the frequency value in hertz of each of the indices of the FFT's [[getValue]] response.\n\t * @example\n\t * const fft = new Tone.FFT(32);\n\t * console.log([0, 1, 2, 3, 4].map(index => fft.getFrequencyOfIndex(index)));\n\t */\n\tgetFrequencyOfIndex(index: number): Hertz {\n\t\tassert(0 <= index && index < this.size, `index must be greater than or equal to 0 and less than ${this.size}`);\n\t\treturn index * this.context.sampleRate / (this.size * 2);\n\t}\n}\n","import { optionsFromArguments } from \"../../core/util/Defaults\";\nimport { MeterBase, MeterBaseOptions } from \"./MeterBase\";\n\nexport type DCMeterOptions = MeterBaseOptions;\n\n/**\n * DCMeter gets the raw value of the input signal at the current time.\n *\n * @example\n * const meter = new Tone.DCMeter();\n * const mic = new Tone.UserMedia();\n * mic.open();\n * // connect mic to the meter\n * mic.connect(meter);\n * // the current level of the mic\n * const level = meter.getValue();\n * @category Component\n */\nexport class DCMeter extends MeterBase<DCMeterOptions> {\n\n\treadonly name: string = \"DCMeter\";\n\n\tconstructor(options?: Partial<DCMeterOptions>);\n\tconstructor() {\n\t\tsuper(optionsFromArguments(DCMeter.getDefaults(), arguments));\n\n\t\tthis._analyser.type = \"waveform\";\n\t\tthis._analyser.size = 256;\n\t}\n\n\t/**\n\t * Get the signal value of the incoming signal\n\t */\n\tgetValue(): number {\n\t\tconst value = this._analyser.getValue() as Float32Array;\n\t\treturn value[0];\n\t}\n}\n","import { PowerOfTwo } from \"../../core/type/Units\";\nimport { optionsFromArguments } from \"../../core/util/Defaults\";\nimport { MeterBase, MeterBaseOptions } from \"./MeterBase\";\n\nexport interface WaveformOptions extends MeterBaseOptions {\n\t/**\n\t * The size of the Waveform. Value must be a power of two in the range 16 to 16384.\n\t */\n\tsize: PowerOfTwo;\n}\n\n/**\n * Get the current waveform data of the connected audio source.\n * @category Component\n */\nexport class Waveform extends MeterBase<WaveformOptions> {\n\n\treadonly name: string = \"Waveform\";\n\n\t/**\n\t * @param size The size of the Waveform. Value must be a power of two in the range 16 to 16384.\n\t */\n\tconstructor(size?: PowerOfTwo);\n\tconstructor(options?: Partial<WaveformOptions>);\n\tconstructor() {\n\t\tsuper(optionsFromArguments(Waveform.getDefaults(), arguments, [\"size\"]));\n\t\tconst options = optionsFromArguments(Waveform.getDefaults(), arguments, [\"size\"]);\n\n\t\tthis._analyser.type = \"waveform\";\n\t\tthis.size = options.size;\n\t}\n\n\tstatic getDefaults(): WaveformOptions {\n\t\treturn Object.assign(MeterBase.getDefaults(), {\n\t\t\tsize: 1024,\n\t\t});\n\t}\n\n\t/**\n\t * Return the waveform for the current time as a Float32Array where each value in the array\n\t * represents a sample in the waveform.\n\t */\n\tgetValue(): Float32Array {\n\t\treturn this._analyser.getValue() as Float32Array;\n\t}\n\n\t/**\n\t * The size of analysis. This must be a power of two in the range 16 to 16384.\n\t * Determines the size of the array returned by [[getValue]].\n\t */\n\tget size(): PowerOfTwo {\n\t\treturn this._analyser.size;\n\t}\n\tset size(size) {\n\t\tthis._analyser.size = size;\n\t}\n}\n","import { BaseContext } from \"../../core/context/BaseContext\";\nimport { Gain } from \"../../core/context/Gain\";\nimport { ToneAudioNode, ToneAudioNodeOptions } from \"../../core/context/ToneAudioNode\";\nimport { optionsFromArguments } from \"../../core/util/Defaults\";\n\nexport interface SoloOptions extends ToneAudioNodeOptions {\n\tsolo: boolean;\n}\n\n/**\n * Solo lets you isolate a specific audio stream. When an instance is set to `solo=true`,\n * it will mute all other instances of Solo.\n * @example\n * const soloA = new Tone.Solo().toDestination();\n * const oscA = new Tone.Oscillator(\"C4\", \"sawtooth\").connect(soloA);\n * const soloB = new Tone.Solo().toDestination();\n * const oscB = new Tone.Oscillator(\"E4\", \"square\").connect(soloB);\n * soloA.solo = true;\n * // no audio will pass through soloB\n * @category Component\n */\nexport class Solo extends ToneAudioNode<SoloOptions> {\n\n\treadonly name: string = \"Solo\";\n\n\treadonly input: Gain;\n\treadonly output: Gain;\n\n\t/**\n\t * @param solo If the connection should be initially solo'ed.\n\t */\n\tconstructor(solo?: boolean);\n\tconstructor(options?: Partial<SoloOptions>);\n\tconstructor() {\n\n\t\tsuper(optionsFromArguments(Solo.getDefaults(), arguments, [\"solo\"]));\n\t\tconst options = optionsFromArguments(Solo.getDefaults(), arguments, [\"solo\"]);\n\n\t\tthis.input = this.output = new Gain({\n\t\t\tcontext: this.context,\n\t\t});\n\n\t\tif (!Solo._allSolos.has(this.context)) {\n\t\t\tSolo._allSolos.set(this.context, new Set());\n\t\t}\n\t\t(Solo._allSolos.get(this.context) as Set<Solo>).add(this);\n\n\t\t// set initially\n\t\tthis.solo = options.solo;\n\t}\n\n\tstatic getDefaults(): SoloOptions {\n\t\treturn Object.assign(ToneAudioNode.getDefaults(), {\n\t\t\tsolo: false,\n\t\t});\n\t}\n\n\t/**\n\t * Hold all of the solo'ed tracks belonging to a specific context\n\t */\n\tprivate static _allSolos: Map<BaseContext, Set<Solo>> = new Map();\n\n\t/**\n\t * Hold the currently solo'ed instance(s)\n\t */\n\tprivate static _soloed: Map<BaseContext, Set<Solo>> = new Map();\n\n\t/**\n\t * Isolates this instance and mutes all other instances of Solo.\n\t * Only one instance can be soloed at a time. A soloed\n\t * instance will report `solo=false` when another instance is soloed.\n\t */\n\tget solo(): boolean {\n\t\treturn this._isSoloed();\n\t}\n\tset solo(solo) {\n\t\tif (solo) {\n\t\t\tthis._addSolo();\n\t\t} else {\n\t\t\tthis._removeSolo();\n\t\t}\n\t\t(Solo._allSolos.get(this.context) as Set<Solo>).forEach(instance => instance._updateSolo());\n\t}\n\n\t/**\n\t * If the current instance is muted, i.e. another instance is soloed\n\t */\n\tget muted(): boolean {\n\t\treturn this.input.gain.value === 0;\n\t}\n\n\t/**\n\t * Add this to the soloed array\n\t */\n\tprivate _addSolo(): void {\n\t\tif (!Solo._soloed.has(this.context)) {\n\t\t\tSolo._soloed.set(this.context, new Set());\n\t\t}\n\t\t(Solo._soloed.get(this.context) as Set<Solo>).add(this);\n\t}\n\n\t/**\n\t * Remove this from the soloed array\n\t */\n\tprivate _removeSolo(): void {\n\t\tif (Solo._soloed.has(this.context)) {\n\t\t\t(Solo._soloed.get(this.context) as Set<Solo>).delete(this);\n\t\t}\n\t}\n\n\t/**\n\t * Is this on the soloed array\n\t */\n\tprivate _isSoloed(): boolean {\n\t\treturn Solo._soloed.has(this.context) && (Solo._soloed.get(this.context) as Set<Solo>).has(this);\n\t}\n\n\t/**\n\t * Returns true if no one is soloed\n\t */\n\tprivate _noSolos(): boolean {\n\t\t// either does not have any soloed added\n\t\treturn !Solo._soloed.has(this.context) ||\n\t\t\t// or has a solo set but doesn't include any items\n\t\t\t(Solo._soloed.has(this.context) && (Solo._soloed.get(this.context) as Set<Solo>).size === 0);\n\t}\n\n\t/**\n\t * Solo the current instance and unsolo all other instances.\n\t */\n\tprivate _updateSolo(): void {\n\t\tif (this._isSoloed()) {\n\t\t\tthis.input.gain.value = 1;\n\t\t} else if (this._noSolos()) {\n\t\t\t// no one is soloed\n\t\t\tthis.input.gain.value = 1;\n\t\t} else {\n\t\t\tthis.input.gain.value = 0;\n\t\t}\n\t}\n\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\t(Solo._allSolos.get(this.context) as Set<Solo>).delete(this);\n\t\tthis._removeSolo();\n\t\treturn this;\n\t}\n}\n","import { readOnly } from \"../../core/util/Interface\";\nimport { Param } from \"../../core/context/Param\";\nimport { InputNode, OutputNode, ToneAudioNode, ToneAudioNodeOptions } from \"../../core/context/ToneAudioNode\";\nimport { AudioRange, Decibels } from \"../../core/type/Units\";\nimport { optionsFromArguments } from \"../../core/util/Defaults\";\nimport { Panner } from \"./Panner\";\nimport { Volume } from \"./Volume\";\n\nexport interface PanVolOptions extends ToneAudioNodeOptions {\n\tpan: AudioRange;\n\tvolume: Decibels;\n\tmute: boolean;\n\tchannelCount: number;\n}\n\n/**\n * PanVol is a Tone.Panner and Tone.Volume in one.\n * @example\n * // pan the incoming signal left and drop the volume\n * const panVol = new Tone.PanVol(-0.25, -12).toDestination();\n * const osc = new Tone.Oscillator().connect(panVol).start();\n * @category Component\n */\nexport class PanVol extends ToneAudioNode<PanVolOptions> {\n\n\treadonly name: string = \"PanVol\";\n\n\treadonly input: InputNode;\n\treadonly output: OutputNode;\n\n\t/**\n\t * The panning node\n\t */\n\tprivate _panner: Panner;\n\n\t/**\n\t * The L/R panning control. -1 = hard left, 1 = hard right.\n\t * @min -1\n\t * @max 1\n\t */\n\treadonly pan: Param<\"audioRange\">;\n\n\t/**\n\t * The volume node\n\t */\n\tprivate _volume: Volume;\n\n\t/**\n\t * The volume control in decibels.\n\t */\n\treadonly volume: Param<\"decibels\">;\n\n\t/**\n\t * @param pan the initial pan\n\t * @param volume The output volume.\n\t */\n\tconstructor(pan?: AudioRange, volume?: Decibels);\n\tconstructor(options?: Partial<PanVolOptions>);\n\tconstructor() {\n\n\t\tsuper(optionsFromArguments(PanVol.getDefaults(), arguments, [\"pan\", \"volume\"]));\n\t\tconst options = optionsFromArguments(PanVol.getDefaults(), arguments, [\"pan\", \"volume\"]);\n\n\t\tthis._panner = this.input = new Panner({\n\t\t\tcontext: this.context,\n\t\t\tpan: options.pan,\n\t\t\tchannelCount: options.channelCount,\n\t\t});\n\t\tthis.pan = this._panner.pan;\n\t\tthis._volume = this.output = new Volume({\n\t\t\tcontext: this.context,\n\t\t\tvolume: options.volume,\n\t\t});\n\t\tthis.volume = this._volume.volume;\n\n\t\t// connections\n\t\tthis._panner.connect(this._volume);\n\t\tthis.mute = options.mute;\n\n\t\treadOnly(this, [\"pan\", \"volume\"]);\n\t}\n\n\tstatic getDefaults(): PanVolOptions {\n\t\treturn Object.assign(ToneAudioNode.getDefaults(), {\n\t\t\tmute: false,\n\t\t\tpan: 0,\n\t\t\tvolume: 0,\n\t\t\tchannelCount: 1,\n\t\t});\n\t}\n\n\t/**\n\t * Mute/unmute the volume\n\t */\n\tget mute(): boolean {\n\t\treturn this._volume.mute;\n\t}\n\tset mute(mute) {\n\t\tthis._volume.mute = mute;\n\t}\n\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis._panner.dispose();\n\t\tthis.pan.dispose();\n\t\tthis._volume.dispose();\n\t\tthis.volume.dispose();\n\t\treturn this;\n\t}\n}\n","import { AudioRange, Decibels } from \"../../core/type/Units\";\nimport { InputNode, OutputNode, ToneAudioNode, ToneAudioNodeOptions } from \"../../core/context/ToneAudioNode\";\nimport { optionsFromArguments } from \"../../core/util/Defaults\";\nimport { Solo } from \"./Solo\";\nimport { PanVol } from \"./PanVol\";\nimport { Param } from \"../../core/context/Param\";\nimport { readOnly } from \"../../core/util/Interface\";\nimport { Gain } from \"../../core/context/Gain\";\n\nexport interface ChannelOptions extends ToneAudioNodeOptions {\n\tpan: AudioRange;\n\tvolume: Decibels;\n\tsolo: boolean;\n\tmute: boolean;\n\tchannelCount: number;\n}\n\n/**\n * Channel provides a channel strip interface with volume, pan, solo and mute controls. \n * See [[PanVol]] and [[Solo]]\n * @example\n * // pan the incoming signal left and drop the volume 12db\n * const channel = new Tone.Channel(-0.25, -12);\n * @category Component\n */\nexport class Channel extends ToneAudioNode<ChannelOptions> {\n\n\treadonly name: string = \"Channel\";\n\n\treadonly input: InputNode;\n\treadonly output: OutputNode;\n\n\t/**\n\t * The soloing interface\n\t */\n\tprivate _solo: Solo;\n\n\t/**\n\t * The panning and volume node\n\t */\n\tprivate _panVol: PanVol;\n\n\t/**\n\t * The L/R panning control. -1 = hard left, 1 = hard right.\n\t * @min -1\n\t * @max 1\n\t */\n\treadonly pan: Param<\"audioRange\">;\n\n\t/**\n\t * The volume control in decibels.\n\t */\n\treadonly volume: Param<\"decibels\">;\n\n\t/**\n\t * @param volume The output volume.\n\t * @param pan the initial pan\n\t */\n\tconstructor(volume?: Decibels, pan?: AudioRange);\n\tconstructor(options?: Partial<ChannelOptions>);\n\tconstructor() {\n\t\tsuper(optionsFromArguments(Channel.getDefaults(), arguments, [\"volume\", \"pan\"]));\n\t\tconst options = optionsFromArguments(Channel.getDefaults(), arguments, [\"volume\", \"pan\"]);\n\n\t\tthis._solo = this.input = new Solo({\n\t\t\tsolo: options.solo,\n\t\t\tcontext: this.context,\n\t\t});\n\t\tthis._panVol = this.output = new PanVol({\n\t\t\tcontext: this.context,\n\t\t\tpan: options.pan,\n\t\t\tvolume: options.volume,\n\t\t\tmute: options.mute,\n\t\t\tchannelCount: options.channelCount\n\t\t});\n\t\tthis.pan = this._panVol.pan;\n\t\tthis.volume = this._panVol.volume;\n\n\t\tthis._solo.connect(this._panVol);\n\t\treadOnly(this, [\"pan\", \"volume\"]);\n\t}\n\n\tstatic getDefaults(): ChannelOptions {\n\t\treturn Object.assign(ToneAudioNode.getDefaults(), {\n\t\t\tpan: 0,\n\t\t\tvolume: 0,\n\t\t\tmute: false,\n\t\t\tsolo: false,\n\t\t\tchannelCount: 1,\n\t\t});\n\t}\n\n\t/**\n\t * Solo/unsolo the channel. Soloing is only relative to other [[Channels]] and [[Solo]] instances\n\t */\n\tget solo(): boolean {\n\t\treturn this._solo.solo;\n\t}\n\tset solo(solo) {\n\t\tthis._solo.solo = solo;\n\t}\n\n\t/**\n\t * If the current instance is muted, i.e. another instance is soloed,\n\t * or the channel is muted\n\t */\n\tget muted(): boolean {\n\t\treturn this._solo.muted || this.mute;\n\t}\n\n\t/**\n\t * Mute/unmute the volume\n\t */\n\tget mute(): boolean {\n\t\treturn this._panVol.mute;\n\t}\n\tset mute(mute) {\n\t\tthis._panVol.mute = mute;\n\t}\n\n\t/**\n\t * Store the send/receive channels by name. \n\t */\n\tprivate static buses: Map<string, Gain> = new Map();\n\n\t/**\n\t * Get the gain node belonging to the bus name. Create it if\n\t * it doesn't exist\n\t * @param name The bus name\n\t */\n\tprivate _getBus(name: string): Gain {\n\t\tif (!Channel.buses.has(name)) {\n\t\t\tChannel.buses.set(name, new Gain({ context: this.context }));\n\t\t}\n\t\treturn Channel.buses.get(name) as Gain;\n\t}\n\n\t/**\n\t * Send audio to another channel using a string. `send` is a lot like\n\t * [[connect]], except it uses a string instead of an object. This can \n\t * be useful in large applications to decouple sections since [[send]]\n\t * and [[receive]] can be invoked separately in order to connect an object\n\t * @param name The channel name to send the audio\n\t * @param volume The amount of the signal to send. \n\t * \tDefaults to 0db, i.e. send the entire signal\n\t * @returns Returns the gain node of this connection.\n\t */\n\tsend(name: string, volume: Decibels = 0): Gain<\"decibels\"> {\n\t\tconst bus = this._getBus(name);\n\t\tconst sendKnob = new Gain({\n\t\t\tcontext: this.context,\n\t\t\tunits: \"decibels\",\n\t\t\tgain: volume,\n\t\t});\n\t\tthis.connect(sendKnob);\n\t\tsendKnob.connect(bus);\n\t\treturn sendKnob;\n\t}\n\n\t/**\n\t * Receive audio from a channel which was connected with [[send]]. \n\t * @param name The channel name to receive audio from.\n\t */\n\treceive(name: string): this {\n\t\tconst bus = this._getBus(name);\n\t\tbus.connect(this);\n\t\treturn this;\n\t}\n\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis._panVol.dispose();\n\t\tthis.pan.dispose();\n\t\tthis.volume.dispose();\n\t\tthis._solo.dispose();\n\t\treturn this;\n\t}\n}\n","import { Gain } from \"../../core/context/Gain\";\nimport { OutputNode, ToneAudioNode, ToneAudioNodeOptions } from \"../../core/context/ToneAudioNode\";\nimport { optionsFromArguments } from \"../../core/util/Defaults\";\nimport { Merge } from \"./Merge\";\n\nexport type MonoOptions = ToneAudioNodeOptions;\n\n/**\n * Mono coerces the incoming mono or stereo signal into a mono signal\n * where both left and right channels have the same value. This can be useful\n * for [stereo imaging](https://en.wikipedia.org/wiki/Stereo_imaging).\n * @category Component\n */\nexport class Mono extends ToneAudioNode<MonoOptions> {\n\n\treadonly name: string = \"Mono\";\n\n\t/**\n\t * merge the signal\n\t */\n\tprivate _merge: Merge;\n\n\t/**\n\t * The summed output of the multiple inputs\n\t */\n\treadonly output: OutputNode;\n\n\t/**\n\t * The stereo signal to sum to mono\n\t */\n\treadonly input: Gain;\n\n\tconstructor(options?: Partial<MonoOptions>);\n\tconstructor() {\n\n\t\tsuper(optionsFromArguments(Mono.getDefaults(), arguments));\n\n\t\tthis.input = new Gain({ context: this.context });\n\n\t\tthis._merge = this.output = new Merge({\n\t\t\tchannels: 2,\n\t\t\tcontext: this.context,\n\t\t});\n\n\t\tthis.input.connect(this._merge, 0, 0);\n\t\tthis.input.connect(this._merge, 0, 1);\n\t}\n\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis._merge.dispose();\n\t\tthis.input.dispose();\n\t\treturn this;\n\t}\n}\n","import { Gain } from \"../../core/context/Gain\";\nimport { ToneAudioNode, ToneAudioNodeOptions } from \"../../core/context/ToneAudioNode\";\nimport { Frequency, Positive } from \"../../core/type/Units\";\nimport { optionsFromArguments } from \"../../core/util/Defaults\";\nimport { readOnly, writable } from \"../../core/util/Interface\";\nimport { Signal } from \"../../signal/Signal\";\nimport { Filter } from \"../filter/Filter\";\n\ninterface MultibandSplitOptions extends ToneAudioNodeOptions {\n\tQ: Positive;\n\tlowFrequency: Frequency;\n\thighFrequency: Frequency;\n}\n\n/**\n * Split the incoming signal into three bands (low, mid, high)\n * with two crossover frequency controls.\n * ```\n *            +----------------------+\n *          +-> input < lowFrequency +------------------> low\n *          | +----------------------+\n *          |\n *          | +--------------------------------------+\n * input ---+-> lowFrequency < input < highFrequency +--> mid\n *          | +--------------------------------------+\n *          |\n *          | +-----------------------+\n *          +-> highFrequency < input +-----------------> high\n *            +-----------------------+\n * ```\n * @category Component\n */\nexport class MultibandSplit extends ToneAudioNode<MultibandSplitOptions> {\n\n\treadonly name: string = \"MultibandSplit\";\n\n\t/**\n\t * the input\n\t */\n\treadonly input = new Gain({ context: this.context });\n\n\t/**\n\t * no output node, use either low, mid or high outputs\n\t */\n\treadonly output = undefined;\n\n\t/**\n\t * The low band.\n\t */\n\treadonly low = new Filter({\n\t\tcontext: this.context,\n\t\tfrequency: 0,\n\t\ttype: \"lowpass\",\n\t});\n\n\t/**\n\t * the lower filter of the mid band\n\t */\n\tprivate _lowMidFilter = new Filter({\n\t\tcontext: this.context,\n\t\tfrequency: 0,\n\t\ttype: \"highpass\",\n\t});\n\n\t/**\n\t * The mid band output.\n\t */\n\treadonly mid = new Filter({\n\t\tcontext: this.context,\n\t\tfrequency: 0,\n\t\ttype: \"lowpass\",\n\t});\n\n\t/**\n\t * The high band output.\n\t */\n\treadonly high = new Filter({\n\t\tcontext: this.context,\n\t\tfrequency: 0,\n\t\ttype: \"highpass\",\n\t});\n\n\t/**\n\t * The low/mid crossover frequency.\n\t */\n\treadonly lowFrequency: Signal<\"frequency\">;\n\n\t/**\n\t * The mid/high crossover frequency.\n\t */\n\treadonly highFrequency: Signal<\"frequency\">;\n\n\tprotected _internalChannels = [this.low, this.mid, this.high];\n\n\t/**\n\t * The Q or Quality of the filter\n\t */\n\treadonly Q: Signal<\"positive\">;\n\n\t/**\n\t * @param lowFrequency the low/mid crossover frequency\n\t * @param highFrequency the mid/high crossover frequency\n\t */\n\tconstructor(lowFrequency?: Frequency, highFrequency?: Frequency);\n\tconstructor(options?: Partial<MultibandSplitOptions>);\n\tconstructor() {\n\t\tsuper(optionsFromArguments(MultibandSplit.getDefaults(), arguments, [\"lowFrequency\", \"highFrequency\"]));\n\t\tconst options = optionsFromArguments(MultibandSplit.getDefaults(), arguments, [\"lowFrequency\", \"highFrequency\"]);\n\n\t\tthis.lowFrequency = new Signal({\n\t\t\tcontext: this.context,\n\t\t\tunits: \"frequency\",\n\t\t\tvalue: options.lowFrequency,\n\t\t});\n\n\t\tthis.highFrequency = new Signal({\n\t\t\tcontext: this.context,\n\t\t\tunits: \"frequency\",\n\t\t\tvalue: options.highFrequency,\n\t\t});\n\n\t\tthis.Q = new Signal({\n\t\t\tcontext: this.context,\n\t\t\tunits: \"positive\",\n\t\t\tvalue: options.Q,\n\t\t});\n\n\t\tthis.input.fan(this.low, this.high);\n\t\tthis.input.chain(this._lowMidFilter, this.mid);\n\t\t// the frequency control signal\n\t\tthis.lowFrequency.fan(this.low.frequency, this._lowMidFilter.frequency);\n\t\tthis.highFrequency.fan(this.mid.frequency, this.high.frequency);\n\t\t// the Q value\n\t\tthis.Q.connect(this.low.Q);\n\t\tthis.Q.connect(this._lowMidFilter.Q);\n\t\tthis.Q.connect(this.mid.Q);\n\t\tthis.Q.connect(this.high.Q);\n\n\t\treadOnly(this, [\"high\", \"mid\", \"low\", \"highFrequency\", \"lowFrequency\"]);\n\t}\n\n\tstatic getDefaults(): MultibandSplitOptions {\n\t\treturn Object.assign(ToneAudioNode.getDefaults(), {\n\t\t\tQ: 1,\n\t\t\thighFrequency: 2500,\n\t\t\tlowFrequency: 400,\n\t\t});\n\t}\n\n\t/**\n\t * Clean up.\n\t */\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\twritable(this, [\"high\", \"mid\", \"low\", \"highFrequency\", \"lowFrequency\"]);\n\t\tthis.low.dispose();\n\t\tthis._lowMidFilter.dispose();\n\t\tthis.mid.dispose();\n\t\tthis.high.dispose();\n\t\tthis.lowFrequency.dispose();\n\t\tthis.highFrequency.dispose();\n\t\tthis.Q.dispose();\n\t\treturn this;\n\t}\n\n}\n","import { ToneAudioNode, ToneAudioNodeOptions } from \"./ToneAudioNode\";\nimport { Param } from \"./Param\";\nimport { onContextClose, onContextInit } from \"./ContextInitialization\";\n\nexport interface ListenerOptions extends ToneAudioNodeOptions{\n\tpositionX: number;\n\tpositionY: number;\n\tpositionZ: number;\n\tforwardX: number;\n\tforwardY: number;\n\tforwardZ: number;\n\tupX: number;\n\tupY: number;\n\tupZ: number;\n}\n\n/**\n * Tone.Listener is a thin wrapper around the AudioListener. Listener combined\n * with [[Panner3D]] makes up the Web Audio API's 3D panning system. Panner3D allows you \n * to place sounds in 3D and Listener allows you to navigate the 3D sound environment from\n * a first-person perspective. There is only one listener per audio context. \n */\nexport class Listener extends ToneAudioNode<ListenerOptions> {\n\n\treadonly name: string = \"Listener\";\n\n\t/**\n\t * The listener has no inputs or outputs. \n\t */\n\toutput: undefined; \n\tinput: undefined; \n\n\treadonly positionX: Param = new Param({\n\t\tcontext: this.context,\n\t\tparam: this.context.rawContext.listener.positionX,\n\t})\n\n\treadonly positionY: Param = new Param({\n\t\tcontext: this.context,\n\t\tparam: this.context.rawContext.listener.positionY,\n\t})\n\n\treadonly positionZ: Param = new Param({\n\t\tcontext: this.context,\n\t\tparam: this.context.rawContext.listener.positionZ,\n\t})\n\n\treadonly forwardX: Param = new Param({\n\t\tcontext: this.context,\n\t\tparam: this.context.rawContext.listener.forwardX,\n\t})\n\n\treadonly forwardY: Param = new Param({\n\t\tcontext: this.context,\n\t\tparam: this.context.rawContext.listener.forwardY,\n\t})\n\n\treadonly forwardZ: Param = new Param({\n\t\tcontext: this.context,\n\t\tparam: this.context.rawContext.listener.forwardZ,\n\t})\n\n\treadonly upX: Param = new Param({\n\t\tcontext: this.context,\n\t\tparam: this.context.rawContext.listener.upX,\n\t})\n\n\treadonly upY: Param = new Param({\n\t\tcontext: this.context,\n\t\tparam: this.context.rawContext.listener.upY,\n\t})\n\n\treadonly upZ: Param = new Param({\n\t\tcontext: this.context,\n\t\tparam: this.context.rawContext.listener.upZ,\n\t})\n\n\tstatic getDefaults(): ListenerOptions {\n\t\treturn Object.assign(ToneAudioNode.getDefaults(), {\n\t\t\tpositionX: 0,\n\t\t\tpositionY: 0,\n\t\t\tpositionZ: 0,\n\t\t\tforwardX: 0,\n\t\t\tforwardY: 0,\n\t\t\tforwardZ: -1,\n\t\t\tupX: 0,\n\t\t\tupY: 1,\n\t\t\tupZ: 0,\n\t\t});\n\t}\n\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis.positionX.dispose();\n\t\tthis.positionY.dispose();\n\t\tthis.positionZ.dispose();\n\t\tthis.forwardX.dispose();\n\t\tthis.forwardY.dispose();\n\t\tthis.forwardZ.dispose();\n\t\tthis.upX.dispose();\n\t\tthis.upY.dispose();\n\t\tthis.upZ.dispose();\n\t\treturn this;\n\t}\n}\n\n//-------------------------------------\n// \tINITIALIZATION\n//-------------------------------------\n\nonContextInit(context => {\n\tcontext.listener = new Listener({ context });\n});\n\nonContextClose(context => {\n\tcontext.listener.dispose();\n});\n","import { Param } from \"../../core/context/Param\";\nimport { ToneAudioNode, ToneAudioNodeOptions } from \"../../core/context/ToneAudioNode\";\nimport { Degrees, GainFactor } from \"../../core/type/Units\";\nimport { optionsFromArguments } from \"../../core/util/Defaults\";\nimport \"../../core/context/Listener\";\n\nexport interface Panner3DOptions extends ToneAudioNodeOptions {\n\tconeInnerAngle: Degrees;\n\tconeOuterAngle: Degrees;\n\tconeOuterGain: GainFactor;\n\tdistanceModel: DistanceModelType;\n\tmaxDistance: number;\n\torientationX: number;\n\torientationY: number;\n\torientationZ: number;\n\tpanningModel: PanningModelType;\n\tpositionX: number;\n\tpositionY: number;\n\tpositionZ: number;\n\trefDistance: number;\n\trolloffFactor: number;\n}\n\n/**\n * A spatialized panner node which supports equalpower or HRTF panning.\n * @category Component\n */\nexport class Panner3D extends ToneAudioNode<Panner3DOptions> {\n\n\treadonly name: string = \"Panner3D\";\n\n\t/**\n\t * The panning object\n\t */\n\tprivate _panner: PannerNode;\n\treadonly input: PannerNode;\n\treadonly output: PannerNode;\n\n\treadonly positionX: Param<\"number\">;\n\treadonly positionY: Param<\"number\">;\n\treadonly positionZ: Param<\"number\">;\n\n\treadonly orientationX: Param<\"number\">;\n\treadonly orientationY: Param<\"number\">;\n\treadonly orientationZ: Param<\"number\">;\n\n\t/**\n\t * @param positionX The initial x position.\n\t * @param positionY The initial y position.\n\t * @param positionZ The initial z position.\n\t */\n\tconstructor(positionX: number, positionY: number, positionZ: number);\n\tconstructor(options?: Partial<Panner3DOptions>);\n\tconstructor() {\n\n\t\tsuper(optionsFromArguments(Panner3D.getDefaults(), arguments, [\"positionX\", \"positionY\", \"positionZ\"]));\n\t\tconst options = optionsFromArguments(Panner3D.getDefaults(), arguments, [\"positionX\", \"positionY\", \"positionZ\"]);\n\n\t\tthis._panner = this.input = this.output = this.context.createPanner();\n\t\t// set some values\n\t\tthis.panningModel = options.panningModel;\n\t\tthis.maxDistance = options.maxDistance;\n\t\tthis.distanceModel = options.distanceModel;\n\t\tthis.coneOuterGain = options.coneOuterGain;\n\t\tthis.coneOuterAngle = options.coneOuterAngle;\n\t\tthis.coneInnerAngle = options.coneInnerAngle;\n\t\tthis.refDistance = options.refDistance;\n\t\tthis.rolloffFactor = options.rolloffFactor;\n\n\t\tthis.positionX = new Param({\n\t\t\tcontext: this.context,\n\t\t\tparam: this._panner.positionX,\n\t\t\tvalue: options.positionX,\n\t\t});\n\t\tthis.positionY = new Param({\n\t\t\tcontext: this.context,\n\t\t\tparam: this._panner.positionY,\n\t\t\tvalue: options.positionY,\n\t\t});\n\t\tthis.positionZ = new Param({\n\t\t\tcontext: this.context,\n\t\t\tparam: this._panner.positionZ,\n\t\t\tvalue: options.positionZ,\n\t\t});\n\t\tthis.orientationX = new Param({\n\t\t\tcontext: this.context,\n\t\t\tparam: this._panner.orientationX,\n\t\t\tvalue: options.orientationX,\n\t\t});\n\t\tthis.orientationY = new Param({\n\t\t\tcontext: this.context,\n\t\t\tparam: this._panner.orientationY,\n\t\t\tvalue: options.orientationY,\n\t\t});\n\t\tthis.orientationZ = new Param({\n\t\t\tcontext: this.context,\n\t\t\tparam: this._panner.orientationZ,\n\t\t\tvalue: options.orientationZ,\n\t\t});\n\t}\n\n\tstatic getDefaults(): Panner3DOptions {\n\t\treturn Object.assign(ToneAudioNode.getDefaults(), {\n\t\t\tconeInnerAngle: 360,\n\t\t\tconeOuterAngle: 360,\n\t\t\tconeOuterGain: 0,\n\t\t\tdistanceModel: \"inverse\" as DistanceModelType,\n\t\t\tmaxDistance: 10000,\n\t\t\torientationX: 0,\n\t\t\torientationY: 0,\n\t\t\torientationZ: 0,\n\t\t\tpanningModel: \"equalpower\" as PanningModelType,\n\t\t\tpositionX: 0,\n\t\t\tpositionY: 0,\n\t\t\tpositionZ: 0,\n\t\t\trefDistance: 1,\n\t\t\trolloffFactor: 1,\n\t\t});\n\t}\n\n\t/**\n\t * Sets the position of the source in 3d space.\n\t */\n\tsetPosition(x: number, y: number, z: number): this {\n\t\tthis.positionX.value = x;\n\t\tthis.positionY.value = y;\n\t\tthis.positionZ.value = z;\n\t\treturn this;\n\t}\n\n\t/**\n\t * Sets the orientation of the source in 3d space.\n\t */\n\tsetOrientation(x: number, y: number, z: number): this {\n\t\tthis.orientationX.value = x;\n\t\tthis.orientationY.value = y;\n\t\tthis.orientationZ.value = z;\n\t\treturn this;\n\t}\n\n\t/**\n\t * The panning model. Either \"equalpower\" or \"HRTF\".\n\t */\n\tget panningModel(): PanningModelType {\n\t\treturn this._panner.panningModel;\n\t}\n\tset panningModel(val) {\n\t\tthis._panner.panningModel = val;\n\t}\n\n\t/**\n\t * A reference distance for reducing volume as source move further from the listener\n\t */\n\tget refDistance(): number {\n\t\treturn this._panner.refDistance;\n\t}\n\tset refDistance(val) {\n\t\tthis._panner.refDistance = val;\n\t}\n\n\t/**\n\t * Describes how quickly the volume is reduced as source moves away from listener.\n\t */\n\tget rolloffFactor(): number {\n\t\treturn this._panner.rolloffFactor;\n\t}\n\tset rolloffFactor(val) {\n\t\tthis._panner.rolloffFactor = val;\n\t}\n\n\t/**\n\t * The distance model used by,  \"linear\", \"inverse\", or \"exponential\".\n\t */\n\tget distanceModel(): DistanceModelType {\n\t\treturn this._panner.distanceModel;\n\t}\n\tset distanceModel(val) {\n\t\tthis._panner.distanceModel = val;\n\t}\n\n\t/**\n\t * The angle, in degrees, inside of which there will be no volume reduction\n\t */\n\tget coneInnerAngle(): Degrees {\n\t\treturn this._panner.coneInnerAngle;\n\t}\n\tset coneInnerAngle(val) {\n\t\tthis._panner.coneInnerAngle = val;\n\t}\n\n\t/**\n\t * The angle, in degrees, outside of which the volume will be reduced\n\t * to a constant value of coneOuterGain\n\t */\n\tget coneOuterAngle(): Degrees {\n\t\treturn this._panner.coneOuterAngle;\n\t}\n\tset coneOuterAngle(val) {\n\t\tthis._panner.coneOuterAngle = val;\n\t}\n\n\t/**\n\t * The gain outside of the coneOuterAngle\n\t */\n\tget coneOuterGain(): GainFactor {\n\t\treturn this._panner.coneOuterGain;\n\t}\n\tset coneOuterGain(val) {\n\t\tthis._panner.coneOuterGain = val;\n\t}\n\n\t/**\n\t * The maximum distance between source and listener,\n\t * after which the volume will not be reduced any further.\n\t */\n\tget maxDistance(): number {\n\t\treturn this._panner.maxDistance;\n\t}\n\tset maxDistance(val) {\n\t\tthis._panner.maxDistance = val;\n\t}\n\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis._panner.disconnect();\n\t\tthis.orientationX.dispose();\n\t\tthis.orientationY.dispose();\n\t\tthis.orientationZ.dispose();\n\t\tthis.positionX.dispose();\n\t\tthis.positionY.dispose();\n\t\tthis.positionZ.dispose();\n\t\treturn this;\n\t}\n}\n","import { ToneAudioNode, ToneAudioNodeOptions } from \"../../core/context/ToneAudioNode\";\nimport { Gain } from \"../../core/context/Gain\";\nimport { assert } from \"../../core/util/Debug\";\nimport { theWindow } from \"../../core/context/AudioContext\";\nimport { optionsFromArguments } from \"../../core/util/Defaults\";\nimport { PlaybackState } from \"../../core/util/StateTimeline\";\n\nexport interface RecorderOptions extends ToneAudioNodeOptions {\n\tmimeType?: string;\n}\n\n/**\n * A wrapper around the MediaRecorder API. Unlike the rest of Tone.js, this module does not offer\n * any sample-accurate scheduling because it is not a feature of the MediaRecorder API.\n * This is only natively supported in Chrome and Firefox. \n * For a cross-browser shim, install (audio-recorder-polyfill)[https://www.npmjs.com/package/audio-recorder-polyfill]. \n * @example\n * const recorder = new Tone.Recorder();\n * const synth = new Tone.Synth().connect(recorder);\n * // start recording\n * recorder.start();\n * // generate a few notes\n * synth.triggerAttackRelease(\"C3\", 0.5);\n * synth.triggerAttackRelease(\"C4\", 0.5, \"+1\");\n * synth.triggerAttackRelease(\"C5\", 0.5, \"+2\");\n * // wait for the notes to end and stop the recording\n * setTimeout(async () => {\n * \t// the recorded audio is returned as a blob\n * \tconst recording = await recorder.stop();\n * \t// download the recording by creating an anchor element and blob url\n * \tconst url = URL.createObjectURL(recording);\n * \tconst anchor = document.createElement(\"a\");\n * \tanchor.download = \"recording.webm\";\n * \tanchor.href = url;\n * \tanchor.click();\n * }, 4000);\n * @category Component\n */\nexport class Recorder extends ToneAudioNode<RecorderOptions> {\n\n\treadonly name = \"Recorder\";\n\n\t/**\n\t * Recorder uses the Media Recorder API\n\t */\n\tprivate _recorder: MediaRecorder;\n\n\t/**\n\t * MediaRecorder requires \n\t */\n\tprivate _stream: MediaStreamAudioDestinationNode;\n\n\treadonly input: Gain;\n\treadonly output: undefined;\n\n\tconstructor(options?: Partial<RecorderOptions>);\n\tconstructor() {\n\n\t\tsuper(optionsFromArguments(Recorder.getDefaults(), arguments));\n\t\tconst options = optionsFromArguments(Recorder.getDefaults(), arguments);\n\n\t\tthis.input = new Gain({\n\t\t\tcontext: this.context\n\t\t});\n\n\t\tassert(Recorder.supported, \"Media Recorder API is not available\");\n\n\t\tthis._stream = this.context.createMediaStreamDestination();\n\t\tthis.input.connect(this._stream);\n\t\tthis._recorder = new MediaRecorder(this._stream.stream, {\n\t\t\tmimeType: options.mimeType\n\t\t});\n\t}\n\n\tstatic getDefaults(): RecorderOptions {\n\t\treturn ToneAudioNode.getDefaults();\n\t}\n\n\t/**\n\t * The mime type is the format that the audio is encoded in. For Chrome \n\t * that is typically webm encoded as \"vorbis\". \n\t */\n\tget mimeType(): string {\n\t\treturn this._recorder.mimeType;\n\t}\n\n\t/**\n\t * Test if your platform supports the Media Recorder API. If it's not available, \n\t * try installing this (polyfill)[https://www.npmjs.com/package/audio-recorder-polyfill].\n\t */\n\tstatic get supported(): boolean {\n\t\treturn theWindow !== null && Reflect.has(theWindow, \"MediaRecorder\");\n\t}\n\n\t/**\n\t * Get the playback state of the Recorder, either \"started\", \"stopped\" or \"paused\"\n\t */\n\tget state(): PlaybackState {\n\t\tif (this._recorder.state === \"inactive\") {\n\t\t\treturn \"stopped\";\n\t\t} else if (this._recorder.state === \"paused\") {\n\t\t\treturn \"paused\";\n\t\t} else {\n\t\t\treturn \"started\";\n\t\t}\n\t}\n\n\t/**\n\t * Start the Recorder. Returns a promise which resolves\n\t * when the recorder has started.\n\t */\n\tasync start() {\n\t\tassert(this.state !== \"started\", \"Recorder is already started\");\n\t\tconst startPromise = new Promise<void>(done => {\n\t\t\tconst handleStart = () => {\n\t\t\t\tthis._recorder.removeEventListener(\"start\", handleStart, false);\n\n\t\t\t\tdone();\n\t\t\t};\n\n\t\t\tthis._recorder.addEventListener(\"start\", handleStart, false);\n\t\t});\n\n\t\tthis._recorder.start();\n\t\treturn await startPromise;\n\t}\n\n\t/**\n\t * Stop the recorder. Returns a promise with the recorded content until this point\n\t * encoded as [[mimeType]]\n\t */\n\tasync stop(): Promise<Blob> {\n\t\tassert(this.state !== \"stopped\", \"Recorder is not started\");\n\t\tconst dataPromise: Promise<Blob> = new Promise(done => {\n\t\t\tconst handleData = (e: BlobEvent) => {\n\t\t\t\tthis._recorder.removeEventListener(\"dataavailable\", handleData, false);\n\n\t\t\t\tdone(e.data);\n\t\t\t};\n\n\t\t\tthis._recorder.addEventListener(\"dataavailable\", handleData, false);\n\t\t});\n\t\tthis._recorder.stop();\n\t\treturn await dataPromise;\n\t}\n\n\t/**\n\t * Pause the recorder\n\t */\n\tpause(): this {\n\t\tassert(this.state === \"started\", \"Recorder must be started\");\n\t\tthis._recorder.pause();\n\t\treturn this;\n\t}\n\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis.input.dispose();\n\t\tthis._stream.disconnect();\n\t\treturn this;\n\t}\n}\n","import { Param } from \"../../core/context/Param\";\nimport { ToneAudioNode, ToneAudioNodeOptions } from \"../../core/context/ToneAudioNode\";\nimport { Decibels, Positive, Time } from \"../../core/type/Units\";\nimport { optionsFromArguments } from \"../../core/util/Defaults\";\nimport { readOnly } from \"../../core/util/Interface\";\n\nexport interface CompressorOptions extends ToneAudioNodeOptions {\n\tattack: Time;\n\tknee: Decibels;\n\tratio: Positive;\n\trelease: Time;\n\tthreshold: Decibels;\n}\n\n/**\n * Compressor is a thin wrapper around the Web Audio\n * [DynamicsCompressorNode](http://webaudio.github.io/web-audio-api/#the-dynamicscompressornode-interface).\n * Compression reduces the volume of loud sounds or amplifies quiet sounds\n * by narrowing or \"compressing\" an audio signal's dynamic range.\n * Read more on [Wikipedia](https://en.wikipedia.org/wiki/Dynamic_range_compression).\n * @example\n * const comp = new Tone.Compressor(-30, 3);\n * @category Component\n */\nexport class Compressor extends ToneAudioNode<CompressorOptions> {\n\n\treadonly name: string = \"Compressor\";\n\n\t/**\n\t * the compressor node\n\t */\n\tprivate _compressor: DynamicsCompressorNode = this.context.createDynamicsCompressor();\n\treadonly input = this._compressor;\n\treadonly output = this._compressor;\n\n\t/**\n\t * The decibel value above which the compression will start taking effect.\n\t * @min -100\n\t * @max 0\n\t */\n\treadonly threshold: Param<\"decibels\">;\n\n\t/**\n\t * The amount of time (in seconds) to reduce the gain by 10dB.\n\t * @min 0\n\t * @max 1\n\t */\n\treadonly attack: Param<\"time\">;\n\n\t/**\n\t * The amount of time (in seconds) to increase the gain by 10dB.\n\t * @min 0\n\t * @max 1\n\t */\n\treadonly release: Param<\"time\">;\n\n\t/**\n\t * A decibel value representing the range above the threshold where the\n\t * curve smoothly transitions to the \"ratio\" portion.\n\t * @min 0\n\t * @max 40\n\t */\n\treadonly knee: Param<\"decibels\">;\n\n\t/**\n\t * The amount of dB change in input for a 1 dB change in output.\n\t * @min 1\n\t * @max 20\n\t */\n\treadonly ratio: Param<\"positive\">;\n\n\t/**\n\t * @param threshold The value above which the compression starts to be applied.\n\t * @param ratio The gain reduction ratio.\n\t */\n\tconstructor(threshold?: Decibels, ratio?: Positive);\n\tconstructor(options?: Partial<CompressorOptions>);\n\tconstructor() {\n\n\t\tsuper(optionsFromArguments(Compressor.getDefaults(), arguments, [\"threshold\", \"ratio\"]));\n\t\tconst options = optionsFromArguments(Compressor.getDefaults(), arguments, [\"threshold\", \"ratio\"]);\n\n\t\tthis.threshold = new Param({\n\t\t\tminValue: this._compressor.threshold.minValue,\n\t\t\tmaxValue: this._compressor.threshold.maxValue,\n\t\t\tcontext: this.context,\n\t\t\tconvert: false,\n\t\t\tparam: this._compressor.threshold,\n\t\t\tunits: \"decibels\",\n\t\t\tvalue: options.threshold,\n\t\t});\n\n\t\tthis.attack = new Param({\n\t\t\tminValue: this._compressor.attack.minValue,\n\t\t\tmaxValue: this._compressor.attack.maxValue,\n\t\t\tcontext: this.context,\n\t\t\tparam: this._compressor.attack,\n\t\t\tunits: \"time\",\n\t\t\tvalue: options.attack,\n\t\t});\n\n\t\tthis.release = new Param({\n\t\t\tminValue: this._compressor.release.minValue,\n\t\t\tmaxValue: this._compressor.release.maxValue,\n\t\t\tcontext: this.context,\n\t\t\tparam: this._compressor.release,\n\t\t\tunits: \"time\",\n\t\t\tvalue: options.release,\n\t\t});\n\n\t\tthis.knee = new Param({\n\t\t\tminValue: this._compressor.knee.minValue,\n\t\t\tmaxValue: this._compressor.knee.maxValue,\n\t\t\tcontext: this.context,\n\t\t\tconvert: false,\n\t\t\tparam: this._compressor.knee,\n\t\t\tunits: \"decibels\",\n\t\t\tvalue: options.knee,\n\t\t});\n\n\t\tthis.ratio = new Param({\n\t\t\tminValue: this._compressor.ratio.minValue,\n\t\t\tmaxValue: this._compressor.ratio.maxValue,\n\t\t\tcontext: this.context,\n\t\t\tconvert: false,\n\t\t\tparam: this._compressor.ratio,\n\t\t\tunits: \"positive\",\n\t\t\tvalue: options.ratio,\n\t\t});\n\n\t\t// set the defaults\n\t\treadOnly(this, [\"knee\", \"release\", \"attack\", \"ratio\", \"threshold\"]);\n\t}\n\n\tstatic getDefaults(): CompressorOptions {\n\t\treturn Object.assign(ToneAudioNode.getDefaults(), {\n\t\t\tattack: 0.003,\n\t\t\tknee: 30,\n\t\t\tratio: 12,\n\t\t\trelease: 0.25,\n\t\t\tthreshold: -24,\n\t\t});\n\t}\n\n\t/**\n\t * A read-only decibel value for metering purposes, representing the current amount of gain\n\t * reduction that the compressor is applying to the signal. If fed no signal the value will be 0 (no gain reduction).\n\t */\n\tget reduction(): Decibels {\n\t\treturn this._compressor.reduction;\n\t}\n\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis._compressor.disconnect();\n\t\tthis.attack.dispose();\n\t\tthis.release.dispose();\n\t\tthis.threshold.dispose();\n\t\tthis.ratio.dispose();\n\t\tthis.knee.dispose();\n\t\treturn this;\n\t}\n}\n","import { ToneAudioNode, ToneAudioNodeOptions } from \"../../core/context/ToneAudioNode\";\nimport { Decibels, Time } from \"../../core/type/Units\";\nimport { GreaterThan } from \"../../signal/GreaterThan\";\nimport { Gain } from \"../../core/context/Gain\";\nimport { Follower } from \"../analysis/Follower\";\nimport { optionsFromArguments } from \"../../core/util/Defaults\";\nimport { dbToGain, gainToDb } from \"../../core/type/Conversions\";\n\nexport interface GateOptions extends ToneAudioNodeOptions {\n\tthreshold: Decibels;\n\tsmoothing: Time;\n}\n\n/**\n * Gate only passes a signal through when the incoming\n * signal exceeds a specified threshold. It uses [[Follower]] to follow the ampltiude\n * of the incoming signal and compares it to the [[threshold]] value using [[GreaterThan]].\n *\n * @example\n * const gate = new Tone.Gate(-30, 0.2).toDestination();\n * const mic = new Tone.UserMedia().connect(gate);\n * // the gate will only pass through the incoming\n * // signal when it's louder than -30db\n * @category Component\n */\nexport class Gate extends ToneAudioNode<GateOptions> {\n\n\treadonly name: string = \"Gate\";\n\n\treadonly input: ToneAudioNode;\n\treadonly output: ToneAudioNode;\n\n\t/**\n\t * Follow the incoming signal\n\t */\n\tprivate _follower: Follower;\n\n\t/**\n\t * Test if it's greater than the threshold\n\t */\n\tprivate _gt: GreaterThan;\n\n\t/**\n\t * Gate the incoming signal when it does not exceed the threshold\n\t */\n\tprivate _gate: Gain;\n\n\t/**\n\t * @param threshold The threshold above which the gate will open.\n\t * @param smoothing The follower's smoothing time\n\t */\n\tconstructor(threshold?: Decibels, smoothing?: Time);\n\tconstructor(options?: Partial<GateOptions>);\n\tconstructor() {\n\t\tsuper(Object.assign(optionsFromArguments(Gate.getDefaults(), arguments, [\"threshold\", \"smoothing\"])));\n\t\tconst options = optionsFromArguments(Gate.getDefaults(), arguments, [\"threshold\", \"smoothing\"]);\n\n\t\tthis._follower = new Follower({\n\t\t\tcontext: this.context,\n\t\t\tsmoothing: options.smoothing,\n\t\t});\n\t\tthis._gt = new GreaterThan({\n\t\t\tcontext: this.context,\n\t\t\tvalue: dbToGain(options.threshold),\n\t\t});\n\t\tthis.input = new Gain({ context: this.context });\n\t\tthis._gate = this.output = new Gain({ context: this.context });\n\n\t\t// connections\n\t\tthis.input.connect(this._gate);\n\t\t// the control signal\n\t\tthis.input.chain(this._follower, this._gt, this._gate.gain);\n\t}\n\n\tstatic getDefaults(): GateOptions {\n\t\treturn Object.assign(ToneAudioNode.getDefaults(), {\n\t\t\tsmoothing: 0.1,\n\t\t\tthreshold: -40\n\t\t});\n\t}\n\n\t/**\n\t * The threshold of the gate in decibels\n\t */\n\tget threshold(): Decibels {\n\t\treturn gainToDb(this._gt.value);\n\t}\n\tset threshold(thresh) {\n\t\tthis._gt.value = dbToGain(thresh);\n\t}\n\n\t/**\n\t * The attack/decay speed of the gate. See [[Follower.smoothing]]\n\t */\n\tget smoothing(): Time {\n\t\treturn this._follower.smoothing;\n\t}\n\tset smoothing(smoothingTime) {\n\t\tthis._follower.smoothing = smoothingTime;\n\t}\n\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis.input.dispose();\n\t\tthis._follower.dispose();\n\t\tthis._gt.dispose();\n\t\tthis._gate.dispose();\n\t\treturn this;\n\t}\n}\n","import { InputNode, OutputNode, ToneAudioNode, ToneAudioNodeOptions } from \"../../core/context/ToneAudioNode\";\nimport { Decibels } from \"../../core/type/Units\";\nimport { optionsFromArguments } from \"../../core/util/Defaults\";\nimport { Compressor } from \"./Compressor\";\nimport { Param } from \"../../core/context/Param\";\nimport { readOnly } from \"../../core/util/Interface\";\n\nexport interface LimiterOptions extends ToneAudioNodeOptions {\n\tthreshold: Decibels;\n}\n\n/**\n * Limiter will limit the loudness of an incoming signal.\n * Under the hood it's composed of a [[Compressor]] with a fast attack\n * and release and max compression ratio. \n *\n * @example\n * const limiter = new Tone.Limiter(-20).toDestination();\n * const oscillator = new Tone.Oscillator().connect(limiter);\n * oscillator.start();\n * @category Component\n */\nexport class Limiter extends ToneAudioNode<LimiterOptions> {\n\n\treadonly name: string = \"Limiter\";\n\n\treadonly input: InputNode;\n\treadonly output: OutputNode;\n\n\t/**\n\t * The compressor which does the limiting\n\t */\n\tprivate _compressor: Compressor;\n\n\treadonly threshold: Param<\"decibels\">\n\n\t/**\n\t * @param threshold The threshold above which the gain reduction is applied.\n\t */\n\tconstructor(threshold?: Decibels);\n\tconstructor(options?: Partial<LimiterOptions>);\n\tconstructor() {\n\t\tsuper(Object.assign(optionsFromArguments(Limiter.getDefaults(), arguments, [\"threshold\"])));\n\t\tconst options = optionsFromArguments(Limiter.getDefaults(), arguments, [\"threshold\"]);\n\n\t\tthis._compressor = this.input = this.output = new Compressor({\n\t\t\tcontext: this.context,\n\t\t\tratio: 20,\n\t\t\tattack: 0.003,\n\t\t\trelease: 0.01,\n\t\t\tthreshold: options.threshold\n\t\t});\n\n\t\tthis.threshold = this._compressor.threshold;\n\t\treadOnly(this, \"threshold\");\n\t}\n\n\tstatic getDefaults(): LimiterOptions {\n\t\treturn Object.assign(ToneAudioNode.getDefaults(), {\n\t\t\tthreshold: -12\n\t\t});\n\t}\n\n\t/**\n\t * A read-only decibel value for metering purposes, representing the current amount of gain\n\t * reduction that the compressor is applying to the signal. \n\t */\n\tget reduction(): Decibels {\n\t\treturn this._compressor.reduction;\n\t}\n\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis._compressor.dispose();\n\t\tthis.threshold.dispose();\n\t\treturn this;\n\t}\n}\n","import { InputNode, OutputNode, ToneAudioNode, ToneAudioNodeOptions } from \"../../core/context/ToneAudioNode\";\nimport { Compressor, CompressorOptions } from \"./Compressor\";\nimport { optionsFromArguments } from \"../../core/util/Defaults\";\nimport { MidSideSplit } from \"../channel/MidSideSplit\";\nimport { MidSideMerge } from \"../channel/MidSideMerge\";\nimport { readOnly, RecursivePartial } from \"../../core/util/Interface\";\n\nexport interface MidSideCompressorOptions extends ToneAudioNodeOptions {\n\tmid: Omit<CompressorOptions, keyof ToneAudioNodeOptions>;\n\tside: Omit<CompressorOptions, keyof ToneAudioNodeOptions>;\n}\n\n/**\n * MidSideCompressor applies two different compressors to the [[mid]]\n * and [[side]] signal components of the input. See [[MidSideSplit]] and [[MidSideMerge]].\n * @category Component\n */\nexport class MidSideCompressor extends ToneAudioNode<MidSideCompressorOptions> {\n\n\treadonly name: string = \"MidSideCompressor\";\n\n\treadonly input: InputNode;\n\treadonly output: OutputNode;\n\n\t/**\n\t * Split the incoming signal into Mid/Side\n\t */\n\tprivate _midSideSplit: MidSideSplit;\n\n\t/**\n\t * Merge the compressed signal back into a single stream\n\t */\n\tprivate _midSideMerge: MidSideMerge;\n\n\t/**\n\t * The compression applied to the mid signal\n\t */\n\treadonly mid: Compressor;\n\n\t/**\n\t * The compression applied to the side signal\n\t */\n\treadonly side: Compressor;\n\n\tconstructor(options?: RecursivePartial<MidSideCompressorOptions>);\n\tconstructor() {\n\t\tsuper(Object.assign(optionsFromArguments(MidSideCompressor.getDefaults(), arguments)));\n\t\tconst options = optionsFromArguments(MidSideCompressor.getDefaults(), arguments);\n\n\t\tthis._midSideSplit = this.input = new MidSideSplit({ context: this.context });\n\t\tthis._midSideMerge = this.output = new MidSideMerge({ context: this.context });\n\t\tthis.mid = new Compressor(Object.assign(options.mid, { context: this.context }));\n\t\tthis.side = new Compressor(Object.assign(options.side, { context: this.context }));\n\n\t\tthis._midSideSplit.mid.chain(this.mid, this._midSideMerge.mid);\n\t\tthis._midSideSplit.side.chain(this.side, this._midSideMerge.side);\n\t\treadOnly(this, [\"mid\", \"side\"]);\n\t}\n\n\tstatic getDefaults(): MidSideCompressorOptions {\n\t\treturn Object.assign(ToneAudioNode.getDefaults(), {\n\t\t\tmid: {\n\t\t\t\tratio: 3,\n\t\t\t\tthreshold: -24,\n\t\t\t\trelease: 0.03,\n\t\t\t\tattack: 0.02,\n\t\t\t\tknee: 16\n\t\t\t},\n\t\t\tside: {\n\t\t\t\tratio: 6,\n\t\t\t\tthreshold: -30,\n\t\t\t\trelease: 0.25,\n\t\t\t\tattack: 0.03,\n\t\t\t\tknee: 10\n\t\t\t}\n\t\t});\n\t}\n\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis.mid.dispose();\n\t\tthis.side.dispose();\n\t\tthis._midSideSplit.dispose();\n\t\tthis._midSideMerge.dispose();\n\t\treturn this;\n\t}\n}\n","import { InputNode, ToneAudioNode, ToneAudioNodeOptions } from \"../../core/context/ToneAudioNode\";\nimport { Compressor, CompressorOptions } from \"./Compressor\";\nimport { optionsFromArguments } from \"../../core/util/Defaults\";\nimport { readOnly, RecursivePartial } from \"../../core/util/Interface\";\nimport { Frequency } from \"../../core/type/Units\";\nimport { MultibandSplit } from \"../channel/MultibandSplit\";\nimport { Signal } from \"../../signal/Signal\";\nimport { Gain } from \"../../core/context/Gain\";\n\nexport interface MultibandCompressorOptions extends ToneAudioNodeOptions {\n\tmid: Omit<CompressorOptions, keyof ToneAudioNodeOptions>;\n\tlow: Omit<CompressorOptions, keyof ToneAudioNodeOptions>;\n\thigh: Omit<CompressorOptions, keyof ToneAudioNodeOptions>;\n\tlowFrequency: Frequency;\n\thighFrequency: Frequency;\n}\n\n/**\n * A compressor with separate controls over low/mid/high dynamics. See [[Compressor]] and [[MultibandSplit]]\n *\n * @example\n * const multiband = new Tone.MultibandCompressor({\n * \tlowFrequency: 200,\n * \thighFrequency: 1300,\n * \tlow: {\n * \t\tthreshold: -12\n * \t}\n * });\n * @category Component\n */\nexport class MultibandCompressor extends ToneAudioNode<MultibandCompressorOptions> {\n\n\treadonly name: string = \"MultibandCompressor\";\n\n\treadonly input: InputNode;\n\treadonly output: ToneAudioNode;\n\n\t/**\n\t * Split the incoming signal into high/mid/low\n\t */\n\tprivate _splitter: MultibandSplit;\n\n\t/**\n\t * low/mid crossover frequency.\n\t */\n\treadonly lowFrequency: Signal<\"frequency\">;\n\n\t/**\n\t * mid/high crossover frequency.\n\t */\n\treadonly highFrequency: Signal<\"frequency\">;\n\n\t/**\n\t * The compressor applied to the low frequencies\n\t */\n\treadonly low: Compressor;\n\n\t/**\n\t * The compressor applied to the mid frequencies\n\t */\n\treadonly mid: Compressor;\n\n\t/**\n\t * The compressor applied to the high frequencies\n\t */\n\treadonly high: Compressor;\n\n\tconstructor(options?: RecursivePartial<MultibandCompressorOptions>);\n\tconstructor() {\n\t\tsuper(Object.assign(optionsFromArguments(MultibandCompressor.getDefaults(), arguments)));\n\t\tconst options = optionsFromArguments(MultibandCompressor.getDefaults(), arguments);\n\n\t\tthis._splitter = this.input = new MultibandSplit({\n\t\t\tcontext: this.context,\n\t\t\tlowFrequency: options.lowFrequency,\n\t\t\thighFrequency: options.highFrequency\n\t\t});\n\t\tthis.lowFrequency = this._splitter.lowFrequency;\n\t\tthis.highFrequency = this._splitter.highFrequency;\n\t\tthis.output = new Gain({ context: this.context });\n\t\tthis.low = new Compressor(Object.assign(options.low, { context: this.context }));\n\t\tthis.mid = new Compressor(Object.assign(options.mid, { context: this.context }));\n\t\tthis.high = new Compressor(Object.assign(options.high, { context: this.context }));\n\n\t\t// connect the compressor\n\t\tthis._splitter.low.chain(this.low, this.output);\n\t\tthis._splitter.mid.chain(this.mid, this.output);\n\t\tthis._splitter.high.chain(this.high, this.output);\n\n\t\treadOnly(this, [\"high\", \"mid\", \"low\", \"highFrequency\", \"lowFrequency\"]);\n\t}\n\n\tstatic getDefaults(): MultibandCompressorOptions {\n\t\treturn Object.assign(ToneAudioNode.getDefaults(), {\n\t\t\tlowFrequency: 250,\n\t\t\thighFrequency: 2000,\n\t\t\tlow: {\n\t\t\t\tratio: 6,\n\t\t\t\tthreshold: -30,\n\t\t\t\trelease: 0.25,\n\t\t\t\tattack: 0.03,\n\t\t\t\tknee: 10\n\t\t\t},\n\t\t\tmid: {\n\t\t\t\tratio: 3,\n\t\t\t\tthreshold: -24,\n\t\t\t\trelease: 0.03,\n\t\t\t\tattack: 0.02,\n\t\t\t\tknee: 16\n\t\t\t},\n\t\t\thigh: {\n\t\t\t\tratio: 3,\n\t\t\t\tthreshold: -24,\n\t\t\t\trelease: 0.03,\n\t\t\t\tattack: 0.02,\n\t\t\t\tknee: 16\n\t\t\t},\n\t\t});\n\t}\n\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis._splitter.dispose();\n\t\tthis.low.dispose();\n\t\tthis.mid.dispose();\n\t\tthis.high.dispose();\n\t\tthis.output.dispose();\n\t\treturn this;\n\t}\n}\n","import { Gain } from \"../../core/context/Gain\";\nimport { Param } from \"../../core/context/Param\";\nimport { ToneAudioNode, ToneAudioNodeOptions } from \"../../core/context/ToneAudioNode\";\nimport { Decibels, Frequency } from \"../../core/type/Units\";\nimport { optionsFromArguments } from \"../../core/util/Defaults\";\nimport { readOnly, writable } from \"../../core/util/Interface\";\nimport { Signal } from \"../../signal/Signal\";\nimport { MultibandSplit } from \"../channel/MultibandSplit\";\n\ninterface EQ3Options extends ToneAudioNodeOptions {\n\tlow: Decibels;\n\tmid: Decibels;\n\thigh: Decibels;\n\tlowFrequency: Frequency;\n\thighFrequency: Frequency;\n}\n\n/**\n * EQ3 provides 3 equalizer bins: Low/Mid/High. \n * @category Component\n */\nexport class EQ3 extends ToneAudioNode<EQ3Options> {\n\n\treadonly name: string = \"EQ3\";\n\n\t/**\n\t * the input\n\t */\n\treadonly input: MultibandSplit;\n\n\t/**\n\t * the output\n\t */\n\treadonly output = new Gain({ context: this.context });\n\n\t/**\n\t * Splits the input into three outputs\n\t */\n\tprivate _multibandSplit: MultibandSplit;\n\n\t/**\n\t * The gain for the lower signals\n\t */\n\tprivate _lowGain: Gain<\"decibels\">;\n\n\t/**\n\t * The gain for the mid signals\n\t */\n\tprivate _midGain: Gain<\"decibels\">;\n\n\t/**\n\t * The gain for the high signals\n\t */\n\tprivate _highGain: Gain<\"decibels\">;\n\n\t/**\n\t * The gain in decibels of the low part\n\t */\n\treadonly low: Param<\"decibels\">;\n\n\t/**\n\t * The gain in decibels of the mid part\n\t */\n\treadonly mid: Param<\"decibels\">;\n\n\t/**\n\t * The gain in decibels of the high part\n\t */\n\treadonly high: Param<\"decibels\">;\n\n\t/**\n\t * The Q value for all of the filters.\n\t */\n\treadonly Q: Signal<\"positive\">;\n\n\t/**\n\t * The low/mid crossover frequency.\n\t */\n\treadonly lowFrequency: Signal<\"frequency\">;\n\n\t/**\n\t * The mid/high crossover frequency.\n\t */\n\treadonly highFrequency: Signal<\"frequency\">;\n\n\tprotected _internalChannels: ToneAudioNode[] = [];\n\n\tconstructor(lowLevel?: Decibels, midLevel?: Decibels, highLevel?: Decibels);\n\tconstructor(options: Partial<EQ3Options>);\n\tconstructor() {\n\t\tsuper(optionsFromArguments(EQ3.getDefaults(), arguments, [\"low\", \"mid\", \"high\"]));\n\t\tconst options = optionsFromArguments(EQ3.getDefaults(), arguments, [\"low\", \"mid\", \"high\"]);\n\n\t\tthis.input = this._multibandSplit = new MultibandSplit({\n\t\t\tcontext: this.context,\n\t\t\thighFrequency: options.highFrequency,\n\t\t\tlowFrequency: options.lowFrequency,\n\t\t});\n\n\t\tthis._lowGain = new Gain({\n\t\t\tcontext: this.context,\n\t\t\tgain: options.low,\n\t\t\tunits: \"decibels\",\n\t\t});\n\n\t\tthis._midGain = new Gain({\n\t\t\tcontext: this.context,\n\t\t\tgain: options.mid,\n\t\t\tunits: \"decibels\",\n\t\t});\n\n\t\tthis._highGain = new Gain({\n\t\t\tcontext: this.context,\n\t\t\tgain: options.high,\n\t\t\tunits: \"decibels\",\n\t\t});\n\n\t\tthis.low = this._lowGain.gain;\n\t\tthis.mid = this._midGain.gain;\n\t\tthis.high = this._highGain.gain;\n\t\tthis.Q = this._multibandSplit.Q;\n\t\tthis.lowFrequency = this._multibandSplit.lowFrequency;\n\t\tthis.highFrequency\t= this._multibandSplit.highFrequency;\n\n\t\t// the frequency bands\n\t\tthis._multibandSplit.low.chain(this._lowGain, this.output);\n\t\tthis._multibandSplit.mid.chain(this._midGain, this.output);\n\t\tthis._multibandSplit.high.chain(this._highGain, this.output);\n\n\t\treadOnly(this, [\"low\", \"mid\", \"high\", \"lowFrequency\", \"highFrequency\"]);\n\t\tthis._internalChannels = [this._multibandSplit];\n\t}\n\n\tstatic getDefaults(): EQ3Options {\n\t\treturn Object.assign(ToneAudioNode.getDefaults(), {\n\t\t\thigh: 0,\n\t\t\thighFrequency: 2500,\n\t\t\tlow: 0,\n\t\t\tlowFrequency: 400,\n\t\t\tmid: 0,\n\t\t});\n\t}\n\n\t/**\n\t * Clean up.\n\t */\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\twritable(this, [\"low\", \"mid\", \"high\", \"lowFrequency\", \"highFrequency\"]);\n\t\tthis._multibandSplit.dispose();\n\t\tthis.lowFrequency.dispose();\n\t\tthis.highFrequency.dispose();\n\t\tthis._lowGain.dispose();\n\t\tthis._midGain.dispose();\n\t\tthis._highGain.dispose();\n\t\tthis.low.dispose();\n\t\tthis.mid.dispose();\n\t\tthis.high.dispose();\n\t\tthis.Q.dispose();\n\t\treturn this;\n\t}\n\n}\n","import { ToneAudioNode, ToneAudioNodeOptions } from \"../../core/context/ToneAudioNode\";\nimport { ToneAudioBuffer } from \"../../core/context/ToneAudioBuffer\";\nimport { optionsFromArguments } from \"../../core/util/Defaults\";\nimport { Gain } from \"../../core/context/Gain\";\nimport { noOp } from \"../../core/util/Interface\";\n\nexport interface ConvolverOptions extends ToneAudioNodeOptions {\n\tonload: () => void;\n\tnormalize: boolean;\n\turl?: string | AudioBuffer | ToneAudioBuffer;\n}\n\n/**\n * Convolver is a wrapper around the Native Web Audio\n * [ConvolverNode](http://webaudio.github.io/web-audio-api/#the-convolvernode-interface).\n * Convolution is useful for reverb and filter emulation. Read more about convolution reverb on\n * [Wikipedia](https://en.wikipedia.org/wiki/Convolution_reverb).\n *\n * @example\n * // initializing the convolver with an impulse response\n * const convolver = new Tone.Convolver(\"./path/to/ir.wav\").toDestination();\n * @category Component\n */\nexport class Convolver extends ToneAudioNode<ConvolverOptions> {\n\n\treadonly name: string = \"Convolver\";\n\n\t/**\n\t * The native ConvolverNode\n\t */\n\tprivate _convolver: ConvolverNode = this.context.createConvolver();\n\n\t/**\n\t * The Buffer belonging to the convolver\n\t */\n\tprivate _buffer: ToneAudioBuffer;\n\n\treadonly input: Gain;\n\treadonly output: Gain;\n\n\t/**\n\t * @param url The URL of the impulse response or the ToneAudioBuffer containing the impulse response.\n\t * @param onload The callback to invoke when the url is loaded.\n\t */\n\tconstructor(url?: string | AudioBuffer | ToneAudioBuffer, onload?: () => void);\n\tconstructor(options?: Partial<ConvolverOptions>);\n\tconstructor() {\n\n\t\tsuper(optionsFromArguments(Convolver.getDefaults(), arguments, [\"url\", \"onload\"]));\n\t\tconst options = optionsFromArguments(Convolver.getDefaults(), arguments, [\"url\", \"onload\"]);\n\n\t\tthis._buffer = new ToneAudioBuffer(options.url, buffer => {\n\t\t\tthis.buffer = buffer;\n\t\t\toptions.onload();\n\t\t});\n\n\t\tthis.input = new Gain({ context: this.context });\n\t\tthis.output = new Gain({ context: this.context });\n\n\t\t// set if it's already loaded, set it immediately\n\t\tif (this._buffer.loaded) {\n\t\t\tthis.buffer = this._buffer;\n\t\t}\n\n\t\t// initially set normalization\n\t\tthis.normalize = options.normalize;\n\n\t\t// connect it up\n\t\tthis.input.chain(this._convolver, this.output);\n\t}\n\n\tstatic getDefaults(): ConvolverOptions {\n\t\treturn Object.assign(ToneAudioNode.getDefaults(), {\n\t\t\tnormalize: true,\n\t\t\tonload: noOp,\n\t\t});\n\t}\n\n\t/**\n\t * Load an impulse response url as an audio buffer.\n\t * Decodes the audio asynchronously and invokes\n\t * the callback once the audio buffer loads.\n\t * @param url The url of the buffer to load. filetype support depends on the browser.\n\t */\n\tasync load(url: string): Promise<void> {\n\t\tthis.buffer = await this._buffer.load(url);\n\t}\n\n\t/**\n\t * The convolver's buffer\n\t */\n\tget buffer(): ToneAudioBuffer | null {\n\t\tif (this._buffer.length) {\n\t\t\treturn this._buffer;\n\t\t} else {\n\t\t\treturn null;\n\t\t}\n\t}\n\tset buffer(buffer) {\n\t\tif (buffer) {\n\t\t\tthis._buffer.set(buffer);\n\t\t}\n\t\t// if it's already got a buffer, create a new one\n\t\tif (this._convolver.buffer) {\n\t\t\t// disconnect the old one\n\t\t\tthis.input.disconnect();\n\t\t\tthis._convolver.disconnect();\n\t\t\t// create and connect a new one\n\t\t\tthis._convolver = this.context.createConvolver();\n\t\t\tthis.input.chain(this._convolver, this.output);\n\t\t}\n\t\tconst buff = this._buffer.get();\n\t\tthis._convolver.buffer = buff ? buff : null;\n\t}\n\n\t/**\n\t * The normalize property of the ConvolverNode interface is a boolean that\n\t * controls whether the impulse response from the buffer will be scaled by\n\t * an equal-power normalization when the buffer attribute is set, or not.\n\t */\n\tget normalize(): boolean {\n\t\treturn this._convolver.normalize;\n\t}\n\tset normalize(norm) {\n\t\tthis._convolver.normalize = norm;\n\t}\n\n\tdispose(): this {\n\t\tsuper.dispose();\n\t\tthis._buffer.dispose();\n\t\tthis._convolver.disconnect();\n\t\treturn this;\n\t}\n}\n","export { getContext, setContext } from \"./core/Global\";\nexport * from \"./classes\";\nexport * from \"./version\";\nimport { getContext } from \"./core/Global\";\nimport { ToneAudioBuffer } from \"./core/context/ToneAudioBuffer\";\nexport { start } from \"./core/Global\";\nimport { Seconds } from \"./core/type/Units\";\nexport { supported } from \"./core/context/AudioContext\";\n\n/**\n * The current audio context time of the global [[Context]]. \n * See [[Context.now]]\n * @category Core\n */\nexport function now(): Seconds {\n\treturn getContext().now();\n}\n\n/**\n * The current audio context time of the global [[Context]] without the [[Context.lookAhead]]\n * See [[Context.immediate]]\n * @category Core\n */\nexport function immediate(): Seconds {\n\treturn getContext().immediate();\n}\n\n/**\n * The Transport object belonging to the global Tone.js Context.\n * See [[Transport]]\n * @category Core\n */\nexport const Transport = getContext().transport;\n\n/**\n * The Transport object belonging to the global Tone.js Context.\n * See [[Transport]]\n * @category Core\n */\nexport function getTransport(): import(\"./core/clock/Transport\").Transport {\n\treturn getContext().transport;\n}\n\n/**\n * The Destination (output) belonging to the global Tone.js Context.\n * See [[Destination]]\n * @category Core\n */\nexport const Destination = getContext().destination;\n\n/**\n * @deprecated Use [[Destination]]\n */\nexport const Master = getContext().destination;\n\n/**\n * The Destination (output) belonging to the global Tone.js Context.\n * See [[Destination]]\n * @category Core\n */\nexport function getDestination(): import(\"./core/context/Destination\").Destination {\n\treturn getContext().destination;\n}\n\n/**\n * The [[Listener]] belonging to the global Tone.js Context.\n * @category Core\n */\nexport const Listener = getContext().listener;\n\n/**\n * The [[Listener]] belonging to the global Tone.js Context.\n * @category Core\n */\nexport function getListener(): import(\"./core/context/Listener\").Listener {\n\treturn getContext().listener;\n}\n\n/**\n * Draw is used to synchronize the draw frame with the Transport's callbacks. \n * See [[Draw]]\n * @category Core\n */\nexport const Draw = getContext().draw;\n\n/**\n * Get the singleton attached to the global context. \n * Draw is used to synchronize the draw frame with the Transport's callbacks. \n * See [[Draw]]\n * @category Core\n */\nexport function getDraw(): import(\"./core/util/Draw\").Draw {\n\treturn getContext().draw;\n}\n\n/**\n * A reference to the global context\n * See [[Context]]\n */\nexport const context = getContext();\n\n/**\n * Promise which resolves when all of the loading promises are resolved. \n * Alias for static [[ToneAudioBuffer.loaded]] method.\n * @category Core\n */\nexport function loaded() {\n\treturn ToneAudioBuffer.loaded();\n}\n\n// this fills in name changes from 13.x to 14.x\nimport { ToneAudioBuffers } from \"./core/context/ToneAudioBuffers\";\nimport { ToneBufferSource } from \"./source/buffer/ToneBufferSource\";\nexport const Buffer: typeof ToneAudioBuffer = ToneAudioBuffer;\nexport const Buffers: typeof ToneAudioBuffers = ToneAudioBuffers;\nexport const BufferSource: typeof ToneBufferSource = ToneBufferSource;\n"],"names":["root","factory","exports","module","define","amd","self","this","arr","len","length","i","arr2","Array","__esModule","isArray","instance","Constructor","TypeError","_defineProperties","target","props","descriptor","enumerable","configurable","writable","Object","defineProperty","key","protoProps","staticProps","prototype","_i","Symbol","iterator","_s","_e","_arr","_n","_d","call","next","done","push","value","err","arrayWithHoles","iterableToArrayLimit","unsupportedIterableToArray","nonIterableRest","arrayLikeToArray","o","minLen","n","toString","slice","constructor","name","from","test","_slicedToArray","_classCallCheck","_createClass","_interopDefaultLegacy","e","_slicedToArray__default","_classCallCheck__default","_createClass__default","createExtendedExponentialRampToValueAutomationEvent","endTime","insertTime","type","createExtendedLinearRampToValueAutomationEvent","createSetValueAutomationEvent","startTime","createSetValueCurveAutomationEvent","values","duration","getTargetValueAtTime","time","valueAtStartTime","_ref","timeConstant","Math","exp","isExponentialRampToValueAutomationEvent","automationEvent","isLinearRampToValueAutomationEvent","isAnyRampToValueAutomationEvent","isSetValueAutomationEvent","isSetValueCurveAutomationEvent","getValueOfAutomationEventAtIndexAtTime","automationEvents","index","defaultValue","undefined","getEndTimeAndValueOfPreviousAutomationEvent","currentAutomationEvent","nextAutomationEvent","isCancelAndHoldAutomationEvent","isCancelScheduledValuesAutomationEvent","getEventTime","cancelTime","getExponentialRampValueAtTime","pow","getLinearRampValueAtTime","getValueCurveValueAtTime","theoreticIndex","lowerIndex","floor","upperIndex","ceil","interpolateValue","isSetTargetAutomationEvent","AutomationEventList","_Symbol$iterator","_automationEvents","_currenTime","_defaultValue","eventTime","findIndex","removedAutomationEvent","lastAutomationEvent","Error","startValue","truncatedAutomationEvent","getValue","Float32Array","_index","previousAutomationEvent","persistentAutomationEvent","splice","remainingAutomationEvents","firstRemainingAutomationEvent","unshift","indexOfNextEvent","indexOfCurrentEvent","_getEndTimeAndValueOf","_getEndTimeAndValueOf2","_getEndTimeAndValueOf3","_getEndTimeAndValueOf4","_startTime","_value","createCancelAndHoldAutomationEvent","createCancelScheduledValuesAutomationEvent","createExponentialRampToValueAutomationEvent","createLinearRampToValueAutomationEvent","createSetTargetAutomationEvent","__webpack_module_cache__","__webpack_require__","moduleId","cachedModule","__webpack_modules__","d","definition","get","obj","prop","hasOwnProperty","r","toStringTag","version","ACTIVE_AUDIO_NODE_STORE","WeakSet","AUDIO_NODE_CONNECTIONS_STORE","WeakMap","AUDIO_NODE_STORE","AUDIO_PARAM_CONNECTIONS_STORE","AUDIO_PARAM_STORE","CONTEXT_STORE","EVENT_LISTENERS","CYCLE_COUNTERS","NODE_NAME_TO_PROCESSOR_CONSTRUCTOR_MAPS","NODE_TO_PROCESSOR_MAPS","handler","construct","IMPORT_STATEMENT_REGEX","splitImportStatements","source","url","importStatements","sourceWithoutImportStatements","replace","result","match","unresolvedUrl","importStatementWithResolvedUrl","URL","join","verifyParameterDescriptors","parameterDescriptors","verifyProcessorCtor","processorCtor","constructible","Proxy","isConstructible","getValueForKey","map","pickElementFromSet","set","predicate","matchingElements","filter","matchingElement","delete","deletePassiveInputConnectionToAudioNode","passiveInputs","output","input","passiveInputConnections","matchingConnection","passiveInputConnection","size","getEventListenersOfAudioNode","audioNode","setInternalStateToActive","has","add","forEach","eventListener","isAudioWorkletNode","setInternalStateToPassive","setInternalStateToPassiveWhenNecessary","activeInputs","every","connections","DEFAULT_OPTIONS","channelCount","channelCountMode","channelInterpretation","fftSize","maxDecibels","minDecibels","smoothingTimeConstant","isOwnedByContext","nativeAudioNode","nativeContext","context","testAudioBufferCopyChannelMethodsOutOfBoundsSupport","nativeAudioBuffer","copyToChannel","createIndexSizeError","DOMException","wrapAudioBufferGetChannelDataMethod","audioBuffer","getChannelData","channel","code","numberOfChannels","MOST_NEGATIVE_SINGLE_FLOAT","MOST_POSITIVE_SINGLE_FLOAT","isActiveAudioNode","buffer","loop","loopEnd","loopStart","playbackRate","getAudioNodeConnections","getAudioParamConnections","audioParam","deactivateActiveAudioNodeInputConnections","trace","includes","audioParams","isAudioBufferSourceNode","parameters","isBiquadFilterNode","Q","detune","frequency","gain","isConstantSourceNode","offset","isGainNode","isOscillatorNode","isStereoPannerNode","pan","audioParamConnections","deactivateAudioGraph","destination","isAudioNode","audioNodeOrAudioParam","isAudioNodeOutputConnection","outputConnection","insertElementInSet","element","ignoreDuplicates","lmnt","addActiveInputConnectionToAudioParam","activeInputConnection","addPassiveInputConnectionToAudioParam","Set","isNativeAudioNodeFaker","nativeAudioNodeOrNativeAudioNodeFaker","connectNativeAudioNodeToNativeAudioNode","nativeSourceAudioNode","nativeDestinationAudioNode","fakeNativeDestinationAudioNode","inputs","connect","deleteActiveInputConnection","activeInputConnections","deleteEventListenerOfAudioNode","deletePassiveInputConnectionToAudioParam","disconnectNativeAudioNodeFromNativeAudioNode","disconnect","getNativeAudioNode","getNativeAudioParam","isPartOfACycle","isPassiveAudioNode","testAudioNodeDisconnectMethodSupport","nativeAudioContext","nativeAudioWorkletNodeConstructor","Promise","resolve","analyzer","createScriptProcessor","dummy","createGain","ones","createBuffer","channelData","createBufferSource","onaudioprocess","event","chnnlDt","inputBuffer","some","sample","stop","start","visitEachAudioNodeOnce","cycles","visitor","counts","Map","cycle","count","isNativeAudioNode","nativeAudioNodeOrAudioParam","wrapAudioNodeDisconnectMethod","returnValue","connectionsToDestination","connection","bind","destinationOrOutput","apply","clear","filteredConnections","deleteInputsOfAudioNode","isOffline","listener","isActive","deleteInputConnectionOfAudioNode","deleteInputsOfAudioParam","deleteInputConnectionOfAudioParam","ReadOnlyMap","_map","entries","callback","thisArg","keys","numberOfInputs","numberOfOutputs","parameterData","processorOptions","copyFromChannel","parent","channelNumber","bufferOffset","byteLength","slicedInput","BYTES_PER_ELEMENT","createNestedArrays","x","y","arrays","array","j","processBuffer","async","proxy","renderedBuffer","nativeOfflineAudioContext","options","outputChannelCount","processorConstructor","exposeCurrentFrameAndCurrentTime","numberOfInputChannels","numberOfOutputChannels","reduce","sum","processedBuffer","sampleRate","audioNodeConnections","audioWorkletProcessor","nodeToProcessorMap","nativeAudioWorkletNode","getAudioWorkletProcessor","outputs","prmtrs","k","potentiallyEmptyInputs","activeSourceFlag","process","outputChannelSplitterNodeOutput","error","dispatchEvent","ErrorEvent","colno","filename","lineno","message","disableNormalization","detachArrayBuffer","arrayBuffer","port1","port2","MessageChannel","closeAndResolve","onmessage","close","postMessage","delayTime","maxDelayTime","getOutputAudioNodeAtIndex","outputAudioNodes","outputAudioNode","attack","knee","ratio","release","threshold","createInvalidStateError","createInvalidAccessError","filterBuffer","feedback","feedbackLength","feedforward","feedforwardLength","minLength","xBuffer","yBuffer","bufferIndex","bufferLength","inputLength","testPromiseSupport","uint32Array","Uint32Array","promise","decodeAudioData","catch","assignNativeAudioNodeOption","option","assignNativeAudioNodeOptions","testAnalyserNodeGetFloatTimeDomainDataMethodSupport","nativeAnalyserNode","getFloatTimeDomainData","assignNativeAudioNodeAudioParamValue","wrapAudioScheduledSourceNodeStartMethodNegativeParameters","nativeAudioScheduledSourceNode","when","RangeError","wrapAudioScheduledSourceNodeStopMethodNegativeParameters","computeBufferSize","baseLatency","max","min","round","log2","createNativeBiquadFilterNode","nativeBiquadFilterNode","createBiquadFilter","createNativeChannelSplitterNode","nativeChannelSplitterNode","createChannelSplitter","channelSplitterNode","wrapChannelSplitterNode","interceptConnections","original","interceptor","createNativeDelayNode","nativeDelayNode","createDelay","createNativeGainNode","nativeGainNode","divide","a","b","denominator","evaluatePolynomial","coefficient","z","createNativeScriptProcessorNode","bufferSize","createNotSupportedError","periodicWave","coneInnerAngle","coneOuterAngle","coneOuterGain","distanceModel","maxDistance","orientationX","orientationY","orientationZ","panningModel","positionX","positionY","positionZ","refDistance","rolloffFactor","createUnknownError","curve","oversample","getFirstSample","isDCCurve","overwriteAccessors","object","property","createGetter","createSetter","getPrototypeOf","getOwnPropertyDescriptor","setValueAtTimeUntilPossible","setValueAtTime","testAudioScheduledSourceNodeStartMethodNegativeParametersSupport","nativeAudioBufferSourceNode","createOscillator","testAudioScheduledSourceNodeStopMethodConsecutiveCallsSupport","testAudioScheduledSourceNodeStopMethodNegativeParametersSupport","testDomExceptionConstructorSupport","testTransferablesSupport","ArrayBuffer","data","wrapAudioScheduledSourceNodeStopMethodConsecutiveCalls","disconnectGainNode","removeEventListener","addEventListener","isStopped","wrapEventListener","defineProperties","currentTarget","handleEvent","addActiveInputConnectionToAudioNode","createAddActiveInputConnectionToAudioNode","addPassiveInputConnectionToAudioNode","createAddPassiveInputConnectionToAudioNode","deleteActiveInputConnectionToAudioNode","createDeleteActiveInputConnectionToAudioNode","audioNodeTailTimeStore","getAudioNodeTailTime","_a","createGetAudioNodeTailTime","cacheTestResult","ongoingTests","testResults","tester","cachedTestResult","ongoingTest","synchronousTestResult","then","finalTestResult","window","createNativeAnalyserNode","createAnalyser","byteTimeDomainData","Uint8Array","getByteTimeDomainData","wrapAnalyserNodeGetFloatTimeDomainDataMethod","createNativeAnalyserNodeFactory","getAudioNodeRenderer","renderer","createGetAudioNodeRenderer","renderInputsOfAudioNode","nextTrace","all","audioNodeRenderer","renderedNativeAudioNode","render","allRenderingPromises","renderingPromises","createRenderInputsOfAudioNode","createAnalyserNodeRenderer","renderedNativeAnalyserNodes","renderedNativeAnalyserNode","createAnalyserNode","createAnalyserNodeRendererFactory","getNativeContext","contextStore","nativeOfflineAudioContextConstructor","OfflineAudioContext","webkitOfflineAudioContext","createNativeOfflineAudioContextConstructor","isNativeOfflineAudioContext","anything","createIsNativeOfflineAudioContext","audioParamAudioNodeStore","eventTargetConstructor","_nativeEventTarget","_listeners","wrappedEventListener","createEventTargetConstructor","nativeAudioContextConstructor","AudioContext","webkitAudioContext","createNativeAudioContextConstructor","isNativeAudioContext","createIsNativeAudioContext","AudioNode","createIsNativeAudioNode","isNativeAudioParam","AudioParam","createIsNativeAudioParam","AudioWorkletNode","createNativeAudioWorkletNodeConstructor","audioNodeConstructor","addAudioNodeConnections","addConnectionToAudioNode","createIncrementCycleCounter","decrementCycleCounter","detectCycles","super","_context","_nativeAudioNode","state","isPassive","nativeAudioParam","maxValue","eventListeners","partialConnection","deleteActiveInputConnectionToAudioParam","addConnectionToAudioParamOfAudioContext","destinations","audioNodeConnectionsOfSource","deleteAnyConnection","deleteConnectionAtOutput","deleteConnectionToDestination","createAudioNodeConstructor","audioNodeConnectionsStore","tailTimeTimeoutIds","tailTime","tailTimeTimeoutId","clearTimeout","setTimeout","createAddConnectionToAudioNode","cycleCounters","cycleCounter","nativeDestinationAudioParam","createIncrementCycleCounterFactory","createDecrementCycleCounter","chain","nextLink","isDelayNode","mergedCycles","nestedCycles","concat","createDetectCycles","analyserNodeConstructor","audionNodeConstructor","mergedOptions","_nativeAnalyserNode","frequencyBinCount","getByteFrequencyData","getFloatFrequencyData","createAnalyserNodeConstructor","audioBufferStore","nativeAudioBufferConstructor","AudioBuffer","createNativeAudioBufferConstructor","convertNumberToUnsignedLong","unit32Array","wrapAudioBufferCopyChannelMethods","channelNumberAsNumber","bufferOffsetAsNumber","audioBufferLength","destinationLength","sourceLength","createWrapAudioBufferCopyChannelMethods","wrapAudioBufferCopyChannelMethodsOutOfBounds","createWrapAudioBufferCopyChannelMethodsOutOfBounds","audioBufferConstructor","testNativeAudioBufferConstructorSupport","static","hasInstance","createAudioBufferConstructor","createTestAudioBufferConstructorSupport","addSilentConnection","createAddSilentConnection","renderInputsOfAudioParam","createRenderInputsOfAudioParam","connectAudioParam","createConnectAudioParam","createNativeAudioBufferSourceNode","testAudioBufferSourceNodeStartMethodConsecutiveCallsSupport","testAudioBufferSourceNodeStartMethodOffsetClampingSupport","testAudioBufferSourceNodeStopMethodNullifiedBufferSupport","wrapAudioBufferSourceNodeStartMethodOffsetClampling","wrapAudioBufferSourceNodeStopMethodNullifiedBuffer","isScheduled","wrapAudioBufferSourceNodeStartMethodConsecutiveCalls","clampedOffset","createNativeAudioBufferSourceNodeFactory","nullifiedBuffer","createWrapAudioBufferSourceNodeStopMethodNullifiedBuffer","renderAutomation","getAudioParamRenderer","replay","createRenderAutomation","createGetAudioParamRenderer","createAudioBufferSourceNodeRenderer","renderedNativeAudioBufferSourceNodes","renderedNativeAudioBufferSourceNode","nativeAudioBufferSourceNodeIsOwnedByContext","createAudioBufferSourceNode","createAudioBufferSourceNodeRendererFactory","createAudioParam","addAudioParamConnections","audioParamStore","createAudioParamRenderer","isAudioParamOfOfflineAudioContext","minValue","automationEventList","audioParamRenderer","exponentialRampToValueAtTime","linearRampToValueAtTime","setTargetAtTime","setValueCurveAtTime","currentTime","cancelAndHoldAtTime","flush","previousLastEvent","pop","currentLastEvent","cancelScheduledValues","Number","isFinite","convertedValues","firstSample","lastSample","numberOfInterpolatedValues","interpolatedValues","timeOfLastSample","createAudioParamFactory","audioParamConnectionsStore","audioBufferSourceNodeConstructor","audioBufferSourceNodeRenderer","_audioBufferSourceNodeRenderer","_isBufferNullified","_isBufferSet","_nativeAudioBufferSourceNode","_onended","_playbackRate","onended","wrappedListener","nativeOnEnded","resetInternalStateToPassive","createAudioBufferSourceNodeConstructor","audioDestinationNodeConstructor","createAudioDestinationNodeRenderer","createNativeAudioDestinationNode","nativeAudioDestinationNode","nativeAudioDestinationNodePromise","createAudioDestinationNode","_isNodeOfNativeOfflineAudioContext","_nativeAudioDestinationNode","maxChannelCount","createAudioDestinationNodeConstructor","isNodeOfNativeOfflineAudioContext","gainNode","createNativeAudioDestinationNodeFactory","createBiquadFilterNodeRenderer","renderedNativeBiquadFilterNodes","renderedNativeBiquadFilterNode","nativeBiquadFilterNodeIsOwnedByContext","createBiquadFilterNode","createBiquadFilterNodeRendererFactory","setAudioNodeTailTime","createSetAudioNodeTailTime","biquadFilterNodeConstructor","_Q","_detune","_frequency","_gain","log10","_nativeBiquadFilterNode","getFrequencyResponse","frequencyHz","magResponse","phaseResponse","createBiquadFilterNodeConstructor","monitorConnections","whenConnected","whenDisconnected","wasDisconnected","wasConnected","isDisconnected","createMonitorConnections","wrapChannelMergerNode","channelMergerNode","audioBufferSourceNode","createWrapChannelMergerNode","createNativeChannelMergerNode","nativeChannelMergerNode","createChannelMerger","createNativeChannelMergerNodeFactory","createChannelMergerNodeRenderer","renderedNativeAudioNodes","createAudioNode","createChannelMergerNodeRendererFactory","channelMergerNodeConstructor","createChannelMergerNodeConstructor","createChannelSplitterNodeRenderer","createChannelSplitterNodeRendererFactory","channelSplitterNodeConstructor","sanitizeChannelSplitterOptions","createChannelSplitterNodeConstructor","createNativeConstantSourceNodeFaker","audioNodeOptions","nativeConstantSourceNodeFaker","args","createNativeConstantSourceNodeFakerFactory","createNativeConstantSourceNode","createConstantSource","nativeConstantSourceNode","createNativeConstantSourceNodeFactory","createConstantSourceNodeRenderer","renderedNativeConstantSourceNodes","renderedNativeConstantSourceNode","nativeConstantSourceNodeIsOwnedByContext","createConstantSourceNode","createConstantSourceNodeRendererFactory","constantSourceNodeConstructor","constantSourceNodeRenderer","_constantSourceNodeRenderer","_nativeConstantSourceNode","_offset","createConstantSourceNodeConstructor","createNativeConvolverNode","nativeConvolverNode","createConvolver","normalize","createNativeConvolverNodeFactory","createConvolverNodeRenderer","renderedNativeConvolverNodes","renderedNativeConvolverNode","createConvolverNode","createConvolverNodeRendererFactory","convolverNodeConstructor","_nativeConvolverNode","createConvolverNodeConstructor","createDelayNodeRenderer","renderedNativeDelayNodes","renderedNativeDelayNode","nativeDelayNodeIsOwnedByContext","createDelayNode","createDelayNodeRendererFactory","delayNodeConstructor","_delayTime","createDelayNodeConstructor","createNativeDynamicsCompressorNode","nativeDynamicsCompressorNode","createDynamicsCompressor","createNativeDynamicsCompressorNodeFactory","createDynamicsCompressorNodeRenderer","renderedNativeDynamicsCompressorNodes","renderedNativeDynamicsCompressorNode","nativeDynamicsCompressorNodeIsOwnedByContext","createDynamicsCompressorNode","createDynamicsCompressorNodeRendererFactory","dynamicsCompressorNodeConstructor","_attack","_knee","_nativeDynamicsCompressorNode","_ratio","_release","_threshold","previousChannelCount","reduction","createDynamicsCompressorNodeConstructor","createGainNodeRenderer","renderedNativeGainNodes","renderedNativeGainNode","nativeGainNodeIsOwnedByContext","createGainNode","createGainNodeRendererFactory","gainNodeConstructor","createGainNodeConstructor","createNativeIIRFilterNodeFaker","convertedFeedback","Float64Array","convertedFeedforward","scriptProcessorNode","bufferIndexes","xBuffers","yBuffers","fill","outputBuffer","nyquist","omega","PI","cos","sin","response","sqrt","atan2","createNativeIIRFilterNodeFakerFactory","renderNativeOfflineAudioContext","testOfflineAudioContextCurrentTimeSupport","isOfflineAudioContextCurrentTimeSupported","oncomplete","startRendering","createRenderNativeOfflineAudioContext","createTestOfflineAudioContextCurrentTimeSupport","createIIRFilterNodeRenderer","filteredBufferPromise","nativeIIRFilterNode","nativeIIRFilterNodeIsOwnedByContext","createIIRFilter","partialOfflineAudioContext","filteredBuffer","filterFullBuffer","createIIRFilterNodeRendererFactory","createNativeIIRFilterNode","createNativeIIRFilterNodeFactory","iIRFilterNodeConstructor","wrapIIRFilterNodeGetFrequencyResponseMethod","_nativeIIRFilterNode","createIIRFilterNodeConstructor","createAudioListener","nativeListener","forwardX","forwardY","forwardZ","upX","upY","upZ","isScriptProcessorNodeCreated","lastOrientation","lastPosition","createScriptProcessorNode","orientation","setOrientation","positon","setPosition","createSetOrientation","createSetPosition","createFakeAudioParam","initialValue","setValue","constantSourceNode","createFakeAudioParams","createAudioListenerFactory","unrenderedAudioWorkletNodeStore","minimalBaseAudioContextConstructor","_nativeContext","_destination","_listener","_onstatechange","onstatechange","nativeOnStateChange","createMinimalBaseAudioContextConstructor","createNativeOscillatorNode","nativeOscillatorNode","setPeriodicWave","createNativeOscillatorNodeFactory","createOscillatorNodeRenderer","renderedNativeOscillatorNodes","renderedNativeOscillatorNode","nativeOscillatorNodeIsOwnedByContext","createOscillatorNode","createOscillatorNodeRendererFactory","oscillatorNodeConstructor","oscillatorNodeRenderer","_nativeOscillatorNode","_oscillatorNodeRenderer","createOscillatorNodeConstructor","createConnectedNativeAudioBufferSourceNode","createConnectedNativeAudioBufferSourceNodeFactory","createNativeWaveShaperNodeFaker","negativeWaveShaperNode","createWaveShaper","positiveWaveShaperNode","inputGainNode","invertGainNode","outputGainNode","revertGainNode","disconnectNativeAudioBufferSourceNode","isConnected","unmodifiedCurve","nativeWaveShaperNodeFaker","curveLength","negativeCurve","positiveCurve","centerIndex","createNativeWaveShaperNodeFakerFactory","createNativeWaveShaperNode","nativeWaveShaperNode","automationRate","createNativeWaveShaperNodeFactory","createNativePannerNodeFaker","pannerNode","createPanner","SINGLE_CHANNEL_OPTIONS","orientationXGainNode","orientationYGainNode","orientationZGainNode","positionXGainNode","positionYGainNode","positionZGainNode","waveShaperNode","nativePannerNodeFaker","createNativePannerNodeFakerFactory","createNativePannerNode","nativePannerNode","createNativePannerNodeFactory","createPannerNodeRenderer","renderedBufferPromise","renderedNativeGainNodeOrNativePannerNode","commonAudioNodeOptions","commonNativePannerNodeOptions","nativePannerNodeIsOwnedByContext","nativeConstantSourceNodes","channelDatas","gateGainNode","partialPannerNode","createPannerNodeRendererFactory","pannerNodeConstructor","_nativePannerNode","_orientationX","_orientationY","_orientationZ","_positionX","_positionY","_positionZ","createPannerNodeConstructor","createNativePeriodicWave","imag","real","convertedImag","convertedReal","nativePeriodicWave","createPeriodicWave","createNativePeriodicWaveFactory","periodicWaveConstructor","periodicWaveStore","sanitizePeriodicWaveOptions","PeriodicWave","createPeriodicWaveConstructor","nativeStereoPannerNodeFakerFactory","CURVE_SIZE","DC_CURVE","HALF_PI","SINGLE_CHANNEL_WAVE_SHAPER_OPTIONS","buildInternalGraph","panGainNode","leftWaveShaperCurve","rightWaveShaperCurve","leftGainNode","leftWaveShaperNode","panWaveShaperNode","rightGainNode","rightWaveShaperNode","connectGraph","disconnectGraph","buildInternalGraphForMono","leftInputForLeftOutputWaveShaperCurve","leftInputForRightOutputWaveShaperCurve","rightInputForLeftOutputWaveShaperCurve","rightInputForRightOutputWaveShaperCurve","leftInputForLeftOutputGainNode","leftInputForLeftOutputWaveShaperNode","leftInputForRightOutputGainNode","leftInputForRightOutputWaveShaperNode","rightInputForLeftOutputGainNode","rightInputForLeftOutputWaveShaperNode","rightInputForRightOutputGainNode","rightInputForRightOutputWaveShaperNode","buildInternalGraphForStereo","createNativeStereoPannerNodeFakerFactory","createNativeStereoPannerNode","createNativeStereoPannerNodeFaker","createStereoPanner","nativeStereoPannerNode","createNativeStereoPannerNodeFactory","createStereoPannerNodeRenderer","renderedNativeStereoPannerNodes","renderedNativeStereoPannerNode","nativeStereoPannerNodeIsOwnedByContext","createStereoPannerNode","createStereoPannerNodeRendererFactory","stereoPannerNodeConstructor","_pan","createStereoPannerNodeConstructor","createWaveShaperNodeRenderer","renderedNativeWaveShaperNodes","renderedNativeWaveShaperNode","createWaveShaperNode","createWaveShaperNodeRendererFactory","waveShaperNodeConstructor","_isCurveNullified","_nativeWaveShaperNode","createWaveShaperNodeConstructor","isSecureContext","createIsSecureContext","fn","currentFrame","createExposeCurrentFrameAndCurrentTime","backupOfflineAudioContextStore","getOrCreateBackupOfflineAudioContext","backupOfflineAudioContext","createGetOrCreateBackupOfflineAudioContext","addAudioWorkletModule","evaluateSource","fetchSource","ongoingRequests","resolvedRequests","testAudioWorkletProcessorPostMessageSupport","moduleURL","credentials","resolvedRequestsOfContext","ongoingRequestsOfContext","promiseOfOngoingRequest","audioWorklet","absoluteUrl","evaluateAudioWorkletGlobalScope","_AWGS","SyntaxError","trim","nodeNameToProcessorConstructorMap","isSupportingPostMessage","currentIndex","blob","Blob","createObjectURL","addModule","nativeContextOrBackupOfflineAudioContext","finally","revokeObjectURL","updatedResolvedRequestsOfContext","updatedOngoingRequestsOfContext","createAddAudioWorkletModule","reject","head","document","script","createElement","originalOnErrorHandler","onerror","removeErrorEventListenerAndRevokeUrl","src","location","href","onload","appendChild","createEvaluateSource","fetch","ok","text","offlineAudioContext","isEmittingMessageEvents","isEmittingProcessorErrorEvents","audioWorkletNode","oscillator","port","onprocessorerror","createTestAudioWorkletProcessorPostMessageSupport","isNativeContext","createIsNativeContext","createDataCloneError","createEncodingError","detachedArrayBuffers","anyContext","audioData","complete","fail","createDecodeAudioData","baseAudioContextConstructor","_audioWorklet","constraints","successCallback","errorCallback","createBaseAudioContextConstructor","mediaElementAudioSourceNodeConstructor","createNativeMediaElementAudioSourceNode","nativeMediaElementAudioSourceNode","createMediaElementSource","mediaElement","_nativeMediaElementAudioSourceNode","createMediaElementAudioSourceNodeConstructor","mediaStreamAudioDestinationNodeConstructor","createNativeMediaStreamAudioDestinationNode","nativeMediaStreamAudioDestinationNode","createMediaStreamDestination","_nativeMediaStreamAudioDestinationNode","stream","createMediaStreamAudioDestinationNodeConstructor","mediaStreamAudioSourceNodeConstructor","createNativeMediaStreamAudioSourceNode","nativeMediaStreamAudioSourceNode","mediaStream","audioStreamTracks","getAudioTracks","sort","id","filteredAudioStreamTracks","createMediaStreamSource","MediaStream","_nativeMediaStreamAudioSourceNode","createMediaStreamAudioSourceNodeConstructor","createNativeMediaStreamTrackAudioSourceNode","mediaStreamTrack","createMediaStreamTrackSource","kind","createNativeMediaStreamTrackAudioSourceNodeFactory","mediaStreamTrackAudioSourceNodeConstructor","createMediaStreamTrackAudioSourceNodeConstructor","audioContextConstructor","latencyHint","isValidLatencyHint","_baseLatency","_nativeAudioContext","_nativeGainNode","_state","revokeState","resume","resolvePromise","suspend","createAudioContextConstructor","getUnrenderedAudioWorkletNodes","unrenderedAudioWorkletNodes","createGetUnrenderedAudioWorkletNodes","addUnrenderedAudioWorkletNode","createAddUnrenderedAudioWorkletNode","connectMultipleOutputs","createConnectMultipleOutputs","deleteUnrenderedAudioWorkletNode","createDeleteUnrenderedAudioWorkletNode","disconnectMultipleOutputs","createDisconnectMultipleOutputs","activeAudioWorkletNodeInputsStore","getActiveAudioWorkletNodeInputs","createGetActiveAudioWorkletNodeInputs","createNativeAudioWorkletNodeFaker","numberOfParameters","messageChannel","gainNodes","inputChannelSplitterNodes","constantSourceNodes","inputChannelMergerNode","outputChannelSplitterNode","outputChannelMergerNodes","parameterMap","nativeAudioWorkletNodeFaker","_","patchedEventListeners","unpatchedEventListener","patchedEventListener","audioWorkletProcessorPromise","audioWorkletNodeOptions","clonedAudioWorkletNodeOptions","onmessageerror","cloneAudioWorkletNodeOptions","createAudioWorkletProcessorPromise","createAudioWorkletProcessor","dWrkltPrcssr","disconnectOutputsGraph","outputChannelMergerNode","activeInputIndexes","disconnectFakeGraph","connectFakeGraph","createNativeAudioWorkletNodeFakerFactory","createNativeAudioWorkletNode","testClonabilityOfAudioWorkletNodeOptions","createNativeAudioWorkletNodeFactory","createAudioWorkletNodeRenderer","processedBufferPromise","renderedNativeAudioWorkletNodeOrGainNode","nativeOutputNodes","nativeAudioWorkletNodeIsOwnedByContext","renderBuffer","nm","createAudioWorkletNodeRendererFactory","getBackupOfflineAudioContext","createGetBackupOfflineAudioContext","setActiveAudioWorkletNodeInputs","createSetActiveAudioWorkletNodeInputs","audioWorkletNodeConstructor","sanitizeAudioWorkletNodeOptions","testAudioWorkletNodeOptionsClonability","_nativeAudioWorkletNode","_onprocessorerror","_parameters","nativeOnProcessorError","createAudioWorkletNodeConstructor","createNativeOfflineAudioContext","createCreateNativeOfflineAudioContext","createStartRendering","offlineAudioContextConstructor","c","delayStateChangeEvent","stopImmediatePropagation","_waitForThePromiseToSettle","_length","_nativeOfflineAudioContext","createOfflineAudioContextConstructor","isAnyAudioContext","createIsAnyAudioContext","isAnyAudioNode","audioNodeStore","createIsAnyAudioNode","isAnyAudioParam","createIsAnyAudioParam","isAnyOfflineAudioContext","createIsAnyOfflineAudioContext","isSupported","testAudioBufferCopyChannelMethodsSubarraySupport","testAudioContextCloseMethodSupport","testAudioContextDecodeAudioDataMethodTypeErrorSupport","testAudioContextOptionsSupport","testAudioNodeConnectMethodSupport","testAudioWorkletProcessorNoOutputsSupport","testChannelMergerNodeChannelCountSupport","testConstantSourceNodeAccurateSchedulingSupport","testConvolverNodeBufferReassignabilitySupport","testConvolverNodeChannelCountSupport","testDomExceptionContrucorSupport","testIsSecureContextSupport","testMediaStreamAudioSourceNodeMediaStreamWithoutAudioTrackSupport","testStereoPannerNodeDefaultValueSupport","createIsSupportedPromise","createTestAudioBufferCopyChannelMethodsSubarraySupport","audioContext","isAudioContextClosable","createTestAudioContextCloseMethodSupport","isPending","createTestAudioContextDecodeAudioDataMethodTypeErrorSupport","createTestAudioContextOptionsSupport","createTestAudioNodeConnectMethodSupport","isCallingProcess","createTestAudioWorkletProcessorNoOutputsSupport","createTestChannelMergerNodeChannelCountSupport","POSITIVE_INFINITY","createTestConstantSourceNodeAccurateSchedulingSupport","createTestConvolverNodeBufferReassignabilitySupport","createTestConvolverNodeChannelCountSupport","createTestIsSecureContextSupport","createTestMediaStreamAudioSourceNodeMediaStreamWithoutAudioTrackSupport","stereoPanner","createTestStereoPannerNodeDefaultValueSupport","isUndef","arg","isDefined","isFunction","isNumber","isObject","isBoolean","isString","isNote","assert","statement","assertRange","gte","lte","Infinity","assertContextRunning","warn","isInsideScheduledCallback","printedScheduledWarning","enterScheduledCallback","insideCallback","assertUsedScheduleTime","defaultLogger","console","setLogger","logger","log","theWindow","hasAudioContext","__decorate","decorators","desc","arguments","Reflect","decorate","__awaiter","_arguments","P","generator","fulfilled","step","rejected","create","Ticker","updateInterval","_callback","_type","_updateInterval","_createClock","_createWorker","toFixed","blobUrl","worker","Worker","_worker","_createTimeout","_timeout","_disposeClock","terminate","interval","dispose","isAudioParam","isOfflineAudioContext","isAudioContext","isAudioBuffer","noCopy","deepMerge","sources","shift","assign","optionsFromArguments","defaults","argsArray","objKey","opts","indexOf","defaultArg","given","fallback","omitFromObject","omit","Tone","debug","_wasDisposed","TONE_DEBUG_CLASS","disposed","EPSILON","GT","GTE","EQ","LT","abs","clamp","Timeline","_timeline","getDefaults","memory","increasing","valueOf","lastValue","_search","diff","remove","param","peek","getAfter","getBefore","cancel","after","cancelBefore","previousEvent","beginning","end","midPoint","nextEvent","_iterate","lowerBound","upperBound","forEachBefore","forEachAfter","forEachBetween","forEachFrom","forEachAtTime","notifyNewContext","onContextInit","cb","notifyCloseContext","onContextClose","Emitter","on","split","eventName","_events","once","boundCallback","off","eventList","emit","constr","BaseContext","toJSON","Context","_constants","_timeouts","_timeoutIds","_initialized","_workletModules","createAudioContext","_ticker","clockSource","_timeoutLoop","_setLatencyHint","lookAhead","initialize","ctx","feedForward","l","transport","_transport","t","draw","_draw","createAudioWorkletNode","rawContext","workletsAreReady","promises","_latencyHint","hint","lookAheadValue","now","immediate","getConstant","val","constant","firstEvent","timeout","clearInterval","setInterval","intervalFn","readOnly","str","noOp","ToneAudioBuffer","reverse","load","_buffer","getContext","loaded","_reversed","_reverse","doneLoading","downloads","fromArray","isMultidimensional","channels","multiChannelArray","toMono","chanNum","toArray","outputArray","numChannels","channelArray","ret","startSamples","endSamples","retBuffer","subarray","rev","matches","extensions","extension","ext","supportsType","baseUrl","endsWith","pathname","hash","encodeURIComponent","canPlayType","OfflineContext","_currentTime","_duration","_renderClock","asynchronous","yieldEvery","dummyContext","_numberOfChannels","_sampleRate","_numberOfInputs","_numberOfOutputs","_maxDelayTime","_feedForward","_feedback","_real","_imag","_constraints","_stream","_element","_audioData","_name","_options","_url","_fn","_id","_interval","_val","globalContext","setContext","disposeOld","TONE_SILENCE_LOGGING","prefix","printString","dbToGain","db","gainToDb","LN10","intervalToFrequencyRatio","A4","ftom","ftomf","mtof","midi","TimeBaseClass","units","defaultUnits","_units","_expressions","_getExpressions","hz","method","_frequencyToUnits","parseFloat","regexp","_ticksToUnits","parseInt","m","_beatsToUnits","_getTimeSignature","dot","numericValue","scalar","number","s","_secondsToUnits","samples","tr","q","total","fromType","_noArg","typeName","quantity","expr","matching","freq","beats","_getBpm","seconds","ticks","_getPPQ","_now","bpm","timeSignature","PPQ","toSeconds","toTicks","toFrequency","toMidi","toSamples","toMilliseconds","TimeClass","capture","quantize","quantTo","nextSubdivision","subdiv","percent","subdivision","toNotation","testNotations","power","closest","closestSeconds","notation","notationSeconds","toBarsBeatsSixteenths","quarterTime","quarters","measures","sixteenths","sixteenthString","Time","FrequencyClass","setA4","note","pitch","octave","noteNumber","noteToScaleIndex","toLowerCase","transpose","harmonize","intervals","toNote","scaleIndexToNote","cbb","cx","dbb","dx","ebb","eb","ex","fbb","fb","f","fx","gbb","gb","g","gx","abb","ab","ax","bbb","bb","bx","Frequency","TransportTimeClass","TransportTime","ToneWithContext","defaultContext","sampleTime","blockTime","_getPartialProperties","attribute","member","StateTimeline","initial","_initial","setStateAtTime","getValueAtTime","getLastState","getNextState","Param","overridden","_minOutput","_param","_swappable","swappable","_initialValue","convert","_minValue","_maxValue","_toType","_is","_assertRange","_fromType","computedTime","JSON","stringify","before","beforeValue","previous","_linearInterpolate","_exponentialInterpolate","previousVal","_exponentialApproach","setRampPoint","currentVal","exponentialRampTo","rampTime","linearRampTo","targetRampTo","exponentialApproachValueAtTime","scaling","startingValue","segTime","valueAtTime","rampTo","subdivisions","setParam","t0","v0","v1","t1","ToneAudioNode","_internalChannels","_isAudioNode","node","_getInternalNodes","nodeList","_setChannelProperties","_getChannelProperties","outputNum","inputNum","toDestination","toMaster","nodes","connectSeries","fan","first","prev","current","srcNode","dstNode","outputNumber","inputNumber","fanIn","Gain","_gainNode","OneShotSource","_stopTime","getStateAtTime","_fadeIn","fadeIn","_fadeOut","fadeOut","_curve","_startGain","fadeInTime","_stopGain","cancelStop","fadeOutTime","additionalTail","_stopSource","disposeCallback","requestIdleCallback","ToneConstantSource","_source","Signal","override","_constantSource","connectSignal","signal","TickParam","_multiplier","multiplier","computedValue","prevEvent","segments","rampVal","ticksUntilTime","_getTicksUntilEvent","computedVal","segmentDur","val0","val1","onTheLineEvent","getTicksAtTime","getDurationOfTicks","currentTick","getTimeOfTick","tick","delta","sol1","sol2","ticksToTime","timeToTicks","computedDuration","startTicks","TickSignal","TickSource","_tickOffset","setTicksAtTime","pause","stopEvent","tmpEvent","lastState","elapsedTicks","periodStartTime","offsetEvent","getSecondsAtTime","elapsedSeconds","absoluteTicks","forEachTickBetween","lastStateEvent","maxStartTime","nextTickTime","Clock","_lastUpdate","_boundLoop","_loop","_tickSource","mixin","Delay","maxDelayInSeconds","maxDelay","_maxDelay","_delayNode","Offline","originalContext","bufferPromise","ToneAudioBuffers","_buffers","_loadingCount","urls","_bufferLoaded","substring","MidiClass","Midi","TicksClass","Ticks","Draw","expiration","anticipation","_boundDrawLoop","_drawLoop","_animationFrame","schedule","requestAnimationFrame","cancelAnimationFrame","IntervalTimeline","_root","IntervalNode","insert","updateHeight","updateMax","_rebalance","results","search","_removeNode","_setRoot","_replaceNodeInParent","replacement","isLeftChild","left","right","temp","getBalance","_rotateLeft","pivotNode","_rotateRight","balance","low","allNodes","traverse","searchAfter","high","_left","_right","height","point","Volume","volume","_unmutedVolume","mute","Destination","TimelineValue","TransportEvent","_eventId","_remainderTime","_once","floatTime","invoke","tickDuration","TransportRepeatEvent","_currentId","_nextId","_nextTick","_boundRestart","_restart","_createEvents","_createEvent","scheduleOnce","Transport","_loopStart","_loopEnd","_scheduledEvents","_repeatedEvents","_syncedSignals","_swingAmount","_ppq","ppq","_clock","_processTick","_bindClockEvents","_timeSignature","_swingTicks","swing","swingSubdivision","tickTime","progress","amount","_addEvent","scheduleRepeat","eventId","item","timeline","computedAfter","offsetTicks","toggle","timeSig","startPosition","endPosition","setLoopPoints","position","remainingTicks","syncSignal","computedFreq","ratioSignal","unsyncSignal","syncedSignal","Source","_synced","_scheduled","_syncedStart","_syncedStop","_volume","onstop","_clampToCurrentTime","sched","_start","restart","_stop","sync","stateEvent","startOffset","unsync","ToneBufferSource","_sourceStarted","_sourceStopped","computedOffset","loopDuration","computedDur","Noise","_noiseBuffers","rate","random","BUFFER_LENGTH","_noiseCache","brown","pink","white","channelNum","lastOut","b0","b1","b2","b3","b4","b5","b6","UserMedia","open","labelOrId","supported","devices","enumerateDevices","_device","find","device","label","deviceId","audio","echoCancellation","noiseSuppression","mozNoiseSuppression","navigator","mediaDevices","getUserMedia","mediaStreamNode","_mediaStream","track","active","groupId","generateWaveform","ToneOscillatorNode","_oscillator","Oscillator","_partials","partials","_partialCount","partialCount","baseType","phase","_wave","syncFrequency","unsyncFrequency","_getCachedPeriodicWave","_periodicWaveCache","description","_phase","arrayA","arrayB","oscProps","isBasicType","cache","wave","_getRealImaginary","p","partial","exec","fullPartials","v","periodicWaveSize","piFactor","_inverseFFT","getInitialValue","twoPi","asArray","SignalOperator","WaveShaper","_shaper","mapping","setMap","normalized","oversampling","AudioToGain","_norm","Multiply","_mult","factor","AMOscillator","_modulationScale","_modulationNode","_carrier","_modulator","modulationType","harmonicity","FMOscillator","modulationIndex","PulseOscillator","_widthGate","_thresh","width","_triangle","carrierType","FatOscillator","_oscillators","_spread","spread","_forEach","osc","PWMOscillator","sourceType","_scale","_pulse","modulationFrequency","OmniOscillatorSourceMap","am","fat","fm","pulse","pwm","OmniOscillator","_sourceType","substr","_createNewOscillator","_getOscType","oscType","OscConstructor","oldOsc","sType","mType","Add","_sum","addend","Scale","_add","_min","_max","_setRange","Zero","LFO","_stoppedValue","_clampValue","_amplitudeGain","amplitude","_stoppedSignal","_zeros","_a2g","_scaler","_setStoppedValue","currentMin","currentMax","range","valueMap","propertyKey","newValue","timeRange","Player","_activeSources","_onload","autostart","_onSourceEnd","origDuration","implicitEnd","seek","Players","_players","player","stopAll","GrainPlayer","_tick","grainSize","_grainSize","_overlap","overlap","_onstop","Abs","_abs","GainToAudio","Negate","_multiply","Subtract","_neg","subtrahend","GreaterThanZero","GreaterThan","_subtract","_gtz","comparator","Pow","_exponentScaler","_expFunc","_exponent","exponent","ScaleExp","_exp","SyncedSignal","_lastVal","_onTick","_syncedCallback","_anchorValue","Envelope","_sig","decay","sustain","attackCurve","releaseCurve","decayCurve","_getCurve","direction","curveName","EnvelopeCurves","_setCurve","curveDef","_attackCurve","_releaseCurve","_decayCurve","triggerAttack","velocity","currentValue","decayValue","decayStart","triggerRelease","triggerAttackRelease","attackPortion","envelopeDuration","sustainTime","totalDuration","clone","curveLen","cosineCurve","rippleCurve","sineWave","stairsCurve","sineCurve","bounceCurve","invertCurve","out","bounce","In","Out","cosine","exponential","linear","ripple","sine","Instrument","_original_triggerAttack","_original_triggerRelease","_syncedRelease","_syncState","_syncMethod","changed","timePosition","originalMethod","Monophonic","portamento","onsilence","_triggerEnvelopeAttack","setNote","_triggerEnvelopeRelease","computedFrequency","getLevelAtTime","portTime","AmplitudeEnvelope","Synth","envelope","computedAttack","computedDecay","ModulationSynth","modulation","modulationEnvelope","AMSynth","BiquadFilter","_filter","freqValues","magValues","phaseValues","filterClone","Filter","_filters","rolloff","_rolloff","rolloffNum","possibilities","cascadingCount","totalResponse","FrequencyEnvelope","_octaves","octaves","_baseFrequency","baseFrequency","MonoSynth","filterEnvelope","DuoSynth","voice0","voice1","_vibrato","vibratoRate","_vibratoGain","vibratoAmount","FMSynth","inharmRatios","MetalSynth","_freqMultipliers","_amplitude","_highpass","mult","_filterFreqScaler","resonance","freqMult","MembraneSynth","pitchDecay","hertz","maxNote","NoiseSynth","noise","workletContext","addToWorklet","classOrFunction","registerProcessor","classDesc","processor","ToneAudioWorklet","workletOptions","_audioWorkletName","_dummyGain","_dummyParam","_worklet","onReady","workletName","FeedbackCombFilter","OnePoleFilter","_createFilter","oldFilter","a0","fq","LowpassCombFilter","_combFilter","_lowpass","dampening","PluckSynth","_noise","attackNoise","_lfcf","delayAmount","PolySynth","_availableVoices","_activeVoices","_voices","_gcTimeout","_averageActiveVoices","releaseAll","voice","maxPolyphony","_dummyVoice","_getNextAvailableVoice","_collectGarbage","activeVoices","_makeVoiceAvailable","activeVoiceIndex","firstAvail","_triggerAttack","notes","midiNote","released","_triggerRelease","_scheduleEvent","durationSeconds","sanitizedOptions","Sampler","urlMap","mid","_findClosest","midiFloat","remainder","difference","closestNote","ToneEvent","_startOffset","_probability","probability","_humanize","humanize","_rescheduleEvents","startTick","_getLoopDuration","prob","variation","rescheduleTime","lastEvent","Loop","_event","iterations","iters","Part","events","_startNote","at","timeInTicks","_restartEvent","_setAll","attr","_testLoopBoundries","upPatternGen","clampToArraySize","downPatternGen","infiniteGen","gen","alternatingGenerator","directionUp","jumpUp","stepIndex","jumpDown","randomOnce","copy","PatternGenerator","pattern","randomIndex","randomGen","randomWalk","Pattern","_values","_pattern","Sequence","_part","_seqCallback","_eventsArray","_subdivision","_createSequence","_eventsUpdated","_indexTime","_rescheduleSequence","sequence","eventOffset","CrossFade","_panner","_split","_g2a","fade","Effect","_dryWet","wet","effectSend","effectReturn","connectEffect","effect","LFOEffect","_lfo","depth","AutoFilter","oct","Panner","AutoPanner","Follower","smoothing","_smoothing","AutoWah","_follower","follower","_sweepRange","_inputBoost","_bandpass","_peaking","_setSweepRange","sensitivity","baseFreq","BitCrusher","_bitCrusherWorklet","BitCrusherWorklet","bits","Chebyshev","_order","order","_getCoefficient","degree","memo","isInteger","Split","_splitter","Merge","_merger","StereoEffect","_merge","connectEffectLeft","connectEffectRight","StereoFeedbackEffect","_feedbackL","_feedbackR","_feedbackSplit","_feedbackMerge","Chorus","_depth","_lfoL","_lfoR","_delayNodeL","_delayNodeR","deviation","Distortion","_distortion","distortion","deg","FeedbackEffect","_feedbackGain","FeedbackDelay","PhaseShiftAllpass","offset90","_bank0","_createAllPassFilterBank","_bank1","_oneSampleDelay","bankValues","coefficients","FrequencyShifter","_sine","_cosine","_sineMultiply","_cosineMultiply","_negate","_phaseShifter","combFilterTunings","allpassFilterFrequencies","Freeverb","_combFilters","_allpassFiltersL","_allpassFiltersR","roomSize","allpassL","allpassR","lfpf","al","ar","cf","combFilterDelayTimes","combFilterResonances","allpassFilterFreqs","JCReverb","_allpassFilters","_feedbackCombFilters","_scaleRoomSize","allpass","fbcf","apf","StereoXFeedbackEffect","PingPongDelay","_leftDelay","_rightDelay","_rightPreDelay","PitchShift","_delayA","_lfoA","_delayB","_lfoB","_crossFade","_crossFadeLFO","_feedbackDelay","_pitch","_windowSize","windowSize","Phaser","_filtersL","_makeFilters","stages","_filtersR","connectToFreq","filters","Reverb","_convolver","ready","_decay","_preDelay","preDelay","generate","previousReady","noiseL","noiseR","merge","renderPromise","MidSideSplit","_midAdd","SQRT1_2","_sideSubtract","side","MidSideMerge","_leftMult","_rightMult","MidSideEffect","_midSideMerge","_midSideSplit","_midSend","_sideSend","_midReturn","_sideReturn","connectEffectMid","connectEffectSide","StereoWidener","_twoTimesWidthMid","_twoTimesWidthSide","_midMult","_oneMinusWidth","_sideMult","Tremolo","_amplitudeL","_amplitudeR","Vibrato","Analyser","_analysers","analyser","MeterBase","_analyser","Meter","_rms","normalRange","getLevel","aValues","vals","totalSquared","rms","FFT","getFrequencyOfIndex","DCMeter","Waveform","Solo","_allSolos","solo","_isSoloed","_addSolo","_removeSolo","_updateSolo","muted","_soloed","_noSolos","PanVol","Channel","_solo","_panVol","_getBus","buses","send","bus","sendKnob","receive","Mono","MultibandSplit","_lowMidFilter","lowFrequency","highFrequency","Listener","Panner3D","Recorder","_recorder","MediaRecorder","mimeType","startPromise","handleStart","dataPromise","handleData","Compressor","_compressor","Gate","_gt","_gate","thresh","smoothingTime","Limiter","MidSideCompressor","MultibandCompressor","EQ3","_multibandSplit","_lowGain","_midGain","_highGain","Convolver","buff","norm","getTransport","Master","getDestination","getListener","getDraw","Buffer","Buffers","BufferSource"],"sourceRoot":""}