treeview.patch

Colin Gormley, 04/01/2011 11:55 am

Download (230.4 kB)

 
modified/dspace-xmlui/dspace-xmlui-api/src/main/resources/aspects/BrowseArtifacts/sitemap.xmap 2011-03-23 14:24:16.000000000 +0000
74 74

  
75 75
            <map:match pattern="">
76 76
                <map:transform type="CommunityBrowser">
77
                        <map:parameter name="depth" value="1"/>
77
                        <map:parameter name="depth" value="999"/>
78 78
                </map:transform>
79 79
                <map:serialize type="xml"/>
80 80
            </map:match>
modified/dspace-xmlui/dspace-xmlui-webapp/src/main/webapp/themes/Reference/images/treeview/ajax-loader.gif 2011-03-23 14:24:16.000000000 +0000
1
GIF89a888&&&֨vvvfff䘘HHHVVV!Created with ajaxload.info!
2
!NETSCAPE2.0,P  di0l!*`Ƒ5و[<iP),IZ$bH85&x5k <yB!
3
,h  GҌh*ਨ@$E}eh @
4
LcQGBP5 <5UdQ+"g0Ak#A<P70<	0Y8*
	#!!
5
,`  #(H*
6
P	-13
7
:C1KHH.$ٱyj.WD@Y0H	,0B
8
kJU?5w|$k
\)!!
9
,R  di 1@Ck!B`?#E8zBQXcmv" £``
UFrp)f!!
10
,`  di@E1m]ǹHІ(4 (,F!aHXSm5bDHab,
11
%p3c#'
"467P&*X/($!!
12
,_  diH@@4²A"I`>nI0$K7
H,-t*E-``1@C7h/1f\)&!;
modified/dspace-xmlui/dspace-xmlui-webapp/src/main/webapp/themes/Reference/images/treeview/file.gif 2011-03-23 14:24:16.000000000 +0000
1
GIF89ajlbAԽ|9tmp|_,;X%ܬPƤ7i4e'E j
2
dq56p1tJU$;
modified/dspace-xmlui/dspace-xmlui-webapp/src/main/webapp/themes/Reference/images/treeview/folder-closed.gif 2011-03-23 14:24:16.000000000 +0000
1
GIF89aZx➭s-҃h$Ç4,6H`KPl\
2
2jLEkuÅalV;
modified/dspace-xmlui/dspace-xmlui-webapp/src/main/webapp/themes/Reference/images/treeview/folder.gif 2011-03-23 14:24:16.000000000 +0000
1
GIF89aZx➭s-҃h$Ç4,7H`KPl\:pL)e9@\"l:+PB;
modified/dspace-xmlui/dspace-xmlui-webapp/src/main/webapp/themes/Reference/images/treeview/minus.gif 2011-03-23 14:24:16.000000000 +0000
1
GIF89a		!,		"H"<paHaE
  ;
