abcjs-rails 2.3 → 3.0

data/app/assets/javascripts/abcjs/midi/abc_midi_create.js

@@ -1,5 +1,5 @@
 //    abc_midi_create.js: Turn a linear series of events into a midi file.
-//    Copyright (C) 2010,2015 Gregory Dyke (gregdyke at gmail dot com) and Paul Rosen
+//    Copyright (C) 2010,2016 Gregory Dyke (gregdyke at gmail dot com) and Paul Rosen
 //
 //    This program is free software: you can redistribute it and/or modify
 //    it under the terms of the GNU General Public License as published by
@@ -26,44 +26,66 @@ if (!window.ABCJS.midi)
 	var baseDuration = 480*4; // nice and divisible, equals 1 whole note
 
 	window.ABCJS.midi.create = function(abcTune, options) {
+		if (options === undefined) options = {};
 		var sequence = window.ABCJS.midi.sequence(abcTune, options);
 		var commands = window.ABCJS.midi.flatten(sequence);
-		var midi = window.ABCJS.midi.rendererFactory(false);
+		var midi = window.ABCJS.midi.rendererFactory();
+		var midiJs = new window.ABCJS.midi.Preparer();
 
-		if (commands.instrument !== undefined)
-			midi.setInstrument(commands.instrument);
-		if (commands.channel !== undefined)
-			midi.setChannel(commands.channel);
 		var title = abcTune.metaText ? abcTune.metaText.title : undefined;
 		if (title && title.length > 128)
 			title = title.substring(0,124) + '...';
 		midi.setGlobalInfo(commands.tempo, title);
+		midiJs.setGlobalInfo(commands.tempo, title);
 
+		if (commands.instrument !== undefined) {
+			midi.setInstrument(commands.instrument);
+			midiJs.setInstrument(commands.instrument);
+		}
+		if (commands.channel !== undefined) {
+			midi.setChannel(commands.channel);
+			midiJs.setChannel(commands.channel);
+		}
 		for (var i = 0; i < commands.tracks.length; i++) {
 			midi.startTrack();
+			midiJs.startTrack();
 			for (var j = 0; j < commands.tracks[i].length; j++) {
 				var event = commands.tracks[i][j];
 				switch (event.cmd) {
 					case 'instrument':
 						midi.setInstrument(event.instrument);
+						midiJs.setInstrument(event.instrument);
 						break;
 					case 'start':
 						midi.startNote(convertPitch(event.pitch), event.volume);
+						midiJs.startNote(convertPitch(event.pitch), event.volume);
 						break;
 					case 'stop':
 						midi.endNote(convertPitch(event.pitch), 0); // TODO-PER: Refactor: the old midi used a duration here.
+						midiJs.endNote(convertPitch(event.pitch));
 						break;
 					case 'move':
 						midi.addRest(event.duration * baseDuration);
+						midiJs.addRest(event.duration * baseDuration);
 						break;
 					default:
 						console.log("MIDI create Unknown: " + event.cmd);
 				}
 			}
 			midi.endTrack();
+			midiJs.endTrack();
 		}
 
-		return midi.getData();
+		var midiFile = midi.getData();
+		var midiInline = midiJs.getData();
+		if (options.generateInline === undefined) // default is to generate inline controls.
+			options.generateInline = true;
+		if (options.generateInline && options.generateDownload)
+			return { download: midiFile, inline: midiInline };
+		else if (options.generateInline)
+			return midiInline;
+		else
+			return midiFile;
 	};
 
 	function convertPitch(pitch) {

data/app/assets/javascripts/abcjs/midi/abc_midi_flattener.js

@@ -1,5 +1,5 @@
 //    abc_midi_create.js: Turn a linear series of events into a series of MIDI commands.
-//    Copyright (C) 2010,2015 Gregory Dyke (gregdyke at gmail dot com) and Paul Rosen
+//    Copyright (C) 2010,2016 Gregory Dyke (gregdyke at gmail dot com) and Paul Rosen
 //
 //    This program is free software: you can redistribute it and/or modify
 //    it under the terms of the GNU General Public License as published by
@@ -34,7 +34,7 @@ if (!window.ABCJS.midi)
 	var multiplier;
 	var tracks;
 	var startingTempo;
-	var currentTempo;
+	var tempoChangeFactor = 1;
 	var instrument;
 	var channel;
 	var currentTrack;
@@ -58,7 +58,7 @@ if (!window.ABCJS.midi)
 		multiplier = 1;
 		tracks = [];
 		startingTempo = undefined;
-		currentTempo = undefined;
+		tempoChangeFactor = 1;
 		instrument = undefined;
 		channel = undefined;
 		currentTrack = undefined;
@@ -93,7 +93,7 @@ if (!window.ABCJS.midi)
 						if (!startingTempo)
 							startingTempo = element.qpm;
 						else
-							currentTempo = element.qpm;
+							tempoChangeFactor = element.qpm ? startingTempo / element.qpm : 1;
 						break;
 					case "transpose":
 						transpose = element.transpose;
@@ -190,7 +190,7 @@ if (!window.ABCJS.midi)
 				// If we ever have a chord in this voice, then we add the chord track.
 				// However, if there are chords on more than one voice, then just use the first voice.
 				if (chordTrack.length === 0) {
-					chordTrack.push({cmd: 'instrument', instrument: 2});
+					chordTrack.push({cmd: 'instrument', instrument: 0});
 					// need to figure out how far in time the chord started: if there are pickup notes before the chords start, we need pauses.
 					var distance = 0;
 					for (var ct = 0; ct < currentTrack.length; ct++) {
@@ -198,7 +198,7 @@ if (!window.ABCJS.midi)
 							distance += currentTrack[ct].duration;
 					}
 					if (distance > 0)
-						chordTrack.push({cmd: 'move', duration: distance});
+						chordTrack.push({cmd: 'move', duration: distance*tempoChangeFactor });
 				}
 
 				lastChord = c;
@@ -253,16 +253,16 @@ if (!window.ABCJS.midi)
 				else if (note.endTie)
 					pitchesTied[''+actualPitch] = false;
 			}
