scribbletune 5.1.0 → 5.2.0

package/dist/browser.js.map

@@ -1 +1 @@
-{"version":3,"file":"browser.js","mappings":"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","sources":["webpack://scribbletune/./node_modules/harmonics/main.js","webpack://scribbletune/./node_modules/jsmidgen/lib/jsmidgen.js","webpack://scribbletune/./src/arp.ts","webpack://scribbletune/./src/browser-clip.ts","webpack://scribbletune/./src/browser-index.ts","webpack://scribbletune/./src/channel.ts","webpack://scribbletune/./src/midi.ts","webpack://scribbletune/./src/progression.ts","webpack://scribbletune/./src/session.ts","webpack://scribbletune/./src/types/index.ts","webpack://scribbletune/./src/utils.ts","webpack://scribbletune/external commonjs \"fs\"","webpack://scribbletune/webpack/bootstrap","webpack://scribbletune/webpack/runtime/node module decorator","webpack://scribbletune/webpack/startup"],"sourcesContent":["(()=>{\"use strict\";var n={413:n=>{n.exports=JSON.parse('{\"5th\":\"100000010000\",\"M7#5sus4\":\"100001001001\",\"7#5sus4\":\"100001001010\",\"sus4\":\"100001010000\",\"M7sus4\":\"100001010001\",\"7sus4\":\"100001010010\",\"7no5\":\"100010000010\",\"aug\":\"100010001000\",\"M7b6\":\"100010001001\",\"maj7#5\":\"100010001001\",\"7#5\":\"100010001010\",\"7b13\":\"100010001010\",\"M\":\"100010010000\",\"maj7\":\"100010010001\",\"7th\":\"100010010010\",\"6th\":\"100010010100\",\"7add6\":\"100010010110\",\"7b6\":\"100010011010\",\"Mb5\":\"100010100000\",\"M7b5\":\"100010100001\",\"7b5\":\"100010100010\",\"maj#4\":\"100010110001\",\"7#11\":\"100010110010\",\"M6#11\":\"100010110100\",\"7#11b13\":\"100010111010\",\"m#5\":\"100100001000\",\"mb6M7\":\"100100001001\",\"m7#5\":\"100100001010\",\"m\":\"100100010000\",\"m/ma7\":\"100100010001\",\"m7\":\"100100010010\",\"m6\":\"100100010100\",\"mMaj7b6\":\"100100011001\",\"dim\":\"100100100000\",\"oM7\":\"100100100001\",\"m7b5\":\"100100100010\",\"dim7\":\"100100100100\",\"o7M7\":\"100100100101\",\"4th\":\"100101000010\",\"madd4\":\"100101010000\",\"m7add11\":\"100101010010\",\"+add#9\":\"100110001000\",\"7#5#9\":\"100110001010\",\"7#9\":\"100110010010\",\"13#9\":\"100110010110\",\"7#9b13\":\"100110011010\",\"maj7#9#11\":\"100110110001\",\"7#9#11\":\"100110110010\",\"13#9#11\":\"100110110110\",\"7#9#11b13\":\"100110111010\",\"sus2\":\"101000010000\",\"M9#5sus4\":\"101001001001\",\"sus24\":\"101001010000\",\"M9sus4\":\"101001010001\",\"11th\":\"101001010010\",\"9sus4\":\"101001010010\",\"13sus4\":\"101001010110\",\"9no5\":\"101010000010\",\"13no5\":\"101010000110\",\"M#5add9\":\"101010001000\",\"maj9#5\":\"101010001001\",\"9#5\":\"101010001010\",\"9b13\":\"101010001010\",\"Madd9\":\"101010010000\",\"maj9\":\"101010010001\",\"9th\":\"101010010010\",\"6/9\":\"101010010100\",\"maj13\":\"101010010101\",\"M7add13\":\"101010010101\",\"13th\":\"101010010110\",\"M9b5\":\"101010100001\",\"9b5\":\"101010100010\",\"13b5\":\"101010100110\",\"9#5#11\":\"101010101010\",\"maj9#11\":\"101010110001\",\"9#11\":\"101010110010\",\"69#11\":\"101010110100\",\"M13#11\":\"101010110101\",\"13#11\":\"101010110110\",\"9#11b13\":\"101010111010\",\"m9#5\":\"101100001010\",\"madd9\":\"101100010000\",\"mM9\":\"101100010001\",\"m9\":\"101100010010\",\"m69\":\"101100010100\",\"m13\":\"101100010110\",\"mMaj9b6\":\"101100011001\",\"m9b5\":\"101100100010\",\"m11A\":\"101101001010\",\"m11\":\"101101010010\",\"b9sus\":\"110001010010\",\"11b9\":\"110001010010\",\"7sus4b9b13\":\"110001011010\",\"alt7\":\"110010000010\",\"7#5b9\":\"110010001010\",\"Maddb9\":\"110010010000\",\"M7b9\":\"110010010001\",\"7b9\":\"110010010010\",\"13b9\":\"110010010110\",\"7b9b13\":\"110010011010\",\"7#5b9#11\":\"110010101010\",\"7b9#11\":\"110010110010\",\"13b9#11\":\"110010110110\",\"7b9b13#11\":\"110010111010\",\"mb6b9\":\"110100001000\",\"7b9#9\":\"110110010010\"}')},722:n=>{n.exports=JSON.parse('{\"major pentatonic\":\"101010010100\",\"ionian pentatonic\":\"100011010001\",\"mixolydian pentatonic\":\"100011010010\",\"ritusen\":\"101001010100\",\"egyptian\":\"101001010010\",\"neopolitan major pentatonic\":\"100011100010\",\"vietnamese 1\":\"100101011000\",\"pelog\":\"110100011000\",\"kumoijoshi\":\"110001011000\",\"hirajoshi\":\"101100011000\",\"iwato\":\"110001100010\",\"in-sen\":\"110001010010\",\"lydian pentatonic\":\"100010110001\",\"malkos raga\":\"100101001010\",\"locrian pentatonic\":\"100101100010\",\"minor pentatonic\":\"100101010010\",\"minor six pentatonic\":\"100101010100\",\"flat three pentatonic\":\"101100010100\",\"flat six pentatonic\":\"101010011000\",\"scriabin\":\"110010010100\",\"whole tone pentatonic\":\"100010101010\",\"lydian #5P pentatonic\":\"100010101001\",\"lydian dominant pentatonic\":\"100010110010\",\"minor #7M pentatonic\":\"100101010001\",\"super locrian pentatonic\":\"100110100010\",\"minor hexatonic\":\"101101010001\",\"augmented\":\"100110011001\",\"major blues\":\"101110010100\",\"piongio\":\"101001010110\",\"prometheus neopolitan\":\"110010100110\",\"prometheus\":\"101010100110\",\"mystery #1\":\"110010101010\",\"six tone symmetric\":\"110011001100\",\"whole tone\":\"101010101010\",\"messiaen\\'s mode #5\":\"110001110001\",\"minor blues\":\"100101110010\",\"locrian major\":\"101011101010\",\"double harmonic lydian\":\"110010111001\",\"harmonic minor\":\"101101011001\",\"altered\":\"110110101010\",\"locrian #2\":\"101101101010\",\"mixolydian b6\":\"101011011010\",\"lydian dominant\":\"101010110110\",\"lydian\":\"101010110101\",\"lydian augmented\":\"101010101101\",\"dorian b2\":\"110101010110\",\"melodic minor\":\"101101010101\",\"locrian\":\"110101101010\",\"ultralocrian\":\"110110101100\",\"locrian 6\":\"110101100110\",\"augmented heptatonic\":\"100111011001\",\"romanian minor\":\"101100110110\",\"dorian #4\":\"101100110110\",\"lydian diminished\":\"101100110101\",\"phrygian\":\"110101011010\",\"leading whole tone\":\"101010101011\",\"lydian minor\":\"101010111010\",\"phrygian dominant\":\"110011011010\",\"balinese\":\"110101011001\",\"neopolitan major\":\"110101010101\",\"aeolian\":\"101101011010\",\"harmonic major\":\"101011011001\",\"double harmonic major\":\"110011011001\",\"dorian\":\"101101010110\",\"hungarian minor\":\"101100111001\",\"hungarian major\":\"100110110110\",\"oriental\":\"110011100110\",\"flamenco\":\"110110110010\",\"todi raga\":\"110100111001\",\"mixolydian\":\"101011010110\",\"persian\":\"110011101001\",\"major\":\"101011010101\",\"enigmatic\":\"110010101011\",\"major augmented\":\"101011001101\",\"lydian #9\":\"100110110101\",\"messiaen\\'s mode #4\":\"111001111001\",\"purvi raga\":\"110011111001\",\"spanish heptatonic\":\"110111011010\",\"bebop\":\"101011010111\",\"bebop minor\":\"101111010110\",\"bebop major\":\"101011011101\",\"bebop locrian\":\"110101111010\",\"minor bebop\":\"101101011011\",\"diminished\":\"101101101101\",\"ichikosucho\":\"101011110101\",\"minor six diminished\":\"101101011101\",\"half-whole diminished\":\"110110110110\",\"kafi raga\":\"100111010111\",\"messiaen\\'s mode #6\":\"101011101011\",\"composite blues\":\"101111110110\",\"messiaen\\'s mode #3\":\"101110111011\",\"messiaen\\'s mode #7\":\"111101111101\",\"chromatic\":\"111111111111\",\"ionian\":\"101011010101\",\"minor\":\"101101011010\"}')}},e={};function o(a){var i=e[a];if(void 0!==i)return i.exports;var r=e[a]={exports:{}};return n[a](r,r.exports,o),r.exports}o.d=(n,e)=>{for(var a in e)o.o(e,a)&&!o.o(n,a)&&Object.defineProperty(n,a,{enumerable:!0,get:e[a]})},o.o=(n,e)=>Object.prototype.hasOwnProperty.call(n,e),o.r=n=>{\"undefined\"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(n,Symbol.toStringTag,{value:\"Module\"}),Object.defineProperty(n,\"__esModule\",{value:!0})};var a={};(()=>{o.r(a),o.d(a,{chord:()=>m,chords:()=>t,inlineChord:()=>r,scale:()=>c,scales:()=>s});var n=o(722),e=o(413),i=function(o){var a=o.scale,i=o.chord,r=a||i,t=a?\"scale\":\"chord\";if(\"string\"!=typeof r)throw new Error(\"\".concat(r,\" is not a valid input for \").concat(t));var s,m,c=r.indexOf(\" \");-1===c?(s=r.slice(1),m=r[0],\"b\"!==r[1]&&\"#\"!==r[1]||(s=r.slice(2),m+=r[1])):(s=r.slice(-1===c?1:c+1),m=r.slice(0,c));var d=function(n){return{\"C#\":\"Db\",\"D#\":\"Eb\",\"F#\":\"Gb\",\"G#\":\"Ab\",\"A#\":\"Bb\"}[n.toUpperCase()]||n.charAt(0).toUpperCase()+n.slice(1)}(m.replace(/\\d/g,\"\")),l=\"\"!==m.replace(/\\D/g,\"\")?+m.replace(/\\D/g,\"\"):4;if(isNaN(l))throw new Error(\"\".concat(m[0],\" does not have a valid octave\"));if(!n[s]&&!e[s])throw new Error(\"\".concat(r,\" is not a valid \").concat(t));for(var b=function(n,e){var o=[\"C\",\"Db\",\"D\",\"Eb\",\"E\",\"F\",\"Gb\",\"G\",\"Ab\",\"A\",\"Bb\",\"B\"],a=o.map((function(n){return n+e})),i=o.map((function(n){return n+(e+1)})),r=a.concat(i);return r.slice(r.indexOf(n+e))}(d,l),u=[],p=0,h=0,f=a?n:e;p<f[s].length;)\"1\"===f[s][p]&&u.push(b[h]),p++,h++;return u},r=function(n){var e,o,a=\"b9sus\",r=4;return n.includes(a)?(o=a,e=n.slice(0,n.indexOf(a))):(e=n[0],o=n.slice(1),\"b\"!==n[1]&&\"#\"!==n[1]||(e+=n[1],o=n.slice(2))),n.includes(\"_\")&&(r=+n.split(\"_\")[1],o=o.slice(0,o.indexOf(\"_\"))),i({chord:e+r+\" \"+o})},t=function(){return Object.keys(e)},s=function(){return Object.keys(n)},m=function(n){return i({chord:n})},c=function(n){return i({scale:n})}})();var i=exports;for(var r in a)i[r]=a[r];a.__esModule&&Object.defineProperty(i,\"__esModule\",{value:!0})})();\n//# sourceMappingURL=main.js.map","var Midi = {};\n\n(function(exported) {\n\n\tvar DEFAULT_VOLUME   = exported.DEFAULT_VOLUME   = 90;\n\tvar DEFAULT_DURATION = exported.DEFAULT_DURATION = 128;\n\tvar DEFAULT_CHANNEL  = exported.DEFAULT_CHANNEL  = 0;\n\n\t/* ******************************************************************\n\t * Utility functions\n\t ****************************************************************** */\n\n\tvar Util = {\n\n\t\tmidi_letter_pitches: { a:21, b:23, c:12, d:14, e:16, f:17, g:19 },\n\n\t\t/**\n\t\t * Convert a symbolic note name (e.g. \"c4\") to a numeric MIDI pitch (e.g.\n\t\t * 60, middle C).\n\t\t *\n\t\t * @param {string} n - The symbolic note name to parse.\n\t\t * @returns {number} The MIDI pitch that corresponds to the symbolic note\n\t\t * name.\n\t\t */\n\t\tmidiPitchFromNote: function(n) {\n\t\t\tvar matches = /([a-g])(#+|b+)?([0-9]+)$/i.exec(n);\n\t\t\tvar note = matches[1].toLowerCase(), accidental = matches[2] || '', octave = parseInt(matches[3], 10);\n\t\t\treturn (12 * octave) + Util.midi_letter_pitches[note] + (accidental.substr(0,1)=='#'?1:-1) * accidental.length;\n\t\t},\n\n\t\t/**\n\t\t * Ensure that the given argument is converted to a MIDI pitch. Note that\n\t\t * it may already be one (including a purely numeric string).\n\t\t *\n\t\t * @param {string|number} p - The pitch to convert.\n\t\t * @returns {number} The resulting numeric MIDI pitch.\n\t\t */\n\t\tensureMidiPitch: function(p) {\n\t\t\tif (typeof p == 'number' || !/[^0-9]/.test(p)) {\n\t\t\t\t// numeric pitch\n\t\t\t\treturn parseInt(p, 10);\n\t\t\t} else {\n\t\t\t\t// assume it's a note name\n\t\t\t\treturn Util.midiPitchFromNote(p);\n\t\t\t}\n\t\t},\n\n\t\tmidi_pitches_letter: { '12':'c', '13':'c#', '14':'d', '15':'d#', '16':'e', '17':'f', '18':'f#', '19':'g', '20':'g#', '21':'a', '22':'a#', '23':'b' },\n\t\tmidi_flattened_notes: { 'a#':'bb', 'c#':'db', 'd#':'eb', 'f#':'gb', 'g#':'ab' },\n\n\t\t/**\n\t\t * Convert a numeric MIDI pitch value (e.g. 60) to a symbolic note name\n\t\t * (e.g. \"c4\").\n\t\t *\n\t\t * @param {number} n - The numeric MIDI pitch value to convert.\n\t\t * @param {boolean} [returnFlattened=false] - Whether to prefer flattened\n\t\t * notes to sharpened ones. Optional, default false.\n\t\t * @returns {string} The resulting symbolic note name.\n\t\t */\n\t\tnoteFromMidiPitch: function(n, returnFlattened) {\n\t\t\tvar octave = 0, noteNum = n, noteName, returnFlattened = returnFlattened || false;\n\t\t\tif (n > 23) {\n\t\t\t\t// noteNum is on octave 1 or more\n\t\t\t\toctave = Math.floor(n/12) - 1;\n\t\t\t\t// subtract number of octaves from noteNum\n\t\t\t\tnoteNum = n - octave * 12;\n\t\t\t}\n\n\t\t\t// get note name (c#, d, f# etc)\n\t\t\tnoteName = Util.midi_pitches_letter[noteNum];\n\t\t\t// Use flattened notes if requested (e.g. f# should be output as gb)\n\t\t\tif (returnFlattened && noteName.indexOf('#') > 0) {\n\t\t\t\tnoteName = Util.midi_flattened_notes[noteName];\n\t\t\t}\n\t\t\treturn noteName + octave;\n\t\t},\n\n\t\t/**\n\t\t * Convert beats per minute (BPM) to microseconds per quarter note (MPQN).\n\t\t *\n\t\t * @param {number} bpm - A number in beats per minute.\n\t\t * @returns {number} The number of microseconds per quarter note.\n\t\t */\n\t\tmpqnFromBpm: function(bpm) {\n\t\t\tvar mpqn = Math.floor(60000000 / bpm);\n\t\t\tvar ret=[];\n\t\t\tdo {\n\t\t\t\tret.unshift(mpqn & 0xFF);\n\t\t\t\tmpqn >>= 8;\n\t\t\t} while (mpqn);\n\t\t\twhile (ret.length < 3) {\n\t\t\t\tret.push(0);\n\t\t\t}\n\t\t\treturn ret;\n\t\t},\n\n\t\t/**\n\t\t * Convert microseconds per quarter note (MPQN) to beats per minute (BPM).\n\t\t *\n\t\t * @param {number} mpqn - The number of microseconds per quarter note.\n\t\t * @returns {number} A number in beats per minute.\n\t\t */\n\t\tbpmFromMpqn: function(mpqn) {\n\t\t\tvar m = mpqn;\n\t\t\tif (typeof mpqn[0] != 'undefined') {\n\t\t\t\tm = 0;\n\t\t\t\tfor (var i=0, l=mpqn.length-1; l >= 0; ++i, --l) {\n\t\t\t\t\tm |= mpqn[i] << l;\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn Math.floor(60000000 / mpqn);\n\t\t},\n\n\t\t/**\n\t\t * Converts an array of bytes to a string of hexadecimal characters. Prepares\n\t\t * it to be converted into a base64 string.\n\t\t *\n\t\t * @param {Array} byteArray - Array of bytes to be converted.\n\t\t * @returns {string} Hexadecimal string, e.g. \"097B8A\".\n\t\t */\n\t\tcodes2Str: function(byteArray) {\n\t\t\treturn String.fromCharCode.apply(null, byteArray);\n\t\t},\n\n\t\t/**\n\t\t * Converts a string of hexadecimal values to an array of bytes. It can also\n\t\t * add remaining \"0\" nibbles in order to have enough bytes in the array as the\n\t\t * `finalBytes` parameter.\n\t\t *\n\t\t * @param {string} str - string of hexadecimal values e.g. \"097B8A\"\n\t\t * @param {number} [finalBytes] - Optional. The desired number of bytes\n\t\t * (not nibbles) that the returned array should contain.\n\t\t * @returns {Array} An array of nibbles.\n\t\t */\n\t\tstr2Bytes: function (str, finalBytes) {\n\t\t\tif (finalBytes) {\n\t\t\t\twhile ((str.length / 2) < finalBytes) { str = \"0\" + str; }\n\t\t\t}\n\n\t\t\tvar bytes = [];\n\t\t\tfor (var i=str.length-1; i>=0; i = i-2) {\n\t\t\t\tvar chars = i === 0 ? str[i] : str[i-1] + str[i];\n\t\t\t\tbytes.unshift(parseInt(chars, 16));\n\t\t\t}\n\n\t\t\treturn bytes;\n\t\t},\n\n\t\t/**\n\t\t * Translates number of ticks to MIDI timestamp format, returning an array\n\t\t * of bytes with the time values. MIDI has a very particular way to express\n\t\t * time; take a good look at the spec before ever touching this function.\n\t\t *\n\t\t * @param {number} ticks - Number of ticks to be translated.\n\t\t * @returns {number} Array of bytes that form the MIDI time value.\n\t\t */\n\t\ttranslateTickTime: function(ticks) {\n\t\t\tvar buffer = ticks & 0x7F;\n\n\t\t\twhile (ticks = ticks >> 7) {\n\t\t\t\tbuffer <<= 8;\n\t\t\t\tbuffer |= ((ticks & 0x7F) | 0x80);\n\t\t\t}\n\n\t\t\tvar bList = [];\n\t\t\twhile (true) {\n\t\t\t\tbList.push(buffer & 0xff);\n\n\t\t\t\tif (buffer & 0x80) { buffer >>= 8; }\n\t\t\t\telse { break; }\n\t\t\t}\n\t\t\treturn bList;\n\t\t},\n\n\t};\n\n\t/* ******************************************************************\n\t * Event class\n\t ****************************************************************** */\n\n\t/**\n\t * Construct a MIDI event.\n\t *\n\t * Parameters include:\n\t *  - time [optional number] - Ticks since previous event.\n\t *  - type [required number] - Type of event.\n\t *  - channel [required number] - Channel for the event.\n\t *  - param1 [required number] - First event parameter.\n\t *  - param2 [optional number] - Second event parameter.\n\t */\n\tvar MidiEvent = function(params) {\n\t\tif (!this) return new MidiEvent(params);\n\t\tif (params &&\n\t\t\t\t(params.type    !== null || params.type    !== undefined) &&\n\t\t\t\t(params.channel !== null || params.channel !== undefined) &&\n\t\t\t\t(params.param1  !== null || params.param1  !== undefined)) {\n\t\t\tthis.setTime(params.time);\n\t\t\tthis.setType(params.type);\n\t\t\tthis.setChannel(params.channel);\n\t\t\tthis.setParam1(params.param1);\n\t\t\tthis.setParam2(params.param2);\n\t\t}\n\t};\n\n\t// event codes\n\tMidiEvent.NOTE_OFF           = 0x80;\n\tMidiEvent.NOTE_ON            = 0x90;\n\tMidiEvent.AFTER_TOUCH        = 0xA0;\n\tMidiEvent.CONTROLLER         = 0xB0;\n\tMidiEvent.PROGRAM_CHANGE     = 0xC0;\n\tMidiEvent.CHANNEL_AFTERTOUCH = 0xD0;\n\tMidiEvent.PITCH_BEND         = 0xE0;\n\n\n\t/**\n\t * Set the time for the event in ticks since the previous event.\n\t *\n\t * @param {number} ticks - The number of ticks since the previous event. May\n\t * be zero.\n\t */\n\tMidiEvent.prototype.setTime = function(ticks) {\n\t\tthis.time = Util.translateTickTime(ticks || 0);\n\t};\n\n\t/**\n\t * Set the type of the event. Must be one of the event codes on MidiEvent.\n\t *\n\t * @param {number} type - Event type.\n\t */\n\tMidiEvent.prototype.setType = function(type) {\n\t\tif (type < MidiEvent.NOTE_OFF || type > MidiEvent.PITCH_BEND) {\n\t\t\tthrow new Error(\"Trying to set an unknown event: \" + type);\n\t\t}\n\n\t\tthis.type = type;\n\t};\n\n\t/**\n\t * Set the channel for the event. Must be between 0 and 15, inclusive.\n\t *\n\t * @param {number} channel - The event channel.\n\t */\n\tMidiEvent.prototype.setChannel = function(channel) {\n\t\tif (channel < 0 || channel > 15) {\n\t\t\tthrow new Error(\"Channel is out of bounds.\");\n\t\t}\n\n\t\tthis.channel = channel;\n\t};\n\n\t/**\n\t * Set the first parameter for the event. Must be between 0 and 255,\n\t * inclusive.\n\t *\n\t * @param {number} p - The first event parameter value.\n\t */\n\tMidiEvent.prototype.setParam1 = function(p) {\n\t\tthis.param1 = p;\n\t};\n\n\t/**\n\t * Set the second parameter for the event. Must be between 0 and 255,\n\t * inclusive.\n\t *\n\t * @param {number} p - The second event parameter value.\n\t */\n\tMidiEvent.prototype.setParam2 = function(p) {\n\t\tthis.param2 = p;\n\t};\n\n\t/**\n\t * Serialize the event to an array of bytes.\n\t *\n\t * @returns {Array} The array of serialized bytes.\n\t */\n\tMidiEvent.prototype.toBytes = function() {\n\t\tvar byteArray = [];\n\n\t\tvar typeChannelByte = this.type | (this.channel & 0xF);\n\n\t\tbyteArray.push.apply(byteArray, this.time);\n\t\tbyteArray.push(typeChannelByte);\n\t\tbyteArray.push(this.param1);\n\n\t\t// Some events don't have a second parameter\n\t\tif (this.param2 !== undefined && this.param2 !== null) {\n\t\t\tbyteArray.push(this.param2);\n\t\t}\n\t\treturn byteArray;\n\t};\n\n\t/* ******************************************************************\n\t * MetaEvent class\n\t ****************************************************************** */\n\n\t/**\n\t * Construct a meta event.\n\t *\n\t * Parameters include:\n\t *  - time [optional number] - Ticks since previous event.\n\t *  - type [required number] - Type of event.\n\t *  - data [optional array|string] - Event data.\n\t */\n\tvar MetaEvent = function(params) {\n\t\tif (!this) return new MetaEvent(params);\n\t\tvar p = params || {};\n\t\tthis.setTime(params.time);\n\t\tthis.setType(params.type);\n\t\tthis.setData(params.data);\n\t};\n\n\tMetaEvent.SEQUENCE   = 0x00;\n\tMetaEvent.TEXT       = 0x01;\n\tMetaEvent.COPYRIGHT  = 0x02;\n\tMetaEvent.TRACK_NAME = 0x03;\n\tMetaEvent.INSTRUMENT = 0x04;\n\tMetaEvent.LYRIC      = 0x05;\n\tMetaEvent.MARKER     = 0x06;\n\tMetaEvent.CUE_POINT  = 0x07;\n\tMetaEvent.CHANNEL_PREFIX = 0x20;\n\tMetaEvent.END_OF_TRACK   = 0x2f;\n\tMetaEvent.TEMPO      = 0x51;\n\tMetaEvent.SMPTE      = 0x54;\n\tMetaEvent.TIME_SIG   = 0x58;\n\tMetaEvent.KEY_SIG    = 0x59;\n\tMetaEvent.SEQ_EVENT  = 0x7f;\n\n\t/**\n\t * Set the time for the event in ticks since the previous event.\n\t *\n\t * @param {number} ticks - The number of ticks since the previous event. May\n\t * be zero.\n\t */\n\tMetaEvent.prototype.setTime = function(ticks) {\n\t\tthis.time = Util.translateTickTime(ticks || 0);\n\t};\n\n\t/**\n\t * Set the type of the event. Must be one of the event codes on MetaEvent.\n\t *\n\t * @param {number} t - Event type.\n\t */\n\tMetaEvent.prototype.setType = function(t) {\n\t\tthis.type = t;\n\t};\n\n\t/**\n\t * Set the data associated with the event. May be a string or array of byte\n\t * values.\n\t *\n\t * @param {string|Array} d - Event data.\n\t */\n\tMetaEvent.prototype.setData = function(d) {\n\t\tthis.data = d;\n\t};\n\n\t/**\n\t * Serialize the event to an array of bytes.\n\t *\n\t * @returns {Array} The array of serialized bytes.\n\t */\n\tMetaEvent.prototype.toBytes = function() {\n\t\tif (!this.type) {\n\t\t\tthrow new Error(\"Type for meta-event not specified.\");\n\t\t}\n\n\t\tvar byteArray = [];\n\t\tbyteArray.push.apply(byteArray, this.time);\n\t\tbyteArray.push(0xFF, this.type);\n\n\t\t// If data is an array, we assume that it contains several bytes. We\n\t\t// apend them to byteArray.\n\t\tif (Array.isArray(this.data)) {\n\t\t\tbyteArray.push(this.data.length);\n\t\t\tbyteArray.push.apply(byteArray, this.data);\n\t\t} else if (typeof this.data == 'number') {\n\t\t\tbyteArray.push(1, this.data);\n\t\t} else if (this.data !== null && this.data !== undefined) {\n\t\t\t// assume string; may be a bad assumption\n\t\t\tbyteArray.push(this.data.length);\n\t\t\tvar dataBytes = this.data.split('').map(function(x){ return x.charCodeAt(0) });\n\t\t\tbyteArray.push.apply(byteArray, dataBytes);\n\t\t} else {\n\t\t\tbyteArray.push(0);\n\t\t}\n\n\t\treturn byteArray;\n\t};\n\n\t/* ******************************************************************\n\t * Track class\n\t ****************************************************************** */\n\n\t/**\n\t * Construct a MIDI track.\n\t *\n\t * Parameters include:\n\t *  - events [optional array] - Array of events for the track.\n\t */\n\tvar Track = function(config) {\n\t\tif (!this) return new Track(config);\n\t\tvar c = config || {};\n\t\tthis.events = c.events || [];\n\t};\n\n\tTrack.START_BYTES = [0x4d, 0x54, 0x72, 0x6b];\n\tTrack.END_BYTES   = [0x00, 0xFF, 0x2F, 0x00];\n\n\t/**\n\t * Add an event to the track.\n\t *\n\t * @param {MidiEvent|MetaEvent} event - The event to add.\n\t * @returns {Track} The current track.\n\t */\n\tTrack.prototype.addEvent = function(event) {\n\t\tthis.events.push(event);\n\t\treturn this;\n\t};\n\n\t/**\n\t * Add a note-on event to the track.\n\t *\n\t * @param {number} channel - The channel to add the event to.\n\t * @param {number|string} pitch - The pitch of the note, either numeric or\n\t * symbolic.\n\t * @param {number} [time=0] - The number of ticks since the previous event,\n\t * defaults to 0.\n\t * @param {number} [velocity=90] - The volume for the note, defaults to\n\t * DEFAULT_VOLUME.\n\t * @returns {Track} The current track.\n\t */\n\tTrack.prototype.addNoteOn = Track.prototype.noteOn = function(channel, pitch, time, velocity) {\n\t\tthis.events.push(new MidiEvent({\n\t\t\ttype: MidiEvent.NOTE_ON,\n\t\t\tchannel: channel,\n\t\t\tparam1: Util.ensureMidiPitch(pitch),\n\t\t\tparam2: velocity || DEFAULT_VOLUME,\n\t\t\ttime: time || 0,\n\t\t}));\n\t\treturn this;\n\t};\n\n\t/**\n\t * Add a note-off event to the track.\n\t *\n\t * @param {number} channel - The channel to add the event to.\n\t * @param {number|string} pitch - The pitch of the note, either numeric or\n\t * symbolic.\n\t * @param {number} [time=0] - The number of ticks since the previous event,\n\t * defaults to 0.\n\t * @param {number} [velocity=90] - The velocity the note was released,\n\t * defaults to DEFAULT_VOLUME.\n\t * @returns {Track} The current track.\n\t */\n\tTrack.prototype.addNoteOff = Track.prototype.noteOff = function(channel, pitch, time, velocity) {\n\t\tthis.events.push(new MidiEvent({\n\t\t\ttype: MidiEvent.NOTE_OFF,\n\t\t\tchannel: channel,\n\t\t\tparam1: Util.ensureMidiPitch(pitch),\n\t\t\tparam2: velocity || DEFAULT_VOLUME,\n\t\t\ttime: time || 0,\n\t\t}));\n\t\treturn this;\n\t};\n\n\t/**\n\t * Add a note-on and -off event to the track.\n\t *\n\t * @param {number} channel - The channel to add the event to.\n\t * @param {number|string} pitch - The pitch of the note, either numeric or\n\t * symbolic.\n\t * @param {number} dur - The duration of the note, in ticks.\n\t * @param {number} [time=0] - The number of ticks since the previous event,\n\t * defaults to 0.\n\t * @param {number} [velocity=90] - The velocity the note was released,\n\t * defaults to DEFAULT_VOLUME.\n\t * @returns {Track} The current track.\n\t */\n\tTrack.prototype.addNote = Track.prototype.note = function(channel, pitch, dur, time, velocity) {\n\t\tthis.noteOn(channel, pitch, time, velocity);\n\t\tif (dur) {\n\t\t\tthis.noteOff(channel, pitch, dur, velocity);\n\t\t}\n\t\treturn this;\n\t};\n\n\t/**\n\t * Add a note-on and -off event to the track for each pitch in an array of pitches.\n\t *\n\t * @param {number} channel - The channel to add the event to.\n\t * @param {array} chord - An array of pitches, either numeric or\n\t * symbolic.\n\t * @param {number} dur - The duration of the chord, in ticks.\n\t * @param {number} [velocity=90] - The velocity of the chord,\n\t * defaults to DEFAULT_VOLUME.\n\t * @returns {Track} The current track.\n\t */\n\tTrack.prototype.addChord = Track.prototype.chord = function(channel, chord, dur, velocity) {\n\t\tif (!Array.isArray(chord) && !chord.length) {\n\t\t\tthrow new Error('Chord must be an array of pitches');\n\t\t}\n\t\tchord.forEach(function(note) {\n\t\t\tthis.noteOn(channel, note, 0, velocity);\n\t\t}, this);\n\t\tchord.forEach(function(note, index) {\n\t\t\tif (index === 0) {\n\t\t\t\tthis.noteOff(channel, note, dur);\n\t\t\t} else {\n\t\t\t\tthis.noteOff(channel, note);\n\t\t\t}\n\t\t}, this);\n\t\treturn this;\n\t};\n\n\t/**\n\t * Set instrument for the track.\n\t *\n\t * @param {number} channel - The channel to set the instrument on.\n\t * @param {number} instrument - The instrument to set it to.\n\t * @param {number} [time=0] - The number of ticks since the previous event,\n\t * defaults to 0.\n\t * @returns {Track} The current track.\n\t */\n\tTrack.prototype.setInstrument = Track.prototype.instrument = function(channel, instrument, time) {\n\t\tthis.events.push(new MidiEvent({\n\t\t\ttype: MidiEvent.PROGRAM_CHANGE,\n\t\t\tchannel: channel,\n\t\t\tparam1: instrument,\n\t\t\ttime: time || 0,\n\t\t}));\n\t\treturn this;\n\t};\n\n\t/**\n\t * Set the tempo for the track.\n\t *\n\t * @param {number} bpm - The new number of beats per minute.\n\t * @param {number} [time=0] - The number of ticks since the previous event,\n\t * defaults to 0.\n\t * @returns {Track} The current track.\n\t */\n\tTrack.prototype.setTempo = Track.prototype.tempo = function(bpm, time) {\n\t\tthis.events.push(new MetaEvent({\n\t\t\ttype: MetaEvent.TEMPO,\n\t\t\tdata: Util.mpqnFromBpm(bpm),\n\t\t\ttime: time || 0,\n\t\t}));\n\t\treturn this;\n\t};\n\n\t/**\n\t * Serialize the track to an array of bytes.\n\t *\n\t * @returns {Array} The array of serialized bytes.\n\t */\n\tTrack.prototype.toBytes = function() {\n\t\tvar trackLength = 0;\n\t\tvar eventBytes = [];\n\t\tvar startBytes = Track.START_BYTES;\n\t\tvar endBytes   = Track.END_BYTES;\n\n\t\tvar addEventBytes = function(event) {\n\t\t\tvar bytes = event.toBytes();\n\t\t\ttrackLength += bytes.length;\n\t\t\teventBytes.push.apply(eventBytes, bytes);\n\t\t};\n\n\t\tthis.events.forEach(addEventBytes);\n\n\t\t// Add the end-of-track bytes to the sum of bytes for the track, since\n\t\t// they are counted (unlike the start-of-track ones).\n\t\ttrackLength += endBytes.length;\n\n\t\t// Makes sure that track length will fill up 4 bytes with 0s in case\n\t\t// the length is less than that (the usual case).\n\t\tvar lengthBytes = Util.str2Bytes(trackLength.toString(16), 4);\n\n\t\treturn startBytes.concat(lengthBytes, eventBytes, endBytes);\n\t};\n\n\t/* ******************************************************************\n\t * File class\n\t ****************************************************************** */\n\n\t/**\n\t * Construct a file object.\n\t *\n\t * Parameters include:\n\t *  - ticks [optional number] - Number of ticks per beat, defaults to 128.\n\t *    Must be 1-32767.\n\t *  - tracks [optional array] - Track data.\n\t */\n\tvar File = function(config){\n\t\tif (!this) return new File(config);\n\n\t\tvar c = config || {};\n\t\tif (c.ticks) {\n\t\t\tif (typeof c.ticks !== 'number') {\n\t\t\t\tthrow new Error('Ticks per beat must be a number!');\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tif (c.ticks <= 0 || c.ticks >= (1 << 15) || c.ticks % 1 !== 0) {\n\t\t\t\tthrow new Error('Ticks per beat must be an integer between 1 and 32767!');\n\t\t\t\treturn;\n\t\t\t}\n\t\t}\n\n\t\tthis.ticks = c.ticks || 128;\n\t\tthis.tracks = c.tracks || [];\n\t};\n\n\tFile.HDR_CHUNKID     = \"MThd\";             // File magic cookie\n\tFile.HDR_CHUNK_SIZE  = \"\\x00\\x00\\x00\\x06\"; // Header length for SMF\n\tFile.HDR_TYPE0       = \"\\x00\\x00\";         // Midi Type 0 id\n\tFile.HDR_TYPE1       = \"\\x00\\x01\";         // Midi Type 1 id\n\n\t/**\n\t * Add a track to the file.\n\t *\n\t * @param {Track} track - The track to add.\n\t */\n\tFile.prototype.addTrack = function(track) {\n\t\tif (track) {\n\t\t\tthis.tracks.push(track);\n\t\t\treturn this;\n\t\t} else {\n\t\t\ttrack = new Track();\n\t\t\tthis.tracks.push(track);\n\t\t\treturn track;\n\t\t}\n\t};\n\n\t/**\n\t * Serialize the MIDI file to an array of bytes.\n\t *\n\t * @returns {Array} The array of serialized bytes.\n\t */\n\tFile.prototype.toBytes = function() {\n\t\tvar trackCount = this.tracks.length.toString(16);\n\n\t\t// prepare the file header\n\t\tvar bytes = File.HDR_CHUNKID + File.HDR_CHUNK_SIZE;\n\n\t\t// set Midi type based on number of tracks\n\t\tif (parseInt(trackCount, 16) > 1) {\n\t\t\tbytes += File.HDR_TYPE1;\n\t\t} else {\n\t\t\tbytes += File.HDR_TYPE0;\n\t\t}\n\n\t\t// add the number of tracks (2 bytes)\n\t\tbytes += Util.codes2Str(Util.str2Bytes(trackCount, 2));\n\t\t// add the number of ticks per beat (currently hardcoded)\n\t\tbytes += String.fromCharCode((this.ticks/256),  this.ticks%256);;\n\n\t\t// iterate over the tracks, converting to bytes too\n\t\tthis.tracks.forEach(function(track) {\n\t\t\tbytes += Util.codes2Str(track.toBytes());\n\t\t});\n\n\t\treturn bytes;\n\t};\n\n\t/* ******************************************************************\n\t * Exports\n\t ****************************************************************** */\n\n\texported.Util = Util;\n\texported.File = File;\n\texported.Track = Track;\n\texported.Event = MidiEvent;\n\texported.MetaEvent = MetaEvent;\n\n})( Midi );\n\nif (typeof module != 'undefined' && module !== null) {\n\tmodule.exports = Midi;\n} else if (typeof exports != 'undefined' && exports !== null) {\n\texports = Midi;\n} else {\n\tthis.Midi = Midi;\n}\n","\"use strict\";\nvar __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {\n    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\n        if (ar || !(i in from)) {\n            if (!ar) ar = Array.prototype.slice.call(from, 0, i);\n            ar[i] = from[i];\n        }\n    }\n    return to.concat(ar || Array.prototype.slice.call(from));\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.arp = void 0;\nvar harmonics_1 = require(\"harmonics\");\nvar utils_1 = require(\"./utils\");\nvar DEFAULT_OCTAVE = 4;\n/**\n * Take an array and fill it with it s own elements in the next octave till it s of the specified `len`\n * @param  {Array} arr e.g. ['a4', 'b4']\n * @param  {Number} e.g. len 4\n * @return {Array} e.g. ['a4', 'b4', 'a5', 'b5']\n */\nvar fillArr = function (arr, len) {\n    var bumpOctave = function (el) {\n        if (!el) {\n            throw new Error('Empty element');\n        }\n        var note = el.replace(/\\d/, '');\n        var oct = el.replace(/\\D/g, '') || DEFAULT_OCTAVE;\n        if (!note) {\n            throw new Error('Incorrect note');\n        }\n        return note + (+oct + 1);\n    };\n    // Create a couple of chord arrays with bumped octaves\n    // so that something like [c3, e3, g4] turns into [c4, e4, g5] and [c5, e5, g6]\n    var arr1 = arr.map(bumpOctave);\n    var arr2 = arr1.map(bumpOctave);\n    var finalArr = __spreadArray(__spreadArray(__spreadArray([], arr, true), arr1, true), arr2, true);\n    // Slice and return only as much as required\n    return finalArr.slice(0, len);\n};\n/**\n *\n * @param chordsOrParams a string that denotes space (comma?) separated chords to be used or an object with additional properties\n * By default, if this is a string, the count of notes generated is 8 and the order is ascending.\n * For instance arp('CM FM') will result in an array of notes [C4, E4, G4, F4, A4, C4, C5, E5]\n * You can even provide Params as an object.\n * For e.g. arp({count: 8, order: '10325476', chords: 'FM_4 Gm7b5_4 AbM_4 Bbm_4 Cm_5 DbM_5 EbM_5})\n */\nvar arp = function (chordsOrParams) {\n    var finalArr = [];\n    var params = {\n        count: 4,\n        order: '0123',\n        chords: '',\n    };\n    if (typeof chordsOrParams === 'string') {\n        params.chords = chordsOrParams;\n    }\n    else {\n        if (chordsOrParams.order && chordsOrParams.order.match(/\\D/g)) {\n            throw new TypeError('Invalid value for order');\n        }\n        if (chordsOrParams.count > 8 || chordsOrParams.count < 2) {\n            throw new TypeError('Invalid value for count');\n        }\n        // Provision a order for the notes in case only count was provided\n        if (chordsOrParams.count && !chordsOrParams.order) {\n            params.order = Array.from(Array(chordsOrParams.count).keys()).join('');\n        }\n        Object.assign(params, chordsOrParams);\n    }\n    // Chords can be passed as a string, e.g. 'CM_4 FM_4'\n    // or as an array of notes arrays e.g. [['C3', 'E3', 'G3', 'B3'], ['F3', 'A3', 'C4', 'E4']]\n    if (typeof params.chords === 'string') {\n        var chordsArr = params.chords.split(' ');\n        chordsArr.forEach(function (c, i) {\n            try {\n                var filledArr_1 = fillArr((0, harmonics_1.inlineChord)(c), params.count);\n                // reorder the filledArr as per params.order\n                var reorderedArr = params.order\n                    .split('')\n                    .map(function (idx) { return filledArr_1[idx]; });\n                finalArr = __spreadArray(__spreadArray([], finalArr, true), reorderedArr, true);\n            }\n            catch (e) {\n                throw new Error(\"Cannot decode chord \" + (i + 1) + \" \\\"\" + c + \"\\\" in given \\\"\" + params.chords + \"\\\"\");\n            }\n        });\n    }\n    else if (Array.isArray(params.chords)) {\n        params.chords.forEach(function (c, i) {\n            try {\n                var filledArr_2 = fillArr(c, params.count);\n                // reorder the filledArr as per params.order\n                var reorderedArr = params.order\n                    .split('')\n                    .map(function (idx) { return filledArr_2[idx]; });\n                finalArr = __spreadArray(__spreadArray([], finalArr, true), reorderedArr, true);\n            }\n            catch (e) {\n                throw new Error(((0, utils_1.errorHasMessage)(e) ? e.message : e) + \" in chord \" + (i + 1) + \" \\\"\" + c + \"\\\"\");\n            }\n        });\n    }\n    else {\n        throw new TypeError('Invalid value for chords');\n    }\n    return finalArr;\n};\nexports.arp = arp;\n","\"use strict\";\nvar __assign = (this && this.__assign) || function () {\n    __assign = Object.assign || function(t) {\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\n            s = arguments[i];\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))\n                t[p] = s[p];\n        }\n        return t;\n    };\n    return __assign.apply(this, arguments);\n};\nvar __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n    return new (P || (P = Promise))(function (resolve, reject) {\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\n    });\n};\nvar __generator = (this && this.__generator) || function (thisArg, body) {\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\n    return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\n    function verb(n) { return function (v) { return step([n, v]); }; }\n    function step(op) {\n        if (f) throw new TypeError(\"Generator is already executing.\");\n        while (_) try {\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\n            if (y = 0, t) op = [op[0] & 2, t.value];\n            switch (op[0]) {\n                case 0: case 1: t = op; break;\n                case 4: _.label++; return { value: op[1], done: false };\n                case 5: _.label++; y = op[1]; op = [0]; continue;\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\n                default:\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\n                    if (t[2]) _.ops.pop();\n                    _.trys.pop(); continue;\n            }\n            op = body.call(thisArg, _);\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\n    }\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.clip = exports.renderingDuration = exports.totalPatternDuration = exports.recursivelyApplyPatternToDurations = exports.getDuration = exports.getNote = void 0;\nvar utils_1 = require(\"./utils\");\n// import { window } from './window';\n// if (!(window as any).Tone) {\n//   (window as any).Tone = Tone;\n// }\n// const tone = (window as any).Tone;\n// const tone = Tone || (window as any).Tone;\nvar defaultSubdiv = '4n';\nvar defaultDur = '8n';\n/**\n * Get default params for a clip, such as root note, pattern etc\n * @return {Object}\n */\nvar getDefaultParams = function () { return ({\n    notes: ['C4'],\n    pattern: 'x',\n    shuffle: false,\n    sizzle: false,\n    sizzleReps: 1,\n    arpegiate: false,\n    subdiv: '4n',\n    align: '1m',\n    alignOffset: '0',\n    amp: 100,\n    accentLow: 70,\n    randomNotes: null,\n    offlineRendering: false,\n}); };\n/* UNUSED *\n * HDR speed is denoted by the number of ticks per note\n * By default this is set to a quarter note (4n) to be in line with Tone.js' default subdivision\n * Technically a bar is 512 ticks long. So it's HDR speed is 512\n * @type {Object}\n * /\nconst hdr: NVP<number> = {\n  '1m': 2048,\n  '2m': 4096,\n  '3m': 6144,\n  '4m': 8192,\n  '1n': 512,\n  '2n': 256,\n  '4n': 128,\n  '8n': 64,\n  '16n': 32,\n};\n/* */\nvar getNote = function (el, params, counter) {\n    if (el === 'R' && params.randomNotes && params.randomNotes.length > 0) {\n        return params.randomNotes[(0, utils_1.randomInt)(params.randomNotes.length - 1)];\n    }\n    if (params.notes) {\n        return params.notes[counter % (params.notes.length || 1)];\n    }\n    return '';\n};\nexports.getNote = getNote;\nvar getDuration = function (params, counter) {\n    return params.durations\n        ? params.durations[counter % params.durations.length]\n        : params.dur || params.subdiv || defaultDur;\n};\nexports.getDuration = getDuration;\nvar recursivelyApplyPatternToDurations = function (patternArr, length, durations) {\n    if (durations === void 0) { durations = []; }\n    patternArr.forEach(function (char) {\n        if (typeof char === 'string') {\n            if (char === 'x' || char === 'R') {\n                durations.push(length);\n            }\n            if (char === '_' && durations.length) {\n                durations[durations.length - 1] += length;\n            }\n        }\n        if (Array.isArray(char)) {\n            (0, exports.recursivelyApplyPatternToDurations)(char, length / char.length, durations);\n        }\n    });\n    return durations;\n};\nexports.recursivelyApplyPatternToDurations = recursivelyApplyPatternToDurations;\nvar generateSequence = function (params, channel, context) {\n    context = context || Tone.getContext();\n    if (!params.pattern) {\n        throw new Error('No pattern provided!');\n    }\n    if (!params.durations && !params.dur) {\n        params.durations = (0, exports.recursivelyApplyPatternToDurations)((0, utils_1.expandStr)(params.pattern), Tone.Ticks(params.subdiv || defaultSubdiv).toSeconds());\n    }\n    return new Tone.Sequence({\n        callback: channel.getSeqFn(params),\n        events: (0, utils_1.expandStr)(params.pattern),\n        subdivision: params.subdiv || defaultSubdiv,\n        context: context,\n    });\n};\nvar totalPatternDuration = function (pattern, subdivOrLength) {\n    return typeof subdivOrLength === 'number'\n        ? subdivOrLength * (0, utils_1.expandStr)(pattern).length\n        : Tone.Ticks(subdivOrLength).toSeconds() * (0, utils_1.expandStr)(pattern).length;\n};\nexports.totalPatternDuration = totalPatternDuration;\nvar leastCommonMultiple = function (n1, n2) {\n    var _a = n1 < n2 ? [n1, n2] : [n2, n1], smallest = _a[0], largest = _a[1];\n    var i = largest;\n    while (i % smallest !== 0) {\n        i += largest;\n    }\n    return i;\n};\nvar renderingDuration = function (pattern, subdivOrLength, notes, randomNotes) {\n    var patternRegularNotesCount = pattern.split('').filter(function (c) {\n        return c === 'x';\n    }).length;\n    var patternRandomNotesCount = pattern.split('').filter(function (c) {\n        return c === 'R';\n    }).length;\n    var patternNotesCount = (randomNotes === null || randomNotes === void 0 ? void 0 : randomNotes.length)\n        ? patternRegularNotesCount\n        : patternRegularNotesCount + patternRandomNotesCount;\n    var notesCount = notes.length || 1;\n    return (((0, exports.totalPatternDuration)(pattern, subdivOrLength) / patternNotesCount) *\n        leastCommonMultiple(notesCount, patternNotesCount));\n};\nexports.renderingDuration = renderingDuration;\nvar ongoingRenderingCounter = 0;\nvar originalContext;\nvar offlineRenderClip = function (params, duration) {\n    if (!originalContext) {\n        originalContext = Tone.getContext();\n    }\n    ongoingRenderingCounter++;\n    var player = new Tone.Player({ context: originalContext, loop: true });\n    Tone.Offline(function (context) { return __awaiter(void 0, void 0, void 0, function () {\n        var sequence;\n        return __generator(this, function (_a) {\n            switch (_a.label) {\n                case 0:\n                    sequence = generateSequence(params, context);\n                    return [4 /*yield*/, Tone.loaded()];\n                case 1:\n                    _a.sent();\n                    sequence.start();\n                    context.transport.start();\n                    return [2 /*return*/];\n            }\n        });\n    }); }, duration).then(function (buffer) {\n        var _a;\n        player.buffer = buffer;\n        ongoingRenderingCounter--;\n        if (ongoingRenderingCounter === 0) {\n            Tone.setContext(originalContext);\n            (_a = params.offlineRenderingCallback) === null || _a === void 0 ? void 0 : _a.call(params);\n        }\n    });\n    player.toDestination();\n    player.sync();\n    return player;\n};\n/**\n * @param  {Object}\n * @return {Tone.js Sequence Object}\n * Take a object literal that may have a Tone.js player OR instrument\n * or simply a sample or synth with a pattern and return a Tone.js sequence\n */\nvar clip = function (params, channel) {\n    params = __assign(__assign({}, getDefaultParams()), (params || {}));\n    // If notes is a string, split it into an array\n    if (typeof params.notes === 'string') {\n        // Remove any accidental double spaces\n        params.notes = params.notes.replace(/\\s{2,}/g, ' ');\n        params.notes = params.notes.split(' ');\n    }\n    params.notes = params.notes ? params.notes.map(utils_1.convertChordsToNotes) : [];\n    if (/[^x\\-_[\\]R]/.test(params.pattern)) {\n        throw new TypeError(\"pattern can only comprise x - _ [ ] R, found \" + params.pattern);\n    }\n    if (params.shuffle) {\n        params.notes = (0, utils_1.shuffle)(params.notes);\n    }\n    if (params.randomNotes && typeof params.randomNotes === 'string') {\n        params.randomNotes = params.randomNotes.replace(/\\s{2,}/g, ' ').split(/\\s/);\n    }\n    if (params.randomNotes) {\n        params.randomNotes = params.randomNotes.map(utils_1.convertChordsToNotes);\n    }\n    if (params.offlineRendering) {\n        return offlineRenderClip(params, (0, exports.renderingDuration)(params.pattern, params.subdiv || defaultSubdiv, params.notes, params.randomNotes));\n    }\n    return generateSequence(params, channel, originalContext);\n};\nexports.clip = clip;\n","\"use strict\";\nvar __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });\n}) : (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    o[k2] = m[k];\n}));\nvar __exportStar = (this && this.__exportStar) || function(m, exports) {\n    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.Session = exports.midi = exports.arp = exports.progression = exports.getChordsByProgression = exports.getChordDegrees = exports.clip = exports.chords = exports.chord = exports.modes = exports.scales = exports.mode = exports.scale = void 0;\nvar harmonics_1 = require(\"harmonics\");\nObject.defineProperty(exports, \"scales\", { enumerable: true, get: function () { return harmonics_1.scales; } });\nObject.defineProperty(exports, \"modes\", { enumerable: true, get: function () { return harmonics_1.scales; } });\nObject.defineProperty(exports, \"chords\", { enumerable: true, get: function () { return harmonics_1.chords; } });\nObject.defineProperty(exports, \"scale\", { enumerable: true, get: function () { return harmonics_1.scale; } });\nObject.defineProperty(exports, \"mode\", { enumerable: true, get: function () { return harmonics_1.scale; } });\nObject.defineProperty(exports, \"chord\", { enumerable: true, get: function () { return harmonics_1.chord; } });\nvar browser_clip_1 = require(\"./browser-clip\");\nObject.defineProperty(exports, \"clip\", { enumerable: true, get: function () { return browser_clip_1.clip; } });\nvar progression_1 = require(\"./progression\");\nObject.defineProperty(exports, \"getChordDegrees\", { enumerable: true, get: function () { return progression_1.getChordDegrees; } });\nObject.defineProperty(exports, \"getChordsByProgression\", { enumerable: true, get: function () { return progression_1.getChordsByProgression; } });\nObject.defineProperty(exports, \"progression\", { enumerable: true, get: function () { return progression_1.progression; } });\nvar arp_1 = require(\"./arp\");\nObject.defineProperty(exports, \"arp\", { enumerable: true, get: function () { return arp_1.arp; } });\nvar midi_1 = require(\"./midi\");\nObject.defineProperty(exports, \"midi\", { enumerable: true, get: function () { return midi_1.midi; } });\nvar session_1 = require(\"./session\");\nObject.defineProperty(exports, \"Session\", { enumerable: true, get: function () { return session_1.Session; } });\n__exportStar(require(\"./types\"), exports);\n","\"use strict\";\nvar __assign = (this && this.__assign) || function () {\n    __assign = Object.assign || function(t) {\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\n            s = arguments[i];\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))\n                t[p] = s[p];\n        }\n        return t;\n    };\n    return __assign.apply(this, arguments);\n};\nvar __rest = (this && this.__rest) || function (s, e) {\n    var t = {};\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\n        t[p] = s[p];\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\n                t[p[i]] = s[p[i]];\n        }\n    return t;\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.Channel = void 0;\nvar browser_clip_1 = require(\"./browser-clip\");\nvar utils_1 = require(\"./utils\");\n/**\n * Get the next logical position to play in the session\n * Tone has a build-in method `Tone.Transport.nextSubdivision('4n')`\n * but I think it s better to round off as follows for live performance\n */\nvar getNextPos = function (clip) {\n    // TODO: (soon) convert to using transportPosTicks (fewer computations)\n    var arr = Tone.Transport.position.split(':');\n    // If we are still around 0:0:0x, then set start position to 0\n    if (arr[0] === '0' && arr[1] === '0') {\n        return 0;\n    }\n    // Else set it to the next bar\n    var transportPosTicks = Tone.Transport.ticks;\n    var align = (clip === null || clip === void 0 ? void 0 : clip.align) || '1m';\n    var alignOffset = (clip === null || clip === void 0 ? void 0 : clip.alignOffset) || '0';\n    var alignTicks = Tone.Ticks(align).toTicks();\n    var alignOffsetTicks = Tone.Ticks(alignOffset).toTicks();\n    var nextPosTicks = Tone.Ticks(Math.floor(transportPosTicks / alignTicks + 1) * alignTicks +\n        alignOffsetTicks);\n    // const nextPosBBS = nextPosTicks.toBarsBeatsSixteenths();\n    // return nextPosBBS; // Extraneous computations\n    return nextPosTicks;\n};\n/**\n * Channel\n * A channel is made up of a Tone.js Player/Instrument, one or more\n * Tone.js sequences (known as clips in Scribbletune)\n * & optionally a set of effects (with or without presets)\n *\n * API:\n * clips -> Get all clips for this channel\n * addClip -> Add a new clip to the channel\n * startClip -> Start a clip at the provided index\n * stopClip -> Stop a clip at the provided index\n * activeClipIdx -> Get the clip that is currently playing\n */\nvar Channel = /** @class */ (function () {\n    function Channel(params) {\n        var _this = this;\n        this.idx = params.idx || 0;\n        this.name = params.name || 'ch ' + params.idx;\n        this.activePatternIdx = -1;\n        this.channelClips = [];\n        this.clipNoteCount = 0;\n        // Filter out unrequired params and create clip params object\n        // eslint-disable-next-line @typescript-eslint/no-unused-vars\n        var clips = params.clips, samples = params.samples, sample = params.sample, synth = params.synth, params1 = __rest(params, [\"clips\", \"samples\", \"sample\", \"synth\"]);\n        // eslint-disable-next-line @typescript-eslint/no-unused-vars\n        var external = params1.external, sampler = params1.sampler, buffer = params1.buffer, params2 = __rest(params1, [\"external\", \"sampler\", \"buffer\"]);\n        // eslint-disable-next-line @typescript-eslint/no-unused-vars\n        var player = params2.player, instrument = params2.instrument, volume = params2.volume, params3 = __rest(params2, [\"player\", \"instrument\", \"volume\"]);\n        // eslint-disable-next-line @typescript-eslint/no-unused-vars\n        var eventCb = params3.eventCb, playerCb = params3.playerCb, effects = params3.effects, params4 = __rest(params3, [\"eventCb\", \"playerCb\", \"effects\"]);\n        var _a = params4.context, context = _a === void 0 ? Tone.getContext() : _a, originalParamsFiltered = __rest(params4, [\"context\"]);\n        this.eventCbFn = eventCb;\n        this.playerCbFn = playerCb;\n        // Async section\n        this.hasLoaded = false;\n        this.hasFailed = false;\n        this.initializerTask = this.initOutputProducer(context, params).then(function () {\n            return _this.initInstrument(context, params).then(function () {\n                return _this.adjustInstrument(context, params).then(function () {\n                    return _this.initEffects(context, params);\n                });\n            });\n        });\n        // End Async section\n        // Sync section\n        var clipsFailed = false;\n        try {\n            params.clips.forEach(function (c, i) {\n                try {\n                    _this.addClip(__assign(__assign({}, c), originalParamsFiltered));\n                }\n                catch (e) {\n                    // Annotate the error with Clip info\n                    throw new Error(((0, utils_1.errorHasMessage)(e) ? e.message : e) + \" in clip \" + (i + 1));\n                }\n            }, this);\n        }\n        catch (e) {\n            clipsFailed = e; // Stash the error\n        }\n        // End Sync section\n        // Reconcile sync section with async section\n        this.initializerTask\n            .then(function () {\n            if (clipsFailed) {\n                throw clipsFailed;\n            }\n            _this.hasLoaded = true;\n            _this.eventCb('loaded', {}); // Report async load completion.\n        })\n            .catch(function (e) {\n            _this.hasFailed = e;\n            _this.eventCb('error', { e: e }); // Report async errors.\n        });\n    }\n    Channel.setTransportTempo = function (valueBpm) {\n        Tone.Transport.bpm.value = valueBpm;\n    };\n    Channel.startTransport = function () {\n        Tone.start();\n        Tone.Transport.start();\n    };\n    Channel.stopTransport = function (deleteEvents) {\n        if (deleteEvents === void 0) { deleteEvents = true; }\n        Tone.Transport.stop();\n        if (deleteEvents) {\n            // Delete all events in the Tone.Transport\n            Tone.Transport.cancel();\n        }\n    };\n    Channel.prototype.setVolume = function (volume) {\n        // ? this.volume = volume;\n        var _a, _b;\n        // Change volume of the player\n        // if (this.player) {\n        //   this.player.volume.value = volume;\n        // }\n        // Change volume of the sampler\n        // if (this.sampler) {\n        //   this.sampler.volume.value = volume;\n        // }\n        // Change volume of the instrument\n        if (this.instrument) {\n            this.instrument.volume.value = volume;\n        }\n        // Change volume of the external\n        if (this.external) {\n            (_b = (_a = this.external).setVolume) === null || _b === void 0 ? void 0 : _b.call(_a, volume);\n        }\n    };\n    Channel.prototype.startClip = function (idx, position) {\n        var _this = this;\n        var clip = this.channelClips[idx];\n        position = position || (position === 0 ? 0 : getNextPos(clip));\n        // Stop any other currently running clip\n        if (this.activePatternIdx > -1 && this.activePatternIdx !== idx) {\n            this.stopClip(this.activePatternIdx, position);\n        }\n        if (clip && clip.state !== 'started') {\n            // We need to schedule that for just before when clip?.start(position) events start coming.\n            this.counterResetTask = Tone.Transport.scheduleOnce(function ( /* time: Tone.Seconds */) {\n                _this.clipNoteCount = 0;\n            }, position);\n            this.activePatternIdx = idx;\n            // clip?.stop(position); // DEBUG: trying to clear out start/stop events\n            // clip?.clear(position); // DEBUG: trying to clear out events\n            clip === null || clip === void 0 ? void 0 : clip.start(position);\n        }\n    };\n    Channel.prototype.stopClip = function (idx, position) {\n        var clip = this.channelClips[idx];\n        position = position || (position === 0 ? 0 : getNextPos(clip));\n        clip === null || clip === void 0 ? void 0 : clip.stop(position);\n        if (idx === this.activePatternIdx) {\n            this.activePatternIdx = -1;\n        }\n    };\n    Channel.prototype.addClip = function (clipParams, idx) {\n        var _this = this;\n        idx = idx || this.channelClips.length;\n        if (clipParams.pattern) {\n            this.channelClips[idx] = (0, browser_clip_1.clip)(__assign({}, clipParams), this);\n            // Pass certain clipParams into getNextPos()\n            ['align', 'alignOffset'].forEach(function (key) {\n                if (clipParams[key]) {\n                    _this.channelClips[idx][key] = clipParams[key];\n                }\n            });\n        }\n        else {\n            // Allow creation of empty clips\n            this.channelClips[idx] = null;\n        }\n    };\n    /**\n     * @param  {Object} ClipParams clip parameters\n     * @return {Function} function that can be used as the callback in Tone.Sequence https://tonejs.github.io/docs/Sequence\n     */\n    Channel.prototype.getSeqFn = function (params) {\n        var _this = this;\n        if (this.external) {\n            return function (time, el) {\n                var _a, _b;\n                if (el === 'x' || el === 'R') {\n                    var counter = _this.clipNoteCount;\n                    if (_this.hasLoaded) {\n                        var note = (0, browser_clip_1.getNote)(el, params, counter)[0];\n                        var duration = (0, browser_clip_1.getDuration)(params, counter);\n                        var durSeconds = Tone.Time(duration).toSeconds();\n                        _this.playerCb({ note: note, duration: duration, time: time, counter: counter });\n                        try {\n                            (_b = (_a = _this.external).triggerAttackRelease) === null || _b === void 0 ? void 0 : _b.call(_a, note, durSeconds, time);\n                        }\n                        catch (e) {\n                            _this.eventCb('error', { e: e }); // Report play errors.\n                        }\n                    }\n                    _this.clipNoteCount++;\n                }\n            };\n        }\n        else if (this.instrument instanceof Tone.Player) {\n            return function (time, el) {\n                if (el === 'x' || el === 'R') {\n                    var counter = _this.clipNoteCount;\n                    if (_this.hasLoaded) {\n                        _this.playerCb({ note: '', duration: '', time: time, counter: counter });\n                        try {\n                            _this.instrument.start(time);\n                        }\n                        catch (e) {\n                            _this.eventCb('error', { e: e }); // Report play errors.\n                        }\n                    }\n                    _this.clipNoteCount++;\n                }\n            };\n        }\n        else if (this.instrument instanceof Tone.PolySynth ||\n            this.instrument instanceof Tone.Sampler) {\n            return function (time, el) {\n                if (el === 'x' || el === 'R') {\n                    var counter = _this.clipNoteCount;\n                    if (_this.hasLoaded) {\n                        var note = (0, browser_clip_1.getNote)(el, params, counter);\n                        var duration = (0, browser_clip_1.getDuration)(params, counter);\n                        _this.playerCb({ note: note, duration: duration, time: time, counter: counter });\n                        try {\n                            _this.instrument.triggerAttackRelease(note, duration, time);\n                        }\n                        catch (e) {\n                            _this.eventCb('error', { e: e }); // Report play errors.\n                        }\n                    }\n                    _this.clipNoteCount++;\n                }\n            };\n        }\n        else if (this.instrument instanceof Tone.NoiseSynth) {\n            return function (time, el) {\n                if (el === 'x' || el === 'R') {\n                    var counter = _this.clipNoteCount;\n                    if (_this.hasLoaded) {\n                        var duration = (0, browser_clip_1.getDuration)(params, counter);\n                        _this.playerCb({ note: '', duration: duration, time: time, counter: counter });\n                        try {\n                            _this.instrument.triggerAttackRelease(duration, time);\n                        }\n                        catch (e) {\n                            _this.eventCb('error', { e: e }); // Report play errors.\n                        }\n                    }\n                    _this.clipNoteCount++;\n                }\n            };\n        }\n        else {\n            return function (time, el) {\n                if (el === 'x' || el === 'R') {\n                    var counter = _this.clipNoteCount;\n                    if (_this.hasLoaded) {\n                        var note = (0, browser_clip_1.getNote)(el, params, counter)[0];\n                        var duration = (0, browser_clip_1.getDuration)(params, counter);\n                        _this.playerCb({ note: note, duration: duration, time: time, counter: counter });\n                        try {\n                            _this.instrument.triggerAttackRelease(note, duration, time);\n                        }\n                        catch (e) {\n                            _this.eventCb('error', { e: e }); // Report play errors.\n                        }\n                    }\n                    _this.clipNoteCount++;\n                }\n            };\n        }\n    };\n    Channel.prototype.eventCb = function (event, params) {\n        if (typeof this.eventCbFn === 'function') {\n            params.channel = this;\n            this.eventCbFn(event, params);\n        }\n    };\n    Channel.prototype.playerCb = function (params) {\n        if (typeof this.playerCbFn === 'function') {\n            params.channel = this;\n            this.playerCbFn(params);\n        }\n    };\n    /**\n     * Check Tone.js object loaded state and either invoke `resolve` right away, or attach to and wait using Tone onload cb.\n     * It's an ugly hack that reaches into Tone's internal ._buffers or ._buffer to insert itself into .onload() callback.\n     * Tone has different ways to pull the onload callback from within to the API, so this implementation is very brittle.\n     * The sole reason for its existence is to handle async loaded state of Tone instruments that we allow to pass in from outside.\n     * If that option is eliminated, then this hacky function can be killed (or re-implemented via public onload API)\n     * @param toneObject Tone.js object (will work with non-Tone objects that have same loaded/onload properties)\n     * @param resolve onload callback\n     */\n    Channel.prototype.checkToneObjLoaded = function (toneObject, resolve) {\n        var _this = this;\n        var skipRecursion = toneObject instanceof Tone.Sampler; // Sampler has a Map of ToneAudioBuffer, and our method to find inner .onload() does not work since there is no single one.\n        // eslint-disable-next-line no-prototype-builtins\n        if ('loaded' in toneObject) {\n            if (toneObject.loaded) {\n                resolve();\n                return;\n            }\n            if (skipRecursion) {\n                return;\n            }\n            // Try Recursion into inner objects:\n            var handled_1 = false;\n            ['buffer', '_buffer', '_buffers'].forEach(function (key) {\n                if (key in toneObject) {\n                    _this.checkToneObjLoaded(toneObject[key], resolve);\n                    handled_1 = true;\n                }\n            });\n            if (handled_1) {\n                return;\n            }\n        }\n        // Check object type if it has load/onload (and _buffers or _buffer), then call resolve()\n        // The list was created for Tone@14.8.0 by grepping and reviewing the source code.\n        // Known objecs to have:\n        var hasOnload = toneObject instanceof Tone.ToneAudioBuffer ||\n            toneObject instanceof Tone.ToneBufferSource ||\n            // Falback for \"future\" objects\n            ('loaded' in toneObject && 'onload' in toneObject);\n        if (!hasOnload) {\n            // console.log('resolve() for ch \"%o\" idx %o onload NOT FOUND', this.name, this.idx);\n            // This is not a good assumption. E.g. it does not work for Tone.ToneAudioBuffers\n            resolve();\n        }\n        else {\n            var oldOnLoad_1 = toneObject.onload;\n            toneObject.onload = function () {\n                if (oldOnLoad_1 && typeof oldOnLoad_1 === 'function') {\n                    toneObject.onload = oldOnLoad_1;\n                    oldOnLoad_1();\n                }\n                // console.log('resolve() for ch \"%o\" idx %o', this.name, this.idx);\n                resolve();\n            };\n        }\n    };\n    Channel.prototype.recreateToneObjectInContext = function (toneObject, // Tone.PolySynth | Tone.Player | Tone.Sampler | Tone['' | '']\n    context) {\n        var _this = this;\n        context = context || Tone.getContext();\n        // eslint-disable-next-line @typescript-eslint/no-unused-vars\n        return new Promise(function (resolve, reject) {\n            // Tone.PolySynth | Tone.Player | Tone.Sampler | Tone['' | '']\n            if (toneObject instanceof Tone.PolySynth) {\n                var newObj_1 = Tone.PolySynth(Tone[toneObject._dummyVoice.name], __assign(__assign({}, toneObject.get()), { context: context }));\n                _this.checkToneObjLoaded(newObj_1, function () { return resolve(newObj_1); });\n            }\n            else if (toneObject instanceof Tone.Player) {\n                var newObj_2 = Tone.Player({\n                    url: toneObject._buffer,\n                    context: context,\n                    onload: function () { return _this.checkToneObjLoaded(newObj_2, function () { return resolve(newObj_2); }); },\n                });\n            }\n            else if (toneObject instanceof Tone.Sampler) {\n                var _a = toneObject.get(), attack = _a.attack, curve = _a.curve, release = _a.release, volume = _a.volume;\n                var paramsFromSampler = {\n                    attack: attack,\n                    curve: curve,\n                    release: release,\n                    volume: volume,\n                };\n                var paramsFromBuffers = {\n                    baseUrl: toneObject._buffers.baseUrl,\n                    urls: Object.fromEntries(toneObject._buffers._buffers.entries()),\n                };\n                var newObj_3 = Tone.Sampler(__assign(__assign(__assign({}, paramsFromSampler), paramsFromBuffers), { context: context, onload: function () { return _this.checkToneObjLoaded(newObj_3, function () { return resolve(newObj_3); }); } }));\n            }\n            else {\n                var newObj_4 = Tone[toneObject.name](__assign(__assign({}, toneObject.get()), { context: context, onload: function () { return _this.checkToneObjLoaded(newObj_4, function () { return resolve(newObj_4); }); } }));\n                _this.checkToneObjLoaded(newObj_4, function () { return resolve(newObj_4); });\n            }\n        });\n    };\n    Channel.prototype.initOutputProducer = function (context, params) {\n        var _this = this;\n        context = context || Tone.getContext();\n        return new Promise(function (resolve, reject) {\n            /*\n             *  1. The params object can be used to pass a sample (sound source) OR a synth(Synth/FMSynth/AMSynth etc) or samples.\n             *  Scribbletune will then create a Tone.js Player or Tone.js Instrument or Tone.js Sampler respectively\n             *  2. It can also be used to pass a Tone.js Player object or instrument that was created elsewhere\n             *  (mostly by Scribbletune itself in the channel creation method)\n             **/\n            if (params.synth) {\n                if (params.instrument) {\n                    throw new Error('Either synth or instrument can be provided, but not both.');\n                }\n                if (params.synth.synth) {\n                    var synthName = params.synth.synth;\n                    //  const presetName = (params.synth as SynthParams).presetName; // Unused here\n                    var preset = params.synth.preset || {};\n                    _this.instrument = new Tone[synthName](__assign(__assign({}, preset), { context: context, \n                        // Use onload for cases when synthName calls out Tone.Sample/Player/Sampler.\n                        // It could be a universal way to load Tone.js instruments.\n                        onload: function () { return _this.checkToneObjLoaded(_this.instrument, resolve); } }));\n                    _this.checkToneObjLoaded(_this.instrument, resolve);\n                }\n                else {\n                    _this.instrument = params.synth; // TODO: This is dangerous by-reference assignment.\n                    console.warn('The \"synth\" parameter with instrument will be deprecated in the future. Please use the \"instrument\" parameter instead.');\n                    // params.synth describing the Tone[params.synth.synth] is allowed.\n                    _this.checkToneObjLoaded(_this.instrument, resolve);\n                }\n            }\n            else if (typeof params.instrument === 'string') {\n                _this.instrument = new Tone[params.instrument]({ context: context });\n                _this.checkToneObjLoaded(_this.instrument, resolve);\n            }\n            else if (params.instrument) {\n                _this.instrument = params.instrument; // TODO: This is dangerous by-reference assignment. Tone.instrument has context that holds all other instruments. Client side params get polluted with circular references. If params come from e.g. react-ApolloClient data, Apollo tools crash on circular references.\n                _this.checkToneObjLoaded(_this.instrument, resolve);\n            }\n            else if (params.sample || params.buffer) {\n                _this.instrument = new Tone.Player({\n                    url: params.sample || params.buffer,\n                    context: context,\n                    onload: function () { return _this.checkToneObjLoaded(_this.instrument, resolve); },\n                });\n            }\n            else if (params.samples) {\n                _this.instrument = new Tone.Sampler({\n                    urls: params.samples,\n                    context: context,\n                    onload: function () { return _this.checkToneObjLoaded(_this.instrument, resolve); },\n                });\n            }\n            else if (params.sampler) {\n                _this.instrument = params.sampler; // TODO: This is dangerous by-reference assignment.\n                _this.checkToneObjLoaded(_this.instrument, resolve);\n            }\n            else if (params.player) {\n                _this.instrument = params.player; // TODO: This is dangerous by-reference assignment.\n                _this.checkToneObjLoaded(_this.instrument, resolve);\n            }\n            else if (params.external) {\n                _this.external = __assign({}, params.external); // Sanitize object by shallow clone\n                _this.instrument = {\n                    context: context,\n                    volume: { value: 0 },\n                };\n                // Do not call! this.checkToneObjLoaded(this.instrument, resolve);\n                if (params.external.init) {\n                    return params.external\n                        .init(context.rawContext)\n                        .then(function () {\n                        resolve();\n                    })\n                        .catch(function (e) {\n                        var _a;\n                        reject(new Error(e.message + \" loading external output module of channel idx \" + _this.idx + \", \" + ((_a = _this.name) !== null && _a !== void 0 ? _a : '(no name)')));\n                    });\n                }\n                else {\n                    resolve();\n                }\n            }\n            else {\n                throw new Error('One of required synth|instrument|sample|sampler|samples|buffer|player|external is not provided!');\n            }\n            if (!_this.instrument) {\n                throw new Error('Failed instantiating instrument from given params.');\n            }\n        });\n    };\n    Channel.prototype.initInstrument = function (context, params) {\n        var _this = this;\n        var _a;\n        context = context || Tone.getContext();\n        if (!params.external && ((_a = this.instrument) === null || _a === void 0 ? void 0 : _a.context) !== context) {\n            return this.recreateToneObjectInContext(this.instrument, context).then(function (newObj) {\n                _this.instrument = newObj;\n            });\n        }\n        else {\n            // Nothing to do\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            return new Promise(function (resolve, reject) {\n                resolve();\n            });\n        }\n    };\n    Channel.prototype.adjustInstrument = function (context, params) {\n        var _this = this;\n        context = context || Tone.getContext();\n        // eslint-disable-next-line @typescript-eslint/no-unused-vars\n        return new Promise(function (resolve, reject) {\n            if (params.volume) {\n                // this.instrument.volume.value = params.volume;\n                _this.setVolume(params.volume);\n            }\n            resolve();\n        });\n    };\n    Channel.prototype.initEffects = function (context, params) {\n        var _this = this;\n        context = context || Tone.getContext();\n        var createEffect = function (effect) {\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            return new Promise(function (resolve, reject) {\n                if (typeof effect === 'string') {\n                    resolve(new Tone[effect]({ context: context }));\n                }\n                else if (effect.context !== context) {\n                    return _this.recreateToneObjectInContext(effect, context);\n                }\n                else {\n                    resolve(effect);\n                }\n            }).then(function (effectOut) {\n                return effectOut.toDestination();\n            });\n        };\n        var startEffect = function (eff) {\n            return typeof eff.start === 'function' ? eff.start() : eff;\n        };\n        var toArray = function (someVal) {\n            if (!someVal) {\n                return [];\n            }\n            if (Array.isArray(someVal)) {\n                return someVal;\n            }\n            return [someVal];\n        };\n        var effectsIn = toArray(params.effects);\n        if (params.external) {\n            if (effectsIn.length !== 0) {\n                throw new Error('Effects cannot be used with external output');\n            }\n            return Promise.resolve();\n        }\n        // effects = params.effects.map(createEffect).map(startEffect);\n        return Promise.all(effectsIn.map(createEffect))\n            .then(function (results) { return results.map(startEffect); })\n            .then(function (effects) {\n            var _a;\n            (_a = _this.instrument).chain.apply(_a, effects).toDestination();\n        });\n    };\n    Object.defineProperty(Channel.prototype, \"clips\", {\n        get: function () {\n            return this.channelClips;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    Object.defineProperty(Channel.prototype, \"activeClipIdx\", {\n        get: function () {\n            return this.activePatternIdx;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    return Channel;\n}());\nexports.Channel = Channel;\n","\"use strict\";\n// global LiveAPI:true\nvar __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });\n}) : (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    o[k2] = m[k];\n}));\nvar __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {\n    Object.defineProperty(o, \"default\", { enumerable: true, value: v });\n}) : function(o, v) {\n    o[\"default\"] = v;\n});\nvar __importStar = (this && this.__importStar) || function (mod) {\n    if (mod && mod.__esModule) return mod;\n    var result = {};\n    if (mod != null) for (var k in mod) if (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\n    __setModuleDefault(result, mod);\n    return result;\n};\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.midi = void 0;\nvar fs_1 = __importDefault(require(\"fs\"));\nvar jsmidgen = __importStar(require(\"jsmidgen\"));\n/**\n * Take an array of note objects to generate a MIDI file in the same location as this method is called\n * @param  {NoteObject[]} notes    Notes are in the format: {note: ['c3'], level: 127, length: 64}\n * @param  {String | null} fileName If a filename is not provided, then `music.mid` is used by default\n * If `null` is passed for `fileName`, bytes are returned instead of creating a file\n * If this method is called from a browser then it will return a HTML link that you can append in your page\n * This link will enable the generated MIDI as a downloadable file.\n * @param {Number | null} bpm If a value is provided, the generated midi file will be set to this bpm value.\n */\nvar midi = function (notes, fileName, bpm) {\n    if (fileName === void 0) { fileName = 'music.mid'; }\n    var file = createFileFromNotes(notes, bpm);\n    var bytes = file.toBytes();\n    if (fileName === null) {\n        return bytes;\n    }\n    if (!fileName.endsWith('.mid')) {\n        fileName = fileName + '.mid';\n    }\n    if (typeof window !== 'undefined' &&\n        window.URL &&\n        window.URL.createObjectURL) {\n        return createDownloadLink(bytes, fileName);\n    }\n    fs_1.default.writeFileSync(fileName, bytes, 'binary');\n    console.log(\"MIDI file generated: \" + fileName + \".\");\n};\nexports.midi = midi;\n/**\n * Create a downloadable link\n * @param b\n */\nvar createDownloadLink = function (b, fileName) {\n    // Convert bytes to array buffer\n    // Accepted answer on https://stackoverflow.com/questions/35038884/download-file-from-bytes-in-javascript\n    var bytes = new Uint8Array(b.length);\n    for (var i = 0; i < b.length; i++) {\n        var ascii = b.charCodeAt(i);\n        bytes[i] = ascii;\n    }\n    // Create a Blob so that we can set it up with the type of file we want (for eg MIDI)\n    var blob = new Blob([bytes], { type: 'audio/midi' });\n    // Create a link element to be used (you can use an existing link on the page as well)\n    var link = document.createElement('a');\n    link.href =\n        (typeof window !== 'undefined' &&\n            typeof window.URL !== 'undefined' &&\n            typeof window.URL.createObjectURL !== 'undefined' &&\n            window.URL.createObjectURL(blob)) ||\n            '';\n    // Give the downloadable file a name\n    link.download = fileName;\n    link.innerText = 'Download MIDI file';\n    return link;\n};\nvar createFileFromNotes = function (notes, bpm) {\n    var file = new jsmidgen.File();\n    var track = new jsmidgen.Track();\n    // set the track's bpm if it is provided\n    if (typeof bpm === 'number') {\n        track.setTempo(bpm);\n    }\n    file.addTrack(track);\n    for (var _i = 0, notes_1 = notes; _i < notes_1.length; _i++) {\n        var noteObj = notes_1[_i];\n        var level = noteObj.level || 127;\n        // While writing chords (multiple notes per tick)\n        // only the first noteOn (or noteOff) needs the complete arity of the function call\n        // subsequent calls need only the first 2 args (channel and note)\n        if (noteObj.note) {\n            if (typeof noteObj.note === 'string') {\n                track.noteOn(0, noteObj.note, noteObj.length, level); // channel, pitch(note), length, velocity\n                track.noteOff(0, noteObj.note, noteObj.length, level);\n            }\n            else {\n                track.addChord(0, noteObj.note, noteObj.length, level);\n            }\n        }\n        else {\n            track.noteOff(0, '', noteObj.length);\n        }\n    }\n    return file;\n};\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.progression = exports.getChordsByProgression = exports.getChordDegrees = void 0;\nvar harmonics_1 = require(\"harmonics\");\nvar utils_1 = require(\"./utils\");\n/**\n * Get the chords that go with a given scale/mode\n * This is useful only in case you want to check what chords work with a scale/mode\n * so that you can come up with chord progressions\n * @param  {String} mode e.g. major\n * @return {Array} e.g.['I', 'ii', 'iii', 'IV', 'V', 'vi', 'vii°']\n */\nvar getChordDegrees = function (mode) {\n    var theRomans = {\n        ionian: ['I', 'ii', 'iii', 'IV', 'V', 'vi', 'vii°'],\n        dorian: ['i', 'ii', 'III', 'IV', 'v', 'vi°', 'VII'],\n        phrygian: ['i', 'II', 'III', 'iv', 'v°', 'VI', 'vii'],\n        lydian: ['I', 'II', 'iii', 'iv°', 'V', 'vi', 'vii'],\n        mixolydian: ['I', 'ii', 'iii°', 'IV', 'v', 'vi', 'VII'],\n        aeolian: ['i', 'ii°', 'III', 'iv', 'v', 'VI', 'VII'],\n        locrian: ['i°', 'II', 'iii', 'iv', 'V', 'VI', 'vii'],\n        'melodic minor': ['i', 'ii', 'III+', 'IV', 'V', 'vi°', 'vii°'],\n        'harmonic minor': ['i', 'ii°', 'III+', 'iv', 'V', 'VI', 'vii°'],\n    };\n    theRomans.major = theRomans.ionian;\n    theRomans.minor = theRomans.aeolian;\n    return theRomans[mode] || [];\n};\nexports.getChordDegrees = getChordDegrees;\nvar idxByDegree = {\n    i: 0,\n    ii: 1,\n    iii: 2,\n    iv: 3,\n    v: 4,\n    vi: 5,\n    vii: 6,\n};\n/**\n * Get a chord name from degree\n * @param  {String} roman e.g. ii OR ii° OR V7\n * @return {String} e.g. m OR m7b5 OR Maj7\n */\nvar getChordName = function (roman) {\n    // remove any non character\n    var str = roman.replace(/\\W/g, '');\n    var prefix = 'M';\n    // check if it s lowercase\n    if (str.toLowerCase() === str) {\n        prefix = 'm';\n    }\n    if (roman.indexOf('°') > -1) {\n        return prefix + '7b5';\n    }\n    if (roman.indexOf('+') > -1) {\n        return prefix + '#5';\n    }\n    if (roman.indexOf('7') > -1) {\n        return prefix === 'M' ? 'maj7' : 'm7';\n    }\n    return prefix;\n};\n/**\n * Take the specified scale and degrees and return the chord names for them\n * These can be used as the value for the `notes` param of the `clip` method\n * @param {String} noteOctaveScale e.g. 'C4 major'\n * @param  {String} chordDegress e.g. 'I IV V IV'\n * @return {String} e.g. 'CM FM GM FM'\n */\nvar getChordsByProgression = function (noteOctaveScale, chordDegress) {\n    // Set the octave if missing\n    // For example if the method was called with `C major` instead of `C4 major`, then add the 4\n    var noteOctaveScaleArr = noteOctaveScale.split(' ');\n    if (!noteOctaveScaleArr[0].match(/\\d/)) {\n        noteOctaveScaleArr[0] += '4';\n        noteOctaveScale = noteOctaveScaleArr.join(' ');\n    }\n    // Get the scale from the given note and scale/mode combination\n    var mode = (0, harmonics_1.scale)(noteOctaveScale);\n    var chordDegreesArr = chordDegress.replace(/\\s*,+\\s*/g, ' ').split(' ');\n    // Now we have something like ['i', 'ii', 'IV']\n    // Convert it to a chord family such as ['Cm', 'Dm', 'FM']\n    var chordFamily = chordDegreesArr.map(function (roman) {\n        var chordName = getChordName(roman); // e.g. m\n        // get the index to be used by removing any digit or non alphabet character\n        var scaleId = idxByDegree[roman.replace(/\\W|\\d/g, '').toLowerCase()]; // e.g. 0\n        // get the note itself\n        var note = mode[scaleId]; // e.g. C\n        // get the octave of the note;\n        var oct = note.replace(/\\D+/, ''); // e.g. 4\n        // now get the chord\n        return note.replace(/\\d/, '') + chordName + '_' + oct;\n    });\n    return chordFamily.toString().replace(/,/g, ' ');\n};\nexports.getChordsByProgression = getChordsByProgression;\nvar getProgFactory = function (_a) {\n    var T = _a.T, P = _a.P, D = _a.D;\n    return function (count) {\n        if (count === void 0) { count = 4; }\n        var chords = [];\n        // Push root/tonic\n        chords.push((0, utils_1.pickOne)(T));\n        var i = 1;\n        // Pick a predominant\n        if (i < count - 1) {\n            chords.push((0, utils_1.pickOne)(P));\n            i++;\n        }\n        // Try another predominant\n        if (i < count - 1 && (0, utils_1.dice)()) {\n            chords.push((0, utils_1.pickOne)(P));\n            i++;\n        }\n        // /////// 4 or more//////////\n        if (i < count - 1) {\n            // Pick a dominant\n            chords.push((0, utils_1.pickOne)(D));\n            i++;\n        }\n        if (i < count - 1) {\n            // Pick a predominant\n            chords.push((0, utils_1.pickOne)(P));\n            i++;\n        }\n        if (i < count - 1) {\n            // Pick a dominant\n            chords.push((0, utils_1.pickOne)(D));\n            i++;\n        }\n        // Pick a predominant if possible\n        if (i < count - 1 && (0, utils_1.dice)()) {\n            chords.push((0, utils_1.pickOne)(P));\n            i++;\n        }\n        // //////////////////////////\n        // Fill the rest with dominant\n        while (i < count) {\n            chords.push((0, utils_1.pickOne)(D));\n            i++;\n        }\n        return chords;\n    };\n};\nvar M = getProgFactory({ T: ['I', 'vi'], P: ['ii', 'IV'], D: ['V'] });\nvar m = getProgFactory({ T: ['i', 'VI'], P: ['ii', 'iv'], D: ['V'] });\n/**\n * Generate a chord progression based on basic music theory\n * where we follow tonic to optionally predominant and then dominant\n * and then randomly to predominant and continue this till we reach `count`\n * @param scaleType e.g. M (for major chord progression), m (for minor chord progression)\n * @param count e.g. 4\n */\nvar progression = function (scaleType, count) {\n    if (count === void 0) { count = 4; }\n    if (scaleType === 'major' || scaleType === 'M') {\n        return M(count);\n    }\n    if (scaleType === 'minor' || scaleType === 'm') {\n        return m(count);\n    }\n    return [];\n};\nexports.progression = progression;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.Session = void 0;\nvar channel_1 = require(\"./channel\");\nvar Session = /** @class */ (function () {\n    function Session(arr) {\n        var _this = this;\n        arr = arr || [];\n        this.sessionChannels = arr.map(function (ch, i) {\n            // Make sure ch.idx is not empty and unique in this.sessionChannels\n            ch.idx = ch.idx || i;\n            ch.idx = _this.uniqueIdx(_this.sessionChannels, ch.idx);\n            return new channel_1.Channel(ch);\n        });\n    }\n    // Return unique idx for given channels\n    Session.prototype.uniqueIdx = function (channels, idx) {\n        if (!channels) {\n            return idx || 0;\n        }\n        // Channel idx's\n        var idxs = channels.reduce(function (acc, c) {\n            return (!acc.find(function (i) { return i === c.idx; }) && acc.concat(c.idx)) || acc;\n        }, []);\n        if (!idx || idxs.find(function (i) { return i === idx; })) {\n            var newIdx_1 = channels.length;\n            while (idxs.find(function (i) { return i === newIdx_1; })) {\n                newIdx_1 = newIdx_1 + 1;\n            }\n            return newIdx_1;\n        }\n        return idx;\n    };\n    Session.prototype.createChannel = function (ch) {\n        // Make sure ch.idx is unique in this.sessionChannels\n        ch.idx = this.uniqueIdx(this.sessionChannels, ch.idx);\n        var newChannel = new channel_1.Channel(ch);\n        this.sessionChannels.push(newChannel);\n        return newChannel;\n    };\n    Object.defineProperty(Session.prototype, \"channels\", {\n        get: function () {\n            return this.sessionChannels;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    Session.prototype.setTransportTempo = function (valueBpm) {\n        channel_1.Channel.setTransportTempo(valueBpm);\n    };\n    Session.prototype.startTransport = function () {\n        channel_1.Channel.startTransport();\n    };\n    Session.prototype.stopTransport = function (deleteEvents) {\n        if (deleteEvents === void 0) { deleteEvents = true; }\n        channel_1.Channel.stopTransport(deleteEvents);\n    };\n    // Start the clips at a specific index in all the channels\n    Session.prototype.startRow = function (idx) {\n        this.sessionChannels.forEach(function (ch) {\n            ch.startClip(idx);\n        });\n    };\n    Session.prototype.play = function (params) {\n        var _this = this;\n        var channelPatterns = params.channelPatterns;\n        var clipDuration = params.clipDuration || '4:0:0';\n        var clipDurationInSeconds = Tone.Time(clipDuration).toSeconds();\n        var stopClips = function (clips, time) {\n            clips.forEach(function (c) { return c.stop(time); });\n        };\n        var startClips = function (channelIdx, clipIdx, time) {\n            return clipIdx === '-'\n                ? []\n                : _this.channels\n                    .filter(function (c) { return c.idx === channelIdx; })\n                    .map(function (c) { var _a; return (_a = c.clips[clipIdx]) === null || _a === void 0 ? void 0 : _a.start(time); });\n        };\n        channelPatterns.forEach(function (_a) {\n            var channelIdx = _a.channelIdx, pattern = _a.pattern;\n            var clips = [];\n            var time = 0;\n            var prevClipIdx = '-';\n            pattern.split('').forEach(function (clipIdx) {\n                if (clipIdx !== prevClipIdx && clipIdx !== '_') {\n                    stopClips(clips, time);\n                    clips = startClips(channelIdx, clipIdx, time);\n                }\n                prevClipIdx = clipIdx;\n                time += clipDurationInSeconds;\n            });\n            stopClips(clips, time);\n        });\n    };\n    return Session;\n}());\nexports.Session = Session;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.randomInt = exports.convertChordsToNotes = exports.convertChordToNotes = exports.errorHasMessage = exports.flat = exports.dice = exports.pickOne = exports.sizzleMap = exports.shuffle = exports.expandStr = exports.isNote = void 0;\nvar harmonics_1 = require(\"harmonics\");\n/**\n * Take a string input and check if it s a note name or not\n * @param  {String} str Note name e.g. c4\n * @return {Boolean} Return true for c4 or return false for something like CM\n */\nvar isNote = function (str) {\n    return /^[a-gA-G](?:#|b)?\\d$/.test(str);\n};\nexports.isNote = isNote;\n/**\n * Take a String input such as xxx[xx[xx]]\n * and return an Array as ['x', 'x', 'x', ['x', 'x', ['x', 'x']]]\n * @param  {String} str\n * @return {Array}\n */\nvar expandStr = function (str) {\n    str = JSON.stringify(str.split(''));\n    str = str.replace(/,\"\\[\",/g, ', [');\n    str = str.replace(/\"\\[\",/g, '[');\n    str = str.replace(/,\"\\]\"/g, ']');\n    return JSON.parse(str);\n};\nexports.expandStr = expandStr;\n/**\n * Basic Array randomizer\n * @param  {Array} arr\n * @param  {boolean} fullShuffle Ensure no elements remain in old place\n * @return {Array}\n */\nvar shuffle = function (arr, fullShuffle) {\n    if (fullShuffle === void 0) { fullShuffle = true; }\n    var lastIndex = arr.length - 1;\n    // Shuffle algorithm by Richard Durstenfeld (Donald E. Knuth), also Ronald Fisher and Frank Yates.\n    // \"Full Shuffle\" Modification to ensure no elements remain in their original place (by taking each element once\n    // and swapping with any remaining elements)\n    arr.forEach(function (el, idx) {\n        if (idx >= lastIndex) {\n            // No shuffling last element\n            // One before last is always swapped with last at the end of the loop\n            // Since previous swaps can move last element into other places, there is still a random shuffle of last element\n            return;\n        }\n        // Swap el with one of the higher elements randomly\n        var rnd = fullShuffle\n            ? // Pick random number from idx+1 to lastIndex (Modified algorithm, (N-1)! combinations)\n                // Math.random -> [0, 1) -> [0, lastIndex-idx ) --floor-> [0, lastIndex-idx-1]\n                // rnd = [0, lastIndex-idx-1] + 1 + idx = [1 + idx, lastIndex]\n                // (Original algorithm would pick rnd = [idx, lastIndex], thus any element could arrive back into its slot)\n                Math.floor(Math.random() * (lastIndex - idx)) + 1 + idx\n            : // Pick random number from idx to lastIndex (Unmodified Richard Durstenfeld, N! combinations)\n                Math.floor(Math.random() * (lastIndex + 1 - idx)) + idx;\n        arr[idx] = arr[rnd];\n        arr[rnd] = el;\n    });\n    return arr;\n};\nexports.shuffle = shuffle;\n/**\n * Return an array of numbers relative to maxLevel || 127 ordered in a Sine wave format\n * This is used by the `sizzle` param of the `clip` method to add a rudimentary variation to the accent of each note\n * @param {Number} maxLevel A number between not more than 127\n * @return {Array}  Example output [63, 90, 110, 127, 110, 90, 63, 0, 63, 90, 110, 127, 110, 90, 63, 0]\n */\nvar sizzleMap = function (maxLevel) {\n    if (maxLevel === void 0) { maxLevel = 127; }\n    var pi = Math.PI;\n    var piArr = [\n        pi / 6,\n        pi / 4,\n        pi / 3,\n        pi / 2,\n        (2 * pi) / 3,\n        (3 * pi) / 4,\n        (5 * pi) / 6,\n        pi,\n    ];\n    var piArrRev = [\n        0,\n        pi / 6,\n        pi / 4,\n        pi / 3,\n        pi / 2,\n        (2 * pi) / 3,\n        (3 * pi) / 4,\n        (5 * pi) / 6,\n    ];\n    piArrRev.reverse();\n    var arr = piArr.concat(piArrRev);\n    return arr.map(function (element) { return Math.round(Math.sin(element) * maxLevel); });\n};\nexports.sizzleMap = sizzleMap;\n/**\n * Pick one item randomly from an array and return it\n * @param arr\n */\nvar pickOne = function (arr) {\n    return arr.length > 1 ? arr[Math.round(Math.random())] : arr[0];\n};\nexports.pickOne = pickOne;\n/**\n * Boolean generator\n */\nvar dice = function () { return !!Math.round(Math.random()); };\nexports.dice = dice;\n/**\n * Polyfill for Array.prototype.flat\n */\nvar flat = function (arr) {\n    return arr.reduce(function (acc, val) { return acc.concat(val); }, []);\n};\nexports.flat = flat;\n// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types\nvar errorHasMessage = function (x) {\n    return typeof x.message === 'string';\n};\nexports.errorHasMessage = errorHasMessage;\n/**\n *  'el' could be an inlineChord() e.g. Cmaj7 or Dbsus2_5\n *  or a chord() e.g. 'C3 M'\n */\nvar convertChordToNotes = function (el) {\n    // Try both inlineChord() and chord()\n    var c1;\n    var c2;\n    var e1;\n    var e2;\n    try {\n        c1 = (0, harmonics_1.inlineChord)(el);\n    }\n    catch (e) {\n        e1 = e;\n    }\n    try {\n        c2 = (0, harmonics_1.chord)(el.replace(/_/g, ' ')); // chord() is not friendly to underscores\n    }\n    catch (e) {\n        e2 = e;\n    }\n    if (!e1 && !e2) {\n        // Both inlineChord() and chord() have result\n        if (c1.toString() !== c2.toString()) {\n            throw new Error(\"Chord \" + el + \" cannot decode, guessing \" + c1 + \" or \" + c2);\n        }\n        return c1;\n    } // else\n    if (!e1) {\n        return c1;\n    } // else\n    if (!e2) {\n        return c2;\n    } // else\n    // Give up, last try:\n    return (0, harmonics_1.chord)(el);\n};\nexports.convertChordToNotes = convertChordToNotes;\nvar convertChordsToNotes = function (el) {\n    if (typeof el === 'string' && (0, exports.isNote)(el)) {\n        // A note needs to be an array so that it can accomodate chords or single notes with a single interface\n        return [el];\n    }\n    if (Array.isArray(el)) {\n        // This could be a chord provided as an array or an array of arrays\n        el.forEach(function (n) {\n            // This could be a chord provided as an array\n            if (Array.isArray(n)) {\n                // TODO: Can we convert it to something useful?\n                // make sure it uses valid notes\n                n.forEach(function (n1) {\n                    if (typeof n1 !== 'string' || !(0, exports.isNote)(n1)) {\n                        throw new TypeError('array of arrays must comprise valid notes');\n                    }\n                });\n                // throw new TypeError('cannot decode array of arrays');\n            }\n            else if (typeof n !== 'string' || !(0, exports.isNote)(n)) {\n                // make sure it uses valid notes\n                throw new TypeError('array must comprise valid notes');\n            }\n        });\n        return el;\n        // ? return el as (string | string[])[];\n    }\n    if (!Array.isArray(el)) {\n        var c = (0, exports.convertChordToNotes)(el);\n        if (c && c.length) {\n            return c;\n        }\n    }\n    throw new Error(\"Chord \" + el + \" not found\");\n};\nexports.convertChordsToNotes = convertChordsToNotes;\nvar randomInt = function (num) {\n    if (num === void 0) { num = 1; }\n    return Math.round(Math.random() * num);\n};\nexports.randomInt = randomInt;\n","module.exports = require(\"fs\");","// The module cache\nvar __webpack_module_cache__ = {};\n\n// The require function\nfunction __webpack_require__(moduleId) {\n\t// Check if module is in cache\n\tvar cachedModule = __webpack_module_cache__[moduleId];\n\tif (cachedModule !== undefined) {\n\t\treturn cachedModule.exports;\n\t}\n\t// Create a new module (and put it into the cache)\n\tvar module = __webpack_module_cache__[moduleId] = {\n\t\tid: moduleId,\n\t\tloaded: false,\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n\t// Flag the module as loaded\n\tmodule.loaded = true;\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\n","__webpack_require__.nmd = (module) => {\n\tmodule.paths = [];\n\tif (!module.children) module.children = [];\n\treturn module;\n};","// startup\n// Load entry module and return exports\n// This entry module is referenced by other modules so it can't be inlined\nvar __webpack_exports__ = __webpack_require__(773);\n"],"names":["n","exports","JSON","parse","e","o","a","i","r","d","Object","defineProperty","enumerable","get","prototype","hasOwnProperty","call","Symbol","toStringTag","value","chord","m","chords","t","inlineChord","scale","c","scales","s","Error","concat","indexOf","slice","toUpperCase","charAt","replace","l","isNaN","b","map","u","p","h","f","length","push","includes","split","keys","__esModule","Midi","exported","DEFAULT_VOLUME","Util","DEFAULT_DURATION","DEFAULT_CHANNEL","midi_letter_pitches","g","midiPitchFromNote","matches","exec","note","toLowerCase","accidental","parseInt","substr","ensureMidiPitch","test","midi_pitches_letter","midi_flattened_notes","noteFromMidiPitch","returnFlattened","noteName","octave","noteNum","Math","floor","mpqnFromBpm","bpm","mpqn","ret","unshift","bpmFromMpqn","codes2Str","byteArray","String","fromCharCode","apply","str2Bytes","str","finalBytes","bytes","chars","translateTickTime","ticks","buffer","bList","MidiEvent","params","this","type","undefined","channel","param1","setTime","time","setType","setChannel","setParam1","setParam2","param2","NOTE_OFF","NOTE_ON","AFTER_TOUCH","CONTROLLER","PROGRAM_CHANGE","CHANNEL_AFTERTOUCH","PITCH_BEND","toBytes","typeChannelByte","MetaEvent","setData","data","SEQUENCE","TEXT","COPYRIGHT","TRACK_NAME","INSTRUMENT","LYRIC","MARKER","CUE_POINT","CHANNEL_PREFIX","END_OF_TRACK","TEMPO","SMPTE","TIME_SIG","KEY_SIG","SEQ_EVENT","Array","isArray","dataBytes","x","charCodeAt","Track","config","events","START_BYTES","END_BYTES","addEvent","event","addNoteOn","noteOn","pitch","velocity","addNoteOff","noteOff","addNote","dur","addChord","forEach","index","setInstrument","instrument","setTempo","tempo","trackLength","eventBytes","startBytes","endBytes","lengthBytes","toString","File","tracks","HDR_CHUNKID","HDR_CHUNK_SIZE","HDR_TYPE0","HDR_TYPE1","addTrack","track","trackCount","Event","module","__spreadArray","to","from","pack","arguments","ar","arp","harmonics_1","utils_1","fillArr","arr","len","bumpOctave","el","oct","arr1","arr2","chordsOrParams","finalArr","count","order","match","TypeError","join","assign","filledArr_1","reorderedArr","idx","filledArr_2","errorHasMessage","message","__assign","__awaiter","thisArg","_arguments","P","generator","Promise","resolve","reject","fulfilled","step","next","rejected","result","done","then","__generator","body","y","_","label","sent","trys","ops","verb","iterator","v","op","pop","clip","renderingDuration","totalPatternDuration","recursivelyApplyPatternToDurations","getDuration","getNote","defaultSubdiv","counter","randomNotes","randomInt","notes","durations","subdiv","patternArr","char","generateSequence","context","Tone","getContext","pattern","expandStr","Ticks","toSeconds","Sequence","callback","getSeqFn","subdivision","subdivOrLength","patternRegularNotesCount","filter","patternRandomNotesCount","patternNotesCount","notesCount","n1","n2","_a","smallest","largest","leastCommonMultiple","originalContext","ongoingRenderingCounter","shuffle","sizzle","sizzleReps","arpegiate","align","alignOffset","amp","accentLow","offlineRendering","convertChordsToNotes","duration","player","Player","loop","Offline","sequence","loaded","start","transport","setContext","offlineRenderingCallback","toDestination","sync","offlineRenderClip","__createBinding","create","k","k2","__exportStar","Session","midi","progression","getChordsByProgression","getChordDegrees","modes","mode","browser_clip_1","progression_1","arp_1","midi_1","session_1","__rest","getOwnPropertySymbols","propertyIsEnumerable","Channel","getNextPos","Transport","position","transportPosTicks","alignTicks","toTicks","alignOffsetTicks","_this","name","activePatternIdx","channelClips","clipNoteCount","clips","samples","sample","synth","params1","params2","external","sampler","params3","volume","eventCb","playerCb","params4","effects","originalParamsFiltered","eventCbFn","playerCbFn","hasLoaded","hasFailed","initializerTask","initOutputProducer","initInstrument","adjustInstrument","initEffects","clipsFailed","addClip","catch","setTransportTempo","valueBpm","startTransport","stopTransport","deleteEvents","stop","cancel","setVolume","_b","startClip","stopClip","state","counterResetTask","scheduleOnce","clipParams","key","durSeconds","Time","triggerAttackRelease","PolySynth","Sampler","NoiseSynth","checkToneObjLoaded","toneObject","skipRecursion","handled_1","ToneAudioBuffer","ToneBufferSource","oldOnLoad_1","onload","recreateToneObjectInContext","newObj_1","_dummyVoice","newObj_2","url","_buffer","paramsFromSampler","attack","curve","release","paramsFromBuffers","baseUrl","_buffers","urls","fromEntries","entries","newObj_3","newObj_4","synthName","preset","console","warn","init","rawContext","newObj","someVal","startEffect","eff","effectsIn","all","effect","effectOut","results","chain","configurable","__setModuleDefault","__importStar","mod","__importDefault","fs_1","jsmidgen","fileName","createFileFromNotes","endsWith","window","URL","createObjectURL","createDownloadLink","default","writeFileSync","log","Uint8Array","ascii","blob","Blob","link","document","createElement","href","download","innerText","file","_i","notes_1","noteObj","level","theRomans","ionian","dorian","phrygian","lydian","mixolydian","aeolian","locrian","major","minor","idxByDegree","ii","iii","iv","vi","vii","noteOctaveScale","chordDegress","noteOctaveScaleArr","roman","chordName","prefix","getChordName","scaleId","getProgFactory","T","D","pickOne","dice","M","scaleType","channel_1","sessionChannels","ch","uniqueIdx","channels","idxs","reduce","acc","find","newIdx_1","createChannel","newChannel","startRow","play","channelPatterns","clipDuration","clipDurationInSeconds","stopClips","channelIdx","prevClipIdx","clipIdx","startClips","convertChordToNotes","flat","sizzleMap","isNote","stringify","fullShuffle","lastIndex","rnd","random","maxLevel","pi","PI","piArr","piArrRev","reverse","element","round","sin","val","c1","c2","e1","e2","num","require","__webpack_module_cache__","__webpack_require__","moduleId","cachedModule","id","__webpack_modules__","nmd","paths","children","__webpack_exports__"],"sourceRoot":""}
+{"version":3,"file":"browser.js","mappings":"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","sources":["webpack://scribbletune/./node_modules/harmonics/dist/index.js","webpack://scribbletune/./src/arp.ts","webpack://scribbletune/./src/browser-clip.ts","webpack://scribbletune/./src/browser-index.ts","webpack://scribbletune/./src/channel.ts","webpack://scribbletune/./src/midi.ts","webpack://scribbletune/./src/progression.ts","webpack://scribbletune/./src/session.ts","webpack://scribbletune/./src/types/index.ts","webpack://scribbletune/./src/utils.ts","webpack://scribbletune/external commonjs \"fs\"","webpack://scribbletune/./node_modules/@scribbletune/midi/dist/index.cjs","webpack://scribbletune/webpack/bootstrap","webpack://scribbletune/webpack/startup"],"sourcesContent":["\"use strict\";\nvar __defProp = Object.defineProperty;\nvar __getOwnPropDesc = Object.getOwnPropertyDescriptor;\nvar __getOwnPropNames = Object.getOwnPropertyNames;\nvar __hasOwnProp = Object.prototype.hasOwnProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\nvar __copyProps = (to, from, except, desc) => {\n  if (from && typeof from === \"object\" || typeof from === \"function\") {\n    for (let key of __getOwnPropNames(from))\n      if (!__hasOwnProp.call(to, key) && key !== except)\n        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });\n  }\n  return to;\n};\nvar __toCommonJS = (mod) => __copyProps(__defProp({}, \"__esModule\", { value: true }), mod);\n\n// src/index.ts\nvar index_exports = {};\n__export(index_exports, {\n  chord: () => chord,\n  chords: () => chords,\n  getIndicesFromScale: () => getIndicesFromScale,\n  inlineChord: () => inlineChord,\n  scale: () => scale,\n  scales: () => scales\n});\nmodule.exports = __toCommonJS(index_exports);\n\n// src/gen/scaleMaps.json\nvar scaleMaps_default = {\n  \"major pentatonic\": \"101010010100\",\n  \"ionian pentatonic\": \"100011010001\",\n  \"mixolydian pentatonic\": \"100011010010\",\n  ritusen: \"101001010100\",\n  egyptian: \"101001010010\",\n  \"neopolitan major pentatonic\": \"100011100010\",\n  \"vietnamese 1\": \"100101011000\",\n  pelog: \"110100011000\",\n  kumoijoshi: \"110001011000\",\n  hirajoshi: \"101100011000\",\n  iwato: \"110001100010\",\n  \"in-sen\": \"110001010010\",\n  \"lydian pentatonic\": \"100010110001\",\n  \"malkos raga\": \"100101001010\",\n  \"locrian pentatonic\": \"100101100010\",\n  \"minor pentatonic\": \"100101010010\",\n  \"minor six pentatonic\": \"100101010100\",\n  \"flat three pentatonic\": \"101100010100\",\n  \"flat six pentatonic\": \"101010011000\",\n  scriabin: \"110010010100\",\n  \"whole tone pentatonic\": \"100010101010\",\n  \"lydian #5P pentatonic\": \"100010101001\",\n  \"lydian dominant pentatonic\": \"100010110010\",\n  \"minor #7M pentatonic\": \"100101010001\",\n  \"super locrian pentatonic\": \"100110100010\",\n  \"minor hexatonic\": \"101101010001\",\n  augmented: \"100110011001\",\n  \"major blues\": \"101110010100\",\n  piongio: \"101001010110\",\n  \"prometheus neopolitan\": \"110010100110\",\n  prometheus: \"101010100110\",\n  \"mystery #1\": \"110010101010\",\n  \"six tone symmetric\": \"110011001100\",\n  \"whole tone\": \"101010101010\",\n  \"messiaen's mode #5\": \"110001110001\",\n  \"minor blues\": \"100101110010\",\n  \"locrian major\": \"101011101010\",\n  \"double harmonic lydian\": \"110010111001\",\n  \"harmonic minor\": \"101101011001\",\n  altered: \"110110101010\",\n  \"locrian #2\": \"101101101010\",\n  \"mixolydian b6\": \"101011011010\",\n  \"lydian dominant\": \"101010110110\",\n  lydian: \"101010110101\",\n  \"lydian augmented\": \"101010101101\",\n  \"dorian b2\": \"110101010110\",\n  \"melodic minor\": \"101101010101\",\n  locrian: \"110101101010\",\n  ultralocrian: \"110110101100\",\n  \"locrian 6\": \"110101100110\",\n  \"augmented heptatonic\": \"100111011001\",\n  \"romanian minor\": \"101100110110\",\n  \"dorian #4\": \"101100110110\",\n  \"lydian diminished\": \"101100110101\",\n  phrygian: \"110101011010\",\n  \"leading whole tone\": \"101010101011\",\n  \"lydian minor\": \"101010111010\",\n  \"phrygian dominant\": \"110011011010\",\n  balinese: \"110101011001\",\n  \"neopolitan major\": \"110101010101\",\n  aeolian: \"101101011010\",\n  \"harmonic major\": \"101011011001\",\n  \"double harmonic major\": \"110011011001\",\n  dorian: \"101101010110\",\n  \"hungarian minor\": \"101100111001\",\n  \"hungarian major\": \"100110110110\",\n  oriental: \"110011100110\",\n  flamenco: \"110110110010\",\n  \"todi raga\": \"110100111001\",\n  mixolydian: \"101011010110\",\n  persian: \"110011101001\",\n  major: \"101011010101\",\n  enigmatic: \"110010101011\",\n  \"major augmented\": \"101011001101\",\n  \"lydian #9\": \"100110110101\",\n  \"messiaen's mode #4\": \"111001111001\",\n  \"purvi raga\": \"110011111001\",\n  \"spanish heptatonic\": \"110111011010\",\n  bebop: \"101011010111\",\n  \"bebop minor\": \"101111010110\",\n  \"bebop major\": \"101011011101\",\n  \"bebop locrian\": \"110101111010\",\n  \"minor bebop\": \"101101011011\",\n  diminished: \"101101101101\",\n  ichikosucho: \"101011110101\",\n  \"minor six diminished\": \"101101011101\",\n  \"half-whole diminished\": \"110110110110\",\n  \"kafi raga\": \"100111010111\",\n  \"messiaen's mode #6\": \"101011101011\",\n  \"composite blues\": \"101111110110\",\n  \"messiaen's mode #3\": \"101110111011\",\n  \"messiaen's mode #7\": \"111101111101\",\n  chromatic: \"111111111111\",\n  ionian: \"101011010101\",\n  minor: \"101101011010\",\n  Kanakangi: \"111001011100\",\n  Ratnangi: \"111001011010\",\n  Ganamurti: \"111001011001\",\n  Vanaspati: \"111001010110\",\n  Manavati: \"111001010101\",\n  Tanarupi: \"111001010011\",\n  Senavati: \"110101011100\",\n  Hanumatodi: \"110101011010\",\n  Dhenuka: \"110101011001\",\n  Natakapriya: \"110101010110\",\n  Kokilapriya: \"110101010101\",\n  Rupavati: \"110101010011\",\n  Gayakapriya: \"110011011100\",\n  Vakulabharanam: \"110011011010\",\n  Mayamalavagowla: \"110011011001\",\n  Chakravakam: \"110011010110\",\n  Suryakantam: \"110011010101\",\n  Hatakambari: \"110011010011\",\n  Jhankaradhwani: \"101101011100\",\n  Natabhairavi: \"101101011010\",\n  Keeravani: \"101101011001\",\n  Kharaharapriya: \"101101010110\",\n  Gourimanohari: \"101101010101\",\n  Varunapriya: \"101101010011\",\n  Mararanjani: \"101011011100\",\n  Charukesi: \"101011011010\",\n  Sarasangi: \"101011011001\",\n  Harikambhoji: \"101011010110\",\n  Dheerasankarabaranam: \"101011010101\",\n  Naganandini: \"101011010011\",\n  Yagapriya: \"100111011100\",\n  Ragavardhini: \"100111011010\",\n  Gangeyabhushani: \"100111011001\",\n  Vagadheeswari: \"100111010110\",\n  Shulini: \"100111010101\",\n  Chalanata: \"100111010011\",\n  Salagam: \"111000111100\",\n  Jalarnavam: \"111000111010\",\n  Jhalavarali: \"111000111001\",\n  Navaneetam: \"111000110110\",\n  Pavani: \"111000110101\",\n  Raghupriya: \"111000110011\",\n  Gavambhodi: \"110100111100\",\n  Bhavapriya: \"110100111010\",\n  Shubhapantuvarali: \"110100111001\",\n  Shadvidamargini: \"110100110110\",\n  Suvarnangi: \"110100110101\",\n  Divyamani: \"110100110011\",\n  Dhavalambari: \"110010111100\",\n  Namanarayani: \"110010111010\",\n  Kamavardhini: \"110010111001\",\n  Ramapriya: \"110010110110\",\n  Gamanashrama: \"110010110101\",\n  Vishwambari: \"110010110011\",\n  Shamalangi: \"101100111100\",\n  Shanmukhapriya: \"101100111010\",\n  Simhendramadhyamam: \"101100111001\",\n  Hemavati: \"101100110110\",\n  Dharmavati: \"101100110101\",\n  Neetimati: \"101100110011\",\n  Kantamani: \"101010111100\",\n  Rishabhapriya: \"101010111010\",\n  Latangi: \"101010111001\",\n  Vachaspati: \"101010110110\",\n  Mechakalyani: \"101010110101\",\n  Chitrambari: \"101010110011\",\n  Sucharitra: \"100110111100\",\n  \"Jyoti swarupini\": \"100110111010\",\n  Dhatuvardani: \"100110111001\",\n  Nasikabhushini: \"100110110110\",\n  Kosalam: \"100110110101\",\n  Rasikapriya: \"100110110011\"\n};\n\n// src/gen/chordMaps.json\nvar chordMaps_default = {\n  \"5th\": \"100000010000\",\n  \"M7#5sus4\": \"100001001001\",\n  \"7#5sus4\": \"100001001010\",\n  sus4: \"100001010000\",\n  M7sus4: \"100001010001\",\n  \"7sus4\": \"100001010010\",\n  \"7no5\": \"100010000010\",\n  aug: \"100010001000\",\n  M7b6: \"100010001001\",\n  \"maj7#5\": \"100010001001\",\n  \"7#5\": \"100010001010\",\n  \"7b13\": \"100010001010\",\n  M: \"100010010000\",\n  maj7: \"100010010001\",\n  \"7th\": \"100010010010\",\n  \"6th\": \"100010010100\",\n  \"7add6\": \"100010010110\",\n  \"7b6\": \"100010011010\",\n  Mb5: \"100010100000\",\n  M7b5: \"100010100001\",\n  \"7b5\": \"100010100010\",\n  \"maj#4\": \"100010110001\",\n  \"7#11\": \"100010110010\",\n  \"M6#11\": \"100010110100\",\n  \"7#11b13\": \"100010111010\",\n  \"m#5\": \"100100001000\",\n  mb6M7: \"100100001001\",\n  \"m7#5\": \"100100001010\",\n  m: \"100100010000\",\n  \"m/ma7\": \"100100010001\",\n  m7: \"100100010010\",\n  m6: \"100100010100\",\n  mMaj7b6: \"100100011001\",\n  dim: \"100100100000\",\n  oM7: \"100100100001\",\n  m7b5: \"100100100010\",\n  dim7: \"100100100100\",\n  o7M7: \"100100100101\",\n  \"4th\": \"100101000010\",\n  madd4: \"100101010000\",\n  m7add11: \"100101010010\",\n  \"+add#9\": \"100110001000\",\n  \"7#5#9\": \"100110001010\",\n  \"7#9\": \"100110010010\",\n  \"13#9\": \"100110010110\",\n  \"7#9b13\": \"100110011010\",\n  \"maj7#9#11\": \"100110110001\",\n  \"7#9#11\": \"100110110010\",\n  \"13#9#11\": \"100110110110\",\n  \"7#9#11b13\": \"100110111010\",\n  sus2: \"101000010000\",\n  \"M9#5sus4\": \"101001001001\",\n  sus24: \"101001010000\",\n  M9sus4: \"101001010001\",\n  \"11th\": \"101001010010\",\n  \"9sus4\": \"101001010010\",\n  \"13sus4\": \"101001010110\",\n  \"9no5\": \"101010000010\",\n  \"13no5\": \"101010000110\",\n  \"M#5add9\": \"101010001000\",\n  \"maj9#5\": \"101010001001\",\n  \"9#5\": \"101010001010\",\n  \"9b13\": \"101010001010\",\n  Madd9: \"101010010000\",\n  maj9: \"101010010001\",\n  \"9th\": \"101010010010\",\n  \"6/9\": \"101010010100\",\n  maj13: \"101010010101\",\n  M7add13: \"101010010101\",\n  \"13th\": \"101010010110\",\n  M9b5: \"101010100001\",\n  \"9b5\": \"101010100010\",\n  \"13b5\": \"101010100110\",\n  \"9#5#11\": \"101010101010\",\n  \"maj9#11\": \"101010110001\",\n  \"9#11\": \"101010110010\",\n  \"69#11\": \"101010110100\",\n  \"M13#11\": \"101010110101\",\n  \"13#11\": \"101010110110\",\n  \"9#11b13\": \"101010111010\",\n  \"m9#5\": \"101100001010\",\n  madd9: \"101100010000\",\n  mM9: \"101100010001\",\n  m9: \"101100010010\",\n  m69: \"101100010100\",\n  m13: \"101100010110\",\n  mMaj9b6: \"101100011001\",\n  m9b5: \"101100100010\",\n  m11A: \"101101001010\",\n  m11: \"101101010010\",\n  b9sus: \"110001010010\",\n  \"11b9\": \"110001010010\",\n  \"7sus4b9b13\": \"110001011010\",\n  alt7: \"110010000010\",\n  \"7#5b9\": \"110010001010\",\n  Maddb9: \"110010010000\",\n  M7b9: \"110010010001\",\n  \"7b9\": \"110010010010\",\n  \"13b9\": \"110010010110\",\n  \"7b9b13\": \"110010011010\",\n  \"7#5b9#11\": \"110010101010\",\n  \"7b9#11\": \"110010110010\",\n  \"13b9#11\": \"110010110110\",\n  \"7b9b13#11\": \"110010111010\",\n  mb6b9: \"110100001000\",\n  \"7b9#9\": \"110110010010\"\n};\n\n// src/scalesAndChords.ts\nvar DEFAULT_OCTAVE = 4;\nvar sharpToFlatMap = {\n  \"C#\": \"Db\",\n  \"D#\": \"Eb\",\n  \"F#\": \"Gb\",\n  \"G#\": \"Ab\",\n  \"A#\": \"Bb\",\n  \"CB\": \"B\",\n  \"FB\": \"E\",\n  \"E#\": \"F\",\n  \"B#\": \"C\"\n};\nfunction sharpToFlat(root) {\n  return sharpToFlatMap[root.toUpperCase()] || root.charAt(0).toUpperCase() + root.slice(1);\n}\nvar CHROMATIC = [\n  \"C\",\n  \"Db\",\n  \"D\",\n  \"Eb\",\n  \"E\",\n  \"F\",\n  \"Gb\",\n  \"G\",\n  \"Ab\",\n  \"A\",\n  \"Bb\",\n  \"B\"\n];\nfunction getChromatic(root, octave) {\n  const index = CHROMATIC.indexOf(root);\n  if (index === -1) {\n    throw new Error(`${root} is not a valid root note`);\n  }\n  const o1 = CHROMATIC.map((n) => n + octave);\n  const o2 = CHROMATIC.map((n) => n + (octave + 1));\n  const c = o1.concat(o2);\n  return c.slice(index);\n}\nvar scaleMap = scaleMaps_default;\nvar chordMap = chordMaps_default;\nfunction _getNotesForScaleOrChord({ scale: scale2, chord: chord2 }) {\n  const input = scale2 || chord2;\n  const SCALE_OR_CHORD = scale2 ? \"scale\" : \"chord\";\n  if (typeof input !== \"string\") {\n    throw new Error(`${input} is not a valid input for ${SCALE_OR_CHORD}`);\n  }\n  const rootOctaveScale = input.trim();\n  const indexOfFirstSpace = rootOctaveScale.indexOf(\" \");\n  let scaleOrChord;\n  let rootOctave;\n  if (indexOfFirstSpace === -1) {\n    scaleOrChord = rootOctaveScale.slice(1);\n    rootOctave = rootOctaveScale[0];\n    if (rootOctaveScale[1] === \"b\" || rootOctaveScale[1] === \"#\") {\n      scaleOrChord = rootOctaveScale.slice(2);\n      rootOctave += rootOctaveScale[1];\n    }\n  } else {\n    scaleOrChord = rootOctaveScale.slice(indexOfFirstSpace === -1 ? 1 : indexOfFirstSpace + 1);\n    rootOctave = rootOctaveScale.slice(0, indexOfFirstSpace);\n  }\n  const root = sharpToFlat(rootOctave.replace(/\\d/g, \"\"));\n  const octaveNumber = rootOctave.replace(/\\D/g, \"\");\n  const octave = octaveNumber !== \"\" ? +rootOctave.replace(/\\D/g, \"\") : DEFAULT_OCTAVE;\n  if (isNaN(octave)) {\n    throw new Error(`${rootOctave[0]} does not have a valid octave`);\n  }\n  if (!scaleMap[scaleOrChord] && !chordMap[scaleOrChord]) {\n    throw new Error(`${rootOctaveScale} is not a valid ${SCALE_OR_CHORD}`);\n  }\n  const chroma = getChromatic(root, octave);\n  const acc = [];\n  let p1 = 0, p2 = 0;\n  const map = scale2 ? scaleMap : chordMap;\n  while (p1 < map[scaleOrChord].length) {\n    if (map[scaleOrChord][p1] === \"1\") {\n      acc.push(chroma[p2]);\n    }\n    p1++;\n    p2++;\n  }\n  return acc;\n}\nfunction inlineChord(rootChord_Oct) {\n  const B9SUS = \"b9sus\";\n  let root, chord2, octave = DEFAULT_OCTAVE;\n  if (rootChord_Oct.includes(B9SUS)) {\n    chord2 = B9SUS;\n    root = rootChord_Oct.slice(0, rootChord_Oct.indexOf(B9SUS));\n  } else {\n    root = rootChord_Oct[0];\n    chord2 = rootChord_Oct.slice(1);\n    if (rootChord_Oct[1] === \"b\" || rootChord_Oct[1] === \"#\") {\n      root += rootChord_Oct[1];\n      chord2 = rootChord_Oct.slice(2);\n    }\n  }\n  if (rootChord_Oct.includes(\"_\")) {\n    octave = +rootChord_Oct.split(\"_\")[1];\n    chord2 = chord2.slice(0, chord2.indexOf(\"_\"));\n  }\n  return _getNotesForScaleOrChord({ chord: root + octave + \" \" + chord2 });\n}\nfunction chords() {\n  return Object.keys(chordMap);\n}\nfunction scales() {\n  return Object.keys(scaleMap);\n}\nfunction chord(chord2) {\n  return _getNotesForScaleOrChord({ chord: chord2 });\n}\nfunction scale(scale2) {\n  return _getNotesForScaleOrChord({ scale: scale2 });\n}\nfunction getIndicesFromScale(scaleOrBitmap) {\n  const str = scaleMap[scaleOrBitmap] || scaleOrBitmap;\n  const intervals = [];\n  for (let i = 0; i < str.length; i++) {\n    if (str[i] === \"1\") {\n      intervals.push(i);\n    }\n  }\n  intervals.push(12);\n  return intervals;\n}\n// Annotate the CommonJS export names for ESM import in node:\n0 && (module.exports = {\n  chord,\n  chords,\n  getIndicesFromScale,\n  inlineChord,\n  scale,\n  scales\n});\n","\"use strict\";\nvar __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {\n    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\n        if (ar || !(i in from)) {\n            if (!ar) ar = Array.prototype.slice.call(from, 0, i);\n            ar[i] = from[i];\n        }\n    }\n    return to.concat(ar || Array.prototype.slice.call(from));\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.arp = void 0;\nvar harmonics_1 = require(\"harmonics\");\nvar utils_1 = require(\"./utils\");\nvar DEFAULT_OCTAVE = 4;\n/**\n * Take an array and fill it with it s own elements in the next octave till it s of the specified `len`\n * @param  {Array} arr e.g. ['a4', 'b4']\n * @param  {Number} e.g. len 4\n * @return {Array} e.g. ['a4', 'b4', 'a5', 'b5']\n */\nvar fillArr = function (arr, len) {\n    var bumpOctave = function (el) {\n        if (!el) {\n            throw new Error('Empty element');\n        }\n        var note = el.replace(/\\d/, '');\n        var oct = el.replace(/\\D/g, '') || DEFAULT_OCTAVE;\n        if (!note) {\n            throw new Error('Incorrect note');\n        }\n        return note + (+oct + 1);\n    };\n    // Create a couple of chord arrays with bumped octaves\n    // so that something like [c3, e3, g4] turns into [c4, e4, g5] and [c5, e5, g6]\n    var arr1 = arr.map(bumpOctave);\n    var arr2 = arr1.map(bumpOctave);\n    var finalArr = __spreadArray(__spreadArray(__spreadArray([], arr, true), arr1, true), arr2, true);\n    // Slice and return only as much as required\n    return finalArr.slice(0, len);\n};\n/**\n *\n * @param chordsOrParams a string that denotes space (comma?) separated chords to be used or an object with additional properties\n * By default, if this is a string, the count of notes generated is 8 and the order is ascending.\n * For instance arp('CM FM') will result in an array of notes [C4, E4, G4, F4, A4, C4, C5, E5]\n * You can even provide Params as an object.\n * For e.g. arp({count: 8, order: '10325476', chords: 'FM_4 Gm7b5_4 AbM_4 Bbm_4 Cm_5 DbM_5 EbM_5})\n */\nvar arp = function (chordsOrParams) {\n    var finalArr = [];\n    var params = {\n        count: 4,\n        order: '0123',\n        chords: '',\n    };\n    if (typeof chordsOrParams === 'string') {\n        params.chords = chordsOrParams;\n    }\n    else {\n        if (chordsOrParams.order && chordsOrParams.order.match(/\\D/g)) {\n            throw new TypeError('Invalid value for order');\n        }\n        if (chordsOrParams.count > 8 || chordsOrParams.count < 2) {\n            throw new TypeError('Invalid value for count');\n        }\n        // Provision a order for the notes in case only count was provided\n        if (chordsOrParams.count && !chordsOrParams.order) {\n            params.order = Array.from(Array(chordsOrParams.count).keys()).join('');\n        }\n        Object.assign(params, chordsOrParams);\n    }\n    // Chords can be passed as a string, e.g. 'CM_4 FM_4'\n    // or as an array of notes arrays e.g. [['C3', 'E3', 'G3', 'B3'], ['F3', 'A3', 'C4', 'E4']]\n    if (typeof params.chords === 'string') {\n        var chordsArr = params.chords.split(' ');\n        chordsArr.forEach(function (c, i) {\n            try {\n                var filledArr_1 = fillArr((0, harmonics_1.inlineChord)(c), params.count);\n                // reorder the filledArr as per params.order\n                var reorderedArr = params.order\n                    .split('')\n                    .map(function (idx) { return filledArr_1[idx]; });\n                finalArr = __spreadArray(__spreadArray([], finalArr, true), reorderedArr, true);\n            }\n            catch (e) {\n                throw new Error(\"Cannot decode chord \".concat(i + 1, \" \\\"\").concat(c, \"\\\" in given \\\"\").concat(params.chords, \"\\\"\"));\n            }\n        });\n    }\n    else if (Array.isArray(params.chords)) {\n        params.chords.forEach(function (c, i) {\n            try {\n                var filledArr_2 = fillArr(c, params.count);\n                // reorder the filledArr as per params.order\n                var reorderedArr = params.order\n                    .split('')\n                    .map(function (idx) { return filledArr_2[idx]; });\n                finalArr = __spreadArray(__spreadArray([], finalArr, true), reorderedArr, true);\n            }\n            catch (e) {\n                throw new Error(\"\".concat((0, utils_1.errorHasMessage)(e) ? e.message : e, \" in chord \").concat(i + 1, \" \\\"\").concat(c, \"\\\"\"));\n            }\n        });\n    }\n    else {\n        throw new TypeError('Invalid value for chords');\n    }\n    return finalArr;\n};\nexports.arp = arp;\n","\"use strict\";\nvar __assign = (this && this.__assign) || function () {\n    __assign = Object.assign || function(t) {\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\n            s = arguments[i];\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))\n                t[p] = s[p];\n        }\n        return t;\n    };\n    return __assign.apply(this, arguments);\n};\nvar __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n    return new (P || (P = Promise))(function (resolve, reject) {\n        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n        function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n        step((generator = generator.apply(thisArg, _arguments || [])).next());\n    });\n};\nvar __generator = (this && this.__generator) || function (thisArg, body) {\n    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === \"function\" ? Iterator : Object).prototype);\n    return g.next = verb(0), g[\"throw\"] = verb(1), g[\"return\"] = verb(2), typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\n    function verb(n) { return function (v) { return step([n, v]); }; }\n    function step(op) {\n        if (f) throw new TypeError(\"Generator is already executing.\");\n        while (g && (g = 0, op[0] && (_ = 0)), _) try {\n            if (f = 1, y && (t = op[0] & 2 ? y[\"return\"] : op[0] ? y[\"throw\"] || ((t = y[\"return\"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;\n            if (y = 0, t) op = [op[0] & 2, t.value];\n            switch (op[0]) {\n                case 0: case 1: t = op; break;\n                case 4: _.label++; return { value: op[1], done: false };\n                case 5: _.label++; y = op[1]; op = [0]; continue;\n                case 7: op = _.ops.pop(); _.trys.pop(); continue;\n                default:\n                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\n                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\n                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\n                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\n                    if (t[2]) _.ops.pop();\n                    _.trys.pop(); continue;\n            }\n            op = body.call(thisArg, _);\n        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\n        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\n    }\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.clip = exports.renderingDuration = exports.totalPatternDuration = exports.recursivelyApplyPatternToDurations = exports.getDuration = exports.getNote = void 0;\nvar utils_1 = require(\"./utils\");\n// import { window } from './window';\n// if (!(window as any).Tone) {\n//   (window as any).Tone = Tone;\n// }\n// const tone = (window as any).Tone;\n// const tone = Tone || (window as any).Tone;\nvar defaultSubdiv = '4n';\nvar defaultDur = '8n';\n/**\n * Get default params for a clip, such as root note, pattern etc\n * @return {Object}\n */\nvar getDefaultParams = function () { return ({\n    notes: ['C4'],\n    pattern: 'x',\n    shuffle: false,\n    sizzle: false,\n    sizzleReps: 1,\n    arpegiate: false,\n    subdiv: '4n',\n    align: '1m',\n    alignOffset: '0',\n    amp: 100,\n    accentLow: 70,\n    randomNotes: null,\n    offlineRendering: false,\n}); };\n/* UNUSED *\n * HDR speed is denoted by the number of ticks per note\n * By default this is set to a quarter note (4n) to be in line with Tone.js' default subdivision\n * Technically a bar is 512 ticks long. So it's HDR speed is 512\n * @type {Object}\n * /\nconst hdr: NVP<number> = {\n  '1m': 2048,\n  '2m': 4096,\n  '3m': 6144,\n  '4m': 8192,\n  '1n': 512,\n  '2n': 256,\n  '4n': 128,\n  '8n': 64,\n  '16n': 32,\n};\n/* */\nvar getNote = function (el, params, counter) {\n    if (el === 'R' && params.randomNotes && params.randomNotes.length > 0) {\n        return params.randomNotes[(0, utils_1.randomInt)(params.randomNotes.length - 1)];\n    }\n    if (params.notes) {\n        return params.notes[counter % (params.notes.length || 1)];\n    }\n    return '';\n};\nexports.getNote = getNote;\nvar getDuration = function (params, counter) {\n    return params.durations\n        ? params.durations[counter % params.durations.length]\n        : params.dur || params.subdiv || defaultDur;\n};\nexports.getDuration = getDuration;\nvar recursivelyApplyPatternToDurations = function (patternArr, length, durations) {\n    if (durations === void 0) { durations = []; }\n    patternArr.forEach(function (char) {\n        if (typeof char === 'string') {\n            if (char === 'x' || char === 'R') {\n                durations.push(length);\n            }\n            if (char === '_' && durations.length) {\n                durations[durations.length - 1] += length;\n            }\n        }\n        if (Array.isArray(char)) {\n            (0, exports.recursivelyApplyPatternToDurations)(char, length / char.length, durations);\n        }\n    });\n    return durations;\n};\nexports.recursivelyApplyPatternToDurations = recursivelyApplyPatternToDurations;\nvar generateSequence = function (params, channel, context) {\n    context = context || Tone.getContext();\n    if (!params.pattern) {\n        throw new Error('No pattern provided!');\n    }\n    if (!params.durations && !params.dur) {\n        params.durations = (0, exports.recursivelyApplyPatternToDurations)((0, utils_1.expandStr)(params.pattern), Tone.Ticks(params.subdiv || defaultSubdiv).toSeconds());\n    }\n    return new Tone.Sequence({\n        callback: channel.getSeqFn(params),\n        events: (0, utils_1.expandStr)(params.pattern),\n        subdivision: params.subdiv || defaultSubdiv,\n        context: context,\n    });\n};\nvar totalPatternDuration = function (pattern, subdivOrLength) {\n    return typeof subdivOrLength === 'number'\n        ? subdivOrLength * (0, utils_1.expandStr)(pattern).length\n        : Tone.Ticks(subdivOrLength).toSeconds() * (0, utils_1.expandStr)(pattern).length;\n};\nexports.totalPatternDuration = totalPatternDuration;\nvar leastCommonMultiple = function (n1, n2) {\n    var _a = n1 < n2 ? [n1, n2] : [n2, n1], smallest = _a[0], largest = _a[1];\n    var i = largest;\n    while (i % smallest !== 0) {\n        i += largest;\n    }\n    return i;\n};\nvar renderingDuration = function (pattern, subdivOrLength, notes, randomNotes) {\n    var patternRegularNotesCount = pattern.split('').filter(function (c) {\n        return c === 'x';\n    }).length;\n    var patternRandomNotesCount = pattern.split('').filter(function (c) {\n        return c === 'R';\n    }).length;\n    var patternNotesCount = (randomNotes === null || randomNotes === void 0 ? void 0 : randomNotes.length)\n        ? patternRegularNotesCount\n        : patternRegularNotesCount + patternRandomNotesCount;\n    var notesCount = notes.length || 1;\n    return (((0, exports.totalPatternDuration)(pattern, subdivOrLength) / patternNotesCount) *\n        leastCommonMultiple(notesCount, patternNotesCount));\n};\nexports.renderingDuration = renderingDuration;\nvar ongoingRenderingCounter = 0;\nvar originalContext;\nvar offlineRenderClip = function (params, duration) {\n    if (!originalContext) {\n        originalContext = Tone.getContext();\n    }\n    ongoingRenderingCounter++;\n    var player = new Tone.Player({ context: originalContext, loop: true });\n    Tone.Offline(function (context) { return __awaiter(void 0, void 0, void 0, function () {\n        var sequence;\n        return __generator(this, function (_a) {\n            switch (_a.label) {\n                case 0:\n                    sequence = generateSequence(params, context);\n                    return [4 /*yield*/, Tone.loaded()];\n                case 1:\n                    _a.sent();\n                    sequence.start();\n                    context.transport.start();\n                    return [2 /*return*/];\n            }\n        });\n    }); }, duration).then(function (buffer) {\n        var _a;\n        player.buffer = buffer;\n        ongoingRenderingCounter--;\n        if (ongoingRenderingCounter === 0) {\n            Tone.setContext(originalContext);\n            (_a = params.offlineRenderingCallback) === null || _a === void 0 ? void 0 : _a.call(params);\n        }\n    });\n    player.toDestination();\n    player.sync();\n    return player;\n};\n/**\n * @param  {Object}\n * @return {Tone.js Sequence Object}\n * Take a object literal that may have a Tone.js player OR instrument\n * or simply a sample or synth with a pattern and return a Tone.js sequence\n */\nvar clip = function (params, channel) {\n    params = __assign(__assign({}, getDefaultParams()), (params || {}));\n    // If notes is a string, split it into an array\n    if (typeof params.notes === 'string') {\n        // Remove any accidental double spaces\n        params.notes = params.notes.replace(/\\s{2,}/g, ' ');\n        params.notes = params.notes.split(' ');\n    }\n    params.notes = params.notes ? params.notes.map(utils_1.convertChordsToNotes) : [];\n    if (/[^x\\-_[\\]R]/.test(params.pattern)) {\n        throw new TypeError(\"pattern can only comprise x - _ [ ] R, found \".concat(params.pattern));\n    }\n    if (params.shuffle) {\n        params.notes = (0, utils_1.shuffle)(params.notes);\n    }\n    if (params.randomNotes && typeof params.randomNotes === 'string') {\n        params.randomNotes = params.randomNotes.replace(/\\s{2,}/g, ' ').split(/\\s/);\n    }\n    if (params.randomNotes) {\n        params.randomNotes = params.randomNotes.map(utils_1.convertChordsToNotes);\n    }\n    if (params.offlineRendering) {\n        return offlineRenderClip(params, (0, exports.renderingDuration)(params.pattern, params.subdiv || defaultSubdiv, params.notes, params.randomNotes));\n    }\n    return generateSequence(params, channel, originalContext);\n};\nexports.clip = clip;\n","\"use strict\";\nvar __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    var desc = Object.getOwnPropertyDescriptor(m, k);\n    if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\n      desc = { enumerable: true, get: function() { return m[k]; } };\n    }\n    Object.defineProperty(o, k2, desc);\n}) : (function(o, m, k, k2) {\n    if (k2 === undefined) k2 = k;\n    o[k2] = m[k];\n}));\nvar __exportStar = (this && this.__exportStar) || function(m, exports) {\n    for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.Session = exports.midi = exports.arp = exports.progression = exports.getChordsByProgression = exports.getChordDegrees = exports.clip = exports.chords = exports.chord = exports.modes = exports.scales = exports.mode = exports.scale = void 0;\nvar harmonics_1 = require(\"harmonics\");\nObject.defineProperty(exports, \"scales\", { enumerable: true, get: function () { return harmonics_1.scales; } });\nObject.defineProperty(exports, \"modes\", { enumerable: true, get: function () { return harmonics_1.scales; } });\nObject.defineProperty(exports, \"chords\", { enumerable: true, get: function () { return harmonics_1.chords; } });\nObject.defineProperty(exports, \"scale\", { enumerable: true, get: function () { return harmonics_1.scale; } });\nObject.defineProperty(exports, \"mode\", { enumerable: true, get: function () { return harmonics_1.scale; } });\nObject.defineProperty(exports, \"chord\", { enumerable: true, get: function () { return harmonics_1.chord; } });\nvar browser_clip_1 = require(\"./browser-clip\");\nObject.defineProperty(exports, \"clip\", { enumerable: true, get: function () { return browser_clip_1.clip; } });\nvar progression_1 = require(\"./progression\");\nObject.defineProperty(exports, \"getChordDegrees\", { enumerable: true, get: function () { return progression_1.getChordDegrees; } });\nObject.defineProperty(exports, \"getChordsByProgression\", { enumerable: true, get: function () { return progression_1.getChordsByProgression; } });\nObject.defineProperty(exports, \"progression\", { enumerable: true, get: function () { return progression_1.progression; } });\nvar arp_1 = require(\"./arp\");\nObject.defineProperty(exports, \"arp\", { enumerable: true, get: function () { return arp_1.arp; } });\nvar midi_1 = require(\"./midi\");\nObject.defineProperty(exports, \"midi\", { enumerable: true, get: function () { return midi_1.midi; } });\nvar session_1 = require(\"./session\");\nObject.defineProperty(exports, \"Session\", { enumerable: true, get: function () { return session_1.Session; } });\n__exportStar(require(\"./types\"), exports);\n","\"use strict\";\nvar __assign = (this && this.__assign) || function () {\n    __assign = Object.assign || function(t) {\n        for (var s, i = 1, n = arguments.length; i < n; i++) {\n            s = arguments[i];\n            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))\n                t[p] = s[p];\n        }\n        return t;\n    };\n    return __assign.apply(this, arguments);\n};\nvar __rest = (this && this.__rest) || function (s, e) {\n    var t = {};\n    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\n        t[p] = s[p];\n    if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\n        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\n            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\n                t[p[i]] = s[p[i]];\n        }\n    return t;\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.Channel = void 0;\nvar browser_clip_1 = require(\"./browser-clip\");\nvar utils_1 = require(\"./utils\");\n/**\n * Get the next logical position to play in the session\n * Tone has a build-in method `Tone.Transport.nextSubdivision('4n')`\n * but I think it s better to round off as follows for live performance\n */\nvar getNextPos = function (clip) {\n    // TODO: (soon) convert to using transportPosTicks (fewer computations)\n    var arr = Tone.Transport.position.split(':');\n    // If we are still around 0:0:0x, then set start position to 0\n    if (arr[0] === '0' && arr[1] === '0') {\n        return 0;\n    }\n    // Else set it to the next bar\n    var transportPosTicks = Tone.Transport.ticks;\n    var align = (clip === null || clip === void 0 ? void 0 : clip.align) || '1m';\n    var alignOffset = (clip === null || clip === void 0 ? void 0 : clip.alignOffset) || '0';\n    var alignTicks = Tone.Ticks(align).toTicks();\n    var alignOffsetTicks = Tone.Ticks(alignOffset).toTicks();\n    var nextPosTicks = Tone.Ticks(Math.floor(transportPosTicks / alignTicks + 1) * alignTicks +\n        alignOffsetTicks);\n    // const nextPosBBS = nextPosTicks.toBarsBeatsSixteenths();\n    // return nextPosBBS; // Extraneous computations\n    return nextPosTicks;\n};\n/**\n * Channel\n * A channel is made up of a Tone.js Player/Instrument, one or more\n * Tone.js sequences (known as clips in Scribbletune)\n * & optionally a set of effects (with or without presets)\n *\n * API:\n * clips -> Get all clips for this channel\n * addClip -> Add a new clip to the channel\n * startClip -> Start a clip at the provided index\n * stopClip -> Stop a clip at the provided index\n * activeClipIdx -> Get the clip that is currently playing\n */\nvar Channel = /** @class */ (function () {\n    function Channel(params) {\n        var _this = this;\n        this.idx = params.idx || 0;\n        this.name = params.name || 'ch ' + params.idx;\n        this.activePatternIdx = -1;\n        this.channelClips = [];\n        this.clipNoteCount = 0;\n        // Filter out unrequired params and create clip params object\n        // eslint-disable-next-line @typescript-eslint/no-unused-vars\n        var clips = params.clips, samples = params.samples, sample = params.sample, synth = params.synth, params1 = __rest(params, [\"clips\", \"samples\", \"sample\", \"synth\"]);\n        // eslint-disable-next-line @typescript-eslint/no-unused-vars\n        var external = params1.external, sampler = params1.sampler, buffer = params1.buffer, params2 = __rest(params1, [\"external\", \"sampler\", \"buffer\"]);\n        // eslint-disable-next-line @typescript-eslint/no-unused-vars\n        var player = params2.player, instrument = params2.instrument, volume = params2.volume, params3 = __rest(params2, [\"player\", \"instrument\", \"volume\"]);\n        // eslint-disable-next-line @typescript-eslint/no-unused-vars\n        var eventCb = params3.eventCb, playerCb = params3.playerCb, effects = params3.effects, params4 = __rest(params3, [\"eventCb\", \"playerCb\", \"effects\"]);\n        var _a = params4.context, context = _a === void 0 ? Tone.getContext() : _a, originalParamsFiltered = __rest(params4, [\"context\"]);\n        this.eventCbFn = eventCb;\n        this.playerCbFn = playerCb;\n        // Async section\n        this.hasLoaded = false;\n        this.hasFailed = false;\n        this.initializerTask = this.initOutputProducer(context, params).then(function () {\n            return _this.initInstrument(context, params).then(function () {\n                return _this.adjustInstrument(context, params).then(function () {\n                    return _this.initEffects(context, params);\n                });\n            });\n        });\n        // End Async section\n        // Sync section\n        var clipsFailed = false;\n        try {\n            params.clips.forEach(function (c, i) {\n                try {\n                    _this.addClip(__assign(__assign({}, c), originalParamsFiltered));\n                }\n                catch (e) {\n                    // Annotate the error with Clip info\n                    throw new Error(\"\".concat((0, utils_1.errorHasMessage)(e) ? e.message : e, \" in clip \").concat(i + 1));\n                }\n            }, this);\n        }\n        catch (e) {\n            clipsFailed = e; // Stash the error\n        }\n        // End Sync section\n        // Reconcile sync section with async section\n        this.initializerTask\n            .then(function () {\n            if (clipsFailed) {\n                throw clipsFailed;\n            }\n            _this.hasLoaded = true;\n            _this.eventCb('loaded', {}); // Report async load completion.\n        })\n            .catch(function (e) {\n            _this.hasFailed = e;\n            _this.eventCb('error', { e: e }); // Report async errors.\n        });\n    }\n    Channel.setTransportTempo = function (valueBpm) {\n        Tone.Transport.bpm.value = valueBpm;\n    };\n    Channel.startTransport = function () {\n        Tone.start();\n        Tone.Transport.start();\n    };\n    Channel.stopTransport = function (deleteEvents) {\n        if (deleteEvents === void 0) { deleteEvents = true; }\n        Tone.Transport.stop();\n        if (deleteEvents) {\n            // Delete all events in the Tone.Transport\n            Tone.Transport.cancel();\n        }\n    };\n    Channel.prototype.setVolume = function (volume) {\n        // ? this.volume = volume;\n        var _a, _b;\n        // Change volume of the player\n        // if (this.player) {\n        //   this.player.volume.value = volume;\n        // }\n        // Change volume of the sampler\n        // if (this.sampler) {\n        //   this.sampler.volume.value = volume;\n        // }\n        // Change volume of the instrument\n        if (this.instrument) {\n            this.instrument.volume.value = volume;\n        }\n        // Change volume of the external\n        if (this.external) {\n            (_b = (_a = this.external).setVolume) === null || _b === void 0 ? void 0 : _b.call(_a, volume);\n        }\n    };\n    Channel.prototype.startClip = function (idx, position) {\n        var _this = this;\n        var clip = this.channelClips[idx];\n        position = position || (position === 0 ? 0 : getNextPos(clip));\n        // Stop any other currently running clip\n        if (this.activePatternIdx > -1 && this.activePatternIdx !== idx) {\n            this.stopClip(this.activePatternIdx, position);\n        }\n        if (clip && clip.state !== 'started') {\n            // We need to schedule that for just before when clip?.start(position) events start coming.\n            this.counterResetTask = Tone.Transport.scheduleOnce(function ( /* time: Tone.Seconds */) {\n                _this.clipNoteCount = 0;\n            }, position);\n            this.activePatternIdx = idx;\n            // clip?.stop(position); // DEBUG: trying to clear out start/stop events\n            // clip?.clear(position); // DEBUG: trying to clear out events\n            clip === null || clip === void 0 ? void 0 : clip.start(position);\n        }\n    };\n    Channel.prototype.stopClip = function (idx, position) {\n        var clip = this.channelClips[idx];\n        position = position || (position === 0 ? 0 : getNextPos(clip));\n        clip === null || clip === void 0 ? void 0 : clip.stop(position);\n        if (idx === this.activePatternIdx) {\n            this.activePatternIdx = -1;\n        }\n    };\n    Channel.prototype.addClip = function (clipParams, idx) {\n        var _this = this;\n        idx = idx || this.channelClips.length;\n        if (clipParams.pattern) {\n            this.channelClips[idx] = (0, browser_clip_1.clip)(__assign({}, clipParams), this);\n            // Pass certain clipParams into getNextPos()\n            ['align', 'alignOffset'].forEach(function (key) {\n                if (clipParams[key]) {\n                    _this.channelClips[idx][key] = clipParams[key];\n                }\n            });\n        }\n        else {\n            // Allow creation of empty clips\n            this.channelClips[idx] = null;\n        }\n    };\n    /**\n     * @param  {Object} ClipParams clip parameters\n     * @return {Function} function that can be used as the callback in Tone.Sequence https://tonejs.github.io/docs/Sequence\n     */\n    Channel.prototype.getSeqFn = function (params) {\n        var _this = this;\n        if (this.external) {\n            return function (time, el) {\n                var _a, _b;\n                if (el === 'x' || el === 'R') {\n                    var counter = _this.clipNoteCount;\n                    if (_this.hasLoaded) {\n                        var note = (0, browser_clip_1.getNote)(el, params, counter)[0];\n                        var duration = (0, browser_clip_1.getDuration)(params, counter);\n                        var durSeconds = Tone.Time(duration).toSeconds();\n                        _this.playerCb({ note: note, duration: duration, time: time, counter: counter });\n                        try {\n                            (_b = (_a = _this.external).triggerAttackRelease) === null || _b === void 0 ? void 0 : _b.call(_a, note, durSeconds, time);\n                        }\n                        catch (e) {\n                            _this.eventCb('error', { e: e }); // Report play errors.\n                        }\n                    }\n                    _this.clipNoteCount++;\n                }\n            };\n        }\n        else if (this.instrument instanceof Tone.Player) {\n            return function (time, el) {\n                if (el === 'x' || el === 'R') {\n                    var counter = _this.clipNoteCount;\n                    if (_this.hasLoaded) {\n                        _this.playerCb({ note: '', duration: '', time: time, counter: counter });\n                        try {\n                            _this.instrument.start(time);\n                        }\n                        catch (e) {\n                            _this.eventCb('error', { e: e }); // Report play errors.\n                        }\n                    }\n                    _this.clipNoteCount++;\n                }\n            };\n        }\n        else if (this.instrument instanceof Tone.PolySynth ||\n            this.instrument instanceof Tone.Sampler) {\n            return function (time, el) {\n                if (el === 'x' || el === 'R') {\n                    var counter = _this.clipNoteCount;\n                    if (_this.hasLoaded) {\n                        var note = (0, browser_clip_1.getNote)(el, params, counter);\n                        var duration = (0, browser_clip_1.getDuration)(params, counter);\n                        _this.playerCb({ note: note, duration: duration, time: time, counter: counter });\n                        try {\n                            _this.instrument.triggerAttackRelease(note, duration, time);\n                        }\n                        catch (e) {\n                            _this.eventCb('error', { e: e }); // Report play errors.\n                        }\n                    }\n                    _this.clipNoteCount++;\n                }\n            };\n        }\n        else if (this.instrument instanceof Tone.NoiseSynth) {\n            return function (time, el) {\n                if (el === 'x' || el === 'R') {\n                    var counter = _this.clipNoteCount;\n                    if (_this.hasLoaded) {\n                        var duration = (0, browser_clip_1.getDuration)(params, counter);\n                        _this.playerCb({ note: '', duration: duration, time: time, counter: counter });\n                        try {\n                            _this.instrument.triggerAttackRelease(duration, time);\n                        }\n                        catch (e) {\n                            _this.eventCb('error', { e: e }); // Report play errors.\n                        }\n                    }\n                    _this.clipNoteCount++;\n                }\n            };\n        }\n        else {\n            return function (time, el) {\n                if (el === 'x' || el === 'R') {\n                    var counter = _this.clipNoteCount;\n                    if (_this.hasLoaded) {\n                        var note = (0, browser_clip_1.getNote)(el, params, counter)[0];\n                        var duration = (0, browser_clip_1.getDuration)(params, counter);\n                        _this.playerCb({ note: note, duration: duration, time: time, counter: counter });\n                        try {\n                            _this.instrument.triggerAttackRelease(note, duration, time);\n                        }\n                        catch (e) {\n                            _this.eventCb('error', { e: e }); // Report play errors.\n                        }\n                    }\n                    _this.clipNoteCount++;\n                }\n            };\n        }\n    };\n    Channel.prototype.eventCb = function (event, params) {\n        if (typeof this.eventCbFn === 'function') {\n            params.channel = this;\n            this.eventCbFn(event, params);\n        }\n    };\n    Channel.prototype.playerCb = function (params) {\n        if (typeof this.playerCbFn === 'function') {\n            params.channel = this;\n            this.playerCbFn(params);\n        }\n    };\n    /**\n     * Check Tone.js object loaded state and either invoke `resolve` right away, or attach to and wait using Tone onload cb.\n     * It's an ugly hack that reaches into Tone's internal ._buffers or ._buffer to insert itself into .onload() callback.\n     * Tone has different ways to pull the onload callback from within to the API, so this implementation is very brittle.\n     * The sole reason for its existence is to handle async loaded state of Tone instruments that we allow to pass in from outside.\n     * If that option is eliminated, then this hacky function can be killed (or re-implemented via public onload API)\n     * @param toneObject Tone.js object (will work with non-Tone objects that have same loaded/onload properties)\n     * @param resolve onload callback\n     */\n    Channel.prototype.checkToneObjLoaded = function (toneObject, resolve) {\n        var _this = this;\n        var skipRecursion = toneObject instanceof Tone.Sampler; // Sampler has a Map of ToneAudioBuffer, and our method to find inner .onload() does not work since there is no single one.\n        // eslint-disable-next-line no-prototype-builtins\n        if ('loaded' in toneObject) {\n            if (toneObject.loaded) {\n                resolve();\n                return;\n            }\n            if (skipRecursion) {\n                return;\n            }\n            // Try Recursion into inner objects:\n            var handled_1 = false;\n            ['buffer', '_buffer', '_buffers'].forEach(function (key) {\n                if (key in toneObject) {\n                    _this.checkToneObjLoaded(toneObject[key], resolve);\n                    handled_1 = true;\n                }\n            });\n            if (handled_1) {\n                return;\n            }\n        }\n        // Check object type if it has load/onload (and _buffers or _buffer), then call resolve()\n        // The list was created for Tone@14.8.0 by grepping and reviewing the source code.\n        // Known objecs to have:\n        var hasOnload = toneObject instanceof Tone.ToneAudioBuffer ||\n            toneObject instanceof Tone.ToneBufferSource ||\n            // Falback for \"future\" objects\n            ('loaded' in toneObject && 'onload' in toneObject);\n        if (!hasOnload) {\n            // console.log('resolve() for ch \"%o\" idx %o onload NOT FOUND', this.name, this.idx);\n            // This is not a good assumption. E.g. it does not work for Tone.ToneAudioBuffers\n            resolve();\n        }\n        else {\n            var oldOnLoad_1 = toneObject.onload;\n            toneObject.onload = function () {\n                if (oldOnLoad_1 && typeof oldOnLoad_1 === 'function') {\n                    toneObject.onload = oldOnLoad_1;\n                    oldOnLoad_1();\n                }\n                // console.log('resolve() for ch \"%o\" idx %o', this.name, this.idx);\n                resolve();\n            };\n        }\n    };\n    Channel.prototype.recreateToneObjectInContext = function (toneObject, // Tone.PolySynth | Tone.Player | Tone.Sampler | Tone['' | '']\n    context) {\n        var _this = this;\n        context = context || Tone.getContext();\n        // eslint-disable-next-line @typescript-eslint/no-unused-vars\n        return new Promise(function (resolve, reject) {\n            // Tone.PolySynth | Tone.Player | Tone.Sampler | Tone['' | '']\n            if (toneObject instanceof Tone.PolySynth) {\n                var newObj_1 = Tone.PolySynth(Tone[toneObject._dummyVoice.name], __assign(__assign({}, toneObject.get()), { context: context }));\n                _this.checkToneObjLoaded(newObj_1, function () { return resolve(newObj_1); });\n            }\n            else if (toneObject instanceof Tone.Player) {\n                var newObj_2 = Tone.Player({\n                    url: toneObject._buffer,\n                    context: context,\n                    onload: function () { return _this.checkToneObjLoaded(newObj_2, function () { return resolve(newObj_2); }); },\n                });\n            }\n            else if (toneObject instanceof Tone.Sampler) {\n                var _a = toneObject.get(), attack = _a.attack, curve = _a.curve, release = _a.release, volume = _a.volume;\n                var paramsFromSampler = {\n                    attack: attack,\n                    curve: curve,\n                    release: release,\n                    volume: volume,\n                };\n                var paramsFromBuffers = {\n                    baseUrl: toneObject._buffers.baseUrl,\n                    urls: Object.fromEntries(toneObject._buffers._buffers.entries()),\n                };\n                var newObj_3 = Tone.Sampler(__assign(__assign(__assign({}, paramsFromSampler), paramsFromBuffers), { context: context, onload: function () { return _this.checkToneObjLoaded(newObj_3, function () { return resolve(newObj_3); }); } }));\n            }\n            else {\n                var newObj_4 = Tone[toneObject.name](__assign(__assign({}, toneObject.get()), { context: context, onload: function () { return _this.checkToneObjLoaded(newObj_4, function () { return resolve(newObj_4); }); } }));\n                _this.checkToneObjLoaded(newObj_4, function () { return resolve(newObj_4); });\n            }\n        });\n    };\n    Channel.prototype.initOutputProducer = function (context, params) {\n        var _this = this;\n        context = context || Tone.getContext();\n        return new Promise(function (resolve, reject) {\n            /*\n             *  1. The params object can be used to pass a sample (sound source) OR a synth(Synth/FMSynth/AMSynth etc) or samples.\n             *  Scribbletune will then create a Tone.js Player or Tone.js Instrument or Tone.js Sampler respectively\n             *  2. It can also be used to pass a Tone.js Player object or instrument that was created elsewhere\n             *  (mostly by Scribbletune itself in the channel creation method)\n             **/\n            if (params.synth) {\n                if (params.instrument) {\n                    throw new Error('Either synth or instrument can be provided, but not both.');\n                }\n                if (params.synth.synth) {\n                    var synthName = params.synth.synth;\n                    //  const presetName = (params.synth as SynthParams).presetName; // Unused here\n                    var preset = params.synth.preset || {};\n                    _this.instrument = new Tone[synthName](__assign(__assign({}, preset), { context: context, \n                        // Use onload for cases when synthName calls out Tone.Sample/Player/Sampler.\n                        // It could be a universal way to load Tone.js instruments.\n                        onload: function () { return _this.checkToneObjLoaded(_this.instrument, resolve); } }));\n                    _this.checkToneObjLoaded(_this.instrument, resolve);\n                }\n                else {\n                    _this.instrument = params.synth; // TODO: This is dangerous by-reference assignment.\n                    console.warn('The \"synth\" parameter with instrument will be deprecated in the future. Please use the \"instrument\" parameter instead.');\n                    // params.synth describing the Tone[params.synth.synth] is allowed.\n                    _this.checkToneObjLoaded(_this.instrument, resolve);\n                }\n            }\n            else if (typeof params.instrument === 'string') {\n                _this.instrument = new Tone[params.instrument]({ context: context });\n                _this.checkToneObjLoaded(_this.instrument, resolve);\n            }\n            else if (params.instrument) {\n                _this.instrument = params.instrument; // TODO: This is dangerous by-reference assignment. Tone.instrument has context that holds all other instruments. Client side params get polluted with circular references. If params come from e.g. react-ApolloClient data, Apollo tools crash on circular references.\n                _this.checkToneObjLoaded(_this.instrument, resolve);\n            }\n            else if (params.sample || params.buffer) {\n                _this.instrument = new Tone.Player({\n                    url: params.sample || params.buffer,\n                    context: context,\n                    onload: function () { return _this.checkToneObjLoaded(_this.instrument, resolve); },\n                });\n            }\n            else if (params.samples) {\n                _this.instrument = new Tone.Sampler({\n                    urls: params.samples,\n                    context: context,\n                    onload: function () { return _this.checkToneObjLoaded(_this.instrument, resolve); },\n                });\n            }\n            else if (params.sampler) {\n                _this.instrument = params.sampler; // TODO: This is dangerous by-reference assignment.\n                _this.checkToneObjLoaded(_this.instrument, resolve);\n            }\n            else if (params.player) {\n                _this.instrument = params.player; // TODO: This is dangerous by-reference assignment.\n                _this.checkToneObjLoaded(_this.instrument, resolve);\n            }\n            else if (params.external) {\n                _this.external = __assign({}, params.external); // Sanitize object by shallow clone\n                _this.instrument = {\n                    context: context,\n                    volume: { value: 0 },\n                };\n                // Do not call! this.checkToneObjLoaded(this.instrument, resolve);\n                if (params.external.init) {\n                    return params.external\n                        .init(context.rawContext)\n                        .then(function () {\n                        resolve();\n                    })\n                        .catch(function (e) {\n                        var _a;\n                        reject(new Error(\"\".concat(e.message, \" loading external output module of channel idx \").concat(_this.idx, \", \").concat((_a = _this.name) !== null && _a !== void 0 ? _a : '(no name)')));\n                    });\n                }\n                else {\n                    resolve();\n                }\n            }\n            else {\n                throw new Error('One of required synth|instrument|sample|sampler|samples|buffer|player|external is not provided!');\n            }\n            if (!_this.instrument) {\n                throw new Error('Failed instantiating instrument from given params.');\n            }\n        });\n    };\n    Channel.prototype.initInstrument = function (context, params) {\n        var _this = this;\n        var _a;\n        context = context || Tone.getContext();\n        if (!params.external && ((_a = this.instrument) === null || _a === void 0 ? void 0 : _a.context) !== context) {\n            return this.recreateToneObjectInContext(this.instrument, context).then(function (newObj) {\n                _this.instrument = newObj;\n            });\n        }\n        else {\n            // Nothing to do\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            return new Promise(function (resolve, reject) {\n                resolve();\n            });\n        }\n    };\n    Channel.prototype.adjustInstrument = function (context, params) {\n        var _this = this;\n        context = context || Tone.getContext();\n        // eslint-disable-next-line @typescript-eslint/no-unused-vars\n        return new Promise(function (resolve, reject) {\n            if (params.volume) {\n                // this.instrument.volume.value = params.volume;\n                _this.setVolume(params.volume);\n            }\n            resolve();\n        });\n    };\n    Channel.prototype.initEffects = function (context, params) {\n        var _this = this;\n        context = context || Tone.getContext();\n        var createEffect = function (effect) {\n            // eslint-disable-next-line @typescript-eslint/no-unused-vars\n            return new Promise(function (resolve, reject) {\n                if (typeof effect === 'string') {\n                    resolve(new Tone[effect]({ context: context }));\n                }\n                else if (effect.context !== context) {\n                    return _this.recreateToneObjectInContext(effect, context);\n                }\n                else {\n                    resolve(effect);\n                }\n            }).then(function (effectOut) {\n                return effectOut.toDestination();\n            });\n        };\n        var startEffect = function (eff) {\n            return typeof eff.start === 'function' ? eff.start() : eff;\n        };\n        var toArray = function (someVal) {\n            if (!someVal) {\n                return [];\n            }\n            if (Array.isArray(someVal)) {\n                return someVal;\n            }\n            return [someVal];\n        };\n        var effectsIn = toArray(params.effects);\n        if (params.external) {\n            if (effectsIn.length !== 0) {\n                throw new Error('Effects cannot be used with external output');\n            }\n            return Promise.resolve();\n        }\n        // effects = params.effects.map(createEffect).map(startEffect);\n        return Promise.all(effectsIn.map(createEffect))\n            .then(function (results) { return results.map(startEffect); })\n            .then(function (effects) {\n            var _a;\n            (_a = _this.instrument).chain.apply(_a, effects).toDestination();\n        });\n    };\n    Object.defineProperty(Channel.prototype, \"clips\", {\n        get: function () {\n            return this.channelClips;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    Object.defineProperty(Channel.prototype, \"activeClipIdx\", {\n        get: function () {\n            return this.activePatternIdx;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    return Channel;\n}());\nexports.Channel = Channel;\n","\"use strict\";\n// global LiveAPI:true\nvar __importDefault = (this && this.__importDefault) || function (mod) {\n    return (mod && mod.__esModule) ? mod : { \"default\": mod };\n};\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.midi = void 0;\nvar fs_1 = __importDefault(require(\"fs\"));\nvar midi_1 = require(\"@scribbletune/midi\");\n/**\n * Take an array of note objects to generate a MIDI file in the same location as this method is called\n * @param  {NoteObject[]} notes    Notes are in the format: {note: ['c3'], level: 127, length: 64}\n * @param  {String | null} fileName If a filename is not provided, then `music.mid` is used by default\n * If `null` is passed for `fileName`, bytes are returned instead of creating a file\n * If this method is called from a browser then it will return a HTML link that you can append in your page\n * This link will enable the generated MIDI as a downloadable file.\n * @param {Number | null} bpm If a value is provided, the generated midi file will be set to this bpm value.\n */\nvar midi = function (notes, fileName, bpm) {\n    if (fileName === void 0) { fileName = 'music.mid'; }\n    var file = createFileFromNotes(notes, bpm);\n    var bytes = file.toBytes();\n    if (fileName === null) {\n        return bytes;\n    }\n    if (!fileName.endsWith('.mid')) {\n        fileName = fileName + '.mid';\n    }\n    if (typeof window !== 'undefined' &&\n        window.URL &&\n        typeof window.URL.createObjectURL === 'function') {\n        return createDownloadLink(bytes, fileName);\n    }\n    fs_1.default.writeFileSync(fileName, bytes, 'binary');\n    console.log(\"MIDI file generated: \".concat(fileName, \".\"));\n};\nexports.midi = midi;\n/**\n * Create a downloadable link\n * @param b\n */\nvar createDownloadLink = function (b, fileName) {\n    // Convert bytes to array buffer\n    // Accepted answer on https://stackoverflow.com/questions/35038884/download-file-from-bytes-in-javascript\n    var bytes = new Uint8Array(b.length);\n    for (var i = 0; i < b.length; i++) {\n        var ascii = b.charCodeAt(i);\n        bytes[i] = ascii;\n    }\n    // Create a Blob so that we can set it up with the type of file we want (for eg MIDI)\n    var blob = new Blob([bytes], { type: 'audio/midi' });\n    // Create a link element to be used (you can use an existing link on the page as well)\n    var link = document.createElement('a');\n    link.href =\n        (typeof window !== 'undefined' &&\n            typeof window.URL !== 'undefined' &&\n            typeof window.URL.createObjectURL !== 'undefined' &&\n            window.URL.createObjectURL(blob)) ||\n            '';\n    // Give the downloadable file a name\n    link.download = fileName;\n    link.innerText = 'Download MIDI file';\n    return link;\n};\nvar createFileFromNotes = function (notes, bpm) {\n    var file = new midi_1.File();\n    var track = new midi_1.Track();\n    // set the track's bpm if it is provided\n    if (typeof bpm === 'number') {\n        track.setTempo(bpm);\n    }\n    file.addTrack(track);\n    for (var _i = 0, notes_1 = notes; _i < notes_1.length; _i++) {\n        var noteObj = notes_1[_i];\n        var level = noteObj.level || 127;\n        // While writing chords (multiple notes per tick)\n        // only the first noteOn (or noteOff) needs the complete arity of the function call\n        // subsequent calls need only the first 2 args (channel and note)\n        if (noteObj.note) {\n            if (typeof noteObj.note === 'string') {\n                track.noteOn(0, noteObj.note, noteObj.length, level); // channel, pitch(note), length, velocity\n                track.noteOff(0, noteObj.note, noteObj.length, level);\n            }\n            else {\n                track.addChord(0, noteObj.note, noteObj.length, level);\n            }\n        }\n        else {\n            track.noteOff(0, '', noteObj.length);\n        }\n    }\n    return file;\n};\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.progression = exports.getChordsByProgression = exports.getChordDegrees = void 0;\nvar harmonics_1 = require(\"harmonics\");\nvar utils_1 = require(\"./utils\");\n/**\n * Get the chords that go with a given scale/mode\n * This is useful only in case you want to check what chords work with a scale/mode\n * so that you can come up with chord progressions\n * @param  {String} mode e.g. major\n * @return {Array} e.g.['I', 'ii', 'iii', 'IV', 'V', 'vi', 'vii°']\n */\nvar getChordDegrees = function (mode) {\n    var theRomans = {\n        ionian: ['I', 'ii', 'iii', 'IV', 'V', 'vi', 'vii°'],\n        dorian: ['i', 'ii', 'III', 'IV', 'v', 'vi°', 'VII'],\n        phrygian: ['i', 'II', 'III', 'iv', 'v°', 'VI', 'vii'],\n        lydian: ['I', 'II', 'iii', 'iv°', 'V', 'vi', 'vii'],\n        mixolydian: ['I', 'ii', 'iii°', 'IV', 'v', 'vi', 'VII'],\n        aeolian: ['i', 'ii°', 'III', 'iv', 'v', 'VI', 'VII'],\n        locrian: ['i°', 'II', 'iii', 'iv', 'V', 'VI', 'vii'],\n        'melodic minor': ['i', 'ii', 'III+', 'IV', 'V', 'vi°', 'vii°'],\n        'harmonic minor': ['i', 'ii°', 'III+', 'iv', 'V', 'VI', 'vii°'],\n    };\n    theRomans.major = theRomans.ionian;\n    theRomans.minor = theRomans.aeolian;\n    return theRomans[mode] || [];\n};\nexports.getChordDegrees = getChordDegrees;\nvar idxByDegree = {\n    i: 0,\n    ii: 1,\n    iii: 2,\n    iv: 3,\n    v: 4,\n    vi: 5,\n    vii: 6,\n};\n/**\n * Get a chord name from degree\n * @param  {String} roman e.g. ii OR ii° OR V7\n * @return {String} e.g. m OR m7b5 OR Maj7\n */\nvar getChordName = function (roman) {\n    // remove any non character\n    var str = roman.replace(/\\W/g, '');\n    var prefix = 'M';\n    // check if it s lowercase\n    if (str.toLowerCase() === str) {\n        prefix = 'm';\n    }\n    if (roman.indexOf('°') > -1) {\n        return prefix + '7b5';\n    }\n    if (roman.indexOf('+') > -1) {\n        return prefix + '#5';\n    }\n    if (roman.indexOf('7') > -1) {\n        return prefix === 'M' ? 'maj7' : 'm7';\n    }\n    return prefix;\n};\n/**\n * Take the specified scale and degrees and return the chord names for them\n * These can be used as the value for the `notes` param of the `clip` method\n * @param {String} noteOctaveScale e.g. 'C4 major'\n * @param  {String} chordDegress e.g. 'I IV V IV'\n * @return {String} e.g. 'CM FM GM FM'\n */\nvar getChordsByProgression = function (noteOctaveScale, chordDegress) {\n    // Set the octave if missing\n    // For example if the method was called with `C major` instead of `C4 major`, then add the 4\n    var noteOctaveScaleArr = noteOctaveScale.split(' ');\n    if (!noteOctaveScaleArr[0].match(/\\d/)) {\n        noteOctaveScaleArr[0] += '4';\n        noteOctaveScale = noteOctaveScaleArr.join(' ');\n    }\n    // Get the scale from the given note and scale/mode combination\n    var mode = (0, harmonics_1.scale)(noteOctaveScale);\n    var chordDegreesArr = chordDegress.replace(/\\s*,+\\s*/g, ' ').split(' ');\n    // Now we have something like ['i', 'ii', 'IV']\n    // Convert it to a chord family such as ['Cm', 'Dm', 'FM']\n    var chordFamily = chordDegreesArr.map(function (roman) {\n        var chordName = getChordName(roman); // e.g. m\n        // get the index to be used by removing any digit or non alphabet character\n        var scaleId = idxByDegree[roman.replace(/\\W|\\d/g, '').toLowerCase()]; // e.g. 0\n        // get the note itself\n        var note = mode[scaleId]; // e.g. C\n        // get the octave of the note;\n        var oct = note.replace(/\\D+/, ''); // e.g. 4\n        // now get the chord\n        return note.replace(/\\d/, '') + chordName + '_' + oct;\n    });\n    return chordFamily.toString().replace(/,/g, ' ');\n};\nexports.getChordsByProgression = getChordsByProgression;\nvar getProgFactory = function (_a) {\n    var T = _a.T, P = _a.P, D = _a.D;\n    return function (count) {\n        if (count === void 0) { count = 4; }\n        var chords = [];\n        // Push root/tonic\n        chords.push((0, utils_1.pickOne)(T));\n        var i = 1;\n        // Pick a predominant\n        if (i < count - 1) {\n            chords.push((0, utils_1.pickOne)(P));\n            i++;\n        }\n        // Try another predominant\n        if (i < count - 1 && (0, utils_1.dice)()) {\n            chords.push((0, utils_1.pickOne)(P));\n            i++;\n        }\n        // /////// 4 or more//////////\n        if (i < count - 1) {\n            // Pick a dominant\n            chords.push((0, utils_1.pickOne)(D));\n            i++;\n        }\n        if (i < count - 1) {\n            // Pick a predominant\n            chords.push((0, utils_1.pickOne)(P));\n            i++;\n        }\n        if (i < count - 1) {\n            // Pick a dominant\n            chords.push((0, utils_1.pickOne)(D));\n            i++;\n        }\n        // Pick a predominant if possible\n        if (i < count - 1 && (0, utils_1.dice)()) {\n            chords.push((0, utils_1.pickOne)(P));\n            i++;\n        }\n        // //////////////////////////\n        // Fill the rest with dominant\n        while (i < count) {\n            chords.push((0, utils_1.pickOne)(D));\n            i++;\n        }\n        return chords;\n    };\n};\nvar M = getProgFactory({ T: ['I', 'vi'], P: ['ii', 'IV'], D: ['V'] });\nvar m = getProgFactory({ T: ['i', 'VI'], P: ['ii', 'iv'], D: ['V'] });\n/**\n * Generate a chord progression based on basic music theory\n * where we follow tonic to optionally predominant and then dominant\n * and then randomly to predominant and continue this till we reach `count`\n * @param scaleType e.g. M (for major chord progression), m (for minor chord progression)\n * @param count e.g. 4\n */\nvar progression = function (scaleType, count) {\n    if (count === void 0) { count = 4; }\n    if (scaleType === 'major' || scaleType === 'M') {\n        return M(count);\n    }\n    if (scaleType === 'minor' || scaleType === 'm') {\n        return m(count);\n    }\n    return [];\n};\nexports.progression = progression;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.Session = void 0;\nvar channel_1 = require(\"./channel\");\nvar Session = /** @class */ (function () {\n    function Session(arr) {\n        var _this = this;\n        arr = arr || [];\n        this.sessionChannels = arr.map(function (ch, i) {\n            // Make sure ch.idx is not empty and unique in this.sessionChannels\n            ch.idx = ch.idx || i;\n            ch.idx = _this.uniqueIdx(_this.sessionChannels, ch.idx);\n            return new channel_1.Channel(ch);\n        });\n    }\n    // Return unique idx for given channels\n    Session.prototype.uniqueIdx = function (channels, idx) {\n        if (!channels) {\n            return idx || 0;\n        }\n        // Channel idx's\n        var idxs = channels.reduce(function (acc, c) {\n            return (!acc.find(function (i) { return i === c.idx; }) && acc.concat(c.idx)) || acc;\n        }, []);\n        if (!idx || idxs.find(function (i) { return i === idx; })) {\n            var newIdx_1 = channels.length;\n            while (idxs.find(function (i) { return i === newIdx_1; })) {\n                newIdx_1 = newIdx_1 + 1;\n            }\n            return newIdx_1;\n        }\n        return idx;\n    };\n    Session.prototype.createChannel = function (ch) {\n        // Make sure ch.idx is unique in this.sessionChannels\n        ch.idx = this.uniqueIdx(this.sessionChannels, ch.idx);\n        var newChannel = new channel_1.Channel(ch);\n        this.sessionChannels.push(newChannel);\n        return newChannel;\n    };\n    Object.defineProperty(Session.prototype, \"channels\", {\n        get: function () {\n            return this.sessionChannels;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    Session.prototype.setTransportTempo = function (valueBpm) {\n        channel_1.Channel.setTransportTempo(valueBpm);\n    };\n    Session.prototype.startTransport = function () {\n        channel_1.Channel.startTransport();\n    };\n    Session.prototype.stopTransport = function (deleteEvents) {\n        if (deleteEvents === void 0) { deleteEvents = true; }\n        channel_1.Channel.stopTransport(deleteEvents);\n    };\n    // Start the clips at a specific index in all the channels\n    Session.prototype.startRow = function (idx) {\n        this.sessionChannels.forEach(function (ch) {\n            ch.startClip(idx);\n        });\n    };\n    Session.prototype.play = function (params) {\n        var _this = this;\n        var channelPatterns = params.channelPatterns;\n        var clipDuration = params.clipDuration || '4:0:0';\n        var clipDurationInSeconds = Tone.Time(clipDuration).toSeconds();\n        var stopClips = function (clips, time) {\n            clips.forEach(function (c) { return c.stop(time); });\n        };\n        var startClips = function (channelIdx, clipIdx, time) {\n            return clipIdx === '-'\n                ? []\n                : _this.channels\n                    .filter(function (c) { return c.idx === channelIdx; })\n                    .map(function (c) { var _a; return (_a = c.clips[clipIdx]) === null || _a === void 0 ? void 0 : _a.start(time); });\n        };\n        channelPatterns.forEach(function (_a) {\n            var channelIdx = _a.channelIdx, pattern = _a.pattern;\n            var clips = [];\n            var time = 0;\n            var prevClipIdx = '-';\n            pattern.split('').forEach(function (clipIdx) {\n                if (clipIdx !== prevClipIdx && clipIdx !== '_') {\n                    stopClips(clips, time);\n                    clips = startClips(channelIdx, clipIdx, time);\n                }\n                prevClipIdx = clipIdx;\n                time += clipDurationInSeconds;\n            });\n            stopClips(clips, time);\n        });\n    };\n    return Session;\n}());\nexports.Session = Session;\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\n","\"use strict\";\nObject.defineProperty(exports, \"__esModule\", { value: true });\nexports.randomInt = exports.convertChordsToNotes = exports.convertChordToNotes = exports.errorHasMessage = exports.flat = exports.dice = exports.pickOne = exports.sizzleMap = exports.shuffle = exports.expandStr = exports.isNote = void 0;\nvar harmonics_1 = require(\"harmonics\");\n/**\n * Take a string input and check if it s a note name or not\n * @param  {String} str Note name e.g. c4\n * @return {Boolean} Return true for c4 or return false for something like CM\n */\nvar isNote = function (str) {\n    return /^[a-gA-G](?:#|b)?\\d$/.test(str);\n};\nexports.isNote = isNote;\n/**\n * Take a String input such as xxx[xx[xx]]\n * and return an Array as ['x', 'x', 'x', ['x', 'x', ['x', 'x']]]\n * @param  {String} str\n * @return {Array}\n */\nvar expandStr = function (str) {\n    str = JSON.stringify(str.split(''));\n    str = str.replace(/,\"\\[\",/g, ', [');\n    str = str.replace(/\"\\[\",/g, '[');\n    str = str.replace(/,\"\\]\"/g, ']');\n    return JSON.parse(str);\n};\nexports.expandStr = expandStr;\n/**\n * Basic Array randomizer\n * @param  {Array} arr\n * @param  {boolean} fullShuffle Ensure no elements remain in old place\n * @return {Array}\n */\nvar shuffle = function (arr, fullShuffle) {\n    if (fullShuffle === void 0) { fullShuffle = true; }\n    var lastIndex = arr.length - 1;\n    // Shuffle algorithm by Richard Durstenfeld (Donald E. Knuth), also Ronald Fisher and Frank Yates.\n    // \"Full Shuffle\" Modification to ensure no elements remain in their original place (by taking each element once\n    // and swapping with any remaining elements)\n    arr.forEach(function (el, idx) {\n        if (idx >= lastIndex) {\n            // No shuffling last element\n            // One before last is always swapped with last at the end of the loop\n            // Since previous swaps can move last element into other places, there is still a random shuffle of last element\n            return;\n        }\n        // Swap el with one of the higher elements randomly\n        var rnd = fullShuffle\n            ? // Pick random number from idx+1 to lastIndex (Modified algorithm, (N-1)! combinations)\n                // Math.random -> [0, 1) -> [0, lastIndex-idx ) --floor-> [0, lastIndex-idx-1]\n                // rnd = [0, lastIndex-idx-1] + 1 + idx = [1 + idx, lastIndex]\n                // (Original algorithm would pick rnd = [idx, lastIndex], thus any element could arrive back into its slot)\n                Math.floor(Math.random() * (lastIndex - idx)) + 1 + idx\n            : // Pick random number from idx to lastIndex (Unmodified Richard Durstenfeld, N! combinations)\n                Math.floor(Math.random() * (lastIndex + 1 - idx)) + idx;\n        arr[idx] = arr[rnd];\n        arr[rnd] = el;\n    });\n    return arr;\n};\nexports.shuffle = shuffle;\n/**\n * Return an array of numbers relative to maxLevel || 127 ordered in a Sine wave format\n * This is used by the `sizzle` param of the `clip` method to add a rudimentary variation to the accent of each note\n * @param {Number} maxLevel A number between not more than 127\n * @return {Array}  Example output [63, 90, 110, 127, 110, 90, 63, 0, 63, 90, 110, 127, 110, 90, 63, 0]\n */\nvar sizzleMap = function (maxLevel) {\n    if (maxLevel === void 0) { maxLevel = 127; }\n    var pi = Math.PI;\n    var piArr = [\n        pi / 6,\n        pi / 4,\n        pi / 3,\n        pi / 2,\n        (2 * pi) / 3,\n        (3 * pi) / 4,\n        (5 * pi) / 6,\n        pi,\n    ];\n    var piArrRev = [\n        0,\n        pi / 6,\n        pi / 4,\n        pi / 3,\n        pi / 2,\n        (2 * pi) / 3,\n        (3 * pi) / 4,\n        (5 * pi) / 6,\n    ];\n    piArrRev.reverse();\n    var arr = piArr.concat(piArrRev);\n    return arr.map(function (element) { return Math.round(Math.sin(element) * maxLevel); });\n};\nexports.sizzleMap = sizzleMap;\n/**\n * Pick one item randomly from an array and return it\n * @param arr\n */\nvar pickOne = function (arr) {\n    return arr.length > 1 ? arr[Math.round(Math.random())] : arr[0];\n};\nexports.pickOne = pickOne;\n/**\n * Boolean generator\n */\nvar dice = function () { return !!Math.round(Math.random()); };\nexports.dice = dice;\n/**\n * Polyfill for Array.prototype.flat\n */\nvar flat = function (arr) {\n    return arr.reduce(function (acc, val) { return acc.concat(val); }, []);\n};\nexports.flat = flat;\n// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types\nvar errorHasMessage = function (x) {\n    return typeof x.message === 'string';\n};\nexports.errorHasMessage = errorHasMessage;\n/**\n *  'el' could be an inlineChord() e.g. Cmaj7 or Dbsus2_5\n *  or a chord() e.g. 'C3 M'\n */\nvar convertChordToNotes = function (el) {\n    // Try both inlineChord() and chord()\n    var c1;\n    var c2;\n    var e1;\n    var e2;\n    try {\n        c1 = (0, harmonics_1.inlineChord)(el);\n    }\n    catch (e) {\n        e1 = e;\n    }\n    try {\n        c2 = (0, harmonics_1.chord)(el.replace(/_/g, ' ')); // chord() is not friendly to underscores\n    }\n    catch (e) {\n        e2 = e;\n    }\n    if (!e1 && !e2) {\n        // Both inlineChord() and chord() have result\n        if (c1.toString() !== c2.toString()) {\n            throw new Error(\"Chord \".concat(el, \" cannot decode, guessing \").concat(c1, \" or \").concat(c2));\n        }\n        return c1;\n    } // else\n    if (!e1) {\n        return c1;\n    } // else\n    if (!e2) {\n        return c2;\n    } // else\n    // Give up, last try:\n    return (0, harmonics_1.chord)(el);\n};\nexports.convertChordToNotes = convertChordToNotes;\nvar convertChordsToNotes = function (el) {\n    if (typeof el === 'string' && (0, exports.isNote)(el)) {\n        // A note needs to be an array so that it can accomodate chords or single notes with a single interface\n        return [el];\n    }\n    if (Array.isArray(el)) {\n        // This could be a chord provided as an array or an array of arrays\n        el.forEach(function (n) {\n            // This could be a chord provided as an array\n            if (Array.isArray(n)) {\n                // TODO: Can we convert it to something useful?\n                // make sure it uses valid notes\n                n.forEach(function (n1) {\n                    if (typeof n1 !== 'string' || !(0, exports.isNote)(n1)) {\n                        throw new TypeError('array of arrays must comprise valid notes');\n                    }\n                });\n                // throw new TypeError('cannot decode array of arrays');\n            }\n            else if (typeof n !== 'string' || !(0, exports.isNote)(n)) {\n                // make sure it uses valid notes\n                throw new TypeError('array must comprise valid notes');\n            }\n        });\n        return el;\n        // ? return el as (string | string[])[];\n    }\n    if (!Array.isArray(el)) {\n        var c = (0, exports.convertChordToNotes)(el);\n        if (c && c.length) {\n            return c;\n        }\n    }\n    throw new Error(\"Chord \".concat(el, \" not found\"));\n};\nexports.convertChordsToNotes = convertChordsToNotes;\nvar randomInt = function (num) {\n    if (num === void 0) { num = 1; }\n    return Math.round(Math.random() * num);\n};\nexports.randomInt = randomInt;\n","module.exports = require(\"fs\");","'use strict';\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\n// src/util.ts\nvar midi_letter_pitches = {\n  a: 21,\n  b: 23,\n  c: 12,\n  d: 14,\n  e: 16,\n  f: 17,\n  g: 19\n};\nvar midi_pitches_letter = {\n  \"12\": \"c\",\n  \"13\": \"c#\",\n  \"14\": \"d\",\n  \"15\": \"d#\",\n  \"16\": \"e\",\n  \"17\": \"f\",\n  \"18\": \"f#\",\n  \"19\": \"g\",\n  \"20\": \"g#\",\n  \"21\": \"a\",\n  \"22\": \"a#\",\n  \"23\": \"b\"\n};\nvar midi_flattened_notes = {\n  \"a#\": \"bb\",\n  \"c#\": \"db\",\n  \"d#\": \"eb\",\n  \"f#\": \"gb\",\n  \"g#\": \"ab\"\n};\nfunction midiPitchFromNote(n) {\n  const matches = /([a-g])(#+|b+)?([0-9]+)$/i.exec(n);\n  if (!matches) {\n    throw new Error(`Invalid note name: ${n}`);\n  }\n  const note = matches[1].toLowerCase();\n  const accidental = matches[2] || \"\";\n  const octave = parseInt(matches[3], 10);\n  return 12 * octave + midi_letter_pitches[note] + (accidental.substring(0, 1) === \"#\" ? 1 : -1) * accidental.length;\n}\nfunction ensureMidiPitch(p) {\n  if (typeof p === \"number\" || !/[^0-9]/.test(p)) {\n    return parseInt(String(p), 10);\n  }\n  return midiPitchFromNote(p);\n}\nfunction noteFromMidiPitch(n, returnFlattened) {\n  let octave = 0;\n  let noteNum = n;\n  if (n > 23) {\n    octave = Math.floor(n / 12) - 1;\n    noteNum = n - octave * 12;\n  }\n  let noteName = midi_pitches_letter[String(noteNum)];\n  if (!noteName) {\n    throw new Error(`Invalid MIDI pitch: ${n}`);\n  }\n  if (returnFlattened && noteName.indexOf(\"#\") > 0) {\n    noteName = midi_flattened_notes[noteName];\n  }\n  return noteName + octave;\n}\nfunction mpqnFromBpm(bpm) {\n  let mpqn = Math.floor(6e7 / bpm);\n  const ret = [];\n  do {\n    ret.unshift(mpqn & 255);\n    mpqn >>= 8;\n  } while (mpqn);\n  while (ret.length < 3) {\n    ret.push(0);\n  }\n  return ret;\n}\nfunction bpmFromMpqn(mpqn) {\n  let m;\n  if (Array.isArray(mpqn)) {\n    m = 0;\n    for (let i = 0, l = mpqn.length - 1; l >= 0; ++i, --l) {\n      m |= mpqn[i] << l * 8;\n    }\n  } else {\n    m = mpqn;\n  }\n  return Math.floor(6e7 / m);\n}\nfunction codes2Str(byteArray) {\n  return String.fromCharCode(...byteArray);\n}\nfunction str2Bytes(str, finalBytes) {\n  let s = str;\n  if (finalBytes) {\n    while (s.length / 2 < finalBytes) {\n      s = \"0\" + s;\n    }\n  }\n  const bytes = [];\n  for (let i = s.length - 1; i >= 0; i = i - 2) {\n    const chars = i === 0 ? s[i] : s[i - 1] + s[i];\n    bytes.unshift(parseInt(chars, 16));\n  }\n  return bytes;\n}\nfunction translateTickTime(ticks) {\n  let buffer = ticks & 127;\n  let t = ticks >> 7;\n  while (t) {\n    buffer <<= 8;\n    buffer |= t & 127 | 128;\n    t = t >> 7;\n  }\n  const bList = [];\n  while (true) {\n    bList.push(buffer & 255);\n    if (buffer & 128) {\n      buffer >>= 8;\n    } else {\n      break;\n    }\n  }\n  return bList;\n}\nvar Util = {\n  midi_letter_pitches,\n  midi_pitches_letter,\n  midi_flattened_notes,\n  midiPitchFromNote,\n  ensureMidiPitch,\n  noteFromMidiPitch,\n  mpqnFromBpm,\n  bpmFromMpqn,\n  codes2Str,\n  str2Bytes,\n  translateTickTime\n};\n\n// src/types.ts\nvar MidiEventType = {\n  NOTE_OFF: 128,\n  NOTE_ON: 144,\n  AFTER_TOUCH: 160,\n  CONTROLLER: 176,\n  PROGRAM_CHANGE: 192,\n  CHANNEL_AFTERTOUCH: 208,\n  PITCH_BEND: 224\n};\nvar MetaEventType = {\n  SEQUENCE: 0,\n  TEXT: 1,\n  COPYRIGHT: 2,\n  TRACK_NAME: 3,\n  INSTRUMENT: 4,\n  LYRIC: 5,\n  MARKER: 6,\n  CUE_POINT: 7,\n  CHANNEL_PREFIX: 32,\n  END_OF_TRACK: 47,\n  TEMPO: 81,\n  SMPTE: 84,\n  TIME_SIG: 88,\n  KEY_SIG: 89,\n  SEQ_EVENT: 127\n};\n\n// src/event.ts\nvar MidiEvent = class _MidiEvent {\n  static NOTE_OFF = MidiEventType.NOTE_OFF;\n  static NOTE_ON = MidiEventType.NOTE_ON;\n  static AFTER_TOUCH = MidiEventType.AFTER_TOUCH;\n  static CONTROLLER = MidiEventType.CONTROLLER;\n  static PROGRAM_CHANGE = MidiEventType.PROGRAM_CHANGE;\n  static CHANNEL_AFTERTOUCH = MidiEventType.CHANNEL_AFTERTOUCH;\n  static PITCH_BEND = MidiEventType.PITCH_BEND;\n  time;\n  type;\n  channel;\n  param1;\n  param2;\n  constructor(params) {\n    this.setTime(params.time);\n    this.setType(params.type);\n    this.setChannel(params.channel);\n    this.setParam1(params.param1);\n    if (params.param2 !== void 0) {\n      this.setParam2(params.param2);\n    }\n  }\n  setTime(ticks) {\n    this.time = translateTickTime(ticks || 0);\n  }\n  setType(type) {\n    if (type < _MidiEvent.NOTE_OFF || type > _MidiEvent.PITCH_BEND) {\n      throw new Error(\"Trying to set an unknown event: \" + type);\n    }\n    this.type = type;\n  }\n  setChannel(channel) {\n    if (channel < 0 || channel > 15) {\n      throw new Error(\"Channel is out of bounds.\");\n    }\n    this.channel = channel;\n  }\n  setParam1(p) {\n    this.param1 = p;\n  }\n  setParam2(p) {\n    this.param2 = p;\n  }\n  toBytes() {\n    const byteArray = [];\n    const typeChannelByte = this.type | this.channel & 15;\n    byteArray.push(...this.time);\n    byteArray.push(typeChannelByte);\n    byteArray.push(this.param1);\n    if (this.param2 !== void 0 && this.param2 !== null) {\n      byteArray.push(this.param2);\n    }\n    return byteArray;\n  }\n};\n\n// src/meta-event.ts\nvar MetaEvent = class {\n  static SEQUENCE = MetaEventType.SEQUENCE;\n  static TEXT = MetaEventType.TEXT;\n  static COPYRIGHT = MetaEventType.COPYRIGHT;\n  static TRACK_NAME = MetaEventType.TRACK_NAME;\n  static INSTRUMENT = MetaEventType.INSTRUMENT;\n  static LYRIC = MetaEventType.LYRIC;\n  static MARKER = MetaEventType.MARKER;\n  static CUE_POINT = MetaEventType.CUE_POINT;\n  static CHANNEL_PREFIX = MetaEventType.CHANNEL_PREFIX;\n  static END_OF_TRACK = MetaEventType.END_OF_TRACK;\n  static TEMPO = MetaEventType.TEMPO;\n  static SMPTE = MetaEventType.SMPTE;\n  static TIME_SIG = MetaEventType.TIME_SIG;\n  static KEY_SIG = MetaEventType.KEY_SIG;\n  static SEQ_EVENT = MetaEventType.SEQ_EVENT;\n  time;\n  type;\n  data;\n  constructor(params) {\n    this.time = translateTickTime(0);\n    this.type = 0;\n    this.setTime(params.time);\n    this.setType(params.type);\n    this.setData(params.data);\n  }\n  setTime(ticks) {\n    this.time = translateTickTime(ticks || 0);\n  }\n  setType(t) {\n    this.type = t;\n  }\n  setData(d) {\n    this.data = d;\n  }\n  toBytes() {\n    if (!this.type) {\n      throw new Error(\"Type for meta-event not specified.\");\n    }\n    const byteArray = [];\n    byteArray.push(...this.time);\n    byteArray.push(255, this.type);\n    if (Array.isArray(this.data)) {\n      byteArray.push(this.data.length);\n      byteArray.push(...this.data);\n    } else if (typeof this.data === \"number\") {\n      byteArray.push(1, this.data);\n    } else if (this.data !== null && this.data !== void 0) {\n      byteArray.push(this.data.length);\n      const dataBytes = this.data.split(\"\").map((x) => x.charCodeAt(0));\n      byteArray.push(...dataBytes);\n    } else {\n      byteArray.push(0);\n    }\n    return byteArray;\n  }\n};\n\n// src/constants.ts\nvar DEFAULT_VOLUME = 90;\nvar DEFAULT_DURATION = 128;\nvar DEFAULT_CHANNEL = 0;\n\n// src/track.ts\nvar Track = class _Track {\n  static START_BYTES = [77, 84, 114, 107];\n  static END_BYTES = [0, 255, 47, 0];\n  events;\n  constructor(config) {\n    this.events = config?.events ?? [];\n  }\n  addEvent(event) {\n    this.events.push(event);\n    return this;\n  }\n  addNoteOn(channel, pitch, time, velocity) {\n    this.events.push(\n      new MidiEvent({\n        type: MidiEvent.NOTE_ON,\n        channel,\n        param1: ensureMidiPitch(pitch),\n        param2: velocity || DEFAULT_VOLUME,\n        time: time || 0\n      })\n    );\n    return this;\n  }\n  addNoteOff(channel, pitch, time, velocity) {\n    this.events.push(\n      new MidiEvent({\n        type: MidiEvent.NOTE_OFF,\n        channel,\n        param1: ensureMidiPitch(pitch),\n        param2: velocity || DEFAULT_VOLUME,\n        time: time || 0\n      })\n    );\n    return this;\n  }\n  addNote(channel, pitch, dur, time, velocity) {\n    this.addNoteOn(channel, pitch, time, velocity);\n    if (dur) {\n      this.addNoteOff(channel, pitch, dur, velocity);\n    }\n    return this;\n  }\n  addChord(channel, chord, dur, velocity) {\n    if (!Array.isArray(chord) || chord.length === 0) {\n      throw new Error(\"Chord must be a non-empty array of pitches\");\n    }\n    chord.forEach((note) => {\n      this.addNoteOn(channel, note, 0, velocity);\n    });\n    chord.forEach((note, index) => {\n      if (index === 0) {\n        this.addNoteOff(channel, note, dur);\n      } else {\n        this.addNoteOff(channel, note);\n      }\n    });\n    return this;\n  }\n  setInstrument(channel, instrument, time) {\n    this.events.push(\n      new MidiEvent({\n        type: MidiEvent.PROGRAM_CHANGE,\n        channel,\n        param1: instrument,\n        time: time || 0\n      })\n    );\n    return this;\n  }\n  setTempo(bpm, time) {\n    this.events.push(\n      new MetaEvent({\n        type: MetaEvent.TEMPO,\n        data: mpqnFromBpm(bpm),\n        time: time || 0\n      })\n    );\n    return this;\n  }\n  setTimeSignature(numerator, denominator, time) {\n    const ddlog2 = Math.log2(denominator);\n    if (ddlog2 !== Math.floor(ddlog2)) {\n      throw new Error(\n        \"Time signature denominator must be an exact power of 2!\"\n      );\n    }\n    this.events.push(\n      new MetaEvent({\n        type: MetaEvent.TIME_SIG,\n        data: [numerator & 255, Math.floor(ddlog2) & 255, 24, 8],\n        time: time || 0\n      })\n    );\n    return this;\n  }\n  setKeySignature(accidentals, minor, time) {\n    this.events.push(\n      new MetaEvent({\n        type: MetaEvent.KEY_SIG,\n        data: [accidentals & 255, minor ? 1 : 0],\n        time: time || 0\n      })\n    );\n    return this;\n  }\n  toBytes() {\n    let trackLength = 0;\n    const eventBytes = [];\n    const startBytes = _Track.START_BYTES;\n    const endBytes = _Track.END_BYTES;\n    this.events.forEach((event) => {\n      const bytes = event.toBytes();\n      trackLength += bytes.length;\n      eventBytes.push(...bytes);\n    });\n    trackLength += endBytes.length;\n    const lengthBytes = str2Bytes(trackLength.toString(16), 4);\n    return startBytes.concat(lengthBytes, eventBytes, endBytes);\n  }\n};\nTrack.prototype.noteOn = Track.prototype.addNoteOn;\nTrack.prototype.noteOff = Track.prototype.addNoteOff;\nTrack.prototype.note = Track.prototype.addNote;\nTrack.prototype.chord = Track.prototype.addChord;\nTrack.prototype.instrument = Track.prototype.setInstrument;\nTrack.prototype.tempo = Track.prototype.setTempo;\nTrack.prototype.timeSignature = Track.prototype.setTimeSignature;\nTrack.prototype.keySignature = Track.prototype.setKeySignature;\n\n// src/file.ts\nvar File = class _File {\n  static HDR_CHUNKID = \"MThd\";\n  static HDR_CHUNK_SIZE = \"\\0\\0\\0\u0006\";\n  static HDR_TYPE0 = \"\\0\\0\";\n  static HDR_TYPE1 = \"\\0\u0001\";\n  ticks;\n  tracks;\n  constructor(config) {\n    const c = config || {};\n    if (c.ticks !== void 0) {\n      if (typeof c.ticks !== \"number\") {\n        throw new Error(\"Ticks per beat must be a number!\");\n      }\n      if (c.ticks <= 0 || c.ticks >= 1 << 15 || c.ticks % 1 !== 0) {\n        throw new Error(\"Ticks per beat must be an integer between 1 and 32767!\");\n      }\n    }\n    this.ticks = c.ticks || 128;\n    this.tracks = [];\n  }\n  addTrack(track) {\n    if (track) {\n      this.tracks.push(track);\n      return this;\n    } else {\n      const newTrack = new Track();\n      this.tracks.push(newTrack);\n      return newTrack;\n    }\n  }\n  toBytes() {\n    const trackCount = this.tracks.length.toString(16);\n    let bytes = _File.HDR_CHUNKID + _File.HDR_CHUNK_SIZE;\n    if (parseInt(trackCount, 16) > 1) {\n      bytes += _File.HDR_TYPE1;\n    } else {\n      bytes += _File.HDR_TYPE0;\n    }\n    bytes += codes2Str(str2Bytes(trackCount, 2));\n    bytes += String.fromCharCode(this.ticks / 256, this.ticks % 256);\n    this.tracks.forEach((track) => {\n      bytes += codes2Str(track.toBytes());\n    });\n    return bytes;\n  }\n  toUint8Array() {\n    const str = this.toBytes();\n    const arr = new Uint8Array(str.length);\n    for (let i = 0; i < str.length; i++) {\n      arr[i] = str.charCodeAt(i);\n    }\n    return arr;\n  }\n  toBlob(genericType) {\n    return new Blob([this.toUint8Array()], {\n      type: genericType ? \"application/octet-stream\" : \"audio/x-midi\"\n    });\n  }\n};\n\n// src/index.ts\nvar Midi = {\n  Util,\n  File,\n  Track,\n  Event: MidiEvent,\n  MetaEvent,\n  DEFAULT_VOLUME,\n  DEFAULT_DURATION,\n  DEFAULT_CHANNEL\n};\nvar index_default = Midi;\n\nexports.DEFAULT_CHANNEL = DEFAULT_CHANNEL;\nexports.DEFAULT_DURATION = DEFAULT_DURATION;\nexports.DEFAULT_VOLUME = DEFAULT_VOLUME;\nexports.Event = MidiEvent;\nexports.File = File;\nexports.MetaEvent = MetaEvent;\nexports.MetaEventType = MetaEventType;\nexports.MidiEvent = MidiEvent;\nexports.MidiEventType = MidiEventType;\nexports.Track = Track;\nexports.Util = Util;\nexports.default = index_default;\n//# sourceMappingURL=index.cjs.map\n//# sourceMappingURL=index.cjs.map","// The module cache\nvar __webpack_module_cache__ = {};\n\n// The require function\nfunction __webpack_require__(moduleId) {\n\t// Check if module is in cache\n\tvar cachedModule = __webpack_module_cache__[moduleId];\n\tif (cachedModule !== undefined) {\n\t\treturn cachedModule.exports;\n\t}\n\t// Create a new module (and put it into the cache)\n\tvar module = __webpack_module_cache__[moduleId] = {\n\t\t// no module.id needed\n\t\t// no module.loaded needed\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\n","// startup\n// Load entry module and return exports\n// This entry module is referenced by other modules so it can't be inlined\nvar __webpack_exports__ = __webpack_require__(376);\n"],"names":["mod","__defProp","Object","defineProperty","__getOwnPropDesc","getOwnPropertyDescriptor","__getOwnPropNames","getOwnPropertyNames","__hasOwnProp","prototype","hasOwnProperty","index_exports","target","all","name","get","enumerable","__export","chord","chords","getIndicesFromScale","inlineChord","scale","scales","module","exports","to","from","except","desc","key","call","__copyProps","value","sharpToFlatMap","CHROMATIC","scaleMap","ritusen","egyptian","pelog","kumoijoshi","hirajoshi","iwato","scriabin","augmented","piongio","prometheus","altered","lydian","locrian","ultralocrian","phrygian","balinese","aeolian","dorian","oriental","flamenco","mixolydian","persian","major","enigmatic","bebop","diminished","ichikosucho","chromatic","ionian","minor","Kanakangi","Ratnangi","Ganamurti","Vanaspati","Manavati","Tanarupi","Senavati","Hanumatodi","Dhenuka","Natakapriya","Kokilapriya","Rupavati","Gayakapriya","Vakulabharanam","Mayamalavagowla","Chakravakam","Suryakantam","Hatakambari","Jhankaradhwani","Natabhairavi","Keeravani","Kharaharapriya","Gourimanohari","Varunapriya","Mararanjani","Charukesi","Sarasangi","Harikambhoji","Dheerasankarabaranam","Naganandini","Yagapriya","Ragavardhini","Gangeyabhushani","Vagadheeswari","Shulini","Chalanata","Salagam","Jalarnavam","Jhalavarali","Navaneetam","Pavani","Raghupriya","Gavambhodi","Bhavapriya","Shubhapantuvarali","Shadvidamargini","Suvarnangi","Divyamani","Dhavalambari","Namanarayani","Kamavardhini","Ramapriya","Gamanashrama","Vishwambari","Shamalangi","Shanmukhapriya","Simhendramadhyamam","Hemavati","Dharmavati","Neetimati","Kantamani","Rishabhapriya","Latangi","Vachaspati","Mechakalyani","Chitrambari","Sucharitra","Dhatuvardani","Nasikabhushini","Kosalam","Rasikapriya","chordMap","sus4","M7sus4","aug","M7b6","M","maj7","Mb5","M7b5","mb6M7","m","m7","m6","mMaj7b6","dim","oM7","m7b5","dim7","o7M7","madd4","m7add11","sus2","sus24","M9sus4","Madd9","maj9","maj13","M7add13","M9b5","madd9","mM9","m9","m69","m13","mMaj9b6","m9b5","m11A","m11","b9sus","alt7","Maddb9","M7b9","mb6b9","_getNotesForScaleOrChord","scale2","chord2","input","SCALE_OR_CHORD","Error","rootOctaveScale","trim","indexOfFirstSpace","indexOf","scaleOrChord","rootOctave","slice","root","toUpperCase","charAt","sharpToFlat","replace","octave","isNaN","chroma","index","o1","map","n","o2","concat","getChromatic","acc","p1","p2","length","push","rootChord_Oct","B9SUS","includes","split","keys","scaleOrBitmap","str","intervals","i","__spreadArray","this","pack","arguments","ar","l","Array","arp","harmonics_1","utils_1","fillArr","arr","len","bumpOctave","el","note","oct","arr1","arr2","chordsOrParams","finalArr","params","count","order","match","TypeError","join","assign","forEach","c","filledArr_1","reorderedArr","idx","e","isArray","filledArr_2","errorHasMessage","message","__assign","t","s","p","apply","__awaiter","thisArg","_arguments","P","generator","Promise","resolve","reject","fulfilled","step","next","rejected","result","done","then","__generator","body","f","y","_","label","sent","trys","ops","g","create","Iterator","verb","Symbol","iterator","v","op","pop","clip","renderingDuration","totalPatternDuration","recursivelyApplyPatternToDurations","getDuration","getNote","defaultSubdiv","counter","randomNotes","randomInt","notes","durations","dur","subdiv","patternArr","char","generateSequence","channel","context","Tone","getContext","pattern","expandStr","Ticks","toSeconds","Sequence","callback","getSeqFn","events","subdivision","subdivOrLength","patternRegularNotesCount","filter","patternRandomNotesCount","patternNotesCount","notesCount","n1","n2","_a","smallest","largest","leastCommonMultiple","originalContext","ongoingRenderingCounter","shuffle","sizzle","sizzleReps","arpegiate","align","alignOffset","amp","accentLow","offlineRendering","convertChordsToNotes","test","duration","player","Player","loop","Offline","sequence","loaded","start","transport","buffer","setContext","offlineRenderingCallback","toDestination","sync","offlineRenderClip","__createBinding","o","k","k2","undefined","__esModule","writable","configurable","__exportStar","Session","midi","progression","getChordsByProgression","getChordDegrees","modes","mode","browser_clip_1","progression_1","arp_1","midi_1","session_1","__rest","getOwnPropertySymbols","propertyIsEnumerable","Channel","getNextPos","Transport","position","transportPosTicks","ticks","alignTicks","toTicks","alignOffsetTicks","Math","floor","_this","activePatternIdx","channelClips","clipNoteCount","clips","samples","sample","synth","params1","params2","external","sampler","params3","instrument","volume","eventCb","playerCb","params4","effects","originalParamsFiltered","eventCbFn","playerCbFn","hasLoaded","hasFailed","initializerTask","initOutputProducer","initInstrument","adjustInstrument","initEffects","clipsFailed","addClip","catch","setTransportTempo","valueBpm","bpm","startTransport","stopTransport","deleteEvents","stop","cancel","setVolume","_b","startClip","stopClip","state","counterResetTask","scheduleOnce","clipParams","time","durSeconds","Time","triggerAttackRelease","PolySynth","Sampler","NoiseSynth","event","checkToneObjLoaded","toneObject","skipRecursion","handled_1","ToneAudioBuffer","ToneBufferSource","oldOnLoad_1","onload","recreateToneObjectInContext","newObj_1","_dummyVoice","newObj_2","url","_buffer","paramsFromSampler","attack","curve","release","paramsFromBuffers","baseUrl","_buffers","urls","fromEntries","entries","newObj_3","newObj_4","synthName","preset","console","warn","init","rawContext","newObj","someVal","startEffect","eff","effectsIn","effect","effectOut","results","chain","__importDefault","fs_1","fileName","bytes","createFileFromNotes","toBytes","endsWith","window","URL","createObjectURL","createDownloadLink","default","writeFileSync","log","b","Uint8Array","ascii","charCodeAt","blob","Blob","type","link","document","createElement","href","download","innerText","file","File","track","Track","setTempo","addTrack","_i","notes_1","noteObj","level","noteOn","noteOff","addChord","theRomans","idxByDegree","ii","iii","iv","vi","vii","noteOctaveScale","chordDegress","noteOctaveScaleArr","roman","chordName","prefix","toLowerCase","getChordName","scaleId","toString","getProgFactory","T","D","pickOne","dice","scaleType","channel_1","sessionChannels","ch","uniqueIdx","channels","idxs","reduce","find","newIdx_1","createChannel","newChannel","startRow","play","channelPatterns","clipDuration","clipDurationInSeconds","stopClips","channelIdx","prevClipIdx","clipIdx","startClips","convertChordToNotes","flat","sizzleMap","isNote","JSON","stringify","parse","fullShuffle","lastIndex","rnd","random","maxLevel","pi","PI","piArr","piArrRev","reverse","element","round","sin","val","x","c1","c2","e1","e2","num","require","midi_letter_pitches","a","d","midi_pitches_letter","midi_flattened_notes","midiPitchFromNote","matches","exec","accidental","parseInt","substring","ensureMidiPitch","String","mpqnFromBpm","mpqn","ret","unshift","codes2Str","byteArray","fromCharCode","str2Bytes","finalBytes","chars","translateTickTime","bList","Util","noteFromMidiPitch","returnFlattened","noteNum","noteName","bpmFromMpqn","MidiEventType","NOTE_OFF","NOTE_ON","AFTER_TOUCH","CONTROLLER","PROGRAM_CHANGE","CHANNEL_AFTERTOUCH","PITCH_BEND","MetaEventType","SEQUENCE","TEXT","COPYRIGHT","TRACK_NAME","INSTRUMENT","LYRIC","MARKER","CUE_POINT","CHANNEL_PREFIX","END_OF_TRACK","TEMPO","SMPTE","TIME_SIG","KEY_SIG","SEQ_EVENT","MidiEvent","_MidiEvent","static","param1","param2","constructor","setTime","setType","setChannel","setParam1","setParam2","typeChannelByte","MetaEvent","data","setData","dataBytes","_Track","config","addEvent","addNoteOn","pitch","velocity","addNoteOff","addNote","setInstrument","setTimeSignature","numerator","denominator","ddlog2","log2","setKeySignature","accidentals","trackLength","eventBytes","startBytes","START_BYTES","endBytes","END_BYTES","lengthBytes","tempo","timeSignature","keySignature","_File","tracks","newTrack","trackCount","HDR_CHUNKID","HDR_CHUNK_SIZE","HDR_TYPE1","HDR_TYPE0","toUint8Array","toBlob","genericType","index_default","Event","DEFAULT_VOLUME","DEFAULT_DURATION","DEFAULT_CHANNEL","__webpack_module_cache__","__webpack_exports__","__webpack_require__","moduleId","cachedModule","__webpack_modules__"],"sourceRoot":""}