/*
 * Script: Moo.js
 * 	My Object Oriented javascript.
 * 		
 * 		Dependancies:
 * 			 Has no dependancies.
 * 			 	
 * 			 	Author:
 * 			 		Valerio Proietti, <http://mad4milk.net>
 *
 * 			 		License:
 * 			 			MIT-style license.
 *
 * 			 			Credits:
 * 			 				- Class is slightly based on Base.js  <http://dean.edwards.name/weblog/2006/03/base/> (c) 2006 Dean Edwards, License <http://creativecommons.org/licenses/LGPL/2.1/>
 * 			 					- Some functions are based on those found in prototype.js <http://prototype.conio.net/> (c) 2005 Sam Stephenson sam [at] conio [dot] net, MIT-style license
 * 			 						- Documentation by Aaron Newton (aaron.newton [at] cnet [dot] com) and Valerio Proietti.
 * 			 						*/

/*
 * Class: Class
 * 	The base class object of the <http://mootools.net> framework.
 * 		
 * 		Arguments:
 * 			properties - the collection of properties that apply to the class. Creates a new class, its initialize method will fire upon class instantiation.
 * 				
 * 				Example:
 * 					>var Cat = new Class({
 * 						>	initialize: function(name){
 * 							>		this.name = name;
 * 								>	}
 * 									>});
 * 										>var myCat = new Cat('Micia');
 * 											>alert myCat.name; //alerts 'Micia'
 * 											*/