-			currentTrack.push({ cmd: 'move', duration: duration-normalBreakBetweenNotes });
+			currentTrack.push({ cmd: 'move', duration: (duration-normalBreakBetweenNotes)*tempoChangeFactor });
 			lastNoteDurationPosition = currentTrack.length-1;
 
 			for (var ii = 0; ii < pitches.length; ii++) {
 				if (!pitchesTied[''+pitches[ii].pitch])
 					currentTrack.push({ cmd: 'stop', pitch: pitches[ii].pitch });
 			}
-			currentTrack.push({ cmd: 'move', duration: normalBreakBetweenNotes });
+			currentTrack.push({ cmd: 'move', duration: normalBreakBetweenNotes*tempoChangeFactor });
 		} else if (elem.rest) {
-			currentTrack.push({ cmd: 'move', duration: duration });
+			currentTrack.push({ cmd: 'move', duration: duration*tempoChangeFactor });
 		}
 
 		if (elem.endTriplet) {
@@ -337,7 +337,7 @@ if (!window.ABCJS.midi)
 			var gp = adjustPitch(graces[g]);
 			if (gp !== skipNote)
 				currentTrack.push({cmd: 'start', pitch: gp, volume: 64});
-			currentTrack.push({cmd: 'move', duration: graces[g].duration});
+			currentTrack.push({cmd: 'move', duration: graces[g].duration*tempoChangeFactor });
 			if (gp !== skipNote)
 				currentTrack.push({cmd: 'stop', pitch: gp});
 			if (!stealFromCurrent)
@@ -404,8 +404,11 @@ if (!window.ABCJS.midi)
 		var arr = remaining.split('/');
 		chick = chordNotes(bass, arr[0]);
 		if (arr.length === 2) {
-			bass = basses[arr[1]] + transpose;
-			bass2 = bass;
+			var explicitBass = basses[arr[1]];
+			if (explicitBass) {
+				bass = basses[arr[1]] + transpose;
+				bass2 = bass;
+			}
 		}
 		return { boom: bass, boom2: bass2, chick: chick };
 	}
@@ -458,19 +461,19 @@ if (!window.ABCJS.midi)
 		// undefined means there is a stop time.
 		if (boom !== undefined)
 			chordTrack.push({cmd: 'start', pitch: boom, volume: 64});
-		chordTrack.push({ cmd: 'move', duration: beatLength/2 });
+		chordTrack.push({ cmd: 'move', duration: (beatLength/2)*tempoChangeFactor });
 		if (boom !== undefined)
 			chordTrack.push({ cmd: 'stop', pitch: boom });
