https://messergroup.com/combo?browserId=other&minifierType=js&lang…/aui/event-hover/event-hover.js

1/*!
2 * jQuery JavaScript Library v3.4.0
3 * https://jquery.com/
4 *
5 * Includes Sizzle.js
6 * https://sizzlejs.com/
7 *
8 * Copyright JS Foundation and other contributors
9 * Released under the MIT license
10 * https://jquery.org/license
11 *
12 * Date: 2019-04-10T19:48Z
13 */
14( function( global, factory ) {
15
16	"use strict";
17
18	if ( typeof module === "object" && typeof module.exports === "object" ) {
19
20		// For CommonJS and CommonJS-like environments where a proper `window`
21		// is present, execute the factory and get jQuery.
22		// For environments that do not have a `window` with a `document`
23		// (such as Node.js), expose a factory as module.exports.
24		// This accentuates the need for the creation of a real `window`.
25		// e.g. var jQuery = require("jquery")(window);
26		// See ticket #14549 for more info.
27		module.exports = global.document ?
28			factory( global, true ) :
29			function( w ) {
30				if ( !w.document ) {
31					throw new Error( "jQuery requires a window with a document" );
32				}
33				return factory( w );
34			};
35	} else {
36		factory( global );
37	}
38
39// Pass this if window is not defined yet
40} )( typeof window !== "undefined" ? window : this, function( window, noGlobal ) {
41
42// Edge <= 12 - 13+, Firefox <=18 - 45+, IE 10 - 11, Safari 5.1 - 9+, iOS 6 - 9.1
43// throw exceptions when non-strict code (e.g., ASP.NET 4.5) accesses strict mode
44// arguments.callee.caller (trac-13335). But as of jQuery 3.0 (2016), strict mode should be common
45// enough that all such attempts are guarded in a try block.
46"use strict";
47
48var arr = [];
49
50var document = window.document;
51
52var getProto = Object.getPrototypeOf;
53
54var slice = arr.slice;
55
56var concat = arr.concat;
57
58var push = arr.push;
59
60var indexOf = arr.indexOf;
61
62var class2type = {};
63
64var toString = class2type.toString;
65
66var hasOwn = class2type.hasOwnProperty;
67
68var fnToString = hasOwn.toString;
69
70var ObjectFunctionString = fnToString.call( Object );
71
72var support = {};
73
74var isFunction = function isFunction( obj ) {
75
76      // Support: Chrome <=57, Firefox <=52
77      // In some browsers, typeof returns "function" for HTML <object> elements
78      // (i.e., `typeof document.createElement( "object" ) === "function"`).
79      // We don't want to classify *any* DOM node as a function.
80      return typeof obj === "function" && typeof obj.nodeType !== "number";
81  };
82
83
84var isWindow = function isWindow( obj ) {
85		return obj != null && obj === obj.window;
86	};
87
88
89
90
91	var preservedScriptAttributes = {
92		type: true,
93		src: true,
94		nonce: true,
95		noModule: true
96	};
97
98	function DOMEval( code, node, doc ) {
99		doc = doc || document;
100
101		var i, val,
102			script = doc.createElement( "script" );
103
104		script.text = code;
105		if ( node ) {
106			for ( i in preservedScriptAttributes ) {
107
108				// Support: Firefox 64+, Edge 18+
109				// Some browsers don't support the "nonce" property on scripts.
110				// On the other hand, just using `getAttribute` is not enough as
111				// the `nonce` attribute is reset to an empty string whenever it
112				// becomes browsing-context connected.
113				// See https://github.com/whatwg/html/issues/2369
114				// See https://html.spec.whatwg.org/#nonce-attributes
115				// The `node.getAttribute` check was added for the sake of
116				// `jQuery.globalEval` so that it can fake a nonce-containing node
117				// via an object.
118				val = node[ i ] || node.getAttribute && node.getAttribute( i );
119				if ( val ) {
120					script.setAttribute( i, val );
121				}
122			}
123		}
124		doc.head.appendChild( script ).parentNode.removeChild( script );
125	}
126
127
128function toType( obj ) {
129	if ( obj == null ) {
130		return obj + "";
131	}
132
133	// Support: Android <=2.3 only (functionish RegExp)
134	return typeof obj === "object" || typeof obj === "function" ?
135		class2type[ toString.call( obj ) ] || "object" :
136		typeof obj;
137}
138/* global Symbol */
139// Defining this global in .eslintrc.json would create a danger of using the global
140// unguarded in another place, it seems safer to define global only for this module
141
142
143
144var
145	version = "3.4.0",
146
147	// Define a local copy of jQuery
148	jQuery = function( selector, context ) {
149
150		// The jQuery object is actually just the init constructor 'enhanced'
151		// Need init if jQuery is called (just allow error to be thrown if not included)
152		return new jQuery.fn.init( selector, context );
153	},
154
155	// Support: Android <=4.0 only
156	// Make sure we trim BOM and NBSP
157	rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g;
158
159jQuery.fn = jQuery.prototype = {
160
161	// The current version of jQuery being used
162	jquery: version,
163
164	constructor: jQuery,
165
166	// The default length of a jQuery object is 0
167	length: 0,
168
169	toArray: function() {
170		return slice.call( this );
171	},
172
173	// Get the Nth element in the matched element set OR
174	// Get the whole matched element set as a clean array
175	get: function( num ) {
176
177		// Return all the elements in a clean array
178		if ( num == null ) {
179			return slice.call( this );
180		}
181
182		// Return just the one element from the set
183		return num < 0 ? this[ num + this.length ] : this[ num ];
184	},
185
186	// Take an array of elements and push it onto the stack
187	// (returning the new matched element set)
188	pushStack: function( elems ) {
189
190		// Build a new jQuery matched element set
191		var ret = jQuery.merge( this.constructor(), elems );
192
193		// Add the old object onto the stack (as a reference)
194		ret.prevObject = this;
195
196		// Return the newly-formed element set
197		return ret;
198	},
199
200	// Execute a callback for every element in the matched set.
201	each: function( callback ) {
202		return jQuery.each( this, callback );
203	},
204
205	map: function( callback ) {
206		return this.pushStack( jQuery.map( this, function( elem, i ) {
207			return callback.call( elem, i, elem );
208		} ) );
209	},
210
211	slice: function() {
212		return this.pushStack( slice.apply( this, arguments ) );
213	},
214
215	first: function() {
216		return this.eq( 0 );
217	},
218
219	last: function() {
220		return this.eq( -1 );
221	},
222
223	eq: function( i ) {
224		var len = this.length,
225			j = +i + ( i < 0 ? len : 0 );
226		return this.pushStack( j >= 0 && j < len ? [ this[ j ] ] : [] );
227	},
228
229	end: function() {
230		return this.prevObject || this.constructor();
231	},
232
233	// For internal use only.
234	// Behaves like an Array's method, not like a jQuery method.
235	push: push,
236	sort: arr.sort,
237	splice: arr.splice
238};
239
240jQuery.extend = jQuery.fn.extend = function() {
241	var options, name, src, copy, copyIsArray, clone,
242		target = arguments[ 0 ] || {},
243		i = 1,
244		length = arguments.length,
245		deep = false;
246
247	// Handle a deep copy situation
248	if ( typeof target === "boolean" ) {
249		deep = target;
250
251		// Skip the boolean and the target
252		target = arguments[ i ] || {};
253		i++;
254	}
255
256	// Handle case when target is a string or something (possible in deep copy)
257	if ( typeof target !== "object" && !isFunction( target ) ) {
258		target = {};
259	}
260
261	// Extend jQuery itself if only one argument is passed
262	if ( i === length ) {
263		target = this;
264		i--;
265	}
266
267	for ( ; i < length; i++ ) {
268
269		// Only deal with non-null/undefined values
270		if ( ( options = arguments[ i ] ) != null ) {
271
272			// Extend the base object
273			for ( name in options ) {
274				copy = options[ name ];
275
276				// Prevent Object.prototype pollution
277				// Prevent never-ending loop
278				if ( name === "__proto__" || target === copy ) {
279					continue;
280				}
281
282				// Recurse if we're merging plain objects or arrays
283				if ( deep && copy && ( jQuery.isPlainObject( copy ) ||
284					( copyIsArray = Array.isArray( copy ) ) ) ) {
285					src = target[ name ];
286
287					// Ensure proper type for the source value
288					if ( copyIsArray && !Array.isArray( src ) ) {
289						clone = [];
290					} else if ( !copyIsArray && !jQuery.isPlainObject( src ) ) {
291						clone = {};
292					} else {
293						clone = src;
294					}
295					copyIsArray = false;
296
297					// Never move original objects, clone them
298					target[ name ] = jQuery.extend( deep, clone, copy );
299
300				// Don't bring in undefined values
301				} else if ( copy !== undefined ) {
302					target[ name ] = copy;
303				}
304			}
305		}
306	}
307
308	// Return the modified object
309	return target;
310};
311
312jQuery.extend( {
313
314	// Unique for each copy of jQuery on the page
315	expando: "jQuery" + ( version + Math.random() ).replace( /\D/g, "" ),
316
317	// Assume jQuery is ready without the ready module
318	isReady: true,
319
320	error: function( msg ) {
321		throw new Error( msg );
322	},
323
324	noop: function() {},
325
326	isPlainObject: function( obj ) {
327		var proto, Ctor;
328
329		// Detect obvious negatives
330		// Use toString instead of jQuery.type to catch host objects
331		if ( !obj || toString.call( obj ) !== "[object Object]" ) {
332			return false;
333		}
334
335		proto = getProto( obj );
336
337		// Objects with no prototype (e.g., `Object.create( null )`) are plain
338		if ( !proto ) {
339			return true;
340		}
341
342		// Objects with prototype are plain iff they were constructed by a global Object function
343		Ctor = hasOwn.call( proto, "constructor" ) && proto.constructor;
344		return typeof Ctor === "function" && fnToString.call( Ctor ) === ObjectFunctionString;
345	},
346
347	isEmptyObject: function( obj ) {
348		var name;
349
350		for ( name in obj ) {
351			return false;
352		}
353		return true;
354	},
355
356	// Evaluates a script in a global context
357	globalEval: function( code, options ) {
358		DOMEval( code, { nonce: options && options.nonce } );
359	},
360
361	each: function( obj, callback ) {
362		var length, i = 0;
363
364		if ( isArrayLike( obj ) ) {
365			length = obj.length;
366			for ( ; i < length; i++ ) {
367				if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {
368					break;
369				}
370			}
371		} else {
372			for ( i in obj ) {
373				if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {
374					break;
375				}
376			}
377		}
378
379		return obj;
380	},
381
382	// Support: Android <=4.0 only
383	trim: function( text ) {
384		return text == null ?
385			"" :

386			( text + "" ).replace( rtrim, "" );
387	},
388
389	// results is for internal usage only
390	makeArray: function( arr, results ) {
391		var ret = results || [];
392
393		if ( arr != null ) {
394			if ( isArrayLike( Object( arr ) ) ) {
395				jQuery.merge( ret,
396					typeof arr === "string" ?
397					[ arr ] : arr
398				);
399			} else {
400				push.call( ret, arr );
401			}
402		}
403
404		return ret;
405	},
406
407	inArray: function( elem, arr, i ) {
408		return arr == null ? -1 : indexOf.call( arr, elem, i );
409	},
410
411	// Support: Android <=4.0 only, PhantomJS 1 only
412	// push.apply(_, arraylike) throws on ancient WebKit
413	merge: function( first, second ) {
414		var len = +second.length,
415			j = 0,
416			i = first.length;
417
418		for ( ; j < len; j++ ) {
419			first[ i++ ] = second[ j ];
420		}
421
422		first.length = i;
423
424		return first;
425	},
426
427	grep: function( elems, callback, invert ) {
428		var callbackInverse,
429			matches = [],
430			i = 0,
431			length = elems.length,
432			callbackExpect = !invert;
433
434		// Go through the array, only saving the items
435		// that pass the validator function
436		for ( ; i < length; i++ ) {
437			callbackInverse = !callback( elems[ i ], i );
438			if ( callbackInverse !== callbackExpect ) {
439				matches.push( elems[ i ] );
440			}
441		}
442
443		return matches;
444	},
445
446	// arg is for internal usage only
447	map: function( elems, callback, arg ) {
448		var length, value,
449			i = 0,
450			ret = [];
451
452		// Go through the array, translating each of the items to their new values
453		if ( isArrayLike( elems ) ) {
454			length = elems.length;
455			for ( ; i < length; i++ ) {
456				value = callback( elems[ i ], i, arg );
457
458				if ( value != null ) {
459					ret.push( value );
460				}
461			}
462
463		// Go through every key on the object,
464		} else {
465			for ( i in elems ) {
466				value = callback( elems[ i ], i, arg );
467
468				if ( value != null ) {
469					ret.push( value );
470				}
471			}
472		}
473
474		// Flatten any nested arrays
475		return concat.apply( [], ret );
476	},
477
478	// A global GUID counter for objects
479	guid: 1,
480
481	// jQuery.support is not used in Core but other projects attach their
482	// properties to it so it needs to exist.
483	support: support
484} );
485
486if ( typeof Symbol === "function" ) {
487	jQuery.fn[ Symbol.iterator ] = arr[ Symbol.iterator ];
488}
489
490// Populate the class2type map
491jQuery.each( "Boolean Number String Function Array Date RegExp Object Error Symbol".split( " " ),
492function( i, name ) {
493	class2type[ "[object " + name + "]" ] = name.toLowerCase();
494} );
495
496function isArrayLike( obj ) {
497
498	// Support: real iOS 8.2 only (not reproducible in simulator)
499	// `in` check used to prevent JIT error (gh-2145)
500	// hasOwn isn't used here due to false negatives
501	// regarding Nodelist length in IE
502	var length = !!obj && "length" in obj && obj.length,
503		type = toType( obj );
504
505	if ( isFunction( obj ) || isWindow( obj ) ) {
506		return false;
507	}
508
509	return type === "array" || length === 0 ||
510		typeof length === "number" && length > 0 && ( length - 1 ) in obj;
511}
512var Sizzle =
513/*!
514 * Sizzle CSS Selector Engine v2.3.4
515 * https://sizzlejs.com/
516 *
517 * Copyright JS Foundation and other contributors
518 * Released under the MIT license
519 * https://js.foundation/
520 *
521 * Date: 2019-04-08
522 */
523(function( window ) {
524
525var i,
526	support,
527	Expr,
528	getText,
529	isXML,
530	tokenize,
531	compile,
532	select,
533	outermostContext,
534	sortInput,
535	hasDuplicate,
536
537	// Local document vars
538	setDocument,
539	document,
540	docElem,
541	documentIsHTML,
542	rbuggyQSA,
543	rbuggyMatches,
544	matches,
545	contains,
546
547	// Instance-specific data
548	expando = "sizzle" + 1 * new Date(),
549	preferredDoc = window.document,
550	dirruns = 0,
551	done = 0,
552	classCache = createCache(),
553	tokenCache = createCache(),
554	compilerCache = createCache(),
555	nonnativeSelectorCache = createCache(),
556	sortOrder = function( a, b ) {
557		if ( a === b ) {
558			hasDuplicate = true;
559		}
560		return 0;
561	},
562
563	// Instance methods
564	hasOwn = ({}).hasOwnProperty,
565	arr = [],
566	pop = arr.pop,
567	push_native = arr.push,
568	push = arr.push,
569	slice = arr.slice,
570	// Use a stripped-down indexOf as it's faster than native
571	// https://jsperf.com/thor-indexof-vs-for/5
572	indexOf = function( list, elem ) {
573		var i = 0,
574			len = list.length;
575		for ( ; i < len; i++ ) {
576			if ( list[i] === elem ) {
577				return i;
578			}
579		}
580		return -1;
581	},
582
583	booleans = "checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped",
584
585	// Regular expressions
586
587	// http://www.w3.org/TR/css3-selectors/#whitespace
588	whitespace = "[\\x20\\t\\r\\n\\f]",
589
590	// http://www.w3.org/TR/CSS21/syndata.html#value-def-identifier
591	identifier = "(?:\\\\.|[\\w-]|[^\0-\\xa0])+",
592
593	// Attribute selectors: http://www.w3.org/TR/selectors/#attribute-selectors
594	attributes = "\\[" + whitespace + "*(" + identifier + ")(?:" + whitespace +
595		// Operator (capture 2)
596		"*([*^$|!~]?=)" + whitespace +
597		// "Attribute values must be CSS identifiers [capture 5] or strings [capture 3 or capture 4]"
598		"*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|(" + identifier + "))|)" + whitespace +
599		"*\\]",
600
601	pseudos = ":(" + identifier + ")(?:\\((" +
602		// To reduce the number of selectors needing tokenize in the preFilter, prefer arguments:
603		// 1. quoted (capture 3; capture 4 or capture 5)
604		"('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|" +
605		// 2. simple (capture 6)
606		"((?:\\\\.|[^\\\\()[\\]]|" + attributes + ")*)|" +
607		// 3. anything else (capture 2)
608		".*" +
609		")\\)|)",
610
611	// Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter
612	rwhitespace = new RegExp( whitespace + "+", "g" ),
613	rtrim = new RegExp( "^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" + whitespace + "+$", "g" ),
614
615	rcomma = new RegExp( "^" + whitespace + "*," + whitespace + "*" ),
616	rcombinators = new RegExp( "^" + whitespace + "*([>+~]|" + whitespace + ")" + whitespace + "*" ),
617	rdescend = new RegExp( whitespace + "|>" ),
618
619	rpseudo = new RegExp( pseudos ),
620	ridentifier = new RegExp( "^" + identifier + "$" ),
621
622	matchExpr = {
623		"ID": new RegExp( "^#(" + identifier + ")" ),
624		"CLASS": new RegExp( "^\\.(" + identifier + ")" ),
625		"TAG": new RegExp( "^(" + identifier + "|[*])" ),
626		"ATTR": new RegExp( "^" + attributes ),
627		"PSEUDO": new RegExp( "^" + pseudos ),
628		"CHILD": new RegExp( "^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(" + whitespace +
629			"*(even|odd|(([+-]|)(\\d*)n|)" + whitespace + "*(?:([+-]|)" + whitespace +
630			"*(\\d+)|))" + whitespace + "*\\)|)", "i" ),
631		"bool": new RegExp( "^(?:" + booleans + ")$", "i" ),
632		// For use in libraries implementing .is()
633		// We use this for POS matching in `select`
634		"needsContext": new RegExp( "^" + whitespace + "*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(" +
635			whitespace + "*((?:-\\d)?\\d*)" + whitespace + "*\\)|)(?=[^-]|$)", "i" )
636	},
637
638	rhtml = /HTML$/i,
639	rinputs = /^(?:input|select|textarea|button)$/i,
640	rheader = /^h\d$/i,
641
642	rnative = /^[^{]+\{\s*\[native \w/,
643
644	// Easily-parseable/retrievable ID or TAG or CLASS selectors
645	rquickExpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,
646
647	rsibling = /[+~]/,
648
649	// CSS escapes
650	// http://www.w3.org/TR/CSS21/syndata.html#escaped-characters
651	runescape = new RegExp( "\\\\([\\da-f]{1,6}" + whitespace + "?|(" + whitespace + ")|.)", "ig" ),
652	funescape = function( _, escaped, escapedWhitespace ) {
653		var high = "0x" + escaped - 0x10000;
654		// NaN means non-codepoint
655		// Support: Firefox<24
656		// Workaround erroneous numeric interpretation of +"0x"
657		return high !== high || escapedWhitespace ?
658			escaped :
659			high < 0 ?
660				// BMP codepoint
661				String.fromCharCode( high + 0x10000 ) :
662				// Supplemental Plane codepoint (surrogate pair)
663				String.fromCharCode( high >> 10 | 0xD800, high & 0x3FF | 0xDC00 );
664	},
665
666	// CSS string/identifier serialization
667	// https://drafts.csswg.org/cssom/#common-serializing-idioms
668	rcssescape = /([\0-\x1f\x7f]|^-?\d)|^-$|[^\0-\x1f\x7f-\uFFFF\w-]/g,
669	fcssescape = function( ch, asCodePoint ) {
670		if ( asCodePoint ) {
671
672			// U+0000 NULL becomes U+FFFD REPLACEMENT CHARACTER
673			if ( ch === "\0" ) {
674				return "\uFFFD";
675			}
676
677			// Control characters and (dependent upon position) numbers get escaped as code points
678			return ch.slice( 0, -1 ) + "\\" + ch.charCodeAt( ch.length - 1 ).toString( 16 ) + " ";
679		}
680
681		// Other potentially-special ASCII characters get backslash-escaped
682		return "\\" + ch;
683	},
684
685	// Used for iframes
686	// See setDocument()
687	// Removing the function wrapper causes a "Permission Denied"
688	// error in IE
689	unloadHandler = function() {
690		setDocument();
691	},
692
693	inDisabledFieldset = addCombinator(
694		function( elem ) {
695			return elem.disabled === true && elem.nodeName.toLowerCase() === "fieldset";
696		},
697		{ dir: "parentNode", next: "legend" }
698	);
699
700// Optimize for push.apply( _, NodeList )
701try {
702	push.apply(
703		(arr = slice.call( preferredDoc.childNodes )),
704		preferredDoc.childNodes
705	);
706	// Support: Android<4.0
707	// Detect silently failing push.apply
708	arr[ preferredDoc.childNodes.length ].nodeType;
709} catch ( e ) {
710	push = { apply: arr.length ?
711
712		// Leverage slice if possible
713		function( target, els ) {
714			push_native.apply( target, slice.call(els) );
715		} :
716
717		// Support: IE<9
718		// Otherwise append directly
719		function( target, els ) {
720			var j = target.length,
721				i = 0;
722			// Can't trust NodeList.length
723			while ( (target[j++] = els[i++]) ) {}
724			target.length = j - 1;
725		}
726	};
727}
728
729function Sizzle( selector, context, results, seed ) {
730	var m, i, elem, nid, match, groups, newSelector,
731		newContext = context && context.ownerDocument,
732
733		// nodeType defaults to 9, since context defaults to document
734		nodeType = context ? context.nodeType : 9;
735
736	results = results || [];
737
738	// Return early from calls with invalid selector or context
739	if ( typeof selector !== "string" || !selector ||
740		nodeType !== 1 && nodeType !== 9 && nodeType !== 11 ) {
741
742		return results;
743	}
744
745	// Try to shortcut find operations (as opposed to filters) in HTML documents
746	if ( !seed ) {
747
748		if ( ( context ? context.ownerDocument || context : preferredDoc ) !== document ) {
749			setDocument( context );
750		}
751		context = context || document;
752
753		if ( documentIsHTML ) {
754
755			// If the selector is sufficiently simple, try using a "get*By*" DOM method
756			// (excepting DocumentFragment context, where the methods don't exist)
757			if ( nodeType !== 11 && (match = rquickExpr.exec( selector )) ) {
758
759				// ID selector
760				if ( (m = match[1]) ) {
761
762					// Document context
763					if ( nodeType === 9 ) {
764						if ( (elem = context.getElementById( m )) ) {
765
766							// Support: IE, Opera, Webkit
767							// TODO: identify versions
768							// getElementById can match elements by name instead of ID
769							if ( elem.id === m ) {
770								results.push( elem );
771								return results;
772							}
773						} else {
774							return results;
775						}
776
777					// Element context
778					} else {
779
780						// Support: IE, Opera, Webkit
781						// TODO: identify versions
782						// getElementById can match elements by name instead of ID
783						if ( newContext && (elem = newContext.getElementById( m )) &&
784							contains( context, elem ) &&
785							elem.id === m ) {
786
787							results.push( elem );
788							return results;
789						}
790					}
791
792				// Type selector
793				} else if ( match[2] ) {
794					push.apply( results, context.getElementsByTagName( selector ) );
795					return results;
796
797				// Class selector
798				} else if ( (m = match[3]) && support.getElementsByClassName &&
799					context.getElementsByClassName ) {
800
801					push.apply( results, context.getElementsByClassName( m ) );
802					return results;
803				}
804			}
805
806			// Take advantage of querySelectorAll
807			if ( support.qsa &&
808				!nonnativeSelectorCache[ selector + " " ] &&
809				(!rbuggyQSA || !rbuggyQSA.test( selector )) &&
810
811				// Support: IE 8 only
812				// Exclude object elements
813				(nodeType !== 1 || context.nodeName.toLowerCase() !== "object") ) {
814
815				newSelector = selector;
816				newContext = context;
817
818				// qSA considers elements outside a scoping root when evaluating child or
819				// descendant combinators, which is not what we want.
820				// In such cases, we work around the behavior by prefixing every selector in the
821				// list with an ID selector referencing the scope context.
822				// Thanks to Andrew Dupont for this technique.
823				if ( nodeType === 1 && rdescend.test( selector ) ) {
824
825					// Capture the context ID, setting it first if necessary
826					if ( (nid = context.getAttribute( "id" )) ) {
827						nid = nid.replace( rcssescape, fcssescape );
828					} else {
829						context.setAttribute( "id", (nid = expando) );
830					}
831
832					// Prefix every selector in the list
833					groups = tokenize( selector );
834					i = groups.length;
835					while ( i-- ) {
836						groups[i] = "#" + nid + " " + toSelector( groups[i] );
837					}
838					newSelector = groups.join( "," );
839
840					// Expand context for sibling selectors
841					newContext = rsibling.test( selector ) && testContext( context.parentNode ) ||
842						context;
843				}
844
845				try {
846					push.apply( results,
847						newContext.querySelectorAll( newSelector )
848					);
849					return results;
850				} catch ( qsaError ) {
851					nonnativeSelectorCache( selector, true );
852				} finally {
853					if ( nid === expando ) {
854						context.removeAttribute( "id" );
855					}
856				}
857			}
858		}
859	}
860
861	// All others
862	return select( selector.replace( rtrim, "$1" ), context, results, seed );
863}
864
865/**
866 * Create key-value caches of limited size
867 * @returns {function(string, object)} Returns the Object data after storing it on itself with
868 *	property name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength)
869 *	deleting the oldest entry
870 */
871function createCache() {
872	var keys = [];
873
874	function cache( key, value ) {
875		// Use (key + " ") to avoid collision with native prototype properties (see Issue #157)
876		if ( keys.push( key + " " ) > Expr.cacheLength ) {
877			// Only keep the most recent entries
878			delete cache[ keys.shift() ];
879		}
880		return (cache[ key + " " ] = value);
881	}
882	return cache;
883}
884
885/**
886 * Mark a function for special use by Sizzle
887 * @param {Function} fn The function to mark
888 */
889function markFunction( fn ) {
890	fn[ expando ] = true;
891	return fn;
892}
893
894/**
895 * Support testing using an element
896 * @param {Function} fn Passed the created element and returns a boolean result
897 */
898function assert( fn ) {
899	var el = document.createElement("fieldset");
900
901	try {
902		return !!fn( el );
903	} catch (e) {
904		return false;

1272			// Support: IE8, Opera 11-12.16
1273			// Nothing should be selected when empty strings follow ^= or $= or *=
1274			// The test attribute must be unknown in Opera but "safe" for WinRT
1275			// https://msdn.microsoft.com/en-us/library/ie/hh465388.aspx#attribute_section
1276			if ( el.querySelectorAll("[msallowcapture^='']").length ) {
1277				rbuggyQSA.push( "[*^$]=" + whitespace + "*(?:''|\"\")" );
1278			}
1279
1280			// Support: IE8
1281			// Boolean attributes and "value" are not treated correctly
1282			if ( !el.querySelectorAll("[selected]").length ) {
1283				rbuggyQSA.push( "\\[" + whitespace + "*(?:value|" + booleans + ")" );
1284			}
1285
1286			// Support: Chrome<29, Android<4.4, Safari<7.0+, iOS<7.0+, PhantomJS<1.9.8+
1287			if ( !el.querySelectorAll( "[id~=" + expando + "-]" ).length ) {
1288				rbuggyQSA.push("~=");
1289			}
1290
1291			// Webkit/Opera - :checked should return selected option elements
1292			// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
1293			// IE8 throws error here and will not see later tests
1294			if ( !el.querySelectorAll(":checked").length ) {
1295				rbuggyQSA.push(":checked");
1296			}
1297
1298			// Support: Safari 8+, iOS 8+
1299			// https://bugs.webkit.org/show_bug.cgi?id=136851
1300			// In-page `selector#id sibling-combinator selector` fails
1301			if ( !el.querySelectorAll( "a#" + expando + "+*" ).length ) {
1302				rbuggyQSA.push(".#.+[+~]");
1303			}
1304		});
1305
1306		assert(function( el ) {
1307			el.innerHTML = "<a href='' disabled='disabled'></a>" +
1308				"<select disabled='disabled'><option/></select>";
1309
1310			// Support: Windows 8 Native Apps
1311			// The type and name attributes are restricted during .innerHTML assignment
1312			var input = document.createElement("input");
1313			input.setAttribute( "type", "hidden" );
1314			el.appendChild( input ).setAttribute( "name", "D" );
1315
1316			// Support: IE8
1317			// Enforce case-sensitivity of name attribute
1318			if ( el.querySelectorAll("[name=d]").length ) {
1319				rbuggyQSA.push( "name" + whitespace + "*[*^$|!~]?=" );
1320			}
1321
1322			// FF 3.5 - :enabled/:disabled and hidden elements (hidden elements are still enabled)
1323			// IE8 throws error here and will not see later tests
1324			if ( el.querySelectorAll(":enabled").length !== 2 ) {
1325				rbuggyQSA.push( ":enabled", ":disabled" );
1326			}
1327
1328			// Support: IE9-11+
1329			// IE's :disabled selector does not pick up the children of disabled fieldsets
1330			docElem.appendChild( el ).disabled = true;
1331			if ( el.querySelectorAll(":disabled").length !== 2 ) {
1332				rbuggyQSA.push( ":enabled", ":disabled" );
1333			}
1334
1335			// Opera 10-11 does not throw on post-comma invalid pseudos
1336			el.querySelectorAll("*,:x");
1337			rbuggyQSA.push(",.*:");
1338		});
1339	}
1340
1341	if ( (support.matchesSelector = rnative.test( (matches = docElem.matches ||
1342		docElem.webkitMatchesSelector ||
1343		docElem.mozMatchesSelector ||
1344		docElem.oMatchesSelector ||
1345		docElem.msMatchesSelector) )) ) {
1346
1347		assert(function( el ) {
1348			// Check to see if it's possible to do matchesSelector
1349			// on a disconnected node (IE 9)
1350			support.disconnectedMatch = matches.call( el, "*" );
1351
1352			// This should fail with an exception
1353			// Gecko does not error, returns false instead
1354			matches.call( el, "[s!='']:x" );
1355			rbuggyMatches.push( "!=", pseudos );
1356		});
1357	}
1358
1359	rbuggyQSA = rbuggyQSA.length && new RegExp( rbuggyQSA.join("|") );
1360	rbuggyMatches = rbuggyMatches.length && new RegExp( rbuggyMatches.join("|") );
1361
1362	/* Contains
1363	---------------------------------------------------------------------- */
1364	hasCompare = rnative.test( docElem.compareDocumentPosition );
1365
1366	// Element contains another
1367	// Purposefully self-exclusive
1368	// As in, an element does not contain itself
1369	contains = hasCompare || rnative.test( docElem.contains ) ?
1370		function( a, b ) {
1371			var adown = a.nodeType === 9 ? a.documentElement : a,
1372				bup = b && b.parentNode;
1373			return a === bup || !!( bup && bup.nodeType === 1 && (
1374				adown.contains ?
1375					adown.contains( bup ) :
1376					a.compareDocumentPosition && a.compareDocumentPosition( bup ) & 16
1377			));
1378		} :
1379		function( a, b ) {
1380			if ( b ) {
1381				while ( (b = b.parentNode) ) {
1382					if ( b === a ) {
1383						return true;
1384					}
1385				}
1386			}
1387			return false;
1388		};
1389
1390	/* Sorting
1391	---------------------------------------------------------------------- */
1392
1393	// Document order sorting
1394	sortOrder = hasCompare ?
1395	function( a, b ) {
1396
1397		// Flag for duplicate removal
1398		if ( a === b ) {
1399			hasDuplicate = true;
1400			return 0;
1401		}
1402
1403		// Sort on method existence if only one input has compareDocumentPosition
1404		var compare = !a.compareDocumentPosition - !b.compareDocumentPosition;
1405		if ( compare ) {
1406			return compare;
1407		}
1408
1409		// Calculate position if both inputs belong to the same document
1410		compare = ( a.ownerDocument || a ) === ( b.ownerDocument || b ) ?
1411			a.compareDocumentPosition( b ) :
1412
1413			// Otherwise we know they are disconnected
1414			1;
1415
1416		// Disconnected nodes
1417		if ( compare & 1 ||
1418			(!support.sortDetached && b.compareDocumentPosition( a ) === compare) ) {
1419
1420			// Choose the first element that is related to our preferred document
1421			if ( a === document || a.ownerDocument === preferredDoc && contains(preferredDoc, a) ) {
1422				return -1;
1423			}
1424			if ( b === document || b.ownerDocument === preferredDoc && contains(preferredDoc, b) ) {
1425				return 1;
1426			}
1427
1428			// Maintain original order
1429			return sortInput ?
1430				( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) :
1431				0;
1432		}
1433
1434		return compare & 4 ? -1 : 1;
1435	} :
1436	function( a, b ) {
1437		// Exit early if the nodes are identical
1438		if ( a === b ) {
1439			hasDuplicate = true;
1440			return 0;
1441		}
1442
1443		var cur,
1444			i = 0,
1445			aup = a.parentNode,
1446			bup = b.parentNode,
1447			ap = [ a ],
1448			bp = [ b ];
1449
1450		// Parentless nodes are either documents or disconnected
1451		if ( !aup || !bup ) {
1452			return a === document ? -1 :
1453				b === document ? 1 :
1454				aup ? -1 :
1455				bup ? 1 :
1456				sortInput ?
1457				( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) :
1458				0;
1459
1460		// If the nodes are siblings, we can do a quick check
1461		} else if ( aup === bup ) {
1462			return siblingCheck( a, b );
1463		}
1464
1465		// Otherwise we need full lists of their ancestors for comparison
1466		cur = a;
1467		while ( (cur = cur.parentNode) ) {
1468			ap.unshift( cur );
1469		}
1470		cur = b;
1471		while ( (cur = cur.parentNode) ) {
1472			bp.unshift( cur );
1473		}
1474
1475		// Walk down the tree looking for a discrepancy
1476		while ( ap[i] === bp[i] ) {
1477			i++;
1478		}
1479
1480		return i ?
1481			// Do a sibling check if the nodes have a common ancestor
1482			siblingCheck( ap[i], bp[i] ) :
1483
1484			// Otherwise nodes in our document sort first
1485			ap[i] === preferredDoc ? -1 :
1486			bp[i] === preferredDoc ? 1 :
1487			0;
1488	};
1489
1490	return document;
1491};
1492
1493Sizzle.matches = function( expr, elements ) {
1494	return Sizzle( expr, null, null, elements );
1495};
1496
1497Sizzle.matchesSelector = function( elem, expr ) {
1498	// Set document vars if needed
1499	if ( ( elem.ownerDocument || elem ) !== document ) {
1500		setDocument( elem );
1501	}
1502
1503	if ( support.matchesSelector && documentIsHTML &&
1504		!nonnativeSelectorCache[ expr + " " ] &&
1505		( !rbuggyMatches || !rbuggyMatches.test( expr ) ) &&
1506		( !rbuggyQSA     || !rbuggyQSA.test( expr ) ) ) {
1507
1508		try {
1509			var ret = matches.call( elem, expr );
1510
1511			// IE 9's matchesSelector returns false on disconnected nodes
1512			if ( ret || support.disconnectedMatch ||
1513					// As well, disconnected nodes are said to be in a document
1514					// fragment in IE 9
1515					elem.document && elem.document.nodeType !== 11 ) {
1516				return ret;
1517			}
1518		} catch (e) {
1519			nonnativeSelectorCache( expr, true );
1520		

1520}
1521	}
1522
1523	return Sizzle( expr, document, null, [ elem ] ).length > 0;
1524};
1525
1526Sizzle.contains = function( context, elem ) {
1527	// Set document vars if needed
1528	if ( ( context.ownerDocument || context ) !== document ) {
1529		setDocument( context );
1530	}
1531	return contains( context, elem );
1532};
1533
1534Sizzle.attr = function( elem, name ) {
1535	// Set document vars if needed
1536	if ( ( elem.ownerDocument || elem ) !== document ) {
1537		setDocument( elem );
1538	}
1539
1540	var fn = Expr.attrHandle[ name.toLowerCase() ],
1541		// Don't get fooled by Object.prototype properties (jQuery #13807)
1542		val = fn && hasOwn.call( Expr.attrHandle, name.toLowerCase() ) ?
1543			fn( elem, name, !documentIsHTML ) :
1544			undefined;
1545
1546	return val !== undefined ?
1547		val :
1548		support.attributes || !documentIsHTML ?
1549			elem.getAttribute( name ) :
1550			(val = elem.getAttributeNode(name)) && val.specified ?
1551				val.value :
1552				null;
1553};
1554
1555Sizzle.escape = function( sel ) {
1556	return (sel + "").replace( rcssescape, fcssescape );
1557};
1558
1559Sizzle.error = function( msg ) {
1560	throw new Error( "Syntax error, unrecognized expression: " + msg );
1561};
1562
1563/**
1564 * Document sorting and removing duplicates
1565 * @param {ArrayLike} results
1566 */
1567Sizzle.uniqueSort = function( results ) {
1568	var elem,
1569		duplicates = [],
1570		j = 0,
1571		i = 0;
1572
1573	// Unless we *know* we can detect duplicates, assume their presence
1574	hasDuplicate = !support.detectDuplicates;
1575	sortInput = !support.sortStable && results.slice( 0 );
1576	results.sort( sortOrder );
1577
1578	if ( hasDuplicate ) {
1579		while ( (elem = results[i++]) ) {
1580			if ( elem === results[ i ] ) {
1581				j = duplicates.push( i );
1582			}
1583		}
1584		while ( j-- ) {
1585			results.splice( duplicates[ j ], 1 );
1586		}
1587	}
1588
1589	// Clear input after sorting to release objects
1590	// See https://github.com/jquery/sizzle/pull/225
1591	sortInput = null;
1592
1593	return results;
1594};
1595
1596/**
1597 * Utility function for retrieving the text value of an array of DOM nodes
1598 * @param {Array|Element} elem
1599 */
1600getText = Sizzle.getText = function( elem ) {
1601	var node,
1602		ret = "",
1603		i = 0,
1604		nodeType = elem.nodeType;
1605
1606	if ( !nodeType ) {
1607		// If no nodeType, this is expected to be an array
1608		while ( (node = elem[i++]) ) {
1609			// Do not traverse comment nodes
1610			ret += getText( node );
1611		}
1612	} else if ( nodeType === 1 || nodeType === 9 || nodeType === 11 ) {
1613		// Use textContent for elements
1614		// innerText usage removed for consistency of new lines (jQuery #11153)
1615		if ( typeof elem.textContent === "string" ) {
1616			return elem.textContent;
1617		} else {
1618			// Traverse its children
1619			for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
1620				ret += getText( elem );
1621			}
1622		}
1623	} else if ( nodeType === 3 || nodeType === 4 ) {
1624		return elem.nodeValue;
1625	}
1626	// Do not include comment or processing instruction nodes
1627
1628	return ret;
1629};
1630
1631Expr = Sizzle.selectors = {
1632
1633	// Can be adjusted by the user
1634	cacheLength: 50,
1635
1636	createPseudo: markFunction,
1637
1638	match: matchExpr,
1639
1640	attrHandle: {},
1641
1642	find: {},
1643
1644	relative: {
1645		">": { dir: "parentNode", first: true },
1646		" ": { dir: "parentNode" },
1647		"+": { dir: "previousSibling", first: true },
1648		"~": { dir: "previousSibling" }
1649	},
1650
1651	preFilter: {
1652		"ATTR": function( match ) {
1653			match[1] = match[1].replace( runescape, funescape );
1654
1655			// Move the given value to match[3] whether quoted or unquoted
1656			match[3] = ( match[3] || match[4] || match[5] || "" ).replace( runescape, funescape );
1657
1658			if ( match[2] === "~=" ) {
1659				match[3] = " " + match[3] + " ";
1660			}
1661
1662			return match.slice( 0, 4 );
1663		},
1664
1665		"CHILD": function( match ) {
1666			/* matches from matchExpr["CHILD"]
1667				1 type (only|nth|...)
1668				2 what (child|of-type)
1669				3 argument (even|odd|\d*|\d*n([+-]\d+)?|...)
1670				4 xn-component of xn+y argument ([+-]?\d*n|)
1671				5 sign of xn-component
1672				6 x of xn-component
1673				7 sign of y-component
1674				8 y of y-component
1675			*/
1676			match[1] = match[1].toLowerCase();
1677
1678			if ( match[1].slice( 0, 3 ) === "nth" ) {
1679				// nth-* requires argument
1680				if ( !match[3] ) {
1681					Sizzle.error( match[0] );
1682				}
1683
1684				// numeric x and y parameters for Expr.filter.CHILD
1685				// remember that false/true cast respectively to 0/1
1686				match[4] = +( match[4] ? match[5] + (match[6] || 1) : 2 * ( match[3] === "even" || match[3] === "odd" ) );
1687				match[5] = +( ( match[7] + match[8] ) || match[3] === "odd" );
1688
1689			// other types prohibit arguments
1690			} else if ( match[3] ) {
1691				Sizzle.error( match[0] );
1692			}
1693
1694			return match;
1695		},
1696
1697		"PSEUDO": function( match ) {
1698			var excess,
1699				unquoted = !match[6] && match[2];
1700
1701			if ( matchExpr["CHILD"].test( match[0] ) ) {
1702				return null;
1703			}
1704
1705			// Accept quoted arguments as-is
1706			if ( match[3] ) {
1707				match[2] = match[4] || match[5] || "";
1708
1709			// Strip excess characters from unquoted arguments
1710			} else if ( unquoted && rpseudo.test( unquoted ) &&
1711				// Get excess from tokenize (recursively)
1712				(excess = tokenize( unquoted, true )) &&
1713				// advance to the next closing parenthesis
1714				(excess = unquoted.indexOf( ")", unquoted.length - excess ) - unquoted.length) ) {
1715
1716				// excess is a negative index
1717				match[0] = match[0].slice( 0, excess );
1718				match[2] = unquoted.slice( 0, excess );
1719			}
1720
1721			// Return only captures needed by the pseudo filter method (type and argument)
1722			return match.slice( 0, 3 );
1723		}
1724	},
1725
1726	filter: {
1727
1728		"TAG": function( nodeNameSelector ) {
1729			var nodeName = nodeNameSelector.replace( runescape, funescape ).toLowerCase();
1730			return nodeNameSelector === "*" ?
1731				function() { return true; } :
1732				function( elem ) {
1733					return elem.nodeName && elem.nodeName.toLowerCase() === nodeName;
1734				};
1735		},
1736
1737		"CLASS": function( className ) {
1738			var pattern = classCache[ className + " " ];
1739
1740			return pattern ||
1741				(pattern = new RegExp( "(^|" + whitespace + ")" + className + "(" + whitespace + "|$)" )) &&
1742				classCache( className, function( elem ) {
1743					return pattern.test( typeof elem.className === "string" && elem.className || typeof elem.getAttribute !== "undefined" && elem.getAttribute("class") || "" );
1744				});
1745		},
1746
1747		"ATTR": function( name, operator, check ) {
1748			return function( elem ) {
1749				var result = Sizzle.attr( elem, name );
1750
1751				if ( result == null ) {
1752					return operator === "!=";
1753				}
1754				if ( !operator ) {
1755					return true;
1756				}
1757
1758				result += "";
1759
1760				return operator === "=" ? result === check :
1761					operator === "!=" ? result !== check :
1762					operator === "^=" ? check && result.indexOf( check ) === 0 :
1763					operator === "*=" ? check && result.indexOf( check ) > -1 :
1764					operator === "$=" ? check && result.slice( -check.length ) === check :
1765					operator === "~=" ? ( " " + result.replace( rwhitespace, " " ) + " " ).indexOf( check ) > -1 :
1766					operator === "|=" ? result === check || result.slice( 0, check.length + 1 ) === check + "-" :
1767					false;
1768			};
1769		},
1770
1771		"CHILD": function( type, what, argument, first, last ) {
1772			var simple = type.slice( 0, 3 ) !== "nth",
1773				forward = type.slice( -4 ) !== "last",
1774				ofType = what === "of-type";
1775
1776			return first === 1 && last === 0 ?
1777
1778				// Shortcut for :nth-*(n)
1779				function( elem ) {
1780					return !!elem.parentNode;
1781				} :
1782
1783				function( elem, context, xml ) {
1784					var cache, uniqueCache, outerCache, node, nodeIndex, start,
1785						dir = simple !== forward ? "nextSibling" : "previousSibling",
1786						parent = elem.parentNode,
1787						name = ofType && elem.nodeName.toLowerCase(),
1788						useCache = !xml && !ofType,
1789						diff = false;
1790
1791					if ( parent ) {
1792
1793						// :(first|last|only)-(child|of-type)
1794						if ( simple ) {
1795							while ( dir ) {
1796								node = elem;
1797								while ( (node = node[ dir ]) ) {
1798									if ( ofType ?
1799										node.nodeName.toLowerCase() === name :
1800										node.nodeType === 1 ) {
1801
1802										return false;
1803									}
1804								}
1805								// Reverse direction for :only-* (if we haven't yet done so)
1806								start = dir = type === "only" && !start && "nextSibling";
1807							}
1808							return true;
1809						}
1810
1811						start = [ forward ? parent.firstChild : parent.lastChild ];
1812
1813						// non-xml :nth-child(...) stores cache data on `parent`
1814						if ( forward && useCache ) {
1815
1816							// Seek `elem` from a previously-cached index
1817
1818							// ...in a gzip-friendly way
1819							node = parent;
1820							outerCache = node[ expando ] || (node[ expando ] = {});
1821
1822							// Support: IE <9 only
1823							// Defend against cloned attroperties (jQuery gh-1709)
1824							uniqueCache = outerCache[ node.uniqueID ] ||
1825								(outerCache[ node.uniqueID ] = {});
1826
1827							cache = uniqueCache[ type ] || [];
1828							nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ];
1829							diff = nodeIndex && cache[ 2 ];
1830							node = nodeIndex && parent.childNodes[ nodeIndex ];
1831
1832							while ( (node = ++nodeIndex && node && node[ dir ] ||
1833
1834								// Fallback to seeking `elem` from the start
1835								(diff = nodeIndex = 0) || start.pop()) ) {
1836
1837								// When found, cache indexes on `parent` and break
1838								if ( node.nodeType === 1 && ++diff && node === elem ) {
1839									uniqueCache[ type ] = [ dirruns, nodeIndex, diff ];
1840									break;
1841								}
1842							}
1843
1844						} else {
1845							// Use previously-cached element index if available
1846							if ( useCache ) {
1847								// ...in a gzip-friendly way
1848								node = elem;
1849								outerCache = node[ expando ] || (node[ expando ] = {});
1850
1851								// Support: IE <9 only
1852								// Defend against cloned attroperties (jQuery gh-1709)
1853								uniqueCache = outerCache[ node.uniqueID ] ||
1854									(outerCache[ node.uniqueID ] = {});
1855
1856								cache = uniqueCache[ type ] || [];
1857								nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ];
1858								diff = nodeIndex;
1859							}
1860
1861							// xml :nth-child(...)
1862							// or :nth-last-child(...) or :nth(-last)?-of-type(...)
1863							if ( diff === false ) {
1864								// Use the same loop as above to seek `elem` from the start
1865								while ( (node = ++nodeIndex && node && node[ dir ] ||
1866									(diff = nodeIndex = 0) || start.pop()) ) {
1867
1868									if ( ( ofType ?
1869										node.nodeName.toLowerCase() === name :
1870										node.nodeType === 1 ) &&
1871										++diff ) {
1872
1873										// Cache the index of each encountered element
1874										if ( useCache ) {
1875											outerCache = node[ expando ] || (node[ expando ] = {});
1876
1877											// Support: IE <9 only
1878											// Defend against cloned attroperties (jQuery gh-1709)
1879											uniqueCache = outerCache[ node.uniqueID ] ||
1880												(outerCache[ node.uniqueID ] = {});
1881
1882											uniqueCache[ type ] = [ dirruns, diff ];
1883										}
1884
1885										if ( node === elem ) {
1886											break;
1887										}
1888									}
1889								}
1890							}
1891						}
1892
1893						// Incorporate the offset, then check against cycle size
1894						diff -= last;
1895						return diff === first || ( diff % first === 0 && diff / first >= 0 );
1896					}
1897				};
1898		},
1899
1900		"PSEUDO": function( pseudo, argument ) {
1901			// pseudo-class names are case-insensitive
1902			// http://www.w3.org/TR/selectors/#pseudo-classes
1903			// Prioritize by case sensitivity in case custom pseudos are added with uppercase letters
1904			// Remember that setFilters inherits from pseudos
1905			var args,
1906				fn = Expr.pseudos[ pseudo ] || Expr.setFilters[ pseudo.toLowerCase() ] ||
1907					Sizzle.error( "unsupported pseudo: " + pseudo );
1908
1909			// The user may use createPseudo to indicate that
1910			// arguments are needed to create the filter function
1911			// just as Sizzle does
1912			if ( fn[ expando ] ) {
1913				return fn( argument );
1914			}
1915
1916			// But maintain support for old signatures
1917			if ( fn.length > 1 ) {
1918				args = [ pseudo, pseudo, "", argument ];
1919				return Expr.setFilters.hasOwnProperty( pseudo.toLowerCase() ) ?
1920					markFunction(function( seed, matches ) {
1921						var idx,
1922							matched = fn( seed, argument ),
1923							i = matched.length;
1924						while ( i-- ) {
1925							idx = indexOf( seed, matched[i] );
1926							seed[ idx ] = !( matches[ idx ] = matched[i] );
1927						}
1928					}) :
1929					function( elem ) {
1930						return fn( elem, 0, args );
1931					};
1932			}
1933
1934			return fn;
1935		}
1936	},
1937
1938	pseudos: {
1939		// Potentially complex pseudos
1940		"not": markFunction(function( selector ) {
1941			// Trim the selector passed to compile
1942			// to avoid treating leading and trailing
1943			// spaces as combinators
1944			var input = [],
1945				results = [],
1946				matcher = compile( selector.replace( rtrim, "$1" ) );
1947
1948			return matcher[ expando ] ?
1949				markFunction(function( seed, matches, context, xml ) {
1950					var elem,
1951						unmatched = matcher( seed, null, xml, [] ),
1952						i = seed.length;
1953
1954					// Match elements unmatched by `matcher`
1955					while ( i-- ) {
1956						if ( (elem = unmatched[i]) ) {
1957							seed[i] = !(matches[i] = elem);
1958						}
1959					}
1960				}) :
1961				function( elem, context, xml ) {
1962					input[0] = elem;
1963					matcher( input, null, xml, results );
1964					// Don't keep the element (issue #299)
1965					input[0] = null;
1966					return !results.pop();
1967				};
1968		}),
1969
1970		"has": markFunction(function( selector ) {
1971			return function( elem ) {
1972				return Sizzle( selector, elem ).length > 0;
1973			};
1974		}),
1975
1976		"contains": markFunction(function( text ) {
1977			text = text.replace( runescape, funescape );
1978			return function( elem ) {
1979				return ( elem.textContent || 

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