Property: getRandom		returns a random item in the Array	*/	getRandom: function(){		return this[$random(0, this.length - 1)] || null;	},	/*	Property: getLast		returns the last item in the Array	*/	getLast: function(){		return this[this.length - 1] || null;	}});//copiesArray.prototype.each = Array.prototype.forEach;Array.each = Array.forEach;/* 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:	(start code)	function myFunction(){		$A(arguments).each(argument, function(){			alert(argument);		});	};	//the above will alert all the arguments passed to the function myFunction.	(end)*/function $A(array){	return Array.copy(array);};/*Function: $each	Use to iterate through iterables that are not regular arrays, such as builtin getElementsByTagName calls, arguments of a function, or an object.Arguments:	iterable - an iterable element or an objct.	function - function to apply to the iterable.	bind - optional, the 'this' of the function will refer to this object.Function argument:	The function argument will be passed the following arguments.	item - the current item in the iterator being procesed	index - integer; the index of the item, or key in case of an object.Examples:	(start code)	$each(['Sun','Mon','Tue'], function(day, index){		alert('name:' + day + ', index: ' + index);	});	//alerts "name: Sun, index: 0", "name: Mon, index: 1", etc.	//over an object	$each({first: "Sunday", second: "Monday", third: "Tuesday"}, function(value, key){		alert("the " + key + " day of the week is " + value);	});	//alerts "the first day of the week is Sunday",	//"the second day of the week is Monday", etc.	(end)*/function $each(iterable, fn, bind){	if (iterable && typeof iterable.length == 'number' && $type(iterable) != 'object'){		Array.forEach(iterable, fn, bind);	} else {		 for (var name in iterable) fn.call(bind || iterable, iterable[name], name);	}};/*compatibility*/Array.prototype.test = Array.prototype.contains;/*end compatibility*//*Script: String.js	Contains String prototypes.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 - a string or regular expression object, the regular expression you want to match the string with		params - optional, if first parameter is a string, any parameters you want to pass to the regex ('g' has no effect)	Returns:		true if a match for the regular expression is found in the string, false if not.		See <http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Objects:RegExp:test>	Example:		>"I like cookies".test("cookie"); // returns true		>"I like cookies".test("COOKIE", "i") // ignore case, returns true		>"I like cookies".test("cake"); // returns false	*/	test: function(regex, params){		return (($type(regex) == 'string') ? new RegExp(regex, params) : regex).test(this);	},	/*	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, 10);	},	/*	Property: toFloat		parses a string to an float.	Returns:		either a float or "NaN" if the string is not a number.	Example:		>var value = "10.848".toFloat(); // value is 10.848	*/	toFloat: function(){		return parseFloat(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/g, function(match){			return match.charAt(1).toUpperCase();		});	},	/*	Property: hyphenate		Converts a camelCased string to a hyphen-ated string.	Example:		>"ILikeCookies".hyphenate(); //"I-like-cookies"	*/	hyphenate: function(){		return this.replace(/\w[A-Z]/g, function(match){			return (match.charAt(0) + '-' + match.charAt(1).toLowerCase());		});	},	/*	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.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{2,}/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 output is set as string and 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.match(/\d{1,3}/g);		return (rgb) ? rgb.rgbToHex(array) : false;	},	/*	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.match(/^#?(\w{1,2})(\w{1,2})(\w{1,2})$/);		return (hex) ? hex.slice(1).hexToRgb(array) : false;	},	/*	Property: contains		checks if the passed in string is contained in the String. also accepts an optional second parameter, to check if the string is contained in a list of separated values.	Example:		>'a b c'.contains('c', ' '); //true		>'a bc'.contains('bc'); //true		>'a bc'.contains('b', ' '); //false	*/	contains: function(string, s){		return (s) ? (s + this + s).indexOf(s + string + s) > -1 : this.indexOf(string) > -1;	},	/*	Property: escapeRegExp		Returns string with escaped regular expression characters	Example:		>var search = 'animals.sheeps[1]'.escapeRegExp(); // search is now 'animals\.sheeps\[1\]'	Returns:		Escaped string	*/	escapeRegExp: function(){		return this.replace(/([.*+?^${}()|[\]\/\\])/g, '\\$1');	}});Array.extend({	/*	Property: rgbToHex		see <String.rgbToHex>, but as an array method.	*/	rgbToHex: function(array){		if (this.length < 3) return false;		if (this.length == 4 && this[3] == 0 && !array) return 'transparent';		var hex = [];		for (var i = 0; i < 3; i++){			var bit = (this[i] - 0).toString(16);			hex.push((bit.length == 1) ? '0' + bit : bit);		}		return array ? hex : '#' + hex.join('');	},	/*	Property: hexToRgb		same as <String.hexToRgb>, but as an array method.	*/	hexToRgb: function(array){		if (this.length != 3) return false;		var rgb = [];		for (var i = 0; i < 3; i++){			rgb.push(parseInt((this[i].length == 1) ? this[i] + this[i] : this[i], 16));		}		return array ? rgb : 'rgb(' + rgb.join(',') + ')';	}});/* Script: Function.js	Contains Function prototypes and utility functions .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: create		Main function to create closures.	Returns:		a function.	Arguments:		options - An Options object.	Options:		bind - The object that the "this" of the function will refer to. Default is the current function.		event - If set to true, the function will act as an event listener and receive an event as first argument.				If set to a class name, the function will receive a new instance of this class (with the event passed as argument's constructor) as first argument.				Default is false.		arguments - A single argument or array of arguments that will be passed to the function when called.							If both the event and arguments options are set, the event is passed as first argument and the arguments array will follow.										Default is no custom arguments, the function will receive the standard arguments when called.							delay - Numeric value: if set, the returned function will delay the actual execution by this amount of milliseconds and return a timer handle when called.				Default is no delay.		periodical - Numeric value: if set, the returned function will periodically perform the actual execution with this specified interval and return a timer handle when called.				Default is no periodical execution.		attempt - If set to true, the returned function will try to execute and return either the results or false on error. Default is false.	*/	create: function(options){		var fn = this;		options = $merge({			'bind': fn,			'event': false,			'arguments': null,			'delay': false,			'periodical': false,			'attempt': false		}, options);		if ($chk(options.arguments) && $type(options.arguments) != 'array') options.arguments = [options.arguments];		return function(event){			var args;			if (options.event){				event = event || window.event;				args = [(options.event === true) ? event : new options.event(event)];				if (options.arguments) args.extend(options.arguments);			}			else args = options.arguments || arguments;			var returns = function(){				return fn.apply($pick(options.bind, fn), args);			};			if (options.delay) return setTimeout(returns, options.delay);			if (options.periodical) return setInterval(returns, options.periodical);			if (options.attempt) try {return returns();} catch(err){return false;};			return returns();		};	},	/*	Property: pass		Shortcut to create closures with arguments and bind.	Returns:		a function.	Arguments:		args - the arguments passed. must be an array if arguments > 1		bind - optional, the object that the "this" of the function will refer to.	Example:		>myFunction.pass([arg1, arg2], myElement);	*/	pass: function(args, bind){		return this.create({'arguments': args, 'bind': bind});	},	/*	Property: attempt		Tries to execute the function, returns either the result of the function or false on error.	Arguments:		args - the arguments passed. must be an array if arguments > 1		bind - optional, the object that the "this" of the function will refer to.	Example:		>myFunction.attempt([arg1, arg2], myElement);	*/	attempt: function(args, bind){		return this.create({'arguments': args, 'bind': bind, 'attempt': true})();	},	/*	Property: bind		method to easily create closures with "this" altered.	Arguments:		bind - optional, the object that the "this" of the function will refer to.		args - optional, the arguments passed. must be an array if arguments > 1	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, args){		return this.create({'bind': bind, 'arguments': args});	},	/*	Property: bindAsEventListener		cross browser method to pass event firer	Arguments:		bind - optional, the object that the "this" of the function will refer to.		args - optional, the arguments passed. must be an array if arguments > 1	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, args){		return this.create({'bind': bind, 'event': true, 'arguments': args});	},	/*	Property: delay		Delays the execution of a function by a specified duration.	Arguments:		delay - the duration to wait in milliseconds.		bind - optional, the object that the "this" of the function will refer to.		args - optional, the arguments passed. must be an array if arguments > 1	Example: