https://mytimefitness.ru/themes/mytimefitness/assets/js/optikov.js?v=48

1// импортируем jQuery
2/*!
3 * jQuery JavaScript Library v3.4.1
4 * https://jquery.com/
5 *
6 * Includes Sizzle.js
7 * https://sizzlejs.com/
8 *
9 * Copyright JS Foundation and other contributors
10 * Released under the MIT license
11 * https://jquery.org/license
12 *
13 * Date: 2019-05-01T21:04Z
14 */
15( function( global, factory ) {
16
17	"use strict";
18
19	if ( typeof module === "object" && typeof module.exports === "object" ) {
20
21		// For CommonJS and CommonJS-like environments where a proper `window`
22		// is present, execute the factory and get jQuery.
23		// For environments that do not have a `window` with a `document`
24		// (such as Node.js), expose a factory as module.exports.
25		// This accentuates the need for the creation of a real `window`.
26		// e.g. var jQuery = require("jquery")(window);
27		// See ticket #14549 for more info.
28		module.exports = global.document ?
29			factory( global, true ) :
30			function( w ) {
31				if ( !w.document ) {
32					throw new Error( "jQuery requires a window with a document" );
33				}
34				return factory( w );
35			};
36	} else {
37		factory( global );
38	}
39
40// Pass this if window is not defined yet
41} )( typeof window !== "undefined" ? window : this, function( window, noGlobal ) {
42
43// Edge <= 12 - 13+, Firefox <=18 - 45+, IE 10 - 11, Safari 5.1 - 9+, iOS 6 - 9.1
44// throw exceptions when non-strict code (e.g., ASP.NET 4.5) accesses strict mode
45// arguments.callee.caller (trac-13335). But as of jQuery 3.0 (2016), strict mode should be common
46// enough that all such attempts are guarded in a try block.
47"use strict";
48
49var arr = [];
50
51var document = window.document;
52
53var getProto = Object.getPrototypeOf;
54
55var slice = arr.slice;
56
57var concat = arr.concat;
58
59var push = arr.push;
60
61var indexOf = arr.indexOf;
62
63var class2type = {};
64
65var toString = class2type.toString;
66
67var hasOwn = class2type.hasOwnProperty;
68
69var fnToString = hasOwn.toString;
70
71var ObjectFunctionString = fnToString.call( Object );
72
73var support = {};
74
75var isFunction = function isFunction( obj ) {
76
77      // Support: Chrome <=57, Firefox <=52
78      // In some browsers, typeof returns "function" for HTML <object> elements
79      // (i.e., `typeof document.createElement( "object" ) === "function"`).
80      // We don't want to classify *any* DOM node as a function.
81      return typeof obj === "function" && typeof obj.nodeType !== "number";
82  };
83
84
85var isWindow = function isWindow( obj ) {
86		return obj != null && obj === obj.window;
87	};
88
89
90
91
92	var preservedScriptAttributes = {
93		type: true,
94		src: true,
95		nonce: true,
96		noModule: true
97	};
98
99	function DOMEval( code, node, doc ) {
100		doc = doc || document;
101
102		var i, val,
103			script = doc.createElement( "script" );
104
105		script.text = code;
106		if ( node ) {
107			for ( i in preservedScriptAttributes ) {
108
109				// Support: Firefox 64+, Edge 18+
110				// Some browsers don't support the "nonce" property on scripts.
111				// On the other hand, just using `getAttribute` is not enough as
112				// the `nonce` attribute is reset to an empty string whenever it
113				// becomes browsing-context connected.
114				// See https://github.com/whatwg/html/issues/2369
115				// See https://html.spec.whatwg.org/#nonce-attributes
116				// The `node.getAttribute` check was added for the sake of
117				// `jQuery.globalEval` so that it can fake a nonce-containing node
118				// via an object.
119				val = node[ i ] || node.getAttribute && node.getAttribute( i );
120				if ( val ) {
121					script.setAttribute( i, val );
122				}
123			}
124		}
125		doc.head.appendChild( script ).parentNode.removeChild( script );
126	}
127
128
129function toType( obj ) {
130	if ( obj == null ) {
131		return obj + "";
132	}
133
134	// Support: Android <=2.3 only (functionish RegExp)
135	return typeof obj === "object" || typeof obj === "function" ?
136		class2type[ toString.call( obj ) ] || "object" :
137		typeof obj;
138}
139/* global Symbol */
140// Defining this global in .eslintrc.json would create a danger of using the global
141// unguarded in another place, it seems safer to define global only for this module
142
143
144
145var
146	version = "3.4.1",
147
148	// Define a local copy of jQuery
149	jQuery = function( selector, context ) {
150
151		// The jQuery object is actually just the init constructor 'enhanced'
152		// Need init if jQuery is called (just allow error to be thrown if not included)
153		return new jQuery.fn.init( selector, context );
154	},
155
156	// Support: Android <=4.0 only
157	// Make sure we trim BOM and NBSP
158	rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g;
159
160jQuery.fn = jQuery.prototype = {
161
162	// The current version of jQuery being used
163	jquery: version,
164
165	constructor: jQuery,
166
167	// The default length of a jQuery object is 0
168	length: 0,
169
170	toArray: function() {
171		return slice.call( this );
172	},
173
174	// Get the Nth element in the matched element set OR
175	// Get the whole matched element set as a clean array
176	get: function( num ) {
177
178		// Return all the elements in a clean array
179		if ( num == null ) {
180			return slice.call( this );
181		}
182
183		// Return just the one element from the set
184		return num < 0 ? this[ num + this.length ] : this[ num ];
185	},
186
187	// Take an array of elements and push it onto the stack
188	// (returning the new matched element set)
189	pushStack: function( elems ) {
190
191		// Build a new jQuery matched element set
192		var ret = jQuery.merge( this.constructor(), elems );
193
194		// Add the old object onto the stack (as a reference)

195		ret.prevObject = this;
196
197		// Return the newly-formed element set
198		return ret;
199	},
200
201	// Execute a callback for every element in the matched set.
202	each: function( callback ) {
203		return jQuery.each( this, callback );
204	},
205
206	map: function( callback ) {
207		return this.pushStack( jQuery.map( this, function( elem, i ) {
208			return callback.call( elem, i, elem );
209		} ) );
210	},
211
212	slice: function() {
213		return this.pushStack( slice.apply( this, arguments ) );
214	},
215
216	first: function() {
217		return this.eq( 0 );
218	},
219
220	last: function() {
221		return this.eq( -1 );
222	},
223
224	eq: function( i ) {
225		var len = this.length,
226			j = +i + ( i < 0 ? len : 0 );
227		return this.pushStack( j >= 0 && j < len ? [ this[ j ] ] : [] );
228	},
229
230	end: function() {
231		return this.prevObject || this.constructor();
232	},
233
234	// For internal use only.
235	// Behaves like an Array's method, not like a jQuery method.
236	push: push,
237	sort: arr.sort,
238	splice: arr.splice
239};
240
241jQuery.extend = jQuery.fn.extend = function() {
242	var options, name, src, copy, copyIsArray, clone,
243		target = arguments[ 0 ] || {},
244		i = 1,
245		length = arguments.length,
246		deep = false;
247
248	// Handle a deep copy situation
249	if ( typeof target === "boolean" ) {
250		deep = target;
251
252		// Skip the boolean and the target
253		target = arguments[ i ] || {};
254		i++;
255	}
256
257	// Handle case when target is a string or something (possible in deep copy)
258	if ( typeof target !== "object" && !isFunction( target ) ) {
259		target = {};
260	}
261
262	// Extend jQuery itself if only one argument is passed
263	if ( i === length ) {
264		target = this;
265		i--;
266	}
267
268	for ( ; i < length; i++ ) {
269
270		// Only deal with non-null/undefined values
271		if ( ( options = arguments[ i ] ) != null ) {
272
273			// Extend the base object
274			for ( name in options ) {
275				copy = options[ name ];
276
277				// Prevent Object.prototype pollution
278				// Prevent never-ending loop
279				if ( name === "__proto__" || target === copy ) {
280					continue;
281				}
282
283				// Recurse if we're merging plain objects or arrays
284				if ( deep && copy && ( jQuery.isPlainObject( copy ) ||
285					( copyIsArray = Array.isArray( copy ) ) ) ) {
286					src = target[ name ];
287
288					// Ensure proper type for the source value
289					if ( copyIsArray && !Array.isArray( src ) ) {
290						clone = [];
291					} else if ( !copyIsArray && !jQuery.isPlainObject( src ) ) {
292						clone = {};
293					} else {
294						clone = src;
295					}
296					copyIsArray = false;
297
298					// Never move original objects, clone them
299					target[ name ] = jQuery.extend( deep, clone, copy );
300
301				// Don't bring in undefined values
302				} else if ( copy !== undefined ) {
303					target[ name ] = copy;
304				}
305			}
306		}
307	}
308
309	// Return the modified object
310	return target;
311};
312
313jQuery.extend( {
314
315	// Unique for each copy of jQuery on the page
316	expando: "jQuery" + ( version + Math.random() ).replace( /\D/g, "" ),
317
318	// Assume jQuery is ready without the ready module
319	isReady: true,
320
321	error: function( msg ) {
322		throw new Error( msg );
323	},
324
325	noop: function() {},
326
327	isPlainObject: function( obj ) {
328		var proto, Ctor;
329
330		// Detect obvious negatives
331		// Use toString instead of jQuery.type to catch host objects
332		if ( !obj || toString.call( obj ) !== "[object Object]" ) {
333			return false;
334		}
335
336		proto = getProto( obj );
337
338		// Objects with no prototype (e.g., `Object.create( null )`) are plain
339		if ( !proto ) {
340			return true;
341		}
342
343		// Objects with prototype are plain iff they were constructed by a global Object function
344		Ctor = hasOwn.call( proto, "constructor" ) && proto.constructor;
345		return typeof Ctor === "function" && fnToString.call( Ctor ) === ObjectFunctionString;
346	},
347
348	isEmptyObject: function( obj ) {
349		var name;
350
351		for ( name in obj ) {
352			return false;
353		}
354		return true;
355	},
356
357	// Evaluates a script in a global context
358	globalEval: function( code, options ) {
359		DOMEval( code, { nonce: options && options.nonce } );
360	},
361
362	each: function( obj, callback ) {
363		var length, i = 0;
364
365		if ( isArrayLike( obj ) ) {
366			length = obj.length;
367			for ( ; i < length; i++ ) {
368				if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {
369					break;
370				}
371			}
372		} else {
373			for ( i in obj ) {
374				if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {
375					break;
376				}
377			}
378		}
379
380		return obj;

381	},
382
383	// Support: Android <=4.0 only
384	trim: function( text ) {
385		return text == null ?
386			"" :
387			( text + "" ).replace( rtrim, "" );
388	},
389
390	// results is for internal usage only
391	makeArray: function( arr, results ) {
392		var ret = results || [];
393
394		if ( arr != null ) {
395			if ( isArrayLike( Object( arr ) ) ) {
396				jQuery.merge( ret,
397					typeof arr === "string" ?
398					[ arr ] : arr
399				);
400			} else {
401				push.call( ret, arr );
402			}
403		}
404
405		return ret;
406	},
407
408	inArray: function( elem, arr, i ) {
409		return arr == null ? -1 : indexOf.call( arr, elem, i );
410	},
411
412	// Support: Android <=4.0 only, PhantomJS 1 only
413	// push.apply(_, arraylike) throws on ancient WebKit
414	merge: function( first, second ) {
415		var len = +second.length,
416			j = 0,
417			i = first.length;
418
419		for ( ; j < len; j++ ) {
420			first[ i++ ] = second[ j ];
421		}
422
423		first.length = i;
424
425		return first;
426	},
427
428	grep: function( elems, callback, invert ) {
429		var callbackInverse,
430			matches = [],
431			i = 0,
432			length = elems.length,
433			callbackExpect = !invert;
434
435		// Go through the array, only saving the items
436		// that pass the validator function
437		for ( ; i < length; i++ ) {
438			callbackInverse = !callback( elems[ i ], i );
439			if ( callbackInverse !== callbackExpect ) {
440				matches.push( elems[ i ] );
441			}
442		}
443
444		return matches;
445	},
446
447	// arg is for internal usage only
448	map: function( elems, callback, arg ) {
449		var length, value,
450			i = 0,
451			ret = [];
452
453		// Go through the array, translating each of the items to their new values
454		if ( isArrayLike( elems ) ) {
455			length = elems.length;
456			for ( ; i < length; i++ ) {
457				value = callback( elems[ i ], i, arg );
458
459				if ( value != null ) {
460					ret.push( value );
461				}
462			}
463
464		// Go through every key on the object,
465		} else {
466			for ( i in elems ) {
467				value = callback( elems[ i ], i, arg );
468
469				if ( value != null ) {
470					ret.push( value );
471				}
472			}
473		}
474
475		// Flatten any nested arrays
476		return concat.apply( [], ret );
477	},
478
479	// A global GUID counter for objects
480	guid: 1,
481
482	// jQuery.support is not used in Core but other projects attach their
483	// properties to it so it needs to exist.
484	support: support
485} );
486
487if ( typeof Symbol === "function" ) {
488	jQuery.fn[ Symbol.iterator ] = arr[ Symbol.iterator ];
489}
490
491// Populate the class2type map
492jQuery.each( "Boolean Number String Function Array Date RegExp Object Error Symbol".split( " " ),
493function( i, name ) {
494	class2type[ "[object " + name + "]" ] = name.toLowerCase();
495} );
496
497function isArrayLike( obj ) {
498
499	// Support: real iOS 8.2 only (not reproducible in simulator)
500	// `in` check used to prevent JIT error (gh-2145)
501	// hasOwn isn't used here due to false negatives
502	// regarding Nodelist length in IE
503	var length = !!obj && "length" in obj && obj.length,
504		type = toType( obj );
505
506	if ( isFunction( obj ) || isWindow( obj ) ) {
507		return false;
508	}
509
510	return type === "array" || length === 0 ||
511		typeof length === "number" && length > 0 && ( length - 1 ) in obj;
512}
513var Sizzle =
514/*!
515 * Sizzle CSS Selector Engine v2.3.4
516 * https://sizzlejs.com/
517 *
518 * Copyright JS Foundation and other contributors
519 * Released under the MIT license
520 * https://js.foundation/
521 *
522 * Date: 2019-04-08
523 */
524(function( window ) {
525
526var i,
527	support,
528	Expr,
529	getText,
530	isXML,
531	tokenize,
532	compile,
533	select,
534	outermostContext,
535	sortInput,
536	hasDuplicate,
537
538	// Local document vars
539	setDocument,
540	document,
541	docElem,
542	documentIsHTML,
543	rbuggyQSA,
544	rbuggyMatches,
545	matches,
546	contains,
547
548	// Instance-specific data
549	expando = "sizzle" + 1 * new Date(),
550	preferredDoc = window.document,
551	dirruns = 0,
552	done = 0,
553	classCache = createCache(),
554	tokenCache = createCache(),
555	compilerCache = createCache(),
556	nonnativeSelectorCache = createCache(),
557	sortOrder = function( a, b ) {
558		if ( a === b ) {
559			hasDuplicate = true;
560		}
561		return 0;
562	},
563
564	// Instance methods
565	hasOwn = ({}).hasOwnProperty,
566	arr = [],
567	pop = arr.pop,
568	push_native = arr.push,
569	push = arr.push,
570	slice = arr.slice,
571	// Use a stripped-down indexOf as it's faster than native
572	// https://jsperf.com/thor-indexof-vs-for/5
573	indexOf = function( list, elem ) {
574		var i = 0,
575			len = list.length;
576		for ( ; i < len; i++ ) {
577			if ( list[i] === elem ) {
578				return i;
579			}
580		}
581		return -1;
582	},
583
584	booleans = "checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped",
585
586	// Regular expressions
587
588	// http://www.w3.org/TR/css3-selectors/#whitespace
589	whitespace = "[\\x20\\t\\r\\n\\f]",
590
591	// http://www.w3.org/TR/CSS21/syndata.html#value-def-identifier
592	identifier = "(?:\\\\.|[\\w-]|[^\0-\\xa0])+",
593
594	// Attribute selectors: http://www.w3.org/TR/selectors/#attribute-selectors
595	attributes = "\\[" + whitespace + "*(" + identifier + ")(?:" + whitespace +
596		// Operator (capture 2)
597		"*([*^$|!~]?=)" + whitespace +
598		// "Attribute values must be CSS identifiers [capture 5] or strings [capture 3 or capture 4]"
599		"*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|(" + identifier + "))|)" + whitespace +
600		"*\\]",
601
602	pseudos = ":(" + identifier + ")(?:\\((" +
603		// To reduce the number of selectors needing tokenize in the preFilter, prefer arguments:
604		// 1. quoted (capture 3; capture 4 or capture 5)

605		"('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|" +
606		// 2. simple (capture 6)
607		"((?:\\\\.|[^\\\\()[\\]]|" + attributes + ")*)|" +
608		// 3. anything else (capture 2)
609		".*" +
610		")\\)|)",
611
612	// Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter
613	rwhitespace = new RegExp( whitespace + "+", "g" ),
614	rtrim = new RegExp( "^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" + whitespace + "+$", "g" ),
615
616	rcomma = new RegExp( "^" + whitespace + "*," + whitespace + "*" ),
617	rcombinators = new RegExp( "^" + whitespace + "*([>+~]|" + whitespace + ")" + whitespace + "*" ),
618	rdescend = new RegExp( whitespace + "|>" ),
619
620	rpseudo = new RegExp( pseudos ),
621	ridentifier = new RegExp( "^" + identifier + "$" ),
622
623	matchExpr = {
624		"ID": new RegExp( "^#(" + identifier + ")" ),
625		"CLASS": new RegExp( "^\\.(" + identifier + ")" ),
626		"TAG": new RegExp( "^(" + identifier + "|[*])" ),
627		"ATTR": new RegExp( "^" + attributes ),
628		"PSEUDO": new RegExp( "^" + pseudos ),
629		"CHILD": new RegExp( "^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(" + whitespace +
630			"*(even|odd|(([+-]|)(\\d*)n|)" + whitespace + "*(?:([+-]|)" + whitespace +
631			"*(\\d+)|))" + whitespace + "*\\)|)", "i" ),
632		"bool": new RegExp( "^(?:" + booleans + ")$", "i" ),
633		// For use in libraries implementing .is()
634		// We use this for POS matching in `select`
635		"needsContext": new RegExp( "^" + whitespace + "*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(" +
636			whitespace + "*((?:-\\d)?\\d*)" + whitespace + "*\\)|)(?=[^-]|$)", "i" )
637	},
638
639	rhtml = /HTML$/i,
640	rinputs = /^(?:input|select|textarea|button)$/i,
641	rheader = /^h\d$/i,
642
643	rnative = /^[^{]+\{\s*\[native \w/,
644
645	// Easily-parseable/retrievable ID or TAG or CLASS selectors
646	rquickExpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,
647
648	rsibling = /[+~]/,
649
650	// CSS escapes
651	// http://www.w3.org/TR/CSS21/syndata.html#escaped-characters
652	runescape = new RegExp( "\\\\([\\da-f]{1,6}" + whitespace + "?|(" + whitespace + ")|.)", "ig" ),
653	funescape = function( _, escaped, escapedWhitespace ) {
654		var high = "0x" + escaped - 0x10000;
655		// NaN means non-codepoint
656		// Support: Firefox<24
657		// Workaround erroneous numeric interpretation of +"0x"
658		return high !== high || escapedWhitespace ?
659			escaped :
660			high < 0 ?
661				// BMP codepoint
662				String.fromCharCode( high + 0x10000 ) :
663				// Supplemental Plane codepoint (surrogate pair)
664				String.fromCharCode( high >> 10 | 0xD800, high & 0x3FF | 0xDC00 );
665	},
666
667	// CSS string/identifier serialization
668	// https://drafts.csswg.org/cssom/#common-serializing-idioms
669	rcssescape = /([\0-\x1f\x7f]|^-?\d)|^-$|[^\0-\x1f\x7f-\uFFFF\w-]/g,
670	fcssescape = function( ch, asCodePoint ) {
671		if ( asCodePoint ) {
672
673			// U+0000 NULL becomes U+FFFD REPLACEMENT CHARACTER
674			if ( ch === "\0" ) {
675				return "\uFFFD";
676			}
677
678			// Control characters and (dependent upon position) numbers get escaped as code points
679			return ch.slice( 0, -1 ) + "\\" + ch.charCodeAt( ch.length - 1 ).toString( 16 ) + " ";
680		}
681
682		// Other potentially-special ASCII characters get backslash-escaped
683		return "\\" + ch;
684	},
685
686	// Used for iframes
687	// See setDocument()
688	// Removing the function wrapper causes a "Permission Denied"
689	// error in IE
690	unloadHandler = function() {
691		setDocument();
692	},
693
694	inDisabledFieldset = addCombinator(
695		function( elem ) {
696			return elem.disabled === true && elem.nodeName.toLowerCase() === "fieldset";
697		},
698		{ dir: "parentNode", next: "legend" }
699	);
700
701// Optimize for push.apply( _, NodeList )
702try {
703	push.apply(
704		(arr = slice.call( preferredDoc.childNodes )),
705		preferredDoc.childNodes
706	);
707	// Support: Android<4.0
708	// Detect silently failing push.apply
709	arr[ preferredDoc.childNodes.length ].nodeType;
710} catch ( e ) {
711	push = { apply: arr.length ?
712
713		// Leverage slice if possible
714		function( target, els ) {
715			push_native.apply( target, slice.call(els) );
716		} :
717
718		// Support: IE<9
719		// Otherwise append directly
720		function( target, els ) {
721			var j = target.length,
722				i = 0;
723			// Can't trust NodeList.length
724			while ( (target[j++] = els[i++]) ) {}
725			target.length = j - 1;
726		}
727	};
728}
729
730function Sizzle( selector, context, results, seed ) {
731	var m, i, elem, nid, match, groups, newSelector,
732		newContext = context && context.ownerDocument,
733
734		// nodeType defaults to 9, since context defaults to document
735		nodeType = context ? context.nodeType : 9;
736
737	results = results || [];
738

739	// Return early from calls with invalid selector or context
740	if ( typeof selector !== "string" || !selector ||
741		nodeType !== 1 && nodeType !== 9 && nodeType !== 11 ) {
742
743		return results;
744	}
745
746	// Try to shortcut find operations (as opposed to filters) in HTML documents
747	if ( !seed ) {
748
749		if ( ( context ? context.ownerDocument || context : preferredDoc ) !== document ) {
750			setDocument( context );
751		}
752		context = context || document;
753
754		if ( documentIsHTML ) {
755
756			// If the selector is sufficiently simple, try using a "get*By*" DOM method
757			// (excepting DocumentFragment context, where the methods don't exist)
758			if ( nodeType !== 11 && (match = rquickExpr.exec( selector )) ) {
759
760				// ID selector
761				if ( (m = match[1]) ) {
762
763					// Document context
764					if ( nodeType === 9 ) {
765						if ( (elem = context.getElementById( m )) ) {
766
767							// Support: IE, Opera, Webkit
768							// TODO: identify versions
769							// getElementById can match elements by name instead of ID
770							if ( elem.id === m ) {
771								results.push( elem );
772								return results;
773							}
774						} else {
775							return results;
776						}
777
778					// Element context
779					} else {
780
781						// Support: IE, Opera, Webkit
782						// TODO: identify versions
783						// getElementById can match elements by name instead of ID
784						if ( newContext && (elem = newContext.getElementById( m )) &&
785							contains( context, elem ) &&
786							elem.id === m ) {
787
788							results.push( elem );
789							return results;
790						}
791					}
792
793				// Type selector
794				} else if ( match[2] ) {
795					push.apply( results, context.getElementsByTagName( selector ) );
796					return results;
797
798				// Class selector
799				} else if ( (m = match[3]) && support.getElementsByClassName &&
800					context.getElementsByClassName ) {
801
802					push.apply( results, context.getElementsByClassName( m ) );
803					return results;
804				}
805			}
806
807			// Take advantage of querySelectorAll
808			if ( support.qsa &&
809				!nonnativeSelectorCache[ selector + " " ] &&
810				(!rbuggyQSA || !rbuggyQSA.test( selector )) &&
811
812				// Support: IE 8 only
813				// Exclude object elements
814				(nodeType !== 1 || context.nodeName.toLowerCase() !== "object") ) {
815
816				newSelector = selector;
817				newContext = context;
818
819				// qSA considers elements outside a scoping root when evaluating child or
820				// descendant combinators, which is not what we want.
821				// In such cases, we work around the behavior by prefixing every selector in the
822				// list with an ID selector referencing the scope context.
823				// Thanks to Andrew Dupont for this technique.
824				if ( nodeType === 1 && rdescend.test( selector ) ) {
825
826					// Capture the context ID, setting it first if necessary
827					if ( (nid = context.getAttribute( "id" )) ) {
828						nid = nid.replace( rcssescape, fcssescape );
829					} else {
830						context.setAttribute( "id", (nid = expando) );
831					}
832
833					// Prefix every selector in the list
834					groups = tokenize( selector );
835					i = groups.length;
836					while ( i-- ) {
837						groups[i] = "#" + nid + " " + toSelector( groups[i] );
838					}
839					newSelector = groups.join( "," );
840
841					// Expand context for sibling selectors
842					newContext = rsibling.test( selector ) && testContext( context.parentNode ) ||
843						context;
844				}
845
846				try {
847					push.apply( results,
848						newContext.querySelectorAll( newSelector )
849					);
850					return results;
851				} catch ( qsaError ) {
852					nonnativeSelectorCache( selector, true );
853				} finally {
854					if ( nid === expando ) {
855						context.removeAttribute( "id" );
856					}
857				}
858			}
859		}
860	}
861
862	// All others
863	return select( selector.replace( rtrim, "$1" ), context, results, seed );
864}
865
866/**
867 * Create key-value caches of limited size
868 * @returns {function(string, object)} Returns the Object data after storing it on itself with
869 *	property name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength)
870 *	deleting the oldest entry
871 */
872function createCache() {
873	var keys = [];
874
875	function cache( key, value ) {
876		// Use (key + " ") to avoid collision with native prototype properties (see Issue #157)
877		if ( keys.push( key + " " ) > Expr.cacheLength ) {
878			// Only keep the most recent entries
879			delete cache[ keys.shift() ];
880		}
881		return (cache[ key + " " ] = value);
882	}
883	return cache;
884}
885
886/**
887 * Mark a function for special use by Sizzle
888 * @param {Function} fn The function to mark
889 */
890function markFunction( fn ) {
891	fn[ expando ] = true;
892	return fn;
893}
894
895/**
896 * Support testing using an element
897 * @param {Function} fn Passed the created element and returns a boolean result
898 */
899function assert( fn ) {
900	var el = document.createElement("fieldset");
901
902	try {
903		return !!fn( el );
904	} catch (e) {
905		return false;
906	} finally {
907		// Remove from its parent by default
908		if ( el.parentNode ) {
909			el.parentNode.removeChild( el );
910		}
911		// release memory in IE
912		el = null;
913	}
914}
915
916/**
917 * Adds the same handler for all of the specified attrs
918 * @param {String} attrs Pipe-separated list of attributes
919 * @param {Function} handler The method that will be applied
920 */
921function addHandle( attrs, handler ) {
922	var arr = attrs.split("|"),
923		i = arr.length;
924
925	while ( i-- ) {
926		Expr.attrHandle[ arr[i] ] = handler;
927	}
928}
929
930/**
931 * Checks document order of two siblings
932 * @param {Element} a
933 * @param {Element} b
934 * @returns {Number} Returns less than 0 if a precedes b, greater than 0 if a follows b
935 */
936function siblingCheck( a, b ) {
937	var cur = b && a,
938		diff = cur && a.nodeType === 1 && b.nodeType === 1 &&
939			a.sourceIndex - b.sourceIndex;
940
941	// Use IE sourceIndex if available on both nodes
942	if ( diff ) {
943		return diff;
944	}
945
946	// Check if b follows a
947	if ( cur ) {
948		while ( (cur = cur.nextSibling) ) {
949			if ( cur === b ) {
950				return -1;
951			}
952		}
953	}
954
955	return a ? 1 : -1;
956}
957
958/**
959 * Returns a function to use in pseudos for input types
960 * @param {String} type
961 */
962function createInputPseudo( type ) {
963	return function( elem ) {
964		var name = elem.nodeName.toLowerCase();
965		return name === "input" && elem.type === type;
966	};
967}
968
969/**
970 * Returns a function to use in pseudos for buttons
971 * @param {String} type
972 */
973function createButtonPseudo( type ) {
974	return function( elem ) {
975		var name = elem.nodeName.toLowerCase();
976		return (name === "input" || name === "button") && elem.type === type;
977	};
978}
979
980/**
981 * Returns a function to use in pseudos for :enabled/:disabled
982 * @param {Boolean} disabled true for :disabled; false for :enabled
983 */
984function createDisabledPseudo( disabled ) {
985
986	// Known :disabled false positives: fieldset[disabled] > legend:nth-of-type(n+2) :can-disable
987	return function( elem ) {
988
989		// Only certain elements can match :enabled or :disabled
990		// https://html.spec.whatwg.org/multipage/scripting.html#selector-enabled
991		// https://html.spec.whatwg.org/multipage/scripting.html#selector-disabled
992		if ( "form" in elem ) {
993
994			// Check for inherited disabledness on relevant non-disabled elements:
995			// * listed form-associated elements in a disabled fieldset
996			//   https://html.spec.whatwg.org/multipage/forms.html#category-listed
997			//   https://html.spec.whatwg.org/multipage/forms.html#concept-fe-disabled
998			// * option elements in a disabled optgroup
999			//   https://html.spec.whatwg.org/multipage/forms.html#concept-option-disabled
1000			// All such elements have a "form" property.
1001			if ( elem.parentNode && elem.disabled === false ) {
1002
1003				// Option elements defer to a parent optgroup if present
1004				if ( "label" in elem ) {
1005					if ( "label" in elem.parentNode ) {
1006						return elem.parentNode.disabled === disabled;
1007					} else {
1008						return elem.disabled === disabled;
1009					}
1010				}
1011

1012				// Support: IE 6 - 11
1013				// Use the isDisabled shortcut property to check for disabled fieldset ancestors
1014				return elem.isDisabled === disabled ||
1015
1016					// Where there is no isDisabled, check manually
1017					/* jshint -W018 */
1018					elem.isDisabled !== !disabled &&
1019						inDisabledFieldset( elem ) === disabled;
1020			}
1021
1022			return elem.disabled === disabled;
1023
1024		// Try to winnow out elements that can't be disabled before trusting the disabled property.
1025		// Some victims get caught in our net (label, legend, menu, track), but it shouldn't
1026		// even exist on them, let alone have a boolean value.
1027		} else if ( "label" in elem ) {
1028			return elem.disabled === disabled;
1029		}
1030
1031		// Remaining elements are neither :enabled nor :disabled
1032		return false;
1033	};
1034}
1035
1036/**
1037 * Returns a function to use in pseudos for positionals
1038 * @param {Function} fn
1039 */
1040function createPositionalPseudo( fn ) {
1041	return markFunction(function( argument ) {
1042		argument = +argument;
1043		return markFunction(function( seed, matches ) {
1044			var j,
1045				matchIndexes = fn( [], seed.length, argument ),
1046				i = matchIndexes.length;
1047
1048			// Match elements found at the specified indexes
1049			while ( i-- ) {
1050				if ( seed[ (j = matchIndexes[i]) ] ) {
1051					seed[j] = !(matches[j] = seed[j]);
1052				}
1053			}
1054		});
1055	});
1056}
1057
1058/**
1059 * Checks a node for validity as a Sizzle context
1060 * @param {Element|Object=} context
1061 * @returns {Element|Object|Boolean} The input node if acceptable, otherwise a falsy value
1062 */
1063function testContext( context ) {
1064	return context && typeof context.getElementsByTagName !== "undefined" && context;
1065}
1066
1067// Expose support vars for convenience
1068support = Sizzle.support = {};
1069
1070/**
1071 * Detects XML nodes
1072 * @param {Element|Object} elem An element or a document
1073 * @returns {Boolean} True iff elem is a non-HTML XML node
1074 */
1075isXML = Sizzle.isXML = function( elem ) {
1076	var namespace = elem.namespaceURI,
1077		docElem = (elem.ownerDocument || elem).documentElement;
1078
1079	// Support: IE <=8
1080	// Assume HTML when documentElement doesn't yet exist, such as inside loading iframes
1081	// https://bugs.jquery.com/ticket/4833
1082	return !rhtml.test( namespace || docElem && docElem.nodeName || "HTML" );
1083};
1084
1085/**
1086 * Sets document-related variables once based on the current document
1087 * @param {Element|Object} [doc] An element or document object to use to set the document
1088 * @returns {Object} Returns the current document
1089 */
1090setDocument = Sizzle.setDocument = function( node ) {
1091	var hasCompare, subWindow,
1092		doc = node ? node.ownerDocument || node : preferredDoc;
1093
1094	// Return early if doc is invalid or already selected
1095	if ( doc === document || doc.nodeType !== 9 || !doc.documentElement ) {
1096		return document;
1097	}
1098
1099	// Update global variables
1100	document = doc;
1101	docElem = document.documentElement;
1102	documentIsHTML = !isXML( document );
1103
1104	// Support: IE 9-11, Edge
1105	// Accessing iframe documents after unload throws "permission denied" errors (jQuery #13936)
1106	if ( preferredDoc !== document &&
1107		(subWindow = document.defaultView) && subWindow.top !== subWindow ) {
1108
1109		// Support: IE 11, Edge
1110		if ( subWindow.addEventListener ) {
1111			subWindow.addEventListener( "unload", unloadHandler, false );
1112
1113		// Support: IE 9 - 10 only
1114		} else if ( subWindow.attachEvent ) {
1115			subWindow.attachEvent( "onunload", unloadHandler );
1116		}
1117	}
1118
1119	/* Attributes
1120	---------------------------------------------------------------------- */
1121
1122	// Support: IE<8
1123	// Verify that getAttribute really returns attributes and not properties
1124	// (excepting IE8 booleans)
1125	support.attributes = assert(function( el ) {
1126		el.className = "i";
1127		return !el.getAttribute("className");
1128	});
1129
1130	/* getElement(s)By*
1131	---------------------------------------------------------------------- */
1132
1133	// Check if getElementsByTagName("*") returns only elements
1134	support.getElementsByTagName = assert(function( el ) {
1135		el.appendChild( document.createComment("") );
1136		return !el.getElementsByTagName("*").length;
1137	});
1138
1139	// Support: IE<9
1140	support.getElementsByClassName = rnative.test( document.getElementsByClassName );
1141
1142	// Support: IE<10
1143	// Check if getElementById returns elements by name
1144	// The broken getElementById methods don't pick up programmatically-set names,
1145	// so use a roundabout getElementsByName test
1146	support.getById = assert(function( el ) {
1147		docElem.appendChild( el ).id = expando;
1148		return !document.getElementsByName || !document.getElementsByName( expando ).length;
1149	});
1150
1151	// ID filter and find
1152	if ( support.getById ) {
1153		Expr.filter["ID"] = function( id ) {
1154			var attrId = id.replace( runescape, funescape );
1155			return function( elem ) {
1156				return elem.getAttribute("id") === attrId;
1157			};
1158		};
1159		Expr.find["ID"] = function( id, context ) {
1160			if ( typeof context.getElementById !== "undefined" && documentIsHTML ) {
1161				var elem = context.getElementById( id );
1162				return elem ? [ elem ] : [];
1163			}
1164		};
1165	} else {
1166		Expr.filter["ID"] =  function( id ) {
1167			var attrId = id.replace( runescape, funescape );
1168			return function( elem ) {
1169				var node = typeof elem.getAttributeNode !== "undefined" &&
1170					elem.getAttributeNode("id");
1171				return node && node.value === attrId;
1172			};
1173		};
1174

1175		// Support: IE 6 - 7 only
1176		// getElementById is not reliable as a find shortcut
1177		Expr.find["ID"] = function( id, context ) {
1178			if ( typeof context.getElementById !== "undefined" && documentIsHTML ) {
1179				var node, i, elems,
1180					elem = context.getElementById( id );
1181
1182				if ( elem ) {
1183
1184					// Verify the id attribute
1185					node = elem.getAttributeNode("id");
1186					if ( node && node.value === id ) {
1187						return [ elem ];
1188					}
1189
1190					// Fall back on getElementsByName
1191					elems = context.getElementsByName( id );
1192					i = 0;
1193					while ( (elem = elems[i++]) ) {
1194						node = elem.getAttributeNode("id");
1195						if ( node && node.value === id ) {
1196							return [ elem ];
1197						}
1198					}
1199				}
1200
1201				return [];
1202			}
1203		};
1204	}
1205
1206	// Tag
1207	Expr.find["TAG"] = support.getElementsByTagName ?
1208		function( tag, context ) {
1209			if ( typeof context.getElementsByTagName !== "undefined" ) {
1210				return context.getElementsByTagName( tag );
1211
1212			// DocumentFragment nodes don't have gEBTN
1213			} else if ( support.qsa ) {
1214				return context.querySelectorAll( tag );
1215			}
1216		} :
1217
1218		function( tag, context ) {
1219			var elem,
1220				tmp = [],
1221				i = 0,
1222				// By happy coincidence, a (broken) gEBTN appears on DocumentFragment nodes too
1223				results = context.getElementsByTagName( tag );
1224
1225			// Filter out possible comments
1226			if ( tag === "*" ) {
1227				while ( (elem = results[i++]) ) {
1228					if ( elem.nodeType === 1 ) {
1229						tmp.push( elem );
1230					}
1231				}
1232
1233				return tmp;
1234			}
1235			return results;
1236		};
1237
1238	// Class
1239	Expr.find["CLASS"] = support.getElementsByClassName && function( className, context ) {
1240		if ( typeof context.getElementsByClassName !== "undefined" && documentIsHTML ) {
1241			return context.getElementsByClassName( className );
1242		}
1243	};
1244
1245	/* QSA/matchesSelector
1246	---------------------------------------------------------------------- */
1247
1248	// QSA and matchesSelector support
1249
1250	// matchesSelector(:active) reports false when true (IE9/Opera 11.5)
1251	rbuggyMatches = [];
1252
1253	// qSa(:focus) reports false when true (Chrome 21)
1254	// We allow this because of a bug in IE8/9 that throws an error
1255	// whenever `document.activeElement` is accessed on an iframe
1256	// So, we allow :focus to pass through QSA all the time to avoid the IE error
1257	// See https://bugs.jquery.com/ticket/13378
1258	rbuggyQSA = [];
1259
1260	if ( (support.qsa = rnative.test( document.querySelectorAll )) ) {
1261		// Build QSA regex
1262		// Regex strategy adopted from Diego Perini
1263		assert(function( el ) {
1264			// Select is set to empty string on purpose
1265			// This is to test IE's treatment of not explicitly
1266			// setting a boolean content attribute,
1267			// since its presence should be enough
1268			// https://bugs.jquery.com/ticket/12359
1269			docElem.appendChild( el ).innerHTML = "<a id='" + expando + "'></a>" +
1270				"<select id='" + expando + "-\r\\' msallowcapture=''>" +
1271				"<option selected=''></option></select>";
1272
1273			// Support: IE8, Opera 11-12.16
1274			// Nothing should be selected when empty strings follow ^= or $= or *=
1275			// The test attribute must be unknown in Opera but "safe" for WinRT
1276			// https://msdn.microsoft.com/en-us/library/ie/hh465388.aspx#attribute_section
1277			if ( el.querySelectorAll("[msallowcapture^='']").length ) {
1278				rbuggyQSA.push( "[*^$]=" + whitespace + "*(?:''|\"\")" );
1279			}
1280
1281			// Support: IE8
1282			// Boolean attributes and "value" are not treated correctly
1283			if ( !el.querySelectorAll("[selected]").length ) {
1284				rbuggyQSA.push( "\\[" + whitespace + "*(?:value|" + booleans + ")" );
1285			}
1286
1287			// Support: Chrome<29, Android<4.4, Safari<7.0+, iOS<7.0+, PhantomJS<1.9.8+
1288			if ( !el.querySelectorAll( "[id~=" + expando + "-]" ).length ) {
1289				rbuggyQSA.push("~=");
1290			}
1291
1292			// Webkit/Opera - :checked should return selected option elements
1293			// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
1294			// IE8 throws error here and will not see later tests
1295			if ( !el.querySelectorAll(":checked").length ) {
1296				rbuggyQSA.push(":checked");
1297			}
1298
1299			// Support: Safari 8+, iOS 8+
1300			// https://bugs.webkit.org/show_bug.cgi?id=136851
1301			// In-page `selector#id sibling-combinator selector` fails
1302			if ( !el.querySelectorAll( "a#" + expando + "+*" ).length ) {
1303				rbuggyQSA.push(".#.+[+~]");
1304			}
1305		});
1306
1307		assert(function( el ) {
1308			el.innerHTML = "<a href='' disabled='disabled'></a>" +
1309				"<select disabled='disabled'><option/></select>";
1310

1311			// Support: Windows 8 Native Apps
1312			// The type and name attributes are restricted during .innerHTML assignment
1313			var input = document.createElement("input");
1314			input.setAttribute( "type", "hidden" );
1315			el.appendChild( input ).setAttribute( "name", "D" );
1316
1317			// Support: IE8
1318			// Enforce case-sensitivity of name attribute
1319			if ( el.querySelectorAll("[name=d]").length ) {
1320				rbuggyQSA.push( "name" + whitespace + "*[*^$|!~]?=" );
1321			}
1322
1323			// FF 3.5 - :enabled/:disabled and hidden elements (hidden elements are still enabled)
1324			// IE8 throws error here and will not see later tests
1325			if ( el.querySelectorAll(":enabled").length !== 2 ) {
1326				rbuggyQSA.push( ":enabled", ":disabled" );
1327			}
1328
1329			// Support: IE9-11+
1330			// IE's :disabled selector does not pick up the children of disabled fieldsets
1331			docElem.appendChild( el ).disabled = true;
1332			if ( el.querySelectorAll(":disabled").length !== 2 ) {
1333				rbuggyQSA.push( ":enabled", ":disabled" );
1334			}
1335
1336			// Opera 10-11 does not throw on post-comma invalid pseudos
1337			el.querySelectorAll("*,:x");
1338			rbuggyQSA.push(",.*:");
1339		});
1340	}
1341
1342	if ( (support.matchesSelector = rnative.test( (matches = docElem.matches ||
1343		docElem.webkitMatchesSelector ||
1344		docElem.mozMatchesSelector ||
1345		docElem.oMatchesSelector ||
1346		docElem.msMatchesSelector) )) ) {
1347
1348		assert(function( el ) {
1349			// Check to see if it's possible to do matchesSelector
1350			// on a disconnected node (IE 9)
1351			support.disconnectedMatch = matches.call( el, "*" );
1352
1353			// This should fail with an exception
1354			// Gecko does not error, returns false instead
1355			matches.call( el, "[s!='']:x" );
1356			rbuggyMatches.push( "!=", pseudos );
1357		});
1358	}
1359
1360	rbuggyQSA = rbuggyQSA.length && new RegExp( rbuggyQSA.join("|") );
1361	rbuggyMatches = rbuggyMatches.length && new RegExp( rbuggyMatches.join("|") );
1362
1363	/* Contains
1364	---------------------------------------------------------------------- */
1365	hasCompare = rnative.test( docElem.compareDocumentPosition );
1366
1367	// Element contains another
1368	// Purposefully self-exclusive
1369	// As in, an element does not contain itself
1370	contains = hasCompare || rnative.test( docElem.contains ) ?
1371		function( a, b ) {
1372			var adown = a.nodeType === 9 ? a.documentElement : a,
1373				bup = b && b.parentNode;
1374			return a === bup || !!( bup && bup.nodeType === 1 && (
1375				adown.contains ?
1376					adown.contains( bup ) :
1377					a.compareDocumentPosition && a.compareDocumentPosition( bup ) & 16
1378			));
1379		} :
1380		function( a, b ) {
1381			if ( b ) {
1382				while ( (b = b.parentNode) ) {
1383					if ( b === a ) {
1384						return true;
1385					}
1386				}
1387			}
1388			return false;
1389		};
1390
1391	/* Sorting
1392	---------------------------------------------------------------------- */
1393
1394	// Document order sorting
1395	sortOrder = hasCompare ?
1396	function( a, b ) {
1397
1398		// Flag for duplicate removal
1399		if ( a === b ) {
1400			hasDuplicate = true;
1401			return 0;
1402		}
1403
1404		// Sort on method existence if only one input has compareDocumentPosition
1405		var compare = !a.compareDocumentPosition - !b.compareDocumentPosition;
1406		if ( compare ) {
1407			return compare;
1408		}
1409
1410		// Calculate position if both inputs belong to the same document
1411		compare = ( a.ownerDocument || a ) === ( b.ownerDocument || b ) ?
1412			a.compareDocumentPosition( b ) :
1413
1414			// Otherwise we know they are disconnected
1415			1;
1416
1417		// Disconnected nodes
1418		if ( compare & 1 ||
1419			(!support.sortDetached && b.compareDocumentPosition( a ) === compare) ) {
1420
1421			// Choose the first element that is related to our preferred document
1422			if ( a === document || a.ownerDocument === preferredDoc && contains(preferredDoc, a) ) {
1423				return -1;
1424			}
1425			if ( b === document || b.ownerDocument === preferredDoc && contains(preferredDoc, b) ) {
1426				return 1;
1427			}
1428
1429			// Maintain original order
1430			return sortInput ?
1431				( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) :
1432				0;
1433		}
1434
1435		return compare & 4 ? -1 : 1;
1436	} :
1437	function( a, b ) {
1438		// Exit early if the nodes are identical
1439		if ( a === b ) {
1440			hasDuplicate = true;
1441			return 0;
1442		}
1443
1444		var cur,
1445			i = 0,
1446			aup = a.parentNode,
1447			bup = b.parentNode,
1448			ap = [ a ],
1449			bp = [ b ];
1450
1451		// Parentless nodes are either documents or disconnected
1452		if ( !aup || !bup ) {
1453			return a === document ? -1 :
1454				b === document ? 1 :
1455				aup ? -1 :
1456				bup ? 1 :
1457				sortInput ?
1458				( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) :
1459				0;
1460
1461		// If the nodes are siblings, we can do a quick check
1462		} else if ( aup === bup ) {
1463			return siblingCheck( a, b );
1464		}
1465
1466		// Otherwise we need full lists of their ancestors for comparison
1467		cur = a;
1468		while ( (cur = cur.parentNode) ) {
1469			ap.unshift( cur );
1470		}
1471		cur = b;
1472		while ( (cur = cur.parentNode) ) {
1473			bp.unshift( cur );
1474		}
1475
1476		// Walk down the tree looking for a discrepancy
1477		while ( ap[i] === bp[i] ) {
1478			i++;
1479		}
1480
1481		return i ?
1482			// Do a sibling check if the nodes have a common ancestor
1483			siblingCheck( ap[i], bp[i] ) :
1484
1485			// Otherwise nodes in our document sort first
1486			ap[i] === preferredDoc ? -1 :
1487			bp[i] === preferredDoc ? 1 :
1488			0;
1489	};
1490
1491	return document;
1492};
1493
1494Sizzle.matches = function( expr, elements ) {
1495	return Sizzle( expr, null, null, elements );
1496};
1497
1498Sizzle.matchesSelector = function( elem, expr ) {
1499	// Set document vars if needed
1500	if ( ( elem.ownerDocument || elem ) !== document ) {
1501		setDocument( elem );
1502	}
1503
1504	if ( support.matchesSelector && documentIsHTML &&
1505		!nonnativeSelectorCache[ expr + " " ] &&
1506		( !rbuggyMatches || !rbuggyMatches.test( expr ) ) &&
1507		( !rbuggyQSA     || !rbuggyQSA.test( expr ) ) ) {
1508
1509		try {
1510			var ret = matches.call( elem, expr );
1511
1512			// IE 9's matchesSelector returns false on disconnected nodes
1513			if ( ret || support.disconnectedMatch ||
1514					// As well, disconnected nodes are said to be in a document
1515					// fragment in IE 9
1516					elem.document && elem.document.nodeType !== 11 ) {
1517				return ret;
1518			}
1519		} catch (e) {
1520			nonnativeSelectorCache( expr, true );
1521		}
1522	}
1523
1524	return Sizzle( expr, document, null, [ elem ] ).length > 0;
1525};
1526
1527Sizzle.contains = function( context, elem ) {
1528	// Set document vars if needed
1529	if ( ( context.ownerDocument || context ) !== document ) {
1530		setDocument( context );
1531	}
1532	return contains( context, elem );
1533};
1534
1535Sizzle.attr = function( elem, name ) {
1536	// Set document vars if needed
1537	if ( ( elem.ownerDocument || elem ) !== document ) {
1538		setDocument( elem );
1539	}
1540
1541	var fn = Expr.attrHandle[ name.toLowerCase() ],
1542		// Don't get fooled by Object.prototype properties (jQuery #13807)
1543		val = fn && hasOwn.call( Expr.attrHandle, name.toLowerCase() ) ?
1544			fn( elem, name, !documentIsHTML ) :
1545			undefined;
1546
1547	return val !== undefined ?
1548		val :
1549		support.attributes || !documentIsHTML ?
1550			elem.getAttribute( name ) :
1551			(val = elem.getAttributeNode(name)) && val.specified ?
1552				val.value :
1553				null;
1554};
1555
1556Sizzle.escape = function( sel ) {
1557	return (sel + "").replace( rcssescape, fcssescape );
1558};
1559
1560Sizzle.error = function( msg ) {
1561	throw new Error( "Syntax error, unrecognized expression: " + msg );
1562};
1563
1564/**
1565 * Document sorting and removing duplicates
1566 * @param {ArrayLike} results
1567 */
1568Sizzle.uniqueSort = function( results ) {
1569	var elem,
1570		duplicates = [],
1571		j = 0,
1572		i = 0;
1573
1574	// Unless we *know* we can detect duplicates, assume their presence
1575	hasDuplicate = !support.detectDuplicates;
1576	sortInput = !support.sortStable && results.slice( 0 );
1577	results.sort( sortOrder );
1578
1579	if ( hasDuplicate ) {
1580		while ( (elem = results[i++]) ) {
1581			if ( elem === results[ i ] ) {
1582				j = duplicates.push( i );
1583			}
1584		}
1585		while ( j-- ) {
1586			results.splice( duplicates[ j ], 1 );
1587		}
1588	}
1589
1590	// Clear input after sorting to release objects
1591	// See https://github.com/jquery/sizzle/pull/225
1592	sortInput = null;
1593
1594	return results;
1595};
1596
1597/**
1598 * Utility function for retrieving the text value of an array of DOM nodes
1599 * @param {Array|Element} elem
1600 */
1601getText = Sizzle.getText = function( elem ) {
1602	var node,
1603		ret = "",
1604		i = 0,
1605		nodeType = elem.nodeType;
1606
1607	if ( !nodeType ) {
1608		// If no nodeType, this is expected to be an array
1609		while ( (node = elem[i++]) ) {
1610			// Do not traverse comment nodes
1611			ret += getText( node );
1612		}
1613	} else if ( nodeType === 1 || nodeType === 9 || nodeType === 11 ) {
1614		// Use textContent for elements
1615		// innerText usage removed for consistency of new lines (jQuery #11153)
1616		if ( typeof elem.textContent === "string" ) {
1617			return elem.textContent;
1618		} else {
1619			// Traverse its children
1620			for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
1621				ret += getText( elem );
1622			}
1623		}
1624	} else if ( nodeType === 3 || nodeType === 4 ) {
1625		return elem.nodeValue;
1626	}
1627	// Do not include comment or processing instruction nodes
1628
1629	return ret;
1630};
1631
1632Expr = Sizzle.selectors = {
1633
1634	// Can be adjusted by the user
1635	cacheLength: 50,
1636
1637	createPseudo: markFunction,
1638
1639	match: matchExpr,
1640
1641	attrHandle: {},
1642
1643	find: {},
1644
1645	relative: {
1646		">": { dir: "parentNode", first: true },
1647		" ": { dir: "parentNode" },
1648		"+": { dir: "previousSibling", first: true },
1649		"~": { dir: "previousSibling" }
1650	},
1651
1652	preFilter: {
1653		"ATTR": function( match ) {
1654			match[1] = match[1].replace( runescape, funescape );
1655
1656			// Move the given value to match[3] whether quoted or unquoted
1657			match[3] = ( match[3] || match[4] || match[5] || "" ).replace( runescape, funescape );
1658
1659			if ( match[2] === "~=" ) {
1660				match[3] = " " + match[3] + " ";
1661			}
1662
1663			return match.slice( 0, 4 );
1664		},
1665
1666		"CHILD": function( match ) {
1667			/* matches from matchExpr["CHILD"]
1668				1 type (only|nth|...)
1669				2 what (child|of-type)
1670				3 argument (even|odd|\d*|\d*n([+-]\d+)?|...)
1671				4 xn-component of xn+y argument ([+-]?\d*n|)
1672				5 sign of xn-component
1673				6 x of xn-component
1674				7 sign of y-component
1675				8 y of y-component
1676			*/
1677			match[1] = match[1].toLowerCase();
1678
1679			if ( match[1].slice( 0, 3 ) === "nth" ) {
1680				// nth-* requires argument
1681				if ( !match[3] ) {
1682					Sizzle.error( match[0] );
1683				}
1684
1685				// numeric x and y parameters for Expr.filter.CHILD
1686				// remember that false/true cast respectively to 0/1
1687				match[4] = +( match[4] ? match[5] + (match[6] || 1) : 2 * ( match[3] === "even" || match[3] === "odd" ) );
1688				match[5] = +( ( match[7] + match[8] ) || match[3] === "odd" );
1689
1690			// other types prohibit arguments
1691			} else if ( match[3] ) {
1692				Sizzle.error( match[0] );
1693			}
1694
1695			return match;
1696		},
1697
1698		"PSEUDO": function( match ) {
1699			var excess,
1700				unquoted = !match[6] && match[2];
1701
1702			if ( matchExpr["CHILD"].test( match[0] ) ) {
1703				return null;
1704			}
1705
1706			// Accept quoted arguments as-is
1707			if ( match[3] ) {
1708				match[2] = match[4] || match[5] || "";
1709
1710			// Strip excess characters from unquoted arguments
1711			} else if ( unquoted && rpseudo.test( unquoted ) &&
1712				// Get excess from tokenize (recursively)
1713				(excess = tokenize( unquoted, true )) &&
1714				// advance to the next closing parenthesis
1715				(excess = unquoted.indexOf( ")", unquoted.length - excess ) - unquoted.length) ) {
1716
1717				// excess is a negative index
1718				match[0] = match[0].slice( 0, excess );
1719				match[2] = unquoted.slice( 0, excess );
1720			}
1721
1722			// Return only captures needed by the pseudo filter method (type and argument)
1723			return match.slice( 0, 3 );
1724		}
1725	},
1726
1727	filter: {
1728
1729		"TAG": function( nodeNameSelector ) {
1730			var nodeName = nodeNameSelector.replace( runescape, funescape ).toLowerCase();
1731			return nodeNameSelector === "*" ?
1732				function() { return true; } :
1733				function( elem ) {
1734					return elem.nodeName && elem.nodeName.toLowerCase() === nodeName;
1735				};
1736		},
1737
1738		"CLASS": function( className ) {
1739			var pattern = classCache[ className + " " ];
1740
1741			return pattern ||
1742				(pattern = new RegExp( "(^|" + whitespace + ")" + className + "(" + whitespace + "|$)" )) &&
1743				classCache( className, function( elem ) {
1744					return pattern.test( typeof elem.className === "string" && elem.className || typeof elem.getAttribute !== "undefined" && elem.getAttribute("class") || "" );
1745				});
1746		},
1747
1748		"ATTR": function( name, operator, check ) {
1749			return function( elem ) {
1750				var result = Sizzle.attr( elem, name );
1751
1752				if ( result == null ) {
1753					return operator === "!=";
1754				}
1755				if ( !operator ) {
1756					return true;
1757				}
1758
1759				result += "";
1760
1761				return operator === "=" ? result === check :
1762					operator === "!=" ? result !== check :
1763					operator === "^=" ? check && result.indexOf( check ) === 0 :
1764					operator === "*=" ? check && result.indexOf( check ) > -1 :
1765					operator === "$=" ? check && result.slice( -check.length ) === check :
1766					operator === "~=" ? ( " " + result.replace( rwhitespace, " " ) + " " ).indexOf( check ) > -1 :
1767					operator === "|=" ? result === check || result.slice( 0, check.length + 1 ) === check + "-" :
1768					false;
1769			};
1770		},
1771
1772		"CHILD": function( type, what, argument, first, last ) {
1773			var simple = type.slice( 0, 3 ) !== "nth",
1774				forward = type.slice( -4 ) !== "last",
1775				ofType = what === "of-type";
1776
1777			return first === 1 && last === 0 ?
1778
1779				// Shortcut for :nth-*(n)
1780				function( elem ) {
1781					return !!elem.parentNode;
1782				} :
1783
1784				function( elem, context, xml ) {
1785					var cache, uniqueCache, outerCache, node, nodeIndex, start,
1786						dir = simple !== forward ? "nextSibling" : "previousSibling",
1787						parent = elem.parentNode,
1788						name = ofType && elem.nodeName.toLowerCase(),
1789						useCache = !xml && !ofType,
1790						diff = false;
1791
1792					if ( parent ) {
1793
1794						// :(first|last|only)-(child|of-type)
1795						if ( simple ) {
1796							while ( dir ) {
1797								node = elem;
1798								while ( (node = node[ dir ]) ) {
1799									if ( ofType ?
1800										node.nodeName.toLowerCase() === name :
1801										node.nodeType === 1 ) {
1802
1803										return false;
1804									}
1805								}
1806								// Reverse direction for :only-* (if we haven't yet done so)
1807								start = dir = type === "only" && !start && "nextSibling";
1808							}
1809							return true;
1810						}
1811
1812						start = [ forward ? parent.firstChild : parent.lastChild ];
1813
1814						// non-xml :nth-child(...) stores cache data on `parent`
1815						if ( forward && useCache ) {
1816
1817							// Seek `elem` from a previously-cached index
1818
1819							// ...in a gzip-friendly way
1820							node = parent;
1821							outerCache = node[ expando ] || (node[ expando ] = {});
1822
1823							// Support: IE <9 only
1824							// Defend against cloned attroperties (jQuery gh-1709)
1825							uniqueCache = outerCache[ node.uniqueID ] ||
1826								(outerCache[ node.uniqueID ] = {});
1827
1828							cache = uniqueCache[ type ] || [];
1829							nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ];
1830							diff = nodeIndex && cache[ 2 ];
1831							node = nodeIndex && parent.childNodes[ nodeIndex ];
1832
1833							while ( (node = ++nodeIndex && node && node[ dir ] ||
1834
1835								// Fallback to seeking `elem` from the start
1836								(diff = nodeIndex = 0) || start.pop()) ) {
1837
1838								// When found, cache indexes on `parent` and break
1839								if ( node.nodeType === 1 && ++diff && node === elem ) {
1840									uniqueCache[ type ] = [ dirruns, nodeIndex, diff ];
1841									break;
1842								}
1843							}
1844
1845						} else {
1846							// Use previously-cached element index if available
1847							if ( useCache ) {
1848								// ...in a gzip-friendly way
1849								node = elem;
1850								outerCache = node[ expando ] || (node[ expando ] = {});
1851
1852								// Support: IE <9 only
1853								// Defend against cloned attroperties (jQuery gh-1709)
1854								uniqueCache = outerCache[ node.uniqueID ] ||
1855									(outerCache[ node.uniqueID ] = {});
1856
1857								cache = uniqueCache[ type ] || [];
1858								nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ];
1859								diff = nodeIndex;
1860							}
1861
1862							// xml :nth-child(...)
1863							// or :nth-last-child(...) or :nth(-last)?-of-type(...)
1864							if ( diff === false ) {
1865								// Use the same loop as above to seek `elem` from the start
1866								while ( (node = ++nodeIndex && node && node[ dir ] ||
1867									(diff = nodeIndex = 0) || start.pop()) ) {
1868
1869									if ( ( ofType ?
1870										node.nodeName.toLowerCase() === name :
1871										node.nodeType === 1 ) &&
1872										++diff ) {
1873
1874										// Cache the index of each encountered element
1875										if ( useCache ) {
1876											outerCache = node[ expando ] || (node[ expando ] = {});
1877
1878											// Support: IE <9 only
1879											// Defend against cloned attroperties (jQuery gh-1709)
1880											uniqueCache = outerCache[ node.uniqueID ] ||
1881												(outerCache[ node.uniqueID ] = {});
1882
1883											uniqueCache[ type ] = [ dirruns, diff ];
1884										}
1885
1886										if ( node === elem ) {
1887											break;
1888										}
1889									}
1890								}
1891							}
1892						}
1893
1894						// Incorporate the offset, then check against cycle size
1895						diff -= last;
1896						return diff === first || ( diff % first === 0 && diff / first >= 0 );
1897					}
1898				};
1899		},
1900
1901		"PSEUDO": function( pseudo, argument ) {
1902			// pseudo-class names are case-insensitive
1903			// http://www.w3.org/TR/selectors/#pseudo-classes
1904			// Prioritize by case sensitivity in case custom pseudos are added with uppercase letters
1905			// Remember that setFilters inherits from pseudos
1906			var args,
1907				fn = Expr.pseudos[ pseudo ] || Expr.setFilters[ pseudo.toLowerCase() ] ||
1908					Sizzle.error( "unsupported pseudo: " + pseudo );
1909
1910			// The user may use createPseudo to indicate that
1911			// arguments are needed to create the filter function
1912			// just as Sizzle does
1913			if ( fn[ expando ] ) {
1914				return fn( argument );
1915			}
1916
1917			// But maintain support for old signatures
1918			if ( fn.length > 1 ) {
1919				args = [ pseudo, pseudo, "", argument ];
1920				return Expr.setFilters.hasOwnProperty( pseudo.toLowerCase() ) ?
1921					markFunction(function( seed, matches ) {
1922						var idx,
1923							matched = fn( seed, argument ),
1924							i = matched.length;
1925						while ( i-- ) {
1926							idx = indexOf( seed, matched[i] );
1927							seed[ idx ] = !( matches[ idx ] = matched[i] );
1928						}
1929					}) :
1930					function( elem ) {
1931						return fn( elem, 0, args );
1932					};
1933			}
1934
1935			return fn;
1936		}
1937	},
1938
1939	pseudos: {
1940		// Potentially complex pseudos
1941		"not": markFunction(function( selector ) {
1942			// Trim the selector passed to compile
1943			// to avoid treating leading and trailing
1944			// spaces as combinators
1945			var input = [],
1946				results = [],
1947				matcher = compile( selector.replace( rtrim, "$1" ) );
1948
1949			return matcher[ expando ] ?
1950				markFunction(function( seed, matches, context, xml ) {
1951					var elem,
1952						unmatched = matcher( seed, null, xml, [] ),
1953						i = seed.length;
1954
1955					// Match elements unmatched by `matcher`
1956					while ( i-- ) {
1957						if ( (elem = unmatched[i]) ) {
1958							seed[i] = !(matches[i] = elem);
1959						}
1960					}
1961				}) :
1962				function( elem, context, xml ) {
1963					input[0] = elem;
1964					matcher( input, null, xml, results );
1965					// Don't keep the element (issue #299)
1966					input[0] = null;
1967					return !results.pop();
1968				};
1969		}),
1970
1971		"has": markFunction(function( selector ) {
1972			return function( elem ) {
1973				return Sizzle( selector, elem ).length > 0;

1974			};
1975		}),
1976
1977		"contains": markFunction(function( text ) {
1978			text = text.replace( runescape, funescape );
1979			return function( elem ) {
1980				return ( elem.textContent || getText( elem ) ).indexOf( text ) > -1;
1981			};
1982		}),
1983
1984		// "Whether an element is represented by a :lang() selector
1985		// is based solely on the element's language value
1986		// being equal to the identifier C,
1987		// or beginning with the identifier C immediately followed by "-".
1988		// The matching of C against the element's language value is performed case-insensitively.
1989		// The identifier C does not have to be a valid language name."
1990		// http://www.w3.org/TR/selectors/#lang-pseudo
1991		"lang": markFunction( function( lang ) {
1992			// lang value must be a valid identifier
1993			if ( !ridentifier.test(lang || "") ) {
1994				Sizzle.error( "unsupported lang: " + lang );
1995			}
1996			lang = lang.replace( runescape, funescape ).toLowerCase();
1997			return function( elem ) {
1998				var elemLang;
1999				do {
2000					if ( (elemLang = documentIsHTML ?
2001						elem.lang :
2002						elem.getAttribute("xml:lang") || elem.getAttribute("lang")) ) {
2003
2004						elemLang = elemLang.toLowerCase();
2005						return elemLang === lang || elemLang.indexOf( lang + "-" ) === 0;
2006					}
2007				} while ( (elem = elem.parentNode) && elem.nodeType === 1 );
2008				return false;
2009			};
2010		}),
2011
2012		// Miscellaneous
2013		"target": function( elem ) {
2014			var hash = window.location && window.location.hash;
2015			return hash && hash.slice( 1 ) === elem.id;
2016		},
2017
2018		"root": function( elem ) {
2019			return elem === docElem;
2020		},
2021
2022		"focus": function( elem ) {
2023			return elem === document.activeElement && (!document.hasFocus || document.hasFocus()) && !!(elem.type || elem.href || ~elem.tabIndex);
2024		},
2025
2026		// Boolean properties
2027		"enabled": createDisabledPseudo( false ),
2028		"disabled": createDisabledPseudo( true ),
2029
2030		"checked": function( elem ) {
2031			// In CSS3, :checked should return both checked and selected elements
2032			// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
2033			var nodeName = elem.nodeName.toLowerCase();
2034			return (nodeName === "input" && !!elem.checked) || (nodeName === "option" && !!elem.selected);
2035		},
2036
2037		"selected": function( elem ) {
2038			// Accessing this property makes selected-by-default
2039			// options in Safari work properly
2040			if ( elem.parentNode ) {
2041				elem.parentNode.selectedIndex;
2042			}
2043
2044			return elem.selected === true;
2045		},
2046
2047		// Contents
2048		"empty": function( elem ) {
2049			// http://www.w3.org/TR/selectors/#empty-pseudo
2050			// :empty is negated by element (1) or content nodes (text: 3; cdata: 4; entity ref: 5),
2051			//   but not by others (comment: 8; processing instruction: 7; etc.)
2052			// nodeType < 6 works because attributes (2) do not appear as children
2053			for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
2054				if ( elem.nodeType < 6 ) {
2055					return false;
2056				}
2057			}
2058			return true;
2059		},
2060
2061		"parent": function( elem ) {
2062			return !Expr.pseudos["empty"]( elem );
2063		},
2064
2065		// Element/input types
2066		"header": function( elem ) {
2067			return rheader.test( elem.nodeName );
2068		},
2069
2070		"input": function( elem ) {
2071			return rinputs.test( elem.nodeName );
2072		},
2073
2074		"button": function( elem ) {
2075			var name = elem.nodeName.toLowerCase();
2076			return name === "input" && elem.type === "button" || name === "button";
2077		},
2078
2079		"text": function( elem ) {
2080			var attr;
2081			return elem.nodeName.toLowerCase() === "input" &&
2082				elem.type === "text" &&
2083
2084				// Support: IE<8
2085				// New HTML5 attribute values (e.g., "search") appear with elem.type === "text"
2086				( (attr = elem.getAttribute("type")) == null || attr.toLowerCase() === "text" );
2087		},
2088
2089		// Position-in-collection
2090		"first": createPositionalPseudo(function() {
2091			return [ 0 ];
2092		}),
2093
2094		"last": createPositionalPseudo(function( matchIndexes, length ) {
2095			return [ length - 1 ];
2096		}),
2097
2098		"eq": createPositionalPseudo(function( matchIndexes, length, argument ) {
2099			return [ argument < 0 ? argument + length : argument ];
2100		}),
2101
2102		"even": createPositionalPseudo(function( matchIndexes, length ) {
2103			var i = 0;
2104			for ( ; i < length; i += 2 ) {
2105				matchIndexes.push( i );
2106			}
2107			return matchIndexes;
2108		}),
2109
2110		"odd": createPositionalPseudo(function( matchIndexes, length ) {
2111			var i = 1;
2112			for ( ; i < length; i += 2 ) {
2113				matchIndexes.push( i );
2114			}
2115			return matchIndexes;
2116		}),
2117
2118		"lt": createPositionalPseudo(function( matchIndexes, length, argument ) {
2119			var i = argument < 0 ?
2120				argument + length :
2121				argument > length ?
2122					length :
2123					argument;
2124			for ( ; --i >= 0; ) {
2125				matchIndexes.push( i );
2126			}
2127			return matchIndexes;
2128		}),
2129
2130		"gt": createPositionalPseudo(function( matchIndexes, length, argument ) {
2131			var i = argument < 0 ? argument + length : argument;
2132			for ( ; ++i < length; ) {
2133				matchIndexes.push( i );
2134			}
2135			return matchIndexes;
2136		})
2137	}
2138};
2139
2140Expr.pseudos["nth"] = Expr.pseudos["eq"];
2141
2142// Add button/input type pseudos
2143for ( i in { radio: true, checkbox: true, file: true, password: true, image: true } ) {
2144	Expr.pseudos[ i ] = createInputPseudo( i );
2145}
2146for ( i in { submit: true, reset: true } ) {
2147	Expr.pseudos[ i ] = createButtonPseudo( i );
2148}
2149
2150// Easy API for creating new setFilters
2151function setFilters() {}
2152setFilters.prototype = Expr.filters = Expr.pseudos;
2153Expr.setFilters = new setFilters();
2154
2155tokenize = Sizzle.tokenize = function( selector, parseOnly ) {
2156	var matched, match, tokens, type,
2157		soFar, groups, preFilters,
2158		cached = tokenCache[ selector + " " ];
2159
2160	if ( cached ) {
2161		return parseOnly ? 0 : cached.slice( 0 );
2162	}
2163
2164	soFar = selector;
2165	groups = [];
2166	preFilters = Expr.preFilter;
2167
2168	while ( soFar ) {
2169
2170		// Comma and first run
2171		if ( !matched || (match = rcomma.exec( soFar )) ) {
2172			if ( match ) {
2173				// Don't consume trailing commas as valid
2174				soFar = soFar.slice( match[0].length ) || soFar;
2175			}
2176			groups.push( (tokens = []) );
2177		}
2178
2179		matched = false;
2180
2181		// Combinators
2182		if ( (match = rcombinators.exec( soFar )) ) {
2183			matched = match.shift();
2184			tokens.push({
2185				value: matched,
2186				// Cast descendant combinators to space
2187				type: match[0].replace( rtrim, " " )
2188			});
2189			soFar = soFar.slice( matched.length );
2190		}
2191
2192		// Filters
2193		for ( type in Expr.filter ) {
2194			if ( (match = matchExpr[ type ].exec( soFar )) && (!preFilters[ type ] ||
2195				(match = preFilters[ type ]( match ))) ) {
2196				matched = match.shift();
2197				tokens.push({
2198					value: matched,
2199					type: type,
2200					matches: match
2201				});
2202				soFar = soFar.slice( matched.length );
2203			}
2204		}
2205
2206		if ( !matched ) {
2207			break;
2208		}
2209	}
2210
2211	// Return the length of the invalid excess
2212	// if we're just parsing
2213	// Otherwise, throw an error or return tokens
2214	return parseOnly ?
2215		soFar.length :
2216		soFar ?
2217			Sizzle.error( selector ) :
2218			// Cache the tokens
2219			tokenCache( selector, groups ).slice( 0 );
2220};

2221
2222function toSelector( tokens ) {
2223	var i = 0,
2224		len = tokens.length,
2225		selector = "";
2226	for ( ; i < len; i++ ) {
2227		selector += tokens[i].value;
2228	}
2229	return selector;
2230}
2231
2232function addCombinator( matcher, combinator, base ) {
2233	var dir = combinator.dir,
2234		skip = combinator.next,
2235		key = skip || dir,
2236		checkNonElements = base && key === "parentNode",
2237		doneName = done++;
2238
2239	return combinator.first ?
2240		// Check against closest ancestor/preceding element
2241		function( elem, context, xml ) {
2242			while ( (elem = elem[ dir ]) ) {
2243				if ( elem.nodeType === 1 || checkNonElements ) {
2244					return matcher( elem, context, xml );
2245				}
2246			}
2247			return false;
2248		} :
2249
2250		// Check against all ancestor/preceding elements
2251		function( elem, context, xml ) {
2252			var oldCache, uniqueCache, outerCache,
2253				newCache = [ dirruns, doneName ];
2254
2255			// We can't set arbitrary data on XML nodes, so they don't benefit from combinator caching
2256			if ( xml ) {
2257				while ( (elem = elem[ dir ]) ) {
2258					if ( elem.nodeType === 1 || checkNonElements ) {
2259						if ( matcher( elem, context, xml ) ) {
2260							return true;
2261						}
2262					}
2263				}
2264			} else {
2265				while ( (elem = elem[ dir ]) ) {
2266					if ( elem.nodeType === 1 || checkNonElements ) {
2267						outerCache = elem[ expando ] || (elem[ expando ] = {});
2268
2269						// Support: IE <9 only
2270						// Defend against cloned attroperties (jQuery gh-1709)
2271						uniqueCache = outerCache[ elem.uniqueID ] || (outerCache[ elem.uniqueID ] = {});
2272
2273						if ( skip && skip === elem.nodeName.toLowerCase() ) {
2274							elem = elem[ dir ] || elem;
2275						} else if ( (oldCache = uniqueCache[ key ]) &&
2276							oldCache[ 0 ] === dirruns && oldCache[ 1 ] === doneName ) {
2277
2278							// Assign to newCache so results back-propagate to previous elements
2279							return (newCache[ 2 ] = oldCache[ 2 ]);
2280						} else {
2281							// Reuse newcache so results back-propagate to previous elements
2282							uniqueCache[ key ] = newCache;
2283
2284							// A match means we're done; a fail means we have to keep checking
2285							if ( (newCache[ 2 ] = matcher( elem, context, xml )) ) {
2286								return true;
2287							}
2288						}
2289					}
2290				}
2291			}
2292			return false;
2293		};
2294}
2295
2296function elementMatcher( matchers ) {
2297	return matchers.length > 1 ?
2298		function( elem, context, xml ) {
2299			var i = matchers.length;
2300			while ( i-- ) {
2301				if ( !matchers[i]( elem, context, xml ) ) {
2302					return false;
2303				}
2304			}
2305			return true;
2306		} :
2307		matchers[0];
2308}
2309
2310function multipleContexts( selector, contexts, results ) {
2311	var i = 0,
2312		len = contexts.length;
2313	for ( ; i < len; i++ ) {
2314		Sizzle( selector, contexts[i], results );
2315	}
2316	return results;
2317}
2318
2319function condense( unmatched, map, filter, context, xml ) {
2320	var elem,
2321		newUnmatched = [],
2322		i = 0,
2323		len = unmatched.length,
2324		mapped = map != null;
2325
2326	for ( ; i < len; i++ ) {
2327		if ( (elem = unmatched[i]) ) {
2328			if ( !filter || filter( elem, context, xml ) ) {
2329				newUnmatched.push( elem );
2330				if ( mapped ) {
2331					map.push( i );
2332				}
2333			}
2334		}
2335	}
2336
2337	return newUnmatched;
2338}
2339
2340function setMatcher( preFilter, selector, matcher, postFilter, postFinder, postSelector ) {
2341	if ( postFilter && !postFilter[ expando ] ) {
2342		postFilter = setMatcher( postFilter );
2343	}
2344	if ( postFinder && !postFinder[ expando ] ) {
2345		postFinder = setMatcher( postFinder, postSelector );
2346	}
2347	return markFunction(function( seed, results, context, xml ) {
2348		var temp, i, elem,
2349			preMap = [],
2350			postMap = [],
2351			preexisting = results.length,
2352
2353			// Get initial elements from seed or context
2354			elems = seed || multipleContexts( selector || "*", context.nodeType ? [ context ] : context, [] ),
2355
2356			// Prefilter to get matcher input, preserving a map for seed-results synchronization
2357			matcherIn = preFilter && ( seed || !selector ) ?
2358				condense( elems, preMap, preFilter, context, xml ) :
2359				elems,
2360
2361			matcherOut = matcher ?
2362				// If we have a postFinder, or filtered seed, or non-seed postFilter or preexisting results,
2363				postFinder || ( seed ? preFilter : preexisting || postFilter ) ?
2364
2365					// ...intermediate processing is necessary
2366					[] :
2367
2368					// ...otherwise use results directly
2369					results :
2370				matcherIn;
2371
2372		// Find primary matches
2373		if ( matcher ) {
2374			matcher( matcherIn, matcherOut, context, xml );
2375		}
2376
2377		// Apply postFilter
2378		if ( postFilter ) {
2379			temp = condense( matcherOut, postMap );
2380			postFilter( temp, [], context, xml );
2381
2382			// Un-match failing elements by moving them back to matcherIn
2383			i = temp.length;
2384			while ( i-- ) {
2385				if ( (elem = temp[i]) ) {
2386					matcherOut[ postMap[i] ] = !(matcherIn[ postMap[i] ] = elem);
2387				}
2388			}
2389		}
2390
2391		if ( seed ) {
2392			if ( postFinder || preFilter ) {
2393				if ( postFinder ) {
2394					// Get the final matcherOut by condensing this intermediate into postFinder contexts
2395					temp = [];
2396					i = matcherOut.length;
2397					while ( i-- ) {
2398						if ( (elem = matcherOut[i]) ) {
2399							// Restore matcherIn since elem is not yet a final match
2400							temp.push( (matcherIn[i] = elem) );
2401						}
2402					}
2403					postFinder( null, (matcherOut = []), temp, xml );
2404				}
2405
2406				// Move matched elements from seed to results to keep them synchronized
2407				i = matcherOut.length;
2408				while ( i-- ) {
2409					if ( (elem = matcherOut[i]) &&
2410						(temp = postFinder ? indexOf( seed, elem ) : preMap[i]) > -1 ) {
2411
2412						seed[temp] = !(results[temp] = elem);
2413					}
2414				}
2415			}
2416
2417		// Add elements to results, through postFinder if defined
2418		} else {
2419			matcherOut = condense(
2420				matcherOut === results ?
2421					matcherOut.splice( preexisting, matcherOut.length ) :
2422					matcherOut
2423			);
2424			if ( postFinder ) {
2425				postFinder( null, results, matcherOut, xml );
2426			} else {
2427				push.apply( results, matcherOut );
2428			}
2429		}
2430	});
2431}
2432
2433function matcherFromTokens( tokens ) {
2434	var checkContext, matcher, j,
2435		len = tokens.length,
2436		leadingRelative = Expr.relative[ tokens[0].type ],

2437		implicitRelative = leadingRelative || Expr.relative[" "],
2438		i = leadingRelative ? 1 : 0,
2439
2440		// The foundational matcher ensures that elements are reachable from top-level context(s)
2441		matchContext = addCombinator( function( elem ) {
2442			return elem === checkContext;
2443		}, implicitRelative, true ),
2444		matchAnyContext = addCombinator( function( elem ) {
2445			return indexOf( checkContext, elem ) > -1;
2446		}, implicitRelative, true ),
2447		matchers = [ function( elem, context, xml ) {
2448			var ret = ( !leadingRelative && ( xml || context !== outermostContext ) ) || (
2449				(checkContext = context).nodeType ?
2450					matchContext( elem, context, xml ) :
2451					matchAnyContext( elem, context, xml ) );
2452			// Avoid hanging onto element (issue #299)
2453			checkContext = null;
2454			return ret;
2455		} ];
2456
2457	for ( ; i < len; i++ ) {
2458		if ( (matcher = Expr.relative[ tokens[i].type ]) ) {
2459			matchers = [ addCombinator(elementMatcher( matchers ), matcher) ];
2460		} else {
2461			matcher = Expr.filter[ tokens[i].type ].apply( null, tokens[i].matches );
2462
2463			// Return special upon seeing a positional matcher
2464			if ( matcher[ expando ] ) {
2465				// Find the next relative operator (if any) for proper handling
2466				j = ++i;
2467				for ( ; j < len; j++ ) {
2468					if ( Expr.relative[ tokens[j].type ] ) {
2469						break;
2470					}
2471				}
2472				return setMatcher(
2473					i > 1 && elementMatcher( matchers ),
2474					i > 1 && toSelector(
2475						// If the preceding token was a descendant combinator, insert an implicit any-element `*`
2476						tokens.slice( 0, i - 1 ).concat({ value: tokens[ i - 2 ].type === " " ? "*" : "" })
2477					).replace( rtrim, "$1" ),
2478					matcher,
2479					i < j && matcherFromTokens( tokens.slice( i, j ) ),
2480					j < len && matcherFromTokens( (tokens = tokens.slice( j )) ),
2481					j < len && toSelector( tokens )
2482				);
2483			}
2484			matchers.push( matcher );
2485		}
2486	}
2487
2488	return elementMatcher( matchers );
2489}
2490
2491function matcherFromGroupMatchers( elementMatchers, setMatchers ) {
2492	var bySet = setMatchers.length > 0,
2493		byElement = elementMatchers.length > 0,
2494		superMatcher = function( seed, context, xml, results, outermost ) {
2495			var elem, j, matcher,
2496				matchedCount = 0,
2497				i = "0",
2498				unmatched = seed && [],
2499				setMatched = [],
2500				contextBackup = outermostContext,
2501				// We must always have either seed elements or outermost context
2502				elems = seed || byElement && Expr.find["TAG"]( "*", outermost ),
2503				// Use integer dirruns iff this is the outermost matcher
2504				dirrunsUnique = (dirruns += contextBackup == null ? 1 : Math.random() || 0.1),
2505				len = elems.length;
2506
2507			if ( outermost ) {
2508				outermostContext = context === document || context || outermost;
2509			}
2510
2511			// Add elements passing elementMatchers directly to results
2512			// Support: IE<9, Safari
2513			// Tolerate NodeList properties (IE: "length"; Safari: <number>) matching elements by id
2514			for ( ; i !== len && (elem = elems[i]) != null; i++ ) {
2515				if ( byElement && elem ) {
2516					j = 0;
2517					if ( !context && elem.ownerDocument !== document ) {
2518						setDocument( elem );
2519						xml = !documentIsHTML;
2520					}
2521					while ( (matcher = elementMatchers[j++]) ) {
2522						if ( matcher( elem, context || document, xml) ) {
2523							results.push( elem );
2524							break;
2525						}
2526					}
2527					if ( outermost ) {
2528						dirruns = dirrunsUnique;
2529					}
2530				}
2531
2532				// Track unmatched elements for set filters
2533				if ( bySet ) {
2534					// They will have gone through all possible matchers
2535					if ( (elem = !matcher && elem) ) {
2536						matchedCount--;
2537					}
2538
2539					// Lengthen the array for every element, matched or not
2540					if ( seed ) {
2541						unmatched.push( elem );
2542					}
2543				}
2544			}
2545
2546			// `i` is now the count of elements visited above, and adding it to `matchedCount`
2547			// makes the latter nonnegative.
2548			matchedCount += i;
2549
2550			// Apply set filters to unmatched elements
2551			// NOTE: This can be skipped if there are no unmatched elements (i.e., `matchedCount`
2552			// equals `i`), unless we didn't visit _any_ elements in the above loop because we have
2553			// no element matchers and no seed.
2554			// Incrementing an initially-string "0" `i` allows `i` to remain a string only in that
2555			// case, which will result in a "00" `matchedCount` that differs from `i` but is also
2556			// numerically zero.
2557			if ( bySet && i !== matchedCount ) {
2558				j = 0;
2559				while ( (matcher = setMatchers[j++]) ) {
2560					matcher( unmatched, setMatched, context, xml );
2561				}
2562
2563				if ( seed ) {
2564					// Reintegrate element matches to eliminate the need for sorting
2565					if ( matchedCount > 0 ) {
2566						while ( i-- ) {
2567							if ( !(unmatched[i] || setMatched[i]) ) {
2568								setMatched[i] = pop.call( results );
2569							}
2570						}
2571					}
2572
2573					// Discard index placeholder values to get only actual matches
2574					setMatched = condense( setMatched );
2575				}
2576
2577				// Add matches to results
2578				push.apply( results, setMatched );
2579
2580				// Seedless set matches succeeding multiple successful matchers stipulate sorting
2581				if ( outermost && !seed && setMatched.length > 0 &&
2582					( matchedCount + setMatchers.length ) > 1 ) {
2583
2584					Sizzle.uniqueSort( results );
2585				}
2586			}
2587
2588			// Override manipulation of globals by nested matchers
2589			if ( outermost ) {
2590				dirruns = dirrunsUnique;
2591				outermostContext = contextBackup;
2592			}
2593
2594			return unmatched;
2595		};
2596
2597	return bySet ?
2598		markFunction( superMatcher ) :
2599		superMatcher;
2600}
2601
2602compile = Sizzle.compile = function( selector, match /* Internal Use Only */ ) {
2603	var i,
2604		setMatchers = [],
2605		elementMatchers = [],
2606		cached = compilerCache[ selector + " " ];
2607
2608	if ( !cached ) {
2609		// Generate a function of recursive functions that can be used to check each element
2610		if ( !match ) {
2611			match = tokenize( selector );
2612		}
2613		i = match.length;
2614		while ( i-- ) {
2615			cached = matcherFromTokens( match[i] );
2616			if ( cached[ expando ] ) {
2617				setMatchers.push( cached );
2618			} else {
2619				elementMatchers.push( cached );
2620			}
2621		}
2622
2623		// Cache the compiled function
2624		cached = compilerCache( selector, matcherFromGroupMatchers( elementMatchers, setMatchers ) );
2625
2626		// Save selector and tokenization
2627		cached.selector = selector;
2628	}
2629	return cached;
2630};

2631
2632/**
2633 * A low-level selection function that works with Sizzle's compiled
2634 *  selector functions
2635 * @param {String|Function} selector A selector or a pre-compiled
2636 *  selector function built with Sizzle.compile
2637 * @param {Element} context
2638 * @param {Array} [results]
2639 * @param {Array} [seed] A set of elements to match against
2640 */
2641select = Sizzle.select = function( selector, context, results, seed ) {
2642	var i, tokens, token, type, find,
2643		compiled = typeof selector === "function" && selector,
2644		match = !seed && tokenize( (selector = compiled.selector || selector) );
2645
2646	results = results || [];
2647
2648	// Try to minimize operations if there is only one selector in the list and no seed
2649	// (the latter of which guarantees us context)
2650	if ( match.length === 1 ) {
2651
2652		// Reduce context if the leading compound selector is an ID
2653		tokens = match[0] = match[0].slice( 0 );
2654		if ( tokens.length > 2 && (token = tokens[0]).type === "ID" &&
2655				context.nodeType === 9 && documentIsHTML && Expr.relative[ tokens[1].type ] ) {
2656
2657			context = ( Expr.find["ID"]( token.matches[0].replace(runescape, funescape), context ) || [] )[0];
2658			if ( !context ) {
2659				return results;
2660
2661			// Precompiled matchers will still verify ancestry, so step up a level
2662			} else if ( compiled ) {
2663				context = context.parentNode;
2664			}
2665
2666			selector = selector.slice( tokens.shift().value.length );
2667		}
2668
2669		// Fetch a seed set for right-to-left matching
2670		i = matchExpr["needsContext"].test( selector ) ? 0 : tokens.length;
2671		while ( i-- ) {
2672			token = tokens[i];
2673
2674			// Abort if we hit a combinator
2675			if ( Expr.relative[ (type = token.type) ] ) {
2676				break;
2677			}
2678			if ( (find = Expr.find[ type ]) ) {
2679				// Search, expanding context for leading sibling combinators
2680				if ( (seed = find(
2681					token.matches[0].replace( runescape, funescape ),
2682					rsibling.test( tokens[0].type ) && testContext( context.parentNode ) || context
2683				)) ) {
2684
2685					// If seed is empty or no tokens remain, we can return early
2686					tokens.splice( i, 1 );
2687					selector = seed.length && toSelector( tokens );
2688					if ( !selector ) {
2689						push.apply( results, seed );
2690						return results;
2691					}
2692
2693					break;
2694				}
2695			}
2696		}
2697	}
2698
2699	// Compile and execute a filtering function if one is not provided
2700	// Provide `match` to avoid retokenization if we modified the selector above
2701	( compiled || compile( selector, match ) )(
2702		seed,
2703		context,
2704		!documentIsHTML,
2705		results,
2706		!context || rsibling.test( selector ) && testContext( context.parentNode ) || context
2707	);
2708	return results;
2709};
2710
2711// One-time assignments
2712
2713// Sort stability
2714support.sortStable = expando.split("").sort( sortOrder ).join("") === expando;
2715
2716// Support: Chrome 14-35+
2717// Always assume duplicates if they aren't passed to the comparison function
2718support.detectDuplicates = !!hasDuplicate;
2719
2720// Initialize against the default document
2721setDocument();
2722
2723// Support: Webkit<537.32 - Safari 6.0.3/Chrome 25 (fixed in Chrome 27)
2724// Detached nodes confoundingly follow *each other*
2725support.sortDetached = assert(function( el ) {
2726	// Should return 1, but returns 4 (following)
2727	return el.compareDocumentPosition( document.createElement("fieldset") ) & 1;
2728});
2729
2730// Support: IE<8
2731// Prevent attribute/property "interpolation"
2732// https://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx
2733if ( !assert(function( el ) {
2734	el.innerHTML = "<a href='#'></a>";
2735	return el.firstChild.getAttribute("href") === "#" ;
2736}) ) {
2737	addHandle( "type|href|height|width", function( elem, name, isXML ) {
2738		if ( !isXML ) {
2739			return elem.getAttribute( name, name.toLowerCase() === "type" ? 1 : 2 );
2740		}
2741	});
2742}
2743
2744// Support: IE<9
2745// Use defaultValue in place of getAttribute("value")
2746if ( !support.attributes || !assert(function( el ) {
2747	el.innerHTML = "<input/>";
2748	el.firstChild.setAttribute( "value", "" );
2749	return el.firstChild.getAttribute( "value" ) === "";
2750}) ) {
2751	addHandle( "value", function( elem, name, isXML ) {
2752		if ( !isXML && elem.nodeName.toLowerCase() === "input" ) {
2753			return elem.defaultValue;
2754		}
2755	});
2756}
2757
2758// Support: IE<9
2759// Use getAttributeNode to fetch booleans when getAttribute lies
2760if ( !assert(function( el ) {
2761	return el.getAttribute("disabled") == null;
2762}) ) {
2763	addHandle( booleans, function( elem, name, isXML ) {
2764		var val;
2765		if ( !isXML ) {
2766			return elem[ name ] === true ? name.toLowerCase() :
2767					(val = elem.getAttributeNode( name )) && val.specified ?
2768					val.value :
2769				null;
2770		}
2771	});
2772}
2773
2774return Sizzle;
2775
2776})( window );
2777
2778
2779
2780jQuery.find = Sizzle;
2781jQuery.expr = Sizzle.selectors;
2782
2783// Deprecated
2784jQuery.expr[ ":" ] = jQuery.expr.pseudos;
2785jQuery.uniqueSort = jQuery.unique = Sizzle.uniqueSort;
2786jQuery.text = Sizzle.getText;
2787jQuery.isXMLDoc = Sizzle.isXML;
2788jQuery.contains = Sizzle.contains;
2789jQuery.escapeSelector = Sizzle.escape;
2790
2791
2792
2793
2794var dir = function( elem, dir, until ) {
2795	var matched = [],
2796		truncate = until !== undefined;
2797
2798	while ( ( elem = elem[ dir ] ) && elem.nodeType !== 9 ) {
2799		if ( elem.nodeType === 1 ) {
2800			if ( truncate && jQuery( elem ).is( until ) ) {
2801				break;
2802			}
2803			matched.push( elem );
2804		}
2805	}
2806	return matched;
2807};
2808
2809
2810var siblings = function( n, elem ) {
2811	var matched = [];
2812
2813	for ( ; n; n = n.nextSibling ) {
2814		if ( n.nodeType === 1 && n !== elem ) {
2815			matched.push( n );
2816		}
2817	}
2818
2819	return matched;
2820};
2821
2822
2823var rneedsContext = jQuery.expr.match.needsContext;
2824
2825
2826
2827function nodeName( elem, name ) {
2828
2829  return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase();
2830
2831};
2832var rsingleTag = ( /^<([a-z][^\/\0>:\x20\t\r\n\f]*)[\x20\t\r\n\f]*\/?>(?:<\/\1>|)$/i );
2833
2834
2835
2836// Implement the identical functionality for filter and not
2837function winnow( elements, qualifier, not ) {
2838	if ( isFunction( qualifier ) ) {
2839		return jQuery.grep( elements, function( elem, i ) {
2840			return !!qualifier.call( elem, i, elem ) !== not;
2841		} );
2842	}
2843
2844	// Single element
2845	if ( qualifier.nodeType ) {
2846		return jQuery.grep( elements, function( elem ) {
2847			return ( elem === qualifier ) !== not;
2848		} );
2849	}
2850
2851	// Arraylike of elements (jQuery, arguments, Array)
2852	if ( typeof qualifier !== "string" ) {
2853		return jQuery.grep( elements, function( elem ) {
2854			return ( indexOf.call( qualifier, elem ) > -1 ) !== not;
2855		} );
2856	}
2857
2858	// Filtered directly for both simple and complex selectors
2859	return jQuery.filter( qualifier, elements, not );
2860}
2861
2862jQuery.filter = function( expr, elems, not ) {
2863	var elem = elems[ 0 ];
2864
2865	if ( not ) {
2866		expr = ":not(" + expr + ")";
2867	}
2868
2869	if ( elems.length === 1 && elem.nodeType === 1 ) {
2870		return jQuery.find.matchesSelector( elem, expr ) ? [ elem ] : [];
2871	}
2872
2873	return jQuery.find.matches( expr, jQuery.grep( elems, function( elem ) {
2874		return elem.nodeType === 1;
2875	} ) );
2876};
2877
2878jQuery.fn.extend( {
2879	find: function( selector ) {
2880		var i, ret,
2881			len = this.length,
2882			self = this;
2883
2884		if ( typeof selector !== "string" ) {
2885			return this.pushStack( jQuery( selector ).filter( function() {
2886				for ( i = 0; i < len; i++ ) {
2887					if ( jQuery.contains( self[ i ], this ) ) {
2888						return true;
2889					}
2890				}
2891			} ) );
2892		}
2893
2894		ret = this.pushStack( [] );
2895
2896		for ( i = 0; i < len; i++ ) {
2897			jQuery.find( selector, self[ i ], ret );
2898		}
2899
2900		return len > 1 ? jQuery.uniqueSort( ret ) : ret;
2901	},
2902	filter: function( selector ) {
2903		return this.pushStack( winnow( this, selector || [], false ) );
2904	},
2905	not: function( selector ) {
2906		return this.pushStack( winnow( this, selector || [], true ) );
2907	},
2908	is: function( selector ) {
2909		return !!winnow(
2910			this,
2911
2912			// If this is a positional/relative selector, check membership in the returned set
2913			// so $("p:first").is("p:last") won't return true for a doc with two "p".
2914			typeof selector === "string" && rneedsContext.test( selector ) ?
2915				jQuery( selector ) :
2916				selector || [],
2917			false
2918		).length;
2919	}
2920} );
2921
2922
2923// Initialize a jQuery object
2924
2925
2926// A central reference to the root jQuery(document)
2927var rootjQuery,
2928
2929	// A simple way to check for HTML strings
2930	// Prioritize #id over <tag> to avoid XSS via location.hash (#9521)
2931	// Strict HTML recognition (#11290: must start with <)
2932	// Shortcut simple #id case for speed
2933	rquickExpr = /^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]+))$/,
2934
2935	init = jQuery.fn.init = function( selector, context, root ) {
2936		var match, elem;
2937
2938		// HANDLE: $(""), $(null), $(undefined), $(false)
2939		if ( !selector ) {
2940			return this;
2941		}
2942
2943		// Method init() accepts an alternate rootjQuery