-		chordTrack.push({ cmd: 'move', duration: beatLength/2 });
+		chordTrack.push({ cmd: 'move', duration: (beatLength/2)*tempoChangeFactor });
 	}
 
 	function writeChick(chick, beatLength) {
 		for (var c = 0; c < chick.length; c++)
 			chordTrack.push({cmd: 'start', pitch: chick[c], volume: 48});
-		chordTrack.push({ cmd: 'move', duration: beatLength/2 });
+		chordTrack.push({ cmd: 'move', duration: (beatLength/2)*tempoChangeFactor });
 		for (c = 0; c < chick.length; c++)
 			chordTrack.push({ cmd: 'stop', pitch: chick[c] });
-		chordTrack.push({ cmd: 'move', duration: beatLength/2 });
+		chordTrack.push({ cmd: 'move', duration: (beatLength/2)*tempoChangeFactor });
 	}
 
 	var rhythmPatterns = { "2/2": [ 'boom', 'chick' ],
@@ -514,7 +517,7 @@ if (!window.ABCJS.midi)
 						writeChick(currentChords[0].chord.chick, beatLength);
 						break;
 					case '':
-						chordTrack.push({ cmd: 'move', duration: beatLength });
+						chordTrack.push({ cmd: 'move', duration: beatLength*tempoChangeFactor });
 						break;
 				}
 			}
@@ -557,7 +560,7 @@ if (!window.ABCJS.midi)
 					if (beats[''+m2])	// If there is an explicit chord on this beat, play it.
 						writeChick(thisChord.chord.chick, beatLength);
 					else
-						chordTrack.push({cmd: 'move', duration: beatLength});
+						chordTrack.push({cmd: 'move', duration: beatLength*tempoChangeFactor });
 					break;
 			}
 		}

data/app/assets/javascripts/abcjs/midi/abc_midi_js_preparer.js

