https://anr.fr/typo3temp/compressor/merged-0616f0da75f7486fed0f401…59827196f6d78df12b96a7257fa2a.js?1790781173

36/*!
37 * jQuery JavaScript Library v3.3.1
38 * https://jquery.com/
39 *
40 * Includes Sizzle.js
41 * https://sizzlejs.com/
42 *
43 * Copyright JS Foundation and other contributors
44 * Released under the MIT license
45 * https://jquery.org/license
46 *
47 * Date: 2018-01-20T17:24Z
48 */
49( function( global, factory ) {
50
51	"use strict";
52
53	if ( typeof module === "object" && typeof module.exports === "object" ) {
54
55		// For CommonJS and CommonJS-like environments where a proper `window`
56		// is present, execute the factory and get jQuery.
57		// For environments that do not have a `window` with a `document`
58		// (such as Node.js), expose a factory as module.exports.
59		// This accentuates the need for the creation of a real `window`.
60		// e.g. var jQuery = require("jquery")(window);
61		// See ticket #14549 for more info.
62		module.exports = global.document ?
63			factory( global, true ) :
64			function( w ) {
65				if ( !w.document ) {
66					throw new Error( "jQuery requires a window with a document" );
67				}
68				return factory( w );
69			};
70	} else {
71		factory( global );
72	}
73
74// Pass this if window is not defined yet
75} )( typeof window !== "undefined" ? window : this, function( window, noGlobal ) {
76
77// Edge <= 12 - 13+, Firefox <=18 - 45+, IE 10 - 11, Safari 5.1 - 9+, iOS 6 - 9.1
78// throw exceptions when non-strict code (e.g., ASP.NET 4.5) accesses strict mode
79// arguments.callee.caller (trac-13335). But as of jQuery 3.0 (2016), strict mode should be common
80// enough that all such attempts are guarded in a try block.
81"use strict";
82
83var arr = [];
84
85var document = window.document;
86
87var getProto = Object.getPrototypeOf;
88
89var slice = arr.slice;
90
91var concat = arr.concat;
92
93var push = arr.push;
94
95var indexOf = arr.indexOf;
96
97var class2type = {};
98
99var toString = class2type.toString;
100
101var hasOwn = class2type.hasOwnProperty;
102
103var fnToString = hasOwn.toString;
104
105var ObjectFunctionString = fnToString.call( Object );
106
107var support = {};
108
109var isFunction = function isFunction( obj ) {
110
111      // Support: Chrome <=57, Firefox <=52
112      // In some browsers, typeof returns "function" for HTML <object> elements
113      // (i.e., `typeof document.createElement( "object" ) === "function"`).
114      // We don't want to classify *any* DOM node as a function.
115      return typeof obj === "function" && typeof obj.nodeType !== "number";
116  };
117
118
119var isWindow = function isWindow( obj ) {
120		return obj != null && obj === obj.window;
121	};
122
123
124
125
126	var preservedScriptAttributes = {
127		type: true,
128		src: true,
129		noModule: true
130	};
131
132	function DOMEval( code, doc, node ) {
133		doc = doc || document;
134
135		var i,
136			script = doc.createElement( "script" );
137
138		script.text = code;
139		if ( node ) {
140			for ( i in preservedScriptAttributes ) {
141				if ( node[ i ] ) {
142					script[ i ] = node[ i ];
143				}
144			}
145		}
146		doc.head.appendChild( script ).parentNode.removeChild( script );
147	}
148
149
150function toType( obj ) {
151	if ( obj == null ) {
152		return obj + "";
153	}
154
155	// Support: Android <=2.3 only (functionish RegExp)
156	return typeof obj === "object" || typeof obj === "function" ?
157		class2type[ toString.call( obj ) ] || "object" :
158		typeof obj;
159}
160/* global Symbol */
161// Defining this global in .eslintrc.json would create a danger of using the global
162// unguarded in another place, it seems safer to define global only for this module
163
164
165
166var
167	version = "3.3.1",
168
169	// Define a local copy of jQuery
170	jQuery = function( selector, context ) {
171
172		// The jQuery object is actually just the init constructor 'enhanced'
173		// Need init if jQuery is called (just allow error to be thrown if not included)
174		return new jQuery.fn.init( selector, context );
175	},
176
177	// Support: Android <=4.0 only
178	// Make sure we trim BOM and NBSP
179	rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g;
180
181jQuery.fn = jQuery.prototype = {
182
183	// The current version of jQuery being used
184	jquery: version,
185
186	constructor: jQuery,
187
188	// The default length of a jQuery object is 0
189	length: 0,
190
191	toArray: function() {
192		return slice.call( this );
193	},
194
195	// Get the Nth element in the matched element set OR
196	// Get the whole matched element set as a clean array
197	get: function( num ) {
198
199		// Return all the elements in a clean array
200		if ( num == null ) {
201			return slice.call( this );
202		}
203
204		// Return just the one element from the set
205		return num < 0 ? this[ num + this.length ] : this[ num ];
206	},
207
208	// Take an array of elements and push it onto the stack
209	// (returning the new matched element set)
210	pushStack: function( elems ) {
211
212		// Build a new jQuery matched element set
213		var ret = jQuery.merge( this.constructor(), elems );
214
215		// Add the old object onto the stack (as a reference)
216		ret.prevObject = this;
217
218		// Return the newly-formed element set
219		return ret;
220	},
221
222	// Execute a callback for every element in the matched set.
223	each: function( callback ) {
224		return jQuery.each( this, callback );
225	},
226
227	map: function( callback ) {
228		return this.pushStack( jQuery.map( this, function( elem, i ) {
229			return callback.call( elem, i, elem );
230		} ) );
231	},
232
233	slice: function() {
234		return this.pushStack( slice.apply( this, arguments ) );
235	},
236
237	first: function() {
238		return this.eq( 0 );
239	},
240
241	last: function() {
242		return this.eq( -1 );
243	},
244
245	eq: function( i ) {
246		var len = this.length,
247			j = +i + ( i < 0 ? len : 0 );
248		return this.pushStack( j >= 0 && j < len ? [ this[ j ] ] : [] );
249	},
250
251	end: function() {
252		return this.prevObject || this.constructor();
253	},
254
255	// For internal use only.
256	// Behaves like an Array's method, not like a jQuery method.
257	push: push,
258	sort: arr.sort,
259	splice: arr.splice
260};
261
262jQuery.extend = jQuery.fn.extend = function() {
263	var options, name, src, copy, copyIsArray, clone,
264		target = arguments[ 0 ] || {},
265		i = 1,
266		length = arguments.length,
267		deep = false;
268
269	// Handle a deep copy situation
270	if ( typeof target === "boolean" ) {
271		deep = target;
272
273		// Skip the boolean and the target
274		target = arguments[ i ] || {};
275		i++;
276	}
277
278	// Handle case when target is a string or something (possible in deep copy)
279	if ( typeof target !== "object" && !isFunction( target ) ) {
280		target = {};
281	}
282
283	// Extend jQuery itself if only one argument is passed
284	if ( i === length ) {
285		target = this;
286		i--;
287	}
288
289	for ( ; i < length; i++ ) {
290
291		// Only deal with non-null/undefined values
292		if ( ( options = arguments[ i ] ) != null ) {
293
294			// Extend the base object
295			for ( name in options ) {
296				src = target[ name ];
297				copy = options[ name ];
298
299				// Prevent never-ending loop
300				if ( target === copy ) {
301					continue;
302				}
303
304				// Recurse if we're merging plain objects or arrays
305				if ( deep && copy && ( jQuery.isPlainObject( copy ) ||
306					( copyIsArray = Array.isArray( copy ) ) ) ) {
307
308					if ( copyIsArray ) {
309						copyIsArray = false;
310						clone = src && Array.isArray( src ) ? src : [];
311
312					} else {
313						clone = src && jQuery.isPlainObject( src ) ? src : {};
314					}
315
316					// Never move original objects, clone them
317					target[ name ] = jQuery.extend( deep, clone, copy );
318
319				// Don't bring in undefined values
320				} else if ( copy !== undefined ) {
321					target[ name ] = copy;
322				}
323			}
324		}
325	}
326
327	// Return the modified object
328	return target;
329};
330
331jQuery.extend( {
332
333	// Unique for each copy of jQuery on the page
334	expando: "jQuery" + ( version + Math.random() ).replace( /\D/g, "" ),
335
336	// Assume jQuery is ready without the ready module
337	isReady: true,
338
339	error: function( msg ) {
340		throw new Error( msg );
341	},
342
343	noop: function() {},
344
345	isPlainObject: function( obj ) {
346		var proto, Ctor;
347
348		// Detect obvious negatives
349		// Use toString instead of jQuery.type to catch host objects
350		if ( !obj || toString.call( obj ) !== "[object Object]" ) {
351			return false;
352		}
353
354		proto = getProto( obj );
355
356		// Objects with no prototype (e.g., `Object.create( null )`) are plain
357		if ( !proto ) {
358			return true;
359		}
360
361		// Objects with prototype are plain iff they were constructed by a global Object function
362		Ctor = hasOwn.call( proto, "constructor" ) && proto.constructor;
363		return typeof Ctor === "function" && fnToString.call( Ctor ) === ObjectFunctionString;
364	},
365
366	isEmptyObject: function( obj ) {
367
368		/* eslint-disable no-unused-vars */
369		// See https://github.com/eslint/eslint/issues/6125
370		var name;
371
372		for ( name in obj ) {
373			return false;
374		}
375		return true;
376	},
377
378	// Evaluates a script in a global context
379	globalEval: function( code ) {
380		DOMEval( code );
381	},
382
383	each: function( obj, callback ) {
384		var length, i = 0;
385
386		if ( isArrayLike( obj ) ) {
387			length = obj.length;
388			for ( ; i < length; i++ ) {
389				if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {
390					break;
391				}
392			}
393		} else {
394			for ( i in obj ) {
395				if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {
396					break;
397				}
398			}
399		}
400
401		return obj;
402	},
403
404	// Support: Android <=4.0 only
405	trim: function( text ) {
406		return text == null ?
407			"" :
408			( text + "" ).replace( rtrim, "" );
409	},
410
411	// results is for internal usage only
412	makeArray: function( arr, results ) {
413		var ret = results || [];
414
415		if ( arr != null ) {
416			if ( isArrayLike( Object( arr ) ) ) {
417				jQuery.merge( ret,
418					typeof arr === "string" ?
419					[ arr ] : arr
420				);
421			} else {
422				push.call( ret, arr );
423			}
424		}
425
426		return ret;
427	},
428
429	inArray: function( elem, arr, i ) {
430		return arr == null ? -1 : indexOf.call( arr, elem, i );
431	},
432
433	// Support: Android <=4.0 only, PhantomJS 1 only
434	// push.apply(_, arraylike) throws on ancient WebKit
435	merge: function( first, second ) {
436		var len = +second.length,
437			j = 0,
438			i = first.length;
439
440		for ( ; j < len; j++ ) {
441			first[ i++ ] = second[ j ];
442		}
443
444		first.length = i;
445
446		return first;
447	},
448
449	grep: function( elems, callback, invert ) {
450		var callbackInverse,
451			matches = [],
452			i = 0,
453			length = elems.length,
454			callbackExpect = !invert;
455
456		// Go through the array, only saving the items
457		// that pass the validator function
458		for ( ; i < length; i++ ) {
459			callbackInverse = !callback( elems[ i ], i );
460			if ( callbackInverse !== callbackExpect ) {
461				matches.push( elems[ i ] );
462			}
463		}
464
465		return matches;
466	},
467
468	// arg is for internal usage only
469	map: function( elems, callback, arg ) {
470		var length, value,
471			i = 0,
472			ret = [];
473
474		// Go through the array, translating each of the items to their new values
475		if ( isArrayLike( elems ) ) {
476			length = elems.length;
477			for ( ; i < length; i++ ) {
478				value = callback( elems[ i ], i, arg );
479
480				if ( value != null ) {
481					ret.push( value );
482				}
483			}
484
485		// Go through every key on the object,
486		} else {
487			for ( i in elems ) {
488				value = callback( elems[ i ], i, arg );
489
490				if ( value != null ) {
491					ret.push( value );
492				}
493			}
494		}
495
496		// Flatten any nested arrays
497		return concat.apply( [], ret );
498	},
499
500	// A global GUID counter for objects
501	guid: 1,
502
503	// jQuery.support is not used in Core but other projects attach their
504	// properties to it so it needs to exist.
505	support: support
506} );
507
508if ( typeof Symbol === "function" ) {
509	jQuery.fn[ Symbol.iterator ] = arr[ Symbol.iterator ];
510}
511
512// Populate the class2type map
513jQuery.each( "Boolean Number String Function Array Date RegExp Object Error Symbol".split( " " ),
514function( i, name ) {
515	class2type[ "[object " + name + "]" ] = name.toLowerCase();
516} );
517
518function isArrayLike( obj ) {
519
520	// Support: real iOS 8.2 only (not reproducible in simulator)
521	// `in` check used to prevent JIT error (gh-2145)
522	// hasOwn isn't used here due to false negatives
523	// regarding Nodelist length in IE
524	var length = !!obj && "length" in obj && obj.length,
525		type = toType( obj );
526
527	if ( isFunction( obj ) || isWindow( obj ) ) {
528		return false;
529	}
530
531	return type === "array" || length === 0 ||
532		typeof length === "number" && length > 0 && ( length - 1 ) in obj;
533}
534var Sizzle =
535/*!
536 * Sizzle CSS Selector Engine v2.3.3
537 * https://sizzlejs.com/
538 *
539 * Copyright jQuery Foundation and other contributors
540 * Released under the MIT license
541 * http://jquery.org/license
542 *
543 * Date: 2016-08-08
544 */
545(function( window ) {
546
547var i,
548	support,
549	Expr,
550	getText,
551	isXML,
552	tokenize,
553	compile,
554	select,
555	outermostContext,
556	sortInput,
557	hasDuplicate,
558
559	// Local document vars
560	setDocument,
561	document,
562	docElem,
563	documentIsHTML,
564	rbuggyQSA,
565	rbuggyMatches,
566	matches,
567	contains,
568
569	// Instance-specific data
570	expando = "sizzle" + 1 * new Date(),
571	preferredDoc = window.document,
572	dirruns = 0,
573	done = 0,
574	classCache = createCache(),
575	tokenCache = createCache(),
576	compilerCache = createCache(),
577	sortOrder = function( a, b ) {
578		if ( a === b ) {
579			hasDuplicate = true;
580		}
581		return 0;
582	},
583
584	// Instance methods
585	hasOwn = ({}).hasOwnProperty,
586	arr = [],
587	pop = arr.pop,
588	push_native = arr.push,
589	push = arr.push,
590	slice = arr.slice,
591	// Use a stripped-down indexOf as it's faster than native
592	// https://jsperf.com/thor-indexof-vs-for/5
593	indexOf = function( list, elem ) {
594		var i = 0,
595			len = list.length;
596		for ( ; i < len; i++ ) {
597			if ( list[i] === elem ) {
598				return i;
599			}
600		}
601		return -1;
602	},
603
604	booleans = "checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped",
605
606	// Regular expressions
607
608	// http://www.w3.org/TR/css3-selectors/#whitespace
609	whitespace = "[\\x20\\t\\r\\n\\f]",
610
611	// http://www.w3.org/TR/CSS21/syndata.html#value-def-identifier
612	identifier = "(?:\\\\.|[\\w-]|[^\0-\\xa0])+",
613
614	// Attribute selectors: http://www.w3.org/TR/selectors/#attribute-selectors
615	attributes = "\\[" + whitespace + "*(" + identifier + ")(?:" + whitespace +
616		// Operator (capture 2)
617		"*([*^$|!~]?=)" + whitespace +
618		// "Attribute values must be CSS identifiers [capture 5] or strings [capture 3 or capture 4]"
619		"*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|(" + identifier + "))|)" + whitespace +
620		"*\\]",
621
622	pseudos = ":(" + identifier + ")(?:\\((" +
623		// To reduce the number of selectors needing tokenize in the preFilter, prefer arguments:
624		// 1. quoted (capture 3; capture 4 or capture 5)
625		"('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|" +
626		// 2. simple (capture 6)
627		"((?:\\\\.|[^\\\\()[\\]]|" + attributes + ")*)|" +
628		// 3. anything else (capture 2)
629		".*" +
630		")\\)|)",
631
632	// Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter
633	rwhitespace = new RegExp( whitespace + "+", "g" ),
634	rtrim = new RegExp( "^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" + whitespace + "+$", "g" ),
635
636	rcomma = new RegExp( "^" + whitespace + "*," + whitespace + "*" ),
637	rcombinators = new RegExp( "^" + whitespace + "*([>+~]|" + whitespace + ")" + whitespace + "*" ),
638
639	rattributeQuotes = new RegExp( "=" + whitespace + "*([^\\]'\"]*?)" + whitespace + "*\\]", "g" ),
640
641	rpseudo = new RegExp( pseudos ),
642	ridentifier = new RegExp( "^" + identifier + "$" ),
643
644	matchExpr = {
645		"ID": new RegExp( "^#(" + identifier + ")" ),
646		"CLASS": new RegExp( "^\\.(" + identifier + ")" ),
647		"TAG": new RegExp( "^(" + identifier + "|[*])" ),
648		"ATTR": new RegExp( "^" + attributes ),
649		"PSEUDO": new RegExp( "^" + pseudos ),
650		"CHILD": new RegExp( "^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(" + whitespace +
651			"*(even|odd|(([+-]|)(\\d*)n|)" + whitespace + "*(?:([+-]|)" + whitespace +
652			"*(\\d+)|))" + whitespace + "*\\)|)", "i" ),
653		"bool": new RegExp( "^(?:" + booleans + ")$", "i" ),
654		// For use in libraries implementing .is()
655		// We use this for POS matching in `select`
656		"needsContext": new RegExp( "^" + whitespace + "*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(" +
657			whitespace + "*((?:-\\d)?\\d*)" + whitespace + "*\\)|)(?=[^-]|$)", "i" )
658	},
659
660	rinputs = /^(?:input|select|textarea|button)$/i,
661	rheader = /^h\d$/i,
662
663	rnative = /^[^{]+\{\s*\[native \w/,
664
665	// Easily-parseable/retrievable ID or TAG or CLASS selectors
666	rquickExpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,
667
668	rsibling = /[+~]/,
669
670	// CSS escapes
671	// http://www.w3.org/TR/CSS21/syndata.html#escaped-characters
672	runescape = new RegExp( "\\\\([\\da-f]{1,6}" + whitespace + "?|(" + whitespace + ")|.)", "ig" ),
673	funescape = function( _, escaped, escapedWhitespace ) {
674		var high = "0x" + escaped - 0x10000;
675		// NaN means non-codepoint
676		// Support: Firefox<24
677		// Workaround erroneous numeric interpretation of +"0x"
678		return high !== high || escapedWhitespace ?
679			escaped :
680			high < 0 ?
681				// BMP codepoint
682				String.fromCharCode( high + 0x10000 ) :
683				// Supplemental Plane codepoint (surrogate pair)
684				String.fromCharCode( high >> 10 | 0xD800, high & 0x3FF | 0xDC00 );
685	},
686
687	// CSS string/identifier serialization
688	// https://drafts.csswg.org/cssom/#common-serializing-idioms
689	rcssescape = /([\0-\x1f\x7f]|^-?\d)|^-$|[^\0-\x1f\x7f-\uFFFF\w-]/g,
690	fcssescape = function( ch, asCodePoint ) {
691		if ( asCodePoint ) {
692
693			// U+0000 NULL becomes U+FFFD REPLACEMENT CHARACTER
694			if ( ch === "\0" ) {
695				return "\uFFFD";
696			}
697
698			// Control characters and (dependent upon position) numbers get escaped as code points
699			return ch.slice( 0, -1 ) + "\\" + ch.charCodeAt( ch.length - 1 ).toString( 16 ) + " ";
700		}
701
702		// Other potentially-special ASCII characters get backslash-escaped
703		return "\\" + ch;
704	},
705
706	// Used for iframes
707	// See setDocument()
708	// Removing the function wrapper causes a "Permission Denied"
709	// error in IE
710	unloadHandler = function() {
711		setDocument();
712	},
713
714	disabledAncestor = addCombinator(
715		function( elem ) {
716			return elem.disabled === true && ("form" in elem || "label" in elem);
717		},
718		{ dir: "parentNode", next: "legend" }
719	);
720
721// Optimize for push.apply( _, NodeList )
722try {
723	push.apply(
724		(arr = slice.call( preferredDoc.childNodes )),
725		preferredDoc.childNodes
726	);
727	// Support: Android<4.0
728	// Detect silently failing push.apply
729	arr[ preferredDoc.childNodes.length ].nodeType;
730} catch ( e ) {
731	push = { apply: arr.length ?
732
733		// Leverage slice if possible
734		function( target, els ) {
735			push_native.apply( target, slice.call(els) );
736		} :
737
738		// Support: IE<9
739		// Otherwise append directly
740		function( target, els ) {
741			var j = target.length,
742				i = 0;
743			// Can't trust NodeList.length
744			while ( (target[j++] = els[i++]) ) {}
745			target.length = j - 1;
746		}
747	};
748}
749
750function Sizzle( selector, context, results, seed ) {
751	var m, i, elem, nid, match, groups, newSelector,
752		newContext = context && context.ownerDocument,
753
754		// nodeType defaults to 9, since context defaults to document
755		nodeType = context ? context.nodeType : 9;
756
757	results = results || [];
758
759	// Return early from calls with invalid selector or context
760	if ( typeof selector !== "string" || !selector ||
761		nodeType !== 1 && nodeType !== 9 && nodeType !== 11 ) {
762
763		return results;
764	}
765
766	// Try to shortcut find operations (as opposed to filters) in HTML documents
767	if ( !seed ) {
768
769		if ( ( context ? context.ownerDocument || context : preferredDoc ) !== document ) {
770			setDocument( context );
771		}
772		context = context || document;
773
774		if ( documentIsHTML ) {
775
776			// If the selector is sufficiently simple, try using a "get*By*" DOM method
777			// (excepting DocumentFragment context, where the methods don't exist)
778			if ( nodeType !== 11 && (match = rquickExpr.exec( selector )) ) {
779
780				// ID selector
781				if ( (m = match[1]) ) {
782
783					// Document context
784					if ( nodeType === 9 ) {
785						if ( (elem = context.getElementById( m )) ) {
786
787							// Support: IE, Opera, Webkit
788							// TODO: identify versions
789							// getElementById can match elements by name instead of ID
790							if ( elem.id === m ) {
791								results.push( elem );
792								return results;
793							}
794						} else {
795							return results;
796						}
797
798					// Element context
799					} else {
800
801						// Support: IE, Opera, Webkit
802						// TODO: identify versions
803						// getElementById can match elements by name instead of ID
804						if ( newContext && (elem = newContext.getElementById( m )) &&
805							contains( context, elem ) &&
806							elem.id === m ) {
807
808							results.push( elem );
809							return results;
810						}
811					}
812
813				// Type selector
814				} else if ( match[2] ) {
815					push.apply( results, context.getElementsByTagName( selector ) );
816					return results;
817
818				// Class selector
819				} else if ( (m = match[3]) && support.getElementsByClassName &&
820					context.getElementsByClassName ) {
821
822					push.apply( results, context.getElementsByClassName( m ) );
823					return results;
824				}
825			}
826
827			// Take advantage of querySelectorAll
828			if ( support.qsa &&
829				!compilerCache[ selector + " " ] &&
830				(!rbuggyQSA || !rbuggyQSA.test( selector )) ) {
831
832				if ( nodeType !== 1 ) {
833					newContext = context;
834					newSelector = selector;
835
836				// qSA looks outside Element context, which is not what we want
837				// Thanks to Andrew Dupont for this workaround technique
838				// Support: IE <=8
839				// Exclude object elements
840				} else if ( context.nodeName.toLowerCase() !== "object" ) {
841
842					// Capture the context ID, setting it first if necessary
843					if ( (nid = context.getAttribute( "id" )) ) {
844						nid = nid.replace( rcssescape, fcssescape );
845					} else {
846						context.setAttribute( "id", (nid = expando) );
847					}
848
849					// Prefix every selector in the list
850					groups = tokenize( selector );
851					i = groups.length;
852					while ( i-- ) {
853						groups[i] = "#" + nid + " " + toSelector( groups[i] );
854					}
855					newSelector = groups.join( "," );
856
857					// Expand context for sibling selectors
858					newContext = rsibling.test( selector ) && testContext( context.parentNode ) ||
859						context;
860				}
861
862				if ( newSelector ) {
863					try {
864						push.apply( results,
865							newContext.querySelectorAll( newSelector )
866						);
867						return results;
868					} catch ( qsaError ) {
869					} finally {
870						if ( nid === expando ) {
871							context.removeAttribute( "id" );
872						}
873					}
874				}
875			}
876		}
877	}
878
879	// All others
880	return select( selector.replace( rtrim, "$1" ), context, results, seed );
881}
882
883/**
884 * Create key-value caches of limited size
885 * @returns {function(string, object)} Returns the Object data after storing it on itself with
886 *	property name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength)
887 *	deleting the oldest entry
888 */
889function createCache() {
890	var keys = [];
891
892	function cache( key, value ) {
893		// Use (key + " ") to avoid collision with native prototype properties (see Issue #157)
894		if ( keys.push( key + " " ) > Expr.cacheLength ) {
895			// Only keep the most recent entries
896			delete cache[ keys.shift() ];
897		}
898		return (cache[ key + " " ] = value);
899	}
900	return cache;
901}
902
903/**
904 * Mark a function for special use by Sizzle
905 * @param {Function} fn The function to mark
906 */
907function markFunction( fn ) {
908	fn[ expando ] = true;
909	return fn;
910}
911
912/**
913 * Support testing using an element
914 * @param {Function} fn Passed the created element and returns a boolean result
915 */
916function assert( fn ) {
917	var el = document.createElement("fieldset");
918
919	try {
920		return !!fn( el );
921	} catch (e) {
922		return false;
923	} finally {
924		// Remove from its parent by default
925		if ( el.parentNode ) {
926			el.parentNode.removeChild( el );
927		}
928		// release memory in IE
929		el = null;
930	}
931}
932
933/**
934 * Adds the same handler for all of the specified attrs
935 * @param {String} attrs Pipe-separated list of attributes
936 * @param {Function} handler The method that will be applied
937 */
938function addHandle( attrs, handler ) {
939	var arr = attrs.split("|"),
940		i = arr.length;
941
942	while ( i-- ) {
943		Expr.attrHandle[ arr[i] ] = handler;
944	}
945}
946
947/**
948 * Checks document order of two siblings
949 * @param {Element} a
950 * @param {Element} b
951 * @returns {Number} Returns less than 0 if a precedes b, greater than 0 if a follows b
952 */
953function siblingCheck( a, b ) {
954	var cur = b && a,
955		diff = cur && a.nodeType === 1 && b.nodeType === 1 &&
956			a.sourceIndex - b.sourceIndex;
957
958	// Use IE sourceIndex if available on both nodes
959	if ( diff ) {
960		return diff;
961	}
962
963	// Check if b follows a
964	if ( cur ) {
965		while ( (cur = cur.nextSibling) ) {
966			if ( cur === b ) {
967				return -1;
968			}
969		}
970	}
971
972	return a ? 1 : -1;
973}
974
975/**
976 * Returns a function to use in pseudos for input types
977 * @param {String} type
978 */
979function createInputPseudo( type ) {
980	return function( elem ) {
981		var name = elem.nodeName.toLowerCase();
982		return name === "input" && elem.type === type;
983	};
984}
985
986/**
987 * Returns a function to use in pseudos for buttons
988 * @param {String} type
989 */
990function createButtonPseudo( type ) {
991	return function( elem ) {
992		var name = elem.nodeName.toLowerCase();
993		return (name === "input" || name === "button") && elem.type === type;
994	};
995}
996
997/**
998 * Returns a function to use in pseudos for :enabled/:disabled
999 * @param {Boolean} disabled true for :disabled; false for :enabled
1000 */
1001function createDisabledPseudo( disabled ) {
1002
1003	// Known :disabled false positives: fieldset[disabled] > legend:nth-of-type(n+2) :can-disable
1004	return function( elem ) {
1005
1006		// Only certain elements can match :enabled or :disabled
1007		// https://html.spec.whatwg.org/multipage/scripting.html#selector-enabled
1008		// https://html.spec.whatwg.org/multipage/scripting.html#selector-disabled
1009		if ( "form" in elem ) {
1010
1011			// Check for inherited disabledness on relevant non-disabled elements:
1012			// * listed form-associated elements in a disabled fieldset
1013			//   https://html.spec.whatwg.org/multipage/forms.html#category-listed
1014			//   https://html.spec.whatwg.org/multipage/forms.html#concept-fe-disabled
1015			// * option elements in a disabled optgroup
1016			//   https://html.spec.whatwg.org/multipage/forms.html#concept-option-disabled
1017			// All such elements have a "form" property.
1018			if ( elem.parentNode && elem.disabled === false ) {
1019
1020				// Option elements defer to a parent optgroup if present
1021				if ( "label" in elem ) {
1022					if ( "label" in elem.parentNode ) {
1023						return elem.parentNode.disabled === disabled;
1024					} else {
1025						return elem.disabled === disabled;
1026					}
1027				}
1028
1029				// Support: IE 6 - 11
1030				// Use the isDisabled shortcut property to check for disabled fieldset ancestors
1031				return elem.isDisabled === disabled ||
1032
1033					// Where there is no isDisabled, check manually
1034					/* jshint -W018 */
1035					elem.isDisabled !== !disabled &&
1036						disabledAncestor( elem ) === disabled;
1037			}
1038
1039			return elem.disabled === disabled;
1040
1041		// Try to winnow out elements that can't be disabled before trusting the disabled property.
1042		// Some victims get caught in our net (label, legend, menu, track), but it shouldn't
1043		// even exist on them, let alone have a boolean value.
1044		} else if ( "label" in elem ) {
1045			return elem.disabled === disabled;
1046		}
1047
1048		// Remaining elements are neither :enabled nor :disabled
1049		return false;
1050	};
1051}
1052
1053/**
1054 * Returns a function to use in pseudos for positionals
1055 * @param {Function} fn
1056 */
1057function createPositionalPseudo( fn ) {
1058	return markFunction(function( argument ) {
1059		argument = +argument;
1060		return markFunction(function( seed, matches ) {
1061			var j,
1062				matchIndexes = fn( [], seed.length, argument ),
1063				i = matchIndexes.length;
1064
1065			// Match elements found at the specified indexes
1066			while ( i-- ) {
1067				if ( seed[ (j = matchIndexes[i]) ] ) {
1068					seed[j] = !(matches[j] = seed[j]);
1069				}
1070			}
1071		});
1072	});
1073}
1074
1075/**
1076 * Checks a node for validity as a Sizzle context
1077 * @param {Element|Object=} context
1078 * @returns {Element|Object|Boolean} The input node if acceptable, otherwise a falsy value
1079 */
1080function testContext( context ) {
1081	return context && typeof context.getElementsByTagName !== "undefined" && context;
1082}
1083
1084// Expose support vars for convenience
1085support = Sizzle.support = {};
1086
1087/**
1088 * Detects XML nodes
1089 * @param {Element|Object} elem An element or a document
1090 * @returns {Boolean} True iff elem is a non-HTML XML node
1091 */
1092isXML = Sizzle.isXML = function( elem ) {
1093	// documentElement is verified for cases where it doesn't yet exist
1094	// (such as loading iframes in IE - #4833)
1095	var documentElement = elem && (elem.ownerDocument || elem).documentElement;
1096	return documentElement ? documentElement.nodeName !== "HTML" : false;
1097};
1098
1099/**
1100 * Sets document-related variables once based on the current document
1101 * @param {Element|Object} [doc] An element or document object to use to set the document
1102 * @returns {Object} Returns the current document
1103 */
1104setDocument = Sizzle.setDocument = function( node ) {
1105	var hasCompare, subWindow,
1106		doc = node ? node.ownerDocument || node : preferredDoc;
1107
1108	// Return early if doc is invalid or already selected
1109	if ( doc === document || doc.nodeType !== 9 || !doc.documentElement ) {
1110		return document;
1111	}
1112
1113	// Update global variables
1114	document = doc;
1115	docElem = document.documentElement;
1116	documentIsHTML = !isXML( document );
1117
1118	// Support: IE 9-11, Edge
1119	// Accessing iframe documents after unload throws "permission denied" errors (jQuery #13936)
1120	if ( preferredDoc !== document &&
1121		(subWindow = document.defaultView) && subWindow.top !== subWindow ) {
1122
1123		// Support: IE 11, Edge
1124		if ( subWindow.addEventListener ) {
1125			subWindow.addEventListener( "unload", unloadHandler, false );
1126
1127		// Support: IE 9 - 10 only
1128		} else if ( subWindow.attachEvent ) {
1129			subWindow.attachEvent( "onunload", unloadHandler );
1130		}
1131	}
1132
1133	/* Attributes
1134	---------------------------------------------------------------------- */
1135
1136	// Support: IE<8
1137	// Verify that getAttribute really returns attributes and not properties
1138	// (excepting IE8 booleans)
1139	support.attributes = assert(function( el ) {
1140		el.className = "i";
1141		return !el.getAttribute("className");
1142	});
1143
1144	/* getElement(s)By*
1145	---------------------------------------------------------------------- */
1146
1147	// Check if getElementsByTagName("*") returns only elements
1148	support.getElementsByTagName = assert(function( el ) {
1149		el.appendChild( document.createComment("") );
1150		return !el.getElementsByTagName("*").length;
1151	});
1152
1153	// Support: IE<9
1154	support.getElementsByClassName = rnative.test( document.getElementsByClassName );
1155
1156	// Support: IE<10
1157	// Check if getElementById returns elements by name
1158	// The broken getElementById methods don't pick up programmatically-set names,
1159	// so use a roundabout getElementsByName test
1160	support.getById = assert(function( el ) {
1161		docElem.appendChild( el ).id = expando;
1162		return !document.getElementsByName || !document.getElementsByName( expando ).length;
1163	});
1164
1165	// ID filter and find
1166	if ( support.getById ) {
1167		Expr.filter["ID"] = function( id ) {
1168			var attrId = id.replace( runescape, funescape );
1169			return function( elem ) {
1170				return elem.getAttribute("id") === attrId;
1171			};
1172		};
1173		Expr.find["ID"] = function( id, context ) {
1174			if ( typeof context.getElementById !== "undefined" && documentIsHTML ) {
1175				var elem = context.getElementById( id );
1176				return elem ? [ elem ] : [];
1177			}
1178		};
1179	} else {
1180		Expr.filter["ID"] =  function( id ) {
1181			var attrId = id.replace( runescape, funescape );
1182			return function( elem ) {
1183				var node = typeof elem.getAttributeNode !== "undefined" &&
1184					elem.getAttributeNode("id");
1185				return node && node.value === attrId;
1186			};
1187		};
1188
1189		// Support: IE 6 - 7 only
1190		// getElementById is not reliable as a find shortcut
1191		Expr.find["ID"] = function( id, context ) {
1192			if ( typeof context.getElementById !== "undefined" && documentIsHTML ) {
1193				var node, i, elems,
1194					elem = context.getElementById( id );
1195
1196				if ( elem ) {
1197
1198					// Verify the id attribute
1199					node = elem.getAttributeNode("id");
1200					if ( node && node.value === id ) {
1201						return [ elem ];
1202					}
1203
1204					// Fall back on getElementsByName
1205					elems = context.getElementsByName( id );
1206					i = 0;
1207					while ( (elem = elems[i++]) ) {
1208						node = elem.getAttributeNode("id");
1209						if ( node && node.value === id ) {
1210							return [ elem ];
1211						}
1212					}
1213				}
1214
1215				return [];
1216			}
1217		};
1218	}
1219
1220	// Tag
1221	Expr.find["TAG"] = support.getElementsByTagName ?
1222		function( tag, context ) {
1223			if ( typeof context.getElementsByTagName !== "undefined" ) {
1224				return context.getElementsByTagName( tag );
1225
1226			// DocumentFragment nodes don't have gEBTN
1227			} else if ( support.qsa ) {
1228				return context.querySelectorAll( tag );
1229			}
1230		} :
1231
1232		function( tag, context ) {
1233			var elem,
1234				tmp = [],
1235				i = 0,
1236				// By happy coincidence, a (broken) gEBTN appears on DocumentFragment nodes too
1237				results = context.getElementsByTagName( tag );
1238
1239			// Filter out possible comments
1240			if ( tag === "*" ) {
1241				while ( (elem = results[i++]) ) {
1242					if ( elem.nodeType === 1 ) {
1243						tmp.push( elem );
1244					}
1245				}
1246
1247				return tmp;
1248			}
1249			return results;
1250		};
1251
1252	// Class
1253	Expr.find["CLASS"] = support.getElementsByClassName && function( className, context ) {
1254		if ( typeof context.getElementsByClassName !== "undefined" && documentIsHTML ) {
1255			return context.getElementsByClassName( className );
1256		}
1257	};
1258
1259	/* QSA/matchesSelector
1260	---------------------------------------------------------------------- */
1261
1262	// QSA and matchesSelector support
1263
1264	// matchesSelector(:active) reports false when true (IE9/Opera 11.5)
1265	rbuggyMatches = [];
1266
1267	// qSa(:focus) reports false when true (Chrome 21)
1268	// We allow this because of a bug in IE8/9 that throws an error
1269	// whenever `document.activeElement` is accessed on an iframe
1270	// So, we allow :focus to pass through QSA all the time to avoid the IE error
1271	// See https://bugs.jquery.com/ticket/13378
1272	rbuggyQSA = [];
1273
1274	if ( (support.qsa = rnative.test( document.querySelectorAll )) ) {
1275		// Build QSA regex
1276		// Regex strategy adopted from Diego Perini
1277		assert(function( el ) {
1278			// Select is set to empty string on purpose
1279			// This is to test IE's treatment of not explicitly
1280			// setting a boolean content attribute,
1281			// since its presence should be enough
1282			// https://bugs.jquery.com/ticket/12359
1283			docElem.appendChild( el ).innerHTML = "<a id='" + expando + "'></a>" +
1284				"<select id='" + expando + "-\r\\' msallowcapture=''>" +
1285				"<option selected=''></option></select>";
1286
1287			// Support: IE8, Opera 11-12.16
1288			// Nothing should be selected when empty strings follow ^= or $= or *=
1289			// The test attribute must be unknown in Opera but "safe" for WinRT
1290			// https://msdn.microsoft.com/en-us/library/ie/hh465388.aspx#attribute_section
1291			if ( el.querySelectorAll("[msallowcapture^='']").length ) {
1292				rbuggyQSA.push( "[*^$]=" + whitespace + "*(?:''|\"\")" );
1293			}
1294
1295			// Support: IE8
1296			// Boolean attributes and "value" are not treated correctly
1297			if ( !el.querySelectorAll("[selected]").length ) {
1298				rbuggyQSA.push( "\\[" + whitespace + "*(?:value|" + booleans + ")" );
1299			}
1300
1301			// Support: Chrome<29, Android<4.4, Safari<7.0+, iOS<7.0+, PhantomJS<1.9.8+
1302			if ( !el.querySelectorAll( "[id~=" + expando + "-]" ).length ) {
1303				rbuggyQSA.push("~=");
1304			}
1305
1306			// Webkit/Opera - :checked should return selected option elements
1307			// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
1308			// IE8 throws error here and will not see later tests
1309			if ( !el.querySelectorAll(":checked").length ) {
1310				rbuggyQSA.push(":checked");
1311			}
1312
1313			// Support: Safari 8+, iOS 8+
1314			// https://bugs.webkit.org/show_bug.cgi?id=136851
1315			// In-page `selector#id sibling-combinator selector` fails
1316			if ( !el.querySelectorAll( "a#" + expando + "+*" ).length ) {
1317				rbuggyQSA.push(".#.+[+~]");
1318			}
1319		});
1320
1321		assert(function( el ) {
1322			el.innerHTML = "<a href='' disabled='disabled'></a>" +
1323				"<select disabled='disabled'><option/></select>";
1324
1325			// Support: Windows 8 Native Apps
1326			// The type and name attributes are restricted during .innerHTML assignment
1327			var input = document.createElement("input");
1328			input.setAttribute( "type", "hidden" );
1329			el.appendChild( input ).setAttribute( "name", "D" );
1330
1331			// Support: IE8
1332			// Enforce case-sensitivity of name attribute
1333			if ( el.querySelectorAll("[name=d]").length ) {
1334				rbuggyQSA.push( "name" + whitespace + "*[*^$|!~]?=" );
1335			}
1336
1337			// FF 3.5 - :enabled/:disabled and hidden elements (hidden elements are still enabled)
1338			// IE8 throws error here and will not see later tests
1339			if ( el.querySelectorAll(":enabled").length !== 2 ) {
1340				rbuggyQSA.push( ":enabled", ":disabled" );
1341			}
1342
1343			// Support: IE9-11+
1344			// IE's :disabled selector does not pick up the children of disabled fieldsets
1345			docElem.appendChild( el ).disabled = true;
1346			if ( el.querySelectorAll(":disabled").length !== 2 ) {
1347				rbuggyQSA.push( ":enabled", ":disabled" );
1348			}
1349
1350			// Opera 10-11 does not throw on post-comma invalid pseudos
1351			el.querySelectorAll("*,:x");
1352			rbuggyQSA.push(",.*:");
1353		});
1354	}
1355
1356	if ( (support.matchesSelector = rnative.test( (matches = docElem.matches ||
1357		docElem.webkitMatchesSelector ||
1358		docElem.mozMatchesSelector ||
1359		docElem.oMatchesSelector ||
1360		docElem.msMatchesSelector) )) ) {
1361
1362		assert(function( el ) {
1363			// Check to see if it's possible to do matchesSelector
1364			// on a disconnected node (IE 9)
1365			support.disconnectedMatch = matches.call( el, "*" );
1366
1367			// This should fail with an exception
1368			// Gecko does not error, returns false instead
1369			matches.call( el, "[s!='']:x" );
1370			rbuggyMatches.push( "!=", pseudos );
1371		});
1372	}
1373
1374	rbuggyQSA = rbuggyQSA.length && new RegExp( rbuggyQSA.join("|") );
1375	rbuggyMatches = rbuggyMatches.length && new RegExp( rbuggyMatches.join("|") );
1376
1377	/* Contains
1378	---------------------------------------------------------------------- */
1379	hasCompare = rnative.test( docElem.compareDocumentPosition );
1380
1381	// Element contains another
1382	// Purposefully self-exclusive
1383	// As in, an element does not contain itself
1384	contains = hasCompare || rnative.test( docElem.contains ) ?
1385		function( a, b ) {
1386			var adown = a.nodeType === 9 ? a.documentElement : a,
1387				bup = b && b.parentNode;
1388			return a === bup || !!( bup && bup.nodeType === 1 && (
1389				adown.contains ?
1390					adown.contains( bup ) :
1391					a.compareDocumentPosition && a.compareDocumentPosition( bup ) & 16
1392			));
1393		} :
1394		function( a, b ) {
1395			if ( b ) {
1396				while ( (b = b.parentNode) ) {
1397					if ( b === a ) {
1398						return true;
1399					}
1400				}
1401			}
1402			return false;
1403		};
1404
1405	/* Sorting
1406	---------------------------------------------------------------------- */
1407
1408	// Document order sorting
1409	sortOrder = hasCompare ?
1410	function( a, b ) {
1411
1412		// Flag for duplicate removal
1413		if ( a === b ) {
1414			hasDuplicate = true;
1415			return 0;
1416		}
1417
1418		// Sort on method existence if only one input has compareDocumentPosition
1419		var compare = !a.compareDocumentPosition - !b.compareDocumentPosition;
1420		if ( compare ) {
1421			return compare;
1422		}
1423
1424		// Calculate position if both inputs belong to the same document
1425		compare = ( a.ownerDocument || a ) === ( b.ownerDocument || b ) ?
1426			a.compareDocumentPosition( b ) :
1427
1428			// Otherwise we know they are disconnected
1429			1;
1430
1431		// Disconnected nodes
1432		if ( compare & 1 ||
1433			(!support.sortDetached && b.compareDocumentPosition( a ) === compare) ) {
1434
1435			// Choose the first element that is related to our preferred document
1436			if ( a === document || a.ownerDocument === preferredDoc && contains(preferredDoc, a) ) {
1437				return -1;
1438			}
1439			if ( b === document || b.ownerDocument === preferredDoc && contains(preferredDoc, b) ) {
1440				return 1;
1441			}
1442
1443			// Maintain original order
1444			return sortInput ?
1445				( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) :
1446				0;
1447		}
1448
1449		return compare & 4 ? -1 : 1;
1450	} :
1451	function( a, b ) {
1452		// Exit early if the nodes are identical
1453		if ( a === b ) {
1454			hasDuplicate = true;
1455			return 0;
1456		}
1457
1458		var cur,
1459			i = 0,
1460			aup = a.parentNode,
1461			bup = b.parentNode,
1462			ap = [ a ],
1463			bp = [ b ];
1464
1465		// Parentless nodes are either documents or disconnected
1466		if ( !aup || !bup ) {
1467			return a === document ? -1 :
1468				b === document ? 1 :
1469				aup ? -1 :
1470				bup ? 1 :
1471				sortInput ?
1472				( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) :
1473				0;
1474
1475		// If the nodes are siblings, we can do a quick check
1476		} else if ( aup === bup ) {
1477			return siblingCheck( a, b );
1478		}
1479
1480		// Otherwise we need full lists of their ancestors for comparison
1481		cur = a;
1482		while ( (cur = cur.parentNode) ) {
1483			ap.unshift( cur );
1484		}
1485		cur = b;
1486		while ( (cur = cur.parentNode) ) {
1487			bp.unshift( cur );
1488		}
1489
1490		// Walk down the tree looking for a discrepancy
1491		while ( ap[i] === bp[i] ) {
1492			i++;
1493		}
1494
1495		return i ?
1496			// Do a sibling check if the nodes have a common ancestor
1497			siblingCheck( ap[i], bp[i] ) :
1498
1499			// Otherwise nodes in our document sort first
1500			ap[i] === preferredDoc ? -1 :
1501			bp[i] === preferredDoc ? 1 :
1502			0;
1503	};
1504
1505	return document;
1506};
1507
1508Sizzle.matches = function( expr, elements ) {
1509	return Sizzle( expr, null, null, elements );
1510};
1511
1512Sizzle.matchesSelector = function( elem, expr ) {
1513	// Set document vars if needed
1514	if ( ( elem.ownerDocument || elem ) !== document ) {
1515		setDocument( elem );
1516	}
1517
1518	// Make sure that attribute selectors are quoted
1519	expr = expr.replace( rattributeQuotes, "='$1']" );
1520
1521	if ( support.matchesSelector && documentIsHTML &&
1522		!compilerCache[ expr + " " ] &&
1523		( !rbuggyMatches || !rbuggyMatches.test( expr ) ) &&
1524		( !rbuggyQSA     || !rbuggyQSA.test( expr ) ) ) {
1525
1526		try {
1527			var ret = matches.call( elem, expr );
1528
1529			// IE 9's matchesSelector returns false on disconnected nodes
1530			if ( ret || support.disconnectedMatch ||
1531					// As well, disconnected nodes are said to be in a document
1532					// fragment in IE 9
1533					elem.document && elem.document.nodeType !== 11 ) {
1534				return ret;
1535			}
1536		} catch (e) {}
1537	}
1538
1539	return Sizzle( expr, document, null, [ elem ] ).length > 0;
1540};
1541
1542Sizzle.contains = function( context, elem ) {
1543	// Set document vars if needed
1544	if ( ( context.ownerDocument || context ) !== document ) {
1545		setDocument( context );
1546	}
1547	return contains( context, elem );
1548};
1549
1550Sizzle.attr = function( elem, name ) {
1551	// Set document vars if needed
1552	if ( ( elem.ownerDocument || elem ) !== document ) {
1553		setDocument( elem );
1554	}
1555
1556	var fn = Expr.attrHandle[ name.toLowerCase() ],
1557		// Don't get fooled by Object.prototype properties (jQuery #13807)
1558		val = fn && hasOwn.call( Expr.attrHandle, name.toLowerCase() ) ?
1559			fn( elem, name, !documentIsHTML ) :
1560			undefined;
1561
1562	return val !== undefined ?
1563		val :
1564		support.attributes || !documentIsHTML ?
1565			elem.getAttribute( name ) :
1566			(val = elem.getAttributeNode(name)) && val.specified ?
1567				val.value :
1568				null;
1569};
1570
1571Sizzle.escape = function( sel ) {
1572	return (sel + "").replace( rcssescape, fcssescape );
1573};
1574
1575Sizzle.error = function( msg ) {
1576	throw new Error( "Syntax error, unrecognized expression: " + msg );
1577};
1578
1579/**
1580 * Document sorting and removing duplicates
1581 * @param {ArrayLike} results
1582 */
1583Sizzle.uniqueSort = function( results ) {
1584	var elem,
1585		duplicates = [],
1586		j = 0,
1587		i = 0;
1588
1589	// Unless we *know* we can detect duplicates, assume their presence
1590	hasDuplicate = !support.detectDuplicates;
1591	sortInput = !support.sortStable && results.slice( 0 );
1592	results.sort( sortOrder );
1593
1594	if ( hasDuplicate ) {
1595		while ( (elem = results[i++]) ) {
1596			if ( elem === results[ i ] ) {
1597				j = duplicates.push( i );
1598			}
1599		}
1600		while ( j-- ) {
1601			results.splice( duplicates[ j ], 1 );
1602		}
1603	}
1604
1605	// Clear input after sorting to release objects
1606	// See https://github.com/jquery/sizzle/pull/225
1607	sortInput = null;
1608
1609	return results;
1610};
1611
1612/**
1613 * Utility function for retrieving the text value of an array of DOM nodes
1614 * @param {Array|Element} elem
1615 */
1616getText = Sizzle.getText = function( elem ) {
1617	var node,
1618		ret = "",
1619		i = 0,
1620		nodeType = elem.nodeType;
1621
1622	if ( !nodeType ) {
1623		// If no nodeType, this is expected to be an array
1624		while ( (node = elem[i++]) ) {

1625			// Do not traverse comment nodes
1626			ret += getText( node );
1627		}
1628	} else if ( nodeType === 1 || nodeType === 9 || nodeType === 11 ) {
1629		// Use textContent for elements
1630		// innerText usage removed for consistency of new lines (jQuery #11153)
1631		if ( typeof elem.textContent === "string" ) {
1632			return elem.textContent;
1633		} else {
1634			// Traverse its children
1635			for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
1636				ret += getText( elem );
1637			}
1638		}
1639	} else if ( nodeType === 3 || nodeType === 4 ) {
1640		return elem.nodeValue;
1641	}
1642	// Do not include comment or processing instruction nodes
1643
1644	return ret;
1645};
1646
1647Expr = Sizzle.selectors = {
1648
1649	// Can be adjusted by the user
1650	cacheLength: 50,
1651
1652	createPseudo: markFunction,
1653
1654	match: matchExpr,
1655
1656	attrHandle: {},
1657
1658	find: {},
1659
1660	relative: {
1661		">": { dir: "parentNode", first: true },
1662		" ": { dir: "parentNode" },
1663		"+": { dir: "previousSibling", first: true },
1664		"~": { dir: "previousSibling" }
1665	},
1666
1667	preFilter: {
1668		"ATTR": function( match ) {
1669			match[1] = match[1].replace( runescape, funescape );
1670
1671			// Move the given value to match[3] whether quoted or unquoted
1672			match[3] = ( match[3] || match[4] || match[5] || "" ).replace( runescape, funescape );
1673
1674			if ( match[2] === "~=" ) {
1675				match[3] = " " + match[3] + " ";
1676			}
1677
1678			return match.slice( 0, 4 );
1679		},
1680
1681		"CHILD": function( match ) {
1682			/* matches from matchExpr["CHILD"]
1683				1 type (only|nth|...)
1684				2 what (child|of-type)
1685				3 argument (even|odd|\d*|\d*n([+-]\d+)?|...)
1686				4 xn-component of xn+y argument ([+-]?\d*n|)
1687				5 sign of xn-component
1688				6 x of xn-component
1689				7 sign of y-component
1690				8 y of y-component
1691			*/
1692			match[1] = match[1].toLowerCase();
1693
1694			if ( match[1].slice( 0, 3 ) === "nth" ) {
1695				// nth-* requires argument
1696				if ( !match[3] ) {
1697					Sizzle.error( match[0] );
1698				}
1699
1700				// numeric x and y parameters for Expr.filter.CHILD
1701				// remember that false/true cast respectively to 0/1
1702				match[4] = +( match[4] ? match[5] + (match[6] || 1) : 2 * ( match[3] === "even" || match[3] === "odd" ) );
1703				match[5] = +( ( match[7] + match[8] ) || match[3] === "odd" );
1704
1705			// other types prohibit arguments
1706			} else if ( match[3] ) {
1707				Sizzle.error( match[0] );
1708			}
1709
1710			return match;
1711		},
1712
1713		"PSEUDO": function( match ) {
1714			var excess,
1715				unquoted = !match[6] && match[2];
1716
1717			if ( matchExpr["CHILD"].test( match[0] ) ) {
1718				return null;
1719			}
1720
1721			// Accept quoted arguments as-is
1722			if ( match[3] ) {
1723				match[2] = match[4] || match[5] || "";
1724
1725			// Strip excess characters from unquoted arguments
1726			} else if ( unquoted && rpseudo.test( unquoted ) &&
1727				// Get excess from tokenize (recursively)
1728				(excess = tokenize( unquoted, true )) &&
1729				// advance to the next closing parenthesis
1730				(excess = unquoted.indexOf( ")", unquoted.length - excess ) - unquoted.length) ) {
1731
1732				// excess is a negative index
1733				match[0] = match[0].slice( 0, excess );
1734				match[2] = unquoted.slice( 0, excess );
1735			}
1736
1737			// Return only captures needed by the pseudo filter method (type and argument)
1738			return match.slice( 0, 3 );
1739		}
1740	},
1741
1742	filter: {
1743
1744		"TAG": function( nodeNameSelector ) {
1745			var nodeName = nodeNameSelector.replace( runescape, funescape ).toLowerCase();
1746			return nodeNameSelector === "*" ?
1747				function() { return true; } :
1748				function( elem ) {
1749					return elem.nodeName && elem.nodeName.toLowerCase() === nodeName;
1750				};
1751		},
1752
1753		"CLASS": function( className ) {
1754			var pattern = classCache[ className + " " ];
1755
1756			return pattern ||
1757				(pattern = new RegExp( "(^|" + whitespace + ")" + className + "(" + whitespace + "|$)" )) &&
1758				classCache( className, function( elem ) {
1759					return pattern.test( typeof elem.className === "string" && elem.className || typeof elem.getAttribute !== "undefined" && elem.getAttribute("class") || "" );
1760				});
1761		},
1762
1763		"ATTR": function( name, operator, check ) {
1764			return function( elem ) {
1765				var result = Sizzle.attr( elem, name );
1766
1767				if ( result == null ) {
1768					return operator === "!=";
1769				}
1770				if ( !operator ) {
1771					return true;
1772				}
1773
1774				result += "";
1775
1776				return operator === "=" ? result === check :
1777					operator === "!=" ? result !== check :
1778					operator === "^=" ? check && result.indexOf( check ) === 0 :
1779					operator === "*=" ? check && result.indexOf( check ) > -1 :
1780					operator === "$=" ? check && result.slice( -check.length ) === check :
1781					operator === "~=" ? ( " " + result.replace( rwhitespace, " " ) + " " ).indexOf( check ) > -1 :
1782					operator === "|=" ? result === check || result.slice( 0, check.length + 1 ) === check + "-" :
1783					false;
1784			};
1785		},
1786
1787		"CHILD": function( type, what, argument, first, last ) {
1788			var simple = type.slice( 0, 3 ) !== "nth",
1789				forward = type.slice( -4 ) !== "last",
1790				ofType = what === "of-type";
1791
1792			return first === 1 && last === 0 ?
1793
1794				// Shortcut for :nth-*(n)
1795				function( elem ) {
1796					return !!elem.parentNode;
1797				} :
1798
1799				function( elem, context, xml ) {
1800					var cache, uniqueCache, outerCache, node, nodeIndex, start,
1801						dir = simple !== forward ? "nextSibling" : "previousSibling",
1802						parent = elem.parentNode,
1803						name = ofType && elem.nodeName.toLowerCase(),
1804						useCache = !xml && !ofType,
1805						diff = false;
1806
1807					if ( parent ) {
1808
1809						// :(first|last|only)-(child|of-type)
1810						if ( simple ) {
1811							while ( dir ) {
1812								node = elem;
1813								while ( (node = node[ dir ]) ) {
1814									if ( ofType ?
1815										node.nodeName.toLowerCase() === name :
1816										node.nodeType === 1 ) {
1817
1818										return false;
1819									}
1820								}
1821								// Reverse direction for :only-* (if we haven't yet done so)
1822								start = dir = type === "only" && !start && "nextSibling";
1823							}
1824							return true;
1825						}
1826
1827						start = [ forward ? parent.firstChild : parent.lastChild ];
1828
1829						// non-xml :nth-child(...) stores cache data on `parent`
1830						if ( forward && useCache ) {
1831
1832							// Seek `elem` from a previously-cached index
1833
1834							// ...in a gzip-friendly way
1835							node = parent;
1836							outerCache = node[ expando ] || (node[ expando ] = {});
1837
1838							// Support: IE <9 only
1839							// Defend against cloned attroperties (jQuery gh-1709)
1840							uniqueCache = outerCache[ node.uniqueID ] ||
1841								(outerCache[ node.uniqueID ] = {});
1842
1843							cache = uniqueCache[ type ] || [];
1844							nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ];
1845							diff = nodeIndex && cache[ 2 ];
1846							node = nodeIndex && parent.childNodes[ nodeIndex ];
1847
1848							while ( (node = ++nodeIndex && node && node[ dir ] ||
1849
1850								// Fallback to seeking `elem` from the start
1851								(diff = nodeIndex = 0) || start.pop()) ) {
1852
1853								// When found, cache indexes on `parent` and break
1854								if ( node.nodeType === 1 && ++diff && node === elem ) {
1855									uniqueCache[ type ] = [ dirruns, nodeIndex, diff ];
1856									break;
1857								}
1858							}
1859
1860						} else {
1861							// Use previously-cached element index if available
1862							if ( useCache ) {
1863								// ...in a gzip-friendly way
1864								node = elem;
1865								outerCache = node[ expando ] || (node[ expando ] = {});
1866
1867								// Support: IE <9 only
1868								// Defend against cloned attroperties (jQuery gh-1709)
1869								uniqueCache = outerCache[ node.uniqueID ] ||
1870									(outerCache[ node.uniqueID ] = {});
1871
1872								cache = uniqueCache[ type ] || [];
1873								nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ];
1874								diff = nodeIndex;
1875							}
1876
1877							// xml :nth-child(...)
1878							// or :nth-last-child(...) or :nth(-last)?-of-type(...)
1879							if ( diff === false ) {
1880								// Use the same loop as above to seek `elem` from the start
1881								while ( (node = ++nodeIndex && node && node[ dir ] ||
1882									(diff = nodeIndex = 0) || start.pop()) ) {
1883
1884									if ( ( ofType ?
1885										node.nodeName.toLowerCase() === name :
1886										node.nodeType === 1 ) &&
1887										++diff ) {
1888
1889										// Cache the index of each encountered element
1890										if ( useCache ) {
1891											outerCache = node[ expando ] || (node[ expando ] = {});
1892
1893											// Support: IE <9 only
1894											// Defend against cloned attroperties (jQuery gh-1709)
1895											uniqueCache = outerCache[ node.uniqueID ] ||
1896												(outerCache[ node.uniqueID ] = {});
1897
1898											uniqueCache[ type ] = [ dirruns, diff ];
1899										}
1900
1901										if ( node === elem ) {
1902											break;
1903										}
1904									}
1905								}
1906							}
1907						}
1908
1909						// Incorporate the offset, then check against cycle size
1910						diff -= last;
1911						return diff === first || ( diff % first === 0 && diff / first >= 0 );
1912					}
1913				};
1914		},
1915
1916		"PSEUDO": function( pseudo, argument ) {
1917			// pseudo-class names are case-insensitive
1918			// http://www.w3.org/TR/selectors/#pseudo-classes
1919			// Prioritize by case sensitivity in case custom pseudos are added with uppercase letters
1920			// Remember that setFilters inherits from pseudos
1921			var args,
1922				fn = Expr.pseudos[ pseudo ] || Expr.setFilters[ pseudo.toLowerCase() ] ||
1923					Sizzle.error( "unsupported pseudo: " + pseudo );
1924
1925			// The user may use createPseudo to indicate that
1926			// arguments are needed to create the filter function
1927			// just as Sizzle does
1928			if ( fn[ expando ] ) {
1929				return fn( argument );
1930			}
1931
1932			// But maintain support for old signatures
1933			if ( fn.length > 1 ) {
1934				args = [ pseudo, pseudo, "", argument ];
1935				return Expr.setFilters.hasOwnProperty( pseudo.toLowerCase() ) ?
1936					markFunction(function( seed, matches ) {
1937						var idx,
1938							matched = fn( seed, argument ),
1939							i = matched.length;
1940						while ( i-- ) {
1941							idx = indexOf( seed, matched[i] );
1942							seed[ idx ] = !( matches[ idx ] = matched[i] );
1943						}
1944					}) :
1945					function( elem ) {
1946						return fn( elem, 0, args );
1947					};
1948			}
1949
1950			return fn;
1951		}
1952	},
1953
1954	pseudos: {
1955		// Potentially complex pseudos
1956		"not": markFunction(function( selector ) {
1957			// Trim the selector passed to compile
1958			// to avoid treating leading and trailing
1959			// spaces as combinators
1960			var input = [],
1961				results = [],
1962				matcher = compile( selector.replace( rtrim, "$1" ) );
1963
1964			return matcher[ expando ] ?
1965				markFunction(function( seed, matches, context, xml ) {
1966					var elem,
1967						unmatched = matcher( seed, null, xml, [] ),
1968						i = seed.length;
1969
1970					// Match elements unmatched by `matcher`
1971					while ( i-- ) {
1972						if ( (elem = unmatched[i]) ) {
1973							seed[i] = !(matches[i] = elem);
1974						}
1975					}
1976				}) :
1977				function( elem, context, xml ) {
1978					input[0] = elem;
1979					matcher( input, null, xml, results );
1980					// Don't keep the element (issue #299)
1981					input[0] = null;
1982					return !results.pop();
1983				};
1984		}),
1985
1986		"has": markFunction(function( selector ) {
1987			return function( elem ) {
1988				return Sizzle( selector, elem ).length > 0;
1989			};
1990		}),
1991
1992		"contains": markFunction(function( text ) {
1993			text = text.replace( runescape, funescape );
1994			return function( elem ) {
1995				return ( elem.textContent || elem.innerText || getText( elem ) ).indexOf( text ) > -1;
1996			};
1997		}),
1998
1999		// "Whether an element is represented by a :lang() selector
2000		// is based solely on the element's language value
2001		// being equal to the identifier C,
2002		// or beginning with the identifier C immediately followed by "-".
2003		// The matching of C against the element's language value is performed case-insensitively.
2004		// The identifier C does not have to be a valid language name."
2005		// http://www.w3.org/TR/selectors/#lang-pseudo
2006		"lang": markFunction( function( lang ) {
2007			// lang value must be a valid identifier
2008			if ( !ridentifier.test(lang || "") ) {
2009				Sizzle.error( "unsupported lang: " + lang );
2010			}
2011			lang = lang.replace( runescape, funescape ).toLowerCase();
2012			return function( elem ) {
2013				var elemLang;
2014				do {
2015					if ( (elemLang = documentIsHTML ?
2016						elem.lang :
2017						elem.getAttribute("xml:lang") || elem.getAttribute("lang")) ) {
2018
2019						elemLang = elemLang.toLowerCase();
2020						return elemLang === lang || elemLang.indexOf( lang + "-" ) === 0;
2021					}
2022				} while ( (elem = elem.parentNode) && elem.nodeType === 1 );
2023				return false;

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