https://www.bluxte.net/theme/js/jquery.js

1/*!
2 * jQuery JavaScript Library v2.1.1
3 * http://jquery.com/
4 *
5 * Includes Sizzle.js
6 * http://sizzlejs.com/
7 *
8 * Copyright 2005, 2014 jQuery Foundation, Inc. and other contributors
9 * Released under the MIT license
10 * http://jquery.org/license
11 *
12 * Date: 2014-05-01T17:11Z
13 */
14
15(function( global, factory ) {
16
17	if ( typeof module === "object" && typeof module.exports === "object" ) {
18		// For CommonJS and CommonJS-like environments where a proper window is present,
19		// execute the factory and get jQuery
20		// For environments that do not inherently posses a window with a document
21		// (such as Node.js), expose a jQuery-making factory as module.exports
22		// This accentuates the need for the creation of a real window
23		// e.g. var jQuery = require("jquery")(window);
24		// See ticket #14549 for more info
25		module.exports = global.document ?
26			factory( global, true ) :
27			function( w ) {
28				if ( !w.document ) {
29					throw new Error( "jQuery requires a window with a document" );
30				}
31				return factory( w );
32			};
33	} else {
34		factory( global );
35	}
36
37// Pass this if window is not defined yet
38}(typeof window !== "undefined" ? window : this, function( window, noGlobal ) {
39
40// Can't do this because several apps including ASP.NET trace
41// the stack via arguments.caller.callee and Firefox dies if
42// you try to trace through "use strict" call chains. (#13335)
43// Support: Firefox 18+
44//
45
46var arr = [];
47
48var slice = arr.slice;
49
50var concat = arr.concat;
51
52var push = arr.push;
53
54var indexOf = arr.indexOf;
55
56var class2type = {};
57
58var toString = class2type.toString;
59
60var hasOwn = class2type.hasOwnProperty;
61
62var support = {};
63
64
65
66var
67	// Use the correct document accordingly with window argument (sandbox)
68	document = window.document,
69
70	version = "2.1.1",
71
72	// Define a local copy of jQuery
73	jQuery = function( selector, context ) {
74		// The jQuery object is actually just the init constructor 'enhanced'
75		// Need init if jQuery is called (just allow error to be thrown if not included)
76		return new jQuery.fn.init( selector, context );
77	},
78
79	// Support: Android<4.1
80	// Make sure we trim BOM and NBSP
81	rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g,
82
83	// Matches dashed string for camelizing
84	rmsPrefix = /^-ms-/,
85	rdashAlpha = /-([\da-z])/gi,
86
87	// Used by jQuery.camelCase as callback to replace()
88	fcamelCase = function( all, letter ) {
89		return letter.toUpperCase();
90	};
91
92jQuery.fn = jQuery.prototype = {
93	// The current version of jQuery being used
94	jquery: version,
95
96	constructor: jQuery,
97
98	// Start with an empty selector
99	selector: "",
100
101	// The default length of a jQuery object is 0
102	length: 0,
103
104	toArray: function() {
105		return slice.call( this );
106	},
107
108	// Get the Nth element in the matched element set OR
109	// Get the whole matched element set as a clean array
110	get: function( num ) {
111		return num != null ?
112
113			// Return just the one element from the set
114			( num < 0 ? this[ num + this.length ] : this[ num ] ) :
115
116			// Return all the elements in a clean array
117			slice.call( this );
118	},
119
120	// Take an array of elements and push it onto the stack
121	// (returning the new matched element set)
122	pushStack: function( elems ) {
123
124		// Build a new jQuery matched element set
125		var ret = jQuery.merge( this.constructor(), elems );
126
127		// Add the old object onto the stack (as a reference)
128		ret.prevObject = this;
129		ret.context = this.context;
130
131		// Return the newly-formed element set
132		return ret;
133	},
134
135	// Execute a callback for every element in the matched set.
136	// (You can seed the arguments with an array of args, but this is
137	// only used internally.)
138	each: function( callback, args ) {
139		return jQuery.each( this, callback, args );
140	},
141
142	map: function( callback ) {
143		return this.pushStack( jQuery.map(this, function( elem, i ) {
144			return callback.call( elem, i, elem );
145		}));
146	},
147
148	slice: function() {
149		return this.pushStack( slice.apply( this, arguments ) );
150	},
151
152	first: function() {
153		return this.eq( 0 );
154	},
155
156	last: function() {
157		return this.eq( -1 );
158	},
159
160	eq: function( i ) {
161		var len = this.length,
162			j = +i + ( i < 0 ? len : 0 );
163		return this.pushStack( j >= 0 && j < len ? [ this[j] ] : [] );
164	},
165
166	end: function() {
167		return this.prevObject || this.constructor(null);
168	},
169
170	// For internal use only.
171	// Behaves like an Array's method, not like a jQuery method.
172	push: push,
173	sort: arr.sort,
174	splice: arr.splice
175};
176
177jQuery.extend = jQuery.fn.extend = function() {
178	var options, name, src, copy, copyIsArray, clone,
179		target = arguments[0] || {},
180		i = 1,
181		length = arguments.length,
182		deep = false;
183
184	// Handle a deep copy situation
185	if ( typeof target === "boolean" ) {
186		deep = target;
187
188		// skip the boolean and the target
189		target = arguments[ i ] || {};
190		i++;
191	}
192
193	// Handle case when target is a string or something (possible in deep copy)
194	if ( typeof target !== "object" && !jQuery.isFunction(target) ) {
195		target = {};
196	}
197
198	// extend jQuery itself if only one argument is passed
199	if ( i === length ) {
200		target = this;
201		i--;
202	}
203
204	for ( ; i < length; i++ ) {
205		// Only deal with non-null/undefined values
206		if ( (options = arguments[ i ]) != null ) {
207			// Extend the base object
208			for ( name in options ) {
209				src = target[ name ];
210				copy = options[ name ];
211
212				// Prevent never-ending loop
213				if ( target === copy ) {
214					continue;
215				}
216
217				// Recurse if we're merging plain objects or arrays
218				if ( deep && copy && ( jQuery.isPlainObject(copy) || (copyIsArray = jQuery.isArray(copy)) ) ) {
219					if ( copyIsArray ) {
220						copyIsArray = false;
221						clone = src && jQuery.isArray(src) ? src : [];
222
223					} else {
224						clone = src && jQuery.isPlainObject(src) ? src : {};
225					}
226
227					// Never move original objects, clone them
228					target[ name ] = jQuery.extend( deep, clone, copy );
229
230				// Don't bring in undefined values
231				} else if ( copy !== undefined ) {
232					target[ name ] = copy;
233				}
234			}
235		}
236	}
237
238	// Return the modified object
239	return target;
240};
241
242jQuery.extend({
243	// Unique for each copy of jQuery on the page
244	expando: "jQuery" + ( version + Math.random() ).replace( /\D/g, "" ),
245
246	// Assume jQuery is ready without the ready module
247	isReady: true,
248
249	error: function( msg ) {
250		throw new Error( msg );
251	},
252
253	noop: function() {},
254
255	// See test/unit/core.js for details concerning isFunction.
256	// Since version 1.3, DOM methods and functions like alert
257	// aren't supported. They return false on IE (#2968).
258	isFunction: function( obj ) {
259		return jQuery.type(obj) === "function";
260	},
261
262	isArray: Array.isArray,
263
264	isWindow: function( obj ) {
265		return obj != null && obj === obj.window;
266	},
267
268	isNumeric: function( obj ) {
269		// parseFloat NaNs numeric-cast false positives (null|true|false|"")
270		// ...but misinterprets leading-number strings, particularly hex literals ("0x...")
271		// subtraction forces infinities to NaN
272		return !jQuery.isArray( obj ) && obj - parseFloat( obj ) >= 0;
273	},
274
275	isPlainObject: function( obj ) {
276		// Not plain objects:
277		// - Any object or value whose internal [[Class]] property is not "[object Object]"
278		// - DOM nodes
279		// - window
280		if ( jQuery.type( obj ) !== "object" || obj.nodeType || jQuery.isWindow( obj ) ) {
281			return false;
282		}
283
284		if ( obj.constructor &&
285				!hasOwn.call( obj.constructor.prototype, "isPrototypeOf" ) ) {
286			return false;
287		}
288
289		// If the function hasn't returned already, we're confident that
290		// |obj| is a plain object, created by {} or constructed with new Object
291		return true;
292	},
293
294	isEmptyObject: function( obj ) {
295		var name;
296		for ( name in obj ) {
297			return false;
298		}
299		return true;
300	},
301
302	type: function( obj ) {
303		if ( obj == null ) {
304			return obj + "";
305		}
306		// Support: Android < 4.0, iOS < 6 (functionish RegExp)
307		return typeof obj === "object" || typeof obj === "function" ?
308			class2type[ toString.call(obj) ] || "object" :
309			typeof obj;
310	},
311
312	// Evaluates a script in a global context
313	globalEval: function( code ) {
314		var script,
315			indirect = eval;
316
317		code = jQuery.trim( code );
318
319		if ( code ) {
320			// If the code includes a valid, prologue position
321			// strict mode pragma, execute code by injecting a
322			// script tag into the document.
323			if ( code.indexOf("use strict") === 1 ) {
324				script = document.createElement("script");
325				script.text = code;
326				document.head.appendChild( script ).parentNode.removeChild( script );
327			} else {
328			// Otherwise, avoid the DOM node creation, insertion
329			// and removal by using an indirect global eval
330				indirect( code );
331			}
332		}
333	},
334
335	// Convert dashed to camelCase; used by the css and data modules
336	// Microsoft forgot to hump their vendor prefix (#9572)
337	camelCase: function( string ) {
338		return string.replace( rmsPrefix, "ms-" ).replace( rdashAlpha, fcamelCase );
339	},
340
341	nodeName: function( elem, name ) {
342		return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase();
343	},
344
345	// args is for internal usage only
346	each: function( obj, callback, args ) {
347		var value,
348			i = 0,
349			length = obj.length,
350			isArray = isArraylike( obj );
351
352		if ( args ) {
353			if ( isArray ) {
354				for ( ; i < length; i++ ) {
355					value = callback.apply( obj[ i ], args );
356
357					if ( value === false ) {
358						break;
359					}
360				}
361			} else {
362				for ( i in obj ) {
363					value = callback.apply( obj[ i ], args );
364
365					if ( value === false ) {
366						break;
367					}
368				}
369			}
370
371		// A special, fast, case for the most common use of each
372		} else {
373			if ( isArray ) {
374				for ( ; i < length; i++ ) {
375					value = callback.call( obj[ i ], i, obj[ i ] );
376
377					if ( value === false ) {
378						break;
379					}
380				}
381			} else {
382				for ( i in obj ) {
383					value = callback.call( obj[ i ], i, obj[ i ] );
384
385					if ( value === false ) {
386						break;
387					}
388				}
389			}
390		}
391
392		return obj;
393	},
394
395	// Support: Android<4.1
396	trim: function( text ) {
397		return text == null ?
398			"" :
399			( text + "" ).replace( rtrim, "" );
400	},
401
402	// results is for internal usage only
403	makeArray: function( arr, results ) {
404		var ret = results || [];
405
406		if ( arr != null ) {
407			if ( isArraylike( Object(arr) ) ) {
408				jQuery.merge( ret,
409					typeof arr === "string" ?
410					[ arr ] : arr
411				);
412			} else {
413				push.call( ret, arr );
414			}
415		}
416
417		return ret;
418	},
419
420	inArray: function( elem, arr, i ) {
421		return arr == null ? -1 : indexOf.call( arr, elem, i );
422	},
423
424	merge: function( first, second ) {
425		var len = +second.length,
426			j = 0,
427			i = first.length;
428
429		for ( ; j < len; j++ ) {
430			first[ i++ ] = second[ j ];
431		}
432
433		first.length = i;
434
435		return first;
436	},
437
438	grep: function( elems, callback, invert ) {
439		var callbackInverse,
440			matches = [],
441			i = 0,
442			length = elems.length,
443			callbackExpect = !invert;
444
445		// Go through the array, only saving the items
446		// that pass the validator function
447		for ( ; i < length; i++ ) {
448			callbackInverse = !callback( elems[ i ], i );
449			if ( callbackInverse !== callbackExpect ) {
450				matches.push( elems[ i ] );
451			}
452		}
453
454		return matches;
455	},
456
457	// arg is for internal usage only
458	map: function( elems, callback, arg ) {
459		var value,
460			i = 0,
461			length = elems.length,
462			isArray = isArraylike( elems ),
463			ret = [];
464
465		// Go through the array, translating each of the items to their new values
466		if ( isArray ) {
467			for ( ; i < length; i++ ) {
468				value = callback( elems[ i ], i, arg );
469
470				if ( value != null ) {
471					ret.push( value );
472				}
473			}
474
475		// Go through every key on the object,
476		} else {
477			for ( i in elems ) {
478				value = callback( elems[ i ], i, arg );
479
480				if ( value != null ) {
481					ret.push( value );
482				}
483			}
484		}
485
486		// Flatten any nested arrays
487		return concat.apply( [], ret );
488	},
489
490	// A global GUID counter for objects
491	guid: 1,
492
493	// Bind a function to a context, optionally partially applying any
494	// arguments.
495	proxy: function( fn, context ) {
496		var tmp, args, proxy;
497
498		if ( typeof context === "string" ) {
499			tmp = fn[ context ];
500			context = fn;
501			fn = tmp;
502		}
503
504		// Quick check to determine if target is callable, in the spec
505		// this throws a TypeError, but we will just return undefined.
506		if ( !jQuery.isFunction( fn ) ) {
507			return undefined;
508		}
509
510		// Simulated bind
511		args = slice.call( arguments, 2 );
512		proxy = function() {
513			return fn.apply( context || this, args.concat( slice.call( arguments ) ) );
514		};
515
516		// Set the guid of unique handler to the same of original handler, so it can be removed
517		proxy.guid = fn.guid = fn.guid || jQuery.guid++;
518
519		return proxy;
520	},
521
522	now: Date.now,
523
524	// jQuery.support is not used in Core but other projects attach their
525	// properties to it so it needs to exist.
526	support: support
527});
528
529// Populate the class2type map
530jQuery.each("Boolean Number String Function Array Date RegExp Object Error".split(" "), function(i, name) {
531	class2type[ "[object " + name + "]" ] = name.toLowerCase();
532});
533
534function isArraylike( obj ) {
535	var length = obj.length,
536		type = jQuery.type( obj );
537
538	if ( type === "function" || jQuery.isWindow( obj ) ) {
539		return false;

822				newContext = rsibling.test( selector ) && testContext( context.parentNode ) || context;
823				newSelector = groups.join(",");
824			}
825
826			if ( newSelector ) {
827				try {
828					push.apply( results,
829						newContext.querySelectorAll( newSelector )
830					);
831					return results;
832				} catch(qsaError) {
833				} finally {
834					if ( !old ) {
835						context.removeAttribute("id");
836					}
837				}
838			}
839		}
840	}
841
842	// All others
843	return select( selector.replace( rtrim, "$1" ), context, results, seed );
844}
845
846/**
847 * Create key-value caches of limited size
848 * @returns {Function(string, Object)} Returns the Object data after storing it on itself with
849 *	property name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength)
850 *	deleting the oldest entry
851 */
852function createCache() {
853	var keys = [];
854
855	function cache( key, value ) {
856		// Use (key + " ") to avoid collision with native prototype properties (see Issue #157)
857		if ( keys.push( key + " " ) > Expr.cacheLength ) {
858			// Only keep the most recent entries
859			delete cache[ keys.shift() ];
860		}
861		return (cache[ key + " " ] = value);
862	}
863	return cache;
864}
865
866/**
867 * Mark a function for special use by Sizzle
868 * @param {Function} fn The function to mark
869 */
870function markFunction( fn ) {
871	fn[ expando ] = true;
872	return fn;
873}
874
875/**
876 * Support testing using an element
877 * @param {Function} fn Passed the created div and expects a boolean result
878 */
879function assert( fn ) {
880	var div = document.createElement("div");
881
882	try {
883		return !!fn( div );
884	} catch (e) {
885		return false;
886	} finally {
887		// Remove from its parent by default
888		if ( div.parentNode ) {
889			div.parentNode.removeChild( div );
890		}
891		// release memory in IE
892		div = null;
893	}
894}
895
896/**
897 * Adds the same handler for all of the specified attrs
898 * @param {String} attrs Pipe-separated list of attributes
899 * @param {Function} handler The method that will be applied
900 */
901function addHandle( attrs, handler ) {
902	var arr = attrs.split("|"),
903		i = attrs.length;
904
905	while ( i-- ) {
906		Expr.attrHandle[ arr[i] ] = handler;
907	}
908}
909
910/**
911 * Checks document order of two siblings
912 * @param {Element} a
913 * @param {Element} b
914 * @returns {Number} Returns less than 0 if a precedes b, greater than 0 if a follows b
915 */
916function siblingCheck( a, b ) {
917	var cur = b && a,
918		diff = cur && a.nodeType === 1 && b.nodeType === 1 &&
919			( ~b.sourceIndex || MAX_NEGATIVE ) -
920			( ~a.sourceIndex || MAX_NEGATIVE );
921
922	// Use IE sourceIndex if available on both nodes
923	if ( diff ) {
924		return diff;
925	}
926
927	// Check if b follows a
928	if ( cur ) {
929		while ( (cur = cur.nextSibling) ) {
930			if ( cur === b ) {
931				return -1;
932			}
933		}
934	}
935
936	return a ? 1 : -1;
937}
938
939/**
940 * Returns a function to use in pseudos for input types
941 * @param {String} type
942 */
943function createInputPseudo( type ) {
944	return function( elem ) {
945		var name = elem.nodeName.toLowerCase();
946		return name === "input" && elem.type === type;
947	};
948}
949
950/**
951 * Returns a function to use in pseudos for buttons
952 * @param {String} type
953 */
954function createButtonPseudo( type ) {
955	return function( elem ) {
956		var name = elem.nodeName.toLowerCase();
957		return (name === "input" || name === "button") && elem.type === type;
958	};
959}
960
961/**
962 * Returns a function to use in pseudos for positionals
963 * @param {Function} fn
964 */
965function createPositionalPseudo( fn ) {
966	return markFunction(function( argument ) {
967		argument = +argument;
968		return markFunction(function( seed, matches ) {
969			var j,
970				matchIndexes = fn( [], seed.length, argument ),
971				i = matchIndexes.length;
972
973			// Match elements found at the specified indexes
974			while ( i-- ) {
975				if ( seed[ (j = matchIndexes[i]) ] ) {
976					seed[j] = !(matches[j] = seed[j]);
977				}
978			}
979		});
980	});
981}
982
983/**
984 * Checks a node for validity as a Sizzle context
985 * @param {Element|Object=} context
986 * @returns {Element|Object|Boolean} The input node if acceptable, otherwise a falsy value
987 */
988function testContext( context ) {
989	return context && typeof context.getElementsByTagName !== strundefined && context;
990}
991
992// Expose support vars for convenience
993support = Sizzle.support = {};
994
995/**
996 * Detects XML nodes
997 * @param {Element|Object} elem An element or a document
998 * @returns {Boolean} True iff elem is a non-HTML XML node
999 */
1000isXML = Sizzle.isXML = function( elem ) {
1001	// documentElement is verified for cases where it doesn't yet exist
1002	// (such as loading iframes in IE - #4833)
1003	var documentElement = elem && (elem.ownerDocument || elem).documentElement;
1004	return documentElement ? documentElement.nodeName !== "HTML" : false;

1103		// Support: IE6/7
1104		// getElementById is not reliable as a find shortcut
1105		delete Expr.find["ID"];
1106
1107		Expr.filter["ID"] =  function( id ) {
1108			var attrId = id.replace( runescape, funescape );
1109			return function( elem ) {
1110				var node = typeof elem.getAttributeNode !== strundefined && elem.getAttributeNode("id");
1111				return node && node.value === attrId;
1112			};
1113		};
1114	}
1115
1116	// Tag
1117	Expr.find["TAG"] = support.getElementsByTagName ?
1118		function( tag, context ) {
1119			if ( typeof context.getElementsByTagName !== strundefined ) {
1120				return context.getElementsByTagName( tag );
1121			}
1122		} :
1123		function( tag, context ) {
1124			var elem,
1125				tmp = [],
1126				i = 0,
1127				results = context.getElementsByTagName( tag );
1128
1129			// Filter out possible comments
1130			if ( tag === "*" ) {
1131				while ( (elem = results[i++]) ) {
1132					if ( elem.nodeType === 1 ) {
1133						tmp.push( elem );
1134					}
1135				}
1136
1137				return tmp;
1138			}
1139			return results;
1140		};
1141
1142	// Class
1143	Expr.find["CLASS"] = support.getElementsByClassName && function( className, context ) {
1144		if ( typeof context.getElementsByClassName !== strundefined && documentIsHTML ) {
1145			return context.getElementsByClassName( className );
1146		}
1147	};
1148
1149	/* QSA/matchesSelector
1150	---------------------------------------------------------------------- */
1151
1152	// QSA and matchesSelector support
1153
1154	// matchesSelector(:active) reports false when true (IE9/Opera 11.5)
1155	rbuggyMatches = [];
1156
1157	// qSa(:focus) reports false when true (Chrome 21)
1158	// We allow this because of a bug in IE8/9 that throws an error
1159	// whenever `document.activeElement` is accessed on an iframe
1160	// So, we allow :focus to pass through QSA all the time to avoid the IE error
1161	// See http://bugs.jquery.com/ticket/13378
1162	rbuggyQSA = [];
1163
1164	if ( (support.qsa = rnative.test( doc.querySelectorAll )) ) {
1165		// Build QSA regex
1166		// Regex strategy adopted from Diego Perini
1167		assert(function( div ) {
1168			// Select is set to empty string on purpose
1169			// This is to test IE's treatment of not explicitly
1170			// setting a boolean content attribute,
1171			// since its presence should be enough
1172			// http://bugs.jquery.com/ticket/12359
1173			div.innerHTML = "<select msallowclip=''><option selected=''></option></select>";
1174
1175			// Support: IE8, Opera 11-12.16
1176			// Nothing should be selected when empty strings follow ^= or $= or *=
1177			// The test attribute must be unknown in Opera but "safe" for WinRT
1178			// http://msdn.microsoft.com/en-us/library/ie/hh465388.aspx#attribute_section
1179			if ( div.querySelectorAll("[msallowclip^='']").length ) {
1180				rbuggyQSA.push( "[*^$]=" + whitespace + "*(?:''|\"\")" );
1181			}
1182
1183			// Support: IE8
1184			// Boolean attributes and "value" are not treated correctly
1185			if ( !div.querySelectorAll("[selected]").length ) {
1186				rbuggyQSA.push( "\\[" + whitespace + "*(?:value|" + booleans + ")" );
1187			}
1188
1189			// Webkit/Opera - :checked should return selected option elements
1190			// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
1191			// IE8 throws error here and will not see later tests
1192			if ( !div.querySelectorAll(":checked").length ) {
1193				rbuggyQSA.push(":checked");
1194			}
1195		});
1196
1197		assert(function( div ) {
1198			// Support: Windows 8 Native Apps
1199			// The type and name attributes are restricted during .innerHTML assignment
1200			var input = doc.createElement("input");
1201			input.setAttribute( "type", "hidden" );
1202			div.appendChild( input ).setAttribute( "name", "D" );
1203
1204			// Support: IE8
1205			// Enforce case-sensitivity of name attribute
1206			if ( div.querySelectorAll("[name=d]").length ) {
1207				rbuggyQSA.push( "name" + whitespace + "*[*^$|!~]?=" );
1208			}
1209
1210			// FF 3.5 - :enabled/:disabled and hidden elements (hidden elements are still enabled)
1211			// IE8 throws error here and will not see later tests
1212			if ( !div.querySelectorAll(":enabled").length ) {
1213				rbuggyQSA.push( ":enabled", ":disabled" );
1214			}
1215
1216			// Opera 10-11 does not throw on post-comma invalid pseudos
1217			div.querySelectorAll("*,:x");
1218			rbuggyQSA.push(",.*:");
1219		});
1220	}
1221
1222	if ( (support.matchesSelector = rnative.test( (matches = docElem.matches ||
1223		docElem.webkitMatchesSelector ||
1224		docElem.mozMatchesSelector ||
1225		docElem.oMatchesSelector ||
1226		docElem.msMatchesSelector) )) ) {
1227
1228		assert(function( div ) {
1229			// Check to see if it's possible to do matchesSelector
1230			// on a disconnected node (IE 9)
1231			support.disconnectedMatch = matches.call( div, "div" );
1232
1233			// This should fail with an exception
1234			// Gecko does not error, returns false instead
1235			matches.call( div, "[s!='']:x" );
1236			rbuggyMatches.push( "!=", pseudos );
1237		});
1238	}
1239
1240	rbuggyQSA = rbuggyQSA.length && new RegExp( rbuggyQSA.join("|") );
1241	rbuggyMatches = rbuggyMatches.length && new RegExp( rbuggyMatches.join("|") );
1242
1243	/* Contains
1244	---------------------------------------------------------------------- */
1245	hasCompare = rnative.test( docElem.compareDocumentPosition );
1246
1247	// Element contains another
1248	// Purposefully does not implement inclusive descendent
1249	// As in, an element does not contain itself
1250	contains = hasCompare || rnative.test( docElem.contains ) ?
1251		function( a, b ) {
1252			var adown = a.nodeType === 9 ? a.documentElement : a,
1253				bup = b && b.parentNode;
1254			return a === bup || !!( bup && bup.nodeType === 1 && (
1255				adown.contains ?
1256					adown.contains( bup ) :
1257					a.compareDocumentPosition && a.compareDocumentPosition( bup ) & 16
1258			));
1259		} :
1260		function( a, b ) {
1261			if ( b ) {
1262				while ( (b = b.parentNode) ) {
1263					if ( b === a ) {
1264						return true;
1265					}
1266				}
1267			}
1268			return false;
1269		};
1270
1271	/* Sorting
1272	---------------------------------------------------------------------- */
1273
1274	// Document order sorting
1275	sortOrder = hasCompare ?
1276	function( a, b ) {
1277
1278		// Flag for duplicate removal
1279		if ( a === b ) {
1280			hasDuplicate = true;
1281			return 0;
1282		}
1283
1284		// Sort on method existence if only one input has compareDocumentPosition
1285		var compare = !a.compareDocumentPosition - !b.compareDocumentPosition;
1286		if ( compare ) {
1287			return compare;
1288		}
1289
1290		// Calculate position if both inputs belong to the same document
1291		compare = ( a.ownerDocument || a ) === ( b.ownerDocument || b ) ?
1292			a.compareDocumentPosition( b ) :
1293
1294			// Otherwise we know they are disconnected
1295			1;
1296
1297		// Disconnected nodes
1298		if ( compare & 1 ||
1299			(!support.sortDetached && b.compareDocumentPosition( a ) === compare) ) {
1300
1301			// Choose the first element that is related to our preferred document
1302			if ( a === doc || a.ownerDocument === preferredDoc && contains(preferredDoc, a) ) {
1303				return -1;
1304			}
1305			if ( b === doc || b.ownerDocument === preferredDoc && contains(preferredDoc, b) ) {
1306				return 1;
1307			}
1308
1309			// Maintain original order
1310			return sortInput ?
1311				( indexOf.call( sortInput, a ) - indexOf.call( sortInput, b ) ) :
1312				0;
1313		}
1314
1315		return compare & 4 ? -1 : 1;
1316	} :
1317	function( a, b ) {
1318		// Exit early if the nodes are identical
1319		if ( a === b ) {
1320			hasDuplicate = true;
1321			return 0;
1322		}
1323
1324		var cur,
1325			i = 0,
1326			aup = a.parentNode,
1327			bup = b.parentNode,
1328			ap = [ a ],
1329			bp = [ b ];
1330
1331		// Parentless nodes are either documents or disconnected
1332		if ( !aup || !bup ) {
1333			return a === doc ? -1 :
1334				b === doc ? 1 :
1335				aup ? -1 :
1336				bup ? 1 :
1337				sortInput ?
1338				( indexOf.call( sortInput, a ) - indexOf.call( sortInput, b ) ) :
1339				0;
1340
1341		// If the nodes are siblings, we can do a quick check
1342		} else if ( aup === bup ) {
1343			return siblingCheck( a, b );
1344		}
1345
1346		// Otherwise we need full lists of their ancestors for comparison
1347		cur = a;
1348		while ( (cur = cur.parentNode) ) {
1349			ap.unshift( cur );
1350		}
1351		cur = b;
1352		while ( (cur = cur.parentNode) ) {
1353			bp.unshift( cur );
1354		}
1355
1356		// Walk down the tree looking for a discrepancy
1357		while ( ap[i] === bp[i] ) {
1358			i++;
1359		}
1360
1361		return i ?
1362			// Do a sibling check if the nodes have a common ancestor
1363			siblingCheck( ap[i], bp[i] ) :
1364
1365			// Otherwise nodes in our document sort first
1366			ap[i] === preferredDoc ? -1 :
1367			bp[i] === preferredDoc ? 1 :
1368			0;
1369	};
1370
1371	return doc;
1372};
1373
1374Sizzle.matches = function( expr, elements ) {
1375	return Sizzle( expr, null, null, elements );
1376};
1377
1378Sizzle.matchesSelector = function( elem, expr ) {
1379	// Set document vars if needed
1380	if ( ( elem.ownerDocument || elem ) !== document ) {
1381		setDocument( elem );
1382	}
1383
1384	// Make sure that attribute selectors are quoted
1385	expr = expr.replace( rattributeQuotes, "='$1']" );
1386
1387	if ( support.matchesSelector && documentIsHTML &&
1388		( !rbuggyMatches || !rbuggyMatches.test( expr ) ) &&
1389		( !rbuggyQSA     || !rbuggyQSA.test( expr ) ) ) {
1390
1391		try {
1392			var ret = matches.call( elem, expr );
1393
1394			// IE 9's matchesSelector returns false on disconnected nodes
1395			if ( ret || support.disconnectedMatch ||
1396					// As well, disconnected nodes are said to be in a document
1397					// fragment in IE 9
1398					elem.document && elem.document.nodeType !== 11 ) {
1399				return ret;
1400			}
1401		} catch(e) {}
1402	}
1403
1404	return Sizzle( expr, document, null, [ elem ] ).length > 0;
1405};
1406
1407Sizzle.contains = function( context, elem ) {
1408	// Set document vars if needed
1409	if ( ( context.ownerDocument || context ) !== document ) {
1410		setDocument( context );
1411	}
1412	return contains( context, elem );
1413};
1414
1415Sizzle.attr = function( elem, name ) {
1416	// Set document vars if needed
1417	if ( ( elem.ownerDocument || elem ) !== document ) {
1418		setDocument( elem );
1419	}
1420
1421	var fn = Expr.attrHandle[ name.toLowerCase() ],
1422		// Don't get fooled by Object.prototype properties (jQuery #13807)
1423		val = fn && hasOwn.call( Expr.attrHandle, name.toLowerCase() ) ?
1424			fn( elem, name, !documentIsHTML ) :
1425			undefined;
1426
1427	return val !== undefined ?
1428		val :
1429		support.attributes || !documentIsHTML ?
1430			elem.getAttribute( name ) :
1431			(val = elem.getAttributeNode(name)) && val.specified ?
1432				val.value :
1433				null;
1434};
1435
1436Sizzle.error = function( msg ) {
1437	throw new Error( "Syntax error, unrecognized expression: " + msg );
1438};
1439
1440/**
1441 * Document sorting and removing duplicates
1442 * @param {ArrayLike} results
1443 */
1444Sizzle.uniqueSort = function( results ) {
1445	var elem,
1446		duplicates = [],
1447		j = 0,
1448		i = 0;
1449
1450	// Unless we *know* we can detect duplicates, assume their presence
1451	hasDuplicate = !support.detectDuplicates;
1452	sortInput = !support.sortStable && results.slice( 0 );
1453	results.sort( sortOrder );
1454
1455	if ( hasDuplicate ) {
1456		while ( (elem = results[i++]) ) {
1457			if ( elem === results[ i ] ) {
1458				j = duplicates.push( i );
1459			}
1460		}
1461		while ( j-- ) {
1462			results.splice( duplicates[ j ], 1 );
1463		}
1464	}
1465
1466	// Clear input after sorting to release objects
1467	// See https://github.com/jquery/sizzle/pull/225
1468	sortInput = null;
1469
1470	return results;
1471};
1472
1473/**
1474 * Utility function for retrieving the text value of an array of DOM nodes
1475 * @param {Array|Element} elem
1476 */
1477getText = Sizzle.getText = function( elem ) {
1478	var node,
1479		ret = "",
1480		i = 0,
1481		nodeType = elem.nodeType;
1482
1483	if ( !nodeType ) {
1484		// If no nodeType, this is expected to be an array
1485		while ( (node = elem[i++]) ) {
1486			// Do not traverse comment nodes
1487			ret += getText( node );
1488		}
1489	} else if ( nodeType === 1 || nodeType === 9 || nodeType === 11 ) {
1490		// Use textContent for elements
1491		// innerText usage removed for consistency of new lines (jQuery #11153)
1492		if ( typeof elem.textContent === "string" ) {
1493			return elem.textContent;
1494		} else {
1495			// Traverse its children
1496			for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
1497				ret += getText( elem );
1498			}
1499		}
1500	} else if ( nodeType === 3 || nodeType === 4 ) {
1501		return elem.nodeValue;
1502	}
1503	// Do not include comment or processing instruction nodes
1504
1505	return ret;
1506};
1507
1508Expr = Sizzle.selectors = {
1509
1510	// Can be adjusted by the user
1511	cacheLength: 50,
1512
1513	createPseudo: markFunction,
1514
1515	match: matchExpr,
1516
1517	attrHandle: {},
1518
1519	find: {},
1520
1521	relative: {
1522		">": { dir: "parentNode", first: true },
1523		" ": { dir: "parentNode" },
1524		"+": { dir: "previousSibling", first: true },
1525		"~": { dir: "previousSibling" }
1526	},
1527
1528	preFilter: {
1529		"ATTR": function( match ) {
1530			match[1] = match[1].replace( runescape, funescape );
1531
1532			// Move the given value to match[3] whether quoted or unquoted
1533			match[3] = ( match[3] || match[4] || match[5] || "" ).replace( runescape, funescape );
1534
1535			if ( match[2] === "~=" ) {
1536				match[3] = " " + match[3] + " ";
1537			}
1538
1539			return match.slice( 0, 4 );
1540		},
1541
1542		"CHILD": function( match ) {
1543			/* matches from matchExpr["CHILD"]
1544				1 type (only|nth|...)
1545				2 what (child|of-type)
1546				3 argument (even|odd|\d*|\d*n([+-]\d+)?|...)
1547				4 xn-component of xn+y argument ([+-]?\d*n|)
1548				5 sign of xn-component
1549				6 x of xn-component
1550				7 sign of y-component
1551				8 y of y-component
1552			*/
1553			match[1] = match[1].toLowerCase();
1554
1555			if ( match[1].slice( 0, 3 ) === "nth" ) {
1556				// nth-* requires argument
1557				if ( !match[3] ) {
1558					Sizzle.error( match[0] );
1559				}
1560
1561				// numeric x and y parameters for Expr.filter.CHILD
1562				// remember that false/true cast respectively to 0/1
1563				match[4] = +( match[4] ? match[5] + (match[6] || 1) : 2 * ( match[3] === "even" || match[3] === "odd" ) );
1564				match[5] = +( ( match[7] + match[8] ) || match[3] === "odd" );
1565
1566			// other types prohibit arguments
1567			} else if ( match[3] ) {
1568				Sizzle.error( match[0] );
1569			}
1570
1571			return match;
1572		},
1573
1574		"PSEUDO": function( match ) {
1575			var excess,
1576				unquoted = !match[6] && match[2];
1577
1578			if ( matchExpr["CHILD"].test( match[0] ) ) {
1579				return null;
1580			}
1581
1582			// Accept quoted arguments as-is
1583			if ( match[3] ) {
1584				match[2] = match[4] || match[5] || "";
1585
1586			// Strip excess characters from unquoted arguments
1587			} else if ( unquoted && rpseudo.test( unquoted ) &&
1588				// Get excess from tokenize (recursively)
1589				(excess = tokenize( unquoted, true )) &&
1590				// advance to the next closing parenthesis
1591				(excess = unquoted.indexOf( ")", unquoted.length - excess ) - unquoted.length) ) {
1592
1593				// excess is a negative index
1594				match[0] = match[0].slice( 0, excess );
1595				match[2] = unquoted.slice( 0, excess );
1596			}
1597
1598			// Return only captures needed by the pseudo filter method (type and argument)
1599			return match.slice( 0, 3 );
1600		}
1601	},
1602
1603	filter: {
1604
1605		"TAG": function( nodeNameSelector ) {
1606			var nodeName = nodeNameSelector.replace( runescape, funescape ).toLowerCase();
1607			return nodeNameSelector === "*" ?
1608				function() { return true; } :
1609				function( elem ) {
1610					return elem.nodeName && elem.nodeName.toLowerCase() === nodeName;
1611				};
1612		},
1613
1614		"CLASS": function( className ) {
1615			var pattern = classCache[ className + " " ];
1616
1617			return pattern ||
1618				(pattern = new RegExp( "(^|" + whitespace + ")" + className + "(" + whitespace + "|$)" )) &&
1619				classCache( className, function( elem ) {
1620					return pattern.test( typeof elem.className === "string" && elem.className || typeof elem.getAttribute !== strundefined && elem.getAttribute("class") || "" );
1621				});
1622		},
1623
1624		"ATTR": function( name, operator, check ) {
1625			return function( elem ) {
1626				var result = Sizzle.attr( elem, name );
1627
1628				if ( result == null ) {
1629					return operator === "!=";
1630				}
1631				if ( !operator ) {
1632					return true;
1633				}
1634
1635				result += "";
1636
1637				return operator === "=" ? result === check :
1638					operator === "!=" ? result !== check :
1639					operator === "^=" ? check && result.indexOf( check ) === 0 :
1640					operator === "*=" ? check && result.indexOf( check ) > -1 :
1641					operator === "$=" ? check && result.slice( -check.length ) === check :
1642					operator === "~=" ? ( " " + result + " " ).indexOf( check ) > -1 :
1643					operator === "|=" ? result === check || result.slice( 0, check.length + 1 ) === check + "-" :
1644					false;
1645			};
1646		},
1647
1648		"CHILD": function( type, what, argument, first, last ) {
1649			var simple = type.slice( 0, 3 ) !== "nth",
1650				forward = type.slice( -4 ) !== "last",
1651				ofType = what === "of-type";
1652
1653			return first === 1 && last === 0 ?
1654
1655				// Shortcut for :nth-*(n)
1656				function( elem ) {
1657					return !!elem.parentNode;
1658				} :
1659
1660				function( elem, context, xml ) {
1661					var cache, outerCache, node, diff, nodeIndex, start,
1662						dir = simple !== forward ? "nextSibling" : "previousSibling",
1663						parent = elem.parentNode,
1664						name = ofType && elem.nodeName.toLowerCase(),
1665						useCache = !xml && !ofType;
1666
1667					if ( parent ) {
1668
1669						// :(first|last|only)-(child|of-type)
1670						if ( simple ) {
1671							while ( dir ) {
1672								node = elem;
1673								while ( (node = node[ dir ]) ) {
1674									if ( ofType ? node.nodeName.toLowerCase() === name : node.nodeType === 1 ) {
1675										return false;
1676									}
1677								}
1678								// Reverse direction for :only-* (if we haven't yet done so)
1679								start = dir = type === "only" && !start && "nextSibling";
1680							}
1681							return true;
1682						}
1683
1684						start = [ forward ? parent.firstChild : parent.lastChild ];
1685
1686						// non-xml :nth-child(...) stores cache data on `parent`
1687						if ( forward && useCache ) {
1688							// Seek `elem` from a previously-cached index
1689							outerCache = parent[ expando ] || (parent[ expando ] = {});
1690							cache = outerCache[ type ] || [];
1691							nodeIndex = cache[0] === dirruns && cache[1];
1692							diff = cache[0] === dirruns && cache[2];
1693							node = nodeIndex && parent.childNodes[ nodeIndex ];
1694
1695							while ( (node = ++nodeIndex && node && node[ dir ] ||
1696
1697								// Fallback to seeking `elem` from the start
1698								(diff = nodeIndex = 0) || start.pop()) ) {
1699
1700								// When found, cache indexes on `parent` and break
1701								if ( node.nodeType === 1 && ++diff && node === elem ) {
1702									outerCache[ type ] = [ dirruns, nodeIndex, diff ];
1703									break;
1704								}
1705							}
1706
1707						// Use previously-cached element index if available
1708						} else if ( useCache && (cache = (elem[ expando ] || (elem[ expando ] = {}))[ type ]) && cache[0] === dirruns ) {
1709							diff = cache[1];
1710
1711						// xml :nth-child(...) or :nth-last-child(...) or :nth(-last)?-of-type(...)
1712						} else {
1713							// Use the same loop as above to seek `elem` from the start
1714							while ( (node = ++nodeIndex && node && node[ dir ] ||
1715								(diff = nodeIndex = 0) || start.pop()) ) {
1716
1717								if ( ( ofType ? node.nodeName.toLowerCase() === name : node.nodeType === 1 ) && ++diff ) {
1718									// Cache the index of each encountered element
1719									if ( useCache ) {
1720										(node[ expando ] || (node[ expando ] = {}))[ type ] = [ dirruns, diff ];
1721									}
1722
1723									if ( node === elem ) {
1724										break;
1725									}
1726								}
1727							}
1728						}
1729
1730						// Incorporate the offset, then check against cycle size
1731						diff -= last;
1732						return diff === first || ( diff % first === 0 && diff / first >= 0 );
1733					}
1734				};
1735		},
1736
1737		"PSEUDO": function( pseudo, argument ) {
1738			// pseudo-class names are case-insensitive
1739			// http://www.w3.org/TR/selectors/#pseudo-classes
1740			// Prioritize by case sensitivity in case custom pseudos are added with uppercase letters
1741			// Remember that setFilters inherits from pseudos
1742			var args,
1743				fn = Expr.pseudos[ pseudo ] || Expr.setFilters[ pseudo.toLowerCase() ] ||
1744					Sizzle.error( "unsupported pseudo: " + pseudo );
1745
1746			// The user may use createPseudo to indicate that
1747			// arguments are needed to create the filter function
1748			// just as Sizzle does
1749			if ( fn[ expando ] ) {
1750				return fn( argument );
1751			}
1752
1753			// But maintain support for old signatures
1754			if ( fn.length > 1 ) {
1755				args = [ pseudo, pseudo, "", argument ];
1756				return Expr.setFilters.hasOwnProperty( pseudo.toLowerCase() ) ?
1757					markFunction(function( seed, matches ) {
1758						var idx,
1759							matched = fn( seed, argument ),
1760							i = matched.length;
1761						while ( i-- ) {
1762							idx = indexOf.call( seed, matched[i] );
1763							seed[ idx ] = !( matches[ idx ] = matched[i] );
1764						}
1765					}) :
1766					function( elem ) {
1767						return fn( elem, 0, args );
1768					};
1769			}
1770
1771			return fn;
1772		}
1773	},
1774
1775	pseudos: {
1776		// Potentially complex pseudos
1777		"not": markFunction(function( selector ) {
1778			// Trim the selector passed to compile
1779			// to avoid treating leading and trailing
1780			// spaces as combinators
1781			var input = [],
1782				results = [],
1783				matcher = compile( selector.replace( rtrim, "$1" ) );
1784
1785			return matcher[ expando ] ?
1786				markFunction(function( seed, matches, context, xml ) {
1787					var elem,
1788						unmatched = matcher( seed, null, xml, [] ),
1789						i = seed.length;
1790
1791					// Match elements unmatched by `matcher`
1792					while ( i-- ) {
1793						if ( (elem = unmatched[i]) ) {
1794							seed[i] = !(matches[i] = elem);
1795						}
1796					}
1797				}) :
1798				function( elem, context, xml ) {
1799					input[0] = elem;
1800					matcher( input, null, xml, results );
1801					return !results.pop();
1802				};
1803		}),
1804
1805		"has": markFunction(function( selector ) {
1806			return function( elem ) {
1807				return Sizzle( selector, elem ).length > 0;
1808			};
1809		}),
1810
1811		"contains": markFunction(function( text ) {
1812			return function( elem ) {
1813				return ( elem.textContent || elem.innerText || getText( elem ) ).indexOf( text ) > -1;
1814			};
1815		}),
1816
1817		// "Whether an element is represented by a :lang() selector
1818		// is based solely on the element's language value
1819		// being equal to the identifier C,
1820		// or beginning with the identifier C immediately followed by "-".
1821		// The matching of C against the element's language value is performed case-insensitively.
1822		// The identifier C does not have to be a valid language name."
1823		// http://www.w3.org/TR/selectors/#lang-pseudo
1824		"lang": markFunction( function( lang ) {
1825			// lang value must be a valid identifier
1826			if ( !ridentifier.test(lang || "") ) {
1827				Sizzle.error( "unsupported lang: " + lang );
1828			}
1829			lang = lang.replace( runescape, funescape ).toLowerCase();
1830			return function( elem ) {
1831				var elemLang;
1832				do {
1833					if ( (elemLang = documentIsHTML ?
1834						elem.lang :
1835						elem.getAttribute("xml:lang") || elem.getAttribute("lang")) ) {
1836
1837						elemLang = elemLang.toLowerCase();
1838						return elemLang === lang || elemLang.indexOf( lang + "-" ) === 0;
1839					}
1840				} while ( (elem = elem.parentNode) && elem.nodeType === 1 );
1841				return false;
1842			};
1843		}),
1844
1845		// Miscellaneous
1846		"target": function( elem ) {
1847			var hash = window.location && window.location.hash;
1848			return hash && hash.slice( 1 ) === elem.id;
1849		},
1850
1851		"root": function( elem ) {
1852			return elem === docElem;
1853		},
1854
1855		"focus": function( elem ) {
1856			return elem === document.activeElement && (!document.hasFocus || document.hasFocus()) && !!(elem.type || elem.href || ~elem.tabIndex);
1857		},
1858
1859		// Boolean properties
1860		"enabled": function( elem ) {
1861			return elem.disabled === false;
1862		},
1863
1864		"disabled": function( elem ) {
1865			return elem.disabled === true;
1866		},
1867
1868		"checked": function( elem ) {
1869			// In CSS3, :checked should return both checked and selected elements
1870			// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
1871			var nodeName = elem.nodeName.toLowerCase();
1872			return (nodeName === "input" && !!elem.checked) || (nodeName === "option" && !!elem.selected);
1873		},
1874
1875		"selected": function( elem ) {
1876			// Accessing this property makes selected-by-default
1877			// options in Safari work properly
1878			if ( elem.parentNode ) {
1879				elem.parentNode.selectedIndex;
1880			}
1881
1882			return elem.selected === true;
1883		},
1884
1885		// Contents
1886		"empty": function( elem ) {
1887			// http://www.w3.org/TR/selectors/#empty-pseudo
1888			// :empty is negated by element (1) or content nodes (text: 3; cdata: 4; entity ref: 5),
1889			//   but not by others (comment: 8; processing instruction: 7; etc.)
1890			// nodeType < 6 works because attributes (2) do not appear as children
1891			for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
1892				if ( elem.nodeType < 6 ) {
1893					return false;
1894				}
1895			}
1896			return true;
1897		},
1898
1899		"parent": function( elem ) {
1900			return !Expr.pseudos["empty"]( elem );
1901		},
1902
1903		// Element/input types
1904		"header": function( elem ) {
1905			return rheader.test( elem.nodeName );
1906		},
1907
1908		"input": function( elem ) {
1909			return rinputs.test( elem.nodeName );
1910		},
1911
1912		"button": function( elem ) {
1913			var name = elem.nodeName.toLowerCase();
1914			return name === "input" && elem.type === "button" || name === "button";
1915		},
1916
1917		"text": function( elem ) {
1918			var attr;
1919			return elem.nodeName.toLowerCase() === "input" &&
1920				elem.type === "text" &&
1921
1922				// Support: IE<8
1923				// New HTML5 attribute values (e.g., "search") appear with elem.type === "text"
1924				( (attr = elem.getAttribute("type")) == null || attr.toLowerCase() === "text" );
1925		},
1926
1927		// Position-in-collection
1928		"first": createPositionalPseudo(function() {
1929			return [ 0 ];
1930		}),
1931
1932		"last": createPositionalPseudo(function( matchIndexes, length ) {
1933			return [ length - 1 ];
1934		}),
1935
1936		"eq": createPositionalPseudo(function( matchIndexes, length, argument ) {
1937			return [ argument < 0 ? argument + length : argument ];
1938		}),
1939
1940		"even": createPositionalPseudo(function( matchIndexes, length ) {
1941			var i = 0;
1942			for ( ; i < length; i += 2 ) {
1943				matchIndexes.push( i );
1944			}
1945			return matchIndexes;
1946		}),
1947
1948		"odd": createPositionalPseudo(function( matchIndexes, length ) {
1949			var i = 1;
1950			for ( ; i < length; i += 2 ) {
1951				matchIndexes.push( i );
1952			}
1953			return matchIndexes;
1954		}),
1955
1956		"lt": createPositionalPseudo(function( matchIndexes, length, argument ) {
1957			var i = argument < 0 ? argument + length : argument;
1958			for ( ; --i >= 0; ) {
1959				matchIndexes.push( i );
1960			}
1961			return matchIndexes;
1962		}),
1963
1964		"gt": createPositionalPseudo(function( matchIndexes, length, argument ) {
1965			var i = argument < 0 ? argument + length : argument;
1966			for ( ; ++i < length; ) {
1967				matchIndexes.push( i );
1968			}
1969			return matchIndexes;
1970		})
1971	}
1972};
1973
1974Expr.pseudos["nth"] = Expr.pseudos["eq"];
1975
1976// Add button/input type pseudos
1977for ( i in { radio: true, checkbox: true, file: true, password: true, image: true } ) {
1978	Expr.pseudos[ i ] = createInputPseudo( i );
1979}
1980for ( i in { submit: true, reset: true } ) {
1981	Expr.pseudos[ i ] = createButtonPseudo( i );
1982}
1983
1984// Easy API for creating new setFilters
1985function setFilters() {}
1986setFilters.prototype = Expr.filters = Expr.pseudos;
1987Expr.setFilters = new setFilters();
1988
1989tokenize = Sizzle.tokenize = function( selector, parseOnly ) {
1990	var matched, match, tokens, type,
1991		soFar, groups, preFilters,
1992		cached = tokenCache[ selector + " " ];
1993
1994	if ( cached ) {
1995		return parseOnly ? 0 : cached.slice( 0 );
1996	}
1997
1998	soFar = selector;
1999	groups = [];
2000	preFilters = Expr.preFilter;
2001
2002	while ( soFar ) {
2003
2004		// Comma and first run
2005		if ( !matched || (match = rcomma.exec( soFar )) ) {
2006			if ( match ) {
2007				// Don't consume trailing commas as valid
2008				soFar = soFar.slice( match[0].length ) || soFar;
2009			}
2010			groups.push( (tokens = []) );
2011		}
2012
2013		matched = false;
2014
2015		// Combinators
2016		if ( (match = rcombinators.exec( soFar )) ) {
2017			matched = match.shift();
2018			tokens.push({
2019				value: matched,
2020				// Cast descendant combinators to space
2021				type: match[0].replace( rtrim, " " )
2022			});
2023			soFar = soFar.slice( matched.length );
2024		}
2025
2026		// Filters
2027		for ( type in Expr.filter ) {
2028			if ( (match = matchExpr[ type ].exec( soFar )) && (!preFilters[ type ] ||
2029				(match = preFilters[ type ]( match ))) ) {
2030				matched = match.shift();
2031				tokens.push({
2032					value: matched,
2033					type: type,
2034					matches: match
2035				});
2036				soFar = soFar.slice( matched.length );
2037			}
2038		}
2039
2040		if ( !matched ) {
2041			break;
2042		}
2043	}
2044
2045	// Return the length of the invalid excess
2046	// if we're just parsing
2047	// Otherwise, throw an error or return tokens
2048	return parseOnly ?
2049		soFar.length :
2050		soFar ?
2051			Sizzle.error( selector ) :
2052			// Cache the tokens
2053			tokenCache( selector, groups ).slice( 0 );
2054};
2055
2056function toSelector( tokens ) {
2057	var i = 0,
2058		len = tokens.length,
2059		selector = "";
2060	for ( ; i < len; i++ ) {
2061		selector += tokens[i].value;
2062	}
2063	return selector;
2064}
2065
2066function addCombinator( matcher, combinator, base ) {
2067	var dir = combinator.dir,
2068		checkNonElements = base && dir === "parentNode",
2069		doneName = done++;
2070
2071	return combinator.first ?
2072		// Check against closest ancestor/preceding element
2073		function( elem, context, xml ) {
2074			while ( (elem = elem[ dir ]) ) {
2075				if ( elem.nodeType === 1 || checkNonElements ) {
2076					return matcher( elem, context, xml );
2077				}
2078			}
2079		} :
2080
2081		// Check against all ancestor/preceding elements
2082		function( elem, context, xml ) {
2083			var oldCache, outerCache,
2084				newCache = [ dirruns, doneName ];
2085
2086			// We can't set arbitrary data on XML nodes, so they don't benefit from dir caching
2087			if ( xml ) {
2088				while ( (elem = elem[ dir ]) ) {
2089					if ( elem.nodeType === 1 || checkNonElements ) {
2090						if ( matcher( elem, context, xml ) ) {
2091							return true;
2092						}
2093					}
2094				}
2095			} else {
2096				while ( (elem = elem[ dir ]) ) {
2097					if ( elem.nodeType === 1 || checkNonElements ) {
2098						outerCache = elem[ expando ] || (elem[ expando ] = {});
2099						if ( (oldCache = outerCache[ dir ]) &&
2100							oldCache[ 0 ] === dirruns && oldCache[ 1 ] === doneName ) {
2101
2102							// Assign to newCache so results back-propagate to previous elements
2103							return (newCache[ 2 ] = oldCache[ 2 ]);
2104						} else {
2105							// Reuse newcache so results back-propagate to previous elements
2106							outerCache[ dir ] = newCache;
2107
2108							// A match means we're done; a fail means we have to keep checking
2109							if ( (newCache[ 2 ] = matcher( elem, context, xml )) ) {
2110								return true;
2111							}
2112						}
2113					}
2114				}
2115			}
2116		};
2117}
2118
2119function elementMatcher( matchers ) {
2120	return matchers.length > 1 ?
2121		function( elem, context, xml ) {
2122			var i = matchers.length;
2123			while ( i-- ) {
2124				if ( !matchers[i]( elem, context, xml ) ) {
2125					return false;
2126				}
2127			}
2128			return true;
2129		} :
2130		matchers[0];
2131}
2132
2133function multipleContexts( selector, contexts, results ) {
2134	var i = 0,
2135		len = contexts.length;
2136	for ( ; i < len; i++ ) {
2137		Sizzle( selector, contexts[i], results );
2138	}
2139	return results;
2140}
2141
2142function condense( unmatched, map, filter, context, xml ) {
2143	var elem,
2144		newUnmatched = [],
2145		i = 0,
2146		len = unmatched.length,
2147		mapped = map != null;
2148
2149	for ( ; i < len; i++ ) {
2150		if ( (elem = unmatched[i]) ) {
2151			if ( !filter || filter( elem, context, xml ) ) {
2152				newUnmatched.push( elem );
2153				if ( mapped ) {
2154					map.push( i );
2155				}
2156			}
2157		}
2158	}
2159
2160	return newUnmatched;
2161}
2162
2163function setMatcher( preFilter, selector, matcher, postFilter, postFinder, postSelector ) {
2164	if ( postFilter && !postFilter[ expando ] ) {
2165		postFilter = setMatcher( postFilter );
2166	}
2167	if ( postFinder && !postFinder[ expando ] ) {
2168		postFinder = setMatcher( postFinder, postSelector );
2169	}
2170	return markFunction(function( seed, results, context, xml ) {
2171		var temp, i, elem,
2172			preMap = [],
2173			postMap = [],
2174			preexisting = results.length,
2175
2176			// Get initial elements from seed or context
2177			elems = seed || multipleContexts( selector || "*", context.nodeType ? [ context ] : context, [] ),
2178
2179			// Prefilter to get matcher input, preserving a map for seed-results synchronization
2180			matcherIn = preFilter && ( seed || !selector ) ?
2181				condense( elems, preMap, preFilter, context, xml ) :
2182				elems,
2183
2184			matcherOut = matcher ?
2185				// If we have a postFinder, or filtered seed, or non-seed postFilter or preexisting results,
2186				postFinder || ( seed ? preFilter : preexisting || postFilter ) ?
2187
2188					// ...intermediate processing is necessary
2189					[] :
2190
2191					// ...otherwise use results directly
2192					results :
2193				matcherIn;
2194
2195		// Find primary matches
2196		if ( matcher ) {
2197			matcher( matcherIn, matcherOut, context, xml );
2198		}
2199
2200		// Apply postFilter
2201		if ( postFilter ) {
2202			temp = condense( matcherOut, postMap );
2203			postFilter( temp, [], context, xml );
2204
2205			// Un-match failing elements by moving them back to matcherIn
2206			i = temp.length;
2207			while ( i-- ) {
2208				if ( (elem = temp[i]) ) {
2209					matcherOut[ postMap[i] ] = !(matcherIn[ postMap[i] ] = elem);
2210				}
2211			}
2212		}
2213
2214		if ( seed ) {
2215			if ( postFinder || preFilter ) {
2216				if ( postFinder ) {
2217					// Get the final matcherOut by condensing this intermediate into postFinder contexts
2218					temp = [];
2219					i = matcherOut.length;
2220					while ( i-- ) {
2221						if ( (elem = matcherOut[i]) ) {
2222							// Restore matcherIn since elem is not yet a final match
2223							temp.push( (matcherIn[i] = elem) );
2224						}
2225					}
2226					postFinder( null, (matcherOut = []), temp, xml );
2227				}
2228
2229				// Move matched elements from seed to results to keep them synchronized
2230				i = matcherOut.length;
2231				while ( i-- ) {
2232					if ( (elem = matcherOut[i]) &&
2233						(temp = postFinder ? indexOf.call( seed, elem ) : preMap[i]) > -1 ) {
2234
2235						seed[temp] = !(results[temp] = elem);
2236					}
2237				}
2238			}
2239
2240		// Add elements to results, through postFinder if defined
2241		} else {
2242			matcherOut = condense(
2243				matcherOut === results ?
2244					matcherOut.splice( preexisting, matcherOut.length ) :
2245					matcherOut
2246			);
2247			if ( postFinder ) {
2248				postFinder( null, results, matcherOut, xml );
2249			} else {
2250				push.apply( results, matcherOut );
2251			}
2252		}
2253	});
2254}
2255
2256function matcherFromTokens( tokens ) {
2257	var checkContext, matcher, j,
2258		len = tokens.length,
2259		leadingRelative = Expr.relative[ tokens[0].type ],
2260		implicitRelative = leadingRelative || Expr.relative[" "],
2261		i = leadingRelative ? 1 : 0,
2262
2263		// The foundational matcher ensures that elements are reachable from top-level context(s)
2264		matchContext = addCombinator( function( elem ) {
2265			return elem === checkContext;
2266		}, implicitRelative, true ),
2267		matchAnyContext = addCombinator( function( elem ) {
2268			return indexOf.call( checkContext, elem ) > -1;
2269		}, implicitRelative, true ),
2270		matchers = [ function( elem, context, xml ) {
2271			return ( !leadingRelative && ( xml || context !== outermostContext ) ) || (
2272				(checkContext = context).nodeType ?
2273					matchContext( elem, context, xml ) :
2274					matchAnyContext( elem, context, xml ) );
2275		} ];
2276
2277	for ( ; i < len; i++ ) {
2278		if ( (matcher = Expr.relative[ tokens[i].type ]) ) {
2279			matchers = [ addCombinator(elementMatcher( matchers ), matcher) ];
2280		} else {
2281			matcher = Expr.filter[ tokens[i].type ].apply( null, tokens[i].matches );
2282
2283			// Return special upon seeing a positional matcher
2284			if ( matcher[ expando ] ) {
2285				// Find the next relative operator (if any) for proper handling
2286				j = ++i;
2287				for ( ; j < len; j++ ) {
2288					if ( Expr.relative[ tokens[j].type ] ) {
2289						break;
2290					}
2291				}
2292				return setMatcher(
2293					i > 1 && elementMatcher( matchers ),
2294					i > 1 && toSelector(
2295						// If the preceding token was a descendant combinator, insert an implicit any-element `*`
2296						tokens.slice( 0, i - 1 ).concat({ value: tokens[ i - 2 ].type === " " ? "*" : "" })
2297					).replace( rtrim, "$1" ),
2298					matcher,
2299					i < j && matcherFromTokens( tokens.slice( i, j ) ),
2300					j < len && matcherFromTokens( (tokens = tokens.slice( j )) ),
2301					j < len && toSelector( tokens )
2302				);
2303			}
2304			matchers.push( matcher );
2305		}
2306	}
2307
2308	return elementMatcher( matchers );
2309}
2310
2311function matcherFromGroupMatchers( elementMatchers, setMatchers ) {
2312	var bySet = setMatchers.length > 0,
2313		byElement = elementMatchers.length > 0,
2314		superMatcher = function( seed, context, xml, results, outermost ) {
2315			var elem, j, matcher,
2316				matchedCount = 0,
2317				i = "0",
2318				unmatched = seed && [],
2319				setMatched = [],
2320				contextBackup = outermostContext,
2321				// We must always have either seed elements or outermost context
2322				elems = seed || byElement && Expr.find["TAG"]( "*", outermost ),
2323				// Use integer dirruns iff this is the outermost matcher
2324				dirrunsUnique = (dirruns += contextBackup == null ? 1 : Math.random() || 0.1),
2325				len = elems.length;
2326
2327			if ( outermost ) {
2328				outermostContext = context !== document && context;
2329			}
2330
2331			// Add elements passing elementMatchers directly to results
2332			// Keep `i` a string if there are no elements so `matchedCount` will be "00" below
2333			// Support: IE<9, Safari
2334			// Tolerate NodeList properties (IE: "length"; Safari: <number>) matching elements by id
2335			for ( ; i !== len && (elem = elems[i]) != null; i++ ) {
2336				if ( byElement && elem ) {
2337					j = 0;
2338					while ( (matcher = elementMatchers[j++]) ) {
2339						if ( matcher( elem, context, xml ) ) {
2340							results.push( elem );
2341							break;
2342						}
2343					}
2344					if ( outermost ) {
2345						dirruns = dirrunsUnique;
2346					}
2347				}
2348
2349				// Track unmatched elements for set filters
2350				if ( bySet ) {
2351					// They will have gone through all possible matchers
2352					if ( (elem = !matcher && elem) ) {
2353						matchedCount--;
2354					}
2355
2356					// Lengthen the array for every element, matched or not
2357					if ( seed ) {
2358						unmatched.push( elem );
2359					}
2360				}
2361			}
2362
2363			// Apply set filters to unmatched elements
2364			matchedCount += i;
2365			if ( bySet && i !== matchedCount ) {
2366				j = 0;
2367				while ( (matcher = setMatchers[j++]) ) {
2368					matcher( unmatched, setMatched, context, xml );
2369				}
2370
2371				if ( seed ) {
2372					// Reintegrate element matches to eliminate the need for sorting
2373					if ( matchedCount > 0 ) {
2374						while ( i-- ) {
2375							if ( !(unmatched[i] || setMatched[i]) ) {
2376								setMatched[i] = pop.call( results );
2377							}
2378						}
2379					}
2380
2381					// Discard index placeholder values to get only actual matches
2382					setMatched = condense( setMatched );
2383				}
2384
2385				// Add matches to results
2386				push.apply( results, setMatched );
2387
2388				// Seedless set matches succeeding multiple successful matchers stipulate sorting
2389				if ( outermost && !seed && setMatched.length > 0 &&
2390					( matchedCount + setMatchers.length ) > 1 ) {
2391
2392					Sizzle.uniqueSort( results );
2393				}
2394			}
2395
2396			// Override manipulation of globals by nested matchers
2397			if ( outermost ) {
2398				dirruns = dirrunsUnique;
2399				outermostContext = contextBackup;
2400			}
2401
2402			return unmatched;
2403		};
2404
2405	return bySet ?
2406		markFunction( superMatcher ) :
2407		superMatcher;
2408}
2409
2410compile = Sizzle.compile = function( selector, match /* Internal Use Only */ ) {
2411	var i,
2412		setMatchers = [],
2413		elementMatchers = [],
2414		cached = compilerCache[ selector + " " ];
2415
2416	if ( !cached ) {
2417		// Generate a function of recursive functions that can be used to check each element
2418		if ( !match ) {
2419			match = tokenize( selector );
2420		}
2421		i = match.length;
2422		while ( i-- ) {
2423			cached = matcherFromTokens( match[i] );
2424			if ( cached[ expando ] ) {
2425				setMatchers.push( cached );
2426			} else {
2427				elementMatchers.push( cached );
2428			}
2429		}
2430
2431		// Cache the compiled function
2432		cached = compilerCache( selector, matcherFromGroupMatchers( elementMatchers, setMatchers ) );
2433
2434		// Save selector and tokenization
2435		cached.selector = selector;
2436	}
2437	return cached;
2438};
2439
2440/**
2441 * A low-level selection function that works with Sizzle's compiled
2442 *  selector functions
2443 * @param {String|Function} selector A selector or a pre-compiled
2444 *  selector function built with Sizzle.compile
2445 * @param {Element} context
2446 * @param {Array} [results]
2447 * @param {Array} [seed] A set of elements to match against
2448 */
2449select = Sizzle.select = function( selector, context, results, seed ) {
2450	var i, tokens, token, type, find,
2451		compiled = typeof selector === "function" && selector,
2452		match = !seed && tokenize( (selector = compiled.selector || selector) );
2453
2454	results = results || [];
2455
2456	// Try to minimize operations if there is no seed and only one group
2457	if ( match.length === 1 ) {
2458
2459		// Take a shortcut and set the context if the root selector is an ID
2460		tokens = match[0] = match[0].slice( 0 );
2461		if ( tokens.length > 2 && (token = tokens[0]).type === "ID" &&
2462				support.getById && context.nodeType === 9 && documentIsHTML &&
2463				Expr.relative[ tokens[1].type ] ) {
2464
2465			context = ( Expr.find["ID"]( token.matches[0].replace(runescape, funescape), context ) || [] )[0];
2466			if ( !context ) {
2467				return results;
2468
2469			// Precompiled matchers will still verify ancestry, so step up a level
2470			} else if ( compiled ) {
2471				context = context.parentNode;
2472			}
2473
2474			selector = selector.slice( tokens.shift().value.length );
2475		}
2476
2477		// Fetch a seed set for right-to-left matching
2478		i = matchExpr["needsContext"].test( selector ) ? 0 : tokens.length;
2479		while ( i-- ) {
2480			token = tokens[i];
2481
2482			// Abort if we hit a combinator
2483			if ( Expr.relative[ (type = token.type) ] ) {
2484				break;
2485			}
2486			if ( (find = Expr.find[ type ]) ) {
2487				// Search, expanding context for leading sibling combinators
2488				if ( (seed = find(
2489					token.matches[0].replace( runescape, funescape ),
2490					rsibling.test( tokens[0].type ) && testContext( context.parentNode ) || context
2491				)) ) {
2492
2493					// If seed is empty or no tokens remain, we can return early
2494					tokens.splice( i, 1 );
2495					selector = seed.length && toSelector( tokens );
2496					if ( !selector ) {
2497						push.apply( results, seed );
2498						return results;
2499					}
2500
2501					break;
2502				}
2503			}
2504		}
2505	}
2506
2507	// Compile and execute a filtering function if one is not provided
2508	// Provide `match` to avoid retokenization if we modified the selector above
2509	( compiled || compile( selector, match ) )(
2510		seed,
2511		context,
2512		!documentIsHTML,
2513		results,
2514		rsibling.test( selector ) && testContext( context.parentNode ) || context
2515	);
2516	return results;
2517};
2518
2519// One-time assignments
2520
2521// Sort stability
2522support.sortStable = expando.split("").sort( sortOrder ).join("") === expando;
2523
2524// Support: Chrome<14
2525// Always assume duplicates if they aren't passed to the comparison function
2526support.detectDuplicates = !!hasDuplicate;
2527
2528// Initialize against the default document
2529setDocument();
2530
2531// Support: Webkit<537.32 - Safari 6.0.3/Chrome 25 (fixed in Chrome 27)
2532// Detached nodes confoundingly follow *each other*
2533support.sortDetached = assert(function( div1 ) {
2534	// Should return 1, but returns 4 (following)
2535	return div1.compareDocumentPosition( document.createElement("div") ) & 1;
2536});
2537
2538// Support: IE<8
2539// Prevent attribute/property "interpolation"
2540// http://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx
2541if ( !assert(function( div ) {
2542	div.innerHTML = "<a href='#'></a>";
2543	return div.firstChild.getAttribute("href") === "#" ;
2544}) ) {
2545	addHandle( "type|href|height|width", function( elem, name, isXML ) {
2546		if ( !isXML ) {
2547			return elem.getAttribute( name, name.toLowerCase() === "type" ? 1 : 2 );
2548		}
2549	});
2550}
2551
2552// Support: IE<9
2553// Use defaultValue in place of getAttribute("value")
2554if ( !support.attributes || !assert(function( div ) {
2555	div.innerHTML = "<input/>";
2556	div.firstChild.setAttribute( "value", "" );
2557	return div.firstChild.getAttribute( "value" ) === "";
2558}) ) {
2559	addHandle( "value", function( elem, name, isXML ) {
2560		if ( !isXML && elem.nodeName.toLowerCase() === "input" ) {
2561			return elem.defaultValue;
2562		}
2563	});
2564}
2565
2566// Support: IE<9
2567// Use getAttributeNode to fetch booleans when getAttribute lies
2568if ( !assert(function( div ) {
2569	return div.getAttribute("disabled") == null;
2570}) ) {
2571	addHandle( booleans, function( elem, name, isXML ) {
2572		var val;
2573		if ( !isXML ) {
2574			return elem[ name ] === true ? name.toLowerCase() :
2575					(val = elem.getAttributeNode( name )) && val.specified ?
2576					val.value :
2577				null;
2578		}
2579	});
2580}
2581
2582return Sizzle;
2583
2584})( window );
2585
2586
2587
2588jQuery.find = Sizzle;
2589jQuery.expr = Sizzle.selectors;
2590jQuery.expr[":"] = jQuery.expr.pseudos;
2591jQuery.unique = Sizzle.uniqueSort;
2592jQuery.text = Sizzle.getText;
2593jQuery.isXMLDoc = Sizzle.isXML;
2594jQuery.contains = Sizzle.contains;
2595
2596
2597
2598var rneedsContext = jQuery.expr.match.needsContext;
2599
2600var rsingleTag = (/^<(\w+)\s*\/?>(?:<\/\1>|)$/);
2601
2602
2603
2604var risSimple = /^.[^:#\[\.,]*$/;
2605
2606// Implement the identical functionality for filter and not
2607function winnow( elements, qualifier, not ) {
2608	if ( jQuery.isFunction( qualifier ) ) {
2609		return jQuery.grep( elements, function( elem, i ) {
2610			/* jshint -W018 */
2611			return !!qualifier.call( elem, i, elem ) !== not;
2612		});
2613
2614	}
2615
2616	if ( qualifier.nodeType ) {
2617		return jQuery.grep( elements, function( elem ) {
2618			return ( elem === qualifier ) !== not;
2619		});
2620
2621	}
2622
2623	if ( typeof qualifier === "string" ) {
2624		if ( risSimple.test( qualifier ) ) {
2625			return jQuery.filter( qualifier, elements, not );
2626		}
2627
2628		qualifier = jQuery.filter( qualifier, elements );
2629	}
2630
2631	return jQuery.grep( elements, function( elem ) {
2632		return ( indexOf.call( qualifier, elem ) >= 0 ) !== not;
2633	});
2634}
2635
2636jQuery.filter = function( expr, elems, not ) {
2637	var elem = elems[ 0 ];
2638
2639	if ( not ) {
2640		expr = ":not(" + expr + ")";
2641	}
2642
2643	return elems.length === 1 && elem.nodeType === 1 ?
2644		jQuery.find.matchesSelector( elem, expr ) ? [ elem ] : [] :
2645		jQuery.find.matches( expr, jQuery.grep( elems, function( elem ) {
2646			return elem.nodeType === 1;
2647		}));
2648};
2649
2650jQuery.fn.extend({
2651	find: function( selector ) {
2652		var i,
2653			len = this.length,
2654			ret = [],
2655			self = this;
2656
2657		if ( typeof selector !== "string" ) {
2658			return this.pushStack( jQuery( selector ).filter(function() {
2659				for ( i = 0; i < len; i++ ) {
2660					if ( jQuery.contains( self[ i ], this ) ) {
2661						return true;
2662					}
2663				}
2664			}) );
2665		}
2666
2667		for ( i = 0; i < len; i++ ) {
2668			jQuery.find( selector, self[ i ], ret );
2669		}
2670
2671		// Needed because $( selector, context ) becomes $( context ).find( selector )
2672		ret = this.pushStack( len > 1 ? jQuery.unique( ret ) : ret );
2673		ret.selector = this.selector ? this.selector + " " + selector : selector;
2674		return ret;
2675	},
2676	filter: function( selector ) {
2677		return this.pushStack( winnow(this, selector || [], false) );
2678	},
2679	not: function( selector ) {
2680		return this.pushStack( winnow(this, selector || [], true) );
2681	},
2682	is: function( selector ) {
2683		return !!winnow(
2684			this,
2685
2686			// If this is a positional/relative selector, check membership in the returned set
2687			// so $("p:first").is("p:last") won't return true for a doc with two "p".
2688			typeof selector === "string" && rneedsContext.test( selector ) ?
2689				jQuery( selector ) :
2690				selector || [],
2691			false
2692		).length;
2693	}
2694});
2695
2696
2697// Initialize a jQuery object
2698
2699
2700// A central reference to the root jQuery(document)
2701var rootjQuery,
2702
2703	// A simple way to check for HTML strings
2704	// Prioritize #id over <tag> to avoid XSS via location.hash (#9521)
2705	// Strict HTML recognition (#11290: must start with <)
2706	rquickExpr = /^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]*))$/,
2707
2708	init = jQuery.fn.init = function( selector, context ) {
2709		var match, elem;
2710
2711		// HANDLE: $(""), $(null), $(undefined), $(false)
2712		if ( !selector ) {
2713			return this;
2714		}
2715
2716		// Handle HTML strings
2717		if ( typeof selector === "string" ) {
2718			if ( selector[0] === "<" && selector[ selector.length - 1 ] === ">" && selector.length >= 3 ) {
2719				// Assume that strings that start and end with <> are HTML and skip the regex check
2720				match = [ null, selector, null ];
2721
2722			} else {
2723				match = rquickExpr.exec( selector );
2724			}
2725
2726			// Match html or make sure no context is specified for #id
2727			if ( match && (match[1] || !context) ) {
2728
2729				// HANDLE: $(html) -> $(array)
2730				if ( match[1] ) {
2731					context = context instanceof jQuery ? context[0] : context;
2732
2733					// scripts is true for back-compat
2734					// Intentionally let the error be thrown if parseHTML is not present
2735					jQuery.merge( this, jQuery.parseHTML(
2736						match[1],
2737						context && context.nodeType ? context.ownerDocument || context : document,
2738						true
2739					) );
2740
2741					// HANDLE: $(html, props)
2742					if ( rsingleTag.test( match[1] ) && jQuery.isPlainObject( context ) ) {
2743						for ( match in context ) {
2744							// Properties of context are called as methods if possible
2745							if ( jQuery.isFunction( this[ match ] ) ) {
2746								this[ match ]( context[ match ] );
2747
2748							// ...and otherwise set as attributes
2749							} else {
2750								this.attr( match, context[ match ] );
2751							}
2752						}
2753					}
2754
2755					return this;
2756
2757				// HANDLE: $(#id)
2758				} else {
2759					elem = document.getElementById( match[2] );
2760
2761					// Check parentNode to catch when Blackberry 4.6 returns
2762					// nodes that are no longer in the document #6963
2763					if ( elem && elem.parentNode ) {
2764						// Inject the element directly into the jQuery object
2765						this.length = 1;
2766						this[0] = elem;
2767					}
2768
2769					this.context = document;
2770					this.selector = selector;
2771					return this;
2772				}
2773
2774			// HANDLE: $(expr, $(...))
2775			} else if ( !context || context.jquery ) {
2776				return ( context || rootjQuery ).find( selector );
2777
2778			// HANDLE: $(expr, context)
2779			// (which is just equivalent to: $(context).find(expr)
2780			} else {
2781				return this.constructor( context ).find( selector );
2782			}
2783
2784		// HANDLE: $(DOMElement)
2785		} else if ( selector.nodeType ) {
2786			this.context = this[0] = selector;
2787			this.length = 1;
2788			return this;
2789
2790		// HANDLE: $(function)
2791		// Shortcut for document ready
2792		} else if ( jQuery.isFunction( selector ) ) {
2793			return typeof rootjQuery.ready !== "undefined" ?
2794				rootjQuery.ready( selector ) :
2795				// Execute immediately if ready is not present
2796				selector( jQuery );
2797		}
2798
2799		if ( selector.selector !== undefined ) {
2800			this.selector = selector.selector;
2801			this.context = selector.context;
2802		}
2803
2804		return jQuery.makeArray( selector, this );
2805	};
2806
2807// Give the init function the jQuery prototype for later instantiation
2808init.prototype = jQuery.fn;
2809
2810// Initialize central reference
2811rootjQuery = jQuery( document );
2812
2813
2814var rparentsprev = /^(?:parents|prev(?:Until|All))/,
2815	// methods guaranteed to produce a unique set when starting from a unique set
2816	guaranteedUnique = {
2817		children: true,
2818		contents: true,
2819		next: true,
2820		prev: true
2821	};
2822
2823jQuery.extend({
2824	dir: function( elem, dir, until ) {
2825		var matched = [],
2826			truncate = until !== undefined;
2827
2828		while ( (elem = elem[ dir ]) && elem.nodeType !== 9 ) {
2829			if ( elem.nodeType === 1 ) {
2830				if ( truncate && jQuery( elem ).is( until ) ) {
2831					break;
2832				}
2833				matched.push( elem );
2834			}
2835		}
2836		return matched;
2837	},
2838
2839	sibling: function( n, elem ) {
2840		var matched = [];
2841
2842		for ( ; n; n = n.nextSibling ) {
2843			if ( n.nodeType === 1 && n !== elem ) {
2844				matched.push( n );
2845			}
2846		}
2847
2848		return matched;
2849	}
2850});
2851
2852jQuery.fn.extend({
2853	has: function( target ) {
2854		var targets = jQuery( target, this ),
2855			l = targets.length;
2856
2857		return this.filter(function() {
2858			var i = 0;
2859			for ( ; i < l; i++ ) {
2860				if ( jQuery.contains( this, targets[i] ) ) {
2861					return true;
2862				}
2863			}
2864		});
2865	},
2866
2867	closest: function( selectors, context ) {
2868		var cur,
2869			i = 0,
2870			l = this.length,
2871			matched = [],
2872			pos = rneedsContext.test( selectors ) || typeof selectors !== "string" ?
2873				jQuery( selectors, context || this.context ) :
2874				0;
2875
2876		for ( ; i < l; i++ ) {
2877			for ( cur = this[i]; cur && cur !== context; cur = cur.parentNode ) {
2878				// Always skip document fragments
2879				if ( cur.nodeType < 11 && (pos ?
2880					pos.index(cur) > -1 :
2881
2882					// Don't pass non-elements to Sizzle
2883					cur.nodeType === 1 &&
2884						jQuery.find.matchesSelector(cur, selectors)) ) {
2885
2886					matched.push( cur );
2887					break;
2888				}
2889			}
2890		}
2891
2892		return this.pushStack( matched.length > 1 ? jQuery.unique( matched ) : matched );
2893	},
2894
2895	// Determine the position of an element within
2896	// the matched set of elements
2897	index: function( elem ) {
2898
2899		// No argument, return index in parent
2900		if ( !elem ) {
2901			return ( this[ 0 ] && this[ 0 ].parentNode ) ? this.first().prevAll().length : -1;
2902		}
2903
2904		// index in selector
2905		if ( typeof elem === "string" ) {
2906			return indexOf.call( jQuery( elem ), this[ 0 ] );
2907		}
2908
2909		// Locate the position of the desired element
2910		return indexOf.call( this,
2911
2912			// If it receives a jQuery object, the first element is used
2913			elem.jquery ? elem[ 0 ] : elem
2914		);
2915	},
2916
2917	add: function( selector, context ) {
2918		return this.pushStack(
2919			jQuery.unique(
2920				jQuery.merge( this.get(), jQuery( selector, context ) )
2921			)
2922		);
2923	},
2924
2925	addBack: function( selector ) {
2926		return this.add( selector == null ?
2927			this.prevObject : this.prevObject.filter(selector)
2928		);
2929	}
2930});
2931
2932function sibling( cur, dir ) {
2933	while ( (cur = cur[dir]) && cur.nodeType !== 1 ) {}
2934	return cur;
2935}
2936
2937jQuery.each({
2938	parent: function( elem ) {
2939		var parent = elem.parentNode;
2940		return parent && parent.nodeType !== 11 ? parent : null;
2941	},
2942	parents: function( elem ) {
2943		return jQuery.dir( elem, "parentNode" );
2944	},
2945	parentsUntil: function( elem, i, until ) {
2946		return jQuery.dir( elem, "parentNode", until );
2947	},
2948	next: function( elem ) {
2949		return sibling( elem, "nextSibling" );
2950	},
2951	prev: function( elem ) {
2952		return sibling( elem, "previousSibling" );
2953	},
2954	nextAll: function( elem ) {
2955		return jQuery.dir( elem, "nextSibling" );
2956	},
2957	prevAll: function( elem ) {
2958		return jQuery.dir( elem, "previousSibling" );
2959	},
2960	nextUntil: function( elem, i, until ) {
2961		return jQuery.dir( elem, "nextSibling", until );
2962	},
2963	prevUntil: function( elem, i, until ) {
2964		return jQuery.dir( elem, "previousSibling", until );
2965	},
2966	siblings: function( elem ) {
2967		return jQuery.sibling( ( elem.parentNode || {} ).firstChild, elem );
2968	},
2969	children: function( elem ) {
2970		return jQuery.sibling( elem.firstChild );
2971	},
2972	contents: function( elem ) {
2973		return elem.contentDocument || jQuery.merge( [], elem.childNodes );
2974	}
2975}, function( name, fn ) {
2976	jQuery.fn[ name ] = function( until, selector ) {
2977		var matched = jQuery.map( this, fn, until );
2978
2979		if ( name.slice( -5 ) !== "Until" ) {
2980			selector = until;
2981		}
2982
2983		if ( selector && typeof selector === "string" ) {
2984			matched = jQuery.filter( selector, matched );
2985		}
2986
2987		if ( this.length > 1 ) {
2988			// Remove duplicates
2989			if ( !guaranteedUnique[ name ] ) {
2990				jQuery.unique( matched );
2991			}
2992
2993			// Reverse order for parents* and prev-derivatives
2994			if ( rparentsprev.test( name ) ) {
2995				matched.reverse();
2996			}
2997		}
2998
2999		return this.pushStack( matched );
3000	};
3001});
3002var rnotwhite = (/\S+/g);
3003
3004
3005
3006// String to Object options format cache
3007var optionsCache = {};
3008
3009// Convert String-formatted options into Object-formatted ones and store in cache
3010function createOptions( options ) {
3011	var object = optionsCache[ options ] = {};
3012	jQuery.each( options.match( rnotwhite ) || [], function( _, flag ) {
3013		object[ flag ] = true;
3014	});
3015	return object;
3016}
3017
3018/*
3019 * Create a callback list using the following parameters:
3020 *
3021 *	options: an optional list of space-separated options that will change how
3022 *			the callback list behaves or a more traditional option object
3023 *
3024 * By default a callback list will act like an event callback list and can be
3025 * "fired" multiple times.
3026 *
3027 * Possible options:
3028 *
3029 *	once:			will ensure the callback list can only be fired once (like a Deferred)
3030 *
3031 *	memory:			will keep track of previous values and will call any callback added
3032 *					after the list has been fired right away with the latest "memorized"
3033 *					values (like a Deferred)
3034 *
3035 *	unique:			will ensure a callback can only be added once (no duplicate in the list)
3036 *
3037 *	stopOnFalse:	interrupt callings when a callback returns false
3038 *
3039 */
3040jQuery.Callbacks = function( options ) {
3041
3042	// Convert options from String-formatted to Object-formatted if needed
3043	// (we check in cache first)
3044	options = typeof options === "string" ?
3045		( optionsCache[ options ] || createOptions( options ) ) :
3046		jQuery.extend( {}, options );
3047
3048	var // Last fire value (for non-forgettable lists)
3049		memory,
3050		// Flag to know if list was already fired
3051		fired,
3052		// Flag to know if list is currently firing
3053		firing,
3054		// First callback to fire (used internally by add and fireWith)
3055		firingStart,
3056		// End of the loop when firing
3057		firingLength,
3058		// Index of currently firing callback (modified by remove if needed)
3059		firingIndex,
3060		// Actual callback list
3061		list = [],