https://indexmain.ru/vendor/jquery/dist/jquery.js

1/*!
2 * jQuery JavaScript Library v2.1.3
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-12-18T15: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`
19		// is present, execute the factory and get jQuery.
20		// For environments that do not have a `window` with a `document`
21		// (such as Node.js), expose a 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// Support: Firefox 18+
41// Can't be in strict mode, several libs including ASP.NET trace
42// the stack via arguments.caller.callee and Firefox dies if
43// you try to trace through "use strict" call chains. (#13335)
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.3",
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	isFunction: function( obj ) {
256		return jQuery.type(obj) === "function";
257	},
258
259	isArray: Array.isArray,
260
261	isWindow: function( obj ) {
262		return obj != null && obj === obj.window;
263	},
264
265	isNumeric: function( obj ) {
266		// parseFloat NaNs numeric-cast false positives (null|true|false|"")
267		// ...but misinterprets leading-number strings, particularly hex literals ("0x...")
268		// subtraction forces infinities to NaN
269		// adding 1 corrects loss of precision from parseFloat (#15100)
270		return !jQuery.isArray( obj ) && (obj - parseFloat( obj ) + 1) >= 0;
271	},
272
273	isPlainObject: function( obj ) {
274		// Not plain objects:
275		// - Any object or value whose internal [[Class]] property is not "[object Object]"
276		// - DOM nodes
277		// - window
278		if ( jQuery.type( obj ) !== "object" || obj.nodeType || jQuery.isWindow( obj ) ) {
279			return false;
280		}
281
282		if ( obj.constructor &&
283				!hasOwn.call( obj.constructor.prototype, "isPrototypeOf" ) ) {
284			return false;
285		}
286
287		// If the function hasn't returned already, we're confident that
288		// |obj| is a plain object, created by {} or constructed with new Object
289		return true;
290	},
291
292	isEmptyObject: function( obj ) {
293		var name;
294		for ( name in obj ) {
295			return false;
296		}
297		return true;
298	},
299
300	type: function( obj ) {
301		if ( obj == null ) {
302			return obj + "";
303		}
304		// Support: Android<4.0, iOS<6 (functionish RegExp)
305		return typeof obj === "object" || typeof obj === "function" ?
306			class2type[ toString.call(obj) ] || "object" :
307			typeof obj;
308	},
309
310	// Evaluates a script in a global context
311	globalEval: function( code ) {
312		var script,
313			indirect = eval;
314
315		code = jQuery.trim( code );
316
317		if ( code ) {
318			// If the code includes a valid, prologue position
319			// strict mode pragma, execute code by injecting a
320			// script tag into the document.
321			if ( code.indexOf("use strict") === 1 ) {
322				script = document.createElement("script");
323				script.text = code;
324				document.head.appendChild( script ).parentNode.removeChild( script );
325			} else {
326			// Otherwise, avoid the DOM node creation, insertion
327			// and removal by using an indirect global eval
328				indirect( code );
329			}
330		}
331	},
332
333	// Convert dashed to camelCase; used by the css and data modules
334	// Support: IE9-11+
335	// Microsoft forgot to hump their vendor prefix (#9572)
336	camelCase: function( string ) {
337		return string.replace( rmsPrefix, "ms-" ).replace( rdashAlpha, fcamelCase );
338	},
339
340	nodeName: function( elem, name ) {
341		return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase();
342	},
343
344	// args is for internal usage only
345	each: function( obj, callback, args ) {
346		var value,
347			i = 0,
348			length = obj.length,
349			isArray = isArraylike( obj );
350
351		if ( args ) {
352			if ( isArray ) {
353				for ( ; i < length; i++ ) {
354					value = callback.apply( obj[ i ], args );
355
356					if ( value === false ) {
357						break;
358					}
359				}
360			} else {
361				for ( i in obj ) {
362					value = callback.apply( obj[ i ], args );
363
364					if ( value === false ) {
365						break;
366					}
367				}
368			}
369
370		// A special, fast, case for the most common use of each
371		} else {
372			if ( isArray ) {
373				for ( ; i < length; i++ ) {
374					value = callback.call( obj[ i ], i, obj[ i ] );
375
376					if ( value === false ) {
377						break;
378					}
379				}
380			} else {
381				for ( i in obj ) {
382					value = callback.call( obj[ i ], i, obj[ i ] );
383
384					if ( value === false ) {
385						break;
386					}
387				}
388			}
389		}
390
391		return obj;
392	},
393
394	// Support: Android<4.1
395	trim: function( text ) {
396		return text == null ?
397			"" :
398			( text + "" ).replace( rtrim, "" );
399	},
400
401	// results is for internal usage only
402	makeArray: function( arr, results ) {
403		var ret = results || [];
404
405		if ( arr != null ) {
406			if ( isArraylike( Object(arr) ) ) {
407				jQuery.merge( ret,
408					typeof arr === "string" ?
409					[ arr ] : arr
410				);
411			} else {
412				push.call( ret, arr );
413			}
414		}
415
416		return ret;
417	},
418
419	inArray: function( elem, arr, i ) {
420		return arr == null ? -1 : indexOf.call( arr, elem, i );
421	},
422
423	merge: function( first, second ) {
424		var len = +second.length,
425			j = 0,
426			i = first.length;
427
428		for ( ; j < len; j++ ) {
429			first[ i++ ] = second[ j ];
430		}
431
432		first.length = i;
433
434		return first;
435	},
436
437	grep: function( elems, callback, invert ) {
438		var callbackInverse,
439			matches = [],
440			i = 0,
441			length = elems.length,
442			callbackExpect = !invert;
443
444		// Go through the array, only saving the items
445		// that pass the validator function
446		for ( ; i < length; i++ ) {
447			callbackInverse = !callback( elems[ i ], i );
448			if ( callbackInverse !== callbackExpect ) {
449				matches.push( elems[ i ] );
450			}
451		}
452
453		return matches;
454	},
455
456	// arg is for internal usage only
457	map: function( elems, callback, arg ) {
458		var value,
459			i = 0,
460			length = elems.length,
461			isArray = isArraylike( elems ),
462			ret = [];
463
464		// Go through the array, translating each of the items to their new values
465		if ( isArray ) {
466			for ( ; i < length; i++ ) {
467				value = callback( elems[ i ], i, arg );
468
469				if ( value != null ) {
470					ret.push( value );
471				}
472			}
473
474		// Go through every key on the object,
475		} else {
476			for ( i in elems ) {
477				value = callback( elems[ i ], i, arg );
478
479				if ( value != null ) {
480					ret.push( value );
481				}
482			}
483		}
484
485		// Flatten any nested arrays
486		return concat.apply( [], ret );
487	},
488
489	// A global GUID counter for objects
490	guid: 1,
491
492	// Bind a function to a context, optionally partially applying any
493	// arguments.
494	proxy: function( fn, context ) {
495		var tmp, args, proxy;
496
497		if ( typeof context === "string" ) {
498			tmp = fn[ context ];
499			context = fn;
500			fn = tmp;
501		}
502
503		// Quick check to determine if target is callable, in the spec
504		// this throws a TypeError, but we will just return undefined.
505		if ( !jQuery.isFunction( fn ) ) {
506			return undefined;
507		}
508
509		// Simulated bind
510		args = slice.call( arguments, 2 );
511		proxy = function() {
512			return fn.apply( context || this, args.concat( slice.call( arguments ) ) );
513		};
514
515		// Set the guid of unique handler to the same of original handler, so it can be removed
516		proxy.guid = fn.guid = fn.guid || jQuery.guid++;
517
518		return proxy;
519	},
520
521	now: Date.now,
522
523	// jQuery.support is not used in Core but other projects attach their
524	// properties to it so it needs to exist.
525	support: support
526});
527
528// Populate the class2type map
529jQuery.each("Boolean Number String Function Array Date RegExp Object Error".split(" "), function(i, name) {
530	class2type[ "[object " + name + "]" ] = name.toLowerCase();
531});
532
533function isArraylike( obj ) {
534	var length = obj.length,
535		type = jQuery.type( obj );
536
537	if ( type === "function" || jQuery.isWindow( obj ) ) {
538		return false;
539	}
540
541	if ( obj.nodeType === 1 && length ) {
542		return true;
543	}
544
545	return type === "array" || length === 0 ||
546		typeof length === "number" && length > 0 && ( length - 1 ) in obj;
547}
548var Sizzle =
549/*!
550 * Sizzle CSS Selector Engine v2.2.0-pre
551 * http://sizzlejs.com/
552 *
553 * Copyright 2008, 2014 jQuery Foundation, Inc. and other contributors
554 * Released under the MIT license
555 * http://jquery.org/license
556 *
557 * Date: 2014-12-16
558 */
559(function( window ) {
560
561var i,
562	support,
563	Expr,
564	getText,
565	isXML,
566	tokenize,
567	compile,
568	select,
569	outermostContext,
570	sortInput,
571	hasDuplicate,
572
573	// Local document vars
574	setDocument,
575	document,
576	docElem,
577	documentIsHTML,
578	rbuggyQSA,
579	rbuggyMatches,
580	matches,
581	contains,
582
583	// Instance-specific data
584	expando = "sizzle" + 1 * new Date(),
585	preferredDoc = window.document,
586	dirruns = 0,
587	done = 0,
588	classCache = createCache(),
589	tokenCache = createCache(),
590	compilerCache = createCache(),
591	sortOrder = function( a, b ) {
592		if ( a === b ) {
593			hasDuplicate = true;
594		}
595		return 0;
596	},
597
598	// General-purpose constants
599	MAX_NEGATIVE = 1 << 31,
600
601	// Instance methods
602	hasOwn = ({}).hasOwnProperty,
603	arr = [],
604	pop = arr.pop,
605	push_native = arr.push,
606	push = arr.push,
607	slice = arr.slice,
608	// Use a stripped-down indexOf as it's faster than native
609	// http://jsperf.com/thor-indexof-vs-for/5
610	indexOf = function( list, elem ) {
611		var i = 0,
612			len = list.length;
613		for ( ; i < len; i++ ) {
614			if ( list[i] === elem ) {
615				return i;
616			}
617		}
618		return -1;
619	},
620
621	booleans = "checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped",
622
623	// Regular expressions
624
625	// Whitespace characters http://www.w3.org/TR/css3-selectors/#whitespace
626	whitespace = "[\\x20\\t\\r\\n\\f]",
627	// http://www.w3.org/TR/css3-syntax/#characters
628	characterEncoding = "(?:\\\\.|[\\w-]|[^\\x00-\\xa0])+",
629
630	// Loosely modeled on CSS identifier characters
631	// An unquoted value should be a CSS identifier http://www.w3.org/TR/css3-selectors/#attribute-selectors
632	// Proper syntax: http://www.w3.org/TR/CSS21/syndata.html#value-def-identifier
633	identifier = characterEncoding.replace( "w", "w#" ),
634
635	// Attribute selectors: http://www.w3.org/TR/selectors/#attribute-selectors
636	attributes = "\\[" + whitespace + "*(" + characterEncoding + ")(?:" + whitespace +
637		// Operator (capture 2)
638		"*([*^$|!~]?=)" + whitespace +
639		// "Attribute values must be CSS identifiers [capture 5] or strings [capture 3 or capture 4]"
640		"*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|(" + identifier + "))|)" + whitespace +
641		"*\\]",
642
643	pseudos = ":(" + characterEncoding + ")(?:\\((" +
644		// To reduce the number of selectors needing tokenize in the preFilter, prefer arguments:
645		// 1. quoted (capture 3; capture 4 or capture 5)
646		"('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|" +
647		// 2. simple (capture 6)
648		"((?:\\\\.|[^\\\\()[\\]]|" + attributes + ")*)|" +
649		// 3. anything else (capture 2)
650		".*" +
651		")\\)|)",
652
653	// Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter
654	rwhitespace = new RegExp( whitespace + "+", "g" ),
655	rtrim = new RegExp( "^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" + whitespace + "+$", "g" ),
656
657	rcomma = new RegExp( "^" + whitespace + "*," + whitespace + "*" ),
658	rcombinators = new RegExp( "^" + whitespace + "*([>+~]|" + whitespace + ")" + whitespace + "*" ),
659
660	rattributeQuotes = new RegExp( "=" + whitespace + "*([^\\]'\"]*?)" + whitespace + "*\\]", "g" ),
661
662	rpseudo = new RegExp( pseudos ),
663	ridentifier = new RegExp( "^" + identifier + "$" ),
664
665	matchExpr = {
666		"ID": new RegExp( "^#(" + characterEncoding + ")" ),
667		"CLASS": new RegExp( "^\\.(" + characterEncoding + ")" ),
668		"TAG": new RegExp( "^(" + characterEncoding.replace( "w", "w*" ) + ")" ),
669		"ATTR": new RegExp( "^" + attributes ),
670		"PSEUDO": new RegExp( "^" + pseudos ),
671		"CHILD": new RegExp( "^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(" + whitespace +
672			"*(even|odd|(([+-]|)(\\d*)n|)" + whitespace + "*(?:([+-]|)" + whitespace +
673			"*(\\d+)|))" + whitespace + "*\\)|)", "i" ),
674		"bool": new RegExp( "^(?:" + booleans + ")$", "i" ),
675		// For use in libraries implementing .is()
676		// We use this for POS matching in `select`
677		"needsContext": new RegExp( "^" + whitespace + "*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(" +
678			whitespace + "*((?:-\\d)?\\d*)" + whitespace + "*\\)|)(?=[^-]|$)", "i" )
679	},
680

829				newContext = rsibling.test( selector ) && testContext( context.parentNode ) || context;
830				newSelector = groups.join(",");
831			}
832
833			if ( newSelector ) {
834				try {
835					push.apply( results,
836						newContext.querySelectorAll( newSelector )
837					);
838					return results;
839				} catch(qsaError) {
840				} finally {
841					if ( !old ) {
842						context.removeAttribute("id");
843					}
844				}
845			}
846		}
847	}
848
849	// All others
850	return select( selector.replace( rtrim, "$1" ), context, results, seed );
851}
852
853/**
854 * Create key-value caches of limited size
855 * @returns {Function(string, Object)} Returns the Object data after storing it on itself with
856 *	property name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength)
857 *	deleting the oldest entry
858 */
859function createCache() {
860	var keys = [];
861
862	function cache( key, value ) {
863		// Use (key + " ") to avoid collision with native prototype properties (see Issue #157)
864		if ( keys.push( key + " " ) > Expr.cacheLength ) {
865			// Only keep the most recent entries
866			delete cache[ keys.shift() ];
867		}
868		return (cache[ key + " " ] = value);
869	}
870	return cache;
871}
872
873/**
874 * Mark a function for special use by Sizzle
875 * @param {Function} fn The function to mark
876 */
877function markFunction( fn ) {
878	fn[ expando ] = true;
879	return fn;
880}
881
882/**
883 * Support testing using an element
884 * @param {Function} fn Passed the created div and expects a boolean result
885 */
886function assert( fn ) {
887	var div = document.createElement("div");
888
889	try {
890		return !!fn( div );
891	} catch (e) {
892		return false;
893	} finally {
894		// Remove from its parent by default
895		if ( div.parentNode ) {
896			div.parentNode.removeChild( div );
897		}
898		// release memory in IE
899		div = null;
900	}
901}
902
903/**
904 * Adds the same handler for all of the specified attrs
905 * @param {String} attrs Pipe-separated list of attributes
906 * @param {Function} handler The method that will be applied
907 */
908function addHandle( attrs, handler ) {
909	var arr = attrs.split("|"),
910		i = attrs.length;
911
912	while ( i-- ) {
913		Expr.attrHandle[ arr[i] ] = handler;
914	}
915}
916
917/**
918 * Checks document order of two siblings
919 * @param {Element} a
920 * @param {Element} b
921 * @returns {Number} Returns less than 0 if a precedes b, greater than 0 if a follows b
922 */
923function siblingCheck( a, b ) {
924	var cur = b && a,
925		diff = cur && a.nodeType === 1 && b.nodeType === 1 &&
926			( ~b.sourceIndex || MAX_NEGATIVE ) -
927			( ~a.sourceIndex || MAX_NEGATIVE );
928
929	// Use IE sourceIndex if available on both nodes
930	if ( diff ) {
931		return diff;
932	}
933
934	// Check if b follows a
935	if ( cur ) {
936		while ( (cur = cur.nextSibling) ) {
937			if ( cur === b ) {
938				return -1;
939			}
940		}
941	}
942
943	return a ? 1 : -1;
944}
945
946/**
947 * Returns a function to use in pseudos for input types
948 * @param {String} type
949 */
950function createInputPseudo( type ) {
951	return function( elem ) {
952		var name = elem.nodeName.toLowerCase();
953		return name === "input" && elem.type === type;
954	};
955}
956
957/**
958 * Returns a function to use in pseudos for buttons
959 * @param {String} type
960 */
961function createButtonPseudo( type ) {
962	return function( elem ) {
963		var name = elem.nodeName.toLowerCase();
964		return (name === "input" || name === "button") && elem.type === type;
965	};
966}
967
968/**
969 * Returns a function to use in pseudos for positionals
970 * @param {Function} fn
971 */
972function createPositionalPseudo( fn ) {
973	return markFunction(function( argument ) {
974		argument = +argument;
975		return markFunction(function( seed, matches ) {
976			var j,
977				matchIndexes = fn( [], seed.length, argument ),
978				i = matchIndexes.length;
979
980			// Match elements found at the specified indexes
981			while ( i-- ) {
982				if ( seed[ (j = matchIndexes[i]) ] ) {
983					seed[j] = !(matches[j] = seed[j]);
984				}
985			}
986		});
987	});
988}
989
990/**
991 * Checks a node for validity as a Sizzle context
992 * @param {Element|Object=} context
993 * @returns {Element|Object|Boolean} The input node if acceptable, otherwise a falsy value
994 */
995function testContext( context ) {
996	return context && typeof context.getElementsByTagName !== "undefined" && context;
997}
998
999// Expose support vars for convenience
1000support = Sizzle.support = {};
1001
1002/**
1003 * Detects XML nodes
1004 * @param {Element|Object} elem An element or a document
1005 * @returns {Boolean} True iff elem is a non-HTML XML node
1006 */
1007isXML = Sizzle.isXML = function( elem ) {
1008	// documentElement is verified for cases where it doesn't yet exist
1009	// (such as loading iframes in IE - #4833)
1010	var documentElement = elem && (elem.ownerDocument || elem).documentElement;
1011	return documentElement ? documentElement.nodeName !== "HTML" : false;
1012};
1013
1014/**
1015 * Sets document-related variables once based on the current document
1016 * @param {Element|Object} [doc] An element or document object to use to set the document
1017 * @returns {Object} Returns the current document
1018 */
1019setDocument = Sizzle.setDocument = function( node ) {
1020	var hasCompare, parent,
1021		doc = node ? node.ownerDocument || node : preferredDoc;
1022
1023	// If no document and documentElement is available, return
1024	if ( doc === document || doc.nodeType !== 9 || !doc.documentElement ) {
1025		return document;
1026	}
1027
1028	// Set our document
1029	document = doc;
1030	docElem = doc.documentElement;
1031	parent = doc.defaultView;
1032
1033	// Support: IE>8
1034	// If iframe document is assigned to "document" variable and if iframe has been reloaded,
1035	// IE will throw "permission denied" error when accessing "document" variable, see jQuery #13936
1036	// IE6-8 do not support the defaultView property so parent will be undefined
1037	if ( parent && parent !== parent.top ) {
1038		// IE11 does not have attachEvent, so all must suffer
1039		if ( parent.addEventListener ) {
1040			parent.addEventListener( "unload", unloadHandler, false );
1041		} else if ( parent.attachEvent ) {
1042			parent.attachEvent( "onunload", unloadHandler );
1043		}
1044	}
1045
1046	/* Support tests
1047	---------------------------------------------------------------------- */
1048	documentIsHTML = !isXML( doc );
1049
1050	/* Attributes
1051	---------------------------------------------------------------------- */
1052
1053	// Support: IE<8
1054	// Verify that getAttribute really returns attributes and not properties
1055	// (excepting IE8 booleans)
1056	support.attributes = assert(function( div ) {
1057		div.className = "i";
1058		return !div.getAttribute("className");
1059	});
1060
1061	/* getElement(s)By*
1062	---------------------------------------------------------------------- */
1063
1064	// Check if getElementsByTagName("*") returns only elements
1065	support.getElementsByTagName = assert(function( div ) {
1066		div.appendChild( doc.createComment("") );
1067		return !div.getElementsByTagName("*").length;
1068	});
1069
1070	// Support: IE<9
1071	support.getElementsByClassName = rnative.test( doc.getElementsByClassName );
1072
1073	// Support: IE<10
1074	// Check if getElementById returns elements by name
1075	// The broken getElementById methods don't pick up programatically-set names,
1076	// so use a roundabout getElementsByName test
1077	support.getById = assert(function( div ) {
1078		docElem.appendChild( div ).id = expando;
1079		return !doc.getElementsByName || !doc.getElementsByName( expando ).length;
1080	});
1081
1082	// ID find and filter
1083	if ( support.getById ) {
1084		Expr.find["ID"] = function( id, context ) {
1085			if ( typeof context.getElementById !== "undefined" && documentIsHTML ) {
1086				var m = context.getElementById( id );
1087				// Check parentNode to catch when Blackberry 4.6 returns
1088				// nodes that are no longer in the document #6963
1089				return m && m.parentNode ? [ m ] : [];
1090			}
1091		};
1092		Expr.filter["ID"] = function( id ) {
1093			var attrId = id.replace( runescape, funescape );
1094			return function( elem ) {
1095				return elem.getAttribute("id") === attrId;
1096			};
1097		};
1098	} else {
1099		// Support: IE6/7
1100		// getElementById is not reliable as a find shortcut
1101		delete Expr.find["ID"];
1102
1103		Expr.filter["ID"] =  function( id ) {
1104			var attrId = id.replace( runescape, funescape );
1105			return function( elem ) {
1106				var node = typeof elem.getAttributeNode !== "undefined" && elem.getAttributeNode("id");
1107				return node && node.value === attrId;
1108			};
1109		};
1110	}
1111
1112	// Tag
1113	Expr.find["TAG"] = support.getElementsByTagName ?
1114		function( tag, context ) {
1115			if ( typeof context.getElementsByTagName !== "undefined" ) {
1116				return context.getElementsByTagName( tag );
1117
1118			// DocumentFragment nodes don't have gEBTN
1119			} else if ( support.qsa ) {
1120				return context.querySelectorAll( tag );
1121			}
1122		} :
1123
1124		function( tag, context ) {
1125			var elem,
1126				tmp = [],
1127				i = 0,
1128				// By happy coincidence, a (broken) gEBTN appears on DocumentFragment nodes too
1129				results = context.getElementsByTagName( tag );
1130
1131			// Filter out possible comments
1132			if ( tag === "*" ) {
1133				while ( (elem = results[i++]) ) {
1134					if ( elem.nodeType === 1 ) {
1135						tmp.push( elem );
1136					}
1137				}
1138
1139				return tmp;
1140			}
1141			return results;
1142		};
1143
1144	// Class
1145	Expr.find["CLASS"] = support.getElementsByClassName && function( className, context ) {
1146		if ( documentIsHTML ) {
1147			return context.getElementsByClassName( className );
1148		}
1149	};
1150
1151	/* QSA/matchesSelector
1152	---------------------------------------------------------------------- */
1153
1154	// QSA and matchesSelector support
1155
1156	// matchesSelector(:active) reports false when true (IE9/Opera 11.5)
1157	rbuggyMatches = [];
1158
1159	// qSa(:focus) reports false when true (Chrome 21)
1160	// We allow this because of a bug in IE8/9 that throws an error
1161	// whenever `document.activeElement` is accessed on an iframe
1162	// So, we allow :focus to pass through QSA all the time to avoid the IE error
1163	// See http://bugs.jquery.com/ticket/13378
1164	rbuggyQSA = [];
1165
1166	if ( (support.qsa = rnative.test( doc.querySelectorAll )) ) {
1167		// Build QSA regex
1168		// Regex strategy adopted from Diego Perini
1169		assert(function( div ) {
1170			// Select is set to empty string on purpose
1171			// This is to test IE's treatment of not explicitly
1172			// setting a boolean content attribute,
1173			// since its presence should be enough
1174			// http://bugs.jquery.com/ticket/12359
1175			docElem.appendChild( div ).innerHTML = "<a id='" + expando + "'></a>" +
1176				"<select id='" + expando + "-\f]' msallowcapture=''>" +
1177				"<option selected=''></option></select>";
1178
1179			// Support: IE8, Opera 11-12.16
1180			// Nothing should be selected when empty strings follow ^= or $= or *=
1181			// The test attribute must be unknown in Opera but "safe" for WinRT
1182			// http://msdn.microsoft.com/en-us/library/ie/hh465388.aspx#attribute_section
1183			if ( div.querySelectorAll("[msallowcapture^='']").length ) {
1184				rbuggyQSA.push( "[*^$]=" + whitespace + "*(?:''|\"\")" );
1185			}
1186
1187			// Support: IE8
1188			// Boolean attributes and "value" are not treated correctly
1189			if ( !div.querySelectorAll("[selected]").length ) {
1190				rbuggyQSA.push( "\\[" + whitespace + "*(?:value|" + booleans + ")" );
1191			}
1192
1193			// Support: Chrome<29, Android<4.2+, Safari<7.0+, iOS<7.0+, PhantomJS<1.9.7+
1194			if ( !div.querySelectorAll( "[id~=" + expando + "-]" ).length ) {
1195				rbuggyQSA.push("~=");
1196			}
1197
1198			// Webkit/Opera - :checked should return selected option elements
1199			// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
1200			// IE8 throws error here and will not see later tests
1201			if ( !div.querySelectorAll(":checked").length ) {
1202				rbuggyQSA.push(":checked");
1203			}
1204
1205			// Support: Safari 8+, iOS 8+
1206			// https://bugs.webkit.org/show_bug.cgi?id=136851
1207			// In-page `selector#id sibing-combinator selector` fails
1208			if ( !div.querySelectorAll( "a#" + expando + "+*" ).length ) {
1209				rbuggyQSA.push(".#.+[+~]");
1210			}
1211		});
1212
1213		assert(function( div ) {
1214			// Support: Windows 8 Native Apps
1215			// The type and name attributes are restricted during .innerHTML assignment
1216			var input = doc.createElement("input");
1217			input.setAttribute( "type", "hidden" );
1218			div.appendChild( input ).setAttribute( "name", "D" );
1219
1220			// Support: IE8
1221			// Enforce case-sensitivity of name attribute
1222			if ( div.querySelectorAll("[name=d]").length ) {
1223				rbuggyQSA.push( "name" + whitespace + "*[*^$|!~]?=" );
1224			}
1225
1226			// FF 3.5 - :enabled/:disabled and hidden elements (hidden elements are still enabled)
1227			// IE8 throws error here and will not see later tests
1228			if ( !div.querySelectorAll(":enabled").length ) {
1229				rbuggyQSA.push( ":enabled", ":disabled" );
1230			}
1231
1232			// Opera 10-11 does not throw on post-comma invalid pseudos
1233			div.querySelectorAll("*,:x");
1234			rbuggyQSA.push(",.*:");
1235		});
1236	}
1237
1238	if ( (support.matchesSelector = rnative.test( (matches = docElem.matches ||
1239		docElem.webkitMatchesSelector ||
1240		docElem.mozMatchesSelector ||
1241		docElem.oMatchesSelector ||
1242		docElem.msMatchesSelector) )) ) {
1243
1244		assert(function( div ) {
1245			// Check to see if it's possible to do matchesSelector
1246			// on a disconnected node (IE 9)
1247			support.disconnectedMatch = matches.call( div, "div" );
1248
1249			// This should fail with an exception
1250			// Gecko does not error, returns false instead
1251			matches.call( div, "[s!='']:x" );
1252			rbuggyMatches.push( "!=", pseudos );
1253		});
1254	}
1255
1256	rbuggyQSA = rbuggyQSA.length && new RegExp( rbuggyQSA.join("|") );
1257	rbuggyMatches = rbuggyMatches.length && new RegExp( rbuggyMatches.join("|") );
1258
1259	/* Contains
1260	---------------------------------------------------------------------- */
1261	hasCompare = rnative.test( docElem.compareDocumentPosition );
1262
1263	// Element contains another
1264	// Purposefully does not implement inclusive descendent
1265	// As in, an element does not contain itself
1266	contains = hasCompare || rnative.test( docElem.contains ) ?
1267		function( a, b ) {
1268			var adown = a.nodeType === 9 ? a.documentElement : a,
1269				bup = b && b.parentNode;
1270			return a === bup || !!( bup && bup.nodeType === 1 && (
1271				adown.contains ?
1272					adown.contains( bup ) :
1273					a.compareDocumentPosition && a.compareDocumentPosition( bup ) & 16
1274			));
1275		} :
1276		function( a, b ) {
1277			if ( b ) {
1278				while ( (b = b.parentNode) ) {
1279					if ( b === a ) {
1280						return true;
1281					}
1282				}
1283			}
1284			return false;
1285		};
1286
1287	/* Sorting
1288	---------------------------------------------------------------------- */
1289
1290	// Document order sorting
1291	sortOrder = hasCompare ?
1292	function( a, b ) {
1293
1294		// Flag for duplicate removal
1295		if ( a === b ) {
1296			hasDuplicate = true;
1297			return 0;
1298		}
1299
1300		// Sort on method existence if only one input has compareDocumentPosition
1301		var compare = !a.compareDocumentPosition - !b.compareDocumentPosition;
1302		if ( compare ) {
1303			return compare;
1304		}
1305
1306		// Calculate position if both inputs belong to the same document
1307		compare = ( a.ownerDocument || a ) === ( b.ownerDocument || b ) ?
1308			a.compareDocumentPosition( b ) :
1309
1310			// Otherwise we know they are disconnected
1311			1;
1312
1313		// Disconnected nodes
1314		if ( compare & 1 ||
1315			(!support.sortDetached && b.compareDocumentPosition( a ) === compare) ) {
1316
1317			// Choose the first element that is related to our preferred document
1318			if ( a === doc || a.ownerDocument === preferredDoc && contains(preferredDoc, a) ) {
1319				return -1;
1320			}
1321			if ( b === doc || b.ownerDocument === preferredDoc && contains(preferredDoc, b) ) {
1322				return 1;
1323			}
1324
1325			// Maintain original order
1326			return sortInput ?
1327				( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) :
1328				0;
1329		}
1330
1331		return compare & 4 ? -1 : 1;
1332	} :
1333	function( a, b ) {
1334		// Exit early if the nodes are identical
1335		if ( a === b ) {
1336			hasDuplicate = true;
1337			return 0;
1338		}
1339
1340		var cur,
1341			i = 0,
1342			aup = a.parentNode,
1343			bup = b.parentNode,
1344			ap = [ a ],
1345			bp = [ b ];
1346
1347		// Parentless nodes are either documents or disconnected
1348		if ( !aup || !bup ) {
1349			return a === doc ? -1 :
1350				b === doc ? 1 :
1351				aup ? -1 :
1352				bup ? 1 :
1353				sortInput ?
1354				( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) :
1355				0;
1356
1357		// If the nodes are siblings, we can do a quick check
1358		} else if ( aup === bup ) {
1359			return siblingCheck( a, b );
1360		}
1361
1362		// Otherwise we need full lists of their ancestors for comparison
1363		cur = a;
1364		while ( (cur = cur.parentNode) ) {
1365			ap.unshift( cur );
1366		}
1367		cur = b;
1368		while ( (cur = cur.parentNode) ) {
1369			bp.unshift( cur );
1370		}
1371
1372		// Walk down the tree looking for a discrepancy
1373		while ( ap[i] === bp[i] ) {
1374			i++;
1375		}
1376
1377		return i ?
1378			// Do a sibling check if the nodes have a common ancestor
1379			siblingCheck( ap[i], bp[i] ) :
1380
1381			// Otherwise nodes in our document sort first
1382			ap[i] === preferredDoc ? -1 :
1383			bp[i] === preferredDoc ? 1 :
1384			0;
1385	};
1386
1387	return doc;
1388};
1389
1390Sizzle.matches = function( expr, elements ) {
1391	return Sizzle( expr, null, null, elements );
1392};
1393
1394Sizzle.matchesSelector = function( elem, expr ) {
1395	// Set document vars if needed
1396	if ( ( elem.ownerDocument || elem ) !== document ) {
1397		setDocument( elem );
1398	}
1399
1400	// Make sure that attribute selectors are quoted
1401	expr = expr.replace( rattributeQuotes, "='$1']" );
1402
1403	if ( support.matchesSelector && documentIsHTML &&
1404		( !rbuggyMatches || !rbuggyMatches.test( expr ) ) &&
1405		( !rbuggyQSA     || !rbuggyQSA.test( expr ) ) ) {
1406
1407		try {
1408			var ret = matches.call( elem, expr );
1409
1410			// IE 9's matchesSelector returns false on disconnected nodes
1411			if ( ret || support.disconnectedMatch ||
1412					// As well, disconnected nodes are said to be in a document
1413					// fragment in IE 9
1414					elem.document && elem.document.nodeType !== 11 ) {
1415				return ret;
1416			}
1417		} catch (e) {}
1418	}
1419
1420	return Sizzle( expr, document, null, [ elem ] ).length > 0;
1421};
1422
1423Sizzle.contains = function( context, elem ) {
1424	// Set document vars if needed
1425	if ( ( context.ownerDocument || context ) !== document ) {
1426		setDocument( context );
1427	}
1428	return contains( context, elem );
1429};
1430
1431Sizzle.attr = function( elem, name ) {
1432	// Set document vars if needed
1433	if ( ( elem.ownerDocument || elem ) !== document ) {
1434		setDocument( elem );
1435	}
1436
1437	var fn = Expr.attrHandle[ name.toLowerCase() ],
1438		// Don't get fooled by Object.prototype properties (jQuery #13807)
1439		val = fn && hasOwn.call( Expr.attrHandle, name.toLowerCase() ) ?
1440			fn( elem, name, !documentIsHTML ) :
1441			undefined;
1442
1443	return val !== undefined ?
1444		val :
1445		support.attributes || !documentIsHTML ?
1446			elem.getAttribute( name ) :
1447			(val = elem.getAttributeNode(name)) && val.specified ?
1448				val.value :
1449				null

1449;
1450};
1451
1452Sizzle.error = function( msg ) {
1453	throw new Error( "Syntax error, unrecognized expression: " + msg );
1454};
1455
1456/**
1457 * Document sorting and removing duplicates
1458 * @param {ArrayLike} results
1459 */
1460Sizzle.uniqueSort = function( results ) {
1461	var elem,
1462		duplicates = [],
1463		j = 0,
1464		i = 0;
1465
1466	// Unless we *know* we can detect duplicates, assume their presence
1467	hasDuplicate = !support.detectDuplicates;
1468	sortInput = !support.sortStable && results.slice( 0 );
1469	results.sort( sortOrder );
1470
1471	if ( hasDuplicate ) {
1472		while ( (elem = results[i++]) ) {
1473			if ( elem === results[ i ] ) {
1474				j = duplicates.push( i );
1475			}
1476		}
1477		while ( j-- ) {
1478			results.splice( duplicates[ j ], 1 );
1479		}
1480	}
1481
1482	// Clear input after sorting to release objects
1483	// See https://github.com/jquery/sizzle/pull/225
1484	sortInput = null;
1485
1486	return results;
1487};
1488
1489/**
1490 * Utility function for retrieving the text value of an array of DOM nodes
1491 * @param {Array|Element} elem
1492 */
1493getText = Sizzle.getText = function( elem ) {
1494	var node,
1495		ret = "",
1496		i = 0,
1497		nodeType = elem.nodeType;
1498
1499	if ( !nodeType ) {
1500		// If no nodeType, this is expected to be an array
1501		while ( (node = elem[i++]) ) {
1502			// Do not traverse comment nodes
1503			ret += getText( node );
1504		}
1505	} else if ( nodeType === 1 || nodeType === 9 || nodeType === 11 ) {
1506		// Use textContent for elements
1507		// innerText usage removed for consistency of new lines (jQuery #11153)
1508		if ( typeof elem.textContent === "string" ) {
1509			return elem.textContent;
1510		} else {
1511			// Traverse its children
1512			for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
1513				ret += getText( elem );
1514			}
1515		}
1516	} else if ( nodeType === 3 || nodeType === 4 ) {
1517		return elem.nodeValue;
1518	}
1519	// Do not include comment or processing instruction nodes
1520
1521	return ret;
1522};
1523
1524Expr = Sizzle.selectors = {
1525
1526	// Can be adjusted by the user
1527	cacheLength: 50,
1528
1529	createPseudo: markFunction,
1530
1531	match: matchExpr,
1532
1533	attrHandle: {},
1534
1535	find: {},
1536
1537	relative: {
1538		">": { dir: "parentNode", first: true },
1539		" ": { dir: "parentNode" },
1540		"+": { dir: "previousSibling", first: true },
1541		"~": { dir: "previousSibling" }
1542	},
1543
1544	preFilter: {
1545		"ATTR": function( match ) {
1546			match[1] = match[1].replace( runescape, funescape );
1547
1548			// Move the given value to match[3] whether quoted or unquoted
1549			match[3] = ( match[3] || match[4] || match[5] || "" ).replace( runescape, funescape );
1550
1551			if ( match[2] === "~=" ) {
1552				match[3] = " " + match[3] + " ";
1553			}
1554
1555			return match.slice( 0, 4 );
1556		},
1557
1558		"CHILD": function( match ) {
1559			/* matches from matchExpr["CHILD"]
1560				1 type (only|nth|...)
1561				2 what (child|of-type)
1562				3 argument (even|odd|\d*|\d*n([+-]\d+)?|...)
1563				4 xn-component of xn+y argument ([+-]?\d*n|)
1564				5 sign of xn-component
1565				6 x of xn-component
1566				7 sign of y-component
1567				8 y of y-component
1568			*/
1569			match[1] = match[1].toLowerCase();
1570
1571			if ( match[1].slice( 0, 3 ) === "nth" ) {
1572				// nth-* requires argument
1573				if ( !match[3] ) {
1574					Sizzle.error( match[0] );
1575				}
1576
1577				// numeric x and y parameters for Expr.filter.CHILD
1578				// remember that false/true cast respectively to 0/1
1579				match[4] = +( match[4] ? match[5] + (match[6] || 1) : 2 * ( match[3] === "even" || match[3] === "odd" ) );
1580				match[5] = +( ( match[7] + match[8] ) || match[3] === "odd" );
1581
1582			// other types prohibit arguments
1583			} else if ( match[3] ) {
1584				Sizzle.error( match[0] );
1585			}
1586
1587			return match;
1588		},
1589
1590		"PSEUDO": function( match ) {
1591			var excess,
1592				unquoted = !match[6] && match[2];
1593
1594			if ( matchExpr["CHILD"].test( match[0] ) ) {
1595				return null;
1596			}
1597
1598			// Accept quoted arguments as-is
1599			if ( match[3] ) {
1600				match[2] = match[4] || match[5] || "";
1601
1602			// Strip excess characters from unquoted arguments
1603			} else if ( unquoted && rpseudo.test( unquoted ) &&
1604				// Get excess from tokenize (recursively)
1605				(excess = tokenize( unquoted, true )) &&
1606				// advance to the next closing parenthesis
1607				(excess = unquoted.indexOf( ")", unquoted.length - excess ) - unquoted.length) ) {
1608
1609				// excess is a negative index
1610				match[0] = match[0].slice( 0, excess );
1611				match[2] = unquoted.slice( 0, excess );
1612			}
1613
1614			// Return only captures needed by the pseudo filter method (type and argument)
1615			return match.slice( 0, 3 );
1616		}
1617	},
1618
1619	filter: {
1620
1621		"TAG": function( nodeNameSelector ) {
1622			var nodeName = nodeNameSelector.replace( runescape, funescape ).toLowerCase();
1623			return nodeNameSelector === "*" ?
1624				function() { return true; } :
1625				function( elem ) {
1626					return elem.nodeName && elem.nodeName.toLowerCase() === nodeName;
1627				};
1628		},
1629
1630		"CLASS": function( className ) {
1631			var pattern = classCache[ className + " " ];
1632
1633			return pattern ||
1634				(pattern = new RegExp( "(^|" + whitespace + ")" + className + "(" + whitespace + "|$)" )) &&
1635				classCache( className, function( elem ) {
1636					return pattern.test( typeof elem.className === "string" && elem.className || typeof elem.getAttribute !== "undefined" && elem.getAttribute("class") || "" );
1637				});
1638		},
1639
1640		"ATTR": function( name, operator, check ) {
1641			return function( elem ) {
1642				var result = Sizzle.attr( elem, name );
1643
1644				if ( result == null ) {
1645					return operator === "!=";
1646				}
1647				if ( !operator ) {
1648					return true;
1649				}
1650
1651				result += "";
1652
1653				return operator === "=" ? result === check :
1654					operator === "!=" ? result !== check :
1655					operator === "^=" ? check && result.indexOf( check ) === 0 :
1656					operator === "*=" ? check && result.indexOf( check ) > -1 :
1657					operator === "$=" ? check && result.slice( -check.length ) === check :
1658					operator === "~=" ? ( " " + result.replace( rwhitespace, " " ) + " " ).indexOf( check ) > -1 :
1659					operator === "|=" ? result === check || result.slice( 0, check.length + 1 ) === check + "-" :
1660					false;
1661			};
1662		},
1663
1664		"CHILD": function( type, what, argument, first, last ) {
1665			var simple = type.slice( 0, 3 ) !== "nth",
1666				forward = type.slice( -4 ) !== "last",
1667				ofType = what === "of-type";
1668
1669			return first === 1 && last === 0 ?
1670
1671				// Shortcut for :nth-*(n)
1672				function( elem ) {
1673					return !!elem.parentNode;
1674				} :
1675
1676				function( elem, context, xml ) {
1677					var cache, 

1677outerCache, node, diff, nodeIndex, start,
1678						dir = simple !== forward ? "nextSibling" : "previousSibling",
1679						parent = elem.parentNode,
1680						name = ofType && elem.nodeName.toLowerCase(),
1681						useCache = !xml && !ofType;
1682
1683					if ( parent ) {
1684
1685						// :(first|last|only)-(child|of-type)
1686						if ( simple ) {
1687							while ( dir ) {
1688								node = elem;
1689								while ( (node = node[ dir ]) ) {
1690									if ( ofType ? node.nodeName.toLowerCase() === name : node.nodeType === 1 ) {
1691										return false;
1692									}
1693								}
1694								// Reverse direction for :only-* (if we haven't yet done so)
1695								start = dir = type === "only" && !start && "nextSibling";
1696							}
1697							return true;
1698						}
1699
1700						start = [ forward ? parent.firstChild : parent.lastChild ];
1701
1702						// non-xml :nth-child(...) stores cache data on `parent`
1703						if ( forward && useCache ) {
1704							// Seek `elem` from a previously-cached index
1705							outerCache = parent[ expando ] || (parent[ expando ] = {});
1706							cache = outerCache[ type ] || [];
1707							nodeIndex = cache[0] === dirruns && cache[1];
1708							diff = cache[0] === dirruns && cache[2];
1709							node = nodeIndex && parent.childNodes[ nodeIndex ];
1710
1711							while ( (node = ++nodeIndex && node && node[ dir ] ||
1712
1713								// Fallback to seeking `elem` from the start
1714								(diff = nodeIndex = 0) || start.pop()) ) {
1715
1716								// When found, cache indexes on `parent` and break
1717								if ( node.nodeType === 1 && ++diff && node === elem ) {
1718									outerCache[ type ] = [ dirruns, nodeIndex, diff ];
1719									break;
1720								}
1721							}
1722
1723						// Use previously-cached element index if available
1724						} else if ( useCache && (cache = (elem[ expando ] || (elem[ expando ] = {}))[ type ]) && cache[0] === dirruns ) {
1725							diff = cache[1];
1726
1727						// xml :nth-child(...) or :nth-last-child(...) or :nth(-last)?-of-type(...)
1728						} else {
1729							// Use the same loop as above to seek `elem` from the start
1730							while ( (node = ++nodeIndex && node && node[ dir ] ||
1731								(diff = nodeIndex = 0) || start.pop()) ) {
1732
1733								if ( ( ofType ? node.nodeName.toLowerCase() === name : node.nodeType === 1 ) && ++diff ) {
1734									// Cache the index of each encountered element
1735									if ( useCache ) {
1736										(node[ expando ] || (node[ expando ] = {}))[ type ] = [ dirruns, diff ];
1737									}
1738
1739									if ( node === elem ) {
1740										break;
1741									}
1742								}
1743							}
1744						}
1745
1746						// Incorporate the offset, then check against cycle size
1747						diff -= last;
1748						return diff === first || ( diff % first === 0 && diff / first >= 0 );
1749					}
1750				};
1751		},
1752
1753		"PSEUDO": function( pseudo, argument ) {
1754			// pseudo-class names are case-insensitive
1755			// http://www.w3.org/TR/selectors/#pseudo-classes
1756			// Prioritize by case sensitivity in case custom pseudos are added with uppercase letters
1757			// Remember that setFilters inherits from pseudos
1758			var args,
1759				fn = Expr.pseudos[ pseudo ] || Expr.setFilters[ pseudo.toLowerCase() ] ||
1760					Sizzle.error( "unsupported pseudo: " + pseudo );
1761
1762			// The user may use createPseudo to indicate that
1763			// arguments are needed to create the filter function
1764			// just as Sizzle does
1765			if ( fn[ expando ] ) {
1766				return fn( argument );
1767			}
1768
1769			// But maintain support for old signatures
1770			if ( fn.length > 1 ) {
1771				args = [ pseudo, pseudo, "", argument ];
1772				return Expr.setFilters.hasOwnProperty( pseudo.toLowerCase() ) ?
1773					markFunction(function( seed, matches ) {
1774						var idx,
1775							matched = fn( seed, argument ),
1776							i = matched.length;
1777						while ( i-- ) {
1778							idx = indexOf( seed, matched[i] );
1779							seed[ idx ] = !( matches[ idx ] = matched[i] );
1780						}
1781					}) :
1782					function( elem ) {
1783						return fn( elem, 0, args );
1784					};
1785			}
1786
1787			return fn;
1788		}
1789	},
1790
1791	pseudos: {
1792		// Potentially complex pseudos
1793		"not": markFunction(function( selector ) {
1794			// Trim the selector passed to compile
1795			// to avoid treating leading and trailing
1796			// spaces as combinators
1797			var input = [],
1798				results = [],
1799				matcher = compile( selector.replace( rtrim, "$1" ) );
1800
1801			return matcher[ expando ] ?
1802				markFunction(function( seed, matches, context, xml ) {
1803					var elem,
1804						unmatched = matcher( seed, null, xml, [] ),
1805						i = seed.length;
1806
1807					// Match elements unmatched by `matcher`
1808					while ( i-- ) {
1809						if ( (elem = unmatched[i]) ) {
1810							seed[i] = !(matches[i] = elem);
1811						}
1812					}
1813				}) :
1814				function( elem, context, xml ) {
1815					input[0] = elem;
1816					matcher( input, null, xml, results );
1817					// Don't keep the element (issue #299)
1818					input[0] = null;
1819					return !results.pop();
1820				};
1821		}),
1822
1823		"has": markFunction(function( selector ) {
1824			return function( elem ) {
1825				return Sizzle( selector, elem ).length > 0;
1826			};
1827		}),
1828
1829		"contains": markFunction(function( text ) {
1830			text = text.replace( runescape, funescape );
1831			return function( elem ) {
1832				return ( elem.textContent || elem.innerText || getText( elem ) ).indexOf( text ) > -1;
1833			};
1834		}),
1835
1836		// "Whether an element is represented by a :lang() selector
1837		// is based solely on the element's language value
1838		// being equal to the identifier C,
1839		// or beginning with the identifier C immediately followed by "-".
1840		// The matching of C against the element's language value is performed case-insensitively.
1841		// The identifier C does not have to be a valid language name."
1842		// http://www.w3.org/TR/selectors/#lang-pseudo
1843		"lang": markFunction( function( lang ) {
1844			// lang value must be a valid identifier
1845			if ( !ridentifier.test(lang || "") ) {
1846				Sizzle.error( "unsupported lang: " + lang );
1847			}
1848			lang = lang.replace( runescape, funescape ).toLowerCase();
1849			return function( elem ) {
1850				var elemLang;
1851				do {
1852					if ( (elemLang = documentIsHTML ?
1853						elem.lang :
1854						elem.getAttribute("xml:lang") || elem.getAttribute("lang")) ) {
1855
1856						elemLang = elemLang.toLowerCase();
1857						return elemLang === lang || elemLang.indexOf( lang + "-" ) === 0;
1858					}
1859				} while ( (elem = elem.parentNode) && elem.nodeType === 1 );
1860				return false;
1861			};
1862		}),
1863
1864		// Miscellaneous
1865		"target": function( elem ) {
1866			var hash = window.location && window.location.hash;
1867			return hash && hash.slice( 1 ) === elem.id;
1868		},
1869
1870		"root": function( elem ) {
1871			return elem === docElem;
1872		},
1873
1874		"focus": function( elem ) {
1875			return elem === document.activeElement && (!document.hasFocus || document.hasFocus()) && !!(elem.type || elem.href || ~elem.tabIndex);
1876		},
1877
1878		// Boolean properties
1879		"enabled": function( elem ) {
1880			return elem.disabled === false;
1881		},
1882
1883		"disabled": function( elem ) {
1884			return elem.disabled === true;
1885		},
1886
1887		"checked": function( elem ) {
1888			// In CSS3, :checked should return both checked and selected elements
1889			// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
1890			var nodeName = elem.nodeName.toLowerCase();
1891			return (nodeName === "input" && !!elem.checked) || (nodeName === "option" && !!elem.selected);
1892		},
1893
1894		"selected": function( elem ) {
1895			// Accessing this property makes selected-by-default
1896			// options in Safari work properly
1897			if ( elem.parentNode ) {
1898				elem.parentNode.selectedIndex;
1899			}
1900
1901			return elem.selected === true;
1902		},
1903
1904		// Contents
1905		"empty": function( elem ) {
1906			// http://www.w3.org/TR/selectors/#empty-pseudo
1907			// :empty is negated by element (1) or content nodes (text: 3; cdata: 4; entity ref: 5),
1908			//   but not by others (comment: 8; processing instruction: 7; etc.)
1909			// nodeType < 6 works because attributes (2) do not appear as children
1910			for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
1911				if ( elem.nodeType < 6 ) {
1912					return false;
1913				}
1914			}
1915			return true;
1916		},
1917
1918		"parent": function( elem ) {
1919			return !Expr.pseudos["empty"]( elem );
1920		},
1921
1922		// Element/input types
1923		"header": function( elem ) {
1924			return rheader.test( elem.nodeName );
1925		},
1926
1927		"input": function( elem ) {
1928			return rinputs.test( elem.nodeName );
1929		},
1930
1931		"button": function( elem ) {
1932			var name = elem.nodeName.toLowerCase();
1933			return name === "input" && elem.type === "button" || name === "button";
1934		},
1935
1936		"text": function( elem ) {
1937			var attr;
1938			return elem.nodeName.toLowerCase() === "input" &&
1939				elem.type === "text" &&
1940
1941				// Support: IE<8
1942				// New HTML5 attribute values (e.g., "search") appear with elem.type === "text"
1943				( (attr = elem.getAttribute("type")) == null || attr.toLowerCase() === "text" );
1944		},
1945
1946		// Position-in-collection
1947		"first": createPositionalPseudo(function() {
1948			return [ 0 ];
1949		}),
1950
1951		"last": createPositionalPseudo(function( matchIndexes, length ) {
1952			return [ length - 1 ];
1953		}),
1954
1955		"eq": createPositionalPseudo(function( matchIndexes, length, argument ) {
1956			return [ argument < 0 ? argument + length : argument ];
1957		}),
1958
1959		"even": createPositionalPseudo(function( matchIndexes, length ) {
1960			var i = 0;
1961			for ( ; i < length; i += 2 ) {
1962				matchIndexes.push( i );
1963			}
1964			return matchIndexes;
1965		}),
1966
1967		"odd": createPositionalPseudo(function( matchIndexes, length ) {
1968			var i = 1;
1969			for ( ; i < length; i += 2 ) {
1970				matchIndexes.push( i );
1971			}
1972			return matchIndexes;
1973		}),
1974
1975		"lt": createPositionalPseudo(function( matchIndexes, length, argument ) {
1976			var i = argument < 0 ? argument + length : argument;
1977			for ( ; --i >= 0; ) {
1978				matchIndexes.push( i );
1979			}
1980			return matchIndexes;
1981		}),
1982
1983		"gt": createPositionalPseudo(function( matchIndexes, length, argument ) {
1984			var i = argument < 0 ? argument + length : argument;
1985			for ( ; ++i < length; ) {
1986				matchIndexes.push( i );
1987			}
1988			return matchIndexes;
1989		})
1990	}
1991};
1992
1993Expr.pseudos["nth"] = Expr.pseudos["eq"];
1994
1995// Add button/input type pseudos
1996for ( i in { radio: true, checkbox: true, file: true, password: true, image: true } ) {
1997	Expr.pseudos[ i ] = createInputPseudo( i );
1998}
1999for ( i in { submit: true, reset: true } ) {
2000	Expr.pseudos[ i ] = createButtonPseudo( i );
2001}
2002
2003// Easy API for creating new setFilters
2004function setFilters() {}
2005setFilters.prototype = Expr.filters = Expr.pseudos;
2006Expr.setFilters = new setFilters();
2007
2008tokenize = Sizzle.tokenize = function( selector, parseOnly ) {
2009	var matched, match, tokens, type,
2010		soFar, groups, preFilters,
2011		cached = tokenCache[ selector + " " ];
2012
2013	if ( cached ) {
2014		return parseOnly ? 0 : cached.slice( 0 );
2015	}
2016
2017	soFar = selector;
2018	groups = [];
2019	preFilters = Expr.preFilter;
2020
2021	while ( soFar ) {
2022
2023		// Comma and first run
2024		if ( !matched || (match = rcomma.exec( soFar )) ) {
2025			if ( match ) {
2026				// Don't consume trailing commas as valid
2027				soFar = soFar.slice( match[0].length ) || soFar;
2028			}
2029			groups.push( (tokens = []) );
2030		}
2031
2032		matched = false;
2033
2034		// Combinators
2035		if ( (match = rcombinators.exec( soFar )) ) {
2036			matched = match.shift();
2037			tokens.push({
2038				value: matched,
2039				// Cast descendant combinators to space
2040				type: match[0].replace( rtrim, " " )
2041			});
2042			soFar = soFar.slice( matched.length );
2043		}
2044
2045		// Filters
2046		for ( type in Expr.filter ) {
2047			if ( (match = matchExpr[ type ].exec( soFar )) && (!preFilters[ type ] ||
2048				(match = preFilters[ type ]( match ))) ) {
2049				matched = match.shift();
2050				tokens.push({
2051					value: matched,
2052					type: type,
2053					matches: match
2054				});
2055				soFar = soFar.slice( matched.length );
2056			}
2057		}
2058
2059		if ( !matched ) {
2060			break;
2061		}
2062	}
2063
2064	// Return the length of the invalid excess
2065	// if we're just parsing
2066	// Otherwise, throw an error or return tokens
2067	return parseOnly ?
2068		soFar.length :
2069		soFar ?
2070			Sizzle.error( selector ) :
2071			// Cache the tokens
2072			tokenCache( selector, groups ).slice( 0 );
2073};
2074
2075function toSelector( tokens ) {
2076	var i = 0,
2077		len = tokens.length,
2078		selector = "";
2079	for ( ; i < len; i++ ) {
2080		selector += tokens[i].value;
2081	}
2082	return selector;
2083}
2084
2085function addCombinator( matcher, combinator, base ) {
2086	var dir = combinator.dir,
2087		checkNonElements = base && dir === "parentNode",
2088		doneName = done++;
2089
2090	return combinator.first ?
2091		// Check against closest ancestor/preceding element
2092		function( elem, context, xml ) {
2093			while ( (elem = elem[ dir ]) ) {
2094				if ( elem.nodeType === 1 || checkNonElements ) {
2095					return matcher( elem, context, xml );
2096				}
2097			}
2098		} :
2099
2100		// Check against all ancestor/preceding elements
2101		function( elem, context, xml ) {
2102			var oldCache, outerCache,
2103				newCache = [ dirruns, doneName ];
2104
2105			// We can't set arbitrary data on XML nodes, so they don't benefit from dir caching
2106			if ( xml ) {
2107				while ( (elem = elem[ dir ]) ) {
2108					if ( elem.nodeType === 1 || checkNonElements ) {
2109						if ( matcher( elem, context, xml ) ) {
2110							return true;
2111						}
2112					}
2113				}
2114			} else {
2115				while ( (elem = elem[ dir ]) ) {
2116					if ( elem.nodeType === 1 || checkNonElements ) {
2117						outerCache = elem[ expando ] || (elem[ expando ] = {});
2118						if ( (oldCache = outerCache[ dir ]) &&
2119							oldCache[ 0 ] === dirruns && oldCache[ 1 ] === doneName ) {
2120
2121							// Assign to newCache so results back-propagate to previous elements
2122							return (newCache[ 2 ] = oldCache[ 2 ]);
2123						} else {
2124							// Reuse newcache so results back-propagate to previous elements
2125							outerCache[ dir ] = newCache;
2126
2127							// A match means we're done; a fail means we have to keep checking
2128							if ( (newCache[ 2 ] = matcher( elem, context, xml )) ) {
2129								return true;
2130							}
2131						}
2132					}
2133				}
2134			}
2135		};
2136}
2137
2138function elementMatcher( matchers ) {
2139	return matchers.length > 1 ?
2140		function( elem, context, xml ) {
2141			var i = matchers.length;
2142			while ( i-- ) {
2143				if ( !matchers[i]( elem, context, xml ) ) {
2144					return false;
2145				}
2146			}
2147			return true;
2148		} :
2149		matchers[0];
2150}
2151
2152function multipleContexts( selector, contexts, results ) {
2153	var i = 0,
2154		len = contexts.length;
2155	for ( ; i < len; i++ ) {
2156		Sizzle( selector, contexts[i], results );
2157	}
2158	return results;
2159}
2160
2161function condense( unmatched, map, filter, context, xml ) {
2162	var elem,
2163		newUnmatched = [],
2164		i = 0,
2165		len = unmatched.length,
2166		mapped = map != null;
2167
2168	for ( ; i < len; i++ ) {
2169		if ( (elem = unmatched[i]) ) {
2170			if ( !filter || filter( elem, context, xml ) ) {
2171				newUnmatched.push( elem );
2172				if ( mapped ) {
2173					map.push( i );
2174				}
2175			}
2176		}
2177	}
2178
2179	return newUnmatched;
2180}
2181
2182function setMatcher( preFilter, selector, matcher, postFilter, postFinder, postSelector ) {
2183	if ( postFilter && !postFilter[ expando ] ) {
2184		postFilter = setMatcher( postFilter );
2185	}
2186	if ( postFinder && !postFinder[ expando ] ) {
2187		postFinder = setMatcher( postFinder, postSelector );
2188	}
2189	return markFunction(function( seed, results, context, xml ) {
2190		var temp, i, elem,
2191			preMap = [],
2192			postMap = [],
2193			preexisting = results.length,
2194
2195			// Get initial elements from seed or context
2196			elems = seed || multipleContexts( selector || "*", context.nodeType ? [ context ] : context, [] ),
2197
2198			// Prefilter to get matcher input, preserving a map for seed-results synchronization
2199			matcherIn = preFilter && ( seed || !selector ) ?
2200				condense( elems, preMap, preFilter, context, xml ) :
2201				elems,
2202
2203			matcherOut = matcher ?
2204				// If we have a postFinder, or filtered seed, or non-seed postFilter or preexisting results,
2205				postFinder || ( seed ? preFilter : preexisting || postFilter ) ?
2206
2207					// ...intermediate processing is necessary
2208					[] :
2209
2210					// ...otherwise use results directly
2211					results :
2212				matcherIn;
2213
2214		// Find primary matches
2215		if ( matcher ) {
2216			matcher( matcherIn, matcherOut, context, xml );
2217		}
2218
2219		// Apply postFilter
2220		if ( postFilter ) {
2221			temp = condense( matcherOut, postMap );
2222			postFilter( temp, [], context, xml );
2223
2224			// Un-match failing elements by moving them back to matcherIn
2225			i = temp.length;
2226			while ( i-- ) {
2227				if ( (elem = temp[i]) ) {
2228					matcherOut[ postMap[i] ] = !(matcherIn[ postMap[i] ] = elem);
2229				}
2230			}
2231		}
2232
2233		if ( seed ) {
2234			if ( postFinder || preFilter ) {
2235				if ( postFinder ) {
2236					// Get the final matcherOut by condensing this intermediate into postFinder contexts
2237					temp = [];
2238					i = matcherOut.length;
2239					while ( i-- ) {
2240						if ( (elem = matcherOut[i]) ) {
2241							// Restore matcherIn since elem is not yet a final match
2242							temp.push( (matcherIn[i] = elem) );
2243						}
2244					}
2245					postFinder( null, (matcherOut = []), temp, xml );
2246				}
2247
2248				// Move matched elements from seed to results to keep them synchronized
2249				i = matcherOut.length;
2250				while ( i-- ) {
2251					if ( (elem = matcherOut[i]) &&
2252						(temp = postFinder ? indexOf( seed, elem ) : preMap[i]) > -1 ) {
2253
2254						seed[temp] = !(results[temp] = elem);
2255					}
2256				}
2257			}
2258
2259		// Add elements to results, through postFinder if defined
2260		} else {
2261			matcherOut = condense(
2262				matcherOut === results ?
2263					matcherOut.splice( preexisting, matcherOut.length ) :
2264					matcherOut
2265			);
2266			if ( postFinder ) {
2267				postFinder( null, results, matcherOut, xml );
2268			} else {
2269				push.apply( results, matcherOut );
2270			}
2271		}
2272	});
2273}
2274
2275function matcherFromTokens( tokens ) {
2276	var checkContext, matcher, j,
2277		len = tokens.length,
2278		leadingRelative = Expr.relative[ tokens[0].type ],
2279		implicitRelative = leadingRelative || Expr.relative[" "],
2280		i = leadingRelative ? 1 : 0,
2281
2282		// The foundational matcher ensures that elements are reachable from top-level context(s)
2283		matchContext = addCombinator( function( elem ) {
2284			return elem === checkContext;
2285		}, implicitRelative, true ),
2286		matchAnyContext = addCombinator( function( elem ) {
2287			return indexOf( checkContext, elem ) > -1;
2288		}, implicitRelative, true ),
2289		matchers = [ function( elem, context, xml ) {
2290			var ret = ( !leadingRelative && ( xml || context !== outermostContext ) ) || (
2291				(checkContext = context).nodeType ?
2292					matchContext( elem, context, xml ) :
2293					matchAnyContext( elem, context, xml ) );
2294			// Avoid hanging onto element (issue #299)
2295			checkContext = null;
2296			return ret;
2297		} ];
2298
2299	for ( ; i < len; i++ ) {
2300		if ( (matcher = Expr.relative[ tokens[i].type ]) ) {
2301			matchers = [ addCombinator(elementMatcher( matchers ), matcher) ];
2302		} else {
2303			matcher = Expr.filter[ tokens[i].type ].apply( null, tokens[i].matches );
2304
2305			// Return special upon seeing a positional matcher
2306			if ( matcher[ expando ] ) {
2307				// Find the next relative operator (if any) for proper handling
2308				j = ++i;
2309				for ( ; j < len; j++ ) {
2310					if ( Expr.relative[ tokens[j].type ] ) {
2311						break;
2312					}
2313				}
2314				return setMatcher(
2315					i > 1 && elementMatcher( matchers ),
2316					i > 1 && toSelector(
2317						// If the preceding token was a descendant combinator, insert an implicit any-element `*`
2318						tokens.slice( 0, i - 1 ).concat({ value: tokens[ i - 2 ].type === " " ? "*" : "" })
2319					).replace( rtrim, "$1" ),
2320					matcher,
2321					i < j && matcherFromTokens( tokens.slice( i, j ) ),
2322					j < len && matcherFromTokens( (tokens = tokens.slice( j )) ),
2323					j < len && toSelector( tokens )
2324				);
2325			}
2326			matchers.push( matcher );
2327		}
2328	}
2329
2330	return elementMatcher( matchers );
2331}
2332
2333function matcherFromGroupMatchers( elementMatchers, setMatchers ) {
2334	var bySet = setMatchers.length > 0,
2335		byElement = elementMatchers.length > 0,
2336		superMatcher = function( seed, context, xml, results, outermost ) {
2337			var elem, j, matcher,
2338				matchedCount = 0,
2339				i = "0",
2340				unmatched = seed && [],
2341				setMatched = [],
2342				contextBackup = outermostContext,
2343				// We must always have either seed elements or outermost context
2344				elems = seed || byElement && Expr.find["TAG"]( "*", outermost ),
2345				// Use integer dirruns iff this is the outermost matcher
2346				dirrunsUnique = (dirruns += contextBackup == null ? 1 : Math.random() || 0.1),
2347				len = elems.length;
2348
2349			if ( outermost ) {
2350				outermostContext = context !== document && context;
2351			}
2352
2353			// Add elements passing elementMatchers directly to results
2354			// Keep `i` a string if there are no elements so `matchedCount` will be "00" below
2355			// Support: IE<9, Safari
2356			// Tolerate NodeList properties (IE: "length"; Safari: <number>) matching elements by id
2357			for ( ; i !== len && (elem = elems[i]) != null; i++ ) {
2358				if ( byElement && elem ) {
2359					j = 0;
2360					while ( (matcher = elementMatchers[j++]) ) {
2361						if ( matcher( elem, context, xml ) ) {
2362							results.push( elem );
2363							break;
2364						}
2365					}
2366					if ( outermost ) {
2367						dirruns = dirrunsUnique;
2368					}
2369				}
2370
2371				// Track unmatched elements for set filters
2372				if ( bySet ) {
2373					// They will have gone through all possible matchers
2374					if ( (elem = !matcher && elem) ) {
2375						matchedCount--;
2376					}
2377
2378					// Lengthen the array for every element, matched or not
2379					if ( seed ) {
2380						unmatched.push( elem );
2381					}
2382				}
2383			}
2384
2385			// Apply set filters to unmatched elements
2386			matchedCount += i;
2387			if ( bySet && i !== matchedCount ) {
2388				j = 0;
2389				while ( (matcher = setMatchers[j++]) ) {
2390					matcher( unmatched, setMatched, context, xml );
2391				}
2392
2393				if ( seed ) {
2394					// Reintegrate element matches to eliminate the need for sorting
2395					if ( matchedCount > 0 ) {
2396						while ( i-- ) {
2397							if ( !(unmatched[i] || setMatched[i]) ) {
2398								setMatched[i] = pop.call( results );
2399							}
2400						}
2401					}
2402
2403					// Discard index placeholder values to get only actual matches
2404					setMatched = condense( setMatched );
2405				}
2406
2407				// Add matches to results
2408				push.apply( results, setMatched );
2409
2410				// Seedless set matches succeeding multiple successful matchers stipulate sorting
2411				if ( outermost && !seed && setMatched.length > 0 &&
2412					( matchedCount + setMatchers.length ) > 1 ) {
2413
2414					Sizzle.uniqueSort( results );
2415				}
2416			}
2417
2418			// Override manipulation of globals by nested matchers
2419			if ( outermost ) {
2420				dirruns = dirrunsUnique;
2421				outermostContext = contextBackup;
2422			}
2423
2424			return unmatched;
2425		};
2426
2427	return bySet ?
2428		markFunction( superMatcher ) :
2429		superMatcher;
2430}
2431
2432compile = Sizzle.compile = function( selector, match /* Internal Use Only */ ) {
2433	var i,
2434		setMatchers = [],
2435		elementMatchers = [],
2436		cached = compilerCache[ selector + " " ];
2437
2438	if ( !cached ) {
2439		// Generate a function of recursive functions that can be used to check each element
2440		if ( !match ) {
2441			match = tokenize( selector );
2442		}
2443		i = match.length;
2444		while ( i-- ) {
2445			cached = matcherFromTokens( match[i] );
2446			if ( cached[ expando ] ) {
2447				setMatchers.push( cached );
2448			} else {
2449				elementMatchers.push( cached );
2450			}
2451		}
2452
2453		// Cache the compiled function
2454		cached = compilerCache( selector, matcherFromGroupMatchers( elementMatchers, setMatchers ) );
2455
2456		// Save selector and tokenization
2457		cached.selector = selector;
2458	}
2459	return cached;
2460};
2461
2462/**
2463 * A low-level selection function that works with Sizzle's compiled
2464 *  selector functions
2465 * @param {String|Function} selector A selector or a pre-compiled
2466 *  selector function built with Sizzle.compile
2467 * @param {Element} context
2468 * @param {Array} [results]
2469 * @param {Array} [seed] A set of elements to match against
2470 */
2471select = Sizzle.select = function( selector, context, results, seed ) {
2472	var i, tokens, token, type, find,
2473		compiled = typeof selector === "function" && selector,
2474		match = !seed && tokenize( (selector = compiled.selector || selector) );
2475
2476	results = results || [];
2477
2478	// Try to minimize operations if there is no seed and only one group
2479	if ( match.length === 1 ) {
2480
2481		// Take a shortcut and set the context if the root selector is an ID
2482		tokens = match[0] = match[0].slice( 0 );
2483		if ( tokens.length > 2 && (token = tokens[0]).type === "ID" &&
2484				support.getById && context.nodeType === 9 && documentIsHTML &&
2485				Expr.relative[ tokens[1].type ] ) {
2486
2487			context = ( Expr.find["ID"]( token.matches[0].replace(runescape, funescape), context ) || [] )[0];
2488			if ( !context ) {
2489				return results;
2490
2491			// Precompiled matchers will still verify ancestry, so step up a level
2492			} else if ( compiled ) {
2493				context = context.parentNode;
2494			}
2495
2496			selector = selector.slice( tokens.shift().value.length );
2497		}
2498
2499		// Fetch a seed set for right-to-left matching
2500		i = matchExpr["needsContext"].test( selector ) ? 0 : tokens.length;
2501		while ( i-- ) {
2502			token = tokens[i];
2503
2504			// Abort if we hit a combinator
2505			if ( Expr.relative[ (type = token.type) ] ) {
2506				break;
2507			}
2508			if ( (find = Expr.find[ type ]) ) {
2509				// Search, expanding context for leading sibling combinators
2510				if ( (seed = find(
2511					token.matches[0].replace( runescape, funescape ),
2512					rsibling.test( tokens[0].type ) && testContext( context.parentNode ) || context
2513				)) ) {
2514
2515					// If seed is empty or no tokens remain, we can return early
2516					tokens.splice( i, 1 );
2517					selector = seed.length && toSelector( tokens );
2518					if ( !selector ) {
2519						push.apply( results, seed );
2520						return results;
2521					}
2522
2523					break;
2524				}
2525			}
2526		}
2527	}
2528
2529	// Compile and execute a filtering function if one is not provided
2530	// Provide `match` to avoid retokenization if we modified the selector above
2531	( compiled || compile( selector, match ) )(
2532		seed,
2533		context,
2534		!documentIsHTML,
2535		results,
2536		rsibling.test( selector ) && testContext( context.parentNode ) || context
2537	);
2538	return results;
2539};
2540
2541// One-time assignments
2542
2543// Sort stability
2544support.sortStable = expando.split("").sort( sortOrder ).join("") === expando;
2545
2546// Support: Chrome 14-35+
2547// Always assume duplicates if they aren't passed to the comparison function
2548support.detectDuplicates = !!hasDuplicate;
2549
2550// Initialize against the default document
2551setDocument();
2552
2553// Support: Webkit<537.32 - Safari 6.0.3/Chrome 25 (fixed in Chrome 27)
2554// Detached nodes confoundingly follow *each other*
2555support.sortDetached = assert(function( div1 ) {
2556	// Should return 1, but returns 4 (following)
2557	return div1.compareDocumentPosition( document.createElement("div") ) & 1;
2558});
2559
2560// Support: IE<8
2561// Prevent attribute/property "interpolation"
2562// http://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx
2563if ( !assert(function( div ) {
2564	div.innerHTML = "<a href='#'></a>";
2565	return div.firstChild.getAttribute("href") === "#" ;
2566}) ) {
2567	addHandle( "type|href|height|width", function( elem, name, isXML ) {
2568		if ( !isXML ) {
2569			return elem.getAttribute( name, name.toLowerCase() === "type" ? 1 : 2 );
2570		}
2571	});
2572}
2573
2574// Support: IE<9
2575// Use defaultValue in place of getAttribute("value")
2576if ( !support.attributes || !assert(function( div ) {
2577	div.innerHTML = "<input/>";
2578	div.firstChild.setAttribute( "value", "" );
2579	return div.firstChild.getAttribute( "value" ) === "";
2580}) ) {
2581	addHandle( "value", function( elem, name, isXML ) {
2582		if ( !isXML && elem.nodeName.toLowerCase() === "input" ) {
2583			return elem.defaultValue;
2584		}
2585	});
2586}
2587
2588// Support: IE<9
2589// Use getAttributeNode to fetch booleans when getAttribute lies
2590if ( !assert(function( div ) {
2591	return div.getAttribute("disabled") == null;
2592}) ) {
2593	addHandle( booleans, function( elem, name, isXML ) {
2594		var val;
2595		if ( !isXML ) {
2596			return elem[ name ] === true ? name.toLowerCase() :
2597					(val = elem.getAttributeNode( name )) && val.specified ?
2598					val.value :
2599				null;
2600		}
2601	});
2602}
2603
2604return Sizzle;
2605
2606})( window );
2607
2608
2609
2610jQuery.find = Sizzle;
2611jQuery.expr = Sizzle.selectors;
2612jQuery.expr[":"] = jQuery.expr.pseudos;
2613jQuery.unique = Sizzle.uniqueSort;
2614jQuery.text = Sizzle.getText;
2615jQuery.isXMLDoc = Sizzle.isXML;
2616jQuery.contains = Sizzle.contains;
2617
2618
2619
2620var rneedsContext = jQuery.expr.match.needsContext;
2621
2622var rsingleTag = (/^<(\w+)\s*\/?>(?:<\/\1>|)$/);
2623
2624
2625
2626var risSimple = /^.[^:#\[\.,]*$/;
2627
2628// Implement the identical functionality for filter and not
2629function winnow( elements, qualifier, not ) {
2630	if ( jQuery.isFunction( qualifier ) ) {
2631		return jQuery.grep( elements, function( elem, i ) {
2632			/* jshint -W018 */
2633			return !!qualifier.call( elem, i, elem ) !== not;
2634		});
2635
2636	}
2637
2638	if ( qualifier.nodeType ) {
2639		return jQuery.grep( elements, function( elem ) {
2640			return ( elem === qualifier ) !== not;
2641		});
2642
2643	}
2644
2645	if ( typeof qualifier === "string" ) {
2646		if ( risSimple.test( qualifier ) ) {
2647			return jQuery.filter( qualifier, elements, not );
2648		}
2649
2650		qualifier = jQuery.filter( qualifier, elements );
2651	}
2652
2653	return jQuery.grep( elements, function( elem ) {
2654		return ( indexOf.call( qualifier, elem ) >= 0 ) !== not;
2655	});
2656}
2657
2658jQuery.filter = function( expr, elems, not ) {
2659	var elem = elems[ 0 ];
2660
2661	if ( not ) {
2662		expr = ":not(" + expr + ")";
2663	}
2664
2665	return elems.length === 1 && elem.nodeType === 1 ?
2666		jQuery.find.matchesSelector( elem, expr ) ? [ elem ] : [] :
2667		jQuery.find.matches( expr, jQuery.grep( elems, function( elem ) {
2668			return elem.nodeType === 1;
2669		}));
2670};
2671
2672jQuery.fn.extend({
2673	find: function( selector ) {
2674		var i,
2675			len = this.length,
2676			ret = [],
2677			self = this;
2678
2679		if ( typeof selector !== "string" ) {
2680			return this.pushStack( jQuery( selector ).filter(function() {
2681				for ( i = 0; i < len; i++ ) {
2682					if ( jQuery.contains( self[ i ], this ) ) {
2683						return true;
2684					}
2685				}
2686			}) );
2687		}
2688
2689		for ( i = 0; i < len; i++ ) {
2690			jQuery.find( selector, self[ i ], ret );
2691		}
2692
2693		// Needed because $( selector, context ) becomes $( context ).find( selector )
2694		ret = this.pushStack( len > 1 ? jQuery.unique( ret ) : ret );
2695		ret.selector = this.selector ? this.selector + " " + selector : selector;
2696		return ret;
2697	},
2698	filter: function( selector ) {
2699		return this.pushStack( winnow(this, selector || [], false) );
2700	},
2701	not: function( selector ) {
2702		return this.pushStack( winnow(this, selector || [], true) );
2703	},
2704	is: function( selector ) {
2705		return !!winnow(
2706			this,
2707
2708			// If this is a positional/relative selector, check membership in the returned set
2709			// so $("p:first").is("p:last") won't return true for a doc with two "p".
2710			typeof selector === "string" && rneedsContext.test( selector ) ?
2711				jQuery( selector ) :
2712				selector || [],
2713			false
2714		).length;
2715	}
2716});
2717
2718
2719// Initialize a jQuery object
2720
2721
2722// A central reference to the root jQuery(document)
2723var rootjQuery,
2724
2725	// A simple way to check for HTML strings
2726	// Prioritize #id over <tag> to avoid XSS via location.hash (#9521)
2727	// Strict HTML recognition (#11290: must start with <)
2728	rquickExpr = /^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]*))$/,
2729
2730	init = jQuery.fn.init = function( selector, context ) {
2731		var match, elem;
2732
2733		// HANDLE: $(""), $(null), $(undefined), $(false)
2734		if ( !selector ) {
2735			return this;
2736		}
2737
2738		// Handle HTML strings
2739		if ( typeof selector === "string" ) {
2740			if ( selector[0] === "<" && selector[ selector.length - 1 ] === ">" && selector.length >= 3 ) {
2741				// Assume that strings that start and end with <> are HTML and skip the regex check
2742				match = [ null, selector, null ];
2743
2744			} else {
2745				match = rquickExpr.exec( selector );
2746			}
2747
2748			// Match html or make sure no context is specified for #id
2749			if ( match && (match[1] || !context) ) {
2750
2751				// HANDLE: $(html) -> $(array)
2752				if ( match[1] ) {
2753					context = context instanceof jQuery ? context[0] : context;
2754
2755					// Option to run scripts is true for back-compat
2756					// Intentionally let the error be thrown if parseHTML is not present
2757					jQuery.merge( this, jQuery.parseHTML(
2758						match[1],
2759						context && context.nodeType ? context.ownerDocument || context : document,
2760						true
2761					) );
2762
2763					// HANDLE: $(html, props)
2764					if ( rsingleTag.test( match[1] ) && jQuery.isPlainObject( context ) ) {
2765						for ( match in context ) {
2766							// Properties of context are called as methods if possible
2767							if ( jQuery.isFunction( this[ match ] ) ) {
2768								this[ match ]( context[ match ] );
2769
2770							// ...and otherwise set as attributes
2771							} else {
2772								this.attr( match, context[ match ] );
2773							}
2774						}
2775					}
2776
2777					return this;
2778
2779				// HANDLE: $(#id)
2780				} else {
2781					elem = document.getElementById( match[2] );
2782
2783					// Support: Blackberry 4.6
2784					// gEBID returns nodes no longer in the document (#6963)
2785					if ( elem && elem.parentNode ) {
2786						// Inject the element directly into the jQuery object
2787						this.length = 1;
2788						this[0] = elem;
2789					}
2790
2791					this.context = document;
2792					this.selector = selector;
2793					return this;
2794				}
2795
2796			// HANDLE: $(expr, $(...))
2797			} else if ( !context || context.jquery ) {
2798				return ( context || rootjQuery ).find( selector );
2799
2800			// HANDLE: $(expr, context)
2801			// (which is just equivalent to: $(context).find(expr)
2802			} else {
2803				return this.constructor( context ).find( selector );
2804			}
2805
2806		// HANDLE: $(DOMElement)
2807		} else if ( selector.nodeType ) {
2808			this.context = this[0] = selector;
2809			this.length = 1;
2810			return this;
2811
2812		// HANDLE: $(function)
2813		// Shortcut for document ready
2814		} else if ( jQuery.isFunction( selector ) ) {
2815			return typeof rootjQuery.ready !== "undefined" ?
2816				rootjQuery.ready( selector ) :
2817				// Execute immediately if ready is not present
2818				selector( jQuery );
2819		}
2820
2821		if ( selector.selector !== undefined ) {
2822			this.selector = selector.selector;
2823			this.context = selector.context;
2824		}
2825
2826		return jQuery.makeArray( selector, this );
2827	};
2828
2829// Give the init function the jQuery prototype for later instantiation
2830init.prototype = jQuery.fn;
2831
2832// Initialize central reference
2833rootjQuery = jQuery( document );
2834
2835
2836var rparentsprev = /^(?:parents|prev(?:Until|All))/,
2837	// Methods guaranteed to produce a unique set when starting from a unique set
2838	guaranteedUnique = {
2839		children: true,
2840		contents: true,
2841		next: true,
2842		prev: true
2843	};
2844
2845jQuery.extend({
2846	dir: function( elem, dir, until ) {
2847		var matched = [],
2848			truncate = until !== undefined;
2849
2850		while ( (elem = elem[ dir ]) && elem.nodeType !== 9 ) {
2851			if ( elem.nodeType === 1 ) {
2852				if ( truncate && jQuery( elem ).is( until ) ) {
2853					break;
2854				}
2855				matched.push( elem );
2856			}
2857		}
2858		return matched;
2859	},
2860
2861	sibling: function( n, elem ) {
2862		var matched = [];
2863
2864		for ( ; n; n = n.nextSibling ) {
2865			if ( n.nodeType === 1 && n !== elem ) {
2866				matched.push( n );
2867			}
2868		}
2869
2870		return matched;
2871	}
2872});
2873
2874jQuery.fn.extend({
2875	has: function( target ) {
2876		var targets = jQuery( target, this ),
2877			l = targets.length;
2878
2879		return this.filter(function() {
2880			var i = 0;
2881			for ( ; i < l; i++ ) {
2882				if ( jQuery.contains( this, targets[i] ) ) {
2883					return true;
2884				}
2885			}
2886		});
2887	},
2888
2889	closest: function( selectors, context ) {
2890		var cur,
2891			i = 0,
2892			l = this.length,
2893			matched = [],
2894			pos = rneedsContext.test( selectors ) || typeof selectors !== "string" ?
2895				jQuery( selectors, context || this.context ) :
2896				0;
2897
2898		for ( ; i < l; i++ ) {
2899			for ( cur = this[i]; cur && cur !== context; cur = cur.parentNode ) {
2900				// Always skip document fragments
2901				if ( cur.nodeType < 11 && (pos ?
2902					pos.index(cur) > -1 :
2903
2904					// Don't pass non-elements to Sizzle
2905					cur.nodeType === 1 &&
2906						jQuery.find.matchesSelector(cur, selectors)) ) {
2907
2908					matched.push( cur );
2909					break;
2910				}
2911			}
2912		}
2913
2914		return this.pushStack( matched.length > 1 ? jQuery.unique( matched ) : matched );
2915	},
2916
2917	// Determine the position of an element within the set
2918	index: function( elem ) {
2919
2920		// No argument, return index in parent
2921		if ( !elem ) {
2922			return ( this[ 0 ] && this[ 0 ].parentNode ) ? this.first().prevAll().length : -1;
2923		}
2924
2925		// Index in selector
2926		if ( typeof elem === "string" ) {
2927			return indexOf.call( jQuery( elem ), this[ 0 ] );
2928		}
2929
2930		// Locate the position of the desired element
2931		return indexOf.call( this,
2932
2933			// If it receives a jQuery object, the first element is used
2934			elem.jquery ? elem[ 0 ] : elem
2935		);
2936	},
2937
2938	add: function( selector, context ) {
2939		return this.pushStack(
2940			jQuery.unique(
2941				jQuery.merge( this.get(), jQuery( selector, context ) )
2942			)
2943		);
2944	},
2945
2946	addBack: function( selector ) {
2947		return this.add( selector == null ?
2948			this.prevObject : this.prevObject.filter(selector)
2949		);
2950	}
2951});
2952
2953function sibling( cur, dir ) {
2954	while ( (cur = cur[dir]) && cur.nodeType !== 1 ) {}
2955	return cur;
2956}
2957
2958jQuery.each({
2959	parent: function( elem ) {
2960		var parent = elem.parentNode;
2961		return parent && parent.nodeType !== 11 ? parent : null;
2962	},
2963	parents: function( elem ) {
2964		return jQuery.dir( elem, "parentNode" );
2965	},
2966	parentsUntil: function( elem, i, until ) {
2967		return jQuery.dir( elem, "parentNode", until );
2968	},
2969	next: function( elem ) {
2970		return sibling( elem, "nextSibling" );
2971	},
2972	prev: function( elem ) {
2973		return sibling( elem, "previousSibling" );
2974	},
2975	nextAll: function( elem ) {
2976		return jQuery.dir( elem, "nextSibling" );
2977	},
2978	prevAll: function( elem ) {
2979		return jQuery.dir( elem, "previousSibling" );
2980	},
2981	nextUntil: function( elem, i, until ) {
2982		return jQuery.dir( elem, "nextSibling", until );
2983	},
2984	prevUntil: function( elem, i, until ) {
2985		return jQuery.dir( elem, "previousSibling", until );
2986	},
2987	siblings: function( elem ) {
2988		return jQuery.sibling( ( elem.parentNode || {} ).firstChild, elem );
2989	},
2990	children: function( elem ) {
2991		return jQuery.sibling( elem.firstChild );
2992	},
2993	contents: function( elem ) {
2994		return elem.contentDocument || jQuery.merge( [], elem.childNodes );
2995	}
2996}, function( name, fn ) {
2997	jQuery.fn[ name ] = function( until, selector ) {
2998		var matched = jQuery.map( this, fn, until );
2999
3000		if ( name.slice( -5 ) !== "Until" ) {
3001			selector = until;
3002		}
3003
3004		if ( selector && typeof selector === "string" ) {
3005			matched = jQuery.filter( selector, matched );
3006		}
3007
3008		if ( this.length > 1 ) {
3009			// Remove duplicates
3010			if ( !guaranteedUnique[ name ] ) {
3011				jQuery.unique( matched );
3012			}
3013
3014			// Reverse order for parents* and prev-derivatives
3015			if ( rparentsprev.test( name ) ) {
3016				matched.reverse();
3017			}
3018		}
3019
3020		return this.pushStack( matched );
3021	};
3022});
3023var rnotwhite = (/\S+/g);
3024
3025
3026
3027// String to Object options format cache
3028var optionsCache = {};
3029
3030// Convert String-formatted options into Object-formatted ones and store in cache
3031function createOptions( options ) {
3032	var object = optionsCache[ options ] = {};
3033	jQuery.each( options.match( rnotwhite ) || [], function( _, flag ) {
3034		object[ flag ] = true;
3035	});
3036	return object;
3037}
3038
3039/*
3040 * Create a callback list using the following parameters:
3041 *
3042 *	options: an optional list of space-separated options that will change how
3043 *			the callback list behaves or a more traditional option object
3044 *
3045 * By default a callback list will act like an event callback list and can be
3046 * "fired" multiple times.
3047 *
3048 * Possible options:
3049 *
3050 *	once:			will ensure the callback list can only be fired once (like a Deferred)
3051 *
3052 *	memory:			will keep track of previous values and will call any callback added
3053 *					after the list has been fired right away with the latest "memorized"
3054 *					values (like a Deferred)
3055 *
3056 *	unique:			will ensure a callback can only be added once (no duplicate in the list)
3057 *
3058 *	stopOnFalse:	interrupt callings when a callback returns false
3059 *
3060 */
3061jQuery.Callbacks = function( options ) {
3062
3063	// Convert options from String-formatted to Object-formatted if needed
3064	// (we check in cache first)
3065	options = typeof options === "string" ?
3066		( optionsCache[ options ] || createOptions( options ) ) :
3067		jQuery.extend( {}, options );
3068
3069	var // Last fire value (for non-forgettable lists)
3070		memory,
3071		// Flag to know if list was already fired
3072		fired,
3073		// Flag to know if list is currently firing
3074		firing,
3075		// First callback to fire (used internally by add and fireWith)
3076		firingStart,
3077		// End of the loop when firing
3078		firingLength,
3079		// Index of currently firing callback (modified by remove if needed)
3080		firingIndex,
3081		// Actual callback list
3082		list = [],