var Class = function(properties){
	var klass = function(){
			for (var p in this){
						if (this[p]) this[p]._proto_ = this;
								}
										if (arguments[0] != 'noinit' && this.initialize) return this.initialize.apply(this, arguments);
											};
												klass.extend = this.extend;
													klass.implement = this.implement;
														klass.prototype = properties;
															return klass;
															};

															/*
															 * Property: empty
															 * 	Returns an empty function
															 * 	*/

															Class.empty = function(){};

															/*
															 * Property: create
															 * 	same as new Class. see <Class>
															 * 	*/

															Class.create = function(properties){
																return new Class(properties);
																};

																Class.prototype = {

																	/*
																	 * 	Property: extend
																	 * 			Returns the copy of the Class extended with the passed in properties.
																	 * 					
																	 * 						Arguments:
																	 * 								properties - the properties to add to the base class in this new Class.
																	 * 										
																	 * 											Example:
																	 * 													>var Animal = new Class({
																	 * 															>	initialize: function(age){
																	 * 																	>		this.age = age;
																	 * 																			>	}
																	 * 																					>});
																	 * 																							>var Cat = Animal.extend({
																	 * 																									>	initialize: function(name, age){
																	 * 																											>		this.parent(age); //will call the previous initialize;
																	 * 																													>		this.name = name;
																	 * 																															>	}
																	 * 																																	>});
																	 * 																																			>var myCat = new Cat('Micia', 20);
																	 * 																																					>alert myCat.name; //alerts 'Micia'
																	 * 																																							>alert myCat.age; //alerts 20
																	 * 																																								*/

																		extend: function(properties){
																				var pr0t0typ3 = new this('noinit');
																						for (var property in properties){
																									var previous = pr0t0typ3[property];
																												var current = properties[property];
																															if (previous && previous != current) current = previous.parentize(current) || current;
																																		pr0t0typ3[property] = current;
																																				}
																																						return new Class(pr0t0typ3);
																																							},
																																								
																																									/*	
																																									 *		Property: implement
																																									 *				Implements the passed in properties to the base Class prototypes, altering the base class, unlike <Class.extend>.
																																									 *
																																									 *					Arguments:
																																									 *							properties - the properties to add to the base class.
																																									 *									
																																									 *										Example:
																																									 *												>var Animal = new Class({
																																									 *														>	initialize: function(age){
																																									 *																>		this.age = age;
																																									 *																		>	}
																																									 *																				>});
																																									 *																						>Animal.implement({
																																									 *																								>	setName: function(name){
																																									 *																										>		this.name = name
																																									 *																												>	}
																																									 *																														>});
																																									 *																																>var myAnimal = new Animal(20);
																																									 *																																		>myAnimal.setName('Micia');
																																									 *																																				>alert(myAnimal.name); //alerts 'Micia'
																																									 *																																					*/
																																										
																																											implement: function(properties){
																																													for (var property in properties) this.prototype[property] = properties[property];
																																														}

																																														};

																																														/* Section: Object related Functions  */

																																														/*
																																														 * Function: Object.extend
																																														 * 	Copies all the properties from the second passed object to the first passed Object.
																																														 * 		If you do myWhatever.extend = Object.extend the first parameter will become myWhatever, and your extend function will only need one parameter.
																																														 * 				
																																														 * 				Example:
																																														 * 					>var firstOb = {
																																														 * 						>	'name': 'John',
																																														 * 							>	'lastName': 'Doe'
																																														 * 								>};
																																														 * 									>var secondOb = {
																																														 * 										>	'age': '20',
																																														 * 											>	'sex': 'male',
																																														 * 												>	'lastName': 'Dorian'
																																														 * 													>};
																																														 * 														>Object.extend(firstOb, secondOb);
																																														 * 															>//firstOb will become: 
																																														 * 																>{
																																														 * 																	>	'name': 'John',
																																														 * 																		>	'lastName': 'Dorian',
																																														 * 																			>	'age': '20',
																																														 * 																				>	'sex': 'male'
																																														 * 																					>};
																																														 * 																						
																																														 * 																						Returns:
																																														 * 																							The first object, extended.
																																														 * 																							*/

																																														Object.extend = function(){
																																															var args = arguments;
																																																if (args[1]) args = [args[0], args[1]];
																																																	else args = [this, args[0]];
																																																		for (var property in args[1]) args[0][property] = args[1][property];
																																																			return args[0];
																																																			};

																																																			/*
																																																			 * Function: Object.Native
																																																			 * 	Will add a .extend method to the objects passed as a parameter, equivalent to <Class.implement>
																																																			 *
																																																			 * 	Arguments:
																																																			 * 		a number of classes/native javascript objects
																																																			 *
																																																			 * 		*/

																																																			Object.Native = function(){
																																																				for (var i = 0; i < arguments.length; i++) arguments[i].extend = Class.prototype.implement;
																																																				};

																																																				new Object.Native(Function, Array, String, Number);

																																																				Function.extend({

																																																					parentize: function(current){
																																																							var previous = this;
																																																									return function(){
																																																												this.parent = previous;
																																																															return current.apply(this, arguments);
																																																																	};
																																																																		}

																																																																		});
																																																																		/* 
																																																																		 * Script: Function.js
																																																																		 * 	Contains Function prototypes, utility functions and Chain.
																																																																		 *
																																																																		 * 	Dependencies: 
																																																																		 * 		<Moo.js>
																																																																		 *
																																																																		 * 		Author:
																																																																		 * 			Valerio Proietti, <http://mad4milk.net>
																																																																		 *
																																																																		 * 			License:
																																																																		 * 				MIT-style license.
																																																																		 *
																																																																		 * 				Credits:
																																																																		 * 					- Some functions are inspired by those found in prototype.js <http://prototype.conio.net/> (c) 2005 Sam Stephenson sam [at] conio [dot] net, MIT-style license
																																																																		 * 					*/

																																																																		/*
																																																																		 * Class: Function
																																																																		 * 	A collection of The Function Object prototype methods.
																																																																		 * 	*/

																																																																		Function.extend({
																																																																			
																																																																				/*
																																																																				 * 	Property: pass
																																																																				 * 			Shortcut to create closures with arguments and bind.
																																																																				 * 				
																																																																				 * 					Returns:
																																																																				 * 							a function.
																																																																				 * 								
																																																																				 * 									Arguments:
																																																																				 * 											args - the arguments to pass to that function (array or single variable)
																																																																				 * 													bind - optional, the object that the "this" of the function will refer to.
																																																																				 * 														
																																																																				 * 															Example:
																																																																				 * 																	>myFunction.pass([arg1, arg2], myElement);
																																																																				 * 																		*/
																																																																					
																																																																						pass: function(args, bind){
																																																																								var fn = this;
																																																																										if ($type(args) != 'array') args = [args];
																																																																												return function(){
																																																																															return fn.apply(bind || fn._proto_ || fn, args);
																																																																																	};
																																																																																		},
																																																																																			
																																																																																				/*
																																																																																				 * 	Property: bind
																																																																																				 * 			method to easily create closures with "this" altered.
																																																																																				 * 				
																																																																																				 * 					Arguments:
																																																																																				 * 							bind - optional, the object that the "this" of the function will refer to.
																																																																																				 * 								
																																																																																				 * 									Returns:
																																																																																				 * 											a function.
																																																																																				 * 												
																																																																																				 * 													Example:
																																																																																				 * 															>function myFunction(){
																																																																																				 * 																	>	this.setStyle('color', 'red');
																																																																																				 * 																			>	// note that 'this' here refers to myFunction, not an element
																																																																																				 * 																					>	// we'll need to bind this function to the element we want to alter
																																																																																				 * 																							>};
																																																																																				 * 																									>var myBoundFunction = myFunction.bind(myElement);
																																																																																				 * 																											>myBoundFunction(); // this will make the element myElement red.
																																																																																				 * 																												*/
																																																																																					
																																																																																						bind: function(bind){
																																																																																								var fn = this;
																																																																																										return function(){
																																																																																													return fn.apply(bind, arguments);
																																																																																															};
																																																																																																},
																																																																																																	
																																																																																																		/*
																																																																																																		 * 	Property: bindAsEventListener
																																																																																																		 * 			cross browser method to pass event firer
																																																																																																		 * 				
																																																																																																		 * 					Arguments:
																																																																																																		 * 							bind - optional, the object that the "this" of the function will refer to.
																																																																																																		 * 								
																																																																																																		 * 									Returns:
																																																																																																		 * 											a function with the parameter bind as its "this" and as a pre-passed argument event or window.event, depending on the browser.
																																																																																																		 * 												
																																																																																																		 * 													Example:
																																																																																																		 * 															>function myFunction(event){
																																																																																																		 * 																	>	alert(event.clientx) //returns the coordinates of the mouse..
																																																																																																		 * 																			>};
																																																																																																		 * 																					>myElement.onclick = myFunction.bindAsEventListener(myElement);
																																																																																																		 * 																						*/
																																																																																																				
																																																																																																					bindAsEventListener: function(bind){
																																																																																																							var fn = this;
																																																																																																									return function(event){
																																																																																																												fn.call(bind, event || window.event);
																																																																																																															return false;
																																																																																																																	};
																																																																																																																		},
																																																																																																																			
																																																																																																																				/*
																																																																																																																				 * 	Property: delay
																																																																																																																				 * 			Delays the execution of a function by a specified duration.
																																																																																																																				 * 				
																																																																																																																				 * 					Arguments:
																																																																																																																				 * 							ms - the duration to wait in milliseconds
																																																																																																																				 * 									bind - optional, the object that the "this" of the function will refer to.
																																																																																																																				 * 										
																																																																																																																				 * 											Example:
																																																																																																																				 * 													>myFunction.delay(50, myElement) //wait 50 milliseconds, then call myFunction and bind myElement to it
																																																																																																																				 * 															>(function(){alert('one second later...')}).delay(1000); //wait a second and alert
																																																																																																																				 * 																*/
																																																																																																																					
																																																																																																																						delay: function(ms, bind){
																																																																																																																								return setTimeout(this.bind(bind || this._proto_ || this), ms);
																																																																																																																									},
																																																																																																																										
																																																																																																																											/*
																																																																																																																											 * 	Property: periodical
																																																																																																																											 * 			Executes a function in the specified intervals of time
																																																																																																																											 * 					
																																																																																																																											 * 						Arguments:
																																																																																																																											 * 								ms - the duration of the intervals between executions.
																																																																																																																											 * 										bind - optional, the object that the "this" of the function will refer to.
																																																																																																																											 * 											*/
																																																																																																																												
																																																																																																																													periodical: function(ms, bind){
																																																																																																																															return setInterval(this.bind(bind || this._proto_ || this), ms);
																																																																																																																																}

																																																																																																																																});

																																																																																																																																/* Section: Utility Functions  */

																																																																																																																																/*
																																																																																																																																 * Function: $clear
																																																																																																																																 * 	clears a timeout or an Interval.
																																																																																																																																 *
																																																																																																																																 * 	Returns:
																																																																																																																																 * 		null
																																																																																																																																 *
																																																																																																																																 * 		Arguments:
																																																																																																																																 * 			timer - the setInterval or setTimeout to clear.
																																																																																																																																 *
																																																																																																																																 * 			Example:
																																																																																																																																 * 				>var myTimer = myFunction.delay(5000); //wait 5 seconds and execute my function.
																																																																																																																																 * 					>myTimer = $clear(myTimer); //nevermind
																																																																																																																																 *
																																																																																																																																 * 					See also:
																																																																																																																																 * 						<Function.delay>, <Function.periodical>
																																																																																																																																 * 						*/

																																																																																																																																function $clear(timer){
																																																																																																																																	clearTimeout(timer);
																																																																																																																																		clearInterval(timer);
																																																																																																																																			return null;
																																																																																																																																			};

																																																																																																																																			/*
																																																																																																																																			 * Function: $type
																																																																																																																																			 * 	Returns the type of object that matches the element passed in.
																																																																																																																																			 *
																																																																																																																																			 * 	Arguments:
																																																																																																																																			 * 		obj - the object to inspect.
																																																																																																																																			 *
																																																																																																																																			 * 		Example:
																																																																																																																																			 * 			>var myString = 'hello';
																																																																																																																																			 * 				>$type(myString); //returns "string"
																																																																																																																																			 *
																																																																																																																																			 * 				Returns:
																																																																																																																																			 * 					'function' - if obj is a function
																																																																																																																																			 * 						'textnode' - if obj is a node but not an element
																																																																																																																																			 * 							'element' - if obj is a DOM element
																																																																																																																																			 * 								'array' - if obj is an array
																																																																																																																																			 * 									'object' - if obj is an object
																																																																																																																																			 * 										'string' - if obj is a string
																																																																																																																																			 * 											'number' - if obj is a number
																																																																																																																																			 * 												false - (boolean) if the object is not defined or none of the above, or if it's an empty string.
																																																																																																																																			 * 												*/
																																																																																																																																				
																																																																																																																																				function $type(obj){
																																																																																																																																					if (!obj) return false;
																																																																																																																																						var type = false;
																																																																																																																																							if (obj instanceof Function) type = 'function';
																																																																																																																																								else if (obj.nodeName){
																																																																																																																																										if (obj.nodeType == 3 && !/\S/.test(obj.nodeValue)) type = 'textnode';
																																																																																																																																												else if (obj.nodeType == 1) type = 'element';
																																																																																																																																													}
																																																																																																																																														else if (obj instanceof Array) type = 'array';
																																																																																																																																															else if (typeof obj == 'object') type = 'object';
																																																																																																																																																else if (typeof obj == 'string') type = 'string';
																																																																																																																																																	else if (typeof obj == 'number' && isFinite(obj)) type = 'number';
																																																																																																																																																		return type;
																																																																																																																																																		};

																																																																																																																																																		/*Class: Chain*/

																																																																																																																																																		var Chain = new Class({
																																																																																																																																																			
																																																																																																																																																				/*
																																																																																																																																																				 * 	Property: chain
																																																																																																																																																				 * 			adds a function to the Chain instance stack.
																																																																																																																																																				 * 					
																																																																																																																																																				 * 						Arguments:
																																																																																																																																																				 * 								fn - the function to append.
																																																																																																																																																				 * 									
																																																																																																																																																				 * 										Returns:
																																																																																																																																																				 * 												the instance of the <Chain> class.
																																																																																																																																																				 * 													
																																																																																																																																																				 * 														Example:
																																																																																																																																																				 * 																>var myChain = new Chain();
																																																																																																																																																				 * 																		>myChain.chain(myFunction).chain(myFunction2);
																																																																																																																																																				 * 																			*/
																																																																																																																																																					
																																																																																																																																																						chain: function(fn){
																																																																																																																																																								this.chains = this.chains || [];
																																																																																																																																																										this.chains.push(fn);
																																																																																																																																																												return this;
																																																																																																																																																													},
																																																																																																																																																														
																																																																																																																																																															/*
																																																																																																																																																															 * 	Property: callChain
																																																																																																																																																															 * 			Executes the first function of the Chain instance stack, then removes it. The first function will then become the second.
																																																																																																																																																															 *
																																																																																																																																																															 * 				Example:
																																																																																																																																																															 * 						>myChain.callChain(); //executes myFunction
																																																																																																																																																															 * 								>myChain.callChain(); //executes myFunction2
																																																																																																																																																															 * 									*/
																																																																																																																																																																
																																																																																																																																																																	callChain: function(){
																																																																																																																																																																			if (this.chains && this.chains.length) this.chains.splice(0, 1)[0].delay(10, this);
																																																																																																																																																																				},

																																																																																																																																																																					/*
																																																																																																																																																																					 * 	Property: clearChain
																																																																																																																																																																					 * 			Clears the stack of a Chain instance.
																																																																																																																																																																					 * 				*/
																																																																																																																																																																						
																																																																																																																																																																							clearChain: function(){
																																																																																																																																																																									this.chains = [];
																																																																																																																																																																										}

																																																																																																																																																																										});
																																																																																																																																																																										/*
																																																																																																																																																																										 * Script: Array.js
																																																																																																																																																																										 * 	Contains Array prototypes and the function <$A>;
																																																																																																																																																																										 *
																																																																																																																																																																										 * 	Dependencies:
																																																																																																																																																																										 * 		<Moo.js>
																																																																																																																																																																										 *
																																																																																																																																																																										 * 			
																																																																																																																																																																										 * 			Author:
																																																																																																																																																																										 * 				Valerio Proietti, <http://mad4milk.net>
																																																																																																																																																																										 *
																																																																																																																																																																										 * 				License:
																																																																																																																																																																										 * 					MIT-style license.
																																																																																																																																																																										 * 					*/

																																																																																																																																																																										/*
																																																																																																																																																																										 * Class: Array
																																																																																																																																																																										 * 	A collection of The Array Object prototype methods.
																																																																																																																																																																										 * 	*/

																																																																																																																																																																										if (!Array.prototype.forEach){
																																																																																																																																																																											
																																																																																																																																																																												/*	
																																																																																																																																																																												 *		Mehod: forEach
																																																																																																																																																																												 *				Iterates through an array; note: <Array.each> is the preferred syntax for this funciton.
																																																																																																																																																																												 *						
																																																																																																																																																																												 *							Arguments:
																																																																																																																																																																												 *									fn - the function to execute with each item in the array
																																																																																																																																																																												 *											bind - optional, the object that the "this" of the function will refer to.
																																																																																																																																																																												 *													
																																																																																																																																																																												 *														Example:
																																																																																																																																																																												 *																>var Animals = ['Cat', 'Dog', 'Coala'];
																																																																																																																																																																												 *																		>Animals.forEach(function(animal){
																																																																																																																																																																												 *																				>	document.write(animal)
																																																																																																																																																																												 *																						>});
																																																																																																																																																																												 *
																																																																																																																																																																												 *																							See also:
																																																																																																																																																																												 *																									<Function.bind>
																																																																																																																																																																												 *																											<Array.each>
																																																																																																																																																																												 *																												*/
																																																																																																																																																																													
																																																																																																																																																																														Array.prototype.forEach = function(fn, bind){
																																																																																																																																																																																for(var i = 0; i < this.length ; i++) fn.call(bind, this[i], i);
																																																																																																																																																																																	};
																																																																																																																																																																																	}

																																																																																																																																																																																	Array.extend({
																																																																																																																																																																																		
																																																																																																																																																																																			/*
																																																																																																																																																																																			 * 	Property: each
																																																																																																																																																																																			 * 			Same as <Array.each>.
																																																																																																																																																																																			 * 				*/
																																																																																																																																																																																				
																																																																																																																																																																																					each: Array.prototype.forEach,
																																																																																																																																																																																						
																																																																																																																																																																																							/*	
																																																																																																																																																																																							 *		Property: copy
																																																																																																																																																																																							 *				Copy the array and returns it.
																																																																																																																																																																																							 *					
																																																																																																																																																																																							 *						Returns:
																																																																																																																																																																																							 *								an Array
																																																																																																																																																																																							 *											
																																																																																																																																																																																							 *												Example:
																																																																																																																																																																																							 *														>var letters = ["a","b","c"];
																																																																																																																																																																																							 *																>var copy = ["a","b","c"].copy();
																																																																																																																																																																																							 *																	*/
																																																																																																																																																																																								
																																																																																																																																																																																									copy: function(){
																																																																																																																																																																																											var newArray = [];
																																																																																																																																																																																													for (var i = 0; i < this.length; i++) newArray.push(this[i]);
																																																																																																																																																																																															return newArray;
																																																																																																																																																																																																},
																																																																																																																																																																																																	
																																																																																																																																																																																																		/*	
																																																																																																																																																																																																		 *		Property: remove
																																																																																																																																																																																																		 *				Removes an item from the array.
																																																																																																																																																																																																		 *						
																																																																																																																																																																																																		 *							Arguments:
																																																																																																																																																																																																		 *									item - the item to remove
																																																																																																																																																																																																		 *											
																																																																																																																																																																																																		 *												Returns:
																																																																																																																																																																																																		 *														the Array without the item removed.
																																																																																																																																																																																																		 *																
																																																																																																																																																																																																		 *																	Example:
																																																																																																																																																																																																		 *																			>["1","2","3"].remove("2") // ["1","3"];
																																																																																																																																																																																																		 *																				*/
																																																																																																																																																																																																			
																																																																																																																																																																																																				remove: function(item){
																																																																																																																																																																																																						for (var i = 0; i < this.length; i++){
																																																																																																																																																																																																									if (this[i] == item) this.splice(i, 1);
																																																																																																																																																																																																											}
																																																																																																																																																																																																													return this;
																																																																																																																																																																																																														},
																																																																																																																																																																																																															
																																																																																																																																																																																																																/*	
																																																																																																																																																																																																																 *		Property: test
																																																																																																																																																																																																																 *				Tests an array for the presence of an item.
																																																																																																																																																																																																																 *						
																																																																																																																																																																																																																 *							Arguments:
																																																																																																																																																																																																																 *									item - the item to search for in the array.
																																																																																																																																																																																																																 *											
																																																																																																																																																																																																																 *												Returns:
																																																																																																																																																																																																																 *														true - the item was found
																																																																																																																																																																																																																 *																false - it wasn't
																																																																																																																																																																																																																 *																		
																																																																																																																																																																																																																 *																			Example:
																																																																																																																																																																																																																 *																					>["a","b","c"].test("a"); // true
																																																																																																																																																																																																																 *																							>["a","b","c"].test("d"); // false
																																																																																																																																																																																																																 *																								*/
																																																																																																																																																																																																																	
																																																																																																																																																																																																																		test: function(item){
																																																																																																																																																																																																																				for (var i = 0; i < this.length; i++){
																																																																																																																																																																																																																							if (this[i] == item) return true;
																																																																																																																																																																																																																									};
																																																																																																																																																																																																																											return false;
																																																																																																																																																																																																																												},
																																																																																																																																																																																																																													
																																																																																																																																																																																																																														/*	
																																																																																																																																																																																																																														 *		Property: extend
																																																																																																																																																																																																																														 *				Extends an array with another
																																																																																																																																																																																																																														 *						
																																																																																																																																																																																																																														 *							Arguments:
																																																																																																																																																																																																																														 *									newArray - the array to extend ours with
																																																																																																																																																																																																																														 *											
																																																																																																																																																																																																																														 *												Example:
																																																																																																																																																																																																																														 *														>var Animals = ['Cat', 'Dog', 'Coala'];
																																																																																																																																																																																																																														 *																>Animals.extend(['Lizard']);
																																																																																																																																																																																																																														 *																		>//Animals is now: ['Cat', 'Dog', 'Coala', 'Lizard'];
																																																																																																																																																																																																																														 *																			*/
																																																																																																																																																																																																																															
																																																																																																																																																																																																																																extend: function(newArray){
																																																																																																																																																																																																																																		for (var i = 0; i < newArray.length; i++) this.push(newArray[i]);
																																																																																																																																																																																																																																				return this;
																																																																																																																																																																																																																																					},
																																																																																																																																																																																																																																						
																																																																																																																																																																																																																																							/*	
																																																																																																																																																																																																																																							 *		Property: associate
																																																																																																																																																																																																																																							 *				Creates an associative array based on the array of keywords passed in.
																																																																																																																																																																																																																																							 *						
																																																																																																																																																																																																																																							 *							Arguments:
																																																																																																																																																																																																																																							 *									keys - the array of keywords.
																																																																																																																																																																																																																																							 *											
																																																																																																																																																																																																																																							 *												Example:
																																																																																																																																																																																																																																							 *														(sart code)
																																																																																																																																																																																																																																							 *																var Animals = ['Cat', 'Dog', 'Coala', 'Lizard'];
																																																																																																																																																																																																																																							 *																		var Speech = ['Miao', 'Bau', 'Fruuu', 'Mute'];
																																																																																																																																																																																																																																							 *																				var Speeches = Animals.associate(speech);
																																																																																																																																																																																																																																							 *																						//Speeches['Miao'] is now Cat.
																																																																																																																																																																																																																																							 *																								//Speeches['Bau'] is now Dog.
																																																																																																																																																																																																																																							 *																										//...
																																																																																																																																																																																																																																							 *																												(end)
																																																																																																																																																																																																																																							 *																													*/
																																																																																																																																																																																																																																								
																																																																																																																																																																																																																																									associate: function(keys){
																																																																																																																																																																																																																																											var newArray = [];
																																																																																																																																																																																																																																													for (var i =0; i < this.length; i++) newArray[keys[i]] = this[i];
																																																																																																																																																																																																																																															return newArray;
																																																																																																																																																																																																																																																}

																																																																																																																																																																																																																																																});

																																																																																																																																																																																																																																																/* Section: Utility Functions  */

																																																																																																																																																																																																																																																/*
																																																																																																																																																																																																																																																 * Function: $A()
																																																																																																																																																																																																																																																 * 	Same as <Array.copy>, but as function. 
																																																																																																																																																																																																																																																 * 		Useful to apply Array prototypes to iterable objects, as a collection of DOM elements or the arguments object.
																																																																																																																																																																																																																																																 * 			
																																																																																																																																																																																																																																																 * 			Example:
																																																																																																																																																																																																																																																 * 				>function myFunction(){
																																																																																																																																																																																																																																																 * 					>	$A(arguments).each(argument, function(){
																																																																																																																																																																																																																																																 * 						>		alert(argument);
																																																																																																																																																																																																																																																 * 							>	});
																																																																																																																																																																																																																																																 * 								>};
																																																																																																																																																																																																																																																 * 									>//the above will alert all the arguments passed to the function myFunction.
																																																																																																																																																																																																																																																 * 									*/

																																																																																																																																																																																																																																																function $A(array){
																																																																																																																																																																																																																																																	return Array.prototype.copy.call(array);
																																																																																																																																																																																																																																																	};
																																																																																																																																																																																																																																																	/*
																																																																																																																																																																																																																																																	 * Script: String.js
																																																																																																																																																																																																																																																	 * 	Contains String prototypes and Number prototypes.
																																																																																																																																																																																																																																																	 *
																																																																																																																																																																																																																																																	 * 	Dependencies:
																																																																																																																																																																																																																																																	 * 		<Moo.js>
																																																																																																																																																																																																																																																	 *
																																																																																																																																																																																																																																																	 * 			
																																																																																																																																																																																																																																																	 * 			Author:
																																																																																																																																																																																																																																																	 * 				Valerio Proietti, <http://mad4milk.net>
																																																																																																																																																																																																																																																	 *
																																																																																																																																																																																																																																																	 * 				License:
																																																																																																																																																																																																																																																	 * 					MIT-style license.
																																																																																																																																																																																																																																																	 * 					*/

																																																																																																																																																																																																																																																	/*
																																																																																																																																																																																																																																																	 * Class: String
																																																																																																																																																																																																																																																	 * 	A collection of The String Object prototype methods.
																																																																																																																																																																																																																																																	 * 	*/

																																																																																																																																																																																																																																																	String.extend({
																																																																																																																																																																																																																																																		
																																																																																																																																																																																																																																																			/*	
																																																																																																																																																																																																																																																			 *		Property: test
																																																																																																																																																																																																																																																			 *				Tests a string with a regular expression.
																																																																																																																																																																																																																																																			 *						
																																																																																																																																																																																																																																																			 *							Arguments:
																																																																																																																																																																																																																																																			 *									regex - the regular expression you want to match the string with
																																																																																																																																																																																																																																																			 *											params - optional, any parameters you want to pass to the regex
																																																																																																																																																																																																																																																			 *													
																																																																																																																																																																																																																																																			 *														Returns:
																																																																																																																																																																																																																																																			 *																an array with the instances of the value searched for or empty array.
																																																																																																																																																																																																																																																			 *																		
																																																																																																																																																																																																																																																			 *																			Example:
																																																																																																																																																																																																																																																			 *																					>"I like cookies".test("cookie"); // returns ["I like cookies", "cookie"]
																																																																																																																																																																																																																																																			 *																							>"I like cookies".test("COOKIE", "i") //ignore case
																																																																																																																																																																																																																																																			 *																									>"I like cookies because cookies are good".test("COOKIE", "ig"); //ignore case, find all instances.
																																																																																																																																																																																																																																																			 *																											>"I like cookies".test("cake"); //returns empty array
																																																																																																																																																																																																																																																			 *																												*/
																																																																																																																																																																																																																																																				
																																																																																																																																																																																																																																																					test: function(regex, params){
																																																																																																																																																																																																																																																							return this.match(new RegExp(regex, params));
																																																																																																																																																																																																																																																								},
																																																																																																																																																																																																																																																									
																																																																																																																																																																																																																																																										/*	
																																																																																																																																																																																																																																																										 *		Property: toInt
																																																																																																																																																																																																																																																										 *				parses a string to an integer.
																																																																																																																																																																																																																																																										 *						
																																																																																																																																																																																																																																																										 *								Returns:
																																																																																																																																																																																																																																																										 *											either an int or "NaN" if the string is not a number.
																																																																																																																																																																																																																																																										 *													
																																																																																																																																																																																																																																																										 *															Example:
																																																																																																																																																																																																																																																										 *																		>var value = "10px".toInt(); // value is 10
																																																																																																																																																																																																																																																										 *																			*/
																																																																																																																																																																																																																																																											toInt: function(){
																																																																																																																																																																																																																																																													return parseInt(this);
																																																																																																																																																																																																																																																														},
																																																																																																																																																																																																																																																															
																																																																																																																																																																																																																																																																/*	
																																																																																																																																																																																																																																																																 *		Property: camelCase
																																																																																																																																																																																																																																																																 *				Converts a hiphenated string to a camelcase string.
																																																																																																																																																																																																																																																																 *						
																																																																																																																																																																																																																																																																 *							Example:
																																																																																																																																																																																																																																																																 *									>"I-like-cookies".camelCase(); //"ILikeCookies"
																																																																																																																																																																																																																																																																 *											
																																																																																																																																																																																																																																																																 *												Returns:
																																																																																																																																																																																																																																																																 *														the camel cased string
																																																																																																																																																																																																																																																																 *															*/
																																																																																																																																																																																																																																																																	
																																																																																																																																																																																																																																																																		camelCase: function(){
																																																																																																																																																																																																																																																																				return this.replace(/-\D/gi, function(match){
																																																																																																																																																																																																																																																																							return match.charAt(match.length - 1).toUpperCase();
																																																																																																																																																																																																																																																																									});
																																																																																																																																																																																																																																																																										},
																																																																																																																																																																																																																																																																											
																																																																																																																																																																																																																																																																												/*	
																																																																																																																																																																																																																																																																												 *		Property: capitalize
																																																																																																																																																																																																																																																																												 *				Converts the first letter in each word of a string to Uppercase.
																																																																																																																																																																																																																																																																												 *						
																																																																																																																																																																																																																																																																												 *							Example:
																																																																																																																																																																																																																																																																												 *									>"i like cookies".capitalize(); //"I Like Cookies"
																																																																																																																																																																																																																																																																												 *											
																																																																																																																																																																																																																																																																												 *												Returns:
																																																																																																																																																																																																																																																																												 *														the capitalized string
																																																																																																																																																																																																																																																																												 *															*/
																																																																																																																																																																																																																																																																													capitalize: function(){
																																																																																																																																																																																																																																																																															return this.toLowerCase().replace(/\b[a-z]/g, function(match){
																																																																																																																																																																																																																																																																																		return match.toUpperCase();
																																																																																																																																																																																																																																																																																				});
																																																																																																																																																																																																																																																																																					},
																																																																																																																																																																																																																																																																																						
																																																																																																																																																																																																																																																																																							/*	
																																																																																																																																																																																																																																																																																							 *		Property: trim
																																																																																																																																																																																																																																																																																							 *				Trims the leading and trailing spaces off a string.
																																																																																																																																																																																																																																																																																							 *						
																																																																																																																																																																																																																																																																																							 *							Example:
																																																																																																																																																																																																																																																																																							 *									>"    i like cookies     ".trim() //"i like cookies"
																																																																																																																																																																																																																																																																																							 *											
																																																																																																																																																																																																																																																																																							 *												Returns:
																																																																																																																																																																																																																																																																																							 *														the trimmed string
																																																																																																																																																																																																																																																																																							 *															*/
																																																																																																																																																																																																																																																																																								
																																																																																																																																																																																																																																																																																									trim: function(){
																																																																																																																																																																																																																																																																																											return this.replace(/^\s*|\s*$/g, '');
																																																																																																																																																																																																																																																																																												},
																																																																																																																																																																																																																																																																																													
																																																																																																																																																																																																																																																																																														/*	
																																																																																																																																																																																																																																																																																														 *		Property: clean
																																																																																																																																																																																																																																																																																														 *				trims (<String.trim>) a string AND removes all the double spaces in a string.
																																																																																																																																																																																																																																																																																														 *						
																																																																																																																																																																																																																																																																																														 *							Returns:
																																																																																																																																																																																																																																																																																														 *									the cleaned string
																																																																																																																																																																																																																																																																																														 *											
																																																																																																																																																																																																																																																																																														 *												Example:
																																																																																																																																																																																																																																																																																														 *														>" i      like     cookies      \n\n".clean() //"i like cookies"
																																																																																																																																																																																																																																																																																														 *															*/

																																																																																																																																																																																																																																																																																															clean: function(){
																																																																																																																																																																																																																																																																																																	return this.replace(/\s\s/g, ' ').trim();
																																																																																																																																																																																																																																																																																																		},

																																																																																																																																																																																																																																																																																																			/*	
																																																																																																																																																																																																																																																																																																			 *		Property: rgbToHex
																																																																																																																																																																																																																																																																																																			 *				Converts an RGB value to hexidecimal. The string must be in the format of "rgb(255, 255, 255)" or "rgba(255, 255, 255, 1)";
																																																																																																																																																																																																																																																																																																			 *						
																																																																																																																																																																																																																																																																																																			 *							Arguments:
																																																																																																																																																																																																																																																																																																			 *									array - boolean value, defaults to false. Use true if you want the array ['FF', '33', '00'] as output instead of #FF3300
																																																																																																																																																																																																																																																																																																			 *											
																																																																																																																																																																																																																																																																																																			 *												Returns:
																																																																																																																																																																																																																																																																																																			 *														hex string or array. returns transparent if the fourth value of rgba in input string is 0,
																																																																																																																																																																																																																																																																																																			 *																
																																																																																																																																																																																																																																																																																																			 *																	Example:
																																																																																																																																																																																																																																																																																																			 *																			>"rgb(17,34,51)".rgbToHex(); //"#112233"
																																																																																																																																																																																																																																																																																																			 *																					>"rgba(17,34,51,0)".rgbToHex(); //"transparent"
																																																																																																																																																																																																																																																																																																			 *																							>"rgb(17,34,51)".rgbToHex(true); //[11,22,33]
																																																																																																																																																																																																																																																																																																			 *																								*/
																																																																																																																																																																																																																																																																																																				
																																																																																																																																																																																																																																																																																																					rgbToHex: function(array){
																																																																																																																																																																																																																																																																																																							var rgb = this.test('([\\d]{1,3})', 'g');
																																																																																																																																																																																																																																																																																																									if (rgb[3] == 0) return 'transparent';
																																																																																																																																																																																																																																																																																																											var hex = [];
																																																																																																																																																																																																																																																																																																													for (var i = 0; i < 3; i++){
																																																																																																																																																																																																																																																																																																																var bit = (rgb[i]-0).toString(16);
																																																																																																																																																																																																																																																																																																																			hex.push(bit.length == 1 ? '0'+bit : bit);
																																																																																																																																																																																																																																																																																																																					}
																																																																																																																																																																																																																																																																																																																							var hexText = '#'+hex.join('');
																																																																																																																																																																																																																																																																																																																									if (array) return hex;
																																																																																																																																																																																																																																																																																																																											else return hexText;
																																																																																																																																																																																																																																																																																																																												},
																																																																																																																																																																																																																																																																																																																													
																																																																																																																																																																																																																																																																																																																														/*	
																																																																																																																																																																																																																																																																																																																														 *		Property: hexToRgb
																																																																																																																																																																																																																																																																																																																														 *				Converts a hexidecimal color value to RGB. Input string must be the hex color value (with or without the hash). Also accepts triplets ('333');
																																																																																																																																																																																																																																																																																																																														 *						
																																																																																																																																																																																																																																																																																																																														 *							Arguments:
																																																																																																																																																																																																																																																																																																																														 *									array - boolean value, defaults to false. Use true if you want the array ['255', '255', '255'] as output instead of "rgb(255,255,255)";
																																																																																																																																																																																																																																																																																																																														 *											
																																																																																																																																																																																																																																																																																																																														 *												Returns:
																																																																																																																																																																																																																																																																																																																														 *														rgb string or array.
																																																																																																																																																																																																																																																																																																																														 *																
																																																																																																																																																																																																																																																																																																																														 *																	Example:
																																																																																																																																																																																																																																																																																																																														 *																			>"#112233".hexToRgb(); //"rgb(17,34,51)"
																																																																																																																																																																																																																																																																																																																														 *																					>"#112233".hexToRgb(true); //[17,34,51]
																																																																																																																																																																																																																																																																																																																														 *																						*/
																																																																																																																																																																																																																																																																																																																															
																																																																																																																																																																																																																																																																																																																																hexToRgb: function(array){
																																																																																																																																																																																																																																																																																																																																		var hex = this.test('^[#]{0,1}([\\w]{1,2})([\\w]{1,2})([\\w]{1,2})$');
																																																																																																																																																																																																																																																																																																																																				var rgb = [];
																																																																																																																																																																																																																																																																																																																																						for (var i = 1; i < hex.length; i++){
																																																																																																																																																																																																																																																																																																																																									if (hex[i].length == 1) hex[i] += hex[i];
																																																																																																																																																																																																																																																																																																																																												rgb.push(parseInt(hex[i], 16));
																																																																																																																																																																																																																																																																																																																																														}
																																																																																																																																																																																																																																																																																																																																																var rgbText = 'rgb('+rgb.join(',')+')';
																																																																																																																																																																																																																																																																																																																																																		if (array) return rgb;
																																																																																																																																																																																																																																																																																																																																																				else return rgbText;
																																																																																																																																																																																																																																																																																																																																																					}

																																																																																																																																																																																																																																																																																																																																																					});

																																																																																																																																																																																																																																																																																																																																																					/*
																																																																																																																																																																																																																																																																																																																																																					 * Class: Number
																																																																																																																																																																																																																																																																																																																																																					 * 	contains the internal method toInt.
																																																																																																																																																																																																																																																																																																																																																					 * 	*/

																																																																																																																																																																																																																																																																																																																																																					Number.extend({

																																																																																																																																																																																																																																																																																																																																																						/*
																																																																																																																																																																																																																																																																																																																																																						 * 	Property: toInt
																																																																																																																																																																																																																																																																																																																																																						 * 			Returns this number; useful because toInt must work on both Strings and Numbers.
																																																																																																																																																																																																																																																																																																																																																						 * 				*/

																																																																																																																																																																																																																																																																																																																																																							toInt: function(){
																																																																																																																																																																																																																																																																																																																																																									return this;
																																																																																																																																																																																																																																																																																																																																																										}

																																																																																																																																																																																																																																																																																																																																																										});
																																																																																																																																																																																																																																																																																																																																																										/*
																																																																																																																																																																																																																																																																																																																																																										 * Script: Element.js
																																																																																																																																																																																																																																																																																																																																																										 * 	Contains useful Element prototypes, to be used with the dollar function <$>.
																																																																																																																																																																																																																																																																																																																																																										 * 		
																																																																																																																																																																																																																																																																																																																																																										 * 		Dependencies:
																																																																																																																																																																																																																																																																																																																																																										 * 			<Moo.js>, <Function.js>, <Array.js>, <String.js>
																																																																																																																																																																																																																																																																																																																																																										 *
																																																																																																																																																																																																																																																																																																																																																										 * 			Author:
																																																																																																																																																																																																																																																																																																																																																										 * 				Valerio Proietti, <http://mad4milk.net>
																																																																																																																																																																																																																																																																																																																																																										 * 					
																																																																																																																																																																																																																																																																																																																																																										 *
																																																																																																																																																																																																																																																																																																																																																										 * 					License:
																																																																																																																																																																																																																																																																																																																																																										 * 						MIT-style license.
																																																																																																																																																																																																																																																																																																																																																										 * 							
																																																																																																																																																																																																																																																																																																																																																										 * 							Credits:
																																																																																																																																																																																																																																																																																																																																																										 * 								- Some functions are inspired by those found in prototype.js <http://prototype.conio.net/> (c) 2005 Sam Stephenson sam [at] conio [dot] net, MIT-style license
																																																																																																																																																																																																																																																																																																																																																										 * 								*/

																																																																																																																																																																																																																																																																																																																																																										/*
																																																																																																																																																																																																																																																																																																																																																										 * Class: Element
																																																																																																																																																																																																																																																																																																																																																										 * 	Custom class to allow all of its methods to be used with any DOM element via the dollar function <$>.
																																																																																																																																																																																																																																																																																																																																																										 * 	*/

																																																																																																																																																																																																																																																																																																																																																										var Element = new Class({

																																																																																																																																																																																																																																																																																																																																																											/*
																																																																																																																																																																																																																																																																																																																																																											 * 	Property: initialize
																																																																																																																																																																																																																																																																																																																																																											 * 			Creates a new element of the type passed in.
																																																																																																																																																																																																																																																																																																																																																											 * 						
																																																																																																																																																																																																																																																																																																																																																											 * 							Arguments:
																																																																																																																																																																																																																																																																																																																																																											 * 									el - the tag name for the element you wish to create.
																																																																																																																																																																																																																																																																																																																																																											 * 												
																																																																																																																																																																																																																																																																																																																																																											 * 													Example:
																																																																																																																																																																																																																																																																																																																																																											 * 															>var div = new Element('div');
																																																																																																																																																																																																																																																																																																																																																											 * 																*/

																																																																																																																																																																																																																																																																																																																																																												initialize: function(el){
																																																																																																																																																																																																																																																																																																																																																														if ($type(el) == 'string') el = document.createElement(el);
																																																																																																																																																																																																																																																																																																																																																																return $(el);
																																																																																																																																																																																																																																																																																																																																																																	},

																																																																																																																																																																																																																																																																																																																																																																		inject: function(el, where){
																																																																																																																																																																																																																																																																																																																																																																				el = $(el) || new Element(el);
																																																																																																																																																																																																																																																																																																																																																																						switch(where){
																																																																																																																																																																																																																																																																																																																																																																									case "before": $(el.parentNode).insertBefore(this, el); break;
																																																																																																																																																																																																																																																																																																																																																																												case "after": {
																																																																																																																																																																																																																																																																																																																																																																																	if (!el.getNext()) $(el.parentNode).appendChild(this);
																																																																																																																																																																																																																																																																																																																																																																																						else $(el.parentNode).insertBefore(this, el.getNext());
																																																																																																																																																																																																																																																																																																																																																																																									} break;
																																																																																																																																																																																																																																																																																																																																																																																												case "inside": el.appendChild(this); break;
																																																																																																																																																																																																																																																																																																																																																																																														}
																																																																																																																																																																																																																																																																																																																																																																																																return this;
																																																																																																																																																																																																																																																																																																																																																																																																	},
																																																																																																																																																																																																																																																																																																																																																																																																		
																																																																																																																																																																																																																																																																																																																																																																																																			/*
																																																																																																																																																																																																																																																																																																																																																																																																			 * 	Property: injectBefore
																																																																																																																																																																																																																																																																																																																																																																																																			 * 			Inserts the Element before the passed element.
																																																																																																																																																																																																																																																																																																																																																																																																			 * 						
																																																																																																																																																																																																																																																																																																																																																																																																			 * 							Parameteres:
																																																																																																																																																																																																																																																																																																																																																																																																			 * 									el - a string representing the element to be injected in (myElementId, or div), or an element reference.
																																																																																																																																																																																																																																																																																																																																																																																																			 * 											If you pass div or another tag, the element will be created.
																																																																																																																																																																																																																																																																																																																																																																																																			 * 														
																																																																																																																																																																																																																																																																																																																																																																																																			 * 															Example:
																																																																																																																																																																																																																																																																																																																																																																																																			 * 																	>html: 
																																																																																																																																																																																																																																																																																																																																																																																																			 * 																			><div id="myElement"></div>
																																																																																																																																																																																																																																																																																																																																																																																																			 * 																					><div id="mySecondElement"></div>
																																																																																																																																																																																																																																																																																																																																																																																																			 * 																							>js:
																																																																																																																																																																																																																																																																																																																																																																																																			 * 																									>$('mySecondElement').injectBefore('myElement');
																																																																																																																																																																																																																																																																																																																																																																																																			 * 																											>resulting html
																																																																																																																																																																																																																																																																																																																																																																																																			 * 																													><div id="myElement"></div>
																																																																																																																																																																																																																																																																																																																																																																																																			 * 																															><div id="mySecondElement"></div>
																																																																																																																																																																																																																																																																																																																																																																																																			 *
																																																																																																																																																																																																																																																																																																																																																																																																			 * 																																*/
																																																																																																																																																																																																																																																																																																																																																																																																				
																																																																																																																																																																																																																																																																																																																																																																																																					injectBefore: function(el){
																																																																																																																																																																																																																																																																																																																																																																																																							return this.inject(el, 'before');
																																																																																																																																																																																																																																																																																																																																																																																																								},
																																																																																																																																																																																																																																																																																																																																																																																																									
																																																																																																																																																																																																																																																																																																																																																																																																										/*  
																																																																																																																																																																																																																																																																																																																																																																																																										 *  	Property: injectAfter
																																																																																																																																																																																																																																																																																																																																																																																																										 *  			Same as <Element.injectBefore>, but inserts the element after.
																																																																																																																																																																																																																																																																																																																																																																																																										 *  				*/
																																																																																																																																																																																																																																																																																																																																																																																																											
																																																																																																																																																																																																																																																																																																																																																																																																												injectAfter: function(el){
																																																																																																																																																																																																																																																																																																																																																																																																														return this.inject(el, 'after');
																																																																																																																																																																																																																																																																																																																																																																																																															},

																																																																																																																																																																																																																																																																																																																																																																																																																/*  
																																																																																																																																																																																																																																																																																																																																																																																																																 *  	Property: injectInside
																																																																																																																																																																																																																																																																																																																																																																																																																 *  			Same as <Element.injectBefore>, but inserts the element inside.
																																																																																																																																																																																																																																																																																																																																																																																																																 *  				*/
																																																																																																																																																																																																																																																																																																																																																																																																																	
																																																																																																																																																																																																																																																																																																																																																																																																																		injectInside: function(el){
																																																																																																																																																																																																																																																																																																																																																																																																																				return this.inject(el, 'inside');
																																																																																																																																																																																																																																																																																																																																																																																																																					},

																																																																																																																																																																																																																																																																																																																																																																																																																						/*  
																																																																																																																																																																																																																																																																																																																																																																																																																						 *  	Property: adopt
																																																																																																																																																																																																																																																																																																																																																																																																																						 *  			Inserts the passed element inside the Element. Works as <Element.injectInside> but in reverse.
																																																																																																																																																																																																																																																																																																																																																																																																																						 *  						
																																																																																																																																																																																																																																																																																																																																																																																																																						 *  							Parameteres:
																																																																																																																																																																																																																																																																																																																																																																																																																						 *  									el - a string representing the element to be injected in (myElementId, or div), or an element reference.
																																																																																																																																																																																																																																																																																																																																																																																																																						 *  											If you pass div or another tag, the element will be created.
																																																																																																																																																																																																																																																																																																																																																																																																																						 *  												*/
																																																																																																																																																																																																																																																																																																																																																																																																																							
																																																																																																																																																																																																																																																																																																																																																																																																																								adopt: function(el){
																																																																																																																																																																																																																																																																																																																																																																																																																										this.appendChild($(el) || new Element(el));
																																																																																																																																																																																																																																																																																																																																																																																																																												return this;
																																																																																																																																																																																																																																																																																																																																																																																																																													},
																																																																																																																																																																																																																																																																																																																																																																																																																														
																																																																																																																																																																																																																																																																																																																																																																																																																															/*  
																																																																																																																																																																																																																																																																																																																																																																																																																															 *  	Property: remove
																																																																																																																																																																																																																																																																																																																																																																																																																															 *  			Removes the Element from the DOM.
																																																																																																																																																																																																																																																																																																																																																																																																																															 *  						
																																																																																																																																																																																																																																																																																																																																																																																																																															 *  							Example:
																																																																																																																																																																																																																																																																																																																																																																																																																															 *  									>$('myElement').remove() //bye bye
																																																																																																																																																																																																																																																																																																																																																																																																																															 *  										*/
																																																																																																																																																																																																																																																																																																																																																																																																																																
																																																																																																																																																																																																																																																																																																																																																																																																																																	remove: function(){
																																																																																																																																																																																																																																																																																																																																																																																																																																			this.parentNode.removeChild(this);
																																																																																																																																																																																																																																																																																																																																																																																																																																				},
																																																																																																																																																																																																																																																																																																																																																																																																																																					
																																																																																																																																																																																																																																																																																																																																																																																																																																						/*  
																																																																																																																																																																																																																																																																																																																																																																																																																																						 *  	Property: clone
																																																																																																																																																																																																																																																																																																																																																																																																																																						 *  			Clones the Element and returns the cloned one.
																																																																																																																																																																																																																																																																																																																																																																																																																																						 *  					
																																																																																																																																																																																																																																																																																																																																																																																																																																						 *  						Returns: 
																																																																																																																																																																																																																																																																																																																																																																																																																																						 *  								the cloned element
																																																																																																																																																																																																																																																																																																																																																																																																																																						 *  										
																																																																																																																																																																																																																																																																																																																																																																																																																																						 *  											Example:
																																																																																																																																																																																																																																																																																																																																																																																																																																						 *  													>var clone = $('myElement').clone().injectAfter('myElement');
																																																																																																																																																																																																																																																																																																																																																																																																																																						 *  															>//clones the Element and append the clone after the Element.
																																																																																																																																																																																																																																																																																																																																																																																																																																						 *  																*/
																																																																																																																																																																																																																																																																																																																																																																																																																																							
																																																																																																																																																																																																																																																																																																																																																																																																																																								clone: function(contents){
																																																																																																																																																																																																																																																																																																																																																																																																																																										return $(this.cloneNode(contents || true));
																																																																																																																																																																																																																																																																																																																																																																																																																																											},

																																																																																																																																																																																																																																																																																																																																																																																																																																												/*  
																																																																																																																																																																																																																																																																																																																																																																																																																																												 *  	Property: replaceWith
																																																																																																																																																																																																																																																																																																																																																																																																																																												 *  			Replaces the Element with an element passed.
																																																																																																																																																																																																																																																																																																																																																																																																																																												 *  						
																																																																																																																																																																																																																																																																																																																																																																																																																																												 *  							Parameteres:
																																																																																																																																																																																																																																																																																																																																																																																																																																												 *  									el - a string representing the element to be injected in (myElementId, or div), or an element reference.
																																																																																																																																																																																																																																																																																																																																																																																																																																												 *  											If you pass div or another tag, the element will be created.
																																																																																																																																																																																																																																																																																																																																																																																																																																												 *  													
																																																																																																																																																																																																																																																																																																																																																																																																																																												 *  														Returns:
																																																																																																																																																																																																																																																																																																																																																																																																																																												 *  																the passed in element
																																																																																																																																																																																																																																																																																																																																																																																																																																												 *  																			
																																																																																																																																																																																																																																																																																																																																																																																																																																												 *  																				Example:
																																																																																																																																																																																																																																																																																																																																																																																																																																												 *  																						>$('myOldElement').replaceWith($('myNewElement')); //$('myOldElement') is gone, and $('myNewElement') is in its place.
																																																																																																																																																																																																																																																																																																																																																																																																																																												 *  																							*/
																																																																																																																																																																																																																																																																																																																																																																																																																																													
																																																																																																																																																																																																																																																																																																																																																																																																																																														replaceWith: function(el){
																																																																																																																																																																																																																																																																																																																																																																																																																																																var el = $(el) || new Element(el);
																																																																																																																																																																																																																																																																																																																																																																																																																																																		this.parentNode.replaceChild(el, this);
																																																																																																																																																																																																																																																																																																																																																																																																																																																				return el;
																																																																																																																																																																																																																																																																																																																																																																																																																																																					},
																																																																																																																																																																																																																																																																																																																																																																																																																																																						
																																																																																																																																																																																																																																																																																																																																																																																																																																																							/*  
																																																																																																																																																																																																																																																																																																																																																																																																																																																							 *  	Property: appendText
																																																																																																																																																																																																																																																																																																																																																																																																																																																							 *  			Appends text node to a DOM element.
																																																																																																																																																																																																																																																																																																																																																																																																																																																							 *
																																																																																																																																																																																																																																																																																																																																																																																																																																																							 *  				Arguments:
																																																																																																																																																																																																																																																																																																																																																																																																																																																							 *  						text - the text to append.
																																																																																																																																																																																																																																																																																																																																																																																																																																																							 *  								
																																																																																																																																																																																																																																																																																																																																																																																																																																																							 *  									Example:
																																																																																																																																																																																																																																																																																																																																																																																																																																																							 *  											><div id="myElement">hey</div>
																																																																																																																																																																																																																																																																																																																																																																																																																																																							 *
																																																																																																																																																																																																																																																																																																																																																																																																																																																							 *  													>$('myElement').appendText(' howdy'); //myElement innerHTML is now "hey howdy"
																																																																																																																																																																																																																																																																																																																																																																																																																																																							 *  													  	*/

																																																																																																																																																																																																																																																																																																																																																																																																																																																								appendText: function(text){
																																																																																																																																																																																																																																																																																																																																																																																																																																																										if (this.getTag() == 'style' && window.ActiveXObject) this.styleSheet.cssText = text;
																																																																																																																																																																																																																																																																																																																																																																																																																																																												else this.appendChild(document.createTextNode(text));
																																																																																																																																																																																																																																																																																																																																																																																																																																																														return this;
																																																																																																																																																																																																																																																																																																																																																																																																																																																															},
																																																																																																																																																																																																																																																																																																																																																																																																																																																																
																																																																																																																																																																																																																																																																																																																																																																																																																																																																	/*
																																																																																																																																																																																																																																																																																																																																																																																																																																																																	 * 	Property: hasClass
																																																																																																																																																																																																																																																																																																																																																																																																																																																																	 * 			Tests the Element to see if it has the passed in className.
																																																																																																																																																																																																																																																																																																																																																																																																																																																																	 * 					
																																																																																																																																																																																																																																																																																																																																																																																																																																																																	 * 						Returns:
																																																																																																																																																																																																																																																																																																																																																																																																																																																																	 * 							 	true - the Element has the class
																																																																																																																																																																																																																																																																																																																																																																																																																																																																	 * 							 		 	false - it doesn't
																																																																																																																																																																																																																																																																																																																																																																																																																																																																	 * 							 		 		 
																																																																																																																																																																																																																																																																																																																																																																																																																																																																	 * 							 		 		 	Arguments:
																																																																																																																																																																																																																																																																																																																																																																																																																																																																	 * 							 		 		 			className - the class name to test.
																																																																																																																																																																																																																																																																																																																																																																																																																																																																	 * 							 		 		 				 
																																																																																																																																																																																																																																																																																																																																																																																																																																																																	 * 							 		 		 				 	Example:
																																																																																																																																																																																																																																																																																																																																																																																																																																																																	 * 							 		 		 				 			><div id="myElement" class="testClass"></div>
																																																																																																																																																																																																																																																																																																																																																																																																																																																																	 * 							 		 		 				 					>$('myElement').hasClass('testClass'); //returns true
																																																																																																																																																																																																																																																																																																																																																																																																																																																																	 * 							 		 		 				 						*/

																																																																																																																																																																																																																																																																																																																																																																																																																																																																		hasClass: function(className){
																																																																																																																																																																																																																																																																																																																																																																																																																																																																				return !!this.className.test("\\b"+className+"\\b");
																																																																																																																																																																																																																																																																																																																																																																																																																																																																					},

																																																																																																																																																																																																																																																																																																																																																																																																																																																																						/*	
																																																																																																																																																																																																																																																																																																																																																																																																																																																																						 *		Property: addClass
																																																																																																																																																																																																																																																																																																																																																																																																																																																																						 *				Adds the passed in class to the Element, if the element doesnt already have it.
																																																																																																																																																																																																																																																																																																																																																																																																																																																																						 *						
																																																																																																																																																																																																																																																																																																																																																																																																																																																																						 *							Arguments:
																																																																																																																																																																																																																																																																																																																																																																																																																																																																						 *									className - the class name to add
																																																																																																																																																																																																																																																																																																																																																																																																																																																																						 *											
																																																																																																																																																																																																																																																																																																																																																																																																																																																																						 *												Example: 
																																																																																																																																																																																																																																																																																																																																																																																																																																																																						 *														><div id="myElement" class="testClass"></div>
																																																																																																																																																																																																																																																																																																																																																																																																																																																																						 *																>$('myElement').addClass('newClass'); //<div id="myElement" class="testClass newClass"></div>
																																																																																																																																																																																																																																																																																																																																																																																																																																																																						 *																	*/
																																																																																																																																																																																																																																																																																																																																																																																																																																																																							
																																																																																																																																																																																																																																																																																																																																																																																																																																																																								addClass: function(className){
																																																																																																																																																																																																																																																																																																																																																																																																																																																																										if (!this.hasClass(className)) this.className = (this.className+' '+className.trim()).clean();
																																																																																																																																																																																																																																																																																																																																																																																																																																																																												return this;
																																																																																																																																																																																																																																																																																																																																																																																																																																																																													},
																																																																																																																																																																																																																																																																																																																																																																																																																																																																														
																																																																																																																																																																																																																																																																																																																																																																																																																																																																															/*	
																																																																																																																																																																																																																																																																																																																																																																																																																																																																															 *		Property: removeClass
																																																																																																																																																																																																																																																																																																																																																																																																																																																																															 *				works like <Element.addClass>, but removes the class from the element.
																																																																																																																																																																																																																																																																																																																																																																																																																																																																															 *					*/

																																																																																																																																																																																																																																																																																																																																																																																																																																																																																removeClass: function(className){
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																		if (this.hasClass(className)) this.className = this.className.replace(className.trim(), '').clean();
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																				return this;
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																					},

																																																																																																																																																																																																																																																																																																																																																																																																																																																																																						/*	
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																						 *		Property: toggleClass
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																						 *				Adds or removes the passed in class name to the element, depending on if it's present or not.
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																						 *						
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																						 *							Arguments:
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																						 *									className - the class to add or remove
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																						 *											
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																						 *												Example:
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																						 *														><div id="myElement" class="myClass"></div>
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																						 *																>$('myElement').toggleClass('myClass');
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																						 *																		><div id="myElement" class=""></div>
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																						 *
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																						 *																				>$('myElement').toggleClass('myClass');
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																						 *																						><div id="myElement" class="myClass"></div>
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																						 *																							*/
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																							
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																								toggleClass: function(className){
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																										if (this.hasClass(className)) return this.removeClass(className);
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																												else return this.addClass(className);
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																													},
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																														
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																															/*
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																															 * 	Property: setStyle	
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																															 * 			Sets a css property to the Element.
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																															 * 					
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																															 * 							Arguments:
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																															 * 										property - the property to set
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																															 * 													value - the value to which to set it
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																															 * 															
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																															 * 																	Example:
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																															 * 																				>$('myElement').setStyle('width', '300px'); //the width is now 300px
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																															 * 																					*/
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																	setStyle: function(property, value){
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																			if (property == 'opacity') this.setOpacity(parseFloat(value));
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																					else this.style[property.camelCase()] = value;
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																							return this;
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																								},

																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																									/*
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																									 * 	Property: setStyles
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																									 * 			Applies a collection of styles to the Element.
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																									 * 					
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																									 * 						Arguments:
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																									 * 								source - an object or string containing all the styles to apply
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																									 * 										
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																									 * 											Examples:
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																									 * 													>$('myElement').setStyles({
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																									 * 															>	border: '1px solid #000',
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																									 * 																	>	width: '300px',
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																									 * 																			>	height: '400px'
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																									 * 																					>});
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																									 *
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																									 * 																							OR
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																									 * 																									
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																									 * 																											>$('myElement').setStyle('border: 1px solid #000; width: 300px; height: 400px;');
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																									 * 																												*/
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																										
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																											setStyles: function(source){
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																													if ($type(source) == 'object') {
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																for (var property in source) this.setStyle(property, source[property]);
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																		} else if ($type(source) == 'string') {
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																					if (window.ActiveXObject) this.cssText = source;
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																								else this.setAttribute('style', source);
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																										}
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																												return this;
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																													},
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																														
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																															/*	
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																															 *		Property: setOpacity
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																															 *				Sets the opacity of the Element, and sets also visibility == "hidden" if opacity == 0, and visibility = "visible" if opacity == 1.
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																															 *						
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																															 *							Arguments:
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																															 *									opacity - Accepts numbers from 0 to 1.
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																															 *											
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																															 *												Example:
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																															 *														>$('myElement').setOpacity(0.5) //make it 50% transparent
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																															 *															*/
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																	setOpacity: function(opacity){
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																			if (opacity == 0){
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																						if(this.style.visibility != "hidden") this.style.visibility = "hidden";
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																								} else {
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																											if(this.style.visibility != "visible") this.style.visibility = "visible";
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																													}
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																															if (window.ActiveXObject) this.style.filter = "alpha(opacity=" + opacity*100 + ")";
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																	this.style.opacity = opacity;
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																			return this;
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																				},
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																					
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																						/*	
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																						 *		Property: getStyle
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																						 *				Returns the style of the Element given the property passed in.
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																						 *						
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																						 *							Arguments:
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																						 *									property - the css style property you want to retrieve
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																						 *											
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																						 *												Example:
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																						 *														>$('myElement').getStyle('width'); //returns "400px"
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																						 *																>//but you can also use
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																						 *																		>$('myElement').getStyle('width').toInt(); //returns "400"
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																						 *																				
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																						 *																					Returns:
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																						 *																							the style as a string
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																						 *																								*/
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																							
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																								getStyle: function(property){
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																										var proPerty = property.camelCase();
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																												var style = this.style[proPerty] || false;
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																														if (!style) {
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																	if (document.defaultView) style = document.defaultView.getComputedStyle(this,null).getPropertyValue(property);
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																				else if (this.currentStyle) style = this.currentStyle[proPerty];
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																						}
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																								if (style && ['color', 'backgroundColor', 'borderColor'].test(proPerty) && style.test('rgb')) style = style.rgbToHex();
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																										return style;
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																											},

																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																												/*	
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																												 *		Property: addEvent
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																												 *				Attaches an event listener to a DOM element.
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																												 *						
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																												 *							Arguments:
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																												 *									action - the event to monitor ('click', 'load', etc)
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																												 *											fn - the function to execute
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																												 *													
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																												 *														Example:
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																												 *																>$('myElement').addEvent('click', function(){alert('clicked!')});
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																												 *																	*/

																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																													addEvent: function(action, fn){
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																															this[action+fn] = fn.bind(this);
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																	if (this.addEventListener) this.addEventListener(action, fn, false);
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																			else this.attachEvent('on'+action, this[action+fn]);
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																					var el = this;
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																							if (this != window) Unload.functions.push(function(){
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																										el.removeEvent(action, fn);
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																													el[action+fn] = null;
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																															});
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																	return this;
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																		},
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																			
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																				/*	
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																				 *		Property: removeEvent
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																				 *				Works as Element.addEvent, but instead removes the previously added event listener.
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																				 *					*/
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																					
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																						removeEvent: function(action, fn){
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																								if (this.removeEventListener) this.removeEventListener(action, fn, false);
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																										else this.detachEvent('on'+action, this[action+fn]);
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																												return this;
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																													},

																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																														getBrother: function(what){
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																var el = this[what+'Sibling'];
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																		while ($type(el) == 'textnode') el = el[what+'Sibling'];
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																				return $(el);
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																					},
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																						
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																							/*
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																							 * 	Property: getPrevious
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																							 * 			Returns the previousSibling of the Element, excluding text nodes.
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																							 * 					
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																							 * 						Example:
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																							 * 								>$('myElement').getPrevious(); //get the previous DOM element from myElement
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																							 * 										
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																							 * 											Returns:
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																							 * 													the sibling element or undefined if none found.
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																							 * 														*/
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																								
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																									getPrevious: function(){
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																											return this.getBrother('previous');
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																												},
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																													
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																														/*
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																														 * 	Property: getNext
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																														 * 			Works as Element.getPrevious, but tries to find the nextSibling.
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																														 * 				*/
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																															
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																getNext: function(){
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																		return this.getBrother('next');
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																			},
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																				
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																					/*
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																					 * 	Property: getNext
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																					 * 			Works as <Element.getPrevious>, but tries to find the firstChild.
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																					 * 				*/

																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																						getFirst: function(){
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																								var el = this.firstChild;
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																										while ($type(el) == 'textnode') el = el.nextSibling;
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																												return $(el);
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																													},

																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																														/*
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																														 * 	Property: getLast
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																														 * 			Works as <Element.getPrevious>, but tries to find the lastChild.
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																														 * 				*/

																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																															getLast: function(){
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																	var el = this.lastChild;
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																			while ($type(el) == 'textnode')
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																					el = el.previousSibling;
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																							return $(el);
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																								},

																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																									/*	
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																									 *		Property: setProperty
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																									 *				Sets an attribute for the Element.
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																									 *						
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																									 *							Arguments:
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																									 *									property - the property to assign the value passed in
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																									 *											value - the value to assign to the property passed in
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																									 *													
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																									 *														Example:
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																									 *																>$('myImage').setProperty('src', 'whatever.gif'); //myImage now points to whatever.gif for its source
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																									 *																	*/

																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																										setProperty: function(property, value){
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																												var el = false;
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																														switch(property){
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																	case 'class': this.className = value; break;
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																				case 'style': this.setStyles(value); break;
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																							case 'name': if (window.ActiveXObject && this.getTag() == 'input'){
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																											el = $(document.createElement('<input name="'+value+'" />'));
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																															$A(this.attributes).each(function(attribute){
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																				if (attribute.name != 'name') el.setProperty(attribute.name, attribute.value);
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																									
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																													});
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																	if (this.parentNode) this.replaceWith(el);
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																				};
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																							default: this.setAttribute(property, value);
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																									}
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																											return el || this;
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																												},
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																													
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																														/*	
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																														 *		Property: setProperties
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																														 *				Sets numerous attributes for the Element.
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																														 *						
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																														 *							Arguments:
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																														 *									source - an object with key/value pairs.
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																														 *											
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																														 *												Example:
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																														 *														>$('myElement').setProperties({
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																														 *																>	src: 'whatever.gif',
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																														 *																		>	alt: 'whatever dude'
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																														 *																				>});
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																														 *																						><img src="whatever.gif" alt="whatever dude">
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																														 *																							*/
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																															
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																setProperties: function(source){
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																		for (var property in source) this.setProperty(property, source[property]);
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																				return this;
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																					},
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																						
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																							/*
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																							 * 	Property: setHTML
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																							 * 			Sets the innerHTML of the Element.
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																							 * 					
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																							 * 						Arguments:
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																							 * 								html - the new innerHTML for the element.
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																							 * 										
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																							 * 											Example:
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																							 * 													>$('myElement').setHTML(newHTML) //the innerHTML of myElement is now = newHTML
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																							 * 														*/
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																								
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																									setHTML: function(html){
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																											this.innerHTML = html;
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																													return this;
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																														},
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																															
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																/*	
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																 *		Property: getProperty
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																 *				Gets the an attribute of the Element.
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																 *						
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																 *							Arguments:
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																 *									property - the attribute to retrieve
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																 *											
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																 *												Example:
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																 *														>$('myImage').getProperty('src') // returns whatever.gif
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																 *																
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																 *																	Returns:
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																 *																			the value, or an empty string
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																 *																				*/
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																	
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																		getProperty: function(property){
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																				return this.getAttribute(property);
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																					},
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																						
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																							/*
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																							 * 	Property: getTag
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																							 * 			Returns the tagName of the element in lower case.
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																							 * 					
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																							 * 						Example:
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																							 * 								>$('myImage').getTag() // returns 'img'
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																							 * 										
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																							 * 											Returns:
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																							 * 													The tag name in lower case
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																							 * 														*/
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																								
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																									getTag: function(){
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																											return this.tagName.toLowerCase();
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																												},
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																													
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																														getOffset: function(what){
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																what = what.capitalize();
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																		var el = this;
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																				var offset = 0;
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																						do {
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																									offset += el['offset'+what] || 0;
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																												el = el.offsetParent;
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																														} while (el);
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																return offset;
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																	},

																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																		/*	
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																		 *		Property: getTop
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																		 *				Returns the distance from the top of the window to the Element.
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																		 *					*/
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																			
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																				getTop: function(){
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																						return this.getOffset('top');
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																							},
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																								
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																									/*	
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																									 *		Property: getLeft
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																									 *				Returns the distance from the left of the window to the Element.
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																									 *					*/
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																										
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																											getLeft: function(){
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																													return this.getOffset('left');
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																														},
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																															
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																/*	
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																 *		Property: getValue
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																 *				Returns the value of the Element, if its tag is textarea, select or input.
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																 *					*/
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																	
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																		getValue: function(){
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																				var value = false;
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																						switch(this.getTag()){
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																									case 'select': value = this.getElementsByTagName('option')[this.selectedIndex].value; break;
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																												case 'input': if ( (this.checked && ['checkbox', 'radio'].test(this.type)) || (['hidden', 'text', 'password'].test(this.type)) ) 
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																value = this.value; break;
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																			case 'textarea': value = this.value;
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																					}
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																							return value;
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																								}

																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																								});

																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																								new Object.Native(Element);

																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																								Element.extend({
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																									hasClassName: Element.prototype.hasClass,
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																										addClassName: Element.prototype.addClass,
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																											removeClassName: Element.prototype.removeClass,
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																												toggleClassName: Element.prototype.toggleClass
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																												});

																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																												/* Section: Utility Functions  */

																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																												/*
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																												 * Function: $Element
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																												 * 	Applies a method with the passed in args to the passed in element. Useful if you dont want to extend the element
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																												 * 			
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																												 * 				Arguments:
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																												 * 						el - the element
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																												 * 								method - a string representing the Element Class method to execute on that element
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																												 * 										args - an array representing the arguments to pass to that method
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																												 * 												
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																												 * 													Example:
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																												 * 															>$Element(el, 'hasClass', className) //true or false
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																												 * 															*/

																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																												function $Element(el, method, args){
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																													if ($type(args) != 'array') args = [args];
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																														return Element.prototype[method].apply(el, args);
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																														};

																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																														/*
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																														 * Function: $()
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																														 * 	returns the element passed in with all the Element prototypes applied.
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																														 * 		
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																														 * 		Arguments:
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																														 * 			el - a reference to an actual element or a string representing the id of an element
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																														 * 					
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																														 * 					Example:
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																														 * 						>$('myElement') // gets a DOM element by id with all the Element prototypes applied.
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																														 * 							>var div = document.getElementById('myElement');
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																														 * 								>$(div) //returns an Element also with all the mootools extentions applied.
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																														 * 										
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																														 * 											You'll use this when you aren't sure if a variable is an actual element or an id, as
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																														 * 												well as just shorthand for document.getElementById().
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																														 * 														
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																														 * 														Returns:
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																														 * 															a DOM element or false (if no id was found)
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																														 * 																	
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																														 * 																	Note:
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																														 * 																		you need to call $ on an element only once to get all the prototypes.
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																														 * 																			But its no harm to call it multiple times, as it will detect if it has been already extended.
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																														 * 																			*/

																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																														function $(el){
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																															if ($type(el) == 'string') el = document.getElementById(el);
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																if ($type(el) == 'element'){
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																		if (!el.extend){
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																					Unload.elements.push(el);
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																								el.extend = Object.extend;
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																											el.extend(Element.prototype);
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																													}
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																															return el;
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																} else return false;
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																};

																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																window.addEvent = document.addEvent = Element.prototype.addEvent;
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																window.removeEvent = document.removeEvent = Element.prototype.removeEvent;

																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																var Unload = {

																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																	elements: [], functions: [], vars: [],

																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																		unload: function(){
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																				Unload.functions.each(function(fn){
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																							fn();
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																									});
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																											
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																													window.removeEvent('unload', window.removeFunction);
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																															
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																	Unload.elements.each(function(el){
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																				for(var p in Element.prototype){
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																								window[p] = null;
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																												document[p] = null;
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																el[p] = null;
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																			}
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																						el.extend = null;
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																								});
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																									}
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																										
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																										};

																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																										window.removeFunction = Unload.unload;
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																										window.addEvent('unload', window.removeFunction);
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																										/*
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																										 * Script: Fx.js
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																										 * 	Applies visual transitions to any element. Contains Fx.Base, Fx.Style and Fx.Styles
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																										 *
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																										 * 	Dependencies:
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																										 * 		<Moo.js>, <Function.js>, <Array.js>, <String.js>, <Element.js>
																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																																										 *