@@ -0,0 +1,233 @@
+//    abc_midi_js_preparer.js: Create the structure that MIDI.js expects.
+//    Copyright (C) 2010,2016 Gregory Dyke (gregdyke at gmail dot com) and Paul Rosen
+//
+//    This program is free software: you can redistribute it and/or modify
+//    it under the terms of the GNU General Public License as published by
+//    the Free Software Foundation, either version 3 of the License, or
+//    (at your option) any later version.
+//
+//    This program is distributed in the hope that it will be useful,
+//    but WITHOUT ANY WARRANTY; without even the implied warranty of
+//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+//    GNU General Public License for more details.
+//
+//    You should have received a copy of the GNU General Public License
+//    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+if (!window.ABCJS)
+	window.ABCJS = {};
+
+if (!window.ABCJS.midi)
+	window.ABCJS.midi = {};
+
+(function() {
+	"use strict";
+
+	window.ABCJS.midi.Preparer = function() {
+		this.tempo = 0;
+		this.timeFactor = 0;
+		this.output = [];
+		this.currentChannel = 0;
+		this.currentInstrument = 0;
+		this.track = 0;
+		this.nextDuration = 0;
+		this.tracks = [ [] ];
+	};
+
+	var Preparer = window.ABCJS.midi.Preparer;
+
+	Preparer.prototype.setInstrument = function(instrument) {
+		// TODO-PER: for the first version, there are no channel or instrument changes.
+		//this.currentInstrument = instrument;
+
+		var ev = [
+			{
+				ticksToEvent: 0,
+				track: this.track,
+				event: {
+					channel: this.currentChannel,
+					deltaTime: 0,
+					programNumber: this.currentInstrument,
+					subtype: 'programChange',
+					type: 'channel'
+				}
+			},
+			this.nextDuration * this.timeFactor
+		];
+		this.tracks[this.track].push(ev);
+	};
+
+	Preparer.prototype.setChannel = function(channel) {
+		// TODO-PER: for the first version, there are no channel or instrument changes.
+		//this.currentChannel = channel;
+	};
+
+	Preparer.prototype.startTrack = function() {
+		this.track++;
+		this.tracks[this.track] = [];
+		this.nextDuration = 0;
+	};
+
+	Preparer.prototype.setGlobalInfo = function(tempo, title) {
+		this.tempo = tempo;
+		var mspb = Math.round((1.0/tempo)*60000000);
+		this.timeFactor = mspb / 480000;
+		var ev = [
+			{
+				ticksToEvent: 0,
+				track: this.track,
+				event: {
+					deltaTime: 0,
+					microsecondsPerBeat: mspb,
+					subtype: 'setTempo',
+					type: 'meta'
+				}
+			},
+			this.nextDuration * this.timeFactor
+		];
+//		this.tracks[this.track].push(ev);
+
+		ev = [
+			{
+				ticksToEvent: 0,
+				track: this.track,
+				event: {
+					deltaTime: 0,
+					subtype: 'trackName',
+					text: title,
+					type: 'meta'
+				}
+			},
+			this.nextDuration * this.timeFactor
+		];
+//		this.tracks[this.track].push(ev);
+
+		ev = [
+			{
+				ticksToEvent: 0,
+				track: this.track,
+				event: {
+					deltaTime: 0,
+					subtype: 'endOfTrack',
+					type: 'meta'
+				}
+			},
+			this.nextDuration * this.timeFactor
+		];
+//		this.tracks[this.track].push(ev);
+	};
+
+	Preparer.prototype.startNote = function(pitch, volume) {
+		var deltaTime = Math.floor(this.nextDuration / 5) * 5;
+		var ev = [
+			{
+				ticksToEvent: deltaTime,
+				track: this.track,
+				event: {
+					deltaTime: deltaTime,
+					channel: this.currentChannel,
+					type: "channel",
+					noteNumber: pitch,
+					velocity: volume,
+					subtype: "noteOn"
+				}
+			},
+			this.nextDuration * this.timeFactor
+		];
+		this.tracks[this.track].push(ev);
+		this.nextDuration = 0;
+	};
+
+	Preparer.prototype.endNote = function(pitch) {
+		var deltaTime = Math.floor(this.nextDuration / 5) * 5;
+		var ev = [
+			{
+				ticksToEvent: deltaTime,
+				track: this.track,
+				event: {
+					deltaTime: deltaTime,
+					channel: this.currentChannel,
+					type: "channel",
+					noteNumber: pitch,
+					velocity: 0,
+					subtype: "noteOff"
+				}
+			},
+			this.nextDuration * this.timeFactor
+		];
+		this.tracks[this.track].push(ev);
+		this.nextDuration = 0;
+	};
+
+	Preparer.prototype.addRest = function(duration) {
+		this.nextDuration += duration;
+	};
+
+	Preparer.prototype.endTrack = function() {
+		var ev = [
+			{
+				ticksToEvent: 0,
+				track: this.track,
+				event: {
+					deltaTime: 0,
+					type: "meta",
+					subtype: "endOfTrack"
+				}
+			},
+			0
+		];
+//		this.tracks[this.track].push(ev);
+	};
+
+	function addAbsoluteTime(tracks) {
+		for (var i = 0; i < tracks.length; i++) {
+			var absTime = 0;
+			for (var j = 0; j < tracks[i].length; j++) {
+				absTime += tracks[i][j][1];
+				tracks[i][j].absTime = absTime;
+			}
+		}
+	}
+
+	function combineTracks(tracks) {
+		var output = [];
+		for (var i = 0; i < tracks.length; i++) {
+			for (var j = 0; j < tracks[i].length; j++) {
+				output.push(tracks[i][j]);
+			}
+		}
+		return output;
+	}
+
+	function sortTracks(output) {
+		return output.sort(function(a,b) {
+			if (a.absTime > b.absTime) return 1;
+			return -1;
+		});
+	}
+
+	function adjustTime(output) {
+		var lastTime = 0;
+		for (var i = 0; i < output.length; i++) {
+			var thisTime = output[i].absTime;
+			output[i][1] = thisTime - lastTime;
+			lastTime = thisTime;
+		}
+	}
+
+	function weaveTracks(tracks) {
+		// Each track has a progression of delta times. To combine them, first assign an absolute time to each event,
+		// then make one large track of all the tracks, sort it by absolute time, then adjust the amount of time each
+		// event causes time to move. That is, the movement was figured out as the distance from the last note in the track,
+		// but now we want the distance from the last note on ANY track.
+		addAbsoluteTime(tracks);
+		var output = combineTracks(tracks);
+		output = sortTracks(output);
+		adjustTime(output);
+		return output;
+	}
+
+	Preparer.prototype.getData = function() {
+		return weaveTracks(this.tracks);
+	};
+})();

