sequenceserver 0.8.9 → 1.0.0.pre.1

data/public/js/sequence.js

@@ -0,0 +1,2419 @@
+require=(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
+// legacy!!
+$.browser = require("jquery-browser-plugin");
+
+/** 
+ * Sequence component 
+ * 
+ * @class
+ * @extends Biojs
+ * 
+ * @author <a href="mailto:johncar@gmail.com">John Gomez</a>, <a href="mailto:secevalliv@gmail.com">Jose Villaveces</a>
+ * @version 1.0.0
+ * @category 3
+ * 
+ * @requires <a href='http://blog.jquery.com/2011/09/12/jquery-1-6-4-released/'>jQuery Core 1.6.4</a>
+ * @dependency <script language="JavaScript" type="text/javascript" src="../biojs/dependencies/jquery/jquery-1.4.2.min.js"></script>
+ * 
+ * @requires <a href='http://jqueryui.com/download'>jQuery UI 1.8.16</a>
+ * @dependency <script language="JavaScript" type="text/javascript" src="../biojs/dependencies/jquery/jquery-ui-1.8.2.custom.min.js"></script>
+ *
+ * @requires <a href='Biojs.Tooltip.css'>Biojs.Tooltip</a>
+ * @dependency <script language="JavaScript" type="text/javascript" src="src/Biojs.Tooltip.js"></script>
+ * 
+ * @param {Object} options An object with the options for Sequence component.
+ *    
+ * @option {string} target 
+ *    Identifier of the DIV tag where the component should be displayed.
+ *    
+ * @option {string} sequence 
+ *    The sequence to be displayed.
+ *    
+ * @option {string} [id] 
+ *    Sequence identifier if apply.
+ *    
+ * @option {string} [format="FASTA"] 
+ *    The display format for the sequence representation.
+ *    
+ * @option {Object[]} [highlights] 
+ * 	  For highlighting multiple regions. 
+ *    <pre class="brush: js" title="Syntax:"> 
+ *    [
+ *    	// Highlight aminoacids from 'start' to 'end' of the current strand using the specified 'color' (optional) and 'background' (optional).
+ *    	{ start: &lt;startVal1&gt;, end: &lt;endVal1&gt; [, id:&lt;idVal1&gt;] [, color: &lt;HTMLColor&gt;] [, background: &lt;HTMLColor&gt;]}, 
+ *    	//
+ *    	// Any others highlights
+ *    	...,  
+ *    	// 
+ *    	{ start: &lt;startValN&gt;, end: &lt;endValN&gt; [, id:&lt;idValN&gt;] [, color: &lt;HTMLColor&gt;] [, background: &lt;HTMLColor&gt;]}
+ *    ]</pre>
+ * 
+ * <pre class="brush: js" title="Example:"> 
+ * highlights : [
+ * 		{ start:30, end:42, color:"white", background:"green", id:"spin1" },
+ *		{ start:139, end:140 }, 
+ *		{ start:631, end:633, color:"white", background:"blue" }
+ *	]
+ * </pre>
+ * 
+ * @option {Object} [columns={size:40,spacedEach:10}] 
+ * 	  Options for displaying the columns. Syntax: { size: &lt;numCols&gt;, spacedEach: &lt;numCols&gt;}
+ * 
+ * @option {Object} [selection] 
+ * 	  Positions for the current selected region. Syntax: { start: &lt;startValue&gt;, end: &lt;endValue&gt;}
+ * 
+ * @option {Object[]} [annotations] 
+ *    Set of overlapping annotations. Must be an array of objects following the syntax:
+ *     		<pre class="brush: js" title="Syntax:">
+ *            [ 
+ *              // An annotation:
+ *              { name: &lt;name&gt;, 
+ *                html: &lt;message&gt;, 
+ *                color: &lt;color_code&gt;, 
+ *                regions: [{ start: &lt;startVal1&gt;, end: &lt;endVal1&gt; color: &lt;HTMLColor&gt;}, ...,{ start: &lt;startValN&gt;, end: &lt;endValN&gt;, color: &lt;HTMLColor&gt;}] 
+ *              }, 
+ *              
+ *              // ...
+ *              // more annotations here 
+ *              // ...
+ *            ]
+ *    		 </pre>
+ *    where:
+ *      <ul>
+ *        <li><b>name</b> is the unique name for the annotation</li>
+ *        <li><b>html</b> is the message (can be HTML) to be displayed in the tool tip.</li>
+ *        <li><b>color</b> is the default HTML color code for all the regions.</li>
+ *        <li><b>regions</b> array of objects defining the intervals which belongs to the annotation.</li>
+ *        <li><b>regions[i].start</b> is the starting character for the i-th interval.</li>
+ *        <li><b>regions[i].end</b> is the ending character for the i-th interval.</li>
+ *        <li><b>regions[i].color</b> is an optional color for the i-th interval.   
+ *      </ul> 
+ *      
+ * @option {Object} [formatOptions={title:true, footer:true}] 
+ * 	  Options for displaying the title. by now just affecting the CODATA format.
+ *    <pre class="brush: js" title="Syntax:"> 
+ * 		formatOptions : {
+ * 			title:false,
+ * 			footer:false
+ * 		}
+ *    </pre>
+ *    
+ * @example 
+ * var theSequence = "METLCQRLNVCQDKILTHYENDSTDLRDHIDYWKHMRLECAIYYKAREMGFKHINHQVVPTLAVSKNKALQAIELQLTLETIYNSQYSNEKWTLQDVSLEVYLTAPTGCIKKHGYTVEVQFDGDICNTMHYTNWTHIYICEEAojs SVTVVEGQVDYYGLYYVHEGIRTYFVQFKDDAEKYSKNKVWEVHAGGQVILCPTSVFSSNEVSSPEIIRQHLANHPAATHTKAVALGTEETQTTIQRPRSEPDTGNPCHTTKLLHRDSVDSAPILTAFNSSHKGRINCNSNTTPIVHLKGDANTLKCLRYRFKKHCTLYTAVSSTWHWTGHNVKHKSAIVTLTYDSEWQRDQFLSQVKIPKTITVSTGFMSI";
+ * var mySequence = new Sequence({
+ * 		sequence : theSequence,
+ * 		target : "YourOwnDivId",
+ * 		format : 'CODATA',
+ * 		id : 'P918283',
+ * 		annotations: [
+ *        { name:"CATH", 
+ * 	  		color:"#F0F020", 
+ * 	  		html: "Using color code #F0F020 ", 
+ * 	  		regions: [{start: 122, end: 135}]
+ * 		  },
+ *        { name:"TEST", 
+ *          html:"&lt;br&gt; Example of &lt;b&gt;HTML&lt;/b&gt;", 
+ *          color:"green", 
+ *          regions: [
+ *            {start: 285, end: 292},
+ *            {start: 293, end: 314, color: "#2E4988"}]
+ *        }
+ *      ],
+ *      highlights : [
+ *      	{ start:30, end:42, color:"white", background:"green", id:"spin1" },
+ *      	{ start:139, end:140 }, 
+ *      	{ start:631, end:633, color:"white", background:"blue" }
+ *      ]
+ * });	
+ * 
+ */
+
+var Class = require('js-class');
+
+var EVT_ON_SELECTION_CHANGE= "onSelectionChange";
+var EVT_ON_SELECTION_CHANGED= "onSelectionChanged";
+var EVT_ON_ANNOTATION_CLICKED= "onAnnotationClicked";
+
+Sequence = Class(
+/** @lends Sequence# */
+{	
+	constructor: function (options) {
+		var self = this;
+
+    this.opt = jQuery.extend(this.opt,options);
+
+    this._container = jQuery(this.opt.target );
+    
+    // legacy support (target id without '#')
+    if(this._container.length == 0){
+      this._container = jQuery( "#" + this.opt.target )
+    }
+
+    if(this._container.length == 0){
+      console.log("empty target container");
+    }
+
+    // legacy: copy target id
+    this.opt.target = this._container[0].id;
+		
+		// Lazy initialization 
+		this._container.ready(function() {
+			self._initialize();
+		});
+	},
+	
+	/**
+	 * Default values for the options
+	 * @name Sequence-opt
+	 */
+	opt : {
+		
+		sequence : "",
+		id : "",
+		target : "",
+		format : "FASTA",
+		selection: { start: 0, end: 0 },
+		columns: { size: 35, spacedEach: 10 },
+		highlights : [],
+		annotations: [],
+		sequenceUrl: 'http://www.ebi.ac.uk/das-srv/uniprot/das/uniprot/sequence',
+		
+		// Styles 
+		selectionColor : 'Yellow',
+		selectionFontColor : 'black',
+		highlightFontColor : 'red',
+		highlightBackgroundColor : 'white',
+		fontColor : 'inherit',
+		backgroundColor : 'inherit',
+		width: undefined,
+		height: undefined,
+		formatSelectorVisible: true
+	},
+	
+	/**
+	 * Array containing the supported event names
+	 * @name Sequence-eventTypes
+	 */
+	eventTypes : [
+		/**
+		 * @name Sequence#onSelectionChanged
+		 * @event
+		 * @param {function} actionPerformed An function which receives an {@link Biojs.Event} object as argument.
+		 * @eventData {Object} source The component which did triggered the event.
+		 * @eventData {string} type The name of the event.
+		 * @eventData {int} start A number indicating the start of the selection.
+		 * @eventData {int} end A number indicating the ending of selection.
+		 * @example 
+		 * mySequence.onSelectionChanged(
+		 *    function( objEvent ) {
+		 *       alert("Selected: " + objEvent.start + ", " + objEvent.end );
+		 *    }
+		 * ); 
+		 * 
+		 * */
+		"onSelectionChanged",
+		
+		/**
+		 * @name Sequence#onSelectionChange
+		 * @event
+		 * @param {function} actionPerformed An function which receives an {@link Biojs.Event} object as argument.
+		 * @eventData {Object} source The component which did triggered the event.
+		 * @eventData {string} type The name of the event.
+		 * @eventData {int} start A number indicating the start of the selection.
+		 * @eventData {int} end A number indicating the ending of selection.
+		 * @example 
+		 * mySequence.onSelectionChange(
+		 *    function( objEvent ) {
+		 *       alert("Selection in progress: " + objEvent.start + ", " + objEvent.end );
+		 *    }
+		 * );  
+		 * 
+		 * 
+		 * */
+		"onSelectionChange",
+		
+		/**
+		 * @name Sequence#onAnnotationClicked
+		 * @event
+		 * @param {function} actionPerformed An function which receives an {@link Biojs.Event} object as argument.
+		 * @eventData {Object} source The component which did triggered the event.
+		 * @eventData {string} type The name of the event.
+		 * @eventData {string} name The name of the selected annotation.
+		 * @eventData {int} pos A number indicating the position of the selected amino acid.
+		 * @example 
+		 * mySequence.onAnnotationClicked(
+		 *    function( objEvent ) {
+		 *       alert("Clicked " + objEvent.name + " on position " + objEvent.pos );
+		 *    }
+		 * );  
+		 * 
+		 * */
+		"onAnnotationClicked"
+	],
+
+  getId : function () {
+    return this.opt.id;
+  },
+
+	// internal members
+	_headerDiv : null,
+	_contentDiv : null,
+	
+	// Methods
+
+	_initialize: function () {
+		
+		if ( this.opt.width !== undefined ) {
+			this._container.width( this.opt.width );
+		}
+		
+		if ( this.opt.height !== undefined ) {
+			this._container.height( this.opt.height );
+		}
+		
+		// DIV for the format selector
+		this._buildFormatSelector();
+		
+		// DIV for the sequence
+		this._contentDiv = jQuery('<div></div>').appendTo(this._container);
+		this._contentDiv.css({
+				'text-align': 'left'
+			});
+		
+		// Initialize highlighting 
+		this._highlights = this.opt.highlights;
+		
+		// Initialize annotations
+		this._annotations = this.opt.annotations;
+		
+		//Initialize tooltip
+		var tooltip = "sequenceTip" + this.opt.target ;
+		jQuery('<div id="' + tooltip + '"></div>') 
+	        .css({	
+	        	'position': "absolute",
+	        	'z-index': "999999",
+	        	'color': "#fff",
+	        	'font-size': "12px",
+	        	'width': "auto",
+	        	'display': 'none'
+	        })
+	        .addClass("tooltip")
+	        .appendTo("body")
+	        .hide();
+		this.opt._tooltip = document.getElementById(tooltip);
+
+		if ( (this.opt.sequence) ) {
+			this._redraw();
+			
+		} else if (  (this.opt.id) ) {
+			this._requestSequence( this.opt.id );
+			
+		} else {
+			this.clearSequence("No sequence available", "../biojs/css/images/warning_icon.png");
+		}
+		
+	},
+	
+	
+	/**
+	 * Shows the columns indicated by the indexes array.
+	 * @param {string} seq The sequence strand.
+	 * @param {string} [identifier] Sequence identifier.
+	 * 
+	 * @example 
+	 * mySequence.setSequence("P99999");
+	 * 
+	 */
+    setSequence: function ( seq, identifier ) {
+
+    	if ( seq.match(/^([A-N,R-Z][0-9][A-Z][A-Z, 0-9][A-Z, 0-9][0-9])|([O,P,Q][0-9][A-Z, 0-9][A-Z, 0-9][A-Z, 0-9][0-9])(\.\d+)?$/i) ) {
+    		this._requestSequence( arguments[0] );
+    		
+    	} else {
+    		this.opt.sequence = seq;
+        	this.opt.id = identifier; 
+        	this._highlights = [];
+    		this._highlightsCount = 0;
+    		this.opt.selection = { start: 0, end: 0 };
+    		this._annotations = [];
+    		
+    		this._contentDiv.children().remove();
+    		this._redraw();
+    	}
+    },
+    
+    _requestSequence: function ( accession ) {
+		var self = this;
+    	
+    	console.log("Requesting sequence for: " + accession );
+
+		jQuery.ajax({ 
+			url: self.opt.sequenceUrl,
+			dataType: "xml",
+			data: { segment: accession },
+			success: function ( xml  ) {
+				try {
+					
+					var sequenceNode = jQuery(xml).find('SEQUENCE:first');
+					self.setSequence( sequenceNode.text(), sequenceNode.attr("id"), sequenceNode.attr("label") );
+					
+				} catch (e) {
+					console.log("Error decoding response data: " + e.message );
+					self.clearSequence("No sequence available", "../biojs/css/images/warning_icon.png");
+				}
+
+			},
+			error: function (jqXHR, textStatus, errorThrown) {
+				console.log("Error decoding response data: " + textStatus );
+				self.clearSequence("Error requesting the sequence to the server " + this.url , "../biojs/css/images/warning_icon.png");
+			}
+		});
+    },
+	
+    /**
+	 * Shows the columns indicated by the indexes array.
+	 * @param {string} [showMessage] Message to be showed.
+	 * @param {string} [icon] Icon to be showed a side of the message
+	 * 
+	 * @example 
+	 * mySequence.clearSequence("No sequence available", "../biojs/css/images/warning_icon.png");
+	 * 
+	 */
+    clearSequence: function ( showMessage, icon ) {
+    	
+    	var message = undefined;
+    		
+    	this.opt.sequence = "";
+    	this.opt.id = ""; 
+    	this._highlights = [];
+		this._highlightsCount = 0;
+		this.opt.selection = { start: 0, end: 0 };
+		this._annotations = [];
+		this._contentDiv.children().remove();
+		
+		this._headerDiv.hide();
+		
+		if ( undefined !== showMessage ) {
+			message = jQuery('<div>' + showMessage + '</div>')
+				.appendTo(this._contentDiv)
+				.addClass("message");
+			
+			if ( undefined !== icon ) {
+				message.css({
+					'background': 'transparent url("' + icon + '") no-repeat center left',
+					'padding-left': '20px'
+				});
+			}
+		}
+    },
+	
+	/**
+    * Set the current selection in the sequence causing the event {@link Sequence#onSelectionChanged}
+    *
+    * @example
+    * // set selection from the position 100 to 150 
+    * mySequence.setSelection(100, 150);
+    * 
+    * @param {int} start The starting character of the selection.
+    * @param {int} end The ending character of the selection
+    */
+	setSelection : function(start, end) {
+		if(start > end) {
+			var aux = end;
+			end = start;
+			start = aux;
+
+		}
+
+		if(start != this.opt.selection.start || end != this.opt.selection.end) {
+			this._setSelection(start, end);
+			this.trigger(
+					EVT_ON_SELECTION_CHANGED, 
+					{ "start" : start, "end" : end }
+			);
+		}
+	},
+	
+	_buildFormatSelector: function () {
+		var self = this;
+		
+		this._headerDiv = jQuery('<div></div>').appendTo(this._container);
+		this._headerDiv.append('Format: ');
+		
+		this._formatSelector = jQuery('<select> '+
+				'<option value="FASTA">FASTA</option>'+
+				'<option value="CODATA">CODATA</option>'+
+				'<option value="PRIDE">PRIDE</option>'+
+				'<option value="RAW">RAW</option></select>').appendTo(self._headerDiv);
+
+		this._formatSelector.change(function(e) {
+			self.opt.format = jQuery(this).val();
+			self._redraw();
+		});
+		
+		this._formatSelector.val(self.opt.format);	
+		
+		this.formatSelectorVisible( this.opt.formatSelectorVisible );
+	},
+	
+	/**
+    * Highlights a region using the font color defined in {Sequence#highlightFontColor} by default is red.
+    *
+    * @example
+    * // highlight the characters within the position 100 to 150, included.
+    * mySequence.addHighlight( { "start": 100, "end": 150, "color": "white", "background": "red", "id": "aaa" } );
+    * 
+    * @param {Object} h The highlight defined as follows:
+    * 	
+    * 
+    * @return {int} representing the id of the highlight on the internal array. Returns -1 on failure  
+    */
+	addHighlight : function ( h ) {
+		var id = '-1';
+		var color = "";
+		var background = "";
+		var highlight = {};
+		
+		if ( h instanceof Object && h.start <= h.end ) {
+			
+			color = ( "string" == typeof h.color )? h.color : this.opt.highlightFontColor;
+			background = ( "string" == typeof h.background )? h.background : this.opt.highlightBackgroundColor;
+			id = ( "string" == typeof h.id )? h.id : (new Number(this._highlightsCount++)).toString();
+			
+			highlight = { "start": h.start, "end": h.end, "color": color, "background": background, "id": id };
+			
+			this._highlights.push(highlight);
+			this._applyHighlight(highlight);
+			this._restoreSelection(h.start,h.end);
+		} 
+		
+		return id;
+	},
+	/* 
+     * Function: Sequence._applyHighlight
+     * Purpose:  Apply the specified color and background to a region between 'start' and 'end'.
+     * Returns:  -
+     * Inputs: highlight -> {Object} An object containing the fields start (int), end (int), 
+     * 						color (HTML color string) and background (HTML color string).
+     */
+	_applyHighlight: function ( highlight ) {		
+		var seq = this._contentDiv.find('.sequence');
+		for ( var i = highlight.start - 1; i < highlight.end; i++ ){
+			zindex = jQuery(seq[i]).css("z-index");
+			if (zindex=="auto"){
+				 z = 1;
+				 o = 1;
+			 }
+			 else{
+				 z = 0;
+				 o = 0.5;
+			 }
+			jQuery(seq[i])
+				.css({ 
+					"color": highlight.color,
+					"background-color": highlight.background,
+					"z-index": z,
+					"opacity": o
+					})
+				.addClass("highlighted");
+		}
+	},
+	/* 
+     * Function: Sequence._applyHighlights
+     * Purpose:  Apply the specified highlights.
+     * Returns:  -
+     * Inputs: highlights -> {Object[]} An array containing the highlights to be applied.
+     */
+	_applyHighlights: function ( highlights ) {
+		for ( var i in highlights ) {
+			this._applyHighlight(highlights[i]);
+		}
+	},
+	/* 
+     * Function: Sequence._restoreHighlights
+     * Purpose:  Repaint the highlights in the specified region.
+     * Returns:  -
+     * Inputs: start -> {int} Start of the region to be restored.
+     * 		   end -> {int} End of the region to be restored.
+     */
+	_restoreHighlights: function ( start, end ) {
+		var h = this._highlights;
+		// paint the region using default blank settings
+		this._applyHighlight({
+			"start": start, 
+			"end": end, 
+			"color": this.opt.fontColor, 
+			"background": this.opt.backgroundColor 
+		});
+		// restore highlights in that region
+		for ( var i in h ) {
+			// interval intersects with highlight i ?
+			if ( !( h[i].start > end || h[i].end < start ) ) {
+				a = ( h[i].start < start ) ? start : h[i].start;
+				b = ( h[i].end > end ) ? end : h[i].end;
+				this._applyHighlight({
+					"start": a, 
+					"end": b, 
+					"color": h[i].color, 
+					"background": h[i].background 
+				});
+			}
+		}
+	},
+	/* 
+     * Function: Sequence._restoreSelection
+     * Purpose:  Repaint the current selection in the specified region. 
+     * 			 It is used in the case of any highlight do overriding of the current selection. 
+     * Returns:  -
+     * Inputs: start -> {int} Start of the region to be restored.
+     * 		   end -> {int} End of the region to be restored.
+     */
+	_restoreSelection: function ( start, end ) {
+		var sel = this.opt.selection;
+		// interval intersects with current selection ?
+		// restore selection
+		if ( !( start > sel.end || end < sel.start ) ) {
+			a = ( start < sel.start ) ? sel.start : start;
+			b = ( end > sel.end ) ? sel.end : end;
+			
+			this._applyHighlight({
+				"start": a, 
+				"end": b, 
+				"color": this.opt.selectionFontColor, 
+				"background": this.opt.selectionColor,
+			});
+		}
+	},
+	
+	/**
+    * Remove a highlight.
+    *
+    * @example
+    * // Clear the highlighted characters within the position 100 to 150, included.
+    * mySequence.removeHighlight("spin1");
+    * 
+    * @param {string} id The id of the highlight on the internal array. This value is returned by method highlight.
+    */
+	removeHighlight : function (id) {	
+		var h = this._highlights;
+		for ( i in h ) {
+			if ( h[i].id == id ) {
+				start = h[i].start;
+				end = h[i].end;
+				h.splice(i,1);
+				
+				this._restoreHighlights(start,end);
+				this._restoreSelection(start,end);
+				
+				break;
+			}
+		}
+	},
+	
+	/**
+    * Remove all the highlights of whole sequence.
+    *
+    * @example
+    * mySequence.removeAllHighlights();
+    */
+	removeAllHighlights : function () {
+		this._highlights = [];
+		this._restoreHighlights(1,this.opt.sequence.length);
+		this._restoreSelection(1,this.opt.sequence.length);
+	},
+	
+	/**
+    * Changes the current displaying format of the sequence.
+    *
+    * @example
+    * // Set format to 'FASTA'.
+    * mySequence.setFormat('FASTA');
+    * 
+    * @param {string} format The format for the sequence to be displayed.
+    */
+	setFormat : function(format) {
+		if ( this.opt.format != format.toUpperCase() ) {
+			this.opt.format = format.toUpperCase();
+			this._redraw();
+		}
+
+		var self = this;
+		// Changes the option in the combo box
+		this._headerDiv.find('option').each(function() {
+			if(jQuery(this).val() == self.opt.format.toUpperCase()) {
+				jQuery(this).attr('selected', 'selected');
+			}
+		});
+	},
+	
+	/**
+    * Changes the current number of columns in the displayed sequence.
+    *
+    * @example
+    * // Set the number of columns to 70.
+    * mySequence.setNumCols(70);
+    * 
+    * @param {int} numCols The number of columns.
+    */
+	setNumCols : function(numCols) {
+		this.opt.columns.size = numCols;
+		this._redraw();
+	},
+	
+	/**
+    * Set the visibility of the drop-down list of formats.
+    * 
+    * @param {boolean} visible true: show; false: hide.
+    */
+	formatSelectorVisible : function (visible){
+		if (visible) {
+			this._headerDiv.show();
+		} else {
+			this._headerDiv.hide();
+		}
+	},
+	
+	/**
+    * This is similar to a {Biojs.Protein3D#formatSelectorVisible} with the 'true' argument.
+    *
+    * @example
+    * // Shows the format selector.
+    * mySequence.showFormatSelector();
+    * 
+    */
+	showFormatSelector : function() {
+		this._headerDiv.show();
+	},
+	
+	/**
+    * This is similar to a {Biojs.Protein3D#formatSelectorVisible} with the 'false' argument.
+    * 
+    * @example
+    * // Hides the format selector.
+    * mySequence.hideFormatSelector();
+    * 
+    */
+	hideFormatSelector : function() {
+		this._headerDiv.hide();
+	},
+	
+	/**
+    * Hides the whole component.
+    * 
+    */
+	hide : function () {
+		this._headerDiv.hide();
+		this._contentDiv.hide();
+	},
+
+	/**
+    * Shows the whole component.
+    * 
+    */
+	show : function () {
+		this._headerDiv.show();
+		this._contentDiv.show();
+	},
+	/* 
+     * Function: Sequence._setSelection
+     * Purpose:  Update the current selection. 
+     * Returns:  -
+     * Inputs: start -> {int} Start of the region to be selected.
+     * 		   end -> {int} End of the region to be selected.
+     */
+	_setSelection : function(start, end) {
+		//alert("adsas");
+		
+		var current = this.opt.selection;
+		var change = {};
+		
+		// Which is the change on selection?
+		if ( current.start == start ) {
+			// forward?
+			if ( current.end < end ) {
+				change.start = current.end;
+				change.end = end;
+			} else {
+				this._restoreHighlights(end+1, current.end);
+			}
+		} else if ( current.end == end ) {
+			// forward?
+			if ( current.start > start ) {
+				change.start = start;
+				change.end = current.start;				
+			} else {
+				this._restoreHighlights(current.start, start-1);
+			}
+		} else {
+			this._restoreHighlights(current.start, current.end);
+			change.start = start;
+			change.end = end;
+		}
+
+		current.start = start;
+		current.end = end;
+	},
+	
+	/* 
+     * Function: Sequence._repaintSelection
+     * Purpose:  Repaint the whole current selection. 
+     * Returns:  -
+     * Inputs: -
+     */
+	_repaintSelection: function(){
+		var s = this.opt.selection;
+		this._setSelection(0,0);
+		this._setSelection(s.start,s.end);
+	},
+	
+	/* 
+     * Function: Sequence._redraw
+     * Purpose:  Repaint the current sequence. 
+     * Returns:  -
+     * Inputs: -
+     */
+	_redraw : function() {
+		var i = 0;	
+		var self = this;
+		
+		// Reset the content
+		//this._contentDiv.text('');
+		this._contentDiv.children().remove();
+		
+		// Rebuild the spans of the sequence 
+		// according to format
+		if(this.opt.format == 'RAW') {
+			this._drawRaw();
+		} else if(this.opt.format == 'CODATA') {
+			this._drawCodata();
+		} else if (this.opt.format == 'FASTA'){
+			this._drawFasta();
+		} else {
+			this.opt.format = 'PRIDE';
+			this._drawPride();
+		}
+		
+		// Restore the highlighted regions
+		this._applyHighlights(this._highlights);
+		this._repaintSelection();
+		this._addSpanEvents();
+	},
+	/* 
+     * Function: Sequence._drawFasta
+     * Purpose:  Repaint the current sequence using FASTA format.  
+     * Returns:  -
+     * Inputs: -
+     */
+	_drawFasta : function() {
+		var self = this;
+		var a = this.opt.sequence.toUpperCase().split('');
+		var pre = jQuery('<pre></pre>').appendTo(this._contentDiv);
+
+		var i = 1;
+		var arr = [];
+	    var str = '>' + this.opt.id + ' ' + a.length + ' bp<br/>';
+		
+		/* Correct column size in case the sequence is as small peptide */
+		var numCols = this.opt.columns.size;
+		if ( this.opt.sequence.length < this.opt.columns.size ) {
+			numCols = this.opt.sequence.length;	
+		}
+		
+	    var opt = {
+			numCols: numCols,
+		    numColsForSpace: 0
+		};
+
+		str += this._drawSequence(a, opt);
+		pre.html(str);
+		
+		this._drawAnnotations(opt);
+	},
+	/* 
+     * Function: Sequence._drawCodata
+     * Purpose:  Repaint the current sequence using CODATA format.  
+     * Returns:  -
+     * Inputs: -
+     */
+	_drawCodata : function() {
+		
+		var self = this;
+		var a = this.opt.sequence.toUpperCase().split('');
+		var pre = jQuery('<pre/>').appendTo(this._contentDiv);
+
+		var i = 0;
+		var str = 'ENTRY           ' + this.opt.id + '<br/>';
+		str += 'SEQUENCE<br/>';
+		if ( this.opt.formatOptions !== undefined ){
+			if(this.opt.formatOptions.title !== undefined ){
+				if (this.opt.formatOptions.title == false) {
+					str = '';
+				}			
+			}
+		} 
+		
+		/* Correct column size in case the sequence is as small peptide */
+		var numCols = this.opt.columns.size;
+		if ( this.opt.sequence.length < this.opt.columns.size ) {
+			numCols = this.opt.sequence.length;	
+		}
+		
+		var opt = {
+				numLeft: true,
+				numLeftSize: 7,
+				numLeftPad:' ',
+				numTop: true,
+				numTopEach: 5,
+				numCols: numCols,
+			    numColsForSpace: 0,
+			    spaceBetweenChars: true
+		};
+		
+		str += this._drawSequence(a, opt);
+		
+		var footer = '<br/>///';
+		if (this.opt.formatOptions !== undefined) {
+			if (this.opt.formatOptions.footer !== undefined) {
+				if (this.opt.formatOptions.footer == false) {
+					footer = '';
+				}
+			}
+		}
+		str += footer;
+		pre.html(str);
+		
+		this._drawAnnotations(opt);
+	},
+	/* 
+     * Function: Sequence._drawAnnotations
+     * Purpose:  Paint the annotations on the sequence.  
+     * Returns:  -
+     * Inputs: settings -> {object} 
+     */
+    _drawAnnotations: function ( settings ){ 
+    	
+    	var self = this;
+    	var a = this.opt.sequence.toLowerCase().split('');    	
+    	var annotations = this._annotations;
+    	var leftSpaces = '';
+    	var row = '';
+    	var annot = '';
+    	
+    	// Index at the left?
+		if ( settings.numLeft ) {
+			leftSpaces += this._formatIndex(' ', settings.numLeftSize+2, ' ');
+		}
+
+		for ( var i = 0; i < a.length; i += settings.numCols ){
+			row = '';
+			for ( var key in annotations ){
+				annotations[key].id = this.getId() + "_" + key;
+				annot = this._getHTMLRowAnnot(i+1, annotations[key], settings);				
+				if (annot.length > 0) {
+					row += '<br/>';
+					row += leftSpaces;
+					row += annot;
+					row += '<br/>';
+				} 
+			}
+			
+			var numCols = settings.numCols;
+			var charRemaining = a.length-i;
+			if(charRemaining < numCols){
+				numCols	= charRemaining;
+			}
+			
+			if ( settings.numRight ) {
+				jQuery(row).insertAfter('div#'+self.opt.target+' div pre span#numRight_' + this.getId() + '_' + (i + numCols) );
+			} else {
+				jQuery(row).insertAfter('div#'+self.opt.target+' div pre span#'+ this.getId() + '_' + (i + numCols) );
+			}
+		}
+		
+		// add tool tips and background' coloring effect
+		jQuery(this._contentDiv).find('.annotation').each( function(){
+			self._addToolTip( this, function() {
+				return self._getAnnotationString( jQuery(this).attr("id") );
+			});
+			
+			jQuery(this).mouseover(function(e) {
+				jQuery('.annotation.'+jQuery(e.target).attr("id")).each(function(){
+					jQuery(this).css("background-color", jQuery(this).attr("color") );
+				});
+		    }).mouseout(function() {
+		    	jQuery('.annotation').css("background-color", "transparent"); 
+		    	
+		    }).click(function(e) {
+		    		var name = undefined;
+		    		var id = jQuery(e.target).attr("id");
+		    		for(var i =0; i < self._annotations.length;i++){
+              if(self._annotations[i].id == id){
+                name = self._annotations[i].name;
+                continue;
+              }
+            }
+		    	self.trigger( EVT_ON_ANNOTATION_CLICKED, {
+	    		"name": name,
+		    		//"pos": parseInt( jQuery(e.target).attr("pos") )
+		    	});
+		    });
+			
+		});
+
+    },
+    /* 
+     * Function: Sequence._getAnnotationString
+     * Purpose:  Get the annotation text message for the tooltip 
+     * Returns:  {string} Annotation text for the annotation
+     * Inputs:   id -> {int} index of the internal annotation array
+     */
+    _getAnnotationString: function ( id ) {
+		var annotation = this._annotations[id.substr(id.indexOf("_") + 1)];
+		return annotation.name + "<br/>" + ((annotation.html)? annotation.html : '');
+    },
+    
+    /* 
+     * Function: Sequence._getHTMLRowAnnot
+     * Purpose:  Build an annotation
+     * Returns:  HTML of the annotation
+     * Inputs:   currentPos -> {int}
+     * 			 annotation -> {Object} 
+     *  		 settings -> {Object}
+     */
+    _getHTMLRowAnnot : function (currentPos, annotation, settings) {
+    	var styleBegin = 'border-left:1px solid; border-bottom:1px solid; border-color:';
+    	var styleOn = 'border-bottom:1px solid; border-color:';
+    	var styleEnd = 'border-bottom:1px solid; border-right:1px solid; border-color:';
+		var styleBeginAndEnd = 'border-left:1px solid; border-right:1px solid; border-bottom:1px solid; border-color:';
+    	
+    	var row = [];
+    	var end = (currentPos + settings.numCols);
+    	var spaceBetweenChars = (settings.spaceBetweenChars)? ' ' : '';    	
+    	var defaultColor = annotation.color;
+    	var id = annotation.id;
+    	for ( var pos=currentPos; pos < end ; pos++ ) {
+			// regions
+			for ( var r in annotation.regions ) {
+				region = annotation.regions[r];
+				
+				spaceAfter = '';
+				spaceAfter += (pos % settings.numColsForSpace == 0 )? ' ' : '';
+				spaceAfter += spaceBetweenChars;
+				
+				color = ((region.color)? region.color : defaultColor);
+				data = 'class="annotation '+id+'" id="'+id+'" color="'+color+'" pos="'+pos+'"';
+				
+				if ( pos == region.start && pos == region.end) {
+					row[pos] = '<span style="'+styleBeginAndEnd+color+'" '+data+'> ';
+					row[pos] += spaceAfter;
+					row[pos] += '</span>';
+				} else if ( pos == region.start ) {
+					row[pos] = '<span style="'+styleBegin+color+'" '+data+'> ';
+					row[pos] += spaceAfter;
+					row[pos] += '</span>';
+				} else if ( pos == region.end ) {
+					row[pos] = '<span style="'+styleEnd+color+' " '+data+'> ';
+					//row[pos] += spaceAfter;
+					row[pos] += '</span>';
+				} else if ( pos > region.start && pos < region.end ) {
+					row[pos] = '<span style="'+styleOn+color+'" '+data+'> ';
+					row[pos] += spaceAfter;
+					row[pos] += '</span>';
+				} else if (!row[pos]) {
+					row[pos] = ' ';
+					row[pos] += spaceAfter;
+				}
+			}
+		}
+
+       	var str = row.join("");
+    	
+    	return ( str.indexOf("span") == -1 )? "" : str;
+    },
+    /* 
+     * Function: Sequence._drawRaw
+     * Purpose:  Repaint the current sequence using RAW format.  
+     * Returns:  -
+     * Inputs: -
+     */
+	_drawRaw : function() {
+		var self = this;
+		var a = this.opt.sequence.toLowerCase().split('');
+		var i = 0;
+		var arr = [];
+		var pre = jQuery('<pre></pre>').appendTo(this._contentDiv);
+		
+		/* Correct column size in case the sequence is as small peptide */
+		var numCols = this.opt.columns.size;
+		if ( this.opt.sequence.length < this.opt.columns.size ) {
+			numCols = this.opt.sequence.length;	
+		}
+
+		var opt = {
+			numCols: numCols
+		};
+		
+		pre.html(
+			this._drawSequence(a, opt)
+		);
+		
+		this._drawAnnotations(opt);
+	},
+	/* 
+     * Function: Sequence._drawPride
+     * Purpose:  Repaint the current sequence using PRIDE format.  
+     * Returns:  -
+     * Inputs: -
+     */
+	_drawPride : function() {
+		var self = this;
+		var a = this.opt.sequence.toUpperCase().split('');
+		var pre = jQuery('<pre></pre>').appendTo(this._contentDiv);
+		
+		/* Correct column size in case the sequence is as small peptide */
+		var numCols = this.opt.columns.size;
+		if ( this.opt.sequence.length < this.opt.columns.size ) {
+			numCols = this.opt.sequence.length;	
+		}
+	
+		opt = {
+			numLeft: true,
+			numLeftSize: 5,
+			numLeftPad:'0',
+			numRight: true,
+			numRightSize: 5,
+			numRightPad: '0',
+			numCols: numCols,
+		    numColsForSpace: self.opt.columns.spacedEach
+		};
+		
+		pre.html(
+			this._drawSequence(a, opt)
+		);
+		
+		this._drawAnnotations(opt);
+	},
+	/* 
+     * Function: Sequence._drawSequence
+     * Purpose:  Repaint the current sequence using CUSTOM format.  
+     * Returns:  -
+     * Inputs:   a -> {char[]} a The sequence strand.
+     * 			 opt -> {Object} opt The CUSTOM format.
+     */
+	_drawSequence : function(a, opt) {
+		var str = '';
+
+		// Index at top?
+		if( opt.numTop )
+		{
+			str += '<span class="numTop pos-marker">'
+			var size = (opt.spaceBetweenChars)? opt.numTopEach*2: opt.numTopEach;
+			
+			if (opt.numLeft) {
+				str += this._formatIndex(' ', opt.numLeftSize, ' ');
+			}
+			
+			str += this._formatIndex(' ', size, ' ');
+			
+			for(var x = opt.numTopEach; x < opt.numCols; x += opt.numTopEach) {
+				str += this._formatIndex(x, size, ' ', true);
+			}
+			str += '</span>'
+		}
+		
+		
+		// Index at the left?
+		if (opt.numLeft) {
+			str += '<span id="numLeft_' + this.getId() + '_' + 0 + '"';
+			str += 'class="pos-marker">'
+			str += this._formatIndex(1, opt.numLeftSize, opt.numLeftPad);
+			str += '  ';
+			str += '</span>';
+		}
+
+		var j=1;
+		for (var i=1; i <= a.length; i++) {
+
+			if( i % opt.numCols == 0) {	
+				str += '<span class="sequence" id="' + this.getId() + '_' + i + '">' + a[i-1] + '</span>';
+				
+				if (opt.numRight) {
+					str += '<span id="numRight_' + this.getId() + '_' + i + '"';
+					str += 'class="pos-marker">'
+					str += '  ';
+					str += this._formatIndex(i, opt.numRightSize, opt.numRightPad);	
+					str += '</span>';
+				}
+				
+				str += '<br/>';
+				
+				var aaRemaining = a.length - i;
+				if (opt.numLeft && aaRemaining > 0) {
+					str += '<span id="numLeft_' + this.getId() + '_' + i + '"';
+					str += 'class="pos-marker">'
+					str += this._formatIndex(i+1, opt.numLeftSize, opt.numLeftPad);
+					str += '  ';
+					str += '</span>';
+				}
+				
+				j = 1;
+				
+			} else {
+                str += '<span class="sequence" id="' + this.getId() + '_' + i + '">' + a[i-1];
+				str += ( j % opt.numColsForSpace == 0)? ' ' : '';
+				str += (opt.spaceBetweenChars)? ' ' : '';
+				str += '</span>';
+				j++;
+			}
+		}
+		
+		str += '<br/>'	
+			
+		if (jQuery.browser.msie) {
+			str = "<pre>" + str + "</pre>";
+		}	
+			
+		return str;
+	},
+	/* 
+     * Function: Sequence._formatIndex
+     * Purpose:  Build the HTML corresponding to counting numbers (top, left, right) in the strand.
+     * Returns:  -
+     * Inputs:   number -> {int} The number 
+     * 			 size -> {int} Number of bins to suit the number.
+     * 			 fillingChar -> {char} Character to be used for filling out blank bins.
+     * 			 alignLeft -> {bool} Tell if aligned to the left.
+     */
+	_formatIndex : function( number, size, fillingChar, alignLeft) {
+		var str = number.toString();
+		var filling = '';
+		var padding = size - str.length;	
+		if ( padding > 0 ) {
+			while ( padding-- > 0 ) {
+				filling += ("<span>"+fillingChar+"</span>");
+			}
+			if (alignLeft){
+				str = number+filling;
+			} else {
+				str = filling+number;
+			}
+		}
+		return str;
+	},
+	/* 
+     * Function: Sequence._addSpanEvents
+     * Purpose:  Add the event handlers to the strand.
+     * Returns:  -
+     * Inputs:   -
+     */
+	_addSpanEvents : function() {
+		var self = this;
+		var isMouseDown = false;
+		var clickPos;
+		var currentPos;
+
+		self._contentDiv.find('.sequence').each( function () {	
+			
+			// Register the starting position
+			jQuery(this).mousedown(function() {
+				var id = jQuery(this).attr('id');
+				currentPos = parseInt(id.substr(id.indexOf("_") + 1));
+				clickPos = currentPos;
+				self._setSelection(clickPos,currentPos);
+				isMouseDown = true;
+				
+				// Selection is happening, raise an event
+				self.trigger(
+					EVT_ON_SELECTION_CHANGE, 
+					{ 
+						"start" : self.opt.selection.start, 
+						"end" : self.opt.selection.end 
+					}
+				);
+			
+			}).mouseover(function() {
+				// Update selection
+				// Show tooltip containing the position
+				var id = jQuery(this).attr('id');
+				currentPos = parseInt(id.substr(id.indexOf("_") + 1));
+				
+				if(isMouseDown) {
+					if( currentPos > clickPos ) {
+						self._setSelection(clickPos, currentPos);
+					} else {
+						self._setSelection(currentPos, clickPos);
+					}
+					
+					// Selection is happening, raise an event
+					self.trigger( EVT_ON_SELECTION_CHANGE, { 
+						"start" : self.opt.selection.start, 
+						"end" : self.opt.selection.end 
+					});
+				} 
+				
+			}).mouseup(function() {
+				isMouseDown = false;
+				// Selection is done, raise an event
+				self.trigger( EVT_ON_SELECTION_CHANGED, { 
+					"start" : self.opt.selection.start, 
+					"end" : self.opt.selection.end 
+				});
+			});
+			
+			// Add a tooltip for this sequence base.
+			self._addToolTip.call( self, this, function( ) {
+				if (isMouseDown) {
+	     			return "[" + self.opt.selection.start +", " + self.opt.selection.end + "]";
+	     		} else {
+	     			return currentPos;
+	     		}
+			});
+			
+		})
+		.css('cursor', 'pointer');
+	},
+	/* 
+     * Function: Sequence._addTooltip
+     * Purpose:  Add a tooltip around the target DOM element provided as argument
+     * Returns:  -
+     * Inputs:   target -> {Element} DOM element wich is the targeted focus for the tooltip.
+     * 			 cbGetMessageFunction -> {function} A callback function wich returns the message to be displayed in the tip.
+     */
+	_addToolTip : function ( target, cbGetMessageFunction ) {
+		
+ 		var tipId = this.opt._tooltip;
+		
+		jQuery(target).mouseover(function(e) {
+			
+	 		var offset = jQuery(e.target).offset();
+
+			if ( ! jQuery( tipId ).is(':visible') ) {
+		        jQuery( tipId ) 
+		        	.css({
+		        		'background-color': "#000",
+		        		'padding': "3px 10px 3px 10px",
+		        		'top': offset.top + jQuery(e.target).height() + "px",
+		        		'left': offset.left + jQuery(e.target).width() + "px"
+		        	})
+			        .animate( {opacity: '0.85'}, 10)
+			        .html( cbGetMessageFunction.call( target ) )
+			        .show();
+			}
+
+	    }).mouseout(function() {
+	        //Remove the appended tooltip template
+	        jQuery( tipId ).hide();	         
+	    });
+	},
+	
+	/**
+    * Annotate a set of intervals provided in the argument.
+    * 
+    * @example
+    * // Annotations using regions with different colors.
+    * mySequence.addAnnotation({
+	*    name:"UNIPROT", 
+	*    html:"&lt;br&gt; Example of &lt;b&gt;HTML&lt;/b&gt;", 
+	*    color:"green", 
+	*    regions: [
+	*       {start: 540, end: 560},
+	*       {start: 561, end:580, color: "#FFA010"}, 
+	*       {start: 581, end:590, color: "red"}, 
+	*       {start: 690, end:710}]
+	* });
+	* 
+    * 
+    * @param {Object} annotation The intervals belonging to the same annotation. 
+    * Syntax: { name: &lt;value&gt;, color: &lt;HTMLColorCode&gt;, html: &lt;HTMLString&gt;, regions: [{ start: &lt;startVal1&gt;, end: &lt;endVal1&gt;}, ...,  { start: &lt;startValN&gt;, end: &lt;endValN&gt;}] }
+    */
+	addAnnotation: function ( annotation ) {
+		this._annotations.push(annotation);
+		this._redraw();
+	},
+	
+	/**
+    * Removes an annotation by means of its name.
+    * 
+    * @example 
+    * // Remove the UNIPROT annotation.
+    * mySequence.removeAnnotation('UNIPROT'); 
+    * 
+    * @param {string} name The name of the annotation to be removed.
+    * 
+    */
+	removeAnnotation: function ( name ) {
+		for (var i=0; i < this._annotations.length ; i++ ){
+			if(name != this._annotations[i].name){
+				this._annotations.splice(i,1);
+				this._redraw();
+				break;
+			}
+		}
+	},
+	/**
+    * Removes all the current annotations.
+    * 
+    * @example 
+    * mySequence.removeAllAnnotations(); 
+    * 
+    */
+	removeAllAnnotations: function () {
+		this._annotations = [];
+		this._redraw();
+	},
+
+	
+});
+
+require("biojs-events").mixin(Sequence.prototype);
+module.exports = Sequence;
+
+},{"biojs-events":2,"jquery-browser-plugin":20,"js-class":22}],2:[function(require,module,exports){
+var events = require("backbone-events-standalone");
+
+events.onAll = function(callback,context){
+  this.on("all", callback,context);
+  return this;
+};
+
+// Mixin utility
+events.oldMixin = events.mixin;
+events.mixin = function(proto) {
+  events.oldMixin(proto);
+  // add custom onAll
+  var exports = ['onAll'];
+  for(var i=0; i < exports.length;i++){
+    var name = exports[i];
+    proto[name] = this[name];
+  }
+  return proto;
+};
+
+module.exports = events;
+
+},{"backbone-events-standalone":4}],3:[function(require,module,exports){
+/**
+ * Standalone extraction of Backbone.Events, no external dependency required.
+ * Degrades nicely when Backone/underscore are already available in the current
+ * global context.
+ *
+ * Note that docs suggest to use underscore's `_.extend()` method to add Events
+ * support to some given object. A `mixin()` method has been added to the Events
+ * prototype to avoid using underscore for that sole purpose:
+ *
+ *     var myEventEmitter = BackboneEvents.mixin({});
+ *
+ * Or for a function constructor:
+ *
+ *     function MyConstructor(){}
+ *     MyConstructor.prototype.foo = function(){}
+ *     BackboneEvents.mixin(MyConstructor.prototype);
+ *
+ * (c) 2009-2013 Jeremy Ashkenas, DocumentCloud Inc.
+ * (c) 2013 Nicolas Perriault
+ */
+/* global exports:true, define, module */
+(function() {
+  var root = this,
+      breaker = {},
+      nativeForEach = Array.prototype.forEach,
+      hasOwnProperty = Object.prototype.hasOwnProperty,
+      slice = Array.prototype.slice,
+      idCounter = 0;
+
+  // Returns a partial implementation matching the minimal API subset required
+  // by Backbone.Events
+  function miniscore() {
+    return {
+      keys: Object.keys || function (obj) {
+        if (typeof obj !== "object" && typeof obj !== "function" || obj === null) {
+          throw new TypeError("keys() called on a non-object");
+        }
+        var key, keys = [];
+        for (key in obj) {
+          if (obj.hasOwnProperty(key)) {
+            keys[keys.length] = key;
+          }
+        }
+        return keys;
+      },
+
+      uniqueId: function(prefix) {
+        var id = ++idCounter + '';
+        return prefix ? prefix + id : id;
+      },
+
+      has: function(obj, key) {
+        return hasOwnProperty.call(obj, key);
+      },
+
+      each: function(obj, iterator, context) {
+        if (obj == null) return;
+        if (nativeForEach && obj.forEach === nativeForEach) {
+          obj.forEach(iterator, context);
+        } else if (obj.length === +obj.length) {
+          for (var i = 0, l = obj.length; i < l; i++) {
+            if (iterator.call(context, obj[i], i, obj) === breaker) return;
+          }
+        } else {
+          for (var key in obj) {
+            if (this.has(obj, key)) {
+              if (iterator.call(context, obj[key], key, obj) === breaker) return;
+            }
+          }
+        }
+      },
+
+      once: function(func) {
+        var ran = false, memo;
+        return function() {
+          if (ran) return memo;
+          ran = true;
+          memo = func.apply(this, arguments);
+          func = null;
+          return memo;
+        };
+      }
+    };
+  }
+
+  var _ = miniscore(), Events;
+
+  // Backbone.Events
+  // ---------------
+
+  // A module that can be mixed in to *any object* in order to provide it with
+  // custom events. You may bind with `on` or remove with `off` callback
+  // functions to an event; `trigger`-ing an event fires all callbacks in
+  // succession.
+  //
+  //     var object = {};
+  //     _.extend(object, Backbone.Events);
+  //     object.on('expand', function(){ alert('expanded'); });
+  //     object.trigger('expand');
+  //
+  Events = {
+
+    // Bind an event to a `callback` function. Passing `"all"` will bind
+    // the callback to all events fired.
+    on: function(name, callback, context) {
+      if (!eventsApi(this, 'on', name, [callback, context]) || !callback) return this;
+      this._events || (this._events = {});
+      var events = this._events[name] || (this._events[name] = []);
+      events.push({callback: callback, context: context, ctx: context || this});
+      return this;
+    },
+
+    // Bind an event to only be triggered a single time. After the first time
+    // the callback is invoked, it will be removed.
+    once: function(name, callback, context) {
+      if (!eventsApi(this, 'once', name, [callback, context]) || !callback) return this;
+      var self = this;
+      var once = _.once(function() {
+        self.off(name, once);
+        callback.apply(this, arguments);
+      });
+      once._callback = callback;
+      return this.on(name, once, context);
+    },
+
+    // Remove one or many callbacks. If `context` is null, removes all
+    // callbacks with that function. If `callback` is null, removes all
+    // callbacks for the event. If `name` is null, removes all bound
+    // callbacks for all events.
+    off: function(name, callback, context) {
+      var retain, ev, events, names, i, l, j, k;
+      if (!this._events || !eventsApi(this, 'off', name, [callback, context])) return this;
+      if (!name && !callback && !context) {
+        this._events = {};
+        return this;
+      }
+
+      names = name ? [name] : _.keys(this._events);
+      for (i = 0, l = names.length; i < l; i++) {
+        name = names[i];
+        if (events = this._events[name]) {
+          this._events[name] = retain = [];
+          if (callback || context) {
+            for (j = 0, k = events.length; j < k; j++) {
+              ev = events[j];
+              if ((callback && callback !== ev.callback && callback !== ev.callback._callback) ||
+                  (context && context !== ev.context)) {
+                retain.push(ev);
+              }
+            }
+          }
+          if (!retain.length) delete this._events[name];
+        }
+      }
+
+      return this;
+    },
+
+    // Trigger one or many events, firing all bound callbacks. Callbacks are
+    // passed the same arguments as `trigger` is, apart from the event name
+    // (unless you're listening on `"all"`, which will cause your callback to
+    // receive the true name of the event as the first argument).
+    trigger: function(name) {
+      if (!this._events) return this;
+      var args = slice.call(arguments, 1);
+      if (!eventsApi(this, 'trigger', name, args)) return this;
+      var events = this._events[name];
+      var allEvents = this._events.all;
+      if (events) triggerEvents(events, args);
+      if (allEvents) triggerEvents(allEvents, arguments);
+      return this;
+    },
+
+    // Tell this object to stop listening to either specific events ... or
+    // to every object it's currently listening to.
+    stopListening: function(obj, name, callback) {
+      var listeners = this._listeners;
+      if (!listeners) return this;
+      var deleteListener = !name && !callback;
+      if (typeof name === 'object') callback = this;
+      if (obj) (listeners = {})[obj._listenerId] = obj;
+      for (var id in listeners) {
+        listeners[id].off(name, callback, this);
+        if (deleteListener) delete this._listeners[id];
+      }
+      return this;
+    }
+
+  };
+
+  // Regular expression used to split event strings.
+  var eventSplitter = /\s+/;
+
+  // Implement fancy features of the Events API such as multiple event
+  // names `"change blur"` and jQuery-style event maps `{change: action}`
+  // in terms of the existing API.
+  var eventsApi = function(obj, action, name, rest) {
+    if (!name) return true;
+
+    // Handle event maps.
+    if (typeof name === 'object') {
+      for (var key in name) {
+        obj[action].apply(obj, [key, name[key]].concat(rest));
+      }
+      return false;
+    }
+
+    // Handle space separated event names.
+    if (eventSplitter.test(name)) {
+      var names = name.split(eventSplitter);
+      for (var i = 0, l = names.length; i < l; i++) {
+        obj[action].apply(obj, [names[i]].concat(rest));
+      }
+      return false;
+    }
+
+    return true;
+  };
+
+  // A difficult-to-believe, but optimized internal dispatch function for
+  // triggering events. Tries to keep the usual cases speedy (most internal
+  // Backbone events have 3 arguments).
+  var triggerEvents = function(events, args) {
+    var ev, i = -1, l = events.length, a1 = args[0], a2 = args[1], a3 = args[2];
+    switch (args.length) {
+      case 0: while (++i < l) (ev = events[i]).callback.call(ev.ctx); return;
+      case 1: while (++i < l) (ev = events[i]).callback.call(ev.ctx, a1); return;
+      case 2: while (++i < l) (ev = events[i]).callback.call(ev.ctx, a1, a2); return;
+      case 3: while (++i < l) (ev = events[i]).callback.call(ev.ctx, a1, a2, a3); return;
+      default: while (++i < l) (ev = events[i]).callback.apply(ev.ctx, args);
+    }
+  };
+
+  var listenMethods = {listenTo: 'on', listenToOnce: 'once'};
+
+  // Inversion-of-control versions of `on` and `once`. Tell *this* object to
+  // listen to an event in another object ... keeping track of what it's
+  // listening to.
+  _.each(listenMethods, function(implementation, method) {
+    Events[method] = function(obj, name, callback) {
+      var listeners = this._listeners || (this._listeners = {});
+      var id = obj._listenerId || (obj._listenerId = _.uniqueId('l'));
+      listeners[id] = obj;
+      if (typeof name === 'object') callback = this;
+      obj[implementation](name, callback, this);
+      return this;
+    };
+  });
+
+  // Aliases for backwards compatibility.
+  Events.bind   = Events.on;
+  Events.unbind = Events.off;
+
+  // Mixin utility
+  Events.mixin = function(proto) {
+    var exports = ['on', 'once', 'off', 'trigger', 'stopListening', 'listenTo',
+                   'listenToOnce', 'bind', 'unbind'];
+    _.each(exports, function(name) {
+      proto[name] = this[name];
+    }, this);
+    return proto;
+  };
+
+  // Export Events as BackboneEvents depending on current context
+  if (typeof define === "function") {
+    define(function() {
+      return Events;
+    });
+  } else if (typeof exports !== 'undefined') {
+    if (typeof module !== 'undefined' && module.exports) {
+      exports = module.exports = Events;
+    }
+    exports.BackboneEvents = Events;
+  } else {
+    root.BackboneEvents = Events;
+  }
+})(this);
+
+},{}],4:[function(require,module,exports){
+module.exports = require('./backbone-events-standalone');
+
+},{"./backbone-events-standalone":3}],5:[function(require,module,exports){
+// Generated by CoffeeScript 1.8.0
+var GenericReader, xhr;
+
+xhr = require('nets');
+
+module.exports = GenericReader = (function() {
+  function GenericReader() {}
+
+  GenericReader.read = function(url, callback) {
+    var onret;
+    onret = (function(_this) {
+      return function(err, response, text) {
+        return _this._onRetrieval(text, callback);
+      };
+    })(this);
+    return xhr(url, onret);
+  };
+
+  GenericReader._onRetrieval = function(text, callback) {
+    var rText;
+    rText = this.parse(text);
+    return callback(rText);
+  };
+
+  return GenericReader;
+
+})();
+
+},{"nets":12}],6:[function(require,module,exports){
+// Generated by CoffeeScript 1.8.0
+var Fasta, GenericReader, Seq, Str,
+  __hasProp = {}.hasOwnProperty,
+  __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };
+
+Str = require("./strings");
+
+GenericReader = require("./generic_reader");
+
+Seq = require("biojs-model").seq;
+
+module.exports = Fasta = (function(_super) {
+  __extends(Fasta, _super);
+
+  function Fasta() {
+    return Fasta.__super__.constructor.apply(this, arguments);
+  }
+
+  Fasta.parse = function(text) {
+    var currentSeq, database, databaseID, identifiers, k, label, line, seqs, _i, _len;
+    seqs = [];
+    if (Object.prototype.toString.call(text) !== '[object Array]') {
+      text = text.split("\n");
+    }
+    for (_i = 0, _len = text.length; _i < _len; _i++) {
+      line = text[_i];
+      if (line[0] === ">" || line[0] === ";") {
+        label = line.slice(1);
+        currentSeq = new Seq("", label, seqs.length);
+        seqs.push(currentSeq);
+        if (Str.contains("|", line)) {
+          identifiers = label.split("|");
+          k = 1;
+          while (k < identifiers.length) {
+            database = identifiers[k];
+            databaseID = identifiers[k + 1];
+            currentSeq.meta[database] = databaseID;
+            k += 2;
+          }
+          currentSeq.name = identifiers[identifiers.length - 1];
+        }
+      } else {
+        currentSeq.seq += line;
+      }
+    }
+    return seqs;
+  };
+
+  return Fasta;
+
+})(GenericReader);
+
+},{"./generic_reader":5,"./strings":7,"biojs-model":10}],7:[function(require,module,exports){
+// Generated by CoffeeScript 1.8.0
+var strings;
+
+strings = {
+  contains: function(text, search) {
+    return ''.indexOf.call(text, search, 0) !== -1;
+  }
+};
+
+module.exports = strings;
+
+},{}],8:[function(require,module,exports){
+// Generated by CoffeeScript 1.8.0
+var Utils;
+
+Utils = {};
+
+Utils.splitNChars = function(txt, num) {
+  var i, result, _i, _ref;
+  result = [];
+  for (i = _i = 0, _ref = txt.length - 1; num > 0 ? _i <= _ref : _i >= _ref; i = _i += num) {
+    result.push(txt.substr(i, num));
+  }
+  return result;
+};
+
+module.exports = Utils;
+
+},{}],9:[function(require,module,exports){
+// Generated by CoffeeScript 1.8.0
+var FastaExporter, Utils;
+
+Utils = require("./utils");
+
+module.exports = FastaExporter = (function() {
+  function FastaExporter() {}
+
+  FastaExporter["export"] = function(seqs, access) {
+    var seq, text, _i, _len;
+    text = "";
+    for (_i = 0, _len = seqs.length; _i < _len; _i++) {
+      seq = seqs[_i];
+      if (access != null) {
+        seq = access(seq);
+      }
+      text += ">" + seq.name + "\n";
+      text += (Utils.splitNChars(seq.seq, 80)).join("\n");
+      text += "\n";
+    }
+    return text;
+  };
+
+  return FastaExporter;
+
+})();
+
+},{"./utils":8}],10:[function(require,module,exports){
+module.exports.seq = require("./seq");
+
+},{"./seq":11}],11:[function(require,module,exports){
+module.exports = function(seq, name, id) {
+    this.seq = seq;
+    this.name = name;
+    this.id = id;
+    this.meta = {};
+};
+
+},{}],12:[function(require,module,exports){
+var req = require('request')
+
+module.exports = Nets
+
+function Nets(uri, opts, cb) {
+  req(uri, opts, cb)
+}
+},{"request":13}],13:[function(require,module,exports){
+var window = require("global/window")
+var once = require("once")
+var parseHeaders = require('parse-headers')
+
+var messages = {
+    "0": "Internal XMLHttpRequest Error",
+    "4": "4xx Client Error",
+    "5": "5xx Server Error"
+}
+
+var XHR = window.XMLHttpRequest || noop
+var XDR = "withCredentials" in (new XHR()) ? XHR : window.XDomainRequest
+
+module.exports = createXHR
+
+function createXHR(options, callback) {
+    if (typeof options === "string") {
+        options = { uri: options }
+    }
+
+    options = options || {}
+    callback = once(callback)
+
+    var xhr = options.xhr || null
+
+    if (!xhr) {
+        if (options.cors || options.useXDR) {
+            xhr = new XDR()
+        }else{
+            xhr = new XHR()
+        }
+    }
+
+    var uri = xhr.url = options.uri || options.url
+    var method = xhr.method = options.method || "GET"
+    var body = options.body || options.data
+    var headers = xhr.headers = options.headers || {}
+    var sync = !!options.sync
+    var isJson = false
+    var key
+    var load = options.response ? loadResponse : loadXhr
+
+    if ("json" in options) {
+        isJson = true
+        headers["Accept"] = "application/json"
+        if (method !== "GET" && method !== "HEAD") {
+            headers["Content-Type"] = "application/json"
+            body = JSON.stringify(options.json)
+        }
+    }
+
+    xhr.onreadystatechange = readystatechange
+    xhr.onload = load
+    xhr.onerror = error
+    // IE9 must have onprogress be set to a unique function.
+    xhr.onprogress = function () {
+        // IE must die
+    }
+    // hate IE
+    xhr.ontimeout = noop
+    xhr.open(method, uri, !sync)
+                                    //backward compatibility
+    if (options.withCredentials || (options.cors && options.withCredentials !== false)) {
+        xhr.withCredentials = true
+    }
+
+    // Cannot set timeout with sync request
+    if (!sync) {
+        xhr.timeout = "timeout" in options ? options.timeout : 5000
+    }
+
+    if (xhr.setRequestHeader) {
+        for(key in headers){
+            if(headers.hasOwnProperty(key)){
+                xhr.setRequestHeader(key, headers[key])
+            }
+        }
+    } else if (options.headers) {
+        throw new Error("Headers cannot be set on an XDomainRequest object")
+    }
+
+    if ("responseType" in options) {
+        xhr.responseType = options.responseType
+    }
+    
+    if ("beforeSend" in options && 
+        typeof options.beforeSend === "function"
+    ) {
+        options.beforeSend(xhr)
+    }
+
+    xhr.send(body)
+
+    return xhr
+
+    function readystatechange() {
+        if (xhr.readyState === 4) {
+            load()
+        }
+    }
+
+    function getBody() {
+        // Chrome with requestType=blob throws errors arround when even testing access to responseText
+        var body = null
+
+        if (xhr.response) {
+            body = xhr.response
+        } else if (xhr.responseType === 'text' || !xhr.responseType) {
+            body = xhr.responseText || xhr.responseXML
+        }
+
+        if (isJson) {
+            try {
+                body = JSON.parse(body)
+            } catch (e) {}
+        }
+
+        return body
+    }
+
+    function getStatusCode() {
+        return xhr.status === 1223 ? 204 : xhr.status
+    }
+
+    // if we're getting a none-ok statusCode, build & return an error
+    function errorFromStatusCode(status, body) {
+        var error = null
+        if (status === 0 || (status >= 400 && status < 600)) {
+            var message = (typeof body === "string" ? body : false) ||
+                messages[String(status).charAt(0)]
+            error = new Error(message)
+            error.statusCode = status
+        }
+
+        return error
+    }
+
+    // will load the data & process the response in a special response object
+    function loadResponse() {
+        var status = getStatusCode()
+        var body = getBody()
+        var error = errorFromStatusCode(status, body)
+        var response = {
+            body: body,
+            statusCode: status,
+            statusText: xhr.statusText,
+            raw: xhr
+        }
+        if(xhr.getAllResponseHeaders){ //remember xhr can in fact be XDR for CORS in IE
+            response.headers = parseHeaders(xhr.getAllResponseHeaders())
+        } else {
+            response.headers = {}
+        }
+
+        callback(error, response, response.body)
+    }
+
+    // will load the data and add some response properties to the source xhr
+    // and then respond with that
+    function loadXhr() {
+        var status = getStatusCode()
+        var error = errorFromStatusCode(status)
+
+        xhr.status = xhr.statusCode = status
+        xhr.body = getBody()
+        xhr.headers = parseHeaders(xhr.getAllResponseHeaders())
+
+        callback(error, xhr, xhr.body)
+    }
+
+    function error(evt) {
+        callback(evt, xhr)
+    }
+}
+
+
+function noop() {}
+
+},{"global/window":14,"once":15,"parse-headers":19}],14:[function(require,module,exports){
+(function (global){
+if (typeof window !== "undefined") {
+    module.exports = window;
+} else if (typeof global !== "undefined") {
+    module.exports = global;
+} else if (typeof self !== "undefined"){
+    module.exports = self;
+} else {
+    module.exports = {};
+}
+
+}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+
+},{}],15:[function(require,module,exports){
+module.exports = once
+
+once.proto = once(function () {
+  Object.defineProperty(Function.prototype, 'once', {
+    value: function () {
+      return once(this)
+    },
+    configurable: true
+  })
+})
+
+function once (fn) {
+  var called = false
+  return function () {
+    if (called) return
+    called = true
+    return fn.apply(this, arguments)
+  }
+}
+
+},{}],16:[function(require,module,exports){
+var isFunction = require('is-function')
+
+module.exports = forEach
+
+var toString = Object.prototype.toString
+var hasOwnProperty = Object.prototype.hasOwnProperty
+
+function forEach(list, iterator, context) {
+    if (!isFunction(iterator)) {
+        throw new TypeError('iterator must be a function')
+    }
+
+    if (arguments.length < 3) {
+        context = this
+    }
+    
+    if (toString.call(list) === '[object Array]')
+        forEachArray(list, iterator, context)
+    else if (typeof list === 'string')
+        forEachString(list, iterator, context)
+    else
+        forEachObject(list, iterator, context)
+}
+
+function forEachArray(array, iterator, context) {
+    for (var i = 0, len = array.length; i < len; i++) {
+        if (hasOwnProperty.call(array, i)) {
+            iterator.call(context, array[i], i, array)
+        }
+    }
+}
+
+function forEachString(string, iterator, context) {
+    for (var i = 0, len = string.length; i < len; i++) {
+        // no such thing as a sparse string.
+        iterator.call(context, string.charAt(i), i, string)
+    }
+}
+
+function forEachObject(object, iterator, context) {
+    for (var k in object) {
+        if (hasOwnProperty.call(object, k)) {
+            iterator.call(context, object[k], k, object)
+        }
+    }
+}
+
+},{"is-function":17}],17:[function(require,module,exports){
+module.exports = isFunction
+
+var toString = Object.prototype.toString
+
+function isFunction (fn) {
+  var string = toString.call(fn)
+  return string === '[object Function]' ||
+    (typeof fn === 'function' && string !== '[object RegExp]') ||
+    (typeof window !== 'undefined' &&
+     // IE8 and below
+     (fn === window.setTimeout ||
+      fn === window.alert ||
+      fn === window.confirm ||
+      fn === window.prompt))
+};
+
+},{}],18:[function(require,module,exports){
+
+exports = module.exports = trim;
+
+function trim(str){
+  return str.replace(/^\s*|\s*$/g, '');
+}
+
+exports.left = function(str){
+  return str.replace(/^\s*/, '');
+};
+
+exports.right = function(str){
+  return str.replace(/\s*$/, '');
+};
+
+},{}],19:[function(require,module,exports){
+var trim = require('trim')
+  , forEach = require('for-each')
+  , isArray = function(arg) {
+      return Object.prototype.toString.call(arg) === '[object Array]';
+    }
+
+module.exports = function (headers) {
+  if (!headers)
+    return {}
+
+  var result = {}
+
+  forEach(
+      trim(headers).split('\n')
+    , function (row) {
+        var index = row.indexOf(':')
+          , key = trim(row.slice(0, index)).toLowerCase()
+          , value = trim(row.slice(index + 1))
+
+        if (typeof(result[key]) === 'undefined') {
+          result[key] = value
+        } else if (isArray(result[key])) {
+          result[key].push(value)
+        } else {
+          result[key] = [ result[key], value ]
+        }
+      }
+  )
+
+  return result
+}
+},{"for-each":16,"trim":18}],20:[function(require,module,exports){
+module.exports = require('./jquery.browser');
+
+},{"./jquery.browser":21}],21:[function(require,module,exports){
+/*!
+ * jQuery Browser Plugin v0.0.6
+ * https://github.com/gabceb/jquery-browser-plugin
+ *
+ * Original jquery-browser code Copyright 2005, 2013 jQuery Foundation, Inc. and other contributors
+ * http://jquery.org/license
+ *
+ * Modifications Copyright 2013 Gabriel Cebrian
+ * https://github.com/gabceb
+ *
+ * Released under the MIT license
+ *
+ * Date: 2013-07-29T17:23:27-07:00
+ */
+
+
+var matched, browser;
+
+var uaMatch = function( ua ) {
+  ua = ua.toLowerCase();
+
+  var match = /(opr)[\/]([\w.]+)/.exec( ua ) ||
+    /(chrome)[ \/]([\w.]+)/.exec( ua ) ||
+    /(version)[ \/]([\w.]+).*(safari)[ \/]([\w.]+)/.exec( ua ) ||
+    /(webkit)[ \/]([\w.]+)/.exec( ua ) ||
+    /(opera)(?:.*version|)[ \/]([\w.]+)/.exec( ua ) ||
+    /(msie) ([\w.]+)/.exec( ua ) ||
+    ua.indexOf("trident") >= 0 && /(rv)(?::| )([\w.]+)/.exec( ua ) ||
+    ua.indexOf("compatible") < 0 && /(mozilla)(?:.*? rv:([\w.]+)|)/.exec( ua ) ||
+    [];
+
+  var platform_match = /(ipad)/.exec( ua ) ||
+    /(iphone)/.exec( ua ) ||
+    /(android)/.exec( ua ) ||
+    /(windows phone)/.exec( ua ) ||
+    /(win)/.exec( ua ) ||
+    /(mac)/.exec( ua ) ||
+    /(linux)/.exec( ua ) ||
+    /(cros)/i.exec( ua ) ||
+    [];
+
+  return {
+    browser: match[ 3 ] || match[ 1 ] || "",
+    version: match[ 2 ] || "0",
+    platform: platform_match[ 0 ] || ""
+  };
+};
+
+matched = uaMatch( window.navigator.userAgent );
+browser = {};
+browser.uaMatch = uaMatch;
+
+if ( matched.browser ) {
+  browser[ matched.browser ] = true;
+  browser.version = matched.version;
+  browser.versionNumber = parseInt(matched.version);
+}
+
+if ( matched.platform ) {
+  browser[ matched.platform ] = true;
+}
+
+// These are all considered mobile platforms, meaning they run a mobile browser
+if ( browser.android || browser.ipad || browser.iphone || browser[ "windows phone" ] ) {
+  browser.mobile = true;
+}
+
+// These are all considered desktop platforms, meaning they run a desktop browser
+if ( browser.cros || browser.mac || browser.linux || browser.win ) {
+  browser.desktop = true;
+}
+
+// Chrome, Opera 15+ and Safari are webkit based browsers
+if ( browser.chrome || browser.opr || browser.safari ) {
+  browser.webkit = true;
+}
+
+// IE11 has a new token so we will assign it msie to avoid breaking changes
+if ( browser.rv )
+{
+  var ie = "msie";
+
+  matched.browser = ie;
+  browser[ie] = true;
+}
+
+// Opera 15+ are identified as opr
+if ( browser.opr )
+{
+  var opera = "opera";
+
+  matched.browser = opera;
+  browser[opera] = true;
+}
+
+// Stock Android browsers are marked as Safari on Android.
+if ( browser.safari && browser.android )
+{
+  var android = "android";
+
+  matched.browser = android;
+  browser[android] = true;
+}
+
+// Assign the name and platform variable
+browser.name = matched.browser;
+browser.platform = matched.platform;
+
+
+module.exports = browser;
+
+},{}],22:[function(require,module,exports){
+(function (global){
+/** @preserve http://github.com/easeway/js-class */
+
+// Class Definition using ECMA5 prototype chain
+
+function inherit(dest, src, noParent) {
+    while (src && src !== Object.prototype) {
+        Object.getOwnPropertyNames(src).forEach(function (name) {
+            if (name != '.class' && !dest.hasOwnProperty(name)) {
+                var desc = Object.getOwnPropertyDescriptor(src, name);
+                Object.defineProperty(dest, name, desc);
+            }
+        });
+        if (noParent) {
+            break;
+        }
+        src = src.__proto__;
+    }
+    return dest;
+}
+
+var Class = function (base, proto, options) {
+    if (typeof(base) != 'function') {
+        options = proto;
+        proto = base;
+        base = Object;
+    }
+    if (!proto) {
+        proto = {};
+    }
+    if (!options) {
+        options = {};
+    }
+    
+    var meta = {
+        name: options.name,
+        base: base,
+        implements: []
+    }
+    var classProto = Class.clone(proto);
+    if (options.implements) {
+        (Array.isArray(options.implements) ? options.implements : [options.implements])
+            .forEach(function (implementedType) {
+                if (typeof(implementedType) == 'function' && implementedType.prototype) {
+                    meta.implements.push(implementedType);
+                    Class.extend(classProto, implementedType.prototype);
+                }
+            });
+    }
+    classProto.__proto__ = base.prototype;
+    var theClass = function () {
+        if (typeof(this.constructor) == 'function') {
+            this.constructor.apply(this, arguments);
+        }
+    };
+    meta.type = theClass;
+    theClass.prototype = classProto;
+    Object.defineProperty(theClass, '.class.meta', { value: meta, enumerable: false, configurable: false, writable: false });
+    Object.defineProperty(classProto, '.class', { value: theClass, enumerable: false, configurable: false, writable: false });
+    if (options.statics) {
+        Class.extend(theClass, options.statics);
+    }
+    return theClass;
+};
+
+Class.extend = inherit;
+
+Class.clone = function (object) {
+    return inherit({}, object);
+};
+
+function findType(meta, type) {
+    while (meta) {
+        if (meta.type.prototype === type.prototype) {
+            return true;
+        }
+        for (var i in meta.implements) {
+            var implType = meta.implements[i];
+            var implMeta = implType['.class.meta'];
+            if (implMeta) {
+                if (findType(implMeta, type)) {
+                    return true;
+                }
+            } else {
+                for (var proto = implType.prototype; proto; proto = proto.__proto__) {
+                    if (proto === type.prototype) {
+                        return true;
+                    }
+                }
+            }
+        }
+        meta = meta.base ? meta.base['.class.meta'] : undefined;
+    }
+    return false;
+}
+
+var Checker = Class({
+    constructor: function (object) {
+        this.object = object;
+    },
+    
+    typeOf: function (type) {
+        if (this.object instanceof type) {
+            return true;
+        }
+        var meta = Class.typeInfo(this.object);
+        return meta && findType(meta, type);
+    }
+});
+
+// aliases
+Checker.prototype.a = Checker.prototype.typeOf;
+Checker.prototype.an = Checker.prototype.typeOf;
+
+Class.is = function (object) {
+    return new Checker(object);
+};
+
+Class.typeInfo = function (object) {
+    var theClass = object.__proto__['.class'];
+    return theClass ? theClass['.class.meta'] : undefined;
+};
+
+Class.VERSION = [0, 0, 2];
+
+if (module) {
+    module.exports = Class;
+} else {
+    global.Class = Class;   // for browser
+}
+}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
+
+},{}],"biojs-io-fasta":[function(require,module,exports){
+// Generated by CoffeeScript 1.8.0
+module.exports.parse = require("./parser");
+
+module.exports.writer = require("./writer");
+
+},{"./parser":6,"./writer":9}],"biojs-vis-sequence":[function(require,module,exports){
+module.exports = require("./lib/index");
+
+},{"./lib/index":1}]},{},["biojs-vis-sequence"])
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["node_modules/browserify/node_modules/browser-pack/_prelude.js","/Users/priyam/sequenceserver/node_modules/biojs-vis-sequence/lib/index.js","/Users/priyam/sequenceserver/node_modules/biojs-vis-sequence/node_modules/biojs-events/index.js","/Users/priyam/sequenceserver/node_modules/biojs-vis-sequence/node_modules/biojs-events/node_modules/backbone-events-standalone/backbone-events-standalone.js","/Users/priyam/sequenceserver/node_modules/biojs-vis-sequence/node_modules/biojs-events/node_modules/backbone-events-standalone/index.js","/Users/priyam/sequenceserver/node_modules/biojs-vis-sequence/node_modules/biojs-io-fasta/lib/generic_reader.js","/Users/priyam/sequenceserver/node_modules/biojs-vis-sequence/node_modules/biojs-io-fasta/lib/parser.js","/Users/priyam/sequenceserver/node_modules/biojs-vis-sequence/node_modules/biojs-io-fasta/lib/strings.js","/Users/priyam/sequenceserver/node_modules/biojs-vis-sequence/node_modules/biojs-io-fasta/lib/utils.js","/Users/priyam/sequenceserver/node_modules/biojs-vis-sequence/node_modules/biojs-io-fasta/lib/writer.js","/Users/priyam/sequenceserver/node_modules/biojs-vis-sequence/node_modules/biojs-io-fasta/node_modules/biojs-model/src/index.js","/Users/priyam/sequenceserver/node_modules/biojs-vis-sequence/node_modules/biojs-io-fasta/node_modules/biojs-model/src/seq.js","/Users/priyam/sequenceserver/node_modules/biojs-vis-sequence/node_modules/biojs-io-fasta/node_modules/nets/index.js","/Users/priyam/sequenceserver/node_modules/biojs-vis-sequence/node_modules/biojs-io-fasta/node_modules/nets/node_modules/xhr/index.js","node_modules/biojs-io-fasta/node_modules/nets/node_modules/xhr/node_modules/global/window.js","/Users/priyam/sequenceserver/node_modules/biojs-vis-sequence/node_modules/biojs-io-fasta/node_modules/nets/node_modules/xhr/node_modules/once/once.js","/Users/priyam/sequenceserver/node_modules/biojs-vis-sequence/node_modules/biojs-io-fasta/node_modules/nets/node_modules/xhr/node_modules/parse-headers/node_modules/for-each/index.js","/Users/priyam/sequenceserver/node_modules/biojs-vis-sequence/node_modules/biojs-io-fasta/node_modules/nets/node_modules/xhr/node_modules/parse-headers/node_modules/for-each/node_modules/is-function/index.js","/Users/priyam/sequenceserver/node_modules/biojs-vis-sequence/node_modules/biojs-io-fasta/node_modules/nets/node_modules/xhr/node_modules/parse-headers/node_modules/trim/index.js","/Users/priyam/sequenceserver/node_modules/biojs-vis-sequence/node_modules/biojs-io-fasta/node_modules/nets/node_modules/xhr/node_modules/parse-headers/parse-headers.js","/Users/priyam/sequenceserver/node_modules/biojs-vis-sequence/node_modules/jquery-browser-plugin/index.js","/Users/priyam/sequenceserver/node_modules/biojs-vis-sequence/node_modules/jquery-browser-plugin/jquery.browser.js","node_modules/js-class/class.js","/Users/priyam/sequenceserver/node_modules/biojs-vis-sequence/node_modules/biojs-io-fasta/lib/index.js","./index.js"],"names":[],"mappings":"AAAA;ACAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC75CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACrRA;AACA;;ACDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC3BA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACVA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACfA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC1BA;AACA;;ACDA;AACA;AACA;AACA;AACA;AACA;AACA;;ACNA;AACA;AACA;AACA;AACA;AACA;AACA;;ACNA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;ACjLA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;ACTA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACnBA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9CA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACfA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;ACdA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AC9BA;AACA;;ACDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AC9GA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;AChIA;AACA;AACA;AACA;AACA;;ACJA;AACA","file":"generated.js","sourceRoot":"","sourcesContent":["(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error(\"Cannot find module '\"+o+\"'\");throw f.code=\"MODULE_NOT_FOUND\",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})","// legacy!!\n$.browser = require(\"jquery-browser-plugin\");\n\n/** \n * Sequence component \n * \n * @class\n * @extends Biojs\n * \n * @author <a href=\"mailto:johncar@gmail.com\">John Gomez</a>, <a href=\"mailto:secevalliv@gmail.com\">Jose Villaveces</a>\n * @version 1.0.0\n * @category 3\n * \n * @requires <a href='http://blog.jquery.com/2011/09/12/jquery-1-6-4-released/'>jQuery Core 1.6.4</a>\n * @dependency <script language=\"JavaScript\" type=\"text/javascript\" src=\"../biojs/dependencies/jquery/jquery-1.4.2.min.js\"></script>\n * \n * @requires <a href='http://jqueryui.com/download'>jQuery UI 1.8.16</a>\n * @dependency <script language=\"JavaScript\" type=\"text/javascript\" src=\"../biojs/dependencies/jquery/jquery-ui-1.8.2.custom.min.js\"></script>\n *\n * @requires <a href='Biojs.Tooltip.css'>Biojs.Tooltip</a>\n * @dependency <script language=\"JavaScript\" type=\"text/javascript\" src=\"src/Biojs.Tooltip.js\"></script>\n * \n * @param {Object} options An object with the options for Sequence component.\n *    \n * @option {string} target \n *    Identifier of the DIV tag where the component should be displayed.\n *    \n * @option {string} sequence \n *    The sequence to be displayed.\n *    \n * @option {string} [id] \n *    Sequence identifier if apply.\n *    \n * @option {string} [format=\"FASTA\"] \n *    The display format for the sequence representation.\n *    \n * @option {Object[]} [highlights] \n * \t  For highlighting multiple regions. \n *    <pre class=\"brush: js\" title=\"Syntax:\"> \n *    [\n *    \t// Highlight aminoacids from 'start' to 'end' of the current strand using the specified 'color' (optional) and 'background' (optional).\n *    \t{ start: &lt;startVal1&gt;, end: &lt;endVal1&gt; [, id:&lt;idVal1&gt;] [, color: &lt;HTMLColor&gt;] [, background: &lt;HTMLColor&gt;]}, \n *    \t//\n *    \t// Any others highlights\n *    \t...,  \n *    \t// \n *    \t{ start: &lt;startValN&gt;, end: &lt;endValN&gt; [, id:&lt;idValN&gt;] [, color: &lt;HTMLColor&gt;] [, background: &lt;HTMLColor&gt;]}\n *    ]</pre>\n * \n * <pre class=\"brush: js\" title=\"Example:\"> \n * highlights : [\n * \t\t{ start:30, end:42, color:\"white\", background:\"green\", id:\"spin1\" },\n *\t\t{ start:139, end:140 }, \n *\t\t{ start:631, end:633, color:\"white\", background:\"blue\" }\n *\t]\n * </pre>\n * \n * @option {Object} [columns={size:40,spacedEach:10}] \n * \t  Options for displaying the columns. Syntax: { size: &lt;numCols&gt;, spacedEach: &lt;numCols&gt;}\n * \n * @option {Object} [selection] \n * \t  Positions for the current selected region. Syntax: { start: &lt;startValue&gt;, end: &lt;endValue&gt;}\n * \n * @option {Object[]} [annotations] \n *    Set of overlapping annotations. Must be an array of objects following the syntax:\n *     \t\t<pre class=\"brush: js\" title=\"Syntax:\">\n *            [ \n *              // An annotation:\n *              { name: &lt;name&gt;, \n *                html: &lt;message&gt;, \n *                color: &lt;color_code&gt;, \n *                regions: [{ start: &lt;startVal1&gt;, end: &lt;endVal1&gt; color: &lt;HTMLColor&gt;}, ...,{ start: &lt;startValN&gt;, end: &lt;endValN&gt;, color: &lt;HTMLColor&gt;}] \n *              }, \n *              \n *              // ...\n *              // more annotations here \n *              // ...\n *            ]\n *    \t\t </pre>\n *    where:\n *      <ul>\n *        <li><b>name</b> is the unique name for the annotation</li>\n *        <li><b>html</b> is the message (can be HTML) to be displayed in the tool tip.</li>\n *        <li><b>color</b> is the default HTML color code for all the regions.</li>\n *        <li><b>regions</b> array of objects defining the intervals which belongs to the annotation.</li>\n *        <li><b>regions[i].start</b> is the starting character for the i-th interval.</li>\n *        <li><b>regions[i].end</b> is the ending character for the i-th interval.</li>\n *        <li><b>regions[i].color</b> is an optional color for the i-th interval.   \n *      </ul> \n *      \n * @option {Object} [formatOptions={title:true, footer:true}] \n * \t  Options for displaying the title. by now just affecting the CODATA format.\n *    <pre class=\"brush: js\" title=\"Syntax:\"> \n * \t\tformatOptions : {\n * \t\t\ttitle:false,\n * \t\t\tfooter:false\n * \t\t}\n *    </pre>\n *    \n * @example \n * var theSequence = \"METLCQRLNVCQDKILTHYENDSTDLRDHIDYWKHMRLECAIYYKAREMGFKHINHQVVPTLAVSKNKALQAIELQLTLETIYNSQYSNEKWTLQDVSLEVYLTAPTGCIKKHGYTVEVQFDGDICNTMHYTNWTHIYICEEAojs SVTVVEGQVDYYGLYYVHEGIRTYFVQFKDDAEKYSKNKVWEVHAGGQVILCPTSVFSSNEVSSPEIIRQHLANHPAATHTKAVALGTEETQTTIQRPRSEPDTGNPCHTTKLLHRDSVDSAPILTAFNSSHKGRINCNSNTTPIVHLKGDANTLKCLRYRFKKHCTLYTAVSSTWHWTGHNVKHKSAIVTLTYDSEWQRDQFLSQVKIPKTITVSTGFMSI\";\n * var mySequence = new Sequence({\n * \t\tsequence : theSequence,\n * \t\ttarget : \"YourOwnDivId\",\n * \t\tformat : 'CODATA',\n * \t\tid : 'P918283',\n * \t\tannotations: [\n *        { name:\"CATH\", \n * \t  \t\tcolor:\"#F0F020\", \n * \t  \t\thtml: \"Using color code #F0F020 \", \n * \t  \t\tregions: [{start: 122, end: 135}]\n * \t\t  },\n *        { name:\"TEST\", \n *          html:\"&lt;br&gt; Example of &lt;b&gt;HTML&lt;/b&gt;\", \n *          color:\"green\", \n *          regions: [\n *            {start: 285, end: 292},\n *            {start: 293, end: 314, color: \"#2E4988\"}]\n *        }\n *      ],\n *      highlights : [\n *      \t{ start:30, end:42, color:\"white\", background:\"green\", id:\"spin1\" },\n *      \t{ start:139, end:140 }, \n *      \t{ start:631, end:633, color:\"white\", background:\"blue\" }\n *      ]\n * });\t\n * \n */\n\nvar Class = require('js-class');\n\nvar EVT_ON_SELECTION_CHANGE= \"onSelectionChange\";\nvar EVT_ON_SELECTION_CHANGED= \"onSelectionChanged\";\nvar EVT_ON_ANNOTATION_CLICKED= \"onAnnotationClicked\";\n\nSequence = Class(\n/** @lends Sequence# */\n{\t\n\tconstructor: function (options) {\n\t\tvar self = this;\n\n    this.opt = jQuery.extend(this.opt,options);\n\n    this._container = jQuery(this.opt.target );\n    \n    // legacy support (target id without '#')\n    if(this._container.length == 0){\n      this._container = jQuery( \"#\" + this.opt.target )\n    }\n\n    if(this._container.length == 0){\n      console.log(\"empty target container\");\n    }\n\n    // legacy: copy target id\n    this.opt.target = this._container[0].id;\n\t\t\n\t\t// Lazy initialization \n\t\tthis._container.ready(function() {\n\t\t\tself._initialize();\n\t\t});\n\t},\n\t\n\t/**\n\t * Default values for the options\n\t * @name Sequence-opt\n\t */\n\topt : {\n\t\t\n\t\tsequence : \"\",\n\t\tid : \"\",\n\t\ttarget : \"\",\n\t\tformat : \"FASTA\",\n\t\tselection: { start: 0, end: 0 },\n\t\tcolumns: { size: 35, spacedEach: 10 },\n\t\thighlights : [],\n\t\tannotations: [],\n\t\tsequenceUrl: 'http://www.ebi.ac.uk/das-srv/uniprot/das/uniprot/sequence',\n\t\t\n\t\t// Styles \n\t\tselectionColor : 'Yellow',\n\t\tselectionFontColor : 'black',\n\t\thighlightFontColor : 'red',\n\t\thighlightBackgroundColor : 'white',\n\t\tfontFamily: '\"Andale mono\", courier, monospace',\n\t\tfontSize: '12px',\n\t\tfontColor : 'inherit',\n\t\tbackgroundColor : 'inherit',\n\t\twidth: undefined,\n\t\theight: undefined,\n\t\tformatSelectorVisible: true\n\t},\n\t\n\t/**\n\t * Array containing the supported event names\n\t * @name Sequence-eventTypes\n\t */\n\teventTypes : [\n\t\t/**\n\t\t * @name Sequence#onSelectionChanged\n\t\t * @event\n\t\t * @param {function} actionPerformed An function which receives an {@link Biojs.Event} object as argument.\n\t\t * @eventData {Object} source The component which did triggered the event.\n\t\t * @eventData {string} type The name of the event.\n\t\t * @eventData {int} start A number indicating the start of the selection.\n\t\t * @eventData {int} end A number indicating the ending of selection.\n\t\t * @example \n\t\t * mySequence.onSelectionChanged(\n\t\t *    function( objEvent ) {\n\t\t *       alert(\"Selected: \" + objEvent.start + \", \" + objEvent.end );\n\t\t *    }\n\t\t * ); \n\t\t * \n\t\t * */\n\t\t\"onSelectionChanged\",\n\t\t\n\t\t/**\n\t\t * @name Sequence#onSelectionChange\n\t\t * @event\n\t\t * @param {function} actionPerformed An function which receives an {@link Biojs.Event} object as argument.\n\t\t * @eventData {Object} source The component which did triggered the event.\n\t\t * @eventData {string} type The name of the event.\n\t\t * @eventData {int} start A number indicating the start of the selection.\n\t\t * @eventData {int} end A number indicating the ending of selection.\n\t\t * @example \n\t\t * mySequence.onSelectionChange(\n\t\t *    function( objEvent ) {\n\t\t *       alert(\"Selection in progress: \" + objEvent.start + \", \" + objEvent.end );\n\t\t *    }\n\t\t * );  \n\t\t * \n\t\t * \n\t\t * */\n\t\t\"onSelectionChange\",\n\t\t\n\t\t/**\n\t\t * @name Sequence#onAnnotationClicked\n\t\t * @event\n\t\t * @param {function} actionPerformed An function which receives an {@link Biojs.Event} object as argument.\n\t\t * @eventData {Object} source The component which did triggered the event.\n\t\t * @eventData {string} type The name of the event.\n\t\t * @eventData {string} name The name of the selected annotation.\n\t\t * @eventData {int} pos A number indicating the position of the selected amino acid.\n\t\t * @example \n\t\t * mySequence.onAnnotationClicked(\n\t\t *    function( objEvent ) {\n\t\t *       alert(\"Clicked \" + objEvent.name + \" on position \" + objEvent.pos );\n\t\t *    }\n\t\t * );  \n\t\t * \n\t\t * */\n\t\t\"onAnnotationClicked\"\n\t],\n\n  getId : function () {\n    return this.opt.id;\n  },\n\n\t// internal members\n\t_headerDiv : null,\n\t_contentDiv : null,\n\t\n\t// Methods\n\n\t_initialize: function () {\n\t\t\n\t\tif ( this.opt.width !== undefined ) {\n\t\t\tthis._container.width( this.opt.width );\n\t\t}\n\t\t\n\t\tif ( this.opt.height !== undefined ) {\n\t\t\tthis._container.height( this.opt.height );\n\t\t}\n\t\t\n\t\t// Disable text selection\n\t\t\n\t\tthis._container.css({\n\t\t\t'-moz-user-select':'none',\n\t\t\t'-webkit-user-select':'none',\n\t\t\t'user-select':'none'\n        });\n\t\t\n\t\t// DIV for the format selector\n\t\tthis._buildFormatSelector();\n\t\t\n\t\t// DIV for the sequence\n\t\tthis._contentDiv = jQuery('<div></div>').appendTo(this._container);\n\t\tthis._contentDiv.css({\n\t\t\t\t'font-family': this.opt.fontFamily,\n\t\t\t\t'font-size': this.opt.fontSize,\n\t\t\t\t'text-align': 'left'\n\t\t\t});\n\t\t\n\t\t// Initialize highlighting \n\t\tthis._highlights = this.opt.highlights;\n\t\t\n\t\t// Initialize annotations\n\t\tthis._annotations = this.opt.annotations;\n\t\t\n\t\t//Initialize tooltip\n\t\tvar tooltip = \"sequenceTip\" + this.opt.target ;\n\t\tjQuery('<div id=\"' + tooltip + '\"></div>') \n\t        .css({\t\n\t        \t'position': \"absolute\",\n\t        \t'z-index': \"999999\",\n\t        \t'color': \"#fff\",\n\t        \t'font-size': \"12px\",\n\t        \t'width': \"auto\",\n\t        \t'display': 'none'\n\t        })\n\t        .addClass(\"tooltip\")\n\t        .appendTo(\"body\")\n\t        .hide();\n\t\tthis.opt._tooltip = document.getElementById(tooltip);\n\n\t\tif ( (this.opt.sequence) ) {\n\t\t\tthis._redraw();\n\t\t\t\n\t\t} else if (  (this.opt.id) ) {\n\t\t\tthis._requestSequence( this.opt.id );\n\t\t\t\n\t\t} else {\n\t\t\tthis.clearSequence(\"No sequence available\", \"../biojs/css/images/warning_icon.png\");\n\t\t}\n\t\t\n\t},\n\t\n\t\n\t/**\n\t * Shows the columns indicated by the indexes array.\n\t * @param {string} seq The sequence strand.\n\t * @param {string} [identifier] Sequence identifier.\n\t * \n\t * @example \n\t * mySequence.setSequence(\"P99999\");\n\t * \n\t */\n    setSequence: function ( seq, identifier ) {\n\n    \tif ( seq.match(/^([A-N,R-Z][0-9][A-Z][A-Z, 0-9][A-Z, 0-9][0-9])|([O,P,Q][0-9][A-Z, 0-9][A-Z, 0-9][A-Z, 0-9][0-9])(\\.\\d+)?$/i) ) {\n    \t\tthis._requestSequence( arguments[0] );\n    \t\t\n    \t} else {\n    \t\tthis.opt.sequence = seq;\n        \tthis.opt.id = identifier; \n        \tthis._highlights = [];\n    \t\tthis._highlightsCount = 0;\n    \t\tthis.opt.selection = { start: 0, end: 0 };\n    \t\tthis._annotations = [];\n    \t\t\n    \t\tthis._contentDiv.children().remove();\n    \t\tthis._redraw();\n    \t}\n    },\n    \n    _requestSequence: function ( accession ) {\n\t\tvar self = this;\n    \t\n    \tconsole.log(\"Requesting sequence for: \" + accession );\n\n\t\tjQuery.ajax({ \n\t\t\turl: self.opt.sequenceUrl,\n\t\t\tdataType: \"xml\",\n\t\t\tdata: { segment: accession },\n\t\t\tsuccess: function ( xml  ) {\n\t\t\t\ttry {\n\t\t\t\t\t\n\t\t\t\t\tvar sequenceNode = jQuery(xml).find('SEQUENCE:first');\n\t\t\t\t\tself.setSequence( sequenceNode.text(), sequenceNode.attr(\"id\"), sequenceNode.attr(\"label\") );\n\t\t\t\t\t\n\t\t\t\t} catch (e) {\n\t\t\t\t\tconsole.log(\"Error decoding response data: \" + e.message );\n\t\t\t\t\tself.clearSequence(\"No sequence available\", \"../biojs/css/images/warning_icon.png\");\n\t\t\t\t}\n\n\t\t\t},\n\t\t\terror: function (jqXHR, textStatus, errorThrown) {\n\t\t\t\tconsole.log(\"Error decoding response data: \" + textStatus );\n\t\t\t\tself.clearSequence(\"Error requesting the sequence to the server \" + this.url , \"../biojs/css/images/warning_icon.png\");\n\t\t\t}\n\t\t});\n    },\n\t\n    /**\n\t * Shows the columns indicated by the indexes array.\n\t * @param {string} [showMessage] Message to be showed.\n\t * @param {string} [icon] Icon to be showed a side of the message\n\t * \n\t * @example \n\t * mySequence.clearSequence(\"No sequence available\", \"../biojs/css/images/warning_icon.png\");\n\t * \n\t */\n    clearSequence: function ( showMessage, icon ) {\n    \t\n    \tvar message = undefined;\n    \t\t\n    \tthis.opt.sequence = \"\";\n    \tthis.opt.id = \"\"; \n    \tthis._highlights = [];\n\t\tthis._highlightsCount = 0;\n\t\tthis.opt.selection = { start: 0, end: 0 };\n\t\tthis._annotations = [];\n\t\tthis._contentDiv.children().remove();\n\t\t\n\t\tthis._headerDiv.hide();\n\t\t\n\t\tif ( undefined !== showMessage ) {\n\t\t\tmessage = jQuery('<div>' + showMessage + '</div>')\n\t\t\t\t.appendTo(this._contentDiv)\n\t\t\t\t.addClass(\"message\");\n\t\t\t\n\t\t\tif ( undefined !== icon ) {\n\t\t\t\tmessage.css({\n\t\t\t\t\t'background': 'transparent url(\"' + icon + '\") no-repeat center left',\n\t\t\t\t\t'padding-left': '20px'\n\t\t\t\t});\n\t\t\t}\n\t\t}\n    },\n\t\n\t/**\n    * Set the current selection in the sequence causing the event {@link Sequence#onSelectionChanged}\n    *\n    * @example\n    * // set selection from the position 100 to 150 \n    * mySequence.setSelection(100, 150);\n    * \n    * @param {int} start The starting character of the selection.\n    * @param {int} end The ending character of the selection\n    */\n\tsetSelection : function(start, end) {\n\t\tif(start > end) {\n\t\t\tvar aux = end;\n\t\t\tend = start;\n\t\t\tstart = aux;\n\n\t\t}\n\n\t\tif(start != this.opt.selection.start || end != this.opt.selection.end) {\n\t\t\tthis._setSelection(start, end);\n\t\t\tthis.trigger(\n\t\t\t\t\tEVT_ON_SELECTION_CHANGED, \n\t\t\t\t\t{ \"start\" : start, \"end\" : end }\n\t\t\t);\n\t\t}\n\t},\n\t\n\t_buildFormatSelector: function () {\n\t\tvar self = this;\n\t\t\n\t\tthis._headerDiv = jQuery('<div></div>').appendTo(this._container);\n\t\tthis._headerDiv.css({\n\t\t\t'font-family': '\"Heveltica Neue\", Arial, \"sans serif\"',\n\t\t\t'font-size': '14px'\t\n\t\t}).append('Format: ');\n\t\t\n\t\tthis._formatSelector = jQuery('<select> '+\n\t\t\t\t'<option value=\"FASTA\">FASTA</option>'+\n\t\t\t\t'<option value=\"CODATA\">CODATA</option>'+\n\t\t\t\t'<option value=\"PRIDE\">PRIDE</option>'+\n\t\t\t\t'<option value=\"RAW\">RAW</option></select>').appendTo(self._headerDiv);\n\n\t\tthis._formatSelector.change(function(e) {\n\t\t\tself.opt.format = jQuery(this).val();\n\t\t\tself._redraw();\n\t\t});\n\t\t\n\t\tthis._formatSelector.val(self.opt.format);\t\n\t\t\n\t\tthis.formatSelectorVisible( this.opt.formatSelectorVisible );\n\t},\n\t\n\t/**\n    * Highlights a region using the font color defined in {Biojs.Protein3D#highlightFontColor} by default is red.\n    *\n    * @deprecated use addHighlight instead.\n    * \n    * @param {int} start The starting character of the highlighting.\n    * @param {int} end The ending character of the highlighting.\n    * @param {string} [color] HTML color code.\n    * @param {string} [background] HTML color code.\n    * @param {string} [id] Custom identifier.\n    * \n    * @return {int} representing the id of the highlight on the internal array. Returns -1 on failure  \n    */\n\thighlight : function (start, end, color, background, id ) {\n\t\treturn this.addHighlight({ \"start\": start, \"end\": end, \"color\": color, \"background\": background, \"id\": id });\n\t},\n\t\n\t/**\n    * Highlights a region using the font color defined in {Sequence#highlightFontColor} by default is red.\n    *\n    * @example\n    * // highlight the characters within the position 100 to 150, included.\n    * mySequence.addHighlight( { \"start\": 100, \"end\": 150, \"color\": \"white\", \"background\": \"red\", \"id\": \"aaa\" } );\n    * \n    * @param {Object} h The highlight defined as follows:\n    * \t\n    * \n    * @return {int} representing the id of the highlight on the internal array. Returns -1 on failure  \n    */\n\taddHighlight : function ( h ) {\n\t\tvar id = '-1';\n\t\tvar color = \"\";\n\t\tvar background = \"\";\n\t\tvar highlight = {};\n\t\t\n\t\tif ( h instanceof Object && h.start <= h.end ) {\n\t\t\t\n\t\t\tcolor = ( \"string\" == typeof h.color )? h.color : this.opt.highlightFontColor;\n\t\t\tbackground = ( \"string\" == typeof h.background )? h.background : this.opt.highlightBackgroundColor;\n\t\t\tid = ( \"string\" == typeof h.id )? h.id : (new Number(this._highlightsCount++)).toString();\n\t\t\t\n\t\t\thighlight = { \"start\": h.start, \"end\": h.end, \"color\": color, \"background\": background, \"id\": id };\n\t\t\t\n\t\t\tthis._highlights.push(highlight);\n\t\t\tthis._applyHighlight(highlight);\n\t\t\tthis._restoreSelection(h.start,h.end);\n\t\t} \n\t\t\n\t\treturn id;\n\t},\n\t/* \n     * Function: Sequence._applyHighlight\n     * Purpose:  Apply the specified color and background to a region between 'start' and 'end'.\n     * Returns:  -\n     * Inputs: highlight -> {Object} An object containing the fields start (int), end (int), \n     * \t\t\t\t\t\tcolor (HTML color string) and background (HTML color string).\n     */\n\t_applyHighlight: function ( highlight ) {\t\t\n\t\tvar seq = this._contentDiv.find('.sequence');\n\t\tfor ( var i = highlight.start - 1; i < highlight.end; i++ ){\n\t\t\tzindex = jQuery(seq[i]).css(\"z-index\");\n\t\t\tif (zindex==\"auto\"){\n\t\t\t\t z = 1;\n\t\t\t\t o = 1;\n\t\t\t }\n\t\t\t else{\n\t\t\t\t z = 0;\n\t\t\t\t o = 0.5;\n\t\t\t }\n\t\t\tjQuery(seq[i])\n\t\t\t\t.css({ \n\t\t\t\t\t\"color\": highlight.color,\n\t\t\t\t\t\"background-color\": highlight.background,\n\t\t\t\t\t\"z-index\": z,\n\t\t\t\t\t\"opacity\": o\n\t\t\t\t\t})\n\t\t\t\t.addClass(\"highlighted\");\n\t\t}\n\t},\n\t/* \n     * Function: Sequence._applyHighlights\n     * Purpose:  Apply the specified highlights.\n     * Returns:  -\n     * Inputs: highlights -> {Object[]} An array containing the highlights to be applied.\n     */\n\t_applyHighlights: function ( highlights ) {\n\t\tfor ( var i in highlights ) {\n\t\t\tthis._applyHighlight(highlights[i]);\n\t\t}\n\t},\n\t/* \n     * Function: Sequence._restoreHighlights\n     * Purpose:  Repaint the highlights in the specified region.\n     * Returns:  -\n     * Inputs: start -> {int} Start of the region to be restored.\n     * \t\t   end -> {int} End of the region to be restored.\n     */\n\t_restoreHighlights: function ( start, end ) {\n\t\tvar h = this._highlights;\n\t\t// paint the region using default blank settings\n\t\tthis._applyHighlight({\n\t\t\t\"start\": start, \n\t\t\t\"end\": end, \n\t\t\t\"color\": this.opt.fontColor, \n\t\t\t\"background\": this.opt.backgroundColor \n\t\t});\n\t\t// restore highlights in that region\n\t\tfor ( var i in h ) {\n\t\t\t// interval intersects with highlight i ?\n\t\t\tif ( !( h[i].start > end || h[i].end < start ) ) {\n\t\t\t\ta = ( h[i].start < start ) ? start : h[i].start;\n\t\t\t\tb = ( h[i].end > end ) ? end : h[i].end;\n\t\t\t\tthis._applyHighlight({\n\t\t\t\t\t\"start\": a, \n\t\t\t\t\t\"end\": b, \n\t\t\t\t\t\"color\": h[i].color, \n\t\t\t\t\t\"background\": h[i].background \n\t\t\t\t});\n\t\t\t}\n\t\t}\n\t},\n\t/* \n     * Function: Sequence._restoreSelection\n     * Purpose:  Repaint the current selection in the specified region. \n     * \t\t\t It is used in the case of any highlight do overriding of the current selection. \n     * Returns:  -\n     * Inputs: start -> {int} Start of the region to be restored.\n     * \t\t   end -> {int} End of the region to be restored.\n     */\n\t_restoreSelection: function ( start, end ) {\n\t\tvar sel = this.opt.selection;\n\t\t// interval intersects with current selection ?\n\t\t// restore selection\n\t\tif ( !( start > sel.end || end < sel.start ) ) {\n\t\t\ta = ( start < sel.start ) ? sel.start : start;\n\t\t\tb = ( end > sel.end ) ? sel.end : end;\n\t\t\t\n\t\t\tthis._applyHighlight({\n\t\t\t\t\"start\": a, \n\t\t\t\t\"end\": b, \n\t\t\t\t\"color\": this.opt.selectionFontColor, \n\t\t\t\t\"background\": this.opt.selectionColor,\n\t\t\t});\n\t\t}\n\t},\n\t\n\t/**\n    * Clear a highlighted region using.\n    *\n    * @deprecated use removeHighlight instead.\n    * \n    * @param {int} id The id of the highlight on the internal array. This value is returned by method highlight.\n    */\n\tunHighlight : function (id) {\t\n\t\tthis.removeHighlight(id);\n\t},\n\t\n\t/**\n    * Remove a highlight.\n    *\n    * @example\n    * // Clear the highlighted characters within the position 100 to 150, included.\n    * mySequence.removeHighlight(\"spin1\");\n    * \n    * @param {string} id The id of the highlight on the internal array. This value is returned by method highlight.\n    */\n\tremoveHighlight : function (id) {\t\n\t\tvar h = this._highlights;\n\t\tfor ( i in h ) {\n\t\t\tif ( h[i].id == id ) {\n\t\t\t\tstart = h[i].start;\n\t\t\t\tend = h[i].end;\n\t\t\t\th.splice(i,1);\n\t\t\t\t\n\t\t\t\tthis._restoreHighlights(start,end);\n\t\t\t\tthis._restoreSelection(start,end);\n\t\t\t\t\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\t},\n\t\n\t/**\n    * Clear the highlights of whole sequence.\n    * @deprecated use removeAllHighlights instead.\n    */\n\tunHighlightAll : function () {\n\t\tthis.removeAllHighlights();\n\t},\n\t\n\t/**\n    * Remove all the highlights of whole sequence.\n    *\n    * @example\n    * mySequence.removeAllHighlights();\n    */\n\tremoveAllHighlights : function () {\n\t\tthis._highlights = [];\n\t\tthis._restoreHighlights(1,this.opt.sequence.length);\n\t\tthis._restoreSelection(1,this.opt.sequence.length);\n\t},\n\t\n\t/**\n    * Changes the current displaying format of the sequence.\n    *\n    * @example\n    * // Set format to 'FASTA'.\n    * mySequence.setFormat('FASTA');\n    * \n    * @param {string} format The format for the sequence to be displayed.\n    */\n\tsetFormat : function(format) {\n\t\tif ( this.opt.format != format.toUpperCase() ) {\n\t\t\tthis.opt.format = format.toUpperCase();\n\t\t\tthis._redraw();\n\t\t}\n\n\t\tvar self = this;\n\t\t// Changes the option in the combo box\n\t\tthis._headerDiv.find('option').each(function() {\n\t\t\tif(jQuery(this).val() == self.opt.format.toUpperCase()) {\n\t\t\t\tjQuery(this).attr('selected', 'selected');\n\t\t\t}\n\t\t});\n\t},\n\t\n\t/**\n    * Changes the current number of columns in the displayed sequence.\n    *\n    * @example\n    * // Set the number of columns to 70.\n    * mySequence.setNumCols(70);\n    * \n    * @param {int} numCols The number of columns.\n    */\n\tsetNumCols : function(numCols) {\n\t\tthis.opt.columns.size = numCols;\n\t\tthis._redraw();\n\t},\n\t\n\t/**\n    * Set the visibility of the drop-down list of formats.\n    * \n    * @param {boolean} visible true: show; false: hide.\n    */\n\tformatSelectorVisible : function (visible){\n\t\tif (visible) {\n\t\t\tthis._headerDiv.show();\n\t\t} else {\n\t\t\tthis._headerDiv.hide();\n\t\t}\n\t},\n\t\n\t/**\n    * This is similar to a {Biojs.Protein3D#formatSelectorVisible} with the 'true' argument.\n    *\n    * @example\n    * // Shows the format selector.\n    * mySequence.showFormatSelector();\n    * \n    */\n\tshowFormatSelector : function() {\n\t\tthis._headerDiv.show();\n\t},\n\t\n\t/**\n    * This is similar to a {Biojs.Protein3D#formatSelectorVisible} with the 'false' argument.\n    * \n    * @example\n    * // Hides the format selector.\n    * mySequence.hideFormatSelector();\n    * \n    */\n\thideFormatSelector : function() {\n\t\tthis._headerDiv.hide();\n\t},\n\t\n\t/**\n    * Hides the whole component.\n    * \n    */\n\thide : function () {\n\t\tthis._headerDiv.hide();\n\t\tthis._contentDiv.hide();\n\t},\n\n\t/**\n    * Shows the whole component.\n    * \n    */\n\tshow : function () {\n\t\tthis._headerDiv.show();\n\t\tthis._contentDiv.show();\n\t},\n\t/* \n     * Function: Sequence._setSelection\n     * Purpose:  Update the current selection. \n     * Returns:  -\n     * Inputs: start -> {int} Start of the region to be selected.\n     * \t\t   end -> {int} End of the region to be selected.\n     */\n\t_setSelection : function(start, end) {\n\t\t//alert(\"adsas\");\n\t\t\n\t\tvar current = this.opt.selection;\n\t\tvar change = {};\n\t\t\n\t\t// Which is the change on selection?\n\t\tif ( current.start == start ) {\n\t\t\t// forward?\n\t\t\tif ( current.end < end ) {\n\t\t\t\tchange.start = current.end;\n\t\t\t\tchange.end = end;\n\t\t\t} else {\n\t\t\t\tthis._restoreHighlights(end+1, current.end);\n\t\t\t}\n\t\t} else if ( current.end == end ) {\n\t\t\t// forward?\n\t\t\tif ( current.start > start ) {\n\t\t\t\tchange.start = start;\n\t\t\t\tchange.end = current.start;\t\t\t\t\n\t\t\t} else {\n\t\t\t\tthis._restoreHighlights(current.start, start-1);\n\t\t\t}\n\t\t} else {\n\t\t\tthis._restoreHighlights(current.start, current.end);\n\t\t\tchange.start = start;\n\t\t\tchange.end = end;\n\t\t}\n\n\t\tcurrent.start = start;\n\t\tcurrent.end = end;\n\n\t\tif ( change.start != undefined ) {\n\t\t\tthis._applyHighlight({\n\t\t\t\t\"start\": change.start, \n\t\t\t\t\"end\": change.end, \n\t\t\t\t\"color\": this.opt.selectionFontColor, \n\t\t\t\t\"background\": this.opt.selectionColor \n\t\t\t});\n\t\t}\n\t\t\n\t},\n\t\n\t/* \n     * Function: Sequence._repaintSelection\n     * Purpose:  Repaint the whole current selection. \n     * Returns:  -\n     * Inputs: -\n     */\n\t_repaintSelection: function(){\n\t\tvar s = this.opt.selection;\n\t\tthis._setSelection(0,0);\n\t\tthis._setSelection(s.start,s.end);\n\t},\n\t\n\t/* \n     * Function: Sequence._redraw\n     * Purpose:  Repaint the current sequence. \n     * Returns:  -\n     * Inputs: -\n     */\n\t_redraw : function() {\n\t\tvar i = 0;\t\n\t\tvar self = this;\n\t\t\n\t\t// Reset the content\n\t\t//this._contentDiv.text('');\n\t\tthis._contentDiv.children().remove();\n\t\t\n\t\t// Rebuild the spans of the sequence \n\t\t// according to format\n\t\tif(this.opt.format == 'RAW') {\n\t\t\tthis._drawRaw();\n\t\t} else if(this.opt.format == 'CODATA') {\n\t\t\tthis._drawCodata();\n\t\t} else if (this.opt.format == 'FASTA'){\n\t\t\tthis._drawFasta();\n\t\t} else {\n\t\t\tthis.opt.format = 'PRIDE';\n\t\t\tthis._drawPride();\n\t\t}\n\t\t\n\t\t// Restore the highlighted regions\n\t\tthis._applyHighlights(this._highlights);\n\t\tthis._repaintSelection();\n\t\tthis._addSpanEvents();\n\t},\n\t/* \n     * Function: Sequence._drawFasta\n     * Purpose:  Repaint the current sequence using FASTA format.  \n     * Returns:  -\n     * Inputs: -\n     */\n\t_drawFasta : function() {\n\t\tvar self = this;\n\t\tvar a = this.opt.sequence.toUpperCase().split('');\n\t\tvar pre = jQuery('<pre></pre>').appendTo(this._contentDiv);\n\n\t\tvar i = 1;\n\t\tvar arr = [];\n\t    var str = '>' + this.opt.id + ' ' + a.length + ' bp<br/>';\n\t\t\n\t\t/* Correct column size in case the sequence is as small peptide */\n\t\tvar numCols = this.opt.columns.size;\n\t\tif ( this.opt.sequence.length < this.opt.columns.size ) {\n\t\t\tnumCols = this.opt.sequence.length;\t\n\t\t}\n\t\t\n\t    var opt = {\n\t\t\tnumCols: numCols,\n\t\t    numColsForSpace: 0\n\t\t};\n\n\t\tstr += this._drawSequence(a, opt);\n\t\tpre.html(str);\n\t\t\n\t\tthis._drawAnnotations(opt);\n\t},\n\t/* \n     * Function: Sequence._drawCodata\n     * Purpose:  Repaint the current sequence using CODATA format.  \n     * Returns:  -\n     * Inputs: -\n     */\n\t_drawCodata : function() {\n\t\t\n\t\tvar self = this;\n\t\tvar a = this.opt.sequence.toUpperCase().split('');\n\t\tvar pre = jQuery('<pre style=\"white-space:pre\"></pre>').appendTo(this._contentDiv);\n\n\t\tvar i = 0;\n\t\tvar str = 'ENTRY           ' + this.opt.id + '<br/>';\n\t\tstr += 'SEQUENCE<br/>';\n\t\tif ( this.opt.formatOptions !== undefined ){\n\t\t\tif(this.opt.formatOptions.title !== undefined ){\n\t\t\t\tif (this.opt.formatOptions.title == false) {\n\t\t\t\t\tstr = '';\n\t\t\t\t}\t\t\t\n\t\t\t}\n\t\t} \n\t\t\n\t\t/* Correct column size in case the sequence is as small peptide */\n\t\tvar numCols = this.opt.columns.size;\n\t\tif ( this.opt.sequence.length < this.opt.columns.size ) {\n\t\t\tnumCols = this.opt.sequence.length;\t\n\t\t}\n\t\t\n\t\tvar opt = {\n\t\t\t\tnumLeft: true,\n\t\t\t\tnumLeftSize: 7,\n\t\t\t\tnumLeftPad:' ',\n\t\t\t\tnumTop: true,\n\t\t\t\tnumTopEach: 5,\n\t\t\t\tnumCols: numCols,\n\t\t\t    numColsForSpace: 0,\n\t\t\t    spaceBetweenChars: true\n\t\t};\n\t\t\n\t\tstr += this._drawSequence(a, opt);\n\t\t\n\t\tvar footer = '<br/>///';\n\t\tif (this.opt.formatOptions !== undefined) {\n\t\t\tif (this.opt.formatOptions.footer !== undefined) {\n\t\t\t\tif (this.opt.formatOptions.footer == false) {\n\t\t\t\t\tfooter = '';\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tstr += footer;\n\t\tpre.html(str);\n\t\t\n\t\tthis._drawAnnotations(opt);\n\t},\n\t/* \n     * Function: Sequence._drawAnnotations\n     * Purpose:  Paint the annotations on the sequence.  \n     * Returns:  -\n     * Inputs: settings -> {object} \n     */\n    _drawAnnotations: function ( settings ){ \n    \t\n    \tvar self = this;\n    \tvar a = this.opt.sequence.toLowerCase().split('');    \t\n    \tvar annotations = this._annotations;\n    \tvar leftSpaces = '';\n    \tvar row = '';\n    \tvar annot = '';\n    \t\n    \t// Index at the left?\n\t\tif ( settings.numLeft ) {\n\t\t\tleftSpaces += this._formatIndex(' ', settings.numLeftSize+2, ' ');\n\t\t}\n\n\t\tfor ( var i = 0; i < a.length; i += settings.numCols ){\n\t\t\trow = '';\n\t\t\tfor ( var key in annotations ){\n\t\t\t\tannotations[key].id = this.getId() + \"_\" + key;\n\t\t\t\tannot = this._getHTMLRowAnnot(i+1, annotations[key], settings);\t\t\t\t\n\t\t\t\tif (annot.length > 0) {\n\t\t\t\t\trow += '<br/>';\n\t\t\t\t\trow += leftSpaces;\n\t\t\t\t\trow += annot;\n\t\t\t\t\trow += '<br/>';\n\t\t\t\t} \n\t\t\t}\n\t\t\t\n\t\t\tvar numCols = settings.numCols;\n\t\t\tvar charRemaining = a.length-i;\n\t\t\tif(charRemaining < numCols){\n\t\t\t\tnumCols\t= charRemaining;\n\t\t\t}\n\t\t\t\n\t\t\tif ( settings.numRight ) {\n\t\t\t\tjQuery(row).insertAfter('div#'+self.opt.target+' div pre span#numRight_' + this.getId() + '_' + (i + numCols) );\n\t\t\t} else {\n\t\t\t\tjQuery(row).insertAfter('div#'+self.opt.target+' div pre span#'+ this.getId() + '_' + (i + numCols) );\n\t\t\t}\n\t\t}\n\t\t\n\t\t// add tool tips and background' coloring effect\n\t\tjQuery(this._contentDiv).find('.annotation').each( function(){\n\t\t\tself._addToolTip( this, function() {\n\t\t\t\treturn self._getAnnotationString( jQuery(this).attr(\"id\") );\n\t\t\t});\n\t\t\t\n\t\t\tjQuery(this).mouseover(function(e) {\n\t\t\t\tjQuery('.annotation.'+jQuery(e.target).attr(\"id\")).each(function(){\n\t\t\t\t\tjQuery(this).css(\"background-color\", jQuery(this).attr(\"color\") );\n\t\t\t\t});\n\t\t    }).mouseout(function() {\n\t\t    \tjQuery('.annotation').css(\"background-color\", \"transparent\"); \n\t\t    \t\n\t\t    }).click(function(e) {\n\t\t    \t\tvar name = undefined;\n\t\t    \t\tvar id = jQuery(e.target).attr(\"id\");\n\t\t    \t\tfor(var i =0; i < self._annotations.length;i++){\n              if(self._annotations[i].id == id){\n                name = self._annotations[i].name;\n                continue;\n              }\n            }\n\t\t    \tself.trigger( EVT_ON_ANNOTATION_CLICKED, {\n\t    \t\t\"name\": name,\n\t\t    \t\t//\"pos\": parseInt( jQuery(e.target).attr(\"pos\") )\n\t\t    \t});\n\t\t    });\n\t\t\t\n\t\t});\n\n    },\n    /* \n     * Function: Sequence._getAnnotationString\n     * Purpose:  Get the annotation text message for the tooltip \n     * Returns:  {string} Annotation text for the annotation\n     * Inputs:   id -> {int} index of the internal annotation array\n     */\n    _getAnnotationString: function ( id ) {\n\t\tvar annotation = this._annotations[id.substr(id.indexOf(\"_\") + 1)];\n\t\treturn annotation.name + \"<br/>\" + ((annotation.html)? annotation.html : '');\n    },\n    \n    /* \n     * Function: Sequence._getHTMLRowAnnot\n     * Purpose:  Build an annotation\n     * Returns:  HTML of the annotation\n     * Inputs:   currentPos -> {int}\n     * \t\t\t annotation -> {Object} \n     *  \t\t settings -> {Object}\n     */\n    _getHTMLRowAnnot : function (currentPos, annotation, settings) {\n    \tvar styleBegin = 'border-left:1px solid; border-bottom:1px solid; border-color:';\n    \tvar styleOn = 'border-bottom:1px solid; border-color:';\n    \tvar styleEnd = 'border-bottom:1px solid; border-right:1px solid; border-color:';\n\t\tvar styleBeginAndEnd = 'border-left:1px solid; border-right:1px solid; border-bottom:1px solid; border-color:';\n    \t\n    \tvar row = [];\n    \tvar end = (currentPos + settings.numCols);\n    \tvar spaceBetweenChars = (settings.spaceBetweenChars)? ' ' : '';    \t\n    \tvar defaultColor = annotation.color;\n    \tvar id = annotation.id;\n    \tfor ( var pos=currentPos; pos < end ; pos++ ) {\n\t\t\t// regions\n\t\t\tfor ( var r in annotation.regions ) {\n\t\t\t\tregion = annotation.regions[r];\n\t\t\t\t\n\t\t\t\tspaceAfter = '';\n\t\t\t\tspaceAfter += (pos % settings.numColsForSpace == 0 )? ' ' : '';\n\t\t\t\tspaceAfter += spaceBetweenChars;\n\t\t\t\t\n\t\t\t\tcolor = ((region.color)? region.color : defaultColor);\n\t\t\t\tdata = 'class=\"annotation '+id+'\" id=\"'+id+'\" color=\"'+color+'\" pos=\"'+pos+'\"';\n\t\t\t\t\n\t\t\t\tif ( pos == region.start && pos == region.end) {\n\t\t\t\t\trow[pos] = '<span style=\"'+styleBeginAndEnd+color+'\" '+data+'> ';\n\t\t\t\t\trow[pos] += spaceAfter;\n\t\t\t\t\trow[pos] += '</span>';\n\t\t\t\t} else if ( pos == region.start ) {\n\t\t\t\t\trow[pos] = '<span style=\"'+styleBegin+color+'\" '+data+'> ';\n\t\t\t\t\trow[pos] += spaceAfter;\n\t\t\t\t\trow[pos] += '</span>';\n\t\t\t\t} else if ( pos == region.end ) {\n\t\t\t\t\trow[pos] = '<span style=\"'+styleEnd+color+' \" '+data+'> ';\n\t\t\t\t\t//row[pos] += spaceAfter;\n\t\t\t\t\trow[pos] += '</span>';\n\t\t\t\t} else if ( pos > region.start && pos < region.end ) {\n\t\t\t\t\trow[pos] = '<span style=\"'+styleOn+color+'\" '+data+'> ';\n\t\t\t\t\trow[pos] += spaceAfter;\n\t\t\t\t\trow[pos] += '</span>';\n\t\t\t\t} else if (!row[pos]) {\n\t\t\t\t\trow[pos] = ' ';\n\t\t\t\t\trow[pos] += spaceAfter;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n       \tvar str = row.join(\"\");\n    \t\n    \treturn ( str.indexOf(\"span\") == -1 )? \"\" : str;\n    },\n    /* \n     * Function: Sequence._drawRaw\n     * Purpose:  Repaint the current sequence using RAW format.  \n     * Returns:  -\n     * Inputs: -\n     */\n\t_drawRaw : function() {\n\t\tvar self = this;\n\t\tvar a = this.opt.sequence.toLowerCase().split('');\n\t\tvar i = 0;\n\t\tvar arr = [];\n\t\tvar pre = jQuery('<pre></pre>').appendTo(this._contentDiv);\n\t\t\n\t\t/* Correct column size in case the sequence is as small peptide */\n\t\tvar numCols = this.opt.columns.size;\n\t\tif ( this.opt.sequence.length < this.opt.columns.size ) {\n\t\t\tnumCols = this.opt.sequence.length;\t\n\t\t}\n\n\t\tvar opt = {\n\t\t\tnumCols: numCols\n\t\t};\n\t\t\n\t\tpre.html(\n\t\t\tthis._drawSequence(a, opt)\n\t\t);\n\t\t\n\t\tthis._drawAnnotations(opt);\n\t},\n\t/* \n     * Function: Sequence._drawPride\n     * Purpose:  Repaint the current sequence using PRIDE format.  \n     * Returns:  -\n     * Inputs: -\n     */\n\t_drawPride : function() {\n\t\tvar self = this;\n\t\tvar a = this.opt.sequence.toUpperCase().split('');\n\t\tvar pre = jQuery('<pre></pre>').appendTo(this._contentDiv);\n\t\t\n\t\t/* Correct column size in case the sequence is as small peptide */\n\t\tvar numCols = this.opt.columns.size;\n\t\tif ( this.opt.sequence.length < this.opt.columns.size ) {\n\t\t\tnumCols = this.opt.sequence.length;\t\n\t\t}\n\t\n\t\topt = {\n\t\t\tnumLeft: true,\n\t\t\tnumLeftSize: 5,\n\t\t\tnumLeftPad:'0',\n\t\t\tnumRight: true,\n\t\t\tnumRightSize: 5,\n\t\t\tnumRightPad: '0',\n\t\t\tnumCols: numCols,\n\t\t    numColsForSpace: self.opt.columns.spacedEach\n\t\t};\n\t\t\n\t\tpre.html(\n\t\t\tthis._drawSequence(a, opt)\n\t\t);\n\t\t\n\t\tthis._drawAnnotations(opt);\n\t},\n\t/* \n     * Function: Sequence._drawSequence\n     * Purpose:  Repaint the current sequence using CUSTOM format.  \n     * Returns:  -\n     * Inputs:   a -> {char[]} a The sequence strand.\n     * \t\t\t opt -> {Object} opt The CUSTOM format.\n     */\n\t_drawSequence : function(a, opt) {\n\t\tvar str = '';\n\n\t\tvar spaceStyle =  \"white-space: pre;\";\n\t\t\n\t\t// Index at top?\n\t\tif( opt.numTop )\n\t\t{\n\t\t\tstr += '<span style=\"'+spaceStyle+'\" class=\"numTop\">'\n\t\t\tvar size = (opt.spaceBetweenChars)? opt.numTopEach*2: opt.numTopEach;\n\t\t\t\n\t\t\tif (opt.numLeft) {\n\t\t\t\tstr += this._formatIndex(' ', opt.numLeftSize, ' ');\n\t\t\t}\n\t\t\t\n\t\t\tstr += this._formatIndex(' ', size, ' ');\n\t\t\t\n\t\t\tfor(var x = opt.numTopEach; x < opt.numCols; x += opt.numTopEach) {\n\t\t\t\tstr += this._formatIndex(x, size, ' ', true);\n\t\t\t}\n\t\t\tstr += '</span><br/>'\n\t\t}\n\t\t\n\t\t\n\t\t// Index at the left?\n\t\tif (opt.numLeft) {\n\t\t\tstr += this._formatIndex(1, opt.numLeftSize, opt.numLeftPad);\n\t\t\tstr += '  ';\n\t\t}\n\n\t\tvar j=1;\n\t\tfor (var i=1; i <= a.length; i++) {\n\n\t\t\tif( i % opt.numCols == 0) {\t\n\t\t\t\tstr += '<span class=\"sequence\" id=\"' + this.getId() + '_' + i + '\">' + a[i-1] + '</span>';\n\t\t\t\t\n\t\t\t\tif (opt.numRight) {\n\t\t\t\t\tstr += '<span style=\"'+spaceStyle+'\" id=\"numRight_' + this.getId() + '_' + i + '\">';\n\t\t\t\t\tstr += '  ';\n\t\t\t\t\tstr += this._formatIndex(i, opt.numRightSize, opt.numRightPad);\t\n\t\t\t\t\tstr += '</span>';\n\t\t\t\t}\n\t\t\t\t\n\t\t\t\tstr += '<br/>';\n\t\t\t\t\n\t\t\t\tvar aaRemaining = a.length - i;\n\t\t\t\tif (opt.numLeft && aaRemaining > 0) {\n\t\t\t\t\tstr += '<span id=\"numLeft_' + this.getId() + '_' + i + '\">';\n\t\t\t\t\tstr += this._formatIndex(i+1, opt.numLeftSize, opt.numLeftPad);\n\t\t\t\t\tstr += '  ';\n\t\t\t\t\tstr += '</span>';\n\t\t\t\t}\n\t\t\t\t\n\t\t\t\tj = 1;\n\t\t\t\t\n\t\t\t} else {\n                str += '<span class=\"sequence\" style=\"'+spaceStyle+'\" id=\"' + this.getId() + '_' + i + '\">' + a[i-1];\n\t\t\t\tstr += ( j % opt.numColsForSpace == 0)? ' ' : '';\n\t\t\t\tstr += (opt.spaceBetweenChars)? ' ' : '';\n\t\t\t\tstr += '</span>';\n\t\t\t\tj++;\n\t\t\t}\n\t\t}\n\t\t\n\t\tstr += '<br/>'\t\n\t\t\t\n\t\tif (jQuery.browser.msie) {\n\t\t\tstr = \"<pre>\" + str + \"</pre>\";\n\t\t}\t\n\t\t\t\n\t\treturn str;\n\t},\n\t/* \n     * Function: Sequence._formatIndex\n     * Purpose:  Build the HTML corresponding to counting numbers (top, left, right) in the strand.\n     * Returns:  -\n     * Inputs:   number -> {int} The number \n     * \t\t\t size -> {int} Number of bins to suit the number.\n     * \t\t\t fillingChar -> {char} Character to be used for filling out blank bins.\n     * \t\t\t alignLeft -> {bool} Tell if aligned to the left.\n     */\n\t_formatIndex : function( number, size, fillingChar, alignLeft) {\n\t\tvar str = number.toString();\n\t\tvar filling = '';\n\t\tvar padding = size - str.length;\t\n\t\tif ( padding > 0 ) {\n\t\t\twhile ( padding-- > 0 ) {\n\t\t\t\tfilling += (\"<span>\"+fillingChar+\"</span>\");\n\t\t\t}\n\t\t\tif (alignLeft){\n\t\t\t\tstr = number+filling;\n\t\t\t} else {\n\t\t\t\tstr = filling+number;\n\t\t\t}\n\t\t}\n\t\treturn str;\n\t},\n\t/* \n     * Function: Sequence._addSpanEvents\n     * Purpose:  Add the event handlers to the strand.\n     * Returns:  -\n     * Inputs:   -\n     */\n\t_addSpanEvents : function() {\n\t\tvar self = this;\n\t\tvar isMouseDown = false;\n\t\tvar currentPos;\n\n\t\tself._contentDiv.find('.sequence').each( function () {\t\n\t\t\t\n\t\t\t// Register the starting position\n\t\t\tjQuery(this).mousedown(function() {\n\t\t\t\tvar id = jQuery(this).attr('id');\n\t\t\t\tcurrentPos = parseInt(id.substr(id.indexOf(\"_\") + 1));\n\t\t\t\tclickPos = currentPos;\n\t\t\t\tself._setSelection(clickPos,currentPos);\n\t\t\t\tisMouseDown = true;\n\t\t\t\t\n\t\t\t\t// Selection is happening, raise an event\n\t\t\t\tself.trigger(\n\t\t\t\t\tEVT_ON_SELECTION_CHANGE, \n\t\t\t\t\t{ \n\t\t\t\t\t\t\"start\" : self.opt.selection.start, \n\t\t\t\t\t\t\"end\" : self.opt.selection.end \n\t\t\t\t\t}\n\t\t\t\t);\n\t\t\t\n\t\t\t}).mouseover(function() {\n\t\t\t\t// Update selection\n\t\t\t\t// Show tooltip containing the position\n\t\t\t\tvar id = jQuery(this).attr('id');\n\t\t\t\tcurrentPos = parseInt(id.substr(id.indexOf(\"_\") + 1));\n\t\t\t\t\n\t\t\t\tif(isMouseDown) {\n\t\t\t\t\tif( currentPos > clickPos ) {\n\t\t\t\t\t\tself._setSelection(clickPos, currentPos);\n\t\t\t\t\t} else {\n\t\t\t\t\t\tself._setSelection(currentPos, clickPos);\n\t\t\t\t\t}\n\t\t\t\t\t\n\t\t\t\t\t// Selection is happening, raise an event\n\t\t\t\t\tself.trigger( EVT_ON_SELECTION_CHANGE, { \n\t\t\t\t\t\t\"start\" : self.opt.selection.start, \n\t\t\t\t\t\t\"end\" : self.opt.selection.end \n\t\t\t\t\t});\n\t\t\t\t} \n\t\t\t\t\n\t\t\t}).mouseup(function() {\n\t\t\t\tisMouseDown = false;\n\t\t\t\t// Selection is done, raise an event\n\t\t\t\tself.trigger( EVT_ON_SELECTION_CHANGED, { \n\t\t\t\t\t\"start\" : self.opt.selection.start, \n\t\t\t\t\t\"end\" : self.opt.selection.end \n\t\t\t\t});\n\t\t\t});\n\t\t\t\n\t\t\t// Add a tooltip for this sequence base.\n\t\t\tself._addToolTip.call( self, this, function( ) {\n\t\t\t\tif (isMouseDown) {\n\t     \t\t\treturn \"[\" + self.opt.selection.start +\", \" + self.opt.selection.end + \"]\";\n\t     \t\t} else {\n\t     \t\t\treturn currentPos;\n\t     \t\t}\n\t\t\t});\n\t\t\t\n\t\t})\n\t\t.css('cursor', 'pointer');\n\t},\n\t/* \n     * Function: Sequence._addTooltip\n     * Purpose:  Add a tooltip around the target DOM element provided as argument\n     * Returns:  -\n     * Inputs:   target -> {Element} DOM element wich is the targeted focus for the tooltip.\n     * \t\t\t cbGetMessageFunction -> {function} A callback function wich returns the message to be displayed in the tip.\n     */\n\t_addToolTip : function ( target, cbGetMessageFunction ) {\n\t\t\n \t\tvar tipId = this.opt._tooltip;\n\t\t\n\t\tjQuery(target).mouseover(function(e) {\n\t\t\t\n\t \t\tvar offset = jQuery(e.target).offset();\n\n\t\t\tif ( ! jQuery( tipId ).is(':visible') ) {\n\t\t        jQuery( tipId ) \n\t\t        \t.css({\n\t\t        \t\t'background-color': \"#000\",\n\t\t        \t\t'padding': \"3px 10px 3px 10px\",\n\t\t        \t\t'top': offset.top + jQuery(e.target).height() + \"px\",\n\t\t        \t\t'left': offset.left + jQuery(e.target).width() + \"px\"\n\t\t        \t})\n\t\t\t        .animate( {opacity: '0.85'}, 10)\n\t\t\t        .html( cbGetMessageFunction.call( target ) )\n\t\t\t        .show();\n\t\t\t}\n\n\t    }).mouseout(function() {\n\t        //Remove the appended tooltip template\n\t        jQuery( tipId ).hide();\t         \n\t    });\n\t},\n\t\n   /**\n    * Annotate a set of intervals provided in the argument.\n\t* \n\t* @deprecated Use addAnnotation() instead.\n    * \n    * @param {Object} annotation The intervals belonging to the same annotation. \n    * Syntax: { name: &lt;value&gt;, color: &lt;HTMLColorCode&gt;, html: &lt;HTMLString&gt;, regions: [{ start: &lt;startVal1&gt;, end: &lt;endVal1&gt;}, ...,  { start: &lt;startValN&gt;, end: &lt;endValN&gt;}] }\n    */\n\tsetAnnotation: function ( annotation ) {\n\t\tthis.addAnnotation(annotation);\n\t},\n\t\n\t/**\n    * Annotate a set of intervals provided in the argument.\n    * \n    * @example\n    * // Annotations using regions with different colors.\n    * mySequence.addAnnotation({\n\t*    name:\"UNIPROT\", \n\t*    html:\"&lt;br&gt; Example of &lt;b&gt;HTML&lt;/b&gt;\", \n\t*    color:\"green\", \n\t*    regions: [\n\t*       {start: 540, end: 560},\n\t*       {start: 561, end:580, color: \"#FFA010\"}, \n\t*       {start: 581, end:590, color: \"red\"}, \n\t*       {start: 690, end:710}]\n\t* });\n\t* \n    * \n    * @param {Object} annotation The intervals belonging to the same annotation. \n    * Syntax: { name: &lt;value&gt;, color: &lt;HTMLColorCode&gt;, html: &lt;HTMLString&gt;, regions: [{ start: &lt;startVal1&gt;, end: &lt;endVal1&gt;}, ...,  { start: &lt;startValN&gt;, end: &lt;endValN&gt;}] }\n    */\n\taddAnnotation: function ( annotation ) {\n\t\tthis._annotations.push(annotation);\n\t\tthis._redraw();\n\t},\n\t\n\t/**\n    * Removes an annotation by means of its name.\n    * \n    * @example \n    * // Remove the UNIPROT annotation.\n    * mySequence.removeAnnotation('UNIPROT'); \n    * \n    * @param {string} name The name of the annotation to be removed.\n    * \n    */\n\tremoveAnnotation: function ( name ) {\n\t\tfor (var i=0; i < this._annotations.length ; i++ ){\n\t\t\tif(name != this._annotations[i].name){\n\t\t\t\tthis._annotations.splice(i,1);\n\t\t\t\tthis._redraw();\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\t},\n\t/**\n    * Removes all the current annotations.\n    * \n    * @example \n    * mySequence.removeAllAnnotations(); \n    * \n    */\n\tremoveAllAnnotations: function () {\n\t\tthis._annotations = [];\n\t\tthis._redraw();\n\t},\n\n\t\n});\n\nrequire(\"biojs-events\").mixin(Sequence.prototype);\nmodule.exports = Sequence;\n","var events = require(\"backbone-events-standalone\");\n\nevents.onAll = function(callback,context){\n  this.on(\"all\", callback,context);\n  return this;\n};\n\n// Mixin utility\nevents.oldMixin = events.mixin;\nevents.mixin = function(proto) {\n  events.oldMixin(proto);\n  // add custom onAll\n  var exports = ['onAll'];\n  for(var i=0; i < exports.length;i++){\n    var name = exports[i];\n    proto[name] = this[name];\n  }\n  return proto;\n};\n\nmodule.exports = events;\n","/**\n * Standalone extraction of Backbone.Events, no external dependency required.\n * Degrades nicely when Backone/underscore are already available in the current\n * global context.\n *\n * Note that docs suggest to use underscore's `_.extend()` method to add Events\n * support to some given object. A `mixin()` method has been added to the Events\n * prototype to avoid using underscore for that sole purpose:\n *\n *     var myEventEmitter = BackboneEvents.mixin({});\n *\n * Or for a function constructor:\n *\n *     function MyConstructor(){}\n *     MyConstructor.prototype.foo = function(){}\n *     BackboneEvents.mixin(MyConstructor.prototype);\n *\n * (c) 2009-2013 Jeremy Ashkenas, DocumentCloud Inc.\n * (c) 2013 Nicolas Perriault\n */\n/* global exports:true, define, module */\n(function() {\n  var root = this,\n      breaker = {},\n      nativeForEach = Array.prototype.forEach,\n      hasOwnProperty = Object.prototype.hasOwnProperty,\n      slice = Array.prototype.slice,\n      idCounter = 0;\n\n  // Returns a partial implementation matching the minimal API subset required\n  // by Backbone.Events\n  function miniscore() {\n    return {\n      keys: Object.keys || function (obj) {\n        if (typeof obj !== \"object\" && typeof obj !== \"function\" || obj === null) {\n          throw new TypeError(\"keys() called on a non-object\");\n        }\n        var key, keys = [];\n        for (key in obj) {\n          if (obj.hasOwnProperty(key)) {\n            keys[keys.length] = key;\n          }\n        }\n        return keys;\n      },\n\n      uniqueId: function(prefix) {\n        var id = ++idCounter + '';\n        return prefix ? prefix + id : id;\n      },\n\n      has: function(obj, key) {\n        return hasOwnProperty.call(obj, key);\n      },\n\n      each: function(obj, iterator, context) {\n        if (obj == null) return;\n        if (nativeForEach && obj.forEach === nativeForEach) {\n          obj.forEach(iterator, context);\n        } else if (obj.length === +obj.length) {\n          for (var i = 0, l = obj.length; i < l; i++) {\n            if (iterator.call(context, obj[i], i, obj) === breaker) return;\n          }\n        } else {\n          for (var key in obj) {\n            if (this.has(obj, key)) {\n              if (iterator.call(context, obj[key], key, obj) === breaker) return;\n            }\n          }\n        }\n      },\n\n      once: function(func) {\n        var ran = false, memo;\n        return function() {\n          if (ran) return memo;\n          ran = true;\n          memo = func.apply(this, arguments);\n          func = null;\n          return memo;\n        };\n      }\n    };\n  }\n\n  var _ = miniscore(), Events;\n\n  // Backbone.Events\n  // ---------------\n\n  // A module that can be mixed in to *any object* in order to provide it with\n  // custom events. You may bind with `on` or remove with `off` callback\n  // functions to an event; `trigger`-ing an event fires all callbacks in\n  // succession.\n  //\n  //     var object = {};\n  //     _.extend(object, Backbone.Events);\n  //     object.on('expand', function(){ alert('expanded'); });\n  //     object.trigger('expand');\n  //\n  Events = {\n\n    // Bind an event to a `callback` function. Passing `\"all\"` will bind\n    // the callback to all events fired.\n    on: function(name, callback, context) {\n      if (!eventsApi(this, 'on', name, [callback, context]) || !callback) return this;\n      this._events || (this._events = {});\n      var events = this._events[name] || (this._events[name] = []);\n      events.push({callback: callback, context: context, ctx: context || this});\n      return this;\n    },\n\n    // Bind an event to only be triggered a single time. After the first time\n    // the callback is invoked, it will be removed.\n    once: function(name, callback, context) {\n      if (!eventsApi(this, 'once', name, [callback, context]) || !callback) return this;\n      var self = this;\n      var once = _.once(function() {\n        self.off(name, once);\n        callback.apply(this, arguments);\n      });\n      once._callback = callback;\n      return this.on(name, once, context);\n    },\n\n    // Remove one or many callbacks. If `context` is null, removes all\n    // callbacks with that function. If `callback` is null, removes all\n    // callbacks for the event. If `name` is null, removes all bound\n    // callbacks for all events.\n    off: function(name, callback, context) {\n      var retain, ev, events, names, i, l, j, k;\n      if (!this._events || !eventsApi(this, 'off', name, [callback, context])) return this;\n      if (!name && !callback && !context) {\n        this._events = {};\n        return this;\n      }\n\n      names = name ? [name] : _.keys(this._events);\n      for (i = 0, l = names.length; i < l; i++) {\n        name = names[i];\n        if (events = this._events[name]) {\n          this._events[name] = retain = [];\n          if (callback || context) {\n            for (j = 0, k = events.length; j < k; j++) {\n              ev = events[j];\n              if ((callback && callback !== ev.callback && callback !== ev.callback._callback) ||\n                  (context && context !== ev.context)) {\n                retain.push(ev);\n              }\n            }\n          }\n          if (!retain.length) delete this._events[name];\n        }\n      }\n\n      return this;\n    },\n\n    // Trigger one or many events, firing all bound callbacks. Callbacks are\n    // passed the same arguments as `trigger` is, apart from the event name\n    // (unless you're listening on `\"all\"`, which will cause your callback to\n    // receive the true name of the event as the first argument).\n    trigger: function(name) {\n      if (!this._events) return this;\n      var args = slice.call(arguments, 1);\n      if (!eventsApi(this, 'trigger', name, args)) return this;\n      var events = this._events[name];\n      var allEvents = this._events.all;\n      if (events) triggerEvents(events, args);\n      if (allEvents) triggerEvents(allEvents, arguments);\n      return this;\n    },\n\n    // Tell this object to stop listening to either specific events ... or\n    // to every object it's currently listening to.\n    stopListening: function(obj, name, callback) {\n      var listeners = this._listeners;\n      if (!listeners) return this;\n      var deleteListener = !name && !callback;\n      if (typeof name === 'object') callback = this;\n      if (obj) (listeners = {})[obj._listenerId] = obj;\n      for (var id in listeners) {\n        listeners[id].off(name, callback, this);\n        if (deleteListener) delete this._listeners[id];\n      }\n      return this;\n    }\n\n  };\n\n  // Regular expression used to split event strings.\n  var eventSplitter = /\\s+/;\n\n  // Implement fancy features of the Events API such as multiple event\n  // names `\"change blur\"` and jQuery-style event maps `{change: action}`\n  // in terms of the existing API.\n  var eventsApi = function(obj, action, name, rest) {\n    if (!name) return true;\n\n    // Handle event maps.\n    if (typeof name === 'object') {\n      for (var key in name) {\n        obj[action].apply(obj, [key, name[key]].concat(rest));\n      }\n      return false;\n    }\n\n    // Handle space separated event names.\n    if (eventSplitter.test(name)) {\n      var names = name.split(eventSplitter);\n      for (var i = 0, l = names.length; i < l; i++) {\n        obj[action].apply(obj, [names[i]].concat(rest));\n      }\n      return false;\n    }\n\n    return true;\n  };\n\n  // A difficult-to-believe, but optimized internal dispatch function for\n  // triggering events. Tries to keep the usual cases speedy (most internal\n  // Backbone events have 3 arguments).\n  var triggerEvents = function(events, args) {\n    var ev, i = -1, l = events.length, a1 = args[0], a2 = args[1], a3 = args[2];\n    switch (args.length) {\n      case 0: while (++i < l) (ev = events[i]).callback.call(ev.ctx); return;\n      case 1: while (++i < l) (ev = events[i]).callback.call(ev.ctx, a1); return;\n      case 2: while (++i < l) (ev = events[i]).callback.call(ev.ctx, a1, a2); return;\n      case 3: while (++i < l) (ev = events[i]).callback.call(ev.ctx, a1, a2, a3); return;\n      default: while (++i < l) (ev = events[i]).callback.apply(ev.ctx, args);\n    }\n  };\n\n  var listenMethods = {listenTo: 'on', listenToOnce: 'once'};\n\n  // Inversion-of-control versions of `on` and `once`. Tell *this* object to\n  // listen to an event in another object ... keeping track of what it's\n  // listening to.\n  _.each(listenMethods, function(implementation, method) {\n    Events[method] = function(obj, name, callback) {\n      var listeners = this._listeners || (this._listeners = {});\n      var id = obj._listenerId || (obj._listenerId = _.uniqueId('l'));\n      listeners[id] = obj;\n      if (typeof name === 'object') callback = this;\n      obj[implementation](name, callback, this);\n      return this;\n    };\n  });\n\n  // Aliases for backwards compatibility.\n  Events.bind   = Events.on;\n  Events.unbind = Events.off;\n\n  // Mixin utility\n  Events.mixin = function(proto) {\n    var exports = ['on', 'once', 'off', 'trigger', 'stopListening', 'listenTo',\n                   'listenToOnce', 'bind', 'unbind'];\n    _.each(exports, function(name) {\n      proto[name] = this[name];\n    }, this);\n    return proto;\n  };\n\n  // Export Events as BackboneEvents depending on current context\n  if (typeof define === \"function\") {\n    define(function() {\n      return Events;\n    });\n  } else if (typeof exports !== 'undefined') {\n    if (typeof module !== 'undefined' && module.exports) {\n      exports = module.exports = Events;\n    }\n    exports.BackboneEvents = Events;\n  } else {\n    root.BackboneEvents = Events;\n  }\n})(this);\n","module.exports = require('./backbone-events-standalone');\n","// Generated by CoffeeScript 1.8.0\nvar GenericReader, xhr;\n\nxhr = require('nets');\n\nmodule.exports = GenericReader = (function() {\n  function GenericReader() {}\n\n  GenericReader.read = function(url, callback) {\n    var onret;\n    onret = (function(_this) {\n      return function(err, response, text) {\n        return _this._onRetrieval(text, callback);\n      };\n    })(this);\n    return xhr(url, onret);\n  };\n\n  GenericReader._onRetrieval = function(text, callback) {\n    var rText;\n    rText = this.parse(text);\n    return callback(rText);\n  };\n\n  return GenericReader;\n\n})();\n","// Generated by CoffeeScript 1.8.0\nvar Fasta, GenericReader, Seq, Str,\n  __hasProp = {}.hasOwnProperty,\n  __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; };\n\nStr = require(\"./strings\");\n\nGenericReader = require(\"./generic_reader\");\n\nSeq = require(\"biojs-model\").seq;\n\nmodule.exports = Fasta = (function(_super) {\n  __extends(Fasta, _super);\n\n  function Fasta() {\n    return Fasta.__super__.constructor.apply(this, arguments);\n  }\n\n  Fasta.parse = function(text) {\n    var currentSeq, database, databaseID, identifiers, k, label, line, seqs, _i, _len;\n    seqs = [];\n    if (Object.prototype.toString.call(text) !== '[object Array]') {\n      text = text.split(\"\\n\");\n    }\n    for (_i = 0, _len = text.length; _i < _len; _i++) {\n      line = text[_i];\n      if (line[0] === \">\" || line[0] === \";\") {\n        label = line.slice(1);\n        currentSeq = new Seq(\"\", label, seqs.length);\n        seqs.push(currentSeq);\n        if (Str.contains(\"|\", line)) {\n          identifiers = label.split(\"|\");\n          k = 1;\n          while (k < identifiers.length) {\n            database = identifiers[k];\n            databaseID = identifiers[k + 1];\n            currentSeq.meta[database] = databaseID;\n            k += 2;\n          }\n          currentSeq.name = identifiers[identifiers.length - 1];\n        }\n      } else {\n        currentSeq.seq += line;\n      }\n    }\n    return seqs;\n  };\n\n  return Fasta;\n\n})(GenericReader);\n","// Generated by CoffeeScript 1.8.0\nvar strings;\n\nstrings = {\n  contains: function(text, search) {\n    return ''.indexOf.call(text, search, 0) !== -1;\n  }\n};\n\nmodule.exports = strings;\n","// Generated by CoffeeScript 1.8.0\nvar Utils;\n\nUtils = {};\n\nUtils.splitNChars = function(txt, num) {\n  var i, result, _i, _ref;\n  result = [];\n  for (i = _i = 0, _ref = txt.length - 1; num > 0 ? _i <= _ref : _i >= _ref; i = _i += num) {\n    result.push(txt.substr(i, num));\n  }\n  return result;\n};\n\nmodule.exports = Utils;\n","// Generated by CoffeeScript 1.8.0\nvar FastaExporter, Utils;\n\nUtils = require(\"./utils\");\n\nmodule.exports = FastaExporter = (function() {\n  function FastaExporter() {}\n\n  FastaExporter[\"export\"] = function(seqs, access) {\n    var seq, text, _i, _len;\n    text = \"\";\n    for (_i = 0, _len = seqs.length; _i < _len; _i++) {\n      seq = seqs[_i];\n      if (access != null) {\n        seq = access(seq);\n      }\n      text += \">\" + seq.name + \"\\n\";\n      text += (Utils.splitNChars(seq.seq, 80)).join(\"\\n\");\n      text += \"\\n\";\n    }\n    return text;\n  };\n\n  return FastaExporter;\n\n})();\n","module.exports.seq = require(\"./seq\");\n","module.exports = function(seq, name, id) {\n    this.seq = seq;\n    this.name = name;\n    this.id = id;\n    this.meta = {};\n};\n","var req = require('request')\n\nmodule.exports = Nets\n\nfunction Nets(uri, opts, cb) {\n  req(uri, opts, cb)\n}","var window = require(\"global/window\")\nvar once = require(\"once\")\nvar parseHeaders = require('parse-headers')\n\nvar messages = {\n    \"0\": \"Internal XMLHttpRequest Error\",\n    \"4\": \"4xx Client Error\",\n    \"5\": \"5xx Server Error\"\n}\n\nvar XHR = window.XMLHttpRequest || noop\nvar XDR = \"withCredentials\" in (new XHR()) ? XHR : window.XDomainRequest\n\nmodule.exports = createXHR\n\nfunction createXHR(options, callback) {\n    if (typeof options === \"string\") {\n        options = { uri: options }\n    }\n\n    options = options || {}\n    callback = once(callback)\n\n    var xhr = options.xhr || null\n\n    if (!xhr) {\n        if (options.cors || options.useXDR) {\n            xhr = new XDR()\n        }else{\n            xhr = new XHR()\n        }\n    }\n\n    var uri = xhr.url = options.uri || options.url\n    var method = xhr.method = options.method || \"GET\"\n    var body = options.body || options.data\n    var headers = xhr.headers = options.headers || {}\n    var sync = !!options.sync\n    var isJson = false\n    var key\n    var load = options.response ? loadResponse : loadXhr\n\n    if (\"json\" in options) {\n        isJson = true\n        headers[\"Accept\"] = \"application/json\"\n        if (method !== \"GET\" && method !== \"HEAD\") {\n            headers[\"Content-Type\"] = \"application/json\"\n            body = JSON.stringify(options.json)\n        }\n    }\n\n    xhr.onreadystatechange = readystatechange\n    xhr.onload = load\n    xhr.onerror = error\n    // IE9 must have onprogress be set to a unique function.\n    xhr.onprogress = function () {\n        // IE must die\n    }\n    // hate IE\n    xhr.ontimeout = noop\n    xhr.open(method, uri, !sync)\n                                    //backward compatibility\n    if (options.withCredentials || (options.cors && options.withCredentials !== false)) {\n        xhr.withCredentials = true\n    }\n\n    // Cannot set timeout with sync request\n    if (!sync) {\n        xhr.timeout = \"timeout\" in options ? options.timeout : 5000\n    }\n\n    if (xhr.setRequestHeader) {\n        for(key in headers){\n            if(headers.hasOwnProperty(key)){\n                xhr.setRequestHeader(key, headers[key])\n            }\n        }\n    } else if (options.headers) {\n        throw new Error(\"Headers cannot be set on an XDomainRequest object\")\n    }\n\n    if (\"responseType\" in options) {\n        xhr.responseType = options.responseType\n    }\n    \n    if (\"beforeSend\" in options && \n        typeof options.beforeSend === \"function\"\n    ) {\n        options.beforeSend(xhr)\n    }\n\n    xhr.send(body)\n\n    return xhr\n\n    function readystatechange() {\n        if (xhr.readyState === 4) {\n            load()\n        }\n    }\n\n    function getBody() {\n        // Chrome with requestType=blob throws errors arround when even testing access to responseText\n        var body = null\n\n        if (xhr.response) {\n            body = xhr.response\n        } else if (xhr.responseType === 'text' || !xhr.responseType) {\n            body = xhr.responseText || xhr.responseXML\n        }\n\n        if (isJson) {\n            try {\n                body = JSON.parse(body)\n            } catch (e) {}\n        }\n\n        return body\n    }\n\n    function getStatusCode() {\n        return xhr.status === 1223 ? 204 : xhr.status\n    }\n\n    // if we're getting a none-ok statusCode, build & return an error\n    function errorFromStatusCode(status, body) {\n        var error = null\n        if (status === 0 || (status >= 400 && status < 600)) {\n            var message = (typeof body === \"string\" ? body : false) ||\n                messages[String(status).charAt(0)]\n            error = new Error(message)\n            error.statusCode = status\n        }\n\n        return error\n    }\n\n    // will load the data & process the response in a special response object\n    function loadResponse() {\n        var status = getStatusCode()\n        var body = getBody()\n        var error = errorFromStatusCode(status, body)\n        var response = {\n            body: body,\n            statusCode: status,\n            statusText: xhr.statusText,\n            raw: xhr\n        }\n        if(xhr.getAllResponseHeaders){ //remember xhr can in fact be XDR for CORS in IE\n            response.headers = parseHeaders(xhr.getAllResponseHeaders())\n        } else {\n            response.headers = {}\n        }\n\n        callback(error, response, response.body)\n    }\n\n    // will load the data and add some response properties to the source xhr\n    // and then respond with that\n    function loadXhr() {\n        var status = getStatusCode()\n        var error = errorFromStatusCode(status)\n\n        xhr.status = xhr.statusCode = status\n        xhr.body = getBody()\n        xhr.headers = parseHeaders(xhr.getAllResponseHeaders())\n\n        callback(error, xhr, xhr.body)\n    }\n\n    function error(evt) {\n        callback(evt, xhr)\n    }\n}\n\n\nfunction noop() {}\n","if (typeof window !== \"undefined\") {\n    module.exports = window;\n} else if (typeof global !== \"undefined\") {\n    module.exports = global;\n} else if (typeof self !== \"undefined\"){\n    module.exports = self;\n} else {\n    module.exports = {};\n}\n","module.exports = once\n\nonce.proto = once(function () {\n  Object.defineProperty(Function.prototype, 'once', {\n    value: function () {\n      return once(this)\n    },\n    configurable: true\n  })\n})\n\nfunction once (fn) {\n  var called = false\n  return function () {\n    if (called) return\n    called = true\n    return fn.apply(this, arguments)\n  }\n}\n","var isFunction = require('is-function')\n\nmodule.exports = forEach\n\nvar toString = Object.prototype.toString\nvar hasOwnProperty = Object.prototype.hasOwnProperty\n\nfunction forEach(list, iterator, context) {\n    if (!isFunction(iterator)) {\n        throw new TypeError('iterator must be a function')\n    }\n\n    if (arguments.length < 3) {\n        context = this\n    }\n    \n    if (toString.call(list) === '[object Array]')\n        forEachArray(list, iterator, context)\n    else if (typeof list === 'string')\n        forEachString(list, iterator, context)\n    else\n        forEachObject(list, iterator, context)\n}\n\nfunction forEachArray(array, iterator, context) {\n    for (var i = 0, len = array.length; i < len; i++) {\n        if (hasOwnProperty.call(array, i)) {\n            iterator.call(context, array[i], i, array)\n        }\n    }\n}\n\nfunction forEachString(string, iterator, context) {\n    for (var i = 0, len = string.length; i < len; i++) {\n        // no such thing as a sparse string.\n        iterator.call(context, string.charAt(i), i, string)\n    }\n}\n\nfunction forEachObject(object, iterator, context) {\n    for (var k in object) {\n        if (hasOwnProperty.call(object, k)) {\n            iterator.call(context, object[k], k, object)\n        }\n    }\n}\n","module.exports = isFunction\n\nvar toString = Object.prototype.toString\n\nfunction isFunction (fn) {\n  var string = toString.call(fn)\n  return string === '[object Function]' ||\n    (typeof fn === 'function' && string !== '[object RegExp]') ||\n    (typeof window !== 'undefined' &&\n     // IE8 and below\n     (fn === window.setTimeout ||\n      fn === window.alert ||\n      fn === window.confirm ||\n      fn === window.prompt))\n};\n","\nexports = module.exports = trim;\n\nfunction trim(str){\n  return str.replace(/^\\s*|\\s*$/g, '');\n}\n\nexports.left = function(str){\n  return str.replace(/^\\s*/, '');\n};\n\nexports.right = function(str){\n  return str.replace(/\\s*$/, '');\n};\n","var trim = require('trim')\n  , forEach = require('for-each')\n  , isArray = function(arg) {\n      return Object.prototype.toString.call(arg) === '[object Array]';\n    }\n\nmodule.exports = function (headers) {\n  if (!headers)\n    return {}\n\n  var result = {}\n\n  forEach(\n      trim(headers).split('\\n')\n    , function (row) {\n        var index = row.indexOf(':')\n          , key = trim(row.slice(0, index)).toLowerCase()\n          , value = trim(row.slice(index + 1))\n\n        if (typeof(result[key]) === 'undefined') {\n          result[key] = value\n        } else if (isArray(result[key])) {\n          result[key].push(value)\n        } else {\n          result[key] = [ result[key], value ]\n        }\n      }\n  )\n\n  return result\n}","module.exports = require('./jquery.browser');\n","/*!\n * jQuery Browser Plugin v0.0.6\n * https://github.com/gabceb/jquery-browser-plugin\n *\n * Original jquery-browser code Copyright 2005, 2013 jQuery Foundation, Inc. and other contributors\n * http://jquery.org/license\n *\n * Modifications Copyright 2013 Gabriel Cebrian\n * https://github.com/gabceb\n *\n * Released under the MIT license\n *\n * Date: 2013-07-29T17:23:27-07:00\n */\n\n\nvar matched, browser;\n\nvar uaMatch = function( ua ) {\n  ua = ua.toLowerCase();\n\n  var match = /(opr)[\\/]([\\w.]+)/.exec( ua ) ||\n    /(chrome)[ \\/]([\\w.]+)/.exec( ua ) ||\n    /(version)[ \\/]([\\w.]+).*(safari)[ \\/]([\\w.]+)/.exec( ua ) ||\n    /(webkit)[ \\/]([\\w.]+)/.exec( ua ) ||\n    /(opera)(?:.*version|)[ \\/]([\\w.]+)/.exec( ua ) ||\n    /(msie) ([\\w.]+)/.exec( ua ) ||\n    ua.indexOf(\"trident\") >= 0 && /(rv)(?::| )([\\w.]+)/.exec( ua ) ||\n    ua.indexOf(\"compatible\") < 0 && /(mozilla)(?:.*? rv:([\\w.]+)|)/.exec( ua ) ||\n    [];\n\n  var platform_match = /(ipad)/.exec( ua ) ||\n    /(iphone)/.exec( ua ) ||\n    /(android)/.exec( ua ) ||\n    /(windows phone)/.exec( ua ) ||\n    /(win)/.exec( ua ) ||\n    /(mac)/.exec( ua ) ||\n    /(linux)/.exec( ua ) ||\n    /(cros)/i.exec( ua ) ||\n    [];\n\n  return {\n    browser: match[ 3 ] || match[ 1 ] || \"\",\n    version: match[ 2 ] || \"0\",\n    platform: platform_match[ 0 ] || \"\"\n  };\n};\n\nmatched = uaMatch( window.navigator.userAgent );\nbrowser = {};\nbrowser.uaMatch = uaMatch;\n\nif ( matched.browser ) {\n  browser[ matched.browser ] = true;\n  browser.version = matched.version;\n  browser.versionNumber = parseInt(matched.version);\n}\n\nif ( matched.platform ) {\n  browser[ matched.platform ] = true;\n}\n\n// These are all considered mobile platforms, meaning they run a mobile browser\nif ( browser.android || browser.ipad || browser.iphone || browser[ \"windows phone\" ] ) {\n  browser.mobile = true;\n}\n\n// These are all considered desktop platforms, meaning they run a desktop browser\nif ( browser.cros || browser.mac || browser.linux || browser.win ) {\n  browser.desktop = true;\n}\n\n// Chrome, Opera 15+ and Safari are webkit based browsers\nif ( browser.chrome || browser.opr || browser.safari ) {\n  browser.webkit = true;\n}\n\n// IE11 has a new token so we will assign it msie to avoid breaking changes\nif ( browser.rv )\n{\n  var ie = \"msie\";\n\n  matched.browser = ie;\n  browser[ie] = true;\n}\n\n// Opera 15+ are identified as opr\nif ( browser.opr )\n{\n  var opera = \"opera\";\n\n  matched.browser = opera;\n  browser[opera] = true;\n}\n\n// Stock Android browsers are marked as Safari on Android.\nif ( browser.safari && browser.android )\n{\n  var android = \"android\";\n\n  matched.browser = android;\n  browser[android] = true;\n}\n\n// Assign the name and platform variable\nbrowser.name = matched.browser;\nbrowser.platform = matched.platform;\n\n\nmodule.exports = browser;\n","/** @preserve http://github.com/easeway/js-class */\n\n// Class Definition using ECMA5 prototype chain\n\nfunction inherit(dest, src, noParent) {\n    while (src && src !== Object.prototype) {\n        Object.getOwnPropertyNames(src).forEach(function (name) {\n            if (name != '.class' && !dest.hasOwnProperty(name)) {\n                var desc = Object.getOwnPropertyDescriptor(src, name);\n                Object.defineProperty(dest, name, desc);\n            }\n        });\n        if (noParent) {\n            break;\n        }\n        src = src.__proto__;\n    }\n    return dest;\n}\n\nvar Class = function (base, proto, options) {\n    if (typeof(base) != 'function') {\n        options = proto;\n        proto = base;\n        base = Object;\n    }\n    if (!proto) {\n        proto = {};\n    }\n    if (!options) {\n        options = {};\n    }\n    \n    var meta = {\n        name: options.name,\n        base: base,\n        implements: []\n    }\n    var classProto = Class.clone(proto);\n    if (options.implements) {\n        (Array.isArray(options.implements) ? options.implements : [options.implements])\n            .forEach(function (implementedType) {\n                if (typeof(implementedType) == 'function' && implementedType.prototype) {\n                    meta.implements.push(implementedType);\n                    Class.extend(classProto, implementedType.prototype);\n                }\n            });\n    }\n    classProto.__proto__ = base.prototype;\n    var theClass = function () {\n        if (typeof(this.constructor) == 'function') {\n            this.constructor.apply(this, arguments);\n        }\n    };\n    meta.type = theClass;\n    theClass.prototype = classProto;\n    Object.defineProperty(theClass, '.class.meta', { value: meta, enumerable: false, configurable: false, writable: false });\n    Object.defineProperty(classProto, '.class', { value: theClass, enumerable: false, configurable: false, writable: false });\n    if (options.statics) {\n        Class.extend(theClass, options.statics);\n    }\n    return theClass;\n};\n\nClass.extend = inherit;\n\nClass.clone = function (object) {\n    return inherit({}, object);\n};\n\nfunction findType(meta, type) {\n    while (meta) {\n        if (meta.type.prototype === type.prototype) {\n            return true;\n        }\n        for (var i in meta.implements) {\n            var implType = meta.implements[i];\n            var implMeta = implType['.class.meta'];\n            if (implMeta) {\n                if (findType(implMeta, type)) {\n                    return true;\n                }\n            } else {\n                for (var proto = implType.prototype; proto; proto = proto.__proto__) {\n                    if (proto === type.prototype) {\n                        return true;\n                    }\n                }\n            }\n        }\n        meta = meta.base ? meta.base['.class.meta'] : undefined;\n    }\n    return false;\n}\n\nvar Checker = Class({\n    constructor: function (object) {\n        this.object = object;\n    },\n    \n    typeOf: function (type) {\n        if (this.object instanceof type) {\n            return true;\n        }\n        var meta = Class.typeInfo(this.object);\n        return meta && findType(meta, type);\n    }\n});\n\n// aliases\nChecker.prototype.a = Checker.prototype.typeOf;\nChecker.prototype.an = Checker.prototype.typeOf;\n\nClass.is = function (object) {\n    return new Checker(object);\n};\n\nClass.typeInfo = function (object) {\n    var theClass = object.__proto__['.class'];\n    return theClass ? theClass['.class.meta'] : undefined;\n};\n\nClass.VERSION = [0, 0, 2];\n\nif (module) {\n    module.exports = Class;\n} else {\n    global.Class = Class;   // for browser\n}","// Generated by CoffeeScript 1.8.0\nmodule.exports.parse = require(\"./parser\");\n\nmodule.exports.writer = require(\"./writer\");\n","module.exports = require(\"./lib/index\");\n"]}