https://groundupmusic.net/dist/vendor.js

1/*!
2 * jQuery JavaScript Library v3.2.1
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: 2017-03-20T18:59Z
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
74
75
76	function DOMEval( code, doc ) {
77		doc = doc || document;
78
79		var script = doc.createElement( "script" );
80
81		script.text = code;
82		doc.head.appendChild( script ).parentNode.removeChild( script );
83	}
84/* global Symbol */
85// Defining this global in .eslintrc.json would create a danger of using the global
86// unguarded in another place, it seems safer to define global only for this module
87
88
89
90var
91	version = "3.2.1",
92
93	// Define a local copy of jQuery
94	jQuery = function( selector, context ) {
95
96		// The jQuery object is actually just the init constructor 'enhanced'
97		// Need init if jQuery is called (just allow error to be thrown if not included)
98		return new jQuery.fn.init( selector, context );
99	},
100
101	// Support: Android <=4.0 only
102	// Make sure we trim BOM and NBSP
103	rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g,
104
105	// Matches dashed string for camelizing
106	rmsPrefix = /^-ms-/,
107	rdashAlpha = /-([a-z])/g,
108
109	// Used by jQuery.camelCase as callback to replace()
110	fcamelCase = function( all, letter ) {
111		return letter.toUpperCase();
112	};
113
114jQuery.fn = jQuery.prototype = {
115
116	// The current version of jQuery being used
117	jquery: version,
118
119	constructor: jQuery,
120
121	// The default length of a jQuery object is 0
122	length: 0,
123
124	toArray: function() {
125		return slice.call( this );
126	},
127
128	// Get the Nth element in the matched element set OR
129	// Get the whole matched element set as a clean array
130	get: function( num ) {
131
132		// Return all the elements in a clean array
133		if ( num == null ) {
134			return slice.call( this );
135		}
136
137		// Return just the one element from the set
138		return num < 0 ? this[ num + this.length ] : this[ num ];
139	},
140
141	// Take an array of elements and push it onto the stack
142	// (returning the new matched element set)
143	pushStack: function( elems ) {
144
145		// Build a new jQuery matched element set
146		var ret = jQuery.merge( this.constructor(), elems );
147
148		// Add the old object onto the stack (as a reference)
149		ret.prevObject = this;
150
151		// Return the newly-formed element set
152		return ret;
153	},
154
155	// Execute a callback for every element in the matched set.
156	each: function( callback ) {
157		return jQuery.each( this, callback );
158	},
159
160	map: function( callback ) {
161		return this.pushStack( jQuery.map( this, function( elem, i ) {
162			return callback.call( elem, i, elem );
163		} ) );
164	},
165
166	slice: function() {
167		return this.pushStack( slice.apply( this, arguments ) );
168	},
169
170	first: function() {
171		return this.eq( 0 );
172	},
173
174	last: function() {
175		return this.eq( -1 );
176	},
177
178	eq: function( i ) {
179		var len = this.length,
180			j = +i + ( i < 0 ? len : 0 );
181		return this.pushStack( j >= 0 && j < len ? [ this[ j ] ] : [] );
182	},
183
184	end: function() {
185		return this.prevObject || this.constructor();
186	},
187
188	// For internal use only.
189	// Behaves like an Array's method, not like a jQuery method.
190	push: push,
191	sort: arr.sort,
192	splice: arr.splice
193};
194
195jQuery.extend = jQuery.fn.extend = function() {
196	var options, name, src, copy, copyIsArray, clone,
197		target = arguments[ 0 ] || {},
198		i = 1,
199		length = arguments.length,
200		deep = false;
201
202	// Handle a deep copy situation
203	if ( typeof target === "boolean" ) {
204		deep = target;
205
206		// Skip the boolean and the target
207		target = arguments[ i ] || {};
208		i++;
209	}
210
211	// Handle case when target is a string or something (possible in deep copy)
212	if ( typeof target !== "object" && !jQuery.isFunction( target ) ) {
213		target = {};
214	}
215
216	// Extend jQuery itself if only one argument is passed
217	if ( i === length ) {
218		target = this;
219		i--;
220	}
221
222	for ( ; i < length; i++ ) {
223
224		// Only deal with non-null/undefined values
225		if ( ( options = arguments[ i ] ) != null ) {
226
227			// Extend the base object
228			for ( name in options ) {
229				src = target[ name ];
230				copy = options[ name ];
231
232				// Prevent never-ending loop
233				if ( target === copy ) {
234					continue;
235				}
236
237				// Recurse if we're merging plain objects or arrays
238				if ( deep && copy && ( jQuery.isPlainObject( copy ) ||
239					( copyIsArray = Array.isArray( copy ) ) ) ) {
240
241					if ( copyIsArray ) {
242						copyIsArray = false;
243						clone = src && Array.isArray( src ) ? src : [];
244
245					} else {
246						clone = src && jQuery.isPlainObject( src ) ? src : {};
247					}
248
249					// Never move original objects, clone them
250					target[ name ] = jQuery.extend( deep, clone, copy );
251
252				// Don't bring in undefined values
253				} else if ( copy !== undefined ) {
254					target[ name ] = copy;
255				}
256			}
257		}
258	}
259
260	// Return the modified object
261	return target;
262};
263
264jQuery.extend( {
265
266	// Unique for each copy of jQuery on the page
267	expando: "jQuery" + ( version + Math.random() ).replace( /\D/g, "" ),
268
269	// Assume jQuery is ready without the ready module
270	isReady: true,
271
272	error: function( msg ) {
273		throw new Error( msg );
274	},
275
276	noop: function() {},
277
278	isFunction: function( obj ) {
279		return jQuery.type( obj ) === "function";
280	},
281
282	isWindow: function( obj ) {
283		return obj != null && obj === obj.window;
284	},
285
286	isNumeric: function( obj ) {
287
288		// As of jQuery 3.0, isNumeric is limited to
289		// strings and numbers (primitives or objects)
290		// that can be coerced to finite numbers (gh-2662)
291		var type = jQuery.type( obj );
292		return ( type === "number" || type === "string" ) &&
293
294			// parseFloat NaNs numeric-cast false positives ("")
295			// ...but misinterprets leading-number strings, particularly hex literals ("0x...")
296			// subtraction forces infinities to NaN
297			!isNaN( obj - parseFloat( obj ) );
298	},
299
300	isPlainObject: function( obj ) {
301		var proto, Ctor;
302
303		// Detect obvious negatives
304		// Use toString instead of jQuery.type to catch host objects
305		if ( !obj || toString.call( obj ) !== "[object Object]" ) {
306			return false;
307		}
308
309		proto = getProto( obj );
310
311		// Objects with no prototype (e.g., `Object.create( null )`) are plain
312		if ( !proto ) {
313			return true;
314		}
315
316		// Objects with prototype are plain iff they were constructed by a global Object function
317		Ctor = hasOwn.call( proto, "constructor" ) && proto.constructor;
318		return typeof Ctor === "function" && fnToString.call( Ctor ) === ObjectFunctionString;
319	},
320
321	isEmptyObject: function( obj ) {
322
323		/* eslint-disable no-unused-vars */
324		// See https://github.com/eslint/eslint/issues/6125
325		var name;
326
327		for ( name in obj ) {
328			return false;
329		}
330		return true;
331	},
332
333	type: function( obj ) {
334		if ( obj == null ) {
335			return obj + "";
336		}
337
338		// Support: Android <=2.3 only (functionish RegExp)
339		return typeof obj === "object" || typeof obj === "function" ?
340			class2type[ toString.call( obj ) ] || "object" :
341			typeof obj;
342	},
343
344	// Evaluates a script in a global context
345	globalEval: function( code ) {
346		DOMEval( code );
347	},
348
349	// Convert dashed to camelCase; used by the css and data modules
350	// Support: IE <=9 - 11, Edge 12 - 13
351	// Microsoft forgot to hump their vendor prefix (#9572)
352	camelCase: function( string ) {
353		return string.replace( rmsPrefix, "ms-" ).replace( rdashAlpha, fcamelCase );
354	},
355
356	each: function( obj, callback ) {
357		var length, i = 0;
358
359		if ( isArrayLike( obj ) ) {
360			length = obj.length;
361			for ( ; i < length; i++ ) {
362				if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {
363					break;
364				}
365			}
366		} else {
367			for ( i in obj ) {
368				if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {
369					break;
370				}
371			}
372		}
373
374		return obj;
375	},
376
377	// Support: Android <=4.0 only
378	trim: function( text ) {
379		return text == null ?
380			"" :
381			( text + "" ).replace( rtrim, "" );
382	},
383
384	// results is for internal usage only
385	makeArray: function( arr, results ) {
386		var ret = results || [];
387
388		if ( arr != null ) {
389			if ( isArrayLike( Object( arr ) ) ) {
390				jQuery.merge( ret,
391					typeof arr === "string" ?
392					[ arr ] : arr
393				);
394			} else {
395				push.call( ret, arr );
396			}
397		}
398
399		return ret;
400	},
401
402	inArray: function( elem, arr, i ) {
403		return arr == null ? -1 : indexOf.call( arr, elem, i );
404	},
405
406	// Support: Android <=4.0 only, PhantomJS 1 only
407	// push.apply(_, arraylike) throws on ancient WebKit
408	merge: function( first, second ) {
409		var len = +second.length,
410			j = 0,
411			i = first.length;
412
413		for ( ; j < len; j++ ) {
414			first[ i++ ] = second[ j ];
415		}
416
417		first.length = i;
418
419		return first;
420	},
421
422	grep: function( elems, callback, invert ) {
423		var callbackInverse,
424			matches = [],
425			i = 0,
426			length = elems.length,
427			callbackExpect = !invert;
428
429		// Go through the array, only saving the items
430		// that pass the validator function
431		for ( ; i < length; i++ ) {
432			callbackInverse = !callback( elems[ i ], i );
433			if ( callbackInverse !== callbackExpect ) {
434				matches.push( elems[ i ] );
435			}
436		}
437
438		return matches;
439	},
440
441	// arg is for internal usage only
442	map: function( elems, callback, arg ) {
443		var length, value,
444			i = 0,
445			ret = [];
446
447		// Go through the array, translating each of the items to their new values
448		if ( isArrayLike( elems ) ) {
449			length = elems.length;
450			for ( ; i < length; i++ ) {
451				value = callback( elems[ i ], i, arg );
452
453				if ( value != null ) {
454					ret.push( value );
455				}
456			}
457
458		// Go through every key on the object,
459		} else {
460			for ( i in elems ) {
461				value = callback( elems[ i ], i, arg );
462
463				if ( value != null ) {
464					ret.push( value );
465				}
466			}
467		}
468
469		// Flatten any nested arrays
470		return concat.apply( [], ret );
471	},
472
473	// A global GUID counter for objects
474	guid: 1,
475
476	// Bind a function to a context, optionally partially applying any
477	// arguments.
478	proxy: function( fn, context ) {
479		var tmp, args, proxy;
480
481		if ( typeof context === "string" ) {
482			tmp = fn[ context ];
483			context = fn;
484			fn = tmp;
485		}
486
487		// Quick check to determine if target is callable, in the spec
488		// this throws a TypeError, but we will just return undefined.
489		if ( !jQuery.isFunction( fn ) ) {
490			return undefined;
491		}
492
493		// Simulated bind
494		args = slice.call( arguments, 2 );
495		proxy = function() {
496			return fn.apply( context || this, args.concat( slice.call( arguments ) ) );
497		};
498
499		// Set the guid of unique handler to the same of original handler, so it can be removed
500		proxy.guid = fn.guid = fn.guid || jQuery.guid++;
501
502		return proxy;
503	},
504
505	now: Date.now,
506
507	// jQuery.support is not used in Core but other projects attach their
508	// properties to it so it needs to exist.
509	support: support
510} );
511
512if ( typeof Symbol === "function" ) {
513	jQuery.fn[ Symbol.iterator ] = arr[ Symbol.iterator ];
514}
515
516// Populate the class2type map
517jQuery.each( "Boolean Number String Function Array Date RegExp Object Error Symbol".split( " " ),
518function( i, name ) {
519	class2type[ "[object " + name + "]" ] = name.toLowerCase();
520} );
521
522function isArrayLike( obj ) {
523
524	// Support: real iOS 8.2 only (not reproducible in simulator)
525	// `in` check used to prevent JIT error (gh-2145)
526	// hasOwn isn't used here due to false negatives
527	// regarding Nodelist length in IE
528	var length = !!obj && "length" in obj && obj.length,
529		type = jQuery.type( obj );
530
531	if ( type === "function" || jQuery.

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

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

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