input[1] from the signal connected \n * to input[0]. If an argument is provided in the constructor, the \n * signals .value will be subtracted from the incoming signal.\n *\n * @extends {Tone.Signal}\n * @constructor\n * @param {number=} value The value to subtract from the incoming signal. If the value\n * is omitted, it will subtract the second signal from the first.\n * @example\n * var sub = new Tone.Subtract(1);\n * var sig = new Tone.Signal(4).connect(sub);\n * //the output of sub is 3. \n * @example\n * var sub = new Tone.Subtract();\n * var sigA = new Tone.Signal(10);\n * var sigB = new Tone.Signal(2.5);\n * sigA.connect(sub, 0, 0);\n * sigB.connect(sub, 0, 1);\n * //output of sub is 7.5\n */\nTone.Subtract = function(value){\n\n\tTone.Signal.call(this);\n\tthis.createInsOuts(2, 0);\n\n\t/**\n\t * the summing node\n\t * @type {GainNode}\n\t * @private\n\t */\n\tthis._sum = this.input[0] = this.output = new Tone.Gain();\n\n\t/**\n\t * negate the input of the second input before connecting it\n\t * to the summing node.\n\t * @type {Tone.Negate}\n\t * @private\n\t */\n\tthis._neg = new Tone.Negate();\n\n\t/**\n\t * the node where the value is set\n\t * @private\n\t * @type {Tone.Signal}\n\t */\n\tthis._param = this.input[1] = new Tone.Signal(value);\n\tthis._param.chain(this._neg, this._sum);\n};\n\nTone.extend(Tone.Subtract, Tone.Signal);\n\n/**\n * Clean up.\n * @returns {Tone.SignalBase} this\n */\nTone.Subtract.prototype.dispose = function(){\n\tTone.Signal.prototype.dispose.call(this);\n\tthis._neg.dispose();\n\tthis._neg = null;\n\tthis._sum.disconnect();\n\tthis._sum = null;\n\treturn this;\n};\n\nexport default Tone.Subtract;\n\n","import Tone from \"../core/Tone\";\nimport \"../type/Type\";\nimport \"../core/AudioNode\";\nimport \"../core/Timeline\";\n\n/**\n * @class Tone.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 * @extends {Tone.AudioNode}\n * @param {AudioParam} param The parameter to wrap.\n * @param {Tone.Type} units The units of the audio param.\n * @param {Boolean} convert If the param should be converted.\n */\nTone.Param = function(){\n\n\tvar options = Tone.defaults(arguments, [\"param\", \"units\", \"convert\"], Tone.Param);\n\tTone.AudioNode.call(this, options);\n\n\t/**\n\t * The native parameter to control\n\t * @type {AudioParam}\n\t * @private\n\t */\n\tthis._param = this.input = options.param;\n\n\t/**\n\t * The units of the parameter\n\t * @type {Tone.Type}\n\t */\n\tthis.units = options.units;\n\n\t/**\n\t * If the value should be converted or not\n\t * @type {Boolean}\n\t */\n\tthis.convert = options.convert;\n\n\t/**\n\t * True if the signal value is being overridden by\n\t * a connected signal.\n\t * @readOnly\n\t * @type {boolean}\n\t * @private\n\t */\n\tthis.overridden = false;\n\n\t/**\n\t * The timeline which tracks all of the automations.\n\t * @type {Tone.Timeline}\n\t * @private\n\t */\n\tthis._events = new Tone.Timeline(1000);\n\n\tif (Tone.isDefined(options.value) && this._param){\n\t\tthis.setValueAtTime(options.value, 0);\n\t}\n};\n\nTone.extend(Tone.Param, Tone.AudioNode);\n\n/**\n * Defaults\n * @type {Object}\n * @const\n */\nTone.Param.defaults = {\n\t\"units\" : Tone.Type.Default,\n\t\"convert\" : true,\n\t\"param\" : undefined\n};\n\n/**\n * The current value of the parameter.\n * @memberOf Tone.Param#\n * @type {Number}\n * @name value\n */\nObject.defineProperty(Tone.Param.prototype, \"value\", {\n\tget : function(){\n\t\tvar now = this.now();\n\t\treturn this._toUnits(this.getValueAtTime(now));\n\t},\n\tset : function(value){\n\t\tthis._initialValue = this._fromUnits(value);\n\t\tthis.cancelScheduledValues(this.now());\n\t\tthis.setValueAtTime(value, this.now());\n\t}\n});\n\n/**\n * The minimum output value of the parameter\n * @memberOf Tone.Param#\n * @type {Number}\n * @name value\n */\nObject.defineProperty(Tone.Param.prototype, \"minValue\", {\n\tget : function(){\n\t\tif (this.units === Tone.Type.Time || this.units === Tone.Type.Frequency ||\n\t\t\tthis.units === Tone.Type.NormalRange || this.units === Tone.Type.Positive ||\n\t\t\tthis.units === Tone.Type.BPM){\n\t\t\treturn 0;\n\t\t} else if (this.units === Tone.Type.AudioRange){\n\t\t\treturn -1;\n\t\t} else if (this.units === Tone.Type.Decibels){\n\t\t\treturn -Infinity;\n\t\t} else {\n\t\t\treturn this._param.minValue;\n\t\t}\n\t}\n});\n\n/**\n * The maximum output value of the parameter\n * @memberOf Tone.Param#\n * @type {Number}\n * @name value\n */\nObject.defineProperty(Tone.Param.prototype, \"maxValue\", {\n\tget : function(){\n\t\tif (this.units === Tone.Type.NormalRange ||\n\t\t\tthis.units === Tone.Type.AudioRange){\n\t\t\treturn 1;\n\t\t} else {\n\t\t\treturn this._param.maxValue;\n\t\t}\n\t}\n});\n\n/**\n * Convert the given value from the type specified by Tone.Param.units\n * into the destination value (such as Gain or Frequency).\n * @private\n * @param {*} val the value to convert\n * @return {number} the number which the value should be set to\n */\nTone.Param.prototype._fromUnits = function(val){\n\tif ((this.convert || Tone.isUndef(this.convert)) && !this.overridden){\n\t\tswitch (this.units){\n\t\t\tcase Tone.Type.Time:\n\t\t\t\treturn this.toSeconds(val);\n\t\t\tcase Tone.Type.Frequency:\n\t\t\t\treturn this.toFrequency(val);\n\t\t\tcase Tone.Type.Decibels:\n\t\t\t\treturn Tone.dbToGain(val);\n\t\t\tcase Tone.Type.NormalRange:\n\t\t\t\treturn Math.min(Math.max(val, 0), 1);\n\t\t\tcase Tone.Type.AudioRange:\n\t\t\t\treturn Math.min(Math.max(val, -1), 1);\n\t\t\tcase Tone.Type.Positive:\n\t\t\t\treturn Math.max(val, 0);\n\t\t\tdefault:\n\t\t\t\treturn val;\n\t\t}\n\t} else {\n\t\treturn val;\n\t}\n};\n\n/**\n * Convert the parameters value into the units specified by Tone.Param.units.\n * @private\n * @param {number} val the value to convert\n * @return {number}\n */\nTone.Param.prototype._toUnits = function(val){\n\tif (this.convert || Tone.isUndef(this.convert)){\n\t\tswitch (this.units){\n\t\t\tcase Tone.Type.Decibels:\n\t\t\t\treturn Tone.gainToDb(val);\n\t\t\tdefault:\n\t\t\t\treturn val;\n\t\t}\n\t} else {\n\t\treturn val;\n\t}\n};\n\n/**\n * the minimum output value\n * @type {Number}\n * @private\n */\nTone.Param.prototype._minOutput = 1e-5;\n\n/**\n * The event types\n * @enum {String}\n * @private\n */\nTone.Param.AutomationType = {\n\tLinear : \"linearRampToValueAtTime\",\n\tExponential : \"exponentialRampToValueAtTime\",\n\tTarget : \"setTargetAtTime\",\n\tSetValue : \"setValueAtTime\",\n\tCancel : \"cancelScheduledValues\"\n};\n\n/**\n * Schedules a parameter value change at the given time.\n * @param {*}\tvalue The value to set the signal.\n * @param {Time} time The time when the change should occur.\n * @returns {Tone.Param} this\n * @example\n * //set the frequency to \"G4\" in exactly 1 second from now.\n * freq.setValueAtTime(\"G4\", \"+1\");\n */\nTone.Param.prototype.setValueAtTime = function(value, time){\n\ttime = this.toSeconds(time);\n\tvalue = this._fromUnits(value);\n\tthis._events.add({\n\t\t\"type\" : Tone.Param.AutomationType.SetValue,\n\t\t\"value\" : value,\n\t\t\"time\" : time,\n\t});\n\tthis.log(Tone.Param.AutomationType.SetValue, value, time);\n\tthis._param.setValueAtTime(value, time);\n\treturn this;\n};\n\n/**\n * Get the signals value at the given time. Subsequent scheduling\n * may invalidate the returned value.\n * @param {Time} time When to get the value\n * @returns {Number} The value at the given time\n */\nTone.Param.prototype.getValueAtTime = function(time){\n\ttime = this.toSeconds(time);\n\tvar after = this._events.getAfter(time);\n\tvar before = this._events.get(time);\n\tvar initialValue = Tone.defaultArg(this._initialValue, this._param.defaultValue);\n\tvar value = initialValue;\n\t//if it was set by\n\tif (before === null){\n\t\tvalue = initialValue;\n\t} else if (before.type === Tone.Param.AutomationType.Target){\n\t\tvar previous = this._events.getBefore(before.time);\n\t\tvar previousVal;\n\t\tif (previous === null){\n\t\t\tpreviousVal = initialValue;\n\t\t} else {\n\t\t\tpreviousVal = previous.value;\n\t\t}\n\t\tvalue = this._exponentialApproach(before.time, previousVal, before.value, before.constant, time);\n\t} else if (after === null){\n\t\tvalue = before.value;\n\t} else if (after.type === Tone.Param.AutomationType.Linear){\n\t\tvalue = this._linearInterpolate(before.time, before.value, after.time, after.value, time);\n\t} else if (after.type === Tone.Param.AutomationType.Exponential){\n\t\tvalue = this._exponentialInterpolate(before.time, before.value, after.time, after.value, time);\n\t} else {\n\t\tvalue = before.value;\n\t}\n\treturn value;\n};\n\n/**\n * Creates a schedule point with the current value at the current time.\n * This is useful for creating an automation anchor point in order to\n * schedule changes from the current value.\n *\n * @param {number=} now (Optionally) pass the now value in.\n * @returns {Tone.Param} this\n */\nTone.Param.prototype.setRampPoint = function(time){\n\ttime = this.toSeconds(time);\n\tvar currentVal = this.getValueAtTime(time);\n\tthis.cancelAndHoldAtTime(time);\n\tif (currentVal === 0){\n\t\tcurrentVal = this._minOutput;\n\t}\n\tthis.setValueAtTime(this._toUnits(currentVal), time);\n\treturn this;\n};\n\n/**\n * Schedules a linear continuous change in parameter value from the\n * previous scheduled parameter value to the given value.\n *\n * @param {number} value\n * @param {Time} endTime\n * @returns {Tone.Param} this\n */\nTone.Param.prototype.linearRampToValueAtTime = function(value, endTime){\n\tvalue = this._fromUnits(value);\n\tendTime = this.toSeconds(endTime);\n\tthis._events.add({\n\t\t\"type\" : Tone.Param.AutomationType.Linear,\n\t\t\"value\" : value,\n\t\t\"time\" : endTime,\n\t});\n\tthis.log(Tone.Param.AutomationType.Linear, value, endTime);\n\tthis._param.linearRampToValueAtTime(value, endTime);\n\treturn this;\n};\n\n/**\n * Schedules an exponential continuous change in parameter value from\n * the previous scheduled parameter value to the given value.\n *\n * @param {number} value\n * @param {Time} endTime\n * @returns {Tone.Param} this\n */\nTone.Param.prototype.exponentialRampToValueAtTime = function(value, endTime){\n\tvalue = this._fromUnits(value);\n\tvalue = Math.max(this._minOutput, value);\n\tendTime = this.toSeconds(endTime);\n\t//store the event\n\tthis._events.add({\n\t\t\"type\" : Tone.Param.AutomationType.Exponential,\n\t\t\"time\" : endTime,\n\t\t\"value\" : value\n\t});\n\tthis.log(Tone.Param.AutomationType.Exponential, value, endTime);\n\tthis._param.exponentialRampToValueAtTime(value, endTime);\n\treturn this;\n};\n\n/**\n * Schedules an exponential continuous change in parameter value from\n * the current time and current value to the given value over the\n * duration of the rampTime.\n *\n * @param {number} value The value to ramp to.\n * @param {Time} rampTime the time that it takes the\n * value to ramp from it's current value\n * @param {Time}\t[startTime=now] \tWhen the ramp should start.\n * @returns {Tone.Param} this\n * @example\n * //exponentially ramp to the value 2 over 4 seconds.\n * signal.exponentialRampTo(2, 4);\n */\nTone.Param.prototype.exponentialRampTo = function(value, rampTime, startTime){\n\tstartTime = this.toSeconds(startTime);\n\tthis.setRampPoint(startTime);\n\tthis.exponentialRampToValueAtTime(value, startTime + this.toSeconds(rampTime));\n\treturn this;\n};\n\n/**\n * Schedules an linear continuous change in parameter value from\n * the current time and current value to the given value over the\n * duration of the rampTime.\n *\n * @param {number} value The value to ramp to.\n * @param {Time} rampTime the time that it takes the\n * value to ramp from it's current value\n * @param {Time}\t[startTime=now] \tWhen the ramp should start.\n * @returns {Tone.Param} this\n * @example\n * //linearly ramp to the value 4 over 3 seconds.\n * signal.linearRampTo(4, 3);\n */\nTone.Param.prototype.linearRampTo = function(value, rampTime, startTime){\n\tstartTime = this.toSeconds(startTime);\n\tthis.setRampPoint(startTime);\n\tthis.linearRampToValueAtTime(value, startTime + this.toSeconds(rampTime));\n\treturn this;\n};\n\n/**\n * Start exponentially approaching the target value at the given time. Since it\n * is an exponential approach it will continue approaching after the ramp duration. The\n * rampTime is the time that it takes to reach over 99% of the way towards the value.\n * @param {number} value The value to ramp to.\n * @param {Time} rampTime the time that it takes the\n * value to ramp from it's current value\n * @param {Time}\t[startTime=now] \tWhen the ramp should start.\n * @returns {Tone.Param} this\n * @example\n * //exponentially ramp to the value 2 over 4 seconds.\n * signal.exponentialRampTo(2, 4);\n */\nTone.Param.prototype.targetRampTo = function(value, rampTime, startTime){\n\tstartTime = this.toSeconds(startTime);\n\tthis.setRampPoint(startTime);\n\tthis.exponentialApproachValueAtTime(value, startTime, rampTime);\n\treturn this;\n};\n\n/**\n * Start exponentially approaching the target value at the given time. Since it\n * is an exponential approach it will continue approaching after the ramp duration. The\n * rampTime is the time that it takes to reach over 99% of the way towards the value. This methods\n * is similar to setTargetAtTime except the third argument is a time instead of a 'timeConstant'\n * @param {number} value The value to ramp to.\n * @param {Time}\ttime \tWhen the ramp should start.\n * @param {Time} rampTime the time that it takes the\n * value to ramp from it's current value\n * @returns {Tone.Param} this\n * @example\n * //exponentially ramp to the value 2 over 4 seconds.\n * signal.exponentialRampTo(2, 4);\n */\nTone.Param.prototype.exponentialApproachValueAtTime = function(value, time, rampTime){\n\tvar timeConstant = Math.log(this.toSeconds(rampTime)+1)/Math.log(200);\n\ttime = this.toSeconds(time);\n\tthis.setTargetAtTime(value, time, timeConstant);\n\t//at 90% start a linear ramp to the final value\n\tthis.cancelAndHoldAtTime(time + rampTime * 0.9);\n\tthis.linearRampToValueAtTime(value, time + rampTime);\n\treturn this;\n};\n\n/**\n * Start exponentially approaching the target value at the given time with\n * a rate having the given time constant.\n * @param {number} value\n * @param {Time} startTime\n * @param {number} timeConstant\n * @returns {Tone.Param} this\n */\nTone.Param.prototype.setTargetAtTime = function(value, startTime, timeConstant){\n\tvalue = this._fromUnits(value);\n\t// The value will never be able to approach without timeConstant > 0.\n\tif (timeConstant <= 0){\n\t\tthrow new Error(\"timeConstant must be greater than 0\");\n\t}\n\tstartTime = this.toSeconds(startTime);\n\tthis._events.add({\n\t\t\"type\" : Tone.Param.AutomationType.Target,\n\t\t\"value\" : value,\n\t\t\"time\" : startTime,\n\t\t\"constant\" : timeConstant\n\t});\n\tthis.log(Tone.Param.AutomationType.Target, value, startTime, timeConstant);\n\tthis._param.setTargetAtTime(value, startTime, timeConstant);\n\treturn this;\n};\n\n/**\n * Sets an array of arbitrary parameter values starting at the given time\n * for the given duration.\n *\n * @param {Array} values\n * @param {Time} startTime\n * @param {Time} duration\n * @param {NormalRange} [scaling=1] If the values in the curve should be scaled by some value\n * @returns {Tone.Param} this\n */\nTone.Param.prototype.setValueCurveAtTime = function(values, startTime, duration, scaling){\n\tscaling = Tone.defaultArg(scaling, 1);\n\tduration = this.toSeconds(duration);\n\tstartTime = this.toSeconds(startTime);\n\tthis.setValueAtTime(values[0] * scaling, startTime);\n\tvar segTime = duration / (values.length - 1);\n\tfor (var i = 1; i < values.length; i++){\n\t\tthis.linearRampToValueAtTime(values[i] * scaling, startTime + i * segTime);\n\t}\n\treturn this;\n};\n\n/**\n * Cancels all scheduled parameter changes with times greater than or\n * equal to startTime.\n *\n * @param {Time} time\n * @returns {Tone.Param} this\n */\nTone.Param.prototype.cancelScheduledValues = function(time){\n\ttime = this.toSeconds(time);\n\tthis._events.cancel(time);\n\tthis._param.cancelScheduledValues(time);\n\tthis.log(Tone.Param.AutomationType.Cancel, time);\n\treturn this;\n};\n\n/**\n * This is similar to [cancelScheduledValues](#cancelScheduledValues) except\n * it holds the automated value at time until the next automated event.\n * @param {Time} time\n * @returns {Tone.Param} this\n */\nTone.Param.prototype.cancelAndHoldAtTime = function(time){\n\ttime = this.toSeconds(time);\n\tvar valueAtTime = this.getValueAtTime(time);\n\tthis.log(\"cancelAndHoldAtTime\", time, \"value=\"+valueAtTime);\n\n\t//remove the schedule events\n\tthis._param.cancelScheduledValues(time);\n\n\t//if there is an event at the given time\n\t//and that even is not a \"set\"\n\tvar before = this._events.get(time);\n\tvar after = this._events.getAfter(time);\n\tif (before && before.time === time){\n\t\t//remove everything after\n\t\tif (after){\n\t\t\tthis._events.cancel(after.time);\n\t\t} else {\n\t\t\tthis._events.cancel(time + this.sampleTime);\n\t\t}\n\t} else if (after){\n\t\t//cancel the next event(s)\n\t\tthis._events.cancel(after.time);\n\t\tif (after.type === Tone.Param.AutomationType.Linear){\n\t\t\tthis.linearRampToValueAtTime(valueAtTime, time);\n\t\t} else if (after.type === Tone.Param.AutomationType.Exponential){\n\t\t\tthis.exponentialRampToValueAtTime(valueAtTime, time);\n\t\t}\n\t}\n\n\t//set the value at the given time\n\tthis._events.add({\n\t\t\"type\" : Tone.Param.AutomationType.SetValue,\n\t\t\"value\" : valueAtTime,\n\t\t\"time\" : time\n\t});\n\tthis._param.setValueAtTime(valueAtTime, time);\n\treturn this;\n};\n\n/**\n * Ramps to the given value over the duration of the rampTime.\n * Automatically selects the best ramp type (exponential or linear)\n * depending on the `units` of the signal\n *\n * @param {number} value\n * @param {Time} rampTime \tThe time that it takes the\n * value to ramp from it's current value\n * @param {Time}\t[startTime=now] \tWhen the ramp should start.\n * @returns {Tone.Param} this\n * @example\n * //ramp to the value either linearly or exponentially\n * //depending on the \"units\" value of the signal\n * signal.rampTo(0, 10);\n * @example\n * //schedule it to ramp starting at a specific time\n * signal.rampTo(0, 10, 5)\n */\nTone.Param.prototype.rampTo = function(value, rampTime, startTime){\n\trampTime = Tone.defaultArg(rampTime, 0.1);\n\tif (this.units === Tone.Type.Frequency || this.units === Tone.Type.BPM || this.units === Tone.Type.Decibels){\n\t\tthis.exponentialRampTo(value, rampTime, startTime);\n\t} else {\n\t\tthis.linearRampTo(value, rampTime, startTime);\n\t}\n\treturn this;\n};\n\n///////////////////////////////////////////////////////////////////////////\n//\tAUTOMATION CURVE CALCULATIONS\n//\tMIT License, copyright (c) 2014 Jordan Santell\n///////////////////////////////////////////////////////////////////////////\n\n// Calculates the the value along the curve produced by setTargetAtTime\nTone.Param.prototype._exponentialApproach = function(t0, v0, v1, timeConstant, t){\n\treturn v1 + (v0 - v1) * Math.exp(-(t - t0) / timeConstant);\n};\n\n// Calculates the the value along the curve produced by linearRampToValueAtTime\nTone.Param.prototype._linearInterpolate = function(t0, v0, t1, v1, t){\n\treturn v0 + (v1 - v0) * ((t - t0) / (t1 - t0));\n};\n\n// Calculates the the value along the curve produced by exponentialRampToValueAtTime\nTone.Param.prototype._exponentialInterpolate = function(t0, v0, t1, v1, t){\n\treturn v0 * Math.pow(v1 / v0, (t - t0) / (t1 - t0));\n};\n\n/**\n * Clean up\n * @returns {Tone.Param} this\n */\nTone.Param.prototype.dispose = function(){\n\tTone.AudioNode.prototype.dispose.call(this);\n\tthis._param = null;\n\tthis._events = null;\n\treturn this;\n};\n\nexport default Tone.Param;\n\n","import Tone from \"../core/Tone\";\nimport \"../effect/Effect\";\nimport \"../component/Split\";\nimport \"../component/Merge\";\nimport \"../component/CrossFade\";\n\n/**\n * @class Base class for Stereo effects. Provides effectSendL/R and effectReturnL/R.\n *\n *\t@constructor\n *\t@extends {Tone.Effect}\n */\nTone.StereoEffect = function(){\n\n\t//get the defaults\n\tTone.AudioNode.call(this);\n\tvar options = Tone.defaults(arguments, [\"wet\"], Tone.Effect);\n\tthis.createInsOuts(1, 1);\n\n\t/**\n\t * the drywet knob to control the amount of effect\n\t * @type {Tone.CrossFade}\n\t * @private\n\t */\n\tthis._dryWet = new Tone.CrossFade(options.wet);\n\n\t/**\n\t * The wet control, i.e. how much of the effected\n\t * will pass through to the output.\n\t * @type {NormalRange}\n\t * @signal\n\t */\n\tthis.wet = this._dryWet.fade;\n\n\t/**\n\t * then split it\n\t * @type {Tone.Split}\n\t * @private\n\t */\n\tthis._split = new Tone.Split();\n\n\t/**\n\t * the effects send LEFT\n\t * @type {GainNode}\n\t * @private\n\t */\n\tthis.effectSendL = this._split.left;\n\n\t/**\n\t * the effects send RIGHT\n\t * @type {GainNode}\n\t * @private\n\t */\n\tthis.effectSendR = this._split.right;\n\n\t/**\n\t * the stereo effect merger\n\t * @type {Tone.Merge}\n\t * @private\n\t */\n\tthis._merge = new Tone.Merge();\n\n\t/**\n\t * the effect return LEFT\n\t * @type {GainNode}\n\t * @private\n\t */\n\tthis.effectReturnL = this._merge.left;\n\n\t/**\n\t * the effect return RIGHT\n\t * @type {GainNode}\n\t * @private\n\t */\n\tthis.effectReturnR = this._merge.right;\n\n\t//connections\n\tTone.connect(this.input, this._split);\n\t//dry wet connections\n\tTone.connect(this.input, this._dryWet, 0, 0);\n\tthis._merge.connect(this._dryWet, 0, 1);\n\tthis._dryWet.connect(this.output);\n\tthis._readOnly([\"wet\"]);\n};\n\nTone.extend(Tone.StereoEffect, Tone.Effect);\n\n/**\n * Clean up.\n * @returns {Tone.StereoEffect} this\n */\nTone.StereoEffect.prototype.dispose = function(){\n\tTone.AudioNode.prototype.dispose.call(this);\n\tthis._dryWet.dispose();\n\tthis._dryWet = null;\n\tthis._split.dispose();\n\tthis._split = null;\n\tthis._merge.dispose();\n\tthis._merge = null;\n\tthis.effectSendL = null;\n\tthis.effectSendR = null;\n\tthis.effectReturnL = null;\n\tthis.effectReturnR = null;\n\tthis._writable([\"wet\"]);\n\tthis.wet = null;\n\treturn this;\n};\n\nexport default Tone.StereoEffect;\n\n","import Tone from \"../core/Tone\";\nimport \"../core/Clock\";\nimport \"../type/Type\";\nimport \"../core/Timeline\";\nimport \"../core/Emitter\";\nimport \"../core/Gain\";\nimport \"../core/IntervalTimeline\";\nimport \"../core/TransportRepeatEvent\";\nimport \"../core/TransportEvent\";\n\n/**\n * @class Transport for timing musical events.\n * Supports tempo curves and time changes. Unlike browser-based timing (setInterval, requestAnimationFrame)\n * Tone.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. \n * A single transport is created for you when the library is initialized.\n *
\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 * @extends {Tone.Emitter}\n * @singleton\n * @example\n * //repeated event every 8th note\n * Tone.Transport.scheduleRepeat(function(time){\n * \t//do something with the time\n * }, \"8n\");\n * @example\n * //schedule an event on the 16th measure\n * Tone.Transport.schedule(function(time){\n * \t//do something with the time\n * }, \"16:0:0\");\n */\nTone.Transport = function(){\n\n\tTone.Emitter.call(this);\n\n\tTone.getContext(function(){\n\n\t\t///////////////////////////////////////////////////////////////////////\n\t\t//\tLOOPING\n\t\t//////////////////////////////////////////////////////////////////////\n\n\t\t/**\n\t\t * \tIf the transport loops or not.\n\t\t * @type {boolean}\n\t\t */\n\t\tthis.loop = false;\n\n\t\t/**\n\t\t * \tThe loop start position in ticks\n\t\t * @type {Ticks}\n\t\t * @private\n\t\t */\n\t\tthis._loopStart = 0;\n\n\t\t/**\n\t\t * \tThe loop end position in ticks\n\t\t * @type {Ticks}\n\t\t * @private\n\t\t */\n\t\tthis._loopEnd = 0;\n\n\t\t///////////////////////////////////////////////////////////////////////\n\t\t//\tCLOCK/TEMPO\n\t\t//////////////////////////////////////////////////////////////////////\n\n\t\t/**\n\t\t * Pulses per quarter is the number of ticks per quarter note.\n\t\t * @private\n\t\t * @type {Number}\n\t\t */\n\t\tthis._ppq = TransportConstructor.defaults.PPQ;\n\n\t\t/**\n\t\t * watches the main oscillator for timing ticks\n\t\t * initially starts at 120bpm\n\t\t * @private\n\t\t * @type {Tone.Clock}\n\t\t */\n\t\tthis._clock = new Tone.Clock({\n\t\t\t\"callback\" : this._processTick.bind(this),\n\t\t\t\"frequency\" : 0,\n\t\t});\n\n\t\tthis._bindClockEvents();\n\n\t\t/**\n\t\t * The Beats Per Minute of the Transport.\n\t\t * @type {BPM}\n\t\t * @signal\n\t\t * @example\n\t\t * Tone.Transport.bpm.value = 80;\n\t\t * //ramp the bpm to 120 over 10 seconds\n\t\t * Tone.Transport.bpm.rampTo(120, 10);\n\t\t */\n\t\tthis.bpm = this._clock.frequency;\n\t\tthis.bpm._toUnits = this._toUnits.bind(this);\n\t\tthis.bpm._fromUnits = this._fromUnits.bind(this);\n\t\tthis.bpm.units = Tone.Type.BPM;\n\t\tthis.bpm.value = TransportConstructor.defaults.bpm;\n\t\tthis._readOnly(\"bpm\");\n\n\t\t/**\n\t\t * The time signature, or more accurately the numerator\n\t\t * of the time signature over a denominator of 4.\n\t\t * @type {Number}\n\t\t * @private\n\t\t */\n\t\tthis._timeSignature = TransportConstructor.defaults.timeSignature;\n\n\t\t///////////////////////////////////////////////////////////////////////\n\t\t//\tTIMELINE EVENTS\n\t\t//////////////////////////////////////////////////////////////////////\n\n\t\t/**\n\t\t * All the events in an object to keep track by ID\n\t\t * @type {Object}\n\t\t * @private\n\t\t */\n\t\tthis._scheduledEvents = {};\n\n\t\t/**\n\t\t * \tThe scheduled events.\n\t\t * @type {Tone.Timeline}\n\t\t * @private\n\t\t */\n\t\tthis._timeline = new Tone.Timeline();\n\n\t\t/**\n\t\t * Repeated events\n\t\t * @type {Array}\n\t\t * @private\n\t\t */\n\t\tthis._repeatedEvents = new Tone.IntervalTimeline();\n\n\t\t/**\n\t\t * All of the synced Signals\n\t\t * @private\n\t\t * @type {Array}\n\t\t */\n\t\tthis._syncedSignals = [];\n\n\t\t///////////////////////////////////////////////////////////////////////\n\t\t//\tSWING\n\t\t//////////////////////////////////////////////////////////////////////\n\n\t\t/**\n\t\t * The subdivision of the swing\n\t\t * @type {Ticks}\n\t\t * @private\n\t\t */\n\t\tthis._swingTicks = TransportConstructor.defaults.PPQ / 2; //8n\n\n\t\t/**\n\t\t * The swing amount\n\t\t * @type {NormalRange}\n\t\t * @private\n\t\t */\n\t\tthis._swingAmount = 0;\n\n\t\t//transport is a singleton so it adds itself to the context\n\t\tthis.context.transport = this;\n\n\t}.bind(this));\n};\n\nTone.extend(Tone.Transport, Tone.Emitter);\n\n/**\n * the defaults\n * @type {Object}\n * @const\n * @static\n */\nTone.Transport.defaults = {\n\t\"bpm\" : 120,\n\t\"swing\" : 0,\n\t\"swingSubdivision\" : \"8n\",\n\t\"timeSignature\" : 4,\n\t\"loopStart\" : 0,\n\t\"loopEnd\" : \"4m\",\n\t\"PPQ\" : 192\n};\n\n/**\n * Is an instanceof Tone.Transport\n * @type {Boolean}\n */\nTone.Transport.prototype.isTransport = true;\n\n///////////////////////////////////////////////////////////////////////////////\n//\tTICKS\n///////////////////////////////////////////////////////////////////////////////\n\n/**\n * called on every tick\n * @param {number} tickTime clock relative tick time\n * @private\n */\nTone.Transport.prototype._processTick = function(tickTime, ticks){\n\t//handle swing\n\tif (this._swingAmount > 0 &&\n\t\tticks % this._ppq !== 0 && //not on a downbeat\n\t\tticks % (this._swingTicks * 2) !== 0){\n\t\t//add some swing\n\t\tvar progress = (ticks % (this._swingTicks * 2)) / (this._swingTicks * 2);\n\t\tvar amount = Math.sin((progress) * Math.PI) * this._swingAmount;\n\t\ttickTime += Tone.Ticks(this._swingTicks * 2/3).toSeconds() * amount;\n\t}\n\t//do the loop test\n\tif (this.loop){\n\t\tif (ticks >= this._loopEnd){\n\t\t\tthis.emit(\"loopEnd\", tickTime);\n\t\t\tthis._clock.setTicksAtTime(this._loopStart, tickTime);\n\t\t\tticks = this._loopStart;\n\t\t\tthis.emit(\"loopStart\", tickTime, this._clock.getSecondsAtTime(tickTime));\n\t\t\tthis.emit(\"loop\", tickTime);\n\t\t}\n\t}\n\t//invoke the timeline events scheduled on this tick\n\tthis._timeline.forEachAtTime(ticks, function(event){\n\t\tevent.invoke(tickTime);\n\t});\n};\n\n///////////////////////////////////////////////////////////////////////////////\n//\tSCHEDULABLE EVENTS\n///////////////////////////////////////////////////////////////////////////////\n\n/**\n * Schedule an event along the timeline.\n * @param {Function} callback The callback to be invoked at the time.\n * @param {TransportTime} time The time to invoke the callback at.\n * @return {Number} The id of the event which can be used for canceling the event.\n * @example\n * //trigger the callback when the Transport reaches the desired time\n * Tone.Transport.schedule(function(time){\n * \tenvelope.triggerAttack(time);\n * }, \"128i\");\n */\nTone.Transport.prototype.schedule = function(callback, time){\n\tvar event = new Tone.TransportEvent(this, {\n\t\t\"time\" : Tone.TransportTime(time),\n\t\t\"callback\" : callback\n\t});\n\treturn this._addEvent(event, this._timeline);\n};\n\n/**\n * Schedule a repeated event along the timeline. The event will fire\n * at the `interval` starting at the `startTime` and for the specified\n * `duration`.\n * @param {Function} callback The callback to invoke.\n * @param {Time} interval The duration between successive\n * callbacks. Must be a positive number.\n * @param {TransportTime=} startTime When along the timeline the events should\n * start being invoked.\n * @param {Time} [duration=Infinity] How long the event should repeat.\n * @return {Number} The ID of the scheduled event. Use this to cancel\n * the event.\n * @example\n * //a callback invoked every eighth note after the first measure\n * Tone.Transport.scheduleRepeat(callback, \"8n\", \"1m\");\n */\nTone.Transport.prototype.scheduleRepeat = function(callback, interval, startTime, duration){\n\tvar event = new Tone.TransportRepeatEvent(this, {\n\t\t\"callback\" : callback,\n\t\t\"interval\" : Tone.Time(interval),\n\t\t\"time\" : Tone.TransportTime(startTime),\n\t\t\"duration\" : Tone.Time(Tone.defaultArg(duration, Infinity)),\n\t});\n\t//kick it off if the Transport is started\n\treturn this._addEvent(event, this._repeatedEvents);\n};\n\n/**\n * Schedule an event that will be removed after it is invoked. \n * @param {Function} callback The callback to invoke once.\n * @param {TransportTime} time The time the callback should be invoked.\n * @returns {Number} The ID of the scheduled event.\n */\nTone.Transport.prototype.scheduleOnce = function(callback, time){\n\tvar event = new Tone.TransportEvent(this, {\n\t\t\"time\" : Tone.TransportTime(time),\n\t\t\"callback\" : callback,\n\t\t\"once\" : true\n\t});\n\treturn this._addEvent(event, this._timeline);\n};\n\n/**\n * Clear the passed in event id from the timeline\n * @param {Number} eventId The id of the event.\n * @returns {Tone.Transport} this\n */\nTone.Transport.prototype.clear = function(eventId){\n\tif (this._scheduledEvents.hasOwnProperty(eventId)){\n\t\tvar item = this._scheduledEvents[eventId.toString()];\n\t\titem.timeline.remove(item.event);\n\t\titem.event.dispose();\n\t\tdelete this._scheduledEvents[eventId.toString()];\n\t}\n\treturn this;\n};\n\n/**\n * Add an event to the correct timeline. Keep track of the\n * timeline it was added to.\n * @param {Tone.TransportEvent}\tevent\n * @param {Tone.Timeline} timeline\n * @returns {Number} the event id which was just added\n * @private\n */\nTone.Transport.prototype._addEvent = function(event, timeline){\n\tthis._scheduledEvents[event.id.toString()] = {\n\t\t\"event\" : event,\n\t\t\"timeline\" : timeline\n\t};\n\ttimeline.add(event);\n\treturn event.id;\n};\n\n/**\n * Remove scheduled events from the timeline after\n * the given time. Repeated events will be removed\n * if their startTime is after the given time\n * @param {TransportTime} [after=0] Clear all events after\n * this time.\n * @returns {Tone.Transport} this\n */\nTone.Transport.prototype.cancel = function(after){\n\tafter = Tone.defaultArg(after, 0);\n\tafter = this.toTicks(after);\n\tthis._timeline.forEachFrom(after, function(event){\n\t\tthis.clear(event.id);\n\t}.bind(this));\n\tthis._repeatedEvents.forEachFrom(after, function(event){\n\t\tthis.clear(event.id);\n\t}.bind(this));\n\treturn this;\n};\n\n///////////////////////////////////////////////////////////////////////////////\n//\tSTART/STOP/PAUSE\n///////////////////////////////////////////////////////////////////////////////\n\n/**\n * Bind start/stop/pause events from the clock and emit them.\n * @private\n */\nTone.Transport.prototype._bindClockEvents = function(){\n\tthis._clock.on(\"start\", function(time, offset){\n\t\toffset = Tone.Ticks(offset).toSeconds();\n\t\tthis.emit(\"start\", time, offset);\n\t}.bind(this));\n\n\tthis._clock.on(\"stop\", function(time){\n\t\tthis.emit(\"stop\", time);\n\t}.bind(this));\n\n\tthis._clock.on(\"pause\", function(time){\n\t\tthis.emit(\"pause\", time);\n\t}.bind(this));\n};\n\n/**\n * Returns the playback state of the source, either \"started\", \"stopped\", or \"paused\"\n * @type {Tone.State}\n * @readOnly\n * @memberOf Tone.Transport#\n * @name state\n */\nObject.defineProperty(Tone.Transport.prototype, \"state\", {\n\tget : function(){\n\t\treturn this._clock.getStateAtTime(this.now());\n\t}\n});\n\n/**\n * Start the transport and all sources synced to the transport.\n * @param {Time} [time=now] The time when the transport should start.\n * @param {TransportTime=} offset The timeline offset to start the transport.\n * @returns {Tone.Transport} this\n * @example\n * //start the transport in one second starting at beginning of the 5th measure.\n * Tone.Transport.start(\"+1\", \"4:0:0\");\n */\nTone.Transport.prototype.start = function(time, offset){\n\t//start the clock\n\tif (Tone.isDefined(offset)){\n\t\toffset = this.toTicks(offset);\n\t}\n\tthis._clock.start(time, offset);\n\treturn this;\n};\n\n/**\n * Stop the transport and all sources synced to the transport.\n * @param {Time} [time=now] The time when the transport should stop.\n * @returns {Tone.Transport} this\n * @example\n * Tone.Transport.stop();\n */\nTone.Transport.prototype.stop = function(time){\n\tthis._clock.stop(time);\n\treturn this;\n};\n\n/**\n * Pause the transport and all sources synced to the transport.\n * @param {Time} [time=now]\n * @returns {Tone.Transport} this\n */\nTone.Transport.prototype.pause = function(time){\n\tthis._clock.pause(time);\n\treturn this;\n};\n\n/**\n * Toggle the current state of the transport. If it is\n * started, it will stop it, otherwise it will start the Transport.\n * @param {Time=} time The time of the event\n * @return {Tone.Transport} this\n */\nTone.Transport.prototype.toggle = function(time){\n\ttime = this.toSeconds(time);\n\tif (this._clock.getStateAtTime(time) !== Tone.State.Started){\n\t\tthis.start(time);\n\t} else {\n\t\tthis.stop(time);\n\t}\n\treturn this;\n};\n\n///////////////////////////////////////////////////////////////////////////////\n//\tSETTERS/GETTERS\n///////////////////////////////////////////////////////////////////////////////\n\n/**\n * The time signature as just the numerator over 4.\n * For example 4/4 would be just 4 and 6/8 would be 3.\n * @memberOf Tone.Transport#\n * @type {Number|Array}\n * @name timeSignature\n * @example\n * //common time\n * Tone.Transport.timeSignature = 4;\n * // 7/8\n * Tone.Transport.timeSignature = [7, 8];\n * //this will be reduced to a single number\n * Tone.Transport.timeSignature; //returns 3.5\n */\nObject.defineProperty(Tone.Transport.prototype, \"timeSignature\", {\n\tget : function(){\n\t\treturn this._timeSignature;\n\t},\n\tset : function(timeSig){\n\t\tif (Tone.isArray(timeSig)){\n\t\t\ttimeSig = (timeSig[0] / timeSig[1]) * 4;\n\t\t}\n\t\tthis._timeSignature = timeSig;\n\t}\n});\n\n/**\n * When the Tone.Transport.loop = true, this is the starting position of the loop.\n * @memberOf Tone.Transport#\n * @type {Time}\n * @name loopStart\n */\nObject.defineProperty(Tone.Transport.prototype, \"loopStart\", {\n\tget : function(){\n\t\treturn Tone.Ticks(this._loopStart).toSeconds();\n\t},\n\tset : function(startPosition){\n\t\tthis._loopStart = this.toTicks(startPosition);\n\t}\n});\n\n/**\n * When the Tone.Transport.loop = true, this is the ending position of the loop.\n * @memberOf Tone.Transport#\n * @type {Time}\n * @name loopEnd\n */\nObject.defineProperty(Tone.Transport.prototype, \"loopEnd\", {\n\tget : function(){\n\t\treturn Tone.Ticks(this._loopEnd).toSeconds();\n\t},\n\tset : function(endPosition){\n\t\tthis._loopEnd = this.toTicks(endPosition);\n\t}\n});\n\n/**\n * Set the loop start and stop at the same time.\n * @param {TransportTime} startPosition\n * @param {TransportTime} endPosition\n * @returns {Tone.Transport} this\n * @example\n * //loop over the first measure\n * Tone.Transport.setLoopPoints(0, \"1m\");\n * Tone.Transport.loop = true;\n */\nTone.Transport.prototype.setLoopPoints = function(startPosition, endPosition){\n\tthis.loopStart = startPosition;\n\tthis.loopEnd = endPosition;\n\treturn this;\n};\n\n/**\n * The swing value. Between 0-1 where 1 equal to\n * the note + half the subdivision.\n * @memberOf Tone.Transport#\n * @type {NormalRange}\n * @name swing\n */\nObject.defineProperty(Tone.Transport.prototype, \"swing\", {\n\tget : function(){\n\t\treturn this._swingAmount;\n\t},\n\tset : function(amount){\n\t\t//scale the values to a normal range\n\t\tthis._swingAmount = amount;\n\t}\n});\n\n/**\n * Set the subdivision which the swing will be applied to.\n * The default value is an 8th note. Value must be less\n * than a quarter note.\n *\n * @memberOf Tone.Transport#\n * @type {Time}\n * @name swingSubdivision\n */\nObject.defineProperty(Tone.Transport.prototype, \"swingSubdivision\", {\n\tget : function(){\n\t\treturn Tone.Ticks(this._swingTicks).toNotation();\n\t},\n\tset : function(subdivision){\n\t\tthis._swingTicks = this.toTicks(subdivision);\n\t}\n});\n\n/**\n * The Transport's position in Bars:Beats:Sixteenths.\n * Setting the value will jump to that position right away.\n * @memberOf Tone.Transport#\n * @type {BarsBeatsSixteenths}\n * @name position\n */\nObject.defineProperty(Tone.Transport.prototype, \"position\", {\n\tget : function(){\n\t\tvar now = this.now();\n\t\tvar ticks = this._clock.getTicksAtTime(now);\n\t\treturn Tone.Ticks(ticks).toBarsBeatsSixteenths();\n\t},\n\tset : function(progress){\n\t\tvar ticks = this.toTicks(progress);\n\t\tthis.ticks = ticks;\n\t}\n});\n\n/**\n * The Transport's position in seconds\n * Setting the value will jump to that position right away.\n * @memberOf Tone.Transport#\n * @type {Seconds}\n * @name seconds\n */\nObject.defineProperty(Tone.Transport.prototype, \"seconds\", {\n\tget : function(){\n\t\treturn this._clock.seconds;\n\t},\n\tset : function(s){\n\t\tvar now = this.now();\n\t\tvar ticks = this.bpm.timeToTicks(s, now);\n\t\tthis.ticks = ticks;\n\t}\n});\n\n/**\n * The Transport's loop position as a normalized value. Always\n * returns 0 if the transport if loop is not true.\n * @memberOf Tone.Transport#\n * @name progress\n * @type {NormalRange}\n */\nObject.defineProperty(Tone.Transport.prototype, \"progress\", {\n\tget : function(){\n\t\tif (this.loop){\n\t\t\tvar now = this.now();\n\t\t\tvar ticks = this._clock.getTicksAtTime(now);\n\t\t\treturn (ticks - this._loopStart) / (this._loopEnd - this._loopStart);\n\t\t} else {\n\t\t\treturn 0;\n\t\t}\n\t}\n});\n\n/**\n * The transports current tick position.\n *\n * @memberOf Tone.Transport#\n * @type {Ticks}\n * @name ticks\n */\nObject.defineProperty(Tone.Transport.prototype, \"ticks\", {\n\tget : function(){\n\t\treturn this._clock.ticks;\n\t},\n\tset : function(t){\n\t\tif (this._clock.ticks !== t){\n\t\t\tvar now = this.now();\n\t\t\t//stop everything synced to the transport\n\t\t\tif (this.state === Tone.State.Started){\n\t\t\t\tthis.emit(\"stop\", now);\n\t\t\t\tthis._clock.setTicksAtTime(t, now);\n\t\t\t\t//restart it with the new time\n\t\t\t\tthis.emit(\"start\", now, this.seconds);\n\t\t\t} else {\n\t\t\t\tthis._clock.setTicksAtTime(t, now);\n\t\t\t}\n\t\t}\n\t}\n});\n\n/**\n * Get the clock's ticks at the given time.\n * @param {Time} time When to get the tick value\n * @return {Ticks} The tick value at the given time.\n */\nTone.Transport.prototype.getTicksAtTime = function(time){\n\treturn Math.round(this._clock.getTicksAtTime(time));\n};\n\n/**\n * Return the elapsed seconds at the given time.\n * @param {Time} time When to get the elapsed seconds\n * @return {Seconds} The number of elapsed seconds\n */\nTone.Transport.prototype.getSecondsAtTime = function(time){\n\treturn this._clock.getSecondsAtTime(time);\n};\n\n/**\n * Pulses Per Quarter note. This is the smallest resolution\n * the Transport timing supports. This should be set once\n * on initialization and not set again. Changing this value\n * after other objects have been created can cause problems.\n *\n * @memberOf Tone.Transport#\n * @type {Number}\n * @name PPQ\n */\nObject.defineProperty(Tone.Transport.prototype, \"PPQ\", {\n\tget : function(){\n\t\treturn this._ppq;\n\t},\n\tset : function(ppq){\n\t\tvar bpm = this.bpm.value;\n\t\tthis._ppq = ppq;\n\t\tthis.bpm.value = bpm;\n\t}\n});\n\n/**\n * Convert from BPM to frequency (factoring in PPQ)\n * @param {BPM} bpm The BPM value to convert to frequency\n * @return {Frequency} The BPM as a frequency with PPQ factored in.\n * @private\n */\nTone.Transport.prototype._fromUnits = function(bpm){\n\treturn 1 / (60 / bpm / this.PPQ);\n};\n\n/**\n * Convert from frequency (with PPQ) into BPM\n * @param {Frequency} freq The clocks frequency to convert to BPM\n * @return {BPM} The frequency value as BPM.\n * @private\n */\nTone.Transport.prototype._toUnits = function(freq){\n\treturn (freq / this.PPQ) * 60;\n};\n\n///////////////////////////////////////////////////////////////////////////////\n//\tSYNCING\n///////////////////////////////////////////////////////////////////////////////\n\n/**\n * Returns the time aligned to the next subdivision\n * of the Transport. If the Transport is not started,\n * it will return 0.\n * Note: this will not work precisely during tempo ramps.\n * @param {Time} subdivision The subdivision to quantize to\n * @return {Number} The context time of the next subdivision.\n * @example\n * Tone.Transport.start(); //the transport must be started\n * Tone.Transport.nextSubdivision(\"4n\");\n */\nTone.Transport.prototype.nextSubdivision = function(subdivision){\n\tsubdivision = this.toTicks(subdivision);\n\tif (this.state !== Tone.State.Started){\n\t\t//if the transport's not started, return 0\n\t\treturn 0;\n\t} else {\n\t\tvar now = this.now();\n\t\t//the remainder of the current ticks and the subdivision\n\t\tvar transportPos = this.getTicksAtTime(now);\n\t\tvar remainingTicks = subdivision - transportPos % subdivision;\n\t\treturn this._clock.nextTickTime(remainingTicks, now);\n\t}\n};\n\n/**\n * Attaches the signal to the tempo control signal so that\n * any changes in the tempo will change the signal in the same\n * ratio.\n *\n * @param {Tone.Signal} signal\n * @param {number=} ratio Optionally pass in the ratio between\n * the two signals. Otherwise it will be computed\n * based on their current values.\n * @returns {Tone.Transport} this\n */\nTone.Transport.prototype.syncSignal = function(signal, ratio){\n\tif (!ratio){\n\t\t//get the sync ratio\n\t\tvar now = this.now();\n\t\tif (signal.getValueAtTime(now) !== 0){\n\t\t\tratio = signal.getValueAtTime(now) / this.bpm.getValueAtTime(now);\n\t\t} else {\n\t\t\tratio = 0;\n\t\t}\n\t}\n\tvar ratioSignal = new Tone.Gain(ratio);\n\tthis.bpm.chain(ratioSignal, signal._param);\n\tthis._syncedSignals.push({\n\t\t\"ratio\" : ratioSignal,\n\t\t\"signal\" : signal,\n\t\t\"initial\" : signal.value\n\t});\n\tsignal.value = 0;\n\treturn this;\n};\n\n/**\n * Unsyncs a previously synced signal from the transport's control.\n * See Tone.Transport.syncSignal.\n * @param {Tone.Signal} signal\n * @returns {Tone.Transport} this\n */\nTone.Transport.prototype.unsyncSignal = function(signal){\n\tfor (var i = this._syncedSignals.length - 1; i >= 0; i--){\n\t\tvar syncedSignal = this._syncedSignals[i];\n\t\tif (syncedSignal.signal === signal){\n\t\t\tsyncedSignal.ratio.dispose();\n\t\t\tsyncedSignal.signal.value = syncedSignal.initial;\n\t\t\tthis._syncedSignals.splice(i, 1);\n\t\t}\n\t}\n\treturn this;\n};\n\n/**\n * Clean up.\n * @returns {Tone.Transport} this\n * @private\n */\nTone.Transport.prototype.dispose = function(){\n\tTone.Emitter.prototype.dispose.call(this);\n\tthis._clock.dispose();\n\tthis._clock = null;\n\tthis._writable(\"bpm\");\n\tthis.bpm = null;\n\tthis._timeline.dispose();\n\tthis._timeline = null;\n\tthis._repeatedEvents.dispose();\n\tthis._repeatedEvents = null;\n\treturn this;\n};\n\n///////////////////////////////////////////////////////////////////////////////\n//\tINITIALIZATION\n///////////////////////////////////////////////////////////////////////////////\n\nvar TransportConstructor = Tone.Transport;\nTone.Transport = new TransportConstructor();\n\nTone.Context.on(\"init\", function(context){\n\tif (context.transport && context.transport.isTransport){\n\t\tTone.Transport = context.transport;\n\t} else {\n\t\tTone.Transport = new TransportConstructor();\n\t}\n});\n\nTone.Context.on(\"close\", function(context){\n\tif (context.transport && context.transport.isTransport){\n\t\tcontext.transport.dispose();\n\t}\n});\n\nexport default Tone.Transport;\n\n","import Tone from \"../core/Tone\";\nimport \"../signal/Signal\";\nimport \"../source/Source\";\nimport \"../core/Transport\";\nimport \"../source/OscillatorNode\";\n\n/**\n * @class Tone.Oscillator supports a number of features including\n * phase rotation, multiple oscillator types (see Tone.Oscillator.type),\n * and Transport syncing (see Tone.Oscillator.syncFrequency).\n *\n * @constructor\n * @extends {Tone.Source}\n * @param {Frequency} [frequency] Starting frequency\n * @param {string} [type] The oscillator type. Read more about type below.\n * @example\n * //make and start a 440hz sine tone\n * var osc = new Tone.Oscillator(440, \"sine\").toMaster().start();\n */\nTone.Oscillator = function(){\n\n\tvar options = Tone.defaults(arguments, [\"frequency\", \"type\"], Tone.Oscillator);\n\tTone.Source.call(this, options);\n\n\t/**\n\t * the main oscillator\n\t * @type {OscillatorNode}\n\t * @private\n\t */\n\tthis._oscillator = null;\n\n\t/**\n\t * The frequency control.\n\t * @type {Frequency}\n\t * @signal\n\t */\n\tthis.frequency = new Tone.Signal(options.frequency, Tone.Type.Frequency);\n\n\t/**\n\t * The detune control signal.\n\t * @type {Cents}\n\t * @signal\n\t */\n\tthis.detune = new Tone.Signal(options.detune, Tone.Type.Cents);\n\n\t/**\n\t * the periodic wave\n\t * @type {PeriodicWave}\n\t * @private\n\t */\n\tthis._wave = null;\n\n\t/**\n\t * The partials of the oscillator\n\t * @type {Array}\n\t * @private\n\t */\n\tthis._partials = options.partials;\n\n\t/**\n\t * The number of partials to limit or extend the periodic wave by\n\t * @type {Number}\n\t * @private\n\t */\n\tthis._partialCount = options.partialCount;\n\n\t/**\n\t * the phase of the oscillator\n\t * between 0 - 360\n\t * @type {number}\n\t * @private\n\t */\n\tthis._phase = options.phase;\n\n\t/**\n\t * the type of the oscillator\n\t * @type {string}\n\t * @private\n\t */\n\tthis._type = options.type;\n\n\t//setup\n\tif (options.partialCount && options.type !== Tone.Oscillator.Type.Custom){\n\t\tthis._type = this.baseType + options.partialCount.toString();\n\t}\n\tthis.phase = this._phase;\n\tthis._readOnly([\"frequency\", \"detune\"]);\n};\n\nTone.extend(Tone.Oscillator, Tone.Source);\n\n/**\n * the default parameters\n * @type {Object}\n */\nTone.Oscillator.defaults = {\n\t\"type\" : \"sine\",\n\t\"frequency\" : 440,\n\t\"detune\" : 0,\n\t\"phase\" : 0,\n\t\"partials\" : [],\n\t\"partialCount\" : 0\n};\n\n/**\n * The Oscillator types\n * @enum {String}\n */\nTone.Oscillator.Type = {\n\tSine : \"sine\",\n\tTriangle : \"triangle\",\n\tSawtooth : \"sawtooth\",\n\tSquare : \"square\",\n\tCustom : \"custom\"\n};\n\n/**\n * start the oscillator\n * @param {Time} [time=now]\n * @private\n */\nTone.Oscillator.prototype._start = function(time){\n\tthis.log(\"start\", time);\n\t//new oscillator with previous values\n\tvar oscillator = new Tone.OscillatorNode();\n\tthis._oscillator = oscillator;\n\tif (this._wave){\n\t\tthis._oscillator.setPeriodicWave(this._wave);\n\t} else {\n\t\tthis._oscillator.type = this._type;\n\t}\n\t//connect the control signal to the oscillator frequency & detune\n\tthis._oscillator.connect(this.output);\n\tthis.frequency.connect(this._oscillator.frequency);\n\tthis.detune.connect(this._oscillator.detune);\n\n\t//start the oscillator\n\ttime = this.toSeconds(time);\n\tthis._oscillator.start(time);\n};\n\n/**\n * stop the oscillator\n * @private\n * @param {Time} [time=now] (optional) timing parameter\n * @returns {Tone.Oscillator} this\n */\nTone.Oscillator.prototype._stop = function(time){\n\tthis.log(\"stop\", time);\n\tif (this._oscillator){\n\t\ttime = this.toSeconds(time);\n\t\tthis._oscillator.stop(time);\n\t}\n\treturn this;\n};\n\n/**\n * Restart the oscillator. Does not stop the oscillator, but instead\n * just cancels any scheduled 'stop' from being invoked.\n * @param {Time=} time\n * @return {Tone.Oscillator} this\n */\nTone.Oscillator.prototype.restart = function(time){\n\tif (this._oscillator){\n\t\tthis._oscillator.cancelStop();\n\t}\n\tthis._state.cancel(this.toSeconds(time));\n\treturn this;\n};\n\n/**\n * Sync the signal to the Transport's bpm. Any changes to the transports bpm,\n * will also affect the oscillators frequency.\n * @returns {Tone.Oscillator} this\n * @example\n * Tone.Transport.bpm.value = 120;\n * osc.frequency.value = 440;\n * //the ration between the bpm and the frequency will be maintained\n * osc.syncFrequency();\n * Tone.Transport.bpm.value = 240;\n * // the frequency of the oscillator is doubled to 880\n */\nTone.Oscillator.prototype.syncFrequency = function(){\n\tTone.Transport.syncSignal(this.frequency);\n\treturn this;\n};\n\n/**\n * Unsync the oscillator's frequency from the Transport.\n * See Tone.Oscillator.syncFrequency\n * @returns {Tone.Oscillator} this\n */\nTone.Oscillator.prototype.unsyncFrequency = function(){\n\tTone.Transport.unsyncSignal(this.frequency);\n\treturn this;\n};\n\n/**\n * The type of the oscillator: either sine, square, triangle, or sawtooth. Also capable of\n * setting the first x number of partials of the oscillator. For example: \"sine4\" would\n * set be the first 4 partials of the sine wave and \"triangle8\" would set the first\n * 8 partials of the triangle wave.\n *
\n * Uses PeriodicWave internally even for native types so that it can set the phase.\n * PeriodicWave equations are from the\n * [Webkit Web Audio implementation](https://code.google.com/p/chromium/codesearch#chromium/src/third_party/WebKit/Source/modules/webaudio/PeriodicWave.cpp&sq=package:chromium).\n *\n * @memberOf Tone.Oscillator#\n * @type {string}\n * @name type\n * @example\n * //set it to a square wave\n * osc.type = \"square\";\n * @example\n * //set the first 6 partials of a sawtooth wave\n * osc.type = \"sawtooth6\";\n */\nObject.defineProperty(Tone.Oscillator.prototype, \"type\", {\n\tget : function(){\n\t\treturn this._type;\n\t},\n\tset : function(type){\n\t\tvar isBasicType = [Tone.Oscillator.Type.Sine, Tone.Oscillator.Type.Square, Tone.Oscillator.Type.Triangle, Tone.Oscillator.Type.Sawtooth].includes(type);\n\t\tif (this._phase === 0 && isBasicType){\n\t\t\tthis._wave = null;\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\tthis._oscillator.type = type;\n\t\t\t}\n\t\t} else {\n\t\t\tvar coefs = this._getRealImaginary(type, this._phase);\n\t\t\tvar periodicWave = this.context.createPeriodicWave(coefs[0], coefs[1]);\n\t\t\tthis._wave = periodicWave;\n\t\t\tif (this._oscillator !== null){\n\t\t\t\tthis._oscillator.setPeriodicWave(this._wave);\n\t\t\t}\n\t\t}\n\t\tthis._type = type;\n\t}\n});\n\n/**\n * The oscillator type without the partialsCount appended to the end\n * @memberOf Tone.Oscillator#\n * @type {string}\n * @name baseType\n * @example\n * osc.type = 'sine2'\n * osc.baseType //'sine'\n * osc.partialCount = 2\n */\nObject.defineProperty(Tone.Oscillator.prototype, \"baseType\", {\n\tget : function(){\n\t\treturn this._type.replace(this.partialCount, \"\");\n\t},\n\tset : function(baseType){\n\t\tif (this.partialCount && this._type !== Tone.Oscillator.Type.Custom && baseType !== Tone.Oscillator.Type.Custom){\n\t\t\tthis.type = baseType + this.partialCount;\n\t\t} else {\n\t\t\tthis.type = baseType;\n\t\t}\n\t}\n});\n\n/**\n * 'partialCount' offers an alternative way to set the number of used partials. \n * When partialCount is 0, the maximum number of partials are used when representing\n * the waveform using the periodicWave. When 'partials' is set, this value is \n * not settable, but equals the length of the partials array.\n * @example\n * osc.type = 'sine'\n * osc.partialCount = 3\n * //is equivalent to\n * osc.type = 'sine3'\n * @memberOf Tone.Oscillator#\n * @type {Number}\n * @name partialCount\n */\nObject.defineProperty(Tone.Oscillator.prototype, \"partialCount\", {\n\tget : function(){\n\t\treturn this._partialCount;\n\t},\n\tset : function(p){\n\t\tvar type = this._type;\n\t\tvar partial = /^(sine|triangle|square|sawtooth)(\\d+)$/.exec(this._type);\n\t\tif (partial){\n\t\t\ttype = partial[1];\n\t\t}\n\t\tif (this._type !== Tone.Oscillator.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();\n\t\t\t}\n\t\t}\n\t}\n});\n\n/**\n * Get the object's attributes. Given no arguments get\n * will return all available object properties and their corresponding\n * values. \n * @memberOf Tone.Oscillator#\n * @returns {Object}\n */\nTone.Oscillator.prototype.get = function(){\n\tvar values = Tone.prototype.get.apply(this, arguments);\n\tif (values.type !== Tone.Oscillator.Type.Custom){\n\t\tdelete values.partials;\n\t}\n\treturn values;\n};\n\n/**\n * Returns the real and imaginary components based\n * on the oscillator type.\n * @returns {Array} [real, imaginary]\n * @private\n */\nTone.Oscillator.prototype._getRealImaginary = function(type, phase){\n\tvar fftSize = 4096;\n\tvar periodicWaveSize = fftSize / 2;\n\n\tvar real = new Float32Array(periodicWaveSize);\n\tvar imag = new Float32Array(periodicWaveSize);\n\n\tvar partialCount = 1;\n\tif (type === Tone.Oscillator.Type.Custom){\n\t\tpartialCount = this._partials.length + 1;\n\t\tthis._partialCount = this._partials.length;\n\t\tperiodicWaveSize = partialCount;\n\t} else {\n\t\tvar partial = /^(sine|triangle|square|sawtooth)(\\d+)$/.exec(type);\n\t\tif (partial){\n\t\t\tpartialCount = parseInt(partial[2]) + 1;\n\t\t\tthis._partialCount = parseInt(partial[2]);\n\t\t\ttype = partial[1];\n\t\t\tpartialCount = Math.max(partialCount, 2);\n\t\t\tperiodicWaveSize = partialCount;\n\t\t} else {\n\t\t\tthis._partialCount = 0;\n\t\t}\n\t\tthis._partials = [];\n\t}\n\n\tfor (var n = 1; n < periodicWaveSize; ++n){\n\t\tvar piFactor = 2 / (n * Math.PI);\n\t\tvar b;\n\t\tswitch (type){\n\t\t\tcase Tone.Oscillator.Type.Sine:\n\t\t\t\tb = (n <= partialCount) ? 1 : 0;\n\t\t\t\tthis._partials[n-1] = b;\n\t\t\t\tbreak;\n\t\t\tcase Tone.Oscillator.Type.Square:\n\t\t\t\tb = (n & 1) ? 2 * piFactor : 0;\n\t\t\t\tthis._partials[n-1] = b;\n\t\t\t\tbreak;\n\t\t\tcase Tone.Oscillator.Type.Sawtooth:\n\t\t\t\tb = piFactor * ((n & 1) ? 1 : -1);\n\t\t\t\tthis._partials[n-1] = b;\n\t\t\t\tbreak;\n\t\t\tcase Tone.Oscillator.Type.Triangle:\n\t\t\t\tif (n & 1){\n\t\t\t\t\tb = 2 * (piFactor * piFactor) * ((((n - 1) >> 1) & 1) ? -1 : 1);\n\t\t\t\t} else {\n\t\t\t\t\tb = 0;\n\t\t\t\t}\n\t\t\t\tthis._partials[n-1] = b;\n\t\t\t\tbreak;\n\t\t\tcase Tone.Oscillator.Type.Custom:\n\t\t\t\tb = this._partials[n - 1];\n\t\t\t\tbreak;\n\t\t\tdefault:\n\t\t\t\tthrow new TypeError(\"Tone.Oscillator: invalid type: \"+type);\n\t\t}\n\t\tif (b !== 0){\n\t\t\treal[n] = -b * Math.sin(phase * n);\n\t\t\timag[n] = b * Math.cos(phase * n);\n\t\t} else {\n\t\t\treal[n] = 0;\n\t\t\timag[n] = 0;\n\t\t}\n\t}\n\treturn [real, imag];\n};\n\n/**\n * Compute the inverse FFT for a given phase.\n * @param {Float32Array} real\n * @param {Float32Array} imag\n * @param {NormalRange} phase\n * @return {AudioRange}\n * @private\n */\nTone.Oscillator.prototype._inverseFFT = function(real, imag, phase){\n\tvar sum = 0;\n\tvar len = real.length;\n\tfor (var i = 0; i < len; i++){\n\t\tsum += real[i] * Math.cos(i * phase) + imag[i] * Math.sin(i * phase);\n\t}\n\treturn sum;\n};\n\n/**\n * Returns the initial value of the oscillator.\n * @return {AudioRange}\n * @private\n */\nTone.Oscillator.prototype._getInitialValue = function(){\n\tvar coefs = this._getRealImaginary(this._type, 0);\n\tvar real = coefs[0];\n\tvar imag = coefs[1];\n\tvar maxValue = 0;\n\tvar twoPi = Math.PI * 2;\n\t//check for peaks in 8 places\n\tfor (var i = 0; i < 8; i++){\n\t\tmaxValue = Math.max(this._inverseFFT(real, imag, (i / 8) * twoPi), maxValue);\n\t}\n\treturn -this._inverseFFT(real, imag, this._phase) / maxValue;\n};\n\n/**\n * The partials of the waveform. A partial represents\n * the amplitude at a harmonic. The first harmonic is the\n * fundamental frequency, the second is the octave and so on\n * following the harmonic series.\n * Setting this value will automatically set the type to \"custom\".\n * The value is an empty array when the type is not \"custom\".\n * @memberOf Tone.Oscillator#\n * @type {Array}\n * @name partials\n * @example\n * osc.partials = [1, 0.2, 0.01];\n */\nObject.defineProperty(Tone.Oscillator.prototype, \"partials\", {\n\tget : function(){\n\t\treturn this._partials;\n\t},\n\tset : function(partials){\n\t\tthis._partials = partials;\n\t\tthis.type = Tone.Oscillator.Type.Custom;\n\t}\n});\n\n/**\n * The phase of the oscillator in degrees.\n * @memberOf Tone.Oscillator#\n * @type {Degrees}\n * @name phase\n * @example\n * osc.phase = 180; //flips the phase of the oscillator\n */\nObject.defineProperty(Tone.Oscillator.prototype, \"phase\", {\n\tget : function(){\n\t\treturn this._phase * (180 / Math.PI);\n\t},\n\tset : function(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\n/**\n * Dispose and disconnect.\n * @return {Tone.Oscillator} this\n */\nTone.Oscillator.prototype.dispose = function(){\n\tTone.Source.prototype.dispose.call(this);\n\tif (this._oscillator !== null){\n\t\tthis._oscillator.dispose();\n\t\tthis._oscillator = null;\n\t}\n\tthis._wave = null;\n\tthis._writable([\"frequency\", \"detune\"]);\n\tthis.frequency.dispose();\n\tthis.frequency = null;\n\tthis.detune.dispose();\n\tthis.detune = null;\n\tthis._partials = null;\n\treturn this;\n};\n\nexport default Tone.Oscillator;\n\n","import Tone from \"../core/Tone\";\nimport \"../core/Param\";\nimport \"../core/AudioNode\";\n\n/**\n * @class Wrapper around Web Audio's native [DelayNode](http://webaudio.github.io/web-audio-api/#the-delaynode-interface).\n * @extends {Tone}\n * @param {Time=} delayTime The delay applied to the incoming signal.\n * @param {Time=} maxDelay The maximum delay time.\n */\nTone.Delay = function(){\n\n\tvar options = Tone.defaults(arguments, [\"delayTime\", \"maxDelay\"], Tone.Delay);\n\tTone.AudioNode.call(this, options);\n\n\t/**\n\t * The maximum delay time initialized with the node\n\t * @type {Number}\n\t * @private\n\t */\n\tthis._maxDelay = Math.max(this.toSeconds(options.maxDelay), this.toSeconds(options.delayTime));\n\t\n\t/**\n\t * The native delay node\n\t * @type {DelayNode}\n\t * @private\n\t */\n\tthis._delayNode = this.input = this.output = this.context.createDelay(this._maxDelay);\n\n\t/**\n\t * The amount of time the incoming signal is\n\t * delayed.\n\t * @type {Time}\n\t * @signal\n\t */\n\tthis.delayTime = new Tone.Param({\n\t\t\"param\" : this._delayNode.delayTime,\n\t\t\"units\" : Tone.Type.Time,\n\t\t\"value\" : options.delayTime\n\t});\n\n\tthis._readOnly(\"delayTime\");\n};\n\nTone.extend(Tone.Delay, Tone.AudioNode);\n\n/**\n * The defaults\n * @const\n * @type {Object}\n */\nTone.Delay.defaults = {\n\t\"maxDelay\" : 1,\n\t\"delayTime\" : 0\n};\n\n/**\n * The maximum delay time. This cannot be changed. The value is passed into the constructor.\n * @memberof Tone.Delay#\n * @type {Time}\n * @name maxDelay\n * @readOnly\n */\nObject.defineProperty(Tone.Delay.prototype, \"maxDelay\", {\n\tget : function(){\n\t\treturn this._maxDelay;\n\t}\n});\n\n/**\n * Clean up.\n * @return {Tone.Delay} this\n */\nTone.Delay.prototype.dispose = function(){\n\tTone.AudioNode.prototype.dispose.call(this);\n\tthis._delayNode.disconnect();\n\tthis._delayNode = null;\n\tthis._writable(\"delayTime\");\n\tthis.delayTime = null;\n\treturn this;\n};\n\nexport default Tone.Delay;\n\n","import Tone from \"../core/Tone\";\nimport \"../core/Gain\";\nimport \"../core/AudioNode\";\n\n/**\n *\t@class Tone.Split splits an incoming signal into left and right channels.\n *\n * @constructor\n * @extends {Tone.AudioNode}\n * @param {number} [channels=2] The number of channels to merge.\n * @example\n * var split = new Tone.Split();\n * stereoSignal.connect(split);\n */\nTone.Split = function(channels){\n\n\t//defaults to 2 channels\n\tchannels = Tone.defaultArg(channels, 2);\n\n\tTone.AudioNode.call(this);\n\tthis.createInsOuts(0, channels);\n\n\t/**\n\t * @type {ChannelSplitterNode}\n\t * @private\n\t */\n\tthis._splitter = this.input = this.context.createChannelSplitter(channels);\n\n\t//connections\n\tfor (var i = 0; i < channels; i++){\n\t\tthis.output[i] = new Tone.Gain();\n\t\tTone.connect(this._splitter, this.output[i], i, 0);\n\t\tthis.output[i].channelCount = 1;\n\t\tthis.output[i].channelCountMode = \"explicit\";\n\t}\n\n\t/**\n\t * Left channel output.\n\t * Alias for
output[0]\n\t * @type {Tone.Gain}\n\t */\n\tthis.left = this.output[0];\n\n\t/**\n\t * Right channel output.\n\t * Alias for output[1]\n\t * @type {Tone.Gain}\n\t */\n\tthis.right = this.output[1];\n};\n\nTone.extend(Tone.Split, Tone.AudioNode);\n\n/**\n * Clean up.\n * @returns {Tone.Split} this\n */\nTone.Split.prototype.dispose = function(){\n\tthis.output.forEach(function(output){\n\t\toutput.dispose();\n\t});\n\tTone.AudioNode.prototype.dispose.call(this);\n\tthis._splitter.disconnect();\n\tthis.left = null;\n\tthis.right = null;\n\tthis._splitter = null;\n\treturn this;\n};\n\nexport default Tone.Split;\n\n","import Tone from \"../core/Tone\";\nimport \"../core/Emitter\";\nimport \"../core/Timeline\";\nimport \"../shim/AudioContext\";\n\nvar AudioContextProperties = [\"baseLatency\", \"destination\", \"currentTime\", \"sampleRate\", \"listener\", \"state\"];\nvar AudioContextMethods = [\"suspend\", \"close\", \"resume\", \"getOutputTimestamp\", \"createMediaElementSource\", \"createMediaStreamSource\", \"createMediaStreamDestination\", \"createBuffer\", \"decodeAudioData\", \"createBufferSource\", \"createConstantSource\", \"createGain\", \"createDelay\", \"createBiquadFilter\", \"createIIRFilter\", \"createWaveShaper\", \"createPanner\", \"createConvolver\", \"createDynamicsCompressor\", \"createAnalyser\", \"createScriptProcessor\", \"createStereoPanner\", \"createOscillator\", \"createPeriodicWave\", \"createChannelSplitter\", \"createChannelMerger\", \"audioWorklet\"];\n\n/**\n * @class Wrapper around the native AudioContext.\n * @extends {Tone.Emitter}\n * @param {AudioContext=} context optionally pass in a context\n */\nTone.Context = function(){\n\n\tTone.Emitter.call(this);\n\n\tvar options = Tone.defaults(arguments, [\"context\"], Tone.Context);\n\n\tif (!options.context){\n\t\toptions.context = new Tone.global.AudioContext();\n\t\tif (!options.context){\n\t\t\tthrow new Error(\"could not create AudioContext. Possibly too many AudioContexts running already.\");\n\t\t}\n\t}\n\tthis._context = options.context;\n\t//make sure it's not an AudioContext wrapper\n\twhile (this._context.rawContext){\n\t\tthis._context = this._context.rawContext;\n\t}\n\n\t// extend all of the properties\n\tAudioContextProperties.forEach(function(prop){\n\t\tthis._defineProperty(this._context, prop);\n\t}.bind(this));\n\t// extend all of the methods\n\tAudioContextMethods.forEach(function(method){\n\t\tthis._defineMethod(this._context, method);\n\t}.bind(this));\n\n\t/**\n\t * The default latency hint\n\t * @type {String}\n\t * @private\n\t */\n\tthis._latencyHint = options.latencyHint;\n\n\t/**\n\t * An object containing all of the constants AudioBufferSourceNodes\n\t * @type {Object}\n\t * @private\n\t */\n\tthis._constants = {};\n\n\t///////////////////////////////////////////////////////////////////////\n\t// WORKER\n\t///////////////////////////////////////////////////////////////////////\n\n\t/**\n\t * The amount of time events are scheduled\n\t * into the future\n\t * @type {Number}\n\t */\n\tthis.lookAhead = options.lookAhead;\n\n\t/**\n\t * A reference to the actual computed update interval\n\t * @type {Number}\n\t * @private\n\t */\n\tthis._computedUpdateInterval = 0;\n\n\t/**\n\t * A reliable callback method\n\t * @private\n\t * @type {Ticker}\n\t */\n\tthis._ticker = new Ticker(this.emit.bind(this, \"tick\"), options.clockSource, options.updateInterval);\n\n\t///////////////////////////////////////////////////////////////////////\n\t// TIMEOUTS\n\t///////////////////////////////////////////////////////////////////////\n\n\t/**\n\t * All of the setTimeout events.\n\t * @type {Tone.Timeline}\n\t * @private\n\t */\n\tthis._timeouts = new Tone.Timeline();\n\n\t/**\n\t * The timeout id counter\n\t * @private\n\t * @type {Number}\n\t */\n\tthis._timeoutIds = 0;\n\n\tthis.on(\"tick\", this._timeoutLoop.bind(this));\n\n\t//forward state change events\n\tthis._context.onstatechange = function(e){\n\t\tthis.emit(\"statechange\", e);\n\t}.bind(this);\n};\n\nTone.extend(Tone.Context, Tone.Emitter);\nTone.Emitter.mixin(Tone.Context);\n\n/**\n * defaults\n * @static\n * @type {Object}\n */\nTone.Context.defaults = {\n\t\"clockSource\" : \"worker\",\n\t\"latencyHint\" : \"interactive\",\n\t\"lookAhead\" : 0.1,\n\t\"updateInterval\" : 0.03\n};\n\n/**\n * Is an instanceof Tone.Context\n * @type {Boolean}\n */\nTone.Context.prototype.isContext = true;\n\n/**\n * Define a property on this Tone.Context.\n * This is used to extend the native AudioContext\n * @param {AudioContext} context\n * @param {String} prop\n * @private\n */\nTone.Context.prototype._defineProperty = function(context, prop){\n\tif (Tone.isUndef(this[prop])){\n\t\tObject.defineProperty(this, prop, {\n\t\t\t\"get\" : function(){\n\t\t\t\treturn context[prop];\n\t\t\t},\n\t\t\t\"set\" : function(val){\n\t\t\t\tcontext[prop] = val;\n\t\t\t}\n\t\t});\n\t}\n};\n\n/**\n * Define a method on this Tone.Context.\n * This is used to extend the native AudioContext\n * @param {AudioContext} context\n * @param {String} prop\n * @private\n */\nTone.Context.prototype._defineMethod = function(context, prop){\n\tif (Tone.isUndef(this[prop])){\n\t\tObject.defineProperty(this, prop, {\n\t\t\t\"get\" : function(){\n\t\t\t\treturn context[prop].bind(context);\n\t\t\t}\n\t\t});\n\t}\n};\n\n/**\n * The current audio context time\n * @return {Number}\n */\nTone.Context.prototype.now = function(){\n\treturn this._context.currentTime + this.lookAhead;\n};\n\n/**\n * The audio output destination. Alias for Tone.Master\n * @readyOnly\n * @type {Tone.Master}\n */\nObject.defineProperty(Tone.Context.prototype, \"destination\", {\n\t\"get\" : function(){\n\t\tif (!this.master){\n\t\t\treturn this._context.destination;\n\t\t} else {\n\t\t\treturn this.master;\n\t\t}\n\t}\n});\n\n/**\n * Starts the audio context from a suspended state. This is required\n * to initially start the AudioContext.\n * @return {Promise}\n */\nTone.Context.prototype.resume = function(){\n\tif (this._context.state === \"suspended\" && this._context instanceof AudioContext){\n\t\treturn this._context.resume();\n\t} else {\n\t\treturn Promise.resolve();\n\t}\n};\n\n/**\n * Promise which is invoked when the context is running.\n * Tries to resume the context if it's not started.\n * @return {Promise}\n */\nTone.Context.prototype.close = function(){\n\tvar closePromise = Promise.resolve();\n\t//never close the global Tone.Context\n\tif (this !== Tone.global.TONE_AUDIO_CONTEXT){\n\t\tclosePromise = this.rawContext.close();\n\t}\n\treturn closePromise.then(function(){\n\t\tTone.Context.emit(\"close\", this);\n\t}.bind(this));\n};\n\n/**\n * Generate a looped buffer at some constant value.\n * @param {Number} val\n * @return {BufferSourceNode}\n */\nTone.Context.prototype.getConstant = function(val){\n\tif (this._constants[val]){\n\t\treturn this._constants[val];\n\t} else {\n\t\tvar buffer = this._context.createBuffer(1, 128, this._context.sampleRate);\n\t\tvar arr = buffer.getChannelData(0);\n\t\tfor (var i = 0; i < arr.length; i++){\n\t\t\tarr[i] = val;\n\t\t}\n\t\tvar constant = this._context.createBufferSource();\n\t\tconstant.channelCount = 1;\n\t\tconstant.channelCountMode = \"explicit\";\n\t\tconstant.buffer = buffer;\n\t\tconstant.loop = true;\n\t\tconstant.start(0);\n\t\tthis._constants[val] = constant;\n\t\treturn constant;\n\t}\n};\n\n/**\n * The private loop which keeps track of the context scheduled timeouts\n * Is invoked from the clock source\n * @private\n */\nTone.Context.prototype._timeoutLoop = function(){\n\tvar now = this.now();\n\twhile (this._timeouts && this._timeouts.length && this._timeouts.peek().time <= now){\n\t\tthis._timeouts.shift().callback();\n\t}\n};\n\n/**\n * A setTimeout which is gaurenteed by the clock source.\n * Also runs in the offline context.\n * @param {Function} fn The callback to invoke\n * @param {Seconds} timeout The timeout in seconds\n * @returns {Number} ID to use when invoking Tone.Context.clearTimeout\n */\nTone.Context.prototype.setTimeout = function(fn, timeout){\n\tthis._timeoutIds++;\n\tvar now = this.now();\n\tthis._timeouts.add({\n\t\t\"callback\" : fn,\n\t\t\"time\" : now + timeout,\n\t\t\"id\" : this._timeoutIds\n\t});\n\treturn this._timeoutIds;\n};\n\n/**\n * Clears a previously scheduled timeout with Tone.context.setTimeout\n * @param {Number} id The ID returned from setTimeout\n * @return {Tone.Context} this\n */\nTone.Context.prototype.clearTimeout = function(id){\n\tthis._timeouts.forEach(function(event){\n\t\tif (event.id === id){\n\t\t\tthis.remove(event);\n\t\t}\n\t});\n\treturn this;\n};\n\n/**\n * How often the Web Worker callback is invoked.\n * This number corresponds to how responsive the scheduling\n * can be. Context.updateInterval + Context.lookAhead gives you the\n * total latency between scheduling an event and hearing it.\n * @type {Number}\n * @memberOf Tone.Context#\n * @name updateInterval\n */\nObject.defineProperty(Tone.Context.prototype, \"updateInterval\", {\n\t\"get\" : function(){\n\t\treturn this._ticker.updateInterval;\n\t},\n\t\"set\" : function(interval){\n\t\tthis._ticker.updateInterval = interval;\n\t}\n});\n\n/**\n * The unwrapped AudioContext.\n * @type {AudioContext}\n * @memberOf Tone.Context#\n * @name rawContext\n * @readOnly\n */\nObject.defineProperty(Tone.Context.prototype, \"rawContext\", {\n\t\"get\" : function(){\n\t\treturn this._context;\n\t}\n});\n\n/**\n * What the source of the clock is, either \"worker\" (Web Worker [default]),\n * \"timeout\" (setTimeout), or \"offline\" (none).\n * @type {String}\n * @memberOf Tone.Context#\n * @name clockSource\n */\nObject.defineProperty(Tone.Context.prototype, \"clockSource\", {\n\t\"get\" : function(){\n\t\treturn this._ticker.type;\n\t},\n\t\"set\" : function(type){\n\t\tthis._ticker.type = type;\n\t}\n});\n\n/**\n * The type of playback, which affects tradeoffs between audio\n * output latency and responsiveness.\n *\n * In addition to setting the value in seconds, the latencyHint also\n * accepts the strings \"interactive\" (prioritizes low latency),\n * \"playback\" (prioritizes sustained playback), \"balanced\" (balances\n * latency and performance), and \"fastest\" (lowest latency, might glitch more often).\n * @type {String|Seconds}\n * @memberOf Tone.Context#\n * @name latencyHint\n * @example\n * //set the lookAhead to 0.3 seconds\n * Tone.context.latencyHint = 0.3;\n */\nObject.defineProperty(Tone.Context.prototype, \"latencyHint\", {\n\t\"get\" : function(){\n\t\treturn this._latencyHint;\n\t},\n\t\"set\" : function(hint){\n\t\tvar lookAhead = hint;\n\t\tthis._latencyHint = hint;\n\t\tif (Tone.isString(hint)){\n\t\t\tswitch (hint){\n\t\t\t\tcase \"interactive\" :\n\t\t\t\t\tlookAhead = 0.1;\n\t\t\t\t\tthis._context.latencyHint = hint;\n\t\t\t\t\tbreak;\n\t\t\t\tcase \"playback\" :\n\t\t\t\t\tlookAhead = 0.8;\n\t\t\t\t\tthis._context.latencyHint = hint;\n\t\t\t\t\tbreak;\n\t\t\t\tcase \"balanced\" :\n\t\t\t\t\tlookAhead = 0.25;\n\t\t\t\t\tthis._context.latencyHint = hint;\n\t\t\t\t\tbreak;\n\t\t\t\tcase \"fastest\" :\n\t\t\t\t\tthis._context.latencyHint = \"interactive\";\n\t\t\t\t\tlookAhead = 0.01;\n\t\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\t\tthis.lookAhead = lookAhead;\n\t\tthis.updateInterval = lookAhead/3;\n\t}\n});\n\n/**\n * Unlike other dispose methods, this returns a Promise\n * which executes when the context is closed and disposed\n * @returns {Promise} this\n */\nTone.Context.prototype.dispose = function(){\n\treturn this.close().then(function(){\n\t\tTone.Emitter.prototype.dispose.call(this);\n\t\tthis._ticker.dispose();\n\t\tthis._ticker = null;\n\t\tthis._timeouts.dispose();\n\t\tthis._timeouts = null;\n\t\tfor (var con in this._constants){\n\t\t\tthis._constants[con].disconnect();\n\t\t}\n\t\tthis._constants = null;\n\t}.bind(this));\n};\n\n/**\n * @class A class which provides a reliable callback using either\n * a Web Worker, or if that isn't supported, falls back to setTimeout.\n * @private\n */\nvar Ticker = function(callback, type, updateInterval){\n\n\t/**\n\t * Either \"worker\" or \"timeout\"\n\t * @type {String}\n\t * @private\n\t */\n\tthis._type = type;\n\n\t/**\n\t * The update interval of the worker\n\t * @private\n\t * @type {Number}\n\t */\n\tthis._updateInterval = updateInterval;\n\n\t/**\n\t * The callback to invoke at regular intervals\n\t * @type {Function}\n\t * @private\n\t */\n\tthis._callback = Tone.defaultArg(callback, Tone.noOp);\n\n\t//create the clock source for the first time\n\tthis._createClock();\n};\n\n/**\n * The possible ticker types\n * @private\n * @type {Object}\n */\nTicker.Type = {\n\t\"Worker\" : \"worker\",\n\t\"Timeout\" : \"timeout\",\n\t\"Offline\" : \"offline\"\n};\n\n/**\n * Generate a web worker\n * @return {WebWorker}\n * @private\n */\nTicker.prototype._createWorker = function(){\n\n\t//URL Shim\n\tTone.global.URL = Tone.global.URL || Tone.global.webkitURL;\n\n\tvar blob = new Blob([\n\t\t//the initial timeout time\n\t\t\"var timeoutTime = \"+(this._updateInterval * 1000).toFixed(1)+\";\" +\n\t\t//onmessage callback\n\t\t\"self.onmessage = function(msg){\" +\n\t\t\"\ttimeoutTime = parseInt(msg.data);\" +\n\t\t\"};\" +\n\t\t//the tick function which posts a message\n\t\t//and schedules a new tick\n\t\t\"function tick(){\" +\n\t\t\"\tsetTimeout(tick, timeoutTime);\" +\n\t\t\"\tself.postMessage('tick');\" +\n\t\t\"}\" +\n\t\t//call tick initially\n\t\t\"tick();\"\n\t]);\n\tvar blobUrl = URL.createObjectURL(blob);\n\tvar worker = new Worker(blobUrl);\n\n\tworker.onmessage = this._callback.bind(this);\n\n\tthis._worker = worker;\n};\n\n/**\n * Create a timeout loop\n * @private\n */\nTicker.prototype._createTimeout = function(){\n\tthis._timeout = setTimeout(function(){\n\t\tthis._createTimeout();\n\t\tthis._callback();\n\t}.bind(this), this._updateInterval * 1000);\n};\n\n/**\n * Create the clock source.\n * @private\n */\nTicker.prototype._createClock = function(){\n\tif (this._type === Ticker.Type.Worker){\n\t\ttry {\n\t\t\tthis._createWorker();\n\t\t} catch (e){\n\t\t\t// workers not supported, fallback to timeout\n\t\t\tthis._type = Ticker.Type.Timeout;\n\t\t\tthis._createClock();\n\t\t}\n\t} else if (this._type === Ticker.Type.Timeout){\n\t\tthis._createTimeout();\n\t}\n};\n\n/**\n * @memberOf Ticker#\n * @type {Number}\n * @name updateInterval\n * @private\n */\nObject.defineProperty(Ticker.prototype, \"updateInterval\", {\n\t\"get\" : function(){\n\t\treturn this._updateInterval;\n\t},\n\t\"set\" : function(interval){\n\t\tthis._updateInterval = Math.max(interval, 128/44100);\n\t\tif (this._type === Ticker.Type.Worker){\n\t\t\tthis._worker.postMessage(Math.max(interval * 1000, 1));\n\t\t}\n\t}\n});\n\n/**\n * The type of the ticker, either a worker or a timeout\n * @memberOf Ticker#\n * @type {Number}\n * @name type\n * @private\n */\nObject.defineProperty(Ticker.prototype, \"type\", {\n\t\"get\" : function(){\n\t\treturn this._type;\n\t},\n\t\"set\" : function(type){\n\t\tthis._disposeClock();\n\t\tthis._type = type;\n\t\tthis._createClock();\n\t}\n});\n\n/**\n * Clean up the current clock source\n * @private\n */\nTicker.prototype._disposeClock = function(){\n\tif (this._timeout){\n\t\tclearTimeout(this._timeout);\n\t\tthis._timeout = null;\n\t}\n\tif (this._worker){\n\t\tthis._worker.terminate();\n\t\tthis._worker.onmessage = null;\n\t\tthis._worker = null;\n\t}\n};\n\n/**\n * Clean up\n * @private\n */\nTicker.prototype.dispose = function(){\n\tthis._disposeClock();\n\tthis._callback = null;\n};\n\n// set the audio context initially, and if one is not already created\nif (Tone.supported && !Tone.initialized){\t\t\t\n\tif (!Tone.global.TONE_AUDIO_CONTEXT){\n\t\tTone.global.TONE_AUDIO_CONTEXT = new Tone.Context();\n\t}\n\tTone.context = Tone.global.TONE_AUDIO_CONTEXT;\n\n\t// log on first initialization\n\t// allow optional silencing of this log\n\tif (!Tone.global.TONE_SILENCE_LOGGING){\n\t\tvar prefix = \"v\";\n\t\tif (Tone.version === \"dev\"){\n\t\t\tprefix = \"\";\n\t\t}\n\t\tvar printString = \" * Tone.js \" + prefix + Tone.version + \" * \"; \n\t\t// eslint-disable-next-line no-console\n\t\tconsole.log(\"%c\" + printString, \"background: #000; color: #fff\");\n\t}\n} else if (!Tone.supported && !Tone.global.TONE_SILENCE_LOGGING){\n\t// eslint-disable-next-line no-console\n\tconsole.warn(\"This browser does not support Tone.js\");\n}\n\nexport default Tone.Context;\n\n","import Tone from \"../core/Tone\";\nimport \"../type/Type\";\nimport \"../core/Master\";\n\n/**\n * @class Base-class for all instruments\n *\n * @constructor\n * @extends {Tone.AudioNode}\n */\nTone.Instrument = function(options){\n\n\t//get the defaults\n\toptions = Tone.defaultArg(options, Tone.Instrument.defaults);\n\tTone.AudioNode.call(this);\n\n\t/**\n\t * The output and volume triming node\n\t * @type {Tone.Volume}\n\t * @private\n\t */\n\tthis._volume = this.output = new Tone.Volume(options.volume);\n\n\t/**\n\t * The volume of the output in decibels.\n\t * @type {Decibels}\n\t * @signal\n\t * @example\n\t * source.volume.value = -6;\n\t */\n\tthis.volume = this._volume.volume;\n\tthis._readOnly(\"volume\");\n\n\t/**\n\t * Keep track of all events scheduled to the transport\n\t * when the instrument is 'synced'\n\t * @type {Arrayinput[0].\n\t * @type {Tone.Gain}\n\t */\n\tthis.a = this.input[0] = new Tone.Gain();\n\n\t/**\n\t * Alias for input[1].\n\t * @type {Tone.Gain}\n\t */\n\tthis.b = this.input[1] = new Tone.Gain();\n\n\t/**\n\t * \tThe mix between the two inputs. A fade value of 0\n\t * \twill output 100% input[0] and\n\t * \ta value of 1 will output 100% input[1].\n\t * @type {NormalRange}\n\t * @signal\n\t */\n\tthis.fade = new Tone.Signal(Tone.defaultArg(initialFade, 0.5), Tone.Type.NormalRange);\n\n\t/**\n\t * equal power gain cross fade\n\t * @private\n\t * @type {Tone.EqualPowerGain}\n\t */\n\tthis._equalPowerA = new Tone.EqualPowerGain();\n\n\t/**\n\t * equal power gain cross fade\n\t * @private\n\t * @type {Tone.EqualPowerGain}\n\t */\n\tthis._equalPowerB = new Tone.EqualPowerGain();\n\n\t/**\n\t * invert the incoming signal\n\t * @private\n\t * @type {Tone}\n\t */\n\tthis._one = this.context.getConstant(1);\n\n\t/**\n\t * invert the incoming signal\n\t * @private\n\t * @type {Tone.Subtract}\n\t */\n\tthis._invert = new Tone.Subtract();\n\n\t//connections\n\tthis.a.connect(this.output);\n\tthis.b.connect(this.output);\n\tthis.fade.chain(this._equalPowerB, this.b.gain);\n\tTone.connect(this._one, this._invert, 0, 0);\n\tthis.fade.connect(this._invert, 0, 1);\n\tthis._invert.chain(this._equalPowerA, this.a.gain);\n\tthis._readOnly(\"fade\");\n};\n\nTone.extend(Tone.CrossFade, Tone.AudioNode);\n\n/**\n * clean up\n * @returns {Tone.CrossFade} this\n */\nTone.CrossFade.prototype.dispose = function(){\n\tTone.AudioNode.prototype.dispose.call(this);\n\tthis._writable(\"fade\");\n\tthis._equalPowerA.dispose();\n\tthis._equalPowerA = null;\n\tthis._equalPowerB.dispose();\n\tthis._equalPowerB = null;\n\tthis.fade.dispose();\n\tthis.fade = null;\n\tthis._invert.dispose();\n\tthis._invert = null;\n\tthis._one = null;\n\tthis.a.dispose();\n\tthis.a = null;\n\tthis.b.dispose();\n\tthis.b = null;\n\treturn this;\n};\n\nexport default Tone.CrossFade;\n\n","import Tone from \"../core/Tone\";\n\n/**\n * @class 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 * @extends {Tone}\n * @param {Positive} [memory=Infinity] The number of previous events that are retained.\n */\nTone.Timeline = function(){\n\n\tvar options = Tone.defaults(arguments, [\"memory\"], Tone.Timeline);\n\tTone.call(this);\n\n\t/**\n\t * The array of scheduled timeline events\n\t * @type {Array}\n\t * @private\n\t */\n\tthis._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 * @type {Positive}\n\t */\n\tthis.memory = options.memory;\n};\n\nTone.extend(Tone.Timeline);\n\n/**\n * the default parameters\n * @static\n * @const\n */\nTone.Timeline.defaults = {\n\t\"memory\" : Infinity\n};\n\n/**\n * The number of items in the timeline.\n * @type {Number}\n * @memberOf Tone.Timeline#\n * @name length\n * @readOnly\n */\nObject.defineProperty(Tone.Timeline.prototype, \"length\", {\n\tget : function(){\n\t\treturn this._timeline.length;\n\t}\n});\n\n/**\n * Insert an event object onto the timeline. Events must have a \"time\" attribute.\n * @param {Object} event The event object to insert into the\n * timeline.\n * @returns {Tone.Timeline} this\n */\nTone.Timeline.prototype.add = function(event){\n\t//the event needs to have a time attribute\n\tif (Tone.isUndef(event.time)){\n\t\tthrow new Error(\"Tone.Timeline: events must have a time attribute\");\n\t}\n\tevent.time = event.time.valueOf();\n\tvar index = this._search(event.time);\n\tthis._timeline.splice(index + 1, 0, event);\n\t//if the length is more than the memory, remove the previous ones\n\tif (this.length > this.memory){\n\t\tvar diff = this.length - this.memory;\n\t\tthis._timeline.splice(0, diff);\n\t}\n\treturn this;\n};\n\n/**\n * Remove an event from the timeline.\n * @param {Object} event The event object to remove from the list.\n * @returns {Tone.Timeline} this\n */\nTone.Timeline.prototype.remove = function(event){\n\tvar index = this._timeline.indexOf(event);\n\tif (index !== -1){\n\t\tthis._timeline.splice(index, 1);\n\t}\n\treturn this;\n};\n\n/**\n * Get the nearest event whose time is less than or equal to the given time.\n * @param {Number} time The time to query.\n * @param {String} comparator Which value in the object to compare\n * @returns {Object} The event object set after that time.\n */\nTone.Timeline.prototype.get = function(time, comparator){\n\tcomparator = Tone.defaultArg(comparator, \"time\");\n\tvar index = this._search(time, comparator);\n\tif (index !== -1){\n\t\treturn this._timeline[index];\n\t} else {\n\t\treturn null;\n\t}\n};\n\n/**\n * Return the first event in the timeline without removing it\n * @returns {Object} The first event object\n */\nTone.Timeline.prototype.peek = function(){\n\treturn this._timeline[0];\n};\n\n/**\n * Return the first event in the timeline and remove it\n * @returns {Object} The first event object\n */\nTone.Timeline.prototype.shift = function(){\n\treturn this._timeline.shift();\n};\n\n/**\n * Get the event which is scheduled after the given time.\n * @param {Number} time The time to query.\n * @param {String} comparator Which value in the object to compare\n * @returns {Object} The event object after the given time\n */\nTone.Timeline.prototype.getAfter = function(time, comparator){\n\tcomparator = Tone.defaultArg(comparator, \"time\");\n\tvar index = this._search(time, comparator);\n\tif (index + 1 < this._timeline.length){\n\t\treturn this._timeline[index + 1];\n\t} else {\n\t\treturn null;\n\t}\n};\n\n/**\n * Get the event before the event at the given time.\n * @param {Number} time The time to query.\n * @param {String} comparator Which value in the object to compare\n * @returns {Object} The event object before the given time\n */\nTone.Timeline.prototype.getBefore = function(time, comparator){\n\tcomparator = Tone.defaultArg(comparator, \"time\");\n\tvar len = this._timeline.length;\n\t//if it's after the last item, return the last item\n\tif (len > 0 && this._timeline[len - 1][comparator] < time){\n\t\treturn this._timeline[len - 1];\n\t}\n\tvar index = this._search(time, comparator);\n\tif (index - 1 >= 0){\n\t\treturn this._timeline[index - 1];\n\t} else {\n\t\treturn null;\n\t}\n};\n\n/**\n * Cancel events after the given time\n * @param {Number} time The time to query.\n * @returns {Tone.Timeline} this\n */\nTone.Timeline.prototype.cancel = function(after){\n\tif (this._timeline.length > 1){\n\t\tvar index = this._search(after);\n\t\tif (index >= 0){\n\t\t\tif (this._timeline[index].time === after){\n\t\t\t\t//get the first item with that time\n\t\t\t\tfor (var i = index; i >= 0; i--){\n\t\t\t\t\tif (this._timeline[i].time === after){\n\t\t\t\t\t\tindex = 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\tthis._timeline = this._timeline.slice(0, index);\n\t\t\t} else {\n\t\t\t\tthis._timeline = this._timeline.slice(0, index + 1);\n\t\t\t}\n\t\t} else {\n\t\t\tthis._timeline = [];\n\t\t}\n\t} else if (this._timeline.length === 1){\n\t\t//the first item's time\n\t\tif (this._timeline[0].time >= after){\n\t\t\tthis._timeline = [];\n\t\t}\n\t}\n\treturn this;\n};\n\n/**\n * Cancel events before or equal to the given time.\n * @param {Number} time The time to cancel before.\n * @returns {Tone.Timeline} this\n */\nTone.Timeline.prototype.cancelBefore = function(time){\n\tvar index = this._search(time);\n\tif (index >= 0){\n\t\tthis._timeline = this._timeline.slice(index + 1);\n\t}\n\treturn this;\n};\n\n/**\n * Returns the previous event if there is one. null otherwise\n * @param {Object} event The event to find the previous one of\n * @return {Object} The event right before the given event\n */\nTone.Timeline.prototype.previousEvent = function(event){\n\tvar index = this._timeline.indexOf(event);\n\tif (index > 0){\n\t\treturn this._timeline[index-1];\n\t} else {\n\t\treturn null;\n\t}\n};\n\n/**\n * Does a binary search on the timeline array and returns the\n * nearest event index whose time is after or equal to the given time.\n * If a time is searched before the first index in the timeline, -1 is returned.\n * If the time is after the end, the index of the last item is returned.\n * @param {Number} time\n * @param {String} comparator Which value in the object to compare\n * @return {Number} the index in the timeline array\n * @private\n */\nTone.Timeline.prototype._search = function(time, comparator){\n\tif (this._timeline.length === 0){\n\t\treturn -1;\n\t}\n\tcomparator = Tone.defaultArg(comparator, \"time\");\n\tvar beginning = 0;\n\tvar len = this._timeline.length;\n\tvar end = len;\n\tif (len > 0 && this._timeline[len - 1][comparator] <= time){\n\t\treturn len - 1;\n\t}\n\twhile (beginning < end){\n\t\t// calculate the midpoint for roughly equal partition\n\t\tvar midPoint = Math.floor(beginning + (end - beginning) / 2);\n\t\tvar event = this._timeline[midPoint];\n\t\tvar nextEvent = this._timeline[midPoint + 1];\n\t\tif (event[comparator] === time){\n\t\t\t//choose the last one that has the same time\n\t\t\tfor (var i = midPoint; i < this._timeline.length; i++){\n\t\t\t\tvar testEvent = this._timeline[i];\n\t\t\t\tif (testEvent[comparator] === time){\n\t\t\t\t\tmidPoint = i;\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn midPoint;\n\t\t} else if (event[comparator] < time && nextEvent[comparator] > time){\n\t\t\treturn midPoint;\n\t\t} else if (event[comparator] > time){\n\t\t\t//search lower\n\t\t\tend = midPoint;\n\t\t} else {\n\t\t\t//search upper\n\t\t\tbeginning = midPoint + 1;\n\t\t}\n\t}\n\treturn -1;\n};\n\n/**\n * Internal iterator. Applies extra safety checks for\n * removing items from the array.\n * @param {Function} callback\n * @param {Number=} lowerBound\n * @param {Number=} upperBound\n * @private\n */\nTone.Timeline.prototype._iterate = function(callback, lowerBound, upperBound){\n\tlowerBound = Tone.defaultArg(lowerBound, 0);\n\tupperBound = Tone.defaultArg(upperBound, this._timeline.length-1);\n\tthis._timeline.slice(lowerBound, upperBound+1).forEach(function(event){\n\t\tcallback.call(this, event);\n\t}.bind(this));\n};\n\n/**\n * Iterate over everything in the array\n * @param {Function} callback The callback to invoke with every item\n * @returns {Tone.Timeline} this\n */\nTone.Timeline.prototype.forEach = function(callback){\n\tthis._iterate(callback);\n\treturn this;\n};\n\n/**\n * Iterate over everything in the array at or before the given time.\n * @param {Number} time The time to check if items are before\n * @param {Function} callback The callback to invoke with every item\n * @returns {Tone.Timeline} this\n */\nTone.Timeline.prototype.forEachBefore = function(time, callback){\n\t//iterate over the items in reverse so that removing an item doesn't break things\n\tvar upperBound = this._search(time);\n\tif (upperBound !== -1){\n\t\tthis._iterate(callback, 0, upperBound);\n\t}\n\treturn this;\n};\n\n/**\n * Iterate over everything in the array after the given time.\n * @param {Number} time The time to check if items are before\n * @param {Function} callback The callback to invoke with every item\n * @returns {Tone.Timeline} this\n */\nTone.Timeline.prototype.forEachAfter = function(time, callback){\n\t//iterate over the items in reverse so that removing an item doesn't break things\n\tvar lowerBound = this._search(time);\n\tthis._iterate(callback, lowerBound + 1);\n\treturn this;\n};\n\n/**\n * Iterate over everything in the array between the startTime and endTime. \n * The timerange is inclusive of the startTime, but exclusive of the endTime. \n * range = [startTime, endTime). \n * @param {Number} startTime The time to check if items are before\n * @param {Number} endTime The end of the test interval. \n * @param {Function} callback The callback to invoke with every item\n * @returns {Tone.Timeline} this\n */\nTone.Timeline.prototype.forEachBetween = function(startTime, endTime, callback){\n\tvar lowerBound = this._search(startTime);\n\tvar upperBound = this._search(endTime);\n\tif (lowerBound !== -1 && upperBound !== -1){\n\t\tif (this._timeline[lowerBound].time !== startTime){\n\t\t\tlowerBound += 1;\n\t\t}\n\t\t//exclusive of the end time\n\t\tif (this._timeline[upperBound].time === endTime){\n\t\t\tupperBound -= 1;\n\t\t}\n\t\tthis._iterate(callback, lowerBound, upperBound);\n\t} else if (lowerBound === -1){\n\t\tthis._iterate(callback, 0, upperBound);\n\t}\n\treturn this;\n};\n\n/**\n * Iterate over everything in the array at or after the given time. Similar to\n * forEachAfter, but includes the item(s) at the given time.\n * @param {Number} time The time to check if items are before\n * @param {Function} callback The callback to invoke with every item\n * @returns {Tone.Timeline} this\n */\nTone.Timeline.prototype.forEachFrom = function(time, callback){\n\t//iterate over the items in reverse so that removing an item doesn't break things\n\tvar lowerBound = this._search(time);\n\t//work backwards until the event time is less than time\n\twhile (lowerBound >= 0 && this._timeline[lowerBound].time >= time){\n\t\tlowerBound--;\n\t}\n\tthis._iterate(callback, lowerBound + 1);\n\treturn this;\n};\n\n/**\n * Iterate over everything in the array at the given time\n * @param {Number} time The time to check if items are before\n * @param {Function} callback The callback to invoke with every item\n * @returns {Tone.Timeline} this\n */\nTone.Timeline.prototype.forEachAtTime = function(time, callback){\n\t//iterate over the items in reverse so that removing an item doesn't break things\n\tvar upperBound = this._search(time);\n\tif (upperBound !== -1){\n\t\tthis._iterate(function(event){\n\t\t\tif (event.time === time){\n\t\t\t\tcallback.call(this, event);\n\t\t\t}\n\t\t}, 0, upperBound);\n\t}\n\treturn this;\n};\n\n/**\n * Clean up.\n * @return {Tone.Timeline} this\n */\nTone.Timeline.prototype.dispose = function(){\n\tTone.prototype.dispose.call(this);\n\tthis._timeline = null;\n\treturn this;\n};\n\nexport default Tone.Timeline;\n\n","import Tone from \"../core/Tone\";\nimport \"../instrument/Instrument\";\nimport \"../signal/Signal\";\n\n/**\n * @class This is an abstract base class for other monophonic instruments to \n * extend. IMPORTANT: It does not make any sound on its own and\n * shouldn't be directly instantiated.\n *\n * @constructor\n * @abstract\n * @extends {Tone.Instrument}\n */\nTone.Monophonic = function(options){\n\n\t//get the defaults\n\toptions = Tone.defaultArg(options, Tone.Monophonic.defaults);\n\tTone.Instrument.call(this, options);\n\n\t/**\n\t * The glide time between notes. \n\t * @type {Time}\n\t */\n\tthis.portamento = options.portamento;\n};\n\nTone.extend(Tone.Monophonic, Tone.Instrument);\n\n/**\n * @static\n * @const\n * @type {Object}\n */\nTone.Monophonic.defaults = {\n\t\"portamento\" : 0\n};\n\n/**\n * Trigger the attack of the note optionally with a given velocity. \n * \n * \n * @param {Frequency} note The note to trigger.\n * @param {Time} [time=now] When the note should start.\n * @param {number} [velocity=1] velocity The velocity scaler \n * determines how \"loud\" the note \n * will be triggered.\n * @returns {Tone.Monophonic} this\n * @example\n * synth.triggerAttack(\"C4\");\n * @example\n * //trigger the note a half second from now at half velocity\n * synth.triggerAttack(\"C4\", \"+0.5\", 0.5);\n */\nTone.Monophonic.prototype.triggerAttack = function(note, time, velocity){\n\tthis.log(\"triggerAttack\", note, time, velocity);\n\ttime = this.toSeconds(time);\n\tthis._triggerEnvelopeAttack(time, velocity);\n\tthis.setNote(note, time);\n\treturn this;\n};\n\n/**\n * Trigger the release portion of the envelope\n * @param {Time} [time=now] If no time is given, the release happens immediatly\n * @returns {Tone.Monophonic} this\n * @example\n * synth.triggerRelease();\n */\nTone.Monophonic.prototype.triggerRelease = function(time){\n\tthis.log(\"triggerRelease\", time);\n\ttime = this.toSeconds(time);\n\tthis._triggerEnvelopeRelease(time);\n\treturn this;\n};\n\n/**\n * override this method with the actual method\n * @abstract\n * @private\n */\t\nTone.Monophonic.prototype._triggerEnvelopeAttack = function(){};\n\n/**\n * override this method with the actual method\n * @abstract\n * @private\n */\t\nTone.Monophonic.prototype._triggerEnvelopeRelease = function(){};\n\n/**\n * Get the level of the output at the given time. Measures\n * the envelope(s) value at the time. \n * @param {Time} time The time to query the envelope value\n * @return {NormalRange} The output level between 0-1\n */\nTone.Monophonic.prototype.getLevelAtTime = function(time){\n\ttime = this.toSeconds(time);\n\treturn this.envelope.getValueAtTime(time);\n};\n\n/**\n * Set the note at the given time. If no time is given, the note\n * will set immediately. \n * @param {Frequency} note The note to change to.\n * @param {Time} [time=now] The time when the note should be set. \n * @returns {Tone.Monophonic} this\n * @example\n * //change to F#6 in one quarter note from now.\n * synth.setNote(\"F#6\", \"+4n\");\n * @example\n * //change to Bb4 right now\n * synth.setNote(\"Bb4\");\n */\nTone.Monophonic.prototype.setNote = function(note, time){\n\ttime = this.toSeconds(time);\n\tif (this.portamento > 0 && this.getLevelAtTime(time) > 0.05){\n\t\tvar portTime = this.toSeconds(this.portamento);\n\t\tthis.frequency.exponentialRampTo(note, portTime, time);\n\t} else {\n\t\tthis.frequency.setValueAtTime(note, time);\n\t}\n\treturn this;\n};\n\nexport default Tone.Monophonic;\n\n","import Tone from \"../core/Tone\";\nimport \"../signal/Add\";\nimport \"../signal/Multiply\";\nimport \"../signal/Signal\";\n\n/**\n * @class Performs a linear scaling on an input signal.\n * Scales a NormalRange input to between\n * outputMin and outputMax.\n *\n * @constructor\n * @extends {Tone.SignalBase}\n * @param {number} [outputMin=0] The output value when the input is 0. \n * @param {number} [outputMax=1]\tThe output value when the input is 1. \n * @example\n * var scale = new Tone.Scale(50, 100);\n * var signal = new Tone.Signal(0.5).connect(scale);\n * //the output of scale equals 75\n */\nTone.Scale = function(outputMin, outputMax){\n\n\tTone.SignalBase.call(this);\n\t\n\t/** \n\t * @private\n\t * @type {number}\n\t */\n\tthis._outputMin = Tone.defaultArg(outputMin, 0);\n\n\t/** \n\t * @private\n\t * @type {number}\n\t */\n\tthis._outputMax = Tone.defaultArg(outputMax, 1);\n\n\t/** \n\t * @private\n\t * @type {Tone.Multiply}\n\t * @private\n\t */\n\tthis._scale = this.input = new Tone.Multiply(1);\n\t\n\t/** \n\t * @private\n\t * @type {Tone.Add}\n\t * @private\n\t */\n\tthis._add = this.output = new Tone.Add(0);\n\n\tthis._scale.connect(this._add);\n\tthis._setRange();\n};\n\nTone.extend(Tone.Scale, Tone.SignalBase);\n\n/**\n * The minimum output value. This number is output when \n * the value input value is 0. \n * @memberOf Tone.Scale#\n * @type {number}\n * @name min\n */\nObject.defineProperty(Tone.Scale.prototype, \"min\", {\n\tget : function(){\n\t\treturn this._outputMin;\n\t},\n\tset : function(min){\n\t\tthis._outputMin = min;\n\t\tthis._setRange();\n\t}\n});\n\n/**\n * The maximum output value. This number is output when \n * the value input value is 1. \n * @memberOf Tone.Scale#\n * @type {number}\n * @name max\n */\nObject.defineProperty(Tone.Scale.prototype, \"max\", {\n\tget : function(){\n\t\treturn this._outputMax;\n\t},\n\tset : function(max){\n\t\tthis._outputMax = max;\n\t\tthis._setRange();\n\t}\n});\n\n/**\n * set the values\n * @private\n */\nTone.Scale.prototype._setRange = function(){\n\tthis._add.value = this._outputMin;\n\tthis._scale.value = this._outputMax - this._outputMin;\n};\n\n/**\n * Clean up.\n * @returns {Tone.Scale} this\n */\nTone.Scale.prototype.dispose = function(){\n\tTone.SignalBase.prototype.dispose.call(this);\n\tthis._add.dispose();\n\tthis._add = null;\n\tthis._scale.dispose();\n\tthis._scale = null;\n\treturn this;\n}; \n\nexport default Tone.Scale;\n\n","import Tone from \"../core/Tone\";\nimport \"../signal/Signal\";\nimport \"../core/Gain\";\nimport \"../core/AudioNode\";\n\n/**\n * @class Tone.Volume is a simple volume node, useful for creating a volume fader.\n *\n * @extends {Tone.AudioNode}\n * @constructor\n * @param {Decibels} [volume=0] the initial volume\n * @example\n * var vol = new Tone.Volume(-12);\n * instrument.chain(vol, Tone.Master);\n */\nTone.Volume = function(){\n\n\tvar options = Tone.defaults(arguments, [\"volume\"], Tone.Volume);\n\tTone.AudioNode.call(this, options);\n\n\t/**\n\t * the output node\n\t * @type {GainNode}\n\t * @private\n\t */\n\tthis.output = this.input = new Tone.Gain(options.volume, Tone.Type.Decibels);\n\n\t/**\n\t * The unmuted volume\n\t * @type {Decibels}\n\t * @private\n\t */\n\tthis._unmutedVolume = options.volume;\n\n\t/**\n\t * The volume control in decibels.\n\t * @type {Decibels}\n\t * @signal\n\t */\n\tthis.volume = this.output.gain;\n\n\tthis._readOnly(\"volume\");\n\n\t//set the mute initially\n\tthis.mute = options.mute;\n};\n\nTone.extend(Tone.Volume, Tone.AudioNode);\n\n/**\n * Defaults\n * @type {Object}\n * @const\n * @static\n */\nTone.Volume.defaults = {\n\t\"volume\" : 0,\n\t\"mute\" : false\n};\n\n/**\n * Mute the output.\n * @memberOf Tone.Volume#\n * @type {boolean}\n * @name mute\n * @example\n * //mute the output\n * volume.mute = true;\n */\nObject.defineProperty(Tone.Volume.prototype, \"mute\", {\n\tget : function(){\n\t\treturn this.volume.value === -Infinity;\n\t},\n\tset : function(mute){\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\n/**\n * clean up\n * @returns {Tone.Volume} this\n */\nTone.Volume.prototype.dispose = function(){\n\tthis.input.dispose();\n\tTone.AudioNode.prototype.dispose.call(this);\n\tthis._writable(\"volume\");\n\tthis.volume.dispose();\n\tthis.volume = null;\n\treturn this;\n};\n\nexport default Tone.Volume;\n\n","import Tone from \"../core/Tone\";\nimport \"../core/Gain\";\nimport \"../signal/SignalBase\";\n\n/**\n * @class 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 * @extends {Tone.SignalBase}\n */\nTone.Zero = function(){\n\n\tTone.SignalBase.call(this);\n\n\t/**\n\t * The gain node\n\t * @type {Tone.Gain}\n\t * @private\n\t */\n\tthis._gain = this.input = this.output = new Tone.Gain();\n\n\tTone.connect(this.context.getConstant(0), this._gain);\n};\n\nTone.extend(Tone.Zero, Tone.SignalBase);\n\n/**\n * clean up\n * @return {Tone.Zero} this\n */\nTone.Zero.prototype.dispose = function(){\n\tTone.SignalBase.prototype.dispose.call(this);\n\tthis._gain.dispose();\n\tthis._gain = null;\n\treturn this;\n};\n\nexport default Tone.Zero;\n\n","import Tone from \"../core/Tone\";\nimport \"../signal/Signal\";\nimport \"../core/Gain\";\n\n/**\n * @class Add a signal and a number or two signals. When no value is\n * passed into the constructor, Tone.Add will sum input[0]\n * and input[1]. If a value is passed into the constructor, \n * the it will be added to the input.\n * \n * @constructor\n * @extends {Tone.Signal}\n * @param {number=} value If no value is provided, Tone.Add will sum the first\n * and second inputs. \n * @example\n * var signal = new Tone.Signal(2);\n * var add = new Tone.Add(2);\n * signal.connect(add);\n * //the output of add equals 4\n * @example\n * //if constructed with no arguments\n * //it will add the first and second inputs\n * var add = new Tone.Add();\n * var sig0 = new Tone.Signal(3).connect(add, 0, 0);\n * var sig1 = new Tone.Signal(4).connect(add, 0, 1);\n * //the output of add equals 7. \n */\nTone.Add = function(value){\n\n\tTone.Signal.call(this);\n\tthis.createInsOuts(2, 0);\n\n\t/**\n\t * the summing node\n\t * @type {GainNode}\n\t * @private\n\t */\n\tthis._sum = this.input[0] = this.input[1] = this.output = new Tone.Gain();\n\n\t/**\n\t * @private\n\t * @type {Tone.Signal}\n\t */\n\tthis._param = this.input[1] = new Tone.Signal(value);\n\n\tthis._param.connect(this._sum);\n};\n\nTone.extend(Tone.Add, Tone.Signal);\n\n/**\n * Clean up.\n * @returns {Tone.Add} this\n */\nTone.Add.prototype.dispose = function(){\n\tTone.Signal.prototype.dispose.call(this);\n\tthis._sum.dispose();\n\tthis._sum = null;\n\treturn this;\n}; \n\nexport default Tone.Add;\n\n","import Tone from \"../core/Tone\";\nimport \"../core/AudioNode\";\n\n/**\n * @class Base class for all Signals. Used Internally.\n *\n * @constructor\n * @extends {Tone}\n */\nTone.SignalBase = function(){\n\tTone.AudioNode.call(this);\n};\n\nTone.extend(Tone.SignalBase, Tone.AudioNode);\n\n/**\n * When signals connect to other signals or AudioParams,\n * they take over the output value of that signal or AudioParam.\n * For all other nodes, the behavior is the same as a default connect.\n *\n * @override\n * @param {AudioParam|AudioNode|Tone.Signal|Tone} node\n * @param {number} [outputNumber=0] The output number to connect from.\n * @param {number} [inputNumber=0] The input number to connect to.\n * @returns {Tone.SignalBase} this\n */\nTone.SignalBase.prototype.connect = function(node, outputNumber, inputNumber){\n\t//zero it out so that the signal can have full control\n\tif ((Tone.Signal && Tone.Signal === node.constructor) ||\n\t\t\t(Tone.Param && Tone.Param === node.constructor)){\n\t\t//cancel changes\n\t\tnode._param.cancelScheduledValues(0);\n\t\t//reset the value\n\t\tnode._param.setValueAtTime(0, 0);\n\t\t//mark the value as overridden\n\t\tnode.overridden = true;\n\t} else if (node instanceof AudioParam){\n\t\tnode.cancelScheduledValues(0);\n\t\tnode.setValueAtTime(0, 0);\n\t}\n\tTone.AudioNode.prototype.connect.call(this, node, outputNumber, inputNumber);\n\treturn this;\n};\n\nexport default Tone.SignalBase;\n\n","import Tone from \"../core/Tone\";\nimport \"../component/Envelope\";\nimport \"../core/Gain\";\n\n/**\n * @class Tone.AmplitudeEnvelope is a Tone.Envelope connected to a gain node.\n * Unlike Tone.Envelope, which outputs the envelope's value, Tone.AmplitudeEnvelope accepts\n * an audio signal as the input and will apply the envelope to the amplitude\n * of the signal. Read more about ADSR Envelopes on [Wikipedia](https://en.wikipedia.org/wiki/Synthesizer#ADSR_envelope).\n *\n * @constructor\n * @extends {Tone.Envelope}\n * @param {Time|Object} [attack] The amount of time it takes for the envelope to go from\n * 0 to it's maximum value.\n * @param {Time} [decay]\tThe period of time after the attack that it takes for the envelope\n * \tto fall to the sustain value.\n * @param {NormalRange} [sustain]\tThe percent of the maximum value that the envelope rests at until\n * \tthe release is triggered.\n * @param {Time} [release]\tThe amount of time after the release is triggered it takes to reach 0.\n * @example\n * var ampEnv = new Tone.AmplitudeEnvelope({\n * \t\"attack\": 0.1,\n * \t\"decay\": 0.2,\n * \t\"sustain\": 1.0,\n * \t\"release\": 0.8\n * }).toMaster();\n * //create an oscillator and connect it\n * var osc = new Tone.Oscillator().connect(ampEnv).start();\n * //trigger the envelopes attack and release \"8t\" apart\n * ampEnv.triggerAttackRelease(\"8t\");\n */\nTone.AmplitudeEnvelope = function(){\n\n\tTone.Envelope.apply(this, arguments);\n\n\t/**\n\t * the input node\n\t * @type {GainNode}\n\t * @private\n\t */\n\tthis.input = this.output = new Tone.Gain();\n\n\tthis._sig.connect(this.output.gain);\n};\n\nTone.extend(Tone.AmplitudeEnvelope, Tone.Envelope);\n\n/**\n * Clean up\n * @return {Tone.AmplitudeEnvelope} this\n */\nTone.AmplitudeEnvelope.prototype.dispose = function(){\n\tTone.Envelope.prototype.dispose.call(this);\n\treturn this;\n};\n\nexport default Tone.AmplitudeEnvelope;\n\n","import Tone from \"../core/Tone\";\nimport \"../core/Buffer\";\nimport \"../source/Source\";\nimport \"../core/Gain\";\nimport \"../core/AudioNode\";\n\n/**\n * @class Wrapper around the native BufferSourceNode.\n * @extends {Tone.AudioNode}\n * @param {AudioBuffer|Tone.Buffer} buffer The buffer to play\n * @param {Function} onload The callback to invoke when the\n * buffer is done playing.\n */\nTone.BufferSource = function(){\n\n\tvar options = Tone.defaults(arguments, [\"buffer\", \"onload\"], Tone.BufferSource);\n\tTone.AudioNode.call(this, options);\n\n\t/**\n\t * The callback to invoke after the\n\t * buffer source is done playing.\n\t * @type {Function}\n\t */\n\tthis.onended = options.onended;\n\n\t/**\n\t * The time that the buffer was started.\n\t * @type {Number}\n\t * @private\n\t */\n\tthis._startTime = -1;\n\n\t/**\n\t * An additional flag if the actual BufferSourceNode\n\t * has been started. b/c stopping an unstarted buffer\n\t * will throw it into an invalid state\n\t * @type {Boolean}\n\t * @private\n\t */\n\tthis._sourceStarted = false;\n\n\t/**\n\t * Flag if the source has already been stopped\n\t * @type {Boolean}\n\t * @private\n\t */\n\tthis._sourceStopped = false;\n\n\t/**\n\t * The time that the buffer is scheduled to stop.\n\t * @type {Number}\n\t * @private\n\t */\n\tthis._stopTime = -1;\n\n\t/**\n\t * The gain node which envelopes the BufferSource\n\t * @type {Tone.Gain}\n\t * @private\n\t */\n\tthis._gainNode = this.output = new Tone.Gain(0);\n\n\t/**\n\t * The buffer source\n\t * @type {AudioBufferSourceNode}\n\t * @private\n\t */\n\tthis._source = this.context.createBufferSource();\n\tTone.connect(this._source, this._gainNode);\n\tthis._source.onended = this._onended.bind(this);\n\n\t/**\n\t * The private buffer instance\n\t * @type {Tone.Buffer}\n\t * @private\n\t */\n\tthis._buffer = new Tone.Buffer(options.buffer, options.onload);\n\n\t/**\n\t * The playbackRate of the buffer\n\t * @type {Positive}\n\t * @signal\n\t */\n\tthis.playbackRate = new Tone.Param({\n\t\tparam : this._source.playbackRate,\n\t\tunits : Tone.Type.Positive,\n\t\tvalue : options.playbackRate\n\t});\n\n\t/**\n\t * The fadeIn time of the amplitude envelope.\n\t * @type {Time}\n\t */\n\tthis.fadeIn = options.fadeIn;\n\n\t/**\n\t * The fadeOut time of the amplitude envelope.\n\t * @type {Time}\n\t */\n\tthis.fadeOut = options.fadeOut;\n\n\t/**\n\t * The curve applied to the fades, either \"linear\" or \"exponential\"\n\t * @type {String}\n\t */\n\tthis.curve = options.curve;\n\n\t/**\n\t * The onended timeout\n\t * @type {Number}\n\t * @private\n\t */\n\tthis._onendedTimeout = -1;\n\n\t//set some values initially\n\tthis.loop = options.loop;\n\tthis.loopStart = options.loopStart;\n\tthis.loopEnd = options.loopEnd;\n};\n\nTone.extend(Tone.BufferSource, Tone.AudioNode);\n\n/**\n * The defaults\n * @const\n * @type {Object}\n */\nTone.BufferSource.defaults = {\n\t\"onended\" : Tone.noOp,\n\t\"onload\" : Tone.noOp,\n\t\"loop\" : false,\n\t\"loopStart\" : 0,\n\t\"loopEnd\" : 0,\n\t\"fadeIn\" : 0,\n\t\"fadeOut\" : 0,\n\t\"curve\" : \"linear\",\n\t\"playbackRate\" : 1\n};\n\n/**\n * Returns the playback state of the source, either \"started\" or \"stopped\".\n * @type {Tone.State}\n * @readOnly\n * @memberOf Tone.BufferSource#\n * @name state\n */\nObject.defineProperty(Tone.BufferSource.prototype, \"state\", {\n\tget : function(){\n\t\treturn this.getStateAtTime(this.now());\n\t}\n});\n\n/**\n * Get the playback state at the given time\n * @param {Time} time The time to test the state at\n * @return {Tone.State} The playback state. \n */\nTone.BufferSource.prototype.getStateAtTime = function(time){\n\ttime = this.toSeconds(time);\n\tif (this._startTime !== -1 && \n\t\tthis._startTime <= time && \n\t\t(this._stopTime === -1 || time < this._stopTime) && \n\t\t!this._sourceStopped){\n\t\treturn Tone.State.Started;\n\t} else {\n\t\treturn Tone.State.Stopped;\n\t}\n};\n\n/**\n * Start the buffer\n * @param {Time} [startTime=now] When the player should start.\n * @param {Time} [offset=0] The offset from the beginning of the sample\n * to start at.\n * @param {Time=} duration How long the sample should play. If no duration\n * is given, it will default to the full length\n * of the sample (minus any offset)\n * @param {Gain} [gain=1] The gain to play the buffer back at.\n * @return {Tone.BufferSource} this\n */\nTone.BufferSource.prototype.start = function(time, offset, duration, gain){\n\tthis.log(\"start\", time, offset, duration, gain);\n\tthis.assert(this._startTime === -1, \"can only be started once\");\n\tthis.assert(this.buffer.loaded, \"buffer is either not set or not loaded\");\n\tthis.assert(!this._sourceStopped, \"source is already stopped\");\n\n\ttime = this.toSeconds(time);\n\t//if it's a loop the default offset is the loopstart point\n\tif (this.loop){\n\t\toffset = Tone.defaultArg(offset, this.loopStart);\n\t} else {\n\t\t//otherwise the default offset is 0\n\t\toffset = Tone.defaultArg(offset, 0);\n\t}\n\toffset = this.toSeconds(offset);\n\t//make sure the offset is not less than 0\n\toffset = Math.max(offset, 0);\n\n\tgain = Tone.defaultArg(gain, 1);\n\n\t//apply a fade in envelope\n\tvar fadeInTime = this.toSeconds(this.fadeIn);\n\tif (fadeInTime > 0){\n\t\tthis._gainNode.gain.setValueAtTime(0, time);\n\t\tif (this.curve === \"linear\"){\n\t\t\tthis._gainNode.gain.linearRampToValueAtTime(gain, time + fadeInTime);\n\t\t} else {\n\t\t\tthis._gainNode.gain.exponentialApproachValueAtTime(gain, time, fadeInTime);\n\t\t}\n\t} else {\n\t\tthis._gainNode.gain.setValueAtTime(gain, time);\n\t}\n\n\tthis._startTime = time;\n\n\t//if a duration is given, schedule a stop\n\tif (Tone.isDefined(duration)){\n\t\tvar computedDur = this.toSeconds(duration);\n\t\t//make sure it's never negative\n\t\tcomputedDur = Math.max(computedDur, 0);\n\n\t\tthis.stop(time + computedDur);\n\t}\n\n\t//start the buffer source\n\tif (this.loop){\n\t\t//modify the offset if it's greater than the loop time\n\t\tvar loopEnd = this.loopEnd || this.buffer.duration;\n\t\tvar loopStart = this.loopStart;\n\t\tvar loopDuration = loopEnd - loopStart;\n\t\t//move the offset back\n\t\tif (offset >= loopEnd){\n\t\t\toffset = ((offset - loopStart) % loopDuration) + loopStart;\n\t\t}\n\t}\n\tthis._source.buffer = this.buffer.get();\n\tthis._source.loopEnd = this.loopEnd || this.buffer.duration;\n\tif (offset < this.buffer.duration){\n\t\tthis._sourceStarted = true;\n\t\tthis._source.start(time, offset);\n\t}\n\n\treturn this;\n};\n\n/**\n * Stop the buffer. \n * @param {Time=} time The time the buffer should stop.\n * @return {Tone.BufferSource} this\n */\nTone.BufferSource.prototype.stop = function(time){\n\tthis.log(\"stop\", time);\n\tthis.assert(this.buffer.loaded, \"buffer is either not set or not loaded\");\n\tthis.assert(!this._sourceStopped, \"source is already stopped\");\n\n\ttime = this.toSeconds(time);\n\n\t//if the event has already been scheduled, clear it\n\tif (this._stopTime !== -1){\n\t\tthis.cancelStop();\n\t}\n\n\t//the fadeOut time\n\tvar fadeOutTime = this.toSeconds(this.fadeOut);\n\n\t//cancel the previous curve\n\tthis._stopTime = time + fadeOutTime;\n\n\tif (fadeOutTime > 0){\n\t\t//start the fade out curve at the given time\n\t\tif (this.curve === \"linear\"){\n\t\t\tthis._gainNode.gain.linearRampTo(0, fadeOutTime, time);\n\t\t} else {\n\t\t\tthis._gainNode.gain.targetRampTo(0, fadeOutTime, time);\n\t\t}\n\t} else {\n\t\t//stop any ongoing ramps, and set the value to 0\n\t\tthis._gainNode.gain.cancelAndHoldAtTime(time);\n\t\tthis._gainNode.gain.setValueAtTime(0, time);\n\t}\n\n\tTone.context.clearTimeout(this._onendedTimeout);\n\tthis._onendedTimeout = Tone.context.setTimeout(this._onended.bind(this), this._stopTime - this.now());\n\n\treturn this;\n};\n\n/**\n * Cancel a scheduled stop event\n * @return {Tone.BufferSource} this\n */\nTone.BufferSource.prototype.cancelStop = function(){\n\tif (this._startTime !== -1 && !this._sourceStopped){\n\t\t//cancel the stop envelope\n\t\tvar fadeInTime = this.toSeconds(this.fadeIn);\n\t\tthis._gainNode.gain.cancelScheduledValues(this._startTime + fadeInTime + this.sampleTime);\n\t\tthis.context.clearTimeout(this._onendedTimeout);\n\t\tthis._stopTime = -1;\n\t}\n\treturn this;\n};\n\n/**\n * Internal callback when the buffer is ended.\n * Invokes `onended` and disposes the node.\n * @private\n */\nTone.BufferSource.prototype._onended = function(){\n\tif (!this._sourceStopped){\n\t\tthis._sourceStopped = true;\n\t\t//allow additional time for the exponential curve to fully decay\n\t\tvar additionalTail = this.curve === \"exponential\" ? this.fadeOut * 2 : 0;\n\t\tif (this._sourceStarted && this._stopTime !== -1){\n\t\t\tthis._source.stop(this._stopTime + additionalTail);\n\t\t}\n\t\tthis.onended(this);\n\n\t\t//dispose the source after it's come to a stop\n\t\tsetTimeout(function(){\n\t\t\t//if it hasn't already been disposed\n\t\t\tif (this._source){\n\t\t\t\tthis._source.disconnect();\n\t\t\t\tthis._gainNode.disconnect();\n\t\t\t}\n\t\t}.bind(this), additionalTail * 1000 + 100);\n\t}\n};\n\n/**\n * If loop is true, the loop will start at this position.\n * @memberOf Tone.BufferSource#\n * @type {Time}\n * @name loopStart\n */\nObject.defineProperty(Tone.BufferSource.prototype, \"loopStart\", {\n\tget : function(){\n\t\treturn this._source.loopStart;\n\t},\n\tset : function(loopStart){\n\t\tthis._source.loopStart = this.toSeconds(loopStart);\n\t}\n});\n\n/**\n * If loop is true, the loop will end at this position.\n * @memberOf Tone.BufferSource#\n * @type {Time}\n * @name loopEnd\n */\nObject.defineProperty(Tone.BufferSource.prototype, \"loopEnd\", {\n\tget : function(){\n\t\treturn this._source.loopEnd;\n\t},\n\tset : function(loopEnd){\n\t\tthis._source.loopEnd = this.toSeconds(loopEnd);\n\t}\n});\n\n/**\n * The audio buffer belonging to the player.\n * @memberOf Tone.BufferSource#\n * @type {Tone.Buffer}\n * @name buffer\n */\nObject.defineProperty(Tone.BufferSource.prototype, \"buffer\", {\n\tget : function(){\n\t\treturn this._buffer;\n\t},\n\tset : function(buffer){\n\t\tthis._buffer.set(buffer);\n\t}\n});\n\n/**\n * If the buffer should loop once it's over.\n * @memberOf Tone.BufferSource#\n * @type {Boolean}\n * @name loop\n */\nObject.defineProperty(Tone.BufferSource.prototype, \"loop\", {\n\tget : function(){\n\t\treturn this._source.loop;\n\t},\n\tset : function(loop){\n\t\tthis._source.loop = loop;\n\t\tthis.cancelStop();\n\t}\n});\n\n/**\n * Clean up.\n * @return {Tone.BufferSource} this\n */\nTone.BufferSource.prototype.dispose = function(){\n\tif (!this._wasDisposed){\n\t\tthis._wasDisposed = true;\n\t\tTone.AudioNode.prototype.dispose.call(this);\n\t\tthis.onended = null;\n\t\tthis._source.onended = null;\n\t\tthis._source.disconnect();\n\t\tthis._source = null;\n\t\tthis._gainNode.dispose();\n\t\tthis._gainNode = null;\n\t\tthis._buffer.dispose();\n\t\tthis._buffer = null;\n\t\tthis._startTime = -1;\n\t\tthis.playbackRate = null;\n\t\tTone.context.clearTimeout(this._onendedTimeout);\n\t}\n\treturn this;\n};\n\nexport default Tone.BufferSource;\n\n","import Tone from \"../core/Tone\";\nimport \"../effect/Effect\";\nimport \"../signal/Signal\";\nimport \"../signal/Multiply\";\nimport \"../core/Gain\";\n\n/**\n * \t@class Tone.FeedbackEffect provides a loop between an \n * \t audio source and its own output. This is a base-class\n * \t for feedback effects. \n *\n * @constructor\n * @extends {Tone.Effect}\n * @param {NormalRange|Object} [feedback] The initial feedback value.\n */\nTone.FeedbackEffect = function(){\n\n\tvar options = Tone.defaults(arguments, [\"feedback\"], Tone.FeedbackEffect);\n\tTone.Effect.call(this, options);\n\t\n\t/**\n\t * the gain which controls the feedback\n\t * @type {Tone.Gain}\n\t * @private\n\t */\n\tthis._feedbackGain = new Tone.Gain(options.feedback, Tone.Type.NormalRange);\n\n\t/**\n\t * The amount of signal which is fed back into the effect input. \n\t * @type {NormalRange}\n\t * @signal\n\t */\n\tthis.feedback = this._feedbackGain.gain;\n\n\t//the feedback loop\n\tthis.effectReturn.chain(this._feedbackGain, this.effectSend);\n\tthis._readOnly([\"feedback\"]);\n};\n\nTone.extend(Tone.FeedbackEffect, Tone.Effect);\n\n/**\n * @static\n * @type {Object}\n */\nTone.FeedbackEffect.defaults = {\n\t\"feedback\" : 0.125\n};\n\n/**\n * Clean up. \n * @returns {Tone.FeedbackEffect} this\n */\nTone.FeedbackEffect.prototype.dispose = function(){\n\tTone.Effect.prototype.dispose.call(this);\n\tthis._writable([\"feedback\"]);\n\tthis._feedbackGain.dispose();\n\tthis._feedbackGain = null;\n\tthis.feedback = null;\n\treturn this;\n};\n\nexport default Tone.FeedbackEffect;\n\n","import Tone from \"../core/Tone\";\nimport \"../core/Timeline\";\nimport \"../type/Type\";\n\n/**\n * @class A Timeline State. Provides the methods: setStateAtTime(\"state\", time)\n * and getValueAtTime(time).\n *\n * @extends {Tone.Timeline}\n * @param {String} initial The initial state of the TimelineState. \n * Defaults to undefined\n */\nTone.TimelineState = function(initial){\n\n\tTone.Timeline.call(this);\n\n\t/**\n\t * The initial state\n\t * @private\n\t * @type {String}\n\t */\n\tthis._initial = initial;\n};\n\nTone.extend(Tone.TimelineState, Tone.Timeline);\n\n/**\n * Returns the scheduled state scheduled before or at\n * the given time.\n * @param {Number} time The time to query.\n * @return {String} The name of the state input in setStateAtTime.\n */\nTone.TimelineState.prototype.getValueAtTime = function(time){\n\tvar event = this.get(time);\n\tif (event !== null){\n\t\treturn event.state;\n\t} else {\n\t\treturn this._initial;\n\t}\n};\n\n/**\n * Add a state to the timeline.\n * @param {String} state The name of the state to set.\n * @param {Number} time The time to query.\n * @returns {Tone.TimelineState} this\n */\nTone.TimelineState.prototype.setStateAtTime = function(state, time){\n\t//all state changes need to be >= the previous state time\n\t//TODO throw error if time < the previous event time\n\tthis.add({\n\t\t\"state\" : state,\n\t\t\"time\" : time\n\t});\n\treturn this;\n};\n\n/**\n * Return the event before the time with the given state\n * @param {Tone.State} state The state to look for\n * @param {Time} time When to check before\t\t\t\n * @return {Object} The event with the given state before the time\n */\nTone.TimelineState.prototype.getLastState = function(state, time){\n\ttime = this.toSeconds(time);\n\tvar index = this._search(time);\n\tfor (var i = index; i >= 0; i--){\n\t\tvar event = this._timeline[i];\n\t\tif (event.state === state){\n\t\t\treturn event;\n\t\t}\n\t}\n};\n\n/**\n * Return the event after the time with the given state\n * @param {Tone.State} state The state to look for\n * @param {Time} time When to check from\n * @return {Object} The event with the given state after the time\n */\nTone.TimelineState.prototype.getNextState = function(state, time){\n\ttime = this.toSeconds(time);\n\tvar index = this._search(time);\n\tif (index !== -1){\n\t\tfor (var i = index; i < this._timeline.length; i++){\n\t\t\tvar 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\nexport default Tone.TimelineState;\n\n","import Tone from \"../core/Tone\";\n\n/**\n * @class Tone.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 *\n * @extends {Tone}\n */\nTone.Emitter = function(){\n\tTone.call(this);\n\t/**\n\t * Contains all of the events.\n\t * @private\n\t * @type {Object}\n\t */\n\tthis._events = {};\n};\n\nTone.extend(Tone.Emitter);\n\n/**\n * Bind a callback to a specific event.\n * @param {String} event The name of the event to listen for.\n * @param {Function} callback The callback to invoke when the\n * event is emitted\n * @return {Tone.Emitter} this\n */\nTone.Emitter.prototype.on = function(event, callback){\n\t//split the event\n\tvar events = event.split(/\\W+/);\n\tfor (var i = 0; i < events.length; i++){\n\t\tvar eventName = events[i];\n\t\tif (!this._events.hasOwnProperty(eventName)){\n\t\t\tthis._events[eventName] = [];\n\t\t}\n\t\tthis._events[eventName].push(callback);\n\t}\n\treturn this;\n};\n\n/**\n * Bind a callback which is only invoked once\n * @param {String} event The name of the event to listen for.\n * @param {Function} callback The callback to invoke when the\n * event is emitted\n * @return {Tone.Emitter} this\n */\nTone.Emitter.prototype.once = function(event, callback){\n\tvar boundCallback = function(){\n\t\t//invoke the callback\n\t\tcallback.apply(this, arguments);\n\t\tthis.off(event, boundCallback);\n\t}.bind(this);\n\tthis.on(event, boundCallback);\n\treturn this;\n};\n\n/**\n * Remove the event listener.\n * @param {String} event The event to stop listening to.\n * @param {Function=} callback The callback which was bound to\n * the event with Tone.Emitter.on.\n * If no callback is given, all callbacks\n * events are removed.\n * @return {Tone.Emitter} this\n */\nTone.Emitter.prototype.off = function(event, callback){\n\tvar events = event.split(/\\W+/);\n\tfor (var ev = 0; ev < events.length; ev++){\n\t\tevent = events[ev];\n\t\tif (this._events.hasOwnProperty(event)){\n\t\t\tif (Tone.isUndef(callback)){\n\t\t\t\tthis._events[event] = [];\n\t\t\t} else {\n\t\t\t\tvar eventList = this._events[event];\n\t\t\t\tfor (var i = 0; i < eventList.length; i++){\n\t\t\t\t\tif (eventList[i] === callback){\n\t\t\t\t\t\teventList.splice(i, 1);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\treturn this;\n};\n\n/**\n * Invoke all of the callbacks bound to the event\n * with any arguments passed in.\n * @param {String} event The name of the event.\n * @param {...*} args The arguments to pass to the functions listening.\n * @return {Tone.Emitter} this\n */\nTone.Emitter.prototype.emit = function(event){\n\tif (this._events){\n\t\tvar args = Array.apply(null, arguments).slice(1);\n\t\tif (this._events.hasOwnProperty(event)){\n\t\t\tvar eventList = this._events[event].slice(0);\n\t\t\tfor (var i = 0, len = eventList.length; i < len; i++){\n\t\t\t\teventList[i].apply(this, args);\n\t\t\t}\n\t\t}\n\t}\n\treturn this;\n};\n\n/**\n * Add Emitter functions (on/off/emit) to the object\n * @param {Object|Function} object The object or class to extend.\n * @returns {Tone.Emitter}\n */\nTone.Emitter.mixin = function(object){\n\tvar functions = [\"on\", \"once\", \"off\", \"emit\"];\n\tobject._events = {};\n\tfor (var i = 0; i < functions.length; i++){\n\t\tvar func = functions[i];\n\t\tvar emitterFunc = Tone.Emitter.prototype[func];\n\t\tobject[func] = emitterFunc;\n\t}\n\treturn Tone.Emitter;\n};\n\n/**\n * Clean up\n * @return {Tone.Emitter} this\n */\nTone.Emitter.prototype.dispose = function(){\n\tTone.prototype.dispose.call(this);\n\tthis._events = null;\n\treturn this;\n};\n\nexport default Tone.Emitter;\n\n","import Tone from \"../core/Tone\";\nimport \"../shim/AudioContext\";\n\n/**\n * AnalyserNode.getFloatTimeDomainData polyfill\n * @private\n */\nif (Tone.supported){\n\tif (!AnalyserNode.prototype.getFloatTimeDomainData){\n\t\t//referenced https://github.com/mohayonao/get-float-time-domain-data\n\t\tAnalyserNode.prototype.getFloatTimeDomainData = function(array){\n\t\t\tvar uint8 = new Uint8Array(array.length);\n\t\t\tthis.getByteTimeDomainData(uint8);\n\t\t\tfor (var i = 0; i < uint8.length; i++){\n\t\t\t\tarray[i] = (uint8[i] - 128) / 128;\n\t\t\t}\n\t\t};\n\t}\n}\n\n","import Tone from \"../core/Tone\";\nimport \"../core/AudioNode\";\nimport \"../shim/AnalyserNode\";\n\n/**\n * @class Wrapper around the native Web Audio's\n * [AnalyserNode](http://webaudio.github.io/web-audio-api/#idl-def-AnalyserNode).\n * Extracts FFT or Waveform data from the incoming signal.\n * @extends {Tone.AudioNode}\n * @param {String=} type The return type of the analysis, either \"fft\", or \"waveform\".\n * @param {Number=} size The size of the FFT. Value must be a power of\n * two in the range 16 to 16384.\n */\nTone.Analyser = function(){\n\n\tvar options = Tone.defaults(arguments, [\"type\", \"size\"], Tone.Analyser);\n\tTone.AudioNode.call(this);\n\n\t/**\n\t * The analyser node.\n\t * @private\n\t * @type {AnalyserNode}\n\t */\n\tthis._analyser = this.input = this.output = this.context.createAnalyser();\n\n\t/**\n\t * The analysis type\n\t * @type {String}\n\t * @private\n\t */\n\tthis._type = options.type;\n\n\t/**\n\t * The buffer that the FFT data is written to\n\t * @type {TypedArray}\n\t * @private\n\t */\n\tthis._buffer = null;\n\n\t//set the values initially\n\tthis.size = options.size;\n\tthis.type = options.type;\n};\n\nTone.extend(Tone.Analyser, Tone.AudioNode);\n\n/**\n * The default values.\n * @type {Object}\n * @const\n */\nTone.Analyser.defaults = {\n\t\"size\" : 1024,\n\t\"type\" : \"fft\",\n\t\"smoothing\" : 0.8\n};\n\n/**\n * Possible return types of analyser.getValue()\n * @enum {String}\n */\nTone.Analyser.Type = {\n\tWaveform : \"waveform\",\n\tFFT : \"fft\"\n};\n\n/**\n * Run the analysis given the current settings and return the\n * result as a TypedArray of length [size](#size).\n * @returns {TypedArray}\n */\nTone.Analyser.prototype.getValue = function(){\n\tif (this._type === Tone.Analyser.Type.FFT){\n\t\tthis._analyser.getFloatFrequencyData(this._buffer);\n\t} else if (this._type === Tone.Analyser.Type.Waveform){\n\t\tthis._analyser.getFloatTimeDomainData(this._buffer);\n\t}\n\treturn this._buffer;\n};\n\n/**\n * The size of analysis. This must be a power of two in the range 16 to 16384.\n * @memberOf Tone.Analyser#\n * @type {Number}\n * @name size\n */\nObject.defineProperty(Tone.Analyser.prototype, \"size\", {\n\tget : function(){\n\t\treturn this._analyser.frequencyBinCount;\n\t},\n\tset : function(size){\n\t\t// fftSize is double frequencyBinCount\n\t\tthis._analyser.fftSize = size * 2;\n\t\tthis._buffer = new Float32Array(size);\n\t}\n});\n\n/**\n * The analysis function returned by analyser.getValue(), either \"fft\" or \"waveform\".\n * @memberOf Tone.Analyser#\n * @type {String}\n * @name type\n */\nObject.defineProperty(Tone.Analyser.prototype, \"type\", {\n\tget : function(){\n\t\treturn this._type;\n\t},\n\tset : function(type){\n\t\tif (type !== Tone.Analyser.Type.Waveform && type !== Tone.Analyser.Type.FFT){\n\t\t\tthrow new TypeError(\"Tone.Analyser: invalid type: \"+type);\n\t\t}\n\t\tthis._type = type;\n\t}\n});\n\n/**\n * 0 represents no time averaging with the last analysis frame.\n * @memberOf Tone.Analyser#\n * @type {NormalRange}\n * @name smoothing\n */\nObject.defineProperty(Tone.Analyser.prototype, \"smoothing\", {\n\tget : function(){\n\t\treturn this._analyser.smoothingTimeConstant;\n\t},\n\tset : function(val){\n\t\tthis._analyser.smoothingTimeConstant = val;\n\t}\n});\n\n/**\n * Clean up.\n * @return {Tone.Analyser} this\n */\nTone.Analyser.prototype.dispose = function(){\n\tTone.AudioNode.prototype.dispose.call(this);\n\tthis._analyser.disconnect();\n\tthis._analyser = null;\n\tthis._buffer = null;\n};\n\nexport default Tone.Analyser;\n\n","import Tone from \"../core/Tone\";\nimport \"../source/Source\";\nimport \"../source/Oscillator\";\nimport \"../source/PulseOscillator\";\nimport \"../source/PWMOscillator\";\nimport \"../source/FMOscillator\";\nimport \"../source/AMOscillator\";\nimport \"../source/FatOscillator\";\n\n/**\n * @class Tone.OmniOscillator aggregates Tone.Oscillator, Tone.PulseOscillator,\n * Tone.PWMOscillator, Tone.FMOscillator, Tone.AMOscillator, and Tone.FatOscillator\n * into one class. The oscillator class can be changed by setting the `type`.\n * `omniOsc.type = \"pwm\"` will set it to the Tone.PWMOscillator. Prefixing\n * any of the basic types (\"sine\", \"square4\", etc.) with \"fm\", \"am\", or \"fat\"\n * will use the FMOscillator, AMOscillator or FatOscillator respectively.\n * For example: `omniOsc.type = \"fatsawtooth\"` will create set the oscillator\n * to a FatOscillator of type \"sawtooth\".\n *\n * @extends {Tone.Source}\n * @constructor\n * @param {Frequency} frequency The initial frequency of the oscillator.\n * @param {String} type The type of the oscillator.\n * @example\n * var omniOsc = new Tone.OmniOscillator(\"C#4\", \"pwm\");\n */\nTone.OmniOscillator = function(){\n\n\tvar options = Tone.defaults(arguments, [\"frequency\", \"type\"], Tone.OmniOscillator);\n\tTone.Source.call(this, options);\n\n\t/**\n\t * The frequency control.\n\t * @type {Frequency}\n\t * @signal\n\t */\n\tthis.frequency = new Tone.Signal(options.frequency, Tone.Type.Frequency);\n\n\t/**\n\t * The detune control\n\t * @type {Cents}\n\t * @signal\n\t */\n\tthis.detune = new Tone.Signal(options.detune, Tone.Type.Cents);\n\n\t/**\n\t * the type of the oscillator source\n\t * @type {String}\n\t * @private\n\t */\n\tthis._sourceType = undefined;\n\n\t/**\n\t * the oscillator\n\t * @type {Tone.Oscillator}\n\t * @private\n\t */\n\tthis._oscillator = null;\n\n\t//set the oscillator\n\tthis.type = options.type;\n\tthis._readOnly([\"frequency\", \"detune\"]);\n\t//set the options\n\tthis.set(options);\n};\n\nTone.extend(Tone.OmniOscillator, Tone.Source);\n\n/**\n * default values\n * @static\n * @type {Object}\n * @const\n */\nTone.OmniOscillator.defaults = {\n\t\"frequency\" : 440,\n\t\"detune\" : 0,\n\t\"type\" : \"sine\",\n\t\"phase\" : 0\n};\n\n/**\n * @enum {String}\n * @private\n */\nvar OmniOscType = {\n\tPulse : \"PulseOscillator\",\n\tPWM : \"PWMOscillator\",\n\tOsc : \"Oscillator\",\n\tFM : \"FMOscillator\",\n\tAM : \"AMOscillator\",\n\tFat : \"FatOscillator\"\n};\n\n/**\n * start the oscillator\n * @param {Time} [time=now] the time to start the oscillator\n * @private\n */\nTone.OmniOscillator.prototype._start = function(time){\n\tthis._oscillator.start(time);\n};\n\n/**\n * start the oscillator\n * @param {Time} [time=now] the time to start the oscillator\n * @private\n */\nTone.OmniOscillator.prototype._stop = function(time){\n\tthis._oscillator.stop(time);\n};\n\nTone.OmniOscillator.prototype.restart = function(time){\n\tthis._oscillator.restart(time);\n};\n\n/**\n * The type of the oscillator. Can be any of the basic types: sine, square, triangle, sawtooth. Or\n * prefix the basic types with \"fm\", \"am\", or \"fat\" to use the FMOscillator, AMOscillator or FatOscillator\n * types. The oscillator could also be set to \"pwm\" or \"pulse\". All of the parameters of the\n * oscillator's class are accessible when the oscillator is set to that type, but throws an error\n * when it's not.\n *\n * @memberOf Tone.OmniOscillator#\n * @type {String}\n * @name type\n * @example\n * omniOsc.type = \"pwm\";\n * //modulationFrequency is parameter which is available\n * //only when the type is \"pwm\".\n * omniOsc.modulationFrequency.value = 0.5;\n * @example\n * //an square wave frequency modulated by a sawtooth\n * omniOsc.type = \"fmsquare\";\n * omniOsc.modulationType = \"sawtooth\";\n */\nObject.defineProperty(Tone.OmniOscillator.prototype, \"type\", {\n\tget : function(){\n\t\tvar prefix = \"\";\n\t\tif (this._sourceType === OmniOscType.FM){\n\t\t\tprefix = \"fm\";\n\t\t} else if (this._sourceType === OmniOscType.AM){\n\t\t\tprefix = \"am\";\n\t\t} else if (this._sourceType === OmniOscType.Fat){\n\t\t\tprefix = \"fat\";\n\t\t}\n\t\treturn prefix + this._oscillator.type;\n\t},\n\tset : function(type){\n\t\tif (type.substr(0, 2) === \"fm\"){\n\t\t\tthis._createNewOscillator(OmniOscType.FM);\n\t\t\tthis._oscillator.type = type.substr(2);\n\t\t} else if (type.substr(0, 2) === \"am\"){\n\t\t\tthis._createNewOscillator(OmniOscType.AM);\n\t\t\tthis._oscillator.type = type.substr(2);\n\t\t} else if (type.substr(0, 3) === \"fat\"){\n\t\t\tthis._createNewOscillator(OmniOscType.Fat);\n\t\t\tthis._oscillator.type = type.substr(3);\n\t\t} else if (type === \"pwm\"){\n\t\t\tthis._createNewOscillator(OmniOscType.PWM);\n\t\t} else if (type === \"pulse\"){\n\t\t\tthis._createNewOscillator(OmniOscType.Pulse);\n\t\t} else {\n\t\t\tthis._createNewOscillator(OmniOscType.Osc);\n\t\t\tthis._oscillator.type = type;\n\t\t}\n\t}\n});\n\n/**\n * The partials of the waveform. A partial represents\n * the amplitude at a harmonic. The first harmonic is the\n * fundamental frequency, the second is the octave and so on\n * following the harmonic series.\n * Setting this value will automatically set the type to \"custom\".\n * The value is an empty array when the type is not \"custom\".\n * This is not available on \"pwm\" and \"pulse\" oscillator types.\n * @memberOf Tone.OmniOscillator#\n * @type {Array}\n * @name partials\n * @example\n * osc.partials = [1, 0.2, 0.01];\n */\nObject.defineProperty(Tone.OmniOscillator.prototype, \"partials\", {\n\tget : function(){\n\t\treturn this._oscillator.partials;\n\t},\n\tset : function(partials){\n\t\tthis._oscillator.partials = partials;\n\t}\n});\n\n/**\n * The partial count of the oscillator. This is not available on \"pwm\" and \"pulse\" oscillator types.\n * @memberOf Tone.OmniOscillator#\n * @type {Number}\n * @name partialCount\n * @example\n * //set the maximum number of partials\n * osc.partialCount = 0;\n */\nObject.defineProperty(Tone.OmniOscillator.prototype, \"partialCount\", {\n\tget : function(){\n\t\treturn this._oscillator.partialCount;\n\t},\n\tset : function(partialCount){\n\t\tthis._oscillator.partialCount = partialCount;\n\t}\n});\n\n/**\n * Set a member/attribute of the oscillator.\n * @param {Object|String} params\n * @param {number=} value\n * @param {Time=} rampTime\n * @returns {Tone.OmniOscillator} this\n */\nTone.OmniOscillator.prototype.set = function(params, value){\n\t//make sure the type is set first\n\tif (params === \"type\"){\n\t\tthis.type = value;\n\t} else if (Tone.isObject(params) && params.hasOwnProperty(\"type\")){\n\t\tthis.type = params.type;\n\t}\n\t//then set the rest\n\tTone.prototype.set.apply(this, arguments);\n\treturn this;\n};\n\n/**\n * Get the object's attributes. Given no arguments get\n * will return all available object properties and their corresponding\n * values. Pass in a single attribute to retrieve or an array\n * of attributes. The attribute strings can also include a \".\"\n * to access deeper properties.\n * @param {Array=|string|undefined} params the parameters to get, otherwise will return\n * \t\t\t\t\t all available.\n * @returns {Object}\n */\nTone.OmniOscillator.prototype.get = function(params){\n\tvar options = this._oscillator.get(params);\n\toptions.type = this.type;\n\treturn options;\n};\n\n/**\n * connect the oscillator to the frequency and detune signals\n * @private\n */\nTone.OmniOscillator.prototype._createNewOscillator = function(oscType){\n\tif (oscType !== this._sourceType){\n\t\tthis._sourceType = oscType;\n\t\tvar OscillatorConstructor = Tone[oscType];\n\t\t//short delay to avoid clicks on the change\n\t\tvar now = this.now();\n\t\tif (this._oscillator !== null){\n\t\t\tvar oldOsc = this._oscillator;\n\t\t\toldOsc.stop(now);\n\t\t\t//dispose the old one\n\t\t\tthis.context.setTimeout(function(){\n\t\t\t\toldOsc.dispose();\n\t\t\t\toldOsc = null;\n\t\t\t}, this.blockTime);\n\t\t}\n\t\tthis._oscillator = new OscillatorConstructor();\n\t\tthis.frequency.connect(this._oscillator.frequency);\n\t\tthis.detune.connect(this._oscillator.detune);\n\t\tthis._oscillator.connect(this.output);\n\t\tif (this.state === Tone.State.Started){\n\t\t\tthis._oscillator.start(now);\n\t\t}\n\t}\n};\n\n/**\n * The phase of the oscillator in degrees.\n * @memberOf Tone.OmniOscillator#\n * @type {Degrees}\n * @name phase\n */\nObject.defineProperty(Tone.OmniOscillator.prototype, \"phase\", {\n\tget : function(){\n\t\treturn this._oscillator.phase;\n\t},\n\tset : function(phase){\n\t\tthis._oscillator.phase = phase;\n\t}\n});\n\n/**\n * The source type names\n * @private\n * @type {Object}\n */\nvar SourceTypeNames = {\n\tPulseOscillator : \"pulse\",\n\tPWMOscillator : \"pwm\",\n\tOscillator : \"oscillator\",\n\tFMOscillator : \"fm\",\n\tAMOscillator : \"am\",\n\tFatOscillator : \"fat\"\n};\n\n/**\n * The source type of the oscillator. \n * @memberOf Tone.OmniOscillator#\n * @type {String}\n * @name sourceType\n * @example\n * var omniOsc = new Tone.OmniOscillator(440, \"fmsquare\");\n * omniOsc.sourceType // 'fm'\n */\nObject.defineProperty(Tone.OmniOscillator.prototype, \"sourceType\", {\n\tget : function(){\n\t\treturn SourceTypeNames[this._sourceType];\n\t},\n\tset : function(sType){\n\t\t//the basetype defaults to sine\n\t\tvar 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 === SourceTypeNames.FMOscillator){\n\t\t\tthis.type = \"fm\" + baseType;\n\t\t} else if (sType === SourceTypeNames.AMOscillator){\n\t\t\tthis.type = \"am\" + baseType;\n\t\t} else if (sType === SourceTypeNames.FatOscillator){\n\t\t\tthis.type = \"fat\" + baseType;\n\t\t} else if (sType === SourceTypeNames.Oscillator){\n\t\t\tthis.type = baseType;\n\t\t} else if (sType === SourceTypeNames.PulseOscillator){\n\t\t\tthis.type = \"pulse\";\n\t\t} else if (sType === SourceTypeNames.PWMOscillator){\n\t\t\tthis.type = \"pwm\";\n\t\t}\n\t}\n});\n\n/**\n * The base type of the oscillator.\n * @memberOf Tone.OmniOscillator#\n * @type {String}\n * @name baseType\n * @example\n * var omniOsc = new Tone.OmniOscillator(440, \"fmsquare4\");\n * omniOsc.sourceType // 'fm'\n * omniOsc.baseType //'square'\n * omniOsc.partialCount //4\n */\nObject.defineProperty(Tone.OmniOscillator.prototype, \"baseType\", {\n\tget : function(){\n\t\treturn this._oscillator.baseType;\n\t},\n\tset : function(baseType){\n\t\tif (this.sourceType !== SourceTypeNames.PulseOscillator && this.sourceType !== SourceTypeNames.PWMOscillator){\n\t\t\tthis._oscillator.baseType = baseType;\n\t\t}\n\t}\n});\n\n/**\n * The width of the oscillator (only if the oscillator is set to \"pulse\")\n * @memberOf Tone.OmniOscillator#\n * @type {NormalRange}\n * @signal\n * @name width\n * @example\n * var omniOsc = new Tone.OmniOscillator(440, \"pulse\");\n * //can access the width attribute only if type === \"pulse\"\n * omniOsc.width.value = 0.2;\n */\nObject.defineProperty(Tone.OmniOscillator.prototype, \"width\", {\n\tget : function(){\n\t\tif (this._sourceType === OmniOscType.Pulse){\n\t\t\treturn this._oscillator.width;\n\t\t} else {\n\t\t\treturn undefined;\n\t\t}\n\t}\n});\n\n/**\n * The number of detuned oscillators\n * @memberOf Tone.OmniOscillator#\n * @type {Number}\n * @name count\n */\nObject.defineProperty(Tone.OmniOscillator.prototype, \"count\", {\n\tget : function(){\n\t\tif (this._sourceType === OmniOscType.Fat){\n\t\t\treturn this._oscillator.count;\n\t\t} else {\n\t\t\treturn undefined;\n\t\t}\n\t},\n\tset : function(count){\n\t\tif (this._sourceType === OmniOscType.Fat){\n\t\t\tthis._oscillator.count = count;\n\t\t}\n\t}\n});\n\n/**\n * The detune spread between the oscillators. If \"count\" is\n * set to 3 oscillators and the \"spread\" is set to 40,\n * the three oscillators would be detuned like this: [-20, 0, 20]\n * for a total detune spread of 40 cents. See Tone.FatOscillator\n * for more info.\n * @memberOf Tone.OmniOscillator#\n * @type {Cents}\n * @name spread\n */\nObject.defineProperty(Tone.OmniOscillator.prototype, \"spread\", {\n\tget : function(){\n\t\tif (this._sourceType === OmniOscType.Fat){\n\t\t\treturn this._oscillator.spread;\n\t\t} else {\n\t\t\treturn undefined;\n\t\t}\n\t},\n\tset : function(spread){\n\t\tif (this._sourceType === OmniOscType.Fat){\n\t\t\tthis._oscillator.spread = spread;\n\t\t}\n\t}\n});\n\n/**\n * The type of the modulator oscillator. Only if the oscillator\n * is set to \"am\" or \"fm\" types. see. Tone.AMOscillator or Tone.FMOscillator\n * for more info.\n * @memberOf Tone.OmniOscillator#\n * @type {String}\n * @name modulationType\n */\nObject.defineProperty(Tone.OmniOscillator.prototype, \"modulationType\", {\n\tget : function(){\n\t\tif (this._sourceType === OmniOscType.FM || this._sourceType === OmniOscType.AM){\n\t\t\treturn this._oscillator.modulationType;\n\t\t} else {\n\t\t\treturn undefined;\n\t\t}\n\t},\n\tset : function(mType){\n\t\tif (this._sourceType === OmniOscType.FM || this._sourceType === OmniOscType.AM){\n\t\t\tthis._oscillator.modulationType = mType;\n\t\t}\n\t}\n});\n\n/**\n * The modulation index which is in essence the depth or amount of the modulation. In other terms it is the\n * ratio of the frequency of the modulating signal (mf) to the amplitude of the\n * modulating signal (ma) -- as in ma/mf.\n * See Tone.FMOscillator for more info.\n * @type {Positive}\n * @signal\n * @name modulationIndex\n * @memberof Tone.OmniOscillator#\n */\nObject.defineProperty(Tone.OmniOscillator.prototype, \"modulationIndex\", {\n\tget : function(){\n\t\tif (this._sourceType === OmniOscType.FM){\n\t\t\treturn this._oscillator.modulationIndex;\n\t\t} else {\n\t\t\treturn undefined;\n\t\t}\n\t}\n});\n\n/**\n * Harmonicity is the frequency ratio between the carrier and the modulator oscillators.\n * A harmonicity of 1 gives both oscillators the same frequency.\n * Harmonicity = 2 means a change of an octave. See Tone.AMOscillator or Tone.FMOscillator\n * for more info.\n * @memberOf Tone.OmniOscillator#\n * @signal\n * @type {Positive}\n * @name harmonicity\n */\nObject.defineProperty(Tone.OmniOscillator.prototype, \"harmonicity\", {\n\tget : function(){\n\t\tif (this._sourceType === OmniOscType.FM || this._sourceType === OmniOscType.AM){\n\t\t\treturn this._oscillator.harmonicity;\n\t\t} else {\n\t\t\treturn undefined;\n\t\t}\n\t}\n});\n\n/**\n * The modulationFrequency Signal of the oscillator\n * (only if the oscillator type is set to pwm). See\n * Tone.PWMOscillator for more info.\n * @memberOf Tone.OmniOscillator#\n * @type {Frequency}\n * @signal\n * @name modulationFrequency\n * @example\n * var omniOsc = new Tone.OmniOscillator(440, \"pwm\");\n * //can access the modulationFrequency attribute only if type === \"pwm\"\n * omniOsc.modulationFrequency.value = 0.2;\n */\nObject.defineProperty(Tone.OmniOscillator.prototype, \"modulationFrequency\", {\n\tget : function(){\n\t\tif (this._sourceType === OmniOscType.PWM){\n\t\t\treturn this._oscillator.modulationFrequency;\n\t\t} else {\n\t\t\treturn undefined;\n\t\t}\n\t}\n});\n\n/**\n * Clean up.\n * @return {Tone.OmniOscillator} this\n */\nTone.OmniOscillator.prototype.dispose = function(){\n\tTone.Source.prototype.dispose.call(this);\n\tthis._writable([\"frequency\", \"detune\"]);\n\tthis.detune.dispose();\n\tthis.detune = null;\n\tthis.frequency.dispose();\n\tthis.frequency = null;\n\tthis._oscillator.dispose();\n\tthis._oscillator = null;\n\tthis._sourceType = null;\n\treturn this;\n};\n\nexport default Tone.OmniOscillator;\n\n","import Tone from \"../core/Tone\";\nimport \"../component/AmplitudeEnvelope\";\nimport \"../source/OmniOscillator\";\nimport \"../instrument/Monophonic\";\n\n/**\n * @class Tone.Synth is composed simply of a Tone.OmniOscillator\n * routed through a Tone.AmplitudeEnvelope.\n * \n * Like Tone.Transport, A single Tone.Master is created\n * on initialization and you do not need to explicitly construct one.\n *\n * @constructor\n * @extends {Tone}\n * @singleton\n * @example\n * //the audio will go from the oscillator to the speakers\n * oscillator.connect(Tone.Master);\n * //a convenience for connecting to the master output is also provided:\n * oscillator.toMaster();\n * //the above two examples are equivalent.\n */\nTone.Master = function(){\n\n\tTone.AudioNode.call(this);\n\tTone.getContext(function(){\n\t\tthis.createInsOuts(1, 0);\n\n\t\t/**\n\t\t * The private volume node\n\t\t * @type {Tone.Volume}\n\t\t * @private\n\t\t */\n\t\tthis._volume = this.output = new Tone.Volume();\n\n\t\t/**\n\t\t * The volume of the master output.\n\t\t * @type {Decibels}\n\t\t * @signal\n\t\t */\n\t\tthis.volume = this._volume.volume;\n\n\t\tthis._readOnly(\"volume\");\n\t\t//connections\n\t\tTone.connectSeries(this.input, this.output, this.context.destination);\n\n\t\t//master is a singleton so it adds itself to the context\n\t\tthis.context.master = this;\n\t}.bind(this));\n};\n\nTone.extend(Tone.Master, Tone.AudioNode);\n\n/**\n * @type {Object}\n * @const\n */\nTone.Master.defaults = {\n\t\"volume\" : 0,\n\t\"mute\" : false\n};\n\n/**\n * Is an instanceof Tone.Master\n * @type {Boolean}\n */\nTone.Master.prototype.isMaster = true;\n\n/**\n * Mute the output.\n * @memberOf Tone.Master#\n * @type {boolean}\n * @name mute\n * @example\n * //mute the output\n * Tone.Master.mute = true;\n */\nObject.defineProperty(Tone.Master.prototype, \"mute\", {\n\tget : function(){\n\t\treturn this._volume.mute;\n\t},\n\tset : function(mute){\n\t\tthis._volume.mute = mute;\n\t}\n});\n\n/**\n * Add a master effects chain. NOTE: this will disconnect any nodes which were previously\n * chained in the master effects chain.\n * @param {...(AudioNode|Tone)} nodes All arguments will be connected in a row\n * and the Master will be routed through it.\n * @return {Tone.Master} this\n * @example\n * //some overall compression to keep the levels in check\n * var masterCompressor = new Tone.Compressor({\n * \t\"threshold\" : -6,\n * \t\"ratio\" : 3,\n * \t\"attack\" : 0.5,\n * \t\"release\" : 0.1\n * });\n * //give a little boost to the lows\n * var lowBump = new Tone.Filter(200, \"lowshelf\");\n * //route everything through the filter\n * //and compressor before going to the speakers\n * Tone.Master.chain(lowBump, masterCompressor);\n */\nTone.Master.prototype.chain = function(){\n\tthis.input.disconnect();\n\tvar args = Array.from(arguments);\n\targs.unshift(this.input);\n\targs.push(this.output);\n\tTone.connectSeries.apply(undefined, args);\n};\n\n/**\n * Clean up\n * @return {Tone.Master} this\n */\nTone.Master.prototype.dispose = function(){\n\tTone.AudioNode.prototype.dispose.call(this);\n\tthis._writable(\"volume\");\n\tthis._volume.dispose();\n\tthis._volume = null;\n\tthis.volume = null;\n};\n\n///////////////////////////////////////////////////////////////////////////\n//\tAUGMENT TONE's PROTOTYPE\n///////////////////////////////////////////////////////////////////////////\n\n/**\n * Connect 'this' to the master output. Shorthand for this.connect(Tone.Master)\n * @returns {Tone.AudioNode} this\n * @example\n * //connect an oscillator to the master output\n * var osc = new Tone.Oscillator().toMaster();\n */\nTone.AudioNode.prototype.toMaster = function(){\n\tthis.connect(this.context.master);\n\treturn this;\n};\n\n/**\n * initialize the module and listen for new audio contexts\n * @private\n */\nvar MasterConstructor = Tone.Master;\nTone.Master = new MasterConstructor();\n\nTone.Context.on(\"init\", function(context){\n\t// if it already exists, just restore it\n\tif (context.master && context.master.isMaster){\n\t\tTone.Master = context.master;\n\t} else {\n\t\tTone.Master = new MasterConstructor();\n\t}\n});\n\nTone.Context.on(\"close\", function(context){\n\tif (context.master && context.master.isMaster){\n\t\tcontext.master.dispose();\n\t}\n});\n\nexport default Tone.Master;\n\n","import Tone from \"../core/Tone\";\nimport \"../component/ScaledEnvelope\";\nimport \"../component/Envelope\";\n\n/**\n * @class Tone.FrequencyEnvelope is a Tone.ScaledEnvelope, but instead of `min` and `max`\n * it's got a `baseFrequency` and `octaves` parameter.\n *\n * @extends {Tone.Envelope}\n * @constructor\n * @param {Time|Object} [attack]\tthe attack time in seconds\n * @param {Time} [decay]\tthe decay time in seconds\n * @param {number} [sustain] \ta percentage (0-1) of the full amplitude\n * @param {Time} [release]\tthe release time in seconds\n * @example\n * var freqEnv = new Tone.FrequencyEnvelope({\n * \t\"attack\" : 0.2,\n * \t\"baseFrequency\" : \"C2\",\n * \t\"octaves\" : 4\n * });\n * freqEnv.connect(oscillator.frequency);\n */\nTone.FrequencyEnvelope = function(){\n\n\tvar options = Tone.defaults(arguments, [\"attack\", \"decay\", \"sustain\", \"release\"], Tone.Envelope);\n\t//merge it with the frequency envelope defaults\n\toptions = Tone.defaultArg(options, Tone.FrequencyEnvelope.defaults);\n\tTone.ScaledEnvelope.call(this, options);\n\n\t/**\n\t * Stores the octave value\n\t * @type {Positive}\n\t * @private\n\t */\n\tthis._octaves = options.octaves;\n\n\t//setup\n\tthis.baseFrequency = options.baseFrequency;\n\tthis.octaves = options.octaves;\n\tthis.exponent = options.exponent;\n};\n\nTone.extend(Tone.FrequencyEnvelope, Tone.Envelope);\n\n/**\n * the default parameters\n * @static\n */\nTone.FrequencyEnvelope.defaults = {\n\t\"baseFrequency\" : 200,\n\t\"octaves\" : 4,\n\t\"exponent\" : 1\n};\n\n/**\n * The envelope's mininum output value. This is the value which it\n * starts at.\n * @memberOf Tone.FrequencyEnvelope#\n * @type {Frequency}\n * @name baseFrequency\n */\nObject.defineProperty(Tone.FrequencyEnvelope.prototype, \"baseFrequency\", {\n\tget : function(){\n\t\treturn this._scale.min;\n\t},\n\tset : function(min){\n\t\tthis._scale.min = this.toFrequency(min);\n\t\t//also update the octaves\n\t\tthis.octaves = this._octaves;\n\t}\n});\n\n/**\n * The number of octaves above the baseFrequency that the\n * envelope will scale to.\n * @memberOf Tone.FrequencyEnvelope#\n * @type {Positive}\n * @name octaves\n */\nObject.defineProperty(Tone.FrequencyEnvelope.prototype, \"octaves\", {\n\tget : function(){\n\t\treturn this._octaves;\n\t},\n\tset : function(octaves){\n\t\tthis._octaves = octaves;\n\t\tthis._scale.max = this.baseFrequency * Math.pow(2, octaves);\n\t}\n});\n\n/**\n * The envelope's exponent value.\n * @memberOf Tone.FrequencyEnvelope#\n * @type {number}\n * @name exponent\n */\nObject.defineProperty(Tone.FrequencyEnvelope.prototype, \"exponent\", {\n\tget : function(){\n\t\treturn this._exp.value;\n\t},\n\tset : function(exp){\n\t\tthis._exp.value = exp;\n\t}\n});\n\n/**\n * clean up\n * @returns {Tone.FrequencyEnvelope} this\n */\nTone.FrequencyEnvelope.prototype.dispose = function(){\n\tTone.ScaledEnvelope.prototype.dispose.call(this);\n\treturn this;\n};\n\nexport default Tone.FrequencyEnvelope;\n\n","import Tone from \"../core/Tone\";\nimport \"../signal/Scale\";\nimport \"../signal/Pow\";\n\n/**\n * @class 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 *\n * @constructor\n * @extends {Tone.SignalBase}\n * @param {number} [outputMin=0] The output value when the input is 0.\n * @param {number} [outputMax=1]\tThe output value when the input is 1.\n * @param {number} [exponent=2] The exponent which scales the incoming signal.\n * @example\n * var scaleExp = new Tone.ScaleExp(0, 100, 2);\n * var signal = new Tone.Signal(0.5).connect(scaleExp);\n */\nTone.ScaleExp = function(outputMin, outputMax, exponent){\n\n\tTone.SignalBase.call(this);\n\n\t/**\n\t * scale the input to the output range\n\t * @type {Tone.Scale}\n\t * @private\n\t */\n\tthis._scale = this.output = new Tone.Scale(outputMin, outputMax);\n\n\t/**\n\t * @private\n\t * @type {Tone.Pow}\n\t * @private\n\t */\n\tthis._exp = this.input = new Tone.Pow(Tone.defaultArg(exponent, 2));\n\n\tthis._exp.connect(this._scale);\n};\n\nTone.extend(Tone.ScaleExp, Tone.SignalBase);\n\n/**\n * Instead of interpolating linearly between the
min and\n * max values, setting the exponent will interpolate between\n * the two values with an exponential curve.\n * @memberOf Tone.ScaleExp#\n * @type {number}\n * @name exponent\n */\nObject.defineProperty(Tone.ScaleExp.prototype, \"exponent\", {\n\tget : function(){\n\t\treturn this._exp.value;\n\t},\n\tset : function(exp){\n\t\tthis._exp.value = exp;\n\t}\n});\n\n/**\n * The minimum output value. This number is output when\n * the value input value is 0.\n * @memberOf Tone.ScaleExp#\n * @type {number}\n * @name min\n */\nObject.defineProperty(Tone.ScaleExp.prototype, \"min\", {\n\tget : function(){\n\t\treturn this._scale.min;\n\t},\n\tset : function(min){\n\t\tthis._scale.min = min;\n\t}\n});\n\n/**\n * The maximum output value. This number is output when\n * the value input value is 1.\n * @memberOf Tone.ScaleExp#\n * @type {number}\n * @name max\n */\nObject.defineProperty(Tone.ScaleExp.prototype, \"max\", {\n\tget : function(){\n\t\treturn this._scale.max;\n\t},\n\tset : function(max){\n\t\tthis._scale.max = max;\n\t}\n});\n\n/**\n * Clean up.\n * @returns {Tone.ScaleExp} this\n */\nTone.ScaleExp.prototype.dispose = function(){\n\tTone.SignalBase.prototype.dispose.call(this);\n\tthis._scale.dispose();\n\tthis._scale = null;\n\tthis._exp.dispose();\n\tthis._exp = null;\n\treturn this;\n};\n\nexport default Tone.ScaleExp;\n\n","import Tone from \"../core/Tone\";\nimport \"../core/Param\";\nimport \"../core/AudioNode\";\n\n/**\n * @class Tone.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 *\n * @extends {Tone.AudioNode}\n * @constructor\n * @param {Decibels|Object} [threshold] The value above which the compression starts to be applied.\n * @param {Positive} [ratio] The gain reduction ratio.\n * @example\n * var comp = new Tone.Compressor(-30, 3);\n */\nTone.Compressor = function(){\n\n\tvar options = Tone.defaults(arguments, [\"threshold\", \"ratio\"], Tone.Compressor);\n\tTone.AudioNode.call(this);\n\n\t/**\n\t * the compressor node\n\t * @type {DynamicsCompressorNode}\n\t * @private\n\t */\n\tthis._compressor = this.input = this.output = this.context.createDynamicsCompressor();\n\n\t/**\n\t * the threshold vaue\n\t * @type {Decibels}\n\t * @signal\n\t */\n\tthis.threshold = new Tone.Param({\n\t\t\"param\" : this._compressor.threshold,\n\t\t\"units\" : Tone.Type.Decibels,\n\t\t\"convert\" : false\n\t});\n\n\t/**\n\t * The attack parameter\n\t * @type {Time}\n\t * @signal\n\t */\n\tthis.attack = new Tone.Param(this._compressor.attack, Tone.Type.Time);\n\n\t/**\n\t * The release parameter\n\t * @type {Time}\n\t * @signal\n\t */\n\tthis.release = new Tone.Param(this._compressor.release, Tone.Type.Time);\n\n\t/**\n\t * The knee parameter\n\t * @type {Decibels}\n\t * @signal\n\t */\n\tthis.knee = new Tone.Param({\n\t\t\"param\" : this._compressor.knee,\n\t\t\"units\" : Tone.Type.Decibels,\n\t\t\"convert\" : false\n\t});\n\n\t/**\n\t * The ratio value\n\t * @type {Number}\n\t * @signal\n\t */\n\tthis.ratio = new Tone.Param({\n\t\t\"param\" : this._compressor.ratio,\n\t\t\"convert\" : false\n\t});\n\n\t//set the defaults\n\tthis._readOnly([\"knee\", \"release\", \"attack\", \"ratio\", \"threshold\"]);\n\tthis.set(options);\n};\n\nTone.extend(Tone.Compressor, Tone.AudioNode);\n\n/**\n * @static\n * @const\n * @type {Object}\n */\nTone.Compressor.defaults = {\n\t\"ratio\" : 12,\n\t\"threshold\" : -24,\n\t\"release\" : 0.25,\n\t\"attack\" : 0.003,\n\t\"knee\" : 30\n};\n\n/**\n * clean up\n * @returns {Tone.Compressor} this\n */\nTone.Compressor.prototype.dispose = function(){\n\tTone.AudioNode.prototype.dispose.call(this);\n\tthis._writable([\"knee\", \"release\", \"attack\", \"ratio\", \"threshold\"]);\n\tthis._compressor.disconnect();\n\tthis._compressor = null;\n\tthis.attack.dispose();\n\tthis.attack = null;\n\tthis.release.dispose();\n\tthis.release = null;\n\tthis.threshold.dispose();\n\tthis.threshold = null;\n\tthis.ratio.dispose();\n\tthis.ratio = null;\n\tthis.knee.dispose();\n\tthis.knee = null;\n\treturn this;\n};\n\nexport default Tone.Compressor;\n\n","import Tone from \"../core/Tone\";\nimport \"../shim/OfflineAudioContext\";\n\nif (Tone.supported){\n\tif (!Tone.global.hasOwnProperty(\"AudioContext\") && Tone.global.hasOwnProperty(\"webkitAudioContext\")){\n\t\tTone.global.AudioContext = Tone.global.webkitAudioContext;\n\t}\n\n\t//not functionally equivalent, but only an API placeholder\n\tif (!AudioContext.prototype.close){\n\t\tAudioContext.prototype.close = function(){\n\t\t\tif (Tone.isFunction(this.suspend)){\n\t\t\t\tthis.suspend();\n\t\t\t}\n\t\t\treturn Promise.resolve();\n\t\t};\n\t}\n\n\t//not functionally equivalent\n\tif (!AudioContext.prototype.resume){\n\t\tAudioContext.prototype.resume = function(){\n\t\t\t//play some silent audio to jumpstart the context\n\t\t\tvar buffer = this.createBuffer(1, 1, this.sampleRate);\n\t\t\tvar source = this.createBufferSource();\n\t\t\tsource.buffer = buffer;\n\t\t\tsource.connect(this.destination);\n\t\t\tsource.start(0);\n\t\t\treturn Promise.resolve();\n\t\t};\n\t}\n\n\t//createGain\n\tif (!AudioContext.prototype.createGain && AudioContext.prototype.createGainNode){\n\t\tAudioContext.prototype.createGain = AudioContext.prototype.createGainNode;\n\t}\n\n\t//createDelay\n\tif (!AudioContext.prototype.createDelay && AudioContext.prototype.createDelayNode){\n\t\tAudioContext.prototype.createDelay = AudioContext.prototype.createDelayNode;\n\t}\n\n\t//test decodeAudioData returns a promise\n\t// https://github.com/mohayonao/web-audio-api-shim/blob/master/src/AudioContext.js\n\t// MIT License (c) 2015 @mohayonao\n\tvar decodeAudioDataPromise = false;\n\tvar offlineContext = new OfflineAudioContext(1, 1, 44100);\n\tvar audioData = new Uint32Array([1179011410, 48, 1163280727, 544501094, 16, 131073, 44100, 176400, 1048580, 1635017060, 8, 0, 0, 0, 0]).buffer;\n\ttry {\n\t\tvar ret = offlineContext.decodeAudioData(audioData);\n\t\tif (ret && Tone.isFunction(ret.then)){\n\t\t\tdecodeAudioDataPromise = true;\n\t\t}\n\t} catch (e){\n\t\tdecodeAudioDataPromise = false;\n\t}\n\n\tif (!decodeAudioDataPromise){\n\t\tAudioContext.prototype._native_decodeAudioData = AudioContext.prototype.decodeAudioData;\n\t\tAudioContext.prototype.decodeAudioData = function(audioData){\n\t\t\treturn new Promise(function(success, error){\n\t\t\t\tthis._native_decodeAudioData(audioData, success, error);\n\t\t\t}.bind(this));\n\t\t};\n\t}\n}\n\n","import Tone from \"../core/Tone\";\nimport \"../type/Time\";\n\n/**\n * @class Tone.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 * @constructor\n * @param {Time} val The time value as a number or string\n * @param {String=} units Unit values\n * @extends {Tone.Time}\n */\nTone.TransportTime = function(val, units){\n\tif (this instanceof Tone.TransportTime){\n\n\t\tTone.Time.call(this, val, units);\n\n\t} else {\n\t\treturn new Tone.TransportTime(val, units);\n\t}\n};\n\nTone.extend(Tone.TransportTime, Tone.Time);\n\n/**\n * Return the current time in whichever context is relevant\n * @type {Number}\n * @private\n */\nTone.TransportTime.prototype._now = function(){\n\treturn Tone.Transport.seconds;\n};\n\nexport default Tone.TransportTime;\n\n","import Tone from \"../core/Tone\";\nimport \"../type/TimeBase\";\n\n/**\n * @class Tone.Frequency is a primitive type for encoding Frequency values.\n * Eventually all time values are evaluated to hertz\n * using the `eval` method.\n * @constructor\n * @extends {Tone.TimeBase}\n * @param {String|Number} val The time value.\n * @param {String=} units The units of the value.\n * @example\n * Tone.Frequency(\"C3\") // 261\n * Tone.Frequency(38, \"midi\") //\n * Tone.Frequency(\"C3\").transpose(4);\n */\nTone.Frequency = function(val, units){\n\tif (this instanceof Tone.Frequency){\n\n\t\tTone.TimeBase.call(this, val, units);\n\n\t} else {\n\t\treturn new Tone.Frequency(val, units);\n\t}\n};\n\nTone.extend(Tone.Frequency, Tone.TimeBase);\n\n///////////////////////////////////////////////////////////////////////////\n//\tAUGMENT BASE EXPRESSIONS\n///////////////////////////////////////////////////////////////////////////\n\nTone.Frequency.prototype._expressions = Object.assign({}, Tone.TimeBase.prototype._expressions, {\n\t\"midi\" : {\n\t\tregexp : /^(\\d+(?:\\.\\d+)?midi)/,\n\t\tmethod : function(value){\n\t\t\tif (this._defaultUnits === \"midi\"){\n\t\t\t\treturn value;\n\t\t\t} else {\n\t\t\t\treturn Tone.Frequency.mtof(value);\n\t\t\t}\n\t\t}\n\t},\n\t\"note\" : {\n\t\tregexp : /^([a-g]{1}(?:b|#|x|bb)?)(-?[0-9]+)/i,\n\t\tmethod : function(pitch, octave){\n\t\t\tvar index = noteToScaleIndex[pitch.toLowerCase()];\n\t\t\tvar noteNumber = index + (parseInt(octave) + 1) * 12;\n\t\t\tif (this._defaultUnits === \"midi\"){\n\t\t\t\treturn noteNumber;\n\t\t\t} else {\n\t\t\t\treturn Tone.Frequency.mtof(noteNumber);\n\t\t\t}\n\t\t}\n\t},\n\t\"tr\" : {\n\t\tregexp : /^(\\d+(?:\\.\\d+)?):(\\d+(?:\\.\\d+)?):?(\\d+(?:\\.\\d+)?)?/,\n\t\tmethod : function(m, q, s){\n\t\t\tvar total = 1;\n\t\t\tif (m && m !== \"0\"){\n\t\t\t\ttotal *= this._beatsToUnits(this._getTimeSignature() * parseFloat(m));\n\t\t\t}\n\t\t\tif (q && q !== \"0\"){\n\t\t\t\ttotal *= this._beatsToUnits(parseFloat(q));\n\t\t\t}\n\t\t\tif (s && s !== \"0\"){\n\t\t\t\ttotal *= this._beatsToUnits(parseFloat(s) / 4);\n\t\t\t}\n\t\t\treturn total;\n\t\t}\n\t}\n});\n\n///////////////////////////////////////////////////////////////////////////\n//\tEXPRESSIONS\n///////////////////////////////////////////////////////////////////////////\n\n/**\n * Transposes the frequency by the given number of semitones.\n * @param {Interval} interval\n * @return {Tone.Frequency} A new transposed frequency\n * @example\n * Tone.Frequency(\"A4\").transpose(3); //\"C5\"\n */\nTone.Frequency.prototype.transpose = function(interval){\n\treturn new this.constructor(this.valueOf() * Tone.intervalToFrequencyRatio(interval));\n};\n\n/**\n * Takes an array of semitone intervals and returns\n * an array of frequencies transposed by those intervals.\n * @param {Array} intervals\n * @return {Array![](\"https://upload.wikimedia.org/wikipedia/commons/e/ea/ADSR_parameter.svg\")
\n *\n * @constructor\n * @extends {Tone.AudioNode}\n * @param {Time} [attack] The amount of time it takes for the envelope to go from\n * 0 to it's maximum value.\n * @param {Time} [decay]\tThe period of time after the attack that it takes for the envelope\n * \tto fall to the sustain value. Value must be greater than 0.\n * @param {NormalRange} [sustain]\tThe percent of the maximum value that the envelope rests at until\n * \tthe release is triggered.\n * @param {Time} [release]\tThe amount of time after the release is triggered it takes to reach 0.\n * \tValue must be greater than 0.\n * @example\n * //an amplitude envelope\n * var gainNode = Tone.context.createGain();\n * var env = new Tone.Envelope({\n * \t\"attack\" : 0.1,\n * \t\"decay\" : 0.2,\n * \t\"sustain\" : 1,\n * \t\"release\" : 0.8,\n * });\n * env.connect(gainNode.gain);\n */\nTone.Envelope = function(){\n\n\t//get all of the defaults\n\tvar options = Tone.defaults(arguments, [\"attack\", \"decay\", \"sustain\", \"release\"], Tone.Envelope);\n\tTone.AudioNode.call(this);\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 * @type {Time}\n\t */\n\tthis.attack = options.attack;\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 * @type {Time}\n\t */\n\tthis.decay = options.decay;\n\n\t/**\n\t * \tThe sustain value is the value\n\t * \twhich the envelope rests at after triggerAttack is\n\t * \tcalled, but before triggerRelease is invoked.\n\t * @type {NormalRange}\n\t */\n\tthis.sustain = options.sustain;\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 * @type {Time}\n\t */\n\tthis.release = options.release;\n\n\t/**\n\t * the next time the envelope is at standby\n\t * @type {number}\n\t * @private\n\t */\n\tthis._attackCurve = \"linear\";\n\n\t/**\n\t * the next time the envelope is at standby\n\t * @type {number}\n\t * @private\n\t */\n\tthis._releaseCurve = \"exponential\";\n\n\t/**\n\t * the signal\n\t * @type {Tone.Signal}\n\t * @private\n\t */\n\tthis._sig = this.output = new Tone.Signal(0);\n\n\t//set the attackCurve initially\n\tthis.attackCurve = options.attackCurve;\n\tthis.releaseCurve = options.releaseCurve;\n\tthis.decayCurve = options.decayCurve;\n};\n\nTone.extend(Tone.Envelope, Tone.AudioNode);\n\n/**\n * the default parameters\n * @static\n * @const\n */\nTone.Envelope.defaults = {\n\t\"attack\" : 0.01,\n\t\"decay\" : 0.1,\n\t\"sustain\" : 0.5,\n\t\"release\" : 1,\n\t\"attackCurve\" : \"linear\",\n\t\"decayCurve\" : \"exponential\",\n\t\"releaseCurve\" : \"exponential\",\n};\n\n/**\n * Read the current value of the envelope. Useful for\n * syncronizing visual output to the envelope.\n * @memberOf Tone.Envelope#\n * @type {Number}\n * @name value\n * @readOnly\n */\nObject.defineProperty(Tone.Envelope.prototype, \"value\", {\n\tget : function(){\n\t\treturn this.getValueAtTime(this.now());\n\t}\n});\n\n/**\n * Get the curve\n * @param {Array|String} curve\n * @param {String} direction In/Out\n * @return {String} The curve name\n * @private\n */\nTone.Envelope.prototype._getCurve = function(curve, direction){\n\tif (Tone.isString(curve)){\n\t\treturn curve;\n\t} else if (Tone.isArray(curve)){\n\t\t//look up the name in the curves array\n\t\tfor (var t in Tone.Envelope.Type){\n\t\t\tif (Tone.Envelope.Type[t][direction] === curve){\n\t\t\t\treturn t;\n\t\t\t}\n\t\t}\n\t}\n};\n\n/**\n * Assign a the curve to the given name using the direction\n * @param {String} name\n * @param {String} direction In/Out\n * @param {Array} curve\n * @private\n */\nTone.Envelope.prototype._setCurve = function(name, direction, curve){\n\t//check if it's a valid type\n\tif (Tone.Envelope.Type.hasOwnProperty(curve)){\n\t\tvar curveDef = Tone.Envelope.Type[curve];\n\t\tif (Tone.isObject(curveDef)){\n\t\t\tthis[name] = curveDef[direction];\n\t\t} else {\n\t\t\tthis[name] = curveDef;\n\t\t}\n\t} else if (Tone.isArray(curve)){\n\t\tthis[name] = curve;\n\t} else {\n\t\tthrow new Error(\"Tone.Envelope: invalid curve: \" + curve);\n\t}\n};\n\n/**\n * The shape of the attack.\n * Can be any of these strings:\n * - \n *
- linear \n *
- exponential \n *
- sine \n *
- cosine \n *
- bounce \n *
- ripple \n *
- step \n *
\n *
\n * Left = (Mid+Side)/sqrt(2); // obtain left signal from mid and side
\n * Right = (Mid-Side)/sqrt(2); // obtain right signal from mid and side
\n * \n *\n * @extends {Tone.AudioNode}\n * @constructor\n */\nTone.MidSideMerge = function(){\n\n\tTone.AudioNode.call(this);\n\tthis.createInsOuts(2, 0);\n\n\t/**\n\t * The mid signal input. Alias for\n\t * input[0]\n\t * @type {Tone.Gain}\n\t */\n\tthis.mid = this.input[0] = new Tone.Gain();\n\n\t/**\n\t * recombine the mid/side into Left\n\t * @type {Tone.Add}\n\t * @private\n\t */\n\tthis._left = new Tone.Add();\n\n\t/**\n\t * Multiply the left by sqrt(1/2)\n\t * @type {Tone.Multiply}\n\t */\n\tthis._timesTwoLeft = new Tone.Multiply(Math.SQRT1_2);\n\n\t/**\n\t * The side signal input. Alias for\n\t * input[1]\n\t * @type {Tone.Gain}\n\t */\n\tthis.side = this.input[1] = new Tone.Gain();\n\n\t/**\n\t * recombine the mid/side into Right\n\t * @type {Tone.Subtract}\n\t * @private\n\t */\n\tthis._right = new Tone.Subtract(/*\"($0 - $1) * $2\"*/);\n\n\t/**\n\t * Multiply the right by sqrt(1/2)\n\t * @type {Tone.Multiply}\n\t */\n\tthis._timesTwoRight = new Tone.Multiply(Math.SQRT1_2);\n\n\t/**\n\t * Merge the left/right signal back into a stereo signal.\n\t * @type {Tone.Merge}\n\t * @private\n\t */\n\tthis._merge = this.output = new Tone.Merge();\n\n\tthis.mid.connect(this._left, 0, 0);\n\tthis.side.connect(this._left, 0, 1);\n\tthis.mid.connect(this._right, 0, 0);\n\tthis.side.connect(this._right, 0, 1);\n\tthis._left.connect(this._timesTwoLeft);\n\tthis._right.connect(this._timesTwoRight);\n\tthis._timesTwoLeft.connect(this._merge, 0, 0);\n\tthis._timesTwoRight.connect(this._merge, 0, 1);\n};\n\nTone.extend(Tone.MidSideMerge, Tone.AudioNode);\n\n/**\n * clean up\n * @returns {Tone.MidSideMerge} this\n */\nTone.MidSideMerge.prototype.dispose = function(){\n\tTone.AudioNode.prototype.dispose.call(this);\n\tthis.mid.dispose();\n\tthis.mid = null;\n\tthis.side.dispose();\n\tthis.side = null;\n\tthis._left.dispose();\n\tthis._left = null;\n\tthis._timesTwoLeft.dispose();\n\tthis._timesTwoLeft = null;\n\tthis._right.dispose();\n\tthis._right = null;\n\tthis._timesTwoRight.dispose();\n\tthis._timesTwoRight = null;\n\tthis._merge.dispose();\n\tthis._merge = null;\n\treturn this;\n};\n\nexport default Tone.MidSideMerge;\n\n","import Tone from \"../core/Tone\";\nimport \"../signal/Add\";\nimport \"../signal/Subtract\";\nimport \"../signal/Signal\";\nimport \"../component/Split\";\nimport \"../core/AudioNode\";\n\n/**\n * @class 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 *
\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 righ
\n * \n *\n * @extends {Tone.AudioNode}\n * @constructor\n */\nTone.MidSideSplit = function(){\n\n\tTone.AudioNode.call(this);\n\tthis.createInsOuts(0, 2);\n\n\t/**\n\t * split the incoming signal into left and right channels\n\t * @type {Tone.Split}\n\t * @private\n\t */\n\tthis._split = this.input = new Tone.Split();\n\n\t/**\n\t * The mid send. Connect to mid processing. Alias for\n\t * output[0]\n\t * @type {Tone.Add}\n\t */\n\tthis._midAdd = new Tone.Add();\n\n\t/**\n\t * Multiply the _midAdd by sqrt(1/2)\n\t * @type {Tone.Multiply}\n\t */\n\tthis.mid = this.output[0] = new Tone.Multiply(Math.SQRT1_2);\n\n\t/**\n\t * The side output. Connect to side processing. Also Output 1\n\t * @type {Tone.Subtract}\n\t */\n\tthis._sideSubtract = new Tone.Subtract();\n\n\t/**\n\t * Multiply the _midAdd by sqrt(1/2)\n\t * @type {Tone.Multiply}\n\t */\n\tthis.side = this.output[1] = new Tone.Multiply(Math.SQRT1_2);\n\n\tthis._split.connect(this._midAdd, 0, 0);\n\tthis._split.connect(this._midAdd, 1, 1);\n\tthis._split.connect(this._sideSubtract, 0, 0);\n\tthis._split.connect(this._sideSubtract, 1, 1);\n\tthis._midAdd.connect(this.mid);\n\tthis._sideSubtract.connect(this.side);\n};\n\nTone.extend(Tone.MidSideSplit, Tone.AudioNode);\n\n/**\n * clean up\n * @returns {Tone.MidSideSplit} this\n */\nTone.MidSideSplit.prototype.dispose = function(){\n\tTone.AudioNode.prototype.dispose.call(this);\n\tthis.mid.dispose();\n\tthis.mid = null;\n\tthis.side.dispose();\n\tthis.side = null;\n\tthis._midAdd.dispose();\n\tthis._midAdd = null;\n\tthis._sideSubtract.dispose();\n\tthis._sideSubtract = null;\n\tthis._split.dispose();\n\tthis._split = null;\n\treturn this;\n};\n\nexport default Tone.MidSideSplit;\n\n","import Tone from \"../core/Tone\";\nimport \"../signal/Signal\";\nimport \"../component/Filter\";\nimport \"../core/AudioNode\";\nimport \"../component/FeedbackCombFilter\";\n\n/**\n * @class Tone.Lowpass is a lowpass feedback comb filter. It is similar to\n * Tone.FeedbackCombFilter, but includes a lowpass filter.\n *\n * @extends {Tone.AudioNode}\n * @constructor\n * @param {Time|Object} [delayTime] The delay time of the comb filter\n * @param {NormalRange=} resonance The resonance (feedback) of the comb filter\n * @param {Frequency=} dampening The cutoff of the lowpass filter dampens the\n * signal as it is fedback.\n */\nTone.LowpassCombFilter = function(){\n\n\tvar options = Tone.defaults(arguments, [\"delayTime\", \"resonance\", \"dampening\"], Tone.LowpassCombFilter);\n\tTone.AudioNode.call(this);\n\n\t/**\n\t * the delay node\n\t * @type {DelayNode}\n\t * @private\n\t */\n\tthis._combFilter = this.output = new Tone.FeedbackCombFilter(options.delayTime, options.resonance);\n\n\t/**\n\t * The delayTime of the comb filter.\n\t * @type {Time}\n\t * @signal\n\t */\n\tthis.delayTime = this._combFilter.delayTime;\n\n\t/**\n\t * the lowpass filter\n\t * @type {BiquadFilterNode}\n\t * @private\n\t */\n\tthis._lowpass = this.input = new Tone.Filter({\n\t\t\"frequency\" : options.dampening,\n\t\t\"type\" : \"lowpass\",\n\t\t\"Q\" : 0,\n\t\t\"rolloff\" : -12\n\t});\n\n\t/**\n\t * The dampening control of the feedback\n\t * @type {Frequency}\n\t * @signal\n\t */\n\tthis.dampening = this._lowpass.frequency;\n\t\n\t/**\n\t * The amount of feedback of the delayed signal.\n\t * @type {NormalRange}\n\t * @signal\n\t */\n\tthis.resonance = this._combFilter.resonance;\n\n\t//connections\n\tthis._lowpass.connect(this._combFilter);\n\tthis._readOnly([\"dampening\", \"resonance\", \"delayTime\"]);\n};\n\nTone.extend(Tone.LowpassCombFilter, Tone.AudioNode);\n\n/**\n * the default parameters\n * @static\n * @const\n * @type {Object}\n */\nTone.LowpassCombFilter.defaults = {\n\t\"delayTime\" : 0.1,\n\t\"resonance\" : 0.5,\n\t\"dampening\" : 3000\n};\n\n/**\n * Clean up.\n * @returns {Tone.LowpassCombFilter} this\n */\nTone.LowpassCombFilter.prototype.dispose = function(){\n\tTone.AudioNode.prototype.dispose.call(this);\n\tthis._writable([\"dampening\", \"resonance\", \"delayTime\"]);\n\tthis._combFilter.dispose();\n\tthis._combFilter = null;\n\tthis.resonance = null;\n\tthis.delayTime = null;\n\tthis._lowpass.dispose();\n\tthis._lowpass = null;\n\tthis.dampening = null;\n\treturn this;\n};\n\nexport default Tone.LowpassCombFilter;\n\n","import Tone from \"../core/Tone\";\nimport \"../type/TransportTime\";\n\n/**\n * @class Tone.Ticks is a primitive type for encoding Time values.\n * Tone.Ticks can be constructed with or without the `new` keyword. Tone.Ticks can be passed\n * into the parameter of any method which takes time as an argument.\n * @constructor\n * @extends {Tone.TransportTime}\n * @param {String|Number} val The time value.\n * @param {String=} units The units of the value.\n * @example\n * var t = Tone.Ticks(\"4n\");//a quarter note\n */\nTone.Ticks = function(val, units){\n\tif (this instanceof Tone.Ticks){\n\n\t\tTone.TransportTime.call(this, val, units);\n\n\t} else {\n\t\treturn new Tone.Ticks(val, units);\n\t}\n};\n\nTone.extend(Tone.Ticks, Tone.TransportTime);\n\n/**\n * The default units if none are given.\n * @type {String}\n * @private\n */\nTone.Ticks.prototype._defaultUnits = \"i\";\n\n/**\n * Get the current time in the given units\n * @return {Ticks}\n * @private\n */\nTone.Ticks.prototype._now = function(){\n\treturn Tone.Transport.ticks;\n};\n\n/**\n * Return the value of the beats in the current units\n * @param {Number} beats\n * @return {Number}\n * @private\n */\nTone.Ticks.prototype._beatsToUnits = function(beats){\n\treturn this._getPPQ() * beats;\n};\n\n/**\n * Returns the value of a second in the current units\n * @param {Seconds} seconds\n * @return {Number}\n * @private\n */\nTone.Ticks.prototype._secondsToUnits = function(seconds){\n\treturn Math.floor(seconds / (60 / this._getBpm()) * this._getPPQ());\n};\n\n/**\n * Returns the value of a tick in the current time units\n * @param {Ticks} ticks\n * @return {Number}\n * @private\n */\nTone.Ticks.prototype._ticksToUnits = function(ticks){\n\treturn ticks;\n};\n\n/**\n * Return the time in ticks\n * @return {Ticks}\n */\nTone.Ticks.prototype.toTicks = function(){\n\treturn this.valueOf();\n};\n\n/**\n * Return the time in ticks\n * @return {Ticks}\n */\nTone.Ticks.prototype.toSeconds = function(){\n\treturn (this.valueOf() / this._getPPQ()) * (60 / this._getBpm());\n};\n\nexport default Tone.Ticks;\n\n","import Tone from \"../core/Tone\";\nimport \"../type/Ticks\";\n\n/**\n * @class Tone.TransportEvent is an internal class used by (Tone.Transport)[Transport]\n * to schedule events. Do no invoke this class directly, it is\n * handled from within Tone.Transport.\n * @extends {Tone}\n * @param {Object} options\n */\nTone.TransportEvent = function(Transport, options){\n\n\toptions = Tone.defaultArg(options, Tone.TransportEvent.defaults);\n\tTone.call(this);\n\n\t/**\n\t * Reference to the Transport that created it\n\t * @type {Tone.Transport}\n\t */\n\tthis.Transport = Transport;\n\n\t/**\n\t * The unique id of the event\n\t * @type {Number}\n\t */\n\tthis.id = Tone.TransportEvent._eventId++;\n\n\t/**\n\t * The time the event starts\n\t * @type {Ticks}\n\t */\n\tthis.time = Tone.Ticks(options.time);\n\n\t/**\n\t * The callback to invoke\n\t * @type {Function}\n\t */\n\tthis.callback = options.callback;\n\n\t/**\n\t * If the event should be removed after being created.\n\t * @type {Boolean}\n\t * @private\n\t */\n\tthis._once = options.once;\n};\n\nTone.extend(Tone.TransportEvent);\n\n/**\n * The defaults\n * @static\n * @type {Object}\n */\nTone.TransportEvent.defaults = {\n\t\"once\" : false,\n\t\"callback\" : Tone.noOp,\n};\n\n/**\n * Current ID counter\n * @private\n * @static\n * @type {Number}\n */\nTone.TransportEvent._eventId = 0;\n\n/**\n * Invoke the event callback.\n * @param {Time} time The AudioContext time in seconds of the event\n */\nTone.TransportEvent.prototype.invoke = function(time){\n\tif (this.callback){\n\t\tthis.callback(time);\n\t\tif (this._once && this.Transport){\n\t\t\tthis.Transport.clear(this.id);\n\t\t}\n\t}\n};\n\n/**\n * Clean up\n * @return {Tone.TransportEvent} this\n */\nTone.TransportEvent.prototype.dispose = function(){\n\tTone.prototype.dispose.call(this);\n\tthis.Transport = null;\n\tthis.callback = null;\n\tthis.time = null;\n\treturn this;\n};\n\nexport default Tone.TransportEvent;\n\n","import Tone from \"../core/Tone\";\nimport \"../signal/TickSignal\";\nimport \"../core/TimelineState\";\nimport \"../core/Timeline\";\nimport \"../core/Param\";\n\n/**\n * @class Uses [Tone.TickSignal](TickSignal) to track elapsed ticks with\n * \t\tcomplex automation curves.\n *\n * \t@constructor\n * @extends {Tone}\n * @param {Frequency} frequency The initial frequency that the signal ticks at\n * @param {Tone.Param=} param A parameter to control (such as playbackRate)\n */\nTone.TickSource = function(){\n\n\tvar options = Tone.defaults(arguments, [\"frequency\"], Tone.TickSource);\n\n\t/**\n\t * The frequency the callback function should be invoked.\n\t * @type {Frequency}\n\t * @signal\n\t */\n\tthis.frequency = new Tone.TickSignal(options.frequency);\n\tthis._readOnly(\"frequency\");\n\n\t/**\n\t * The state timeline\n\t * @type {Tone.TimelineState}\n\t * @private\n\t */\n\tthis._state = new Tone.TimelineState(Tone.State.Stopped);\n\tthis._state.setStateAtTime(Tone.State.Stopped, 0);\n\n\t/**\n\t * The offset values of the ticks\n\t * @type {Tone.Timeline}\n\t * @private\n\t */\n\tthis._tickOffset = new Tone.Timeline();\n\t//add the first event\n\tthis.setTicksAtTime(0, 0);\n};\n\nTone.extend(Tone.TickSource);\n\n/**\n * The defaults\n * @const\n * @type {Object}\n */\nTone.TickSource.defaults = {\n\t\"frequency\" : 1,\n};\n\n/**\n * Returns the playback state of the source, either \"started\", \"stopped\" or \"paused\".\n * @type {Tone.State}\n * @readOnly\n * @memberOf Tone.TickSource#\n * @name state\n */\nObject.defineProperty(Tone.TickSource.prototype, \"state\", {\n\tget : function(){\n\t\treturn this._state.getValueAtTime(this.now());\n\t}\n});\n\n/**\n * Start the clock at the given time. Optionally pass in an offset\n * of where to start the tick counter from.\n * @param {Time=} time The time the clock should start\n * @param {Ticks} [offset=0] The number of ticks to start the source at\n * @return {Tone.TickSource} this\n */\nTone.TickSource.prototype.start = function(time, offset){\n\ttime = this.toSeconds(time);\n\tif (this._state.getValueAtTime(time) !== Tone.State.Started){\n\t\tthis._state.setStateAtTime(Tone.State.Started, time);\n\t\tif (Tone.isDefined(offset)){\n\t\t\tthis.setTicksAtTime(offset, time);\n\t\t}\n\t}\n\treturn this;\n};\n\n/**\n * Stop the clock. Stopping the clock resets the tick counter to 0.\n * @param {Time} [time=now] The time when the clock should stop.\n * @returns {Tone.TickSource} this\n * @example\n * clock.stop();\n */\nTone.TickSource.prototype.stop = function(time){\n\ttime = this.toSeconds(time);\n\t//cancel the previous stop\n\tif (this._state.getValueAtTime(time) === Tone.State.Stopped){\n\t\tvar event = this._state.get(time);\n\t\tif (event.time > 0){\n\t\t\tthis._tickOffset.cancel(event.time);\n\t\t\tthis._state.cancel(event.time);\n\t\t}\n\t}\n\tthis._state.cancel(time);\n\tthis._state.setStateAtTime(Tone.State.Stopped, time);\n\tthis.setTicksAtTime(0, time);\n\treturn this;\n};\n\n/**\n * Pause the clock. Pausing does not reset the tick counter.\n * @param {Time} [time=now] The time when the clock should stop.\n * @returns {Tone.TickSource} this\n */\nTone.TickSource.prototype.pause = function(time){\n\ttime = this.toSeconds(time);\n\tif (this._state.getValueAtTime(time) === Tone.State.Started){\n\t\tthis._state.setStateAtTime(Tone.State.Paused, time);\n\t}\n\treturn this;\n};\n\n/**\n * Cancel start/stop/pause and setTickAtTime events scheduled after the given time.\n * @param {Time} [time=now] When to clear the events after\n * @returns {Tone.TickSource} this\n */\nTone.TickSource.prototype.cancel = function(time){\n\ttime = this.toSeconds(time);\n\tthis._state.cancel(time);\n\tthis._tickOffset.cancel(time);\n\treturn this;\n};\n\n/**\n * Get the elapsed ticks at the given time\n * @param {Time} time When to get the tick value\n * @return {Ticks} The number of ticks\n */\nTone.TickSource.prototype.getTicksAtTime = function(time){\n\ttime = this.toSeconds(time);\n\tvar stopEvent = this._state.getLastState(Tone.State.Stopped, time);\n\t//this event allows forEachBetween to iterate until the current time\n\tvar tmpEvent = { state : Tone.State.Paused, time : time };\n\tthis._state.add(tmpEvent);\n\n\t//keep track of the previous offset event\n\tvar lastState = stopEvent;\n\tvar elapsedTicks = 0;\n\n\t//iterate through all the events since the last stop\n\tthis._state.forEachBetween(stopEvent.time, time + this.sampleTime, function(e){\n\t\tvar periodStartTime = lastState.time;\n\t\t//if there is an offset event in this period use that\n\t\tvar offsetEvent = this._tickOffset.get(e.time);\n\t\tif (offsetEvent.time >= lastState.time){\n\t\t\telapsedTicks = offsetEvent.ticks;\n\t\t\tperiodStartTime = offsetEvent.time;\n\t\t}\n\t\tif (lastState.state === Tone.State.Started && e.state !== Tone.State.Started){\n\t\t\telapsedTicks += this.frequency.getTicksAtTime(e.time) - this.frequency.getTicksAtTime(periodStartTime);\n\t\t} \n\t\tlastState = e;\n\t}.bind(this));\n\n\t//remove the temporary event\n\tthis._state.remove(tmpEvent);\n\n\t//return the ticks\n\treturn elapsedTicks;\n};\n\n/**\n * The number of times the callback was invoked. Starts counting at 0\n * and increments after the callback was invoked. Returns -1 when stopped.\n * @memberOf Tone.TickSource#\n * @name ticks\n * @type {Ticks}\n */\nObject.defineProperty(Tone.TickSource.prototype, \"ticks\", {\n\tget : function(){\n\t\treturn this.getTicksAtTime(this.now());\n\t},\n\tset : function(t){\n\t\tthis.setTicksAtTime(t, this.now());\n\t}\n});\n\n/**\n * The time since ticks=0 that the TickSource has been running. Accounts\n * for tempo curves\n * @memberOf Tone.TickSource#\n * @name seconds\n * @type {Seconds}\n */\nObject.defineProperty(Tone.TickSource.prototype, \"seconds\", {\n\tget : function(){\n\t\treturn this.getSecondsAtTime(this.now());\n\t},\n\tset : function(s){\n\t\tvar now = this.now();\n\t\tvar ticks = this.frequency.timeToTicks(s, now);\n\t\tthis.setTicksAtTime(ticks, now);\n\t}\n});\n\n/**\n * Return the elapsed seconds at the given time.\n * @param {Time} time When to get the elapsed seconds\n * @return {Seconds} The number of elapsed seconds\n */\nTone.TickSource.prototype.getSecondsAtTime = function(time){\n\ttime = this.toSeconds(time);\n\tvar stopEvent = this._state.getLastState(Tone.State.Stopped, time);\n\t//this event allows forEachBetween to iterate until the current time\n\tvar tmpEvent = { state : Tone.State.Paused, time : time };\n\tthis._state.add(tmpEvent);\n\n\t//keep track of the previous offset event\n\tvar lastState = stopEvent;\n\tvar elapsedSeconds = 0;\n\n\t//iterate through all the events since the last stop\n\tthis._state.forEachBetween(stopEvent.time, time + this.sampleTime, function(e){\n\t\tvar periodStartTime = lastState.time;\n\t\t//if there is an offset event in this period use that\n\t\tvar offsetEvent = this._tickOffset.get(e.time);\n\t\tif (offsetEvent.time >= lastState.time){\n\t\t\telapsedSeconds = offsetEvent.seconds;\n\t\t\tperiodStartTime = offsetEvent.time;\n\t\t}\n\t\tif (lastState.state === Tone.State.Started && e.state !== Tone.State.Started){\n\t\t\telapsedSeconds += e.time - periodStartTime;\n\t\t} \n\t\tlastState = e;\n\t}.bind(this));\n\n\t//remove the temporary event\n\tthis._state.remove(tmpEvent);\n\n\t//return the ticks\n\treturn elapsedSeconds;\n};\n\n/**\n * Set the clock's ticks at the given time.\n * @param {Ticks} ticks The tick value to set\n * @param {Time} time When to set the tick value\n * @return {Tone.TickSource} this\n */\nTone.TickSource.prototype.setTicksAtTime = function(ticks, time){\n\ttime = this.toSeconds(time);\n\tthis._tickOffset.cancel(time);\n\tthis._tickOffset.add({\n\t\t\"time\" : time,\n\t\t\"ticks\" : ticks,\n\t\t\"seconds\" : this.frequency.getDurationOfTicks(ticks, time)\n\t});\n\treturn this;\n};\n\n/**\n * Returns the scheduled state at the given time.\n * @param {Time} time The time to query.\n * @return {String} The name of the state input in setStateAtTime.\n * @example\n * source.start(\"+0.1\");\n * source.getStateAtTime(\"+0.1\"); //returns \"started\"\n */\nTone.TickSource.prototype.getStateAtTime = function(time){\n\ttime = this.toSeconds(time);\n\treturn this._state.getValueAtTime(time);\n};\n\n/**\n * Get the time of the given tick. The second argument\n * is when to test before. Since ticks can be set (with setTicksAtTime)\n * there may be multiple times for a given tick value. \n * @param {Ticks} ticks The tick number.\n * @param {Time=} before When to measure the tick value from. \n * @return {Time} The time of the tick\n */\nTone.TickSource.prototype.getTimeOfTick = function(tick, before){\n\tbefore = Tone.defaultArg(before, this.now());\n\tvar offset = this._tickOffset.get(before);\n\tvar event = this._state.get(before);\n\tvar startTime = Math.max(offset.time, event.time);\n\tvar absoluteTicks = this.frequency.getTicksAtTime(startTime) + tick - offset.ticks;\n\treturn this.frequency.getTimeOfTick(absoluteTicks);\n};\n\n/**\n * @callback forEachTickBetween\n * @param {Time} when\n * @param {Ticks} when\n */\n\n/**\n * Invoke the callback event at all scheduled ticks between the \n * start time and the end time\n * @param {Time} startTime The beginning of the search range\n * @param {Time} endTime The end of the search range\n * @param {ForEachCallback} callback The callback to invoke with each tick\n * @return {Tone.TickSource} this\n */\nTone.TickSource.prototype.forEachTickBetween = function(startTime, endTime, callback){\n\n\t//only iterate through the sections where it is \"started\"\n\tvar lastStateEvent = this._state.get(startTime);\n\tthis._state.forEachBetween(startTime, endTime, function(event){\n\t\tif (lastStateEvent.state === Tone.State.Started && event.state !== Tone.State.Started){\n\t\t\tthis.forEachTickBetween(Math.max(lastStateEvent.time, startTime), event.time - this.sampleTime, callback);\n\t\t}\n\t\tlastStateEvent = event;\n\t}.bind(this));\n\n\tstartTime = Math.max(lastStateEvent.time, startTime);\n\n\tif (lastStateEvent.state === Tone.State.Started && this._state){\n\t\t//figure out the difference between the frequency ticks and the \n\t\tvar startTicks = this.frequency.getTicksAtTime(startTime);\n\t\tvar ticksAtStart = this.frequency.getTicksAtTime(lastStateEvent.time);\n\t\tvar diff = startTicks - ticksAtStart;\n\t\tvar offset = diff % 1;\n\t\tif (offset !== 0){\n\t\t\toffset = 1 - offset;\n\t\t}\n\t\tvar nextTickTime = this.frequency.getTimeOfTick(startTicks + offset);\n\t\tvar error = null;\n\t\twhile (nextTickTime < endTime && this._state){\n\t\t\ttry {\n\t\t\t\tcallback(nextTickTime, Math.round(this.getTicksAtTime(nextTickTime)));\n\t\t\t} catch (e){\n\t\t\t\terror = e;\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tif (this._state){\n\t\t\t\tnextTickTime += this.frequency.getDurationOfTicks(1, nextTickTime);\n\t\t\t} \n\t\t}\n\t}\n\n\tif (error){\n\t\tthrow error;\n\t}\n\t\n\treturn this;\n};\n\n/**\n * Clean up\n * @returns {Tone.TickSource} this\n */\nTone.TickSource.prototype.dispose = function(){\n\tTone.Param.prototype.dispose.call(this);\n\tthis._state.dispose();\n\tthis._state = null;\n\tthis._tickOffset.dispose();\n\tthis._tickOffset = null;\n\tthis._writable(\"frequency\");\n\tthis.frequency.dispose();\n\tthis.frequency = null;\n\treturn this;\n};\n\nexport default Tone.TickSource;\n\n","import Tone from \"../core/Tone\";\nimport \"../signal/Abs\";\nimport \"../signal/Subtract\";\nimport \"../signal/Signal\";\nimport \"../type/Type\";\nimport \"../core/Delay\";\nimport \"../core/AudioNode\";\n\n/**\n * @class Tone.Follower is a crude envelope follower which will follow\n * the amplitude of an incoming signal. Read more about envelope followers (also known\n * as envelope detectors) on [Wikipedia](https://en.wikipedia.org/wiki/Envelope_detector).\n *\n * @constructor\n * @extends {Tone.AudioNode}\n * @param {Time} [smoothing=0.05] The rate of change of the follower.\n * @example\n * var follower = new Tone.Follower(0.3);\n */\nTone.Follower = function(){\n\n\tvar options = Tone.defaults(arguments, [\"smoothing\"], Tone.Follower);\n\tTone.AudioNode.call(this);\n\tthis.createInsOuts(1, 1);\n\n\t/**\n\t * @type {Tone.Abs}\n\t * @private\n\t */\n\tthis._abs = new Tone.Abs();\n\n\t/**\n\t * the lowpass filter which smooths the input\n\t * @type {BiquadFilterNode}\n\t * @private\n\t */\n\tthis._filter = this.context.createBiquadFilter();\n\tthis._filter.type = \"lowpass\";\n\tthis._filter.frequency.value = 0;\n\tthis._filter.Q.value = 0;\n\n\t/**\n\t * @type {Tone.Subtract}\n\t * @private\n\t */\n\tthis._sub = new Tone.Subtract();\n\n\t/**\n\t * delay node to compare change over time\n\t * @type {Tone.Delay}\n\t * @private\n\t */\n\tthis._delay = new Tone.Delay(this.blockTime);\n\n\t/**\n\t * the smoothing value\n\t * @private\n\t * @type {Number}\n\t */\n\tthis._smoothing = options.smoothing;\n\n\tTone.connect(this.input, this._delay);\n\tTone.connect(this.input, this._sub, 0, 1);\n\tthis._sub.chain(this._abs, this._filter, this.output);\n\n\t//set the smoothing initially\n\tthis.smoothing = options.smoothing;\n};\n\nTone.extend(Tone.Follower, Tone.AudioNode);\n\n/**\n * @static\n * @type {Object}\n */\nTone.Follower.defaults = {\n\t\"smoothing\" : 0.05,\n};\n\n/**\n * The attack time.\n * @memberOf Tone.Follower#\n * @type {Time}\n * @name smoothing\n */\nObject.defineProperty(Tone.Follower.prototype, \"smoothing\", {\n\tget : function(){\n\t\treturn this._smoothing;\n\t},\n\tset : function(smoothing){\n\t\tthis._smoothing = smoothing;\n\t\tthis._filter.frequency.value = Tone.Time(smoothing).toFrequency() * 0.5;\n\t}\n});\n\n/**\n * Borrows the connect method from Signal so that the output can be used\n * as a Tone.Signal control signal.\n * @function\n */\nTone.Follower.prototype.connect = Tone.SignalBase.prototype.connect;\n\n/**\n * dispose\n * @returns {Tone.Follower} this\n */\nTone.Follower.prototype.dispose = function(){\n\tTone.AudioNode.prototype.dispose.call(this);\n\tthis._filter.disconnect();\n\tthis._filter = null;\n\tthis._delay.dispose();\n\tthis._delay = null;\n\tthis._sub.disconnect();\n\tthis._sub = null;\n\tthis._abs.dispose();\n\tthis._abs = null;\n\treturn this;\n};\n\nexport default Tone.Follower;\n\n","import Tone from \"../core/Tone\";\nimport \"../signal/ScaleExp\";\nimport \"../signal/Signal\";\nimport \"../core/Param\";\nimport \"../core/Delay\";\nimport \"../core/Gain\";\nimport \"../core/AudioNode\";\n\n/**\n * @class 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 * @extends {Tone.AudioNode}\n * @constructor\n * @param {Time|Object} [delayTime] The delay time of the filter.\n * @param {NormalRange=} resonance The amount of feedback the filter has.\n */\nTone.FeedbackCombFilter = function(){\n\n\tvar options = Tone.defaults(arguments, [\"delayTime\", \"resonance\"], Tone.FeedbackCombFilter);\n\tTone.AudioNode.call(this);\n\n\t/**\n\t * the delay node\n\t * @type {DelayNode}\n\t * @private\n\t */\n\tthis._delay = this.input = this.output = new Tone.Delay(options.delayTime);\n\n\t/**\n\t * The amount of delay of the comb filter.\n\t * @type {Time}\n\t * @signal\n\t */\n\tthis.delayTime = this._delay.delayTime;\n\n\t/**\n\t * the feedback node\n\t * @type {GainNode}\n\t * @private\n\t */\n\tthis._feedback = new Tone.Gain(options.resonance, Tone.Type.NormalRange);\n\n\t/**\n\t * The amount of feedback of the delayed signal.\n\t * @type {NormalRange}\n\t * @signal\n\t */\n\tthis.resonance = this._feedback.gain;\n\n\tthis._delay.chain(this._feedback, this._delay);\n\tthis._readOnly([\"resonance\", \"delayTime\"]);\n};\n\nTone.extend(Tone.FeedbackCombFilter, Tone.AudioNode);\n\n/**\n * the default parameters\n * @static\n * @const\n * @type {Object}\n */\nTone.FeedbackCombFilter.defaults = {\n\t\"delayTime\" : 0.1,\n\t\"resonance\" : 0.5\n};\n\n/**\n * clean up\n * @returns {Tone.FeedbackCombFilter} this\n */\nTone.FeedbackCombFilter.prototype.dispose = function(){\n\tTone.AudioNode.prototype.dispose.call(this);\n\tthis._writable([\"resonance\", \"delayTime\"]);\n\tthis._delay.dispose();\n\tthis._delay = null;\n\tthis.delayTime = null;\n\tthis._feedback.dispose();\n\tthis._feedback = null;\n\tthis.resonance = null;\n\treturn this;\n};\n\nexport default Tone.FeedbackCombFilter;\n\n","import Tone from \"../core/Tone\";\nimport \"../component/Filter\";\nimport \"../signal/Signal\";\nimport \"../core/Gain\";\nimport \"../core/AudioNode\";\n\n/**\n * @class Split the incoming signal into three bands (low, mid, high)\n * with two crossover frequency controls.\n *\n * @extends {Tone.AudioNode}\n * @constructor\n * @param {Frequency|Object} [lowFrequency] the low/mid crossover frequency\n * @param {Frequency} [highFrequency] the mid/high crossover frequency\n */\nTone.MultibandSplit = function(){\n\n\tvar options = Tone.defaults(arguments, [\"lowFrequency\", \"highFrequency\"], Tone.MultibandSplit);\n\tTone.AudioNode.call(this);\n\n\t/**\n\t * the input\n\t * @type {Tone.Gain}\n\t * @private\n\t */\n\tthis.input = new Tone.Gain();\n\n\t/**\n\t * the outputs\n\t * @type {Array}\n\t * @private\n\t */\n\tthis.output = new Array(3);\n\n\t/**\n\t * The low band. Alias for output[0]\n\t * @type {Tone.Filter}\n\t */\n\tthis.low = this.output[0] = new Tone.Filter(0, \"lowpass\");\n\n\t/**\n\t * the lower filter of the mid band\n\t * @type {Tone.Filter}\n\t * @private\n\t */\n\tthis._lowMidFilter = new Tone.Filter(0, \"highpass\");\n\n\t/**\n\t * The mid band output. Alias for output[1]\n\t * @type {Tone.Filter}\n\t */\n\tthis.mid = this.output[1] = new Tone.Filter(0, \"lowpass\");\n\n\t/**\n\t * The high band output. Alias for output[2]\n\t * @type {Tone.Filter}\n\t */\n\tthis.high = this.output[2] = new Tone.Filter(0, \"highpass\");\n\n\t/**\n\t * The low/mid crossover frequency.\n\t * @type {Frequency}\n\t * @signal\n\t */\n\tthis.lowFrequency = new Tone.Signal(options.lowFrequency, Tone.Type.Frequency);\n\n\t/**\n\t * The mid/high crossover frequency.\n\t * @type {Frequency}\n\t * @signal\n\t */\n\tthis.highFrequency = new Tone.Signal(options.highFrequency, Tone.Type.Frequency);\n\n\t/**\n\t * The quality of all the filters\n\t * @type {Number}\n\t * @signal\n\t */\n\tthis.Q = new Tone.Signal(options.Q);\n\n\tthis.input.fan(this.low, this.high);\n\tthis.input.chain(this._lowMidFilter, this.mid);\n\t//the frequency control signal\n\tthis.lowFrequency.connect(this.low.frequency);\n\tthis.lowFrequency.connect(this._lowMidFilter.frequency);\n\tthis.highFrequency.connect(this.mid.frequency);\n\tthis.highFrequency.connect(this.high.frequency);\n\t//the Q value\n\tthis.Q.connect(this.low.Q);\n\tthis.Q.connect(this._lowMidFilter.Q);\n\tthis.Q.connect(this.mid.Q);\n\tthis.Q.connect(this.high.Q);\n\n\tthis._readOnly([\"high\", \"mid\", \"low\", \"highFrequency\", \"lowFrequency\"]);\n};\n\nTone.extend(Tone.MultibandSplit, Tone.AudioNode);\n\n/**\n * @private\n * @static\n * @type {Object}\n */\nTone.MultibandSplit.defaults = {\n\t\"lowFrequency\" : 400,\n\t\"highFrequency\" : 2500,\n\t\"Q\" : 1,\n};\n\n/**\n * Clean up.\n * @returns {Tone.MultibandSplit} this\n */\nTone.MultibandSplit.prototype.dispose = function(){\n\tTone.AudioNode.prototype.dispose.call(this);\n\tthis._writable([\"high\", \"mid\", \"low\", \"highFrequency\", \"lowFrequency\"]);\n\tthis.low.dispose();\n\tthis.low = null;\n\tthis._lowMidFilter.dispose();\n\tthis._lowMidFilter = null;\n\tthis.mid.dispose();\n\tthis.mid = null;\n\tthis.high.dispose();\n\tthis.high = null;\n\tthis.lowFrequency.dispose();\n\tthis.lowFrequency = null;\n\tthis.highFrequency.dispose();\n\tthis.highFrequency = null;\n\tthis.Q.dispose();\n\tthis.Q = null;\n\treturn this;\n};\n\nexport default Tone.MultibandSplit;\n\n","import Tone from \"../core/Tone\";\nimport \"../signal/WaveShaper\";\n\n/**\n * @class Pow applies an exponent to the incoming signal. The incoming signal\n * must be AudioRange.\n *\n * @extends {Tone.SignalBase}\n * @constructor\n * @param {Positive} exp The exponent to apply to the incoming signal, must be at least 2. \n * @example\n * var pow = new Tone.Pow(2);\n * var sig = new Tone.Signal(0.5).connect(pow);\n * //output of pow is 0.25. \n */\nTone.Pow = function(exp){\n\n\tTone.SignalBase.call(this);\n\t\n\t/**\n\t * the exponent\n\t * @private\n\t * @type {number}\n\t */\n\tthis._exp = Tone.defaultArg(exp, 1);\n\n\t/**\n\t * @type {WaveShaperNode}\n\t * @private\n\t */\n\tthis._expScaler = this.input = this.output = new Tone.WaveShaper(this._expFunc(this._exp), 8192);\n};\n\nTone.extend(Tone.Pow, Tone.SignalBase);\n\n/**\n * The value of the exponent.\n * @memberOf Tone.Pow#\n * @type {number}\n * @name value\n */\nObject.defineProperty(Tone.Pow.prototype, \"value\", {\n\tget : function(){\n\t\treturn this._exp;\n\t},\n\tset : function(exp){\n\t\tthis._exp = exp;\n\t\tthis._expScaler.setMap(this._expFunc(this._exp));\n\t}\n});\n\n/**\n * the function which maps the waveshaper\n * @param {number} exp\n * @return {function}\n * @private\n */\nTone.Pow.prototype._expFunc = function(exp){\n\treturn function(val){\n\t\treturn Math.pow(Math.abs(val), exp);\n\t};\n};\n\n/**\n * Clean up.\n * @returns {Tone.Pow} this\n */\nTone.Pow.prototype.dispose = function(){\n\tTone.SignalBase.prototype.dispose.call(this);\n\tthis._expScaler.dispose();\n\tthis._expScaler = null;\n\treturn this;\n};\n\nexport default Tone.Pow;\n\n","import Tone from \"../core/Tone\";\n\n/**\n * @class Tone.TimeBase is a flexible encoding of time\n * which can be evaluated to and from a string.\n * @extends {Tone}\n * @param {Time} val The time value as a number, string or object\n * @param {String=} units Unit values\n * @example\n * Tone.TimeBase(4, \"n\")\n * Tone.TimeBase(2, \"t\")\n * Tone.TimeBase(\"2t\")\n * Tone.TimeBase({\"2t\" : 2})\n * Tone.TimeBase(\"2t\") + Tone.TimeBase(\"4n\");\n */\nTone.TimeBase = function(val, units){\n\n\t//allows it to be constructed with or without 'new'\n\tif (this instanceof Tone.TimeBase){\n\n\t\t/**\n\t\t * The value\n\t\t * @type {Number|String|Tone.TimeBase}\n\t\t * @private\n\t\t */\n\t\tthis._val = val;\n\n\t\t/**\n\t\t * The units\n\t\t * @type {String?}\n\t\t * @private\n\t\t */\n\t\tthis._units = units;\n\n\t\t//test if the value is a string representation of a number\n\t\tif (Tone.isUndef(this._units) && Tone.isString(this._val) &&\n\t\t\t// eslint-disable-next-line eqeqeq\n\t\t\tparseFloat(this._val) == this._val && this._val.charAt(0) !== \"+\"){\n\t\t\tthis._val = parseFloat(this._val);\n\t\t\tthis._units = this._defaultUnits;\n\t\t} else if (val && val.constructor === this.constructor){\n\t\t\t//if they're the same type, just copy values over\n\t\t\tthis._val = val._val;\n\t\t\tthis._units = val._units;\n\t\t} else if (val instanceof Tone.TimeBase){\n\t\t\tswitch (this._defaultUnits){\n\t\t\t\tcase \"s\" :\n\t\t\t\t\tthis._val = val.toSeconds();\n\t\t\t\t\tbreak;\n\t\t\t\tcase \"i\" :\n\t\t\t\t\tthis._val = val.toTicks();\n\t\t\t\t\tbreak;\n\t\t\t\tcase \"hz\" :\n\t\t\t\t\tthis._val = val.toFrequency();\n\t\t\t\t\tbreak;\n\t\t\t\tcase \"midi\" :\n\t\t\t\t\tthis._val = val.toMidi();\n\t\t\t\t\tbreak;\n\t\t\t\tdefault :\n\t\t\t\t\tthrow new Error(\"Unrecognized default units \"+this._defaultUnits);\n\t\t\t}\n\t\t}\n\n\t} else {\n\n\t\treturn new Tone.TimeBase(val, units);\n\t}\n};\n\nTone.extend(Tone.TimeBase);\n\n///////////////////////////////////////////////////////////////////////////\n//\tABSTRACT SYNTAX TREE PARSER\n///////////////////////////////////////////////////////////////////////////\n\n/**\n * All the primary expressions.\n * @private\n * @type {Object}\n */\nTone.TimeBase.prototype._expressions = {\n\t\"n\" : {\n\t\tregexp : /^(\\d+)n(\\.?)$/i,\n\t\tmethod : function(value, dot){\n\t\t\tvalue = parseInt(value);\n\t\t\tvar scalar = dot === \".\" ? 1.5 : 1;\n\t\t\tif (value === 1){\n\t\t\t\treturn this._beatsToUnits(this._getTimeSignature())*scalar;\n\t\t\t} else {\n\t\t\t\treturn this._beatsToUnits(4 / value)*scalar;\n\t\t\t}\n\t\t}\n\t},\n\t\"t\" : {\n\t\tregexp : /^(\\d+)t$/i,\n\t\tmethod : function(value){\n\t\t\tvalue = parseInt(value);\n\t\t\treturn this._beatsToUnits(8 / (parseInt(value) * 3));\n\t\t}\n\t},\n\t\"m\" : {\n\t\tregexp : /^(\\d+)m$/i,\n\t\tmethod : function(value){\n\t\t\treturn this._beatsToUnits(parseInt(value) * this._getTimeSignature());\n\t\t}\n\t},\n\t\"i\" : {\n\t\tregexp : /^(\\d+)i$/i,\n\t\tmethod : function(value){\n\t\t\treturn this._ticksToUnits(parseInt(value));\n\t\t}\n\t},\n\t\"hz\" : {\n\t\tregexp : /^(\\d+(?:\\.\\d+)?)hz$/i,\n\t\tmethod : function(value){\n\t\t\treturn this._frequencyToUnits(parseFloat(value));\n\t\t}\n\t},\n\t\"tr\" : {\n\t\tregexp : /^(\\d+(?:\\.\\d+)?):(\\d+(?:\\.\\d+)?):?(\\d+(?:\\.\\d+)?)?$/,\n\t\tmethod : function(m, q, s){\n\t\t\tvar total = 0;\n\t\t\tif (m && m !== \"0\"){\n\t\t\t\ttotal += this._beatsToUnits(this._getTimeSignature() * parseFloat(m));\n\t\t\t}\n\t\t\tif (q && q !== \"0\"){\n\t\t\t\ttotal += this._beatsToUnits(parseFloat(q));\n\t\t\t}\n\t\t\tif (s && s !== \"0\"){\n\t\t\t\ttotal += this._beatsToUnits(parseFloat(s) / 4);\n\t\t\t}\n\t\t\treturn total;\n\t\t}\n\t},\n\t\"s\" : {\n\t\tregexp : /^(\\d+(?:\\.\\d+)?)s$/,\n\t\tmethod : function(value){\n\t\t\treturn this._secondsToUnits(parseFloat(value));\n\t\t}\n\t},\n\t\"samples\" : {\n\t\tregexp : /^(\\d+)samples$/,\n\t\tmethod : function(value){\n\t\t\treturn parseInt(value) / this.context.sampleRate;\n\t\t}\n\t},\n\t\"default\" : {\n\t\tregexp : /^(\\d+(?:\\.\\d+)?)$/,\n\t\tmethod : function(value){\n\t\t\treturn this._expressions[this._defaultUnits].method.call(this, value);\n\t\t}\n\t}\n};\n\n/**\n * The default units if none are given.\n * @type {String}\n * @private\n */\nTone.TimeBase.prototype._defaultUnits = \"s\";\n\n///////////////////////////////////////////////////////////////////////////\n//\tTRANSPORT FALLBACKS\n///////////////////////////////////////////////////////////////////////////\n\n/**\n * Return the bpm, or 120 if Transport is not available\n * @type {Number}\n * @private\n */\nTone.TimeBase.prototype._getBpm = function(){\n\tif (Tone.Transport){\n\t\treturn Tone.Transport.bpm.value;\n\t} else {\n\t\treturn 120;\n\t}\n};\n\n/**\n * Return the timeSignature or 4 if Transport is not available\n * @type {Number}\n * @private\n */\nTone.TimeBase.prototype._getTimeSignature = function(){\n\tif (Tone.Transport){\n\t\treturn Tone.Transport.timeSignature;\n\t} else {\n\t\treturn 4;\n\t}\n};\n\n/**\n * Return the PPQ or 192 if Transport is not available\n * @type {Number}\n * @private\n */\nTone.TimeBase.prototype._getPPQ = function(){\n\tif (Tone.Transport){\n\t\treturn Tone.Transport.PPQ;\n\t} else {\n\t\treturn 192;\n\t}\n};\n\n/**\n * Return the current time in whichever context is relevant\n * @type {Number}\n * @private\n */\nTone.TimeBase.prototype._now = function(){\n\treturn this.now();\n};\n\n///////////////////////////////////////////////////////////////////////////\n//\tUNIT CONVERSIONS\n///////////////////////////////////////////////////////////////////////////\n\n/**\n * Returns the value of a frequency in the current units\n * @param {Frequency} freq\n * @return {Number}\n * @private\n */\nTone.TimeBase.prototype._frequencyToUnits = function(freq){\n\treturn 1/freq;\n};\n\n/**\n * Return the value of the beats in the current units\n * @param {Number} beats\n * @return {Number}\n * @private\n */\nTone.TimeBase.prototype._beatsToUnits = function(beats){\n\treturn (60 / this._getBpm()) * beats;\n};\n\n/**\n * Returns the value of a second in the current units\n * @param {Seconds} seconds\n * @return {Number}\n * @private\n */\nTone.TimeBase.prototype._secondsToUnits = function(seconds){\n\treturn seconds;\n};\n\n/**\n * Returns the value of a tick in the current time units\n * @param {Ticks} ticks\n * @return {Number}\n * @private\n */\nTone.TimeBase.prototype._ticksToUnits = function(ticks){\n\treturn ticks * (this._beatsToUnits(1) / this._getPPQ());\n};\n\n/**\n * With no arguments, return 'now'\n * @return {Number}\n * @private\n */\nTone.TimeBase.prototype._noArg = function(){\n\treturn this._now();\n};\n\n///////////////////////////////////////////////////////////////////////////\n//\tEXPRESSIONS\n///////////////////////////////////////////////////////////////////////////\n\n/**\n * Evaluate the time value. Returns the time\n * in seconds.\n * @return {Seconds}\n */\nTone.TimeBase.prototype.valueOf = function(){\n\tif (Tone.isUndef(this._val)){\n\t\treturn this._noArg();\n\t} else if (Tone.isString(this._val) && Tone.isUndef(this._units)){\n\t\tfor (var units in this._expressions){\n\t\t\tif (this._expressions[units].regexp.test(this._val.trim())){\n\t\t\t\tthis._units = units;\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\t} else if (Tone.isObject(this._val)){\n\t\tvar total = 0;\n\t\tfor (var typeName in this._val){\n\t\t\tvar quantity = this._val[typeName];\n\t\t\tvar time = (new this.constructor(typeName)).valueOf() * quantity;\n\t\t\ttotal += time;\n\t\t}\n\t\treturn total;\n\t}\n\tif (Tone.isDefined(this._units)){\n\t\tvar expr = this._expressions[this._units];\n\t\tvar matching = this._val.toString().trim().match(expr.regexp);\n\t\tif (matching){\n\t\t\treturn expr.method.apply(this, matching.slice(1));\n\t\t} else {\n\t\t\treturn expr.method.call(this, parseFloat(this._val));\n\t\t}\n\t} else {\n\t\treturn this._val;\n\t}\n};\n\n/**\n * Return the value in seconds\n * @return {Seconds}\n */\nTone.TimeBase.prototype.toSeconds = function(){\n\treturn this.valueOf();\n};\n\n/**\n * Return the value in hertz\n * @return {Frequency}\n */\nTone.TimeBase.prototype.toFrequency = function(){\n\treturn 1 / this.toSeconds();\n};\n\n/**\n * Return the time in samples\n * @return {Samples}\n */\nTone.TimeBase.prototype.toSamples = function(){\n\treturn this.toSeconds() * this.context.sampleRate;\n};\n\n/**\n * Return the time in milliseconds.\n * @return {Milliseconds}\n */\nTone.TimeBase.prototype.toMilliseconds = function(){\n\treturn this.toSeconds() * 1000;\n};\n\n/**\n * Clean up\n * @return {Tone.TimeBase} this\n */\nTone.TimeBase.prototype.dispose = function(){\n\tthis._val = null;\n\tthis._units = null;\n};\n\nexport default Tone.TimeBase;\n\n","import Tone from \"../core/Tone\";\nimport \"../type/TimeBase\";\nimport \"../type/Frequency\";\n\n/**\n * @class Tone.Time is a primitive type for encoding Time values.\n * Tone.Time can be constructed with or without the `new` keyword. Tone.Time can be passed\n * into the parameter of any method which takes time as an argument.\n * @constructor\n * @extends {Tone.TimeBase}\n * @param {String|Number|Object} val The time value.\n * @param {String=} units The units of the value.\n * @example\n * var t = Tone.Time(\"4n\");//a quarter note\n */\nTone.Time = function(val, units){\n\tif (this instanceof Tone.Time){\n\n\t\tTone.TimeBase.call(this, val, units);\n\n\t} else {\n\t\treturn new Tone.Time(val, units);\n\t}\n};\n\nTone.extend(Tone.Time, Tone.TimeBase);\n\n/**\n * Extend the base expressions\n */\nTone.Time.prototype._expressions = Object.assign({}, Tone.TimeBase.prototype._expressions, {\n\t\"quantize\" : {\n\t\tregexp : /^@(.+)/,\n\t\tmethod : function(capture){\n\t\t\tif (Tone.Transport){\n\t\t\t\tvar quantTo = new this.constructor(capture);\n\t\t\t\treturn this._secondsToUnits(Tone.Transport.nextSubdivision(quantTo));\n\t\t\t} else {\n\t\t\t\treturn 0;\n\t\t\t}\n\t\t}\n\t},\n\t\"now\" : {\n\t\tregexp : /^\\+(.+)/,\n\t\tmethod : function(capture){\n\t\t\treturn this._now() + (new this.constructor(capture));\n\t\t}\n\t}\n});\n\n/**\n * Quantize the time by the given subdivision. Optionally add a\n * percentage which will move the time value towards the ideal\n * quantized value by that percentage.\n * @param {Number|Time} val The subdivision to quantize to\n * @param {NormalRange} [percent=1] Move the time value\n * towards the quantized value by\n * a percentage.\n * @return {Number} this\n * @example\n * Tone.Time(21).quantize(2) //returns 22\n * Tone.Time(0.6).quantize(\"4n\", 0.5) //returns 0.55\n */\nTone.Time.prototype.quantize = function(subdiv, percent){\n\tpercent = Tone.defaultArg(percent, 1);\n\tvar subdivision = new this.constructor(subdiv);\n\tvar value = this.valueOf();\n\tvar multiple = Math.round(value / subdivision);\n\tvar ideal = multiple * subdivision;\n\tvar diff = ideal - value;\n\treturn value + diff * percent;\n};\n\n///////////////////////////////////////////////////////////////////////////\n// CONVERSIONS\n///////////////////////////////////////////////////////////////////////////\n\n/**\n * Convert a Time to Notation. The notation values are will be the\n * closest representation between 1m to 128th note.\n * @return {Notation}\n * @example\n * //if the Transport is at 120bpm:\n * Tone.Time(2).toNotation();//returns \"1m\"\n */\nTone.Time.prototype.toNotation = function(){\n\tvar time = this.toSeconds();\n\tvar testNotations = [\"1m\"];\n\tfor (var power = 1; power < 8; power++){\n\t\tvar subdiv = Math.pow(2, power);\n\t\ttestNotations.push(subdiv + \"n.\");\n\t\ttestNotations.push(subdiv + \"n\");\n\t\ttestNotations.push(subdiv + \"t\");\n\t}\n\ttestNotations.push(\"0\");\n\t//find the closets notation representation\n\tvar closest = testNotations[0];\n\tvar closestSeconds = Tone.Time(testNotations[0]).toSeconds();\n\ttestNotations.forEach(function(notation){\n\t\tvar notationSeconds = Tone.Time(notation).toSeconds();\n\t\tif (Math.abs(notationSeconds - time) < Math.abs(closestSeconds - time)){\n\t\t\tclosest = notation;\n\t\t\tclosestSeconds = notationSeconds;\n\t\t}\n\t});\n\treturn closest;\n};\n\n/**\n * Return the time encoded as Bars:Beats:Sixteenths.\n * @return {BarsBeatsSixteenths}\n */\nTone.Time.prototype.toBarsBeatsSixteenths = function(){\n\tvar quarterTime = this._beatsToUnits(1);\n\tvar quarters = this.valueOf() / quarterTime;\n\tquarters = parseFloat(quarters.toFixed(4));\n\tvar measures = Math.floor(quarters / this._getTimeSignature());\n\tvar sixteenths = (quarters % 1) * 4;\n\tquarters = Math.floor(quarters) % this._getTimeSignature();\n\tsixteenths = sixteenths.toString();\n\tif (sixteenths.length > 3){\n\t\t// the additional parseFloat removes insignificant trailing zeroes\n\t\tsixteenths = parseFloat(parseFloat(sixteenths).toFixed(3));\n\t}\n\tvar progress = [measures, quarters, sixteenths];\n\treturn progress.join(\":\");\n};\n\n/**\n * Return the time in ticks.\n * @return {Ticks}\n */\nTone.Time.prototype.toTicks = function(){\n\tvar quarterTime = this._beatsToUnits(1);\n\tvar quarters = this.valueOf() / quarterTime;\n\treturn Math.round(quarters * this._getPPQ());\n};\n\n/**\n * Return the time in seconds.\n * @return {Seconds}\n */\nTone.Time.prototype.toSeconds = function(){\n\treturn this.valueOf();\n};\n\n/**\n * Return the value as a midi note.\n * @return {Midi}\n */\nTone.Time.prototype.toMidi = function(){\n\treturn Tone.Frequency.ftom(this.toFrequency());\n};\n\nexport default Tone.Time;\n\n","import Tone from \"../core/Tone\";\n\nif (Tone.supported){\n\tif (!OscillatorNode.prototype.setPeriodicWave){\n\t\tOscillatorNode.prototype.setPeriodicWave = OscillatorNode.prototype.setWaveTable;\n\t}\n\tif (!AudioContext.prototype.createPeriodicWave){\n\t\tAudioContext.prototype.createPeriodicWave = AudioContext.prototype.createWaveTable;\n\t}\n}\n\n","import Tone from \"../core/Tone\";\nimport \"../core/Buffer\";\nimport \"../source/Source\";\nimport \"../core/Gain\";\nimport \"../core/AudioNode\";\nimport \"../shim/OscillatorNode\";\n\n/**\n * @class Wrapper around the native fire-and-forget OscillatorNode. Adds the\n * ability to reschedule the stop method. ***[Tone.Oscillator](Oscillator) is better \n * for most use-cases***\n * @extends {Tone.AudioNode}\n * @param {AudioBuffer|Tone.Buffer} buffer The buffer to play\n * @param {Function} onload The callback to invoke when the\n * buffer is done playing.\n */\nTone.OscillatorNode = function(){\n\n\tvar options = Tone.defaults(arguments, [\"frequency\", \"type\"], Tone.OscillatorNode);\n\tTone.AudioNode.call(this, options);\n\n\t/**\n\t * The callback to invoke after the\n\t * buffer source is done playing.\n\t * @type {Function}\n\t */\n\tthis.onended = options.onended;\n\n\t/**\n\t * The oscillator start time\n\t * @type {Number}\n\t * @private\n\t */\n\tthis._startTime = -1;\n\n\t/**\n\t * The oscillator stop time\n\t * @type {Number}\n\t * @private\n\t */\n\tthis._stopTime = -1;\n\n\t/**\n\t * The gain node which envelopes the OscillatorNode\n\t * @type {Tone.Gain}\n\t * @private\n\t */\n\tthis._gainNode = this.output = new Tone.Gain(0);\n\n\t/**\n\t * The oscillator\n\t * @type {OscillatorNode}\n\t * @private\n\t */\n\tthis._oscillator = this.context.createOscillator();\n\tTone.connect(this._oscillator, this._gainNode);\n\tthis.type = options.type;\n\n\t/**\n\t * The frequency of the oscillator\n\t * @type {Frequency}\n\t * @signal\n\t */\n\tthis.frequency = new Tone.Param({\n\t\tparam : this._oscillator.frequency, \n\t\tunits : Tone.Type.Frequency,\n\t\tvalue : options.frequency\n\t});\n\n\t/**\n\t * The detune of the oscillator\n\t * @type {Frequency}\n\t * @signal\n\t */\n\tthis.detune = new Tone.Param({\n\t\tparam : this._oscillator.detune,\n\t\tunits : Tone.Type.Cents,\n\t\tvalue : options.detune\n\t});\n\n\t/**\n\t * The value that the buffer ramps to\n\t * @type {Gain}\n\t * @private\n\t */\n\tthis._gain = 1;\n};\n\nTone.extend(Tone.OscillatorNode, Tone.AudioNode);\n\n/**\n * The defaults\n * @const\n * @type {Object}\n */\nTone.OscillatorNode.defaults = {\n\t\"frequency\" : 440,\n\t\"detune\" : 0,\n\t\"type\" : \"sine\",\n\t\"onended\" : Tone.noOp\n};\n\n/**\n * Returns the playback state of the oscillator, either \"started\" or \"stopped\".\n * @type {Tone.State}\n * @readOnly\n * @memberOf Tone.OscillatorNode#\n * @name state\n */\nObject.defineProperty(Tone.OscillatorNode.prototype, \"state\", {\n\tget : function(){\n\t\treturn this.getStateAtTime(this.now());\n\t}\n});\n\n/**\n * Get the playback state at the given time\n * @param {Time} time The time to test the state at\n * @return {Tone.State} The playback state. \n */\nTone.OscillatorNode.prototype.getStateAtTime = function(time){\n\ttime = this.toSeconds(time);\n\tif (this._startTime !== -1 && time >= this._startTime && (this._stopTime === -1 || time <= this._stopTime)){\n\t\treturn Tone.State.Started;\n\t} else {\n\t\treturn Tone.State.Stopped;\n\t}\n};\n\n/**\n * Start the oscillator node at the given time\n * @param {Time=} time When to start the oscillator\n * @return {OscillatorNode} this\n */\nTone.OscillatorNode.prototype.start = function(time){\n\tthis.log(\"start\", time);\n\tif (this._startTime === -1){\n\t\tthis._startTime = this.toSeconds(time);\n\t\tthis._startTime = Math.max(this._startTime, this.context.currentTime);\n\t\tthis._oscillator.start(this._startTime);\n\t\tthis._gainNode.gain.setValueAtTime(1, this._startTime);\n\t} else {\n\t\tthrow new Error(\"cannot call OscillatorNode.start more than once\");\n\t}\n\treturn this;\n};\n\n/**\n * Sets an arbitrary custom periodic waveform given a PeriodicWave.\n * @param {PeriodicWave} periodicWave PeriodicWave should be created with context.createPeriodicWave\n * @return {OscillatorNode} this\n */\nTone.OscillatorNode.prototype.setPeriodicWave = function(periodicWave){\n\tthis._oscillator.setPeriodicWave(periodicWave);\n\treturn this;\n};\n\n/**\n * Stop the oscillator node at the given time\n * @param {Time=} time When to stop the oscillator\n * @return {OscillatorNode} this\n */\nTone.OscillatorNode.prototype.stop = function(time){\n\tthis.log(\"stop\", time);\n\tthis.assert(this._startTime !== -1, \"'start' must be called before 'stop'\");\n\t//cancel the previous stop\n\tthis.cancelStop();\n\t//reschedule it\n\tthis._stopTime = this.toSeconds(time);\n\tthis._stopTime = Math.max(this._stopTime, this.context.currentTime);\n\tif (this._stopTime > this._startTime){\n\t\tthis._gainNode.gain.setValueAtTime(0, this._stopTime);\n\t\tthis.context.clearTimeout(this._timeout);\n\t\tthis._timeout = this.context.setTimeout(function(){\n\t\t\tthis._oscillator.stop(this.now());\n\t\t\tthis.onended();\n\t\t\t//disconnect the object when it's ended\n\t\t\tsetTimeout(function(){\n\t\t\t\tif (this._oscillator){\n\t\t\t\t\tthis._oscillator.disconnect();\n\t\t\t\t\tthis._gainNode.disconnect();\n\t\t\t\t}\n\t\t\t}.bind(this), 100);\n\t\t}.bind(this), this._stopTime - this.context.currentTime);\n\t} else {\n\t\t//cancel the stop envelope\n\t\tthis._gainNode.gain.cancelScheduledValues(this._startTime);\n\t}\n\treturn this;\n};\n\n/**\n * Cancel a scheduled stop event\n * @return {Tone.OscillatorNode} this\n */\nTone.OscillatorNode.prototype.cancelStop = function(){\n\tif (this._startTime !== -1){\n\t\t//cancel the stop envelope\n\t\tthis._gainNode.gain.cancelScheduledValues(this._startTime+this.sampleTime);\n\t\tthis.context.clearTimeout(this._timeout);\n\t\tthis._stopTime = -1;\n\t}\n\treturn this;\n};\n\n/**\n * The oscillator type. Either 'sine', 'sawtooth', 'square', or 'triangle'\n * @memberOf Tone.OscillatorNode#\n * @type {Time}\n * @name type\n */\nObject.defineProperty(Tone.OscillatorNode.prototype, \"type\", {\n\tget : function(){\n\t\treturn this._oscillator.type;\n\t},\n\tset : function(type){\n\t\tthis._oscillator.type = type;\n\t}\n});\n\n/**\n * Clean up.\n * @return {Tone.OscillatorNode} this\n */\nTone.OscillatorNode.prototype.dispose = function(){\n\tif (!this._wasDisposed){\n\t\tthis._wasDisposed = true;\n\t\tthis.context.clearTimeout(this._timeout);\n\t\tTone.AudioNode.prototype.dispose.call(this);\n\t\tthis.onended = null;\n\t\tthis._oscillator.disconnect();\n\t\tthis._oscillator = null;\n\t\tthis._gainNode.dispose();\n\t\tthis._gainNode = null;\n\t\tthis.frequency.dispose();\n\t\tthis.frequency = null;\n\t\tthis.detune.dispose();\n\t\tthis.detune = null;\n\t}\n\treturn this;\n};\n\nexport default Tone.OscillatorNode;\n\n","import Tone from \"../core/Tone\";\nimport \"../core/Buffer\";\nimport \"../source/Source\";\nimport \"../source/TickSource\";\nimport \"../source/BufferSource\";\n\n/**\n * @class Tone.Player is an audio file player with start, loop, and stop functions.\n *\n * @constructor\n * @extends {Tone.Source}\n * @param {string|AudioBuffer} url Either the AudioBuffer or the url from\n * which to load the AudioBuffer\n * @param {Function=} onload The function to invoke when the buffer is loaded.\n * Recommended to use Tone.Buffer.on('load') instead.\n * @example\n * var player = new Tone.Player(\"./path/to/sample.mp3\").toMaster();\n * //play as soon as the buffer is loaded\n * player.autostart = true;\n */\nTone.Player = function(url){\n\n\tvar options;\n\tif (url instanceof Tone.Buffer && url.loaded){\n\t\turl = url.get();\n\t\toptions = Tone.Player.defaults;\n\t} else {\n\t\toptions = Tone.defaults(arguments, [\"url\", \"onload\"], Tone.Player);\n\t}\n\tTone.Source.call(this, options);\n\n\t/**\n\t * If the file should play as soon\n\t * as the buffer is loaded.\n\t * @type {Boolean}\n\t * @example\n\t * //will play as soon as it's loaded\n\t * var player = new Tone.Player({\n\t * \t\"url\" : \"./path/to/sample.mp3\",\n\t * \t\"autostart\" : true,\n\t * }).toMaster();\n\t */\n\tthis.autostart = options.autostart;\n\n\t/**\n\t * the buffer\n\t * @private\n\t * @type {Tone.Buffer}\n\t */\n\tthis._buffer = new Tone.Buffer({\n\t\t\"url\" : options.url,\n\t\t\"onload\" : this._onload.bind(this, options.onload),\n\t\t\"reverse\" : options.reverse\n\t});\n\tif (url instanceof AudioBuffer){\n\t\tthis._buffer.set(url);\n\t}\n\n\t/**\n\t * if the buffer should loop once it's over\n\t * @type {Boolean}\n\t * @private\n\t */\n\tthis._loop = options.loop;\n\n\t/**\n\t * if 'loop' is true, the loop will start at this position\n\t * @type {Time}\n\t * @private\n\t */\n\tthis._loopStart = options.loopStart;\n\n\t/**\n\t * if 'loop' is true, the loop will end at this position\n\t * @type {Time}\n\t * @private\n\t */\n\tthis._loopEnd = options.loopEnd;\n\n\t/**\n\t * the playback rate\n\t * @private\n\t * @type {Number}\n\t */\n\tthis._playbackRate = options.playbackRate;\n\n\t/**\n\t * All of the active buffer source nodes\n\t * @type {Array\n * This is a base-class for Mid/Side Effects.\n *\n * @extends {Tone.Effect}\n * @constructor\n */\nTone.MidSideEffect = function(){\n\n\tTone.Effect.apply(this, arguments);\n\n\t/**\n\t * The mid/side split\n\t * @type {Tone.MidSideSplit}\n\t * @private\n\t */\n\tthis._midSideSplit = new Tone.MidSideSplit();\n\n\t/**\n\t * The mid/side merge\n\t * @type {Tone.MidSideMerge}\n\t * @private\n\t */\n\tthis._midSideMerge = new Tone.MidSideMerge();\n\n\t/**\n\t * The mid send. Connect to mid processing\n\t * @type {Tone}\n\t * @private\n\t */\n\tthis.midSend = this._midSideSplit.mid;\n\n\t/**\n\t * The side send. Connect to side processing\n\t * @type {Tone}\n\t * @private\n\t */\n\tthis.sideSend = this._midSideSplit.side;\n\n\t/**\n\t * The mid return connection\n\t * @type {GainNode}\n\t * @private\n\t */\n\tthis.midReturn = this._midSideMerge.mid;\n\n\t/**\n\t * The side return connection\n\t * @type {GainNode}\n\t * @private\n\t */\n\tthis.sideReturn = this._midSideMerge.side;\n\n\t//the connections\n\tthis.effectSend.connect(this._midSideSplit);\n\tthis._midSideMerge.connect(this.effectReturn);\n};\n\nTone.extend(Tone.MidSideEffect, Tone.Effect);\n\n/**\n * Clean up.\n * @returns {Tone.MidSideEffect} this\n */\nTone.MidSideEffect.prototype.dispose = function(){\n\tTone.Effect.prototype.dispose.call(this);\n\tthis._midSideSplit.dispose();\n\tthis._midSideSplit = null;\n\tthis._midSideMerge.dispose();\n\tthis._midSideMerge = null;\n\tthis.midSend = null;\n\tthis.sideSend = null;\n\tthis.midReturn = null;\n\tthis.sideReturn = null;\n\treturn this;\n};\n\nexport default Tone.MidSideEffect;\n\n","import Tone from \"../core/Tone\";\nimport \"../core/Buffer\";\nimport \"../effect/Effect\";\n\n/**\n * @class Tone.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 * @constructor\n * @extends {Tone.Effect}\n * @param {string|Tone.Buffer|Object} [url] The URL of the impulse response or the Tone.Buffer\n * contianing the impulse response.\n * @param {Function=} onload The callback to invoke when the url is loaded.\n * @example\n * //initializing the convolver with an impulse response\n * var convolver = new Tone.Convolver(\"./path/to/ir.wav\").toMaster();\n */\nTone.Convolver = function(){\n\n\tvar options = Tone.defaults(arguments, [\"url\", \"onload\"], Tone.Convolver);\n\tTone.Effect.call(this, options);\n\n\t/**\n\t * convolver node\n\t * @type {ConvolverNode}\n\t * @private\n\t */\n\tthis._convolver = this.context.createConvolver();\n\n\t/**\n\t * the convolution buffer\n\t * @type {Tone.Buffer}\n\t * @private\n\t */\n\tthis._buffer = new Tone.Buffer(options.url, function(buffer){\n\t\tthis.buffer = buffer.get();\n\t\toptions.onload();\n\t}.bind(this));\n\n\t//set if it's already loaded\n\tif (this._buffer.loaded){\n\t\tthis.buffer = this._buffer;\n\t}\n\n\t//initially set normalization\n\tthis.normalize = options.normalize;\n\n\tthis.connectEffect(this._convolver);\n};\n\nTone.extend(Tone.Convolver, Tone.Effect);\n\n/**\n * @static\n * @const\n * @type {Object}\n */\nTone.Convolver.defaults = {\n\t\"onload\" : Tone.noOp,\n\t\"normalize\" : true\n};\n\n/**\n * The convolver's buffer\n * @memberOf Tone.Convolver#\n * @type {AudioBuffer}\n * @name buffer\n */\nObject.defineProperty(Tone.Convolver.prototype, \"buffer\", {\n\t\"get\" : function(){\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\t\"set\" : function(buffer){\n\t\tthis._buffer.set(buffer);\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.effectSend.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.connectEffect(this._convolver);\n\t\t}\n\t\tthis._convolver.buffer = this._buffer.get();\n\t}\n});\n\n/**\n * The normalize property of the ConvolverNode interface is a boolean that controls whether the impulse response from the buffer will be scaled by an equal-power normalization when the buffer attribute is set, or not.\n * @memberOf Tone.Convolver#\n * @type {Boolean}\n * @name normalize\n */\nObject.defineProperty(Tone.Convolver.prototype, \"normalize\", {\n\t\"get\" : function(){\n\t\treturn this._convolver.normalize;\n\t},\n\t\"set\" : function(norm){\n\t\tthis._convolver.normalize = norm;\n\t}\n});\n\n/**\n * Load an impulse response url as an audio buffer.\n * Decodes the audio asynchronously and invokes\n * the callback once the audio buffer loads.\n * @param {string} url The url of the buffer to load.\n * filetype support depends on the\n * browser.\n * @param {function=} callback\n * @returns {Promise}\n */\nTone.Convolver.prototype.load = function(url, callback){\n\treturn this._buffer.load(url, function(buff){\n\t\tthis.buffer = buff;\n\t\tif (callback){\n\t\t\tcallback();\n\t\t}\n\t}.bind(this));\n};\n\n/**\n * Clean up.\n * @returns {Tone.Convolver} this\n */\nTone.Convolver.prototype.dispose = function(){\n\tTone.Effect.prototype.dispose.call(this);\n\tthis._buffer.dispose();\n\tthis._buffer = null;\n\tthis._convolver.disconnect();\n\tthis._convolver = null;\n\treturn this;\n};\n\nexport default Tone.Convolver;\n\n","import Tone from \"../core/Tone\";\nimport \"../signal/WaveShaper\";\nimport \"../signal/Multiply\";\nimport \"../signal/Subtract\";\n\n/**\n * @class Signal-rate modulo operator. Only works in AudioRange [-1, 1] and for modulus\n * values in the NormalRange.\n *\n * @constructor\n * @extends {Tone.SignalBase}\n * @param {NormalRange} modulus The modulus to apply.\n * @example\n * var mod = new Tone.Modulo(0.2)\n * var sig = new Tone.Signal(0.5).connect(mod);\n * //mod outputs 0.1\n */\nTone.Modulo = function(modulus){\n\n\tTone.SignalBase.call(this);\n\tthis.createInsOuts(1, 0);\n\n\t/**\n\t * A waveshaper gets the integer multiple of\n\t * the input signal and the modulus.\n\t * @private\n\t * @type {Tone.WaveShaper}\n\t */\n\tthis._shaper = new Tone.WaveShaper(Math.pow(2, 16));\n\n\t/**\n\t * the integer multiple is multiplied by the modulus\n\t * @type {Tone.Multiply}\n\t * @private\n\t */\n\tthis._multiply = new Tone.Multiply();\n\n\t/**\n\t * and subtracted from the input signal\n\t * @type {Tone.Subtract}\n\t * @private\n\t */\n\tthis._subtract = this.output = new Tone.Subtract();\n\n\t/**\n\t * the modulus signal\n\t * @type {Tone.Signal}\n\t * @private\n\t */\n\tthis._modSignal = new Tone.Signal(modulus);\n\n\t//connections\n\tTone.connect(this.input, this._shaper);\n\tTone.connect(this.input, this._subtract);\n\tthis._modSignal.connect(this._multiply, 0, 0);\n\tthis._shaper.connect(this._multiply, 0, 1);\n\tthis._multiply.connect(this._subtract, 0, 1);\n\tthis._setWaveShaper(modulus);\n};\n\nTone.extend(Tone.Modulo, Tone.SignalBase);\n\n/**\n * @param {number} mod the modulus to apply\n * @private\n */\nTone.Modulo.prototype._setWaveShaper = function(mod){\n\tthis._shaper.setMap(function(val){\n\t\tvar multiple = Math.floor((val + 0.0001) / mod);\n\t\treturn multiple;\n\t});\n};\n\n/**\n * The modulus value.\n * @memberOf Tone.Modulo#\n * @type {NormalRange}\n * @name value\n */\nObject.defineProperty(Tone.Modulo.prototype, \"value\", {\n\tget : function(){\n\t\treturn this._modSignal.value;\n\t},\n\tset : function(mod){\n\t\tthis._modSignal.value = mod;\n\t\tthis._setWaveShaper(mod);\n\t}\n});\n\n/**\n * clean up\n * @returns {Tone.Modulo} this\n */\nTone.Modulo.prototype.dispose = function(){\n\tTone.SignalBase.prototype.dispose.call(this);\n\tthis._shaper.dispose();\n\tthis._shaper = null;\n\tthis._multiply.dispose();\n\tthis._multiply = null;\n\tthis._subtract.dispose();\n\tthis._subtract = null;\n\tthis._modSignal.dispose();\n\tthis._modSignal = null;\n\treturn this;\n};\n\nexport default Tone.Modulo;\n\n","import Tone from \"../core/Tone\";\nimport \"../core/Context\";\nimport \"../shim/OfflineAudioContext\";\n\n/**\n * @class Wrapper around the OfflineAudioContext\n * @extends {Tone.Context}\n * @param {Number} channels The number of channels to render\n * @param {Number} duration The duration to render in samples\n * @param {Number} sampleRate the sample rate to render at\n */\nTone.OfflineContext = function(channels, duration, sampleRate){\n\n\t/**\n\t * The offline context\n\t * @private\n\t * @type {OfflineAudioContext}\n\t */\n\tvar offlineContext = new OfflineAudioContext(channels, duration * sampleRate, sampleRate);\n\n\t//wrap the methods/members\n\tTone.Context.call(this, {\n\t\t\"context\" : offlineContext,\n\t\t\"clockSource\" : \"offline\",\n\t\t\"lookAhead\" : 0,\n\t\t\"updateInterval\" : 128 / sampleRate\n\t});\n\n\t/**\n\t * A private reference to the duration\n\t * @private\n\t * @type {Number}\n\t */\n\tthis._duration = duration;\n\n\t/**\n\t * An artificial clock source\n\t * @type {Number}\n\t * @private\n\t */\n\tthis._currentTime = 0;\n};\n\nTone.extend(Tone.OfflineContext, Tone.Context);\n\n/**\n * Override the now method to point to the internal clock time\n * @return {Number}\n */\nTone.OfflineContext.prototype.now = function(){\n\treturn this._currentTime;\n};\n\n/**\n * Overwrite resume, should not do anything in the OfflineAudioContext.\n * @return {Promise}\n */\nTone.OfflineContext.prototype.resume = function(){\n\treturn Promise.resolve();\n};\n\n/**\n * Render the output of the OfflineContext\n * @return {Promise}\n */\nTone.OfflineContext.prototype.render = function(){\n\twhile (this._duration - this._currentTime >= 0){\n\t\t//invoke all the callbacks on that time\n\t\tthis.emit(\"tick\");\n\t\t//increment the clock in 5ms chunks\n\t\tthis._currentTime += 0.005;\n\t}\n\n\treturn this._context.startRendering();\n};\n\n/**\n * Close the context\n * @return {Promise}\n */\nTone.OfflineContext.prototype.close = function(){\n\tthis._context = null;\n\treturn Promise.resolve();\n};\n\nexport default Tone.OfflineContext;\n\n","import Tone from \"../core/Tone\";\nimport \"../core/Transport\";\nimport \"../core/Buffer\";\nimport \"../core/OfflineContext\";\nimport \"../core/Master\";\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 Tone.Transport which can be used\n * to schedule events along the Transport. **NOTE** OfflineAudioContext has the same restrictions\n * as the AudioContext in that on certain platforms (like iOS) it must be invoked by an explicit\n * user action like a click or tap. \n * @param {Function} callback All Tone.js nodes which are created and scheduled within this callback are recorded into the output Buffer.\n * @param {Time} duration the amount of time to record for.\n * @return {Promise} The promise which is invoked with the Tone.Buffer of the recorded output.\n * @example\n * //render 2 seconds of the oscillator\n * Tone.Offline(function(){\n * \t//only nodes created in this callback will be recorded\n * \tvar oscillator = new Tone.Oscillator().toMaster().start(0)\n * \t//schedule their events\n * }, 2).then(function(buffer){\n * \t//do something with the output buffer\n * })\n * @example\n * //can also schedule events along the Transport\n * //using the passed in Offline Transport\n * Tone.Offline(function(Transport){\n * \tvar osc = new Tone.Oscillator().toMaster()\n * \tTransport.schedule(function(time){\n * \t\tosc.start(time).stop(time + 0.1)\n * \t}, 1)\n * \tTransport.start(0.2)\n * }, 4).then(function(buffer){\n * \t//do something with the output buffer\n * })\n */\nTone.Offline = function(callback, duration){\n\t//set the OfflineAudioContext\n\tvar sampleRate = Tone.context.sampleRate;\n\tvar originalContext = Tone.context;\n\n\tvar context = new Tone.OfflineContext(2, duration, sampleRate);\n\tTone.context = context;\n\n\t//invoke the callback/scheduling\n\tvar response = callback(Tone.Transport);\n\n\t//the return value\n\tvar ret = null;\n\n\tif (response && Tone.isFunction(response.then)){\n\t\t//wait for the promise to resolve\n\t\tret = response.then(function(){\n\t\t\t//then render the audio\n\t\t\treturn context.render();\n\t\t});\n\t} else {\n\t\t//process the audio\n\t\tret = context.render();\n\t}\n\n\t//return the original AudioContext\n\tTone.context = originalContext;\n\n\t//return the audio\n\treturn ret.then(function(buffer){\n\t\t//wrap it in a Tone.Buffer\n\t\treturn new Tone.Buffer(buffer);\n\t});\n};\n\nexport default Tone.Offline;\n\n","import Tone from \"../core/Tone\";\nimport \"../core/Buffer\";\n\n/**\n * @class A data structure for holding multiple buffers.\n * \n * @param {Object|Array} urls An object literal or array\n * of urls to load.\n * @param {Function=} callback The callback to invoke when\n * the buffers are loaded. \n * @extends {Tone}\n * @example\n * //load a whole bank of piano samples\n * var pianoSamples = new Tone.Buffers({\n * \t\"C4\" : \"path/to/C4.mp3\"\n * \t\"C#4\" : \"path/to/C#4.mp3\"\n * \t\"D4\" : \"path/to/D4.mp3\"\n * \t\"D#4\" : \"path/to/D#4.mp3\"\n * \t...\n * }, function(){\n * \t//play one of the samples when they all load\n * \tplayer.buffer = pianoSamples.get(\"C4\");\n * \tplayer.start();\n * });\n * \t@example\n * //To pass in additional parameters in the second parameter\n * var buffers = new Tone.Buffers(urls, {\n * \t\"onload\" : callback,\n * \t\"baseUrl\" : \"../path/to/audio/\"\n * })\n */\nTone.Buffers = function(urls){\n\n\t//remove the urls from the options\n\tvar args = Array.prototype.slice.call(arguments);\n\targs.shift();\n\tvar options = Tone.defaults(args, [\"onload\", \"baseUrl\"], Tone.Buffers);\n\tTone.call(this);\n\n\t/**\n\t * All of the buffers\n\t * @type {Object}\n\t * @private\n\t */\n\tthis._buffers = {};\n\n\t/**\n\t * A path which is prefixed before every url.\n\t * @type {String}\n\t */\n\tthis.baseUrl = options.baseUrl;\n\n\tthis._loadingCount = 0;\n\t//add each one\n\tfor (var key in urls){\n\t\tthis._loadingCount++;\n\t\tthis.add(key, urls[key], this._bufferLoaded.bind(this, options.onload));\n\t}\n};\n\nTone.extend(Tone.Buffers);\n\n/**\n * Defaults\n * @type {Object}\n */\nTone.Buffers.defaults = {\n\t\"onload\" : Tone.noOp,\n\t\"baseUrl\" : \"\"\n};\n\n/**\n * True if the buffers object has a buffer by that name.\n * @param {String|Number} name The key or index of the \n * buffer.\n * @return {Boolean}\n */\nTone.Buffers.prototype.has = function(name){\n\treturn this._buffers.hasOwnProperty(name);\n};\n\n/**\n * Get a buffer by name. If an array was loaded, \n * then use the array index.\n * @param {String|Number} name The key or index of the \n * buffer.\n * @return {Tone.Buffer}\n */\nTone.Buffers.prototype.get = function(name){\n\tif (this.has(name)){\n\t\treturn this._buffers[name];\n\t} else {\n\t\tthrow new Error(\"Tone.Buffers: no buffer named \"+name);\n\t}\n};\n\n/**\n * A buffer was loaded. decrement the counter.\n * @param {Function} callback \n * @private\n */\nTone.Buffers.prototype._bufferLoaded = function(callback){\n\tthis._loadingCount--;\n\tif (this._loadingCount === 0 && callback){\n\t\tcallback(this);\n\t}\n};\n\n/**\n * If the buffers are loaded or not\n * @memberOf Tone.Buffers#\n * @type {Boolean}\n * @name loaded\n * @readOnly\n */\nObject.defineProperty(Tone.Buffers.prototype, \"loaded\", {\n\tget : function(){\n\t\tvar isLoaded = true;\n\t\tfor (var buffName in this._buffers){\n\t\t\tvar buff = this.get(buffName);\n\t\t\tisLoaded = isLoaded && buff.loaded;\n\t\t}\n\t\treturn isLoaded;\n\t}\n});\n\n/**\n * Add a buffer by name and url to the Buffers\n * @param {String} name A unique name to give\n * the buffer\n * @param {String|Tone.Buffer|Audiobuffer} url Either the url of the bufer, \n * or a buffer which will be added\n * with the given name.\n * @param {Function=} callback The callback to invoke \n * when the url is loaded.\n */\nTone.Buffers.prototype.add = function(name, url, callback){\n\tcallback = Tone.defaultArg(callback, Tone.noOp);\n\tif (url instanceof Tone.Buffer){\n\t\tthis._buffers[name] = url;\n\t\tcallback(this);\n\t} else if (url instanceof AudioBuffer){\n\t\tthis._buffers[name] = new Tone.Buffer(url);\n\t\tcallback(this);\n\t} else if (Tone.isString(url)){\n\t\tthis._buffers[name] = new Tone.Buffer(this.baseUrl + url, callback);\n\t}\n\treturn this;\n};\n\n/**\n * Clean up.\n * @return {Tone.Buffers} this\n */\nTone.Buffers.prototype.dispose = function(){\n\tTone.prototype.dispose.call(this);\n\tfor (var name in this._buffers){\n\t\tthis._buffers[name].dispose();\n\t}\n\tthis._buffers = null;\n\treturn this;\n};\n\nexport default Tone.Buffers;\n\n","import Tone from \"../core/Tone\";\n\n/**\n * @class Generate patterns from an array of values.\n * Has a number of arpeggiation and randomized\n * selection patterns. \n *
- \n * \t
- \"up\" - cycles upward \n * \t\t\t
- \"down\" - cycles downward \n * \t\t\t
- \"upDown\" - up then and down \n * \t\t\t
- \"downUp\" - cycles down then and up \n * \t\t\t
- \"alternateUp\" - jump up two and down one \n * \t\t\t
- \"alternateDown\" - jump down two and up one \n * \t\t\t
- \"random\" - randomly select an index \n * \t\t\t
- \"randomWalk\" - randomly moves one index away from the current position \n * \t\t\t
- \"randomOnce\" - randomly select an index without repeating until all values have been chosen. \n * \t\t
note * .octaves and ramps to note\n * over the duration of .pitchDecay.\n *\n * @constructor\n * @extends {Tone.Instrument}\n * @param {Object} [options] the options available for the synth\n * see defaults below\n * @example\n * var synth = new Tone.MembraneSynth().toMaster();\n * synth.triggerAttackRelease(\"C2\", \"8n\");\n */\nTone.MembraneSynth = function(options){\n\n\toptions = Tone.defaultArg(options, Tone.MembraneSynth.defaults);\n\tTone.Instrument.call(this, options);\n\n\t/**\n\t * The oscillator.\n\t * @type {Tone.OmniOscillator}\n\t */\n\tthis.oscillator = new Tone.OmniOscillator(options.oscillator);\n\n\t/**\n\t * The amplitude envelope.\n\t * @type {Tone.AmplitudeEnvelope}\n\t */\n\tthis.envelope = new Tone.AmplitudeEnvelope(options.envelope);\n\n\t/**\n\t * The number of octaves the pitch envelope ramps.\n\t * @type {Positive}\n\t */\n\tthis.octaves = options.octaves;\n\n\t/**\n\t * The amount of time the frequency envelope takes.\n\t * @type {Time}\n\t */\n\tthis.pitchDecay = options.pitchDecay;\n\n\tthis.oscillator.chain(this.envelope, this.output);\n\tthis._readOnly([\"oscillator\", \"envelope\"]);\n};\n\nTone.extend(Tone.MembraneSynth, Tone.Instrument);\n\n/**\n * @static\n * @type {Object}\n */\nTone.MembraneSynth.defaults = {\n\t\"pitchDecay\" : 0.05,\n\t\"octaves\" : 10,\n\t\"oscillator\" : {\n\t\t\"type\" : \"sine\",\n\t},\n\t\"envelope\" : {\n\t\t\"attack\" : 0.001,\n\t\t\"decay\" : 0.4,\n\t\t\"sustain\" : 0.01,\n\t\t\"release\" : 1.4,\n\t\t\"attackCurve\" : \"exponential\"\n\t}\n};\n\n/**\n * Trigger the note at the given time with the given velocity.\n *\n * @param {Frequency} note the note\n * @param {Time} [time=now] the time, if not given is now\n * @param {number} [velocity=1] velocity defaults to 1\n * @returns {Tone.MembraneSynth} this\n * @example\n * kick.triggerAttack(60);\n */\nTone.MembraneSynth.prototype.triggerAttack = function(note, time, velocity){\n\ttime = this.toSeconds(time);\n\tnote = this.toFrequency(note);\n\tvar maxNote = note * this.octaves;\n\tthis.oscillator.frequency.setValueAtTime(maxNote, time);\n\tthis.oscillator.frequency.exponentialRampToValueAtTime(note, time + this.toSeconds(this.pitchDecay));\n\tthis.envelope.triggerAttack(time, velocity);\n\tthis.oscillator.start(time);\n\tif (this.envelope.sustain === 0){\n\t\tthis.oscillator.stop(time + this.envelope.attack + this.envelope.decay);\n\t}\n\treturn this;\n};\n\n/**\n * Trigger the release portion of the note.\n *\n * @param {Time} [time=now] the time the note will release\n * @returns {Tone.MembraneSynth} this\n */\nTone.MembraneSynth.prototype.triggerRelease = function(time){\n\ttime = this.toSeconds(time);\n\tthis.envelope.triggerRelease(time);\n\tthis.oscillator.stop(time + this.envelope.release);\n\treturn this;\n};\n\n/**\n * Clean up.\n * @returns {Tone.MembraneSynth} this\n */\nTone.MembraneSynth.prototype.dispose = function(){\n\tTone.Instrument.prototype.dispose.call(this);\n\tthis._writable([\"oscillator\", \"envelope\"]);\n\tthis.oscillator.dispose();\n\tthis.oscillator = null;\n\tthis.envelope.dispose();\n\tthis.envelope = null;\n\treturn this;\n};\n\nexport default Tone.MembraneSynth;\n\n","import Tone from \"../core/Tone\";\nimport \"../instrument/Synth\";\nimport \"../signal/Signal\";\nimport \"../signal/Multiply\";\nimport \"../instrument/Monophonic\";\n\n/**\n * @class 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 *
\n * Mid *= 2*(1-width)
\n * Side *= 2*width\n * \n *\n * @extends {Tone.MidSideEffect}\n * @constructor\n * @param {NormalRange|Object} [width] The stereo width. A width of 0 is mono and 1 is stereo. 0.5 is no change.\n */\nTone.StereoWidener = function(){\n\n\tvar options = Tone.defaults(arguments, [\"width\"], Tone.StereoWidener);\n\tTone.MidSideEffect.call(this, options);\n\n\t/**\n\t * The width control. 0 = 100% mid. 1 = 100% side. 0.5 = no change.\n\t * @type {NormalRange}\n\t * @signal\n\t */\n\tthis.width = new Tone.Signal(options.width, Tone.Type.NormalRange);\n\tthis._readOnly([\"width\"]);\n\n\t/**\n\t * Two times the (1-width) for the mid channel\n\t * @type {Tone.Multiply}\n\t * @private\n\t */\n\tthis._twoTimesWidthMid = new Tone.Multiply(2);\n\n\t/**\n\t * Two times the width for the side channel\n\t * @type {Tone.Multiply}\n\t * @private\n\t */\n\tthis._twoTimesWidthSide = new Tone.Multiply(2);\n\n\t/**\n\t * Mid multiplier\n\t * @type {Tone.Multiply}\n\t * @private\n\t */\n\tthis._midMult = new Tone.Multiply();\n\tthis._twoTimesWidthMid.connect(this._midMult, 0, 1);\n\tthis.midSend.chain(this._midMult, this.midReturn);\n\n\t/**\n\t * 1 - width\n\t * @type {Tone.Subtract}\n\t * @private\n\t */\n\tthis._oneMinusWidth = new Tone.Subtract();\n\tthis._oneMinusWidth.connect(this._twoTimesWidthMid);\n\tTone.connect(this.context.getConstant(1), this._oneMinusWidth, 0, 0);\n\tthis.width.connect(this._oneMinusWidth, 0, 1);\n\n\t/**\n\t * Side multiplier\n\t * @type {Tone.Multiply}\n\t * @private\n\t */\n\tthis._sideMult = new Tone.Multiply();\n\tthis.width.connect(this._twoTimesWidthSide);\n\tthis._twoTimesWidthSide.connect(this._sideMult, 0, 1);\n\tthis.sideSend.chain(this._sideMult, this.sideReturn);\n};\n\nTone.extend(Tone.StereoWidener, Tone.MidSideEffect);\n\n/**\n * the default values\n * @static\n * @type {Object}\n */\nTone.StereoWidener.defaults = {\n\t\"width\" : 0.5\n};\n\n/**\n * Clean up.\n * @returns {Tone.StereoWidener} this\n */\nTone.StereoWidener.prototype.dispose = function(){\n\tTone.MidSideEffect.prototype.dispose.call(this);\n\tthis._writable([\"width\"]);\n\tthis.width.dispose();\n\tthis.width = null;\n\tthis._midMult.dispose();\n\tthis._midMult = null;\n\tthis._sideMult.dispose();\n\tthis._sideMult = null;\n\tthis._twoTimesWidthMid.dispose();\n\tthis._twoTimesWidthMid = null;\n\tthis._twoTimesWidthSide.dispose();\n\tthis._twoTimesWidthSide = null;\n\tthis._oneMinusWidth.dispose();\n\tthis._oneMinusWidth = null;\n\treturn this;\n};\n\nexport default Tone.StereoWidener;\n\n","import Tone from \"../core/Tone\";\nimport \"../effect/StereoEffect\";\nimport \"../effect/FeedbackEffect\";\nimport \"../core/Gain\";\n\n/**\n * @class Base class for stereo feedback effects where the effectReturn\n * is fed back into the same channel.\n *\n *\t@constructor\n *\t@extends {Tone.StereoEffect}\n */\nTone.StereoFeedbackEffect = function(){\n\n\tvar options = Tone.defaults(arguments, [\"feedback\"], Tone.FeedbackEffect);\n\tTone.StereoEffect.call(this, options);\n\n\t/**\n\t * controls the amount of feedback\n\t * @type {NormalRange}\n\t * @signal\n\t */\n\tthis.feedback = new Tone.Signal(options.feedback, Tone.Type.NormalRange);\n\n\t/**\n\t * the left side feeback\n\t * @type {Tone.Gain}\n\t * @private\n\t */\n\tthis._feedbackL = new Tone.Gain();\n\n\t/**\n\t * the right side feeback\n\t * @type {Tone.Gain}\n\t * @private\n\t */\n\tthis._feedbackR = new Tone.Gain();\n\n\t//connect it up\n\tthis.effectReturnL.chain(this._feedbackL, this.effectSendL);\n\tthis.effectReturnR.chain(this._feedbackR, this.effectSendR);\n\tthis.feedback.fan(this._feedbackL.gain, this._feedbackR.gain);\n\tthis._readOnly([\"feedback\"]);\n};\n\nTone.extend(Tone.StereoFeedbackEffect, Tone.StereoEffect);\n\n/**\n * clean up\n * @returns {Tone.StereoFeedbackEffect} this\n */\nTone.StereoFeedbackEffect.prototype.dispose = function(){\n\tTone.StereoEffect.prototype.dispose.call(this);\n\tthis._writable([\"feedback\"]);\n\tthis.feedback.dispose();\n\tthis.feedback = null;\n\tthis._feedbackL.dispose();\n\tthis._feedbackL = null;\n\tthis._feedbackR.dispose();\n\tthis._feedbackR = null;\n\treturn this;\n};\n\nexport default Tone.StereoFeedbackEffect;\n\n","import Tone from \"../core/Tone\";\nimport \"../core/Offline\";\nimport \"../component/Filter\";\nimport \"../component/Merge\";\nimport \"../source/Noise\";\nimport \"../core/Gain\";\nimport \"../effect/Convolver\";\n\n/**\n * @class Simple convolution created with decaying noise.\n * \t\tGenerates an Impulse Response Buffer\n * \t\t\twith Tone.Offline then feeds the IR into ConvolverNode.\n * \t\t\tNote: the Reverb will not make any sound until [generate](#generate)\n * \t\t\thas been invoked and resolved.\n *\n * \t\t\tInspiration from [ReverbGen](https://github.com/adelespinasse/reverbGen).\n * \t\t\tCopyright (c) 2014 Alan deLespinasse Apache 2.0 License.\n *\n * @extends {Tone.Convolver}\n * @param {Time=} decay The amount of time it will reverberate for.\n */\nTone.Reverb = function(){\n\n\tvar options = Tone.defaults(arguments, [\"decay\"], Tone.Reverb);\n\tTone.Effect.call(this, options);\n\n\t/**\n\t * Convolver node\n\t * @type {ConvolverNode}\n\t * @private\n\t */\n\tthis._convolver = this.context.createConvolver();\n\n\t/**\n\t * The duration of the reverb\n\t * @type {Time}\n\t */\n\tthis.decay = options.decay;\n\n\t/**\n\t * The amount of time before the reverb is fully\n\t * ramped in.\n\t * @type {Time}\n\t */\n\tthis.preDelay = options.preDelay;\n\n\tthis.connectEffect(this._convolver);\n};\n\nTone.extend(Tone.Reverb, Tone.Effect);\n\n/**\n * The defaults\n * @type {Object}\n * @static\n */\nTone.Reverb.defaults = {\n\t\"decay\" : 1.5,\n\t\"preDelay\" : 0.01,\n};\n\n/**\n * Generate the Impulse Response. Returns a promise while the IR is being\n * generated.\n * @return {Promise\n * order 2: 2x^2 + 1
\n * order 3: 4x^3 + 3x
\n * @memberOf Tone.Chebyshev#\n * @type {Positive}\n * @name order\n */\nObject.defineProperty(Tone.Chebyshev.prototype, \"order\", {\n\tget : function(){\n\t\treturn this._order;\n\t},\n\tset : function(order){\n\t\tthis._order = order;\n\t\tvar curve = new Array(4096);\n\t\tvar len = curve.length;\n\t\tfor (var i = 0; i < len; ++i){\n\t\t\tvar x = i * 2 / len - 1;\n\t\t\tif (x === 0){\n\t\t\t\t//should output 0 when input is 0\n\t\t\t\tcurve[i] = 0;\n\t\t\t} else {\n\t\t\t\tcurve[i] = this._getCoefficient(x, order, {});\n\t\t\t}\n\t\t}\n\t\tthis._shaper.curve = curve;\n\t} \n});\n\n/**\n * The oversampling of the effect. Can either be \"none\", \"2x\" or \"4x\".\n * @memberOf Tone.Chebyshev#\n * @type {string}\n * @name oversample\n */\nObject.defineProperty(Tone.Chebyshev.prototype, \"oversample\", {\n\tget : function(){\n\t\treturn this._shaper.oversample;\n\t},\n\tset : function(oversampling){\n\t\tthis._shaper.oversample = oversampling;\n\t} \n});\n\n/**\n * Clean up. \n * @returns {Tone.Chebyshev} this\n */\nTone.Chebyshev.prototype.dispose = function(){\n\tTone.Effect.prototype.dispose.call(this);\n\tthis._shaper.dispose();\n\tthis._shaper = null;\n\treturn this;\n};\n\nexport default Tone.Chebyshev;\n\n","import Tone from \"../core/Tone\";\nimport \"../effect/Effect\";\nimport \"../signal/Subtract\";\nimport \"../signal/Modulo\";\n\n/**\n * @class Tone.Bitcrusher downsamples the incoming signal to a different bitdepth.\n * Lowering the bitdepth of the signal creates distortion. Read more about Bitcrushing\n * on [Wikipedia](https://en.wikipedia.org/wiki/Bitcrusher).\n *\n * @constructor\n * @extends {Tone.Effect}\n * @param {Number} bits The number of bits to downsample the signal. Nominal range\n * of 1 to 8.\n * @example\n * //initialize crusher and route a synth through it\n * var crusher = new Tone.BitCrusher(4).toMaster();\n * var synth = new Tone.MonoSynth().connect(crusher);\n */\nTone.BitCrusher = function(){\n\n\tvar options = Tone.defaults(arguments, [\"bits\"], Tone.BitCrusher);\n\tTone.Effect.call(this, options);\n\n\tvar invStepSize = 1 / Math.pow(2, options.bits - 1);\n\n\t/**\n\t * Subtract the input signal and the modulus of the input signal\n\t * @type {Tone.Subtract}\n\t * @private\n\t */\n\tthis._subtract = new Tone.Subtract();\n\n\t/**\n\t * The mod function\n\t * @type {Tone.Modulo}\n\t * @private\n\t */\n\tthis._modulo = new Tone.Modulo(invStepSize);\n\n\t/**\n\t * keeps track of the bits\n\t * @type {number}\n\t * @private\n\t */\n\tthis._bits = options.bits;\n\n\t//connect it up\n\tthis.effectSend.fan(this._subtract, this._modulo);\n\tthis._modulo.connect(this._subtract, 0, 1);\n\tthis._subtract.connect(this.effectReturn);\n};\n\nTone.extend(Tone.BitCrusher, Tone.Effect);\n\n/**\n * the default values\n * @static\n * @type {Object}\n */\nTone.BitCrusher.defaults = {\n\t\"bits\" : 4\n};\n\n/**\n * The bit depth of the effect. Nominal range of 1-8.\n * @memberOf Tone.BitCrusher#\n * @type {number}\n * @name bits\n */\nObject.defineProperty(Tone.BitCrusher.prototype, \"bits\", {\n\tget : function(){\n\t\treturn this._bits;\n\t},\n\tset : function(bits){\n\t\tthis._bits = bits;\n\t\tvar invStepSize = 1 / Math.pow(2, bits - 1);\n\t\tthis._modulo.value = invStepSize;\n\t}\n});\n\n/**\n * Clean up.\n * @returns {Tone.BitCrusher} this\n */\nTone.BitCrusher.prototype.dispose = function(){\n\tTone.Effect.prototype.dispose.call(this);\n\tthis._subtract.dispose();\n\tthis._subtract = null;\n\tthis._modulo.dispose();\n\tthis._modulo = null;\n\treturn this;\n};\n\nexport default Tone.BitCrusher;\n\n","import Tone from \"../core/Tone\";\nimport \"../component/Follower\";\nimport \"../signal/ScaleExp\";\nimport \"../effect/Effect\";\nimport \"../component/Filter\";\n\n/**\n * @class Tone.AutoWah connects a Tone.Follower to a bandpass filter (Tone.Filter).\n * The frequency of the filter is adjusted proportionally to the\n * incoming signal's amplitude. Inspiration from [Tuna.js](https://github.com/Dinahmoe/tuna).\n *\n * @constructor\n * @extends {Tone.Effect}\n * @param {Frequency|Object} [baseFrequency] The frequency the filter is set\n * to at the low point of the wah\n * @param {Positive} [octaves] The number of octaves above the baseFrequency\n * the filter will sweep to when fully open\n * @param {Decibels} [sensitivity] The decibel threshold sensitivity for\n * the incoming signal. Normal range of -40 to 0.\n * @example\n * var autoWah = new Tone.AutoWah(50, 6, -30).toMaster();\n * //initialize the synth and connect to autowah\n * var synth = new 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 */\nTone.AutoWah = function(){\n\n\tvar options = Tone.defaults(arguments, [\"baseFrequency\", \"octaves\", \"sensitivity\"], Tone.AutoWah);\n\tTone.Effect.call(this, options);\n\n\t/**\n\t * The envelope follower. Set the attack/release\n\t * timing to adjust how the envelope is followed.\n\t * @type {Tone.Follower}\n\t * @private\n\t */\n\tthis.follower = new Tone.Follower(options.follower);\n\n\t/**\n\t * scales the follower value to the frequency domain\n\t * @type {Tone}\n\t * @private\n\t */\n\tthis._sweepRange = new Tone.ScaleExp(0, 1, 0.5);\n\n\t/**\n\t * @type {number}\n\t * @private\n\t */\n\tthis._baseFrequency = options.baseFrequency;\n\n\t/**\n\t * @type {number}\n\t * @private\n\t */\n\tthis._octaves = options.octaves;\n\n\t/**\n\t * the input gain to adjust the sensitivity\n\t * @type {Tone.Gain}\n\t * @private\n\t */\n\tthis._inputBoost = new Tone.Gain();\n\n\t/**\n\t * @type {BiquadFilterNode}\n\t * @private\n\t */\n\tthis._bandpass = new Tone.Filter({\n\t\t\"rolloff\" : -48,\n\t\t\"frequency\" : 0,\n\t\t\"Q\" : options.Q,\n\t});\n\n\t/**\n\t * @type {Tone.Filter}\n\t * @private\n\t */\n\tthis._peaking = new Tone.Filter(0, \"peaking\");\n\tthis._peaking.gain.value = options.gain;\n\n\t/**\n\t * The gain of the filter.\n\t * @type {Number}\n\t * @signal\n\t */\n\tthis.gain = this._peaking.gain;\n\n\t/**\n\t * The quality of the filter.\n\t * @type {Positive}\n\t * @signal\n\t */\n\tthis.Q = this._bandpass.Q;\n\n\t//the control signal path\n\tthis.effectSend.chain(this._inputBoost, this.follower, this._sweepRange);\n\tthis._sweepRange.connect(this._bandpass.frequency);\n\tthis._sweepRange.connect(this._peaking.frequency);\n\t//the filtered path\n\tthis.effectSend.chain(this._bandpass, this._peaking, this.effectReturn);\n\t//set the initial value\n\tthis._setSweepRange();\n\tthis.sensitivity = options.sensitivity;\n\n\tthis._readOnly([\"gain\", \"Q\"]);\n};\n\nTone.extend(Tone.AutoWah, Tone.Effect);\n\n/**\n * @static\n * @type {Object}\n */\nTone.AutoWah.defaults = {\n\t\"baseFrequency\" : 100,\n\t\"octaves\" : 6,\n\t\"sensitivity\" : 0,\n\t\"Q\" : 2,\n\t\"gain\" : 2,\n\t\"follower\" : {\n\t\t\"attack\" : 0.3,\n\t\t\"release\" : 0.5\n\t}\n};\n\n/**\n * The number of octaves that the filter will sweep above the\n * baseFrequency.\n * @memberOf Tone.AutoWah#\n * @type {Number}\n * @name octaves\n */\nObject.defineProperty(Tone.AutoWah.prototype, \"octaves\", {\n\tget : function(){\n\t\treturn this._octaves;\n\t},\n\tset : function(octaves){\n\t\tthis._octaves = octaves;\n\t\tthis._setSweepRange();\n\t}\n});\n\n/**\n * The base frequency from which the sweep will start from.\n * @memberOf Tone.AutoWah#\n * @type {Frequency}\n * @name baseFrequency\n */\nObject.defineProperty(Tone.AutoWah.prototype, \"baseFrequency\", {\n\tget : function(){\n\t\treturn this._baseFrequency;\n\t},\n\tset : function(baseFreq){\n\t\tthis._baseFrequency = baseFreq;\n\t\tthis._setSweepRange();\n\t}\n});\n\n/**\n * The sensitivity to control how responsive to the input signal the filter is.\n * @memberOf Tone.AutoWah#\n * @type {Decibels}\n * @name sensitivity\n */\nObject.defineProperty(Tone.AutoWah.prototype, \"sensitivity\", {\n\tget : function(){\n\t\treturn Tone.gainToDb(1 / this._inputBoost.gain.value);\n\t},\n\tset : function(sensitivy){\n\t\tthis._inputBoost.gain.value = 1 / Tone.dbToGain(sensitivy);\n\t}\n});\n\n/**\n * sets the sweep range of the scaler\n * @private\n */\nTone.AutoWah.prototype._setSweepRange = function(){\n\tthis._sweepRange.min = this._baseFrequency;\n\tthis._sweepRange.max = Math.min(this._baseFrequency * Math.pow(2, this._octaves), this.context.sampleRate / 2);\n};\n\n/**\n * Clean up.\n * @returns {Tone.AutoWah} this\n */\nTone.AutoWah.prototype.dispose = function(){\n\tTone.Effect.prototype.dispose.call(this);\n\tthis.follower.dispose();\n\tthis.follower = null;\n\tthis._sweepRange.dispose();\n\tthis._sweepRange = null;\n\tthis._bandpass.dispose();\n\tthis._bandpass = null;\n\tthis._peaking.dispose();\n\tthis._peaking = null;\n\tthis._inputBoost.dispose();\n\tthis._inputBoost = null;\n\tthis._writable([\"gain\", \"Q\"]);\n\tthis.gain = null;\n\tthis.Q = null;\n\treturn this;\n};\n\nexport default Tone.AutoWah;\n\n","import Tone from \"../core/Tone\";\nimport \"../effect/Effect\";\nimport \"../component/LFO\";\nimport \"../component/Panner\";\n\n/**\n * @class Tone.AutoPanner is a Tone.Panner with an LFO connected to the pan amount. \n * More on using autopanners [here](https://www.ableton.com/en/blog/autopan-chopper-effect-and-more-liveschool/).\n *\n * @constructor\n * @extends {Tone.Effect}\n * @param {Frequency|Object} [frequency] Rate of left-right oscillation. \n * @example\n * //create an autopanner and start it's LFO\n * var autoPanner = new Tone.AutoPanner(\"4n\").toMaster().start();\n * //route an oscillator through the panner and start it\n * var oscillator = new Tone.Oscillator().connect(autoPanner).start();\n */\nTone.AutoPanner = function(){\n\n\tvar options = Tone.defaults(arguments, [\"frequency\"], Tone.AutoPanner);\n\tTone.Effect.call(this, options);\n\n\t/**\n\t * the lfo which drives the panning\n\t * @type {Tone.LFO}\n\t * @private\n\t */\n\tthis._lfo = new Tone.LFO({\n\t\t\"frequency\" : options.frequency,\n\t\t\"amplitude\" : options.depth,\n\t\t\"min\" : -1,\n\t\t\"max\" : 1,\n\t});\n\n\t/**\n\t * The amount of panning between left and right. \n\t * 0 = always center. 1 = full range between left and right. \n\t * @type {NormalRange}\n\t * @signal\n\t */\n\tthis.depth = this._lfo.amplitude;\n\n\t/**\n\t * the panner node which does the panning\n\t * @type {Tone.Panner}\n\t * @private\n\t */\n\tthis._panner = new Tone.Panner();\n\n\t/**\n\t * How fast the panner modulates between left and right. \n\t * @type {Frequency}\n\t * @signal\n\t */\n\tthis.frequency = this._lfo.frequency;\n\n\t//connections\n\tthis.connectEffect(this._panner);\n\tthis._lfo.connect(this._panner.pan);\n\tthis.type = options.type;\n\tthis._readOnly([\"depth\", \"frequency\"]);\n};\n\n//extend Effect\nTone.extend(Tone.AutoPanner, Tone.Effect);\n\n/**\n * defaults\n * @static\n * @type {Object}\n */\nTone.AutoPanner.defaults = {\n\t\"frequency\" : 1,\n\t\"type\" : \"sine\",\n\t\"depth\" : 1\n};\n\n/**\n * Start the effect.\n * @param {Time} [time=now] When the LFO will start. \n * @returns {Tone.AutoPanner} this\n */\nTone.AutoPanner.prototype.start = function(time){\n\tthis._lfo.start(time);\n\treturn this;\n};\n\n/**\n * Stop the effect.\n * @param {Time} [time=now] When the LFO will stop. \n * @returns {Tone.AutoPanner} this\n */\nTone.AutoPanner.prototype.stop = function(time){\n\tthis._lfo.stop(time);\n\treturn this;\n};\n\n/**\n * Sync the panner to the transport.\n * @param {Time} [delay=0] Delay time before starting the effect after the\n * Transport has started. \n * @returns {Tone.AutoPanner} this\n */\nTone.AutoPanner.prototype.sync = function(delay){\n\tthis._lfo.sync(delay);\n\treturn this;\n};\n\n/**\n * Unsync the panner from the transport\n * @returns {Tone.AutoPanner} this\n */\nTone.AutoPanner.prototype.unsync = function(){\n\tthis._lfo.unsync();\n\treturn this;\n};\n\n/**\n * Type of oscillator attached to the AutoFilter. \n * Possible values: \"sine\", \"square\", \"triangle\", \"sawtooth\".\n * @memberOf Tone.AutoFilter#\n * @type {string}\n * @name type\n */\nObject.defineProperty(Tone.AutoPanner.prototype, \"type\", {\n\tget : function(){\n\t\treturn this._lfo.type;\n\t},\n\tset : function(type){\n\t\tthis._lfo.type = type;\n\t}\n});\n\n/**\n * clean up\n * @returns {Tone.AutoPanner} this\n */\nTone.AutoPanner.prototype.dispose = function(){\n\tTone.Effect.prototype.dispose.call(this);\n\tthis._lfo.dispose();\n\tthis._lfo = null;\n\tthis._panner.dispose();\n\tthis._panner = null;\n\tthis._writable([\"depth\", \"frequency\"]);\n\tthis.frequency = null;\n\tthis.depth = null;\n\treturn this;\n};\n\nexport default Tone.AutoPanner;\n\n","import Tone from \"../core/Tone\";\nimport \"../effect/Effect\";\nimport \"../component/LFO\";\nimport \"../component/Filter\";\n\n/**\n * @class Tone.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 * @constructor\n * @extends {Tone.Effect}\n * @param {Time|Object} [frequency] The rate of the LFO.\n * @param {Frequency=} baseFrequency The lower value of the LFOs oscillation\n \t * @param {Frequency=} octaves The number of octaves above the baseFrequency\n * @example\n * //create an autofilter and start it's LFO\n * var autoFilter = new Tone.AutoFilter(\"4n\").toMaster().start();\n * //route an oscillator through the filter and start it\n * var oscillator = new Tone.Oscillator().connect(autoFilter).start();\n */\nTone.AutoFilter = function(){\n\n\tvar options = Tone.defaults(arguments, [\"frequency\", \"baseFrequency\", \"octaves\"], Tone.AutoFilter);\n\tTone.Effect.call(this, options);\n\n\t/**\n\t * the lfo which drives the filter cutoff\n\t * @type {Tone.LFO}\n\t * @private\n\t */\n\tthis._lfo = new Tone.LFO({\n\t\t\"frequency\" : options.frequency,\n\t\t\"amplitude\" : options.depth,\n\t});\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 * @type {NormalRange}\n\t * @signal\n\t */\n\tthis.depth = this._lfo.amplitude;\n\n\t/**\n\t * How fast the filter modulates between min and max. \n\t * @type {Frequency}\n\t * @signal\n\t */\n\tthis.frequency = this._lfo.frequency;\n\n\t/**\n\t * The filter node\n\t * @type {Tone.Filter}\n\t */\n\tthis.filter = new Tone.Filter(options.filter);\n\n\t/**\n\t * The octaves placeholder\n\t * @type {Positive}\n\t * @private\n\t */\n\tthis._octaves = 0;\n\n\t//connections\n\tthis.connectEffect(this.filter);\n\tthis._lfo.connect(this.filter.frequency);\n\tthis.type = options.type;\n\tthis._readOnly([\"frequency\", \"depth\"]);\n\tthis.octaves = options.octaves;\n\tthis.baseFrequency = options.baseFrequency;\n};\n\n//extend Effect\nTone.extend(Tone.AutoFilter, Tone.Effect);\n\n/**\n * defaults\n * @static\n * @type {Object}\n */\nTone.AutoFilter.defaults = {\n\t\"frequency\" : 1,\n\t\"type\" : \"sine\",\n\t\"depth\" : 1,\n\t\"baseFrequency\" : 200,\n\t\"octaves\" : 2.6,\n\t\"filter\" : {\n\t\t\"type\" : \"lowpass\",\n\t\t\"rolloff\" : -12,\n\t\t\"Q\" : 1,\n\t}\n};\n\n/**\n * Start the effect.\n * @param {Time} [time=now] When the LFO will start. \n * @returns {Tone.AutoFilter} this\n */\nTone.AutoFilter.prototype.start = function(time){\n\tthis._lfo.start(time);\n\treturn this;\n};\n\n/**\n * Stop the effect.\n * @param {Time} [time=now] When the LFO will stop. \n * @returns {Tone.AutoFilter} this\n */\nTone.AutoFilter.prototype.stop = function(time){\n\tthis._lfo.stop(time);\n\treturn this;\n};\n\n/**\n * Sync the filter to the transport.\n * @param {Time} [delay=0] Delay time before starting the effect after the\n * Transport has started. \n * @returns {Tone.AutoFilter} this\n */\nTone.AutoFilter.prototype.sync = function(delay){\n\tthis._lfo.sync(delay);\n\treturn this;\n};\n\n/**\n * Unsync the filter from the transport.\n * @returns {Tone.AutoFilter} this\n */\nTone.AutoFilter.prototype.unsync = function(){\n\tthis._lfo.unsync();\n\treturn this;\n};\n\n/**\n * Type of oscillator attached to the AutoFilter. \n * Possible values: \"sine\", \"square\", \"triangle\", \"sawtooth\".\n * @memberOf Tone.AutoFilter#\n * @type {string}\n * @name type\n */\nObject.defineProperty(Tone.AutoFilter.prototype, \"type\", {\n\tget : function(){\n\t\treturn this._lfo.type;\n\t},\n\tset : function(type){\n\t\tthis._lfo.type = type;\n\t}\n});\n\n/**\n * The minimum value of the filter's cutoff frequency.\n * @memberOf Tone.AutoFilter#\n * @type {Frequency}\n * @name baseFrequency\n */\nObject.defineProperty(Tone.AutoFilter.prototype, \"baseFrequency\", {\n\tget : function(){\n\t\treturn this._lfo.min;\n\t},\n\tset : function(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\n/**\n * The maximum value of the filter's cutoff frequency. \n * @memberOf Tone.AutoFilter#\n * @type {Positive}\n * @name octaves\n */\nObject.defineProperty(Tone.AutoFilter.prototype, \"octaves\", {\n\tget : function(){\n\t\treturn this._octaves;\n\t},\n\tset : function(oct){\n\t\tthis._octaves = oct;\n\t\tthis._lfo.max = this.baseFrequency * Math.pow(2, oct);\n\t}\n});\n\n/**\n * Clean up. \n * @returns {Tone.AutoFilter} this\n */\nTone.AutoFilter.prototype.dispose = function(){\n\tTone.Effect.prototype.dispose.call(this);\n\tthis._lfo.dispose();\n\tthis._lfo = null;\n\tthis.filter.dispose();\n\tthis.filter = null;\n\tthis._writable([\"frequency\", \"depth\"]);\n\tthis.frequency = null;\n\tthis.depth = null;\n\treturn this;\n};\n\nexport default Tone.AutoFilter;\n\n","import Tone from \"../core/Tone\";\nimport \"../component/CrossFade\";\nimport \"../component/Merge\";\nimport \"../component/Split\";\nimport \"../signal/Signal\";\nimport \"../signal/AudioToGain\";\nimport \"../signal/Zero\";\n\n/**\n * @class Both Tone.Panner3D and Tone.Listener have a position in 3D space\n * using a right-handed cartesian coordinate system.\n * The units used in the coordinate system are not defined;\n * these coordinates are independent/invariant of any particular\n * units such as meters or feet. Tone.Panner3D objects have an forward\n * vector representing the direction the sound is projecting. Additionally,\n * they have a sound cone representing how directional the sound is.\n * For example, the sound could be omnidirectional, in which case it would\n * be heard anywhere regardless of its forward, or it can be more directional\n * and heard only if it is facing the listener. Tone.Listener objects\n * (representing a person's ears) have an forward and up vector\n * representing in which direction the person is facing. Because both the\n * source stream and the listener can be moving, they both have a velocity\n * vector representing both the speed and direction of movement. Taken together,\n * these two velocities can be used to generate a doppler shift effect which changes the pitch.\n *
\n * Note: the position of the Listener will have no effect on nodes not connected to a Tone.Panner3D\n *\n * @constructor\n * @extends {Tone}\n * @singleton\n */\nTone.Listener = function(){\n\n\tTone.call(this);\n\n\t/**\n\t * Holds the current forward orientation\n\t * @type {Array}\n\t * @private\n\t */\n\tthis._orientation = [0, 0, 0, 0, 0, 0];\n\n\t/**\n\t * Holds the current position\n\t * @type {Array}\n\t * @private\n\t */\n\tthis._position = [0, 0, 0];\n\n\tTone.getContext(function(){\n\t\t// set the default position/forward\n\t\tthis.set(ListenerConstructor.defaults);\n\n\t\t//listener is a singleton so it adds itself to the context\n\t\t// this.context.listener = this;\n\t}.bind(this));\n\n};\n\nTone.extend(Tone.Listener);\n\n/**\n * Defaults according to the specification\n * @static\n * @const\n * @type {Object}\n */\nTone.Listener.defaults = {\n\t\"positionX\" : 0,\n\t\"positionY\" : 0,\n\t\"positionZ\" : 0,\n\t\"forwardX\" : 0,\n\t\"forwardY\" : 0,\n\t\"forwardZ\" : 1,\n\t\"upX\" : 0,\n\t\"upY\" : 1,\n\t\"upZ\" : 0\n};\n\n/**\n * Is an instanceof Tone.Listener\n * @type {Boolean}\n */\nTone.Listener.prototype.isListener = true;\n\n/**\n * The ramp time which is applied to the setTargetAtTime\n * @type {Number}\n * @private\n */\nTone.Listener.prototype._rampTimeConstant = 0.01;\n\n/**\n * Sets the position of the listener in 3d space.\n * @param {Number} x\n * @param {Number} y\n * @param {Number} z\n * @return {Tone.Listener} this\n */\nTone.Listener.prototype.setPosition = function(x, y, z){\n\tif (this.context.rawContext.listener.positionX){\n\t\tvar now = this.now();\n\t\tthis.context.rawContext.listener.positionX.setTargetAtTime(x, now, this._rampTimeConstant);\n\t\tthis.context.rawContext.listener.positionY.setTargetAtTime(y, now, this._rampTimeConstant);\n\t\tthis.context.rawContext.listener.positionZ.setTargetAtTime(z, now, this._rampTimeConstant);\n\t} else {\n\t\tthis.context.rawContext.listener.setPosition(x, y, z);\n\t}\n\tthis._position = Array.prototype.slice.call(arguments);\n\treturn this;\n};\n\n/**\n * Sets the orientation of the listener using two vectors, the forward\n * vector (which direction the listener is facing) and the up vector\n * (which the up direction of the listener). An up vector\n * of 0, 0, 1 is equivalent to the listener standing up in the Z direction.\n * @param {Number} x\n * @param {Number} y\n * @param {Number} z\n * @param {Number} upX\n * @param {Number} upY\n * @param {Number} upZ\n * @return {Tone.Listener} this\n */\nTone.Listener.prototype.setOrientation = function(x, y, z, upX, upY, upZ){\n\tif (this.context.rawContext.listener.forwardX){\n\t\tvar now = this.now();\n\t\tthis.context.rawContext.listener.forwardX.setTargetAtTime(x, now, this._rampTimeConstant);\n\t\tthis.context.rawContext.listener.forwardY.setTargetAtTime(y, now, this._rampTimeConstant);\n\t\tthis.context.rawContext.listener.forwardZ.setTargetAtTime(z, now, this._rampTimeConstant);\n\t\tthis.context.rawContext.listener.upX.setTargetAtTime(upX, now, this._rampTimeConstant);\n\t\tthis.context.rawContext.listener.upY.setTargetAtTime(upY, now, this._rampTimeConstant);\n\t\tthis.context.rawContext.listener.upZ.setTargetAtTime(upZ, now, this._rampTimeConstant);\n\t} else {\n\t\tthis.context.rawContext.listener.setOrientation(x, y, z, upX, upY, upZ);\n\t}\n\tthis._orientation = Array.prototype.slice.call(arguments);\n\treturn this;\n};\n\n/**\n * The x position of the panner object.\n * @type {Number}\n * @memberOf Tone.Listener#\n * @name positionX\n */\nObject.defineProperty(Tone.Listener.prototype, \"positionX\", {\n\tset : function(pos){\n\t\tthis._position[0] = pos;\n\t\tthis.setPosition.apply(this, this._position);\n\t},\n\tget : function(){\n\t\treturn this._position[0];\n\t}\n});\n\n/**\n * The y position of the panner object.\n * @type {Number}\n * @memberOf Tone.Listener#\n * @name positionY\n */\nObject.defineProperty(Tone.Listener.prototype, \"positionY\", {\n\tset : function(pos){\n\t\tthis._position[1] = pos;\n\t\tthis.setPosition.apply(this, this._position);\n\t},\n\tget : function(){\n\t\treturn this._position[1];\n\t}\n});\n\n/**\n * The z position of the panner object.\n * @type {Number}\n * @memberOf Tone.Listener#\n * @name positionZ\n */\nObject.defineProperty(Tone.Listener.prototype, \"positionZ\", {\n\tset : function(pos){\n\t\tthis._position[2] = pos;\n\t\tthis.setPosition.apply(this, this._position);\n\t},\n\tget : function(){\n\t\treturn this._position[2];\n\t}\n});\n\n/**\n * The x coordinate of the listeners front direction. i.e.\n * which way they are facing.\n * @type {Number}\n * @memberOf Tone.Listener#\n * @name forwardX\n */\nObject.defineProperty(Tone.Listener.prototype, \"forwardX\", {\n\tset : function(pos){\n\t\tthis._orientation[0] = pos;\n\t\tthis.setOrientation.apply(this, this._orientation);\n\t},\n\tget : function(){\n\t\treturn this._orientation[0];\n\t}\n});\n\n/**\n * The y coordinate of the listeners front direction. i.e.\n * which way they are facing.\n * @type {Number}\n * @memberOf Tone.Listener#\n * @name forwardY\n */\nObject.defineProperty(Tone.Listener.prototype, \"forwardY\", {\n\tset : function(pos){\n\t\tthis._orientation[1] = pos;\n\t\tthis.setOrientation.apply(this, this._orientation);\n\t},\n\tget : function(){\n\t\treturn this._orientation[1];\n\t}\n});\n\n/**\n * The z coordinate of the listeners front direction. i.e.\n * which way they are facing.\n * @type {Number}\n * @memberOf Tone.Listener#\n * @name forwardZ\n */\nObject.defineProperty(Tone.Listener.prototype, \"forwardZ\", {\n\tset : function(pos){\n\t\tthis._orientation[2] = pos;\n\t\tthis.setOrientation.apply(this, this._orientation);\n\t},\n\tget : function(){\n\t\treturn this._orientation[2];\n\t}\n});\n\n/**\n * The x coordinate of the listener's up direction. i.e.\n * the direction the listener is standing in.\n * @type {Number}\n * @memberOf Tone.Listener#\n * @name upX\n */\nObject.defineProperty(Tone.Listener.prototype, \"upX\", {\n\tset : function(pos){\n\t\tthis._orientation[3] = pos;\n\t\tthis.setOrientation.apply(this, this._orientation);\n\t},\n\tget : function(){\n\t\treturn this._orientation[3];\n\t}\n});\n\n/**\n * The y coordinate of the listener's up direction. i.e.\n * the direction the listener is standing in.\n * @type {Number}\n * @memberOf Tone.Listener#\n * @name upY\n */\nObject.defineProperty(Tone.Listener.prototype, \"upY\", {\n\tset : function(pos){\n\t\tthis._orientation[4] = pos;\n\t\tthis.setOrientation.apply(this, this._orientation);\n\t},\n\tget : function(){\n\t\treturn this._orientation[4];\n\t}\n});\n\n/**\n * The z coordinate of the listener's up direction. i.e.\n * the direction the listener is standing in.\n * @type {Number}\n * @memberOf Tone.Listener#\n * @name upZ\n */\nObject.defineProperty(Tone.Listener.prototype, \"upZ\", {\n\tset : function(pos){\n\t\tthis._orientation[5] = pos;\n\t\tthis.setOrientation.apply(this, this._orientation);\n\t},\n\tget : function(){\n\t\treturn this._orientation[5];\n\t}\n});\n\n/**\n * Clean up.\n * @returns {Tone.Listener} this\n */\nTone.Listener.prototype.dispose = function(){\n\tthis._orientation = null;\n\tthis._position = null;\n\treturn this;\n};\n\n//SINGLETON SETUP\nvar ListenerConstructor = Tone.Listener;\nTone.Listener = new ListenerConstructor();\n\nTone.Context.on(\"init\", function(context){\n\tif (context.listener && context.listener.isListener){\n\t\t//a single listener object\n\t\tTone.Listener = context.listener;\n\t} else {\n\t\t//make new Listener insides\n\t\tTone.Listener = new ListenerConstructor();\n\t}\n});\n//END SINGLETON SETUP\n\nexport default Tone.Listener;\n\n","import Tone from \"../core/Tone\";\nimport \"../core/Timeline\";\n\n/**\n * @class Tone.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. Tone.Draw makes it easy to schedule\n * callbacks using the AudioContext time and uses requestAnimationFrame.\n * \n * @singleton\n * @extends {Tone}\n * @example\n * Tone.Transport.schedule(function(time){\n * \t//use the time argument to schedule a callback with Tone.Draw\n * \tTone.Draw.schedule(function(){\n * \t\t//do drawing or DOM manipulation here\n * \t}, time)\n * }, \"+0.5\")\n */\nTone.Draw = function(){\n\n\tTone.call(this);\n\t\n\t/**\n\t * All of the events.\n\t * @type {Tone.Timeline}\n\t * @private\n\t */\n\tthis._events = new Tone.Timeline();\n\n\t/**\n\t * The duration after which events are not invoked.\n\t * @type {Number}\n\t * @default 0.25\n\t */\n\tthis.expiration = 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 * @type {Number}\n\t * @default 0.008\n\t */\n\tthis.anticipation = 0.008;\n\n\t/**\n\t * The draw loop\n\t * @type {Function}\n\t * @private\n\t */\n\tthis._boundDrawLoop = this._drawLoop.bind(this);\n};\n\nTone.extend(Tone.Draw);\n\n/**\n * Schedule a function at the given time to be invoked\n * on the nearest animation frame.\n * @param {Function} callback Callback is invoked at the given time.\n * @param {Time} time The time relative to the AudioContext time\n * to invoke the callback.\n * @return {Tone.Draw} this\n */\nTone.Draw.prototype.schedule = function(callback, time){\n\tthis._events.add({\n\t\tcallback : callback,\n\t\ttime : this.toSeconds(time)\n\t});\n\t//start the draw loop on the first event\n\tif (this._events.length === 1){\n\t\trequestAnimationFrame(this._boundDrawLoop);\n\t}\n\treturn this;\n};\n\n/**\n * Cancel events scheduled after the given time\n * @param {Time=} after Time after which scheduled events will \n * be removed from the scheduling timeline.\n * @return {Tone.Draw} this\n */\nTone.Draw.prototype.cancel = function(after){\n\tthis._events.cancel(this.toSeconds(after));\n\treturn this;\n};\n\n/**\n * The draw loop\n * @private\n */\nTone.Draw.prototype._drawLoop = function(){\n\tvar now = Tone.context.currentTime;\n\twhile (this._events.length && this._events.peek().time - this.anticipation <= now){\n\t\tvar event = this._events.shift();\n\t\tif (now - event.time <= this.expiration){\n\t\t\tevent.callback();\n\t\t}\n\t}\n\tif (this._events.length > 0){\n\t\trequestAnimationFrame(this._boundDrawLoop);\n\t}\n};\n\n//make a singleton\nTone.Draw = new Tone.Draw();\n\nexport default Tone.Draw;\n\n","import Tone from \"../core/Tone\";\nimport \"../core/Gain\";\n\n/**\n * buses are another way of routing audio\n *\n * augments Tone.prototype to include send and receive\n */\n\n/**\n * All of the routes\n *\n * @type {Object}\n * @static\n * @private\n */\nvar Buses = {};\n\n/**\n * Send this signal to the channel name.\n * @param {String} channelName A named channel to send the signal to.\n * @param {Decibels} amount The amount of the source to send to the bus.\n * @return {GainNode} The gain node which connects this node to the desired channel.\n * Can be used to adjust the levels of the send.\n * @example\n * source.send(\"reverb\", -12);\n */\nTone.prototype.send = function(channelName, amount){\n\tif (!Buses.hasOwnProperty(channelName)){\n\t\tBuses[channelName] = this.context.createGain();\n\t}\n\tamount = Tone.defaultArg(amount, 0);\n\tvar sendKnob = new Tone.Gain(amount, Tone.Type.Decibels);\n\tthis.connect(sendKnob);\n\tsendKnob.connect(Buses[channelName]);\n\treturn sendKnob;\n};\n\n/**\n * Receive the input from the desired channelName to the input\n *\n * @param {String} channelName A named channel to send the signal to.\n * @param {Number=} channelNumber The channel to connect to\n * @returns {Tone} this\n * @example\n * reverbEffect.receive(\"reverb\");\n */\nTone.prototype.receive = function(channelName, inputNum){\n\tif (!Buses.hasOwnProperty(channelName)){\n\t\tBuses[channelName] = this.context.createGain();\n\t}\n\tTone.connect(Buses[channelName], this, 0, inputNum);\n\treturn this;\n};\n\n//remove all the send/receives when a new audio context is passed in\nTone.Context.on(\"init\", function(context){\n\tif (context.buses){\n\t\tBuses = context.buses;\n\t} else {\n\t\tBuses = {};\n\t\tcontext.buses = Buses;\n\t}\n});\n\nexport default Tone;\n\n","import Tone from \"../core/Tone\";\nimport \"../type/Type\";\n\n/**\n * @class Choose a random value.\n * @extends {Tone}\n * @example\n * var randomWalk = new Tone.CtrlRandom({\n * \t\"min\" : 0,\n * \t\"max\" : 10,\n * \t\"integer\" : true\n * });\n * randomWalk.eval();\n *\n * @param {Number|Time=} min The minimum return value.\n * @param {Number|Time=} max The maximum return value.\n */\nTone.CtrlRandom = function(){\n\n\tvar options = Tone.defaults(arguments, [\"min\", \"max\"], Tone.CtrlRandom);\n\tTone.call(this);\n\n\t/**\n\t * The minimum return value\n\t * @type {Number|Time}\n\t */\n\tthis.min = options.min;\n\n\t/**\n\t * The maximum return value\n\t * @type {Number|Time}\n\t */\n\tthis.max = options.max;\n\n\t/**\n\t * If the return value should be an integer\n\t * @type {Boolean}\n\t */\n\tthis.integer = options.integer;\n};\n\nTone.extend(Tone.CtrlRandom);\n\n/**\n * The defaults\n * @const\n * @type {Object}\n */\nTone.CtrlRandom.defaults = {\n\t\"min\" : 0,\n\t\"max\" : 1,\n\t\"integer\" : false\n};\n\n/**\n * Return a random value between min and max. \n * @readOnly\n * @memberOf Tone.CtrlRandom#\n * @type {*}\n * @name value\n */\nObject.defineProperty(Tone.CtrlRandom.prototype, \"value\", {\n\tget : function(){\n\t\tvar min = this.toSeconds(this.min);\n\t\tvar max = this.toSeconds(this.max);\n\t\tvar rand = Math.random(); \n\t\tvar val = rand * min + (1 - rand) * max;\n\t\tif (this.integer){\n\t\t\tval = Math.floor(val);\n\t\t}\n\t\treturn val;\n\t}\n});\n\nexport default Tone.CtrlRandom;\n\n","import Tone from \"../core/Tone\";\n\n/**\n * @class Tone.CtrlMarkov represents a Markov Chain where each call\n * to Tone.CtrlMarkov.next will move to the next state. If the next\n * state choice is an array, the next state is chosen randomly with\n * even probability for all of the choices. For a weighted probability\n * of the next choices, pass in an object with \"state\" and \"probability\" attributes. \n * The probabilities will be normalized and then chosen. If no next options\n * are given for the current state, the state will stay there. \n * @extends {Tone}\n * @example\n * var chain = new Tone.CtrlMarkov({\n * \t\"beginning\" : [\"end\", \"middle\"],\n * \t\"middle\" : \"end\"\n * });\n * chain.value = \"beginning\";\n * chain.next(); //returns \"end\" or \"middle\" with 50% probability\n *\n * @example\n * var chain = new Tone.CtrlMarkov({\n * \t\"beginning\" : [{\"value\" : \"end\", \"probability\" : 0.8}, \n * \t\t\t\t\t{\"value\" : \"middle\", \"probability\" : 0.2}],\n * \t\"middle\" : \"end\"\n * });\n * chain.value = \"beginning\";\n * chain.next(); //returns \"end\" with 80% probability or \"middle\" with 20%.\n * @param {Object} values An object with the state names as the keys\n * and the next state(s) as the values. \n */\nTone.CtrlMarkov = function(values, initial){\n\n\tTone.call(this);\n\n\t/**\n\t * The Markov values with states as the keys\n\t * and next state(s) as the values. \n\t * @type {Object}\n\t */\n\tthis.values = Tone.defaultArg(values, {});\n\t\n\t/**\n\t * The current state of the Markov values. The next\n\t * state will be evaluated and returned when Tone.CtrlMarkov.next\n\t * is invoked.\n\t * @type {String}\n\t */\n\tthis.value = Tone.defaultArg(initial, Object.keys(this.values)[0]);\n};\n\nTone.extend(Tone.CtrlMarkov);\n\n/**\n * Returns the next state of the Markov values. \n * @return {String}\n */\nTone.CtrlMarkov.prototype.next = function(){\n\tif (this.values.hasOwnProperty(this.value)){\n\t\tvar next = this.values[this.value];\n\t\tif (Tone.isArray(next)){\n\t\t\tvar distribution = this._getProbDistribution(next);\n\t\t\tvar rand = Math.random();\n\t\t\tvar total = 0;\n\t\t\tfor (var i = 0; i < distribution.length; i++){\n\t\t\t\tvar dist = distribution[i];\n\t\t\t\tif (rand > total && rand < total + dist){\n\t\t\t\t\tvar chosen = next[i];\n\t\t\t\t\tif (Tone.isObject(chosen)){\n\t\t\t\t\t\tthis.value = chosen.value;\n\t\t\t\t\t} else {\n\t\t\t\t\t\tthis.value = chosen;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\ttotal += dist;\n\t\t\t}\n\t\t} else {\n\t\t\tthis.value = next;\n\t\t}\n\t} \n\treturn this.value;\n};\n\n/**\n * Choose randomly from an array weighted options in the form \n * {\"state\" : string, \"probability\" : number} or an array of values\n * @param {Array} options \n * @return {Array} The randomly selected choice\n * @private\n */\nTone.CtrlMarkov.prototype._getProbDistribution = function(options){\n\tvar distribution = [];\n\tvar total = 0;\n\tvar needsNormalizing = false;\n\tfor (var i = 0; i < options.length; i++){\n\t\tvar option = options[i];\n\t\tif (Tone.isObject(option)){\n\t\t\tneedsNormalizing = true;\n\t\t\tdistribution[i] = option.probability;\n\t\t} else {\n\t\t\tdistribution[i] = 1 / options.length;\n\t\t}\n\t\ttotal += distribution[i];\n\t}\n\tif (needsNormalizing){\n\t\t//normalize the values\n\t\tfor (var j = 0; j < distribution.length; j++){\n\t\t\tdistribution[j] = distribution[j] / total;\n\t\t}\n\t}\n\treturn distribution;\n};\n\n/**\n * Clean up\n * @return {Tone.CtrlMarkov} this\n */\nTone.CtrlMarkov.prototype.dispose = function(){\n\tthis.values = null;\n};\n\nexport default Tone.CtrlMarkov;\n\n","import Tone from \"../core/Tone\";\nimport \"../type/Type\";\n\n/**\n * @class Tone.CtrlInterpolate will interpolate between given values based\n * on the \"index\" property. Passing in an array or object literal\n * will interpolate each of the parameters. Note (i.e. \"C3\")\n * and Time (i.e. \"4n + 2\") can be interpolated. All other values are\n * assumed to be numbers. \n * @example\n * var interp = new Tone.CtrlInterpolate([0, 2, 9, 4]);\n * interp.index = 0.75;\n * interp.value; //returns 1.5\n *\n * @example\n * var interp = new Tone.CtrlInterpolate([\n * \t[2, 4, 5],\n * \t[9, 3, 2],\n * ]);\n * @param {Array} values The array of values to interpolate over\n * @param {Positive} index The initial interpolation index.\n * @extends {Tone}\n */\nTone.CtrlInterpolate = function(){\n\n\tvar options = Tone.defaults(arguments, [\"values\", \"index\"], Tone.CtrlInterpolate);\n\tTone.call(this);\n\n\t/**\n\t * The values to interpolate between\n\t * @type {Array}\n\t */\n\tthis.values = options.values;\n\n\t/**\n\t * The interpolated index between values. For example: a value of 1.5\n\t * would interpolate equally between the value at index 1\n\t * and the value at index 2. \n\t * @example\n\t * interp.index = 0; \n\t * interp.value; //returns the value at 0\n\t * interp.index = 0.5;\n\t * interp.value; //returns the value between indices 0 and 1. \n\t * @type {Positive}\n\t */\n\tthis.index = options.index;\n};\n\nTone.extend(Tone.CtrlInterpolate);\n\n/**\n * The defaults\n * @const\n * @type {Object}\n */\nTone.CtrlInterpolate.defaults = {\n\t\"index\" : 0,\n\t\"values\" : []\n};\n\n/**\n * The current interpolated value based on the index\n * @readOnly\n * @memberOf Tone.CtrlInterpolate#\n * @type {*}\n * @name value\n */\nObject.defineProperty(Tone.CtrlInterpolate.prototype, \"value\", {\n\tget : function(){\n\t\tvar index = this.index;\n\t\tindex = Math.min(index, this.values.length - 1);\n\t\tvar lowerPosition = Math.floor(index);\n\t\tvar lower = this.values[lowerPosition];\n\t\tvar upper = this.values[Math.ceil(index)];\n\t\treturn this._interpolate(index - lowerPosition, lower, upper);\n\t}\n});\n\n/**\n * Internal interpolation routine\n * @param {NormalRange} index The index between the lower and upper\n * @param {*} lower \n * @param {*} upper \n * @return {*} The interpolated value\n * @private\n */\nTone.CtrlInterpolate.prototype._interpolate = function(index, lower, upper){\n\tif (Tone.isArray(lower)){\n\t\tvar retArray = [];\n\t\tfor (var i = 0; i < lower.length; i++){\n\t\t\tretArray[i] = this._interpolate(index, lower[i], upper[i]);\n\t\t}\n\t\treturn retArray;\n\t} else if (Tone.isObject(lower)){\n\t\tvar retObj = {};\n\t\tfor (var attr in lower){\n\t\t\tretObj[attr] = this._interpolate(index, lower[attr], upper[attr]);\n\t\t}\n\t\treturn retObj;\n\t} else {\n\t\tlower = this._toNumber(lower);\n\t\tupper = this._toNumber(upper);\n\t\treturn (1 - index) * lower + index * upper;\n\t}\n};\n\n/**\n * Convert from the given type into a number\n * @param {Number|String} value\n * @return {Number}\n * @private\n */\nTone.CtrlInterpolate.prototype._toNumber = function(val){\n\tif (Tone.isNumber(val)){\n\t\treturn val;\n\t} else {\n\t\t//otherwise assume that it's Time...\n\t\treturn this.toSeconds(val);\n\t}\n};\n\n/**\n * Clean up\n * @return {Tone.CtrlInterpolate} this\n */\nTone.CtrlInterpolate.prototype.dispose = function(){\n\tthis.values = null;\n};\n\nexport default Tone.CtrlInterpolate;\n\n","import Tone from \"../core/Tone\";\nimport \"../component/Analyser\";\nimport \"../core/AudioNode\";\n\n/**\n * @class Get the current waveform data of the connected audio source.\n * @extends {Tone.AudioNode}\n * @param {Number=} size The size of the FFT. Value must be a power of\n * two in the range 32 to 32768.\n */\nTone.Waveform = function(){\n\n\tvar options = Tone.defaults(arguments, [\"size\"], Tone.Waveform);\n\toptions.type = Tone.Analyser.Type.Waveform;\n\tTone.AudioNode.call(this);\n\n\t/**\n\t * The analyser node.\n\t * @private\n\t * @type {Tone.Analyser}\n\t */\n\tthis._analyser = this.input = this.output = new Tone.Analyser(options);\n};\n\nTone.extend(Tone.Waveform, Tone.AudioNode);\n\n/**\n * The default values.\n * @type {Object}\n * @const\n */\nTone.Waveform.defaults = {\n\t\"size\" : 1024\n};\n\n/**\n * Gets the waveform of the audio source. Returns the waveform data\n * of length [size](#size) as a Float32Array with values between -1 and 1.\n * @returns {TypedArray}\n */\nTone.Waveform.prototype.getValue = function(){\n\treturn this._analyser.getValue();\n};\n\n/**\n * The size of analysis. This must be a power of two in the range 32 to 32768.\n * @memberOf Tone.Waveform#\n * @type {Number}\n * @name size\n */\nObject.defineProperty(Tone.Waveform.prototype, \"size\", {\n\tget : function(){\n\t\treturn this._analyser.size;\n\t},\n\tset : function(size){\n\t\tthis._analyser.size = size;\n\t}\n});\n/**\n * Clean up.\n * @return {Tone.Waveform} this\n */\nTone.Waveform.prototype.dispose = function(){\n\tTone.AudioNode.prototype.dispose.call(this);\n\tthis._analyser.dispose();\n\tthis._analyser = null;\n};\n\nexport default Tone.Waveform;\n\n","import Tone from \"../core/Tone\";\nimport \"../component/CrossFade\";\nimport \"../component/Merge\";\nimport \"../component/Split\";\nimport \"../signal/Signal\";\nimport \"../signal/AudioToGain\";\nimport \"../signal/Zero\";\nimport \"../core/AudioNode\";\n\n/**\n * @class A spatialized panner node which supports equalpower or HRTF panning.\n * Tries to normalize the API across various browsers. See Tone.Listener\n *\n * @constructor\n * @extends {Tone.AudioNode}\n * @param {Number} positionX The initial x position.\n * @param {Number} positionY The initial y position.\n * @param {Number} positionZ The initial z position.\n */\nTone.Panner3D = function(){\n\n\tvar options = Tone.defaults(arguments, [\"positionX\", \"positionY\", \"positionZ\"], Tone.Panner3D);\n\tTone.AudioNode.call(this);\n\n\t/**\n\t * The panner node\n\t * @type {PannerNode}\n\t * @private\n\t */\n\tthis._panner = this.input = this.output = this.context.createPanner();\n\t//set some values\n\tthis._panner.panningModel = options.panningModel;\n\tthis._panner.maxDistance = options.maxDistance;\n\tthis._panner.distanceModel = options.distanceModel;\n\tthis._panner.coneOuterGain = options.coneOuterGain;\n\tthis._panner.coneOuterAngle = options.coneOuterAngle;\n\tthis._panner.coneInnerAngle = options.coneInnerAngle;\n\tthis._panner.refDistance = options.refDistance;\n\tthis._panner.rolloffFactor = options.rolloffFactor;\n\n\t/**\n\t * Holds the current orientation\n\t * @type {Array}\n\t * @private\n\t */\n\tthis._orientation = [options.orientationX, options.orientationY, options.orientationZ];\n\n\t/**\n\t * Holds the current position\n\t * @type {Array}\n\t * @private\n\t */\n\tthis._position = [options.positionX, options.positionY, options.positionZ];\n\n\t// set the default position/orientation\n\tthis.orientationX = options.orientationX;\n\tthis.orientationY = options.orientationY;\n\tthis.orientationZ = options.orientationZ;\n\tthis.positionX = options.positionX;\n\tthis.positionY = options.positionY;\n\tthis.positionZ = options.positionZ;\n};\n\nTone.extend(Tone.Panner3D, Tone.AudioNode);\n\n/**\n * Defaults according to the specification\n * @static\n * @const\n * @type {Object}\n */\nTone.Panner3D.defaults = {\n\t\"positionX\" : 0,\n\t\"positionY\" : 0,\n\t\"positionZ\" : 0,\n\t\"orientationX\" : 0,\n\t\"orientationY\" : 0,\n\t\"orientationZ\" : 0,\n\t\"panningModel\" : \"equalpower\",\n\t\"maxDistance\" : 10000,\n\t\"distanceModel\" : \"inverse\",\n\t\"coneOuterGain\" : 0,\n\t\"coneOuterAngle\" : 360,\n\t\"coneInnerAngle\" : 360,\n\t\"refDistance\" : 1,\n\t\"rolloffFactor\" : 1\n};\n\n/**\n * The ramp time which is applied to the setTargetAtTime\n * @type {Number}\n * @private\n */\nTone.Panner3D.prototype._rampTimeConstant = 0.01;\n\n/**\n * Sets the position of the source in 3d space.\n * @param {Number} x\n * @param {Number} y\n * @param {Number} z\n * @return {Tone.Panner3D} this\n */\nTone.Panner3D.prototype.setPosition = function(x, y, z){\n\tif (this._panner.positionX){\n\t\tvar now = this.now();\n\t\tthis._panner.positionX.setTargetAtTime(x, now, this._rampTimeConstant);\n\t\tthis._panner.positionY.setTargetAtTime(y, now, this._rampTimeConstant);\n\t\tthis._panner.positionZ.setTargetAtTime(z, now, this._rampTimeConstant);\n\t} else {\n\t\tthis._panner.setPosition(x, y, z);\n\t}\n\tthis._position = Array.prototype.slice.call(arguments);\n\treturn this;\n};\n\n/**\n * Sets the orientation of the source in 3d space.\n * @param {Number} x\n * @param {Number} y\n * @param {Number} z\n * @return {Tone.Panner3D} this\n */\nTone.Panner3D.prototype.setOrientation = function(x, y, z){\n\tif (this._panner.orientationX){\n\t\tvar now = this.now();\n\t\tthis._panner.orientationX.setTargetAtTime(x, now, this._rampTimeConstant);\n\t\tthis._panner.orientationY.setTargetAtTime(y, now, this._rampTimeConstant);\n\t\tthis._panner.orientationZ.setTargetAtTime(z, now, this._rampTimeConstant);\n\t} else {\n\t\tthis._panner.setOrientation(x, y, z);\n\t}\n\tthis._orientation = Array.prototype.slice.call(arguments);\n\treturn this;\n};\n\n/**\n * The x position of the panner object.\n * @type {Number}\n * @memberOf Tone.Panner3D#\n * @name positionX\n */\nObject.defineProperty(Tone.Panner3D.prototype, \"positionX\", {\n\tset : function(pos){\n\t\tthis._position[0] = pos;\n\t\tthis.setPosition.apply(this, this._position);\n\t},\n\tget : function(){\n\t\treturn this._position[0];\n\t}\n});\n\n/**\n * The y position of the panner object.\n * @type {Number}\n * @memberOf Tone.Panner3D#\n * @name positionY\n */\nObject.defineProperty(Tone.Panner3D.prototype, \"positionY\", {\n\tset : function(pos){\n\t\tthis._position[1] = pos;\n\t\tthis.setPosition.apply(this, this._position);\n\t},\n\tget : function(){\n\t\treturn this._position[1];\n\t}\n});\n\n/**\n * The z position of the panner object.\n * @type {Number}\n * @memberOf Tone.Panner3D#\n * @name positionZ\n */\nObject.defineProperty(Tone.Panner3D.prototype, \"positionZ\", {\n\tset : function(pos){\n\t\tthis._position[2] = pos;\n\t\tthis.setPosition.apply(this, this._position);\n\t},\n\tget : function(){\n\t\treturn this._position[2];\n\t}\n});\n\n/**\n * The x orientation of the panner object.\n * @type {Number}\n * @memberOf Tone.Panner3D#\n * @name orientationX\n */\nObject.defineProperty(Tone.Panner3D.prototype, \"orientationX\", {\n\tset : function(pos){\n\t\tthis._orientation[0] = pos;\n\t\tthis.setOrientation.apply(this, this._orientation);\n\t},\n\tget : function(){\n\t\treturn this._orientation[0];\n\t}\n});\n\n/**\n * The y orientation of the panner object.\n * @type {Number}\n * @memberOf Tone.Panner3D#\n * @name orientationY\n */\nObject.defineProperty(Tone.Panner3D.prototype, \"orientationY\", {\n\tset : function(pos){\n\t\tthis._orientation[1] = pos;\n\t\tthis.setOrientation.apply(this, this._orientation);\n\t},\n\tget : function(){\n\t\treturn this._orientation[1];\n\t}\n});\n\n/**\n * The z orientation of the panner object.\n * @type {Number}\n * @memberOf Tone.Panner3D#\n * @name orientationZ\n */\nObject.defineProperty(Tone.Panner3D.prototype, \"orientationZ\", {\n\tset : function(pos){\n\t\tthis._orientation[2] = pos;\n\t\tthis.setOrientation.apply(this, this._orientation);\n\t},\n\tget : function(){\n\t\treturn this._orientation[2];\n\t}\n});\n\n/**\n * Proxy a property on the panner to an exposed public propery\n * @param {String} prop\n * @private\n */\nTone.Panner3D._aliasProperty = function(prop){\n\tObject.defineProperty(Tone.Panner3D.prototype, prop, {\n\t\tset : function(val){\n\t\t\tthis._panner[prop] = val;\n\t\t},\n\t\tget : function(){\n\t\t\treturn this._panner[prop];\n\t\t}\n\t});\n};\n\n/**\n * The panning model. Either \"equalpower\" or \"HRTF\".\n * @type {String}\n * @memberOf Tone.Panner3D#\n * @name panningModel\n */\nTone.Panner3D._aliasProperty(\"panningModel\");\n\n/**\n * A reference distance for reducing volume as source move further from the listener\n * @type {Number}\n * @memberOf Tone.Panner3D#\n * @name refDistance\n */\nTone.Panner3D._aliasProperty(\"refDistance\");\n\n/**\n * Describes how quickly the volume is reduced as source moves away from listener.\n * @type {Number}\n * @memberOf Tone.Panner3D#\n * @name rolloffFactor\n */\nTone.Panner3D._aliasProperty(\"rolloffFactor\");\n\n/**\n * The distance model used by, \"linear\", \"inverse\", or \"exponential\".\n * @type {String}\n * @memberOf Tone.Panner3D#\n * @name distanceModel\n */\nTone.Panner3D._aliasProperty(\"distanceModel\");\n\n/**\n * The angle, in degrees, inside of which there will be no volume reduction\n * @type {Degrees}\n * @memberOf Tone.Panner3D#\n * @name coneInnerAngle\n */\nTone.Panner3D._aliasProperty(\"coneInnerAngle\");\n\n/**\n * The angle, in degrees, outside of which the volume will be reduced\n * to a constant value of coneOuterGain\n * @type {Degrees}\n * @memberOf Tone.Panner3D#\n * @name coneOuterAngle\n */\nTone.Panner3D._aliasProperty(\"coneOuterAngle\");\n\n/**\n * The gain outside of the coneOuterAngle\n * @type {Gain}\n * @memberOf Tone.Panner3D#\n * @name coneOuterGain\n */\nTone.Panner3D._aliasProperty(\"coneOuterGain\");\n\n/**\n * The maximum distance between source and listener,\n * after which the volume will not be reduced any further.\n * @type {Positive}\n * @memberOf Tone.Panner3D#\n * @name maxDistance\n */\nTone.Panner3D._aliasProperty(\"maxDistance\");\n\n/**\n * Clean up.\n * @returns {Tone.Panner3D} this\n */\nTone.Panner3D.prototype.dispose = function(){\n\tTone.AudioNode.prototype.dispose.call(this);\n\tthis._panner.disconnect();\n\tthis._panner = null;\n\tthis._orientation = null;\n\tthis._position = null;\n\treturn this;\n};\n\nexport default Tone.Panner3D;\n\n","import Tone from \"../core/Tone\";\nimport \"../component/MultibandSplit\";\nimport \"../component/Compressor\";\nimport \"../core/AudioNode\";\n\n/**\n * @class A compressor with seperate controls over low/mid/high dynamics\n *\n * @extends {Tone.AudioNode}\n * @constructor\n * @param {Object} options The low/mid/high compressor settings.\n * @example\n * var multiband = new Tone.MultibandCompressor({\n * \t\"lowFrequency\" : 200,\n * \t\"highFrequency\" : 1300\n * \t\"low\" : {\n * \t\t\"threshold\" : -12\n * \t}\n * })\n */\nTone.MultibandCompressor = function(options){\n\n\tTone.AudioNode.call(this);\n\toptions = Tone.defaultArg(arguments, Tone.MultibandCompressor.defaults);\n\n\t/**\n\t * split the incoming signal into high/mid/low\n\t * @type {Tone.MultibandSplit}\n\t * @private\n\t */\n\tthis._splitter = this.input = new Tone.MultibandSplit({\n\t\t\"lowFrequency\" : options.lowFrequency,\n\t\t\"highFrequency\" : options.highFrequency\n\t});\n\n\t/**\n\t * low/mid crossover frequency.\n\t * @type {Frequency}\n\t * @signal\n\t */\n\tthis.lowFrequency = this._splitter.lowFrequency;\n\n\t/**\n\t * mid/high crossover frequency.\n\t * @type {Frequency}\n\t * @signal\n\t */\n\tthis.highFrequency = this._splitter.highFrequency;\n\n\t/**\n\t * the output\n\t * @type {Tone.Gain}\n\t * @private\n\t */\n\tthis.output = new Tone.Gain();\n\n\t/**\n\t * The compressor applied to the low frequencies.\n\t * @type {Tone.Compressor}\n\t */\n\tthis.low = new Tone.Compressor(options.low);\n\n\t/**\n\t * The compressor applied to the mid frequencies.\n\t * @type {Tone.Compressor}\n\t */\n\tthis.mid = new Tone.Compressor(options.mid);\n\n\t/**\n\t * The compressor applied to the high frequencies.\n\t * @type {Tone.Compressor}\n\t */\n\tthis.high = new Tone.Compressor(options.high);\n\n\t//connect the compressor\n\tthis._splitter.low.chain(this.low, this.output);\n\tthis._splitter.mid.chain(this.mid, this.output);\n\tthis._splitter.high.chain(this.high, this.output);\n\n\tthis._readOnly([\"high\", \"mid\", \"low\", \"highFrequency\", \"lowFrequency\"]);\n};\n\nTone.extend(Tone.MultibandCompressor, Tone.AudioNode);\n\n/**\n * @const\n * @static\n * @type {Object}\n */\nTone.MultibandCompressor.defaults = {\n\t\"low\" : Tone.Compressor.defaults,\n\t\"mid\" : Tone.Compressor.defaults,\n\t\"high\" : Tone.Compressor.defaults,\n\t\"lowFrequency\" : 250,\n\t\"highFrequency\" : 2000\n};\n\n/**\n * clean up\n * @returns {Tone.MultibandCompressor} this\n */\nTone.MultibandCompressor.prototype.dispose = function(){\n\tTone.AudioNode.prototype.dispose.call(this);\n\tthis._splitter.dispose();\n\tthis._writable([\"high\", \"mid\", \"low\", \"highFrequency\", \"lowFrequency\"]);\n\tthis.low.dispose();\n\tthis.mid.dispose();\n\tthis.high.dispose();\n\tthis._splitter = null;\n\tthis.low = null;\n\tthis.mid = null;\n\tthis.high = null;\n\tthis.lowFrequency = null;\n\tthis.highFrequency = null;\n\treturn this;\n};\n\nexport default Tone.MultibandCompressor;\n\n","import Tone from \"../core/Tone\";\nimport \"../component/Merge\";\nimport \"../core/AudioNode\";\n\n/**\n * @class Tone.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 *\n * @extends {Tone.AudioNode}\n * @constructor\n */\nTone.Mono = function(){\n\n\tTone.AudioNode.call(this);\n\tthis.createInsOuts(1, 0);\n\n\t/**\n\t * merge the signal\n\t * @type {Tone.Merge}\n\t * @private\n\t */\n\tthis._merge = this.output = new Tone.Merge();\n\n\tTone.connect(this.input, this._merge, 0, 0);\n\tTone.connect(this.input, this._merge, 0, 1);\n};\n\nTone.extend(Tone.Mono, Tone.AudioNode);\n\n/**\n * clean up\n * @returns {Tone.Mono} this\n */\nTone.Mono.prototype.dispose = function(){\n\tTone.AudioNode.prototype.dispose.call(this);\n\tthis._merge.dispose();\n\tthis._merge = null;\n\treturn this;\n};\n\nexport default Tone.Mono;\n\n","import Tone from \"../core/Tone\";\nimport \"../component/MidSideSplit\";\nimport \"../component/MidSideMerge\";\nimport \"../component/Compressor\";\nimport \"../core/AudioNode\";\n\n/**\n * @class Tone.MidSideCompressor applies two different compressors to the mid\n * and side signal components. See Tone.MidSideSplit.\n *\n * @extends {Tone.AudioNode}\n * @param {Object} options The options that are passed to the mid and side\n * compressors.\n * @constructor\n */\nTone.MidSideCompressor = function(options){\n\n\tTone.AudioNode.call(this);\n\toptions = Tone.defaultArg(options, Tone.MidSideCompressor.defaults);\n\n\t/**\n\t * the mid/side split\n\t * @type {Tone.MidSideSplit}\n\t * @private\n\t */\n\tthis._midSideSplit = this.input = new Tone.MidSideSplit();\n\n\t/**\n\t * the mid/side recombination\n\t * @type {Tone.MidSideMerge}\n\t * @private\n\t */\n\tthis._midSideMerge = this.output = new Tone.MidSideMerge();\n\n\t/**\n\t * The compressor applied to the mid signal\n\t * @type {Tone.Compressor}\n\t */\n\tthis.mid = new Tone.Compressor(options.mid);\n\n\t/**\n\t * The compressor applied to the side signal\n\t * @type {Tone.Compressor}\n\t */\n\tthis.side = new Tone.Compressor(options.side);\n\n\tthis._midSideSplit.mid.chain(this.mid, this._midSideMerge.mid);\n\tthis._midSideSplit.side.chain(this.side, this._midSideMerge.side);\n\tthis._readOnly([\"mid\", \"side\"]);\n};\n\nTone.extend(Tone.MidSideCompressor, Tone.AudioNode);\n\n/**\n * @const\n * @static\n * @type {Object}\n */\nTone.MidSideCompressor.defaults = {\n\t\"mid\" : {\n\t\t\"ratio\" : 3,\n\t\t\"threshold\" : -24,\n\t\t\"release\" : 0.03,\n\t\t\"attack\" : 0.02,\n\t\t\"knee\" : 16\n\t},\n\t\"side\" : {\n\t\t\"ratio\" : 6,\n\t\t\"threshold\" : -30,\n\t\t\"release\" : 0.25,\n\t\t\"attack\" : 0.03,\n\t\t\"knee\" : 10\n\t}\n};\n\n/**\n * Clean up.\n * @returns {Tone.MidSideCompressor} this\n */\nTone.MidSideCompressor.prototype.dispose = function(){\n\tTone.AudioNode.prototype.dispose.call(this);\n\tthis._writable([\"mid\", \"side\"]);\n\tthis.mid.dispose();\n\tthis.mid = null;\n\tthis.side.dispose();\n\tthis.side = null;\n\tthis._midSideSplit.dispose();\n\tthis._midSideSplit = null;\n\tthis._midSideMerge.dispose();\n\tthis._midSideMerge = null;\n\treturn this;\n};\n\nexport default Tone.MidSideCompressor;\n\n","import Tone from \"../core/Tone\";\nimport \"../component/Analyser\";\nimport \"../core/AudioNode\";\n\n/**\n * @class Tone.Meter gets the [RMS](https://en.wikipedia.org/wiki/Root_mean_square)\n * of an input signal. It can also get the raw\n * value of the input signal.\n *\n * @constructor\n * @param {Number} smoothing The amount of smoothing applied between frames.\n * @extends {Tone.AudioNode}\n * @example\n * var meter = new Tone.Meter();\n * var mic = new Tone.UserMedia().open();\n * //connect mic to the meter\n * mic.connect(meter);\n * //the current level of the mic input in decibels\n * var level = meter.getLevel();\n */\nTone.Meter = function(){\n\n\tvar options = Tone.defaults(arguments, [\"smoothing\"], Tone.Meter);\n\tTone.AudioNode.call(this);\n\n\t/**\n\t * A value from 0 -> 1 where 0 represents no time averaging with the last analysis frame.\n\t * @type {Number}\n\t */\n\tthis.smoothing = options.smoothing;\n\n\t/**\n\t * The previous frame's value\n\t * @type {Number}\n\t * @private\n\t */\n\tthis._rms = 0;\n\n\t/**\n\t * The analyser node which computes the levels.\n\t * @private\n\t * @type {Tone.Analyser}\n\t */\n\tthis.input = this.output = this._analyser = new Tone.Analyser(\"waveform\", 256);\n};\n\nTone.extend(Tone.Meter, Tone.AudioNode);\n\n/**\n * The defaults\n * @type {Object}\n * @static\n * @const\n */\nTone.Meter.defaults = {\n\t\"smoothing\" : 0.8,\n};\n\n/**\n * Get the current decibel value of the incoming signal\n * @returns {Decibels}\n */\nTone.Meter.prototype.getLevel = function(){\n\tvar values = this._analyser.getValue();\n\tvar totalSquared = 0;\n\tfor (var i = 0; i < values.length; i++){\n\t\tvar value = values[i];\n\t\ttotalSquared += value * value;\n\t}\n\tvar rms = Math.sqrt(totalSquared / values.length);\n\n\t//the rms can only fall at the rate of the smoothing\n\t//but can jump up instantly\n\tthis._rms = Math.max(rms, this._rms * this.smoothing);\n\n\treturn Tone.gainToDb(this._rms);\n};\n\n/**\n * Get the signal value of the incoming signal\n * @returns {Number}\n */\nTone.Meter.prototype.getValue = function(){\n\tvar value = this._analyser.getValue();\n\treturn value[0];\n};\n\n/**\n * Clean up.\n * @returns {Tone.Meter} this\n */\nTone.Meter.prototype.dispose = function(){\n\tTone.AudioNode.prototype.dispose.call(this);\n\tthis._analyser.dispose();\n\tthis._analyser = null;\n\treturn this;\n};\n\nexport default Tone.Meter;\n\n","import Tone from \"../core/Tone\";\nimport \"../component/Compressor\";\nimport \"../core/AudioNode\";\n\n/**\n * @class Tone.Limiter will limit the loudness of an incoming signal.\n * It is composed of a Tone.Compressor with a fast attack\n * and release. Limiters are commonly used to safeguard against\n * signal clipping. Unlike a compressor, limiters do not provide\n * smooth gain reduction and almost completely prevent\n * additional gain above the threshold.\n *\n * @extends {Tone.AudioNode}\n * @constructor\n * @param {number} threshold The theshold above which the limiting is applied.\n * @example\n * var limiter = new Tone.Limiter(-6);\n */\nTone.Limiter = function(){\n\n\tvar options = Tone.defaults(arguments, [\"threshold\"], Tone.Limiter);\n\tTone.AudioNode.call(this);\n\n\t/**\n\t * the compressor\n\t * @private\n\t * @type {Tone.Compressor}\n\t */\n\tthis._compressor = this.input = this.output = new Tone.Compressor({\n\t\t\"attack\" : 0.001,\n\t\t\"decay\" : 0.001,\n\t\t\"threshold\" : options.threshold\n\t});\n\n\t/**\n\t * The threshold of of the limiter\n\t * @type {Decibel}\n\t * @signal\n\t */\n\tthis.threshold = this._compressor.threshold;\n\n\tthis._readOnly(\"threshold\");\n};\n\nTone.extend(Tone.Limiter, Tone.AudioNode);\n\n/**\n * The default value\n * @type {Object}\n * @const\n * @static\n */\nTone.Limiter.defaults = {\n\t\"threshold\" : -12\n};\n\n/**\n * Clean up.\n * @returns {Tone.Limiter} this\n */\nTone.Limiter.prototype.dispose = function(){\n\tTone.AudioNode.prototype.dispose.call(this);\n\tthis._compressor.dispose();\n\tthis._compressor = null;\n\tthis._writable(\"threshold\");\n\tthis.threshold = null;\n\treturn this;\n};\n\nexport default Tone.Limiter;\n\n","import Tone from \"../core/Tone\";\nimport \"../component/Follower\";\nimport \"../signal/GreaterThan\";\nimport \"../core/AudioNode\";\n\n/**\n * @class Tone.Gate only passes a signal through when the incoming\n * signal exceeds a specified threshold. To do this, Gate uses\n * a Tone.Follower to follow the amplitude of the incoming signal.\n * A common implementation of this class is a [Noise Gate](https://en.wikipedia.org/wiki/Noise_gate).\n *\n * @constructor\n * @extends {Tone.AudioNode}\n * @param {Decibels|Object} [threshold] The threshold above which the gate will open.\n * @param {Time=} smoothing The follower's smoothing time\n * @example\n * var gate = new Tone.Gate(-30, 0.2, 0.3).toMaster();\n * var mic = new Tone.UserMedia().connect(gate);\n * //the gate will only pass through the incoming\n * //signal when it's louder than -30db\n */\nTone.Gate = function(){\n\n\tvar options = Tone.defaults(arguments, [\"threshold\", \"smoothing\"], Tone.Gate);\n\tTone.AudioNode.call(this);\n\tthis.createInsOuts(1, 1);\n\n\t/**\n\t * @type {Tone.Follower}\n\t * @private\n\t */\n\tthis._follower = new Tone.Follower(options.smoothing);\n\n\t/**\n\t * @type {Tone.GreaterThan}\n\t * @private\n\t */\n\tthis._gt = new Tone.GreaterThan(Tone.dbToGain(options.threshold));\n\n\t//the connections\n\tTone.connect(this.input, this.output);\n\t//the control signal\n\tTone.connectSeries(this.input, this._follower, this._gt, this.output.gain);\n};\n\nTone.extend(Tone.Gate, Tone.AudioNode);\n\n/**\n * @const\n * @static\n * @type {Object}\n */\nTone.Gate.defaults = {\n\t\"smoothing\" : 0.1,\n\t\"threshold\" : -40\n};\n\n/**\n * The threshold of the gate in decibels\n * @memberOf Tone.Gate#\n * @type {Decibels}\n * @name threshold\n */\nObject.defineProperty(Tone.Gate.prototype, \"threshold\", {\n\tget : function(){\n\t\treturn Tone.gainToDb(this._gt.value);\n\t},\n\tset : function(thresh){\n\t\tthis._gt.value = Tone.dbToGain(thresh);\n\t}\n});\n\n/**\n * The attack/decay speed of the gate\n * @memberOf Tone.Gate#\n * @type {Time}\n * @name smoothing\n */\nObject.defineProperty(Tone.Gate.prototype, \"smoothing\", {\n\tget : function(){\n\t\treturn this._follower.smoothing;\n\t},\n\tset : function(smoothingTime){\n\t\tthis._follower.smoothing = smoothingTime;\n\t}\n});\n\n/**\n * Clean up.\n * @returns {Tone.Gate} this\n */\nTone.Gate.prototype.dispose = function(){\n\tTone.AudioNode.prototype.dispose.call(this);\n\tthis._follower.dispose();\n\tthis._gt.dispose();\n\tthis._follower = null;\n\tthis._gt = null;\n\treturn this;\n};\n\nexport default Tone.Gate;\n\n","import Tone from \"../core/Tone\";\nimport \"../component/Analyser\";\nimport \"../core/AudioNode\";\n\n/**\n * @class Get the current frequency data of the connected audio source\n * using a fast Fourier transform.\n * @extends {Tone.AudioNode}\n * @param {Number=} size The size of the FFT. Value must be a power of\n * two in the range 16 to 16384.\n */\nTone.FFT = function(){\n\n\tvar options = Tone.defaults(arguments, [\"size\"], Tone.FFT);\n\toptions.type = Tone.Analyser.Type.FFT;\n\tTone.AudioNode.call(this);\n\n\t/**\n\t * The analyser node.\n\t * @private\n\t * @type {Tone.Analyser}\n\t */\n\tthis._analyser = this.input = this.output = new Tone.Analyser(options);\n};\n\nTone.extend(Tone.FFT, Tone.AudioNode);\n\n/**\n * The default values.\n * @type {Object}\n * @const\n */\nTone.FFT.defaults = {\n\t\"size\" : 1024\n};\n\n/**\n * Gets the current frequency data from the connected audio source. \n * Returns the frequency data of length [size](#size) as a Float32Array of decibel values. \n * @returns {TypedArray}\n */\nTone.FFT.prototype.getValue = function(){\n\treturn this._analyser.getValue();\n};\n\n/**\n * The size of analysis. This must be a power of two in the range 16 to 16384.\n * Determines the size of the array returned by [getValue](#getvalue) (i.e. the number of\n * frequency bins). Large FFT sizes may be costly to compute.\n * @memberOf Tone.FFT#\n * @type {Number}\n * @name size\n */\nObject.defineProperty(Tone.FFT.prototype, \"size\", {\n\tget : function(){\n\t\treturn this._analyser.size;\n\t},\n\tset : function(size){\n\t\tthis._analyser.size = size;\n\t}\n});\n\n/**\n * Clean up.\n * @return {Tone.FFT} this\n */\nTone.FFT.prototype.dispose = function(){\n\tTone.AudioNode.prototype.dispose.call(this);\n\tthis._analyser.dispose();\n\tthis._analyser = null;\n};\n\nexport default Tone.FFT;\n\n","import Tone from \"../core/Tone\";\nimport \"../component/MultibandSplit\";\nimport \"../core/Gain\";\nimport \"../core/AudioNode\";\n\n/**\n * @class Tone.EQ3 is a three band EQ with control over low, mid, and high gain as\n * well as the low and high crossover frequencies.\n *\n * @constructor\n * @extends {Tone.AudioNode}\n *\n * @param {Decibels|Object} [lowLevel] The gain applied to the lows.\n * @param {Decibels} [midLevel] The gain applied to the mid.\n * @param {Decibels} [highLevel] The gain applied to the high.\n * @example\n * var eq = new Tone.EQ3(-10, 3, -20);\n */\nTone.EQ3 = function(){\n\n\tvar options = Tone.defaults(arguments, [\"low\", \"mid\", \"high\"], Tone.EQ3);\n\tTone.AudioNode.call(this);\n\n\t/**\n\t * the output node\n\t * @type {GainNode}\n\t * @private\n\t */\n\tthis.output = new Tone.Gain();\n\n\t/**\n\t * the multiband split\n\t * @type {Tone.MultibandSplit}\n\t * @private\n\t */\n\tthis._multibandSplit = this.input = new Tone.MultibandSplit({\n\t\t\"lowFrequency\" : options.lowFrequency,\n\t\t\"highFrequency\" : options.highFrequency\n\t});\n\n\t/**\n\t * The gain for the lower signals\n\t * @type {Tone.Gain}\n\t * @private\n\t */\n\tthis._lowGain = new Tone.Gain(options.low, Tone.Type.Decibels);\n\n\t/**\n\t * The gain for the mid signals\n\t * @type {Tone.Gain}\n\t * @private\n\t */\n\tthis._midGain = new Tone.Gain(options.mid, Tone.Type.Decibels);\n\n\t/**\n\t * The gain in decibels of the high part\n\t * @type {Tone.Gain}\n\t * @private\n\t */\n\tthis._highGain = new Tone.Gain(options.high, Tone.Type.Decibels);\n\n\t/**\n\t * The gain in decibels of the low part\n\t * @type {Decibels}\n\t * @signal\n\t */\n\tthis.low = this._lowGain.gain;\n\n\t/**\n\t * The gain in decibels of the mid part\n\t * @type {Decibels}\n\t * @signal\n\t */\n\tthis.mid = this._midGain.gain;\n\n\t/**\n\t * The gain in decibels of the high part\n\t * @type {Decibels}\n\t * @signal\n\t */\n\tthis.high = this._highGain.gain;\n\n\t/**\n\t * The Q value for all of the filters.\n\t * @type {Positive}\n\t * @signal\n\t */\n\tthis.Q = this._multibandSplit.Q;\n\n\t/**\n\t * The low/mid crossover frequency.\n\t * @type {Frequency}\n\t * @signal\n\t */\n\tthis.lowFrequency = this._multibandSplit.lowFrequency;\n\n\t/**\n\t * The mid/high crossover frequency.\n\t * @type {Frequency}\n\t * @signal\n\t */\n\tthis.highFrequency = this._multibandSplit.highFrequency;\n\n\t//the frequency bands\n\tthis._multibandSplit.low.chain(this._lowGain, this.output);\n\tthis._multibandSplit.mid.chain(this._midGain, this.output);\n\tthis._multibandSplit.high.chain(this._highGain, this.output);\n\tthis._readOnly([\"low\", \"mid\", \"high\", \"lowFrequency\", \"highFrequency\"]);\n};\n\nTone.extend(Tone.EQ3, Tone.AudioNode);\n\n/**\n * the default values\n */\nTone.EQ3.defaults = {\n\t\"low\" : 0,\n\t\"mid\" : 0,\n\t\"high\" : 0,\n\t\"lowFrequency\" : 400,\n\t\"highFrequency\" : 2500\n};\n\n/**\n * clean up\n * @returns {Tone.EQ3} this\n */\nTone.EQ3.prototype.dispose = function(){\n\tTone.AudioNode.prototype.dispose.call(this);\n\tthis._writable([\"low\", \"mid\", \"high\", \"lowFrequency\", \"highFrequency\"]);\n\tthis._multibandSplit.dispose();\n\tthis._multibandSplit = null;\n\tthis.lowFrequency = null;\n\tthis.highFrequency = null;\n\tthis._lowGain.dispose();\n\tthis._lowGain = null;\n\tthis._midGain.dispose();\n\tthis._midGain = null;\n\tthis._highGain.dispose();\n\tthis._highGain = null;\n\tthis.low = null;\n\tthis.mid = null;\n\tthis.high = null;\n\tthis.Q = null;\n\treturn this;\n};\n\nexport default Tone.EQ3;\n\n","import Tone from \"../core/Tone\";\nimport \"../component/PanVol\";\nimport \"../component/Solo\";\nimport \"../core/AudioNode\";\n\n/**\n * @class Tone.Channel provides a channel strip interface with \n * volume, pan, solo and mute controls. \n *\n * @extends {Tone.AudioNode}\n * @constructor\n * @param {Decibels} volume The output volume.\n * @param {AudioRange} pan the initial pan\n * @example\n * //pan the incoming signal left and drop the volume\n * var channel = new Tone.Channel(-0.25, -12);\n */\nTone.Channel = function(){\n\n\tvar options = Tone.defaults(arguments, [\"volume\", \"pan\"], Tone.PanVol);\n\tTone.AudioNode.call(this, options);\n\n\t/**\n\t * The soloing interface\n\t * @type {Tone.Solo}\n\t * @private\n\t */\n\tthis._solo = this.input = new Tone.Solo(options.solo);\n\n\t/**\n\t * The panning and volume node\n\t * @type {Tone.PanVol}\n\t * @private\n\t */\n\tthis._panVol = this.output = new Tone.PanVol({\n\t\t\"pan\" : options.pan, \n\t\t\"volume\" : options.volume,\n\t\t\"mute\" : options.mute\n\t});\n\n\t/**\n\t * The L/R panning control.\n\t * @type {AudioRange}\n\t * @signal\n\t */\n\tthis.pan = this._panVol.pan;\n\n\t/**\n\t * The volume control in decibels.\n\t * @type {Decibels}\n\t * @signal\n\t */\n\tthis.volume = this._panVol.volume;\n\n\tthis._solo.connect(this._panVol);\n\tthis._readOnly([\"pan\", \"volume\"]);\n};\n\nTone.extend(Tone.Channel, Tone.AudioNode);\n\n/**\n * The defaults\n * @type {Object}\n * @const\n * @static\n */\nTone.Channel.defaults = {\n\t\"pan\" : 0,\n\t\"volume\" : 0,\n\t\"mute\" : false,\n\t\"solo\" : false\n};\n\n/**\n * Solo/unsolo the channel. Soloing is only relative to other\n * Tone.Channels and Tone.Solos. \n * @memberOf Tone.Channel#\n * @name solo\n * @type {Boolean}\n */\nObject.defineProperty(Tone.Channel.prototype, \"solo\", {\n\tget : function(){\n\t\treturn this._solo.solo;\n\t},\n\tset : function(solo){\n\t\tthis._solo.solo = solo;\n\t}\n});\n\n/**\n * If the current instance is muted, i.e. another instance is soloed,\n * or the channel is muted\n * @memberOf Tone.Channel#\n * @type {Boolean}\n * @name muted\n * @readOnly\n */\nObject.defineProperty(Tone.Channel.prototype, \"muted\", {\n\tget : function(){\n\t\treturn this._solo.muted || this.mute;\n\t}\n});\n\n/**\n * Mute/unmute the volume\n * @memberOf Tone.Channel#\n * @name mute\n * @type {Boolean}\n */\nObject.defineProperty(Tone.Channel.prototype, \"mute\", {\n\tget : function(){\n\t\treturn this._panVol.mute;\n\t},\n\tset : function(mute){\n\t\tthis._panVol.mute = mute;\n\t}\n});\n\n/**\n * clean up\n * @returns {Tone.Channel} this\n */\nTone.Channel.prototype.dispose = function(){\n\tTone.AudioNode.prototype.dispose.call(this);\n\tthis._writable([\"pan\", \"volume\"]);\n\tthis._panVol.dispose();\n\tthis._panVol = null;\n\tthis.pan = null;\n\tthis.volume = null;\n\tthis._solo.dispose();\n\tthis._solo = null;\n\treturn this;\n};\n\nexport default Tone.Channel;\n\n","var g;\r\n\r\n// This works in non-strict mode\r\ng = (function() {\r\n\treturn this;\r\n})();\r\n\r\ntry {\r\n\t// This works if eval is allowed (see CSP)\r\n\tg = g || Function(\"return this\")() || (1, eval)(\"this\");\r\n} catch (e) {\r\n\t// This works if the window reference is available\r\n\tif (typeof window === \"object\") g = window;\r\n}\r\n\r\n// g can still be undefined, but nothing to do about it...\r\n// We return undefined, instead of nothing here, so it's\r\n// easier to handle this case. if(!global) { ...}\r\n\r\nmodule.exports = g;\r\n","require(\"./component/AmplitudeEnvelope\");\nrequire(\"./component/Analyser\");\nrequire(\"./component/Channel\");\nrequire(\"./component/Compressor\");\nrequire(\"./component/CrossFade\");\nrequire(\"./component/Envelope\");\nrequire(\"./component/EQ3\");\nrequire(\"./component/FeedbackCombFilter\");\nrequire(\"./component/FFT\");\nrequire(\"./component/Filter\");\nrequire(\"./component/Follower\");\nrequire(\"./component/FrequencyEnvelope\");\nrequire(\"./component/Gate\");\nrequire(\"./component/LFO\");\nrequire(\"./component/Limiter\");\nrequire(\"./component/LowpassCombFilter\");\nrequire(\"./component/Merge\");\nrequire(\"./component/Meter\");\nrequire(\"./component/MidSideCompressor\");\nrequire(\"./component/MidSideMerge\");\nrequire(\"./component/MidSideSplit\");\nrequire(\"./component/Mono\");\nrequire(\"./component/MultibandCompressor\");\nrequire(\"./component/MultibandSplit\");\nrequire(\"./component/Panner\");\nrequire(\"./component/Panner3D\");\nrequire(\"./component/PanVol\");\nrequire(\"./component/ScaledEnvelope\");\nrequire(\"./component/Solo\");\nrequire(\"./component/Split\");\nrequire(\"./component/Volume\");\nrequire(\"./component/Waveform\");\nrequire(\"./control/CtrlInterpolate\");\nrequire(\"./control/CtrlMarkov\");\nrequire(\"./control/CtrlPattern\");\nrequire(\"./control/CtrlRandom\");\nrequire(\"./core/AudioNode\");\nrequire(\"./core/Buffer\");\nrequire(\"./core/Buffers\");\nrequire(\"./core/Bus\");\nrequire(\"./core/Clock\");\nrequire(\"./core/Context\");\nrequire(\"./core/Delay\");\nrequire(\"./core/Draw\");\nrequire(\"./core/Emitter\");\nrequire(\"./core/Gain\");\nrequire(\"./core/IntervalTimeline\");\nrequire(\"./core/Listener\");\nrequire(\"./core/Master\");\nrequire(\"./core/Offline\");\nrequire(\"./core/OfflineContext\");\nrequire(\"./core/Param\");\nrequire(\"./core/Timeline\");\nrequire(\"./core/TimelineState\");\nrequire(\"./core/Transport\");\nrequire(\"./core/TransportEvent\");\nrequire(\"./core/TransportRepeatEvent\");\nrequire(\"./effect/AutoFilter\");\nrequire(\"./effect/AutoPanner\");\nrequire(\"./effect/AutoWah\");\nrequire(\"./effect/BitCrusher\");\nrequire(\"./effect/Chebyshev\");\nrequire(\"./effect/Chorus\");\nrequire(\"./effect/Convolver\");\nrequire(\"./effect/Distortion\");\nrequire(\"./effect/Effect\");\nrequire(\"./effect/FeedbackDelay\");\nrequire(\"./effect/FeedbackEffect\");\nrequire(\"./effect/Freeverb\");\nrequire(\"./effect/JCReverb\");\nrequire(\"./effect/MidSideEffect\");\nrequire(\"./effect/Phaser\");\nrequire(\"./effect/PingPongDelay\");\nrequire(\"./effect/PitchShift\");\nrequire(\"./effect/Reverb\");\nrequire(\"./effect/StereoEffect\");\nrequire(\"./effect/StereoFeedbackEffect\");\nrequire(\"./effect/StereoWidener\");\nrequire(\"./effect/StereoXFeedbackEffect\");\nrequire(\"./effect/Tremolo\");\nrequire(\"./effect/Vibrato\");\nrequire(\"./event/Event\");\nrequire(\"./event/Loop\");\nrequire(\"./event/Part\");\nrequire(\"./event/Pattern\");\nrequire(\"./event/Sequence\");\nrequire(\"./instrument/AMSynth\");\nrequire(\"./instrument/DuoSynth\");\nrequire(\"./instrument/FMSynth\");\nrequire(\"./instrument/Instrument\");\nrequire(\"./instrument/MembraneSynth\");\nrequire(\"./instrument/MetalSynth\");\nrequire(\"./instrument/Monophonic\");\nrequire(\"./instrument/MonoSynth\");\nrequire(\"./instrument/NoiseSynth\");\nrequire(\"./instrument/PluckSynth\");\nrequire(\"./instrument/PolySynth\");\nrequire(\"./instrument/Sampler\");\nrequire(\"./instrument/Synth\");\nrequire(\"./signal/Abs\");\nrequire(\"./signal/Add\");\nrequire(\"./signal/AudioToGain\");\nrequire(\"./signal/EqualPowerGain\");\nrequire(\"./signal/GainToAudio\");\nrequire(\"./signal/GreaterThan\");\nrequire(\"./signal/GreaterThanZero\");\nrequire(\"./signal/Modulo\");\nrequire(\"./signal/Multiply\");\nrequire(\"./signal/Negate\");\nrequire(\"./signal/Normalize\");\nrequire(\"./signal/Pow\");\nrequire(\"./signal/Scale\");\nrequire(\"./signal/ScaleExp\");\nrequire(\"./signal/Signal\");\nrequire(\"./signal/SignalBase\");\nrequire(\"./signal/Subtract\");\nrequire(\"./signal/TickSignal\");\nrequire(\"./signal/TransportTimelineSignal\");\nrequire(\"./signal/WaveShaper\");\nrequire(\"./signal/Zero\");\nrequire(\"./source/AMOscillator\");\nrequire(\"./source/BufferSource\");\nrequire(\"./source/FatOscillator\");\nrequire(\"./source/FMOscillator\");\nrequire(\"./source/GrainPlayer\");\nrequire(\"./source/Noise\");\nrequire(\"./source/OmniOscillator\");\nrequire(\"./source/Oscillator\");\nrequire(\"./source/OscillatorNode\");\nrequire(\"./source/Player\");\nrequire(\"./source/Players\");\nrequire(\"./source/PulseOscillator\");\nrequire(\"./source/PWMOscillator\");\nrequire(\"./source/Source\");\nrequire(\"./source/TickSource\");\nrequire(\"./source/UserMedia\");\nrequire(\"./type/Frequency\");\nrequire(\"./type/Midi\");\nrequire(\"./type/Ticks\");\nrequire(\"./type/Time\");\nrequire(\"./type/TimeBase\");\nrequire(\"./type/TransportTime\");\nrequire(\"./type/Type\");\nmodule.exports = require(\"./core/Tone\").default;\n"],"sourceRoot":""}