mercury-engine 1.2.2 → 1.3.0

package/dist/mercury.js

@@ -6656,6 +6656,12 @@ module.exports={
 		"polyphonic"
 	], 
 
+	"program" : [
+		"programChange",
+		"pgm",
+		"pc"
+	],
+
 	"tempo" : [
 		"bpm"
 	],
@@ -7367,13 +7373,21 @@ function traverseTree(tree, code, level, obj){
 			let inst = map['@inst'](el['@inst'], ccode);
 			delete el['@inst'];
 			
+			// generate unique ID name for object before checking the name()
+			// this ID is used for groups if there are any
+			inst.functions.name = [ uniqueID(8) ];
+			
 			Object.keys(el).forEach((k) => {
 				inst = map[k](el[k], ccode, '@object', inst);
 			});
+			// add the name to the all group
+			ccode.groups.all.push(inst.functions.name[0]);
+
 			// generate unique ID name for object if no name()
-			if (!inst.functions.name){
-				inst.functions.name = [ uniqueID(8) ];
-			}
+			// if (!inst.functions.name){
+			// 	inst.functions.name = [ uniqueID(8) ];
+			// }
+			// console.log('code', ccode);
 			// add object to complete code
 			ccode.objects[inst.functions.name] = inst;
 			return ccode;
@@ -7391,15 +7405,27 @@ function traverseTree(tree, code, level, obj){
 					inst = map[k](el[k], ccode, '@object', inst);
 				});
 				ccode.objects[inst.functions.name] = inst;
