https://www.durhamnephrology.com/wp-content/themes/durham/js/bundle.js

213ict mode should be common
214// enough that all such attempts are guarded in a try block.
215"use strict";
216
217var arr = [];
218
219var document = window.document;
220
221var getProto = Object.getPrototypeOf;
222
223var slice = arr.slice;
224
225var concat = arr.concat;
226
227var push = arr.push;
228
229var indexOf = arr.indexOf;
230
231var class2type = {};
232
233var toString = class2type.toString;
234
235var hasOwn = class2type.hasOwnProperty;
236
237var fnToString = hasOwn.toString;
238
239var ObjectFunctionString = fnToString.call( Object );
240
241var support = {};
242
243
244
245	function DOMEval( code, doc ) {
246		doc = doc || document;
247
248		var script = doc.createElement( "script" );
249
250		script.text = code;
251		doc.head.appendChild( script ).parentNode.removeChild( script );
252	}
253/* global Symbol */
254// Defining this global in .eslintrc.json would create a danger of using the global
255// unguarded in another place, it seems safer to define global only for this module
256
257
258
259var
260	version = "3.2.1",
261
262	// Define a local copy of jQuery
263	jQuery = function( selector, context ) {
264
265		// The jQuery object is actually just the init constructor 'enhanced'
266		// Need init if jQuery is called (just allow error to be thrown if not included)
267		return new jQuery.fn.init( selector, context );
268	},
269
270	// Support: Android <=4.0 only
271	// Make sure we trim BOM and NBSP
272	rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g,
273
274	// Matches dashed string for camelizing
275	rmsPrefix = /^-ms-/,
276	rdashAlpha = /-([a-z])/g,
277
278	// Used by jQuery.camelCase as callback to replace()
279	fcamelCase = function( all, letter ) {
280		return letter.toUpperCase();
281	};
282
283jQuery.fn = jQuery.prototype = {
284
285	// The current version of jQuery being used
286	jquery: version,
287
288	constructor: jQuery,
289
290	// The default length of a jQuery object is 0
291	length: 0,
292
293	toArray: function() {
294		return slice.call( this );
295	},
296
297	// Get the Nth element in the matched element set OR
298	// Get the whole matched element set as a clean array
299	get: function( num ) {
300
301		// Return all the elements in a clean array
302		if ( num == null ) {
303			return slice.call( this );
304		}
305
306		// Return just the one element from the set
307		return num < 0 ? this[ num + this.length ] : this[ num ];
308	},
309
310	// Take an array of elements and push it onto the stack
311	// (returning the new matched element set)
312	pushStack: function( elems ) {
313
314		// Build a new jQuery matched element set
315		var ret = jQuery.merge( this.constructor(), elems );
316
317		// Add the old object onto the stack (as a reference)
318		ret.prevObject = this;
319
320		// Return the newly-formed element set
321		return ret;
322	},
323
324	// Execute a callback for every element in the matched set.
325	each: function( callback ) {
326		return jQuery.each( this, callback );
327	},
328
329	map: function( callback ) {
330		return this.pushStack( jQuery.map( this, function( elem, i ) {
331			return callback.call( elem, i, elem );
332		} ) );
333	},
334
335	slice: function() {
336		return this.pushStack( slice.apply( this, arguments ) );
337	},
338
339	first: function() {
340		return this.eq( 0 );
341	},
342
343	last: function() {
344		return this.eq( -1 );
345	},
346
347	eq: function( i ) {
348		var len = this.length,
349			j = +i + ( i < 0 ? len : 0 );
350		return this.pushStack( j >= 0 && j < len ? [ this[ j ] ] : [] );
351	},
352
353	end: function() {
354		return this.prevObject || this.constructor();
355	},
356
357	// For internal use only.
358	// Behaves like an Array's method, not like a jQuery method.
359	push: push,
360	sort: arr.sort,
361	splice: arr.splice
362};
363
364jQuery.extend = jQuery.fn.extend = function() {
365	var options, name, src, copy, copyIsArray, clone,
366		target = arguments[ 0 ] || {},
367		i = 1,
368		length = arguments.length,
369		deep = false;
370
371	// Handle a deep copy situation
372	if ( typeof target === "boolean" ) {
373		deep = target;
374
375		// Skip the boolean and the target
376		target = arguments[ i ] || {};
377		i++;
378	}
379
380	// Handle case when target is a string or something (possible in deep copy)
381	if ( typeof target !== "object" && !jQuery.isFunction( target ) ) {
382		target = {};
383	}
384
385	// Extend jQuery itself if only one argument is passed
386	if ( i === length ) {
387		target = this;
388		i--;
389	}
390
391	for ( ; i < length; i++ ) {
392
393		// Only deal with non-null/undefined values
394		if ( ( options = arguments[ i ] ) != null ) {
395
396			// Extend the base object
397			for ( name in options ) {
398				src = target[ name ];
399				copy = options[ name ];
400
401				// Prevent never-ending loop
402				if ( target === copy ) {
403					continue;
404				}
405
406				// Recurse if we're merging plain objects or arrays
407				if ( deep && copy && ( jQuery.isPlainObject( copy ) ||
408					( copyIsArray = Array.isArray( copy ) ) ) ) {
409
410					if ( copyIsArray ) {
411						copyIsArray = false;
412						clone = src && Array.isArray( src ) ? src : [];
413
414					} else {
415						clone = src && jQuery.isPlainObject( src ) ? src : {};
416					}
417
418					// Never move original objects, clone them
419					target[ name ] = jQuery.extend( deep, clone, copy );
420
421				// Don't bring in undefined values
422				} else if ( copy !== undefined ) {
423					target[ name ] = copy;
424				}
425			}
426		}
427	}
428
429	// Return the modified object
430	return target;
431};
432
433jQuery.extend( {
434
435	// Unique for each copy of jQuery on the page
436	expando: "jQuery" + ( version + Math.random() ).replace( /\D/g, "" ),
437
438	// Assume jQuery is ready without the ready module
439	isReady: true,
440
441	error: function( msg ) {
442		throw new Error( msg );
443	},
444
445	noop: function() {},
446
447	isFunction: function( obj ) {
448		return jQuery.type( obj ) === "function";
449	},
450
451	isWindow: function( obj ) {
452		return obj != null && obj === obj.window;
453	},
454
455	isNumeric: function( obj ) {
456
457		// As of jQuery 3.0, isNumeric is limited to
458		// strings and numbers (primitives or objects)
459		// that can be coerced to finite numbers (gh-2662)
460		var type = jQuery.type( obj );
461		return ( type === "number" || type === "string" ) &&
462
463			// parseFloat NaNs numeric-cast false positives ("")
464			// ...but misinterprets leading-number strings, particularly hex literals ("0x...")
465			// subtraction forces infinities to NaN
466			!isNaN( obj - parseFloat( obj ) );
467	},
468
469	isPlainObject: function( obj ) {
470		var proto, Ctor;
471
472		// Detect obvious negatives
473		// Use toString instead of jQuery.type to catch host objects
474		if ( !obj || toString.call( obj ) !== "[object Object]" ) {
475			return false;
476		}
477
478		proto = getProto( obj );
479
480		// Objects with no prototype (e.g., `Object.create( null )`) are plain
481		if ( !proto ) {
482			return true;
483		}
484
485		// Objects with prototype are plain iff they were constructed by a global Object function
486		Ctor = hasOwn.call( proto, "constructor" ) && proto.constructor;
487		return typeof Ctor === "function" && fnToString.call( Ctor ) === ObjectFunctionString;
488	},
489
490	isEmptyObject: function( obj ) {
491
492		/* eslint-disable no-unused-vars */
493		// See https://github.com/eslint/eslint/issues/6125
494		var name;
495
496		for ( name in obj ) {
497			return false;
498		}
499		return true;
500	},
501
502	type: function( obj ) {
503		if ( obj == null ) {
504			return obj + "";
505		}
506
507		// Support: Android <=2.3 only (functionish RegExp)
508		return typeof obj === "object" || typeof obj === "function" ?
509			class2type[ toString.call( obj ) ] || "object" :
510			typeof obj;
511	},
512
513	// Evaluates a script in a global context
514	globalEval: function( code ) {
515		DOMEval( code );
516	},
517
518	// Convert dashed to camelCase; used by the css and data modules
519	// Support: IE <=9 - 11, Edge 12 - 13
520	// Microsoft forgot to hump their vendor prefix (#9572)
521	camelCase: function( string ) {
522		return string.replace( rmsPrefix, "ms-" ).replace( rdashAlpha, fcamelCase );
523	},
524
525	each: function( obj, callback ) {
526		var length, i = 0;
527
528		if ( isArrayLike( obj ) ) {
529			length = obj.length;
530			for ( ; i < length; i++ ) {
531				if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {
532					break;
533				}
534			}
535		} else {
536			for ( i in obj ) {
537				if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {
538					break;
539				}
540			}
541		}
542
543		return obj;
544	},
545
546	// Support: Android <=4.0 only
547	trim: function( text ) {
548		return text == null ?
549			"" :
550			( text + "" ).replace( rtrim, "" );
551	},
552
553	// results is for internal usage only
554	makeArray: function( arr, results ) {
555		var ret = results || [];
556
557		if ( arr != null ) {
558			if ( isArrayLike( Object( arr ) ) ) {
559				jQuery.merge( ret,
560					typeof arr === "string" ?
561					[ arr ] : arr
562				);
563			} else {
564				push.call( ret, arr );
565			}
566		}
567
568		return ret;
569	},
570
571	inArray: function( elem, arr, i ) {
572		return arr == null ? -1 : indexOf.call( arr, elem, i );
573	},
574
575	// Support: Android <=4.0 only, PhantomJS 1 only
576	// push.apply(_, arraylike) throws on ancient WebKit
577	merge: function( first, second ) {
578		var len = +second.length,
579			j = 0,
580			i = first.length;
581
582		for ( ; j < len; j++ ) {
583			first[ i++ ] = second[ j ];
584		}
585
586		first.length = i;
587
588		return first;
589	},
590
591	grep: function( elems, callback, invert ) {
592		var callbackInverse,
593			matches = [],
594			i = 0,
595			length = elems.length,
596			callbackExpect = !invert;
597
598		// Go through the array, only saving the items
599		// that pass the validator function
600		for ( ; i < length; i++ ) {
601			callbackInverse = !callback( elems[ i ], i );
602			if ( callbackInverse !== callbackExpect ) {
603				matches.push( elems[ i ] );
604			}
605		}
606
607		return matches;
608	},
609
610	// arg is for internal usage only
611	map: function( elems, callback, arg ) {
612		var length, value,
613			i = 0,
614			ret = [];
615
616		// Go through the array, translating each of the items to their new values
617		if ( isArrayLike( elems ) ) {
618			length = elems.length;
619			for ( ; i < length; i++ ) {
620				value = callback( elems[ i ], i, arg );
621
622				if ( value != null ) {
623					ret.push( value );
624				}
625			}
626
627		// Go through every key on the object,
628		} else {
629			for ( i in elems ) {
630				value = callback( elems[ i ], i, arg );
631
632				if ( value != null ) {
633					ret.push( value );
634				}
635			}
636		}
637
638		// Flatten any nested arrays
639		return concat.apply( [], ret );
640	},
641
642	// A global GUID counter for objects
643	guid: 1,
644
645	// Bind a function to a context, optionally partially applying any
646	// arguments.
647	proxy: function( fn, context ) {
648		var tmp, args, proxy;
649
650		if ( typeof context === "string" ) {
651			tmp = fn[ context ];
652			context = fn;
653			fn = tmp;
654		}
655
656		// Quick check to determine if target is callable, in the spec
657		// this throws a TypeError, but we will just return undefined.
658		if ( !jQuery.isFunction( fn ) ) {
659			return undefined;
660		}
661
662		// Simulated bind
663		args = slice.call( arguments, 2 );
664		proxy = function() {
665			return fn.apply( context || this, args.concat( slice.call( arguments ) ) );
666		};
667
668		// Set the guid of unique handler to the same of original handler, so it can be removed
669		proxy.guid = fn.guid = fn.guid || jQuery.guid++;
670
671		return proxy;
672	},
673
674	now: Date.now,
675
676	// jQuery.support is not used in Core but other projects attach their
677	// properties to it so it needs to exist.
678	support: support
679} );
680
681if ( typeof Symbol === "function" ) {
682	jQuery.fn[ Symbol.iterator ] = arr[ Symbol.iterator ];
683}
684
685// Populate the class2type map
686jQuery.each( "Boolean Number String Function Array Date RegExp Object Error Symbol".split( " " ),
687function( i, name ) {
688	class2type[ "[object " + name + "]" ] = name.toLowerCase();
689} );
690
691function isArrayLike( obj ) {
692
693	// Support: real iOS 8.2 only (not reproducible in simulator)
694	// `in` check used to prevent JIT error (gh-2145)
695	// hasOwn isn't used here due to false negatives
696	// regarding Nodelist length in IE
697	var length = !!obj && "length" in obj && obj.length,
698		type = jQuery.type( obj );
699
700	if ( type === "function" || jQuery.

700isWindow( obj ) ) {
701		return false;
702	}
703
704	return type === "array" || length === 0 ||
705		typeof length === "number" && length > 0 && ( length - 1 ) in obj;
706}
707var Sizzle =
708/*!
709 * Sizzle CSS Selector Engine v2.3.3
710 * https://sizzlejs.com/
711 *
712 * Copyright jQuery Foundation and other contributors
713 * Released under the MIT license
714 * http://jquery.org/license
715 *
716 * Date: 2016-08-08
717 */
718(function( window ) {
719
720var i,
721	support,
722	Expr,
723	getText,
724	isXML,
725	tokenize,
726	compile,
727	select,
728	outermostContext,
729	sortInput,
730	hasDuplicate,
731
732	// Local document vars
733	setDocument,
734	document,
735	docElem,
736	documentIsHTML,
737	rbuggyQSA,
738	rbuggyMatches,
739	matches,
740	contains,
741
742	// Instance-specific data
743	expando = "sizzle" + 1 * new Date(),
744	preferredDoc = window.document,
745	dirruns = 0,
746	done = 0,
747	classCache = createCache(),
748	tokenCache = createCache(),
749	compilerCache = createCache(),
750	sortOrder = function( a, b ) {
751		if ( a === b ) {
752			hasDuplicate = true;
753		}
754		return 0;
755	},
756
757	// Instance methods
758	hasOwn = ({}).hasOwnProperty,
759	arr = [],
760	pop = arr.pop,
761	push_native = arr.push,
762	push = arr.push,
763	slice = arr.slice,
764	// Use a stripped-down indexOf as it's faster than native
765	// https://jsperf.com/thor-indexof-vs-for/5
766	indexOf = function( list, elem ) {
767		var i = 0,
768			len = list.length;
769		for ( ; i < len; i++ ) {
770			if ( list[i] === elem ) {
771				return i;
772			}
773		}
774		return -1;
775	},
776
777	booleans = "checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped",
778
779	// Regular expressions
780
781	// http://www.w3.org/TR/css3-selectors/#whitespace
782	whitespace = "[\\x20\\t\\r\\n\\f]",
783
784	// http://www.w3.org/TR/CSS21/syndata.html#value-def-identifier
785	identifier = "(?:\\\\.|[\\w-]|[^\0-\\xa0])+",
786
787	// Attribute selectors: http://www.w3.org/TR/selectors/#attribute-selectors
788	attributes = "\\[" + whitespace + "*(" + identifier + ")(?:" + whitespace +
789		// Operator (capture 2)
790		"*([*^$|!~]?=)" + whitespace +
791		// "Attribute values must be CSS identifiers [capture 5] or strings [capture 3 or capture 4]"
792		"*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|(" + identifier + "))|)" + whitespace +
793		"*\\]",
794
795	pseudos = ":(" + identifier + ")(?:\\((" +
796		// To reduce the number of selectors needing tokenize in the preFilter, prefer arguments:
797		// 1. quoted (capture 3; capture 4 or capture 5)
798		"('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|" +
799		// 2. simple (capture 6)
800		"((?:\\\\.|[^\\\\()[\\]]|" + attributes + ")*)|" +
801		// 3. anything else (capture 2)
802		".*" +
803		")\\)|)",
804
805	// Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter
806	rwhitespace = new RegExp( whitespace + "+", "g" ),
807	rtrim = new RegExp( "^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" + whitespace + "+$", "g" ),
808
809	rcomma = new RegExp( "^" + whitespace + "*," + whitespace + "*" ),
810	rcombinators = new RegExp( "^" + whitespace + "*([>+~]|" + whitespace + ")" + whitespace + "*" ),
811
812	rattributeQuotes = new RegExp( "=" + whitespace + "*([^\\]'\"]*?)" + whitespace + "*\\]", "g" ),
813
814	rpseudo = new RegExp( pseudos ),
815	ridentifier = new RegExp( "^" + identifier + "$" ),
816
817	matchExpr = {
818		"ID": new RegExp( "^#(" + identifier + ")" ),
819		"CLASS": new RegExp( "^\\.(" + identifier + ")" ),
820		"TAG": new RegExp( "^(" + identifier + "|[*])" ),
821		"ATTR": new RegExp( "^" + attributes ),
822		"PSEUDO": new RegExp( "^" + pseudos ),
823		"CHILD": new RegExp( "^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(" + whitespace +
824			"*(even|odd|(([+-]|)(\\d*)n|)" + whitespace + "*(?:([+-]|)" + whitespace +
825			"*(\\d+)|))" + whitespace + "*\\)|)", "i" ),
826		"bool": new RegExp( "^(?:" + booleans + ")$", "i" ),
827		// For use in libraries implementing .is()
828		// We use this for POS matching in `select`
829		"needsContext": new RegExp( "^" + whitespace + "*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(" +
830			whitespace + "*((?:-\\d)?\\d*)" + whitespace + "*\\)|)(?=[^-]|$)", "i" )
831	},
832
833	rinputs = /^(?:input|select|textarea|button)$/i,
834	rheader = /^h\d$/i,
835
836	rnative = /^[^{]+\{\s*\[native \w/,
837
838	// Easily-parseable/retrievable ID or TAG or CLASS selectors
839	rquickExpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,
840
841	rsibling = /[+~]/,
842
843	// CSS escapes
844	// http://www.w3.org/TR/CSS21/syndata.html#escaped-characters
845	runescape = new RegExp( "\\\\([\\da-f]{1,6}" + whitespace + "?|(" + whitespace + ")|.)", "ig" ),
846	funescape = function( _, escaped, escapedWhitespace ) {
847		var high = "0x" + escaped - 0x10000;
848		// NaN means non-codepoint
849		// Support: Firefox<24
850		// Workaround erroneous numeric interpretation of +"0x"
851		return high !== high || escapedWhitespace ?
852			escaped :
853			high < 0 ?
854				// BMP codepoint
855				String.fromCharCode( high + 0x10000 ) :
856				// Supplemental Plane codepoint (surrogate pair)
857				String.fromCharCode( high >> 10 | 0xD800, high & 0x3FF | 0xDC00 );
858	},
859
860	// CSS string/identifier serialization
861	// https://drafts.csswg.org/cssom/#common-serializing-idioms
862	rcssescape = /([\0-\x1f\x7f]|^-?\d)|^-$|[^\0-\x1f\x7f-\uFFFF\w-]/g,
863	fcssescape = function( ch, asCodePoint ) {
864		if ( asCodePoint ) {
865
866			// U+0000 NULL becomes U+FFFD REPLACEMENT CHARACTER
867			if ( ch === "\0" ) {
868				return "\uFFFD";
869			}
870
871			// Control characters and (dependent upon position) numbers get escaped as code points
872			return ch.slice( 0, -1 ) + "\\" + ch.charCodeAt( ch.length - 1 ).toString( 16 ) + " ";
873		}
874
875		// Other potentially-special ASCII characters get backslash-escaped
876		return "\\" + ch;
877	},
878
879	// Used for iframes
880	// See setDocument()
881	// Removing the function wrapper causes a "Permission Denied"
882	// error in IE
883	unloadHandler = function() {
884		setDocument();
885	},
886
887	disabledAncestor = addCombinator(
888		function( elem ) {
889			return elem.disabled === true && ("form" in elem || "label" in elem);
890		},
891		{ dir: "parentNode", next: "legend" }
892	);
893
894// Optimize for push.apply( _, NodeList )
895try {
896	push.apply(
897		(arr = slice.call( preferredDoc.childNodes )),
898		preferredDoc.childNodes
899	);
900	// Support: Android<4.0
901	// Detect silently failing push.apply
902	arr[ preferredDoc.childNodes.length ].nodeType;
903} catch ( e ) {
904	push = { apply: arr.length ?
905
906		// Leverage slice if possible
907		function( target, els ) {
908			push_native.apply( target, slice.call(els) );
909		} :
910
911		// Support: IE<9
912		// Otherwise append directly
913		function( target, els ) {
914			var j = target.length,
915				i = 0;
916			// Can't trust NodeList.length
917			while ( (target[j++] = els[i++]) ) {}
918			target.length = j - 1;
919		}
920	};
921}
922
923function Sizzle( selector, context, results, seed ) {
924	var m, i, elem, nid, match, groups, newSelector,
925		newContext = context && context.ownerDocument,
926
927		// nodeType defaults to 9, since context defaults to document
928		nodeType = context ? context.nodeType : 9;
929
930	results = results || [];
931
932	// Return early from calls with invalid selector or context
933	if ( typeof selector !== "string" || !selector ||
934		nodeType !== 1 && nodeType !== 9 && nodeType !== 11 ) {
935
936		return results;
937	}
938
939	// Try to shortcut find operations (as opposed to filters) in HTML documents
940	if ( !seed ) {
941
942		if ( ( context ? context.ownerDocument || context : preferredDoc ) !== document ) {
943			setDocument( context );
944		}
945		context = context || document;
946
947		if ( documentIsHTML ) {
948
949			// If the selector is sufficiently simple, try using a "get*By*" DOM method
950			// (excepting DocumentFragment context, where the methods don't exist)
951			if ( nodeType !== 11 && (match = rquickExpr.exec( selector )) ) {
952
953				// ID selector
954				if ( (m = match[1]) ) {
955
956					// Document context
957					if ( nodeType === 9 ) {
958						if ( (elem = context.getElementById( m )) ) {
959
960							// Support: IE, Opera, Webkit
961							// TODO: identify versions
962							// getElementById can match elements by name instead of ID
963							if ( elem.id === m ) {
964								results.push( elem );
965								return results;
966							}
967						} else {
968							return results;
969						}
970
971					// Element context
972					} else {
973
974						// Support: IE, Opera, Webkit
975						// TODO: identify versions
976						// getElementById can match elements by name instead of ID
977						if ( newContext && (elem = newContext.getElementById( m )) &&
978							contains( context, elem ) &&
979							elem.id === m ) {
980
981							results.push( elem );
982							return results;
983						}
984					}
985
986				// Type selector
987				} else if ( match[2] ) {
988					push.apply( results, context.getElementsByTagName( selector ) );
989					return results;
990
991				// Class selector
992				} else if ( (m = match[3]) && support.getElementsByClassName &&
993					context.getElementsByClassName ) {
994
995					push.apply( results, context.getElementsByClassName( m ) );
996					return results;
997				}
998			}
999
1000			// Take advantage of querySelectorAll
1001			if ( support.qsa &&
1002				!compilerCache[ selector + " " ] &&
1003				(!rbuggyQSA || !rbuggyQSA.test( selector )) ) {
1004
1005				if ( nodeType !== 1 ) {
1006					newContext = context;
1007					newSelector = selector;
1008
1009				// qSA looks outside Element context, which is not what we want
1010				// Thanks to Andrew Dupont for this workaround technique
1011				// Support: IE <=8
1012				// Exclude object elements
1013				} else if ( context.nodeName.toLowerCase() !== "object" ) {
1014
1015					// Capture the context ID, setting it first if necessary
1016					if ( (nid = context.getAttribute( "id" )) ) {
1017						nid = nid.replace( rcssescape, fcssescape );
1018					} else {
1019						context.setAttribute( "id", (nid = expando) );
1020					}
1021
1022					// Prefix every selector in the list
1023					groups = tokenize( selector );
1024					i = groups.length;
1025					while ( i-- ) {
1026						groups[i] = "#" + nid + " " + toSelector( groups[i] );
1027					}
1028					newSelector = groups.join( "," );
1029
1030					// Expand context for sibling selectors
1031					newContext = rsibling.test( selector ) && testContext( context.parentNode ) ||
1032						context;
1033				}
1034
1035				if ( newSelector ) {
1036					try {
1037						push.apply( results,
1038							newContext.querySelectorAll( newSelector )
1039						);
1040						return results;
1041					} catch ( qsaError ) {
1042					} finally {
1043						if ( nid === expando ) {
1044							context.removeAttribute( "id" );
1045						}
1046					}
1047				}
1048			}
1049		}
1050	}
1051
1052	// All others
1053	return select( selector.replace( rtrim, "$1" ), context, results, seed );
1054}
1055
1056/**
1057 * Create key-value caches of limited size
1058 * @returns {function(string, object)} Returns the Object data after storing it on itself with
1059 *	property name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength)
1060 *	deleting the oldest entry
1061 */
1062function createCache() {
1063	var keys = [];
1064
1065	function cache( key, value ) {
1066		// Use (key + " ") to avoid collision with native prototype properties (see Issue #157)
1067		if ( keys.push( key + " " ) > Expr.cacheLength ) {
1068			// Only keep the most recent entries
1069			delete cache[ keys.shift() ];
1070		}
1071		return (cache[ key + " " ] = value);
1072	}
1073	return cache;
1074}
1075
1076/**
1077 * Mark a function for special use by Sizzle
1078 * @param {Function} fn The function to mark
1079 */
1080function markFunction( fn ) {
1081	fn[ expando ] = true;
1082	return fn;
1083}
1084
1085/**
1086 * Support testing using an element
1087 * @param {Function} fn Passed the created element and returns a boolean result
1088 */
1089function assert( fn ) {
1090	var el = document.createElement("fieldset");
1091
1092	try {
1093		return !!fn( el );
1094	} catch (e) {
1095		return false;
1096	} finally {
1097		// Remove from its parent by default
1098		if ( el.parentNode ) {
1099			el.parentNode.removeChild( el );
1100		}
1101		// release memory in IE
1102		el = null;
1103	}
1104}
1105
1106/**
1107 * Adds the same handler for all of the specified attrs
1108 * @param {String} attrs Pipe-separated list of attributes
1109 * @param {Function} handler The method that will be applied
1110 */
1111function addHandle( attrs, handler ) {
1112	var arr = attrs.split("|"),
1113		i = arr.length;
1114
1115	while ( i-- ) {
1116		Expr.attrHandle[ arr[i] ] = handler;
1117	}
1118}
1119
1120/**
1121 * Checks document order of two siblings
1122 * @param {Element} a
1123 * @param {Element} b
1124 * @returns {Number} Returns less than 0 if a precedes b, greater than 0 if a follows b
1125 */
1126function siblingCheck( a, b ) {
1127	var cur = b && a,
1128		diff = cur && a.nodeType === 1 && b.nodeType === 1 &&
1129			a.sourceIndex - b.sourceIndex;
1130
1131	// Use IE sourceIndex if available on both nodes
1132	if ( diff ) {
1133		return diff;
1134	}
1135
1136	// Check if b follows a
1137	if ( cur ) {
1138		while ( (cur = cur.nextSibling) ) {
1139			if ( cur === b ) {
1140				return -1;
1141			}
1142		}
1143	}
1144
1145	return a ? 1 : -1;
1146}
1147
1148/**
1149 * Returns a function to use in pseudos for input types
1150 * @param {String} type
1151 */
1152function createInputPseudo( type ) {
1153	return function( elem ) {
1154		var name = elem.nodeName.toLowerCase();
1155		return name === "input" && elem.type === type;
1156	};
1157}
1158
1159/**
1160 * Returns a function to use in pseudos for buttons
1161 * @param {String} type
1162 */
1163function createButtonPseudo( type ) {
1164	return function( elem ) {
1165		var name = elem.nodeName.toLowerCase();
1166		return (name === "input" || name === "button") && elem.type === type;
1167	};
1168}
1169
1170/**
1171 * Returns a function to use in pseudos for :enabled/:disabled
1172 * @param {Boolean} disabled true for :disabled; false for :enabled
1173 */
1174function createDisabledPseudo( disabled ) {
1175
1176	// Known :disabled false positives: fieldset[disabled] > legend:nth-of-type(n+2) :can-disable
1177	return function( elem ) {
1178
1179		// Only certain elements can match :enabled or :disabled
1180		// https://html.spec.whatwg.org/multipage/scripting.html#selector-enabled
1181		// https://html.spec.whatwg.org/multipage/scripting.html#selector-disabled
1182		if ( "form" in elem ) {
1183
1184			// Check for inherited disabledness on relevant non-disabled elements:
1185			// * listed form-associated elements in a disabled fieldset
1186			//   https://html.spec.whatwg.org/multipage/forms.html#category-listed
1187			//   https://html.spec.whatwg.org/multipage/forms.html#concept-fe-disabled
1188			// * option elements in a disabled optgroup
1189			//   https://html.spec.whatwg.org/multipage/forms.html#concept-option-disabled
1190			// All such elements have a "form" property.
1191			if ( elem.parentNode && elem.disabled === false ) {
1192
1193				// Option elements defer to a parent optgroup if present
1194				if ( "label" in elem ) {
1195					if ( "label" in elem.parentNode ) {
1196						return elem.parentNode.disabled === disabled;
1197					} else {
1198						return elem.disabled === disabled;
1199					}
1200				}
1201
1202				// Support: IE 6 - 11
1203				// Use the isDisabled shortcut property to check for disabled fieldset ancestors
1204				return elem.isDisabled === disabled ||
1205
1206					// Where there is no isDisabled, check manually
1207					/* jshint -W018 */
1208					elem.isDisabled !== !disabled &&
1209						disabledAncestor( elem ) === disabled;
1210			}
1211
1212			return elem.disabled === disabled;
1213
1214		// Try to winnow out elements that can't be disabled before trusting the disabled property.
1215		// Some victims get caught in our net (label, legend, menu, track), but it shouldn't
1216		// even exist on them, let alone have a boolean value.
1217		} else if ( "label" in elem ) {
1218			return elem.disabled === disabled;
1219		}
1220
1221		// Remaining elements are neither :enabled nor :disabled
1222		return false;
1223	};
1224}
1225
1226/**
1227 * Returns a function to use in pseudos for positionals
1228 * @param {Function} fn
1229 */
1230function createPositionalPseudo( fn ) {
1231	return markFunction(function( argument ) {
1232		argument = +argument;
1233		return markFunction(function( seed, matches ) {
1234			var j,
1235				matchIndexes = fn( [], seed.length, argument ),
1236				i = matchIndexes.length;
1237
1238			// Match elements found at the specified indexes
1239			while ( i-- ) {
1240				if ( seed[ (j = matchIndexes[i]) ] ) {
1241					seed[j] = !(matches[j] = seed[j]);
1242				}
1243			}
1244		});
1245	});
1246}
1247
1248/**
1249 * Checks a node for validity as a Sizzle context
1250 * @param {Element|Object=} context
1251 * @returns {Element|Object|Boolean} The input node if acceptable, otherwise a falsy value
1252 */
1253function testContext( context ) {
1254	return context && typeof context.getElementsByTagName !== "undefined" && context;
1255}
1256
1257// Expose support vars for convenience
1258support = Sizzle.support = {};
1259
1260/**
1261 * Detects XML nodes
1262 * @param {Element|Object} elem An element or a document
1263 * @returns {Boolean} True iff elem is a non-HTML XML node
1264 */
1265isXML = Sizzle.isXML = function( elem ) {
1266	// documentElement is verified for cases where it doesn't yet exist
1267	// (such as loading iframes in IE - #4833)
1268	var documentElement = elem && (elem.ownerDocument || elem).documentElement;
1269	return documentElement ? documentElement.nodeName !== "HTML" : false;
1270};
1271
1272/**
1273 * Sets document-related variables once based on the current document
1274 * @param {Element|Object} [doc] An element or document object to use to set the document
1275 * @returns {Object} Returns the current document
1276 */
1277setDocument = Sizzle.setDocument = function( node ) {
1278	var hasCompare, subWindow,
1279		doc = node ? node.ownerDocument || node : preferredDoc;
1280
1281	// Return early if doc is invalid or already selected
1282	if ( doc === document || doc.nodeType !== 9 || !doc.documentElement ) {
1283		return document;
1284	}
1285
1286	// Update global variables
1287	document = doc;
1288	docElem = document.documentElement;
1289	documentIsHTML = !isXML( document );
1290
1291	// Support: IE 9-11, Edge
1292	// Accessing iframe documents after unload throws "permission denied" errors (jQuery #13936)
1293	if ( preferredDoc !== document &&
1294		(subWindow = document.defaultView) && subWindow.top !== subWindow ) {
1295
1296		// Support: IE 11, Edge
1297		if ( subWindow.addEventListener ) {
1298			subWindow.addEventListener( "unload", unloadHandler, false );
1299
1300		// Support: IE 9 - 10 only
1301		} else if ( subWindow.attachEvent ) {
1302			subWindow.attachEvent( "onunload", unloadHandler );
1303		}
1304	}
1305
1306	/* Attributes
1307	---------------------------------------------------------------------- */
1308
1309	// Support: IE<8
1310	// Verify that getAttribute really returns attributes and not properties
1311	// (excepting IE8 booleans)
1312	support.attributes = assert(function( el ) {
1313		el.className = "i";
1314		return !el.getAttribute("className");
1315	});
1316
1317	/* getElement(s)By*
1318	---------------------------------------------------------------------- */
1319
1320	// Check if getElementsByTagName("*") returns only elements
1321	support.getElementsByTagName = assert(function( el ) {
1322		el.appendChild( document.createComment("") );
1323		return !el.getElementsByTagName("*").length;
1324	});
1325
1326	// Support: IE<9
1327	support.getElementsByClassName = rnative.test( document.getElementsByClassName );
1328
1329	// Support: IE<10
1330	// Check if getElementById returns elements by name
1331	// The broken getElementById methods don't pick up programmatically-set names,
1332	// so use a roundabout getElementsByName test
1333	support.getById = assert(function( el ) {
1334		docElem.appendChild( el ).id = expando;
1335		return !document.getElementsByName || !document.getElementsByName( expando ).length;
1336	});
1337
1338	// ID filter and find
1339	if ( support.getById ) {
1340		Expr.filter["ID"] = function( id ) {
1341			var attrId = id.replace( runescape, funescape );
1342			return function( elem ) {
1343				return elem.getAttribute("id") === attrId;
1344			};
1345		};
1346		Expr.find["ID"] = function( id, context ) {
1347			if ( typeof context.getElementById !== "undefined" && documentIsHTML ) {
1348				var elem = context.getElementById( id );
1349				return elem ? [ elem ] : [];
1350			}
1351		};
1352	} else {
1353		Expr.filter["ID"] =  function( id ) {
1354			var attrId = id.replace( runescape, funescape );
1355			return function( elem ) {
1356				var node = typeof elem.getAttributeNode !== "undefined" &&
1357					elem.getAttributeNode("id");
1358				return node && node.value === attrId;
1359			};
1360		};
1361
1362		// Support: IE 6 - 7 only
1363		// getElementById is not reliable as a find shortcut
1364		Expr.find["ID"] = function( id, context ) {
1365			if ( typeof context.getElementById !== "undefined" && documentIsHTML ) {
1366				var node, i, elems,
1367					elem = context.getElementById( id );
1368
1369				if ( elem ) {
1370
1371					// Verify the id attribute
1372					node = elem.getAttributeNode("id");
1373					if ( node && node.value === id ) {
1374						return [ elem ];
1375					}
1376
1377					// Fall back on getElementsByName
1378					elems = context.getElementsByName( id );
1379					i = 0;
1380					while ( (elem = elems[i++]) ) {
1381						node = elem.getAttributeNode("id");
1382						if ( node && node.value === id ) {
1383							return [ elem ];
1384						}
1385					}
1386				}
1387
1388				return [];
1389			}
1390		};
1391	}
1392
1393	// Tag
1394	Expr.find["TAG"] = support.getElementsByTagName ?
1395		function( tag, context ) {
1396			if ( typeof context.getElementsByTagName !== "undefined" ) {
1397				return context.getElementsByTagName( tag );
1398
1399			// DocumentFragment nodes don't have gEBTN
1400			} else if ( support.qsa ) {
1401				return context.querySelectorAll( tag );
1402			}
1403		} :
1404
1405		function( tag, context ) {
1406			var elem,
1407				tmp = [],
1408				i = 0,
1409				// By happy coincidence, a (broken) gEBTN appears on DocumentFragment nodes too
1410				results = context.getElementsByTagName( tag );
1411
1412			// Filter out possible comments
1413			if ( tag === "*" ) {
1414				while ( (elem = results[i++]) ) {
1415					if ( elem.nodeType === 1 ) {
1416						tmp.push( elem );
1417					}
1418				}
1419
1420				return tmp;
1421			}
1422			return results;
1423		};
1424
1425	// Class
1426	Expr.find["CLASS"] = support.getElementsByClassName && function( className, context ) {
1427		if ( typeof context.getElementsByClassName !== "undefined" && documentIsHTML ) {
1428			return context.getElementsByClassName( className );
1429		}
1430	};
1431
1432	/* QSA/matchesSelector
1433	---------------------------------------------------------------------- */
1434
1435	// QSA and matchesSelector support
1436
1437	// matchesSelector(:active) reports false when true (IE9/Opera 11.5)
1438	rbuggyMatches = [];
1439
1440	// qSa(:focus) reports false when true (Chrome 21)
1441	// We allow this because of a bug in IE8/9 that throws an error
1442	// whenever `document.activeElement` is accessed on an iframe
1443	// So, we allow :focus to pass through QSA all the time to avoid the IE error
1444	// See https://bugs.jquery.com/ticket/13378
1445	rbuggyQSA = [];
1446
1447	if ( (support.qsa = rnative.test( document.querySelectorAll )) ) {
1448		// Build QSA regex
1449		// Regex strategy adopted from Diego Perini
1450		assert(function( el ) {
1451			// Select is set to empty string on purpose
1452			// This is to test IE's treatment of not explicitly
1453			// setting a boolean content attribute,
1454			// since its presence should be enough
1455			// https://bugs.jquery.com/ticket/12359
1456			docElem.appendChild( el ).innerHTML = "<a id='" + expando + "'></a>" +
1457				"<select id='" + expando + "-\r\\' msallowcapture=''>" +
1458				"<option selected=''></option></select>";
1459
1460			// Support: IE8, Opera 11-12.16
1461			// Nothing should be selected when empty strings follow ^= or $= or *=
1462			// The test attribute must be unknown in Opera but "safe" for WinRT
1463			// https://msdn.microsoft.com/en-us/library/ie/hh465388.aspx#attribute_section
1464			if ( el.querySelectorAll("[msallowcapture^='']").length ) {
1465				rbuggyQSA.push( "[*^$]=" + whitespace + "*(?:''|\"\")" );
1466			}
1467
1468			// Support: IE8
1469			// Boolean attributes and "value" are not treated correctly
1470			if ( !el.querySelectorAll("[selected]").length ) {
1471				rbuggyQSA.push( "\\[" + whitespace + "*(?:value|" + booleans + ")" );
1472			}
1473
1474			// Support: Chrome<29, Android<4.4, Safari<7.0+, iOS<7.0+, PhantomJS<1.9.8+
1475			if ( !el.querySelectorAll( "[id~=" + expando + "-]" ).length ) {
1476				rbuggyQSA.push("~=");
1477			}
1478
1479			// Webkit/Opera - :checked should return selected option elements
1480			// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
1481			// IE8 throws error here and will not see later tests
1482			if ( !el.querySelectorAll(":checked").length ) {
1483				rbuggyQSA.push(":checked");
1484			}
1485
1486			// Support: Safari 8+, iOS 8+
1487			// https://bugs.webkit.org/show_bug.cgi?id=136851
1488			// In-page `selector#id sibling-combinator selector` fails
1489			if ( !el.querySelectorAll( "a#" + expando + "+*" ).length ) {
1490				rbuggyQSA.push(".#.+[+~]");
1491			}
1492		});
1493
1494		assert(function( el ) {
1495			el.innerHTML = "<a href='' disabled='disabled'></a>" +
1496				"<select disabled='disabled'><option/></select>";
1497
1498			// Support: Windows 8 Native Apps
1499			// The type and name attributes are restricted during .innerHTML assignment
1500			var input = document.createElement("input");
1501			input.setAttribute( "type", "hidden" );
1502			el.appendChild( input ).setAttribute( "name", "D" );
1503
1504			// Support: IE8
1505			// Enforce case-sensitivity of name attribute
1506			if ( el.querySelectorAll("[name=d]").length ) {
1507				rbuggyQSA.push( "name" + whitespace + "*[*^$|!~]?=" );
1508			}
1509
1510			// FF 3.5 - :enabled/:disabled and hidden elements (hidden elements are still enabled)
1511			// IE8 throws error here and will not see later tests
1512			if ( el.querySelectorAll(":enabled").length !== 2 ) {
1513				rbuggyQSA.push( ":enabled", ":disabled" );
1514			}
1515
1516			// Support: IE9-11+
1517			// IE's :disabled selector does not pick up the children of disabled fieldsets
1518			docElem.appendChild( el ).disabled = true;
1519			if ( el.querySelectorAll(":disabled").length !== 2 ) {
1520				rbuggyQSA.push( ":enabled", ":disabled" );
1521			}
1522
1523			// Opera 10-11 does not throw on post-comma invalid pseudos
1524			el.querySelectorAll("*,:x");
1525			rbuggyQSA.push(",.*:");
1526		});
1527	}
1528
1529	if ( (support.matchesSelector = rnative.test( (matches = docElem.matches ||
1530		docElem.webkitMatchesSelector ||
1531		docElem.mozMatchesSelector ||
1532		docElem.oMatchesSelector ||
1533		docElem.msMatchesSelector) )) ) {
1534
1535		assert(function( el ) {
1536			// Check to see if it's possible to do matchesSelector
1537			// on a disconnected node (IE 9)
1538			support.disconnectedMatch = matches.call( el, "*" );
1539
1540			// This should fail with an exception
1541			// Gecko does not error, returns false instead
1542			matches.call( el, "[s!='']:x" );
1543			rbuggyMatches.push( "!=", pseudos );
1544		});
1545	}
1546
1547	rbuggyQSA = rbuggyQSA.length && new RegExp( rbuggyQSA.join("|") );
1548	rbuggyMatches = rbuggyMatches.length && new RegExp( rbuggyMatches.join("|") );
1549
1550	/* Contains
1551	---------------------------------------------------------------------- */
1552	hasCompare = rnative.test( docElem.compareDocumentPosition );
1553
1554	// Element contains another
1555	// Purposefully self-exclusive
1556	// As in, an element does not contain itself
1557	contains = hasCompare || rnative.test( docElem.contains ) ?
1558		function( a, b ) {
1559			var adown = a.nodeType === 9 ? a.documentElement : a,
1560				bup = b && b.parentNode;
1561			return a === bup || !!( bup && bup.nodeType === 1 && (
1562				adown.contains ?
1563					adown.contains( bup ) :
1564					a.compareDocumentPosition && a.compareDocumentPosition( bup ) & 16
1565			));
1566		} :
1567		function( a, b ) {
1568			if ( b ) {
1569				while ( (b = b.parentNode) ) {
1570					if ( b === a ) {
1571						return true;
1572					}
1573				}
1574			}
1575			return false;
1576		};
1577
1578	/* Sorting
1579	---------------------------------------------------------------------- */
1580
1581	// Document order sorting
1582	sortOrder = hasCompare ?
1583	function( a, b ) {
1584
1585		// Flag for duplicate removal
1586		if ( a === b ) {
1587			hasDuplicate = true;
1588			return 0;
1589		}
1590
1591		// Sort on method existence if only one input has compareDocumentPosition
1592		var compare = !a.compareDocumentPosition - !b.compareDocumentPosition;
1593		if ( compare ) {
1594			return compare;
1595		}
1596
1597		// Calculate position if both inputs belong to the same document
1598		compare = ( a.ownerDocument || a ) === ( b.ownerDocument || b ) ?
1599			a.compareDocumentPosition( b ) :
1600
1601			// Otherwise we know they are disconnected
1602			1;
1603
1604		// Disconnected nodes
1605		if ( compare & 1 ||
1606			(!support.sortDetached && b.compareDocumentPosition( a ) === compare) ) {
1607
1608			// Choose the first element that is related to our preferred document
1609			if ( a === document || a.ownerDocument === preferredDoc && contains(preferredDoc, a) ) {
1610				return -1;
1611			}
1612			if ( b === document || b.ownerDocument === preferredDoc && contains(preferredDoc, b) ) {
1613				return 1;
1614			}
1615
1616			// Maintain original order
1617			return sortInput ?
1618				( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) :
1619				0;
1620		}
1621
1622		return compare & 4 ? -1 : 1;
1623	} :
1624	function( a, b ) {
1625		// Exit early if the nodes are identical
1626		if ( a === b ) {
1627			hasDuplicate = true;
1628			return 0;
1629		}
1630
1631		var cur,
1632			i = 0,
1633			aup = a.parentNode,
1634			bup = b.parentNode,
1635			ap = [ a ],
1636			bp = [ b ];
1637
1638		// Parentless nodes are either documents or disconnected
1639		if ( !aup || !bup ) {
1640			return a === document ? -1 :
1641				b === document ? 1 :
1642				aup ? -1 :
1643				bup ? 1 :
1644				sortInput ?
1645				( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) :
1646				0;
1647
1648		// If the nodes are siblings, we can do a quick check
1649		} else if ( aup === bup ) {
1650			return siblingCheck( a, b );
1651		}
1652
1653		// Otherwise we need full lists of their ancestors for comparison
1654		cur = a;
1655		while ( (cur = cur.parentNode) ) {
1656			ap.unshift( cur );
1657		}
1658		cur = b;
1659		while ( (cur = cur.parentNode) ) {
1660			bp.unshift( cur );
1661		}
1662
1663		// Walk down the tree looking for a discrepancy
1664		while ( ap[i] === bp[i] ) {
1665			i++;
1666		}
1667
1668		return i ?
1669			// Do a sibling check if the nodes have a common ancestor
1670			siblingCheck( ap[i], bp[i] ) :
1671
1672			// Otherwise nodes in our document sort first
1673			ap[i] === preferredDoc ? -1 :
1674			bp[i] === preferredDoc ? 1 :
1675			0;
1676	};
1677
1678	return document;
1679};
1680
1681Sizzle.matches = function( expr, elements ) {
1682	return Sizzle( expr, null, null, elements );
1683};
1684
1685Sizzle.matchesSelector = function( elem, expr ) {
1686	// Set document vars if needed
1687	if ( ( elem.ownerDocument || elem ) !== document ) {
1688		setDocument( elem );
1689	}
1690
1691	// Make sure that attribute selectors are quoted
1692	expr = expr.replace( rattributeQuotes, "='$1']" );
1693
1694	if ( support.matchesSelector && documentIsHTML &&
1695		!compilerCache[ expr + " " ] &&
1696		( !rbuggyMatches || !rbuggyMatches.test( expr ) ) &&
1697		( !rbuggyQSA     || !rbuggyQSA.test( expr ) ) ) {
1698
1699		try {
1700			var ret = matches.call( elem, expr );
1701
1702			// IE 9's matchesSelector returns false on disconnected nodes
1703			if ( ret || support.disconnectedMatch ||
1704					// As well, disconnected nodes are said to be in a document
1705					// fragment in IE 9
1706					elem.document && elem.document.nodeType !== 11 ) {
1707				return ret;
1708			}
1709		} catch (e) {}
1710	}
1711
1712	return Sizzle( expr, document, null, [ elem ] ).length > 0;
1713};
1714
1715Sizzle.contains = function( context, elem ) {
1716	// Set document vars if needed
1717	if ( ( context.ownerDocument || context ) !== document ) {
1718		setDocument( context );
1719	}
1720	return contains( context, elem );
1721};
1722
1723Sizzle.attr = function( elem, name ) {
1724	// Set document vars if needed
1725	if ( ( elem.ownerDocument || elem ) !== document ) {
1726		setDocument( elem );
1727	}
1728
1729	var fn = Expr.attrHandle[ name.toLowerCase() ],
1730		// Don't get fooled by Object.prototype properties (jQuery #13807)
1731		val = fn && hasOwn.call( Expr.attrHandle, name.toLowerCase() ) ?
1732			fn( elem, name, !documentIsHTML ) :
1733			undefined;
1734
1735	return val !== undefined ?
1736		val :
1737		support.attributes || !documentIsHTML ?
1738			elem.getAttribute( name ) :
1739			(val = elem.getAttributeNode(name)) && val.specified ?
1740				val.value :
1741				null;
1742};
1743
1744Sizzle.escape = function( sel ) {
1745	return (sel + "").replace( rcssescape, fcssescape );
1746};
1747
1748Sizzle.error = function( msg ) {
1749	throw new Error( "Syntax error, unrecognized expression: " + msg );
1750};
1751
1752/**
1753 * Document sorting and removing duplicates
1754 * @param {ArrayLike} results
1755 */
1756Sizzle.uniqueSort = function( results ) {
1757	var elem,
1758		duplicates = [],
1759		j = 0,
1760		i = 0;
1761
1762	// Unless we *know* we can detect duplicates, assume their presence
1763	hasDuplicate = !support.detectDuplicates;
1764	sortInput = !support.sortStable && results.slice( 0 );
1765	results.sort( sortOrder );
1766
1767	if ( hasDuplicate ) {
1768		while ( (elem = results[i++]) ) {
1769			if ( elem === results[ i ] ) {
1770				j = duplicates.push( i );
1771			}
1772		}
1773		while ( j-- ) {
1774			results.splice( duplicates[ j ], 1 );
1775		}
1776	}
1777
1778	// Clear input after sorting to release objects
1779	// See https://github.com/jquery/sizzle/pull/225
1780	sortInput = null;
1781
1782	return results;
1783};
1784
1785/**
1786 * Utility function for retrieving the text value of an array of DOM nodes
1787 * @param {Array|Element} elem
1788 */
1789getText = Sizzle.getText = function( elem ) {
1790	var node,
1791		ret = "",
1792		i = 0,
1793		nodeType = elem.nodeType;
1794
1795	if ( !nodeType ) {
1796		// If no nodeType, this is expected to be an array
1797		while ( (node = elem[i++]) ) {

1798			// Do not traverse comment nodes
1799			ret += getText( node );
1800		}
1801	} else if ( nodeType === 1 || nodeType === 9 || nodeType === 11 ) {
1802		// Use textContent for elements
1803		// innerText usage removed for consistency of new lines (jQuery #11153)
1804		if ( typeof elem.textContent === "string" ) {
1805			return elem.textContent;
1806		} else {
1807			// Traverse its children
1808			for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
1809				ret += getText( elem );
1810			}
1811		}
1812	} else if ( nodeType === 3 || nodeType === 4 ) {
1813		return elem.nodeValue;
1814	}
1815	// Do not include comment or processing instruction nodes
1816
1817	return ret;
1818};
1819
1820Expr = Sizzle.selectors = {
1821
1822	// Can be adjusted by the user
1823	cacheLength: 50,
1824
1825	createPseudo: markFunction,
1826
1827	match: matchExpr,
1828
1829	attrHandle: {},
1830
1831	find: {},
1832
1833	relative: {
1834		">": { dir: "parentNode", first: true },
1835		" ": { dir: "parentNode" },
1836		"+": { dir: "previousSibling", first: true },
1837		"~": { dir: "previousSibling" }
1838	},
1839
1840	preFilter: {
1841		"ATTR": function( match ) {
1842			match[1] = match[1].replace( runescape, funescape );
1843
1844			// Move the given value to match[3] whether quoted or unquoted
1845			match[3] = ( match[3] || match[4] || match[5] || "" ).replace( runescape, funescape );
1846
1847			if ( match[2] === "~=" ) {
1848				match[3] = " " + match[3] + " ";
1849			}
1850
1851			return match.slice( 0, 4 );
1852		},
1853
1854		"CHILD": function( match ) {
1855			/* matches from matchExpr["CHILD"]
1856				1 type (only|nth|...)
1857				2 what (child|of-type)
1858				3 argument (even|odd|\d*|\d*n([+-]\d+)?|...)
1859				4 xn-component of xn+y argument ([+-]?\d*n|)
1860				5 sign of xn-component
1861				6 x of xn-component
1862				7 sign of y-component
1863				8 y of y-component
1864			*/
1865			match[1] = match[1].toLowerCase();
1866
1867			if ( match[1].slice( 0, 3 ) === "nth" ) {
1868				// nth-* requires argument
1869				if ( !match[3] ) {
1870					Sizzle.error( match[0] );
1871				}
1872
1873				// numeric x and y parameters for Expr.filter.CHILD
1874				// remember that false/true cast respectively to 0/1
1875				match[4] = +( match[4] ? match[5] + (match[6] || 1) : 2 * ( match[3] === "even" || match[3] === "odd" ) );
1876				match[5] = +( ( match[7] + match[8] ) || match[3] === "odd" );
1877
1878			// other types prohibit arguments
1879			} else if ( match[3] ) {
1880				Sizzle.error( match[0] );
1881			}
1882
1883			return match;
1884		},
1885
1886		"PSEUDO": function( match ) {
1887			var excess,
1888				unquoted = !match[6] && match[2];
1889
1890			if ( matchExpr["CHILD"].test( match[0] ) ) {
1891				return null;
1892			}
1893
1894			// Accept quoted arguments as-is
1895			if ( match[3] ) {
1896				match[2] = match[4] || match[5] || "";
1897
1898			// Strip excess characters from unquoted arguments
1899			} else if ( unquoted && rpseudo.test( unquoted ) &&
1900				// Get excess from tokenize (recursively)
1901				(excess = tokenize( unquoted, true )) &&
1902				// advance to the next closing parenthesis
1903				(excess = unquoted.indexOf( ")", unquoted.length - excess ) - unquoted.length) ) {
1904
1905				// excess is a negative index
1906				match[0] = match[0].slice( 0, excess );
1907				match[2] = unquoted.slice( 0, excess );
1908			}
1909
1910			// Return only captures needed by the pseudo filter method (type and argument)
1911			return match.slice( 0, 3 );
1912		}
1913	},
1914
1915	filter: {
1916
1917		"TAG": function( nodeNameSelector ) {
1918			var nodeName = nodeNameSelector.replace( runescape, funescape ).toLowerCase();
1919			return nodeNameSelector === "*" ?
1920				function() { return true; } :
1921				function( elem ) {
1922					return elem.nodeName && elem.nodeName.toLowerCase() === nodeName;
1923				};
1924		},
1925
1926		"CLASS": function( className ) {
1927			var pattern = classCache[ className + " " ];
1928
1929			return pattern ||
1930				(pattern = new RegExp( "(^|" + whitespace + ")" + className + "(" + whitespace + "|$)" )) &&
1931				classCache( className, function( elem ) {
1932					return pattern.test( typeof elem.className === "string" && elem.className || typeof elem.getAttribute !== "undefined" && elem.getAttribute("class") || "" );
1933				});
1934		},
1935
1936		"ATTR": function( name, operator, check ) {
1937			return function( elem ) {
1938				var result = Sizzle.attr( elem, name );
1939
1940				if ( result == null ) {
1941					return operator === "!=";
1942				}
1943				if ( !operator ) {
1944					return true;
1945				}
1946
1947				result += "";
1948
1949				return operator === "=" ? result === check :
1950					operator === "!=" ? result !== check :
1951					operator === "^=" ? check && result.indexOf( check ) === 0 :
1952					operator === "*=" ? check && result.indexOf( check ) > -1 :
1953					operator === "$=" ? check && result.slice( -check.length ) === check :
1954					operator === "~=" ? ( " " + result.replace( rwhitespace, " " ) + " " ).indexOf( check ) > -1 :
1955					operator === "|=" ? result === check || result.slice( 0, check.length + 1 ) === check + "-" :
1956					false;
1957			};
1958		},
1959
1960		"CHILD": function( type, what, argument, first, last ) {
1961			var simple = type.slice( 0, 3 ) !== "nth",
1962				forward = type.slice( -4 ) !== "last",
1963				ofType = what === "of-type";
1964
1965			return first === 1 && last === 0 ?
1966
1967				// Shortcut for :nth-*(n)
1968				function( elem ) {
1969					return !!elem.parentNode;
1970				} :
1971
1972				function( elem, context, xml ) {
1973					var cache, uniqueCache, outerCache, node, nodeIndex, start,
1974						dir = simple !== forward ? "nextSibling" : "previousSibling",
1975						parent = elem.parentNode,
1976						name = ofType && elem.nodeName.toLowerCase(),
1977						useCache = !xml && !ofType,
1978						diff = false;
1979
1980					if ( parent ) {
1981
1982						// :(first|last|only)-(child|of-type)
1983						if ( simple ) {
1984							while ( dir ) {
1985								node = elem;
1986								while ( (node = node[ dir ]) ) {
1987									if ( ofType ?
1988										node.nodeName.toLowerCase() === name :
1989										node.nodeType === 1 ) {
1990
1991										return false;
1992									}
1993								}
1994								// Reverse direction for :only-* (if we haven't yet done so)
1995								start = dir = type === "only" && !start && "nextSibling";
1996							}
1997							return true;
1998						}
1999
2000						start = [ forward ? parent.firstChild : parent.lastChild ];
2001
2002						// non-xml :nth-child(...) stores cache data on `parent`
2003						if ( forward && useCache ) {
2004
2005							// Seek `elem` from a previously-cached index
2006
2007							// ...in a gzip-friendly way
2008							node = parent;
2009							outerCache = node[ expando ] || (node[ expando ] = {});
2010
2011							// Support: IE <9 only
2012							// Defend against cloned attroperties (jQuery gh-1709)
2013							uniqueCache = outerCache[ node.uniqueID ] ||
2014								(outerCache[ node.uniqueID ] = {});
2015
2016							cache = uniqueCache[ type ] || [];
2017							nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ];
2018							diff = nodeIndex && cache[ 2 ];
2019							node = nodeIndex && parent.childNodes[ nodeIndex ];
2020
2021							while ( (node = ++nodeIndex && node && node[ dir ] ||
2022
2023								// Fallback to seeking `elem` from the start
2024								(diff = nodeIndex = 0) || start.pop()) ) {
2025
2026								// When found, cache indexes on `parent` and break
2027								if ( node.nodeType === 1 && ++diff && node === elem ) {
2028									uniqueCache[ type ] = [ dirruns, nodeIndex, diff ];
2029									break;
2030								}
2031							}
2032
2033						} else {
2034							// Use previously-cached element index if available
2035							if ( useCache ) {
2036								// ...in a gzip-friendly way
2037								node = elem;
2038								outerCache = node[ expando ] || (node[ expando ] = {});
2039
2040								// Support: IE <9 only
2041								// Defend against cloned attroperties (jQuery gh-1709)
2042								uniqueCache = outerCache[ node.uniqueID ] ||
2043									(outerCache[ node.uniqueID ] = {});
2044
2045								cache = uniqueCache[ type ] || [];
2046								nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ];
2047								diff = nodeIndex;
2048							}
2049
2050							// xml :nth-child(...)
2051							// or :nth-last-child(...) or :nth(-last)?-of-type(...)
2052							if ( diff === false ) {
2053								// Use the same loop as above to seek `elem` from the start
2054								while ( (node = ++nodeIndex && node && node[ dir ] ||
2055									(diff = nodeIndex = 0) || start.pop()) ) {
2056
2057									if ( ( ofType ?
2058										node.nodeName.toLowerCase() === name :
2059										node.nodeType === 1 ) &&
2060										++diff ) {
2061
2062										// Cache the index of each encountered element
2063										if ( useCache ) {
2064											outerCache = node[ expando ] || (node[ expando ] = {});
2065
2066											// Support: IE <9 only
2067											// Defend against cloned attroperties (jQuery gh-1709)
2068											uniqueCache = outerCache[ node.uniqueID ] ||
2069												(outerCache[ node.uniqueID ] = {});
2070
2071											uniqueCache[ type ] = [ dirruns, diff ];
2072										}
2073
2074										if ( node === elem ) {
2075											break;
2076										}
2077									}
2078								}
2079							}
2080						}
2081
2082						// Incorporate the offset, then check against cycle size
2083						diff -= last;
2084						return diff === first || ( diff % first === 0 && diff / first >= 0 );
2085					}
2086				};
2087		},
2088
2089		"PSEUDO": function( pseudo, argument ) {
2090			// pseudo-class names are case-insensitive
2091			// http://www.w3.org/TR/selectors/#pseudo-classes
2092			// Prioritize by case sensitivity in case custom pseudos are added with uppercase letters
2093			// Remember that setFilters inherits from pseudos
2094			var args,
2095				fn = Expr.pseudos[ pseudo ] || Expr.setFilters[ pseudo.toLowerCase() ] ||
2096					Sizzle.error( "unsupported pseudo: " + pseudo );
2097
2098			// The user may use createPseudo to indicate that
2099			// arguments are needed to create the filter function
2100			// just as Sizzle does
2101			if ( fn[ expando ] ) {
2102				return fn( argument );
2103			}
2104
2105			// But maintain support for old signatures
2106			if ( fn.length > 1 ) {
2107				args = [ pseudo, pseudo, "", argument ];
2108				return Expr.setFilters.hasOwnProperty( pseudo.toLowerCase() ) ?
2109					markFunction(function( seed, matches ) {
2110						var idx,
2111							matched = fn( seed, argument ),
2112							i = matched.length;
2113						while ( i-- ) {
2114							idx = indexOf( seed, matched[i] );
2115							seed[ idx ] = !( matches[ idx ] = matched[i] );
2116						}
2117					}) :
2118					function( elem ) {
2119						return fn( elem, 0, args );
2120					};
2121			}
2122
2123			return fn;
2124		}
2125	},
2126
2127	pseudos: {
2128		// Potentially complex pseudos
2129		"not": markFunction(function( selector ) {
2130			// Trim the selector passed to compile
2131			// to avoid treating leading and trailing
2132			// spaces as combinators
2133			var input = [],
2134				results = [],
2135				matcher = compile( selector.replace( rtrim, "$1" ) );
2136
2137			return matcher[ expando ] ?
2138				markFunction(function( seed, matches, context, xml ) {
2139					var elem,
2140						unmatched = matcher( seed, null, xml, [] ),
2141						i = seed.length;
2142
2143					// Match elements unmatched by `matcher`
2144					while ( i-- ) {
2145						if ( (elem = unmatched[i]) ) {
2146							seed[i] = !(matches[i] = elem);
2147						}
2148					}
2149				}) :
2150				function( elem, context, xml ) {
2151					input[0] = elem;
2152					matcher( input, null, xml, results );
2153					// Don't keep the element (issue #299)
2154					input[0] = null;
2155					return !results.pop();
2156				};
2157		}),
2158
2159		"has": markFunction(function( selector ) {
2160			return function( elem ) {
2161				return Sizzle( selector, elem ).length > 0;
2162			};
2163		}),
2164
2165		"contains": markFunction(function( text ) {
2166			text = text.replace( runescape, funescape );
2167			return function( elem ) {
2168				return ( elem.textContent || elem.innerText || getText( elem ) ).indexOf( text ) > -1;
2169			};
2170		}),
2171
2172		// "Whether an element is represented by a :lang() selector
2173		// is based solely on the element's language value
2174		// being equal to the identifier C,
2175		// or beginning with the identifier C immediately followed by "-".
2176		// The matching of C against the element's language value is performed case-insensitively.
2177		// The identifier C does not have to be a valid language name."
2178		// http://www.w3.org/TR/selectors/#lang-pseudo
2179		"lang": markFunction( function( lang ) {
2180			// lang value must be a valid identifier
2181			if ( !ridentifier.test(lang || "") ) {
2182				Sizzle.error( "unsupported lang: " + lang );
2183			}
2184			lang = lang.replace( runescape, funescape ).toLowerCase();
2185			return function( elem ) {
2186				var elemLang;
2187				do {
2188					if ( (elemLang = documentIsHTML ?
2189						elem.lang :
2190						elem.getAttribute("xml:lang") || elem.getAttribute("lang")) ) {
2191
2192						elemLang = elemLang.toLowerCase();
2193						return elemLang === lang || elemLang.indexOf( lang + "-" ) === 0;
2194					}
2195				} while ( (elem = elem.parentNode) && elem.nodeType === 1 );
2196				return false;

2197			};
2198		}),
2199
2200		// Miscellaneous
2201		"target": function( elem ) {
2202			var hash = window.location && window.location.hash;
2203			return hash && hash.slice( 1 ) === elem.id;
2204		},
2205
2206		"root": function( elem ) {
2207			return elem === docElem;
2208		},
2209
2210		"focus": function( elem ) {
2211			return elem === document.activeElement && (!document.hasFocus || document.hasFocus()) && !!(elem.type || elem.href || ~elem.tabIndex);
2212		},
2213
2214		// Boolean properties
2215		"enabled": createDisabledPseudo( false ),
2216		"disabled": createDisabledPseudo( true ),
2217
2218		"checked": function( elem ) {
2219			// In CSS3, :checked should return both checked and selected elements
2220			// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
2221			var nodeName = elem.nodeName.toLowerCase();
2222			return (nodeName === "input" && !!elem.checked) || (nodeName === "option" && !!elem.selected);
2223		},
2224
2225		"selected": function( elem ) {
2226			// Accessing this property makes selected-by-default
2227			// options in Safari work properly
2228			if ( elem.parentNode ) {
2229				elem.parentNode.selectedIndex;
2230			}
2231
2232			return elem.selected === true;
2233		},
2234
2235		// Contents
2236		"empty": function( elem ) {
2237			// http://www.w3.org/TR/selectors/#empty-pseudo
2238			// :empty is negated by element (1) or content nodes (text: 3; cdata: 4; entity ref: 5),
2239			//   but not by others (comment: 8; processing instruction: 7; etc.)
2240			// nodeType < 6 works because attributes (2) do not appear as children
2241			for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
2242				if ( elem.nodeType < 6 ) {
2243					return false;
2244				}
2245			}
2246			return true;
2247		},
2248
2249		"parent": function( elem ) {
2250			return !Expr.pseudos["empty"]( elem );
2251		},
2252
2253		// Element/input types
2254		"header": function( elem ) {
2255			return rheader.test( elem.nodeName );
2256		},
2257
2258		"input": function( elem ) {
2259			return rinputs.test( elem.nodeName );
2260		},
2261
2262		"button": function( elem ) {
2263			var name = elem.nodeName.toLowerCase();
2264			return name === "input" && elem.type === "button" || name === "button";
2265		},
2266
2267		"text": function( elem ) {
2268			var attr;
2269			return elem.nodeName.toLowerCase() === "input" &&
2270				elem.type === "text" &&
2271
2272				// Support: IE<8
2273				// New HTML5 attribute values (e.g., "search") appear with elem.type === "text"
2274				( (attr = elem.getAttribute("type")) == null || attr.toLowerCase() === "text" );
2275		},
2276
2277		// Position-in-collection
2278		"first": createPositionalPseudo(function() {
2279			return [ 0 ];
2280		}),
2281
2282		"last": createPositionalPseudo(function( matchIndexes, length ) {
2283			return [ length - 1 ];
2284		}),
2285
2286		"eq": createPositionalPseudo(function( matchIndexes, length, argument ) {
2287			return [ argument < 0 ? argument + length : argument ];
2288		}),
2289
2290		"even": createPositionalPseudo(function( matchIndexes, length ) {
2291			var i = 0;
2292			for ( ; i < length; i += 2 ) {
2293				matchIndexes.push( i );
2294			}
2295			return matchIndexes;
2296		}),
2297
2298		"odd": createPositionalPseudo(function( matchIndexes, length ) {
2299			var i = 1;
2300			for ( ; i < length; i += 2 ) {
2301				matchIndexes.push( i );
2302			}
2303			return matchIndexes;
2304		}),
2305
2306		"lt": createPositionalPseudo(function( matchIndexes, length, argument ) {
2307			var i = argument < 0 ? argument + length : argument;
2308			for ( ; --i >= 0; ) {
2309				matchIndexes.push( i );
2310			}
2311			return matchIndexes;
2312		}),
2313
2314		"gt": createPositionalPseudo(function( matchIndexes, length, argument ) {
2315			var i = argument < 0 ? argument + length : argument;
2316			for ( ; ++i < length; ) {
2317				matchIndexes.push( i );
2318			}
2319			return matchIndexes;
2320		})
2321	}
2322};
2323
2324Expr.pseudos["nth"] = Expr.pseudos["eq"];
2325
2326// Add button/input type pseudos
2327for ( i in { radio: true, checkbox: true, file: true, password: true, image: true } ) {
2328	Expr.pseudos[ i ] = createInputPseudo( i );
2329}
2330for ( i in { submit: true, reset: true } ) {
2331	Expr.pseudos[ i ] = createButtonPseudo( i );
2332}
2333
2334// Easy API for creating new setFilters
2335function setFilters() {}
2336setFilters.prototype = Expr.filters = Expr.pseudos;
2337Expr.setFilters = new setFilters();
2338
2339tokenize = Sizzle.tokenize = function( selector, parseOnly ) {
2340	var matched, match, tokens, type,
2341		soFar, groups, preFilters,
2342		cached = tokenCache[ selector + " " ];
2343
2344	if ( cached ) {
2345		return parseOnly ? 0 : cached.slice( 0 );
2346	}
2347
2348	soFar = selector;
2349	groups = [];
2350	preFilters = Expr.preFilter;
2351
2352	while ( soFar ) {
2353
2354		// Comma and first run
2355		if ( !matched || (match = rcomma.exec( soFar )) ) {
2356			if ( match ) {
2357				// Don't consume trailing commas as valid
2358				soFar = soFar.slice( match[0].length ) || soFar;
2359			}
2360			groups.push( (tokens = []) );
2361		}
2362
2363		matched = false;
2364
2365		// Combinators
2366		if ( (match = rcombinators.exec( soFar )) ) {
2367			matched = match.shift();
2368			tokens.push({
2369				value: matched,
2370				// Cast descendant combinators to space
2371				type: match[0].replace( rtrim, " " )
2372			});
2373			soFar = soFar.slice( matched.length );
2374		}
2375
2376		// Filters
2377		for ( type in Expr.filter ) {
2378			if ( (match = matchExpr[ type ].exec( soFar )) && (!preFilters[ type ] ||
2379				(match = preFilters[ type ]( match ))) ) {
2380				matched = match.shift();
2381				tokens.push({
2382					value: matched,
2383					type: type,
2384					matches: match
2385				});
2386				soFar = soFar.slice( matched.length );
2387			}
2388		}
2389
2390		if ( !matched ) {
2391			break;
2392		}
2393	}
2394
2395	// Return the length of the invalid excess
2396	// if we're just parsing
2397	// Otherwise, throw an error or return tokens
2398	return parseOnly ?
2399		soFar.length :
2400		soFar ?
2401			Sizzle.error( selector ) :
2402			// Cache the tokens
2403			tokenCache( selector, groups ).slice( 0 );
2404};
2405
2406function toSelector( tokens ) {
2407	var i = 0,
2408		len = tokens.length,
2409		selector = "";
2410	for ( ; i < len; i++ ) {
2411		selector += tokens[i].value;
2412	}
2413	return selector;
2414}
2415
2416function addCombinator( matcher, combinator, base ) {
2417	var dir = combinator.dir,
2418		skip = combinator.next,
2419		key = skip || dir,
2420		checkNonElements = base && key === "parentNode",
2421		doneName = done++;
2422
2423	return combinator.first ?
2424		// Check against closest ancestor/preceding element
2425		function( elem, context, xml ) {
2426			while ( (elem = elem[ dir ]) ) {
2427				if ( elem.nodeType === 1 || checkNonElements ) {
2428					return matcher( elem, context, xml );
2429				}
2430			}
2431			return false;
2432		} :
2433
2434		// Check against all ancestor/preceding elements
2435		function( elem, context, xml ) {
2436			var oldCache, uniqueCache, outerCache,
2437				newCache = [ dirruns, doneName ];
2438
2439			// We can't set arbitrary data on XML nodes, so they don't benefit from combinator caching
2440			if ( xml ) {
2441				while ( (elem = elem[ dir ]) ) {
2442					if ( elem.nodeType === 1 || checkNonElements ) {
2443						if ( matcher( elem, context, xml ) ) {
2444							return true;
2445						}
2446					}
2447				}
2448			} else {
2449				while ( (elem = elem[ dir ]) ) {
2450					if ( elem.nodeType === 1 || checkNonElements ) {
2451						outerCache = elem[ expando ] || (elem[ expando ] = {});
2452
2453						// Support: IE <9 only
2454						// Defend against cloned attroperties (jQuery gh-1709)
2455						uniqueCache = outerCache[ elem.uniqueID ] || (outerCache[ elem.uniqueID ] = {});
2456
2457						if ( skip && skip === elem.nodeName.toLowerCase() ) {
2458							elem = elem[ dir ] || elem;
2459						} else if ( (oldCache = uniqueCache[ key ]) &&
2460							oldCache[ 0 ] === dirruns && oldCache[ 1 ] === doneName ) {
2461
2462							// Assign to newCache so results back-propagate to previous elements
2463							return (newCache[ 2 ] = oldCache[ 2 ]);
2464						} else {
2465							// Reuse newcache so results back-propagate to previous elements
2466							uniqueCache[ key ] = newCache;
2467
2468							// A match means we're done; a fail means we have to keep checking
2469							if ( (newCache[ 2 ] = matcher( elem, context, xml )) ) {
2470								return true;
2471							}
2472						}
2473					}
2474				}
2475			}
2476			return false;
2477		};
2478}
2479
2480function elementMatcher( matchers ) {
2481	return matchers.length > 1 ?
2482		function( elem, context, xml ) {
2483			var i = matchers.length;
2484			while ( i-- ) {
2485				if ( !matchers[i]( elem, context, xml ) ) {
2486					return false;
2487				}
2488			}
2489			return true;
2490		} :
2491		matchers[0];
2492}
2493
2494function multipleContexts( selector, contexts, results ) {
2495	var i = 0,
2496		len = contexts.length;
2497	for ( ; i < len; i++ ) {
2498		Sizzle( selector, contexts[i], results );
2499	}
2500	return results;
2501}
2502
2503function condense( unmatched, map, filter, context, xml ) {
2504	var elem,
2505		newUnmatched = [],
2506		i = 0,
2507		len = unmatched.length,
2508		mapped = map != null;
2509
2510	for ( ; i < len; i++ ) {
2511		if ( (elem = unmatched[i]) ) {
2512			if ( !filter || filter( elem, context, xml ) ) {
2513				newUnmatched.push( elem );
2514				if ( mapped ) {
2515					map.push( i );
2516				}
2517			}
2518		}
2519	}
2520
2521	return newUnmatched;
2522}
2523
2524function setMatcher( preFilter, selector, matcher, postFilter, postFinder, postSelector ) {
2525	if ( postFilter && !postFilter[ expando ] ) {
2526		postFilter = setMatcher( postFilter );
2527	}
2528	if ( postFinder && !postFinder[ expando ] ) {
2529		postFinder = setMatcher( postFinder, postSelector );
2530	}
2531	return markFunction(function( seed, results, context, xml ) {
2532		var temp, i, elem,
2533			preMap = [],
2534			postMap = [],
2535			preexisting = results.length,
2536
2537			// Get initial elements from seed or context
2538			elems = seed || multipleContexts( selector || "*", context.nodeType ? [ context ] : context, [] ),
2539
2540			// Prefilter to get matcher input, preserving a map for seed-results synchronization
2541			matcherIn = preFilter && ( seed || !selector ) ?
2542				condense( elems, preMap, preFilter, context, xml ) :
2543				elems,
2544
2545			matcherOut = matcher ?
2546				// If we have a postFinder, or filtered seed, or non-seed postFilter or preexisting results,
2547				postFinder || ( seed ? preFilter : preexisting || postFilter ) ?
2548
2549					// ...intermediate processing is necessary
2550					[] :
2551
2552					// ...otherwise use results directly
2553					results :
2554				matcherIn;
2555
2556		// Find primary matches
2557		if ( matcher ) {
2558			matcher( matcherIn, matcherOut, context, xml );
2559		}
2560
2561		// Apply postFilter
2562		if ( postFilter ) {
2563			temp = condense( matcherOut, postMap );
2564			postFilter( temp, [], context, xml );
2565
2566			// Un-match failing elements by moving them back to matcherIn
2567			i = temp.length;
2568			while ( i-- ) {
2569				if ( (elem = temp[i]) ) {
2570					matcherOut[ postMap[i] ] = !(matcherIn[ postMap[i] ] = elem);
2571				}
2572			}
2573		}
2574
2575		if ( seed ) {
2576			if ( postFinder || preFilter ) {
2577				if ( postFinder ) {
2578					// Get the final matcherOut by condensing this intermediate into postFinder contexts
2579					temp = [];
2580					i = matcherOut.length;
2581					while ( i-- ) {
2582						if ( (elem = matcherOut[i]) ) {
2583							// Restore matcherIn since elem is not yet a final match
2584							temp.push( (matcherIn[i] = elem) );
2585						}
2586					}
2587					postFinder( null, (matcherOut = []), temp, xml );
2588				}
2589
2590				// Move matched elements from seed to results to keep them synchronized
2591				i = matcherOut.length;
2592				while ( i-- ) {
2593					if ( (elem = matcherOut[i]) &&
2594						(temp = postFinder ? indexOf( seed, elem ) : preMap[i]) > -1 ) {
2595
2596						seed[temp] = !(results[temp] = elem);
2597					}
2598				}
2599			}
2600
2601		// Add elements to results, through postFinder if defined
2602		} else {
2603			matcherOut = condense(
2604				matcherOut === results ?
2605					matcherOut.splice( preexisting, matcherOut.length ) :
2606					matcherOut
2607			);
2608			if ( postFinder ) {
2609				postFinder( null, results, matcherOut, xml );
2610			} else {
2611				push.apply( results, matcherOut );
2612			}
2613		}
2614	});
2615}
2616
2617function matcherFromTokens( tokens ) {
2618	var checkContext, matcher, j,
2619		len = tokens.length,
2620		leadingRelative = Expr.relative[ tokens[0].type ],
2621		implicitRelative = leadingRelative || Expr.relative[" "],
2622		i = leadingRelative ? 1 : 0,
2623
2624		// The foundational matcher ensures that elements are reachable from top-level context(s)
2625		matchContext = addCombinator( function( elem ) {
2626			return elem === checkContext;
2627		}, implicitRelative, true ),
2628		matchAnyContext = addCombinator( function( elem ) {
2629			return indexOf( checkContext, elem ) > -1;
2630		}, implicitRelative, true ),
2631		matchers = [ function( elem, context, xml ) {
2632			var ret = ( !leadingRelative && ( xml || context !== outermostContext ) ) || (
2633				(checkContext = context).nodeType ?
2634					matchContext( elem, context, xml ) :
2635					matchAnyContext( elem, context, xml ) );
2636			// Avoid hanging onto element (issue #299)
2637			checkContext = null;
2638			return ret;
2639		} ];
2640
2641	for ( ; i < len; i++ ) {
2642		if ( (matcher = Expr.relative[ tokens[i].type ]) ) {
2643			matchers = [ addCombinator(elementMatcher( matchers ), matcher) ];
2644		} else {
2645			matcher = Expr.filter[ tokens[i].type ].apply( null, tokens[i].matches );
2646
2647			// Return special upon seeing a positional matcher
2648			if ( matcher[ expando ] ) {
2649				// Find the next relative operator (if any) for proper handling
2650				j = ++i;
2651				for ( ; j < len; j++ ) {
2652					if ( Expr.relative[ tokens[j].type ] ) {
2653						break;
2654					}
2655				}
2656				return setMatcher(
2657					i > 1 && elementMatcher( matchers ),
2658					i > 1 && toSelector(
2659						// If the preceding token was a descendant combinator, insert an implicit any-element `*`
2660						tokens.slice( 0, i - 1 ).concat({ value: tokens[ i - 2 ].type === " " ? "*" : "" })
2661					).replace( rtrim, "$1" ),
2662					matcher,
2663					i < j && matcherFromTokens( tokens.slice( i, j ) ),
2664					j < len && matcherFromTokens( (tokens = tokens.slice( j )) ),
2665					j < len && toSelector( tokens )
2666				);
2667			}
2668			matchers.push( matcher );
2669		}
2670	}
2671
2672	return elementMatcher( matchers );
2673}
2674
2675function matcherFromGroupMatchers( elementMatchers, setMatchers ) {
2676	var bySet = setMatchers.length > 0,
2677		byElement = elementMatchers.length > 0,
2678		superMatcher = function( seed, context, xml, results, outermost ) {
2679			var elem, j, matcher,
2680				matchedCount = 0,
2681				i = "0",
2682				unmatched = seed && [],
2683				setMatched = [],
2684				contextBackup = outermostContext,
2685				// We must always have either seed elements or outermost context
2686				elems = seed || byElement && Expr.find["TAG"]( "*", outermost ),
2687				// Use integer dirruns iff this is the outermost matcher
2688				dirrunsUnique = (dirruns += contextBackup == null ? 1 : Math.random() || 0.1),
2689				len = elems.length;
2690
2691			if ( outermost ) {
2692				outermostContext = context === document || context || outermost;
2693			}
2694
2695			// Add elements passing elementMatchers directly to results
2696			// Support: IE<9, Safari
2697			// Tolerate NodeList properties (IE: "length"; Safari: <number>) matching elements by id
2698			for ( ; i !== len && (elem = elems[i]) != null; i++ ) {
2699				if ( byElement && elem ) {
2700					j = 0;
2701					if ( !context && elem.ownerDocument !== document ) {
2702						setDocument( elem );
2703						xml = !documentIsHTML;
2704					}
2705					while ( (matcher = elementMatchers[j++]) ) {
2706						if ( matcher( elem, context || document, xml) ) {
2707							results.push( elem );
2708							break;
2709						}
2710					}
2711					if ( outermost ) {
2712						dirruns = dirrunsUnique;
2713					}
2714				}
2715
2716				// Track unmatched elements for set filters
2717				if ( bySet ) {
2718					// They will have gone through all possible matchers
2719					if ( (elem = !matcher && elem) ) {
2720						matchedCount--;
2721					}
2722
2723					// Lengthen the array for every element, matched or not
2724					if ( seed ) {
2725						unmatched.push( elem );
2726					}
2727				}
2728			}
2729
2730			// `i` is now the count of elements visited above, and adding it to `matchedCount`
2731			// makes the latter nonnegative.
2732			matchedCount += i;
2733
2734			// Apply set filters to unmatched elements
2735			// NOTE: This can be skipped if there are no unmatched elements (i.e., `matchedCount`
2736			// equals `i`), unless we didn't visit _any_ elements in the above loop because we have
2737			// no element matchers and no seed.
2738			// Incrementing an initially-string "0" `i` allows `i` to remain a string only in that
2739			// case, which will result in a "00" `matchedCount` that differs from `i` but is also
2740			// numerically zero.
2741			if ( bySet && i !== matchedCount ) {
2742				j = 0;
2743				while ( (matcher = setMatchers[j++]) ) {
2744					matcher( unmatched, setMatched, context, xml );
2745				}
2746
2747				if ( seed ) {
2748					// Reintegrate element matches to eliminate the need for sorting
2749					if ( matchedCount > 0 ) {
2750						while ( i-- ) {
2751							if ( !(unmatched[i] || setMatched[i]) ) {
2752								setMatched[i] = pop.call( results );
2753							}
2754						}
2755					}
2756
2757					// Discard index placeholder values to get only actual matches
2758					setMatched = condense( setMatched );
2759				}
2760
2761				// Add matches to results
2762				push.apply( results, setMatched );
2763
2764				// Seedless set matches succeeding multiple successful matchers stipulate sorting
2765				if ( outermost && !seed && setMatched.length > 0 &&
2766					( matchedCount + setMatchers.length ) > 1 ) {
2767
2768					Sizzle.uniqueSort( results );
2769				}
2770			}
2771
2772			// Override manipulation of globals by nested matchers
2773			if ( outermost ) {
2774				dirruns = dirrunsUnique;
2775				outermostContext = contextBackup;
2776			}
2777
2778			return unmatched;
2779		};
2780
2781	return bySet ?
2782		markFunction( superMatcher ) :
2783		superMatcher;
2784}
2785
2786compile = Sizzle.compile = function( selector, match /* Internal Use Only */ ) {
2787	var i,
2788		setMatchers = [],
2789		elementMatchers = [],
2790		cached = compilerCache[ selector + " " ];
2791
2792	if ( !cached ) {
2793		// Generate a function of recursive functions that can be used to check each element
2794		if ( !match ) {
2795			match = tokenize( selector );
2796		}
2797		i = match.length;
2798		while ( i-- ) {
2799			cached = matcherFromTokens( match[i] );
2800			if ( cached[ expando ] ) {
2801				setMatchers.push( cached );
2802			} else {
2803				elementMatchers.push( cached );
2804			}
2805		}
2806
2807		// Cache the compiled function
2808		cached = compilerCache( selector, matcherFromGroupMatchers( elementMatchers, setMatchers ) );
2809
2810		// Save selector and tokenization
2811		cached.selector = selector;
2812	}
2813	return cached;
2814};
2815
2816/**
2817 * A low-level selection function that works with Sizzle's compiled
2818 *  selector functions
2819 * @param {String|Function} selector A selector or a pre-compiled
2820 *  selector function built with Sizzle.compile
2821 * @param {Element} context
2822 * @param {Array} [results]
2823 * @param {Array} [seed] A set of elements to match against
2824 */
2825select = Sizzle.select = function( selector, context, results, seed ) {
2826	var i, tokens, token, type, find,
2827		compiled = typeof selector === "function" && selector,
2828		match = !seed && tokenize( (selector = compiled.selector || selector) );
2829
2830	results = results || [];
2831
2832	// Try to minimize operations if there is only one selector in the list and no seed
2833	// (the latter of which guarantees us context)
2834	if ( match.length === 1 ) {
2835
2836		// Reduce context if the leading compound selector is an ID
2837		tokens = match[0] = match[0].slice( 0 );
2838		if ( tokens.length > 2 && (token = tokens[0]).type === "ID" &&
2839				context.nodeType === 9 && documentIsHTML && Expr.relative[ tokens[1].type ] ) {
2840
2841			context = ( Expr.find["ID"]( token.matches[0].replace(runescape, funescape), context ) || [] )[0];
2842			if ( !context ) {
2843				return results;
2844
2845			// Precompiled matchers will still verify ancestry, so step up a level
2846			} else if ( compiled ) {
2847				context = context.parentNode;
2848			}
2849
2850			selector = selector.slice( tokens.shift().value.length );
2851		}
2852
2853		// Fetch a seed set for right-to-left matching
2854		i = matchExpr["needsContext"].test( selector ) ? 0 : tokens.length;
2855		while ( i-- ) {
2856			token = tokens[i];
2857
2858			// Abort if we hit a combinator
2859			if ( Expr.relative[ (type = token.type) ] ) {
2860				break;
2861			}
2862			if ( (find = Expr.find[ type ]) ) {
2863				// Search, expanding context for leading sibling combinators
2864				if ( (seed = find(
2865					token.matches[0].replace( runescape, funescape ),
2866					rsibling.test( tokens[0].type ) && testContext( context.parentNode ) || context
2867				)) ) {
2868
2869					// If seed is empty or no tokens remain, we can return early
2870					tokens.splice( i, 1 );
2871					selector = seed.length && toSelector( tokens );
2872					if ( !selector ) {
2873						push.apply( results, seed );
2874						return results;
2875					}
2876
2877					break;
2878				}
2879			}
2880		}
2881	}
2882
2883	// Compile and execute a filtering function if one is not provided
2884	// Provide `match` to avoid retokenization if we modified the selector above
2885	( compiled || compile( selector, match ) )(
2886		seed,
2887		context,
2888		!documentIsHTML,
2889		results,
2890		!context || rsibling.test( selector ) && testContext( context.parentNode ) || context
2891	);
2892	return results;
2893};
2894
2895// One-time assignments
2896
2897// Sort stability
2898support.sortStable = expando.split("").sort( sortOrder ).join("") === expando;
2899
2900// Support: Chrome 14-35+
2901// Always assume duplicates if they aren't passed to the comparison function
2902support.detectDuplicates = !!hasDuplicate;
2903
2904// Initialize against the default document
2905setDocument();
2906
2907// Support: Webkit<537.32 - Safari 6.0.3/Chrome 25 (fixed in Chrome 27)
2908// Detached nodes confoundingly follow *each other*
2909support.sortDetached = assert(function( el ) {
2910	// Should return 1, but returns 4 (following)
2911	return el.compareDocumentPosition( document.createElement("fieldset") ) & 1;
2912});
2913
2914// Support: IE<8
2915// Prevent attribute/property "interpolation"
2916// https://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx
2917if ( !assert(function( el ) {
2918	el.innerHTML = "<a href='#'></a>";
2919	return el.firstChild.getAttribute("href") === "#" ;
2920}) ) {
2921	addHandle( "type|href|height|width", function( elem, name, isXML ) {
2922		if ( !isXML ) {
2923			return elem.getAttribute( name, name.toLowerCase() === "type" ? 1 : 2 );
2924		}
2925	});
2926}
2927
2928// Support: IE<9
2929// Use defaultValue in place of getAttribute("value")
2930if ( !support.attributes || !assert(function( el ) {
2931	el.innerHTML = "<input/>";
2932	el.firstChild.setAttribute( "value", "" );
2933	return el.firstChild.getAttribute( "value" ) === "";
2934}) ) {
2935	addHandle( "value", function( elem, name, isXML ) {
2936		if ( !isXML && elem.nodeName.toLowerCase() === "input" ) {
2937			return elem.defaultValue;
2938		}
2939	});
2940}
2941
2942// Support: IE<9
2943// Use getAttributeNode to fetch booleans when getAttribute lies
2944if ( !assert(function( el ) {
2945	return el.getAttribute("disabled") == null;
2946}) ) {
2947	addHandle( booleans, function( elem, name, isXML ) {
2948		var val;
2949		if ( !isXML ) {
2950			return elem[ name ] === true ? name.toLowerCase() :
2951					(val = elem.getAttributeNode( name )) && val.specified ?
2952					val.value :
2953				null;
2954		}
2955	});
2956}
2957
2958return Sizzle;
2959
2960})( window );
2961
2962
2963
2964jQuery.find = Sizzle;
2965jQuery.expr = Sizzle.selectors;
2966
2967// Deprecated
2968jQuery.expr[ ":" ] = jQuery.expr.pseudos;
2969jQuery.uniqueSort = jQuery.unique = Sizzle.uniqueSort;
2970jQuery.text = Sizzle.getText;
2971jQuery.isXMLDoc = Sizzle.isXML;
2972jQuery.contains = Sizzle.contains;
2973jQuery.escapeSelector = Sizzle.escape;
2974
2975
2976
2977
2978var dir = function( elem, dir, until ) {
2979	var matched = [],
2980		truncate = until !== undefined;
2981
2982	while ( ( elem = elem[ dir ] ) && elem.nodeType !== 9 ) {
2983		if ( elem.nodeType === 1 ) {
2984			if ( truncate && jQuery( elem ).is( until ) ) {
2985				break;
2986			}
2987			matched.push( elem );
2988		}
2989	}
2990	return matched;
2991};
2992
2993
2994var siblings = function( n, elem ) {
2995	var matched = [];
2996
2997	for ( ; n; n = n.nextSibling ) {
2998		if ( n.nodeType === 1 && n !== elem ) {
2999			matched.push( n );
3000		}
3001	}
3002
3003	return matched;
3004};
3005
3006
3007var rneedsContext = jQuery.expr.match.needsContext;
3008
3009
3010
3011function nodeName( elem, name ) {
3012
3013  return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase();
3014
3015};
3016var rsingleTag = ( /^<([a-z][^\/\0>:\x20\t\r\n\f]*)[\x20\t\r\n\f]*\/?>(?:<\/\1>|)$/i );
3017
3018
3019