modified/dspace-xmlui/dspace-xmlui-webapp/src/main/webapp/themes/Reference/images/treeview/plus.gif 2011-03-23 14:24:16.000000000 +0000
1
GIF89a		!,		&HpPA81a
/>̈0#A;
modified/dspace-xmlui/dspace-xmlui-webapp/src/main/webapp/themes/Reference/images/treeview/treeview-black-line.gif 2011-03-23 14:24:16.000000000 +0000
1
GIF89a!,	
"\XB	B(p"E1:ǏR8r G%<0ʒ,$L6s	SgO#oVEnTڑ)ʟP=:5iեWf}*5*UVb,ׯ]Ӣ]Vm[cƅ[Vn]gꝻn߼|xˆ[nUl2:;oe—gLqş=w~thҧ)skͯ9=Zumַ]熽[PڳEGtƇVn缡~Iܥسkν{W|s^y*:?_zrW ~*8
B I^ZHx"f8%&c.(cˆc;bx@($A9$=vE"dOeSx$WJ%[ZiNvi#X\ejeyiҹfxΙg{ީ|gj}"*2zhbBڦv:j)br(U^
2
jNZj꣩zjnk~*ʚ+ڪd[+L[,˺zmRbkr묶Ւ{٢{»KJo;/[0+<
C0J_[L"g<%'s.,sÌs;c|@,4A=4=wE#tOuS|4WK5[[mNwm3X\uje}iӽvxϝw{|wn}#.3~xbC޶v;n9cs8U_zO^z型髣~zo{:˞;ۮt_꿓;L_<˻~}Sc{sՓ٣ÿOK?_#@Ѐ
=	2pAr!'pCT?τ%L`+ʰ!#CP@2iD"=`OXD$61O\a[8WbE+N
i;
modified/dspace-xmlui/dspace-xmlui-webapp/src/main/webapp/themes/Reference/images/treeview/treeview-black.gif 2011-03-23 14:24:16.000000000 +0000
1
GIF89a`!,`	H*\BlHŋ#bȱEC	rɓ(S<	Õ0I,ǁ iܹ0'N@FteУ
2
ԉϥMB5TNFZ)׮A)vͲfcMZ8QKs/E7o߼`r#x1211希/c~r῝99z$ҢQs<Zik_0߻Y5o7ds6ix%gSO͎3Ëg{6|qcPɷu]~G߂6`}ؙcaH=
3
7|#
4
EM~%x'݇4hcmr؜~֣(d:-&p2K+*1"9%3ި\v`;
modified/dspace-xmlui/dspace-xmlui-webapp/src/main/webapp/themes/Reference/images/treeview/treeview-default-line.gif 2011-03-23 14:24:16.000000000 +0000
1
GIF89a!,	HA*\x0!ÇBHP"E	3xaNj?2)R!ɒOrdˈ/M8ʗ7[\eϒ?E8cQ5m&eaSOb|ԉW!f}eT`mإeeM&ٰol.Zl;R}4ỀƹXgc}F:Yhej̹3H34dӒQSVm5fFAOp^ڳmōUvoZ}W݁EXZ棡~zj뫱{ln{-FpW\r?tx!~ᝧ yFރIXaq8yx8x	¸6V昡١"#Y'2+B٢/R3"Y#7ȥ^y?CYK٤OSYW♥I~	mq":u2zyBgeRzib顟&ꢣ6Z꣧Fꤜ
2
j*j⪪**lZlllFkR>,Nm^nn;n+k.+o;okoVڪܬ"\2\B/Kc\sܰ[\1gܱ#\'2+1=5#}93=CAK=t/[]5Es}IMQ=*
Tt]vj_}owց]݇8߃w׏ؓ]ٗڋw
>#3^:{C^Sc޻s^x3<œͣӳ^ϋ~ٛ=^㞾޾o<<H=Zπ=s$>
3
ςà4?
4
?3P@Ѕe@.
qANЇA"nЈDBp pfJyN*C2R%4c
јB5損-tcxC9>*aE>vQ?d9DBѐGDdDF6яtFI~m5YFNqAYGQ{4QHVҕ!eHZ.)H@;
modified/dspace-xmlui/dspace-xmlui-webapp/src/main/webapp/themes/Reference/images/treeview/treeview-default.gif 2011-03-23 14:24:16.000000000 +0000
1
GIF89a`!,`	H*\BlHŋ#bȱEC	rɓ(S<K+cp̛m:φ:AI!M\Z)<J}:PԫCfW`ÊU:Y[Ϫ];2-[oDIrѭުK!EP1㎎t,S#cys暞9nŦSDI֦^(vܻ	q3;pm8r"TcdcܣOy\9w]v5eU]9߀'xE('aHnq["$!ؠ)8e	_p3v<5"| aFF2dO"U.VfPWl[$`)d9[@;
modified/dspace-xmlui/dspace-xmlui-webapp/src/main/webapp/themes/Reference/images/treeview/treeview-famfamfam-line.gif 2011-03-23 14:24:16.000000000 +0000
1
GIF89a!,;
modified/dspace-xmlui/dspace-xmlui-webapp/src/main/webapp/themes/Reference/images/treeview/treeview-famfamfam.gif 2011-03-23 14:24:16.000000000 +0000
1
GIF89a`1k9s!Bs!R1scBJZZ!k!s{cc{Bs֔ƭҤޥ筌絔ﵔҵ!,`	H*\BlHŋ#bȱEC	rɓ(S\ɲ˗0cʜ)B&ܙB
2
x(A(tp@ѧH;HthjQ	PJ+O	`۷pʝK.͒v[[qć|7
r0È+^̸	$c8DP2 0`!8Hi	"0X1$e!K
ȓ+~FֳkνU8ur	,wJ:ujXr]XѪe뽿8vDM1A(^NݑP%TW)wmb}aa~iU0xX|)h >(D$d]fmhݦ]j]l&ev[!YdR=!`ұip)県IvJjٕVwTJefw]%wv裐F*;
modified/dspace-xmlui/dspace-xmlui-webapp/src/main/webapp/themes/Reference/images/treeview/treeview-gray-line.gif 2011-03-23 14:24:16.000000000 +0000
1
GIF89a!,	/
"\XB	B(p"E1:0ǏR8r G%<0ʒ,$L6s	SgO#oVEnTڑ)ʟP=:5iեWf}*5*UVb,ׯ]Ӣ]Vm[cƅ[Vn]gꝻn߼|xˆ[nUl2:;oe—gLqş=w~thҧ)skͯ9=Zumַ]熽[PڳEGtƇVn缡~Iܥسkν{W|s^y*:?_zrW ~*8
B I^ZHx"f8%&c.(cˆc;bx@($A9$=vE"dOeSx$WJ%[ZiNvi#X\ejeyiҹfxΙg{ީ|gj}"*2zhbBڦv:j)br(U^
2
jNZj꣩zjnk~*ʚ+ڪd[+L[,˺zmRbkr묶Ւ{٢{»KJo;/[0+<
C0J_[L"g<%'s.,sÌs;c|@,4A=4=wE#tOuS|4WK5[[mNwm3X\uje}iӽvxϝw{|wn}#.3~xbC޶v;n9cs8U_zO^z型髣~zo{:˞;ۮt_꿓;L_<˻~}Sc{sՓ٣ÿOK?_#@Ѐ
=	2pAr!'pCT?τ%L`+ʰ!#CP@2iD"=`OXD$61O\a[8WbE+N
i;
modified/dspace-xmlui/dspace-xmlui-webapp/src/main/webapp/themes/Reference/images/treeview/treeview-gray.gif 2011-03-23 14:24:16.000000000 +0000
1
GIF89a`!,`	H*\BlHŋ#bȱEC	rɓ(S<K+cp̛m:φ:AI!MZhPM|*T5j]Rת_Â*YgUfImeDIރs
2
L8-WGZ3BxҮ/>q3g?;>X4Ҧ)N}u_הaw\
;0m׶SMMUI#\wjJ(TzsZ4w뾙'ӫ7}{Ӗy-|}_}=ym7Pu}W vi'18x)߄VhNq6qgaX
B"R)"ȹ8t
h<uX7RXqK$lO߁8>XWfIGu_za>ih;
modified/dspace-xmlui/dspace-xmlui-webapp/src/main/webapp/themes/Reference/images/treeview/treeview-red-line.gif 2011-03-23 14:24:16.000000000 +0000
1
GIF89avv!,	/
"\XB	B(p"E1:0ǏR8r G%<0ʒ,$L6s	SgO#oVEnTڑ)ʟP=:5iեWf}*5*UVb,ׯ]Ӣ]Vm[cƅ[Vn]gꝻn߼|xˆ[nUl2:;oe—gLqş=w~thҧ)skͯ9=Zumַ]熽[PڳEGtƇVn缡~Iܥسkν{W|s^y*:?_zrW ~*8
B I^ZHx"f8%&c.(cˆc;bx@($A9$=vE"dOeSx$WJ%[ZiNvi#X\ejeyiҹfxΙg{ީ|gj}"*2zhbBڦv:j)br(U^
2
jNZj꣩zjnk~*ʚ+ڪd[+L[,˺zmRbkr묶Ւ{٢{»KJo;/[0+<
C0J_[L"g<%'s.,sÌs;c|@,4A=4=wE#tOuS|4WK5[[mNwm3X\uje}iӽvxϝw{|wn}#.3~xbC޶v;n9cs8U_zO^z型髣~zo{:˞;ۮt_꿓;L_<˻~}Sc{sՓ٣ÿOK?_#@Ѐ
=	2pAr!'pCT?τ%L`+ʰ!#CP@2iD"=`OXD$61O\a[8WbE+N
i;
modified/dspace-xmlui/dspace-xmlui-webapp/src/main/webapp/themes/Reference/images/treeview/treeview-red.gif 2011-03-23 14:24:16.000000000 +0000
1
GIF89a`vv!,`	H*\BlHŋ#bȱEC	rɓ(S<K+cp̛m:φ:AI!MZhPM|*T5j]Rת_Â*YgUfImeDIރs
2
L8-WGZ3BxҮ/>q3g?;>X4Ҧ)N}u_הaw\
;0m׶SMMUI#\wjJ(TzsZ4w뾙'ӫ7}{Ӗy-|}_}=ym7Pu}W vi'18x)߄VhNq6qgaX
B"R)"ȹ8t
h<uX7RXqK$lO߁8>XWfIGu_za>ih;
modified/dspace-xmlui/dspace-xmlui-webapp/src/main/webapp/themes/Reference/lib/jquery/jquery.js 2011-03-23 14:24:16.000000000 +0000
1
/*!
2
 * jQuery JavaScript Library v1.4.3
3
 * http://jquery.com/
4
 *
5
 * Copyright 2010, John Resig
6
 * Dual licensed under the MIT or GPL Version 2 licenses.
7
 * http://jquery.org/license
8
 *
9
 * Includes Sizzle.js
10
 * http://sizzlejs.com/
11
 * Copyright 2010, The Dojo Foundation
12
 * Released under the MIT, BSD, and GPL Licenses.
13
 *
14
 * Date: Thu Oct 14 23:10:06 2010 -0400
15
 */
16
(function( window, undefined ) {
17

  
18
// Use the correct document accordingly with window argument (sandbox)
19
var document = window.document;
20
var jQuery = (function() {
21

  
22
// Define a local copy of jQuery
23
var jQuery = function( selector, context ) {
24
		// The jQuery object is actually just the init constructor 'enhanced'
25
		return new jQuery.fn.init( selector, context );
26
	},
27

  
28
	// Map over jQuery in case of overwrite
29
	_jQuery = window.jQuery,
30

  
31
	// Map over the $ in case of overwrite
32
	_$ = window.$,
33

  
34
	// A central reference to the root jQuery(document)
35
	rootjQuery,
36

  
37
	// A simple way to check for HTML strings or ID strings
38
	// (both of which we optimize for)
39
	quickExpr = /^(?:[^<]*(<[\w\W]+>)[^>]*$|#([\w\-]+)$)/,
40

  
41
	// Is it a simple selector
42
	isSimple = /^.[^:#\[\.,]*$/,
43

  
44
	// Check if a string has a non-whitespace character in it
45
	rnotwhite = /\S/,
46
	rwhite = /\s/,
47

  
48
	// Used for trimming whitespace
49
	trimLeft = /^\s+/,
50
	trimRight = /\s+$/,
51

  
52
	// Check for non-word characters
53
	rnonword = /\W/,
54

  
55
	// Check for digits
56
	rdigit = /\d/,
57

  
58
	// Match a standalone tag
59
	rsingleTag = /^<(\w+)\s*\/?>(?:<\/\1>)?$/,
60

  
61
	// JSON RegExp
62
	rvalidchars = /^[\],:{}\s]*$/,
63
	rvalidescape = /\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g,
64
	rvalidtokens = /"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g,
65
	rvalidbraces = /(?:^|:|,)(?:\s*\[)+/g,
66

  
67
	// Useragent RegExp
68
	rwebkit = /(webkit)[ \/]([\w.]+)/,
69
	ropera = /(opera)(?:.*version)?[ \/]([\w.]+)/,
70
	rmsie = /(msie) ([\w.]+)/,
71
	rmozilla = /(mozilla)(?:.*? rv:([\w.]+))?/,
72

  
73
	// Keep a UserAgent string for use with jQuery.browser
74
	userAgent = navigator.userAgent,
75

  
76
	// For matching the engine and version of the browser
77
	browserMatch,
78
	
79
	// Has the ready events already been bound?
80
	readyBound = false,
81
	
82
	// The functions to execute on DOM ready
83
	readyList = [],
84

  
85
	// The ready event handler
86
	DOMContentLoaded,
87

  
88
	// Save a reference to some core methods
89
	toString = Object.prototype.toString,
90
	hasOwn = Object.prototype.hasOwnProperty,
91
	push = Array.prototype.push,
92
	slice = Array.prototype.slice,
93
	trim = String.prototype.trim,
94
	indexOf = Array.prototype.indexOf,
95
	
96
	// [[Class]] -> type pairs
97
	class2type = {};
98

  
99
jQuery.fn = jQuery.prototype = {
100
	init: function( selector, context ) {
101
		var match, elem, ret, doc;
102

  
103
		// Handle $(""), $(null), or $(undefined)
104
		if ( !selector ) {
105
			return this;
106
		}
107

  
108
		// Handle $(DOMElement)
109
		if ( selector.nodeType ) {
110
			this.context = this[0] = selector;
111
			this.length = 1;
112
			return this;
113
		}
114
		
115
		// The body element only exists once, optimize finding it
116
		if ( selector === "body" && !context && document.body ) {
117
			this.context = document;
118
			this[0] = document.body;
119
			this.selector = "body";
120
			this.length = 1;
121
			return this;
122
		}
123

  
124
		// Handle HTML strings
125
		if ( typeof selector === "string" ) {
126
			// Are we dealing with HTML string or an ID?
127
			match = quickExpr.exec( selector );
128

  
129
			// Verify a match, and that no context was specified for #id
130
			if ( match && (match[1] || !context) ) {
131

  
132
				// HANDLE: $(html) -> $(array)
133
				if ( match[1] ) {
134
					doc = (context ? context.ownerDocument || context : document);
135

  
136
					// If a single string is passed in and it's a single tag
137
					// just do a createElement and skip the rest
138
					ret = rsingleTag.exec( selector );
139

  
140
					if ( ret ) {
141
						if ( jQuery.isPlainObject( context ) ) {
142
							selector = [ document.createElement( ret[1] ) ];
143
							jQuery.fn.attr.call( selector, context, true );
144

  
145
						} else {
146
							selector = [ doc.createElement( ret[1] ) ];
147
						}
148

  
149
					} else {
150
						ret = jQuery.buildFragment( [ match[1] ], [ doc ] );
151
						selector = (ret.cacheable ? ret.fragment.cloneNode(true) : ret.fragment).childNodes;
152
					}
153
					
154
					return jQuery.merge( this, selector );
155
					
156
				// HANDLE: $("#id")
157
				} else {
158
					elem = document.getElementById( match[2] );
159

  
160
					// Check parentNode to catch when Blackberry 4.6 returns
161
					// nodes that are no longer in the document #6963
162
					if ( elem && elem.parentNode ) {
163
						// Handle the case where IE and Opera return items
164
						// by name instead of ID
165
						if ( elem.id !== match[2] ) {
166
							return rootjQuery.find( selector );
167
						}
168

  
169
						// Otherwise, we inject the element directly into the jQuery object
170
						this.length = 1;
171
						this[0] = elem;
172
					}
173

  
174
					this.context = document;
175
					this.selector = selector;
176
					return this;
177
				}
178

  
179
			// HANDLE: $("TAG")
180
			} else if ( !context && !rnonword.test( selector ) ) {
181
				this.selector = selector;
182
				this.context = document;
183
				selector = document.getElementsByTagName( selector );
184
				return jQuery.merge( this, selector );
185

  
186
			// HANDLE: $(expr, $(...))
187
			} else if ( !context || context.jquery ) {
188
				return (context || rootjQuery).find( selector );
189

  
190
			// HANDLE: $(expr, context)
191
			// (which is just equivalent to: $(context).find(expr)
192
			} else {
193
				return jQuery( context ).find( selector );
194
			}
195

  
196
		// HANDLE: $(function)
197
		// Shortcut for document ready
198
		} else if ( jQuery.isFunction( selector ) ) {
199
			return rootjQuery.ready( selector );
200
		}
201

  
202
		if (selector.selector !== undefined) {
203
			this.selector = selector.selector;
204
			this.context = selector.context;
205
		}
206

  
207
		return jQuery.makeArray( selector, this );
208
	},
209

  
210
	// Start with an empty selector
211
	selector: "",
212

  
213
	// The current version of jQuery being used
214
	jquery: "1.4.3",
215

  
216
	// The default length of a jQuery object is 0
217
	length: 0,
218

  
219
	// The number of elements contained in the matched element set
220
	size: function() {
221
		return this.length;
222
	},
223

  
224
	toArray: function() {
225
		return slice.call( this, 0 );
226
	},
227

  
228
	// Get the Nth element in the matched element set OR
229
	// Get the whole matched element set as a clean array
230
	get: function( num ) {
231
		return num == null ?
232

  
233
			// Return a 'clean' array
234
			this.toArray() :
235

  
236
			// Return just the object
237
			( num < 0 ? this.slice(num)[ 0 ] : this[ num ] );
238
	},
239

  
240
	// Take an array of elements and push it onto the stack
241
	// (returning the new matched element set)
242
	pushStack: function( elems, name, selector ) {
243
		// Build a new jQuery matched element set
244
		var ret = jQuery();
245

  
246
		if ( jQuery.isArray( elems ) ) {
247
			push.apply( ret, elems );
248
		
249
		} else {
250
			jQuery.merge( ret, elems );
251
		}
252

  
253
		// Add the old object onto the stack (as a reference)
254
		ret.prevObject = this;
255

  
256
		ret.context = this.context;
257

  
258
		if ( name === "find" ) {
259
			ret.selector = this.selector + (this.selector ? " " : "") + selector;
260
		} else if ( name ) {
261
			ret.selector = this.selector + "." + name + "(" + selector + ")";
262
		}
263

  
264
		// Return the newly-formed element set
265
		return ret;
266
	},
267

  
268
	// Execute a callback for every element in the matched set.
269
	// (You can seed the arguments with an array of args, but this is
270
	// only used internally.)
271
	each: function( callback, args ) {
272
		return jQuery.each( this, callback, args );
273
	},
274
	
275
	ready: function( fn ) {
276
		// Attach the listeners
277
		jQuery.bindReady();
278

  
279
		// If the DOM is already ready
280
		if ( jQuery.isReady ) {
281
			// Execute the function immediately
282
			fn.call( document, jQuery );
283

  
284
		// Otherwise, remember the function for later
285
		} else if ( readyList ) {
286
			// Add the function to the wait list
287
			readyList.push( fn );
288
		}
289

  
290
		return this;
291
	},
292
	
293
	eq: function( i ) {
294
		return i === -1 ?
295
			this.slice( i ) :
296
			this.slice( i, +i + 1 );
297
	},
298

  
299
	first: function() {
300
		return this.eq( 0 );
301
	},
302

  
303
	last: function() {
304
		return this.eq( -1 );
305
	},
306

  
307
	slice: function() {
308
		return this.pushStack( slice.apply( this, arguments ),
309
			"slice", slice.call(arguments).join(",") );
310
	},
311

  
312
	map: function( callback ) {
313
		return this.pushStack( jQuery.map(this, function( elem, i ) {
314
			return callback.call( elem, i, elem );
315
		}));
316
	},
317
	
318
	end: function() {
319
		return this.prevObject || jQuery(null);
320
	},
321

  
322
	// For internal use only.
323
	// Behaves like an Array's method, not like a jQuery method.
324
	push: push,
325
	sort: [].sort,
326
	splice: [].splice
327
};
328

  
329
// Give the init function the jQuery prototype for later instantiation
330
jQuery.fn.init.prototype = jQuery.fn;
331

  
332
jQuery.extend = jQuery.fn.extend = function() {
333
	// copy reference to target object
334
	var target = arguments[0] || {}, i = 1, length = arguments.length, deep = false, options, name, src, copy, copyIsArray;
335

  
336
	// Handle a deep copy situation
337
	if ( typeof target === "boolean" ) {
338
		deep = target;
339
		target = arguments[1] || {};
340
		// skip the boolean and the target
341
		i = 2;
342
	}
343

  
344
	// Handle case when target is a string or something (possible in deep copy)
345
	if ( typeof target !== "object" && !jQuery.isFunction(target) ) {
346
		target = {};
347
	}
348

  
349
	// extend jQuery itself if only one argument is passed
350
	if ( length === i ) {
351
		target = this;
352
		--i;
353
	}
354

  
355
	for ( ; i < length; i++ ) {
356
		// Only deal with non-null/undefined values
357
		if ( (options = arguments[ i ]) != null ) {
358
			// Extend the base object
359
			for ( name in options ) {
360
				src = target[ name ];
361
				copy = options[ name ];
362

  
363
				// Prevent never-ending loop
364
				if ( target === copy ) {
365
					continue;
366
				}
367

  
368
				// Recurse if we're merging plain objects or arrays
369
				if ( deep && copy && ( jQuery.isPlainObject(copy) || (copyIsArray = jQuery.isArray(copy)) ) ) {
370
					if ( copyIsArray ) {
371
						copyIsArray = false;
372
						clone = src && jQuery.isArray(src) ? src : [];
373

  
374
					} else {
375
						clone = src && jQuery.isPlainObject(src) ? src : {};
376
					}
377

  
378
					// Never move original objects, clone them
379
					target[ name ] = jQuery.extend( deep, clone, copy );
380

  
381
				// Don't bring in undefined values
382
				} else if ( copy !== undefined ) {
383
					target[ name ] = copy;
384
				}
385
			}
386
		}
387
	}
388

  
389
	// Return the modified object
390
	return target;
391
};
392

  
393
jQuery.extend({
394
	noConflict: function( deep ) {
395
		window.$ = _$;
396

  
397
		if ( deep ) {
398
			window.jQuery = _jQuery;
399
		}
400

  
401
		return jQuery;
402
	},
403
	
404
	// Is the DOM ready to be used? Set to true once it occurs.
405
	isReady: false,
406

  
407
	// A counter to track how many items to wait for before
408
	// the ready event fires. See #6781
409
	readyWait: 1,
410
	
411
	// Handle when the DOM is ready
412
	ready: function( wait ) {
413
		// A third-party is pushing the ready event forwards
414
		if ( wait === true ) {
415
			jQuery.readyWait--;
416
		}
417

  
418
		// Make sure that the DOM is not already loaded
419
		if ( !jQuery.readyWait || (wait !== true && !jQuery.isReady) ) {
420
			// Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
421
			if ( !document.body ) {
422
				return setTimeout( jQuery.ready, 1 );
423
			}
424

  
425
			// Remember that the DOM is ready
426
			jQuery.isReady = true;
427

  
428
			// If a normal DOM Ready event fired, decrement, and wait if need be
429
			if ( wait !== true && --jQuery.readyWait > 0 ) {
430
				return;
431
			}
432

  
433
			// If there are functions bound, to execute
434
			if ( readyList ) {
435
				// Execute all of them
436
				var fn, i = 0;
437
				while ( (fn = readyList[ i++ ]) ) {
438
					fn.call( document, jQuery );
439
				}
440

  
441
				// Reset the list of functions
442
				readyList = null;
443
			}
444

  
445
			// Trigger any bound ready events
446
			if ( jQuery.fn.triggerHandler ) {
447
				jQuery( document ).triggerHandler( "ready" );
448
			}
449
		}
450
	},
451
	
452
	bindReady: function() {
453
		if ( readyBound ) {
454
			return;
455
		}
456

  
457
		readyBound = true;
458

  
459
		// Catch cases where $(document).ready() is called after the
460
		// browser event has already occurred.
461
		if ( document.readyState === "complete" ) {
462
			// Handle it asynchronously to allow scripts the opportunity to delay ready
463
			return setTimeout( jQuery.ready, 1 );
464
		}
465

  
466
		// Mozilla, Opera and webkit nightlies currently support this event
467
		if ( document.addEventListener ) {
468
			// Use the handy event callback
469
			document.addEventListener( "DOMContentLoaded", DOMContentLoaded, false );
470
			
471
			// A fallback to window.onload, that will always work
472
			window.addEventListener( "load", jQuery.ready, false );
473

  
474
		// If IE event model is used
475
		} else if ( document.attachEvent ) {
476
			// ensure firing before onload,
477
			// maybe late but safe also for iframes
478
			document.attachEvent("onreadystatechange", DOMContentLoaded);
479
			
480
			// A fallback to window.onload, that will always work
481
			window.attachEvent( "onload", jQuery.ready );
482

  
483
			// If IE and not a frame
484
			// continually check to see if the document is ready
485
			var toplevel = false;
486

  
487
			try {
488
				toplevel = window.frameElement == null;
489
			} catch(e) {}
490

  
491
			if ( document.documentElement.doScroll && toplevel ) {
492
				doScrollCheck();
493
			}
494
		}
495
	},
496

  
497
	// See test/unit/core.js for details concerning isFunction.
498
	// Since version 1.3, DOM methods and functions like alert
499
	// aren't supported. They return false on IE (#2968).
500
	isFunction: function( obj ) {
501
		return jQuery.type(obj) === "function";
502
	},
503

  
504
	isArray: Array.isArray || function( obj ) {
505
		return jQuery.type(obj) === "array";
506
	},
507

  
508
	// A crude way of determining if an object is a window
509
	isWindow: function( obj ) {
510
		return obj && typeof obj === "object" && "setInterval" in obj;
511
	},
512

  
513
	isNaN: function( obj ) {
514
		return obj == null || !rdigit.test( obj ) || isNaN( obj );
515
	},
516

  
517
	type: function( obj ) {
518
		return obj == null ?
519
			String( obj ) :
520
			class2type[ toString.call(obj) ] || "object";
521
	},
522

  
523
	isPlainObject: function( obj ) {
524
		// Must be an Object.
525
		// Because of IE, we also have to check the presence of the constructor property.
526
		// Make sure that DOM nodes and window objects don't pass through, as well
527
		if ( !obj || jQuery.type(obj) !== "object" || obj.nodeType || jQuery.isWindow( obj ) ) {
528
			return false;
529
		}
530
		
531
		// Not own constructor property must be Object
532
		if ( obj.constructor &&
533
			!hasOwn.call(obj, "constructor") &&
534
			!hasOwn.call(obj.constructor.prototype, "isPrototypeOf") ) {
535
			return false;
536
		}
537
		
538
		// Own properties are enumerated firstly, so to speed up,
539
		// if last one is own, then all properties are own.
540
	
541
		var key;
542
		for ( key in obj ) {}
543
		
544
		return key === undefined || hasOwn.call( obj, key );
545
	},
546

  
547
	isEmptyObject: function( obj ) {
548
		for ( var name in obj ) {
549
			return false;
550
		}
551
		return true;
552
	},
553
	
554
	error: function( msg ) {
555
		throw msg;
556
	},
557
	
558
	parseJSON: function( data ) {
559
		if ( typeof data !== "string" || !data ) {
560
			return null;
561
		}
562

  
563
		// Make sure leading/trailing whitespace is removed (IE can't handle it)
564
		data = jQuery.trim( data );
565
		
566
		// Make sure the incoming data is actual JSON
567
		// Logic borrowed from http://json.org/json2.js
568
		if ( rvalidchars.test(data.replace(rvalidescape, "@")
569
			.replace(rvalidtokens, "]")
570
			.replace(rvalidbraces, "")) ) {
571

  
572
			// Try to use the native JSON parser first
573
			return window.JSON && window.JSON.parse ?
574
				window.JSON.parse( data ) :
575
				(new Function("return " + data))();
576

  
577
		} else {
578
			jQuery.error( "Invalid JSON: " + data );
579
		}
580
	},
581

  
582
	noop: function() {},
583

  
584
	// Evalulates a script in a global context
585
	globalEval: function( data ) {
586
		if ( data && rnotwhite.test(data) ) {
587
			// Inspired by code by Andrea Giammarchi
588
			// http://webreflection.blogspot.com/2007/08/global-scope-evaluation-and-dom.html
589
			var head = document.getElementsByTagName("head")[0] || document.documentElement,
590
				script = document.createElement("script");
591

  
592
			script.type = "text/javascript";
593

  
594
			if ( jQuery.support.scriptEval ) {
595
				script.appendChild( document.createTextNode( data ) );
596
			} else {
597
				script.text = data;
598
			}
599

  
600
			// Use insertBefore instead of appendChild to circumvent an IE6 bug.
601
			// This arises when a base node is used (#2709).
602
			head.insertBefore( script, head.firstChild );
603
			head.removeChild( script );
604
		}
605
	},
606

  
607
	nodeName: function( elem, name ) {
608
		return elem.nodeName && elem.nodeName.toUpperCase() === name.toUpperCase();
609
	},
610

  
611
	// args is for internal usage only
612
	each: function( object, callback, args ) {
613
		var name, i = 0,
614
			length = object.length,
615
			isObj = length === undefined || jQuery.isFunction(object);
616

  
617
		if ( args ) {
618
			if ( isObj ) {
619
				for ( name in object ) {
620
					if ( callback.apply( object[ name ], args ) === false ) {
621
						break;
622
					}
623
				}
624
			} else {
625
				for ( ; i < length; ) {
626
					if ( callback.apply( object[ i++ ], args ) === false ) {
627
						break;
628
					}
629
				}
630
			}
631

  
632
		// A special, fast, case for the most common use of each
633
		} else {
634
			if ( isObj ) {
635
				for ( name in object ) {
636
					if ( callback.call( object[ name ], name, object[ name ] ) === false ) {
637
						break;
638
					}
639
				}
640
			} else {
641
				for ( var value = object[0];
642
					i < length && callback.call( value, i, value ) !== false; value = object[++i] ) {}
643
			}
644
		}
645

  
646
		return object;
647
	},
648

  
649
	// Use native String.trim function wherever possible
650
	trim: trim ?
651
		function( text ) {
652
			return text == null ?
653
				"" :
654
				trim.call( text );
655
		} :
656

  
657
		// Otherwise use our own trimming functionality
658
		function( text ) {
659
			return text == null ?
660
				"" :
661
				text.toString().replace( trimLeft, "" ).replace( trimRight, "" );
662
		},
663

  
664
	// results is for internal usage only
665
	makeArray: function( array, results ) {
666
		var ret = results || [];
667

  
668
		if ( array != null ) {
669
			// The window, strings (and functions) also have 'length'
670
			// The extra typeof function check is to prevent crashes
671
			// in Safari 2 (See: #3039)
672
			// Tweaked logic slightly to handle Blackberry 4.7 RegExp issues #6930
673
			var type = jQuery.type(array);
674

  
675
			if ( array.length == null || type === "string" || type === "function" || type === "regexp" || jQuery.isWindow( array ) ) {
676
				push.call( ret, array );
677
			} else {
678
				jQuery.merge( ret, array );
679
			}
680
		}
681

  
682
		return ret;
683
	},
684

  
685
	inArray: function( elem, array ) {
686
		if ( array.indexOf ) {
687
			return array.indexOf( elem );
688
		}
689

  
690
		for ( var i = 0, length = array.length; i < length; i++ ) {
691
			if ( array[ i ] === elem ) {
692
				return i;
693
			}
694
		}
695

  
696
		return -1;
697
	},
698

  
699
	merge: function( first, second ) {
700
		var i = first.length, j = 0;
701

  
702
		if ( typeof second.length === "number" ) {
703
			for ( var l = second.length; j < l; j++ ) {
704
				first[ i++ ] = second[ j ];
705
			}
706
		
707
		} else {
708
			while ( second[j] !== undefined ) {
709
				first[ i++ ] = second[ j++ ];
710
			}
711
		}
712

  
713
		first.length = i;
714

  
715
		return first;
716
	},
717

  
718
	grep: function( elems, callback, inv ) {
719
		var ret = [], retVal;
720
		inv = !!inv;
721

  
722
		// Go through the array, only saving the items
723
		// that pass the validator function
724
		for ( var i = 0, length = elems.length; i < length; i++ ) {
725
			retVal = !!callback( elems[ i ], i );
726
			if ( inv !== retVal ) {
727
				ret.push( elems[ i ] );
728
			}
729
		}
730

  
731
		return ret;
732
	},
733

  
734
	// arg is for internal usage only
735
	map: function( elems, callback, arg ) {
736
		var ret = [], value;
737

  
738
		// Go through the array, translating each of the items to their
739
		// new value (or values).
740
		for ( var i = 0, length = elems.length; i < length; i++ ) {
741
			value = callback( elems[ i ], i, arg );
742

  
743
			if ( value != null ) {
744
				ret[ ret.length ] = value;
745
			}
746
		}
747

  
748
		return ret.concat.apply( [], ret );
749
	},
750

  
751
	// A global GUID counter for objects
752
	guid: 1,
753

  
754
	proxy: function( fn, proxy, thisObject ) {
755
		if ( arguments.length === 2 ) {
756
			if ( typeof proxy === "string" ) {
757
				thisObject = fn;
758
				fn = thisObject[ proxy ];
759
				proxy = undefined;
760

  
761
			} else if ( proxy && !jQuery.isFunction( proxy ) ) {
762
				thisObject = proxy;
763
				proxy = undefined;
764
			}
765
		}
766

  
767
		if ( !proxy && fn ) {
768
			proxy = function() {
769
				return fn.apply( thisObject || this, arguments );
770
			};
771
		}
772

  
773
		// Set the guid of unique handler to the same of original handler, so it can be removed
774
		if ( fn ) {
775
			proxy.guid = fn.guid = fn.guid || proxy.guid || jQuery.guid++;
776
		}
777

  
778
		// So proxy can be declared as an argument
779
		return proxy;
780
	},
781

  
782
	// Mutifunctional method to get and set values to a collection
783
	// The value/s can be optionally by executed if its a function
784
	access: function( elems, key, value, exec, fn, pass ) {
785
		var length = elems.length;
786
	
787
		// Setting many attributes
788
		if ( typeof key === "object" ) {
789
			for ( var k in key ) {
790
				jQuery.access( elems, k, key[k], exec, fn, value );
791
			}
792
			return elems;
793
		}
794
	
795
		// Setting one attribute
796
		if ( value !== undefined ) {
797
			// Optionally, function values get executed if exec is true
798
			exec = !pass && exec && jQuery.isFunction(value);
799
		
800
			for ( var i = 0; i < length; i++ ) {
801
				fn( elems[i], key, exec ? value.call( elems[i], i, fn( elems[i], key ) ) : value, pass );
802
			}
803
		
804
			return elems;
805
		}
806
	
807
		// Getting an attribute
808
		return length ? fn( elems[0], key ) : undefined;
809
	},
810

  
811
	now: function() {
812
		return (new Date()).getTime();
813
	},
814

  
815
	// Use of jQuery.browser is frowned upon.
816
	// More details: http://docs.jquery.com/Utilities/jQuery.browser
817
	uaMatch: function( ua ) {
818
		ua = ua.toLowerCase();
819

  
820
		var match = rwebkit.exec( ua ) ||
821
			ropera.exec( ua ) ||
822
			rmsie.exec( ua ) ||
823
			ua.indexOf("compatible") < 0 && rmozilla.exec( ua ) ||
824
			[];
825

  
826
		return { browser: match[1] || "", version: match[2] || "0" };
827
	},
828

  
829
	browser: {}
830
});
831

  
832
// Populate the class2type map
833
jQuery.each("Boolean Number String Function Array Date RegExp Object".split(" "), function(i, name) {
834
	class2type[ "[object " + name + "]" ] = name.toLowerCase();
835
});
836

  
837
browserMatch = jQuery.uaMatch( userAgent );
838
if ( browserMatch.browser ) {
839
	jQuery.browser[ browserMatch.browser ] = true;
840
	jQuery.browser.version = browserMatch.version;
841
}
842

  
843
// Deprecated, use jQuery.browser.webkit instead
844
if ( jQuery.browser.webkit ) {
845
	jQuery.browser.safari = true;
846
}
847

  
848
if ( indexOf ) {
849
	jQuery.inArray = function( elem, array ) {
850
		return indexOf.call( array, elem );
851
	};
852
}
853

  
854
// Verify that \s matches non-breaking spaces
855
// (IE fails on this test)
856
if ( !rwhite.test( "\xA0" ) ) {
857
	trimLeft = /^[\s\xA0]+/;
858
	trimRight = /[\s\xA0]+$/;
859
}
860

  
861
// All jQuery objects should point back to these
862
rootjQuery = jQuery(document);
863

  
864
// Cleanup functions for the document ready method
865
if ( document.addEventListener ) {
866
	DOMContentLoaded = function() {
867
		document.removeEventListener( "DOMContentLoaded", DOMContentLoaded, false );
868
		jQuery.ready();
869
	};
870

  
871
} else if ( document.attachEvent ) {
872
	DOMContentLoaded = function() {
873
		// Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443).
874
		if ( document.readyState === "complete" ) {
875
			document.detachEvent( "onreadystatechange", DOMContentLoaded );
876
			jQuery.ready();
877
		}
878
	};
879
}
880

  
881
// The DOM ready check for Internet Explorer
882
function doScrollCheck() {
883
	if ( jQuery.isReady ) {
884
		return;
885
	}
886

  
887
	try {
888
		// If IE is used, use the trick by Diego Perini
889
		// http://javascript.nwbox.com/IEContentLoaded/
890
		document.documentElement.doScroll("left");
891
	} catch(e) {
892
		setTimeout( doScrollCheck, 1 );
893
		return;
894
	}
895

  
896
	// and execute any waiting functions
897
	jQuery.ready();
898
}
899

  
900
// Expose jQuery to the global object
901
return (window.jQuery = window.$ = jQuery);
902

  
903
})();
904

  
905

  
906
(function() {
907

  
908
	jQuery.support = {};
909

  
910
	var root = document.documentElement,
911
		script = document.createElement("script"),
912
		div = document.createElement("div"),
913
		id = "script" + jQuery.now();
914

  
915
	div.style.display = "none";
916
	div.innerHTML = "   <link/><table></table><a href='/a' style='color:red;float:left;opacity:.55;'>a</a><input type='checkbox'/>";
917

  
918
	var all = div.getElementsByTagName("*"),
919
		a = div.getElementsByTagName("a")[0],
920
		select = document.createElement("select"),
921
		opt = select.appendChild( document.createElement("option") );
922

  
923
	// Can't get basic test support
924
	if ( !all || !all.length || !a ) {
925
		return;
926
	}
927

  
928
	jQuery.support = {
929
		// IE strips leading whitespace when .innerHTML is used
930
		leadingWhitespace: div.firstChild.nodeType === 3,
931

  
932
		// Make sure that tbody elements aren't automatically inserted
933
		// IE will insert them into empty tables
934
		tbody: !div.getElementsByTagName("tbody").length,
935

  
936
		// Make sure that link elements get serialized correctly by innerHTML
937
		// This requires a wrapper element in IE
938
		htmlSerialize: !!div.getElementsByTagName("link").length,
939

  
940
		// Get the style information from getAttribute
941
		// (IE uses .cssText insted)
942
		style: /red/.test( a.getAttribute("style") ),
943

  
944
		// Make sure that URLs aren't manipulated
945
		// (IE normalizes it by default)
946
		hrefNormalized: a.getAttribute("href") === "/a",
947

  
948
		// Make sure that element opacity exists
949
		// (IE uses filter instead)
950
		// Use a regex to work around a WebKit issue. See #5145
951
		opacity: /^0.55$/.test( a.style.opacity ),
952

  
953
		// Verify style float existence
954
		// (IE uses styleFloat instead of cssFloat)
955
		cssFloat: !!a.style.cssFloat,
956

  
957
		// Make sure that if no value is specified for a checkbox
958
		// that it defaults to "on".
959
		// (WebKit defaults to "" instead)
960
		checkOn: div.getElementsByTagName("input")[0].value === "on",
961

  
962
		// Make sure that a selected-by-default option has a working selected property.
963
		// (WebKit defaults to false instead of true, IE too, if it's in an optgroup)
964
		optSelected: opt.selected,
965

  
966
		// Will be defined later
967
		optDisabled: false,
968
		checkClone: false,
969
		scriptEval: false,
970
		noCloneEvent: true,
971
		boxModel: null,
972
		inlineBlockNeedsLayout: false,
973
		shrinkWrapBlocks: false,
974
		reliableHiddenOffsets: true
975
	};
976

  
977
	// Make sure that the options inside disabled selects aren't marked as disabled
978
	// (WebKit marks them as diabled)
979
	select.disabled = true;
980
	jQuery.support.optDisabled = !opt.disabled;
981

  
982
	script.type = "text/javascript";
983
	try {
984
		script.appendChild( document.createTextNode( "window." + id + "=1;" ) );
985
	} catch(e) {}
986

  
987
	root.insertBefore( script, root.firstChild );
988

  
989
	// Make sure that the execution of code works by injecting a script
990
	// tag with appendChild/createTextNode
991
	// (IE doesn't support this, fails, and uses .text instead)
992
	if ( window[ id ] ) {
993
		jQuery.support.scriptEval = true;
994
		delete window[ id ];
995
	}
996

  
997
	root.removeChild( script );
998

  
999
	if ( div.attachEvent && div.fireEvent ) {
1000
		div.attachEvent("onclick", function click() {
1001
			// Cloning a node shouldn't copy over any
1002
			// bound event handlers (IE does this)
1003
			jQuery.support.noCloneEvent = false;
1004
			div.detachEvent("onclick", click);
1005
		});
1006
		div.cloneNode(true).fireEvent("onclick");
1007
	}
1008

  
1009
	div = document.createElement("div");
1010
	div.innerHTML = "<input type='radio' name='radiotest' checked='checked'/>";
1011

  
1012
	var fragment = document.createDocumentFragment();
1013
	fragment.appendChild( div.firstChild );
1014

  
1015
	// WebKit doesn't clone checked state correctly in fragments
1016
	jQuery.support.checkClone = fragment.cloneNode(true).cloneNode(true).lastChild.checked;
1017

  
1018
	// Figure out if the W3C box model works as expected
1019
	// document.body must exist before we can do this
1020
	jQuery(function() {
1021
		var div = document.createElement("div");
1022
		div.style.width = div.style.paddingLeft = "1px";
1023

  
1024
		document.body.appendChild( div );
1025
		jQuery.boxModel = jQuery.support.boxModel = div.offsetWidth === 2;
1026

  
1027
		if ( "zoom" in div.style ) {
1028
			// Check if natively block-level elements act like inline-block
1029
			// elements when setting their display to 'inline' and giving
1030
			// them layout
1031
			// (IE < 8 does this)
1032
			div.style.display = "inline";
1033
			div.style.zoom = 1;
1034
			jQuery.support.inlineBlockNeedsLayout = div.offsetWidth === 2;
1035

  
1036
			// Check if elements with layout shrink-wrap their children
1037
			// (IE 6 does this)
1038
			div.style.display = "";
1039
			div.innerHTML = "<div style='width:4px;'></div>";
1040
			jQuery.support.shrinkWrapBlocks = div.offsetWidth !== 2;
1041
		}
1042

  
1043
		div.innerHTML = "<table><tr><td style='padding:0;display:none'></td><td>t</td></tr></table>";
1044
		var tds = div.getElementsByTagName("td");
1045

  
1046
		// Check if table cells still have offsetWidth/Height when they are set
1047
		// to display:none and there are still other visible table cells in a
1048
		// table row; if so, offsetWidth/Height are not reliable for use when
1049
		// determining if an element has been hidden directly using
1050
		// display:none (it is still safe to use offsets if a parent element is
1051
		// hidden; don safety goggles and see bug #4512 for more information).
1052
		// (only IE 8 fails this test)
1053
		jQuery.support.reliableHiddenOffsets = tds[0].offsetHeight === 0;
1054

  
1055
		tds[0].style.display = "";
1056
		tds[1].style.display = "none";
1057

  
1058
		// Check if empty table cells still have offsetWidth/Height
1059
		// (IE < 8 fail this test)
1060
		jQuery.support.reliableHiddenOffsets = jQuery.support.reliableHiddenOffsets && tds[0].offsetHeight === 0;
1061
		div.innerHTML = "";
1062

  
1063
		document.body.removeChild( div ).style.display = "none";
1064
		div = tds = null;
1065
	});
1066

  
1067
	// Technique from Juriy Zaytsev
1068
	// http://thinkweb2.com/projects/prototype/detecting-event-support-without-browser-sniffing/
1069
	var eventSupported = function( eventName ) {
1070
		var el = document.createElement("div");
1071
		eventName = "on" + eventName;
1072

  
1073
		var isSupported = (eventName in el);
1074
		if ( !isSupported ) {
1075
			el.setAttribute(eventName, "return;");
1076
			isSupported = typeof el[eventName] === "function";
1077
		}
1078
		el = null;
1079

  
1080
		return isSupported;
1081
	};
1082

  
1083
	jQuery.support.submitBubbles = eventSupported("submit");
1084
	jQuery.support.changeBubbles = eventSupported("change");
1085

  
1086
	// release memory in IE
1087
	root = script = div = all = a = null;
1088
})();
1089

  
1090
jQuery.props = {
1091
	"for": "htmlFor",
1092
	"class": "className",
1093
	readonly: "readOnly",
1094
	maxlength: "maxLength",
1095
	cellspacing: "cellSpacing",
1096
	rowspan: "rowSpan",
1097
	colspan: "colSpan",
1098
	tabindex: "tabIndex",
1099
	usemap: "useMap",
1100
	frameborder: "frameBorder"
1101
};
1102

  
1103

  
1104

  
1105

  
1106
var windowData = {},
1107
	rbrace = /^(?:\{.*\}|\[.*\])$/;
1108

  
1109
jQuery.extend({
1110
	cache: {},
1111

  
1112
	// Please use with caution
1113
	uuid: 0,
1114

  
1115
	// Unique for each copy of jQuery on the page	
1116
	expando: "jQuery" + jQuery.now(),
1117

  
1118
	// The following elements throw uncatchable exceptions if you
1119
	// attempt to add expando properties to them.
1120
	noData: {
1121
		"embed": true,
1122
		// Ban all objects except for Flash (which handle expandos)
1123
		"object": "clsid:D27CDB6E-AE6D-11cf-96B8-444553540000",
1124
		"applet": true
1125
	},
1126

  
1127
	data: function( elem, name, data ) {
1128
		if ( !jQuery.acceptData( elem ) ) {
1129
			return;
1130
		}
1131

  
1132
		elem = elem == window ?
1133
			windowData :
1134
			elem;
1135

  
1136
		var isNode = elem.nodeType,
1137
			id = isNode ? elem[ jQuery.expando ] : null,
1138
			cache = jQuery.cache, thisCache;
1139

  
1140
		if ( isNode && !id && typeof name === "string" && data === undefined ) {
1141
			return;
1142
		}
1143

  
1144
		// Get the data from the object directly
1145
		if ( !isNode ) {
1146
			cache = elem;
1147

  
1148
		// Compute a unique ID for the element
1149
		} else if ( !id ) {
1150
			elem[ jQuery.expando ] = id = ++jQuery.uuid;
1151
		}
1152

  
1153
		// Avoid generating a new cache unless none exists and we
1154
		// want to manipulate it.
1155
		if ( typeof name === "object" ) {
1156
			if ( isNode ) {
1157
				cache[ id ] = jQuery.extend(cache[ id ], name);
1158

  
1159
			} else {
1160
				jQuery.extend( cache, name );
1161
			}
1162

  
1163
		} else if ( isNode && !cache[ id ] ) {
1164
			cache[ id ] = {};
1165
		}
1166

  
1167
		thisCache = isNode ? cache[ id ] : cache;
1168

  
1169
		// Prevent overriding the named cache with undefined values
1170
		if ( data !== undefined ) {
1171
			thisCache[ name ] = data;
1172
		}
1173

  
1174
		return typeof name === "string" ? thisCache[ name ] : thisCache;
1175
	},
1176

  
1177
	removeData: function( elem, name ) {
1178
		if ( !jQuery.acceptData( elem ) ) {
1179
			return;
1180
		}
1181

  
1182
		elem = elem == window ?
1183
			windowData :
1184
			elem;
1185

  
1186
		var isNode = elem.nodeType,
1187
			id = isNode ? elem[ jQuery.expando ] : elem,
1188
			cache = jQuery.cache,
1189
			thisCache = isNode ? cache[ id ] : id;
1190

  
1191
		// If we want to remove a specific section of the element's data
1192
		if ( name ) {
1193
			if ( thisCache ) {
1194
				// Remove the section of cache data
1195
				delete thisCache[ name ];
1196

  
1197
				// If we've removed all the data, remove the element's cache
1198
				if ( isNode && jQuery.isEmptyObject(thisCache) ) {
1199
					jQuery.removeData( elem );
1200
				}
1201
			}
1202

  
1203
		// Otherwise, we want to remove all of the element's data
1204
		} else {
1205
			if ( isNode && jQuery.support.deleteExpando ) {
1206
				delete elem[ jQuery.expando ];
1207

  
1208
			} else if ( elem.removeAttribute ) {
1209
				elem.removeAttribute( jQuery.expando );
1210

  
1211
			// Completely remove the data cache
1212
			} else if ( isNode ) {
1213
				delete cache[ id ];
1214

  
1215
			// Remove all fields from the object
1216
			} else {
1217
				for ( var n in elem ) {
1218
					delete elem[ n ];
1219
				}
1220
			}
1221
		}
1222
	},
1223

  
1224
	// A method for determining if a DOM node can handle the data expando
1225
	acceptData: function( elem ) {
1226
		if ( elem.nodeName ) {
1227
			var match = jQuery.noData[ elem.nodeName.toLowerCase() ];
1228

  
1229
			if ( match ) {
1230
				return !(match === true || elem.getAttribute("classid") !== match);
1231
			}
1232
		}
1233

  
1234
		return true;
1235
	}
1236
});
1237

  
1238
jQuery.fn.extend({
1239
	data: function( key, value ) {
1240
		if ( typeof key === "undefined" ) {
1241
			return this.length ? jQuery.data( this[0] ) : null;
1242

  
1243
		} else if ( typeof key === "object" ) {
1244
			return this.each(function() {
1245
				jQuery.data( this, key );
1246
			});
1247
		}
1248

  
1249
		var parts = key.split(".");
1250
		parts[1] = parts[1] ? "." + parts[1] : "";
1251

  
1252
		if ( value === undefined ) {
1253
			var data = this.triggerHandler("getData" + parts[1] + "!", [parts[0]]);
1254

  
1255
			// Try to fetch any internally stored data first
1256
			if ( data === undefined && this.length ) {
1257
				data = jQuery.data( this[0], key );
1258

  
1259
				// If nothing was found internally, try to fetch any
1260
				// data from the HTML5 data-* attribute
1261
				if ( data === undefined && this[0].nodeType === 1 ) {
1262
					data = this[0].getAttribute( "data-" + key );
1263

  
1264
					if ( typeof data === "string" ) {
1265
						try {
1266
							data = data === "true" ? true :
1267
								data === "false" ? false :
1268
								data === "null" ? null :
1269
								!jQuery.isNaN( data ) ? parseFloat( data ) :
1270
								rbrace.test( data ) ? jQuery.parseJSON( data ) :
1271
								data;
1272
						} catch( e ) {}
1273

  
1274
					} else {
1275
						data = undefined;
1276
					}
1277
				}
1278
			}
1279

  
1280
			return data === undefined && parts[1] ?
1281
				this.data( parts[0] ) :
1282
				data;
1283

  
1284
		} else {
1285
			return this.each(function() {
1286
				var $this = jQuery( this ), args = [ parts[0], value ];
1287

  
1288
				$this.triggerHandler( "setData" + parts[1] + "!", args );
1289
				jQuery.data( this, key, value );
1290
				$this.triggerHandler( "changeData" + parts[1] + "!", args );
1291
			});
1292
		}
1293
	},
1294

  
1295
	removeData: function( key ) {
1296
		return this.each(function() {
1297
			jQuery.removeData( this, key );
1298
		});
1299
	}
1300
});
1301

  
1302

  
1303

  
1304

  
1305
jQuery.extend({
1306
	queue: function( elem, type, data ) {
1307
		if ( !elem ) {
1308
			return;
1309
		}
1310

  
1311
		type = (type || "fx") + "queue";
1312
		var q = jQuery.data( elem, type );
1313

  
1314
		// Speed up dequeue by getting out quickly if this is just a lookup
1315
		if ( !data ) {
1316
			return q || [];
1317
		}
1318

  
1319
		if ( !q || jQuery.isArray(data) ) {
1320
			q = jQuery.data( elem, type, jQuery.makeArray(data) );
1321

  
1322
		} else {
1323
			q.push( data );
1324
		}
1325

  
1326
		return q;
1327
	},
1328

  
1329
	dequeue: function( elem, type ) {
1330
		type = type || "fx";
1331

  
1332
		var queue = jQuery.queue( elem, type ), fn = queue.shift();
1333

  
1334
		// If the fx queue is dequeued, always remove the progress sentinel
1335
		if ( fn === "inprogress" ) {
1336
			fn = queue.shift();
1337
		}
1338

  
1339
		if ( fn ) {
1340
			// Add a progress sentinel to prevent the fx queue from being
1341
			// automatically dequeued
1342
			if ( type === "fx" ) {
1343
				queue.unshift("inprogress");
1344
			}
1345

  
1346
			fn.call(elem, function() {
1347
				jQuery.dequeue(elem, type);
1348
			});
1349
		}
1350
	}
1351
});
1352

  
1353
jQuery.fn.extend({
1354
	queue: function( type, data ) {
1355
		if ( typeof type !== "string" ) {
1356
			data = type;
1357
			type = "fx";
1358
		}
1359

  
1360
		if ( data === undefined ) {
1361
			return jQuery.queue( this[0], type );
1362
		}
1363
		return this.each(function( i ) {
1364
			var queue = jQuery.queue( this, type, data );
1365

  
1366
			if ( type === "fx" && queue[0] !== "inprogress" ) {
1367
				jQuery.dequeue( this, type );
1368
			}
1369
		});
1370
	},
1371
	dequeue: function( type ) {
1372
		return this.each(function() {
1373
			jQuery.dequeue( this, type );
1374
		});
1375
	},
1376

  
1377
	// Based off of the plugin by Clint Helfers, with permission.
1378
	// http://blindsignals.com/index.php/2009/07/jquery-delay/
1379
	delay: function( time, type ) {
1380
		time = jQuery.fx ? jQuery.fx.speeds[time] || time : time;
1381
		type = type || "fx";
1382

  
1383
		return this.queue( type, function() {
1384
			var elem = this;
1385
			setTimeout(function() {
1386
				jQuery.dequeue( elem, type );
1387
			}, time );
1388
		});
1389
	},
1390

  
1391
	clearQueue: function( type ) {
1392
		return this.queue( type || "fx", [] );
1393
	}
1394
});
1395

  
1396

  
1397

  
1398

  
1399
var rclass = /[\n\t]/g,
1400
	rspaces = /\s+/,
1401
	rreturn = /\r/g,
1402
	rspecialurl = /^(?:href|src|style)$/,
1403
	rtype = /^(?:button|input)$/i,
1404
	rfocusable = /^(?:button|input|object|select|textarea)$/i,
1405
	rclickable = /^a(?:rea)?$/i,
1406
	rradiocheck = /^(?:radio|checkbox)$/i;
1407

  
1408
jQuery.fn.extend({
1409
	attr: function( name, value ) {
1410
		return jQuery.access( this, name, value, true, jQuery.attr );
1411
	},
1412

  
1413
	removeAttr: function( name, fn ) {
1414
		return this.each(function(){
1415
			jQuery.attr( this, name, "" );
1416
			if ( this.nodeType === 1 ) {
1417
				this.removeAttribute( name );
1418
			}
1419
		});
1420
	},
1421

  
1422
	addClass: function( value ) {
1423
		if ( jQuery.isFunction(value) ) {
1424
			return this.each(function(i) {
1425
				var self = jQuery(this);
1426
				self.addClass( value.call(this, i, self.attr("class")) );
1427
			});
1428
		}
1429

  
1430
		if ( value && typeof value === "string" ) {
1431
			var classNames = (value || "").split( rspaces );
1432

  
1433
			for ( var i = 0, l = this.length; i < l; i++ ) {
1434
				var elem = this[i];
1435

  
1436
				if ( elem.nodeType === 1 ) {
1437
					if ( !elem.className ) {
1438
						elem.className = value;
1439

  
1440
					} else {
1441
						var className = " " + elem.className + " ", setClass = elem.className;
1442
						for ( var c = 0, cl = classNames.length; c < cl; c++ ) {
1443
							if ( className.indexOf( " " + classNames[c] + " " ) < 0 ) {
1444
								setClass += " " + classNames[c];
1445
							}
1446
						}
1447
						elem.className = jQuery.trim( setClass );
1448
					}
1449
				}
1450
			}
1451
		}
1452

  
1453
		return this;
1454
	},
1455

  
1456
	removeClass: function( value ) {
1457
		if ( jQuery.isFunction(value) ) {
1458
			return this.each(function(i) {
1459
				var self = jQuery(this);
1460
				self.removeClass( value.call(this, i, self.attr("class")) );
1461
			});
1462
		}
1463

  
1464
		if ( (value && typeof value === "string") || value === undefined ) {
1465
			var classNames = (value || "").split( rspaces );
1466

  
1467
			for ( var i = 0, l = this.length; i < l; i++ ) {
1468
				var elem = this[i];
1469

  
1470
				if ( elem.nodeType === 1 && elem.className ) {
1471
					if ( value ) {
1472
						var className = (" " + elem.className + " ").replace(rclass, " ");
1473
						for ( var c = 0, cl = classNames.length; c < cl; c++ ) {
1474
							className = className.replace(" " + classNames[c] + " ", " ");
1475
						}
1476
						elem.className = jQuery.trim( className );
1477

  
1478
					} else {
1479
						elem.className = "";
1480
					}
1481
				}
1482
			}
1483
		}
1484

  
1485
		return this;
1486
	},
1487

  
1488
	toggleClass: function( value, stateVal ) {
1489
		var type = typeof value, isBool = typeof stateVal === "boolean";
1490

  
1491
		if ( jQuery.isFunction( value ) ) {
1492
			return this.each(function(i) {
1493
				var self = jQuery(this);
1494
				self.toggleClass( value.call(this, i, self.attr("class"), stateVal), stateVal );
1495
			});
1496
		}
1497

  
1498
		return this.each(function() {
1499
			if ( type === "string" ) {
1500
				// toggle individual class names
1501
				var className, i = 0, self = jQuery(this),
1502
					state = stateVal,
1503
					classNames = value.split( rspaces );
1504

  
1505
				while ( (className = classNames[ i++ ]) ) {
1506
					// check each className given, space seperated list
1507
					state = isBool ? state : !self.hasClass( className );
1508
					self[ state ? "addClass" : "removeClass" ]( className );
1509
				}
1510

  
1511
			} else if ( type === "undefined" || type === "boolean" ) {
1512
				if ( this.className ) {
1513
					// store className if set
1514
					jQuery.data( this, "__className__", this.className );
1515
				}
1516

  
1517
				// toggle whole className
1518
				this.className = this.className || value === false ? "" : jQuery.data( this, "__className__" ) || "";
1519
			}
1520
		});
1521
	},
1522

  
1523
	hasClass: function( selector ) {
1524
		var className = " " + selector + " ";
1525
		for ( var i = 0, l = this.length; i < l; i++ ) {
1526
			if ( (" " + this[i].className + " ").replace(rclass, " ").indexOf( className ) > -1 ) {
1527
				return true;
1528
			}
1529
		}
1530

  
1531
		return false;
1532
	},
1533

  
1534
	val: function( value ) {
1535
		if ( !arguments.length ) {
1536
			var elem = this[0];
1537

  
1538
			if ( elem ) {
1539
				if ( jQuery.nodeName( elem, "option" ) ) {
1540
					// attributes.value is undefined in Blackberry 4.7 but
1541
					// uses .value. See #6932
1542
					var val = elem.attributes.value;
1543
					return !val || val.specified ? elem.value : elem.text;
1544
				}
1545

  
1546
				// We need to handle select boxes special
1547
				if ( jQuery.nodeName( elem, "select" ) ) {
1548
					var index = elem.selectedIndex,
1549
						values = [],
1550
						options = elem.options,
1551
						one = elem.type === "select-one";
1552

  
1553
					// Nothing was selected
1554
					if ( index < 0 ) {
1555
						return null;
1556
					}
1557

  
1558
					// Loop through all the selected options
1559
					for ( var i = one ? index : 0, max = one ? index + 1 : options.length; i < max; i++ ) {
1560
						var option = options[ i ];
1561

  
1562
						// Don't return options that are disabled or in a disabled optgroup
1563
						if ( option.selected && (jQuery.support.optDisabled ? !option.disabled : option.getAttribute("disabled") === null) && 
1564
								(!option.parentNode.disabled || !jQuery.nodeName( option.parentNode, "optgroup" )) ) {
1565

  
1566
							// Get the specific value for the option
1567
							value = jQuery(option).val();
1568

  
1569
							// We don't need an array for one selects
1570
							if ( one ) {
1571
								return value;
1572
							}
1573

  
1574
							// Multi-Selects return an array
1575
							values.push( value );
1576
						}
1577
					}
1578

  
1579
					return values;
1580
				}
1581

  
1582
				// Handle the case where in Webkit "" is returned instead of "on" if a value isn't specified
1583
				if ( rradiocheck.test( elem.type ) && !jQuery.support.checkOn ) {
1584
					return elem.getAttribute("value") === null ? "on" : elem.value;
1585
				}
1586
				
1587

  
1588
				// Everything else, we just grab the value
1589
				return (elem.value || "").replace(rreturn, "");
1590

  
1591
			}
1592

  
1593
			return undefined;
1594
		}
1595

  
1596
		var isFunction = jQuery.isFunction(value);
1597

  
1598
		return this.each(function(i) {
1599
			var self = jQuery(this), val = value;
1600

  
1601
			if ( this.nodeType !== 1 ) {
1602
				return;
1603
			}
1604

  
1605
			if ( isFunction ) {
1606
				val = value.call(this, i, self.val());
1607
			}
1608

  
1609
			// Treat null/undefined as ""; convert numbers to string
1610
			if ( val == null ) {
1611
				val = "";
1612
			} else if ( typeof val === "number" ) {
1613
				val += "";
1614
			} else if ( jQuery.isArray(val) ) {
1615
				val = jQuery.map(val, function (value) {
1616
					return value == null ? "" : value + "";
1617
				});
1618
			}
1619

  
1620
			if ( jQuery.isArray(val) && rradiocheck.test( this.type ) ) {
1621
				this.checked = jQuery.inArray( self.val(), val ) >= 0;
1622

  
1623
			} else if ( jQuery.nodeName( this, "select" ) ) {
1624
				var values = jQuery.makeArray(val);
1625

  
1626
				jQuery( "option", this ).each(function() {
1627
					this.selected = jQuery.inArray( jQuery(this).val(), values ) >= 0;
1628
				});
1629

  
1630
				if ( !values.length ) {
1631
					this.selectedIndex = -1;
1632
				}
1633

  
1634
			} else {
1635
				this.value = val;
1636
			}
1637
		});
1638
	}
1639
});
1640

  
1641
jQuery.extend({
1642
	attrFn: {
1643
		val: true,
1644
		css: true,
1645
		html: true,
1646
		text: true,
1647
		data: true,
1648
		width: true,
1649
		height: true,
1650
		offset: true
1651
	},
1652
		
1653
	attr: function( elem, name, value, pass ) {
1654
		// don't set attributes on text and comment nodes
1655
		if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 ) {
1656
			return undefined;
1657
		}
1658

  
1659
		if ( pass && name in jQuery.attrFn ) {
1660
			return jQuery(elem)[name](value);
1661
		}
1662

  
1663
		var notxml = elem.nodeType !== 1 || !jQuery.isXMLDoc( elem ),
1664
			// Whether we are setting (or getting)
1665
			set = value !== undefined;
1666

  
1667
		// Try to normalize/fix the name
1668
		name = notxml && jQuery.props[ name ] || name;
1669

  
1670
		// Only do all the following if this is a node (faster for style)
1671
		if ( elem.nodeType === 1 ) {
1672
			// These attributes require special treatment
1673
			var special = rspecialurl.test( name );
1674

  
1675
			// Safari mis-reports the default selected property of an option
1676
			// Accessing the parent's selectedIndex property fixes it
1677
			if ( name === "selected" && !jQuery.support.optSelected ) {
1678
				var parent = elem.parentNode;
1679
				if ( parent ) {
1680
					parent.selectedIndex;
1681
	
1682
					// Make sure that it also works with optgroups, see #5701
1683
					if ( parent.parentNode ) {
1684
						parent.parentNode.selectedIndex;
1685
					}
1686
				}
1687
			}
1688

  
1689
			// If applicable, access the attribute via the DOM 0 way
1690
			// 'in' checks fail in Blackberry 4.7 #6931
1691
			if ( (name in elem || elem[ name ] !== undefined) && notxml && !special ) {
1692
				if ( set ) {
1693
					// We can't allow the type property to be changed (since it causes problems in IE)
1694
					if ( name === "type" && rtype.test( elem.nodeName ) && elem.parentNode ) {
1695
						jQuery.error( "type property can't be changed" );
1696
					}
1697

  
1698
					if ( value === null ) {
1699
						if ( elem.nodeType === 1 ) {
1700
							elem.removeAttribute( name );
1701
						}
1702

  
1703
					} else {
1704
						elem[ name ] = value;
1705
					}
1706
				}
1707

  
1708
				// browsers index elements by id/name on forms, give priority to attributes.
1709
				if ( jQuery.nodeName( elem, "form" ) && elem.getAttributeNode(name) ) {
1710
					return elem.getAttributeNode( name ).nodeValue;
1711
				}
1712

  
1713
				// elem.tabIndex doesn't always return the correct value when it hasn't been explicitly set
1714
				// http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/
1715
				if ( name === "tabIndex" ) {
1716
					var attributeNode = elem.getAttributeNode( "tabIndex" );
1717

  
1718
					return attributeNode && attributeNode.specified ?
1719
						attributeNode.value :
1720
						rfocusable.test( elem.nodeName ) || rclickable.test( elem.nodeName ) && elem.href ?
1721
							0 :
1722
							undefined;
1723
				}
1724

  
1725
				return elem[ name ];
1726
			}
1727

  
1728
			if ( !jQuery.support.style && notxml && name === "style" ) {
1729
				if ( set ) {
1730
					elem.style.cssText = "" + value;
1731
				}
1732

  
1733
				return elem.style.cssText;
1734
			}
1735

  
1736
			if ( set ) {
1737
				// convert the value to a string (all browsers do this but IE) see #1070
1738
				elem.setAttribute( name, "" + value );
1739
			}
1740

  
1741
			// Ensure that missing attributes return undefined
1742
			// Blackberry 4.7 returns "" from getAttribute #6938
1743
			if ( !elem.attributes[ name ] && (elem.hasAttribute && !elem.hasAttribute( name )) ) {
1744
				return undefined;
1745
			}
1746

  
1747
			var attr = !jQuery.support.hrefNormalized && notxml && special ?
1748
					// Some attributes require a special call on IE
1749
					elem.getAttribute( name, 2 ) :
1750
					elem.getAttribute( name );
1751

  
1752
			// Non-existent attributes return null, we normalize to undefined
1753
			return attr === null ? undefined : attr;
1754
		}
1755
	}
1756
});
1757

  
1758

  
1759

  
1760

  
1761
var rnamespaces = /\.(.*)$/,
1762
	rformElems = /^(?:textarea|input|select)$/i,
1763
	rperiod = /\./g,
1764
	rspace = / /g,
1765
	rescape = /[^\w\s.|`]/g,
1766
	fcleanup = function( nm ) {
1767
		return nm.replace(rescape, "\\$&");
1768
	},
1769
	focusCounts = { focusin: 0, focusout: 0 };
1770

  
1771
/*
1772
 * A number of helper functions used for managing events.
1773
 * Many of the ideas behind this code originated from
1774
 * Dean Edwards' addEvent library.
1775
 */
1776
jQuery.event = {
1777

  
1778
	// Bind an event to an element
1779
	// Original by Dean Edwards
1780
	add: function( elem, types, handler, data ) {
1781
		if ( elem.nodeType === 3 || elem.nodeType === 8 ) {
1782
			return;
1783
		}
1784

  
1785
		// For whatever reason, IE has trouble passing the window object
1786
		// around, causing it to be cloned in the process
1787
		if ( jQuery.isWindow( elem ) && ( elem !== window && !elem.frameElement ) ) {
1788
			elem = window;
1789
		}
1790

  
1791
		if ( handler === false ) {
1792
			handler = returnFalse;
1793
		}
1794

  
1795
		var handleObjIn, handleObj;
1796

  
1797
		if ( handler.handler ) {
1798
			handleObjIn = handler;
1799
			handler = handleObjIn.handler;
1800
		}
1801

  
1802
		// Make sure that the function being executed has a unique ID
1803
		if ( !handler.guid ) {
1804
			handler.guid = jQuery.guid++;
1805
		}
1806

  
1807
		// Init the element's event structure
1808
		var elemData = jQuery.data( elem );
1809

  
1810
		// If no elemData is found then we must be trying to bind to one of the
1811
		// banned noData elements
1812
		if ( !elemData ) {
1813
			return;
1814
		}
1815

  
1816
		// Use a key less likely to result in collisions for plain JS objects.
1817
		// Fixes bug #7150.
1818
		var eventKey = elem.nodeType ? "events" : "__events__",
1819
			events = elemData[ eventKey ],
1820
			eventHandle = elemData.handle;
1821
			
1822
		if ( typeof events === "function" ) {
1823
			// On plain objects events is a fn that holds the the data
1824
			// which prevents this data from being JSON serialized
1825
			// the function does not need to be called, it just contains the data
1826
			eventHandle = events.handle;
1827
			events = events.events;
1828

  
1829
		} else if ( !events ) {
1830
			if ( !elem.nodeType ) {
1831
				// On plain objects, create a fn that acts as the holder
1832
				// of the values to avoid JSON serialization of event data
1833
				elemData[ eventKey ] = elemData = function(){};
1834
			}
1835

  
1836
			elemData.events = events = {};
1837
		}
1838

  
1839
		if ( !eventHandle ) {
1840
			elemData.handle = eventHandle = function() {
1841
				// Handle the second event of a trigger and when
1842
				// an event is called after a page has unloaded
1843
				return typeof jQuery !== "undefined" && !jQuery.event.triggered ?
1844
					jQuery.event.handle.apply( eventHandle.elem, arguments ) :
1845
					undefined;
1846
			};
1847
		}
1848

  
1849
		// Add elem as a property of the handle function
1850
		// This is to prevent a memory leak with non-native events in IE.
1851
		eventHandle.elem = elem;
1852

  
1853
		// Handle multiple events separated by a space
1854
		// jQuery(...).bind("mouseover mouseout", fn);
1855
		types = types.split(" ");
1856

  
1857
		var type, i = 0, namespaces;
1858

  
1859
		while ( (type = types[ i++ ]) ) {
1860
			handleObj = handleObjIn ?
1861
				jQuery.extend({}, handleObjIn) :
1862
				{ handler: handler, data: data };
1863

  
1864
			// Namespaced event handlers
1865
			if ( type.indexOf(".") > -1 ) {
1866
				namespaces = type.split(".");
1867
				type = namespaces.shift();
1868
				handleObj.namespace = namespaces.slice(0).sort().join(".");
1869

  
1870
			} else {
1871
				namespaces = [];
1872
				handleObj.namespace = "";
1873
			}
1874

  
1875
			handleObj.type = type;
1876
			if ( !handleObj.guid ) {
1877
				handleObj.guid = handler.guid;
1878
			}
1879

  
1880
			// Get the current list of functions bound to this event
1881
			var handlers = events[ type ],
1882
				special = jQuery.event.special[ type ] || {};
1883

  
1884
			// Init the event handler queue
1885
			if ( !handlers ) {
1886
				handlers = events[ type ] = [];
1887

  
1888
				// Check for a special event handler
1889
				// Only use addEventListener/attachEvent if the special
1890
				// events handler returns false
1891
				if ( !special.setup || special.setup.call( elem, data, namespaces, eventHandle ) === false ) {
1892
					// Bind the global event handler to the element
1893
					if ( elem.addEventListener ) {
1894
						elem.addEventListener( type, eventHandle, false );
1895

  
1896
					} else if ( elem.attachEvent ) {
1897
						elem.attachEvent( "on" + type, eventHandle );
1898
					}
1899
				}
1900
			}
1901
			
1902
			if ( special.add ) { 
1903
				special.add.call( elem, handleObj ); 
1904

  
1905
				if ( !handleObj.handler.guid ) {
1906
					handleObj.handler.guid = handler.guid;
1907
				}
1908
			}
1909

  
1910
			// Add the function to the element's handler list
1911
			handlers.push( handleObj );
1912

  
1913
			// Keep track of which events have been used, for global triggering
1914
			jQuery.event.global[ type ] = true;
1915
		}
1916

  
1917
		// Nullify elem to prevent memory leaks in IE
1918
		elem = null;
1919
	},
1920

  
1921
	global: {},
1922

  
1923
	// Detach an event or set of events from an element
1924
	remove: function( elem, types, handler, pos ) {
1925
		// don't do events on text and comment nodes
1926
		if ( elem.nodeType === 3 || elem.nodeType === 8 ) {
1927
			return;
1928
		}
1929

  
1930
		if ( handler === false ) {
1931
			handler = returnFalse;
1932
		}
1933

  
1934
		var ret, type, fn, j, i = 0, all, namespaces, namespace, special, eventType, handleObj, origType,
1935
			eventKey = elem.nodeType ? "events" : "__events__",
1936
			elemData = jQuery.data( elem ),
1937
			events = elemData && elemData[ eventKey ];
1938

  
1939
		if ( !elemData || !events ) {
1940
			return;
1941
		}
1942
		
1943
		if ( typeof events === "function" ) {
1944
			elemData = events;
1945
			events = events.events;
1946
		}
1947

  
1948
		// types is actually an event object here
1949
		if ( types && types.type ) {
1950
			handler = types.handler;
1951
			types = types.type;
1952
		}
1953

  
1954
		// Unbind all events for the element
1955
		if ( !types || typeof types === "string" && types.charAt(0) === "." ) {
1956
			types = types || "";
1957

  
1958
			for ( type in events ) {
1959
				jQuery.event.remove( elem, type + types );
1960
			}
1961

  
1962
			return;
1963
		}
1964

  
1965
		// Handle multiple events separated by a space
1966
		// jQuery(...).unbind("mouseover mouseout", fn);
1967
		types = types.split(" ");
1968

  
1969
		while ( (type = types[ i++ ]) ) {
1970
			origType = type;
1971
			handleObj = null;
1972
			all = type.indexOf(".") < 0;
1973
			namespaces = [];
1974

  
1975
			if ( !all ) {
1976
				// Namespaced event handlers
1977
				namespaces = type.split(".");
1978
				type = namespaces.shift();
1979

  
1980
				namespace = new RegExp("(^|\\.)" + 
1981
					jQuery.map( namespaces.slice(0).sort(), fcleanup ).join("\\.(?:.*\\.)?") + "(\\.|$)");
1982
			}
1983

  
1984
			eventType = events[ type ];
1985

  
1986
			if ( !eventType ) {
1987
				continue;
1988
			}
1989

  
1990
			if ( !handler ) {
1991
				for ( j = 0; j < eventType.length; j++ ) {
1992
					handleObj = eventType[ j ];
1993

  
1994
					if ( all || namespace.test( handleObj.namespace ) ) {
1995
						jQuery.event.remove( elem, origType, handleObj.handler, j );
1996
						eventType.splice( j--, 1 );
1997
					}
1998
				}
1999

  
2000
				continue;
2001
			}
2002

  
2003
			special = jQuery.event.special[ type ] || {};
2004

  
2005
			for ( j = pos || 0; j < eventType.length; j++ ) {
2006
				handleObj = eventType[ j ];
2007

  
2008
				if ( handler.guid === handleObj.guid ) {
2009
					// remove the given handler for the given type
2010
					if ( all || namespace.test( handleObj.namespace ) ) {
2011
						if ( pos == null ) {
2012
							eventType.splice( j--, 1 );
2013
						}
2014

  
2015
						if ( special.remove ) {
2016
							special.remove.call( elem, handleObj );
2017
						}
2018
					}
2019

  
2020
					if ( pos != null ) {
2021
						break;
2022
					}
2023
				}
2024
			}
2025

  
2026
			// remove generic event handler if no more handlers exist
2027
			if ( eventType.length === 0 || pos != null && eventType.length === 1 ) {
2028
				if ( !special.teardown || special.teardown.call( elem, namespaces ) === false ) {
2029
					jQuery.removeEvent( elem, type, elemData.handle );
2030
				}
2031

  
2032
				ret = null;
2033
				delete events[ type ];
2034
			}
2035
		}
2036

  
2037
		// Remove the expando if it's no longer used
2038
		if ( jQuery.isEmptyObject( events ) ) {
2039
			var handle = elemData.handle;
2040
			if ( handle ) {
2041
				handle.elem = null;
2042
			}
2043

  
2044
			delete elemData.events;
2045
			delete elemData.handle;
2046

  
2047
			if ( typeof elemData === "function" ) {
2048
				jQuery.removeData( elem, eventKey );
2049

  
2050
			} else if ( jQuery.isEmptyObject( elemData ) ) {
2051
				jQuery.removeData( elem );
2052
			}
2053
		}
2054
	},
2055

  
2056
	// bubbling is internal
2057
	trigger: function( event, data, elem /*, bubbling */ ) {
2058
		// Event object or event type
2059
		var type = event.type || event,
2060
			bubbling = arguments[3];
2061

  
2062
		if ( !bubbling ) {
2063
			event = typeof event === "object" ?
2064
				// jQuery.Event object
2065
				event[ jQuery.expando ] ? event :
2066
				// Object literal
2067
				jQuery.extend( jQuery.Event(type), event ) :
2068
				// Just the event type (string)
2069
				jQuery.Event(type);
2070

  
2071
			if ( type.indexOf("!") >= 0 ) {
2072
				event.type = type = type.slice(0, -1);
2073
				event.exclusive = true;
2074
			}
2075

  
2076
			// Handle a global trigger
2077
			if ( !elem ) {
2078
				// Don't bubble custom events when global (to avoid too much overhead)
2079
				event.stopPropagation();
2080

  
2081
				// Only trigger if we've ever bound an event for it
2082
				if ( jQuery.event.global[ type ] ) {
2083
					jQuery.each( jQuery.cache, function() {
2084
						if ( this.events && this.events[type] ) {
2085
							jQuery.event.trigger( event, data, this.handle.elem );
2086
						}
2087
					});
2088
				}
2089
			}
2090

  
2091
			// Handle triggering a single element
2092

  
2093
			// don't do events on text and comment nodes
2094
			if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 ) {
2095
				return undefined;
2096
			}
2097

  
2098
			// Clean up in case it is reused
2099
			event.result = undefined;
2100
			event.target = elem;
2101

  
2102
			// Clone the incoming data, if any
2103
			data = jQuery.makeArray( data );
2104
			data.unshift( event );
2105
		}
2106

  
2107
		event.currentTarget = elem;
2108

  
2109
		// Trigger the event, it is assumed that "handle" is a function
2110
		var handle = elem.nodeType ?
2111
			jQuery.data( elem, "handle" ) :
2112
			(jQuery.data( elem, "__events__" ) || {}).handle;
2113

  
2114
		if ( handle ) {
2115
			handle.apply( elem, data );
2116
		}
2117

  
2118
		var parent = elem.parentNode || elem.ownerDocument;
2119

  
2120
		// Trigger an inline bound script
2121
		try {
2122
			if ( !(elem && elem.nodeName && jQuery.noData[elem.nodeName.toLowerCase()]) ) {
2123
				if ( elem[ "on" + type ] && elem[ "on" + type ].apply( elem, data ) === false ) {
2124
					event.result = false;
2125
					event.preventDefault();
2126
				}
2127
			}
2128

  
2129
		// prevent IE from throwing an error for some elements with some event types, see #3533
2130
		} catch (inlineError) {}
2131

  
2132
		if ( !event.isPropagationStopped() && parent ) {
2133
			jQuery.event.trigger( event, data, parent, true );
2134

  
2135
		} else if ( !event.isDefaultPrevented() ) {
2136
			var target = event.target, old, targetType = type.replace(rnamespaces, ""),
2137
				isClick = jQuery.nodeName(target, "a") && targetType === "click",
2138
				special = jQuery.event.special[ targetType ] || {};
2139

  
2140
			if ( (!special._default || special._default.call( elem, event ) === false) && 
2141
				!isClick && !(target && target.nodeName && jQuery.noData[target.nodeName.toLowerCase()]) ) {
2142

  
2143
				try {
2144
					if ( target[ targetType ] ) {
2145
						// Make sure that we don't accidentally re-trigger the onFOO events
2146
						old = target[ "on" + targetType ];
2147

  
2148
						if ( old ) {
2149
							target[ "on" + targetType ] = null;
2150
						}
2151

  
2152
						jQuery.event.triggered = true;
2153
						target[ targetType ]();
2154
					}
2155

  
2156
				// prevent IE from throwing an error for some elements with some event types, see #3533
2157
				} catch (triggerError) {}
2158

  
2159
				if ( old ) {
2160
					target[ "on" + targetType ] = old;
2161
				}
2162

  
2163
				jQuery.event.triggered = false;
2164
			}
2165
		}
2166
	},
2167

  
2168
	handle: function( event ) {
2169
		var all, handlers, namespaces, namespace_sort = [], namespace_re, events, args = jQuery.makeArray( arguments );
2170

  
2171
		event = args[0] = jQuery.event.fix( event || window.event );
2172
		event.currentTarget = this;
2173

  
2174
		// Namespaced event handlers
2175
		all = event.type.indexOf(".") < 0 && !event.exclusive;
2176

  
2177
		if ( !all ) {
2178
			namespaces = event.type.split(".");
2179
			event.type = namespaces.shift();
2180
			namespace_sort = namespaces.slice(0).sort();
2181
			namespace_re = new RegExp("(^|\\.)" + namespace_sort.join("\\.(?:.*\\.)?") + "(\\.|$)");
2182
		}
2183

  
2184
		event.namespace = event.namespace || namespace_sort.join(".");
2185

  
2186
		events = jQuery.data(this, this.nodeType ? "events" : "__events__");
2187

  
2188
		if ( typeof events === "function" ) {
2189
			events = events.events;
2190
		}
2191

  
2192
		handlers = (events || {})[ event.type ];
2193

  
2194
		if ( events && handlers ) {
2195
			// Clone the handlers to prevent manipulation
2196
			handlers = handlers.slice(0);
2197

  
2198
			for ( var j = 0, l = handlers.length; j < l; j++ ) {
2199
				var handleObj = handlers[ j ];
2200

  
2201
				// Filter the functions by class
2202
				if ( all || namespace_re.test( handleObj.namespace ) ) {
2203
					// Pass in a reference to the handler function itself
2204
					// So that we can later remove it
2205
					event.handler = handleObj.handler;
2206
					event.data = handleObj.data;
2207
					event.handleObj = handleObj;
2208
	
2209
					var ret = handleObj.handler.apply( this, args );
2210

  
2211
					if ( ret !== undefined ) {
2212
						event.result = ret;
2213
						if ( ret === false ) {
2214
							event.preventDefault();
2215
							event.stopPropagation();
2216
						}
2217
					}
2218

  
2219
					if ( event.isImmediatePropagationStopped() ) {
2220
						break;
2221
					}
2222
				}
2223
			}
2224
		}
2225

  
2226
		return event.result;
2227
	},
2228

  
2229
	props: "altKey attrChange attrName bubbles button cancelable charCode clientX clientY ctrlKey currentTarget data detail eventPhase fromElement handler keyCode layerX layerY metaKey newValue offsetX offsetY pageX pageY prevValue relatedNode relatedTarget screenX screenY shiftKey srcElement target toElement view wheelDelta which".split(" "),
2230

  
2231
	fix: function( event ) {
2232
		if ( event[ jQuery.expando ] ) {
2233
			return event;
2234
		}
2235

  
2236
		// store a copy of the original event object
2237
		// and "clone" to set read-only properties
2238
		var originalEvent = event;
2239
		event = jQuery.Event( originalEvent );
2240

  
2241
		for ( var i = this.props.length, prop; i; ) {
2242
			prop = this.props[ --i ];
2243
			event[ prop ] = originalEvent[ prop ];
2244
		}
2245

  
2246
		// Fix target property, if necessary
2247
		if ( !event.target ) {
2248
			event.target = event.srcElement || document; // Fixes #1925 where srcElement might not be defined either
2249
		}
2250

  
2251
		// check if target is a textnode (safari)
2252
		if ( event.target.nodeType === 3 ) {
2253
			event.target = event.target.parentNode;
2254
		}
2255

  
2256
		// Add relatedTarget, if necessary
2257
		if ( !event.relatedTarget && event.fromElement ) {
2258
			event.relatedTarget = event.fromElement === event.target ? event.toElement : event.fromElement;
2259
		}
2260

  
2261
		// Calculate pageX/Y if missing and clientX/Y available
2262
		if ( event.pageX == null && event.clientX != null ) {
2263
			var doc = document.documentElement, body = document.body;
2264
			event.pageX = event.clientX + (doc && doc.scrollLeft || body && body.scrollLeft || 0) - (doc && doc.clientLeft || body && body.clientLeft || 0);
2265
			event.pageY = event.clientY + (doc && doc.scrollTop  || body && body.scrollTop  || 0) - (doc && doc.clientTop  || body && body.clientTop  || 0);
2266
		}
2267

  
2268
		// Add which for key events
2269
		if ( event.which == null && (event.charCode != null || event.keyCode != null) ) {
2270
			event.which = event.charCode != null ? event.charCode : event.keyCode;
2271
		}
2272

  
2273
		// Add metaKey to non-Mac browsers (use ctrl for PC's and Meta for Macs)
2274
		if ( !event.metaKey && event.ctrlKey ) {
2275
			event.metaKey = event.ctrlKey;
2276
		}
2277

  
2278
		// Add which for click: 1 === left; 2 === middle; 3 === right
2279
		// Note: button is not normalized, so don't use it
2280
		if ( !event.which && event.button !== undefined ) {
2281
			event.which = (event.button & 1 ? 1 : ( event.button & 2 ? 3 : ( event.button & 4 ? 2 : 0 ) ));
2282
		}
2283

  
2284
		return event;
2285
	},
2286

  
2287
	// Deprecated, use jQuery.guid instead
2288
	guid: 1E8,
2289

  
2290
	// Deprecated, use jQuery.proxy instead
2291
	proxy: jQuery.proxy,
2292

  
2293
	special: {
2294
		ready: {
2295
			// Make sure the ready event is setup
2296
			setup: jQuery.bindReady,
2297
			teardown: jQuery.noop
2298
		},
2299

  
2300
		live: {
2301
			add: function( handleObj ) {
2302
				jQuery.event.add( this,
2303
					liveConvert( handleObj.origType, handleObj.selector ),
2304
					jQuery.extend({}, handleObj, {handler: liveHandler, guid: handleObj.handler.guid}) ); 
2305
			},
2306

  
2307
			remove: function( handleObj ) {
2308
				jQuery.event.remove( this, liveConvert( handleObj.origType, handleObj.selector ), handleObj );
2309
			}
2310
		},
2311

  
2312
		beforeunload: {
2313
			setup: function( data, namespaces, eventHandle ) {
2314
				// We only want to do this special case on windows
2315
				if ( jQuery.isWindow( this ) ) {
2316
					this.onbeforeunload = eventHandle;
2317
				}
2318
			},
2319

  
2320
			teardown: function( namespaces, eventHandle ) {
2321
				if ( this.onbeforeunload === eventHandle ) {
2322
					this.onbeforeunload = null;
2323
				}
2324
			}
2325
		}
2326
	}
2327
};
2328

  
2329
jQuery.removeEvent = document.removeEventListener ?
2330
	function( elem, type, handle ) {
2331
		if ( elem.removeEventListener ) {
2332
			elem.removeEventListener( type, handle, false );
2333
		}
2334
	} : 
2335
	function( elem, type, handle ) {
2336
		if ( elem.detachEvent ) {
2337
			elem.detachEvent( "on" + type, handle );
2338
		}
2339
	};
2340

  
2341
jQuery.Event = function( src ) {
2342
	// Allow instantiation without the 'new' keyword
2343
	if ( !this.preventDefault ) {
2344
		return new jQuery.Event( src );
2345
	}
2346

  
2347
	// Event object
2348
	if ( src && src.type ) {
2349
		this.originalEvent = src;
2350
		this.type = src.type;
2351
	// Event type
2352
	} else {
2353
		this.type = src;
2354
	}
2355

  
2356
	// timeStamp is buggy for some events on Firefox(#3843)
2357
	// So we won't rely on the native value
2358
	this.timeStamp = jQuery.now();
2359

  
2360
	// Mark it as fixed
2361
	this[ jQuery.expando ] = true;
2362
};
2363

  
2364
function returnFalse() {
2365
	return false;
2366
}
2367
function returnTrue() {
2368
	return true;
2369
}
2370

  
2371
// jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding
2372
// http://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html
2373
jQuery.Event.prototype = {
2374
	preventDefault: function() {
2375
		this.isDefaultPrevented = returnTrue;
2376

  
2377
		var e = this.originalEvent;
2378
		if ( !e ) {
2379
			return;
2380
		}
2381
		
2382
		// if preventDefault exists run it on the original event
2383
		if ( e.preventDefault ) {
2384
			e.preventDefault();
2385

  
2386
		// otherwise set the returnValue property of the original event to false (IE)
2387
		} else {
2388
			e.returnValue = false;
2389
		}
2390
	},
2391
	stopPropagation: function() {
2392
		this.isPropagationStopped = returnTrue;
2393

  
2394
		var e = this.originalEvent;
2395
		if ( !e ) {
2396
			return;
2397
		}
2398
		// if stopPropagation exists run it on the original event
2399
		if ( e.stopPropagation ) {
2400
			e.stopPropagation();
2401
		}
2402
		// otherwise set the cancelBubble property of the original event to true (IE)
2403
		e.cancelBubble = true;
2404
	},
2405
	stopImmediatePropagation: function() {
2406
		this.isImmediatePropagationStopped = returnTrue;
2407
		this.stopPropagation();
2408
	},
2409
	isDefaultPrevented: returnFalse,
2410
	isPropagationStopped: returnFalse,
2411
	isImmediatePropagationStopped: returnFalse
2412
};
2413

  
2414
// Checks if an event happened on an element within another element
2415
// Used in jQuery.event.special.mouseenter and mouseleave handlers
2416
var withinElement = function( event ) {
2417
	// Check if mouse(over|out) are still within the same parent element
2418
	var parent = event.relatedTarget;
2419

  
2420
	// Firefox sometimes assigns relatedTarget a XUL element
2421
	// which we cannot access the parentNode property of
2422
	try {
2423
		// Traverse up the tree
2424
		while ( parent && parent !== this ) {
2425
			parent = parent.parentNode;
2426
		}
2427

  
2428
		if ( parent !== this ) {
2429
			// set the correct event type
2430
			event.type = event.data;
2431

  
2432
			// handle event if we actually just moused on to a non sub-element
2433
			jQuery.event.handle.apply( this, arguments );
2434
		}
2435

  
2436
	// assuming we've left the element since we most likely mousedover a xul element
2437
	} catch(e) { }
2438
},
2439

  
2440
// In case of event delegation, we only need to rename the event.type,
2441
// liveHandler will take care of the rest.
2442
delegate = function( event ) {
2443
	event.type = event.data;
2444
	jQuery.event.handle.apply( this, arguments );
2445
};
2446

  
2447
// Create mouseenter and mouseleave events
2448
jQuery.each({
2449
	mouseenter: "mouseover",
2450
	mouseleave: "mouseout"
2451
}, function( orig, fix ) {
2452
	jQuery.event.special[ orig ] = {
2453
		setup: function( data ) {
2454
			jQuery.event.add( this, fix, data && data.selector ? delegate : withinElement, orig );
2455
		},
2456
		teardown: function( data ) {
2457
			jQuery.event.remove( this, fix, data && data.selector ? delegate : withinElement );
2458
		}
2459
	};
2460
});
2461

  
2462
// submit delegation
2463
if ( !jQuery.support.submitBubbles ) {
2464

  
2465
	jQuery.event.special.submit = {
2466
		setup: function( data, namespaces ) {
2467
			if ( this.nodeName.toLowerCase() !== "form" ) {
2468
				jQuery.event.add(this, "click.specialSubmit", function( e ) {
2469
					var elem = e.target, type = elem.type;
2470

  
2471
					if ( (type === "submit" || type === "image") && jQuery( elem ).closest("form").length ) {
2472
						e.liveFired = undefined;
2473
						return trigger( "submit", this, arguments );
2474
					}
2475
				});
2476
	 
2477
				jQuery.event.add(this, "keypress.specialSubmit", function( e ) {
2478
					var elem = e.target, type = elem.type;
2479

  
2480
					if ( (type === "text" || type === "password") && jQuery( elem ).closest("form").length && e.keyCode === 13 ) {
2481
						e.liveFired = undefined;
2482
						return trigger( "submit", this, arguments );
2483
					}
2484
				});
2485

  
2486
			} else {
2487
				return false;
2488
			}
2489
		},
2490

  
2491
		teardown: function( namespaces ) {
2492
			jQuery.event.remove( this, ".specialSubmit" );
2493
		}
2494
	};
2495

  
2496
}
2497

  
2498
// change delegation, happens here so we have bind.
2499
if ( !jQuery.support.changeBubbles ) {
2500

  
2501
	var changeFilters,
2502

  
2503
	getVal = function( elem ) {
2504
		var type = elem.type, val = elem.value;
2505

  
2506
		if ( type === "radio" || type === "checkbox" ) {
2507
			val = elem.checked;
2508

  
2509
		} else if ( type === "select-multiple" ) {
2510
			val = elem.selectedIndex > -1 ?
2511
				jQuery.map( elem.options, function( elem ) {
2512
					return elem.selected;
2513
				}).join("-") :
2514
				"";
2515

  
2516
		} else if ( elem.nodeName.toLowerCase() === "select" ) {
2517
			val = elem.selectedIndex;
2518
		}
2519

  
2520
		return val;
2521
	},
2522

  
2523
	testChange = function testChange( e ) {
2524
		var elem = e.target, data, val;
2525

  
2526
		if ( !rformElems.test( elem.nodeName ) || elem.readOnly ) {
2527
			return;
2528
		}
2529

  
2530
		data = jQuery.data( elem, "_change_data" );
2531
		val = getVal(elem);
2532

  
2533
		// the current data will be also retrieved by beforeactivate
2534
		if ( e.type !== "focusout" || elem.type !== "radio" ) {
2535
			jQuery.data( elem, "_change_data", val );
2536
		}
2537
		
2538
		if ( data === undefined || val === data ) {
2539
			return;
2540
		}
2541

  
2542
		if ( data != null || val ) {
2543
			e.type = "change";
2544
			e.liveFired = undefined;
2545
			return jQuery.event.trigger( e, arguments[1], elem );
2546
		}
2547
	};
2548

  
2549
	jQuery.event.special.change = {
2550
		filters: {
2551
			focusout: testChange, 
2552

  
2553
			beforedeactivate: testChange,
2554

  
2555
			click: function( e ) {
2556
				var elem = e.target, type = elem.type;
2557

  
2558
				if ( type === "radio" || type === "checkbox" || elem.nodeName.toLowerCase() === "select" ) {
2559
					return testChange.call( this, e );
2560
				}
2561
			},
2562

  
2563
			// Change has to be called before submit
2564
			// Keydown will be called before keypress, which is used in submit-event delegation
2565
			keydown: function( e ) {
2566
				var elem = e.target, type = elem.type;
2567

  
2568
				if ( (e.keyCode === 13 && elem.nodeName.toLowerCase() !== "textarea") ||
2569
					(e.keyCode === 32 && (type === "checkbox" || type === "radio")) ||
2570
					type === "select-multiple" ) {
2571
					return testChange.call( this, e );
2572
				}
2573
			},
2574

  
2575
			// Beforeactivate happens also before the previous element is blurred
2576
			// with this event you can't trigger a change event, but you can store
2577
			// information
2578
			beforeactivate: function( e ) {
2579
				var elem = e.target;
2580
				jQuery.data( elem, "_change_data", getVal(elem) );
2581
			}
2582
		},
2583

  
2584
		setup: function( data, namespaces ) {
2585
			if ( this.type === "file" ) {
2586
				return false;
2587
			}
2588

  
2589
			for ( var type in changeFilters ) {
2590
				jQuery.event.add( this, type + ".specialChange", changeFilters[type] );
2591
			}
2592

  
2593
			return rformElems.test( this.nodeName );
2594
		},
2595

  
2596
		teardown: function( namespaces ) {
2597
			jQuery.event.remove( this, ".specialChange" );
2598

  
2599
			return rformElems.test( this.nodeName );
2600
		}
2601
	};
2602

  
2603
	changeFilters = jQuery.event.special.change.filters;
2604

  
2605
	// Handle when the input is .focus()'d
2606
	changeFilters.focus = changeFilters.beforeactivate;
2607
}
2608

  
2609
function trigger( type, elem, args ) {
2610
	args[0].type = type;
2611
	return jQuery.event.handle.apply( elem, args );
2612
}
2613

  
2614
// Create "bubbling" focus and blur events
2615
if ( document.addEventListener ) {
2616
	jQuery.each({ focus: "focusin", blur: "focusout" }, function( orig, fix ) {
2617
		jQuery.event.special[ fix ] = {
2618
			setup: function() {
2619
				if ( focusCounts[fix]++ === 0 ) {
2620
					document.addEventListener( orig, handler, true );
2621
				}
2622
			}, 
2623
			teardown: function() { 
2624
				if ( --focusCounts[fix] === 0 ) {
2625
					document.removeEventListener( orig, handler, true );
2626
				}
2627
			}
2628
		};
2629

  
2630
		function handler( e ) { 
2631
			e = jQuery.event.fix( e );
2632
			e.type = fix;
2633
			return jQuery.event.trigger( e, null, e.target );
2634
		}
2635
	});
2636
}
2637

  
2638
jQuery.each(["bind", "one"], function( i, name ) {
2639
	jQuery.fn[ name ] = function( type, data, fn ) {
2640
		// Handle object literals
2641
		if ( typeof type === "object" ) {
2642
			for ( var key in type ) {
2643
				this[ name ](key, data, type[key], fn);
2644
			}
2645
			return this;
2646
		}
2647
		
2648
		if ( jQuery.isFunction( data ) || data === false ) {
2649
			fn = data;
2650
			data = undefined;
2651
		}
2652

  
2653
		var handler = name === "one" ? jQuery.proxy( fn, function( event ) {
2654
			jQuery( this ).unbind( event, handler );
2655
			return fn.apply( this, arguments );
2656
		}) : fn;
2657

  
2658
		if ( type === "unload" && name !== "one" ) {
2659
			this.one( type, data, fn );
2660

  
2661
		} else {
2662
			for ( var i = 0, l = this.length; i < l; i++ ) {
2663
				jQuery.event.add( this[i], type, handler, data );
2664
			}
2665
		}
2666

  
2667
		return this;
2668
	};
2669
});
2670

  
2671
jQuery.fn.extend({
2672
	unbind: function( type, fn ) {
2673
		// Handle object literals
2674
		if ( typeof type === "object" && !type.preventDefault ) {
2675
			for ( var key in type ) {
2676
				this.unbind(key, type[key]);
2677
			}
2678

  
2679
		} else {
2680
			for ( var i = 0, l = this.length; i < l; i++ ) {
2681
				jQuery.event.remove( this[i], type, fn );
2682
			}
2683
		}
2684

  
2685
		return this;
2686
	},
2687
	
2688
	delegate: function( selector, types, data, fn ) {
2689
		return this.live( types, data, fn, selector );
2690
	},
2691
	
2692
	undelegate: function( selector, types, fn ) {
2693
		if ( arguments.length === 0 ) {
2694
				return this.unbind( "live" );
2695
		
2696
		} else {
2697
			return this.die( types, null, fn, selector );
2698
		}
2699
	},
2700
	
2701
	trigger: function( type, data ) {
2702
		return this.each(function() {
2703
			jQuery.event.trigger( type, data, this );
2704
		});
2705
	},
2706

  
2707
	triggerHandler: function( type, data ) {
2708
		if ( this[0] ) {
2709
			var event = jQuery.Event( type );
2710
			event.preventDefault();
2711
			event.stopPropagation();
2712
			jQuery.event.trigger( event, data, this[0] );
2713
			return event.result;
2714
		}
2715
	},
2716

  
2717
	toggle: function( fn ) {
2718
		// Save reference to arguments for access in closure
2719
		var args = arguments, i = 1;
2720

  
2721
		// link all the functions, so any of them can unbind this click handler
2722
		while ( i < args.length ) {
2723
			jQuery.proxy( fn, args[ i++ ] );
2724
		}
2725

  
2726
		return this.click( jQuery.proxy( fn, function( event ) {
2727
			// Figure out which function to execute
2728
			var lastToggle = ( jQuery.data( this, "lastToggle" + fn.guid ) || 0 ) % i;
2729
			jQuery.data( this, "lastToggle" + fn.guid, lastToggle + 1 );
2730

  
2731
			// Make sure that clicks stop
2732
			event.preventDefault();
2733

  
2734
			// and execute the function
2735
			return args[ lastToggle ].apply( this, arguments ) || false;
2736
		}));
2737
	},
2738

  
2739
	hover: function( fnOver, fnOut ) {
2740
		return this.mouseenter( fnOver ).mouseleave( fnOut || fnOver );
2741
	}
2742
});
2743

  
2744
var liveMap = {
2745
	focus: "focusin",
2746
	blur: "focusout",
2747
	mouseenter: "mouseover",
2748
	mouseleave: "mouseout"
2749
};
2750

  
2751
jQuery.each(["live", "die"], function( i, name ) {
2752
	jQuery.fn[ name ] = function( types, data, fn, origSelector /* Internal Use Only */ ) {
2753
		var type, i = 0, match, namespaces, preType,
2754
			selector = origSelector || this.selector,
2755
			context = origSelector ? this : jQuery( this.context );
2756
		
2757
		if ( typeof types === "object" && !types.preventDefault ) {
2758
			for ( var key in types ) {
2759
				context[ name ]( key, data, types[key], selector );
2760
			}
2761
			
2762
			return this;
2763
		}
2764

  
2765
		if ( jQuery.isFunction( data ) ) {
2766
			fn = data;
2767
			data = undefined;
2768
		}
2769

  
2770
		types = (types || "").split(" ");
2771

  
2772
		while ( (type = types[ i++ ]) != null ) {
2773
			match = rnamespaces.exec( type );
2774
			namespaces = "";
2775

  
2776
			if ( match )  {
2777
				namespaces = match[0];
2778
				type = type.replace( rnamespaces, "" );
2779
			}
2780

  
2781
			if ( type === "hover" ) {
2782
				types.push( "mouseenter" + namespaces, "mouseleave" + namespaces );
2783
				continue;
2784
			}
2785

  
2786
			preType = type;
2787

  
2788
			if ( type === "focus" || type === "blur" ) {
2789
				types.push( liveMap[ type ] + namespaces );
2790
				type = type + namespaces;
2791

  
2792
			} else {
2793
				type = (liveMap[ type ] || type) + namespaces;
2794
			}
2795

  
2796
			if ( name === "live" ) {
2797
				// bind live handler
2798
				for ( var j = 0, l = context.length; j < l; j++ ) {
2799
					jQuery.event.add( context[j], "live." + liveConvert( type, selector ),
2800
						{ data: data, selector: selector, handler: fn, origType: type, origHandler: fn, preType: preType } );
2801
				}
2802

  
2803
			} else {
2804
				// unbind live handler
2805
				context.unbind( "live." + liveConvert( type, selector ), fn );
2806
			}
2807
		}
2808
		
2809
		return this;
2810
	};
2811
});
2812

  
2813
function liveHandler( event ) {
2814
	var stop, maxLevel, elems = [], selectors = [],
2815
		related, match, handleObj, elem, j, i, l, data, close, namespace, ret,
2816
		events = jQuery.data( this, this.nodeType ? "events" : "__events__" );
2817

  
2818
	if ( typeof events === "function" ) {
2819
		events = events.events;
2820
	}
2821

  
2822
	// Make sure we avoid non-left-click bubbling in Firefox (#3861)
2823
	if ( event.liveFired === this || !events || !events.live || event.button && event.type === "click" ) {
2824
		return;
2825
	}
2826

  
2827
	if ( event.namespace ) {
2828
		namespace = new RegExp("(^|\\.)" + event.namespace.split(".").join("\\.(?:.*\\.)?") + "(\\.|$)");
2829
	}
2830

  
2831
	event.liveFired = this;
2832

  
2833
	var live = events.live.slice(0);
2834

  
2835
	for ( j = 0; j < live.length; j++ ) {
2836
		handleObj = live[j];
2837

  
2838
		if ( handleObj.origType.replace( rnamespaces, "" ) === event.type ) {
2839
			selectors.push( handleObj.selector );
2840

  
2841
		} else {
2842
			live.splice( j--, 1 );
2843
		}
2844
	}
2845

  
2846
	match = jQuery( event.target ).closest( selectors, event.currentTarget );
2847

  
2848
	for ( i = 0, l = match.length; i < l; i++ ) {
2849
		close = match[i];
2850

  
2851
		for ( j = 0; j < live.length; j++ ) {
2852
			handleObj = live[j];
2853

  
2854
			if ( close.selector === handleObj.selector && (!namespace || namespace.test( handleObj.namespace )) ) {
2855
				elem = close.elem;
2856
				related = null;
2857

  
2858
				// Those two events require additional checking
2859
				if ( handleObj.preType === "mouseenter" || handleObj.preType === "mouseleave" ) {
2860
					event.type = handleObj.preType;
2861
					related = jQuery( event.relatedTarget ).closest( handleObj.selector )[0];
2862
				}
2863

  
2864
				if ( !related || related !== elem ) {
2865
					elems.push({ elem: elem, handleObj: handleObj, level: close.level });
2866
				}
2867
			}
2868
		}
2869
	}
2870

  
2871
	for ( i = 0, l = elems.length; i < l; i++ ) {
2872
		match = elems[i];
2873

  
2874
		if ( maxLevel && match.level > maxLevel ) {
2875
			break;
2876
		}
2877

  
2878
		event.currentTarget = match.elem;
2879
		event.data = match.handleObj.data;
2880
		event.handleObj = match.handleObj;
2881

  
2882
		ret = match.handleObj.origHandler.apply( match.elem, arguments );
2883

  
2884
		if ( ret === false || event.isPropagationStopped() ) {
2885
			maxLevel = match.level;
2886

  
2887
			if ( ret === false ) {
2888
				stop = false;
2889
			}
2890
		}
2891
	}
2892

  
2893
	return stop;
2894
}
2895

  
2896
function liveConvert( type, selector ) {
2897
	return (type && type !== "*" ? type + "." : "") + selector.replace(rperiod, "`").replace(rspace, "&");
2898
}
2899

  
2900
jQuery.each( ("blur focus focusin focusout load resize scroll unload click dblclick " +
2901
	"mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave " +
2902
	"change select submit keydown keypress keyup error").split(" "), function( i, name ) {
2903

  
2904
	// Handle event binding
2905
	jQuery.fn[ name ] = function( data, fn ) {
2906
		if ( fn == null ) {
2907
			fn = data;
2908
			data = null;
2909
		}
2910

  
2911
		return arguments.length > 0 ?
2912
			this.bind( name, data, fn ) :
2913
			this.trigger( name );
2914
	};
2915

  
2916
	if ( jQuery.attrFn ) {
2917
		jQuery.attrFn[ name ] = true;
2918
	}
2919
});
2920

  
2921
// Prevent memory leaks in IE
2922
// Window isn't included so as not to unbind existing unload events
2923
// More info:
2924
//  - http://isaacschlueter.com/2006/10/msie-memory-leaks/
2925
if ( window.attachEvent && !window.addEventListener ) {
2926
	jQuery(window).bind("unload", function() {
2927
		for ( var id in jQuery.cache ) {
2928
			if ( jQuery.cache[ id ].handle ) {
2929
				// Try/Catch is to handle iframes being unloaded, see #4280
2930
				try {
2931
					jQuery.event.remove( jQuery.cache[ id ].handle.elem );
2932
				} catch(e) {}
2933
			}
2934
		}
2935
	});
2936
}
2937

  
2938

  
2939
/*!
2940
 * Sizzle CSS Selector Engine - v1.0
2941
 *  Copyright 2009, The Dojo Foundation
2942
 *  Released under the MIT, BSD, and GPL Licenses.
2943
 *  More information: http://sizzlejs.com/
2944
 */
2945
(function(){
2946

  
2947
var chunker = /((?:\((?:\([^()]+\)|[^()]+)+\)|\[(?:\[[^\[\]]*\]|['"][^'"]*['"]|[^\[\]'"]+)+\]|\\.|[^ >+~,(\[\\]+)+|[>+~])(\s*,\s*)?((?:.|\r|\n)*)/g,
2948
	done = 0,
2949
	toString = Object.prototype.toString,
2950
	hasDuplicate = false,
2951
	baseHasDuplicate = true;
2952

  
2953
// Here we check if the JavaScript engine is using some sort of
2954
// optimization where it does not always call our comparision
2955
// function. If that is the case, discard the hasDuplicate value.
2956
//   Thus far that includes Google Chrome.
2957
[0, 0].sort(function(){
2958
	baseHasDuplicate = false;
2959
	return 0;
2960
});
2961

  
2962
var Sizzle = function(selector, context, results, seed) {
2963
	results = results || [];
2964
	context = context || document;
2965

  
2966
	var origContext = context;
2967

  
2968
	if ( context.nodeType !== 1 && context.nodeType !== 9 ) {
2969
		return [];
2970
	}
2971
	
2972
	if ( !selector || typeof selector !== "string" ) {
2973
		return results;
2974
	}
2975

  
2976
	var parts = [], m, set, checkSet, extra, prune = true, contextXML = Sizzle.isXML(context),
2977
		soFar = selector, ret, cur, pop, i;
2978
	
2979
	// Reset the position of the chunker regexp (start from head)
2980
	do {
2981
		chunker.exec("");
2982
		m = chunker.exec(soFar);
2983

  
2984
		if ( m ) {
2985
			soFar = m[3];
2986
		
2987
			parts.push( m[1] );
2988
		
2989
			if ( m[2] ) {
2990
				extra = m[3];
2991
				break;
2992
			}
2993
		}
2994
	} while ( m );
2995

  
2996
	if ( parts.length > 1 && origPOS.exec( selector ) ) {
2997
		if ( parts.length === 2 && Expr.relative[ parts[0] ] ) {
2998
			set = posProcess( parts[0] + parts[1], context );
2999
		} else {
3000
			set = Expr.relative[ parts[0] ] ?
3001
				[ context ] :
3002
				Sizzle( parts.shift(), context );
3003

  
3004
			while ( parts.length ) {
3005
				selector = parts.shift();
3006

  
3007
				if ( Expr.relative[ selector ] ) {
3008
					selector += parts.shift();
3009
				}
3010
				
3011
				set = posProcess( selector, set );
3012
			}
3013
		}
3014
	} else {
3015
		// Take a shortcut and set the context if the root selector is an ID
3016
		// (but not if it'll be faster if the inner selector is an ID)
3017
		if ( !seed && parts.length > 1 && context.nodeType === 9 && !contextXML &&
3018
				Expr.match.ID.test(parts[0]) && !Expr.match.ID.test(parts[parts.length - 1]) ) {
3019
			ret = Sizzle.find( parts.shift(), context, contextXML );
3020
			context = ret.expr ? Sizzle.filter( ret.expr, ret.set )[0] : ret.set[0];
3021
		}
3022

  
3023
		if ( context ) {
3024
			ret = seed ?
3025
				{ expr: parts.pop(), set: makeArray(seed) } :
3026
				Sizzle.find( parts.pop(), parts.length === 1 && (parts[0] === "~" || parts[0] === "+") && context.parentNode ? context.parentNode : context, contextXML );
3027
			set = ret.expr ? Sizzle.filter( ret.expr, ret.set ) : ret.set;
3028

  
3029
			if ( parts.length > 0 ) {
3030
				checkSet = makeArray(set);
3031
			} else {
3032
				prune = false;
3033
			}
3034

  
3035
			while ( parts.length ) {
3036
				cur = parts.pop();
3037
				pop = cur;
3038

  
3039
				if ( !Expr.relative[ cur ] ) {
3040
					cur = "";
3041
				} else {
3042
					pop = parts.pop();
3043
				}
3044

  
3045
				if ( pop == null ) {
3046
					pop = context;
3047
				}
3048

  
3049
				Expr.relative[ cur ]( checkSet, pop, contextXML );
3050
			}
3051
		} else {
3052
			checkSet = parts = [];
3053
		}
3054
	}
3055

  
3056
	if ( !checkSet ) {
3057
		checkSet = set;
3058
	}
3059

  
3060
	if ( !checkSet ) {
3061
		Sizzle.error( cur || selector );
3062
	}
3063

  
3064
	if ( toString.call(checkSet) === "[object Array]" ) {
3065
		if ( !prune ) {
3066
			results.push.apply( results, checkSet );
3067
		} else if ( context && context.nodeType === 1 ) {
3068
			for ( i = 0; checkSet[i] != null; i++ ) {
3069
				if ( checkSet[i] && (checkSet[i] === true || checkSet[i].nodeType === 1 && Sizzle.contains(context, checkSet[i])) ) {
3070
					results.push( set[i] );
3071
				}
3072
			}
3073
		} else {
3074
			for ( i = 0; checkSet[i] != null; i++ ) {
3075
				if ( checkSet[i] && checkSet[i].nodeType === 1 ) {
3076
					results.push( set[i] );
3077
				}
3078
			}
3079
		}
3080
	} else {
3081
		makeArray( checkSet, results );
3082
	}
3083

  
3084
	if ( extra ) {
3085
		Sizzle( extra, origContext, results, seed );
3086
		Sizzle.uniqueSort( results );
3087
	}
3088

  
3089
	return results;
3090
};
3091

  
3092
Sizzle.uniqueSort = function(results){
3093
	if ( sortOrder ) {
3094
		hasDuplicate = baseHasDuplicate;
3095
		results.sort(sortOrder);
3096

  
3097
		if ( hasDuplicate ) {
3098
			for ( var i = 1; i < results.length; i++ ) {
3099
				if ( results[i] === results[i-1] ) {
3100
					results.splice(i--, 1);
3101
				}
3102
			}
3103
		}
3104
	}
3105

  
3106
	return results;
3107
};
3108

  
3109
Sizzle.matches = function(expr, set){
3110
	return Sizzle(expr, null, null, set);
3111
};
3112

  
3113
Sizzle.matchesSelector = function(node, expr){
3114
	return Sizzle(expr, null, null, [node]).length > 0;
3115
};
3116

  
3117
Sizzle.find = function(expr, context, isXML){
3118
	var set;
3119

  
3120
	if ( !expr ) {
3121
		return [];
3122
	}
3123

  
3124
	for ( var i = 0, l = Expr.order.length; i < l; i++ ) {
3125
		var type = Expr.order[i], match;
3126
		
3127
		if ( (match = Expr.leftMatch[ type ].exec( expr )) ) {
3128
			var left = match[1];
3129
			match.splice(1,1);
3130

  
3131
			if ( left.substr( left.length - 1 ) !== "\\" ) {
3132
				match[1] = (match[1] || "").replace(/\\/g, "");
3133
				set = Expr.find[ type ]( match, context, isXML );
3134
				if ( set != null ) {
3135
					expr = expr.replace( Expr.match[ type ], "" );
3136
					break;
3137
				}
3138
			}
3139
		}
3140
	}
3141

  
3142
	if ( !set ) {
3143
		set = context.getElementsByTagName("*");
3144
	}
3145

  
3146
	return {set: set, expr: expr};
3147
};
3148

  
3149
Sizzle.filter = function(expr, set, inplace, not){
3150
	var old = expr, result = [], curLoop = set, match, anyFound,
3151
		isXMLFilter = set && set[0] && Sizzle.isXML(set[0]);
3152

  
3153
	while ( expr && set.length ) {
3154
		for ( var type in Expr.filter ) {
3155
			if ( (match = Expr.leftMatch[ type ].exec( expr )) != null && match[2] ) {
3156
				var filter = Expr.filter[ type ], found, item, left = match[1];
3157
				anyFound = false;
3158

  
3159
				match.splice(1,1);
3160

  
3161
				if ( left.substr( left.length - 1 ) === "\\" ) {
3162
					continue;
3163
				}
3164

  
3165
				if ( curLoop === result ) {
3166
					result = [];
3167
				}
3168

  
3169
				if ( Expr.preFilter[ type ] ) {
3170
					match = Expr.preFilter[ type ]( match, curLoop, inplace, result, not, isXMLFilter );
3171

  
3172
					if ( !match ) {
3173
						anyFound = found = true;
3174
					} else if ( match === true ) {
3175
						continue;
3176
					}
3177
				}
3178

  
3179
				if ( match ) {
3180
					for ( var i = 0; (item = curLoop[i]) != null; i++ ) {
3181
						if ( item ) {
3182
							found = filter( item, match, i, curLoop );
3183
							var pass = not ^ !!found;
3184

  
3185
							if ( inplace && found != null ) {
3186
								if ( pass ) {
3187
									anyFound = true;
3188
								} else {
3189
									curLoop[i] = false;
3190
								}
3191
							} else if ( pass ) {
3192
								result.push( item );
3193
								anyFound = true;
3194
							}
3195
						}
3196
					}
3197
				}
3198

  
3199
				if ( found !== undefined ) {
3200
					if ( !inplace ) {
3201
						curLoop = result;
3202
					}
3203

  
3204
					expr = expr.replace( Expr.match[ type ], "" );
3205

  
3206
					if ( !anyFound ) {
3207
						return [];
3208
					}
3209

  
3210
					break;
3211
				}
3212
			}
3213
		}
3214

  
3215
		// Improper expression
3216
		if ( expr === old ) {
3217
			if ( anyFound == null ) {
3218
				Sizzle.error( expr );
3219
			} else {
3220
				break;
3221
			}
3222
		}
3223

  
3224
		old = expr;
3225
	}
3226

  
3227
	return curLoop;
3228
};
3229

  
3230
Sizzle.error = function( msg ) {
3231
	throw "Syntax error, unrecognized expression: " + msg;
3232
};
3233

  
3234
var Expr = Sizzle.selectors = {
3235
	order: [ "ID", "NAME", "TAG" ],
3236
	match: {
3237
		ID: /#((?:[\w\u00c0-\uFFFF\-]|\\.)+)/,
3238
		CLASS: /\.((?:[\w\u00c0-\uFFFF\-]|\\.)+)/,
3239
		NAME: /\[name=['"]*((?:[\w\u00c0-\uFFFF\-]|\\.)+)['"]*\]/,
3240
		ATTR: /\[\s*((?:[\w\u00c0-\uFFFF\-]|\\.)+)\s*(?:(\S?=)\s*(['"]*)(.*?)\3|)\s*\]/,
3241
		TAG: /^((?:[\w\u00c0-\uFFFF\*\-]|\\.)+)/,
3242
		CHILD: /:(only|nth|last|first)-child(?:\((even|odd|[\dn+\-]*)\))?/,
3243
		POS: /:(nth|eq|gt|lt|first|last|even|odd)(?:\((\d*)\))?(?=[^\-]|$)/,
3244
		PSEUDO: /:((?:[\w\u00c0-\uFFFF\-]|\\.)+)(?:\((['"]?)((?:\([^\)]+\)|[^\(\)]*)+)\2\))?/
3245
	},
3246
	leftMatch: {},
3247
	attrMap: {
3248
		"class": "className",
3249
		"for": "htmlFor"
3250
	},
3251
	attrHandle: {
3252
		href: function(elem){
3253
			return elem.getAttribute("href");
3254
		}
3255
	},
3256
	relative: {
3257
		"+": function(checkSet, part){
3258
			var isPartStr = typeof part === "string",
3259
				isTag = isPartStr && !/\W/.test(part),
3260
				isPartStrNotTag = isPartStr && !isTag;
3261

  
3262
			if ( isTag ) {
3263
				part = part.toLowerCase();
3264
			}
3265

  
3266
			for ( var i = 0, l = checkSet.length, elem; i < l; i++ ) {
3267
				if ( (elem = checkSet[i]) ) {
3268
					while ( (elem = elem.previousSibling) && elem.nodeType !== 1 ) {}
3269

  
3270
					checkSet[i] = isPartStrNotTag || elem && elem.nodeName.toLowerCase() === part ?
3271
						elem || false :
3272
						elem === part;
3273
				}
3274
			}
3275

  
3276
			if ( isPartStrNotTag ) {
3277
				Sizzle.filter( part, checkSet, true );
3278
			}
3279
		},
3280
		">": function(checkSet, part){
3281
			var isPartStr = typeof part === "string",
3282
				elem, i = 0, l = checkSet.length;
3283

  
3284
			if ( isPartStr && !/\W/.test(part) ) {
3285
				part = part.toLowerCase();
3286

  
3287
				for ( ; i < l; i++ ) {
3288
					elem = checkSet[i];
3289
					if ( elem ) {
3290
						var parent = elem.parentNode;
3291
						checkSet[i] = parent.nodeName.toLowerCase() === part ? parent : false;
3292
					}
3293
				}
3294
			} else {
3295
				for ( ; i < l; i++ ) {
3296
					elem = checkSet[i];
3297
					if ( elem ) {
3298
						checkSet[i] = isPartStr ?
3299
							elem.parentNode :
3300
							elem.parentNode === part;
3301
					}
3302
				}
3303

  
3304
				if ( isPartStr ) {
3305
					Sizzle.filter( part, checkSet, true );
3306
				}
3307
			}
3308
		},
3309
		"": function(checkSet, part, isXML){
3310
			var doneName = done++, checkFn = dirCheck, nodeCheck;
3311

  
3312
			if ( typeof part === "string" && !/\W/.test(part) ) {
3313
				part = part.toLowerCase();
3314
				nodeCheck = part;
3315
				checkFn = dirNodeCheck;
3316
			}
3317

  
3318
			checkFn("parentNode", part, doneName, checkSet, nodeCheck, isXML);
3319
		},
3320
		"~": function(checkSet, part, isXML){
3321
			var doneName = done++, checkFn = dirCheck, nodeCheck;
3322

  
3323
			if ( typeof part === "string" && !/\W/.test(part) ) {
3324
				part = part.toLowerCase();
3325
				nodeCheck = part;
3326
				checkFn = dirNodeCheck;
3327
			}
3328

  
3329
			checkFn("previousSibling", part, doneName, checkSet, nodeCheck, isXML);
3330
		}
3331
	},
3332
	find: {
3333
		ID: function(match, context, isXML){
3334
			if ( typeof context.getElementById !== "undefined" && !isXML ) {
3335
				var m = context.getElementById(match[1]);
3336
				// Check parentNode to catch when Blackberry 4.6 returns
3337
				// nodes that are no longer in the document #6963
3338
				return m && m.parentNode ? [m] : [];
3339
			}
3340
		},
3341
		NAME: function(match, context){
3342
			if ( typeof context.getElementsByName !== "undefined" ) {
3343
				var ret = [], results = context.getElementsByName(match[1]);
3344

  
3345
				for ( var i = 0, l = results.length; i < l; i++ ) {
3346
					if ( results[i].getAttribute("name") === match[1] ) {
3347
						ret.push( results[i] );
3348
					}
3349
				}
3350

  
3351
				return ret.length === 0 ? null : ret;
3352
			}
3353
		},
3354
		TAG: function(match, context){
3355
			return context.getElementsByTagName(match[1]);
3356
		}
3357
	},
3358
	preFilter: {
3359
		CLASS: function(match, curLoop, inplace, result, not, isXML){
3360
			match = " " + match[1].replace(/\\/g, "") + " ";
3361

  
3362
			if ( isXML ) {
3363
				return match;
3364
			}
3365

  
3366
			for ( var i = 0, elem; (elem = curLoop[i]) != null; i++ ) {
3367
				if ( elem ) {
3368
					if ( not ^ (elem.className && (" " + elem.className + " ").replace(/[\t\n]/g, " ").indexOf(match) >= 0) ) {
3369
						if ( !inplace ) {
3370
							result.push( elem );
3371
						}
3372
					} else if ( inplace ) {
3373
						curLoop[i] = false;
3374
					}
3375
				}
3376
			}
3377

  
3378
			return false;
3379
		},
3380
		ID: function(match){
3381
			return match[1].replace(/\\/g, "");
3382
		},
3383
		TAG: function(match, curLoop){
3384
			return match[1].toLowerCase();
3385
		},
3386
		CHILD: function(match){
3387
			if ( match[1] === "nth" ) {
3388
				// parse equations like 'even', 'odd', '5', '2n', '3n+2', '4n-1', '-n+6'
3389
				var test = /(-?)(\d*)n((?:\+|-)?\d*)/.exec(
3390
					match[2] === "even" && "2n" || match[2] === "odd" && "2n+1" ||
3391
					!/\D/.test( match[2] ) && "0n+" + match[2] || match[2]);
3392

  
3393
				// calculate the numbers (first)n+(last) including if they are negative
3394
				match[2] = (test[1] + (test[2] || 1)) - 0;
3395
				match[3] = test[3] - 0;
3396
			}
3397

  
3398
			// TODO: Move to normal caching system
3399
			match[0] = done++;
3400

  
3401
			return match;
3402
		},
3403
		ATTR: function(match, curLoop, inplace, result, not, isXML){
3404
			var name = match[1].replace(/\\/g, "");
3405
			
3406
			if ( !isXML && Expr.attrMap[name] ) {
3407
				match[1] = Expr.attrMap[name];
3408
			}
3409

  
3410
			if ( match[2] === "~=" ) {
3411
				match[4] = " " + match[4] + " ";
3412
			}
3413

  
3414
			return match;
3415
		},
3416
		PSEUDO: function(match, curLoop, inplace, result, not){
3417
			if ( match[1] === "not" ) {
3418
				// If we're dealing with a complex expression, or a simple one
3419
				if ( ( chunker.exec(match[3]) || "" ).length > 1 || /^\w/.test(match[3]) ) {
3420
					match[3] = Sizzle(match[3], null, null, curLoop);
3421
				} else {
3422
					var ret = Sizzle.filter(match[3], curLoop, inplace, true ^ not);
3423
					if ( !inplace ) {
3424
						result.push.apply( result, ret );
3425
					}
3426
					return false;
3427
				}
3428
			} else if ( Expr.match.POS.test( match[0] ) || Expr.match.CHILD.test( match[0] ) ) {
3429
				return true;
3430
			}
3431
			
3432
			return match;
3433
		},
3434
		POS: function(match){
3435
			match.unshift( true );
3436
			return match;
3437
		}
3438
	},
3439
	filters: {
3440
		enabled: function(elem){
3441
			return elem.disabled === false && elem.type !== "hidden";
3442
		},
3443
		disabled: function(elem){
3444
			return elem.disabled === true;
3445
		},
3446
		checked: function(elem){
3447
			return elem.checked === true;
3448
		},
3449
		selected: function(elem){
3450
			// Accessing this property makes selected-by-default
3451
			// options in Safari work properly
3452
			elem.parentNode.selectedIndex;
3453
			return elem.selected === true;
3454
		},
3455
		parent: function(elem){
3456
			return !!elem.firstChild;
3457
		},
3458
		empty: function(elem){
3459
			return !elem.firstChild;
3460
		},
3461
		has: function(elem, i, match){
3462
			return !!Sizzle( match[3], elem ).length;
3463
		},
3464
		header: function(elem){
3465
			return (/h\d/i).test( elem.nodeName );
3466
		},
3467
		text: function(elem){
3468
			return "text" === elem.type;
3469
		},
3470
		radio: function(elem){
3471
			return "radio" === elem.type;
3472
		},
3473
		checkbox: function(elem){
3474
			return "checkbox" === elem.type;
3475
		},
3476
		file: function(elem){
3477
			return "file" === elem.type;
3478
		},
3479
		password: function(elem){
3480
			return "password" === elem.type;
3481
		},
3482
		submit: function(elem){
3483
			return "submit" === elem.type;
3484
		},
3485
		image: function(elem){
3486
			return "image" === elem.type;
3487
		},
3488
		reset: function(elem){
3489
			return "reset" === elem.type;
3490
		},
3491
		button: function(elem){
3492
			return "button" === elem.type || elem.nodeName.toLowerCase() === "button";
3493
		},
3494
		input: function(elem){
3495
			return (/input|select|textarea|button/i).test(elem.nodeName);
3496
		}
3497
	},
3498
	setFilters: {
3499
		first: function(elem, i){
3500
			return i === 0;
3501
		},
3502
		last: function(elem, i, match, array){
3503
			return i === array.length - 1;
3504
		},
3505
		even: function(elem, i){
3506
			return i % 2 === 0;
3507
		},
3508
		odd: function(elem, i){
3509
			return i % 2 === 1;
3510
		},
3511
		lt: function(elem, i, match){
3512
			return i < match[3] - 0;
3513
		},
3514
		gt: function(elem, i, match){
3515
			return i > match[3] - 0;
3516
		},
3517
		nth: function(elem, i, match){
3518
			return match[3] - 0 === i;
3519
		},
3520
		eq: function(elem, i, match){
3521
			return match[3] - 0 === i;
3522
		}
3523
	},
3524
	filter: {
3525
		PSEUDO: function(elem, match, i, array){
3526
			var name = match[1], filter = Expr.filters[ name ];
3527

  
3528
			if ( filter ) {
3529
				return filter( elem, i, match, array );
3530
			} else if ( name === "contains" ) {
3531
				return (elem.textContent || elem.innerText || Sizzle.getText([ elem ]) || "").indexOf(match[3]) >= 0;
3532
			} else if ( name === "not" ) {
3533
				var not = match[3];
3534

  
3535
				for ( var j = 0, l = not.length; j < l; j++ ) {
3536
					if ( not[j] === elem ) {
3537
						return false;
3538
					}
3539
				}
3540

  
3541
				return true;
3542
			} else {
3543
				Sizzle.error( "Syntax error, unrecognized expression: " + name );
3544
			}
3545
		},
3546
		CHILD: function(elem, match){
3547
			var type = match[1], node = elem;
3548
			switch (type) {
3549
				case 'only':
3550
				case 'first':
3551
					while ( (node = node.previousSibling) )	 {
3552
						if ( node.nodeType === 1 ) { 
3553
							return false; 
3554
						}
3555
					}
3556
					if ( type === "first" ) { 
3557
						return true; 
3558
					}
3559
					node = elem;
3560
				case 'last':
3561
					while ( (node = node.nextSibling) )	 {
3562
						if ( node.nodeType === 1 ) { 
3563
							return false; 
3564
						}
3565
					}
3566
					return true;
3567
				case 'nth':
3568
					var first = match[2], last = match[3];
3569

  
3570
					if ( first === 1 && last === 0 ) {
3571
						return true;
3572
					}
3573
					
3574
					var doneName = match[0],
3575
						parent = elem.parentNode;
3576
	
3577
					if ( parent && (parent.sizcache !== doneName || !elem.nodeIndex) ) {
3578
						var count = 0;
3579
						for ( node = parent.firstChild; node; node = node.nextSibling ) {
3580
							if ( node.nodeType === 1 ) {
3581
								node.nodeIndex = ++count;
3582
							}
3583
						} 
3584
						parent.sizcache = doneName;
3585
					}
3586
					
3587
					var diff = elem.nodeIndex - last;
3588
					if ( first === 0 ) {
3589
						return diff === 0;
3590
					} else {
3591
						return ( diff % first === 0 && diff / first >= 0 );
3592
					}
3593
			}
3594
		},
3595
		ID: function(elem, match){
3596
			return elem.nodeType === 1 && elem.getAttribute("id") === match;
3597
		},
3598
		TAG: function(elem, match){
3599
			return (match === "*" && elem.nodeType === 1) || elem.nodeName.toLowerCase() === match;
3600
		},
3601
		CLASS: function(elem, match){
3602
			return (" " + (elem.className || elem.getAttribute("class")) + " ")
3603
				.indexOf( match ) > -1;
3604
		},
3605
		ATTR: function(elem, match){
3606
			var name = match[1],
3607
				result = Expr.attrHandle[ name ] ?
3608
					Expr.attrHandle[ name ]( elem ) :
3609
					elem[ name ] != null ?
3610
						elem[ name ] :
3611
						elem.getAttribute( name ),
3612
				value = result + "",
3613
				type = match[2],
3614
				check = match[4];
3615

  
3616
			return result == null ?
3617
				type === "!=" :
3618
				type === "=" ?
3619
				value === check :
3620
				type === "*=" ?
3621
				value.indexOf(check) >= 0 :
3622
				type === "~=" ?
3623
				(" " + value + " ").indexOf(check) >= 0 :
3624
				!check ?
3625
				value && result !== false :
3626
				type === "!=" ?
3627
				value !== check :
3628
				type === "^=" ?
3629
				value.indexOf(check) === 0 :
3630
				type === "$=" ?
3631
				value.substr(value.length - check.length) === check :
3632
				type === "|=" ?
3633
				value === check || value.substr(0, check.length + 1) === check + "-" :
3634
				false;
3635
		},
3636
		POS: function(elem, match, i, array){
3637
			var name = match[2], filter = Expr.setFilters[ name ];
3638

  
3639
			if ( filter ) {
3640
				return filter( elem, i, match, array );
3641
			}
3642
		}
3643
	}
3644
};
3645

  
3646
var origPOS = Expr.match.POS,
3647
	fescape = function(all, num){
3648
		return "\\" + (num - 0 + 1);
3649
	};
3650

  
3651
for ( var type in Expr.match ) {
3652
	Expr.match[ type ] = new RegExp( Expr.match[ type ].source + (/(?![^\[]*\])(?![^\(]*\))/.source) );
3653
	Expr.leftMatch[ type ] = new RegExp( /(^(?:.|\r|\n)*?)/.source + Expr.match[ type ].source.replace(/\\(\d+)/g, fescape) );
3654
}
3655

  
3656
var makeArray = function(array, results) {
3657
	array = Array.prototype.slice.call( array, 0 );
3658

  
3659
	if ( results ) {
3660
		results.push.apply( results, array );
3661
		return results;
3662
	}
3663
	
3664
	return array;
3665
};
3666

  
3667
// Perform a simple check to determine if the browser is capable of
3668
// converting a NodeList to an array using builtin methods.
3669
// Also verifies that the returned array holds DOM nodes
3670
// (which is not the case in the Blackberry browser)
3671
try {
3672
	Array.prototype.slice.call( document.documentElement.childNodes, 0 )[0].nodeType;
3673

  
3674
// Provide a fallback method if it does not work
3675
} catch(e){
3676
	makeArray = function(array, results) {
3677
		var ret = results || [], i = 0;
3678

  
3679
		if ( toString.call(array) === "[object Array]" ) {
3680
			Array.prototype.push.apply( ret, array );
3681
		} else {
3682
			if ( typeof array.length === "number" ) {
3683
				for ( var l = array.length; i < l; i++ ) {
3684
					ret.push( array[i] );
3685
				}
3686
			} else {
3687
				for ( ; array[i]; i++ ) {
3688
					ret.push( array[i] );
3689
				}
3690
			}
3691
		}
3692

  
3693
		return ret;
3694
	};
3695
}
3696

  
3697
var sortOrder, siblingCheck;
3698

  
3699
if ( document.documentElement.compareDocumentPosition ) {
3700
	sortOrder = function( a, b ) {
3701
		if ( a === b ) {
3702
			hasDuplicate = true;
3703
			return 0;
3704
		}
3705

  
3706
		if ( !a.compareDocumentPosition || !b.compareDocumentPosition ) {
3707
			return a.compareDocumentPosition ? -1 : 1;
3708
		}
3709

  
3710
		return a.compareDocumentPosition(b) & 4 ? -1 : 1;
3711
	};
3712
} else {
3713
	sortOrder = function( a, b ) {
3714
		var ap = [], bp = [], aup = a.parentNode, bup = b.parentNode,
3715
			cur = aup, al, bl;
3716

  
3717
		// The nodes are identical, we can exit early
3718
		if ( a === b ) {
3719
			hasDuplicate = true;
3720
			return 0;
3721

  
3722
		// If the nodes are siblings (or identical) we can do a quick check
3723
		} else if ( aup === bup ) {
3724
			return siblingCheck( a, b );
3725

  
3726
		// If no parents were found then the nodes are disconnected
3727
		} else if ( !aup ) {
3728
			return -1;
3729

  
3730
		} else if ( !bup ) {
3731
			return 1;
3732
		}
3733

  
3734
		// Otherwise they're somewhere else in the tree so we need
3735
		// to build up a full list of the parentNodes for comparison
3736
		while ( cur ) {
3737
			ap.unshift( cur );
3738
			cur = cur.parentNode;
3739
		}
3740

  
3741
		cur = bup;
3742

  
3743
		while ( cur ) {
3744
			bp.unshift( cur );
3745
			cur = cur.parentNode;
3746
		}
3747

  
3748
		al = ap.length;
3749
		bl = bp.length;
3750

  
3751
		// Start walking down the tree looking for a discrepancy
3752
		for ( var i = 0; i < al && i < bl; i++ ) {
3753
			if ( ap[i] !== bp[i] ) {
3754
				return siblingCheck( ap[i], bp[i] );
3755
			}
3756
		}
3757

  
3758
		// We ended someplace up the tree so do a sibling check
3759
		return i === al ?
3760
			siblingCheck( a, bp[i], -1 ) :
3761
			siblingCheck( ap[i], b, 1 );
3762
	};
3763

  
3764
	siblingCheck = function( a, b, ret ) {
3765
		if ( a === b ) {
3766
			return ret;
3767
		}
3768

  
3769
		var cur = a.nextSibling;
3770

  
3771
		while ( cur ) {
3772
			if ( cur === b ) {
3773
				return -1;
3774
			}
3775

  
3776
			cur = cur.nextSibling;
3777
		}
3778

  
3779
		return 1;
3780
	};
3781
}
3782

  
3783
// Utility function for retreiving the text value of an array of DOM nodes
3784
Sizzle.getText = function( elems ) {
3785
	var ret = "", elem;
3786

  
3787
	for ( var i = 0; elems[i]; i++ ) {
3788
		elem = elems[i];
3789

  
3790
		// Get the text from text nodes and CDATA nodes
3791
		if ( elem.nodeType === 3 || elem.nodeType === 4 ) {
3792
			ret += elem.nodeValue;
3793

  
3794
		// Traverse everything else, except comment nodes
3795
		} else if ( elem.nodeType !== 8 ) {
3796
			ret += Sizzle.getText( elem.childNodes );
3797
		}
3798
	}
3799

  
3800
	return ret;
3801
};
3802

  
3803
// Check to see if the browser returns elements by name when
3804
// querying by getElementById (and provide a workaround)
3805
(function(){
3806
	// We're going to inject a fake input element with a specified name
3807
	var form = document.createElement("div"),
3808
		id = "script" + (new Date()).getTime();
3809
	form.innerHTML = "<a name='" + id + "'/>";
3810

  
3811
	// Inject it into the root element, check its status, and remove it quickly
3812
	var root = document.documentElement;
3813
	root.insertBefore( form, root.firstChild );
3814

  
3815
	// The workaround has to do additional checks after a getElementById
3816
	// Which slows things down for other browsers (hence the branching)
3817
	if ( document.getElementById( id ) ) {
3818
		Expr.find.ID = function(match, context, isXML){
3819
			if ( typeof context.getElementById !== "undefined" && !isXML ) {
3820
				var m = context.getElementById(match[1]);
3821
				return m ? m.id === match[1] || typeof m.getAttributeNode !== "undefined" && m.getAttributeNode("id").nodeValue === match[1] ? [m] : undefined : [];
3822
			}
3823
		};
3824

  
3825
		Expr.filter.ID = function(elem, match){
3826
			var node = typeof elem.getAttributeNode !== "undefined" && elem.getAttributeNode("id");
3827
			return elem.nodeType === 1 && node && node.nodeValue === match;
3828
		};
3829
	}
3830

  
3831
	root.removeChild( form );
3832
	root = form = null; // release memory in IE
3833
})();
3834

  
3835
(function(){
3836
	// Check to see if the browser returns only elements
3837
	// when doing getElementsByTagName("*")
3838

  
3839
	// Create a fake element
3840
	var div = document.createElement("div");
3841
	div.appendChild( document.createComment("") );
3842

  
3843
	// Make sure no comments are found
3844
	if ( div.getElementsByTagName("*").length > 0 ) {
3845
		Expr.find.TAG = function(match, context){
3846
			var results = context.getElementsByTagName(match[1]);
3847

  
3848
			// Filter out possible comments
3849
			if ( match[1] === "*" ) {
3850
				var tmp = [];
3851

  
3852
				for ( var i = 0; results[i]; i++ ) {
3853
					if ( results[i].nodeType === 1 ) {
3854
						tmp.push( results[i] );
3855
					}
3856
				}
3857

  
3858
				results = tmp;
3859
			}
3860

  
3861
			return results;
3862
		};
3863
	}
3864

  
3865
	// Check to see if an attribute returns normalized href attributes
3866
	div.innerHTML = "<a href='#'></a>";
3867
	if ( div.firstChild && typeof div.firstChild.getAttribute !== "undefined" &&
3868
			div.firstChild.getAttribute("href") !== "#" ) {
3869
		Expr.attrHandle.href = function(elem){
3870
			return elem.getAttribute("href", 2);
3871
		};
3872
	}
3873

  
3874
	div = null; // release memory in IE
3875
})();
3876

  
3877
if ( document.querySelectorAll ) {
3878
	(function(){
3879
		var oldSizzle = Sizzle, div = document.createElement("div");
3880
		div.innerHTML = "<p class='TEST'></p>";
3881

  
3882
		// Safari can't handle uppercase or unicode characters when
3883
		// in quirks mode.
3884
		if ( div.querySelectorAll && div.querySelectorAll(".TEST").length === 0 ) {
3885
			return;
3886
		}
3887
	
3888
		Sizzle = function(query, context, extra, seed){
3889
			context = context || document;
3890

  
3891
			// Only use querySelectorAll on non-XML documents
3892
			// (ID selectors don't work in non-HTML documents)
3893
			if ( !seed && !Sizzle.isXML(context) ) {
3894
				if ( context.nodeType === 9 ) {
3895
					try {
3896
						return makeArray( context.querySelectorAll(query), extra );
3897
					} catch(qsaError) {}
3898

  
3899
				// qSA works strangely on Element-rooted queries
3900
				// We can work around this by specifying an extra ID on the root
3901
				// and working up from there (Thanks to Andrew Dupont for the technique)
3902
				// IE 8 doesn't work on object elements
3903
				} else if ( context.nodeType === 1 && context.nodeName.toLowerCase() !== "object" ) {
3904
					var old = context.id, id = context.id = "__sizzle__";
3905

  
3906
					try {
3907
						return makeArray( context.querySelectorAll( "#" + id + " " + query ), extra );
3908

  
3909
					} catch(pseudoError) {
3910
					} finally {
3911
						if ( old ) {
3912
							context.id = old;
3913

  
3914
						} else {
3915
							context.removeAttribute( "id" );
3916
						}
3917
					}
3918
				}
3919
			}
3920
		
3921
			return oldSizzle(query, context, extra, seed);
3922
		};
3923

  
3924
		for ( var prop in oldSizzle ) {
3925
			Sizzle[ prop ] = oldSizzle[ prop ];
3926
		}
3927

  
3928
		div = null; // release memory in IE
3929
	})();
3930
}
3931

  
3932
(function(){
3933
	var html = document.documentElement,
3934
		matches = html.matchesSelector || html.mozMatchesSelector || html.webkitMatchesSelector || html.msMatchesSelector,
3935
		pseudoWorks = false;
3936

  
3937
	try {
3938
		// This should fail with an exception
3939
		// Gecko does not error, returns false instead
3940
		matches.call( document.documentElement, ":sizzle" );
3941
	
3942
	} catch( pseudoError ) {
3943
		pseudoWorks = true;
3944
	}
3945

  
3946
	if ( matches ) {
3947
		Sizzle.matchesSelector = function( node, expr ) {
3948
				try { 
3949
					if ( pseudoWorks || !Expr.match.PSEUDO.test( expr ) ) {
3950
						return matches.call( node, expr );
3951
					}
3952
				} catch(e) {}
3953

  
3954
				return Sizzle(expr, null, null, [node]).length > 0;
3955
		};
3956
	}
3957
})();
3958

  
3959
(function(){
3960
	var div = document.createElement("div");
3961

  
3962
	div.innerHTML = "<div class='test e'></div><div class='test'></div>";
3963

  
3964
	// Opera can't find a second classname (in 9.6)
3965
	// Also, make sure that getElementsByClassName actually exists
3966
	if ( !div.getElementsByClassName || div.getElementsByClassName("e").length === 0 ) {
3967
		return;
3968
	}
3969

  
3970
	// Safari caches class attributes, doesn't catch changes (in 3.2)
3971
	div.lastChild.className = "e";
3972

  
3973
	if ( div.getElementsByClassName("e").length === 1 ) {
3974
		return;
3975
	}
3976
	
3977
	Expr.order.splice(1, 0, "CLASS");
3978
	Expr.find.CLASS = function(match, context, isXML) {
3979
		if ( typeof context.getElementsByClassName !== "undefined" && !isXML ) {
3980
			return context.getElementsByClassName(match[1]);
3981
		}
3982
	};
3983

  
3984
	div = null; // release memory in IE
3985
})();
3986

  
3987
function dirNodeCheck( dir, cur, doneName, checkSet, nodeCheck, isXML ) {
3988
	for ( var i = 0, l = checkSet.length; i < l; i++ ) {
3989
		var elem = checkSet[i];
3990
		if ( elem ) {
3991
			elem = elem[dir];
3992
			var match = false;
3993

  
3994
			while ( elem ) {
3995
				if ( elem.sizcache === doneName ) {
3996
					match = checkSet[elem.sizset];
3997
					break;
3998
				}
3999

  
4000
				if ( elem.nodeType === 1 && !isXML ){
4001
					elem.sizcache = doneName;
4002
					elem.sizset = i;
4003
				}
4004

  
4005
				if ( elem.nodeName.toLowerCase() === cur ) {
4006
					match = elem;
4007
					break;
4008
				}
4009

  
4010
				elem = elem[dir];
4011
			}
4012

  
4013
			checkSet[i] = match;
4014
		}
4015
	}
4016
}
4017

  
4018
function dirCheck( dir, cur, doneName, checkSet, nodeCheck, isXML ) {
4019
	for ( var i = 0, l = checkSet.length; i < l; i++ ) {
4020
		var elem = checkSet[i];
4021
		if ( elem ) {
4022
			elem = elem[dir];
4023
			var match = false;
4024

  
4025
			while ( elem ) {
4026
				if ( elem.sizcache === doneName ) {
4027
					match = checkSet[elem.sizset];
4028
					break;
4029
				}
4030

  
4031
				if ( elem.nodeType === 1 ) {
4032
					if ( !isXML ) {
4033
						elem.sizcache = doneName;
4034
						elem.sizset = i;
4035
					}
4036
					if ( typeof cur !== "string" ) {
4037
						if ( elem === cur ) {
4038
							match = true;
4039
							break;
4040
						}
4041

  
4042
					} else if ( Sizzle.filter( cur, [elem] ).length > 0 ) {
4043
						match = elem;
4044
						break;
4045
					}
4046
				}
4047

  
4048
				elem = elem[dir];
4049
			}
4050

  
4051
			checkSet[i] = match;
4052
		}
4053
	}
4054
}
4055

  
4056
Sizzle.contains = document.documentElement.contains ? function(a, b){
4057
	return a !== b && (a.contains ? a.contains(b) : true);
4058
} : function(a, b){
4059
	return !!(a.compareDocumentPosition(b) & 16);
4060
};
4061

  
4062
Sizzle.isXML = function(elem){
4063
	// documentElement is verified for cases where it doesn't yet exist
4064
	// (such as loading iframes in IE - #4833) 
4065
	var documentElement = (elem ? elem.ownerDocument || elem : 0).documentElement;
4066
	return documentElement ? documentElement.nodeName !== "HTML" : false;
4067
};
4068

  
4069
var posProcess = function(selector, context){
4070
	var tmpSet = [], later = "", match,
4071
		root = context.nodeType ? [context] : context;
4072

  
4073
	// Position selectors must be done after the filter
4074
	// And so must :not(positional) so we move all PSEUDOs to the end
4075
	while ( (match = Expr.match.PSEUDO.exec( selector )) ) {
4076
		later += match[0];
4077
		selector = selector.replace( Expr.match.PSEUDO, "" );
4078
	}
4079

  
4080
	selector = Expr.relative[selector] ? selector + "*" : selector;
4081

  
4082
	for ( var i = 0, l = root.length; i < l; i++ ) {
4083
		Sizzle( selector, root[i], tmpSet );
4084
	}
4085

  
4086
	return Sizzle.filter( later, tmpSet );
4087
};
4088

  
4089
// EXPOSE
4090
jQuery.find = Sizzle;
4091
jQuery.expr = Sizzle.selectors;
4092
jQuery.expr[":"] = jQuery.expr.filters;
4093
jQuery.unique = Sizzle.uniqueSort;
4094
jQuery.text = Sizzle.getText;
4095
jQuery.isXMLDoc = Sizzle.isXML;
4096
jQuery.contains = Sizzle.contains;
4097

  
4098

  
4099
})();
4100

  
4101

  
4102
var runtil = /Until$/,
4103
	rparentsprev = /^(?:parents|prevUntil|prevAll)/,
4104
	// Note: This RegExp should be improved, or likely pulled from Sizzle
4105
	rmultiselector = /,/,
4106
	isSimple = /^.[^:#\[\.,]*$/,
4107
	slice = Array.prototype.slice,
4108
	POS = jQuery.expr.match.POS;
4109

  
4110
jQuery.fn.extend({
4111
	find: function( selector ) {
4112
		var ret = this.pushStack( "", "find", selector ), length = 0;
4113

  
4114
		for ( var i = 0, l = this.length; i < l; i++ ) {
4115
			length = ret.length;
4116
			jQuery.find( selector, this[i], ret );
4117

  
4118
			if ( i > 0 ) {
4119
				// Make sure that the results are unique
4120
				for ( var n = length; n < ret.length; n++ ) {
4121
					for ( var r = 0; r < length; r++ ) {
4122
						if ( ret[r] === ret[n] ) {
4123
							ret.splice(n--, 1);
4124
							break;
4125
						}
4126
					}
4127
				}
4128
			}
4129
		}
4130

  
4131
		return ret;
4132
	},
4133

  
4134
	has: function( target ) {
4135
		var targets = jQuery( target );
4136
		return this.filter(function() {
4137
			for ( var i = 0, l = targets.length; i < l; i++ ) {
4138
				if ( jQuery.contains( this, targets[i] ) ) {
4139
					return true;
4140
				}
4141
			}
4142
		});
4143
	},
4144

  
4145
	not: function( selector ) {
4146
		return this.pushStack( winnow(this, selector, false), "not", selector);
4147
	},
4148

  
4149
	filter: function( selector ) {
4150
		return this.pushStack( winnow(this, selector, true), "filter", selector );
4151
	},
4152
	
4153
	is: function( selector ) {
4154
		return !!selector && jQuery.filter( selector, this ).length > 0;
4155
	},
4156

  
4157
	closest: function( selectors, context ) {
4158
		var ret = [], i, l, cur = this[0];
4159

  
4160
		if ( jQuery.isArray( selectors ) ) {
4161
			var match, matches = {}, selector, level = 1;
4162

  
4163
			if ( cur && selectors.length ) {
4164
				for ( i = 0, l = selectors.length; i < l; i++ ) {
4165
					selector = selectors[i];
4166

  
4167
					if ( !matches[selector] ) {
4168
						matches[selector] = jQuery.expr.match.POS.test( selector ) ? 
4169
							jQuery( selector, context || this.context ) :
4170
							selector;
4171
					}
4172
				}
4173

  
4174
				while ( cur && cur.ownerDocument && cur !== context ) {
4175
					for ( selector in matches ) {
4176
						match = matches[selector];
4177

  
4178
						if ( match.jquery ? match.index(cur) > -1 : jQuery(cur).is(match) ) {
4179
							ret.push({ selector: selector, elem: cur, level: level });
4180
						}
4181
					}
4182

  
4183
					cur = cur.parentNode;
4184
					level++;
4185
				}
4186
			}
4187

  
4188
			return ret;
4189
		}
4190

  
4191
		var pos = POS.test( selectors ) ? 
4192
			jQuery( selectors, context || this.context ) : null;
4193

  
4194
		for ( i = 0, l = this.length; i < l; i++ ) {
4195
			cur = this[i];
4196

  
4197
			while ( cur ) {
4198
				if ( pos ? pos.index(cur) > -1 : jQuery.find.matchesSelector(cur, selectors) ) {
4199
					ret.push( cur );
4200
					break;
4201

  
4202
				} else {
4203
					cur = cur.parentNode;
4204
					if ( !cur || !cur.ownerDocument || cur === context ) {
4205
						break;
4206
					}
4207
				}
4208
			}
4209
		}
4210

  
4211
		ret = ret.length > 1 ? jQuery.unique(ret) : ret;
4212
		
4213
		return this.pushStack( ret, "closest", selectors );
4214
	},
4215
	
4216
	// Determine the position of an element within
4217
	// the matched set of elements
4218
	index: function( elem ) {
4219
		if ( !elem || typeof elem === "string" ) {
4220
			return jQuery.inArray( this[0],
4221
				// If it receives a string, the selector is used
4222
				// If it receives nothing, the siblings are used
4223
				elem ? jQuery( elem ) : this.parent().children() );
4224
		}
4225
		// Locate the position of the desired element
4226
		return jQuery.inArray(
4227
			// If it receives a jQuery object, the first element is used
4228
			elem.jquery ? elem[0] : elem, this );
4229
	},
4230

  
4231
	add: function( selector, context ) {
4232
		var set = typeof selector === "string" ?
4233
				jQuery( selector, context || this.context ) :
4234
				jQuery.makeArray( selector ),
4235
			all = jQuery.merge( this.get(), set );
4236

  
4237
		return this.pushStack( isDisconnected( set[0] ) || isDisconnected( all[0] ) ?
4238
			all :
4239
			jQuery.unique( all ) );
4240
	},
4241

  
4242
	andSelf: function() {
4243
		return this.add( this.prevObject );
4244
	}
4245
});
4246

  
4247
// A painfully simple check to see if an element is disconnected
4248
// from a document (should be improved, where feasible).
4249
function isDisconnected( node ) {
4250
	return !node || !node.parentNode || node.parentNode.nodeType === 11;
4251
}
4252

  
4253
jQuery.each({
4254
	parent: function( elem ) {
4255
		var parent = elem.parentNode;
4256
		return parent && parent.nodeType !== 11 ? parent : null;
4257
	},
4258
	parents: function( elem ) {
4259
		return jQuery.dir( elem, "parentNode" );
4260
	},
4261
	parentsUntil: function( elem, i, until ) {
4262
		return jQuery.dir( elem, "parentNode", until );
4263
	},
4264
	next: function( elem ) {
4265
		return jQuery.nth( elem, 2, "nextSibling" );
4266
	},
4267
	prev: function( elem ) {
4268
		return jQuery.nth( elem, 2, "previousSibling" );
4269
	},
4270
	nextAll: function( elem ) {
4271
		return jQuery.dir( elem, "nextSibling" );
4272
	},
4273
	prevAll: function( elem ) {
4274
		return jQuery.dir( elem, "previousSibling" );
4275
	},
4276
	nextUntil: function( elem, i, until ) {
4277
		return jQuery.dir( elem, "nextSibling", until );
4278
	},
4279
	prevUntil: function( elem, i, until ) {
4280
		return jQuery.dir( elem, "previousSibling", until );
4281
	},
4282
	siblings: function( elem ) {
4283
		return jQuery.sibling( elem.parentNode.firstChild, elem );
4284
	},
4285
	children: function( elem ) {
4286
		return jQuery.sibling( elem.firstChild );
4287
	},
4288
	contents: function( elem ) {
4289
		return jQuery.nodeName( elem, "iframe" ) ?
4290
			elem.contentDocument || elem.contentWindow.document :
4291
			jQuery.makeArray( elem.childNodes );
4292
	}
4293
}, function( name, fn ) {
4294
	jQuery.fn[ name ] = function( until, selector ) {
4295
		var ret = jQuery.map( this, fn, until );
4296
		
4297
		if ( !runtil.test( name ) ) {
4298
			selector = until;
4299
		}
4300

  
4301
		if ( selector && typeof selector === "string" ) {
4302
			ret = jQuery.filter( selector, ret );
4303
		}
4304

  
4305
		ret = this.length > 1 ? jQuery.unique( ret ) : ret;
4306

  
4307
		if ( (this.length > 1 || rmultiselector.test( selector )) && rparentsprev.test( name ) ) {
4308
			ret = ret.reverse();
4309
		}
4310

  
4311
		return this.pushStack( ret, name, slice.call(arguments).join(",") );
4312
	};
4313
});
4314

  
4315
jQuery.extend({
4316
	filter: function( expr, elems, not ) {
4317
		if ( not ) {
4318
			expr = ":not(" + expr + ")";
4319
		}
4320

  
4321
		return elems.length === 1 ?
4322
			jQuery.find.matchesSelector(elems[0], expr) ? [ elems[0] ] : [] :
4323
			jQuery.find.matches(expr, elems);
4324
	},
4325
	
4326
	dir: function( elem, dir, until ) {
4327
		var matched = [], cur = elem[dir];
4328
		while ( cur && cur.nodeType !== 9 && (until === undefined || cur.nodeType !== 1 || !jQuery( cur ).is( until )) ) {
4329
			if ( cur.nodeType === 1 ) {
4330
				matched.push( cur );
4331
			}
4332
			cur = cur[dir];
4333
		}
4334
		return matched;
4335
	},
4336

  
4337
	nth: function( cur, result, dir, elem ) {
4338
		result = result || 1;
4339
		var num = 0;
4340

  
4341
		for ( ; cur; cur = cur[dir] ) {
4342
			if ( cur.nodeType === 1 && ++num === result ) {
4343
				break;
4344
			}
4345
		}
4346

  
4347
		return cur;
4348
	},
4349

  
4350
	sibling: function( n, elem ) {
4351
		var r = [];
4352

  
4353
		for ( ; n; n = n.nextSibling ) {
4354
			if ( n.nodeType === 1 && n !== elem ) {
4355
				r.push( n );
4356
			}
4357
		}
4358

  
4359
		return r;
4360
	}
4361
});
4362

  
4363
// Implement the identical functionality for filter and not
4364
function winnow( elements, qualifier, keep ) {
4365
	if ( jQuery.isFunction( qualifier ) ) {
4366
		return jQuery.grep(elements, function( elem, i ) {
4367
			var retVal = !!qualifier.call( elem, i, elem );
4368
			return retVal === keep;
4369
		});
4370

  
4371
	} else if ( qualifier.nodeType ) {
4372
		return jQuery.grep(elements, function( elem, i ) {
4373
			return (elem === qualifier) === keep;
4374
		});
4375

  
4376
	} else if ( typeof qualifier === "string" ) {
4377
		var filtered = jQuery.grep(elements, function( elem ) {
4378
			return elem.nodeType === 1;
4379
		});
4380

  
4381
		if ( isSimple.test( qualifier ) ) {
4382
			return jQuery.filter(qualifier, filtered, !keep);
4383
		} else {
4384
			qualifier = jQuery.filter( qualifier, filtered );
4385
		}
4386
	}
4387

  
4388
	return jQuery.grep(elements, function( elem, i ) {
4389
		return (jQuery.inArray( elem, qualifier ) >= 0) === keep;
4390
	});
4391
}
4392

  
4393

  
4394

  
4395

  
4396
var rinlinejQuery = / jQuery\d+="(?:\d+|null)"/g,
4397
	rleadingWhitespace = /^\s+/,
4398
	rxhtmlTag = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:]+)[^>]*)\/>/ig,
4399
	rtagName = /<([\w:]+)/,
4400
	rtbody = /<tbody/i,
4401
	rhtml = /<|&#?\w+;/,
4402
	rnocache = /<(?:script|object|embed|option|style)/i,
4403
	rchecked = /checked\s*(?:[^=]|=\s*.checked.)/i,  // checked="checked" or checked (html5)
4404
	raction = /\=([^="'>\s]+\/)>/g,
4405
	wrapMap = {
4406
		option: [ 1, "<select multiple='multiple'>", "</select>" ],
4407
		legend: [ 1, "<fieldset>", "</fieldset>" ],
4408
		thead: [ 1, "<table>", "</table>" ],
4409
		tr: [ 2, "<table><tbody>", "</tbody></table>" ],
4410
		td: [ 3, "<table><tbody><tr>", "</tr></tbody></table>" ],
4411
		col: [ 2, "<table><tbody></tbody><colgroup>", "</colgroup></table>" ],
4412
		area: [ 1, "<map>", "</map>" ],
4413
		_default: [ 0, "", "" ]
4414
	};
4415

  
4416
wrapMap.optgroup = wrapMap.option;
4417
wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;
4418
wrapMap.th = wrapMap.td;
4419

  
4420
// IE can't serialize <link> and <script> tags normally
4421
if ( !jQuery.support.htmlSerialize ) {
4422
	wrapMap._default = [ 1, "div<div>", "</div>" ];
4423
}
4424

  
4425
jQuery.fn.extend({
4426
	text: function( text ) {
4427
		if ( jQuery.isFunction(text) ) {
4428
			return this.each(function(i) {
4429
				var self = jQuery(this);
4430
				self.text( text.call(this, i, self.text()) );
4431
			});
4432
		}
4433

  
4434
		if ( typeof text !== "object" && text !== undefined ) {
4435
			return this.empty().append( (this[0] && this[0].ownerDocument || document).createTextNode( text ) );
4436
		}
4437

  
4438
		return jQuery.text( this );
4439
	},
4440

  
4441
	wrapAll: function( html ) {
4442
		if ( jQuery.isFunction( html ) ) {
4443
			return this.each(function(i) {
4444
				jQuery(this).wrapAll( html.call(this, i) );
4445
			});
4446
		}
4447

  
4448
		if ( this[0] ) {
4449
			// The elements to wrap the target around
4450
			var wrap = jQuery( html, this[0].ownerDocument ).eq(0).clone(true);
4451

  
4452
			if ( this[0].parentNode ) {
4453
				wrap.insertBefore( this[0] );
4454
			}
4455

  
4456
			wrap.map(function() {
4457
				var elem = this;
4458

  
4459
				while ( elem.firstChild && elem.firstChild.nodeType === 1 ) {
4460
					elem = elem.firstChild;
4461
				}
4462

  
4463
				return elem;
4464
			}).append(this);
4465
		}
4466

  
4467
		return this;
4468
	},
4469

  
4470
	wrapInner: function( html ) {
4471
		if ( jQuery.isFunction( html ) ) {
4472
			return this.each(function(i) {
4473
				jQuery(this).wrapInner( html.call(this, i) );
4474
			});
4475
		}
4476

  
4477
		return this.each(function() {
4478
			var self = jQuery( this ), contents = self.contents();
4479

  
4480
			if ( contents.length ) {
4481
				contents.wrapAll( html );
4482

  
4483
			} else {
4484
				self.append( html );
4485
			}
4486
		});
4487
	},
4488

  
4489
	wrap: function( html ) {
4490
		return this.each(function() {
4491
			jQuery( this ).wrapAll( html );
4492
		});
4493
	},
4494

  
4495
	unwrap: function() {
4496
		return this.parent().each(function() {
4497
			if ( !jQuery.nodeName( this, "body" ) ) {
4498
				jQuery( this ).replaceWith( this.childNodes );
4499
			}
4500
		}).end();
4501
	},
4502

  
4503
	append: function() {
4504
		return this.domManip(arguments, true, function( elem ) {
4505
			if ( this.nodeType === 1 ) {
4506
				this.appendChild( elem );
4507
			}
4508
		});
4509
	},
4510

  
4511
	prepend: function() {
4512
		return this.domManip(arguments, true, function( elem ) {
4513
			if ( this.nodeType === 1 ) {
4514
				this.insertBefore( elem, this.firstChild );
4515
			}
4516
		});
4517
	},
4518

  
4519
	before: function() {
4520
		if ( this[0] && this[0].parentNode ) {
4521
			return this.domManip(arguments, false, function( elem ) {
4522
				this.parentNode.insertBefore( elem, this );
4523
			});
4524
		} else if ( arguments.length ) {
4525
			var set = jQuery(arguments[0]);
4526
			set.push.apply( set, this.toArray() );
4527
			return this.pushStack( set, "before", arguments );
4528
		}
4529
	},
4530

  
4531
	after: function() {
4532
		if ( this[0] && this[0].parentNode ) {
4533
			return this.domManip(arguments, false, function( elem ) {
4534
				this.parentNode.insertBefore( elem, this.nextSibling );
4535
			});
4536
		} else if ( arguments.length ) {
4537
			var set = this.pushStack( this, "after", arguments );
4538
			set.push.apply( set, jQuery(arguments[0]).toArray() );
4539
			return set;
4540
		}
4541
	},
4542
	
4543
	// keepData is for internal use only--do not document
4544
	remove: function( selector, keepData ) {
4545
		for ( var i = 0, elem; (elem = this[i]) != null; i++ ) {
4546
			if ( !selector || jQuery.filter( selector, [ elem ] ).length ) {
4547
				if ( !keepData && elem.nodeType === 1 ) {
4548
					jQuery.cleanData( elem.getElementsByTagName("*") );
4549
					jQuery.cleanData( [ elem ] );
4550
				}
4551

  
4552
				if ( elem.parentNode ) {
4553
					 elem.parentNode.removeChild( elem );
4554
				}
4555
			}
4556
		}
4557
		
4558
		return this;
4559
	},
4560

  
4561
	empty: function() {
4562
		for ( var i = 0, elem; (elem = this[i]) != null; i++ ) {
4563
			// Remove element nodes and prevent memory leaks
4564
			if ( elem.nodeType === 1 ) {
4565
				jQuery.cleanData( elem.getElementsByTagName("*") );
4566
			}
4567

  
4568
			// Remove any remaining nodes
4569
			while ( elem.firstChild ) {
4570
				elem.removeChild( elem.firstChild );
4571
			}
4572
		}
4573
		
4574
		return this;
4575
	},
4576

  
4577
	clone: function( events ) {
4578
		// Do the clone
4579
		var ret = this.map(function() {
4580
			if ( !jQuery.support.noCloneEvent && !jQuery.isXMLDoc(this) ) {
4581
				// IE copies events bound via attachEvent when
4582
				// using cloneNode. Calling detachEvent on the
4583
				// clone will also remove the events from the orignal
4584
				// In order to get around this, we use innerHTML.
4585
				// Unfortunately, this means some modifications to
4586
				// attributes in IE that are actually only stored
4587
				// as properties will not be copied (such as the
4588
				// the name attribute on an input).
4589
				var html = this.outerHTML, ownerDocument = this.ownerDocument;
4590
				if ( !html ) {
4591
					var div = ownerDocument.createElement("div");
4592
					div.appendChild( this.cloneNode(true) );
4593
					html = div.innerHTML;
4594
				}
4595

  
4596
				return jQuery.clean([html.replace(rinlinejQuery, "")
4597
					// Handle the case in IE 8 where action=/test/> self-closes a tag
4598
					.replace(raction, '="$1">')
4599
					.replace(rleadingWhitespace, "")], ownerDocument)[0];
4600
			} else {
4601
				return this.cloneNode(true);
4602
			}
4603
		});
4604

  
4605
		// Copy the events from the original to the clone
4606
		if ( events === true ) {
4607
			cloneCopyEvent( this, ret );
4608
			cloneCopyEvent( this.find("*"), ret.find("*") );
4609
		}
4610

  
4611
		// Return the cloned set
4612
		return ret;
4613
	},
4614

  
4615
	html: function( value ) {
4616
		if ( value === undefined ) {
4617
			return this[0] && this[0].nodeType === 1 ?
4618
				this[0].innerHTML.replace(rinlinejQuery, "") :
4619
				null;
4620

  
4621
		// See if we can take a shortcut and just use innerHTML
4622
		} else if ( typeof value === "string" && !rnocache.test( value ) &&
4623
			(jQuery.support.leadingWhitespace || !rleadingWhitespace.test( value )) &&
4624
			!wrapMap[ (rtagName.exec( value ) || ["", ""])[1].toLowerCase() ] ) {
4625

  
4626
			value = value.replace(rxhtmlTag, "<$1></$2>");
4627

  
4628
			try {
4629
				for ( var i = 0, l = this.length; i < l; i++ ) {
4630
					// Remove element nodes and prevent memory leaks
4631
					if ( this[i].nodeType === 1 ) {
4632
						jQuery.cleanData( this[i].getElementsByTagName("*") );
4633
						this[i].innerHTML = value;
4634
					}
4635
				}
4636

  
4637
			// If using innerHTML throws an exception, use the fallback method
4638
			} catch(e) {
4639
				this.empty().append( value );
4640
			}
4641

  
4642
		} else if ( jQuery.isFunction( value ) ) {
4643
			this.each(function(i){
4644
				var self = jQuery(this);
4645
				self.html( value.call(this, i, self.html()) );
4646
			});
4647

  
4648
		} else {
4649
			this.empty().append( value );
4650
		}
4651

  
4652
		return this;
4653
	},
4654

  
4655
	replaceWith: function( value ) {
4656
		if ( this[0] && this[0].parentNode ) {
4657
			// Make sure that the elements are removed from the DOM before they are inserted
4658
			// this can help fix replacing a parent with child elements
4659
			if ( jQuery.isFunction( value ) ) {
4660
				return this.each(function(i) {
4661
					var self = jQuery(this), old = self.html();
4662
					self.replaceWith( value.call( this, i, old ) );
4663
				});
4664
			}
4665

  
4666
			if ( typeof value !== "string" ) {
4667
				value = jQuery(value).detach();
4668
			}
4669

  
4670
			return this.each(function() {
4671
				var next = this.nextSibling, parent = this.parentNode;
4672

  
4673
				jQuery(this).remove();
4674

  
4675
				if ( next ) {
4676
					jQuery(next).before( value );
4677
				} else {
4678
					jQuery(parent).append( value );
4679
				}
4680
			});
4681
		} else {
4682
			return this.pushStack( jQuery(jQuery.isFunction(value) ? value() : value), "replaceWith", value );
4683
		}
4684
	},
4685

  
4686
	detach: function( selector ) {
4687
		return this.remove( selector, true );
4688
	},
4689

  
4690
	domManip: function( args, table, callback ) {
4691
		var results, first, value = args[0], scripts = [], fragment, parent;
4692

  
4693
		// We can't cloneNode fragments that contain checked, in WebKit
4694
		if ( !jQuery.support.checkClone && arguments.length === 3 && typeof value === "string" && rchecked.test( value ) ) {
4695
			return this.each(function() {
4696
				jQuery(this).domManip( args, table, callback, true );
4697
			});
4698
		}
4699

  
4700
		if ( jQuery.isFunction(value) ) {
4701
			return this.each(function(i) {
4702
				var self = jQuery(this);
4703
				args[0] = value.call(this, i, table ? self.html() : undefined);
4704
				self.domManip( args, table, callback );
4705
			});
4706
		}
4707

  
4708
		if ( this[0] ) {
4709
			parent = value && value.parentNode;
4710

  
4711
			// If we're in a fragment, just use that instead of building a new one
4712
			if ( jQuery.support.parentNode && parent && parent.nodeType === 11 && parent.childNodes.length === this.length ) {
4713
				results = { fragment: parent };
4714

  
4715
			} else {
4716
				results = jQuery.buildFragment( args, this, scripts );
4717
			}
4718
			
4719
			fragment = results.fragment;
4720
			
4721
			if ( fragment.childNodes.length === 1 ) {
4722
				first = fragment = fragment.firstChild;
4723
			} else {
4724
				first = fragment.firstChild;
4725
			}
4726

  
4727
			if ( first ) {
4728
				table = table && jQuery.nodeName( first, "tr" );
4729

  
4730
				for ( var i = 0, l = this.length; i < l; i++ ) {
4731
					callback.call(
4732
						table ?
4733
							root(this[i], first) :
4734
							this[i],
4735
						i > 0 || results.cacheable || this.length > 1  ?
4736
							fragment.cloneNode(true) :
4737
							fragment
4738
					);
4739
				}
4740
			}
4741

  
4742
			if ( scripts.length ) {
4743
				jQuery.each( scripts, evalScript );
4744
			}
4745
		}
4746

  
4747
		return this;
4748
	}
4749
});
4750

  
4751
function root( elem, cur ) {
4752
	return jQuery.nodeName(elem, "table") ?
4753
		(elem.getElementsByTagName("tbody")[0] ||
4754
		elem.appendChild(elem.ownerDocument.createElement("tbody"))) :
4755
		elem;
4756
}
4757

  
4758
function cloneCopyEvent(orig, ret) {
4759
	var i = 0;
4760

  
4761
	ret.each(function() {
4762
		if ( this.nodeName !== (orig[i] && orig[i].nodeName) ) {
4763
			return;
4764
		}
4765

  
4766
		var oldData = jQuery.data( orig[i++] ), curData = jQuery.data( this, oldData ), events = oldData && oldData.events;
4767

  
4768
		if ( events ) {
4769
			delete curData.handle;
4770
			curData.events = {};
4771

  
4772
			for ( var type in events ) {
4773
				for ( var handler in events[ type ] ) {
4774
					jQuery.event.add( this, type, events[ type ][ handler ], events[ type ][ handler ].data );
4775
				}
4776
			}
4777
		}
4778
	});
4779
}
4780

  
4781
jQuery.buildFragment = function( args, nodes, scripts ) {
4782
	var fragment, cacheable, cacheresults,
4783
		doc = (nodes && nodes[0] ? nodes[0].ownerDocument || nodes[0] : document);
4784

  
4785
	// Only cache "small" (1/2 KB) strings that are associated with the main document
4786
	// Cloning options loses the selected state, so don't cache them
4787
	// IE 6 doesn't like it when you put <object> or <embed> elements in a fragment
4788
	// Also, WebKit does not clone 'checked' attributes on cloneNode, so don't cache
4789
	if ( args.length === 1 && typeof args[0] === "string" && args[0].length < 512 && doc === document &&
4790
		!rnocache.test( args[0] ) && (jQuery.support.checkClone || !rchecked.test( args[0] )) ) {
4791

  
4792
		cacheable = true;
4793
		cacheresults = jQuery.fragments[ args[0] ];
4794
		if ( cacheresults ) {
4795
			if ( cacheresults !== 1 ) {
4796
				fragment = cacheresults;
4797
			}
4798
		}
4799
	}
4800

  
4801
	if ( !fragment ) {
4802
		fragment = doc.createDocumentFragment();
4803
		jQuery.clean( args, doc, fragment, scripts );
4804
	}
4805

  
4806
	if ( cacheable ) {
4807
		jQuery.fragments[ args[0] ] = cacheresults ? fragment : 1;
4808
	}
4809

  
4810
	return { fragment: fragment, cacheable: cacheable };
4811
};
4812

  
4813
jQuery.fragments = {};
4814

  
4815
jQuery.each({
4816
	appendTo: "append",
4817
	prependTo: "prepend",
4818
	insertBefore: "before",
4819
	insertAfter: "after",
4820
	replaceAll: "replaceWith"
4821
}, function( name, original ) {
4822
	jQuery.fn[ name ] = function( selector ) {
4823
		var ret = [], insert = jQuery( selector ),
4824
			parent = this.length === 1 && this[0].parentNode;
4825
		
4826
		if ( parent && parent.nodeType === 11 && parent.childNodes.length === 1 && insert.length === 1 ) {
4827
			insert[ original ]( this[0] );
4828
			return this;
4829
			
4830
		} else {
4831
			for ( var i = 0, l = insert.length; i < l; i++ ) {
4832
				var elems = (i > 0 ? this.clone(true) : this).get();
4833
				jQuery( insert[i] )[ original ]( elems );
4834
				ret = ret.concat( elems );
4835
			}
4836
		
4837
			return this.pushStack( ret, name, insert.selector );
4838
		}
4839
	};
4840
});
4841

  
4842
jQuery.extend({
4843
	clean: function( elems, context, fragment, scripts ) {
4844
		context = context || document;
4845

  
4846
		// !context.createElement fails in IE with an error but returns typeof 'object'
4847
		if ( typeof context.createElement === "undefined" ) {
4848
			context = context.ownerDocument || context[0] && context[0].ownerDocument || document;
4849
		}
4850

  
4851
		var ret = [];
4852

  
4853
		for ( var i = 0, elem; (elem = elems[i]) != null; i++ ) {
4854
			if ( typeof elem === "number" ) {
4855
				elem += "";
4856
			}
4857

  
4858
			if ( !elem ) {
4859
				continue;
4860
			}
4861

  
4862
			// Convert html string into DOM nodes
4863
			if ( typeof elem === "string" && !rhtml.test( elem ) ) {
4864
				elem = context.createTextNode( elem );
4865

  
4866
			} else if ( typeof elem === "string" ) {
4867
				// Fix "XHTML"-style tags in all browsers
4868
				elem = elem.replace(rxhtmlTag, "<$1></$2>");
4869

  
4870
				// Trim whitespace, otherwise indexOf won't work as expected
4871
				var tag = (rtagName.exec( elem ) || ["", ""])[1].toLowerCase(),
4872
					wrap = wrapMap[ tag ] || wrapMap._default,
4873
					depth = wrap[0],
4874
					div = context.createElement("div");
4875

  
4876
				// Go to html and back, then peel off extra wrappers
4877
				div.innerHTML = wrap[1] + elem + wrap[2];
4878

  
4879
				// Move to the right depth
4880
				while ( depth-- ) {
4881
					div = div.lastChild;
4882
				}
4883

  
4884
				// Remove IE's autoinserted <tbody> from table fragments
4885
				if ( !jQuery.support.tbody ) {
4886

  
4887
					// String was a <table>, *may* have spurious <tbody>
4888
					var hasBody = rtbody.test(elem),
4889
						tbody = tag === "table" && !hasBody ?
4890
							div.firstChild && div.firstChild.childNodes :
4891

  
4892
							// String was a bare <thead> or <tfoot>
4893
							wrap[1] === "<table>" && !hasBody ?
4894
								div.childNodes :
4895
								[];
4896

  
4897
					for ( var j = tbody.length - 1; j >= 0 ; --j ) {
4898
						if ( jQuery.nodeName( tbody[ j ], "tbody" ) && !tbody[ j ].childNodes.length ) {
4899
							tbody[ j ].parentNode.removeChild( tbody[ j ] );
4900
						}
4901
					}
4902

  
4903
				}
4904

  
4905
				// IE completely kills leading whitespace when innerHTML is used
4906
				if ( !jQuery.support.leadingWhitespace && rleadingWhitespace.test( elem ) ) {
4907
					div.insertBefore( context.createTextNode( rleadingWhitespace.exec(elem)[0] ), div.firstChild );
4908
				}
4909

  
4910
				elem = div.childNodes;
4911
			}
4912

  
4913
			if ( elem.nodeType ) {
4914
				ret.push( elem );
4915
			} else {
4916
				ret = jQuery.merge( ret, elem );
4917
			}
4918
		}
4919

  
4920
		if ( fragment ) {
4921
			for ( i = 0; ret[i]; i++ ) {
4922
				if ( scripts && jQuery.nodeName( ret[i], "script" ) && (!ret[i].type || ret[i].type.toLowerCase() === "text/javascript") ) {
4923
					scripts.push( ret[i].parentNode ? ret[i].parentNode.removeChild( ret[i] ) : ret[i] );
4924
				
4925
				} else {
4926
					if ( ret[i].nodeType === 1 ) {
4927
						ret.splice.apply( ret, [i + 1, 0].concat(jQuery.makeArray(ret[i].getElementsByTagName("script"))) );
4928
					}
4929
					fragment.appendChild( ret[i] );
4930
				}
4931
			}
4932
		}
4933

  
4934
		return ret;
4935
	},
4936
	
4937
	cleanData: function( elems ) {
4938
		var data, id, cache = jQuery.cache,
4939
			special = jQuery.event.special,
4940
			deleteExpando = jQuery.support.deleteExpando;
4941
		
4942
		for ( var i = 0, elem; (elem = elems[i]) != null; i++ ) {
4943
			if ( elem.nodeName && jQuery.noData[elem.nodeName.toLowerCase()] ) {
4944
				continue;
4945
			}
4946

  
4947
			id = elem[ jQuery.expando ];
4948
			
4949
			if ( id ) {
4950
				data = cache[ id ];
4951
				
4952
				if ( data && data.events ) {
4953
					for ( var type in data.events ) {
4954
						if ( special[ type ] ) {
4955
							jQuery.event.remove( elem, type );
4956

  
4957
						} else {
4958
							jQuery.removeEvent( elem, type, data.handle );
4959
						}
4960
					}
4961
				}
4962
				
4963
				if ( deleteExpando ) {
4964
					delete elem[ jQuery.expando ];
4965

  
4966
				} else if ( elem.removeAttribute ) {
4967
					elem.removeAttribute( jQuery.expando );
4968
				}
4969
				
4970
				delete cache[ id ];
4971
			}
4972
		}
4973
	}
4974
});
4975

  
4976
function evalScript( i, elem ) {
4977
	if ( elem.src ) {
4978
		jQuery.ajax({
4979
			url: elem.src,
4980
			async: false,
4981
			dataType: "script"
4982
		});
4983
	} else {
4984
		jQuery.globalEval( elem.text || elem.textContent || elem.innerHTML || "" );
4985
	}
4986

  
4987
	if ( elem.parentNode ) {
4988
		elem.parentNode.removeChild( elem );
4989
	}
4990
}
4991

  
4992

  
4993

  
4994

  
4995
var ralpha = /alpha\([^)]*\)/i,
4996
	ropacity = /opacity=([^)]*)/,
4997
	rdashAlpha = /-([a-z])/ig,
4998
	rupper = /([A-Z])/g,
4999
	rnumpx = /^-?\d+(?:px)?$/i,
5000
	rnum = /^-?\d/,
5001

  
5002
	cssShow = { position: "absolute", visibility: "hidden", display: "block" },
5003
	cssWidth = [ "Left", "Right" ],
5004
	cssHeight = [ "Top", "Bottom" ],
5005
	curCSS,
5006

  
5007
	// cache check for defaultView.getComputedStyle
5008
	getComputedStyle = document.defaultView && document.defaultView.getComputedStyle,
5009

  
5010
	fcamelCase = function( all, letter ) {
5011
		return letter.toUpperCase();
5012
	};
5013

  
5014
jQuery.fn.css = function( name, value ) {
5015
	// Setting 'undefined' is a no-op
5016
	if ( arguments.length === 2 && value === undefined ) {
5017
		return this;
5018
	}
5019

  
5020
	return jQuery.access( this, name, value, true, function( elem, name, value ) {
5021
		return value !== undefined ?
5022
			jQuery.style( elem, name, value ) :
5023
			jQuery.css( elem, name );
5024
	});
5025
};
5026

  
5027
jQuery.extend({
5028
	// Add in style property hooks for overriding the default
5029
	// behavior of getting and setting a style property
5030
	cssHooks: {
5031
		opacity: {
5032
			get: function( elem, computed ) {
5033
				if ( computed ) {
5034
					// We should always get a number back from opacity
5035
					var ret = curCSS( elem, "opacity", "opacity" );
5036
					return ret === "" ? "1" : ret;
5037

  
5038
				} else {
5039
					return elem.style.opacity;
5040
				}
5041
			}
5042
		}
5043
	},
5044

  
5045
	// Exclude the following css properties to add px
5046
	cssNumber: {
5047
		"zIndex": true,
5048
		"fontWeight": true,
5049
		"opacity": true,
5050
		"zoom": true,
5051
		"lineHeight": true
5052
	},
5053

  
5054
	// Add in properties whose names you wish to fix before
5055
	// setting or getting the value
5056
	cssProps: {
5057
		// normalize float css property
5058
		"float": jQuery.support.cssFloat ? "cssFloat" : "styleFloat"
5059
	},
5060

  
5061
	// Get and set the style property on a DOM Node
5062
	style: function( elem, name, value, extra ) {
5063
		// Don't set styles on text and comment nodes
5064
		if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style ) {
5065
			return;
5066
		}
5067

  
5068
		// Make sure that we're working with the right name
5069
		var ret, origName = jQuery.camelCase( name ),
5070
			style = elem.style, hooks = jQuery.cssHooks[ origName ];
5071

  
5072
		name = jQuery.cssProps[ origName ] || origName;
5073

  
5074
		// Check if we're setting a value
5075
		if ( value !== undefined ) {
5076
			// Make sure that NaN and null values aren't set. See: #7116
5077
			if ( typeof value === "number" && isNaN( value ) || value == null ) {
5078
				return;
5079
			}
5080

  
5081
			// If a number was passed in, add 'px' to the (except for certain CSS properties)
5082
			if ( typeof value === "number" && !jQuery.cssNumber[ origName ] ) {
5083
				value += "px";
5084
			}
5085

  
5086
			// If a hook was provided, use that value, otherwise just set the specified value
5087
			if ( !hooks || !("set" in hooks) || (value = hooks.set( elem, value )) !== undefined ) {
5088
				// Wrapped to prevent IE from throwing errors when 'invalid' values are provided
5089
				// Fixes bug #5509
5090
				try {
5091
					style[ name ] = value;
5092
				} catch(e) {}
5093
			}
5094

  
5095
		} else {
5096
			// If a hook was provided get the non-computed value from there
5097
			if ( hooks && "get" in hooks && (ret = hooks.get( elem, false, extra )) !== undefined ) {
5098
				return ret;
5099
			}
5100

  
5101
			// Otherwise just get the value from the style object
5102
			return style[ name ];
5103
		}
5104
	},
5105

  
5106
	css: function( elem, name, extra ) {
5107
		// Make sure that we're working with the right name
5108
		var ret, origName = jQuery.camelCase( name ),
5109
			hooks = jQuery.cssHooks[ origName ];
5110

  
5111
		name = jQuery.cssProps[ origName ] || origName;
5112

  
5113
		// If a hook was provided get the computed value from there
5114
		if ( hooks && "get" in hooks && (ret = hooks.get( elem, true, extra )) !== undefined ) {
5115
			return ret;
5116

  
5117
		// Otherwise, if a way to get the computed value exists, use that
5118
		} else if ( curCSS ) {
5119
			return curCSS( elem, name, origName );
5120
		}
5121
	},
5122

  
5123
	// A method for quickly swapping in/out CSS properties to get correct calculations
5124
	swap: function( elem, options, callback ) {
5125
		var old = {};
5126

  
5127
		// Remember the old values, and insert the new ones
5128
		for ( var name in options ) {
5129
			old[ name ] = elem.style[ name ];
5130
			elem.style[ name ] = options[ name ];
5131
		}
5132

  
5133
		callback.call( elem );
5134

  
5135
		// Revert the old values
5136
		for ( name in options ) {
5137
			elem.style[ name ] = old[ name ];
5138
		}
5139
	},
5140

  
5141
	camelCase: function( string ) {
5142
		return string.replace( rdashAlpha, fcamelCase );
5143
	}
5144
});
5145

  
5146
// DEPRECATED, Use jQuery.css() instead
5147
jQuery.curCSS = jQuery.css;
5148

  
5149
jQuery.each(["height", "width"], function( i, name ) {
5150
	jQuery.cssHooks[ name ] = {
5151
		get: function( elem, computed, extra ) {
5152
			var val;
5153

  
5154
			if ( computed ) {
5155
				if ( elem.offsetWidth !== 0 ) {
5156
					val = getWH( elem, name, extra );
5157

  
5158
				} else {
5159
					jQuery.swap( elem, cssShow, function() {
5160
						val = getWH( elem, name, extra );
5161
					});
5162
				}
5163

  
5164
				return val + "px";
5165
			}
5166
		},
5167

  
5168
		set: function( elem, value ) {
5169
			if ( rnumpx.test( value ) ) {
5170
				// ignore negative width and height values #1599
5171
				value = parseFloat(value);
5172

  
5173
				if ( value >= 0 ) {
5174
					return value + "px";
5175
				}
5176

  
5177
			} else {
5178
				return value;
5179
			}
5180
		}
5181
	};
5182
});
5183

  
5184
if ( !jQuery.support.opacity ) {
5185
	jQuery.cssHooks.opacity = {
5186
		get: function( elem, computed ) {
5187
			// IE uses filters for opacity
5188
			return ropacity.test((computed && elem.currentStyle ? elem.currentStyle.filter : elem.style.filter) || "") ?
5189
				(parseFloat(RegExp.$1) / 100) + "" :
5190
				computed ? "1" : "";
5191
		},
5192

  
5193
		set: function( elem, value ) {
5194
			var style = elem.style;
5195

  
5196
			// IE has trouble with opacity if it does not have layout
5197
			// Force it by setting the zoom level
5198
			style.zoom = 1;
5199

  
5200
			// Set the alpha filter to set the opacity
5201
			var opacity = jQuery.isNaN(value) ?
5202
				"" :
5203
				"alpha(opacity=" + value * 100 + ")",
5204
				filter = style.filter || "";
5205

  
5206
			style.filter = ralpha.test(filter) ?
5207
				filter.replace(ralpha, opacity) :
5208
				style.filter + ' ' + opacity;
5209
		}
5210
	};
5211
}
5212

  
5213
if ( getComputedStyle ) {
5214
	curCSS = function( elem, newName, name ) {
5215
		var ret, defaultView, computedStyle;
5216

  
5217
		name = name.replace( rupper, "-$1" ).toLowerCase();
5218

  
5219
		if ( !(defaultView = elem.ownerDocument.defaultView) ) {
5220
			return undefined;
5221
		}
5222

  
5223
		if ( (computedStyle = defaultView.getComputedStyle( elem, null )) ) {
5224
			ret = computedStyle.getPropertyValue( name );
5225
			if ( ret === "" && !jQuery.contains( elem.ownerDocument.documentElement, elem ) ) {
5226
				ret = jQuery.style( elem, name );
5227
			}
5228
		}
5229

  
5230
		return ret;
5231
	};
5232

  
5233
} else if ( document.documentElement.currentStyle ) {
5234
	curCSS = function( elem, name ) {
5235
		var left, rsLeft, ret = elem.currentStyle && elem.currentStyle[ name ], style = elem.style;
5236

  
5237
		// From the awesome hack by Dean Edwards
5238
		// http://erik.eae.net/archives/2007/07/27/18.54.15/#comment-102291
5239

  
5240
		// If we're not dealing with a regular pixel number
5241
		// but a number that has a weird ending, we need to convert it to pixels
5242
		if ( !rnumpx.test( ret ) && rnum.test( ret ) ) {
5243
			// Remember the original values
5244
			left = style.left;
5245
			rsLeft = elem.runtimeStyle.left;
5246

  
5247
			// Put in the new values to get a computed value out
5248
			elem.runtimeStyle.left = elem.currentStyle.left;
5249
			style.left = name === "fontSize" ? "1em" : (ret || 0);
5250
			ret = style.pixelLeft + "px";
5251

  
5252
			// Revert the changed values
5253
			style.left = left;
5254
			elem.runtimeStyle.left = rsLeft;
5255
		}
5256

  
5257
		return ret;
5258
	};
5259
}
5260

  
5261
function getWH( elem, name, extra ) {
5262
	var which = name === "width" ? cssWidth : cssHeight,
5263
		val = name === "width" ? elem.offsetWidth : elem.offsetHeight;
5264

  
5265
	if ( extra === "border" ) {
5266
		return val;
5267
	}
5268

  
5269
	jQuery.each( which, function() {
5270
		if ( !extra ) {
5271
			val -= parseFloat(jQuery.css( elem, "padding" + this )) || 0;
5272
		}
5273

  
5274
		if ( extra === "margin" ) {
5275
			val += parseFloat(jQuery.css( elem, "margin" + this )) || 0;
5276

  
5277
		} else {
5278
			val -= parseFloat(jQuery.css( elem, "border" + this + "Width" )) || 0;
5279
		}
5280
	});
5281

  
5282
	return val;
5283
}
5284

  
5285
if ( jQuery.expr && jQuery.expr.filters ) {
5286
	jQuery.expr.filters.hidden = function( elem ) {
5287
		var width = elem.offsetWidth, height = elem.offsetHeight;
5288

  
5289
		return (width === 0 && height === 0) || (!jQuery.support.reliableHiddenOffsets && (elem.style.display || jQuery.css( elem, "display" )) === "none");
5290
	};
5291

  
5292
	jQuery.expr.filters.visible = function( elem ) {
5293
		return !jQuery.expr.filters.hidden( elem );
5294
	};
5295
}
5296

  
5297

  
5298

  
5299

  
5300
var jsc = jQuery.now(),
5301
	rscript = /<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi,
5302
	rselectTextarea = /^(?:select|textarea)/i,
5303
	rinput = /^(?:color|date|datetime|email|hidden|month|number|password|range|search|tel|text|time|url|week)$/i,
5304
	rnoContent = /^(?:GET|HEAD|DELETE)$/,
5305
	rbracket = /\[\]$/,
5306
	jsre = /\=\?(&|$)/,
5307
	rquery = /\?/,
5308
	rts = /([?&])_=[^&]*/,
5309
	rurl = /^(\w+:)?\/\/([^\/?#]+)/,
5310
	r20 = /%20/g,
5311
	rhash = /#.*$/,
5312

  
5313
	// Keep a copy of the old load method
5314
	_load = jQuery.fn.load;
5315

  
5316
jQuery.fn.extend({
5317
	load: function( url, params, callback ) {
5318
		if ( typeof url !== "string" && _load ) {
5319
			return _load.apply( this, arguments );
5320

  
5321
		// Don't do a request if no elements are being requested
5322
		} else if ( !this.length ) {
5323
			return this;
5324
		}
5325

  
5326
		var off = url.indexOf(" ");
5327
		if ( off >= 0 ) {
5328
			var selector = url.slice(off, url.length);
5329
			url = url.slice(0, off);
5330
		}
5331

  
5332
		// Default to a GET request
5333
		var type = "GET";
5334

  
5335
		// If the second parameter was provided
5336
		if ( params ) {
5337
			// If it's a function
5338
			if ( jQuery.isFunction( params ) ) {
5339
				// We assume that it's the callback
5340
				callback = params;
5341
				params = null;
5342

  
5343
			// Otherwise, build a param string
5344
			} else if ( typeof params === "object" ) {
5345
				params = jQuery.param( params, jQuery.ajaxSettings.traditional );
5346
				type = "POST";
5347
			}
5348
		}
5349

  
5350
		var self = this;
5351

  
5352
		// Request the remote document
5353
		jQuery.ajax({
5354
			url: url,
5355
			type: type,
5356
			dataType: "html",
5357
			data: params,
5358
			complete: function( res, status ) {
5359
				// If successful, inject the HTML into all the matched elements
5360
				if ( status === "success" || status === "notmodified" ) {
5361
					// See if a selector was specified
5362
					self.html( selector ?
5363
						// Create a dummy div to hold the results
5364
						jQuery("<div>")
5365
							// inject the contents of the document in, removing the scripts
5366
							// to avoid any 'Permission Denied' errors in IE
5367
							.append(res.responseText.replace(rscript, ""))
5368

  
5369
							// Locate the specified elements
5370
							.find(selector) :
5371

  
5372
						// If not, just inject the full result
5373
						res.responseText );
5374
				}
5375

  
5376
				if ( callback ) {
5377
					self.each( callback, [res.responseText, status, res] );
5378
				}
5379
			}
5380
		});
5381

  
5382
		return this;
5383
	},
5384

  
5385
	serialize: function() {
5386
		return jQuery.param(this.serializeArray());
5387
	},
5388

  
5389
	serializeArray: function() {
5390
		return this.map(function() {
5391
			return this.elements ? jQuery.makeArray(this.elements) : this;
5392
		})
5393
		.filter(function() {
5394
			return this.name && !this.disabled &&
5395
				(this.checked || rselectTextarea.test(this.nodeName) ||
5396
					rinput.test(this.type));
5397
		})
5398
		.map(function( i, elem ) {
5399
			var val = jQuery(this).val();
5400

  
5401
			return val == null ?
5402
				null :
5403
				jQuery.isArray(val) ?
5404
					jQuery.map( val, function( val, i ) {
5405
						return { name: elem.name, value: val };
5406
					}) :
5407
					{ name: elem.name, value: val };
5408
		}).get();
5409
	}
5410
});
5411

  
5412
// Attach a bunch of functions for handling common AJAX events
5413
jQuery.each( "ajaxStart ajaxStop ajaxComplete ajaxError ajaxSuccess ajaxSend".split(" "), function( i, o ) {
5414
	jQuery.fn[o] = function( f ) {
5415
		return this.bind(o, f);
5416
	};
5417
});
5418

  
5419
jQuery.extend({
5420
	get: function( url, data, callback, type ) {
5421
		// shift arguments if data argument was omited
5422
		if ( jQuery.isFunction( data ) ) {
5423
			type = type || callback;
5424
			callback = data;
5425
			data = null;
5426
		}
5427

  
5428
		return jQuery.ajax({
5429
			type: "GET",
5430
			url: url,
5431
			data: data,
5432
			success: callback,
5433
			dataType: type
5434
		});
5435
	},
5436

  
5437
	getScript: function( url, callback ) {
5438
		return jQuery.get(url, null, callback, "script");
5439
	},
5440

  
5441
	getJSON: function( url, data, callback ) {
5442
		return jQuery.get(url, data, callback, "json");
5443
	},
5444

  
5445
	post: function( url, data, callback, type ) {
5446
		// shift arguments if data argument was omited
5447
		if ( jQuery.isFunction( data ) ) {
5448
			type = type || callback;
5449
			callback = data;
5450
			data = {};
5451
		}
5452

  
5453
		return jQuery.ajax({
5454
			type: "POST",
5455
			url: url,
5456
			data: data,
5457
			success: callback,
5458
			dataType: type
5459
		});
5460
	},
5461

  
5462
	ajaxSetup: function( settings ) {
5463
		jQuery.extend( jQuery.ajaxSettings, settings );
5464
	},
5465

  
5466
	ajaxSettings: {
5467
		url: location.href,
5468
		global: true,
5469
		type: "GET",
5470
		contentType: "application/x-www-form-urlencoded",
5471
		processData: true,
5472
		async: true,
5473
		/*
5474
		timeout: 0,
5475
		data: null,
5476
		username: null,
5477
		password: null,
5478
		traditional: false,
5479
		*/
5480
		// This function can be overriden by calling jQuery.ajaxSetup
5481
		xhr: function() {
5482
			return new window.XMLHttpRequest();
5483
		},
5484
		accepts: {
5485
			xml: "application/xml, text/xml",
5486
			html: "text/html",
5487
			script: "text/javascript, application/javascript",
5488
			json: "application/json, text/javascript",
5489
			text: "text/plain",
5490
			_default: "*/*"
5491
		}
5492
	},
5493

  
5494
	ajax: function( origSettings ) {
5495
		var s = jQuery.extend(true, {}, jQuery.ajaxSettings, origSettings),
5496
			jsonp, status, data, type = s.type.toUpperCase(), noContent = rnoContent.test(type);
5497

  
5498
		s.url = s.url.replace( rhash, "" );
5499

  
5500
		// Use original (not extended) context object if it was provided
5501
		s.context = origSettings && origSettings.context != null ? origSettings.context : s;
5502

  
5503
		// convert data if not already a string
5504
		if ( s.data && s.processData && typeof s.data !== "string" ) {
5505
			s.data = jQuery.param( s.data, s.traditional );
5506
		}
5507

  
5508
		// Handle JSONP Parameter Callbacks
5509
		if ( s.dataType === "jsonp" ) {
5510
			if ( type === "GET" ) {
5511
				if ( !jsre.test( s.url ) ) {
5512
					s.url += (rquery.test( s.url ) ? "&" : "?") + (s.jsonp || "callback") + "=?";
5513
				}
5514
			} else if ( !s.data || !jsre.test(s.data) ) {
5515
				s.data = (s.data ? s.data + "&" : "") + (s.jsonp || "callback") + "=?";
5516
			}
5517
			s.dataType = "json";
5518
		}
5519

  
5520
		// Build temporary JSONP function
5521
		if ( s.dataType === "json" && (s.data && jsre.test(s.data) || jsre.test(s.url)) ) {
5522
			jsonp = s.jsonpCallback || ("jsonp" + jsc++);
5523

  
5524
			// Replace the =? sequence both in the query string and the data
5525
			if ( s.data ) {
5526
				s.data = (s.data + "").replace(jsre, "=" + jsonp + "$1");
5527
			}
5528

  
5529
			s.url = s.url.replace(jsre, "=" + jsonp + "$1");
5530

  
5531
			// We need to make sure
5532
			// that a JSONP style response is executed properly
5533
			s.dataType = "script";
5534

  
5535
			// Handle JSONP-style loading
5536
			var customJsonp = window[ jsonp ];
5537

  
5538
			window[ jsonp ] = function( tmp ) {
5539
				data = tmp;
5540
				jQuery.handleSuccess( s, xhr, status, data );
5541
				jQuery.handleComplete( s, xhr, status, data );
5542

  
5543
				if ( jQuery.isFunction( customJsonp ) ) {
5544
					customJsonp( tmp );
5545

  
5546
				} else {
5547
					// Garbage collect
5548
					window[ jsonp ] = undefined;
5549

  
5550
					try {
5551
						delete window[ jsonp ];
5552
					} catch( jsonpError ) {}
5553
				}
5554
				
5555
				if ( head ) {
5556
					head.removeChild( script );
5557
				}
5558
			};
5559
		}
5560

  
5561
		if ( s.dataType === "script" && s.cache === null ) {
5562
			s.cache = false;
5563
		}
5564

  
5565
		if ( s.cache === false && type === "GET" ) {
5566
			var ts = jQuery.now();
5567

  
5568
			// try replacing _= if it is there
5569
			var ret = s.url.replace(rts, "$1_=" + ts);
5570

  
5571
			// if nothing was replaced, add timestamp to the end
5572
			s.url = ret + ((ret === s.url) ? (rquery.test(s.url) ? "&" : "?") + "_=" + ts : "");
5573
		}
5574

  
5575
		// If data is available, append data to url for get requests
5576
		if ( s.data && type === "GET" ) {
5577
			s.url += (rquery.test(s.url) ? "&" : "?") + s.data;
5578
		}
5579

  
5580
		// Watch for a new set of requests
5581
		if ( s.global && jQuery.active++ === 0 ) {
5582
			jQuery.event.trigger( "ajaxStart" );
5583
		}
5584

  
5585
		// Matches an absolute URL, and saves the domain
5586
		var parts = rurl.exec( s.url ),
5587
			remote = parts && (parts[1] && parts[1] !== location.protocol || parts[2] !== location.host);
5588

  
5589
		// If we're requesting a remote document
5590
		// and trying to load JSON or Script with a GET
5591
		if ( s.dataType === "script" && type === "GET" && remote ) {
5592
			var head = document.getElementsByTagName("head")[0] || document.documentElement;
5593
			var script = document.createElement("script");
5594
			if ( s.scriptCharset ) {
5595
				script.charset = s.scriptCharset;
5596
			}
5597
			script.src = s.url;
5598

  
5599
			// Handle Script loading
5600
			if ( !jsonp ) {
5601
				var done = false;
5602

  
5603
				// Attach handlers for all browsers
5604
				script.onload = script.onreadystatechange = function() {
5605
					if ( !done && (!this.readyState ||
5606
							this.readyState === "loaded" || this.readyState === "complete") ) {
5607
						done = true;
5608
						jQuery.handleSuccess( s, xhr, status, data );
5609
						jQuery.handleComplete( s, xhr, status, data );
5610

  
5611
						// Handle memory leak in IE
5612
						script.onload = script.onreadystatechange = null;
5613
						if ( head && script.parentNode ) {
5614
							head.removeChild( script );
5615
						}
5616
					}
5617
				};
5618
			}
5619

  
5620
			// Use insertBefore instead of appendChild  to circumvent an IE6 bug.
5621
			// This arises when a base node is used (#2709 and #4378).
5622
			head.insertBefore( script, head.firstChild );
5623

  
5624
			// We handle everything using the script element injection
5625
			return undefined;
5626
		}
5627

  
5628
		var requestDone = false;
5629

  
5630
		// Create the request object
5631
		var xhr = s.xhr();
5632

  
5633
		if ( !xhr ) {
5634
			return;
5635
		}
5636

  
5637
		// Open the socket
5638
		// Passing null username, generates a login popup on Opera (#2865)
5639
		if ( s.username ) {
5640
			xhr.open(type, s.url, s.async, s.username, s.password);
5641
		} else {
5642
			xhr.open(type, s.url, s.async);
5643
		}
5644

  
5645
		// Need an extra try/catch for cross domain requests in Firefox 3
5646
		try {
5647
			// Set content-type if data specified and content-body is valid for this type
5648
			if ( (s.data != null && !noContent) || (origSettings && origSettings.contentType) ) {
5649
				xhr.setRequestHeader("Content-Type", s.contentType);
5650
			}
5651

  
5652
			// Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
5653
			if ( s.ifModified ) {
5654
				if ( jQuery.lastModified[s.url] ) {
5655
					xhr.setRequestHeader("If-Modified-Since", jQuery.lastModified[s.url]);
5656
				}
5657

  
5658
				if ( jQuery.etag[s.url] ) {
5659
					xhr.setRequestHeader("If-None-Match", jQuery.etag[s.url]);
5660
				}
5661
			}
5662

  
5663
			// Set header so the called script knows that it's an XMLHttpRequest
5664
			// Only send the header if it's not a remote XHR
5665
			if ( !remote ) {
5666
				xhr.setRequestHeader("X-Requested-With", "XMLHttpRequest");
5667
			}
5668

  
5669
			// Set the Accepts header for the server, depending on the dataType
5670
			xhr.setRequestHeader("Accept", s.dataType && s.accepts[ s.dataType ] ?
5671
				s.accepts[ s.dataType ] + ", */*; q=0.01" :
5672
				s.accepts._default );
5673
		} catch( headerError ) {}
5674

  
5675
		// Allow custom headers/mimetypes and early abort
5676
		if ( s.beforeSend && s.beforeSend.call(s.context, xhr, s) === false ) {
5677
			// Handle the global AJAX counter
5678
			if ( s.global && jQuery.active-- === 1 ) {
5679
				jQuery.event.trigger( "ajaxStop" );
5680
			}
5681

  
5682
			// close opended socket
5683
			xhr.abort();
5684
			return false;
5685
		}
5686

  
5687
		if ( s.global ) {
5688
			jQuery.triggerGlobal( s, "ajaxSend", [xhr, s] );
5689
		}
5690

  
5691
		// Wait for a response to come back
5692
		var onreadystatechange = xhr.onreadystatechange = function( isTimeout ) {
5693
			// The request was aborted
5694
			if ( !xhr || xhr.readyState === 0 || isTimeout === "abort" ) {
5695
				// Opera doesn't call onreadystatechange before this point
5696
				// so we simulate the call
5697
				if ( !requestDone ) {
5698
					jQuery.handleComplete( s, xhr, status, data );
5699
				}
5700

  
5701
				requestDone = true;
5702
				if ( xhr ) {
5703
					xhr.onreadystatechange = jQuery.noop;
5704
				}
5705

  
5706
			// The transfer is complete and the data is available, or the request timed out
5707
			} else if ( !requestDone && xhr && (xhr.readyState === 4 || isTimeout === "timeout") ) {
5708
				requestDone = true;
5709
				xhr.onreadystatechange = jQuery.noop;
5710

  
5711
				status = isTimeout === "timeout" ?
5712
					"timeout" :
5713
					!jQuery.httpSuccess( xhr ) ?
5714
						"error" :
5715
						s.ifModified && jQuery.httpNotModified( xhr, s.url ) ?
5716
							"notmodified" :
5717
							"success";
5718

  
5719
				var errMsg;
5720

  
5721
				if ( status === "success" ) {
5722
					// Watch for, and catch, XML document parse errors
5723
					try {
5724
						// process the data (runs the xml through httpData regardless of callback)
5725
						data = jQuery.httpData( xhr, s.dataType, s );
5726
					} catch( parserError ) {
5727
						status = "parsererror";
5728
						errMsg = parserError;
5729
					}
5730
				}
5731

  
5732
				// Make sure that the request was successful or notmodified
5733
				if ( status === "success" || status === "notmodified" ) {
5734
					// JSONP handles its own success callback
5735
					if ( !jsonp ) {
5736
						jQuery.handleSuccess( s, xhr, status, data );
5737
					}
5738
				} else {
5739
					jQuery.handleError( s, xhr, status, errMsg );
5740
				}
5741

  
5742
				// Fire the complete handlers
5743
				if ( !jsonp ) {
5744
					jQuery.handleComplete( s, xhr, status, data );
5745
				}
5746

  
5747
				if ( isTimeout === "timeout" ) {
5748
					xhr.abort();
5749
				}
5750

  
5751
				// Stop memory leaks
5752
				if ( s.async ) {
5753
					xhr = null;
5754
				}
5755
			}
5756
		};
5757

  
5758
		// Override the abort handler, if we can (IE 6 doesn't allow it, but that's OK)
5759
		// Opera doesn't fire onreadystatechange at all on abort
5760
		try {
5761
			var oldAbort = xhr.abort;
5762
			xhr.abort = function() {
5763
				// xhr.abort in IE7 is not a native JS function
5764
				// and does not have a call property
5765
				if ( xhr && oldAbort.call ) {
5766
					oldAbort.call( xhr );
5767
				}
5768

  
5769
				onreadystatechange( "abort" );
5770
			};
5771
		} catch( abortError ) {}
5772

  
5773
		// Timeout checker
5774
		if ( s.async && s.timeout > 0 ) {
5775
			setTimeout(function() {
5776
				// Check to see if the request is still happening
5777
				if ( xhr && !requestDone ) {
5778
					onreadystatechange( "timeout" );
5779
				}
5780
			}, s.timeout);
5781
		}
5782

  
5783
		// Send the data
5784
		try {
5785
			xhr.send( noContent || s.data == null ? null : s.data );
5786

  
5787
		} catch( sendError ) {
5788
			jQuery.handleError( s, xhr, null, sendError );
5789

  
5790
			// Fire the complete handlers
5791
			jQuery.handleComplete( s, xhr, status, data );
5792
		}
5793

  
5794
		// firefox 1.5 doesn't fire statechange for sync requests
5795
		if ( !s.async ) {
5796
			onreadystatechange();
5797
		}
5798

  
5799
		// return XMLHttpRequest to allow aborting the request etc.
5800
		return xhr;
5801
	},
5802

  
5803
	// Serialize an array of form elements or a set of
5804
	// key/values into a query string
5805
	param: function( a, traditional ) {
5806
		var s = [], add = function( key, value ) {
5807
			// If value is a function, invoke it and return its value
5808
			value = jQuery.isFunction(value) ? value() : value;
5809
			s[ s.length ] = encodeURIComponent(key) + "=" + encodeURIComponent(value);
5810
		};
5811
		
5812
		// Set traditional to true for jQuery <= 1.3.2 behavior.
5813
		if ( traditional === undefined ) {
5814
			traditional = jQuery.ajaxSettings.traditional;
5815
		}
5816
		
5817
		// If an array was passed in, assume that it is an array of form elements.
5818
		if ( jQuery.isArray(a) || a.jquery ) {
5819
			// Serialize the form elements
5820
			jQuery.each( a, function() {
5821
				add( this.name, this.value );
5822
			});
5823
			
5824
		} else {
5825
			// If traditional, encode the "old" way (the way 1.3.2 or older
5826
			// did it), otherwise encode params recursively.
5827
			for ( var prefix in a ) {
5828
				buildParams( prefix, a[prefix], traditional, add );
5829
			}
5830
		}
5831

  
5832
		// Return the resulting serialization
5833
		return s.join("&").replace(r20, "+");
5834
	}
5835
});
5836

  
5837
function buildParams( prefix, obj, traditional, add ) {
5838
	if ( jQuery.isArray(obj) && obj.length ) {
5839
		// Serialize array item.
5840
		jQuery.each( obj, function( i, v ) {
5841
			if ( traditional || rbracket.test( prefix ) ) {
5842
				// Treat each array item as a scalar.
5843
				add( prefix, v );
5844

  
5845
			} else {
5846
				// If array item is non-scalar (array or object), encode its
5847
				// numeric index to resolve deserialization ambiguity issues.
5848
				// Note that rack (as of 1.0.0) can't currently deserialize
5849
				// nested arrays properly, and attempting to do so may cause
5850
				// a server error. Possible fixes are to modify rack's
5851
				// deserialization algorithm or to provide an option or flag
5852
				// to force array serialization to be shallow.
5853
				buildParams( prefix + "[" + ( typeof v === "object" || jQuery.isArray(v) ? i : "" ) + "]", v, traditional, add );
5854
			}
5855
		});
5856
			
5857
	} else if ( !traditional && obj != null && typeof obj === "object" ) {
5858
		if ( jQuery.isEmptyObject( obj ) ) {
5859
			add( prefix, "" );
5860

  
5861
		// Serialize object item.
5862
		} else {
5863
			jQuery.each( obj, function( k, v ) {
5864
				buildParams( prefix + "[" + k + "]", v, traditional, add );
5865
			});
5866
		}
5867
					
5868
	} else {
5869
		// Serialize scalar item.
5870
		add( prefix, obj );
5871
	}
5872
}
5873

  
5874
// This is still on the jQuery object... for now
5875
// Want to move this to jQuery.ajax some day
5876
jQuery.extend({
5877

  
5878
	// Counter for holding the number of active queries
5879
	active: 0,
5880

  
5881
	// Last-Modified header cache for next request
5882
	lastModified: {},
5883
	etag: {},
5884

  
5885
	handleError: function( s, xhr, status, e ) {
5886
		// If a local callback was specified, fire it
5887
		if ( s.error ) {
5888
			s.error.call( s.context, xhr, status, e );
5889
		}
5890

  
5891
		// Fire the global callback
5892
		if ( s.global ) {
5893
			jQuery.triggerGlobal( s, "ajaxError", [xhr, s, e] );
5894
		}
5895
	},
5896

  
5897
	handleSuccess: function( s, xhr, status, data ) {
5898
		// If a local callback was specified, fire it and pass it the data
5899
		if ( s.success ) {
5900
			s.success.call( s.context, data, status, xhr );
5901
		}
5902

  
5903
		// Fire the global callback
5904
		if ( s.global ) {
5905
			jQuery.triggerGlobal( s, "ajaxSuccess", [xhr, s] );
5906
		}
5907
	},
5908

  
5909
	handleComplete: function( s, xhr, status ) {
5910
		// Process result
5911
		if ( s.complete ) {
5912
			s.complete.call( s.context, xhr, status );
5913
		}
5914

  
5915
		// The request was completed
5916
		if ( s.global ) {
5917
			jQuery.triggerGlobal( s, "ajaxComplete", [xhr, s] );
5918
		}
5919

  
5920
		// Handle the global AJAX counter
5921
		if ( s.global && jQuery.active-- === 1 ) {
5922
			jQuery.event.trigger( "ajaxStop" );
5923
		}
5924
	},
5925
		
5926
	triggerGlobal: function( s, type, args ) {
5927
		(s.context && s.context.url == null ? jQuery(s.context) : jQuery.event).trigger(type, args);
5928
	},
5929

  
5930
	// Determines if an XMLHttpRequest was successful or not
5931
	httpSuccess: function( xhr ) {
5932
		try {
5933
			// IE error sometimes returns 1223 when it should be 204 so treat it as success, see #1450
5934
			return !xhr.status && location.protocol === "file:" ||
5935
				xhr.status >= 200 && xhr.status < 300 ||
5936
				xhr.status === 304 || xhr.status === 1223;
5937
		} catch(e) {}
5938

  
5939
		return false;
5940
	},
5941

  
5942
	// Determines if an XMLHttpRequest returns NotModified
5943
	httpNotModified: function( xhr, url ) {
5944
		var lastModified = xhr.getResponseHeader("Last-Modified"),
5945
			etag = xhr.getResponseHeader("Etag");
5946

  
5947
		if ( lastModified ) {
5948
			jQuery.lastModified[url] = lastModified;
5949
		}
5950

  
5951
		if ( etag ) {
5952
			jQuery.etag[url] = etag;
5953
		}
5954

  
5955
		return xhr.status === 304;
5956
	},
5957

  
5958
	httpData: function( xhr, type, s ) {
5959
		var ct = xhr.getResponseHeader("content-type") || "",
5960
			xml = type === "xml" || !type && ct.indexOf("xml") >= 0,
5961
			data = xml ? xhr.responseXML : xhr.responseText;
5962

  
5963
		if ( xml && data.documentElement.nodeName === "parsererror" ) {
5964
			jQuery.error( "parsererror" );
5965
		}
5966

  
5967
		// Allow a pre-filtering function to sanitize the response
5968
		// s is checked to keep backwards compatibility
5969
		if ( s && s.dataFilter ) {
5970
			data = s.dataFilter( data, type );
5971
		}
5972

  
5973
		// The filter can actually parse the response
5974
		if ( typeof data === "string" ) {
5975
			// Get the JavaScript object, if JSON is used.
5976
			if ( type === "json" || !type && ct.indexOf("json") >= 0 ) {
5977
				data = jQuery.parseJSON( data );
5978

  
5979
			// If the type is "script", eval it in global context
5980
			} else if ( type === "script" || !type && ct.indexOf("javascript") >= 0 ) {
5981
				jQuery.globalEval( data );
5982
			}
5983
		}
5984

  
5985
		return data;
5986
	}
5987

  
5988
});
5989

  
5990
/*
5991
 * Create the request object; Microsoft failed to properly
5992
 * implement the XMLHttpRequest in IE7 (can't request local files),
5993
 * so we use the ActiveXObject when it is available
5994
 * Additionally XMLHttpRequest can be disabled in IE7/IE8 so
5995
 * we need a fallback.
5996
 */
5997
if ( window.ActiveXObject ) {
5998
	jQuery.ajaxSettings.xhr = function() {
5999
		if ( window.location.protocol !== "file:" ) {
6000
			try {
6001
				return new window.XMLHttpRequest();
6002
			} catch(xhrError) {}
6003
		}
6004

  
6005
		try {
6006
			return new window.ActiveXObject("Microsoft.XMLHTTP");
6007
		} catch(activeError) {}
6008
	};
6009
}
6010

  
6011
// Does this browser support XHR requests?
6012
jQuery.support.ajax = !!jQuery.ajaxSettings.xhr();
6013

  
6014

  
6015

  
6016

  
6017
var elemdisplay = {},
6018
	rfxtypes = /^(?:toggle|show|hide)$/,
6019
	rfxnum = /^([+\-]=)?([\d+.\-]+)(.*)$/,
6020
	timerId,
6021
	fxAttrs = [
6022
		// height animations
6023
		[ "height", "marginTop", "marginBottom", "paddingTop", "paddingBottom" ],
6024
		// width animations
6025
		[ "width", "marginLeft", "marginRight", "paddingLeft", "paddingRight" ],
6026
		// opacity animations
6027
		[ "opacity" ]
6028
	];
6029

  
6030
jQuery.fn.extend({
6031
	show: function( speed, easing, callback ) {
6032
		if ( speed || speed === 0 ) {
6033
			return this.animate( genFx("show", 3), speed, easing, callback);
6034
		} else {
6035
			for ( var i = 0, j = this.length; i < j; i++ ) {
6036
				// Reset the inline display of this element to learn if it is
6037
				// being hidden by cascaded rules or not
6038
				if ( !jQuery.data(this[i], "olddisplay") && this[i].style.display === "none" ) {
6039
					this[i].style.display = "";
6040
				}
6041

  
6042
				// Set elements which have been overridden with display: none
6043
				// in a stylesheet to whatever the default browser style is
6044
				// for such an element
6045
				if ( this[i].style.display === "" && jQuery.css( this[i], "display" ) === "none" ) {
6046
					jQuery.data(this[i], "olddisplay", defaultDisplay(this[i].nodeName));
6047
				}
6048
			}
6049

  
6050
			// Set the display of most of the elements in a second loop
6051
			// to avoid the constant reflow
6052
			for ( i = 0; i < j; i++ ) {
6053
				this[i].style.display = jQuery.data(this[i], "olddisplay") || "";
6054
			}
6055

  
6056
			return this;
6057
		}
6058
	},
6059

  
6060
	hide: function( speed, easing, callback ) {
6061
		if ( speed || speed === 0 ) {
6062
			return this.animate( genFx("hide", 3), speed, easing, callback);
6063

  
6064
		} else {
6065
			for ( var i = 0, j = this.length; i < j; i++ ) {
6066
				var display = jQuery.css( this[i], "display" );
6067

  
6068
				if ( display !== "none" ) {
6069
					jQuery.data( this[i], "olddisplay", display );
6070
				}
6071
			}
6072

  
6073
			// Set the display of the elements in a second loop
6074
			// to avoid the constant reflow
6075
			for ( i = 0; i < j; i++ ) {
6076
				this[i].style.display = "none";
6077
			}
6078

  
6079
			return this;
6080
		}
6081
	},
6082

  
6083
	// Save the old toggle function
6084
	_toggle: jQuery.fn.toggle,
6085

  
6086
	toggle: function( fn, fn2, callback ) {
6087
		var bool = typeof fn === "boolean";
6088

  
6089
		if ( jQuery.isFunction(fn) && jQuery.isFunction(fn2) ) {
6090
			this._toggle.apply( this, arguments );
6091

  
6092
		} else if ( fn == null || bool ) {
6093
			this.each(function() {
6094
				var state = bool ? fn : jQuery(this).is(":hidden");
6095
				jQuery(this)[ state ? "show" : "hide" ]();
6096
			});
6097

  
6098
		} else {
6099
			this.animate(genFx("toggle", 3), fn, fn2, callback);
6100
		}
6101

  
6102
		return this;
6103
	},
6104

  
6105
	fadeTo: function( speed, to, easing, callback ) {
6106
		return this.filter(":hidden").css("opacity", 0).show().end()
6107
					.animate({opacity: to}, speed, easing, callback);
6108
	},
6109

  
6110
	animate: function( prop, speed, easing, callback ) {
6111
		var optall = jQuery.speed(speed, easing, callback);
6112

  
6113
		if ( jQuery.isEmptyObject( prop ) ) {
6114
			return this.each( optall.complete );
6115
		}
6116

  
6117
		return this[ optall.queue === false ? "each" : "queue" ](function() {
6118
			// XXX ‘this’ does not always have a nodeName when running the
6119
			// test suite
6120

  
6121
			var opt = jQuery.extend({}, optall), p,
6122
				isElement = this.nodeType === 1,
6123
				hidden = isElement && jQuery(this).is(":hidden"),
6124
				self = this;
6125

  
6126
			for ( p in prop ) {
6127
				var name = jQuery.camelCase( p );
6128

  
6129
				if ( p !== name ) {
6130
					prop[ name ] = prop[ p ];
6131
					delete prop[ p ];
6132
					p = name;
6133
				}
6134

  
6135
				if ( prop[p] === "hide" && hidden || prop[p] === "show" && !hidden ) {
6136
					return opt.complete.call(this);
6137
				}
6138

  
6139
				if ( isElement && ( p === "height" || p === "width" ) ) {
6140
					// Make sure that nothing sneaks out
6141
					// Record all 3 overflow attributes because IE does not
6142
					// change the overflow attribute when overflowX and
6143
					// overflowY are set to the same value
6144
					opt.overflow = [ this.style.overflow, this.style.overflowX, this.style.overflowY ];
6145

  
6146
					// Set display property to inline-block for height/width
6147
					// animations on inline elements that are having width/height
6148
					// animated
6149
					if ( jQuery.css( this, "display" ) === "inline" &&
6150
							jQuery.css( this, "float" ) === "none" ) {
6151
						if ( !jQuery.support.inlineBlockNeedsLayout ) {
6152
							this.style.display = "inline-block";
6153

  
6154
						} else {
6155
							var display = defaultDisplay(this.nodeName);
6156

  
6157
							// inline-level elements accept inline-block;
6158
							// block-level elements need to be inline with layout
6159
							if ( display === "inline" ) {
6160
								this.style.display = "inline-block";
6161

  
6162
							} else {
6163
								this.style.display = "inline";
6164
								this.style.zoom = 1;
6165
							}
6166
						}
6167
					}
6168
				}
6169

  
6170
				if ( jQuery.isArray( prop[p] ) ) {
6171
					// Create (if needed) and add to specialEasing
6172
					(opt.specialEasing = opt.specialEasing || {})[p] = prop[p][1];
6173
					prop[p] = prop[p][0];
6174
				}
6175
			}
6176

  
6177
			if ( opt.overflow != null ) {
6178
				this.style.overflow = "hidden";
6179
			}
6180

  
6181
			opt.curAnim = jQuery.extend({}, prop);
6182

  
6183
			jQuery.each( prop, function( name, val ) {
6184
				var e = new jQuery.fx( self, opt, name );
6185

  
6186
				if ( rfxtypes.test(val) ) {
6187
					e[ val === "toggle" ? hidden ? "show" : "hide" : val ]( prop );
6188

  
6189
				} else {
6190
					var parts = rfxnum.exec(val),
6191
						start = e.cur(true) || 0;
6192

  
6193
					if ( parts ) {
6194
						var end = parseFloat( parts[2] ),
6195
							unit = parts[3] || "px";
6196

  
6197
						// We need to compute starting value
6198
						if ( unit !== "px" ) {
6199
							jQuery.style( self, name, (end || 1) + unit);
6200
							start = ((end || 1) / e.cur(true)) * start;
6201
							jQuery.style( self, name, start + unit);
6202
						}
6203

  
6204
						// If a +=/-= token was provided, we're doing a relative animation
6205
						if ( parts[1] ) {
6206
							end = ((parts[1] === "-=" ? -1 : 1) * end) + start;
6207
						}
6208

  
6209
						e.custom( start, end, unit );
6210

  
6211
					} else {
6212
						e.custom( start, val, "" );
6213
					}
6214
				}
6215
			});
6216

  
6217
			// For JS strict compliance
6218
			return true;
6219
		});
6220
	},
6221

  
6222
	stop: function( clearQueue, gotoEnd ) {
6223
		var timers = jQuery.timers;
6224

  
6225
		if ( clearQueue ) {
6226
			this.queue([]);
6227
		}
6228

  
6229
		this.each(function() {
6230
			// go in reverse order so anything added to the queue during the loop is ignored
6231
			for ( var i = timers.length - 1; i >= 0; i-- ) {
6232
				if ( timers[i].elem === this ) {
6233
					if (gotoEnd) {
6234
						// force the next step to be the last
6235
						timers[i](true);
6236
					}
6237

  
6238
					timers.splice(i, 1);
6239
				}
6240
			}
6241
		});
6242

  
6243
		// start the next in the queue if the last step wasn't forced
6244
		if ( !gotoEnd ) {
6245
			this.dequeue();
6246
		}
6247

  
6248
		return this;
6249
	}
6250

  
6251
});
6252

  
6253
function genFx( type, num ) {
6254
	var obj = {};
6255

  
6256
	jQuery.each( fxAttrs.concat.apply([], fxAttrs.slice(0,num)), function() {
6257
		obj[ this ] = type;
6258
	});
6259

  
6260
	return obj;
6261
}
6262

  
6263
// Generate shortcuts for custom animations
6264
jQuery.each({
6265
	slideDown: genFx("show", 1),
6266
	slideUp: genFx("hide", 1),
6267
	slideToggle: genFx("toggle", 1),
6268
	fadeIn: { opacity: "show" },
6269
	fadeOut: { opacity: "hide" }
6270
}, function( name, props ) {
6271
	jQuery.fn[ name ] = function( speed, easing, callback ) {
6272
		return this.animate( props, speed, easing, callback );
6273
	};
6274
});
6275

  
6276
jQuery.extend({
6277
	speed: function( speed, easing, fn ) {
6278
		var opt = speed && typeof speed === "object" ? jQuery.extend({}, speed) : {
6279
			complete: fn || !fn && easing ||
6280
				jQuery.isFunction( speed ) && speed,
6281
			duration: speed,
6282
			easing: fn && easing || easing && !jQuery.isFunction(easing) && easing
6283
		};
6284

  
6285
		opt.duration = jQuery.fx.off ? 0 : typeof opt.duration === "number" ? opt.duration :
6286
			opt.duration in jQuery.fx.speeds ? jQuery.fx.speeds[opt.duration] : jQuery.fx.speeds._default;
6287

  
6288
		// Queueing
6289