1 /* prevent execution of jQuery if included more than once */

     2 if(typeof window.jQuery == "undefined") {

     3 /*

     4  * jQuery 1.1.2 - New Wave Javascript

     5  *

     6  * Copyright (c) 2007 John Resig (jquery.com)

     7  * Dual licensed under the MIT (MIT-LICENSE.txt)

     8  * and GPL (GPL-LICENSE.txt) licenses.

     9  *

    10  * $Date: 2007-02-28 12:03:00 -0500 (Wed, 28 Feb 2007) $

    11  * $Rev: 1465 $

    12  */

    13 

    14 // Global undefined variable

    15 window.undefined = window.undefined;

    16 var jQuery = function(a,c) {

    17 	// If the context is global, return a new object

    18 	if ( window == this )

    19 		return new jQuery(a,c);

    20 

    21 	// Make sure that a selection was provided

    22 	a = a || document;

    23 	

    24 	// HANDLE: $(function)

    25 	// Shortcut for document ready

    26 	if ( jQuery.isFunction(a) )

    27 		return new jQuery(document)[ jQuery.fn.ready ? "ready" : "load" ]( a );

    28 	

    29 	// Handle HTML strings

    30 	if ( typeof a  == "string" ) {

    31 		// HANDLE: $(html) -> $(array)

    32 		var m = /^[^<]*(<(.|\s)+>)[^>]*$/.exec(a);

    33 		if ( m )

    34 			a = jQuery.clean( [ m[1] ] );

    35 		

    36 		// HANDLE: $(expr)

    37 		else

    38 			return new jQuery( c ).find( a );

    39 	}

    40 	

    41 	return this.setArray(

    42 		// HANDLE: $(array)

    43 		a.constructor == Array && a ||

    44 

    45 		// HANDLE: $(arraylike)

    46 		// Watch for when an array-like object is passed as the selector

    47 		(a.jquery || a.length && a != window && !a.nodeType && a[0] != undefined && a[0].nodeType) && jQuery.makeArray( a ) ||

    48 

    49 		// HANDLE: $(*)

    50 		[ a ] );

    51 };

    52 

    53 // Map over the $ in case of overwrite

    54 if ( typeof $ != "undefined" )

    55 	jQuery._$ = $;

    56 	

    57 // Map the jQuery namespace to the '$' one

    58 var $jq = jQuery;

    59 

    60 jQuery.fn = jQuery.prototype = {

    61 	jquery: "1.1.2",

    62 

    63 	size: function() {

    64 		return this.length;

    65 	},

    66 	

    67 	length: 0,

    68 

    69 	get: function( num ) {

    70 		return num == undefined ?

    71 

    72 			// Return a 'clean' array

    73 			jQuery.makeArray( this ) :

    74 

    75 			// Return just the object

    76 			this[num];

    77 	},

    78 	pushStack: function( a ) {

    79 		var ret = jQuery(a);

    80 		ret.prevObject = this;

    81 		return ret;

    82 	},

    83 	setArray: function( a ) {

    84 		this.length = 0;

    85 		[].push.apply( this, a );

    86 		return this;

    87 	},

    88 	each: function( fn, args ) {

    89 		return jQuery.each( this, fn, args );

    90 	},

    91 	index: function( obj ) {

    92 		var pos = -1;

    93 		this.each(function(i){

    94 			if ( this == obj ) pos = i;

    95 		});

    96 		return pos;

    97 	},

    98 

    99 	attr: function( key, value, type ) {

   100 		var obj = key;

   101 		

   102 		// Look for the case where we're accessing a style value

   103 		if ( key.constructor == String )

   104 			if ( value == undefined )

   105 				return this.length && jQuery[ type || "attr" ]( this[0], key ) || undefined;

   106 			else {

   107 				obj = {};

   108 				obj[ key ] = value;

   109 			}

   110 		

   111 		// Check to see if we're setting style values

   112 		return this.each(function(index){

   113 			// Set all the styles

   114 			for ( var prop in obj )

   115 				jQuery.attr(

   116 					type ? this.style : this,

   117 					prop, jQuery.prop(this, obj[prop], type, index, prop)

   118 				);

   119 		});

   120 	},

   121 

   122 	css: function( key, value ) {

   123 		return this.attr( key, value, "curCSS" );

   124 	},

   125 

   126 	text: function(e) {

   127 		if ( typeof e == "string" )

   128 			return this.empty().append( document.createTextNode( e ) );

   129 

   130 		var t = "";

   131 		jQuery.each( e || this, function(){

   132 			jQuery.each( this.childNodes, function(){

   133 				if ( this.nodeType != 8 )

   134 					t += this.nodeType != 1 ?

   135 						this.nodeValue : jQuery.fn.text([ this ]);

   136 			});

   137 		});

   138 		return t;

   139 	},

   140 

   141 	wrap: function() {

   142 		// The elements to wrap the target around

   143 		var a = jQuery.clean(arguments);

   144 

   145 		// Wrap each of the matched elements individually

   146 		return this.each(function(){

   147 			// Clone the structure that we're using to wrap

   148 			var b = a[0].cloneNode(true);

   149 

   150 			// Insert it before the element to be wrapped

   151 			this.parentNode.insertBefore( b, this );

   152 

   153 			// Find the deepest point in the wrap structure

   154 			while ( b.firstChild )

   155 				b = b.firstChild;

   156 

   157 			// Move the matched element to within the wrap structure

   158 			b.appendChild( this );

   159 		});

   160 	},

   161 	append: function() {

   162 		return this.domManip(arguments, true, 1, function(a){

   163 			this.appendChild( a );

   164 		});

   165 	},

   166 	prepend: function() {

   167 		return this.domManip(arguments, true, -1, function(a){

   168 			this.insertBefore( a, this.firstChild );

   169 		});

   170 	},

   171 	before: function() {

   172 		return this.domManip(arguments, false, 1, function(a){

   173 			this.parentNode.insertBefore( a, this );

   174 		});

   175 	},

   176 	after: function() {

   177 		return this.domManip(arguments, false, -1, function(a){

   178 			this.parentNode.insertBefore( a, this.nextSibling );

   179 		});

   180 	},

   181 	end: function() {

   182 		return this.prevObject || jQuery([]);

   183 	},

   184 	find: function(t) {

   185 		return this.pushStack( jQuery.map( this, function(a){

   186 			return jQuery.find(t,a);

   187 		}), t );

   188 	},

   189 	clone: function(deep) {

   190 		return this.pushStack( jQuery.map( this, function(a){

   191 			var a = a.cloneNode( deep != undefined ? deep : true );

   192 			a.$events = null; // drop $events expando to avoid firing incorrect events

   193 			return a;

   194 		}) );

   195 	},

   196 

   197 	filter: function(t) {

   198 		return this.pushStack(

   199 			jQuery.isFunction( t ) &&

   200 			jQuery.grep(this, function(el, index){

   201 				return t.apply(el, [index])

   202 			}) ||

   203 

   204 			jQuery.multiFilter(t,this) );

   205 	},

   206 

   207 	not: function(t) {

   208 		return this.pushStack(

   209 			t.constructor == String &&

   210 			jQuery.multiFilter(t, this, true) ||

   211 

   212 			jQuery.grep(this, function(a) {

   213 				return ( t.constructor == Array || t.jquery )

   214 					? jQuery.inArray( a, t ) < 0

   215 					: a != t;

   216 			})

   217 		);

   218 	},

   219 

   220 	add: function(t) {

   221 		return this.pushStack( jQuery.merge(

   222 			this.get(),

   223 			t.constructor == String ?

   224 				jQuery(t).get() :

   225 				t.length != undefined && (!t.nodeName || t.nodeName == "FORM") ?

   226 					t : [t] )

   227 		);

   228 	},

   229 	is: function(expr) {

   230 		return expr ? jQuery.filter(expr,this).r.length > 0 : false;

   231 	},

   232 

   233 	val: function( val ) {

   234 		return val == undefined ?

   235 			( this.length ? this[0].value : null ) :

   236 			this.attr( "value", val );

   237 	},

   238 

   239 	html: function( val ) {

   240 		return val == undefined ?

   241 			( this.length ? this[0].innerHTML : null ) :

   242 			this.empty().append( val );

   243 	},

   244 	domManip: function(args, table, dir, fn){

   245 		var clone = this.length > 1; 

   246 		var a = jQuery.clean(args);

   247 		if ( dir < 0 )

   248 			a.reverse();

   249 

   250 		return this.each(function(){

   251 			var obj = this;

   252 

   253 			if ( table && jQuery.nodeName(this, "table") && jQuery.nodeName(a[0], "tr") )

   254 				obj = this.getElementsByTagName("tbody")[0] || this.appendChild(document.createElement("tbody"));

   255 

   256 			jQuery.each( a, function(){

   257 				fn.apply( obj, [ clone ? this.cloneNode(true) : this ] );

   258 			});

   259 

   260 		});

   261 	}

   262 };

   263 

   264 jQuery.extend = jQuery.fn.extend = function() {

   265 	// copy reference to target object

   266 	var target = arguments[0],

   267 		a = 1;

   268 

   269 	// extend jQuery itself if only one argument is passed

   270 	if ( arguments.length == 1 ) {

   271 		target = this;

   272 		a = 0;

   273 	}

   274 	var prop;

   275 	while (prop = arguments[a++])

   276 		// Extend the base object

   277 		for ( var i in prop ) target[i] = prop[i];

   278 

   279 	// Return the modified object

   280 	return target;

   281 };

   282 

   283 jQuery.extend({

   284 	noConflict: function() {

   285 		if ( jQuery._$ )

   286 			$ = jQuery._$;

   287 		return jQuery;

   288 	},

   289 

   290 	// This may seem like some crazy code, but trust me when I say that this

   291 	// is the only cross-browser way to do this. --John

   292 	isFunction: function( fn ) {

   293 		return !!fn && typeof fn != "string" && !fn.nodeName && 

   294 			typeof fn[0] == "undefined" && /function/i.test( fn + "" );

   295 	},

   296 	

   297 	// check if an element is in a XML document

   298 	isXMLDoc: function(elem) {

   299 		return elem.tagName && elem.ownerDocument && !elem.ownerDocument.body;

   300 	},

   301 

   302 	nodeName: function( elem, name ) {

   303 		return elem.nodeName && elem.nodeName.toUpperCase() == name.toUpperCase();

   304 	},

   305 	// args is for internal usage only

   306 	each: function( obj, fn, args ) {

   307 		if ( obj.length == undefined )

   308 			for ( var i in obj )

   309 				fn.apply( obj[i], args || [i, obj[i]] );

   310 		else

   311 			for ( var i = 0, ol = obj.length; i < ol; i++ )

   312 				if ( fn.apply( obj[i], args || [i, obj[i]] ) === false ) break;

   313 		return obj;

   314 	},

   315 	

   316 	prop: function(elem, value, type, index, prop){

   317 			// Handle executable functions

   318 			if ( jQuery.isFunction( value ) )

   319 				value = value.call( elem, [index] );

   320 				

   321 			// exclude the following css properties to add px

   322 			var exclude = /z-?index|font-?weight|opacity|zoom|line-?height/i;

   323 

   324 			// Handle passing in a number to a CSS property

   325 			return value && value.constructor == Number && type == "curCSS" && !exclude.test(prop) ?

   326 				value + "px" :

   327 				value;

   328 	},

   329 

   330 	className: {

   331 		// internal only, use addClass("class")

   332 		add: function( elem, c ){

   333 			jQuery.each( c.split(/\s+/), function(i, cur){

   334 				if ( !jQuery.className.has( elem.className, cur ) )

   335 					elem.className += ( elem.className ? " " : "" ) + cur;

   336 			});

   337 		},

   338 

   339 		// internal only, use removeClass("class")

   340 		remove: function( elem, c ){

   341 			elem.className = c ?

   342 				jQuery.grep( elem.className.split(/\s+/), function(cur){

   343 					return !jQuery.className.has( c, cur );	

   344 				}).join(" ") : "";

   345 		},

   346 

   347 		// internal only, use is(".class")

   348 		has: function( t, c ) {

   349 			t = t.className || t;

   350 			// escape regex characters

   351 			c = c.replace(/([\.\\\+\*\?\[\^\]\$\(\)\{\}\=\!\<\>\|\:])/g, "\\$1");

   352 			return t && new RegExp("(^|\\s)" + c + "(\\s|$)").test( t );

   353 		}

   354 	},

   355 	swap: function(e,o,f) {

   356 		for ( var i in o ) {

   357 			e.style["old"+i] = e.style[i];

   358 			e.style[i] = o[i];

   359 		}

   360 		f.apply( e, [] );

   361 		for ( var i in o )

   362 			e.style[i] = e.style["old"+i];

   363 	},

   364 

   365 	css: function(e,p) {

   366 		if ( p == "height" || p == "width" ) {

   367 			var old = {}, oHeight, oWidth, d = ["Top","Bottom","Right","Left"];

   368 

   369 			jQuery.each( d, function(){

   370 				old["padding" + this] = 0;

   371 				old["border" + this + "Width"] = 0;

   372 			});

   373 

   374 			jQuery.swap( e, old, function() {

   375 				if (jQuery.css(e,"display") != "none") {

   376 					oHeight = e.offsetHeight;

   377 					oWidth = e.offsetWidth;

   378 				} else {

   379 					e = jQuery(e.cloneNode(true))

   380 						.find(":radio").removeAttr("checked").end()

   381 						.css({

   382 							visibility: "hidden", position: "absolute", display: "block", right: "0", left: "0"

   383 						}).appendTo(e.parentNode)[0];

   384 

   385 					var parPos = jQuery.css(e.parentNode,"position");

   386 					if ( parPos == "" || parPos == "static" )

   387 						e.parentNode.style.position = "relative";

   388 

   389 					oHeight = e.clientHeight;

   390 					oWidth = e.clientWidth;

   391 

   392 					if ( parPos == "" || parPos == "static" )

   393 						e.parentNode.style.position = "static";

   394 

   395 					e.parentNode.removeChild(e);

   396 				}

   397 			});

   398 

   399 			return p == "height" ? oHeight : oWidth;

   400 		}

   401 

   402 		return jQuery.curCSS( e, p );

   403 	},

   404 

   405 	curCSS: function(elem, prop, force) {

   406 		var ret;

   407 		

   408 		if (prop == "opacity" && jQuery.browser.msie)

   409 			return jQuery.attr(elem.style, "opacity");

   410 			

   411 		if (prop == "float" || prop == "cssFloat")

   412 		    prop = jQuery.browser.msie ? "styleFloat" : "cssFloat";

   413 

   414 		if (!force && elem.style[prop])

   415 			ret = elem.style[prop];

   416 

   417 		else if (document.defaultView && document.defaultView.getComputedStyle) {

   418 

   419 			if (prop == "cssFloat" || prop == "styleFloat")

   420 				prop = "float";

   421 

   422 			prop = prop.replace(/([A-Z])/g,"-$1").toLowerCase();

   423 			var cur = document.defaultView.getComputedStyle(elem, null);

   424 

   425 			if ( cur )

   426 				ret = cur.getPropertyValue(prop);

   427 			else if ( prop == "display" )

   428 				ret = "none";

   429 			else

   430 				jQuery.swap(elem, { display: "block" }, function() {

   431 				    var c = document.defaultView.getComputedStyle(this, "");

   432 				    ret = c && c.getPropertyValue(prop) || "";

   433 				});

   434 

   435 		} else if (elem.currentStyle) {

   436 

   437 			var newProp = prop.replace(/\-(\w)/g,function(m,c){return c.toUpperCase();});

   438 			ret = elem.currentStyle[prop] || elem.currentStyle[newProp];

   439 			

   440 		}

   441 

   442 		return ret;

   443 	},

   444 	

   445 	clean: function(a) {

   446 		var r = [];

   447 

   448 		jQuery.each( a, function(i,arg){

   449 			if ( !arg ) return;

   450 

   451 			if ( arg.constructor == Number )

   452 				arg = arg.toString();

   453 			

   454 			 // Convert html string into DOM nodes

   455 			if ( typeof arg == "string" ) {

   456 				// Trim whitespace, otherwise indexOf won't work as expected

   457 				var s = jQuery.trim(arg), div = document.createElement("div"), tb = [];

   458 

   459 				var wrap =

   460 					 // option or optgroup

   461 					!s.indexOf("<opt") &&

   462 					[1, "<select>", "</select>"] ||

   463 					

   464 					(!s.indexOf("<thead") || !s.indexOf("<tbody") || !s.indexOf("<tfoot")) &&

   465 					[1, "<table>", "</table>"] ||

   466 					

   467 					!s.indexOf("<tr") &&

   468 					[2, "<table><tbody>", "</tbody></table>"] ||

   469 					

   470 				 	// <thead> matched above

   471 					(!s.indexOf("<td") || !s.indexOf("<th")) &&

   472 					[3, "<table><tbody><tr>", "</tr></tbody></table>"] ||

   473 					

   474 					[0,"",""];

   475 

   476 				// Go to html and back, then peel off extra wrappers

   477 				div.innerHTML = wrap[1] + s + wrap[2];

   478 				

   479 				// Move to the right depth

   480 				while ( wrap[0]-- )

   481 					div = div.firstChild;

   482 				

   483 				// Remove IE's autoinserted <tbody> from table fragments

   484 				if ( jQuery.browser.msie ) {

   485 					

   486 					// String was a <table>, *may* have spurious <tbody>

   487 					if ( !s.indexOf("<table") && s.indexOf("<tbody") < 0 ) 

   488 						tb = div.firstChild && div.firstChild.childNodes;

   489 						

   490 					// String was a bare <thead> or <tfoot>

   491 					else if ( wrap[1] == "<table>" && s.indexOf("<tbody") < 0 )

   492 						tb = div.childNodes;

   493 

   494 					for ( var n = tb.length-1; n >= 0 ; --n )

   495 						if ( jQuery.nodeName(tb[n], "tbody") && !tb[n].childNodes.length )

   496 							tb[n].parentNode.removeChild(tb[n]);

   497 					

   498 				}

   499 				

   500 				arg = [];

   501 				for (var i=0, l=div.childNodes.length; i<l; i++)

   502 					arg.push(div.childNodes[i]);

   503 			}

   504 

   505 			if ( arg.length === 0 && !jQuery.nodeName(arg, "form") )

   506 				return;

   507 			

   508 			if ( arg[0] == undefined || jQuery.nodeName(arg, "form") )

   509 				r.push( arg );

   510 			else

   511 				r = jQuery.merge( r, arg );

   512 

   513 		});

   514 

   515 		return r;

   516 	},

   517 	

   518 	attr: function(elem, name, value){

   519 		var fix = jQuery.isXMLDoc(elem) ? {} : {

   520 			"for": "htmlFor",

   521 			"class": "className",

   522 			"float": jQuery.browser.msie ? "styleFloat" : "cssFloat",

   523 			cssFloat: jQuery.browser.msie ? "styleFloat" : "cssFloat",

   524 			innerHTML: "innerHTML",

   525 			className: "className",

   526 			value: "value",

   527 			disabled: "disabled",

   528 			checked: "checked",

   529 			readonly: "readOnly",

   530 			selected: "selected"

   531 		};

   532 		

   533 		// IE actually uses filters for opacity ... elem is actually elem.style

   534 		if ( name == "opacity" && jQuery.browser.msie && value != undefined ) {

   535 			// IE has trouble with opacity if it does not have layout

   536 			// Force it by setting the zoom level

   537 			elem.zoom = 1; 

   538 

   539 			// Set the alpha filter to set the opacity

   540 			return elem.filter = elem.filter.replace(/alpha\([^\)]*\)/gi,"") +

   541 				( value == 1 ? "" : "alpha(opacity=" + value * 100 + ")" );

   542 

   543 		} else if ( name == "opacity" && jQuery.browser.msie )

   544 			return elem.filter ? 

   545 				parseFloat( elem.filter.match(/alpha\(opacity=(.*)\)/)[1] ) / 100 : 1;

   546 		

   547 		// Mozilla doesn't play well with opacity 1

   548 		if ( name == "opacity" && jQuery.browser.mozilla && value == 1 )

   549 			value = 0.9999;

   550 			

   551 

   552 		// Certain attributes only work when accessed via the old DOM 0 way

   553 		if ( fix[name] ) {

   554 			if ( value != undefined ) elem[fix[name]] = value;

   555 			return elem[fix[name]];

   556 

   557 		} else if ( value == undefined && jQuery.browser.msie && jQuery.nodeName(elem, "form") && (name == "action" || name == "method") )

   558 			return elem.getAttributeNode(name).nodeValue;

   559 

   560 		// IE elem.getAttribute passes even for style

   561 		else if ( elem.tagName ) {

   562 			if ( value != undefined ) elem.setAttribute( name, value );

   563 			if ( jQuery.browser.msie && /href|src/.test(name) && !jQuery.isXMLDoc(elem) ) 

   564 				return elem.getAttribute( name, 2 );

   565 			return elem.getAttribute( name );

   566 

   567 		// elem is actually elem.style ... set the style

   568 		} else {

   569 			name = name.replace(/-([a-z])/ig,function(z,b){return b.toUpperCase();});

   570 			if ( value != undefined ) elem[name] = value;

   571 			return elem[name];

   572 		}

   573 	},

   574 	trim: function(t){

   575 		return t.replace(/^\s+|\s+$/g, "");

   576 	},

   577 

   578 	makeArray: function( a ) {

   579 		var r = [];

   580 

   581 		if ( a.constructor != Array )

   582 			for ( var i = 0, al = a.length; i < al; i++ )

   583 				r.push( a[i] );

   584 		else

   585 			r = a.slice( 0 );

   586 

   587 		return r;

   588 	},

   589 

   590 	inArray: function( b, a ) {

   591 		for ( var i = 0, al = a.length; i < al; i++ )

   592 			if ( a[i] == b )

   593 				return i;

   594 		return -1;

   595 	},

   596 	merge: function(first, second) {

   597 		var r = [].slice.call( first, 0 );

   598 

   599 		// Now check for duplicates between the two arrays

   600 		// and only add the unique items

   601 		for ( var i = 0, sl = second.length; i < sl; i++ )

   602 			// Check for duplicates

   603 			if ( jQuery.inArray( second[i], r ) == -1 )

   604 				// The item is unique, add it

   605 				first.push( second[i] );

   606 

   607 		return first;

   608 	},

   609 	grep: function(elems, fn, inv) {

   610 		// If a string is passed in for the function, make a function

   611 		// for it (a handy shortcut)

   612 		if ( typeof fn == "string" )

   613 			fn = new Function("a","i","return " + fn);

   614 

   615 		var result = [];

   616 

   617 		// Go through the array, only saving the items

   618 		// that pass the validator function

   619 		for ( var i = 0, el = elems.length; i < el; i++ )

   620 			if ( !inv && fn(elems[i],i) || inv && !fn(elems[i],i) )

   621 				result.push( elems[i] );

   622 

   623 		return result;

   624 	},

   625 	map: function(elems, fn) {

   626 		// If a string is passed in for the function, make a function

   627 		// for it (a handy shortcut)

   628 		if ( typeof fn == "string" )

   629 			fn = new Function("a","return " + fn);

   630 

   631 		var result = [], r = [];

   632 

   633 		// Go through the array, translating each of the items to their

   634 		// new value (or values).

   635 		for ( var i = 0, el = elems.length; i < el; i++ ) {

   636 			var val = fn(elems[i],i);

   637 

   638 			if ( val !== null && val != undefined ) {

   639 				if ( val.constructor != Array ) val = [val];

   640 				result = result.concat( val );

   641 			}

   642 		}

   643 

   644 		var r = result.length ? [ result[0] ] : [];

   645 

   646 		check: for ( var i = 1, rl = result.length; i < rl; i++ ) {

   647 			for ( var j = 0; j < i; j++ )

   648 				if ( result[i] == r[j] )

   649 					continue check;

   650 

   651 			r.push( result[i] );

   652 		}

   653 

   654 		return r;

   655 	}

   656 });

   657  

   658 /*

   659  * Whether the W3C compliant box model is being used.

   660  *

   661  * @property

   662  * @name $.boxModel

   663  * @type Boolean

   664  * @cat JavaScript

   665  */

   666 new function() {

   667 	var b = navigator.userAgent.toLowerCase();

   668 

   669 	// Figure out what browser is being used

   670 	jQuery.browser = {

   671 		safari: /webkit/.test(b),

   672 		opera: /opera/.test(b),

   673 		msie: /msie/.test(b) && !/opera/.test(b),

   674 		mozilla: /mozilla/.test(b) && !/(compatible|webkit)/.test(b)

   675 	};

   676 

   677 	// Check to see if the W3C box model is being used

   678 	jQuery.boxModel = !jQuery.browser.msie || document.compatMode == "CSS1Compat";

   679 };

   680 

   681 jQuery.each({

   682 	parent: "a.parentNode",

   683 	parents: "jQuery.parents(a)",

   684 	next: "jQuery.nth(a,2,'nextSibling')",

   685 	prev: "jQuery.nth(a,2,'previousSibling')",

   686 	siblings: "jQuery.sibling(a.parentNode.firstChild,a)",

   687 	children: "jQuery.sibling(a.firstChild)"

   688 }, function(i,n){

   689 	jQuery.fn[ i ] = function(a) {

   690 		var ret = jQuery.map(this,n);

   691 		if ( a && typeof a == "string" )

   692 			ret = jQuery.multiFilter(a,ret);

   693 		return this.pushStack( ret );

   694 	};

   695 });

   696 

   697 jQuery.each({

   698 	appendTo: "append",

   699 	prependTo: "prepend",

   700 	insertBefore: "before",

   701 	insertAfter: "after"

   702 }, function(i,n){

   703 	jQuery.fn[ i ] = function(){

   704 		var a = arguments;

   705 		return this.each(function(){

   706 			for ( var j = 0, al = a.length; j < al; j++ )

   707 				jQuery(a[j])[n]( this );

   708 		});

   709 	};

   710 });

   711 

   712 jQuery.each( {

   713 	removeAttr: function( key ) {

   714 		jQuery.attr( this, key, "" );

   715 		this.removeAttribute( key );

   716 	},

   717 	addClass: function(c){

   718 		jQuery.className.add(this,c);

   719 	},

   720 	removeClass: function(c){

   721 		jQuery.className.remove(this,c);

   722 	},

   723 	toggleClass: function( c ){

   724 		jQuery.className[ jQuery.className.has(this,c) ? "remove" : "add" ](this, c);

   725 	},

   726 	remove: function(a){

   727 		if ( !a || jQuery.filter( a, [this] ).r.length )

   728 			this.parentNode.removeChild( this );

   729 	},

   730 	empty: function() {

   731 		while ( this.firstChild )

   732 			this.removeChild( this.firstChild );

   733 	}

   734 }, function(i,n){

   735 	jQuery.fn[ i ] = function() {

   736 		return this.each( n, arguments );

   737 	};

   738 });

   739 

   740 jQuery.each( [ "eq", "lt", "gt", "contains" ], function(i,n){

   741 	jQuery.fn[ n ] = function(num,fn) {

   742 		return this.filter( ":" + n + "(" + num + ")", fn );

   743 	};

   744 });

   745 

   746 jQuery.each( [ "height", "width" ], function(i,n){

   747 	jQuery.fn[ n ] = function(h) {

   748 		return h == undefined ?

   749 			( this.length ? jQuery.css( this[0], n ) : null ) :

   750 			this.css( n, h.constructor == String ? h : h + "px" );

   751 	};

   752 });

   753 jQuery.extend({

   754 	expr: {

   755 		"": "m[2]=='*'||jQuery.nodeName(a,m[2])",

   756 		"#": "a.getAttribute('id')==m[2]",

   757 		":": {

   758 			// Position Checks

   759 			lt: "i<m[3]-0",

   760 			gt: "i>m[3]-0",

   761 			nth: "m[3]-0==i",

   762 			eq: "m[3]-0==i",

   763 			first: "i==0",

   764 			last: "i==r.length-1",

   765 			even: "i%2==0",

   766 			odd: "i%2",

   767 

   768 			// Child Checks

   769 			"nth-child": "jQuery.nth(a.parentNode.firstChild,m[3],'nextSibling',a)==a",

   770 			"first-child": "jQuery.nth(a.parentNode.firstChild,1,'nextSibling')==a",

   771 			"last-child": "jQuery.nth(a.parentNode.lastChild,1,'previousSibling')==a",

   772 			"only-child": "jQuery.sibling(a.parentNode.firstChild).length==1",

   773 

   774 			// Parent Checks

   775 			parent: "a.firstChild",

   776 			empty: "!a.firstChild",

   777 

   778 			// Text Check

   779 			contains: "jQuery.fn.text.apply([a]).indexOf(m[3])>=0",

   780 

   781 			// Visibility

   782 			visible: 'a.type!="hidden"&&jQuery.css(a,"display")!="none"&&jQuery.css(a,"visibility")!="hidden"',

   783 			hidden: 'a.type=="hidden"||jQuery.css(a,"display")=="none"||jQuery.css(a,"visibility")=="hidden"',

   784 

   785 			// Form attributes

   786 			enabled: "!a.disabled",

   787 			disabled: "a.disabled",

   788 			checked: "a.checked",

   789 			selected: "a.selected||jQuery.attr(a,'selected')",

   790 

   791 			// Form elements

   792 			text: "a.type=='text'",

   793 			radio: "a.type=='radio'",

   794 			checkbox: "a.type=='checkbox'",

   795 			file: "a.type=='file'",

   796 			password: "a.type=='password'",

   797 			submit: "a.type=='submit'",

   798 			image: "a.type=='image'",

   799 			reset: "a.type=='reset'",

   800 			button: 'a.type=="button"||jQuery.nodeName(a,"button")',

   801 			input: "/input|select|textarea|button/i.test(a.nodeName)"

   802 		},

   803 		".": "jQuery.className.has(a,m[2])",

   804 		"@": {

   805 			"=": "z==m[4]",

   806 			"!=": "z!=m[4]",

   807 			"^=": "z&&!z.indexOf(m[4])",

   808 			"$=": "z&&z.substr(z.length - m[4].length,m[4].length)==m[4]",

   809 			"*=": "z&&z.indexOf(m[4])>=0",

   810 			"": "z",

   811 			_resort: function(m){

   812 				return ["", m[1], m[3], m[2], m[5]];

   813 			},

   814 			_prefix: "z=a[m[3]];if(!z||/href|src/.test(m[3]))z=jQuery.attr(a,m[3]);"

   815 		},

   816 		"[": "jQuery.find(m[2],a).length"

   817 	},

   818 	

   819 	// The regular expressions that power the parsing engine

   820 	parse: [

   821 		// Match: [@value='test'], [@foo]

   822 		/^\[ *(@)([a-z0-9_-]*) *([!*$^=]*) *('?"?)(.*?)\4 *\]/i,

   823 

   824 		// Match: [div], [div p]

   825 		/^(\[)\s*(.*?(\[.*?\])?[^[]*?)\s*\]/,

   826 

   827 		// Match: :contains('foo')

   828 		/^(:)([a-z0-9_-]*)\("?'?(.*?(\(.*?\))?[^(]*?)"?'?\)/i,

   829 

   830 		// Match: :even, :last-chlid

   831 		/^([:.#]*)([a-z0-9_*-]*)/i

   832 	],

   833 

   834 	token: [

   835 		/^(\/?\.\.)/, "a.parentNode",

   836 		/^(>|\/)/, "jQuery.sibling(a.firstChild)",

   837 		/^(\+)/, "jQuery.nth(a,2,'nextSibling')",

   838 		/^(~)/, function(a){

   839 			var s = jQuery.sibling(a.parentNode.firstChild);

   840 			return s.slice(jQuery.inArray(a,s) + 1);

   841 		}

   842 	],

   843 

   844 	multiFilter: function( expr, elems, not ) {

   845 		var old, cur = [];

   846 

   847 		while ( expr && expr != old ) {

   848 			old = expr;

   849 			var f = jQuery.filter( expr, elems, not );

   850 			expr = f.t.replace(/^\s*,\s*/, "" );

   851 			cur = not ? elems = f.r : jQuery.merge( cur, f.r );

   852 		}

   853 

   854 		return cur;

   855 	},

   856 	find: function( t, context ) {

   857 		// Quickly handle non-string expressions

   858 		if ( typeof t != "string" )

   859 			return [ t ];

   860 

   861 		// Make sure that the context is a DOM Element

   862 		if ( context && !context.nodeType )

   863 			context = null;

   864 

   865 		// Set the correct context (if none is provided)

   866 		context = context || document;

   867 

   868 		// Handle the common XPath // expression

   869 		if ( !t.indexOf("//") ) {

   870 			context = context.documentElement;

   871 			t = t.substr(2,t.length);

   872 

   873 		// And the / root expression

   874 		} else if ( !t.indexOf("/") ) {

   875 			context = context.documentElement;

   876 			t = t.substr(1,t.length);

   877 			if ( t.indexOf("/") >= 1 )

   878 				t = t.substr(t.indexOf("/"),t.length);

   879 		}

   880 

   881 		// Initialize the search

   882 		var ret = [context], done = [], last = null;

   883 

   884 		// Continue while a selector expression exists, and while

   885 		// we're no longer looping upon ourselves

   886 		while ( t && last != t ) {

   887 			var r = [];

   888 			last = t;

   889 

   890 			t = jQuery.trim(t).replace( /^\/\//i, "" );

   891 

   892 			var foundToken = false;

   893 

   894 			// An attempt at speeding up child selectors that

   895 			// point to a specific element tag

   896 			var re = /^[\/>]\s*([a-z0-9*-]+)/i;

   897 			var m = re.exec(t);

   898 

   899 			if ( m ) {

   900 				// Perform our own iteration and filter

   901 				jQuery.each( ret, function(){

   902 					for ( var c = this.firstChild; c; c = c.nextSibling )

   903 						if ( c.nodeType == 1 && ( jQuery.nodeName(c, m[1]) || m[1] == "*" ) )

   904 							r.push( c );

   905 				});

   906 

   907 				ret = r;

   908 				t = t.replace( re, "" );

   909 				if ( t.indexOf(" ") == 0 ) continue;

   910 				foundToken = true;

   911 			} else {

   912 				// Look for pre-defined expression tokens

   913 				for ( var i = 0; i < jQuery.token.length; i += 2 ) {

   914 					// Attempt to match each, individual, token in

   915 					// the specified order

   916 					var re = jQuery.token[i];

   917 					var m = re.exec(t);

   918 

   919 					// If the token match was found

   920 					if ( m ) {

   921 						// Map it against the token's handler

   922 						r = ret = jQuery.map( ret, jQuery.isFunction( jQuery.token[i+1] ) ?

   923 							jQuery.token[i+1] :

   924 							function(a){ return eval(jQuery.token[i+1]); });

   925 

   926 						// And remove the token

   927 						t = jQuery.trim( t.replace( re, "" ) );

   928 						foundToken = true;

   929 						break;

   930 					}

   931 				}

   932 			}

   933 

   934 			// See if there's still an expression, and that we haven't already

   935 			// matched a token

   936 			if ( t && !foundToken ) {

   937 				// Handle multiple expressions

   938 				if ( !t.indexOf(",") ) {

   939 					// Clean the result set

   940 					if ( ret[0] == context ) ret.shift();

   941 

   942 					// Merge the result sets

   943 					jQuery.merge( done, ret );

   944 

   945 					// Reset the context

   946 					r = ret = [context];

   947 

   948 					// Touch up the selector string

   949 					t = " " + t.substr(1,t.length);

   950 

   951 				} else {

   952 					// Optomize for the case nodeName#idName

   953 					var re2 = /^([a-z0-9_-]+)(#)([a-z0-9\\*_-]*)/i;

   954 					var m = re2.exec(t);

   955 					

   956 					// Re-organize the results, so that they're consistent

   957 					if ( m ) {

   958 					   m = [ 0, m[2], m[3], m[1] ];

   959 

   960 					} else {

   961 						// Otherwise, do a traditional filter check for

   962 						// ID, class, and element selectors

   963 						re2 = /^([#.]?)([a-z0-9\\*_-]*)/i;

   964 						m = re2.exec(t);

   965 					}

   966 

   967 					// Try to do a global search by ID, where we can

   968 					if ( m[1] == "#" && ret[ret.length-1].getElementById ) {

   969 						// Optimization for HTML document case

   970 						var oid = ret[ret.length-1].getElementById(m[2]);

   971 						

   972 						// Do a quick check for the existence of the actual ID attribute

   973 						// to avoid selecting by the name attribute in IE

   974 						if ( jQuery.browser.msie && oid && oid.id != m[2] )

   975 							oid = jQuery('[@id="'+m[2]+'"]', ret[ret.length-1])[0];

   976 

   977 						// Do a quick check for node name (where applicable) so

   978 						// that div#foo searches will be really fast

   979 						ret = r = oid && (!m[3] || jQuery.nodeName(oid, m[3])) ? [oid] : [];

   980 

   981 					} else {

   982 						// Pre-compile a regular expression to handle class searches

   983 						if ( m[1] == "." )

   984 							var rec = new RegExp("(^|\\s)" + m[2] + "(\\s|$)");

   985 

   986 						// We need to find all descendant elements, it is more

   987 						// efficient to use getAll() when we are already further down

   988 						// the tree - we try to recognize that here

   989 						jQuery.each( ret, function(){

   990 							// Grab the tag name being searched for

   991 							var tag = m[1] != "" || m[0] == "" ? "*" : m[2];

   992 

   993 							// Handle IE7 being really dumb about <object>s

   994 							if ( jQuery.nodeName(this, "object") && tag == "*" )

   995 								tag = "param";

   996 

   997 							jQuery.merge( r,

   998 								m[1] != "" && ret.length != 1 ?

   999 									jQuery.getAll( this, [], m[1], m[2], rec ) :

  1000 									this.getElementsByTagName( tag )

  1001 							);

  1002 						});

  1003 

  1004 						// It's faster to filter by class and be done with it

  1005 						if ( m[1] == "." && ret.length == 1 )

  1006 							r = jQuery.grep( r, function(e) {

  1007 								return rec.test(e.className);

  1008 							});

  1009 

  1010 						// Same with ID filtering

  1011 						if ( m[1] == "#" && ret.length == 1 ) {

  1012 							// Remember, then wipe out, the result set

  1013 							var tmp = r;

  1014 							r = [];

  1015 

  1016 							// Then try to find the element with the ID

  1017 							jQuery.each( tmp, function(){

  1018 								if ( this.getAttribute("id") == m[2] ) {

  1019 									r = [ this ];

  1020 									return false;

  1021 								}

  1022 							});

  1023 						}

  1024 

  1025 						ret = r;

  1026 					}

  1027 

  1028 					t = t.replace( re2, "" );

  1029 				}

  1030 

  1031 			}

  1032 

  1033 			// If a selector string still exists

  1034 			if ( t ) {

  1035 				// Attempt to filter it

  1036 				var val = jQuery.filter(t,r);

  1037 				ret = r = val.r;

  1038 				t = jQuery.trim(val.t);

  1039 			}

  1040 		}

  1041 

  1042 		// Remove the root context

  1043 		if ( ret && ret[0] == context ) ret.shift();

  1044 

  1045 		// And combine the results

  1046 		jQuery.merge( done, ret );

  1047 

  1048 		return done;

  1049 	},

  1050 

  1051 	filter: function(t,r,not) {

  1052 		// Look for common filter expressions

  1053 		while ( t && /^[a-z[({<*:.#]/i.test(t) ) {

  1054 

  1055 			var p = jQuery.parse, m;

  1056 

  1057 			jQuery.each( p, function(i,re){

  1058 		

  1059 				// Look for, and replace, string-like sequences

  1060 				// and finally build a regexp out of it

  1061 				m = re.exec( t );

  1062 

  1063 				if ( m ) {

  1064 					// Remove what we just matched

  1065 					t = t.substring( m[0].length );

  1066 

  1067 					// Re-organize the first match

  1068 					if ( jQuery.expr[ m[1] ]._resort )

  1069 						m = jQuery.expr[ m[1] ]._resort( m );

  1070 

  1071 					return false;

  1072 				}

  1073 			});

  1074 

  1075 			// :not() is a special case that can be optimized by

  1076 			// keeping it out of the expression list

  1077 			if ( m[1] == ":" && m[2] == "not" )

  1078 				r = jQuery.filter(m[3], r, true).r;

  1079 

  1080 			// Handle classes as a special case (this will help to

  1081 			// improve the speed, as the regexp will only be compiled once)

  1082 			else if ( m[1] == "." ) {

  1083 

  1084 				var re = new RegExp("(^|\\s)" + m[2] + "(\\s|$)");

  1085 				r = jQuery.grep( r, function(e){

  1086 					return re.test(e.className || "");

  1087 				}, not);

  1088 

  1089 			// Otherwise, find the expression to execute

  1090 			} else {

  1091 				var f = jQuery.expr[m[1]];

  1092 				if ( typeof f != "string" )

  1093 					f = jQuery.expr[m[1]][m[2]];

  1094 

  1095 				// Build a custom macro to enclose it

  1096 				eval("f = function(a,i){" +

  1097 					( jQuery.expr[ m[1] ]._prefix || "" ) +

  1098 					"return " + f + "}");

  1099 

  1100 				// Execute it against the current filter

  1101 				r = jQuery.grep( r, f, not );

  1102 			}

  1103 		}

  1104 

  1105 		// Return an array of filtered elements (r)

  1106 		// and the modified expression string (t)

  1107 		return { r: r, t: t };

  1108 	},

  1109 	

  1110 	getAll: function( o, r, token, name, re ) {

  1111 		for ( var s = o.firstChild; s; s = s.nextSibling )

  1112 			if ( s.nodeType == 1 ) {

  1113 				var add = true;

  1114 

  1115 				if ( token == "." )

  1116 					add = s.className && re.test(s.className);

  1117 				else if ( token == "#" )

  1118 					add = s.getAttribute("id") == name;

  1119 	

  1120 				if ( add )

  1121 					r.push( s );

  1122 

  1123 				if ( token == "#" && r.length ) break;

  1124 

  1125 				if ( s.firstChild )

  1126 					jQuery.getAll( s, r, token, name, re );

  1127 			}

  1128 

  1129 		return r;

  1130 	},

  1131 	parents: function( elem ){

  1132 		var matched = [];

  1133 		var cur = elem.parentNode;

  1134 		while ( cur && cur != document ) {

  1135 			matched.push( cur );