data/app/assets/javascripts/abcjs/midi/abc_midi_renderer.js

@@ -1,5 +1,5 @@
 //    abc_midi_renderer.js: Create the actual format for the midi.
-//    Copyright (C) 2010,2015 Gregory Dyke (gregdyke at gmail dot com) and Paul Rosen
+//    Copyright (C) 2010,2016 Gregory Dyke (gregdyke at gmail dot com) and Paul Rosen
 //
 //    This program is free software: you can redistribute it and/or modify
 //    it under the terms of the GNU General Public License as published by
@@ -29,215 +29,6 @@ if (!window.ABCJS.midi)
 		return elm;
 	}
 
-	var MIDIPlugin;
-	//TODO-PER: put this back in when the MIDIPlugin works again.
-	//window.oldunload = window.onbeforeunload;
-	//window.onbeforeunload = function() {
-	//    if (window.oldunload)
-	//        window.oldunload();
-	//  if (typeof(MIDIPlugin) !== "undefined" && MIDIPlugin) { // PER: take care of crash in IE 8
-	//    MIDIPlugin.closePlugin();
-	//  }
-	//};
-
-
-	function MidiProxy(javamidi, qtmidi) {
-		this.javamidi = javamidi;
-		this.qtmidi = qtmidi;
-	}
-
-	MidiProxy.prototype.setTempo = function(qpm) {
-		this.javamidi.setTempo(qpm);
-		this.qtmidi.setTempo(qpm);
-	};
-
-	MidiProxy.prototype.startTrack = function() {
-		this.javamidi.startTrack();
-		this.qtmidi.startTrack();
-	};
-
-	MidiProxy.prototype.endTrack = function() {
-		this.javamidi.endTrack();
-		this.qtmidi.endTrack();
-	};
-
-	MidiProxy.prototype.setInstrument = function(number) {
-		this.javamidi.setInstrument(number);
-		this.qtmidi.setInstrument(number);
-	};
-
-	MidiProxy.prototype.startNote = function(pitch, loudness, abcelem) {
-		this.javamidi.startNote(pitch, loudness, abcelem);
-		this.qtmidi.startNote(pitch, loudness, abcelem);
-	};
-
-	MidiProxy.prototype.endNote = function(pitch, length) {
-		this.javamidi.endNote(pitch, length);
-		this.qtmidi.endNote(pitch, length);
-	};
-
-	MidiProxy.prototype.addRest = function(length) {
-		this.javamidi.addRest(length);
-		this.qtmidi.addRest(length);
-	};
-
-	MidiProxy.prototype.embed = function(parent) {
-		this.javamidi.embed(parent);
-		this.qtmidi.embed(parent, true);
-	};
-
-	function JavaMidi(midiwriter) {
-		this.playlist = []; // contains {time:t,funct:f} pairs
-		this.trackcount = 0;
-		this.timecount = 0;
-		this.tempo = 60;
-		this.midiapi = MIDIPlugin;
-		this.midiwriter = midiwriter;
-		this.noteOnAndChannel = "%90";
-	}
-
-	JavaMidi.prototype.setTempo = function(qpm) {
-		this.tempo = qpm;
-	};
-
-	JavaMidi.prototype.startTrack = function() {
-		this.silencelength = 0;
-		this.trackcount++;
-		this.timecount = 0;
-		this.playlistpos = 0;
-		this.first = true;
-		if (this.instrument) {
-			this.setInstrument(this.instrument);
-		}
-		if (this.channel) {
-			this.setChannel(this.channel);
-		}
-	};
-
-	JavaMidi.prototype.endTrack = function() {
-		// need to do anything?
-	};
-
-	JavaMidi.prototype.setInstrument = function(number) {
-		this.instrument = number;
-		this.midiapi.setInstrument(number);
-		//TODO push this into the playlist?
-	};
-
-	JavaMidi.prototype.setChannel = function(number) {
-		this.channel = number;
-		this.midiapi.setChannel(number);
-	};
-
-	JavaMidi.prototype.updatePos = function() {
-		while (this.playlist[this.playlistpos] &&
-		this.playlist[this.playlistpos].time < this.timecount) {
-			this.playlistpos++;
-		}
-	};
-
-	JavaMidi.prototype.startNote = function(pitch, loudness, abcelem) {
-		this.timecount += this.silencelength;
-		this.silencelength = 0;
-		if (this.first) {
-			//nothing special if first?
-		}
-		this.updatePos();
-		var self = this;
-		this.playlist.splice(this.playlistpos, 0, {
-			time: this.timecount,
-			funct: function() {
-				self.midiapi.playNote(pitch);
-				self.midiwriter.notifySelect(abcelem);
-			}
-		});
-	};
-
-	JavaMidi.prototype.endNote = function(pitch, length) {
-		this.timecount += length;
-		this.updatePos();
-		var self = this;
-		this.playlist.splice(this.playlistpos, 0, {
-			time: this.timecount,
-			funct: function() {
-				self.midiapi.stopNote(pitch);
-			}
-		});
-	};
-
-	JavaMidi.prototype.addRest = function(length) {
-		this.silencelength += length;
-	};
-
-	JavaMidi.prototype.embed = function(parent) {
-
-
-		this.playlink = setAttributes(document.createElement('a'), {
-			style: "border:1px solid black; margin:3px;"
-		});
-		this.playlink.innerHTML = "play";
-		var self = this;
-		this.playlink.onmousedown = function() {
-			if (self.playing) {
-				this.innerHTML = "play";
-				self.pausePlay();
-			} else {
-				this.innerHTML = "pause";
-				self.startPlay();
-			}
-		};
-		parent.appendChild(this.playlink);
-
-		var stoplink = setAttributes(document.createElement('a'), {
-			style: "border:1px solid black; margin:3px;"
-		});
-		stoplink.innerHTML = "stop";
-		//var self = this;
-		stoplink.onmousedown = function() {
-			self.stopPlay();
-		};
-		parent.appendChild(stoplink);
-		this.i = 0;
-		this.currenttime = 0;
-		this.playing = false;
-	};
-
-	JavaMidi.prototype.stopPlay = function() {
-		this.i = 0;
-		this.currenttime = 0;
-		this.pausePlay();
-		this.playlink.innerHTML = "play";
-	};
-
-	JavaMidi.prototype.startPlay = function() {
-		this.playing = true;
-		var self = this;
-		// repeat every 16th note TODO see the min in the piece
-		this.ticksperinterval = 480 / 4;
-		this.doPlay();
-		this.playinterval = window.setInterval(function() {self.doPlay(); },
-			(60000 / (this.tempo * 4)));
-	};
-
-	JavaMidi.prototype.pausePlay = function() {
-		this.playing = false;
-		window.clearInterval(this.playinterval);
-		this.midiapi.stopAllNotes();
-	};
-
-	JavaMidi.prototype.doPlay = function() {
-		while (this.playlist[this.i] &&
-		this.playlist[this.i].time <= this.currenttime) {
-			this.playlist[this.i].funct();
-			this.i++;
-		}
-		if (this.playlist[this.i]) {
-			this.currenttime += this.ticksperinterval;
-		} else {
-			this.stopPlay();
-		}
-	};
-
 	function Midi() {
 		this.trackstrings = "";
 		this.trackcount = 0;
@@ -403,24 +194,7 @@ if (!window.ABCJS.midi)
 		return toHex(res, padding);
 	}
 
-	window.ABCJS.midi.rendererFactory = function(isJava) {
-		return (isJava) ? new MidiProxy(new JavaMidi(this), new Midi()) : new Midi();
+	window.ABCJS.midi.rendererFactory = function() {
+		return new Midi();
 	};
-
-	window.ABCJS.midi.initializeJava = function() {
-		MIDIPlugin = document.MIDIPlugin;
-		setTimeout(function() { // run on next event loop (once MIDIPlugin is loaded)
-			try { // activate MIDIPlugin
-				MIDIPlugin.openPlugin();
-
-			} catch(e) { // plugin not supported (download externals)
-				var a = document.createElement("a");
-				a.href = "http://java.sun.com/products/java-media/sound/soundbanks.html";
-				a.target = "_blank";
-				a.appendChild(document.createTextNode("Download Soundbank"));
-				parent.appendChild(a);
-			}
-		}, 0);
-	};
-
 })();