-			} else if (name === 'all'){
+			} else if (code.groups[name]){ //name === 'all' 
 				// if set all, set all instrument objects
-				Object.keys(ccode.objects).forEach((o) => {
+				code.groups[name].forEach((o) => {
 					let inst = ccode.objects[o];
-					Object.keys(el).forEach((k) => {
-						inst = map[k](el[k], ccode, '@object', inst);
-					});
-					ccode.objects[inst.functions.name] = inst;
+					if (inst){
+						Object.keys(el).forEach((k) => {
+							inst = map[k](el[k], ccode, '@object', inst);
+						});
+						ccode.objects[inst.functions.name] = inst;
+					}
 				});
+
+				// console.log(ccode.objects);
+
+				// Object.keys(ccode.objects).forEach((o) => {
+				// 	let inst = ccode.objects[o];
+				// 	Object.keys(el).forEach((k) => {
+				// 		inst = map[k](el[k], ccode, '@object', inst);
+				// 	});
+				// 	ccode.objects[inst.functions.name] = inst;
+				// });
 			} else {
 				// if name is part of global settings
 				let args;
@@ -7507,12 +7533,16 @@ function traverseTree(tree, code, level, obj){
 				if (func === 'add_fx'){
 					funcs[func].push(args);
 				} else {
-					if (func === 'name'){
-						ccode.groups.all.push(...args);
-					}
-					else if (func === 'group'){
-						// TO-DO:
-						// code for group functions
+					// if (func === 'name'){
+						// ccode.groups.all.push(...args);
+					// } else 
+					if (func === 'group'){
+						args.forEach((a) => {
+							// add empty array if the group doesn't exist yet
+							if (!ccode.groups[a]) { ccode.groups[a] = []; }
+							// add the name of the inst to the group array
+							ccode.groups[a].push(funcs.name[0]);
+						});
 					}
 					funcs[func] = args;
 				}
@@ -7710,6 +7740,18 @@ const functionMap = {
 	'rectF' : (...v) => {
 		return Gen.squareFloat(...v);
 	},
+	'binaryBeat' : (...v) => {
+		return Gen.binaryBeat(...v);
+	},
+	'binary' : (...v) => {
+		return Gen.binaryBeat(...v);
+	},
+	'spacingBeat' : (...v) => {
+		return Gen.spacingBeat(...v);
+	},
+	'spacing' : (...v) => {
+		return Gen.spacingBeat(...v);
+	},
 	// 
 	// Algorithmic Methods
 	// 
@@ -7850,6 +7892,40 @@ const functionMap = {
 		v[1] = Math.max(2, (Array.isArray(v[1])) ? v[1][0] : v[1]);
 		return Rand.expand(v[0], v[1]);
 	},
+	// markov chain methods
+	// combine the markovTrain with markovChain
+	// first train the model based on a list
+	// then generate a list output from the chain
+	'markovTrain' : (...v) => {
+		// generate markovchain from the incoming list
+		let markov = new Rand.DeepMarkovChain(...v);
+		// create string of data
+		let data = markov.stringify();
+		// clear data and delete
+		markov.clear();
+		markov = null;
+		// output the table as a string array to use for generating
+		return [ data ];
+	},
+	'markov' : (...v) => {
+		return functionMap['markovTrain'](...v);
+	},
+	'markovChain' : (...v) => {
+		// train from a markov table and generate a chain
+		let markov = new Rand.DeepMarkovChain();
+		markov.parse(v[1]);
+		// set the seed based on the global seed
+		markov.seed(Rand.getSeed());
+		let gen = markov.chain(v[0]);
+		// clear the data and remove markov
+		markov.clear();
+		markov = null;
+		// return generated array
+		return gen;
+	},
+	'chain' : (...v) => {
+		return functionMap['markovChain'](...v);
+	},
 	// 
 	// Transformational Methods
 	// 
@@ -8161,15 +8237,19 @@ const functionMap = {
 	'chordsNamed' : (...v) => {
 		return functionMap.chordsFromNames(v);
 	},
+	// translate text to ASCII
+	'textCode' : (...v) => {
+		return TL.textCode(...v);
+	},
 	// 
 	// Statistic Methods
 	// 
 	// IMPLEMENTATION NEEDED
 	// maximum
 	// minimum
-	// mean
-	// median
-	// mode
+	// mean / average
+	// median / center
+	// mode / common
 
 	// 
 	// Utility Methods
@@ -8271,7 +8351,49 @@ const functionMap = {
 	},
 	'ceil' : (v) => {
 		return Util.arrayCalc(v, 0, (a) => Math.ceil(a));
-	}
+	},
+	// compare two lists for equals
+	'equals' : (...v) => {
+		return Util.arrayCalc(v[0], v[1], (a,b) => Number(a === b));
+	},
+	'eq' : (...v) => {
+		return functionMap.equals(...v);
+	},
+	// compare two lists for not equal
+	'notEquals' : (...v) => {
+		return Util.arrayCalc(v[0], v[1], (a,b) => Number(a !== b));
+	},
+	'neq' : (...v) => {
+		return functionMap.notEquals(...v);
+	},
+	// compare left for greater than right list
+	'greater' : (...v) => {
+		return Util.arrayCalc(v[0], v[1], (a,b) => Number(a > b));	
+	},
+	'gt' : (...v) => {
+		return functionMap.greater(...v);
+	},
+	// compare left for greater than or equal to right list
+	'greaterEquals' : (...v) => {
+		return Util.arrayCalc(v[0], v[1], (a,b) => Number(a >= b));	
+	},
+	'gte' : (...v) => {
+		return functionMap.greaterEquals(...v);
+	},
+	// compare left for less than right list
+	'less' : (...v) => {
+		return Util.arrayCalc(v[0], v[1], (a,b) => Number(a < b));	
+	},
+	'lt' : (...v) => {
+		return functionMap.less(...v);
+	},
+	// compare left for less than or equal to right list
+	'lessEquals' : (...v) => {
+		return Util.arrayCalc(v[0], v[1], (a,b) => Number(a <= b));	
+	},
+	'lte' : (...v) => {
+		return functionMap.lessEquals(...v);
+	},
 }
 exports.functionMap = functionMap;
 },{"total-serialism":47}],33:[function(require,module,exports){
@@ -12190,9 +12312,11 @@ class MarkovChain {
 	read(t){
 		// read a markov chain table from a json file
 		if (Array.isArray(t) || typeof t !== 'object'){
-			return console.error(`Error: input is not a valid json formatted table. If your input is an array use train() instead.`);
+			console.error(`Error: input is not a valid json formatted table. If your input is an array use train() instead.`);
+			return false;
 		}
 		this._table = t;
+		return true;
 	}
 	clear(){
 		// empty the transition probabilities
@@ -12263,18 +12387,46 @@ exports.MarkovChain = MarkovChain;
 // @method chain() -> generate an array of values (default length=2)
 // 
 class DeepMarkov {
-	constructor(data){
+	constructor(data, order){
 		// transition probabilities table
 		this._table = new Map();
 		// train if dataset is provided
-		if (data) { this.train(data) };
+		if (data) { this.train(data, order) };
 		// current state of markov chain
 		this._state = '';
 	}
 	get table(){
-		// return copy of object
+		// return copy of Map object
 		return new Map(JSON.parse(JSON.stringify(Array.from(this._table))));
 	}
+	read(t){
+		// read a markov chain table from a Map() generated with DeepMarkov
+		if (Array.isArray(t) || t instanceof Map === false){
+			console.error(`Error: input is not a valid Map() formatted table. If your input is an array use train() instead.`);
+			return false;
+		}
+		this._table = t;
+		return true;
+	}
+	stringify(){
+		// return stringified version of the DeepMarkov table
+		return JSON.stringify(this._table, replacer);
+	}
+	parse(p){
+		// parse an incoming string to a Map() for transition table
+		try {
+			let parsed = JSON.parse(p, reviver);
+			if (parsed instanceof Map === false){
+				console.error(`Error: input is not a valid string that can be parsed to a Map().`)
+				return false;
+			}
+			this._table = parsed;
+			return true;
+		} catch (e) {
+			console.error(`Error: input is not a valid string that can be parsed to a Map().`);
+			return false;
+		}
+	}
 	clear(){
 		// empty the transition probabilities
 		this._table = new Map();
@@ -12348,6 +12500,30 @@ class DeepMarkov {
 }
 exports.DeepMarkov = DeepMarkov;
 exports.DeepMarkovChain = DeepMarkov;
+
+// functions thanks to:
+// https://stackoverflow.com/questions/29085197/how-do-you-json-stringify-an-es6-map
+// helper function for Stringifying a Map() in DeepMarkov
+function replacer(key, value) {
+	if (value instanceof Map) {
+		return {
+			dataType: 'Map',
+			value: [...value]
+			// value: [Array.from(value.entries())], 
+		};
+	}
+	return value;
+}
+
+// helper function for parsing a Map() in DeepMarkov
+function reviver(key, value) {
+	if (typeof value === 'object' && value !== null) {
+		if (value.dataType === 'Map') {
+			return new Map(value.value);
+		}
+	}
+	return value;
+}
 },{"./gen-basic.js":48,"./statistic":51,"./transform.js":52,"./utility":54,"seedrandom":36}],51:[function(require,module,exports){
 //=======================================================================
 // statistic.js
@@ -12545,7 +12721,11 @@ exports.diff = change;
 // by Timo Hoogland (@t.mo / @tmhglnd), www.timohoogland.com
 // MIT License
 //
-// Basic methods that can transform number sequences
+// Methods that transform number sequences
+// These are called the "transformers"
+// A transformer always takes an input list as the first argument
+// A transformer never destructively changes the input list
+// The output of the transformer is the modified input list(s)
 // 
 // TODO:
 // - make invert() work with note-values 'c' etc.
@@ -12561,7 +12741,7 @@ exports.diff = change;
 // require the Utility methods
 // const Rand = require('./gen-stochastic');
 const { sort } = require('./statistic');
-const { flatten, add, max, min, lerp, toArray, size } = require('./utility');
+const { flat, add, max, min, lerp, toArray, size, unique, arrayCombinations } = require('./utility');
 
 // Duplicate an array multiple times,
 // optionaly add an offset to every value when duplicating
@@ -12574,11 +12754,12 @@ const { flatten, add, max, min, lerp, toArray, size } = require('./utility');
 // 
 function clone(a=[0], ...c){
 	a = toArray(a);
-	// flatten clone array if multi-dimensional
 	if (!c.length) { 
+		// return input if no clone arguments
 		return a;
 	} else { 
-		c = flatten(c); 
+		// flatten clone array if multi-dimensional
+		c = flat(c); 
 	}
 	let arr = [];
 	for (let i=0; i<c.length; i++){
@@ -12594,11 +12775,11 @@ exports.clone = clone;
 // @params {Array0, Array1, ..., Array-n} -> Arrays to join
 // @return {Array}
 // 
-function combine(...args){
-	if (!args.length){ return [0]; }
+function combine(...arrs){
+	if (!arrs.length){ return [0]; }
 	let arr = [];
-	for (let i=0; i<args.length; i++){
-		arr = arr.concat(args[i]);
+	for (let i=0; i<arrs.length; i++){
+		arr = arr.concat(arrs[i]);
 	}
 	return arr;
 }
@@ -12644,8 +12825,8 @@ exports.every = every;
 // flatten a multidimensional array. Optionally set the depth
 // for the flattening
 //
-exports.flatten = flatten;
-exports.flat = flatten;
+exports.flatten = flat;
+exports.flat = flat;
 
 // similar to every(), but instead of specifying bars/divisions
 // this method allows you to specify the exact length of the array
@@ -12734,12 +12915,15 @@ function invert(a=[0], lo, hi){
 	a = toArray(a);
 
 	if (lo === undefined){
+		// if no center value set lo/hi based on min/max
 		hi = max(a);
 		lo = min(a);
 	} else if (hi === undefined){
+		// if no hi defined set hi to be same as lo
 		hi = lo;
 	}
 	return a.slice().map(v => {
+		// apply the algorithm recursively for all items
 		if (Array.isArray(v)){
 			return invert(v, lo, hi);
 		}
@@ -12753,17 +12937,19 @@ exports.invert = invert;
 // @param {Array0, Array1, ..., Array-n} -> arrays to interleave
 // @return {Array}
 //  
-function lace(...args){
-	if (!args.length){ return [0]; }
+function lace(...arrs){
+	if (!arrs.length){ return [0]; }
+	// get the length of longest list
 	var l = 0;
-	for (let i=0; i<args.length; i++){
-		args[i] = toArray(args[i]);
-		l = Math.max(args[i].length, l);
+	for (let i=0; i<arrs.length; i++){
+		arrs[i] = toArray(arrs[i]);
+		l = Math.max(arrs[i].length, l);
 	}
+	// for the max length push all values of the various lists
 	var arr = [];
 	for (var i=0; i<l; i++){
-		for (var k=0; k<args.length; k++){
-			let v = args[k][i];
+		for (var k=0; k<arrs.length; k++){
+			let v = arrs[k][i];
 			if (v !== undefined){ arr.push(v); }
 		}
 	}
@@ -12785,7 +12971,8 @@ function lookup(idx=[0], arr=[0]){
 	arr = toArray(arr);
 	let a = [];
 	let len = arr.length;
-	for (let i in idx){
+	for (let i=0; i<idx.length; i++){
+		// recursively lookup values for multidimensional arrays
 		if (Array.isArray(idx[i])){
 			a.push(lookup(idx[i], arr));
 		} else {
@@ -12806,18 +12993,18 @@ exports.lookup = lookup;
 // @params {Array0, Array1, ..., Array-n} -> Arrays to merge
 // @return {Array}
 // 
-function merge(...args){
-	if (!args.length){ return [0]; }
+function merge(...arrs){
+	if (!arrs.length){ return [0]; }
 	let l = 0;
-	for (let i=0; i<args.length; i++){
-		args[i] = toArray(args[i]);
-		l = Math.max(args[i].length, l);
+	for (let i=0; i<arrs.length; i++){
+		arrs[i] = toArray(arrs[i]);
+		l = Math.max(arrs[i].length, l);
 	}
 	let arr = [];
 	for (let i=0; i<l; i++){
 		let a = [];
-		for (let k=0; k<args.length; k++){
-			let v = args[k][i];
+		for (let k=0; k<arrs.length; k++){
+			let v = arrs[k][i];
 			if (v !== undefined){ 
 				if (Array.isArray(v)) a.push(...v);
 				else a.push(v);
@@ -12862,7 +13049,7 @@ function repeat(arr=[0], rep=1){
 	rep = toArray(rep);
 	
 	let a = [];
-	for (let i in arr){
+	for (let i=0; i<arr.length; i++){
 		let r = rep[i % rep.length];
 		r = (isNaN(r) || r < 0)? 0 : r;
 		for (let k=0; k<r; k++){
@@ -12916,7 +13103,7 @@ exports.sort = sort;
 // @params {Number|Array} -> slice points
 // @return {Array}
 // 
-function slice(a=[0], s=[1], r=true){
+function slice(a=[0], s=[0], r=true){
 	a = toArray(a);
 	s = toArray(s);
 
@@ -12930,7 +13117,9 @@ function slice(a=[0], s=[1], r=true){
 		}
 	}
 	if (r){
-		arr.push(a.slice(_s, a.length));
+		let rest = a.slice(_s, a.length);
+		// attach the rest if not an empty array and r=true
+		if (rest.length > 0){ arr.push(rest); }
 	}
 	return arr;
 }
@@ -12986,6 +13175,20 @@ function spray(values=[0], beats=[0]){
 }
 exports.spray = spray;
 
+// Alternate through 2 or multiple lists consecutively
+// Gives a similar result as lace except the output
+// length is the lowest common denominator of the input lists
+// so that every combination of consecutive values is included
+//
+// @param {Array0, Array1, ..., Array-n} -> arrays to interleave
+// @return {Array} -> array of results 1 dimension less
+//
+function step(...arrs){
+	if (!arrs.length){ return [ 0 ] }
+	return flat(arrayCombinations(...arrs), 1);
+}
+exports.step = step;
+
 // stretch (or shrink) an array of numbers to a specified length
 // interpolating the values to fill in the gaps. 
 // TO-DO: Interpolations options are: none, linear, cosine, cubic
@@ -13019,15 +13222,9 @@ function stretch(a=[0], len=1, mode='linear'){
 }
 exports.stretch = stretch;
 
+// placeholder for unique from Utils.js
 // filter duplicate items from an array
 // does not account for 2-dimensional arrays in the array
-// 
-// @param {Array} -> array to filter
-// @return {Array}
-// 
-function unique(a=[0]){
-	return [...new Set(toArray(a))];
-}
 exports.unique = unique;
 
 },{"./statistic":51,"./utility":54}],53:[function(require,module,exports){
@@ -13406,22 +13603,43 @@ exports.rtof = relativeToFreq;
 // Also offsets the values with the root note selected
 // 
 // @params {Array/Number} -> Array of relative semitones
+// @params {String} -> Scale name (optional)
+// @params {String/Int} -> Root offset
 // @return {Array/Number} -> mapped to scale
 // 
-function mapToScale(a=[0]){
-	if (!Array.isArray(a)) {
+function mapToScale(a=[0], s, r){
+	// get the global settings 
+	let scale = getSettings().map;
+	let root = getSettings().rootInt;
+	// if a scale is provided and is not undefined
+	if (s && Scales[s]){
+		scale = Scales[s];
+	}
+	// if a root is provided
+	if (r) { 
+		root = isNaN(Number(r)) ? chromaToRelative(r) : Math.floor(r);
+	}
+	// apply recursively through the entire array
+	return _mapToScale(a, scale, root);
+}
+exports.mapToScale = mapToScale;
+exports.toScale = mapToScale;
+
+// private function for mapToScale()
+// 
+function _mapToScale(arr, scale, root){
+	if (!Array.isArray(arr)) {
 		// detuning float
-		let d = a - Math.floor(a);
+		let d = arr - Math.floor(arr);
 		// selected semitone
-		let s = Math.floor(((a % 12) + 12) % 12);
+		let s = Math.floor(((arr % 12) + 12) % 12);
 		// octave offset
-		let o = Math.floor(a / 12) * 12;
-		return notation.map[s] + o + d + notation.rootInt;
+		let o = Math.floor(arr / 12) * 12;
+		// return notation.map[s] + o + d + notation.rootInt;
+		return scale[s] + o + d + root;
 	}
-	return a.map(x => mapToScale(x));
+	return arr.map(x => _mapToScale(x, scale, root));
 }
-exports.mapToScale = mapToScale;
-exports.toScale = mapToScale;
 
 // Map an array of relative semitone intervals to scale and 
 // output in specified octave as midi value
@@ -13671,6 +13889,23 @@ function timevalueRatio(x){
 // function tonetimeRatio(x){
 // }
 
+// Convert a string or array of strings to the 
+// ASCII code values that belong to those characters
+// ASCII is the American Standard Code for Information Interchange
+// 
+// @param {String/Array} -> string to convert
+// @return {Array} -> array of integers
+//
+function textToCode(a=[0]){
+	if (!Array.isArray(a)){
+		return String(a).split('').map(c => c.charCodeAt(0));
+	}
+	return a.map(x => textToCode(x));
+}
+exports.textToCode = textToCode;
+exports.textCode = textToCode;
+exports.ttoc = textToCode;
+
 //=======================================================================
 // Scala class
 // 
@@ -14231,6 +14466,31 @@ function arrayCalc(a=0, v=0, func=()=>{return a;}){
 }
 exports.arrayCalc = arrayCalc;
 
+// Alternate through 2 or multiple lists consecutively
+// The output length is the lowest common denominator of the input lists
+// so that every combination of consecutive values is included
+// This function is used to allow arrays as input for Generators
+// And for the step function for algorithmic composition
+//
+// @param {Array0, Array1, ..., Array-n} -> arrays to interleave
+// @return {Array} -> outputs a 2D array of the results
+//
+function arrayCombinations(...arrs){
+	// make sure all values are array
+	arrs = arrs.map(a => toArray(a));
+	// the output is the unique list sizes multiplied
+	let sizes = unique(arrs.map(a => a.length));
+	let iters = 1;	
+	sizes.forEach((l) => iters *= l);
+	// iterate over the total amount pushing the items to array
+	let arr = [];
+	for (let i=0; i<iters; i++){
+		arr.push(arrs.map((e) => e[i % e.length] ));
+	}
+	return arr;
+}
+exports.arrayCombinations = arrayCombinations;
+
 // flatten a multidimensional array. Optionally set the depth
 // for the flattening
 //
@@ -14329,6 +14589,17 @@ function signedNormalize(a=[0]){
 exports.signedNormalize = signedNormalize;
 exports.snorm = signedNormalize;
 
+// filter duplicate items from an array
+// does not account for 2-dimensional arrays in the array
+// 
+// @param {Array} -> array to filter
+// @return {Array}
+// 
+function unique(a=[0]){
+	return [...new Set(toArray(a))];
+}
+exports.unique = unique;
+
 // Plot an array of values to the console in the form of an
 // ascii chart and return chart from function. If you just want the 
 // chart returned as text and not log to console set { log: false }.
@@ -14934,7 +15205,7 @@ const fxMap = {
 	'room' : (params) => {
 		return new Reverb(params);
 	},
-	'verb' : (params) => {
+	'hall' : (params) => {
 		return new Reverb(params);
 	},
 	'reverb' : (params) => {
@@ -14970,9 +15241,9 @@ const fxMap = {
 	'echo' : (params) => {
 		return new Delay(params);
 	},
-	'ppDelay' : (params) => {
-		return new PingPongDelay(params);
-	},
+	// 'ppDelay' : (params) => {
+	// 	return new PingPongDelay(params);
+	// },
 	// 'freeverb' : (params) => {
 	// 	return new FreeVerb(params);
 	// },
@@ -14990,32 +15261,52 @@ module.exports = fxMap;
 // Programmed with a custom AudioWorkletProcessor, see effects/Processors.js
 //
 const DownSampler = function(_params){
-	this._down = (_params[0])? Util.toArray(_params[0]) : [0.5];
-
+	// apply the default values and convert to arrays where necessary
+	_params = Util.mapDefaults(_params, [ 0.5, 1 ]);
+	this._down = Util.toArray(_params[0]);
+	this._wet = Util.toArray(_params[1]);
+	
 	// ToneAudioNode has all the tone effect parameters
 	this._fx = new Tone.ToneAudioNode();
+
+	// The crossfader mix
+	this._mix = new Tone.Add();
+	this._mixDry = new Tone.Gain(0).connect(this._mix.input);
+	// this._mixWet = new Tone.Gain(0.5).connect(this._mix.addend);
+	
 	// A gain node for connecting with input and output
-	this._fx.input = new Tone.Gain(1);
-	this._fx.output = new Tone.Gain(1);
+	this._fx.input = new Tone.Gain(1).connect(this._mixDry);
+	this._fx.output = new Tone.Gain(1).connect(this._mix.addend);
+
 	// the fx processor
 	this._fx.workletNode = Tone.getContext().createAudioWorkletNode('downsampler-processor');
+
 	// connect input, fx and output
 	this._fx.input.chain(this._fx.workletNode, this._fx.output);
 
 	this.set = function(c, time, bpm){
 		// some parameter mapping changing input range 0-1 to 1-inf
-		let p = this._fx.workletNode.parameters.get('down');
-		let d = Math.floor(1 / (1 - Util.clip(Util.getParam(this._down, c) ** 0.25, 0, 0.999)));
+		const p = this._fx.workletNode.parameters.get('down');
+		const d = Math.floor(1 / (1 - Util.clip(Util.getParam(this._down, c) ** 0.25, 0, 0.999)));
+
 		p.setValueAtTime(Util.assureNum(d), time);
+
+		const w = Util.clip(Util.getParam(this._wet, c), 0, 1);
+		this._fx.output.gain.setValueAtTime(w, time);
+		this._mixDry.gain.setValueAtTime(1 - w, time);
 	}
 
 	this.chain = function(){
-		return { 'send' : this._fx, 'return' : this._fx }
+		return { 'send' : this._fx, 'return' : this._mix }
 	}
 
 	this.delete = function(){
-		this._fx.disconnect();
-		this._fx.dispose();
+		const nodes = [ this._fx, this._mix, this._mixDry ];
+
+		nodes.forEach((n) => {
+			n.disconnect();
+			n.dispose();
+		});
 	}
 }
 
@@ -15024,37 +15315,63 @@ const DownSampler = function(_params){
 // distortion is applied on the overdrive parameter
 //
 const TanhDistortion = function(_params){
-	this._drive = (_params[0])? Util.toArray(_params[0]) : [4];
+	_params = Util.mapDefaults(_params, [ 4, 1 ]);
+	// apply the default values and convert to arrays where necessary
+	this._drive = Util.toArray(_params[0]);
+	this._wet = Util.toArray(_params[1]);
+
+	console.log('Distortion with:', this._drive, this._wet);
+
+	// The crossfader for wet-dry (originally implemented with CrossFade)
+	// this._mix = new Tone.CrossFade();
+	this._mix = new Tone.Add();
+	this._mixWet = new Tone.Gain(0).connect(this._mix.input);
+	this._mixDry = new Tone.Gain(1).connect(this._mix.addend);	
 
 	// ToneAudioNode has all the tone effect parameters
 	this._fx = new Tone.ToneAudioNode();
 	// A gain node for connecting with input and output
-	this._fx.input = new Tone.Gain(1);
-	this._fx.output = new Tone.Gain(1);
+	this._fx.input = new Tone.Gain(1).connect(this._mixDry);
+	this._fx.output = new Tone.Gain(1).connect(this._mixWet);
+
 	// the fx processor
 	this._fx.workletNode = Tone.getContext().createAudioWorkletNode('tanh-distortion-processor');
-	// connect input, fx and output
+
+	// connect input, fx, output and wetdry
 	this._fx.input.chain(this._fx.workletNode, this._fx.output);
 
 	this.set = function(c, time, bpm){
 		// drive amount, minimum drive of 1
-		const d = Util.assureNum(Math.max(1, Math.pow(Util.getParam(this._drive, c), 2) + 1));
+		const d = Util.assureNum(Math.max(0, Util.getParam(this._drive, c)) + 1);
+
 		// preamp gain reduction for linear at drive = 1
-		const p = 0.4;
+		const p = 0.8;
 		// makeup gain
-		const m = 1.0 / p / (d ** 0.6);
-		// set the input gain and output gain reduction
-		this._fx.input.gain.setValueAtTime(p * d, time);
-		this._fx.output.gain.setValueAtTime(m, time);
+		const m = 1.0 / (p * (d ** 1.1));
+
+		// set the parameters in the workletNode
+		const amount = this._fx.workletNode.parameters.get('amount');
+		amount.setValueAtTime(p * d * d, time);
+
+		const makeup = this._fx.workletNode.parameters.get('makeup');
+		makeup.setValueAtTime(m, time);
+
+		const wet = Util.clip(Util.getParam(this._wet, c), 0, 1);
+		this._mixWet.gain.setValueAtTime(wet);
+		this._mixDry.gain.setValueAtTime(1 - wet);
 	}
 
 	this.chain = function(){
-		return { 'send' : this._fx, 'return' : this._fx }
+		return { 'send' : this._fx, 'return' : this._mix }
 	}
 
 	this.delete = function(){
-		this._fx.disconnect();
-		this._fx.dispose();
+		let nodes = [ this._fx, this._mix, this._mixDry, this._mixWet ];
+
+		nodes.forEach((n) => {
+			n.disconnect();
+			n.dispose();
+		});
 	}
 }
 
@@ -15064,9 +15381,7 @@ const TanhDistortion = function(_params){
 //
 const Compressor = function(_params){
 	// replace defaults with provided params
-	this.defaults = [-30, 6, 10, 80];
-	this.defaults.splice(0, _params.length, ..._params);
-	_params = this.defaults.map(p => Util.toArray(p));	
+	_params = Util.mapDefaults(_params, [-30, 6, 10, 80]);
 
 	this._fx = new Tone.Compressor({
 		threshold: -24,
@@ -15111,7 +15426,9 @@ const Chorus = function(_params){
 		this._fx.frequency.setValueAtTime(f, time);
 		// delaytime/2 because of up and down through center
 		// eg. 25 goes from 0 to 50, 40 goes from 0 to 80, etc.
-		this._fx.delayTime = Util.getParam(_params[1], c) / 2;
+		Util.atTime(() => {
+			this._fx.delayTime = Util.getParam(_params[1], c) / 2;
+		}, time);
 
 		// waveform for chorus is not supported in browser instead change wetdry
 		let w = Util.getParam(_params[2], c);
@@ -15137,49 +15454,71 @@ const Chorus = function(_params){
 // Based on an algorithm by Peter McCulloch
 // 
 const Squash = function(_params){
-	this._squash = (_params[0])? Util.toArray(_params[0]) : [1];
+	_params = Util.mapDefaults(_params, [ 4, 1, 0.28 ]);
+	// apply the default values and convert to arrays where necessary
+	this._squash = Util.toArray(_params[0]);
+	this._wet = Util.toArray(_params[1]);
+
+	// The crossfader for wet-dry (originally implemented with CrossFade)
+	this._mix = new Tone.Add();
+	this._mixDry = new Tone.Gain(0).connect(this._mix.input);
 
 	// ToneAudioNode has all the tone effect parameters
 	this._fx = new Tone.ToneAudioNode();
 	// A gain node for connecting with input and output
-	this._fx.input = new Tone.Gain(1);
-	this._fx.output = new Tone.Gain(1);
+	this._fx.input = new Tone.Gain(1).connect(this._mixDry);
+	this._fx.output = new Tone.Gain(1).connect(this._mix.addend);
+
 	// the fx processor
 	this._fx.workletNode = Tone.getContext().createAudioWorkletNode('squash-processor');
 	// connect input, fx and output
 	this._fx.input.chain(this._fx.workletNode, this._fx.output);
 
 	this.set = function(c, time, bpm){
-		let d = Util.assureNum(Math.max(1, Util.getParam(this._squash, c)));
-		let p = this._fx.workletNode.parameters.get('amount');
-		let m = 1.0 / Math.sqrt(d);
-		p.setValueAtTime(d, time);
+		const d = Util.assureNum(Math.max(1, Util.getParam(this._squash, c)));
+		const m = 1.0 / Math.sqrt(d);
+
+		const amount = this._fx.workletNode.parameters.get('amount');
+		amount.setValueAtTime(d, time);
+		
+		const makeup = this._fx.workletNode.parameters.get('makeup');
+		makeup.setValueAtTime(m, time);
+		
+		const wet = Util.clip(Util.getParam(this._wet, c));
 		this._fx.output.gain.setValueAtTime(m, time);
+		this._mixDry.gain.setValueAtTime(1 - wet, time);
 	}
 
 	this.chain = function(){
-		return { 'send' : this._fx, 'return' : this._fx }
+		return { 'send' : this._fx, 'return' : this._mix }
 	}
 
 	this.delete = function(){
-		this._fx.disconnect();
-		this._fx.dispose();
+		let nodes = [ this._fx, this._mix, this._mixDry ];
+
+		nodes.forEach((n) => {
+			n.disconnect();
+			n.dispose();
+		});
 	}
 }
 
 // Reverb FX
 // Add a reverb to the sound to give it a feel of space
+// Using a decaying noise reverb algorithm, that does seem to 
+// increase the memory usage over time slowly
 // 
 const Reverb = function(_params){
-	this._fx = new Tone.Reverb();
+	_params = Util.mapDefaults(_params, [ 0.5, 1.5 ]);
+	this._wet = _params[0];
+	this._size = _params[1];
 
-	this._wet = (_params[0] !== undefined)? Util.toArray(_params[0]) : [ 0.5 ];
-	this._size = (_params[1] !== undefined)? Util.toArray(_params[1]) : [ 1.5 ];
+	this._fx = new Tone.Reverb();
 
 	this.set = function(c, time){
-		let tmp = Math.min(10, Math.max(0.1, Util.getParam(this._size, c)));
+		let tmp = Math.min(15, Math.max(0.1, Util.getParam(this._size, c)));
 		if (this._fx.decay != tmp){
-			this._fx.decay = tmp; 
+			Util.atTime(() => this._fx.decay = tmp, time);
 		}
 
 		let wet = Math.min(1, Math.max(0, Util.getParam(this._wet, c)));
@@ -15198,19 +15537,21 @@ const Reverb = function(_params){
 
 // PitchShift FX
 // Shift the pitch up or down with semitones
+// Utilizes the default PitchShift FX from ToneJS
 // 
 const PitchShift = function(_params){
-	this._fx = new Tone.PitchShift();
+	_params = Util.mapDefaults(_params, [ -12, 1 ]);
+	// apply the default values and convert to arrays where necessary
+	this._pitch = _params[0];
+	this._wet = _params[1];
 
-	this._pitch = (_params[0] !== undefined)? Util.toArray(_params[0]) : [-12];
-	this._wet = (_params[1] !== undefined)? Util.toArray(_params[1]) : [1];
+	this._fx = new Tone.PitchShift();
 
 	this.set = function(c, time){
 		let p = Util.getParam(this._pitch, c);
 		let w = Util.getParam(this._wet, c);
 
-		this._fx.pitch = TL.toScale(p);
-		// this._fx.pitch = p;
+		Util.atTime(() => this._fx.pitch = TL.toScale(p), time);
 		this._fx.wet.setValueAtTime(w, time);
 	}
 
@@ -15228,47 +15569,74 @@ const PitchShift = function(_params){
 // a Low Frequency Oscillator effect, control tempo, type and depth
 //
 const LFO = function(_params){
+	_params = Util.mapDefaults(_params, [ '1/8', 'sine', 1 ]);
+	_params = _params.map(x => Util.toArray(x));
+	this._speed = _params[0];
+	this._type = _params[1];
+	this._depth = _params[2];
+
 	this._waveMap = {
 		sine : 'sine',
-		saw : 'sawtooth',
+		sineUp : 'sine',
+		sineDown : 'sine',
+		sawUp: 'sawtooth',
+		sawDown: 'sawtooth',
+		up: 'sawtooth',
+		down: 'sawtooth',
 		square : 'square',
+		squareUp : 'square',
+		squareDown : 'square',
 		rect : 'square',
 		triangle : 'triangle',
 		tri : 'triangle',
-		up: 'sawtooth',
-		sawUp: 'sawtooth'
 	}
 
 	this._lfo = new Tone.LFO();
 	this._fx = new Tone.Gain();
 	this._lfo.connect(this._fx.gain);
-	// this._fx = new Tone.Tremolo('8n').start();
-
-	this._speed = (_params[0]) ? Util.toArray(_params[0]) : ['1/8'];
-	this._type = (_params[1]) ? Util.toArray(_params[1]) : ['sine'];
-	this._depth = (_params[2] !== undefined) ? Util.toArray(_params[2]) : [ 1 ];
 
 	this.set = function(c, time, bpm){
 		let w = Util.getParam(this._type, c);
-		if (this._waveMap[w]){
-			w = this._waveMap[w];
-		} else {
+		if (!this._waveMap[w]){
 			Util.log(`'${w} is not a valid waveshape`);
 			// default wave if wave does not exist
 			w = 'sine';
 		}
-		this._lfo.set({ type: w });
+		this._lfo.set({ type: this._waveMap[w] });
 		
 		let s = Util.getParam(this._speed, c);
-		let f = Math.max(0.0001, Util.divToS(s, bpm));
+		let t = Util.divToS(s, bpm);
+		let f = Math.max(0.0001, t);
 		this._lfo.frequency.setValueAtTime(1/f, time);
 
 		let a = Util.getParam(this._depth, c);
-		this._lfo.min = Math.min(1, Math.max(0, 1 - a));	
-		if (this._lfo.state !== 'started'){
-			if (w === 'sawtooth') {
-				this._lfo.phase = 180;
+		Util.atTime(() => {
+			this._lfo.min = Math.min(1, Math.max(0, 1 - a));
+			this._lfo.max = 1;
+			// fix for squarewave not going to 0 fully
+			if (this._waveMap[w] === 'square'){ 
+				this._lfo.min += -0.1;
 			}
+			
+			// swap high and low point to create a saw down
+			if (w === 'down' || w === 'sawDown' || w === 'squareUp' || w === 'sineDown' ){
+				let tmp = this._lfo.min;
+				this._lfo.min = this._lfo.max;
+				this._lfo.max = tmp;
+			} 
+		}, time);
+
+		if (this._lfo.state !== 'started'){
+			// fix incorrect phases for sawtooth sine and triangle
+			// simply by starting them a bit later.
+			switch (this._waveMap[w]) {
+				case 'sine' :
+					time += t * 0.25; break;
+				case 'triangle' :
+					time += t * 0.25; break;
+				case 'sawtooth' :
+					time += t * 0.5; break;
+			}	
 			this._lfo.start(time);
 		}
 	}
@@ -15278,9 +15646,9 @@ const LFO = function(_params){
 	}
 
 	this.delete = function(){
-		let blocks = [ this._fx, this._lfo ];
+		let nodes = [ this._fx, this._lfo ];
 		
-		blocks.forEach((b) => {
+		nodes.forEach((b) => {
 			b.disconnect();
 			b.dispose();
 		});
@@ -15289,10 +15657,35 @@ const LFO = function(_params){
 
 // A filter FX, choose between highpass, lowpass and bandpass
 // Set the cutoff frequency and Q factor
+// Optionally with extra arguments you can apply a modulation
 //
 const Filter = function(_params){
+	// parameter mapping changes based on amount of arguments
+	this._static = true;
+	if (_params.length < 4){
+		if (typeof _params[0] === 'string'){
+			_params = Util.mapDefaults(_params, ['low', 1200, 0.45]);
+		} else {
+			_params = [['low']].concat(Util.mapDefaults(_params, [1200, 0.45]));
+		}
+	}
+	else {
+		_params = Util.mapDefaults(_params, ['low', '1/1', 200, 3000, 0.45, 'sine', 0.5]);
+		this._static = false;
+	}
+
 	this._fx = new Tone.Filter();
 
+	// the following is only used if the parameters for modulation
+	// are added as arguments to the fx(filter) function
+	if (!this._static){
+		this._lfo = new Tone.LFO();
+		this._scale = new Tone.ScaleExp();
+		this._lfo.connect(this._scale);
+		this._scale.connect(this._fx.frequency);
+	}
+
+	// available filter types for the filter
 	this._types = {
 		'lo' : 'lowpass',
 		'low' : 'lowpass',
@@ -15301,32 +15694,107 @@ const Filter = function(_params){
 		'high' : 'highpass',
 		'highpass' : 'highpass',
 		'band' : 'bandpass',
-		'bandpass': 'bandpass'
+		'bandpass': 'bandpass',
 	}
 	if (this._types[_params[0]]){
 		this._fx.set({ type: this._types[_params[0]] });
 	} else {
-		Util.log(`'${_params[0]}' is not a valid filter type`);
+		console.log(`'${_params[0]}' is not a valid filter type. Defaults to lowpass`);
 		this._fx.set({ type: 'lowpass' });
 	}
 	this._fx.set({ rolloff: -24 });
 
-	this._cutoff = (_params[1]) ? Util.toArray(_params[1]) : [ 1000 ];
-	this._q = (_params[2]) ? Util.toArray(_params[2]) : [ 0.5 ];
-	this._rt = (_params[3]) ? Util.toArray(_params[3]) : [ 0 ];
+	// available waveforms for the LFO
+	this._waveMap = {
+		sine : 'sine',
+		// sineUp : 'sine',
+		// sineDown : 'sine',
+		saw : 'sawtooth',
+		sawUp: 'sawtooth',
+		sawDown: 'sawtooth',
+		up: 'sawtooth',
+		down: 'sawtooth',
+		// square : 'square',
+		// squareUp : 'square',
+		// squareDown : 'square',
+		// rect : 'square',
+		triangle : 'triangle',
+		tri : 'triangle',
+	}
 
 	this.set = function(c, time, bpm){
-		let f = Util.getParam(this._cutoff, c);
-		let r = 1 / (1 - Math.min(0.95, Math.max(0, Util.getParam(this._q, c))));
-		let rt = Util.divToS(Util.getParam(this._rt, c), bpm);
+		let _q;
+		// if the filter is static use the settings of frequency and resonance 
+		if (this._static){
+			let f = Util.getParam(_params[1], c);
+			_q = _params[2];
 
-		if (rt > 0){
-			this._fx.frequency.rampTo(f, rt, time);
-		} else {
 			this._fx.frequency.setValueAtTime(f, time);
+			// let rt = Util.divToS(Util.getParam(this._rt, c), bpm);
+		} else {
+			_q = _params[4];
+			let t = Util.divToS(Util.getParam(_params[1], c), bpm);
+			let f = 1 / t;
+			let lo = Util.clip(Util.getParam(_params[2], c), 5, 19000);
+			let hi = Util.clip(Util.getParam(_params[3], c), 5, 19000);
+
+			let w = Util.getParam(_params[5], c);
+			if (this._waveMap[w]){
+				w = this._waveMap[w];
+			} else {
+				if (isNaN(w)){
+					log(`${w} is not a valid waveshape. Defaults to sine`);
+					// default wave if wave does not exist
+					w = 'sine';
+				} else {
+					// w = value between 0 and 1, map to up, down, triangle 
+					// 0=down, 0.5=triangle, 1=up
+					switch(Math.floor(Util.clip(w, 0, 1)*2.99)){
+						case 0: 
+							// regular saw up
+							w = 'sawtooth'; break;
+						case 1:
+							w = 'sine'; break;
+						case 2:
+							w = 'sawtooth';
+							// swap hi/lo range for saw down effect
+							let tmp = lo; lo = hi; hi = tmp; break;
+					}
+				}
+			}
+			this._lfo.set({ type: w });
+
+			let exp = Util.clip(Util.getParam(_params[6], c), 0.01, 100);
+
+			this._scale.min = lo;
+			this._scale.max = hi;
+			this._scale.exponent = exp;
+			this._lfo.frequency.setValueAtTime(f, time);
+
+			this._lfo.max = 1;
+
+			if (this._lfo.state !== 'started'){
+				switch (w) {
+					case 'sine' :
+						time += t * 0.25; break;
+					case 'triangle' :
+						time += t * 0.25; break;
+					case 'sawtooth' :
+						time += t * 0.5; break;
+				}	
+				this._lfo.start(time);
+			}
 		}
 
+		let r = 1 / (1 - Math.min(0.95, Math.max(0, Util.getParam(_q, c))));
 		this._fx.Q.setValueAtTime(r, time);
+
+		// ramptime removed now that modulation is possible
+		// if (rt > 0){
+		// 	this._fx.frequency.rampTo(f, rt, time);
+		// } else {
+		// 	this._fx.frequency.setValueAtTime(f, time);
+		// }
 	}
 
 	this.chain = function(){
@@ -15334,8 +15802,12 @@ const Filter = function(_params){
 	}
 
 	this.delete = function(){
-		this._fx.disconnect();
-		this._fx.dispose();
+		let nodes = [ this._fx, this._lfo, this._scale ];
+
+		nodes.forEach((n) => {
+			n?.disconnect();
+			n?.dispose();
+		});
 	}
 }
 
@@ -15372,10 +15844,10 @@ const TriggerFilter = function(_params){
 		'bandpass': 'bandpass'
 	}
 
-	this.defaults = ['low', 1, '1/16', 4000, 30];
 	// replace defaults with provided arguments
-	this.defaults.splice(0, _params.length, ..._params);
-	_params = this.defaults.map(p => Util.toArray(p));
+	_params = Util.mapDefaults(_params, ['low', 1, '1/16', 4000, 100, 1]);
+	// this.defaults.splice(0, _params.length, ..._params);
+	_params = _params.map(p => Util.toArray(p));
 
 	if (this._types[_params[0][0]]){
 		this._fx.set({ type: this._types[_params[0][0]] });
@@ -15388,6 +15860,7 @@ const TriggerFilter = function(_params){
 	this._rel = _params[2];
 	this._high = _params[3];
 	this._low = _params[4];
+	this._exp = _params[5];
 
 	this.set = function(c, time, bpm){
 		this._adsr.attack = Util.divToS(Util.getParam(this._att, c), bpm);
@@ -15397,9 +15870,11 @@ const TriggerFilter = function(_params){
 		let max = Util.getParam(this._high, c);
 		let range = Math.abs(max - min);
 		let lower = Math.min(max, min);
+		let exp = 1 / Util.getParam(this._exp, c);
 
 		this._mul.setValueAtTime(range, time);
 		this._add.setValueAtTime(lower, time);
+		Util.atTime(() => { this._pow.value = exp }, time);
 
 		// fade-out running envelope over 5 ms
 		if (this._adsr.value > 0){
@@ -15414,9 +15889,9 @@ const TriggerFilter = function(_params){
 	}
 
 	this.delete = function(){
-		let blocks = [ this._fx, this._adsr, this._mul, this._add, this._pow ];
+		let nodes = [ this._fx, this._adsr, this._mul, this._add, this._pow ];
 
-		blocks.forEach((b) => {
+		nodes.forEach((b) => {
 			b.disconnect();
 			b.dispose();
 		});
@@ -15444,27 +15919,31 @@ const TriggerFilter = function(_params){
 
 // Custom stereo delay implementation with lowpass filter in feedback loop
 const Delay = function(_params){
+	// apply the default values and convert to arrays where necessary
+	if (_params.length === 1){ _params[1] = _params[0] }
+	else if (_params.length === 2){
+		_params[2] = _params[1];
+		_params[1] = _params[0];
+	}
+
+	_params = Util.mapDefaults(_params, [ '3/16', '2/8', 0.7, 0.6, 0.5 ]);
+	this._timeL = Util.toArray(_params[0]);
+	this._timeR = Util.toArray(_params[1]);
+	this._feedBack = Util.toArray(_params[2]);
+	this._fbDamp = Util.toArray(_params[3]);
+	this._wet = Util.toArray(_params[4]);
+
 	this._fx = new Tone.Gain(1);
 	this._fb = new Tone.Gain(0.5);
 	this._mix = new Tone.CrossFade(0.5);
 	this._split = new Tone.Split(2);
 	this._merge = new Tone.Merge(2);
-	this._maxDelay = 5;
+	this._maxDelay = 3;
 
 	this._delayL = new Tone.Delay({ maxDelay: this._maxDelay });
 	this._delayR = new Tone.Delay({ maxDelay: this._maxDelay });
 	this._flt = new Tone.Filter(1000, 'lowpass', '-12');
 
-	if (_params.length === 2){
-		_params[2] = _params[1];
-		_params[1] = _params[0];
-	}
-	// All params and defaults
-	this._timeL = (_params[0] !== undefined)? Util.toArray(_params[0]) : [ '2/16' ];
-	this._timeR = (_params[1] !== undefined)? Util.toArray(_params[1]) : [ '3/16' ];
-	this._feedBack = (_params[2] !== undefined)? Util.toArray(_params[2]) : [ 0.7 ];
-	this._fbDamp = (_params[3] !== undefined)? Util.toArray(_params[3]) : [ 0.6 ];
-
 	// split the signal
 	this._fx.connect(this._mix.a);
 	this._fx.connect(this._fb);
@@ -15487,13 +15966,16 @@ const Delay = function(_params){
 	this.set = function(c, time, bpm){
 		let dL = Math.min(this._maxDelay, Math.max(0, Util.formatRatio(Util.getParam(this._timeL, c), bpm)));
 		let dR = Math.min(this._maxDelay, Math.max(0, Util.formatRatio(Util.getParam(this._timeR, c), bpm)));
-		let ct = Math.max(10, Util.getParam(this._fbDamp, c) * 5000);
 		let fb = Math.max(0, Math.min(0.99, Util.getParam(this._feedBack, c) * 0.707));
+		let cf = Math.max(10, Util.getParam(this._fbDamp, c) * 8000);
+
+		this._delayL.delayTime.setValueAtTime(dL + Math.random() * 0.001, time);		
+		this._delayR.delayTime.setValueAtTime(dR + Math.random() * 0.001, time);
+		this._fb.gain.setValueAtTime(Util.assureNum(fb, 0.7), time);
+		this._flt.frequency.setValueAtTime(cf, time);
 
-		this._delayL.delayTime.setValueAtTime(dL, time);
-		this._delayR.delayTime.setValueAtTime(dR, time);
-		this._flt.frequency.setValueAtTime(ct, time);
-		this._fb.gain.setValueAtTime(fb, time);
+		const wet = Util.clip(Util.getParam(this._wet, c));
+		this._mix.fade.setValueAtTime(wet, time);
 	}
 
 	this.chain = function(){
@@ -15501,9 +15983,9 @@ const Delay = function(_params){
 	}
 
 	this.delete = function(){
-		let blocks = [ this._fx, this._fb, this._mix, this._split, this._merge, this._delayL, this._delayR, this._flt ];
+		let nodes = [ this._fx, this._fb, this._mix, this._split, this._merge, this._delayL, this._delayR, this._flt ];
 
-		blocks.forEach((b) => {
+		nodes.forEach((b) => {
 			b.disconnect();
 			b.dispose();
 		});
@@ -15511,124 +15993,124 @@ const Delay = function(_params){
 }
 
 // Old pingpong delay implementation, just using the Tone.PingPongDelay()
-const PingPongDelay = function(_params){
-	this._fx = new Tone.PingPongDelay();
-	this._fx.set({ wet: 0.4 });
-
-	// console.log('delay', param);
-	this._dTime = (_params[0] !== undefined)? Util.toArray(_params[0]) : [ '3/16' ];
-	this._fb = (_params[1] !== undefined)? Util.toArray(_params[1]) : [ 0.3 ];
-	// let del = new Tone.PingPongDelay(formatRatio(t), fb);
-
-	this.set = function(c, time, bpm){
-		let t = Math.max(0, Util.formatRatio(Util.getParam(this._dTime, c), bpm));
-		let fb = Math.max(0, Math.min(0.99, Util.getParam(this._fb, c)));
-
-		this._fx.delayTime.setValueAtTime(t, time);
-		this._fx.feedback.setValueAtTime(fb, time);
-	}
-
-	this.chain = function(){
-		return { 'send' : this._fx, 'return' : this._fx };
-	}
-
-	this.delete = function(){
-		this._fx.disconnect();
-		this._fx.dispose();
-	}
-}
+// const PingPongDelay = function(_params){
+// 	this._fx = new Tone.PingPongDelay();
+// 	this._fx.set({ wet: 0.4 });
+
+// 	// console.log('delay', param);
+// 	this._dTime = (_params[0] !== undefined)? Util.toArray(_params[0]) : [ '3/16' ];
+// 	this._fb = (_params[1] !== undefined)? Util.toArray(_params[1]) : [ 0.3 ];
+// 	// let del = new Tone.PingPongDelay(formatRatio(t), fb);
+
+// 	this.set = function(c, time, bpm){
+// 		let t = Math.max(0, Util.formatRatio(Util.getParam(this._dTime, c), bpm));
+// 		let fb = Math.max(0, Math.min(0.99, Util.getParam(this._fb, c)));
+
+// 		this._fx.delayTime.setValueAtTime(t, time);
+// 		this._fx.feedback.setValueAtTime(fb, time);
+// 	}
+
+// 	this.chain = function(){
+// 		return { 'send' : this._fx, 'return' : this._fx };
+// 	}
+
+// 	this.delete = function(){
+// 		this._fx.disconnect();
+// 		this._fx.dispose();
+// 	}
+// }
 
-const FreeVerb = function(_params){
-	this._fx = new Tone.Freeverb(_params[0], _params[1]);
+// const FreeVerb = function(_params){
+// 	this._fx = new Tone.Freeverb(_params[0], _params[1]);
 
-	this.set = function(c, time, bpm){
+// 	this.set = function(c, time, bpm){
 
-	}
+// 	}
 
-	this.chain = function(){
-		return { 'send' : this._fx, 'return' : this._fx };
-	}
+// 	this.chain = function(){
+// 		return { 'send' : this._fx, 'return' : this._fx };
+// 	}
 
-	this.delete = function(){
-		let blocks = [ this._fx ];
+// 	this.delete = function(){
+// 		let nodes = [ this._fx ];
 
-		blocks.forEach((b) => {
-			b.disconnect();
-			b.dispose();
-		});
-	}
-}
+// 		nodes.forEach((b) => {
+// 			b.disconnect();
+// 			b.dispose();
+// 		});
+// 	}
+// }
 
 // squash/compress an incoming signal
 // based on algorithm by Peter McCulloch
-const SquashDeprecated = function(_params){
-	this._compress = (_params[0] !== undefined)? Util.toArray(_params[0]) : [1];
-
-	this._fx = new Tone.WaveShaper();
-
-	this.shaper = function(amount){
-		// (a * c) / ((a * c)^2 * 0.28 + 1) / √c
-		// drive amount, minimum of 1
-		const c = amount;
-		// makeup gain
-		const m = 1.0 / Math.sqrt(c);
-		// set the waveshaper effect
-		this._fx.setMap((x) => {
-			return (x * c) / ((x * c) * (x * c) * 0.28 + 1) * m; 
-		});
-	}
+// const SquashDeprecated = function(_params){
+// 	this._compress = (_params[0] !== undefined)? Util.toArray(_params[0]) : [1];
+
+// 	this._fx = new Tone.WaveShaper();
+
+// 	this.shaper = function(amount){
+// 		// (a * c) / ((a * c)^2 * 0.28 + 1) / √c
+// 		// drive amount, minimum of 1
+// 		const c = amount;
+// 		// makeup gain
+// 		const m = 1.0 / Math.sqrt(c);
+// 		// set the waveshaper effect
+// 		this._fx.setMap((x) => {
+// 			return (x * c) / ((x * c) * (x * c) * 0.28 + 1) * m; 
+// 		});
+// 	}
 	
-	this.set = function(c){
-		let d = Util.getParam(this._compress, c);
-		this.shaper(isNaN(d)? 1 : Math.max(1, d));
-	}
-
-	this.chain = function(){
-		return { 'send' : this._fx, 'return' : this._fx };
-	}
-
-	this.delete = function(){
-		this._fx.disconnect();
-		this._fx.dispose();
-	}
-}
+// 	this.set = function(c){
+// 		let d = Util.getParam(this._compress, c);
+// 		this.shaper(isNaN(d)? 1 : Math.max(1, d));
+// 	}
+
+// 	this.chain = function(){
+// 		return { 'send' : this._fx, 'return' : this._fx };
+// 	}
+
+// 	this.delete = function(){
+// 		this._fx.disconnect();
+// 		this._fx.dispose();
+// 	}
+// }
 
 // A distortion algorithm using the tanh (hyperbolic-tangent) as a 
 // waveshaping technique. Some mapping to apply a more equal loudness 
 // distortion is applied on the overdrive parameter
 //
-const DriveDeprecated = function(_params){
-	this._drive = (_params[0] !== undefined)? Util.toArray(_params[0]) : [1.5];
-
-	this._fx = new Tone.WaveShaper();
-
-	this.shaper = function(amount){
-		// drive curve, minimum drive of 1
-		const d = Math.pow(amount, 2);
-		// makeup gain
-		const m = Math.pow(d, 0.6);
-		// preamp gain reduction for linear at drive = 1
-		const p = 0.4;
-		// set the waveshaping effect
-		this._fx.setMap((x) => {
-			return Math.tanh(x * p * d) / p / m;
-		});
-	}
+// const DriveDeprecated = function(_params){
+// 	this._drive = (_params[0] !== undefined)? Util.toArray(_params[0]) : [1.5];
+
+// 	this._fx = new Tone.WaveShaper();
+
+// 	this.shaper = function(amount){
+// 		// drive curve, minimum drive of 1
+// 		const d = Math.pow(amount, 2);
+// 		// makeup gain
+// 		const m = Math.pow(d, 0.6);
+// 		// preamp gain reduction for linear at drive = 1
+// 		const p = 0.4;
+// 		// set the waveshaping effect
+// 		this._fx.setMap((x) => {
+// 			return Math.tanh(x * p * d) / p / m;
+// 		});
+// 	}
 	
-	this.set = function(c){
-		let d = Util.getParam(this._drive, c);
-		this.shaper(isNaN(d)? 1 : Math.max(1, d));
-	}
-
-	this.chain = function(){
-		return { 'send' : this._fx, 'return' : this._fx };
-	}
-
-	this.delete = function(){
-		this._fx.disconnect();
-		this._fx.dispose();
-	}
-}
+// 	this.set = function(c){
+// 		let d = Util.getParam(this._drive, c);
+// 		this.shaper(isNaN(d)? 1 : Math.max(1, d));
+// 	}
+
+// 	this.chain = function(){
+// 		return { 'send' : this._fx, 'return' : this._fx };
+// 	}
+
+// 	this.delete = function(){
+// 		this._fx.disconnect();
+// 		this._fx.dispose();
+// 	}
+// }
 },{"./Util.js":66,"tone":44,"total-serialism":47}],57:[function(require,module,exports){
 const Tone = require('tone');
 const Util = require('./Util.js');
@@ -15709,13 +16191,14 @@ class Instrument extends Sequencer {
 		this.sourceEvent(c, e, time);
 
 		// fade-out running envelope over 5 ms
-		if (this.adsr.value > 0){
-			let tmp = this.adsr.release;
-			this.adsr.release = 0.005;
-			this.adsr.triggerRelease(time);
-			this.adsr.release = tmp;
-			time += 0.005;
-		}
+		// retrigger temporarily disabled to reduce distortion
+		// if (this.adsr.value > 0){
+		// 	let tmp = this.adsr.release;
+		// 	this.adsr.release = 0.004;
+		// 	this.adsr.triggerRelease(time-0.004);
+		// 	this.adsr.release = tmp;
+		// 	time += 0.010;
+		// }
 
 		// set shape for playback (fade-in / out and length)
 		if (this._att){
@@ -15723,15 +16206,21 @@ class Instrument extends Sequencer {
 			let dec = Util.divToS(Util.getParam(this._sus, c), this.bpm());
 			let rel = Util.divToS(Util.getParam(this._rel, c), this.bpm());
 
-			this.adsr.attack = att;
+			// minimum attaack and release times are 1 millisecond
+			this.adsr.attack = Math.max(0.001, att);
 			this.adsr.decay = dec;
-			this.adsr.release = rel;
+			this.adsr.release = Math.max(0.001, rel);
 			
-			e = Math.min(this._time, att + dec + rel);
+			// trigger the envelope and release after a short while
+			// a better working alternative for the code below
+			this.adsr.triggerAttack(time);
+			this.adsr.triggerRelease(time + att + dec);
+
+			// e = Math.min(this._time, att + dec + rel);
 			// e = Math.min(t, att + dec + rel);
 
-			let rt = Math.max(0.001, e - this.adsr.release);
-			this.adsr.triggerAttackRelease(rt, time);
+			// let rt = Math.max(0.001, e - this.adsr.release);
+			// this.adsr.triggerAttackRelease(rt, time);
 		} else {
 			// if shape is 'off' only trigger attack
 			this.adsr.triggerAttack(time);
@@ -15762,7 +16251,10 @@ class Instrument extends Sequencer {
 		// delete super class
 		super.delete();
 		// disconnect the sound dispose the player
+		this.gain.disconnect();
 		this.gain.dispose();
+
+		this.panner.disconnect();
 		this.panner.dispose();
 		// this.adsr.dispose();
 		// remove all fx
@@ -15920,11 +16412,14 @@ class MonoMidi extends Sequencer {
 		}
 
 		// Midi specific parameters
-		this._note = [];		
+		this._note = [];	
+		this._midinote = [];	
 		this._velocity = [ 127, 0 ];
 		this._dur = [ 100 ];
 		this._cc = [];
 		this._channel = [ 1 ];
+		this._program = false;
+		this._pgm = null;
 		this._chord = false;
 		this._bend = [];
 
@@ -15935,8 +16430,8 @@ class MonoMidi extends Sequencer {
 		// normalized velocity (0 - 1)
 		let g = Util.getParam(this._velocity[0], c);
 				
-		// get the duration
-		let d = Util.divToS(Util.getParam(this._dur, c), this.bpm()) * 1000;
+		// get the duration (minus 5ms to ensure note-off send before note-on)
+		let d = Util.divToS(Util.getParam(this._dur, c), this.bpm()) * 1000 - 5;
 
 		// get the channel
 		let ch = Util.getParam(this._channel, c);
@@ -15945,6 +16440,15 @@ class MonoMidi extends Sequencer {
 		let offset = WebMidi.time - Tone.context.currentTime * 1000;
 		let sync = time * 1000 + offset;
 
+		// send program change messages on specified channel
+		// only if the value is an integer
+		let pc = Util.getParam(this._program, c);
+		if (!isNaN(pc) && this._pgm !== pc){
+			this._device.sendProgramChange(pc, ch, { time: sync - 1 });
+			// only send value if different from previous one
+			this._pgm = pc;
+		}
+
 		// send pitchbend message in hires -1 1 at specified channel
 		if (this._bend.length > 0){
 			let b = Util.lookup(this._bend, c);
@@ -15965,6 +16469,20 @@ class MonoMidi extends Sequencer {
 		// only play a note if the notes are provided in the function
 		// if (this._note.length > 0){
 
+		let noteOptions = { duration: d, velocity: g, time: sync };
+
+		// if a midinote is selected instead of note
+		// play the value without mapping
+		let m = Util.getParam(this._midinote, c);
+		if (m){
+			if (this._chord){
+				m = Util.lookup(this._midinote, c);
+				m = Util.toArray(m);
+			}
+			this._device.playNote(m, ch, noteOptions);
+			return;
+		}
+
 		// note as interval / octave coordinate
 		let o = Util.getParam(this._note[1], c);
 		let n = [];
@@ -15975,17 +16493,18 @@ class MonoMidi extends Sequencer {
 		} else {
 			i = [ Util.getParam(this._note[0], c) ];
 		}
+
+		// if the note is 'off' don't play the note
+		// useful when only CC or Programchange is needed
+		if (i[0] === 'off'){ return; }
 		
 		for (let x=0; x<i.length; x++){
 			// reconstruct midi note value, (0, 0) = 36
 			// convert to scale and include the octave
 			n[x] = Util.toMidi(i[x], o);
 		}
-		
 		// play the note(s)! updated for webmidi 3.x
-		this._device.playNote(n, ch, { duration: d, attack: g, time: sync });
-
-		// }
+		this._device.playNote(n, ch, noteOptions);
 	}
 
 	amp(g, r){
@@ -16010,6 +16529,10 @@ class MonoMidi extends Sequencer {
 		this._bend = Util.toArray(b);
 	}
 
+	midinote(n=[60]){
+		this._midinote = Util.toArray(n);
+	}
+
 	chord(c){
 		this._chord = false;
 		if (c === 'on' || c === 1){
@@ -16017,6 +16540,10 @@ class MonoMidi extends Sequencer {
 		}
 	}
 
+	program(p){
+		this._program = Util.toArray(p);
+	}
+
 	add_fx(...cc){
 		// control parameters via control change midi messages
 		this._cc = [];
@@ -16036,7 +16563,14 @@ class MonoMidi extends Sequencer {
 		// send out midiclock messages to sync external devices
 		// on this specific midi output and channel
 		// this._sync;
-	}	
+	}
+	
+	delete(){
+		// delete super class
+		super.delete();
+
+		console.log('=> disposed MonoMidi()', this._device);
+	}
 }
 module.exports = MonoMidi;
 },{"./Sequencer.js":65,"./Util.js":66,"tone":44,"webmidi":55}],60:[function(require,module,exports){
@@ -16083,16 +16617,19 @@ class MonoSample extends Instrument {
 			// clean-up previous buffer
 			this.sample.buffer.dispose();
 		}
+
+		if (!this._bufs.has(f)){	
+			Util.log(`${w} is not a valid sample name`);
+			// defaul sample if file doesn not exist
+			f = 'kick_909';
+		} 
+		
 		if (this._bufs.has(f)){	
 			this.sample.buffer = this._bufs.get(f);
-			// this.sample.buffer = this._bufs.get(f).slice(0);
 		} else {
 			// default sample if file does not exist
-			this.sample.buffer = this._bufs.get('kick_min');
-			// this.sample.buffer = this._bufs.get('kick_min').slice(0);
+			this.sample.buffer = this._bufs.get('kick_909');
 		}
-		// the duration of the buffer in seconds
-		let dur = this.sample.buffer.duration;
 
 		// get speed and if 2d array pick randomly
 		let s = Util.getParam(this._speed, c);
@@ -16115,6 +16652,8 @@ class MonoSample extends Instrument {
 		// it becomes normal playback again) no fix yet
 		// this.sample.reverse = s < 0.0;
 
+		// the duration of the buffer in seconds
+		let dur = this.sample.buffer.duration;
 		let l = Util.lookup(this._stretch, c);
 		let n = 1;
 		if (l){
@@ -16186,7 +16725,12 @@ class MonoSample extends Instrument {
 		// delete super class
 		super.delete();
 		// disconnect the sound dispose the player
+		this.source.stop();
+		this.source.disconnect();
 		this.source.dispose();
+
+		this.sample.stop();
+		this.sample.disconnect();
 		this.sample.dispose();
 
 		console.log('=> disposed MonoSample()', this._sound);
@@ -16213,10 +16757,11 @@ class MonoSynth extends Instrument {
 			triangle : 'triangle',
 			tri : 'triangle',
 			rect : 'square',
-			fm: 'fmsine',
-			am: 'amsine',
-			pwm: 'pwm',
-			organ: 'sine4',
+			organ : 'sine4',
+			// fm: 'fmsine',
+			// am: 'amsine',
+			// pwm: 'pwm',
+			// organ: 'sine4',
 		}
 		// // synth specific variables;
 		this._note = [ 0, 0 ];
@@ -16277,8 +16822,9 @@ class MonoSynth extends Instrument {
 			this.synth.frequency.rampTo(f, s, time);
 		} else {
 			this.synth.frequency.setValueAtTime(f, time);
-			this._firstSlide = false;
 		}
+		// first time the synth plays don't slide!
+		this._firstSlide = false;
 	}
 
 	super(v=[3], d=[0.111]){
@@ -16303,6 +16849,11 @@ class MonoSynth extends Instrument {
 		super.delete();
 		// dispose the sound source
 		// this.source.delete();
+		// this.adsr.dispose();
+		this.synth.stop();
+		this.synth.disconnect();
+		this.synth.dispose();
+
 		this.adsr.dispose();
 		this.synth.dispose();
 		this.source.dispose();
@@ -16314,10 +16865,10 @@ module.exports = MonoSynth;
 },{"./Instrument":57,"./Util.js":66,"tone":44,"total-serialism":47}],62:[function(require,module,exports){
 const Tone = require('tone');
 const Util = require('./Util.js');
-const fxMap = require('./Effects.js');
-const TL = require('total-serialism').Translate;
-// const Sequencer = require('./Sequencer.js');
 const Instrument = require('./Instrument.js');
+// const fxMap = require('./Effects.js');
+// const TL = require('total-serialism').Translate;
+// const Sequencer = require('./Sequencer.js');
 
 // Basic class for a poly-instrument
 class PolyInstrument extends Instrument {
@@ -16425,15 +16976,17 @@ class PolyInstrument extends Instrument {
 					let dec = Util.divToS(Util.lookup(this._sus, c), this.bpm());
 					let rel = Util.divToS(Util.lookup(this._rel, c), this.bpm());
 		
-					this.adsrs[i].attack = att;
+					this.adsrs[i].attack = Math.max(0.001, att);
 					this.adsrs[i].decay = dec;
-					this.adsrs[i].release = rel;
+					this.adsrs[i].release = Math.max(0.001, rel);
 					
-					e = Math.min(this._time, att + dec + rel);
-			
+					// e = Math.min(this._time, att + dec + rel);
+					// let rt = Math.max(0.001, e - this.adsrs[i].release);
+					// this.adsrs[i].triggerAttackRelease(rt, time);
+
 					// trigger the envelope
-					let rt = Math.max(0.001, e - this.adsrs[i].release);
-					this.adsrs[i].triggerAttackRelease(rt, time);
+					this.adsrs[i].triggerAttack(time);
+					this.adsrs[i].triggerRelease(time + att + dec);
 				} else {
 					// if shape is off only trigger attack
 					// when voice stealing is 'off' this will lead to all 
@@ -16469,18 +17022,27 @@ class PolyInstrument extends Instrument {
 		// delete super class
 		super.delete();
 		// disconnect the sound dispose the player
-		// this.gain.dispose();
-		// this.panner.dispose();
+		this.gain.disconnect();
+		this.gain.dispose();
+		this.panner.disconnect();
+		this.panner.dispose();
 
-		this.adsrs.map((a) => a.dispose());
-		this.sources.map((s) => s.dispose());
+		this.adsrs.map((a) => {
+			a.disconnect();
+			a.dispose();
+		});
+		this.sources.map((s) => {
+			s.stop();
+			s.disconnect();
+			s.dispose();
+		});
 		// remove all fx
 		// this._fx.map((f) => f.delete());
 		console.log('=> disposed PolyInstrument() with FX:', this._fx);
 	}
 }
 module.exports = PolyInstrument;
-},{"./Effects.js":56,"./Instrument.js":57,"./Util.js":66,"tone":44,"total-serialism":47}],63:[function(require,module,exports){
+},{"./Instrument.js":57,"./Util.js":66,"tone":44}],63:[function(require,module,exports){
 const Tone = require('tone');
 const Util = require('./Util.js');
 const PolyInstrument = require('./PolyInstrument.js');
@@ -16545,7 +17107,7 @@ class PolySample extends PolyInstrument {
 			this.sources[id].buffer = this._bufs.get(b);
 		} else {
 			// default sample if file does not exist
-			this.sources[id].buffer = this._bufs.get('kick_min');
+			this.sources[id].buffer = this._bufs.get('kick_909');
 		}
 		// the duration of the buffer in seconds
 		let dur = this.sources[id].buffer.duration;
@@ -16738,6 +17300,11 @@ class PolySynth extends PolyInstrument {
 		this._detune = Util.toArray(d);
 	}
 
+	fat(...a){
+		// alias for super/unison synth
+		this.super(...a);
+	}
+
 	slide(s){
 		// portamento from one note to another
 		this._slide = Util.toArray(s);
@@ -16751,14 +17318,14 @@ class PolySynth extends PolyInstrument {
 		// delete super class
 		super.delete();
 		
-		console.log('disposed MonoSynth()', this._wave);
+		console.log('disposed PolySynth()', this._wave);
 	}
 }
 module.exports = PolySynth;
 },{"./PolyInstrument":62,"./Util.js":66,"tone":44}],65:[function(require,module,exports){
 const Tone = require('tone');
 const Util = require('./Util.js');
-const WebMidi = require("webmidi");
+// const WebMidi = require("webmidi");
 
 // Basic Sequencer class for triggering events
 class Sequencer {
@@ -16770,10 +17337,12 @@ class Sequencer {
 		// Sequencer specific parameters
 		this._count = 0;
 		this._beatCount = 0;
+		this._subdivCnt = 0;
 		this._time = 1;
 		this._subdiv = [ 1 ];
 		this._offset = 0;
 		this._beat = [ 1 ];
+		this._wait = null;
 		this._human = 0;
 
 		// visual code
@@ -16815,6 +17384,9 @@ class Sequencer {
 			}
 			// set subdivision speeds
 			this._loop.playbackRate = Util.getParam(this._subdiv, this._count);
+
+			// get the subdivision count (always 0, except when subdividing)
+			this._subdivCnt = (this._subdivCnt + 1) % this._loop.playbackRate;
 	
 			// humanize method is interesting to add
 			this._loop.humanize = Util.getParam(this._human, this._count);
@@ -16826,6 +17398,12 @@ class Sequencer {
 			if (Math.random() < b){
 				// get the count value
 				let c = this._beatCount;
+
+				// get the wait time (delay) convert to seconds
+				if (this._wait !== null){
+					let w = Util.getParam(this._wait, c);
+					time += Util.divToS(w, this.bpm());
+				}
 	
 				// trigger some events for this instrument based
 				// on the current count and time
@@ -16848,9 +17426,12 @@ class Sequencer {
 						this._canvas.eval(Util.getParam(this._visual, c));
 					}
 				}
-	
+
 				// increment internal beat counter
-				this._beatCount++;
+				// only increment if ratchetcounter is 0
+				if (this._subdivCnt < 1) { 
+					this._beatCount++; 
+				}
 			}
 			// increment count for sequencing
 			this._count++;
@@ -16868,7 +17449,9 @@ class Sequencer {
 			// calculate the scheduling
 			let schedule = Tone.Time(this._offset).toSeconds();
 			// create new loop for synth
-			this._loop = new Tone.Loop((time) => { this._event(time) }, this._time).start(schedule);
+			this._loop = new Tone.Loop((time) => { 
+				this._event(time) 
+			}, this._time).start(schedule);
 		} 
 		// else {
 		// 	// generate a listener for the osc-address
@@ -16962,6 +17545,11 @@ class Sequencer {
 		}
 	}
 
+	wait(w=[0]){
+		// wait a specified amount of milliseconds before triggering
+		this._wait = Util.toArray(w);
+	}
+
 	human(h){
 		// set the humanizing factor for the instrument in seconds
 		this._human = Util.toArray(h).map(x => Util.divToS(x));
@@ -16986,7 +17574,8 @@ class Sequencer {
 	}
 }
 module.exports = Sequencer;
-},{"./Util.js":66,"tone":44,"webmidi":55}],66:[function(require,module,exports){
+},{"./Util.js":66,"tone":44}],66:[function(require,module,exports){
+const Tone = require('tone');
 const { noteToMidi, toScale, mtof } = require('total-serialism').Translate;
 
 // replace defaults with incoming parameters
@@ -16995,6 +17584,13 @@ function mapDefaults(params, defaults){
 	return defaults.map(p => toArray(p));
 }
 
+// Function that is evaluated at a specific time from Tone Transpor
+// More precise than Tone.Transport.ScheduleOnce()
+// Workaround for Tone objects that don't have setValueAtTime
+function atTime(callback, time){
+	setTimeout(callback, (time - Tone.context.currentTime) * 1000);
+}
+
 // convert amplitude to dBFS scale
 function atodb(a=0){
 	return 20 * Math.log(a);
@@ -17005,8 +17601,8 @@ function dbtoa(db=0){
 	return 10 ** (db/20);
 }
 
-// clip a value between a specified range
-function clip(v, l, h){
+// clip a value between a specified range, defaults to 0 and 1 clip
+function clip(v, l=0, h=1){
 	return Math.max(l, Math.min(h, v));
 }
 
@@ -17203,8 +17799,8 @@ function log(msg){
 	}
 }
 
-module.exports = { mapDefaults, atodb, dbtoa, clip, assureNum, lookup, randLookup, isRandom, getParam, toArray, msToS, formatRatio, divToS, divToF, toMidi, mtof, noteToMidi, noteToFreq, assureWave, log }
-},{"total-serialism":47}],67:[function(require,module,exports){
+module.exports = { mapDefaults, atTime, atodb, dbtoa, clip, assureNum, lookup, randLookup, isRandom, getParam, toArray, msToS, formatRatio, divToS, divToF, toMidi, mtof, noteToMidi, noteToFreq, assureWave, log }
+},{"tone":44,"total-serialism":47}],67:[function(require,module,exports){
 module.exports={
 	"uptempo" : 10,
 	"downtempo" : 10,
@@ -17565,7 +18161,7 @@ const { WebMidi } = require("webmidi");
 // load extra AudioWorkletProcessors from file
 // transformed to inline with browserify brfs
 
-const fxExtensions = "\n// A white noise generator at -6dBFS to test AudioWorkletProcessor\n//\nclass NoiseProcessor extends AudioWorkletProcessor {\n\tprocess(inputs, outputs, parameters){\n\t\tconst output = outputs[0];\n\n\t\toutput.forEach((channel) => {\n\t\t\tfor (let i=0; i<channel.length; i++) {\n\t\t\t\tchannel[i] = Math.random() - 0.5;\n\t\t\t}\n\t\t});\n\t\treturn true;\n\t}\n}\nregisterProcessor('noise-processor', NoiseProcessor);\n\n// A Downsampling Chiptune effect. Downsamples the signal by a specified amount\n// Resulting in a lower samplerate, making it sound more like 8bit/chiptune\n// Programmed with a custom AudioWorkletProcessor, see effects/Processors.js\n//\nclass DownSampleProcessor extends AudioWorkletProcessor {\n\tstatic get parameterDescriptors() {\n\t\treturn [{\n\t\t\tname: 'down',\n\t\t\tdefaultValue: 8,\n\t\t\tminValue: 1,\n\t\t\tmaxValue: 2048\n\t\t}];\n\t}\n\n\tconstructor(){\n\t\tsuper();\n\t\t// the frame counter\n\t\tthis.count = 0;\n\t\t// sample and hold variable array\n\t\tthis.sah = [];\n\t}\n\n\tprocess(inputs, outputs, parameters){\n\t\tconst input = inputs[0];\n\t\tconst output = outputs[0];\n\n\t\t// if there is anything to process\n\t\tif (input.length > 0){\n\t\t\t// for the length of the sample array (generally 128)\n\t\t\tfor (let i=0; i<input[0].length; i++){\n\t\t\t\tconst d = (parameters.down.length > 1) ? parameters.down[i] : parameters.down[0];\n\t\t\t\t// for every channel\n\t\t\t\tfor (let channel=0; channel<input.length; ++channel){\n\t\t\t\t\t// if counter equals 0, sample and hold\n\t\t\t\t\tif (this.count % d === 0){\n\t\t\t\t\t\tthis.sah[channel] = input[channel][i];\n\t\t\t\t\t}\n\t\t\t\t\t// output the currently held sample\n\t\t\t\t\toutput[channel][i] = this.sah[channel];\n\t\t\t\t}\n\t\t\t\t// increment sample counter\n\t\t\t\tthis.count++;\n\t\t\t}\n\t\t}\n\t\treturn true;\n\t}\n}\nregisterProcessor('downsampler-processor', DownSampleProcessor);\n\n// A distortion algorithm using the tanh (hyperbolic-tangent) as a \n// waveshaping technique. Some mapping to apply a more equal loudness \n// distortion is applied on the overdrive parameter\n//\nclass TanhDistortionProcessor extends AudioWorkletProcessor {\n\tconstructor(){\n\t\tsuper();\n\t}\n\n\tprocess(inputs, outputs, parameters){\n\t\tconst input = inputs[0];\n\t\tconst output = outputs[0];\n\n\t\tif (input.length > 0){\n\t\t\tfor (let channel=0; channel<input.length; ++channel){\n\t\t\t\tfor (let i=0; i<input[channel].length; i++){\n\t\t\t\t\t// simple waveshaping with tanh\n\t\t\t\t\toutput[channel][i] = Math.tanh(input[channel][i]);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\treturn true;\n\t}\n}\nregisterProcessor('tanh-distortion-processor', TanhDistortionProcessor);\n\n// A distortion/compression effect of an incoming signal\n// Based on an algorithm by Peter McCulloch\n// \nclass SquashProcessor extends AudioWorkletProcessor {\n\tstatic get parameterDescriptors(){\n\t\treturn [{\n\t\t\tname: 'amount',\n\t\t\tdefaultValue: 4,\n\t\t\tminValue: 1,\n\t\t\tmaxValue: 1024\n\t\t}];\n\t}\n\n\tconstructor(){\n\t\tsuper();\n\t}\n\n\tprocess(inputs, outputs, parameters){\n\t\tconst input = inputs[0];\n\t\tconst output = outputs[0];\n\t\t\n\t\tif (input.length > 0){\n\t\t\tfor (let channel=0; channel<input.length; ++channel){\n\t\t\t\tfor (let i=0; i<input[channel].length; i++){\n\t\t\t\t\t// (s * a) / ((s * a)^2 * 0.28 + 1) / √a\n\t\t\t\t\t// drive amount, minimum of 1\n\t\t\t\t\tconst a = (parameters.amount.length > 1)? parameters.amount[i] : parameters.amount[0];\n\t\t\t\t\t// set the waveshaper effect\n\t\t\t\t\tconst s = input[channel][i];\n\t\t\t\t\tconst p = (s * a) / ((s * a) * (s * a) * 0.28 + 1.0);\n\t\t\t\t\toutput[channel][i] = p;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\treturn true;\n\t}\n}\nregisterProcessor('squash-processor', SquashProcessor);";
+const fxExtensions = "\n// A white noise generator at -6dBFS to test AudioWorkletProcessor\n//\n// class NoiseProcessor extends AudioWorkletProcessor {\n// \tprocess(inputs, outputs, parameters){\n// \t\tconst output = outputs[0];\n\n// \t\toutput.forEach((channel) => {\n// \t\t\tfor (let i=0; i<channel.length; i++) {\n// \t\t\t\tchannel[i] = Math.random() - 0.5;\n// \t\t\t}\n// \t\t});\n// \t\treturn true;\n// \t}\n// }\n// registerProcessor('noise-processor', NoiseProcessor);\n\n// A Downsampling Chiptune effect. Downsamples the signal by a specified amount\n// Resulting in a lower samplerate, making it sound more like 8bit/chiptune\n// Programmed with a custom AudioWorkletProcessor, see effects/Processors.js\n//\nclass DownSampleProcessor extends AudioWorkletProcessor {\n\tstatic get parameterDescriptors() {\n\t\treturn [{\n\t\t\tname: 'down',\n\t\t\tdefaultValue: 8,\n\t\t\tminValue: 1,\n\t\t\tmaxValue: 2048\n\t\t}];\n\t}\n\n\tconstructor(){\n\t\tsuper();\n\t\t// the frame counter\n\t\tthis.count = 0;\n\t\t// sample and hold variable array\n\t\tthis.sah = [];\n\t}\n\n\tprocess(inputs, outputs, parameters){\n\t\tconst input = inputs[0];\n\t\tconst output = outputs[0];\n\n\t\t// if there is anything to process\n\t\tif (input.length > 0){\n\t\t\t// for the length of the sample array (generally 128)\n\t\t\tfor (let i=0; i<input[0].length; i++){\n\t\t\t\tconst d = (parameters.down.length > 1) ? parameters.down[i] : parameters.down[0];\n\t\t\t\t// for every channel\n\t\t\t\tfor (let channel=0; channel<input.length; ++channel){\n\t\t\t\t\t// if counter equals 0, sample and hold\n\t\t\t\t\tif (this.count % d === 0){\n\t\t\t\t\t\tthis.sah[channel] = input[channel][i];\n\t\t\t\t\t}\n\t\t\t\t\t// output the currently held sample\n\t\t\t\t\toutput[channel][i] = this.sah[channel];\n\t\t\t\t}\n\t\t\t\t// increment sample counter\n\t\t\t\tthis.count++;\n\t\t\t}\n\t\t}\n\t\treturn true;\n\t}\n}\nregisterProcessor('downsampler-processor', DownSampleProcessor);\n\n// A distortion algorithm using the tanh (hyperbolic-tangent) as a \n// waveshaping technique. Some mapping to apply a more equal loudness \n// distortion is applied on the overdrive parameter\n//\nclass TanhDistortionProcessor extends AudioWorkletProcessor {\n\tstatic get parameterDescriptors(){\n\t\treturn [{\n\t\t\tname: 'amount',\n\t\t\tdefaultValue: 4,\n\t\t\tminValue: 1\n\t\t}, {\n\t\t\tname: 'makeup',\n\t\t\tdefaultValue: 0.5,\n\t\t\tminValue: 0,\n\t\t\tmaxValue: 2\n\t\t}]\n\t}\n\n\tconstructor(){\n\t\tsuper();\n\t}\n\n\tprocess(inputs, outputs, parameters){\n\t\tconst input = inputs[0];\n\t\tconst output = outputs[0];\n\n\t\tif (input.length > 0){\n\t\t\tfor (let channel=0; channel<input.length; ++channel){\n\t\t\t\tfor (let i=0; i<input[channel].length; i++){\n\t\t\t\t\tconst a = (parameters.amount.length > 1)? parameters.amount[i] : parameters.amount[0];\n\t\t\t\t\tconst m = (parameters.makeup.length > 1)? parameters.makeup[i] : parameters.makeup[0];\n\t\t\t\t\t// simple waveshaping with tanh\n\t\t\t\t\toutput[channel][i] = Math.tanh(input[channel][i] * a) * m;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\treturn true;\n\t}\n}\nregisterProcessor('tanh-distortion-processor', TanhDistortionProcessor);\n\n// A distortion/compression effect of an incoming signal\n// Based on an algorithm by Peter McCulloch\n// \nclass SquashProcessor extends AudioWorkletProcessor {\n\tstatic get parameterDescriptors(){\n\t\treturn [{\n\t\t\tname: 'amount',\n\t\t\tdefaultValue: 4,\n\t\t\tminValue: 1,\n\t\t\tmaxValue: 1024\n\t\t}, {\n\t\t\tname: 'makeup',\n\t\t\tdefaultValue: 0.5,\n\t\t\tminValue: 0,\n\t\t\tmaxValue: 2\n\t\t}];\n\t}\n\n\tconstructor(){\n\t\tsuper();\n\t}\n\n\tprocess(inputs, outputs, parameters){\n\t\tconst input = inputs[0];\n\t\tconst output = outputs[0];\n\t\t\n\t\tif (input.length > 0){\n\t\t\tfor (let channel=0; channel<input.length; ++channel){\n\t\t\t\tfor (let i=0; i<input[channel].length; i++){\n\t\t\t\t\t// (s * a) / ((s * a)^2 * 0.28 + 1) / √a\n\t\t\t\t\t// drive amount, minimum of 1\n\t\t\t\t\tconst a = (parameters.amount.length > 1)? parameters.amount[i] : parameters.amount[0];\n\t\t\t\t\t// makeup gain\n\t\t\t\t\tconst m = (parameters.makeup.length > 1)? parameters.makeup[i] : parameters.makeup[0];\n\t\t\t\t\t// set the waveshaper effect\n\t\t\t\t\tconst s = input[channel][i];\n\t\t\t\t\tconst x = s * a * 1.412;\n\t\t\t\t\toutput[channel][i] = (x / (x * x * 0.28 + 1.0)) * m * 0.708;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\treturn true;\n\t}\n}\nregisterProcessor('squash-processor', SquashProcessor);";
 Tone.getContext().addAudioWorkletModule(URL.createObjectURL(new Blob([ fxExtensions ], { type: 'text/javascript' })));
 
 // Mercury main class controls Tone and loads samples