tone 14.8.27

package/CHANGELOG.md

@@ -0,0 +1,313 @@
+# 14.7.0
+
+
+### Features
+
+* **Converted to typescript!!!**
+* adding AudioWorkletNode constructors to Context ([f7bdd75](https://github.com/Tonejs/Tone.js/commit/f7bdd75))
+* adding ability to get the frequency at the FFT index ([22cecdc](https://github.com/Tonejs/Tone.js/commit/22cecdc281c8076c054affaef9dc422665acda2e))
+* adding AudioWorkletNode constructors to Context ([f7bdd75](https://github.com/Tonejs/Tone.js/commit/f7bdd7528fa9549740dc514df6308303c060e091))
+* adding BiquadFilter ([75617d3](https://github.com/Tonejs/Tone.js/commit/75617d341fe44ca5d332ea4e547f07c266a54753)), closes [#686](https://github.com/Tonejs/Tone.js/issues/686)
+* adding linting to jsdocs ([10ef513](https://github.com/Tonejs/Tone.js/commit/10ef513))
+* adding send/receive to Channel ([703f27a](https://github.com/Tonejs/Tone.js/commit/703f27a))
+* Adding triggerRelease to PluckSynth ([04405af](https://github.com/Tonejs/Tone.js/commit/04405af))
+* Can set the parameter after constructing Param ([23ca0f9](https://github.com/Tonejs/Tone.js/commit/23ca0f9))
+* adding onerror to Sampler ([7236600](https://github.com/Tonejs/Tone.js/commit/7236600182d336d6598f86d7d7afe8761e733774)), closes [#605](https://github.com/Tonejs/Tone.js/issues/605)
+* Chorus extends StereoFeedbackEffect ([a28f1af](https://github.com/Tonejs/Tone.js/commit/a28f1af)), closes [#575](https://github.com/Tonejs/Tone.js/issues/575)
+* Convolver is just a wrapper around the ConvolverNode, no longer an effect ([1668dec](https://github.com/Tonejs/Tone.js/commit/1668dec))
+* Get an oscillator wave as an array ([9ad519e](https://github.com/Tonejs/Tone.js/commit/9ad519e))
+* OfflineContext returns a ToneAudioBuffer ([889dafa](https://github.com/Tonejs/Tone.js/commit/889dafa))
+* OfflineContext yields thread every second of audio rendered ([1154470](https://github.com/Tonejs/Tone.js/commit/1154470)), closes [#436](https://github.com/Tonejs/Tone.js/issues/436)
+* Renaming TransportTimelineSignal to SyncedSignal ([86853fb](https://github.com/Tonejs/Tone.js/commit/86853fb))
+* es6 output ([e5d28ba](https://github.com/Tonejs/Tone.js/commit/e5d28baa5f02c19a6f1c8c50c99e98bd1551d15b))
+* Render a segment of the envelope as an array ([fc5b6f7](https://github.com/Tonejs/Tone.js/commit/fc5b6f7))
+* testing examples in jsdocs ([e306319](https://github.com/Tonejs/Tone.js/commit/e306319))
+* Wrapper around the AudioWorkletNode ([2ee8cb1](https://github.com/Tonejs/Tone.js/commit/2ee8cb1))
+* Input/Outputs are no longer arrays.
+	* simplifies connect/disconnect logic greatly. Simplifies API to just have clearly named inputs/outputs instead of overloading input/output connect numbers
+* Using "Destination" instead of "Master" for output
+	* More consistent with Web Audio API
+* FrequencyShifter - thanks @Foaly
+* PolySynth does not require a polyphony value.
+	* Voice allocation and disposing is done automatically based on demand.
+* MetalSynth and MembraneSynth extends Monophonic enabling them to be used in PolySynth
+* OnePoleFilter is a 6b-per-octave lowpass or highpass filter
+	* Using OnePoleFilter in PluckSynth and LowpassCombFilter
+* latencyHint is now set in constructor ([ba8e82b](https://github.com/Tonejs/Tone.js/commit/ba8e82b1ca8a841a23d6e774641916019c37cc92)), closes [#658](https://github.com/Tonejs/Tone.js/issues/658)
+* meter output can be normalRange in addition to decibels ([2625a13](https://github.com/Tonejs/Tone.js/commit/2625a134b62af117c1c525a4e631e4e52b25ba90))
+* option to pass in the number of input channels to Panner ([d966735](https://github.com/Tonejs/Tone.js/commit/d966735bd97bddc70039bce5a48f26413054eddc)), closes [#609](https://github.com/Tonejs/Tone.js/issues/609)
+
+
+### BREAKING CHANGES
+
+* TransportTimelineSignal renamed SyncedSignal
+* Master renamed Destination
+* Buffer renamed ToneAudioBuffer
+* Buffer.on("loaded") is should now use: `Tone.loaded(): Promise<void>`
+* Removing bower ([71c8b3b](https://github.com/Tonejs/Tone.js/commit/71c8b3bbb96e45cfc4aa2cce8a2d8c61a092c91e)), closes [#197](https://github.com/Tonejs/Tone.js/issues/197)
+* Removing Ctrl classes ([51d06bd](https://github.com/Tonejs/Tone.js/commit/51d06bd9873b2f1936a3169930f9696f1ccfb845))
+* `Players.get(name: string)` is renamed to `Players.player(name: string)`
+
+# 13.8.25
+
+* Moving to common.js-style code
+
+### BREAKING CHANGES
+
+* AudioNode.prototype.connect is no longer overwritten. This means that you can no longer connect native nodes to Tone.js Nodes.
+* Tone.connect(srcNode, destNode, [ouputNum], [inputNum]) is the way to connect native Web Audio nodes with Tone.js nodes.
+
+# 13.4.9
+
+* Updating semantic versioning to be more in line with other [semvers](https://semver.org/). Now version is 13.x.x
+* logging full version
+* Added Object notation for Tone.TimeBase and classes that extend it.
+	- i.e. Tone.Time({'4n' : 1, '8t' : 2})
+	- Replacement for deprecated expression strings.
+* Tone.Meter uses RMS instead of peak (thanks [@Idicious](https://github.com/Idicious))
+* Tone.Sampler supports polyphonic syntax (thanks [@zfan40](https://github.com/zfan40))
+* Building files with [webpack](https://webpack.js.org/)
+* Follower/Gate uses a single "smoothing" value instead of separate attacks and releases
+* Changing references to `window` allowing it to not throw error in node context
+* Testing examples
+* Tone.Channel combines Tone.PanVol with Tone.Solo.
+* Removing require.html example.
+* adding `partialCount` and `baseType` to Oscillator classes, helps with getting/setting complex types.
+
+
+# r12
+
+* Consolidating all shims into [shim folder](https://github.com/Tonejs/Tone.js/tree/dev/Tone/shim)
+* Using ConstantSourceNode in Signal when available
+* switching to eslint from jshint
+* Running [CI tests](https://travis-ci.org/Tonejs/Tone.js/) on Firefox, Chrome (latest and canary) and Safari (latest and version 9).
+* [Tone.Reverb](https://tonejs.github.io/docs/Reverb) is a convolution-based stereo reverb. [Example](https://tonejs.github.io/examples/#reverb).
+* Optimizing basic Oscillator types and many Signal use-case
+* Optimizing basic connection use-case of Tone.Signal where one signal is controlling another signal
+* Testing rendered output against an existing audio file for continuity and consistency
+* Optimizing triggerAttack/Release by starting/stopping oscillators when not playing
+* [TickSource](https://tonejs.github.io/docs/TickSource) (used in Clock and Player) tracks the elapsed ticks
+	* Improved precision of tracking ticks in Transport and Clock
+* `Player.position` returns the playback position of the AudioBuffer accounting for any playbackRate changes
+* Removing `retrigger` option with Tone.Player. Tone.BufferSource should be used if retriggering is desired.
+
+**BREAKING CHANGES:**
+
+* Tone.TimeBase and all classes that extend it not longer support string expressions.
+	RATIONALE :
+		* Since all classes implement `valueOf`, expressions can be composed in JS instead of as strings
+			* e.g. `Time('4n') * 2 + Time('3t')` instead of `Time('4n * 2 + 3t')`
+		* this change greatly simplifies the code and is more performant
+
+# r11
+
+* [Code coverage](https://coveralls.io/github/Tonejs/Tone.js) analysis
+* [Dev build](https://tonejs.github.io/build/dev/Tone.js) with each successful commit
+* [Versioned docs](https://tonejs.github.io/docs/Tone) plus a [dev build of the docs](https://tonejs.github.io/docs/dev/Tone) on successful commits
+* [Tone.AudioNode](https://tonejs.github.io/docs/AudioNode) is base class for all classes which generate or process audio
+* [Tone.Sampler](https://tonejs.github.io/docs/Sampler) simplifies creating multisampled instruments
+* [Tone.Solo](https://tonejs.github.io/docs/Solo) makes it easier to mute/solo audio
+* [Mixer](https://tonejs.github.io/examples/#mixer) and [sampler](https://tonejs.github.io/examples/#sampler) examples
+* Making type-checking methods static
+* [Tone.TransportTimelineSignal](https://tonejs.github.io/docs/TransportTimelineSignal) is a signal which can be scheduled along the Transport
+* [Tone.FFT](https://tonejs.github.io/docs/FFT) and [Tone.Waveform](https://tonejs.github.io/docs/Waveform) abstract Tone.Analyser
+* [Tone.Meter](https://tonejs.github.io/docs/Meter) returns decibels
+* [Tone.Envelope](https://tonejs.github.io/docs/Envelope) uses exponential approach instead of exponential curve for decay and release curves
+* [Tone.BufferSource](https://tonejs.github.io/docs/BufferSource) fadeIn/Out can be either "linear" or "exponential" curve
+
+# r10
+
+* Tone.Context wraps AudioContext
+* Tone.OfflineContext wraps OfflineAudioContext
+* Tone.Offline: method for rendering audio offline
+* Rewriting tests with Tone.Offline
+* Optimizing Tone.Draw to only loop when events are scheduled: [#194](https://github.com/Tonejs/Tone.js/issues/194)
+* Time.eval->valueOf which takes advantage of build-in primitive evaluation [#205](https://github.com/Tonejs/Tone.js/issues/205)
+* [Offline example](https://tonejs.github.io/examples/#offline)
+
+# r9
+
+* Tone.Clock performance and lookAhead updates.
+* Tone.Transport.lookAhead = seconds|'playback'|'interactive'|'balanced'
+* Convolver.load and Player.load returns Promise
+* Tone.ExternalInput -> Tone.UserMedia, simplified API, open() returns Promise.
+* Tone.Draw for animation-frame synced drawing
+* Compressor Parameters are now Tone.Params
+* Bug fixes
+
+# r8
+
+* Transport.seconds returns the progress in seconds.
+* Buffer.from/toArray, Float32Array <-> Buffer conversions
+* Buffer.slice(start, end) slices and returns a subsection of the Buffer
+* Source.sync now syncs all subsequent calls to `start` and `stop` to the TransportTime instead of the AudioContext time.
+	* e.g. source.sync().start(0).stop(0.8); //plays source between 0 and 0.8 of the Transport
+* Transport.on("start" / "stop") callbacks are invoked just before the event.
+* Param can accept an LFO description in the constructor or .value
+	* e.g. param.value = {min : 10, max : 20, frequency : 0.4}
+* Time.TimeBase has clone/copy methods.
+* Tone.Buffer.prototype.load returns Promise
+* Using Tone.Delay and Tone.Gain everywhere
+* Patch for Chrome 53+ issue of not correctly scheduling AudioParams with setValueAtTime
+* Panner3D and Tone.Listener wrap native PannerNode and AudioListener to give 3D panning ability.
+
+# r7
+
+* MetalSynth creates metalic, cymbal sounds
+* DrumSynth -> MembraneSynth
+* FMOscillator, AMOscillator types
+* FatOscillator creates multiple oscillators and detunes them slightly
+* FM, AM, Fat Oscillators incorporated into OmniOscillator
+* Simplified FM and AM Synths and APIs
+* Panner.pan is between -1,1 like the StereoPannerNode
+* Pruned away unused (or little used) Signal classes.
+	* All this functionality will be available when the AudioWorkerNode is introduced.
+* Clock uses Web Workers instead of requestAnimationFrame which allows it to run in the background.
+* Removed `startMobile`. Using [StartAudioContext](https://github.com/tambien/StartAudioContext) in examples.
+* Automated test runner using [Travis CI](https://travis-ci.org/Tonejs/Tone.js/)
+* Simplified NoiseSynth by removing filter and filter envelope.
+* Added new timing primitive types: Time, Frequency, TransportTime.
+* Switching parameter position of type and size in Tone.Analyser
+* Tone.Meter uses Tone.Analyser instead of ScriptProcessorNode.
+* Tone.Envelope has 5 new attack/release curves: "sine", "cosine", "bounce", "ripple", "step"
+* Renamed Tone.SimpleSynth -> Tone.Synth
+* Tone.Buffers combines multiple buffers
+* Tone.BufferSource a low-level wrapper, and Tone.MultiPlayer which is good for multisampled instruments.
+* Tone.GrainPlayer: granular synthesis buffer player.
+* Simplified Sampler
+
+DEPRECATED:
+* Removed SimpleFM and SimpleAM
+
+# r6
+
+* Added PitchShift and Vibrato Effect.
+* Added Timeline/TimelineState/TimelineSignal which keeps track of all scheduled state changes.
+* Clock uses requestAnimationFrame instead of ScriptProcessorNode
+* Removed `onended` event from Tone.Source
+* Refactored tests into individual files.
+* Renamed some Signal methods: `exponentialRampToValueNow`->`exponentialRampToValue`, `setCurrentValueNow`->`setRampPoint`
+* LFO no longer starts at bottom of cycle. Starts at whatever phase it's set at.
+* Transport is an event emitter. triggers events on "start", "stop", "pause", and "loop".
+* Oscillator accepts a "partials" array.
+* Microphone inherits from ExternalInput which is generalized for different inputs.
+* New scheduling methods on Transport - `schedule`, `scheduleOnce`, and `scheduleRepeat`.
+* Tone.Gain and Tone.Delay classes wrap the native Web Audio nodes.
+* Moved [MidiToScore](https://github.com/Tonejs/MidiConvert) and [TypeScript](https://github.com/Tonejs/TypeScript) definitions to separate repos.
+* Tone.Param wraps the native AudioParam and allows for unit conversion.
+* Quantization with Transport.quantize and using "@" in any Time. [Read more](https://github.com/Tonejs/Tone.js/wiki/Time).
+* Control-rate generators for value interpolation, patterns, random numbers, and markov chains.
+* Scheduable musical events: Tone.Event, Tone.Loop, Tone.Part, Tone.Pattern, Tone.Sequence.
+* Player's playbackRate is now a signal and Noise includes a playbackRate signal.
+* All filterEnvelopes use new Tone.FrequencyEnvelope with frequency units and `baseFrequency` and `octaves` instead of `min` and `max`.
+* Phaser uses "octaves" instead of "depth" to be more consistent across the whole Tone.js API.
+* Presets now have [their own repo](https://github.com/Tonejs/Presets)
+
+DEPRECATED:
+* `setTimeout`, `setInterval`, `setTimeline` in favor of new `schedule`, `scheduleOnce`, and `scheduleRepeat`.
+* Tone.Signal no longer takes an AudioParam in the first argument. Use Tone.Param instead.
+* Tone.Buffer.onload/onprogress/onerror is deprecated. Use `Tone.Buffer.on("load", callback)` instead.
+
+# r5
+
+* reverse buffer for Player and Sampler.
+* Tone.Volume for simple volume control in Decibels.
+* Panner uses StereoPannerNode when available.
+* AutoFilter and Tremolo effects.
+* Made many attributes read-only. preventing this common type of error: `oscillator.frequency = 200` when it should be `oscillator.frequency.value = 200`.
+* Envelope supports "linear" and "exponential" attack curves.
+* Renamed Tone.EQ -> Tone.EQ3.
+* Tone.DrumSynth makes kick and tom sounds.
+* Tone.MidSideCompressor and Tone.MidSideSplit/Tone.MidSideMerge
+* Tone.Oscillator - can specify the number of partials in the type: i.e. "sine10", "triangle3", "square4", etc.
+* mute/unmute the master output: `Tone.Master.mute = true`.
+* 3 new simplified synths: SimpleSynth, SimpleAM and SimpleFM
+* `harmonicity` is a signal-rate value for all instruments.
+* expose Q in Phaser.
+* unit conversions using Tone.Type for signals and LFO.
+* [new docs](http://tonejs.org/docs)
+* [updated examples](http://tonejs.org/examples)
+
+# r4
+
+* `toFrequency` accepts notes by name (i.e. `"C4"`)
+* Envelope no longer accepts exponential scaling, only Tone.ScaledEnvelope
+* Buffer progress and load events which tracks the progress of all downloads
+* Buffer only accepts a single url
+* Sampler accepts multiple samples as an object.
+* `setPitch` in sampler -> `setNote`
+* Deprecated MultiSampler - use Sampler with PolySynth instead
+* Added [cdn](http://cdn.tonejs.org/latest/Tone.min.js) - please don't use for production code
+* Renamed DryWet to CrossFade
+* Functions return `this` to allow for chaining. i.e. `player.toMaster().start(2)`.
+* Added `units` to Signal class which allows signals to be set in terms of Tone.Time, Tone.Frequency, Numbers, or Decibels.
+* Replaced set/get method with ES5 dot notation. i.e. `player.setVolume(-10)` is now `player.volume.value = -10`.
+	To ramp the volume use either `player.volume.linearRampToValueNow(-10, "4n")`, or the new `rampTo` method which automaically selects the ramp (linear|exponential) based on the type of data.
+* set/get methods for all components
+* syncSignal and unsyncSignal moved from Signal to Transport
+* Add/Multiply/Subtract/Min/Max/GreaterThan/LessThan all extend Tone.Signal which allows them to be scheduled and automated just like Tone.Signal.
+* Deprecated Tone.Divide and Tone.Inverse. They were more complicated than they were useful.
+
+BREAKING CHANGES:
+
+The API has been changed consistently to use `.attribute` for getting and setting instead of `getAttribute` and `setAttribute` methods. The reasoning for this is twofold: firstly, Tone.Signal attributes were previously limited in their scheduling capabilities when set through a setter function. For exactly, it was not possible to do a setValueAtTime on the `bpm` of the Transport. Secondly, the new EcmaScript 5 getter/setter approach resembles the Web Audio API much more closely, which will make intermixing the two APIs even easier.
+
+If you're using Sublime Text, one way to transition from the old API to the new one is with a regex find/replace:
+	find `Tone.Transport.setBpm\((\d+)\)` and replace it with `Tone.Transport.bpm.value = $1`.
+
+Or if setBpm was being invoked with a rampTime:
+	find `Tone.Transport.setBpm\((\d+)\, (\d+)\)` and replace it with `Tone.Transport.bpm.rampTo($1, $2)`.
+
+
+# r3
+
+Core Change:
+
+* Swing parameter on Transport
+* Player loop positions stay in tempo-relative terms even with tempo changes
+* Envelope ASDR stay in tempo-relative terms even with tempo changes
+* Modified build script to accommodate using requirejs with build and minified version
+
+Signal Processing:
+
+* Tone.Expr: signal processing expression parser for Tone.Signal math
+* All signal binary operators accept two signals as inputs
+* Deprecated Tone.Threshold - new class Tone.GreaterThanZero
+* NOT, OR, AND, and IfThenElse signal logic operators
+* Additional signal classes: Inverse, Divide, Pow, AudioToGain, Subtract
+* Scale no longer accepts input min/max. Assumes [0,1] range.
+* Normalize class if scaling needs to happen from other input ranges
+* WaveShaper function wraps the WaveShaperNode
+
+Effects:
+
+* Distortion and Chebyshev distortion effects
+* Compressor and MultibandCompressor
+* MidSide effect type and StereoWidener
+* Convolver effect and example
+
+Synths:
+
+* Setters on PluckSynth and PulseOscillator
+* new PWMOscillator
+* OmniOscillator which combines PWMOscillator, Oscillator, and PulseOscillator into one
+* NoiseSynth
+
+
+# r2
+
+* PluckSynth - Karplus-Strong Plucked String modeling synth
+* Freeverb
+* John Chowning Reverb (JCReverb)
+* LowpassCombFilter and FeedbackCombFilter
+* Sampler with pitch control
+* Clock tick callback is out of the audio thread using setTimeout
+* Optimized Tone.Modulo
+* Tests run using OfflineRenderingContext
+* Fixed Transport bug where timeouts/intervals and timelines were on a different tick counter
+* AmplitudeEnvelope + triggerAttackDecay on Envelope
+* Instruments inherit from Tone.Instrument base-class
+* midi<-->note conversions
+
+
+# r1 - First!

package/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2014-2020 Yotam Mann
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,255 @@
+Tone.js
+=========
+
+[![Build Status](https://travis-ci.org/Tonejs/Tone.js.svg?branch=dev)](https://travis-ci.org/Tonejs/Tone.js) [![codecov](https://codecov.io/gh/Tonejs/Tone.js/branch/dev/graph/badge.svg)](https://codecov.io/gh/Tonejs/Tone.js)
+
+
+Tone.js is a Web Audio framework for creating interactive music in the browser. The architecture of Tone.js aims to be familiar to both musicians and audio programmers creating web-based audio applications. On the high-level, Tone offers common DAW (digital audio workstation) features like a global transport for synchronizing and scheduling events as well as prebuilt synths and effects. Additionally, Tone provides high-performance building blocks to create your own synthesizers, effects, and complex control signals.
+
+* [API](https://tonejs.github.io/docs/)
+* [Examples](https://tonejs.github.io/examples/)
+* [Demos](https://tonejs.github.io/demos)
+
+# Installation
+
+To install the latest stable version.
+
+```bash
+npm install tone
+```
+
+Or to install the 'next' version
+
+```bash
+npm install tone@next
+```
+
+To import Tone.js:
+
+```js
+import * as Tone from 'tone'
+```
+
+# Hello Tone
+
+```javascript
+//create a synth and connect it to the main output (your speakers)
+const synth = new Tone.Synth().toDestination();
+
+//play a middle 'C' for the duration of an 8th note
+synth.triggerAttackRelease("C4", "8n");
+```
+
+#### Tone.Synth
+
+[Tone.Synth](https://tonejs.github.io/docs/Synth) is a basic synthesizer with a single [oscillator](https://tonejs.github.io/docs/OmniOscillator) and an [ADSR envelope](https://tonejs.github.io/docs/Envelope).
+
+#### triggerAttack / triggerRelease
+
+`triggerAttack` starts the note (the amplitude is rising), and `triggerRelease` is when the amplitude is going back to 0 (i.e. **note off**).
+
+```javascript
+const synth = new Tone.Synth().toDestination();
+const now = Tone.now()
+// trigger the attack immediately
+synth.triggerAttack("C4", now)
+// wait one second before triggering the release
+synth.triggerRelease(now + 1)
+```
+
+#### triggerAttackRelease
+
+`triggerAttackRelease` is a combination of `triggerAttack` and `triggerRelease`
+
+The first argument to the note which can either be a frequency in hertz (like `440`) or as "pitch-octave" notation (like `"D#2"`). 
+
+The second argument is the duration that the note is held. This value can either be in seconds, or as a [tempo-relative value](https://github.com/Tonejs/Tone.js/wiki/Time). 
+
+The third (optional) argument of `triggerAttackRelease` is _when_ along the AudioContext time the note should play. It can be used to schedule events in the future.
+
+```javascript
+const synth = new Tone.Synth().toDestination();
+const now = Tone.now()
+synth.triggerAttackRelease("C4", "8n", now)
+synth.triggerAttackRelease("E4", "8n", now + 0.5)
+synth.triggerAttackRelease("G4", "8n", now + 1)
+```
+
+#### Time
+
+Web Audio has advanced, sample accurate scheduling capabilities. The AudioContext time is what the Web Audio API uses to schedule events, starts at 0 when the page loads and counts up in **seconds**.
+
+`Tone.now()` gets the current time of the AudioContext. 
+
+```javascript
+setInterval(() => console.log(Tone.now()), 100);
+```
+
+Tone.js abstracts away the AudioContext time. Instead of defining all values in seconds, any method which takes time as an argument can accept a number or a string. For example `"4n"` is a quarter-note, `"8t"` is an eighth-note triplet, and `"1m"` is one measure.
+
+[Read about Time encodings](https://github.com/Tonejs/Tone.js/wiki/Time).
+
+# Starting Audio
+
+**IMPORTANT**: Browsers will not play _any_ audio until a user clicks something (like a play button). Run your Tone.js code only after calling `Tone.start()` from a event listener which is triggered by a user action such as "click" or "keydown". 
+
+`Tone.start()` returns a promise, the audio will be ready only after that promise is resolved. Scheduling or playing audio before the AudioContext is running will result in silence or incorrect scheduling.
+
+```javascript
+//attach a click listener to a play button
+document.querySelector('button')?.addEventListener('click', async () => {
+	await Tone.start()
+	console.log('audio is ready')
+})
+``` 
+
+# Scheduling
+
+### Transport
+
+[Tone.Transport](https://tonejs.github.io/docs/Transport) is the main timekeeper. Unlike the AudioContext clock, it can be started, stopped, looped and adjusted on the fly. You can think of it like the arrangement view in a Digital Audio Workstation or channels in a Tracker. 
+
+Multiple events and parts can be arranged and synchronized along the Transport. [Tone.Loop](https://tonejs.github.io/docs/Loop) is a simple way to create a looped callback that can be scheduled to start and stop.
+
+```javascript
+// create two monophonic synths
+const synthA = new Tone.FMSynth().toDestination();
+const synthB = new Tone.AMSynth().toDestination();
+//play a note every quarter-note
+const loopA = new Tone.Loop(time => {
+	synthA.triggerAttackRelease("C2", "8n", time);
+}, "4n").start(0);
+//play another note every off quarter-note, by starting it "8n"
+const loopB = new Tone.Loop(time => {
+	synthB.triggerAttackRelease("C4", "8n", time);
+}, "4n").start("8n");
+// all loops start until the Transport is started
+Tone.Transport.start()
+```
+
+Since Javascript callbacks are **not precisely timed**, the sample-accurate time of the event is passed into the callback function. **Use this time value to schedule the events**.
+
+# Instruments
+
+There are numerous synths to choose from including [Tone.FMSynth](https://tonejs.github.io/docs/FMSynth), [Tone.AMSynth](https://tonejs.github.io/docs/AMSynth) and [Tone.NoiseSynth](https://tonejs.github.io/docs/NoiseSynth). 
+
+All of these instruments are **monophonic** (single voice) which means that they can only play one note at a time. 
+
+To create a **polyphonic** synthesizer, use [Tone.PolySynth](https://tonejs.github.io/docs/PolySynth), which accepts a monophonic synth as its first parameter and automatically handles the note allocation so you can pass in multiple notes. The API is similar to the monophonic synths, except `triggerRelease` must be given a note or array of notes. 
+
+```javascript
+//pass in some initial values for the filter and filter envelope
+const synth = new Tone.PolySynth(Tone.Synth).toDestination();
+const now = Tone.now()
+synth.triggerAttack("D4", now);
+synth.triggerAttack("F4", now + 0.5);
+synth.triggerAttack("A4", now + 1);
+synth.triggerAttack("C4", now + 1.5);
+synth.triggerAttack("E4", now + 2);
+synth.triggerRelease(["D4", "F4", "A4", "C4", "E4"], now + 4);
+```
+
+# Samples
+
+Sound generation is not limited to synthesized sounds. You can also load a sample and play that back in a number of ways. [Tone.Player](https://tonejs.github.io/docs/Player) is one way to load and play back an audio file. 
+
+```javascript
+const player = new Tone.Player("https://tonejs.github.io/audio/berklee/gong_1.mp3").toDestination();
+Tone.loaded().then(() => {
+	player.start();
+});
+```
+
+`Tone.loaded()` returns a promise which resolves when _all_ audio files are loaded. It's a helpful shorthand instead of waiting on each individual audio buffer's `onload` event to resolve. 
+
+## Sampler
+
+Multiple samples can also be combined into an instrument. If you have audio files organized by note, [Tone.Sampler](https://tonejs.github.io/docs/Sampler) will pitch shift the samples to fill in gaps between notes. So for example, if you only have every 3rd note on a piano sampled, you could turn that into a full piano sample. 
+
+Unlike the other synths, Tone.Sampler is polyphonic so doesn't need to be passed into Tone.PolySynth
+
+```javascript
+const sampler = new Tone.Sampler({
+	urls: {
+		"C4": "C4.mp3",
+		"D#4": "Ds4.mp3",
+		"F#4": "Fs4.mp3",
+		"A4": "A4.mp3",
+	},
+	baseUrl: "https://tonejs.github.io/audio/salamander/",
+}).toDestination();
+
+Tone.loaded().then(() => {
+	sampler.triggerAttackRelease(["Eb4", "G4", "Bb4"], 0.5);
+})
+```
+
+# Effects
+
+In the above examples, the sources were always connected directly to the [Destination](https://tonejs.github.io/docs/Destination), but the output of the synth could also be routed through one (or more) effects before going to the speakers.
+
+```javascript
+const player = new Tone.Player({
+	url: "https://tonejs.github.io/audio/berklee/gurgling_theremin_1.mp3",
+	loop: true,
+	autostart: true,
+})
+//create a distortion effect
+const distortion = new Tone.Distortion(0.4).toDestination();
+//connect a player to the distortion
+player.connect(distortion);
+```
+
+The connection routing is very flexible. For example, you can connect multiple sources to the same effect and then route the effect through a network of other effects either serially or in parallel. 
+
+[Tone.Gain](https://tonejs.github.io/docs/Gain) is very useful in creating complex routing. 
+
+# Signals
+
+Like the underlying Web Audio API, Tone.js is built with audio-rate signal control over nearly everything. This is a powerful feature which allows for sample-accurate synchronization and scheduling of parameters.
+
+[Signal](https://tonejs.github.io/docs/Signal) properties have a few built in methods for creating automation curves. 
+
+For example, the `frequency` parameter on [Oscillator](https://tonejs.github.io/docs/Signal) is a Signal so you can create a smooth ramp from one frequency to another.
+
+```javascript
+const osc = new Tone.Oscillator().toDestination();
+// start at "C4"
+osc.frequency.value = "C4";
+// ramp to "C5" over 2 seconds
+osc.frequency.rampTo("C5", 2)
+```
+
+# AudioContext
+
+Tone.js creates an AudioContext when it loads and shims it for maximum browser compatibility using [standardized-audio-context](https://github.com/chrisguttandin/standardized-audio-context). The AudioContext can be accessed at `Tone.context`. Or set your own AudioContext using `Tone.setContext(audioContext)`.
+
+# MIDI
+
+To use MIDI files, you'll first need to convert them into a JSON format which Tone.js can understand using [Midi](https://tonejs.github.io/Midi/).
+
+# Performance
+
+Tone.js makes extensive use of the native Web Audio Nodes such as the GainNode and WaveShaperNode for all signal processing, which enables Tone.js to work well on both desktop and mobile browsers. 
+
+[This wiki](https://github.com/Tonejs/Tone.js/wiki/Performance) article has some suggestions related to performance for best practices.
+
+# Testing
+
+Tone.js runs an extensive test suite using [mocha](https://mochajs.org/) and [chai](http://chaijs.com/) with nearly 100% coverage. Each commit and pull request is run on [Travis-CI](https://travis-ci.org/Tonejs/Tone.js/) across browsers and versions. Passing builds on the 'dev' branch are published on npm as `tone@next`. 
+
+# Contributing
+
+There are many ways to contribute to Tone.js. Check out [this wiki](https://github.com/Tonejs/Tone.js/wiki/Contributing) if you're interested.
+
+If you have questions (or answers) that are not necessarily bugs/issues, please post them to the [forum](https://groups.google.com/forum/#!forum/tonejs).
+
+# References and Inspiration
+
+* [Tuna.js](https://github.com/Dinahmoe/tuna)
+* [Many of Chris Wilson's Repositories](https://github.com/cwilso)
+* [Many of Mohayonao's Repositories](https://github.com/mohayonao)
+* [The Spec](http://webaudio.github.io/web-audio-api/)
+* [Sound on Sound - Synth Secrets](http://www.soundonsound.com/sos/may99/articles/synthsec.htm)
+* [Miller Puckette - Theory and Techniques of Electronic Music](http://msp.ucsd.edu/techniques.htm)
+* [standardized-audio-context](https://github.com/chrisguttandin/standardized-audio-context)

package/Tone/classes.ts

@@ -0,0 +1,7 @@
+export * from "./core/index";
+export * from "./source/index";
+export * from "./signal/index";
+export * from "./instrument/index";
+export * from "./event/index";
+export * from "./effect/index";
+export * from "./component/index";