jysGvG4w

1/******/ (function(modules) { // webpackBootstrap
2/******/ 	// The module cache
3/******/ 	var installedModules = {};
4
5/******/ 	// The require function
6/******/ 	function __webpack_require__(moduleId) {
7
8/******/ 		// Check if module is in cache
9/******/ 		if(installedModules[moduleId])
10/******/ 			return installedModules[moduleId].exports;
11
12/******/ 		// Create a new module (and put it into the cache)
13/******/ 		var module = installedModules[moduleId] = {
14/******/ 			i: moduleId,
15/******/ 			l: false,
16/******/ 			exports: {}
17/******/ 		};
18
19/******/ 		// Execute the module function
20/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
21
22/******/ 		// Flag the module as loaded
23/******/ 		module.l = true;
24
25/******/ 		// Return the exports of the module
26/******/ 		return module.exports;
27/******/ 	}
28
29
30/******/ 	// expose the modules object (__webpack_modules__)
31/******/ 	__webpack_require__.m = modules;
32
33/******/ 	// expose the module cache
34/******/ 	__webpack_require__.c = installedModules;
35
36/******/ 	// identity function for calling harmony imports with the correct context
37/******/ 	__webpack_require__.i = function(value) { return value; };
38
39/******/ 	// define getter function for harmony exports
40/******/ 	__webpack_require__.d = function(exports, name, getter) {
41/******/ 		if(!__webpack_require__.o(exports, name)) {
42/******/ 			Object.defineProperty(exports, name, {
43/******/ 				configurable: false,
44/******/ 				enumerable: true,
45/******/ 				get: getter
46/******/ 			});
47/******/ 		}
48/******/ 	};
49
50/******/ 	// getDefaultExport function for compatibility with non-harmony modules
51/******/ 	__webpack_require__.n = function(module) {
52/******/ 		var getter = module && module.__esModule ?
53/******/ 			function getDefault() { return module['default']; } :
54/******/ 			function getModuleExports() { return module; };
55/******/ 		__webpack_require__.d(getter, 'a', getter);
56/******/ 		return getter;
57/******/ 	};
58
59/******/ 	// Object.prototype.hasOwnProperty.call
60/******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
61
62/******/ 	// __webpack_public_path__
63/******/ 	__webpack_require__.p = "./";
64
65/******/ 	// Load entry module and return exports
66/******/ 	return __webpack_require__(__webpack_require__.s = 9);
67/******/ })
68/************************************************************************/
69/******/ ([
70/* 0 */
71/***/ (function(module, exports, __webpack_require__) {
72
73var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/*!
74 * jQuery JavaScript Library v3.1.1
75 * https://jquery.com/
76 *
77 * Includes Sizzle.js
78 * https://sizzlejs.com/
79 *
80 * Copyright jQuery Foundation and other contributors
81 * Released under the MIT license
82 * https://jquery.org/license
83 *
84 * Date: 2016-09-22T22:30Z
85 */
86( function( global, factory ) {
87
88	"use strict";
89
90	if ( typeof module === "object" && typeof module.exports === "object" ) {
91
92		// For CommonJS and CommonJS-like environments where a proper `window`
93		// is present, execute the factory and get jQuery.
94		// For environments that do not have a `window` with a `document`
95		// (such as Node.js), expose a factory as module.exports.
96		// This accentuates the need for the creation of a real `window`.
97		// e.g. var jQuery = require("jquery")(window);
98		// See ticket #14549 for more info.
99		module.exports = global.document ?
100			factory( global, true ) :
101			function( w ) {
102				if ( !w.document ) {
103					throw new Error( "jQuery requires a window with a document" );
104				}
105				return factory( w );
106			};
107	} else {
108		factory( global );
109	}
110
111// Pass this if window is not defined yet
112} )( typeof window !== "undefined" ? window : this, function( window, noGlobal ) {
113
114// Edge <= 12 - 13+, Firefox <=18 - 45+, IE 10 - 11, Safari 5.1 - 9+, iOS 6 - 9.1
115// throw exceptions when non-strict code (e.g., ASP.NET 4.5) accesses strict mode
116// arguments.callee.caller (trac-13335). But as of jQuery 3.0 (2016), strict mode should be common
117// enough that all such attempts are guarded in a try block.
118"use strict";
119
120var arr = [];
121
122var document = window.document;
123
124var getProto = Object.getPrototypeOf;
125
126var slice = arr.slice;
127
128var concat = arr.concat;
129
130var push = arr.push;
131
132var indexOf = arr.indexOf;
133
134var class2type = {};
135
136var toString = class2type.toString;
137
138var hasOwn = class2type.hasOwnProperty;
139
140var fnToString = hasOwn.toString;
141
142var ObjectFunctionString = fnToString.call( Object );
143
144var support = {};
145
146
147
148	function DOMEval( code, doc ) {
149		doc = doc || document;
150
151		var script = doc.createElement( "script" );
152
153		script.text = code;
154		doc.head.appendChild( script ).parentNode.removeChild( script );
155	}
156/* global Symbol */
157// Defining this global in .eslintrc.json would create a danger of using the global
158// unguarded in another place, it seems safer to define global only for this module
159
160
161
162var
163	version = "3.1.1",
164
165	// Define a local copy of jQuery
166	jQuery = function( selector, context ) {
167
168		// The jQuery object is actually just the init constructor 'enhanced'
169		// Need init if jQuery is called (just allow error to be thrown if not included)
170		return new jQuery.fn.init( selector, context );
171	},
172
173	// Support: Android <=4.0 only
174	// Make sure we trim BOM and NBSP
175	rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g,
176
177	// Matches dashed string for camelizing
178	rmsPrefix = /^-ms-/,
179	rdashAlpha = /-([a-z])/g,
180
181	// Used by jQuery.camelCase as callback to replace()
182	fcamelCase = function( all, letter ) {
183		return letter.toUpperCase();
184	};
185
186jQuery.fn = jQuery.prototype = {
187
188	// The current version of jQuery being used
189	jquery: version,
190
191	constructor: jQuery,
192
193	// The default length of a jQuery object is 0
194	length: 0,
195
196	toArray: function() {
197		return slice.call( this );
198	},
199
200	// Get the Nth element in the matched element set OR
201	// Get the whole matched element set as a clean array
202	get: function( num ) {
203
204		// Return all the elements in a clean array
205		if ( num == null ) {
206			return slice.call( this );
207		}
208
209		// Return just the one element from the set
210		return num < 0 ? this[ num + this.length ] : this[ num ];
211	},
212
213	// Take an array of elements and push it onto the stack
214	// (returning the new matched element set)
215	pushStack: function( elems ) {
216
217		// Build a new jQuery matched element set
218		var ret = jQuery.merge( this.constructor(), elems );
219
220		// Add the old object onto the stack (as a reference)
221		ret.prevObject = this;
222
223		// Return the newly-formed element set
224		return ret;
225	},
226
227	// Execute a callback for every element in the matched set.
228	each: function( callback ) {
229		return jQuery.each( this, callback );
230	},
231
232	map: function( callback ) {
233		return this.pushStack( jQuery.map( this, function( elem, i ) {
234			return callback.call( elem, i, elem );
235		} ) );
236	},
237
238	slice: function() {
239		return this.pushStack( slice.apply( this, arguments ) );
240	},
241
242	first: function() {
243		return this.eq( 0 );
244	},
245
246	last: function() {
247		return this.eq( -1 );
248	},
249
250	eq: function( i ) {
251		var len = this.length,
252			j = +i + ( i < 0 ? len : 0 );
253		return this.pushStack( j >= 0 && j < len ? [ this[ j ] ] : [] );
254	},
255
256	end: function() {
257		return this.prevObject || this.constructor();
258	},
259
260	// For internal use only.
261	// Behaves like an Array's method, not like a jQuery method.
262	push: push,
263	sort: arr.sort,
264	splice: arr.splice
265};
266
267jQuery.extend = jQuery.fn.extend = function() {
268	var options, name, src, copy, copyIsArray, clone,
269		target = arguments[ 0 ] || {},
270		i = 1,
271		length = arguments.length,
272		deep = false;
273
274	// Handle a deep copy situation
275	if ( typeof target === "boolean" ) {
276		deep = target;
277
278		// Skip the boolean and the target
279		target = arguments[ i ] || {};
280		i++;
281	}
282
283	// Handle case when target is a string or something (possible in deep copy)
284	if ( typeof target !== "object" && !jQuery.isFunction( target ) ) {
285		target = {};
286	}
287
288	// Extend jQuery itself if only one argument is passed
289	if ( i === length ) {
290		target = this;
291		i--;
292	}
293
294	for ( ; i < length; i++ ) {
295
296		// Only deal with non-null/undefined values
297		if ( ( options = arguments[ i ] ) != null ) {
298
299			// Extend the base object
300			for ( name in options ) {
301				src = target[ name ];
302				copy = options[ name ];
303
304				// Prevent never-ending loop
305				if ( target === copy ) {
306					continue;
307				}
308
309				// Recurse if we're merging plain objects or arrays
310				if ( deep && copy && ( jQuery.isPlainObject( copy ) ||
311					( copyIsArray = jQuery.isArray( copy ) ) ) ) {
312
313					if ( copyIsArray ) {
314						copyIsArray = false;
315						clone = src && jQuery.isArray( src ) ? src : [];
316
317					} else {
318						clone = src && jQuery.isPlainObject( src ) ? src : {};
319					}
320
321					// Never move original objects, clone them
322					target[ name ] = jQuery.extend( deep, clone, copy );
323
324				// Don't bring in undefined values
325				} else if ( copy !== undefined ) {
326					target[ name ] = copy;
327				}
328			}
329		}
330	}
331
332	// Return the modified object
333	return target;
334};
335
336jQuery.extend( {
337
338	// Unique for each copy of jQuery on the page
339	expando: "jQuery" + ( version + Math.random() ).replace( /\D/g, "" ),
340
341	// Assume jQuery is ready without the ready module
342	isReady: true,
343
344	error: function( msg ) {
345		throw new Error( msg );
346	},
347
348	noop: function() {},
349
350	isFunction: function( obj ) {
351		return jQuery.type( obj ) === "function";
352	},
353
354	isArray: Array.isArray,
355
356	isWindow: function( obj ) {
357		return obj != null && obj === obj.window;
358	},
359
360	isNumeric: function( obj ) {
361
362		// As of jQuery 3.0, isNumeric is limited to
363		// strings and numbers (primitives or objects)
364		// that can be coerced to finite numbers (gh-2662)
365		var type = jQuery.type( obj );
366		return ( type === "number" || type === "string" ) &&
367
368			// parseFloat NaNs numeric-cast false positives ("")
369			// ...but misinterprets leading-number strings, particularly hex literals ("0x...")
370			// subtraction forces infinities to NaN
371			!isNaN( obj - parseFloat( obj ) );
372	},
373
374	isPlainObject: function( obj ) {
375		var proto, Ctor;
376
377		// Detect obvious negatives
378		// Use toString instead of jQuery.type to catch host objects
379		if ( !obj || toString.call( obj ) !== "[object Object]" ) {
380			return false;
381		}
382
383		proto = getProto( obj );
384
385		// Objects with no prototype (e.g., `Object.create( null )`) are plain
386		if ( !proto ) {
387			return true;
388		}
389
390		// Objects with prototype are plain iff they were constructed by a global Object function
391		Ctor = hasOwn.call( proto, "constructor" ) && proto.constructor;
392		return typeof Ctor === "function" && fnToString.call( Ctor ) === ObjectFunctionString;
393	},
394
395	isEmptyObject: function( obj ) {
396
397		/* eslint-disable no-unused-vars */
398		// See https://github.com/eslint/eslint/issues/6125
399		var name;
400
401		for ( name in obj ) {
402			return false;
403		}
404		return true;
405	},
406
407	type: function( obj ) {
408		if ( obj == null ) {
409			return obj + "";
410		}
411
412		// Support: Android <=2.3 only (functionish RegExp)
413		return typeof obj === "object" || typeof obj === "function" ?
414			class2type[ toString.call( obj ) ] || "object" :
415			typeof obj;
416	},
417
418	// Evaluates a script in a global context
419	globalEval: function( code ) {
420		DOMEval( code );
421	},
422
423	// Convert dashed to camelCase; used by the css and data modules
424	// Support: IE <=9 - 11, Edge 12 - 13
425	// Microsoft forgot to hump their vendor prefix (#9572)
426	camelCase: function( string ) {
427		return string.replace( rmsPrefix, "ms-" ).replace( rdashAlpha, fcamelCase );
428	},
429
430	nodeName: function( elem, name ) {
431		return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase();
432	},
433
434	each: function( obj, callback ) {
435		var length, i = 0;
436
437		if ( isArrayLike( obj ) ) {
438			length = obj.length;
439			for ( ; i < length; i++ ) {
440				if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {
441					break;
442				}
443			}
444		} else {
445			for ( i in obj ) {
446				if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {
447					break;
448				}
449			}
450		}
451
452		return obj;
453	},
454
455	// Support: Android <=4.0 only
456	trim: function( text ) {
457		return text == null ?
458			"" :
459			( text + "" ).replace( rtrim, "" );
460	},
461
462	// results is for internal usage only
463	makeArray: function( arr, results ) {
464		var ret = results || [];
465
466		if ( arr != null ) {
467			if ( isArrayLike( Object( arr ) ) ) {
468				jQuery.merge( ret,
469					typeof arr === "string" ?
470					[ arr ] : arr
471				);
472			} else {
473				push.call( ret, arr );
474			}
475		}
476
477		return ret;
478	},
479
480	inArray: function( elem, arr, i ) {
481		return arr == null ? -1 : indexOf.call( arr, elem, i );
482	},
483
484	// Support: Android <=4.0 only, PhantomJS 1 only
485	// push.apply(_, arraylike) throws on ancient WebKit
486	merge: function( first, second ) {
487		var len = +second.length,
488			j = 0,
489			i = first.length;
490
491		for ( ; j < len; j++ ) {
492			first[ i++ ] = second[ j ];
493		}
494
495		first.length = i;
496
497		return first;
498	},
499
500	grep: function( elems, callback, invert ) {
501		var callbackInverse,
502			matches = [],
503			i = 0,
504			length = elems.length,
505			callbackExpect = !invert;
506
507		// Go through the array, only saving the items
508		// that pass the validator function
509		for ( ; i < length; i++ ) {
510			callbackInverse = !callback( elems[ i ], i );
511			if ( callbackInverse !== callbackExpect ) {
512				matches.push( elems[ i ] );
513			}
514		}
515
516		return matches;
517	},
518
519	// arg is for internal usage only
520	map: function( elems, callback, arg ) {
521		var length, value,
522			i = 0,
523			ret = [];
524
525		// Go through the array, translating each of the items to their new values
526		if ( isArrayLike( elems ) ) {
527			length = elems.length;
528			for ( ; i < length; i++ ) {
529				value = callback( elems[ i ], i, arg );
530
531				if ( value != null ) {
532					ret.push( value );
533				}
534			}
535
536		// Go through every key on the object,
537		} else {
538			for ( i in elems ) {
539				value = callback( elems[ i ], i, arg );
540
541				if ( value != null ) {
542					ret.push( value );
543				}
544			}
545		}
546
547		// Flatten any nested arrays
548		return concat.apply( [], ret );
549	},
550
551	// A global GUID counter for objects
552	guid: 1,
553
554	// Bind a function to a context, optionally partially applying any
555	// arguments.
556	proxy: function( fn, context ) {
557		var tmp, args, proxy;
558
559		if ( typeof context === "string" ) {
560			tmp = fn[ context ];
561			context = fn;
562			fn = tmp;
563		}
564
565		// Quick check to determine if target is callable, in the spec
566		// this throws a TypeError, but we will just return undefined.
567		if ( !jQuery.isFunction( fn ) ) {
568			return undefined;
569		}
570
571		// Simulated bind
572		args = slice.call( arguments, 2 );
573		proxy = function() {
574			return fn.apply( context || this, args.concat( slice.call( arguments ) ) );
575		};
576
577		// Set the guid of unique handler to the same of original handler, so it can be removed
578		proxy.guid = fn.guid = fn.guid || jQuery.guid++;
579
580		return proxy;
581	},
582
583	now: Date.now,
584
585	// jQuery.support is not used in Core but other projects attach their
586	// properties to it so it needs to exist.
587	support: support
588} );
589
590if ( typeof Symbol === "function" ) {
591	jQuery.fn[ Symbol.iterator ] = arr[ Symbol.iterator ];
592}
593
594// Populate the class2type map
595jQuery.each( "Boolean Number String Function Array Date RegExp Object Error Symbol".split( " " ),
596function( i, name ) {
597	class2type[ "[object " + name + "]" ] = name.toLowerCase();
598} );
599
600function isArrayLike( obj ) {
601
602	// Support: real iOS 8.2 only (not reproducible in simulator)
603	// `in` check used to prevent JIT error (gh-2145)
604	// hasOwn isn't used here due to false negatives
605	// regarding Nodelist length in IE
606	var length = !!obj && "length" in obj && obj.length,
607		type = jQuery.type( obj );
608
609	if ( type === "function" || jQuery.isWindow( obj ) ) {
610		return false;
611	}
612
613	return type === "array" || length === 0 ||
614		typeof length === "number" && length > 0 && ( length - 1 ) in obj;
615}
616var Sizzle =
617/*!
618 * Sizzle CSS Selector Engine v2.3.3
619 * https://sizzlejs.com/
620 *
621 * Copyright jQuery Foundation and other contributors
622 * Released under the MIT license
623 * http://jquery.org/license
624 *
625 * Date: 2016-08-08
626 */
627(function( window ) {
628
629var i,
630	support,
631	Expr,
632	getText,
633	isXML,
634	tokenize,
635	compile,
636	select,
637	outermostContext,
638	sortInput,
639	hasDuplicate,
640
641	// Local document vars
642	setDocument,
643	document,
644	docElem,
645	documentIsHTML,
646	rbuggyQSA,
647	rbuggyMatches,
648	matches,
649	contains,
650
651	// Instance-specific data
652	expando = "sizzle" + 1 * new Date(),
653	preferredDoc = window.document,
654	dirruns = 0,
655	done = 0,
656	classCache = createCache(),
657	tokenCache = createCache(),
658	compilerCache = createCache(),
659	sortOrder = function( a, b ) {
660		if ( a === b ) {
661			hasDuplicate = true;
662		}
663		return 0;
664	},
665
666	// Instance methods
667	hasOwn = ({}).hasOwnProperty,
668	arr = [],
669	pop = arr.pop,
670	push_native = arr.push,
671	push = arr.push,
672	slice = arr.slice,
673	// Use a stripped-down indexOf as it's faster than native
674	// https://jsperf.com/thor-indexof-vs-for/5
675	indexOf = function( list, elem ) {
676		var i = 0,
677			len = list.length;
678		for ( ; i < len; i++ ) {
679			if ( list[i] === elem ) {
680				return i;
681			}
682		}
683		return -1;
684	},
685
686	booleans = "checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped",
687
688	// Regular expressions
689
690	// http://www.w3.org/TR/css3-selectors/#whitespace
691	whitespace = "[\\x20\\t\\r\\n\\f]",
692
693	// http://www.w3.org/TR/CSS21/syndata.html#value-def-identifier
694	identifier = "(?:\\\\.|[\\w-]|[^\0-\\xa0])+",
695
696	// Attribute selectors: http://www.w3.org/TR/selectors/#attribute-selectors
697	attributes = "\\[" + whitespace + "*(" + identifier + ")(?:" + whitespace +
698		// Operator (capture 2)
699		"*([*^$|!~]?=)" + whitespace +
700		// "Attribute values must be CSS identifiers [capture 5] or strings [capture 3 or capture 4]"
701		"*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|(" + identifier + "))|)" + whitespace +
702		"*\\]",
703
704	pseudos = ":(" + identifier + ")(?:\\((" +
705		// To reduce the number of selectors needing tokenize in the preFilter, prefer arguments:
706		// 1. quoted (capture 3; capture 4 or capture 5)
707		"('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|" +
708		// 2. simple (capture 6)
709		"((?:\\\\.|[^\\\\()[\\]]|" + attributes + ")*)|" +
710		// 3. anything else (capture 2)
711		".*" +
712		")\\)|)",
713
714	// Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter
715	rwhitespace = new RegExp( whitespace + "+", "g" ),
716	rtrim = new RegExp( "^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" + whitespace + "+$", "g" ),
717
718	rcomma = new RegExp( "^" + whitespace + "*," + whitespace + "*" ),
719	rcombinators = new RegExp( "^" + whitespace + "*([>+~]|" + whitespace + ")" + whitespace + "*" ),
720
721	rattributeQuotes = new RegExp( "=" + whitespace + "*([^\\]'\"]*?)" + whitespace + "*\\]", "g" ),
722
723	rpseudo = new RegExp( pseudos ),
724	ridentifier = new RegExp( "^" + identifier + "$" ),
725
726	matchExpr = {
727		"ID": new RegExp( "^#(" + identifier + ")" ),
728		"CLASS": new RegExp( "^\\.(" + identifier + ")" ),
729		"TAG": new RegExp( "^(" + identifier + "|[*])" ),
730		"ATTR": new RegExp( "^" + attributes ),
731		"PSEUDO": new RegExp( "^" + pseudos ),
732		"CHILD": new RegExp( "^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(" + whitespace +
733			"*(even|odd|(([+-]|)(\\d*)n|)" + whitespace + "*(?:([+-]|)" + whitespace +
734			"*(\\d+)|))" + whitespace + "*\\)|)", "i" ),
735		"bool": new RegExp( "^(?:" + booleans + ")$", "i" ),
736		// For use in libraries implementing .is()
737		// We use this for POS matching in `select`
738		"needsContext": new RegExp( "^" + whitespace + "*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(" +
739			whitespace + "*((?:-\\d)?\\d*)" + whitespace + "*\\)|)(?=[^-]|$)", "i" )
740	},
741
742	rinputs = /^(?:input|select|textarea|button)$/i,
743	rheader = /^h\d$/i,
744
745	rnative = /^[^{]+\{\s*\[native \w/,
746
747	// Easily-parseable/retrievable ID or TAG or CLASS selectors
748	rquickExpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,
749
750	rsibling = /[+~]/,
751
752	// CSS escapes
753	// http://www.w3.org/TR/CSS21/syndata.html#escaped-characters
754	runescape = new RegExp( "\\\\([\\da-f]{1,6}" + whitespace + "?|(" + whitespace + ")|.)", "ig" ),
755	funescape = function( _, escaped, escapedWhitespace ) {
756		var high = "0x" + escaped - 0x10000;
757		// NaN means non-codepoint
758		// Support: Firefox<24
759		// Workaround erroneous numeric interpretation of +"0x"
760		return high !== high || escapedWhitespace ?
761			escaped :
762			high < 0 ?
763				// BMP codepoint
764				String.fromCharCode( high + 0x10000 ) :
765				// Supplemental Plane codepoint (surrogate pair)
766				String.fromCharCode( high >> 10 | 0xD800, high & 0x3FF | 0xDC00 );
767	},
768
769	// CSS string/identifier serialization
770	// https://drafts.csswg.org/cssom/#common-serializing-idioms
771	rcssescape = /([\0-\x1f\x7f]|^-?\d)|^-$|[^\0-\x1f\x7f-\uFFFF\w-]/g,
772	fcssescape = function( ch, asCodePoint ) {
773		if ( asCodePoint ) {
774
775			// U+0000 NULL becomes U+FFFD REPLACEMENT CHARACTER
776			if ( ch === "\0" ) {
777				return "\uFFFD";
778			}
779
780			// Control characters and (dependent upon position) numbers get escaped as code points
781			return ch.slice( 0, -1 ) + "\\" + ch.charCodeAt( ch.length - 1 ).toString( 16 ) + " ";
782		}
783
784		// Other potentially-special ASCII characters get backslash-escaped
785		return "\\" + ch;
786	},
787
788	// Used for iframes
789	// See setDocument()
790	// Removing the function wrapper causes a "Permission Denied"
791	// error in IE
792	unloadHandler = function() {
793		setDocument();
794	},
795
796	disabledAncestor = addCombinator(
797		function( elem ) {
798			return elem.disabled === true && ("form" in elem || "label" in elem);
799		},
800		{ dir: "parentNode", next: "legend" }
801	);
802
803// Optimize for push.apply( _, NodeList )
804try {
805	push.apply(
806		(arr = slice.call( preferredDoc.childNodes )),
807		preferredDoc.childNodes
808	);
809	// Support: Android<4.0
810	// Detect silently failing push.apply
811	arr[ preferredDoc.childNodes.length ].nodeType;
812} catch ( e ) {
813	push = { apply: arr.length ?
814
815		// Leverage slice if possible
816		function( target, els ) {
817			push_native.apply( target, slice.call(els) );
818		} :
819
820		// Support: IE<9
821		// Otherwise append directly
822		function( target, els ) {
823			var j = target.length,
824				i = 0;
825			// Can't trust NodeList.length
826			while ( (target[j++] = els[i++]) ) {}
827			target.length = j - 1;
828		}
829	};
830}
831
832function Sizzle( selector, context, results, seed ) {
833	var m, i, elem, nid, match, groups, newSelector,
834		newContext = context && context.ownerDocument,
835
836		// nodeType defaults to 9, since context defaults to document
837		nodeType = context ? context.nodeType : 9;
838
839	results = results || [];
840
841	// Return early from calls with invalid selector or context
842	if ( typeof selector !== "string" || !selector ||
843		nodeType !== 1 && nodeType !== 9 && nodeType !== 11 ) {
844
845		return results;
846	}
847
848	// Try to shortcut find operations (as opposed to filters) in HTML documents
849	if ( !seed ) {
850
851		if ( ( context ? context.ownerDocument || context : preferredDoc ) !== document ) {
852			setDocument( context );
853		}
854		context = context || document;
855
856		if ( documentIsHTML ) {
857
858			// If the selector is sufficiently simple, try using a "get*By*" DOM method
859			// (excepting DocumentFragment context, where the methods don't exist)
860			if ( nodeType !== 11 && (match = rquickExpr.exec( selector )) ) {
861
862				// ID selector
863				if ( (m = match[1]) ) {
864
865					// Document context
866					if ( nodeType === 9 ) {
867						if ( (elem = context.getElementById( m )) ) {
868
869							// Support: IE, Opera, Webkit
870							// TODO: identify versions
871							// getElementById can match elements by name instead of ID
872							if ( elem.id === m ) {
873								results.push( elem );
874								return results;
875							}
876						} else {
877							return results;
878						}
879
880					// Element context
881					} else {
882
883						// Support: IE, Opera, Webkit
884						// TODO: identify versions
885						// getElementById can match elements by name instead of ID
886						if ( newContext && (elem = newContext.getElementById( m )) &&
887							contains( context, elem ) &&
888							elem.id === m ) {
889
890							results.push( elem );
891							return results;
892						}
893					}
894
895				// Type selector
896				} else if ( match[2] ) {
897					push.apply( results, context.getElementsByTagName( selector ) );
898					return results;
899
900				// Class selector
901				} else if ( (m = match[3]) && support.getElementsByClassName &&
902					context.getElementsByClassName ) {
903
904					push.apply( results, context.getElementsByClassName( m ) );
905					return results;
906				}
907			}
908
909			// Take advantage of querySelectorAll
910			if ( support.qsa &&
911				!compilerCache[ selector + " " ] &&
912				(!rbuggyQSA || !rbuggyQSA.test( selector )) ) {
913
914				if ( nodeType !== 1 ) {
915					newContext = context;
916					newSelector = selector;
917
918				// qSA looks outside Element context, which is not what we want
919				// Thanks to Andrew Dupont for this workaround technique
920				// Support: IE <=8
921				// Exclude object elements
922				} else if ( context.nodeName.toLowerCase() !== "object" ) {
923
924					// Capture the context ID, setting it first if necessary
925					if ( (nid = context.getAttribute( "id" )) ) {
926						nid = nid.replace( rcssescape, fcssescape );
927					} else {
928						context.setAttribute( "id", (nid = expando) );
929					}
930
931					// Prefix every selector in the list
932					groups = tokenize( selector );
933					i = groups.length;
934					while ( i-- ) {
935						groups[i] = "#" + nid + " " + toSelector( groups[i] );
936					}
937					newSelector = groups.join( "," );
938
939					// Expand context for sibling selectors
940					newContext = rsibling.test( selector ) && testContext( context.parentNode ) ||
941						context;
942				}
943
944				if ( newSelector ) {
945					try {
946						push.apply( results,
947							newContext.querySelectorAll( newSelector )
948						);
949						return results;
950					} catch ( qsaError ) {
951					} finally {
952						if ( nid === expando ) {
953							context.removeAttribute( "id" );
954						}
955					}
956				}
957			}
958		}
959	}
960
961	// All others
962	return select( selector.replace( rtrim, "$1" ), context, results, seed );
963}
964
965/**
966 * Create key-value caches of limited size
967 * @returns {function(string, object)} Returns the Object data after storing it on itself with
968 *	property name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength)
969 *	deleting the oldest entry
970 */
971function createCache() {
972	var keys = [];
973
974	function cache( key, value ) {
975		// Use (key + " ") to avoid collision with native prototype properties (see Issue #157)
976		if ( keys.push( key + " " ) > Expr.cacheLength ) {
977			// Only keep the most recent entries
978			delete cache[ keys.shift() ];
979		}
980		return (cache[ key + " " ] = value);
981	}
982	return cache;
983}
984
985/**
986 * Mark a function for special use by Sizzle
987 * @param {Function} fn The function to mark
988 */
989function markFunction( fn ) {
990	fn[ expando ] = true;
991	return fn;
992}
993
994/**
995 * Support testing using an element
996 * @param {Function} fn Passed the created element and returns a boolean result
997 */
998function assert( fn ) {
999	var el = document.createElement("fieldset");
1000
1001	try {
1002		return !!fn( el );
1003	} catch (e) {
1004		return false;
1005	} finally {
1006		// Remove from its parent by default
1007		if ( el.parentNode ) {
1008			el.parentNode.removeChild( el );
1009		}
1010		// release memory in IE
1011		el = null;
1012	}
1013}
1014
1015/**
1016 * Adds the same handler for all of the specified attrs
1017 * @param {String} attrs Pipe-separated list of attributes
1018 * @param {Function} handler The method that will be applied
1019 */
1020function addHandle( attrs, handler ) {
1021	var arr = attrs.split("|"),
1022		i = arr.length;
1023
1024	while ( i-- ) {
1025		Expr.attrHandle[ arr[i] ] = handler;
1026	}
1027}
1028
1029/**
1030 * Checks document order of two siblings
1031 * @param {Element} a
1032 * @param {Element} b
1033 * @returns {Number} Returns less than 0 if a precedes b, greater than 0 if a follows b
1034 */
1035function siblingCheck( a, b ) {
1036	var cur = b && a,
1037		diff = cur && a.nodeType === 1 && b.nodeType === 1 &&
1038			a.sourceIndex - b.sourceIndex;
1039
1040	// Use IE sourceIndex if available on both nodes
1041	if ( diff ) {
1042		return diff;
1043	}
1044
1045	// Check if b follows a
1046	if ( cur ) {
1047		while ( (cur = cur.nextSibling) ) {
1048			if ( cur === b ) {
1049				return -1;
1050			}
1051		}
1052	}
1053
1054	return a ? 1 : -1;
1055}
1056
1057/**
1058 * Returns a function to use in pseudos for input types
1059 * @param {String} type
1060 */
1061function createInputPseudo( type ) {
1062	return function( elem ) {
1063		var name = elem.nodeName.toLowerCase();
1064		return name === "input" && elem.type === type;
1065	};
1066}
1067
1068/**
1069 * Returns a function to use in pseudos for buttons
1070 * @param {String} type
1071 */
1072function createButtonPseudo( type ) {
1073	return function( elem ) {
1074		var name = elem.nodeName.toLowerCase();
1075		return (name === "input" || name === "button") && elem.type === type;
1076	};
1077}
1078
1079/**
1080 * Returns a function to use in pseudos for :enabled/:disabled
1081 * @param {Boolean} disabled true for :disabled; false for :enabled
1082 */
1083function createDisabledPseudo( disabled ) {
1084
1085	// Known :disabled false positives: fieldset[disabled] > legend:nth-of-type(n+2) :can-disable
1086	return function( elem ) {
1087
1088		// Only certain elements can match :enabled or :disabled
1089		// https://html.spec.whatwg.org/multipage/scripting.html#selector-enabled
1090		// https://html.spec.whatwg.org/multipage/scripting.html#selector-disabled
1091		if ( "form" in elem ) {
1092
1093			// Check for inherited disabledness on relevant non-disabled elements:
1094			// * listed form-associated elements in a disabled fieldset
1095			//   https://html.spec.whatwg.org/multipage/forms.html#category-listed
1096			//   https://html.spec.whatwg.org/multipage/forms.html#concept-fe-disabled
1097			// * option elements in a disabled optgroup
1098			//   https://html.spec.whatwg.org/multipage/forms.html#concept-option-disabled
1099			// All such elements have a "form" property.
1100			if ( elem.parentNode && elem.disabled === false ) {
1101
1102				// Option elements defer to a parent optgroup if present
1103				if ( "label" in elem ) {
1104					if ( "label" in elem.parentNode ) {
1105						return elem.parentNode.disabled === disabled;
1106					} else {
1107						return elem.disabled === disabled;
1108					}
1109				}
1110
1111				// Support: IE 6 - 11
1112				// Use the isDisabled shortcut property to check for disabled fieldset ancestors
1113				return elem.isDisabled === disabled ||
1114
1115					// Where there is no isDisabled, check manually
1116					/* jshint -W018 */
1117					elem.isDisabled !== !disabled &&
1118						disabledAncestor( elem ) === disabled;
1119			}
1120
1121			return elem.disabled === disabled;
1122
1123		// Try to winnow out elements that can't be disabled before trusting the disabled property.
1124		// Some victims get caught in our net (label, legend, menu, track), but it shouldn't
1125		// even exist on them, let alone have a boolean value.
1126		} else if ( "label" in elem ) {
1127			return elem.disabled === disabled;
1128		}
1129
1130		// Remaining elements are neither :enabled nor :disabled
1131		return false;
1132	};
1133}
1134
1135/**
1136 * Returns a function to use in pseudos for positionals
1137 * @param {Function} fn
1138 */
1139function createPositionalPseudo( fn ) {
1140	return markFunction(function( argument ) {
1141		argument = +argument;
1142		return markFunction(function( seed, matches ) {
1143			var j,
1144				matchIndexes = fn( [], seed.length, argument ),
1145				i = matchIndexes.length;
1146
1147			// Match elements found at the specified indexes
1148			while ( i-- ) {
1149				if ( seed[ (j = matchIndexes[i]) ] ) {
1150					seed[j] = !(matches[j] = seed[j]);
1151				}
1152			}
1153		});
1154	});
1155}
1156
1157/**
1158 * Checks a node for validity as a Sizzle context
1159 * @param {Element|Object=} context
1160 * @returns {Element|Object|Boolean} The input node if acceptable, otherwise a falsy value
1161 */
1162function testContext( context ) {
1163	return context && typeof context.getElementsByTagName !== "undefined" && context;
1164}
1165
1166// Expose support vars for convenience
1167support = Sizzle.support = {};
1168
1169/**
1170 * Detects XML nodes
1171 * @param {Element|Object} elem An element or a document
1172 * @returns {Boolean} True iff elem is a non-HTML XML node
1173 */
1174isXML = Sizzle.isXML = function( elem ) {
1175	// documentElement is verified for cases where it doesn't yet exist
1176	// (such as loading iframes in IE - #4833)
1177	var documentElement = elem && (elem.ownerDocument || elem).documentElement;
1178	return documentElement ? documentElement.nodeName !== "HTML" : false;
1179};
1180
1181/**
1182 * Sets document-related variables once based on the current document
1183 * @param {Element|Object} [doc] An element or document object to use to set the document
1184 * @returns {Object} Returns the current document
1185 */
1186setDocument = Sizzle.setDocument = function( node ) {
1187	var hasCompare, subWindow,
1188		doc = node ? node.ownerDocument || node : preferredDoc;
1189
1190	// Return early if doc is invalid or already selected
1191	if ( doc === document || doc.nodeType !== 9 || !doc.documentElement ) {
1192		return document;
1193	}
1194
1195	// Update global variables
1196	document = doc;
1197	docElem = document.documentElement;
1198	documentIsHTML = !isXML( document );
1199
1200	// Support: IE 9-11, Edge
1201	// Accessing iframe documents after unload throws "permission denied" errors (jQuery #13936)
1202	if ( preferredDoc !== document &&
1203		(subWindow = document.defaultView) && subWindow.top !== subWindow ) {
1204
1205		// Support: IE 11, Edge
1206		if ( subWindow.addEventListener ) {
1207			subWindow.addEventListener( "unload", unloadHandler, false );
1208
1209		// Support: IE 9 - 10 only
1210		} else if ( subWindow.attachEvent ) {
1211			subWindow.attachEvent( "onunload", unloadHandler );
1212		}
1213	}
1214
1215	/* Attributes
1216	---------------------------------------------------------------------- */
1217
1218	// Support: IE<8
1219	// Verify that getAttribute really returns attributes and not properties
1220	// (excepting IE8 booleans)
1221	support.attributes = assert(function( el ) {
1222		el.className = "i";
1223		return !el.getAttribute("className");
1224	});
1225
1226	/* getElement(s)By*
1227	---------------------------------------------------------------------- */
1228
1229	// Check if getElementsByTagName("*") returns only elements
1230	support.getElementsByTagName = assert(function( el ) {
1231		el.appendChild( document.createComment("") );
1232		return !el.getElementsByTagName("*").length;
1233	});
1234
1235	// Support: IE<9
1236	support.getElementsByClassName = rnative.test( document.getElementsByClassName );
1237
1238	// Support: IE<10
1239	// Check if getElementById returns elements by name
1240	// The broken getElementById methods don't pick up programmatically-set names,
1241	// so use a roundabout getElementsByName test
1242	support.getById = assert(function( el ) {
1243		docElem.appendChild( el ).id = expando;
1244		return !document.getElementsByName || !document.getElementsByName( expando ).length;
1245	});
1246
1247	// ID filter and find
1248	if ( support.getById ) {
1249		Expr.filter["ID"] = function( id ) {
1250			var attrId = id.replace( runescape, funescape );
1251			return function( elem ) {
1252				return elem.getAttribute("id") === attrId;
1253			};
1254		};
1255		Expr.find["ID"] = function( id, context ) {
1256			if ( typeof context.getElementById !== "undefined" && documentIsHTML ) {
1257				var elem = context.getElementById( id );
1258				return elem ? [ elem ] : [];
1259			}
1260		};
1261	} else {
1262		Expr.filter["ID"] =  function( id ) {
1263			var attrId = id.replace( runescape, funescape );
1264			return function( elem ) {
1265				var node = typeof elem.getAttributeNode !== "undefined" &&
1266					elem.getAttributeNode("id");
1267				return node && node.value === attrId;
1268			};
1269		};
1270
1271		// Support: IE 6 - 7 only
1272		// getElementById is not reliable as a find shortcut
1273		Expr.find["ID"] = function( id, context ) {
1274			if ( typeof context.getElementById !== "undefined" && documentIsHTML ) {
1275				var node, i, elems,
1276					elem = context.getElementById( id );
1277
1278				if ( elem ) {
1279
1280					// Verify the id attribute
1281					node = elem.getAttributeNode("id");
1282					if ( node && node.value === id ) {
1283						return [ elem ];
1284					}
1285
1286					// Fall back on getElementsByName
1287					elems = context.getElementsByName( id );
1288					i = 0;
1289					while ( (elem = elems[i++]) ) {
1290						node = elem.getAttributeNode("id");
1291						if ( node && node.value === id ) {
1292							return [ elem ];
1293						}
1294					}
1295				}
1296
1297				return [];
1298			}
1299		};
1300	}
1301
1302	// Tag
1303	Expr.find["TAG"] = support.getElementsByTagName ?
1304		function( tag, context ) {
1305			if ( typeof context.getElementsByTagName !== "undefined" ) {
1306				return context.getElementsByTagName( tag );
1307
1308			// DocumentFragment nodes don't have gEBTN
1309			} else if ( support.qsa ) {
1310				return context.querySelectorAll( tag );
1311			}
1312		} :
1313
1314		function( tag, context ) {
1315			var elem,
1316				tmp = [],
1317				i = 0,
1318				// By happy coincidence, a (broken) gEBTN appears on DocumentFragment nodes too
1319				results = context.getElementsByTagName( tag );
1320
1321			// Filter out possible comments
1322			if ( tag === "*" ) {
1323				while ( (elem = results[i++]) ) {
1324					if ( elem.nodeType === 1 ) {
1325						tmp.push( elem );
1326					}
1327				}
1328
1329				return tmp;
1330			}
1331			return results;
1332		};
1333
1334	// Class
1335	Expr.find["CLASS"] = support.getElementsByClassName && function( className, context ) {
1336		if ( typeof context.getElementsByClassName !== "undefined" && documentIsHTML ) {
1337			return context.getElementsByClassName( className );
1338		}
1339	};
1340
1341	/* QSA/matchesSelector
1342	---------------------------------------------------------------------- */
1343
1344	// QSA and matchesSelector support
1345
1346	// matchesSelector(:active) reports false when true (IE9/Opera 11.5)
1347	rbuggyMatches = [];
1348
1349	// qSa(:focus) reports false when true (Chrome 21)
1350	// We allow this because of a bug in IE8/9 that throws an error
1351	// whenever `document.activeElement` is accessed on an iframe
1352	// So, we allow :focus to pass through QSA all the time to avoid the IE error
1353	// See https://bugs.jquery.com/ticket/13378
1354	rbuggyQSA = [];
1355
1356	if ( (support.qsa = rnative.test( document.querySelectorAll )) ) {
1357		// Build QSA regex
1358		// Regex strategy adopted from Diego Perini
1359		assert(function( el ) {
1360			// Select is set to empty string on purpose
1361			// This is to test IE's treatment of not explicitly
1362			// setting a boolean content attribute,
1363			// since its presence should be enough
1364			// https://bugs.jquery.com/ticket/12359
1365			docElem.appendChild( el ).innerHTML = "<a id='" + expando + "'></a>" +
1366				"<select id='" + expando + "-\r\\' msallowcapture=''>" +
1367				"<option selected=''></option></select>";
1368
1369			// Support: IE8, Opera 11-12.16
1370			// Nothing should be selected when empty strings follow ^= or $= or *=
1371			// The test attribute must be unknown in Opera but "safe" for WinRT
1372			// https://msdn.microsoft.com/en-us/library/ie/hh465388.aspx#attribute_section
1373			if ( el.querySelectorAll("[msallowcapture^='']").length ) {
1374				rbuggyQSA.push( "[*^$]=" + whitespace + "*(?:''|\"\")" );
1375			}
1376
1377			// Support: IE8
1378			// Boolean attributes and "value" are not treated correctly
1379			if ( !el.querySelectorAll("[selected]").length ) {
1380				rbuggyQSA.push( "\\[" + whitespace + "*(?:value|" + booleans + ")" );
1381			}
1382
1383			// Support: Chrome<29, Android<4.4, Safari<7.0+, iOS<7.0+, PhantomJS<1.9.8+
1384			if ( !el.querySelectorAll( "[id~=" + expando + "-]" ).length ) {
1385				rbuggyQSA.push("~=");
1386			}
1387
1388			// Webkit/Opera - :checked should return selected option elements
1389			// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
1390			// IE8 throws error here and will not see later tests
1391			if ( !el.querySelectorAll(":checked").length ) {
1392				rbuggyQSA.push(":checked");
1393			}
1394
1395			// Support: Safari 8+, iOS 8+
1396			// https://bugs.webkit.org/show_bug.cgi?id=136851
1397			// In-page `selector#id sibling-combinator selector` fails
1398			if ( !el.querySelectorAll( "a#" + expando + "+*" ).length ) {
1399				rbuggyQSA.push(".#.+[+~]");
1400			}
1401		});
1402
1403		assert(function( el ) {
1404			el.innerHTML = "<a href='' disabled='disabled'></a>" +
1405				"<select disabled='disabled'><option/></select>";
1406
1407			// Support: Windows 8 Native Apps
1408			// The type and name attributes are restricted during .innerHTML assignment
1409			var input = document.createElement("input");
1410			input.setAttribute( "type", "hidden" );
1411			el.appendChild( input ).setAttribute( "name", "D" );
1412
1413			// Support: IE8
1414			// Enforce case-sensitivity of name attribute
1415			if ( el.querySelectorAll("[name=d]").length ) {
1416				rbuggyQSA.push( "name" + whitespace + "*[*^$|!~]?=" );
1417			}
1418
1419			// FF 3.5 - :enabled/:disabled and hidden elements (hidden elements are still enabled)
1420			// IE8 throws error here and will not see later tests
1421			if ( el.querySelectorAll(":enabled").length !== 2 ) {
1422				rbuggyQSA.push( ":enabled", ":disabled" );
1423			}
1424
1425			// Support: IE9-11+
1426			// IE's :disabled selector does not pick up the children of disabled fieldsets
1427			docElem.appendChild( el ).disabled = true;
1428			if ( el.querySelectorAll(":disabled").length !== 2 ) {
1429				rbuggyQSA.push( ":enabled", ":disabled" );
1430			}
1431
1432			// Opera 10-11 does not throw on post-comma invalid pseudos
1433			el.querySelectorAll("*,:x");
1434			rbuggyQSA.push(",.*:");
1435		});
1436	}
1437
1438	if ( (support.matchesSelector = rnative.test( (matches = docElem.matches ||
1439		docElem.webkitMatchesSelector ||
1440		docElem.mozMatchesSelector ||
1441		docElem.oMatchesSelector ||
1442		docElem.msMatchesSelector) )) ) {
1443
1444		assert(function( el ) {
1445			// Check to see if it's possible to do matchesSelector
1446			// on a disconnected node (IE 9)
1447			support.disconnectedMatch = matches.call( el, "*" );
1448
1449			// This should fail with an exception
1450			// Gecko does not error, returns false instead
1451			matches.call( el, "[s!='']:x" );
1452			rbuggyMatches.push( "!=", pseudos );
1453		});
1454	}
1455
1456	rbuggyQSA = rbuggyQSA.length && new RegExp( rbuggyQSA.join("|") );
1457	rbuggyMatches = rbuggyMatches.length && new RegExp( rbuggyMatches.join("|") );
1458
1459	/* Contains
1460	---------------------------------------------------------------------- */
1461	hasCompare = rnative.test( docElem.compareDocumentPosition );
1462
1463	// Element contains another
1464	// Purposefully self-exclusive
1465	// As in, an element does not contain itself
1466	contains = hasCompare || rnative.test( docElem.contains ) ?
1467		function( a, b ) {
1468			var adown = a.nodeType === 9 ? a.documentElement : a,
1469				bup = b && b.parentNode;
1470			return a === bup || !!( bup && bup.nodeType === 1 && (
1471				adown.contains ?
1472					adown.contains( bup ) :
1473					a.compareDocumentPosition && a.compareDocumentPosition( bup ) & 16
1474			));
1475		} :
1476		function( a, b ) {
1477			if ( b ) {
1478				while ( (b = b.parentNode) ) {
1479					if ( b === a ) {
1480						return true;
1481					}
1482				}
1483			}
1484			return false;
1485		};
1486
1487	/* Sorting
1488	---------------------------------------------------------------------- */
1489
1490	// Document order sorting
1491	sortOrder = hasCompare ?
1492	function( a, b ) {
1493
1494		// Flag for duplicate removal
1495		if ( a === b ) {
1496			hasDuplicate = true;
1497			return 0;
1498		}
1499
1500		// Sort on method existence if only one input has compareDocumentPosition
1501		var compare = !a.compareDocumentPosition - !b.compareDocumentPosition;
1502		if ( compare ) {
1503			return compare;
1504		}
1505
1506		// Calculate position if both inputs belong to the same document
1507		compare = ( a.ownerDocument || a ) === ( b.ownerDocument || b ) ?
1508			a.compareDocumentPosition( b ) :
1509
1510			// Otherwise we know they are disconnected
1511			1;
1512
1513		// Disconnected nodes
1514		if ( compare & 1 ||
1515			(!support.sortDetached && b.compareDocumentPosition( a ) === compare) ) {
1516
1517			// Choose the first element that is related to our preferred document
1518			if ( a === document || a.ownerDocument === preferredDoc && contains(preferredDoc, a) ) {
1519				return -1;
1520			}
1521			if ( b === document || b.ownerDocument === preferredDoc && contains(preferredDoc, b) ) {
1522				return 1;
1523			}
1524
1525			// Maintain original order
1526			return sortInput ?
1527				( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) :
1528				0;
1529		}
1530
1531		return compare & 4 ? -1 : 1;
1532	} :
1533	function( a, b ) {
1534		// Exit early if the nodes are identical
1535		if ( a === b ) {
1536			hasDuplicate = true;
1537			return 0;
1538		}
1539
1540		var cur,
1541			i = 0,
1542			aup = a.parentNode,
1543			bup = b.parentNode,
1544			ap = [ a ],
1545			bp = [ b ];
1546
1547		// Parentless nodes are either documents or disconnected
1548		if ( !aup || !bup ) {
1549			return a === document ? -1 :
1550				b === document ? 1 :
1551				aup ? -1 :
1552				bup ? 1 :
1553				sortInput ?
1554				( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) :
1555				0;
1556
1557		// If the nodes are siblings, we can do a quick check
1558		} else if ( aup === bup ) {
1559			return siblingCheck( a, b );
1560		}
1561
1562		// Otherwise we need full lists of their ancestors for comparison
1563		cur = a;
1564		while ( (cur = cur.parentNode) ) {
1565			ap.unshift( cur );
1566		}
1567		cur = b;
1568		while ( (cur = cur.parentNode) ) {
1569			bp.unshift( cur );
1570		}
1571
1572		// Walk down the tree looking for a discrepancy
1573		while ( ap[i] === bp[i] ) {
1574			i++;
1575		}
1576
1577		return i ?
1578			// Do a sibling check if the nodes have a common ancestor
1579			siblingCheck( ap[i], bp[i] ) :
1580
1581			// Otherwise nodes in our document sort first
1582			ap[i] === preferredDoc ? -1 :
1583			bp[i] === preferredDoc ? 1 :
1584			0;
1585	};
1586
1587	return document;
1588};
1589
1590Sizzle.matches = function( expr, elements ) {
1591	return Sizzle( expr, null, null, elements );
1592};
1593
1594Sizzle.matchesSelector = function( elem, expr ) {
1595	// Set document vars if needed
1596	if ( ( elem.ownerDocument || elem ) !== document ) {
1597		setDocument( elem );
1598	}
1599
1600	// Make sure that attribute selectors are quoted
1601	expr = expr.replace( rattributeQuotes, "='$1']" );
1602
1603	if ( support.matchesSelector && documentIsHTML &&
1604		!compilerCache[ expr + " " ] &&
1605		( !rbuggyMatches || !rbuggyMatches.test( expr ) ) &&
1606		( !rbuggyQSA     || !rbuggyQSA.test( expr ) ) ) {
1607
1608		try {
1609			var ret = matches.call( elem, expr );
1610
1611			// IE 9's matchesSelector returns false on disconnected nodes
1612			if ( ret || support.disconnectedMatch ||
1613					// As well, disconnected nodes are said to be in a document
1614					// fragment in IE 9
1615					elem.document && elem.document.nodeType !== 11 ) {
1616				return ret;
1617			}
1618		} catch (e) {}
1619	}
1620
1621	return Sizzle( expr, document, null, [ elem ] ).length > 0;
1622};
1623
1624Sizzle.contains = function( context, elem ) {
1625	// Set document vars if needed
1626	if ( ( context.ownerDocument || context ) !== document ) {
1627		setDocument( context );
1628	}
1629	return contains( context, elem );
1630};
1631
1632Sizzle.attr = function( elem, name ) {
1633	// Set document vars if needed
1634	if ( ( elem.ownerDocument || elem ) !== document ) {
1635		setDocument( elem );
1636	}
1637
1638	var fn = Expr.attrHandle[ name.toLowerCase() ],
1639		// Don't get fooled by Object.prototype properties (jQuery #13807)
1640		val = fn && hasOwn.call( Expr.attrHandle, name.toLowerCase() ) ?
1641			fn( elem, name, !documentIsHTML ) :
1642			undefined;
1643
1644	return val !== undefined ?
1645		val :
1646		support.attributes || !documentIsHTML ?
1647			elem.getAttribute( name ) :
1648			(val = elem.getAttributeNode(name)) && val.specified ?
1649				val.value :
1650				null;
1651};
1652
1653Sizzle.escape = function( sel ) {
1654	return (sel + "").replace( rcssescape, fcssescape );
1655};
1656
1657Sizzle.error = function( msg ) {
1658	throw new Error( "Syntax error, unrecognized expression: " + msg );
1659};
1660
1661/**
1662 * Document sorting and removing duplicates
1663 * @param {ArrayLike} results
1664 */
1665Sizzle.uniqueSort = function( results ) {
1666	var elem,
1667		duplicates = [],
1668		j = 0,
1669		i = 0;
1670
1671	// Unless we *know* we can detect duplicates, assume their presence
1672	hasDuplicate = !support.detectDuplicates;
1673	sortInput = !support.sortStable && results.slice( 0 );
1674	results.sort( sortOrder );
1675
1676	if ( hasDuplicate ) {
1677		while ( (elem = results[i++]) ) {
1678			if ( elem === results[ i ] ) {
1679				j = duplicates.push( i );
1680			}
1681		}
1682		while ( j-- ) {
1683			results.splice( duplicates[ j ], 1 );
1684		}
1685	}
1686
1687	// Clear input after sorting to release objects
1688	// See https://github.com/jquery/sizzle/pull/225
1689	sortInput = null;
1690
1691	return results;
1692};
1693
1694/**
1695 * Utility function for retrieving the text value of an array of DOM nodes
1696 * @param {Array|Element} elem
1697 */
1698getText = Sizzle.getText = function( elem ) {
1699	var node,
1700		ret = "",
1701		i = 0,
1702		nodeType = elem.nodeType;
1703
1704	if ( !nodeType ) {
1705		// If no nodeType, this is expected to be an array
1706		while ( (node = elem[i++]) ) {
1707			// Do not traverse comment nodes
1708			ret += getText( node );
1709		}
1710	} else if ( nodeType === 1 || nodeType === 9 || nodeType === 11 ) {
1711		// Use textContent for elements
1712		// innerText usage removed for consistency of new lines (jQuery #11153)
1713		if ( typeof elem.textContent === "string" ) {
1714			return elem.textContent;
1715		} else {
1716			// Traverse its children
1717			for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
1718				ret += getText( elem );
1719			}
1720		}
1721	} else if ( nodeType === 3 || nodeType === 4 ) {
1722		return elem.nodeValue;
1723	}
1724	// Do not include comment or processing instruction nodes
1725
1726	return ret;
1727};
1728
1729Expr = Sizzle.selectors = {
1730
1731	// Can be adjusted by the user
1732	cacheLength: 50,
1733
1734	createPseudo: markFunction,
1735
1736	match: matchExpr,
1737
1738	attrHandle: {},
1739
1740	find: {},
1741
1742	relative: {
1743		">": { dir: "parentNode", first: true },
1744		" ": { dir: "parentNode" },
1745		"+": { dir: "previousSibling", first: true },
1746		"~": { dir: "previousSibling" }
1747	},
1748
1749	preFilter: {
1750		"ATTR": function( match ) {
1751			match[1] = match[1].replace( runescape, funescape );
1752
1753			// Move the given value to match[3] whether quoted or unquoted
1754			match[3] = ( match[3] || match[4] || match[5] || "" ).replace( runescape, funescape );
1755
1756			if ( match[2] === "~=" ) {
1757				match[3] = " " + match[3] + " ";
1758			}
1759
1760			return match.slice( 0, 4 );
1761		},
1762
1763		"CHILD": function( match ) {
1764			/* matches from matchExpr["CHILD"]
1765				1 type (only|nth|...)
1766				2 what (child|of-type)
1767				3 argument (even|odd|\d*|\d*n([+-]\d+)?|...)
1768				4 xn-component of xn+y argument ([+-]?\d*n|)
1769				5 sign of xn-component
1770				6 x of xn-component
1771				7 sign of y-component
1772				8 y of y-component
1773			*/
1774			match[1] = match[1].toLowerCase();
1775
1776			if ( match[1].slice( 0, 3 ) === "nth" ) {
1777				// nth-* requires argument
1778				if ( !match[3] ) {
1779					Sizzle.error( match[0] );
1780				}
1781
1782				// numeric x and y parameters for Expr.filter.CHILD
1783				// remember that false/true cast respectively to 0/1
1784				match[4] = +( match[4] ? match[5] + (match[6] || 1) : 2 * ( match[3] === "even" || match[3] === "odd" ) );
1785				match[5] = +( ( match[7] + match[8] ) || match[3] === "odd" );
1786
1787			// other types prohibit arguments
1788			} else if ( match[3] ) {
1789				Sizzle.error( match[0] );
1790			}
1791
1792			return match;
1793		},
1794
1795		"PSEUDO": function( match ) {
1796			var excess,
1797				unquoted = !match[6] && match[2];
1798
1799			if ( matchExpr["CHILD"].test( match[0] ) ) {
1800				return null;
1801			}
1802
1803			// Accept quoted arguments as-is
1804			if ( match[3] ) {
1805				match[2] = match[4] || match[5] || "";
1806
1807			// Strip excess characters from unquoted arguments
1808			} else if ( unquoted && rpseudo.test( unquoted ) &&
1809				// Get excess from tokenize (recursively)
1810				(excess = tokenize( unquoted, true )) &&
1811				// advance to the next closing parenthesis
1812				(excess = unquoted.indexOf( ")", unquoted.length - excess ) - unquoted.length) ) {
1813
1814				// excess is a negative index
1815				match[0] = match[0].slice( 0, excess );
1816				match[2] = unquoted.slice( 0, excess );
1817			}
1818
1819			// Return only captures needed by the pseudo filter method (type and argument)
1820			return match.slice( 0, 3 );
1821		}
1822	},
1823
1824	filter: {
1825
1826		"TAG": function( nodeNameSelector ) {
1827			var nodeName = nodeNameSelector.replace( runescape, funescape ).toLowerCase();
1828			return nodeNameSelector === "*" ?
1829				function() { return true; } :
1830				function( elem ) {
1831					return elem.nodeName && elem.nodeName.toLowerCase() === nodeName;
1832				};
1833		},
1834
1835		"CLASS": function( className ) {
1836			var pattern = classCache[ className + " " ];
1837
1838			return pattern ||
1839				(pattern = new RegExp( "(^|" + whitespace + ")" + className + "(" + whitespace + "|$)" )) &&
1840				classCache( className, function( elem ) {
1841					return pattern.test( typeof elem.className === "string" && elem.className || typeof elem.getAttribute !== "undefined" && elem.getAttribute("class") || "" );
1842				});
1843		},
1844
1845		"ATTR": function( name, operator, check ) {
1846			return function( elem ) {
1847				var result = Sizzle.attr( elem, name );
1848
1849				if ( result == null ) {
1850					return operator === "!=";
1851				}
1852				if ( !operator ) {
1853					return true;
1854				}
1855
1856				result += "";
1857
1858				return operator === "=" ? result === check :
1859					operator === "!=" ? result !== check :
1860					operator === "^=" ? check && result.indexOf( check ) === 0 :
1861					operator === "*=" ? check && result.indexOf( check ) > -1 :
1862					operator === "$=" ? check && result.slice( -check.length ) === check :
1863					operator === "~=" ? ( " " + result.replace( rwhitespace, " " ) + " " ).indexOf( check ) > -1 :
1864					operator === "|=" ? result === check || result.slice( 0, check.length + 1 ) === check + "-" :
1865					false;
1866			};
1867		},
1868
1869		"CHILD": function( type, what, argument, first, last ) {
1870			var simple = type.slice( 0, 3 ) !== "nth",
1871				forward = type.slice( -4 ) !== "last",
1872				ofType = what === "of-type";
1873
1874			return first === 1 && last === 0 ?
1875
1876				// Shortcut for :nth-*(n)
1877				function( elem ) {
1878					return !!elem.parentNode;
1879				} :
1880
1881				function( elem, context, xml ) {
1882					var cache, uniqueCache, outerCache, node, nodeIndex, start,
1883						dir = simple !== forward ? "nextSibling" : "previousSibling",
1884						parent = elem.parentNode,
1885						name = ofType && elem.nodeName.toLowerCase(),
1886						useCache = !xml && !ofType,
1887						diff = false;
1888
1889					if ( parent ) {
1890
1891						// :(first|last|only)-(child|of-type)
1892						if ( simple ) {
1893							while ( dir ) {
1894								node = elem;
1895								while ( (node = node[ dir ]) ) {
1896									if ( ofType ?
1897										node.nodeName.toLowerCase() === name :
1898										node.nodeType === 1 ) {
1899
1900										return false;
1901									}
1902								}
1903								// Reverse direction for :only-* (if we haven't yet done so)
1904								start = dir = type === "only" && !start && "nextSibling";
1905							}
1906							return true;
1907						}
1908
1909						start = [ forward ? parent.firstChild : parent.lastChild ];
1910
1911						// non-xml :nth-child(...) stores cache data on `parent`
1912						if ( forward && useCache ) {
1913
1914							// Seek `elem` from a previously-cached index
1915
1916							// ...in a gzip-friendly way
1917							node = parent;
1918							outerCache = node[ expando ] || (node[ expando ] = {});
1919
1920							// Support: IE <9 only
1921							// Defend against cloned attroperties (jQuery gh-1709)
1922							uniqueCache = outerCache[ node.uniqueID ] ||
1923								(outerCache[ node.uniqueID ] = {});
1924
1925							cache = uniqueCache[ type ] || [];
1926							nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ];
1927							diff = nodeIndex && cache[ 2 ];
1928							node = nodeIndex && parent.childNodes[ nodeIndex ];
1929
1930							while ( (node = ++nodeIndex && node && node[ dir ] ||
1931
1932								// Fallback to seeking `elem` from the start
1933								(diff = nodeIndex = 0) || start.pop()) ) {
1934
1935								// When found, cache indexes on `parent` and break
1936								if ( node.nodeType === 1 && ++diff && node === elem ) {
1937									uniqueCache[ type ] = [ dirruns, nodeIndex, diff ];
1938									break;
1939								}
1940							}
1941
1942						} else {
1943							// Use previously-cached element index if available
1944							if ( useCache ) {
1945								// ...in a gzip-friendly way
1946								node = elem;
1947								outerCache = node[ expando ] || (node[ expando ] = {});
1948
1949								// Support: IE <9 only
1950								// Defend against cloned attroperties (jQuery gh-1709)
1951								uniqueCache = outerCache[ node.uniqueID ] ||
1952									(outerCache[ node.uniqueID ] = {});
1953
1954								cache = uniqueCache[ type ] || [];
1955								nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ];
1956								diff = nodeIndex;
1957							}
1958
1959							// xml :nth-child(...)
1960							// or :nth-last-child(...) or :nth(-last)?-of-type(...)
1961							if ( diff === false ) {
1962								// Use the same loop as above to seek `elem` from the start
1963								while ( (node = ++nodeIndex && node && node[ dir ] ||
1964									(diff = nodeIndex = 0) || start.pop()) ) {
1965
1966									if ( ( ofType ?
1967										node.nodeName.toLowerCase() === name :
1968										node.nodeType === 1 ) &&
1969										++diff ) {
1970
1971										// Cache the index of each encountered element
1972										if ( useCache ) {
1973											outerCache = node[ expando ] || (node[ expando ] = {});
1974
1975											// Support: IE <9 only
1976											// Defend against cloned attroperties (jQuery gh-1709)
1977											uniqueCache = outerCache[ node.uniqueID ] ||
1978												(outerCache[ node.uniqueID ] = {});
1979
1980											uniqueCache[ type ] = [ dirruns, diff ];
1981										}
1982
1983										if ( node === elem ) {
1984											break;
1985										}
1986									}
1987								}
1988							}
1989						}
1990
1991						// Incorporate the offset, then check against cycle size
1992						diff -= last;
1993						return diff === first || ( diff % first === 0 && diff / first >= 0 );
1994					}
1995				};
1996		},
1997
1998		"PSEUDO": function( pseudo, argument ) {
1999			// pseudo-class names are case-insensitive
2000			// http://www.w3.org/TR/selectors/#pseudo-classes
2001			// Prioritize by case sensitivity in case custom pseudos are added with uppercase letters
2002			// Remember that setFilters inherits from pseudos
2003			var args,
2004				fn = Expr.pseudos[ pseudo ] || Expr.setFilters[ pseudo.toLowerCase() ] ||
2005					Sizzle.error( "unsupported pseudo: " + pseudo );
2006
2007			// The user may use createPseudo to indicate that
2008			// arguments are needed to create the filter function
2009			// just as Sizzle does
2010			if ( fn[ expando ] ) {
2011				return fn( argument );
2012			}
2013
2014			// But maintain support for old signatures
2015			if ( fn.length > 1 ) {
2016				args = [ pseudo, pseudo, "", argument ];
2017				return Expr.setFilters.hasOwnProperty( pseudo.toLowerCase() ) ?
2018					markFunction(function( seed, matches ) {
2019						var idx,
2020							matched = fn( seed, argument ),
2021							i = matched.length;
2022						while ( i-- ) {
2023							idx = indexOf( seed, matched[i] );
2024							seed[ idx ] = !( matches[ idx ] = matched[i] );
2025						}
2026					}) :
2027					function( elem ) {
2028						return fn( elem, 0, args );
2029					};
2030			}
2031
2032			return fn;
2033		}
2034	},
2035
2036	pseudos: {
2037		// Potentially complex pseudos
2038		"not": markFunction(function( selector ) {
2039			// Trim the selector passed to compile
2040			// to avoid treating leading and trailing
2041			// spaces as combinators
2042			var input = [],
2043				results = [],
2044				matcher = compile( selector.replace( rtrim, "$1" ) );
2045
2046			return matcher[ expando ] ?
2047				markFunction(function( seed, matches, context, xml ) {
2048					var elem,
2049						unmatched = matcher( seed, null, xml, [] ),
2050						i = seed.length;
2051
2052					// Match elements unmatched by `matcher`
2053					while ( i-- ) {
2054						if ( (elem = unmatched[i]) ) {
2055							seed[i] = !(matches[i] = elem);
2056						}
2057					}
2058				}) :
2059				function( elem, context, xml ) {
2060					input[0] = elem;
2061					matcher( input, null, xml, results );
2062					// Don't keep the element (issue #299)
2063					input[0] = null;
2064					return !results.pop();
2065				};
2066		}),
2067
2068		"has": markFunction(function( selector ) {
2069			return function( elem ) {
2070				return Sizzle( selector, elem ).length > 0;
2071			};
2072		}),
2073
2074		"contains": markFunction(function( text ) {
2075			text = text.replace( runescape, funescape );
2076			return function( elem ) {
2077				return ( elem.textContent || elem.innerText || getText( elem ) ).indexOf( text ) > -1;
2078			};
2079		}),
2080
2081		// "Whether an element is represented by a :lang() selector
2082		// is based solely on the element's language value
2083		// being equal to the identifier C,
2084		// or beginning with the identifier C immediately followed by "-".
2085		// The matching of C against the element's language value is performed case-insensitively.
2086		// The identifier C does not have to be a valid language name."
2087		// http://www.w3.org/TR/selectors/#lang-pseudo
2088		"lang": markFunction( function( lang ) {
2089			// lang value must be a valid identifier
2090			if ( !ridentifier.test(lang || "") ) {
2091				Sizzle.error( "unsupported lang: " + lang );
2092			}
2093			lang = lang.replace( runescape, funescape ).toLowerCase();
2094			return function( elem ) {
2095				var elemLang;
2096				do {
2097					if ( (elemLang = documentIsHTML ?
2098						elem.lang :
2099						elem.getAttribute("xml:lang") || elem.getAttribute("lang")) ) {
2100
2101						elemLang = elemLang.toLowerCase();
2102						return elemLang === lang || elemLang.indexOf( lang + "-" ) === 0;
2103					}
2104				} while ( (elem = elem.parentNode) && elem.nodeType === 1 );
2105				return false;
2106			};
2107		}),
2108
2109		// Miscellaneous
2110		"target": function( elem ) {
2111			var hash = window.location && window.location.hash;
2112			return hash && hash.slice( 1 ) === elem.id;
2113		},
2114
2115		"root": function( elem ) {
2116			return elem === docElem;
2117		},
2118
2119		"focus": function( elem ) {
2120			return elem === document.activeElement && (!document.hasFocus || document.hasFocus()) && !!(elem.type || elem.href || ~elem.tabIndex);
2121		},
2122
2123		// Boolean properties
2124		"enabled": createDisabledPseudo( false ),
2125		"disabled": createDisabledPseudo( true ),
2126
2127		"checked": function( elem ) {
2128			// In CSS3, :checked should return both checked and selected elements
2129			// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
2130			var nodeName = elem.nodeName.toLowerCase();
2131			return (nodeName === "input" && !!elem.checked) || (nodeName === "option" && !!elem.selected);
2132		},
2133
2134		"selected": function( elem ) {
2135			// Accessing this property makes selected-by-default
2136			// options in Safari work properly
2137			if ( elem.parentNode ) {
2138				elem.parentNode.selectedIndex;
2139			}
2140
2141			return elem.selected === true;
2142		},
2143
2144		// Contents
2145		"empty": function( elem ) {
2146			// http://www.w3.org/TR/selectors/#empty-pseudo
2147			// :empty is negated by element (1) or content nodes (text: 3; cdata: 4; entity ref: 5),
2148			//   but not by others (comment: 8; processing instruction: 7; etc.)
2149			// nodeType < 6 works because attributes (2) do not appear as children
2150			for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
2151				if ( elem.nodeType < 6 ) {
2152					return false;
2153				}
2154			}
2155			return true;
2156		},
2157
2158		"parent": function( elem ) {
2159			return !Expr.pseudos["empty"]( elem );
2160		},
2161
2162		// Element/input types
2163		"header": function( elem ) {
2164			return rheader.test( elem.nodeName );
2165		},
2166
2167		"input": function( elem ) {
2168			return rinputs.test( elem.nodeName );
2169		},
2170
2171		"button": function( elem ) {
2172			var name = elem.nodeName.toLowerCase();
2173			return name === "input" && elem.type === "button" || name === "button";
2174		},
2175
2176		"text": function( elem ) {
2177			var attr;
2178			return elem.nodeName.toLowerCase() === "input" &&
2179				elem.type === "text" &&
2180
2181				// Support: IE<8
2182				// New HTML5 attribute values (e.g., "search") appear with elem.type === "text"
2183				( (attr = elem.getAttribute("type")) == null || attr.toLowerCase() === "text" );
2184		},
2185
2186		// Position-in-collection
2187		"first": createPositionalPseudo(function() {
2188			return [ 0 ];
2189		}),
2190
2191		"last": createPositionalPseudo(function( matchIndexes, length ) {
2192			return [ length - 1 ];
2193		}),
2194
2195		"eq": createPositionalPseudo(function( matchIndexes, length, argument ) {
2196			return [ argument < 0 ? argument + length : argument ];
2197		}),
2198
2199		"even": createPositionalPseudo(function( matchIndexes, length ) {
2200			var i = 0;
2201			for ( ; i < length; i += 2 ) {
2202				matchIndexes.push( i );
2203			}
2204			return matchIndexes;
2205		}),
2206
2207		"odd": createPositionalPseudo(function( matchIndexes, length ) {
2208			var i = 1;
2209			for ( ; i < length; i += 2 ) {
2210				matchIndexes.push( i );
2211			}
2212			return matchIndexes;
2213		}),
2214
2215		"lt": createPositionalPseudo(function( matchIndexes, length, argument ) {
2216			var i = argument < 0 ? argument + length : argument;
2217			for ( ; --i >= 0; ) {
2218				matchIndexes.push( i );
2219			}
2220			return matchIndexes;
2221		}),
2222
2223		"gt": createPositionalPseudo(function( matchIndexes, length, argument ) {
2224			var i = argument < 0 ? argument + length : argument;
2225			for ( ; ++i < length; ) {
2226				matchIndexes.push( i );
2227			}
2228			return matchIndexes;
2229		})
2230	}
2231};
2232
2233Expr.pseudos["nth"] = Expr.pseudos["eq"];
2234
2235// Add button/input type pseudos
2236for ( i in { radio: true, checkbox: true, file: true, password: true, image: true } ) {
2237	Expr.pseudos[ i ] = createInputPseudo( i );
2238}
2239for ( i in { submit: true, reset: true } ) {
2240	Expr.pseudos[ i ] = createButtonPseudo( i );
2241}
2242
2243// Easy API for creating new setFilters
2244function setFilters() {}
2245setFilters.prototype = Expr.filters = Expr.pseudos;
2246Expr.setFilters = new setFilters();
2247
2248tokenize = Sizzle.tokenize = function( selector, parseOnly ) {
2249	var matched, match, tokens, type,
2250		soFar, groups, preFilters,
2251		cached = tokenCache[ selector + " " ];
2252
2253	if ( cached ) {
2254		return parseOnly ? 0 : cached.slice( 0 );
2255	}
2256
2257	soFar = selector;
2258	groups = [];
2259	preFilters = Expr.preFilter;
2260
2261	while ( soFar ) {
2262
2263		// Comma and first run
2264		if ( !matched || (match = rcomma.exec( soFar )) ) {
2265			if ( match ) {
2266				// Don't consume trailing commas as valid
2267				soFar = soFar.slice( match[0].length ) || soFar;
2268			}
2269			groups.push( (tokens = []) );
2270		}
2271
2272		matched = false;
2273
2274		// Combinators
2275		if ( (match = rcombinators.exec( soFar )) ) {
2276			matched = match.shift();
2277			tokens.push({
2278				value: matched,
2279				// Cast descendant combinators to space
2280				type: match[0].replace( rtrim, " " )
2281			});
2282			soFar = soFar.slice( matched.length );
2283		}
2284
2285		// Filters
2286		for ( type in Expr.filter ) {
2287			if ( (match = matchExpr[ type ].exec( soFar )) && (!preFilters[ type ] ||
2288				(match = preFilters[ type ]( match ))) ) {
2289				matched = match.shift();
2290				tokens.push({
2291					value: matched,
2292					type: type,
2293					matches: match
2294				});
2295				soFar = soFar.slice( matched.length );
2296			}
2297		}
2298
2299		if ( !matched ) {
2300			break;
2301		}
2302	}
2303
2304	// Return the length of the invalid excess
2305	// if we're just parsing
2306	// Otherwise, throw an error or return tokens
2307	return parseOnly ?
2308		soFar.length :
2309		soFar ?
2310			Sizzle.error( selector ) :
2311			// Cache the tokens
2312			tokenCache( selector, groups ).slice( 0 );
2313};
2314
2315function toSelector( tokens ) {
2316	var i = 0,
2317		len = tokens.length,
2318		selector = "";
2319	for ( ; i < len; i++ ) {
2320		selector += tokens[i].value;
2321	}
2322	return selector;
2323}
2324
2325function addCombinator( matcher, combinator, base ) {
2326	var dir = combinator.dir,
2327		skip = combinator.next,
2328		key = skip || dir,
2329		checkNonElements = base && key === "parentNode",
2330		doneName = done++;
2331
2332	return combinator.first ?
2333		// Check against closest ancestor/preceding element
2334		function( elem, context, xml ) {
2335			while ( (elem = elem[ dir ]) ) {
2336				if ( elem.nodeType === 1 || checkNonElements ) {
2337					return matcher( elem, context, xml );
2338				}
2339			}
2340			return false;
2341		} :
2342
2343		// Check against all ancestor/preceding elements
2344		function( elem, context, xml ) {
2345			var oldCache, uniqueCache, outerCache,
2346				newCache = [ dirruns, doneName ];
2347
2348			// We can't set arbitrary data on XML nodes, so they don't benefit from combinator caching
2349			if ( xml ) {
2350				while ( (elem = elem[ dir ]) ) {
2351					if ( elem.nodeType === 1 || checkNonElements ) {
2352						if ( matcher( elem, context, xml ) ) {
2353							return true;
2354						}
2355					}
2356				}
2357			} else {
2358				while ( (elem = elem[ dir ]) ) {
2359					if ( elem.nodeType === 1 || checkNonElements ) {
2360						outerCache = elem[ expando ] || (elem[ expando ] = {});
2361
2362						// Support: IE <9 only
2363						// Defend against cloned attroperties (jQuery gh-1709)
2364						uniqueCache = outerCache[ elem.uniqueID ] || (outerCache[ elem.uniqueID ] = {});
2365
2366						if ( skip && skip === elem.nodeName.toLowerCase() ) {
2367							elem = elem[ dir ] || elem;
2368						} else if ( (oldCache = uniqueCache[ key ]) &&
2369							oldCache[ 0 ] === dirruns && oldCache[ 1 ] === doneName ) {
2370
2371							// Assign to newCache so results back-propagate to previous elements
2372							return (newCache[ 2 ] = oldCache[ 2 ]);
2373						} else {
2374							// Reuse newcache so results back-propagate to previous elements
2375							uniqueCache[ key ] = newCache;
2376
2377							// A match means we're done; a fail means we have to keep checking
2378							if ( (newCache[ 2 ] = matcher( elem, context, xml )) ) {
2379								return true;
2380							}
2381						}
2382					}
2383				}
2384			}
2385			return false;
2386		};
2387}
2388
2389function elementMatcher( matchers ) {
2390	return matchers.length > 1 ?
2391		function( elem, context, xml ) {
2392			var i = matchers.length;
2393			while ( i-- ) {
2394				if ( !matchers[i]( elem, context, xml ) ) {
2395					return false;
2396				}
2397			}
2398			return true;
2399		} :
2400		matchers[0];
2401}
2402
2403function multipleContexts( selector, contexts, results ) {
2404	var i = 0,
2405		len = contexts.length;
2406	for ( ; i < len; i++ ) {
2407		Sizzle( selector, contexts[i], results );
2408	}
2409	return results;
2410}
2411
2412function condense( unmatched, map, filter, context, xml ) {
2413	var elem,
2414		newUnmatched = [],
2415		i = 0,
2416		len = unmatched.length,
2417		mapped = map != null;
2418
2419	for ( ; i < len; i++ ) {
2420		if ( (elem = unmatched[i]) ) {
2421			if ( !filter || filter( elem, context, xml ) ) {
2422				newUnmatched.push( elem );
2423				if ( mapped ) {
2424					map.push( i );
2425				}
2426			}
2427		}
2428	}
2429
2430	return newUnmatched;
2431}
2432
2433function setMatcher( preFilter, selector, matcher, postFilter, postFinder, postSelector ) {
2434	if ( postFilter && !postFilter[ expando ] ) {
2435		postFilter = setMatcher( postFilter );
2436	}
2437	if ( postFinder && !postFinder[ expando ] ) {
2438		postFinder = setMatcher( postFinder, postSelector );
2439	}
2440	return markFunction(function( seed, results, context, xml ) {
2441		var temp, i, elem,
2442			preMap = [],
2443			postMap = [],
2444			preexisting = results.length,
2445
2446			// Get initial elements from seed or context
2447			elems = seed || multipleContexts( selector || "*", context.nodeType ? [ context ] : context, [] ),
2448
2449			// Prefilter to get matcher input, preserving a map for seed-results synchronization
2450			matcherIn = preFilter && ( seed || !selector ) ?
2451				condense( elems, preMap, preFilter, context, xml ) :
2452				elems,
2453
2454			matcherOut = matcher ?
2455				// If we have a postFinder, or filtered seed, or non-seed postFilter or preexisting results,
2456				postFinder || ( seed ? preFilter : preexisting || postFilter ) ?
2457
2458					// ...intermediate processing is necessary
2459					[] :
2460
2461					// ...otherwise use results directly
2462					results :
2463				matcherIn;
2464
2465		// Find primary matches
2466		if ( matcher ) {
2467			matcher( matcherIn, matcherOut, context, xml );
2468		}
2469
2470		// Apply postFilter
2471		if ( postFilter ) {
2472			temp = condense( matcherOut, postMap );
2473			postFilter( temp, [], context, xml );
2474
2475			// Un-match failing elements by moving them back to matcherIn
2476			i = temp.length;
2477			while ( i-- ) {
2478				if ( (elem = temp[i]) ) {
2479					matcherOut[ postMap[i] ] = !(matcherIn[ postMap[i] ] = elem);
2480				}
2481			}
2482		}
2483
2484		if ( seed ) {
2485			if ( postFinder || preFilter ) {
2486				if ( postFinder ) {
2487					// Get the final matcherOut by condensing this intermediate into postFinder contexts
2488					temp = [];
2489					i = matcherOut.length;
2490					while ( i-- ) {
2491						if ( (elem = matcherOut[i]) ) {
2492							// Restore matcherIn since elem is not yet a final match
2493							temp.push( (matcherIn[i] = elem) );
2494						}
2495					}
2496					postFinder( null, (matcherOut = []), temp, xml );
2497				}
2498
2499				// Move matched elements from seed to results to keep them synchronized
2500				i = matcherOut.length;
2501				while ( i-- ) {
2502					if ( (elem = matcherOut[i]) &&
2503						(temp = postFinder ? indexOf( seed, elem ) : preMap[i]) > -1 ) {
2504
2505						seed[temp] = !(results[temp] = elem);
2506					}
2507				}
2508			}
2509
2510		// Add elements to results, through postFinder if defined
2511		} else {
2512			matcherOut = condense(
2513				matcherOut === results ?
2514					matcherOut.splice( preexisting, matcherOut.length ) :
2515					matcherOut
2516			);
2517			if ( postFinder ) {
2518				postFinder( null, results, matcherOut, xml );
2519			} else {
2520				push.apply( results, matcherOut );
2521			}
2522		}
2523	});
2524}
2525
2526function matcherFromTokens( tokens ) {
2527	var checkContext, matcher, j,
2528		len = tokens.length,
2529		leadingRelative = Expr.relative[ tokens[0].type ],
2530		implicitRelative = leadingRelative || Expr.relative[" "],
2531		i = leadingRelative ? 1 : 0,
2532
2533		// The foundational matcher ensures that elements are reachable from top-level context(s)
2534		matchContext = addCombinator( function( elem ) {
2535			return elem === checkContext;
2536		}, implicitRelative, true ),
2537		matchAnyContext = addCombinator( function( elem ) {
2538			return indexOf( checkContext, elem ) > -1;
2539		}, implicitRelative, true ),
2540		matchers = [ function( elem, context, xml ) {
2541			var ret = ( !leadingRelative && ( xml || context !== outermostContext ) ) || (
2542				(checkContext = context).nodeType ?
2543					matchContext( elem, context, xml ) :
2544					matchAnyContext( elem, context, xml ) );
2545			// Avoid hanging onto element (issue #299)
2546			checkContext = null;
2547			return ret;
2548		} ];
2549
2550	for ( ; i < len; i++ ) {
2551		if ( (matcher = Expr.relative[ tokens[i].type ]) ) {
2552			matchers = [ addCombinator(elementMatcher( matchers ), matcher) ];
2553		} else {
2554			matcher = Expr.filter[ tokens[i].type ].apply( null, tokens[i].matches );
2555
2556			// Return special upon seeing a positional matcher
2557			if ( matcher[ expando ] ) {
2558				// Find the next relative operator (if any) for proper handling
2559				j = ++i;
2560				for ( ; j < len; j++ ) {
2561					if ( Expr.relative[ tokens[j].type ] ) {
2562						break;
2563					}
2564				}
2565				return setMatcher(
2566					i > 1 && elementMatcher( matchers ),
2567					i > 1 && toSelector(
2568						// If the preceding token was a descendant combinator, insert an implicit any-element `*`
2569						tokens.slice( 0, i - 1 ).concat({ value: tokens[ i - 2 ].type === " " ? "*" : "" })
2570					).replace( rtrim, "$1" ),
2571					matcher,
2572					i < j && matcherFromTokens( tokens.slice( i, j ) ),
2573					j < len && matcherFromTokens( (tokens = tokens.slice( j )) ),
2574					j < len && toSelector( tokens )
2575				);
2576			}
2577			matchers.push( matcher );
2578		}
2579	}
2580
2581	return elementMatcher( matchers );
2582}
2583
2584function matcherFromGroupMatchers( elementMatchers, setMatchers ) {
2585	var bySet = setMatchers.length > 0,
2586		byElement = elementMatchers.length > 0,
2587		superMatcher = function( seed, context, xml, results, outermost ) {
2588			var elem, j, matcher,
2589				matchedCount = 0,
2590				i = "0",
2591				unmatched = seed && [],
2592				setMatched = [],
2593				contextBackup = outermostContext,
2594				// We must always have either seed elements or outermost context
2595				elems = seed || byElement && Expr.find["TAG"]( "*", outermost ),
2596				// Use integer dirruns iff this is the outermost matcher
2597				dirrunsUnique = (dirruns += contextBackup == null ? 1 : Math.random() || 0.1),
2598				len = elems.length;
2599
2600			if ( outermost ) {
2601				outermostContext = context === document || context || outermost;
2602			}
2603
2604			// Add elements passing elementMatchers directly to results
2605			// Support: IE<9, Safari
2606			// Tolerate NodeList properties (IE: "length"; Safari: <number>) matching elements by id
2607			for ( ; i !== len && (elem = elems[i]) != null; i++ ) {
2608				if ( byElement && elem ) {
2609					j = 0;
2610					if ( !context && elem.ownerDocument !== document ) {
2611						setDocument( elem );
2612						xml = !documentIsHTML;
2613					}
2614					while ( (matcher = elementMatchers[j++]) ) {
2615						if ( matcher( elem, context || document, xml) ) {
2616							results.push( elem );
2617							break;
2618						}
2619					}
2620					if ( outermost ) {
2621						dirruns = dirrunsUnique;
2622					}
2623				}
2624
2625				// Track unmatched elements for set filters
2626				if ( bySet ) {
2627					// They will have gone through all possible matchers
2628					if ( (elem = !matcher && elem) ) {
2629						matchedCount--;
2630					}
2631
2632					// Lengthen the array for every element, matched or not
2633					if ( seed ) {
2634						unmatched.push( elem );
2635					}
2636				}
2637			}
2638
2639			// `i` is now the count of elements visited above, and adding it to `matchedCount`
2640			// makes the latter nonnegative.
2641			matchedCount += i;
2642
2643			// Apply set filters to unmatched elements
2644			// NOTE: This can be skipped if there are no unmatched elements (i.e., `matchedCount`
2645			// equals `i`), unless we didn't visit _any_ elements in the above loop because we have
2646			// no element matchers and no seed.
2647			// Incrementing an initially-string "0" `i` allows `i` to remain a string only in that
2648			// case, which will result in a "00" `matchedCount` that differs from `i` but is also
2649			// numerically zero.
2650			if ( bySet && i !== matchedCount ) {
2651				j = 0;
2652				while ( (matcher = setMatchers[j++]) ) {
2653					matcher( unmatched, setMatched, context, xml );
2654				}
2655
2656				if ( seed ) {
2657					// Reintegrate element matches to eliminate the need for sorting
2658					if ( matchedCount > 0 ) {
2659						while ( i-- ) {
2660							if ( !(unmatched[i] || setMatched[i]) ) {
2661								setMatched[i] = pop.call( results );
2662							}
2663						}
2664					}
2665
2666					// Discard index placeholder values to get only actual matches
2667					setMatched = condense( setMatched );
2668				}
2669
2670				// Add matches to results
2671				push.apply( results, setMatched );
2672
2673				// Seedless set matches succeeding multiple successful matchers stipulate sorting
2674				if ( outermost && !seed && setMatched.length > 0 &&
2675					( matchedCount + setMatchers.length ) > 1 ) {
2676
2677					Sizzle.uniqueSort( results );
2678				}
2679			}
2680
2681			// Override manipulation of globals by nested matchers
2682			if ( outermost ) {
2683				dirruns = dirrunsUnique;
2684				outermostContext = contextBackup;
2685			}
2686
2687			return unmatched;
2688		};
2689
2690	return bySet ?
2691		markFunction( superMatcher ) :
2692		superMatcher;
2693}
2694
2695compile = Sizzle.compile = function( selector, match /* Internal Use Only */ ) {
2696	var i,
2697		setMatchers = [],
2698		elementMatchers = [],
2699		cached = compilerCache[ selector + " " ];
2700
2701	if ( !cached ) {
2702		// Generate a function of recursive functions that can be used to check each element
2703		if ( !match ) {
2704			match = tokenize( selector );
2705		}
2706		i = match.length;
2707		while ( i-- ) {
2708			cached = matcherFromTokens( match[i] );
2709			if ( cached[ expando ] ) {
2710				setMatchers.push( cached );
2711			} else {
2712				elementMatchers.push( cached );
2713			}
2714		}
2715
2716		// Cache the compiled function
2717		cached = compilerCache( selector, matcherFromGroupMatchers( elementMatchers, setMatchers ) );
2718
2719		// Save selector and tokenization
2720		cached.selector = selector;
2721	}
2722	return cached;
2723};
2724
2725/**
2726 * A low-level selection function that works with Sizzle's compiled
2727 *  selector functions
2728 * @param {String|Function} selector A selector or a pre-compiled
2729 *  selector function built with Sizzle.compile
2730 * @param {Element} context
2731 * @param {Array} [results]
2732 * @param {Array} [seed] A set of elements to match against
2733 */
2734select = Sizzle.select = function( selector, context, results, seed ) {
2735	var i, tokens, token, type, find,
2736		compiled = typeof selector === "function" && selector,
2737		match = !seed && tokenize( (selector = compiled.selector || selector) );
2738
2739	results = results || [];
2740
2741	// Try to minimize operations if there is only one selector in the list and no seed
2742	// (the latter of which guarantees us context)
2743	if ( match.length === 1 ) {
2744
2745		// Reduce context if the leading compound selector is an ID
2746		tokens = match[0] = match[0].slice( 0 );
2747		if ( tokens.length > 2 && (token = tokens[0]).type === "ID" &&
2748				context.nodeType === 9 && documentIsHTML && Expr.relative[ tokens[1].type ] ) {
2749
2750			context = ( Expr.find["ID"]( token.matches[0].replace(runescape, funescape), context ) || [] )[0];
2751			if ( !context ) {
2752				return results;
2753
2754			// Precompiled matchers will still verify ancestry, so step up a level
2755			} else if ( compiled ) {
2756				context = context.parentNode;
2757			}
2758
2759			selector = selector.slice( tokens.shift().value.length );
2760		}
2761
2762		// Fetch a seed set for right-to-left matching
2763		i = matchExpr["needsContext"].test( selector ) ? 0 : tokens.length;
2764		while ( i-- ) {
2765			token = tokens[i];
2766
2767			// Abort if we hit a combinator
2768			if ( Expr.relative[ (type = token.type) ] ) {
2769				break;
2770			}
2771			if ( (find = Expr.find[ type ]) ) {
2772				// Search, expanding context for leading sibling combinators
2773				if ( (seed = find(
2774					token.matches[0].replace( runescape, funescape ),
2775					rsibling.test( tokens[0].type ) && testContext( context.parentNode ) || context
2776				)) ) {
2777
2778					// If seed is empty or no tokens remain, we can return early
2779					tokens.splice( i, 1 );
2780					selector = seed.length && toSelector( tokens );
2781					if ( !selector ) {
2782						push.apply( results, seed );
2783						return results;
2784					}
2785
2786					break;
2787				}
2788			}
2789		}
2790	}
2791
2792	// Compile and execute a filtering function if one is not provided
2793	// Provide `match` to avoid retokenization if we modified the selector above
2794	( compiled || compile( selector, match ) )(
2795		seed,
2796		context,
2797		!documentIsHTML,
2798		results,
2799		!context || rsibling.test( selector ) && testContext( context.parentNode ) || context
2800	);
2801	return results;
2802};
2803
2804// One-time assignments
2805
2806// Sort stability
2807support.sortStable = expando.split("").sort( sortOrder ).join("") === expando;
2808
2809// Support: Chrome 14-35+
2810// Always assume duplicates if they aren't passed to the comparison function
2811support.detectDuplicates = !!hasDuplicate;
2812
2813// Initialize against the default document
2814setDocument();
2815
2816// Support: Webkit<537.32 - Safari 6.0.3/Chrome 25 (fixed in Chrome 27)
2817// Detached nodes confoundingly follow *each other*
2818support.sortDetached = assert(function( el ) {
2819	// Should return 1, but returns 4 (following)
2820	return el.compareDocumentPosition( document.createElement("fieldset") ) & 1;
2821});
2822
2823// Support: IE<8
2824// Prevent attribute/property "interpolation"
2825// https://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx
2826if ( !assert(function( el ) {
2827	el.innerHTML = "<a href='#'></a>";
2828	return el.firstChild.getAttribute("href") === "#" ;
2829}) ) {
2830	addHandle( "type|href|height|width", function( elem, name, isXML ) {
2831		if ( !isXML ) {
2832			return elem.getAttribute( name, name.toLowerCase() === "type" ? 1 : 2 );
2833		}
2834	});
2835}
2836
2837// Support: IE<9
2838// Use defaultValue in place of getAttribute("value")
2839if ( !support.attributes || !assert(function( el ) {
2840	el.innerHTML = "<input/>";
2841	el.firstChild.setAttribute( "value", "" );
2842	return el.firstChild.getAttribute( "value" ) === "";
2843}) ) {
2844	addHandle( "value", function( elem, name, isXML ) {
2845		if ( !isXML && elem.nodeName.toLowerCase() === "input" ) {
2846			return elem.defaultValue;
2847		}
2848	});
2849}
2850
2851// Support: IE<9
2852// Use getAttributeNode to fetch booleans when getAttribute lies
2853if ( !assert(function( el ) {
2854	return el.getAttribute("disabled") == null;
2855}) ) {
2856	addHandle( booleans, function( elem, name, isXML ) {
2857		var val;
2858		if ( !isXML ) {
2859			return elem[ name ] === true ? name.toLowerCase() :
2860					(val = elem.getAttributeNode( name )) && val.specified ?
2861					val.value :
2862				null;
2863		}
2864	});
2865}
2866
2867return Sizzle;
2868
2869})( window );
2870
2871
2872
2873jQuery.find = Sizzle;
2874jQuery.expr = Sizzle.selectors;
2875
2876// Deprecated
2877jQuery.expr[ ":" ] = jQuery.expr.pseudos;
2878jQuery.uniqueSort = jQuery.unique = Sizzle.uniqueSort;
2879jQuery.text = Sizzle.getText;
2880jQuery.isXMLDoc = Sizzle.isXML;
2881jQuery.contains = Sizzle.contains;
2882jQuery.escapeSelector = Sizzle.escape;
2883
2884
2885
2886
2887var dir = function( elem, dir, until ) {
2888	var matched = [],
2889		truncate = until !== undefined;
2890
2891	while ( ( elem = elem[ dir ] ) && elem.nodeType !== 9 ) {
2892		if ( elem.nodeType === 1 ) {
2893			if ( truncate && jQuery( elem ).is( until ) ) {
2894				break;
2895			}
2896			matched.push( elem );
2897		}
2898	}
2899	return matched;
2900};
2901
2902
2903var siblings = function( n, elem ) {
2904	var matched = [];
2905
2906	for ( ; n; n = n.nextSibling ) {
2907		if ( n.nodeType === 1 && n !== elem ) {
2908			matched.push( n );
2909		}
2910	}
2911
2912	return matched;
2913};
2914
2915
2916var rneedsContext = jQuery.expr.match.needsContext;
2917
2918var rsingleTag = ( /^<([a-z][^\/\0>:\x20\t\r\n\f]*)[\x20\t\r\n\f]*\/?>(?:<\/\1>|)$/i );
2919
2920
2921
2922var risSimple = /^.[^:#\[\.,]*$/;
2923
2924// Implement the identical functionality for filter and not
2925function winnow( elements, qualifier, not ) {
2926	if ( jQuery.isFunction( qualifier ) ) {
2927		return jQuery.grep( elements, function( elem, i ) {
2928			return !!qualifier.call( elem, i, elem ) !== not;
2929		} );
2930	}
2931
2932	// Single element
2933	if ( qualifier.nodeType ) {
2934		return jQuery.grep( elements, function( elem ) {
2935			return ( elem === qualifier ) !== not;
2936		} );
2937	}
2938
2939	// Arraylike of elements (jQuery, arguments, Array)
2940	if ( typeof qualifier !== "string" ) {
2941		return jQuery.grep( elements, function( elem ) {
2942			return ( indexOf.call( qualifier, elem ) > -1 ) !== not;
2943		} );
2944	}
2945
2946	// Simple selector that can be filtered directly, removing non-Elements
2947	if ( risSimple.test( qualifier ) ) {
2948		return jQuery.filter( qualifier, elements, not );
2949	}
2950
2951	// Complex selector, compare the two sets, removing non-Elements
2952	qualifier = jQuery.filter( qualifier, elements );
2953	return jQuery.grep( elements, function( elem ) {
2954		return ( indexOf.call( qualifier, elem ) > -1 ) !== not && elem.nodeType === 1;
2955	} );
2956}
2957
2958jQuery.filter = function( expr, elems, not ) {
2959	var elem = elems[ 0 ];
2960
2961	if ( not ) {
2962		expr = ":not(" + expr + ")";
2963	}
2964
2965	if ( elems.length === 1 && elem.nodeType === 1 ) {
2966		return jQuery.find.matchesSelector( elem, expr ) ? [ elem ] : [];
2967	}
2968
2969	return jQuery.find.matches( expr, jQuery.grep( elems, function( elem ) {
2970		return elem.nodeType === 1;
2971	} ) );
2972};
2973
2974jQuery.fn.extend( {
2975	find: function( selector ) {
2976		var i, ret,
2977			len = this.length,
2978			self = this;
2979
2980		if ( typeof selector !== "string" ) {
2981			return this.pushStack( jQuery( selector ).filter( function() {
2982				for ( i = 0; i < len; i++ ) {
2983					if ( jQuery.contains( self[ i ], this ) ) {
2984						return true;
2985					}
2986				}
2987			} ) );
2988		}
2989
2990		ret = this.pushStack( [] );
2991
2992		for ( i = 0; i < len; i++ ) {
2993			jQuery.find( selector, self[ i ], ret );
2994		}
2995
2996		return len > 1 ? jQuery.uniqueSort( ret ) : ret;
2997	},
2998	filter: function( selector ) {
2999		return this.pushStack( winnow( this, selector || [], false ) );
3000	},
3001	not: function( selector ) {
3002		return this.pushStack( winnow( this, selector || [], true ) );
3003	},
3004	is: function( selector ) {
3005		return !!winnow(
3006			this,
3007
3008			// If this is a positional/relative selector, check membership in the returned set
3009			// so $("p:first").is("p:last") won't return true for a doc with two "p".
3010			typeof selector === "string" && rneedsContext.test( selector ) ?
3011				jQuery( selector ) :
3012				selector || [],
3013			false
3014		).length;
3015	}
3016} );
3017
3018
3019// Initialize a jQuery object
3020
3021
3022// A central reference to the root jQuery(document)
3023var rootjQuery,
3024
3025	// A simple way to check for HTML strings
3026	// Prioritize #id over <tag> to avoid XSS via location.hash (#9521)
3027	// Strict HTML recognition (#11290: must start with <)
3028	// Shortcut simple #id case for speed
3029	rquickExpr = /^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]+))$/,
3030
3031	init = jQuery.fn.init = function( selector, context, root ) {
3032		var match, elem;
3033
3034		// HANDLE: $(""), $(null), $(undefined), $(false)
3035		if ( !selector ) {
3036			return this;
3037		}
3038
3039		// Method init() accepts an alternate rootjQuery
3040		// so migrate can support jQuery.sub (gh-2101)
3041		root = root || rootjQuery;
3042
3043		// Handle HTML strings
3044		if ( typeof selector === "string" ) {
3045			if ( selector[ 0 ] === "<" &&
3046				selector[ selector.length - 1 ] === ">" &&
3047				selector.length >= 3 ) {
3048
3049				// Assume that strings that start and end with <> are HTML and skip the regex check
3050				match = [ null, selector, null ];
3051
3052			} else {
3053				match = rquickExpr.exec( selector );
3054			}
3055
3056			// Match html or make sure no context is specified for #id
3057			if ( match && ( match[ 1 ] || !context ) ) {
3058
3059				// HANDLE: $(html) -> $(array)
3060				if ( match[ 1 ] ) {
3061					context = context instanceof jQuery ? context[ 0 ] : context;
3062
3063					// Option to run scripts is true for back-compat
3064					// Intentionally let the error be thrown if parseHTML is not present
3065					jQuery.merge( this, jQuery.parseHTML(
3066						match[ 1 ],
3067						context && context.nodeType ? context.ownerDocument || context : document,
3068						true
3069					) );
3070
3071					// HANDLE: $(html, props)
3072					if ( rsingleTag.test( match[ 1 ] ) && jQuery.isPlainObject( context ) ) {
3073						for ( match in context ) {
3074
3075							// Properties of context are called as methods if possible
3076							if ( jQuery.isFunction( this[ match ] ) ) {
3077								this[ match ]( context[ match ] );
3078
3079							// ...and otherwise set as attributes
3080							} else {
3081								this.attr( match, context[ match ] );
3082							}
3083						}
3084					}
3085
3086					return this;
3087
3088				// HANDLE: $(#id)
3089				} else {
3090					elem = document.getElementById( match[ 2 ] );
3091
3092					if ( elem ) {
3093
3094						// Inject the element directly into the jQuery object
3095						this[ 0 ] = elem;
3096						this.length = 1;
3097					}
3098					return this;
3099				}
3100
3101			// HANDLE: $(expr, $(...))
3102			} else if ( !context || context.jquery ) {
3103				return ( context || root ).find( selector );
3104
3105			// HANDLE: $(expr, context)
3106			// (which is just equivalent to: $(context).find(expr)
3107			} else {
3108				return this.constructor( context ).find( selector );
3109			}
3110
3111		// HANDLE: $(DOMElement)
3112		} else if ( selector.nodeType ) {
3113			this[ 0 ] = selector;
3114			this.length = 1;
3115			return this;
3116
3117		// HANDLE: $(function)
3118		// Shortcut for document ready
3119		} else if ( jQuery.isFunction( selector ) ) {
3120			return root.ready !== undefined ?
3121				root.ready( selector ) :
3122
3123				// Execute immediately if ready is not present
3124				selector( jQuery );
3125		}
3126
3127		return jQuery.makeArray( selector, this );
3128	};
3129
3130// Give the init function the jQuery prototype for later instantiation
3131init.prototype = jQuery.fn;
3132
3133// Initialize central reference
3134rootjQuery = jQuery( document );
3135
3136
3137var rparentsprev = /^(?:parents|prev(?:Until|All))/,
3138
3139	// Methods guaranteed to produce a unique set when starting from a unique set
3140	guaranteedUnique = {
3141		children: true,
3142		contents: true,
3143		next: true,
3144		prev: true
3145	};
3146
3147jQuery.fn.extend( {
3148	has: function( target ) {
3149		var targets = jQuery( target, this ),
3150			l = targets.length;
3151
3152		return this.filter( function() {
3153			var i = 0;
3154			for ( ; i < l; i++ ) {
3155				if ( jQuery.contains( this, targets[ i ] ) ) {
3156					return true;
3157				}
3158			}
3159		} );
3160	},
3161
3162	closest: function( selectors, context ) {
3163		var cur,
3164			i = 0,
3165			l = this.length,
3166			matched = [],
3167			targets = typeof selectors !== "string" && jQuery( selectors );
3168
3169		// Positional selectors never match, since there's no _selection_ context
3170		if ( !rneedsContext.test( selectors ) ) {
3171			for ( ; i < l; i++ ) {
3172				for ( cur = this[ i ]; cur && cur !== context; cur = cur.parentNode ) {
3173
3174					// Always skip document fragments
3175					if ( cur.nodeType < 11 && ( targets ?
3176						targets.index( cur ) > -1 :
3177
3178						// Don't pass non-elements to Sizzle
3179						cur.nodeType === 1 &&
3180							jQuery.find.matchesSelector( cur, selectors ) ) ) {
3181
3182						matched.push( cur );
3183						break;
3184					}
3185				}
3186			}
3187		}
3188
3189		return this.pushStack( matched.length > 1 ? jQuery.uniqueSort( matched ) : matched );
3190	},
3191
3192	// Determine the position of an element within the set
3193	index: function( elem ) {
3194
3195		// No argument, return index in parent
3196		if ( !elem ) {
3197			return ( this[ 0 ] && this[ 0 ].parentNode ) ? this.first().prevAll().length : -1;
3198		}
3199
3200		// Index in selector
3201		if ( typeof elem === "string" ) {
3202			return indexOf.call( jQuery( elem ), this[ 0 ] );
3203		}
3204
3205		// Locate the position of the desired element
3206		return indexOf.call( this,
3207
3208			// If it receives a jQuery object, the first element is used
3209			elem.jquery ? elem[ 0 ] : elem
3210		);
3211	},
3212
3213	add: function( selector, context ) {
3214		return this.pushStack(
3215			jQuery.uniqueSort(
3216				jQuery.merge( this.get(), jQuery( selector, context ) )
3217			)
3218		);
3219	},
3220
3221	addBack: function( selector ) {
3222		return this.add( selector == null ?
3223			this.prevObject : this.prevObject.filter( selector )
3224		);
3225	}
3226} );
3227
3228function sibling( cur, dir ) {
3229	while ( ( cur = cur[ dir ] ) && cur.nodeType !== 1 ) {}
3230	return cur;
3231}
3232
3233jQuery.each( {
3234	parent: function( elem ) {
3235		var parent = elem.parentNode;
3236		return parent && parent.nodeType !== 11 ? parent : null;
3237	},
3238	parents: function( elem ) {
3239		return dir( elem, "parentNode" );
3240	},
3241	parentsUntil: function( elem, i, until ) {
3242		return dir( elem, "parentNode", until );
3243	},
3244	next: function( elem ) {
3245		return sibling( elem, "nextSibling" );
3246	},
3247	prev: function( elem ) {
3248		return sibling( elem, "previousSibling" );
3249	},
3250	nextAll: function( elem ) {
3251		return dir( elem, "nextSibling" );
3252	},
3253	prevAll: function( elem ) {
3254		return dir( elem, "previousSibling" );
3255	},
3256	nextUntil: function( elem, i, until ) {
3257		return dir( elem, "nextSibling", until );
3258	},
3259	prevUntil: function( elem, i, until ) {
3260		return dir( elem, "previousSibling", until );
3261	},
3262	siblings: function( elem ) {
3263		return siblings( ( elem.parentNode || {} ).firstChild, elem );
3264	},
3265	children: function( elem ) {
3266		return siblings( elem.firstChild );
3267	},
3268	contents: function( elem ) {
3269		return elem.contentDocument || jQuery.merge( [], elem.childNodes );
3270	}
3271}, function( name, fn ) {
3272	jQuery.fn[ name ] = function( until, selector ) {
3273		var matched = jQuery.map( this, fn, until );
3274
3275		if ( name.slice( -5 ) !== "Until" ) {
3276			selector = until;
3277		}
3278
3279		if ( selector && typeof selector === "string" ) {
3280			matched = jQuery.filter( selector, matched );
3281		}
3282
3283		if ( this.length > 1 ) {
3284
3285			// Remove duplicates
3286			if ( !guaranteedUnique[ name ] ) {
3287				jQuery.uniqueSort( matched );
3288			}
3289
3290			// Reverse order for parents* and prev-derivatives
3291			if ( rparentsprev.test( name ) ) {
3292				matched.reverse();
3293			}
3294		}
3295
3296		return this.pushStack( matched );
3297	};
3298} );
3299var rnothtmlwhite = ( /[^\x20\t\r\n\f]+/g );
3300
3301
3302
3303// Convert String-formatted options into Object-formatted ones
3304function createOptions( options ) {
3305	var object = {};
3306	jQuery.each( options.match( rnothtmlwhite ) || [], function( _, flag ) {
3307		object[ flag ] = true;
3308	} );
3309	return object;
3310}
3311
3312/*
3313 * Create a callback list using the following parameters:
3314 *
3315 *	options: an optional list of space-separated options that will change how
3316 *			the callback list behaves or a more traditional option object
3317 *
3318 * By default a callback list will act like an event callback list and can be
3319 * "fired" multiple times.
3320 *
3321 * Possible options:
3322 *
3323 *	once:			will ensure the callback list can only be fired once (like a Deferred)
3324 *
3325 *	memory:			will keep track of previous values and will call any callback added
3326 *					after the list has been fired right away with the latest "memorized"
3327 *					values (like a Deferred)
3328 *
3329 *	unique:			will ensure a callback can only be added once (no duplicate in the list)
3330 *
3331 *	stopOnFalse:	interrupt callings when a callback returns false
3332 *
3333 */
3334jQuery.Callbacks = function( options ) {
3335
3336	// Convert options from String-formatted to Object-formatted if needed
3337	// (we check in cache first)
3338	options = typeof options === "string" ?
3339		createOptions( options ) :
3340		jQuery.extend( {}, options );
3341
3342	var // Flag to know if list is currently firing
3343		firing,
3344
3345		// Last fire value for non-forgettable lists
3346		memory,
3347
3348		// Flag to know if list was already fired
3349		fired,
3350
3351		// Flag to prevent firing
3352		locked,
3353
3354		// Actual callback list
3355		list = [],
3356
3357		// Queue of execution data for repeatable lists
3358		queue = [],
3359
3360		// Index of currently firing callback (modified by add/remove as needed)
3361		firingIndex = -1,
3362
3363		// Fire callbacks
3364		fire = function() {
3365
3366			// Enforce single-firing
3367			locked = options.once;
3368
3369			// Execute callbacks for all pending executions,
3370			// respecting firingIndex overrides and runtime changes
3371			fired = firing = true;
3372			for ( ; queue.length; firingIndex = -1 ) {
3373				memory = queue.shift();
3374				while ( ++firingIndex < list.length ) {
3375
3376					// Run callback and check for early termination
3377					if ( list[ firingIndex ].apply( memory[ 0 ], memory[ 1 ] ) === false &&
3378						options.stopOnFalse ) {
3379
3380						// Jump to end and forget the data so .add doesn't re-fire
3381						firingIndex = list.length;
3382						memory = false;
3383					}
3384				}
3385			}
3386
3387			// Forget the data if we're done with it
3388			if ( !options.memory ) {
3389				memory = false;
3390			}
3391
3392			firing = false;
3393
3394			// Clean up if we're done firing for good
3395			if ( locked ) {
3396
3397				// Keep an empty list if we have data for future add calls
3398				if ( memory ) {
3399					list = [];
3400
3401				// Otherwise, this object is spent
3402				} else {
3403					list = "";
3404				}
3405			}
3406		},
3407
3408		// Actual Callbacks object
3409		self = {
3410
3411			// Add a callback or a collection of callbacks to the list
3412			add: function() {
3413				if ( list ) {
3414
3415					// If we have memory from a past run, we should fire after adding
3416					if ( memory && !firing ) {
3417						firingIndex = list.length - 1;
3418						queue.push( memory );
3419					}
3420
3421					( function add( args ) {
3422						jQuery.each( args, function( _, arg ) {
3423							if ( jQuery.isFunction( arg ) ) {
3424								if ( !options.unique || !self.has( arg ) ) {
3425									list.push( arg );
3426								}
3427							} else if ( arg && arg.length && jQuery.type( arg ) !== "string" ) {
3428
3429								// Inspect recursively
3430								add( arg );
3431							}
3432						} );
3433					} )( arguments );
3434
3435					if ( memory && !firing ) {
3436						fire();
3437					}
3438				}
3439				return this;
3440			},
3441
3442			// Remove a callback from the list
3443			remove: function() {
3444				jQuery.each( arguments, function( _, arg ) {
3445					var index;
3446					while ( ( index = jQuery.inArray( arg, list, index ) ) > -1 ) {
3447						list.splice( index, 1 );
3448
3449						// Handle firing indexes
3450						if ( index <= firingIndex ) {
3451							firingIndex--;
3452						}
3453					}
3454				} );
3455				return this;
3456			},
3457
3458			// Check if a given callback is in the list.
3459			// If no argument is given, return whether or not list has callbacks attached.
3460			has: function( fn ) {
3461				return fn ?
3462					jQuery.inArray( fn, list ) > -1 :
3463					list.length > 0;
3464			},
3465
3466			// Remove all callbacks from the list
3467			empty: function() {
3468				if ( list ) {
3469					list = [];
3470				}
3471				return this;
3472			},
3473
3474			// Disable .fire and .add
3475			// Abort any current/pending executions
3476			// Clear all callbacks and values
3477			disable: function() {
3478				locked = queue = [];
3479				list = memory = "";
3480				return this;
3481			},
3482			disabled: function() {
3483				return !list;
3484			},
3485
3486			// Disable .fire
3487			// Also disable .add unless we have memory (since it would have no effect)
3488			// Abort any pending executions
3489			lock: function() {
3490				locked = queue = [];
3491				if ( !memory && !firing ) {
3492					list = memory = "";
3493				}
3494				return this;
3495			},
3496			locked: function() {
3497				return !!locked;
3498			},
3499
3500			// Call all callbacks with the given context and arguments
3501			fireWith: function( context, args ) {
3502				if ( !locked ) {
3503					args = args || [];
3504					args = [ context, args.slice ? args.slice() : args ];
3505					queue.push( args );
3506					if ( !firing ) {
3507						fire();
3508					}
3509				}
3510				return this;
3511			},
3512
3513			// Call all the callbacks with the given arguments
3514			fire: function() {
3515				self.fireWith( this, arguments );
3516				return this;
3517			},
3518
3519			// To know if the callbacks have already been called at least once
3520			fired: function() {
3521				return !!fired;
3522			}
3523		};
3524
3525	return self;
3526};
3527
3528
3529function Identity( v ) {
3530	return v;
3531}
3532function Thrower( ex ) {
3533	throw ex;
3534}
3535
3536function adoptValue( value, resolve, reject ) {
3537	var method;
3538
3539	try {
3540
3541		// Check for promise aspect first to privilege synchronous behavior
3542		if ( value && jQuery.isFunction( ( method = value.promise ) ) ) {
3543			method.call( value ).done( resolve ).fail( reject );
3544
3545		// Other thenables
3546		} else if ( value && jQuery.isFunction( ( method = value.then ) ) ) {
3547			method.call( value, resolve, reject );
3548
3549		// Other non-thenables
3550		} else {
3551
3552			// Support: Android 4.0 only
3553			// Strict mode functions invoked without .call/.apply get global-object context
3554			resolve.call( undefined, value );
3555		}
3556
3557	// For Promises/A+, convert exceptions into rejections
3558	// Since jQuery.when doesn't unwrap thenables, we can skip the extra checks appearing in
3559	// Deferred#then to conditionally suppress rejection.
3560	} catch ( value ) {
3561
3562		// Support: Android 4.0 only
3563		// Strict mode functions invoked without .call/.apply get global-object context
3564		reject.call( undefined, value );
3565	}
3566}
3567
3568jQuery.extend( {
3569
3570	Deferred: function( func ) {
3571		var tuples = [
3572
3573				// action, add listener, callbacks,
3574				// ... .then handlers, argument index, [final state]
3575				[ "notify", "progress", jQuery.Callbacks( "memory" ),
3576					jQuery.Callbacks( "memory" ), 2 ],
3577				[ "resolve", "done", jQuery.Callbacks( "once memory" ),
3578					jQuery.Callbacks( "once memory" ), 0, "resolved" ],
3579				[ "reject", "fail", jQuery.Callbacks( "once memory" ),
3580					jQuery.Callbacks( "once memory" ), 1, "rejected" ]
3581			],
3582			state = "pending",
3583			promise = {
3584				state: function() {
3585					return state;
3586				},
3587				always: function() {
3588					deferred.done( arguments ).fail( arguments );
3589					return this;
3590				},
3591				"catch": function( fn ) {
3592					return promise.then( null, fn );
3593				},
3594
3595				// Keep pipe for back-compat
3596				pipe: function( /* fnDone, fnFail, fnProgress */ ) {
3597					var fns = arguments;
3598
3599					return jQuery.Deferred( function( newDefer ) {
3600						jQuery.each( tuples, function( i, tuple ) {
3601
3602							// Map tuples (progress, done, fail) to arguments (done, fail, progress)
3603							var fn = jQuery.isFunction( fns[ tuple[ 4 ] ] ) && fns[ tuple[ 4 ] ];
3604
3605							// deferred.progress(function() { bind to newDefer or newDefer.notify })
3606							// deferred.done(function() { bind to newDefer or newDefer.resolve })
3607							// deferred.fail(function() { bind to newDefer or newDefer.reject })
3608							deferred[ tuple[ 1 ] ]( function() {
3609								var returned = fn && fn.apply( this, arguments );
3610								if ( returned && jQuery.isFunction( returned.promise ) ) {
3611									returned.promise()
3612										.progress( newDefer.notify )
3613										.done( newDefer.resolve )
3614										.fail( newDefer.reject );
3615								} else {
3616									newDefer[ tuple[ 0 ] + "With" ](
3617										this,
3618										fn ? [ returned ] : arguments
3619									);
3620								}
3621							} );
3622						} );
3623						fns = null;
3624					} ).promise();
3625				},
3626				then: function( onFulfilled, onRejected, onProgress ) {
3627					var maxDepth = 0;
3628					function resolve( depth, deferred, handler, special ) {
3629						return function() {
3630							var that = this,
3631								args = arguments,
3632								mightThrow = function() {
3633									var returned, then;
3634
3635									// Support: Promises/A+ section 2.3.3.3.3
3636									// https://promisesaplus.com/#point-59
3637									// Ignore double-resolution attempts
3638									if ( depth < maxDepth ) {
3639										return;
3640									}
3641
3642									returned = handler.apply( that, args );
3643
3644									// Support: Promises/A+ section 2.3.1
3645									// https://promisesaplus.com/#point-48
3646									if ( returned === deferred.promise() ) {
3647										throw new TypeError( "Thenable self-resolution" );
3648									}
3649
3650									// Support: Promises/A+ sections 2.3.3.1, 3.5
3651									// https://promisesaplus.com/#point-54
3652									// https://promisesaplus.com/#point-75
3653									// Retrieve `then` only once
3654									then = returned &&
3655
3656										// Support: Promises/A+ section 2.3.4
3657										// https://promisesaplus.com/#point-64
3658										// Only check objects and functions for thenability
3659										( typeof returned === "object" ||
3660											typeof returned === "function" ) &&
3661										returned.then;
3662
3663									// Handle a returned thenable
3664									if ( jQuery.isFunction( then ) ) {
3665
3666										// Special processors (notify) just wait for resolution
3667										if ( special ) {
3668											then.call(
3669												returned,
3670												resolve( maxDepth, deferred, Identity, special ),
3671												resolve( maxDepth, deferred, Thrower, special )
3672											);
3673
3674										// Normal processors (resolve) also hook into progress
3675										} else {
3676
3677											// ...and disregard older resolution values
3678											maxDepth++;
3679
3680											then.call(
3681												returned,
3682												resolve( maxDepth, deferred, Identity, special ),
3683												resolve( maxDepth, deferred, Thrower, special ),
3684												resolve( maxDepth, deferred, Identity,
3685													deferred.notifyWith )
3686											);
3687										}
3688
3689									// Handle all other returned values
3690									} else {
3691
3692										// Only substitute handlers pass on context
3693										// and multiple values (non-spec behavior)
3694										if ( handler !== Identity ) {
3695											that = undefined;
3696											args = [ returned ];
3697										}
3698
3699										// Process the value(s)
3700										// Default process is resolve
3701										( special || deferred.resolveWith )( that, args );
3702									}
3703								},
3704
3705								// Only normal processors (resolve) catch and reject exceptions
3706								process = special ?
3707									mightThrow :
3708									function() {
3709										try {
3710											mightThrow();
3711										} catch ( e ) {
3712
3713											if ( jQuery.Deferred.exceptionHook ) {
3714												jQuery.Deferred.exceptionHook( e,
3715													process.stackTrace );
3716											}
3717
3718											// Support: Promises/A+ section 2.3.3.3.4.1
3719											// https://promisesaplus.com/#point-61
3720											// Ignore post-resolution exceptions
3721											if ( depth + 1 >= maxDepth ) {
3722
3723												// Only substitute handlers pass on context
3724												// and multiple values (non-spec behavior)
3725												if ( handler !== Thrower ) {
3726													that = undefined;
3727													args = [ e ];
3728												}
3729
3730												deferred.rejectWith( that, args );
3731											}
3732										}
3733									};
3734
3735							// Support: Promises/A+ section 2.3.3.3.1
3736							// https://promisesaplus.com/#point-57
3737							// Re-resolve promises immediately to dodge false rejection from
3738							// subsequent errors
3739							if ( depth ) {
3740								process();
3741							} else {
3742
3743								// Call an optional hook to record the stack, in case of exception
3744								// since it's otherwise lost when execution goes async
3745								if ( jQuery.Deferred.getStackHook ) {
3746									process.stackTrace = jQuery.Deferred.getStackHook();
3747								}
3748								window.setTimeout( process );
3749							}
3750						};
3751					}
3752
3753					return jQuery.Deferred( function( newDefer ) {
3754
3755						// progress_handlers.add( ... )
3756						tuples[ 0 ][ 3 ].add(
3757							resolve(
3758								0,
3759								newDefer,
3760								jQuery.isFunction( onProgress ) ?
3761									onProgress :
3762									Identity,
3763								newDefer.notifyWith
3764							)
3765						);
3766
3767						// fulfilled_handlers.add( ... )
3768						tuples[ 1 ][ 3 ].add(
3769							resolve(
3770								0,
3771								newDefer,
3772								jQuery.isFunction( onFulfilled ) ?
3773									onFulfilled :
3774									Identity
3775							)
3776						);
3777
3778						// rejected_handlers.add( ... )
3779						tuples[ 2 ][ 3 ].add(
3780							resolve(
3781								0,
3782								newDefer,
3783								jQuery.isFunction( onRejected ) ?
3784									onRejected :
3785									Thrower
3786							)
3787						);
3788					} ).promise();
3789				},
3790
3791				// Get a promise for this deferred
3792				// If obj is provided, the promise aspect is added to the object
3793				promise: function( obj ) {
3794					return obj != null ? jQuery.extend( obj, promise ) : promise;
3795				}
3796			},
3797			deferred = {};
3798
3799		// Add list-specific methods
3800		jQuery.each( tuples, function( i, tuple ) {
3801			var list = tuple[ 2 ],
3802				stateString = tuple[ 5 ];
3803
3804			// promise.progress = list.add
3805			// promise.done = list.add
3806			// promise.fail = list.add
3807			promise[ tuple[ 1 ] ] = list.add;
3808
3809			// Handle state
3810			if ( stateString ) {
3811				list.add(
3812					function() {
3813
3814						// state = "resolved" (i.e., fulfilled)
3815						// state = "rejected"
3816						state = stateString;
3817					},
3818
3819					// rejected_callbacks.disable
3820					// fulfilled_callbacks.disable
3821					tuples[ 3 - i ][ 2 ].disable,
3822
3823					// progress_callbacks.lock
3824					tuples[ 0 ][ 2 ].lock
3825				);
3826			}
3827
3828			// progress_handlers.fire
3829			// fulfilled_handlers.fire
3830			// rejected_handlers.fire
3831			list.add( tuple[ 3 ].fire );
3832
3833			// deferred.notify = function() { deferred.notifyWith(...) }
3834			// deferred.resolve = function() { deferred.resolveWith(...) }
3835			// deferred.reject = function() { deferred.rejectWith(...) }
3836			deferred[ tuple[ 0 ] ] = function() {
3837				deferred[ tuple[ 0 ] + "With" ]( this === deferred ? undefined : this, arguments );
3838				return this;
3839			};
3840
3841			// deferred.notifyWith = list.fireWith
3842			// deferred.resolveWith = list.fireWith
3843			// deferred.rejectWith = list.fireWith
3844			deferred[ tuple[ 0 ] + "With" ] = list.fireWith;
3845		} );
3846
3847		// Make the deferred a promise
3848		promise.promise( deferred );
3849
3850		// Call given func if any
3851		if ( func ) {
3852			func.call( deferred, deferred );
3853		}
3854
3855		// All done!
3856		return deferred;
3857	},
3858
3859	// Deferred helper
3860	when: function( singleValue ) {
3861		var
3862
3863			// count of uncompleted subordinates
3864			remaining = arguments.length,
3865
3866			// count of unprocessed arguments
3867			i = remaining,
3868
3869			// subordinate fulfillment data
3870			resolveContexts = Array( i ),
3871			resolveValues = slice.call( arguments ),
3872
3873			// the master Deferred
3874			master = jQuery.Deferred(),
3875
3876			// subordinate callback factory
3877			updateFunc = function( i ) {
3878				return function( value ) {
3879					resolveContexts[ i ] = this;
3880					resolveValues[ i ] = arguments.length > 1 ? slice.call( arguments ) : value;
3881					if ( !( --remaining ) ) {
3882						master.resolveWith( resolveContexts, resolveValues );
3883					}
3884				};
3885			};
3886
3887		// Single- and empty arguments are adopted like Promise.resolve
3888		if ( remaining <= 1 ) {
3889			adoptValue( singleValue, master.done( updateFunc( i ) ).resolve, master.reject );
3890
3891			// Use .then() to unwrap secondary thenables (cf. gh-3000)
3892			if ( master.state() === "pending" ||
3893				jQuery.isFunction( resolveValues[ i ] && resolveValues[ i ].then ) ) {
3894
3895				return master.then();
3896			}
3897		}
3898
3899		// Multiple arguments are aggregated like Promise.all array elements
3900		while ( i-- ) {
3901			adoptValue( resolveValues[ i ], updateFunc( i ), master.reject );
3902		}
3903
3904		return master.promise();
3905	}
3906} );
3907
3908
3909// These usually indicate a programmer mistake during development,
3910// warn about them ASAP rather than swallowing them by default.
3911var rerrorNames = /^(Eval|Internal|Range|Reference|Syntax|Type|URI)Error$/;
3912
3913jQuery.Deferred.exceptionHook = function( error, stack ) {
3914
3915	// Support: IE 8 - 9 only
3916	// Console exists when dev tools are open, which can happen at any time
3917	if ( window.console && window.console.warn && error && rerrorNames.test( error.name ) ) {
3918		window.console.warn( "jQuery.Deferred exception: " + error.message, error.stack, stack );
3919	}
3920};
3921
3922
3923
3924
3925jQuery.readyException = function( error ) {
3926	window.setTimeout( function() {
3927		throw error;
3928	} );
3929};
3930
3931
3932
3933
3934// The deferred used on DOM ready
3935var readyList = jQuery.Deferred();
3936
3937jQuery.fn.ready = function( fn ) {
3938
3939	readyList
3940		.then( fn )
3941
3942		// Wrap jQuery.readyException in a function so that the lookup
3943		// happens at the time of error handling instead of callback
3944		// registration.
3945		.catch( function( error ) {
3946			jQuery.readyException( error );
3947		} );
3948
3949	return this;
3950};
3951
3952jQuery.extend( {
3953
3954	// Is the DOM ready to be used? Set to true once it occurs.
3955	isReady: false,
3956
3957	// A counter to track how many items to wait for before
3958	// the ready event fires. See #6781
3959	readyWait: 1,
3960
3961	// Hold (or release) the ready event
3962	holdReady: function( hold ) {
3963		if ( hold ) {
3964			jQuery.readyWait++;
3965		} else {
3966			jQuery.ready( true );
3967		}
3968	},
3969
3970	// Handle when the DOM is ready
3971	ready: function( wait ) {
3972
3973		// Abort if there are pending holds or we're already ready
3974		if ( wait === true ? --jQuery.readyWait : jQuery.isReady ) {
3975			return;
3976		}
3977
3978		// Remember that the DOM is ready
3979		jQuery.isReady = true;
3980
3981		// If a normal DOM Ready event fired, decrement, and wait if need be
3982		if ( wait !== true && --jQuery.readyWait > 0 ) {
3983			return;
3984		}
3985
3986		// If there are functions bound, to execute
3987		readyList.resolveWith( document, [ jQuery ] );
3988	}
3989} );
3990
3991jQuery.ready.then = readyList.then;
3992
3993// The ready event handler and self cleanup method
3994function completed() {
3995	document.removeEventListener( "DOMContentLoaded", completed );
3996	window.removeEventListener( "load", completed );
3997	jQuery.ready();
3998}
3999
4000// Catch cases where $(document).ready() is called
4001// after the browser event has already occurred.
4002// Support: IE <=9 - 10 only
4003// Older IE sometimes signals "interactive" too soon
4004if ( document.readyState === "complete" ||
4005	( document.readyState !== "loading" && !document.documentElement.doScroll ) ) {
4006
4007	// Handle it asynchronously to allow scripts the opportunity to delay ready
4008	window.setTimeout( jQuery.ready );
4009
4010} else {
4011
4012	// Use the handy event callback
4013	document.addEventListener( "DOMContentLoaded", completed );
4014
4015	// A fallback to window.onload, that will always work
4016	window.addEventListener( "load", completed );
4017}
4018
4019
4020
4021
4022// Multifunctional method to get and set values of a collection
4023// The value/s can optionally be executed if it's a function
4024var access = function( elems, fn, key, value, chainable, emptyGet, raw ) {
4025	var i = 0,
4026		len = elems.length,
4027		bulk = key == null;
4028
4029	// Sets many values
4030	if ( jQuery.type( key ) === "object" ) {
4031		chainable = true;
4032		for ( i in key ) {
4033			access( elems, fn, i, key[ i ], true, emptyGet, raw );
4034		}
4035
4036	// Sets one value
4037	} else if ( value !== undefined ) {
4038		chainable = true;
4039
4040		if ( !jQuery.isFunction( value ) ) {
4041			raw = true;
4042		}
4043
4044		if ( bulk ) {
4045
4046			// Bulk operations run against the entire set
4047			if ( raw ) {
4048				fn.call( elems, value );
4049				fn = null;
4050
4051			// ...except when executing function values
4052			} else {
4053				bulk = fn;
4054				fn = function( elem, key, value ) {
4055					return bulk.call( jQuery( elem ), value );
4056				};
4057			}
4058		}
4059
4060		if ( fn ) {
4061			for ( ; i < len; i++ ) {
4062				fn(
4063					elems[ i ], key, raw ?
4064					value :
4065					value.call( elems[ i ], i, fn( elems[ i ], key ) )
4066				);
4067			}
4068		}
4069	}
4070
4071	if ( chainable ) {
4072		return elems;
4073	}
4074
4075	// Gets
4076	if ( bulk ) {
4077		return fn.call( elems );
4078	}
4079
4080	return len ? fn( elems[ 0 ], key ) : emptyGet;
4081};
4082var acceptData = function( owner ) {
4083
4084	// Accepts only:
4085	//  - Node
4086	//    - Node.ELEMENT_NODE
4087	//    - Node.DOCUMENT_NODE
4088	//  - Object
4089	//    - Any
4090	return owner.nodeType === 1 || owner.nodeType === 9 || !( +owner.nodeType );
4091};
4092
4093
4094
4095
4096function Data() {
4097	this.expando = jQuery.expando + Data.uid++;
4098}
4099
4100Data.uid = 1;
4101
4102Data.prototype = {
4103
4104	cache: function( owner ) {
4105
4106		// Check if the owner object already has a cache
4107		var value = owner[ this.expando ];
4108
4109		// If not, create one
4110		if ( !value ) {
4111			value = {};
4112
4113			// We can accept data for non-element nodes in modern browsers,
4114			// but we should not, see #8335.
4115			// Always return an empty object.
4116			if ( acceptData( owner ) ) {
4117
4118				// If it is a node unlikely to be stringify-ed or looped over
4119				// use plain assignment
4120				if ( owner.nodeType ) {
4121					owner[ this.expando ] = value;
4122
4123				// Otherwise secure it in a non-enumerable property
4124				// configurable must be true to allow the property to be
4125				// deleted when data is removed
4126				} else {
4127					Object.defineProperty( owner, this.expando, {
4128						value: value,
4129						configurable: true
4130					} );
4131				}
4132			}
4133		}
4134
4135		return value;
4136	},
4137	set: function( owner, data, value ) {
4138		var prop,
4139			cache = this.cache( owner );
4140
4141		// Handle: [ owner, key, value ] args
4142		// Always use camelCase key (gh-2257)
4143		if ( typeof data === "string" ) {
4144			cache[ jQuery.camelCase( data ) ] = value;
4145
4146		// Handle: [ owner, { properties } ] args
4147		} else {
4148
4149			// Copy the properties one-by-one to the cache object
4150			for ( prop in data ) {
4151				cache[ jQuery.camelCase( prop ) ] = data[ prop ];
4152			}
4153		}
4154		return cache;
4155	},
4156	get: function( owner, key ) {
4157		return key === undefined ?
4158			this.cache( owner ) :
4159
4160			// Always use camelCase key (gh-2257)
4161			owner[ this.expando ] && owner[ this.expando ][ jQuery.camelCase( key ) ];
4162	},
4163	access: function( owner, key, value ) {
4164
4165		// In cases where either:
4166		//
4167		//   1. No key was specified
4168		//   2. A string key was specified, but no value provided
4169		//
4170		// Take the "read" path and allow the get method to determine
4171		// which value to return, respectively either:
4172		//
4173		//   1. The entire cache object
4174		//   2. The data stored at the key
4175		//
4176		if ( key === undefined ||
4177				( ( key && typeof key === "string" ) && value === undefined ) ) {
4178
4179			return this.get( owner, key );
4180		}
4181
4182		// When the key is not a string, or both a key and value
4183		// are specified, set or extend (existing objects) with either:
4184		//
4185		//   1. An object of properties
4186		//   2. A key and value
4187		//
4188		this.set( owner, key, value );
4189
4190		// Since the "set" path can have two possible entry points
4191		// return the expected data based on which path was taken[*]
4192		return value !== undefined ? value : key;
4193	},
4194	remove: function( owner, key ) {
4195		var i,
4196			cache = owner[ this.expando ];
4197
4198		if ( cache === undefined ) {
4199			return;
4200		}
4201
4202		if ( key !== undefined ) {
4203
4204			// Support array or space separated string of keys
4205			if ( jQuery.isArray( key ) ) {
4206
4207				// If key is an array of keys...
4208				// We always set camelCase keys, so remove that.
4209				key = key.map( jQuery.camelCase );
4210			} else {
4211				key = jQuery.camelCase( key );
4212
4213				// If a key with the spaces exists, use it.
4214				// Otherwise, create an array by matching non-whitespace
4215				key = key in cache ?
4216					[ key ] :
4217					( key.match( rnothtmlwhite ) || [] );
4218			}
4219
4220			i = key.length;
4221
4222			while ( i-- ) {
4223				delete cache[ key[ i ] ];
4224			}
4225		}
4226
4227		// Remove the expando if there's no more data
4228		if ( key === undefined || jQuery.isEmptyObject( cache ) ) {
4229
4230			// Support: Chrome <=35 - 45
4231			// Webkit & Blink performance suffers when deleting properties
4232			// from DOM nodes, so set to undefined instead
4233			// https://bugs.chromium.org/p/chromium/issues/detail?id=378607 (bug restricted)
4234			if ( owner.nodeType ) {
4235				owner[ this.expando ] = undefined;
4236			} else {
4237				delete owner[ this.expando ];
4238			}
4239		}
4240	},
4241	hasData: function( owner ) {
4242		var cache = owner[ this.expando ];
4243		return cache !== undefined && !jQuery.isEmptyObject( cache );
4244	}
4245};
4246var dataPriv = new Data();
4247
4248var dataUser = new Data();
4249
4250
4251
4252//	Implementation Summary
4253//
4254//	1. Enforce API surface and semantic compatibility with 1.9.x branch
4255//	2. Improve the module's maintainability by reducing the storage
4256//		paths to a single mechanism.
4257//	3. Use the same single mechanism to support "private" and "user" data.
4258//	4. _Never_ expose "private" data to user code (TODO: Drop _data, _removeData)
4259//	5. Avoid exposing implementation details on user objects (eg. expando properties)
4260//	6. Provide a clear path for implementation upgrade to WeakMap in 2014
4261
4262var rbrace = /^(?:\{[\w\W]*\}|\[[\w\W]*\])$/,
4263	rmultiDash = /[A-Z]/g;
4264
4265function getData( data ) {
4266	if ( data === "true" ) {
4267		return true;
4268	}
4269
4270	if ( data === "false" ) {
4271		return false;
4272	}
4273
4274	if ( data === "null" ) {
4275		return null;
4276	}
4277
4278	// Only convert to a number if it doesn't change the string
4279	if ( data === +data + "" ) {
4280		return +data;
4281	}
4282
4283	if ( rbrace.test( data ) ) {
4284		return JSON.parse( data );
4285	}
4286
4287	return data;
4288}
4289
4290function dataAttr( elem, key, data ) {
4291	var name;
4292
4293	// If nothing was found internally, try to fetch any
4294	// data from the HTML5 data-* attribute
4295	if ( data === undefined && elem.nodeType === 1 ) {
4296		name = "data-" + key.replace( rmultiDash, "-$&" ).toLowerCase();
4297		data = elem.getAttribute( name );
4298
4299		if ( typeof data === "string" ) {
4300			try {
4301				data = getData( data );
4302			} catch ( e ) {}
4303
4304			// Make sure we set the data so it isn't changed later
4305			dataUser.set( elem, key, data );
4306		} else {
4307			data = undefined;
4308		}
4309	}
4310	return data;
4311}
4312
4313jQuery.extend( {
4314	hasData: function( elem ) {
4315		return dataUser.hasData( elem ) || dataPriv.hasData( elem );
4316	},
4317
4318	data: function( elem, name, data ) {
4319		return dataUser.access( elem, name, data );
4320	},
4321
4322	removeData: function( elem, name ) {
4323		dataUser.remove( elem, name );
4324	},
4325
4326	// TODO: Now that all calls to _data and _removeData have been replaced
4327	// with direct calls to dataPriv methods, these can be deprecated.
4328	_data: function( elem, name, data ) {
4329		return dataPriv.access( elem, name, data );
4330	},
4331
4332	_removeData: function( elem, name ) {
4333		dataPriv.remove( elem, name );
4334	}
4335} );
4336
4337jQuery.fn.extend( {
4338	data: function( key, value ) {
4339		var i, name, data,
4340			elem = this[ 0 ],
4341			attrs = elem && elem.attributes;
4342
4343		// Gets all values
4344		if ( key === undefined ) {
4345			if ( this.length ) {
4346				data = dataUser.get( elem );
4347
4348				if ( elem.nodeType === 1 && !dataPriv.get( elem, "hasDataAttrs" ) ) {
4349					i = attrs.length;
4350					while ( i-- ) {
4351
4352						// Support: IE 11 only
4353						// The attrs elements can be null (#14894)
4354						if ( attrs[ i ] ) {
4355							name = attrs[ i ].name;
4356							if ( name.indexOf( "data-" ) === 0 ) {
4357								name = jQuery.camelCase( name.slice( 5 ) );
4358								dataAttr( elem, name, data[ name ] );
4359							}
4360						}
4361					}
4362					dataPriv.set( elem, "hasDataAttrs", true );
4363				}
4364			}
4365
4366			return data;
4367		}
4368
4369		// Sets multiple values
4370		if ( typeof key === "object" ) {
4371			return this.each( function() {
4372				dataUser.set( this, key );
4373			} );
4374		}
4375
4376		return access( this, function( value ) {
4377			var data;
4378
4379			// The calling jQuery object (element matches) is not empty
4380			// (and therefore has an element appears at this[ 0 ]) and the
4381			// `value` parameter was not undefined. An empty jQuery object
4382			// will result in `undefined` for elem = this[ 0 ] which will
4383			// throw an exception if an attempt to read a data cache is made.
4384			if ( elem && value === undefined ) {
4385
4386				// Attempt to get data from the cache
4387				// The key will always be camelCased in Data
4388				data = dataUser.get( elem, key );
4389				if ( data !== undefined ) {
4390					return data;
4391				}
4392
4393				// Attempt to "discover" the data in
4394				// HTML5 custom data-* attrs
4395				data = dataAttr( elem, key );
4396				if ( data !== undefined ) {
4397					return data;
4398				}
4399
4400				// We tried really hard, but the data doesn't exist.
4401				return;
4402			}
4403
4404			// Set the data...
4405			this.each( function() {
4406
4407				// We always store the camelCased key
4408				dataUser.set( this, key, value );
4409			} );
4410		}, null, value, arguments.length > 1, null, true );
4411	},
4412
4413	removeData: function( key ) {
4414		return this.each( function() {
4415			dataUser.remove( this, key );
4416		} );
4417	}
4418} );
4419
4420
4421jQuery.extend( {
4422	queue: function( elem, type, data ) {
4423		var queue;
4424
4425		if ( elem ) {
4426			type = ( type || "fx" ) + "queue";
4427			queue = dataPriv.get( elem, type );
4428
4429			// Speed up dequeue by getting out quickly if this is just a lookup
4430			if ( data ) {
4431				if ( !queue || jQuery.isArray( data ) ) {
4432					queue = dataPriv.access( elem, type, jQuery.makeArray( data ) );
4433				} else {
4434					queue.push( data );
4435				}
4436			}
4437			return queue || [];
4438		}
4439	},
4440
4441	dequeue: function( elem, type ) {
4442		type = type || "fx";
4443
4444		var queue = jQuery.queue( elem, type ),
4445			startLength = queue.length,
4446			fn = queue.shift(),
4447			hooks = jQuery._queueHooks( elem, type ),
4448			next = function() {
4449				jQuery.dequeue( elem, type );
4450			};
4451
4452		// If the fx queue is dequeued, always remove the progress sentinel
4453		if ( fn === "inprogress" ) {
4454			fn = queue.shift();
4455			startLength--;
4456		}
4457
4458		if ( fn ) {
4459
4460			// Add a progress sentinel to prevent the fx queue from being
4461			// automatically dequeued
4462			if ( type === "fx" ) {
4463				queue.unshift( "inprogress" );
4464			}
4465
4466			// Clear up the last queue stop function
4467			delete hooks.stop;
4468			fn.call( elem, next, hooks );
4469		}
4470
4471		if ( !startLength && hooks ) {
4472			hooks.empty.fire();
4473		}
4474	},
4475
4476	// Not public - generate a queueHooks object, or return the current one
4477	_queueHooks: function( elem, type ) {
4478		var key = type + "queueHooks";
4479		return dataPriv.get( elem, key ) || dataPriv.access( elem, key, {
4480			empty: jQuery.Callbacks( "once memory" ).add( function() {
4481				dataPriv.remove( elem, [ type + "queue", key ] );
4482			} )
4483		} );
4484	}
4485} );
4486
4487jQuery.fn.extend( {
4488	queue: function( type, data ) {
4489		var setter = 2;
4490
4491		if ( typeof type !== "string" ) {
4492			data = type;
4493			type = "fx";
4494			setter--;
4495		}
4496
4497		if ( arguments.length < setter ) {
4498			return jQuery.queue( this[ 0 ], type );
4499		}
4500
4501		return data === undefined ?
4502			this :
4503			this.each( function() {
4504				var queue = jQuery.queue( this, type, data );
4505
4506				// Ensure a hooks for this queue
4507				jQuery._queueHooks( this, type );
4508
4509				if ( type === "fx" && queue[ 0 ] !== "inprogress" ) {
4510					jQuery.dequeue( this, type );
4511				}
4512			} );
4513	},
4514	dequeue: function( type ) {
4515		return this.each( function() {
4516			jQuery.dequeue( this, type );
4517		} );
4518	},
4519	clearQueue: function( type ) {
4520		return this.queue( type || "fx", [] );
4521	},
4522
4523	// Get a promise resolved when queues of a certain type
4524	// are emptied (fx is the type by default)
4525	promise: function( type, obj ) {
4526		var tmp,
4527			count = 1,
4528			defer = jQuery.Deferred(),
4529			elements = this,
4530			i = this.length,
4531			resolve = function() {
4532				if ( !( --count ) ) {
4533					defer.resolveWith( elements, [ elements ] );
4534				}
4535			};
4536
4537		if ( typeof type !== "string" ) {
4538			obj = type;
4539			type = undefined;
4540		}
4541		type = type || "fx";
4542
4543		while ( i-- ) {
4544			tmp = dataPriv.get( elements[ i ], type + "queueHooks" );
4545			if ( tmp && tmp.empty ) {
4546				count++;
4547				tmp.empty.add( resolve );
4548			}
4549		}
4550		resolve();
4551		return defer.promise( obj );
4552	}
4553} );
4554var pnum = ( /[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/ ).source;
4555
4556var rcssNum = new RegExp( "^(?:([+-])=|)(" + pnum + ")([a-z%]*)$", "i" );
4557
4558
4559var cssExpand = [ "Top", "Right", "Bottom", "Left" ];
4560
4561var isHiddenWithinTree = function( elem, el ) {
4562
4563		// isHiddenWithinTree might be called from jQuery#filter function;
4564		// in that case, element will be second argument
4565		elem = el || elem;
4566
4567		// Inline style trumps all
4568		return elem.style.display === "none" ||
4569			elem.style.display === "" &&
4570
4571			// Otherwise, check computed style
4572			// Support: Firefox <=43 - 45
4573			// Disconnected elements can have computed display: none, so first confirm that elem is
4574			// in the document.
4575			jQuery.contains( elem.ownerDocument, elem ) &&
4576
4577			jQuery.css( elem, "display" ) === "none";
4578	};
4579
4580var swap = function( elem, options, callback, args ) {
4581	var ret, name,
4582		old = {};
4583
4584	// Remember the old values, and insert the new ones
4585	for ( name in options ) {
4586		old[ name ] = elem.style[ name ];
4587		elem.style[ name ] = options[ name ];
4588	}
4589
4590	ret = callback.apply( elem, args || [] );
4591
4592	// Revert the old values
4593	for ( name in options ) {
4594		elem.style[ name ] = old[ name ];
4595	}
4596
4597	return ret;
4598};
4599
4600
4601
4602
4603function adjustCSS( elem, prop, valueParts, tween ) {
4604	var adjusted,
4605		scale = 1,
4606		maxIterations = 20,
4607		currentValue = tween ?
4608			function() {
4609				return tween.cur();
4610			} :
4611			function() {
4612				return jQuery.css( elem, prop, "" );
4613			},
4614		initial = currentValue(),
4615		unit = valueParts && valueParts[ 3 ] || ( jQuery.cssNumber[ prop ] ? "" : "px" ),
4616
4617		// Starting value computation is required for potential unit mismatches
4618		initialInUnit = ( jQuery.cssNumber[ prop ] || unit !== "px" && +initial ) &&
4619			rcssNum.exec( jQuery.css( elem, prop ) );
4620
4621	if ( initialInUnit && initialInUnit[ 3 ] !== unit ) {
4622
4623		// Trust units reported by jQuery.css
4624		unit = unit || initialInUnit[ 3 ];
4625
4626		// Make sure we update the tween properties later on
4627		valueParts = valueParts || [];
4628
4629		// Iteratively approximate from a nonzero starting point
4630		initialInUnit = +initial || 1;
4631
4632		do {
4633
4634			// If previous iteration zeroed out, double until we get *something*.
4635			// Use string for doubling so we don't accidentally see scale as unchanged below
4636			scale = scale || ".5";
4637
4638			// Adjust and apply
4639			initialInUnit = initialInUnit / scale;
4640			jQuery.style( elem, prop, initialInUnit + unit );
4641
4642		// Update scale, tolerating zero or NaN from tween.cur()
4643		// Break the loop if scale is unchanged or perfect, or if we've just had enough.
4644		} while (
4645			scale !== ( scale = currentValue() / initial ) && scale !== 1 && --maxIterations
4646		);
4647	}
4648
4649	if ( valueParts ) {
4650		initialInUnit = +initialInUnit || +initial || 0;
4651
4652		// Apply relative offset (+=/-=) if specified
4653		adjusted = valueParts[ 1 ] ?
4654			initialInUnit + ( valueParts[ 1 ] + 1 ) * valueParts[ 2 ] :
4655			+valueParts[ 2 ];
4656		if ( tween ) {
4657			tween.unit = unit;
4658			tween.start = initialInUnit;
4659			tween.end = adjusted;
4660		}
4661	}
4662	return adjusted;
4663}
4664
4665
4666var defaultDisplayMap = {};
4667
4668function getDefaultDisplay( elem ) {
4669	var temp,
4670		doc = elem.ownerDocument,
4671		nodeName = elem.nodeName,
4672		display = defaultDisplayMap[ nodeName ];
4673
4674	if ( display ) {
4675		return display;
4676	}
4677
4678	temp = doc.body.appendChild( doc.createElement( nodeName ) );
4679	display = jQuery.css( temp, "display" );
4680
4681	temp.parentNode.removeChild( temp );
4682
4683	if ( display === "none" ) {
4684		display = "block";
4685	}
4686	defaultDisplayMap[ nodeName ] = display;
4687
4688	return display;
4689}
4690
4691function showHide( elements, show ) {
4692	var display, elem,
4693		values = [],
4694		index = 0,
4695		length = elements.length;
4696
4697	// Determine new display value for elements that need to change
4698	for ( ; index < length; index++ ) {
4699		elem = elements[ index ];
4700		if ( !elem.style ) {
4701			continue;
4702		}
4703
4704		display = elem.style.display;
4705		if ( show ) {
4706
4707			// Since we force visibility upon cascade-hidden elements, an immediate (and slow)
4708			// check is required in this first loop unless we have a nonempty display value (either
4709			// inline or about-to-be-restored)
4710			if ( display === "none" ) {
4711				values[ index ] = dataPriv.get( elem, "display" ) || null;
4712				if ( !values[ index ] ) {
4713					elem.style.display = "";
4714				}
4715			}
4716			if ( elem.style.display === "" && isHiddenWithinTree( elem ) ) {
4717				values[ index ] = getDefaultDisplay( elem );
4718			}
4719		} else {
4720			if ( display !== "none" ) {
4721				values[ index ] = "none";
4722
4723				// Remember what we're overwriting
4724				dataPriv.set( elem, "display", display );
4725			}
4726		}
4727	}
4728
4729	// Set the display of the elements in a second loop to avoid constant reflow
4730	for ( index = 0; index < length; index++ ) {
4731		if ( values[ index ] != null ) {
4732			elements[ index ].style.display = values[ index ];
4733		}
4734	}
4735
4736	return elements;
4737}
4738
4739jQuery.fn.extend( {
4740	show: function() {
4741		return showHide( this, true );
4742	},
4743	hide: function() {
4744		return showHide( this );
4745	},
4746	toggle: function( state ) {
4747		if ( typeof state === "boolean" ) {
4748			return state ? this.show() : this.hide();
4749		}
4750
4751		return this.each( function() {
4752			if ( isHiddenWithinTree( this ) ) {
4753				jQuery( this ).show();
4754			} else {
4755				jQuery( this ).hide();
4756			}
4757		} );
4758	}
4759} );
4760var rcheckableType = ( /^(?:checkbox|radio)$/i );
4761
4762var rtagName = ( /<([a-z][^\/\0>\x20\t\r\n\f]+)/i );
4763
4764var rscriptType = ( /^$|\/(?:java|ecma)script/i );
4765
4766
4767
4768// We have to close these tags to support XHTML (#13200)
4769var wrapMap = {
4770
4771	// Support: IE <=9 only
4772	option: [ 1, "<select multiple='multiple'>", "</select>" ],
4773
4774	// XHTML parsers do not magically insert elements in the
4775	// same way that tag soup parsers do. So we cannot shorten
4776	// this by omitting <tbody> or other required elements.
4777	thead: [ 1, "<table>", "</table>" ],
4778	col: [ 2, "<table><colgroup>", "</colgroup></table>" ],
4779	tr: [ 2, "<table><tbody>", "</tbody></table>" ],
4780	td: [ 3, "<table><tbody><tr>", "</tr></tbody></table>" ],
4781
4782	_default: [ 0, "", "" ]
4783};
4784
4785// Support: IE <=9 only
4786wrapMap.optgroup = wrapMap.option;
4787
4788wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;
4789wrapMap.th = wrapMap.td;
4790
4791
4792function getAll( context, tag ) {
4793
4794	// Support: IE <=9 - 11 only
4795	// Use typeof to avoid zero-argument method invocation on host objects (#15151)
4796	var ret;
4797
4798	if ( typeof context.getElementsByTagName !== "undefined" ) {
4799		ret = context.getElementsByTagName( tag || "*" );
4800
4801	} else if ( typeof context.querySelectorAll !== "undefined" ) {
4802		ret = context.querySelectorAll( tag || "*" );
4803
4804	} else {
4805		ret = [];
4806	}
4807
4808	if ( tag === undefined || tag && jQuery.nodeName( context, tag ) ) {
4809		return jQuery.merge( [ context ], ret );
4810	}
4811
4812	return ret;
4813}
4814
4815
4816// Mark scripts as having already been evaluated
4817function setGlobalEval( elems, refElements ) {
4818	var i = 0,
4819		l = elems.length;
4820
4821	for ( ; i < l; i++ ) {
4822		dataPriv.set(
4823			elems[ i ],
4824			"globalEval",
4825			!refElements || dataPriv.get( refElements[ i ], "globalEval" )
4826		);
4827	}
4828}
4829
4830
4831var rhtml = /<|&#?\w+;/;
4832
4833function buildFragment( elems, context, scripts, selection, ignored ) {
4834	var elem, tmp, tag, wrap, contains, j,
4835		fragment = context.createDocumentFragment(),
4836		nodes = [],
4837		i = 0,
4838		l = elems.length;
4839
4840	for ( ; i < l; i++ ) {
4841		elem = elems[ i ];
4842
4843		if ( elem || elem === 0 ) {
4844
4845			// Add nodes directly
4846			if ( jQuery.type( elem ) === "object" ) {
4847
4848				// Support: Android <=4.0 only, PhantomJS 1 only
4849				// push.apply(_, arraylike) throws on ancient WebKit
4850				jQuery.merge( nodes, elem.nodeType ? [ elem ] : elem );
4851
4852			// Convert non-html into a text node
4853			} else if ( !rhtml.test( elem ) ) {
4854				nodes.push( context.createTextNode( elem ) );
4855
4856			// Convert html into DOM nodes
4857			} else {
4858				tmp = tmp || fragment.appendChild( context.createElement( "div" ) );
4859
4860				// Deserialize a standard representation
4861				tag = ( rtagName.exec( elem ) || [ "", "" ] )[ 1 ].toLowerCase();
4862				wrap = wrapMap[ tag ] || wrapMap._default;
4863				tmp.innerHTML = wrap[ 1 ] + jQuery.htmlPrefilter( elem ) + wrap[ 2 ];
4864
4865				// Descend through wrappers to the right content
4866				j = wrap[ 0 ];
4867				while ( j-- ) {
4868					tmp = tmp.lastChild;
4869				}
4870
4871				// Support: Android <=4.0 only, PhantomJS 1 only
4872				// push.apply(_, arraylike) throws on ancient WebKit
4873				jQuery.merge( nodes, tmp.childNodes );
4874
4875				// Remember the top-level container
4876				tmp = fragment.firstChild;
4877
4878				// Ensure the created nodes are orphaned (#12392)
4879				tmp.textContent = "";
4880			}
4881		}
4882	}
4883
4884	// Remove wrapper from fragment
4885	fragment.textContent = "";
4886
4887	i = 0;
4888	while ( ( elem = nodes[ i++ ] ) ) {
4889
4890		// Skip elements already in the context collection (trac-4087)
4891		if ( selection && jQuery.inArray( elem, selection ) > -1 ) {
4892			if ( ignored ) {
4893				ignored.push( elem );
4894			}
4895			continue;
4896		}
4897
4898		contains = jQuery.contains( elem.ownerDocument, elem );
4899
4900		// Append to fragment
4901		tmp = getAll( fragment.appendChild( elem ), "script" );
4902
4903		// Preserve script evaluation history
4904		if ( contains ) {
4905			setGlobalEval( tmp );
4906		}
4907
4908		// Capture executables
4909		if ( scripts ) {
4910			j = 0;
4911			while ( ( elem = tmp[ j++ ] ) ) {
4912				if ( rscriptType.test( elem.type || "" ) ) {
4913					scripts.push( elem );
4914				}
4915			}
4916		}
4917	}
4918
4919	return fragment;
4920}
4921
4922
4923( function() {
4924	var fragment = document.createDocumentFragment(),
4925		div = fragment.appendChild( document.createElement( "div" ) ),
4926		input = document.createElement( "input" );
4927
4928	// Support: Android 4.0 - 4.3 only
4929	// Check state lost if the name is set (#11217)
4930	// Support: Windows Web Apps (WWA)
4931	// `name` and `type` must use .setAttribute for WWA (#14901)
4932	input.setAttribute( "type", "radio" );
4933	input.setAttribute( "checked", "checked" );
4934	input.setAttribute( "name", "t" );
4935
4936	div.appendChild( input );
4937
4938	// Support: Android <=4.1 only
4939	// Older WebKit doesn't clone checked state correctly in fragments
4940	support.checkClone = div.cloneNode( true ).cloneNode( true ).lastChild.checked;
4941
4942	// Support: IE <=11 only
4943	// Make sure textarea (and checkbox) defaultValue is properly cloned
4944	div.innerHTML = "<textarea>x</textarea>";
4945	support.noCloneChecked = !!div.cloneNode( true ).lastChild.defaultValue;
4946} )();
4947var documentElement = document.documentElement;
4948
4949
4950
4951var
4952	rkeyEvent = /^key/,
4953	rmouseEvent = /^(?:mouse|pointer|contextmenu|drag|drop)|click/,
4954	rtypenamespace = /^([^.]*)(?:\.(.+)|)/;
4955
4956function returnTrue() {
4957	return true;
4958}
4959
4960function returnFalse() {
4961	return false;
4962}
4963
4964// Support: IE <=9 only
4965// See #13393 for more info
4966function safeActiveElement() {
4967	try {
4968		return document.activeElement;
4969	} catch ( err ) { }
4970}
4971
4972function on( elem, types, selector, data, fn, one ) {
4973	var origFn, type;
4974
4975	// Types can be a map of types/handlers
4976	if ( typeof types === "object" ) {
4977
4978		// ( types-Object, selector, data )
4979		if ( typeof selector !== "string" ) {
4980
4981			// ( types-Object, data )
4982			data = data || selector;
4983			selector = undefined;
4984		}
4985		for ( type in types ) {
4986			on( elem, type, selector, data, types[ type ], one );
4987		}
4988		return elem;
4989	}
4990
4991	if ( data == null && fn == null ) {
4992
4993		// ( types, fn )
4994		fn = selector;
4995		data = selector = undefined;
4996	} else if ( fn == null ) {
4997		if ( typeof selector === "string" ) {
4998
4999			// ( types, selector, fn )
5000			fn = data;
5001			data = undefined;
5002		} else {
5003
5004			// ( types, data, fn )
5005			fn = data;
5006			data = selector;
5007			selector = undefined;
5008		}
5009	}
5010	if ( fn === false ) {
5011		fn = returnFalse;
5012	} else if ( !fn ) {
5013		return elem;
5014	}
5015
5016	if ( one === 1 ) {
5017		origFn = fn;
5018		fn = function( event ) {
5019
5020			// Can use an empty set, since event contains the info
5021			jQuery().off( event );
5022			return origFn.apply( this, arguments );
5023		};
5024
5025		// Use same guid so caller can remove using origFn
5026		fn.guid = origFn.guid || ( origFn.guid = jQuery.guid++ );
5027	}
5028	return elem.each( function() {
5029		jQuery.event.add( this, types, fn, data, selector );
5030	} );
5031}
5032
5033/*
5034 * Helper functions for managing events -- not part of the public interface.
5035 * Props to Dean Edwards' addEvent library for many of the ideas.
5036 */
5037jQuery.event = {
5038
5039	global: {},
5040
5041	add: function( elem, types, handler, data, selector ) {
5042
5043		var handleObjIn, eventHandle, tmp,
5044			events, t, handleObj,
5045			special, handlers, type, namespaces, origType,
5046			elemData = dataPriv.get( elem );
5047
5048		// Don't attach events to noData or text/comment nodes (but allow plain objects)
5049		if ( !elemData ) {
5050			return;
5051		}
5052
5053		// Caller can pass in an object of custom data in lieu of the handler
5054		if ( handler.handler ) {
5055			handleObjIn = handler;
5056			handler = handleObjIn.handler;
5057			selector = handleObjIn.selector;
5058		}
5059
5060		// Ensure that invalid selectors throw exceptions at attach time
5061		// Evaluate against documentElement in case elem is a non-element node (e.g., document)
5062		if ( selector ) {
5063			jQuery.find.matchesSelector( documentElement, selector );
5064		}
5065
5066		// Make sure that the handler has a unique ID, used to find/remove it later
5067		if ( !handler.guid ) {
5068			handler.guid = jQuery.guid++;
5069		}
5070
5071		// Init the element's event structure and main handler, if this is the first
5072		if ( !( events = elemData.events ) ) {
5073			events = elemData.events = {};
5074		}
5075		if ( !( eventHandle = elemData.handle ) ) {
5076			eventHandle = elemData.handle = function( e ) {
5077
5078				// Discard the second event of a jQuery.event.trigger() and
5079				// when an event is called after a page has unloaded
5080				return typeof jQuery !== "undefined" && jQuery.event.triggered !== e.type ?
5081					jQuery.event.dispatch.apply( elem, arguments ) : undefined;
5082			};
5083		}
5084
5085		// Handle multiple events separated by a space
5086		types = ( types || "" ).match( rnothtmlwhite ) || [ "" ];
5087		t = types.length;
5088		while ( t-- ) {
5089			tmp = rtypenamespace.exec( types[ t ] ) || [];
5090			type = origType = tmp[ 1 ];
5091			namespaces = ( tmp[ 2 ] || "" ).split( "." ).sort();
5092
5093			// There *must* be a type, no attaching namespace-only handlers
5094			if ( !type ) {
5095				continue;
5096			}
5097
5098			// If event changes its type, use the special event handlers for the changed type
5099			special = jQuery.event.special[ type ] || {};
5100
5101			// If selector defined, determine special event api type, otherwise given type
5102			type = ( selector ? special.delegateType : special.bindType ) || type;
5103
5104			// Update special based on newly reset type
5105			special = jQuery.event.special[ type ] || {};
5106
5107			// handleObj is passed to all event handlers
5108			handleObj = jQuery.extend( {
5109				type: type,
5110				origType: origType,
5111				data: data,
5112				handler: handler,
5113				guid: handler.guid,
5114				selector: selector,
5115				needsContext: selector && jQuery.expr.match.needsContext.test( selector ),
5116				namespace: namespaces.join( "." )
5117			}, handleObjIn );
5118
5119			// Init the event handler queue if we're the first
5120			if ( !( handlers = events[ type ] ) ) {
5121				handlers = events[ type ] = [];
5122				handlers.delegateCount = 0;
5123
5124				// Only use addEventListener if the special events handler returns false
5125				if ( !special.setup ||
5126					special.setup.call( elem, data, namespaces, eventHandle ) === false ) {
5127
5128					if ( elem.addEventListener ) {
5129						elem.addEventListener( type, eventHandle );
5130					}
5131				}
5132			}
5133
5134			if ( special.add ) {
5135				special.add.call( elem, handleObj );
5136
5137				if ( !handleObj.handler.guid ) {
5138					handleObj.handler.guid = handler.guid;
5139				}
5140			}
5141
5142			// Add to the element's handler list, delegates in front
5143			if ( selector ) {
5144				handlers.splice( handlers.delegateCount++, 0, handleObj );
5145			} else {
5146				handlers.push( handleObj );
5147			}
5148
5149			// Keep track of which events have ever been used, for event optimization
5150			jQuery.event.global[ type ] = true;
5151		}
5152
5153	},
5154
5155	// Detach an event or set of events from an element
5156	remove: function( elem, types, handler, selector, mappedTypes ) {
5157
5158		var j, origCount, tmp,
5159			events, t, handleObj,
5160			special, handlers, type, namespaces, origType,
5161			elemData = dataPriv.hasData( elem ) && dataPriv.get( elem );
5162
5163		if ( !elemData || !( events = elemData.events ) ) {
5164			return;
5165		}
5166
5167		// Once for each type.namespace in types; type may be omitted
5168		types = ( types || "" ).match( rnothtmlwhite ) || [ "" ];
5169		t = types.length;
5170		while ( t-- ) {
5171			tmp = rtypenamespace.exec( types[ t ] ) || [];
5172			type = origType = tmp[ 1 ];
5173			namespaces = ( tmp[ 2 ] || "" ).split( "." ).sort();
5174
5175			// Unbind all events (on this namespace, if provided) for the element
5176			if ( !type ) {
5177				for ( type in events ) {
5178					jQuery.event.remove( elem, type + types[ t ], handler, selector, true );
5179				}
5180				continue;
5181			}
5182
5183			special = jQuery.event.special[ type ] || {};
5184			type = ( selector ? special.delegateType : special.bindType ) || type;
5185			handlers = events[ type ] || [];
5186			tmp = tmp[ 2 ] &&
5187				new RegExp( "(^|\\.)" + namespaces.join( "\\.(?:.*\\.|)" ) + "(\\.|$)" );
5188
5189			// Remove matching events
5190			origCount = j = handlers.length;
5191			while ( j-- ) {
5192				handleObj = handlers[ j ];
5193
5194				if ( ( mappedTypes || origType === handleObj.origType ) &&
5195					( !handler || handler.guid === handleObj.guid ) &&
5196					( !tmp || tmp.test( handleObj.namespace ) ) &&
5197					( !selector || selector === handleObj.selector ||
5198						selector === "**" && handleObj.selector ) ) {
5199					handlers.splice( j, 1 );
5200
5201					if ( handleObj.selector ) {
5202						handlers.delegateCount--;
5203					}
5204					if ( special.remove ) {
5205						special.remove.call( elem, handleObj );
5206					}
5207				}
5208			}
5209
5210			// Remove generic event handler if we removed something and no more handlers exist
5211			// (avoids potential for endless recursion during removal of special event handlers)
5212			if ( origCount && !handlers.length ) {
5213				if ( !special.teardown ||
5214					special.teardown.call( elem, namespaces, elemData.handle ) === false ) {
5215
5216					jQuery.removeEvent( elem, type, elemData.handle );
5217				}
5218
5219				delete events[ type ];
5220			}
5221		}
5222
5223		// Remove data and the expando if it's no longer used
5224		if ( jQuery.isEmptyObject( events ) ) {
5225			dataPriv.remove( elem, "handle events" );
5226		}
5227	},
5228
5229	dispatch: function( nativeEvent ) {
5230
5231		// Make a writable jQuery.Event from the native event object
5232		var event = jQuery.event.fix( nativeEvent );
5233
5234		var i, j, ret, matched, handleObj, handlerQueue,
5235			args = new Array( arguments.length ),
5236			handlers = ( dataPriv.get( this, "events" ) || {} )[ event.type ] || [],
5237			special = jQuery.event.special[ event.type ] || {};
5238
5239		// Use the fix-ed jQuery.Event rather than the (read-only) native event
5240		args[ 0 ] = event;
5241
5242		for ( i = 1; i < arguments.length; i++ ) {
5243			args[ i ] = arguments[ i ];
5244		}
5245
5246		event.delegateTarget = this;
5247
5248		// Call the preDispatch hook for the mapped type, and let it bail if desired
5249		if ( special.preDispatch && special.preDispatch.call( this, event ) === false ) {
5250			return;
5251		}
5252
5253		// Determine handlers
5254		handlerQueue = jQuery.event.handlers.call( this, event, handlers );
5255
5256		// Run delegates first; they may want to stop propagation beneath us
5257		i = 0;
5258		while ( ( matched = handlerQueue[ i++ ] ) && !event.isPropagationStopped() ) {
5259			event.currentTarget = matched.elem;
5260
5261			j = 0;
5262			while ( ( handleObj = matched.handlers[ j++ ] ) &&
5263				!event.isImmediatePropagationStopped() ) {
5264
5265				// Triggered event must either 1) have no namespace, or 2) have namespace(s)
5266				// a subset or equal to those in the bound event (both can have no namespace).
5267				if ( !event.rnamespace || event.rnamespace.test( handleObj.namespace ) ) {
5268
5269					event.handleObj = handleObj;
5270					event.data = handleObj.data;
5271
5272					ret = ( ( jQuery.event.special[ handleObj.origType ] || {} ).handle ||
5273						handleObj.handler ).apply( matched.elem, args );
5274
5275					if ( ret !== undefined ) {
5276						if ( ( event.result = ret ) === false ) {
5277							event.preventDefault();
5278							event.stopPropagation();
5279						}
5280					}
5281				}
5282			}
5283		}
5284
5285		// Call the postDispatch hook for the mapped type
5286		if ( special.postDispatch ) {
5287			special.postDispatch.call( this, event );
5288		}
5289
5290		return event.result;
5291	},
5292
5293	handlers: function( event, handlers ) {
5294		var i, handleObj, sel, matchedHandlers, matchedSelectors,
5295			handlerQueue = [],
5296			delegateCount = handlers.delegateCount,
5297			cur = event.target;
5298
5299		// Find delegate handlers
5300		if ( delegateCount &&
5301
5302			// Support: IE <=9
5303			// Black-hole SVG <use> instance trees (trac-13180)
5304			cur.nodeType &&
5305
5306			// Support: Firefox <=42
5307			// Suppress spec-violating clicks indicating a non-primary pointer button (trac-3861)
5308			// https://www.w3.org/TR/DOM-Level-3-Events/#event-type-click
5309			// Support: IE 11 only
5310			// ...but not arrow key "clicks" of radio inputs, which can have `button` -1 (gh-2343)
5311			!( event.type === "click" && event.button >= 1 ) ) {
5312
5313			for ( ; cur !== this; cur = cur.parentNode || this ) {
5314
5315				// Don't check non-elements (#13208)
5316				// Don't process clicks on disabled elements (#6911, #8165, #11382, #11764)
5317				if ( cur.nodeType === 1 && !( event.type === "click" && cur.disabled === true ) ) {
5318					matchedHandlers = [];
5319					matchedSelectors = {};
5320					for ( i = 0; i < delegateCount; i++ ) {
5321						handleObj = handlers[ i ];
5322
5323						// Don't conflict with Object.prototype properties (#13203)
5324						sel = handleObj.selector + " ";
5325
5326						if ( matchedSelectors[ sel ] === undefined ) {
5327							matchedSelectors[ sel ] = handleObj.needsContext ?
5328								jQuery( sel, this ).index( cur ) > -1 :
5329								jQuery.find( sel, this, null, [ cur ] ).length;
5330						}
5331						if ( matchedSelectors[ sel ] ) {
5332							matchedHandlers.push( handleObj );
5333						}
5334					}
5335					if ( matchedHandlers.length ) {
5336						handlerQueue.push( { elem: cur, handlers: matchedHandlers } );
5337					}
5338				}
5339			}
5340		}
5341
5342		// Add the remaining (directly-bound) handlers
5343		cur = this;
5344		if ( delegateCount < handlers.length ) {
5345			handlerQueue.push( { elem: cur, handlers: handlers.slice( delegateCount ) } );
5346		}
5347
5348		return handlerQueue;
5349	},
5350
5351	addProp: function( name, hook ) {
5352		Object.defineProperty( jQuery.Event.prototype, name, {
5353			enumerable: true,
5354			configurable: true,
5355
5356			get: jQuery.isFunction( hook ) ?
5357				function() {
5358					if ( this.originalEvent ) {
5359							return hook( this.originalEvent );
5360					}
5361				} :
5362				function() {
5363					if ( this.originalEvent ) {
5364							return this.originalEvent[ name ];
5365					}
5366				},
5367
5368			set: function( value ) {
5369				Object.defineProperty( this, name, {
5370					enumerable: true,
5371					configurable: true,
5372					writable: true,
5373					value: value
5374				} );
5375			}
5376		} );
5377	},
5378
5379	fix: function( originalEvent ) {
5380		return originalEvent[ jQuery.expando ] ?
5381			originalEvent :
5382			new jQuery.Event( originalEvent );
5383	},
5384
5385	special: {
5386		load: {
5387
5388			// Prevent triggered image.load events from bubbling to window.load
5389			noBubble: true
5390		},
5391		focus: {
5392
5393			// Fire native event if possible so blur/focus sequence is correct
5394			trigger: function() {
5395				if ( this !== safeActiveElement() && this.focus ) {
5396					this.focus();
5397					return false;
5398				}
5399			},
5400			delegateType: "focusin"
5401		},
5402		blur: {
5403			trigger: function() {
5404				if ( this === safeActiveElement() && this.blur ) {
5405					this.blur();
5406					return false;
5407				}
5408			},
5409			delegateType: "focusout"
5410		},
5411		click: {
5412
5413			// For checkbox, fire native event so checked state will be right
5414			trigger: function() {
5415				if ( this.type === "checkbox" && this.click && jQuery.nodeName( this, "input" ) ) {
5416					this.click();
5417					return false;
5418				}
5419			},
5420
5421			// For cross-browser consistency, don't fire native .click() on links
5422			_default: function( event ) {
5423				return jQuery.nodeName( event.target, "a" );
5424			}
5425		},
5426
5427		beforeunload: {
5428			postDispatch: function( event ) {
5429
5430				// Support: Firefox 20+
5431				// Firefox doesn't alert if the returnValue field is not set.
5432				if ( event.result !== undefined && event.originalEvent ) {
5433					event.originalEvent.returnValue = event.result;
5434				}
5435			}
5436		}
5437	}
5438};
5439
5440jQuery.removeEvent = function( elem, type, handle ) {
5441
5442	// This "if" is needed for plain objects
5443	if ( elem.removeEventListener ) {
5444		elem.removeEventListener( type, handle );
5445	}
5446};
5447
5448jQuery.Event = function( src, props ) {
5449
5450	// Allow instantiation without the 'new' keyword
5451	if ( !( this instanceof jQuery.Event ) ) {
5452		return new jQuery.Event( src, props );
5453	}
5454
5455	// Event object
5456	if ( src && src.type ) {
5457		this.originalEvent = src;
5458		this.type = src.type;
5459
5460		// Events bubbling up the document may have been marked as prevented
5461		// by a handler lower down the tree; reflect the correct value.
5462		this.isDefaultPrevented = src.defaultPrevented ||
5463				src.defaultPrevented === undefined &&
5464
5465				// Support: Android <=2.3 only
5466				src.returnValue === false ?
5467			returnTrue :
5468			returnFalse;
5469
5470		// Create target properties
5471		// Support: Safari <=6 - 7 only
5472		// Target should not be a text node (#504, #13143)
5473		this.target = ( src.target && src.target.nodeType === 3 ) ?
5474			src.target.parentNode :
5475			src.target;
5476
5477		this.currentTarget = src.currentTarget;
5478		this.relatedTarget = src.relatedTarget;
5479
5480	// Event type
5481	} else {
5482		this.type = src;
5483	}
5484
5485	// Put explicitly provided properties onto the event object
5486	if ( props ) {
5487		jQuery.extend( this, props );
5488	}
5489
5490	// Create a timestamp if incoming event doesn't have one
5491	this.timeStamp = src && src.timeStamp || jQuery.now();
5492
5493	// Mark it as fixed
5494	this[ jQuery.expando ] = true;
5495};
5496
5497// jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding
5498// https://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html
5499jQuery.Event.prototype = {
5500	constructor: jQuery.Event,
5501	isDefaultPrevented: returnFalse,
5502	isPropagationStopped: returnFalse,
5503	isImmediatePropagationStopped: returnFalse,
5504	isSimulated: false,
5505
5506	preventDefault: function() {
5507		var e = this.originalEvent;
5508
5509		this.isDefaultPrevented = returnTrue;
5510
5511		if ( e && !this.isSimulated ) {
5512			e.preventDefault();
5513		}
5514	},
5515	stopPropagation: function() {
5516		var e = this.originalEvent;
5517
5518		this.isPropagationStopped = returnTrue;
5519
5520		if ( e && !this.isSimulated ) {
5521			e.stopPropagation();
5522		}
5523	},
5524	stopImmediatePropagation: function() {
5525		var e = this.originalEvent;
5526
5527		this.isImmediatePropagationStopped = returnTrue;
5528
5529		if ( e && !this.isSimulated ) {
5530			e.stopImmediatePropagation();
5531		}
5532
5533		this.stopPropagation();
5534	}
5535};
5536
5537// Includes all common event props including KeyEvent and MouseEvent specific props
5538jQuery.each( {
5539	altKey: true,
5540	bubbles: true,
5541	cancelable: true,
5542	changedTouches: true,
5543	ctrlKey: true,
5544	detail: true,
5545	eventPhase: true,
5546	metaKey: true,
5547	pageX: true,
5548	pageY: true,
5549	shiftKey: true,
5550	view: true,
5551	"char": true,
5552	charCode: true,
5553	key: true,
5554	keyCode: true,
5555	button: true,
5556	buttons: true,
5557	clientX: true,
5558	clientY: true,
5559	offsetX: true,
5560	offsetY: true,
5561	pointerId: true,
5562	pointerType: true,
5563	screenX: true,
5564	screenY: true,
5565	targetTouches: true,
5566	toElement: true,
5567	touches: true,
5568
5569	which: function( event ) {
5570		var button = event.button;
5571
5572		// Add which for key events
5573		if ( event.which == null && rkeyEvent.test( event.type ) ) {
5574			return event.charCode != null ? event.charCode : event.keyCode;
5575		}
5576
5577		// Add which for click: 1 === left; 2 === middle; 3 === right
5578		if ( !event.which && button !== undefined && rmouseEvent.test( event.type ) ) {
5579			if ( button & 1 ) {
5580				return 1;
5581			}
5582
5583			if ( button & 2 ) {
5584				return 3;
5585			}
5586
5587			if ( button & 4 ) {
5588				return 2;
5589			}
5590
5591			return 0;
5592		}
5593
5594		return event.which;
5595	}
5596}, jQuery.event.addProp );
5597
5598// Create mouseenter/leave events using mouseover/out and event-time checks
5599// so that event delegation works in jQuery.
5600// Do the same for pointerenter/pointerleave and pointerover/pointerout
5601//
5602// Support: Safari 7 only
5603// Safari sends mouseenter too often; see:
5604// https://bugs.chromium.org/p/chromium/issues/detail?id=470258
5605// for the description of the bug (it existed in older Chrome versions as well).
5606jQuery.each( {
5607	mouseenter: "mouseover",
5608	mouseleave: "mouseout",
5609	pointerenter: "pointerover",
5610	pointerleave: "pointerout"
5611}, function( orig, fix ) {
5612	jQuery.event.special[ orig ] = {
5613		delegateType: fix,
5614		bindType: fix,
5615
5616		handle: function( event ) {
5617			var ret,
5618				target = this,
5619				related = event.relatedTarget,
5620				handleObj = event.handleObj;
5621
5622			// For mouseenter/leave call the handler if related is outside the target.
5623			// NB: No relatedTarget if the mouse left/entered the browser window
5624			if ( !related || ( related !== target && !jQuery.contains( target, related ) ) ) {
5625				event.type = handleObj.origType;
5626				ret = handleObj.handler.apply( this, arguments );
5627				event.type = fix;
5628			}
5629			return ret;
5630		}
5631	};
5632} );
5633
5634jQuery.fn.extend( {
5635
5636	on: function( types, selector, data, fn ) {
5637		return on( this, types, selector, data, fn );
5638	},
5639	one: function( types, selector, data, fn ) {
5640		return on( this, types, selector, data, fn, 1 );
5641	},
5642	off: function( types, selector, fn ) {
5643		var handleObj, type;
5644		if ( types && types.preventDefault && types.handleObj ) {
5645
5646			// ( event )  dispatched jQuery.Event
5647			handleObj = types.handleObj;
5648			jQuery( types.delegateTarget ).off(
5649				handleObj.namespace ?
5650					handleObj.origType + "." + handleObj.namespace :
5651					handleObj.origType,
5652				handleObj.selector,
5653				handleObj.handler
5654			);
5655			return this;
5656		}
5657		if ( typeof types === "object" ) {
5658
5659			// ( types-object [, selector] )
5660			for ( type in types ) {
5661				this.off( type, selector, types[ type ] );
5662			}
5663			return this;
5664		}
5665		if ( selector === false || typeof selector === "function" ) {
5666
5667			// ( types [, fn] )
5668			fn = selector;
5669			selector = undefined;
5670		}
5671		if ( fn === false ) {
5672			fn = returnFalse;
5673		}
5674		return this.each( function() {
5675			jQuery.event.remove( this, types, fn, selector );
5676		} );
5677	}
5678} );
5679
5680
5681var
5682
5683	/* eslint-disable max-len */
5684
5685	// See https://github.com/eslint/eslint/issues/3229
5686	rxhtmlTag = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([a-z][^\/\0>\x20\t\r\n\f]*)[^>]*)\/>/gi,
5687
5688	/* eslint-enable */
5689
5690	// Support: IE <=10 - 11, Edge 12 - 13
5691	// In IE/Edge using regex groups here causes severe slowdowns.
5692	// See https://connect.microsoft.com/IE/feedback/details/1736512/
5693	rnoInnerhtml = /<script|<style|<link/i,
5694
5695	// checked="checked" or checked
5696	rchecked = /checked\s*(?:[^=]|=\s*.checked.)/i,
5697	rscriptTypeMasked = /^true\/(.*)/,
5698	rcleanScript = /^\s*<!(?:\[CDATA\[|--)|(?:\]\]|--)>\s*$/g;
5699
5700function manipulationTarget( elem, content ) {
5701	if ( jQuery.nodeName( elem, "table" ) &&
5702		jQuery.nodeName( content.nodeType !== 11 ? content : content.firstChild, "tr" ) ) {
5703
5704		return elem.getElementsByTagName( "tbody" )[ 0 ] || elem;
5705	}
5706
5707	return elem;
5708}
5709
5710// Replace/restore the type attribute of script elements for safe DOM manipulation
5711function disableScript( elem ) {
5712	elem.type = ( elem.getAttribute( "type" ) !== null ) + "/" + elem.type;
5713	return elem;
5714}
5715function restoreScript( elem ) {
5716	var match = rscriptTypeMasked.exec( elem.type );
5717
5718	if ( match ) {
5719		elem.type = match[ 1 ];
5720	} else {
5721		elem.removeAttribute( "type" );
5722	}
5723
5724	return elem;
5725}
5726
5727function cloneCopyEvent( src, dest ) {
5728	var i, l, type, pdataOld, pdataCur, udataOld, udataCur, events;
5729
5730	if ( dest.nodeType !== 1 ) {
5731		return;
5732	}
5733
5734	// 1. Copy private data: events, handlers, etc.
5735	if ( dataPriv.hasData( src ) ) {
5736		pdataOld = dataPriv.access( src );
5737		pdataCur = dataPriv.set( dest, pdataOld );
5738		events = pdataOld.events;
5739
5740		if ( events ) {
5741			delete pdataCur.handle;
5742			pdataCur.events = {};
5743
5744			for ( type in events ) {
5745				for ( i = 0, l = events[ type ].length; i < l; i++ ) {
5746					jQuery.event.add( dest, type, events[ type ][ i ] );
5747				}
5748			}
5749		}
5750	}
5751
5752	// 2. Copy user data
5753	if ( dataUser.hasData( src ) ) {
5754		udataOld = dataUser.access( src );
5755		udataCur = jQuery.extend( {}, udataOld );
5756
5757		dataUser.set( dest, udataCur );
5758	}
5759}
5760
5761// Fix IE bugs, see support tests
5762function fixInput( src, dest ) {
5763	var nodeName = dest.nodeName.toLowerCase();
5764
5765	// Fails to persist the checked state of a cloned checkbox or radio button.
5766	if ( nodeName === "input" && rcheckableType.test( src.type ) ) {
5767		dest.checked = src.checked;
5768
5769	// Fails to return the selected option to the default selected state when cloning options
5770	} else if ( nodeName === "input" || nodeName === "textarea" ) {
5771		dest.defaultValue = src.defaultValue;
5772	}
5773}
5774
5775function domManip( collection, args, callback, ignored ) {
5776
5777	// Flatten any nested arrays
5778	args = concat.apply( [], args );
5779
5780	var fragment, first, scripts, hasScripts, node, doc,
5781		i = 0,
5782		l = collection.length,
5783		iNoClone = l - 1,
5784		value = args[ 0 ],
5785		isFunction = jQuery.isFunction( value );
5786
5787	// We can't cloneNode fragments that contain checked, in WebKit
5788	if ( isFunction ||
5789			( l > 1 && typeof value === "string" &&
5790				!support.checkClone && rchecked.test( value ) ) ) {
5791		return collection.each( function( index ) {
5792			var self = collection.eq( index );
5793			if ( isFunction ) {
5794				args[ 0 ] = value.call( this, index, self.html() );
5795			}
5796			domManip( self, args, callback, ignored );
5797		} );
5798	}
5799
5800	if ( l ) {
5801		fragment = buildFragment( args, collection[ 0 ].ownerDocument, false, collection, ignored );
5802		first = fragment.firstChild;
5803
5804		if ( fragment.childNodes.length === 1 ) {
5805			fragment = first;
5806		}
5807
5808		// Require either new content or an interest in ignored elements to invoke the callback
5809		if ( first || ignored ) {
5810			scripts = jQuery.map( getAll( fragment, "script" ), disableScript );
5811			hasScripts = scripts.length;
5812
5813			// Use the original fragment for the last item
5814			// instead of the first because it can end up
5815			// being emptied incorrectly in certain situations (#8070).
5816			for ( ; i < l; i++ ) {
5817				node = fragment;
5818
5819				if ( i !== iNoClone ) {
5820					node = jQuery.clone( node, true, true );
5821
5822					// Keep references to cloned scripts for later restoration
5823					if ( hasScripts ) {
5824
5825						// Support: Android <=4.0 only, PhantomJS 1 only
5826						// push.apply(_, arraylike) throws on ancient WebKit
5827						jQuery.merge( scripts, getAll( node, "script" ) );
5828					}
5829				}
5830
5831				callback.call( collection[ i ], node, i );
5832			}
5833
5834			if ( hasScripts ) {
5835				doc = scripts[ scripts.length - 1 ].ownerDocument;
5836
5837				// Reenable scripts
5838				jQuery.map( scripts, restoreScript );
5839
5840				// Evaluate executable scripts on first document insertion
5841				for ( i = 0; i < hasScripts; i++ ) {
5842					node = scripts[ i ];
5843					if ( rscriptType.test( node.type || "" ) &&
5844						!dataPriv.access( node, "globalEval" ) &&
5845						jQuery.contains( doc, node ) ) {
5846
5847						if ( node.src ) {
5848
5849							// Optional AJAX dependency, but won't run scripts if not present
5850							if ( jQuery._evalUrl ) {
5851								jQuery._evalUrl( node.src );
5852							}
5853						} else {
5854							DOMEval( node.textContent.replace( rcleanScript, "" ), doc );
5855						}
5856					}
5857				}
5858			}
5859		}
5860	}
5861
5862	return collection;
5863}
5864
5865function remove( elem, selector, keepData ) {
5866	var node,
5867		nodes = selector ? jQuery.filter( selector, elem ) : elem,
5868		i = 0;
5869
5870	for ( ; ( node = nodes[ i ] ) != null; i++ ) {
5871		if ( !keepData && node.nodeType === 1 ) {
5872			jQuery.cleanData( getAll( node ) );
5873		}
5874
5875		if ( node.parentNode ) {
5876			if ( keepData && jQuery.contains( node.ownerDocument, node ) ) {
5877				setGlobalEval( getAll( node, "script" ) );
5878			}
5879			node.parentNode.removeChild( node );
5880		}
5881	}
5882
5883	return elem;
5884}
5885
5886jQuery.extend( {
5887	htmlPrefilter: function( html ) {
5888		return html.replace( rxhtmlTag, "<$1></$2>" );
5889	},
5890
5891	clone: function( elem, dataAndEvents, deepDataAndEvents ) {
5892		var i, l, srcElements, destElements,
5893			clone = elem.cloneNode( true ),
5894			inPage = jQuery.contains( elem.ownerDocument, elem );
5895
5896		// Fix IE cloning issues
5897		if ( !support.noCloneChecked && ( elem.nodeType === 1 || elem.nodeType === 11 ) &&
5898				!jQuery.isXMLDoc( elem ) ) {
5899
5900			// We eschew Sizzle here for performance reasons: https://jsperf.com/getall-vs-sizzle/2
5901			destElements = getAll( clone );
5902			srcElements = getAll( elem );
5903
5904			for ( i = 0, l = srcElements.length; i < l; i++ ) {
5905				fixInput( srcElements[ i ], destElements[ i ] );
5906			}
5907		}
5908
5909		// Copy the events from the original to the clone
5910		if ( dataAndEvents ) {
5911			if ( deepDataAndEvents ) {
5912				srcElements = srcElements || getAll( elem );
5913				destElements = destElements || getAll( clone );
5914
5915				for ( i = 0, l = srcElements.length; i < l; i++ ) {
5916					cloneCopyEvent( srcElements[ i ], destElements[ i ] );
5917				}
5918			} else {
5919				cloneCopyEvent( elem, clone );
5920			}
5921		}
5922
5923		// Preserve script evaluation history
5924		destElements = getAll( clone, "script" );
5925		if ( destElements.length > 0 ) {
5926			setGlobalEval( destElements, !inPage && getAll( elem, "script" ) );
5927		}
5928
5929		// Return the cloned set
5930		return clone;
5931	},
5932
5933	cleanData: function( elems ) {
5934		var data, elem, type,
5935			special = jQuery.event.special,
5936			i = 0;
5937
5938		for ( ; ( elem = elems[ i ] ) !== undefined; i++ ) {
5939			if ( acceptData( elem ) ) {
5940				if ( ( data = elem[ dataPriv.expando ] ) ) {
5941					if ( data.events ) {
5942						for ( type in data.events ) {
5943							if ( special[ type ] ) {
5944								jQuery.event.remove( elem, type );
5945
5946							// This is a shortcut to avoid jQuery.event.remove's overhead
5947							} else {
5948								jQuery.removeEvent( elem, type, data.handle );
5949							}
5950						}
5951					}
5952
5953					// Support: Chrome <=35 - 45+
5954					// Assign undefined instead of using delete, see Data#remove
5955					elem[ dataPriv.expando ] = undefined;
5956				}
5957				if ( elem[ dataUser.expando ] ) {
5958
5959					// Support: Chrome <=35 - 45+
5960					// Assign undefined instead of using delete, see Data#remove
5961					elem[ dataUser.expando ] = undefined;
5962				}
5963			}
5964		}
5965	}
5966} );
5967
5968jQuery.fn.extend( {
5969	detach: function( selector ) {
5970		return remove( this, selector, true );
5971	},
5972
5973	remove: function( selector ) {
5974		return remove( this, selector );
5975	},
5976
5977	text: function( value ) {
5978		return access( this, function( value ) {
5979			return value === undefined ?
5980				jQuery.text( this ) :
5981				this.empty().each( function() {
5982					if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {
5983						this.textContent = value;
5984					}
5985				} );
5986		}, null, value, arguments.length );
5987	},
5988
5989	append: function() {
5990		return domManip( this, arguments, function( elem ) {
5991			if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {
5992				var target = manipulationTarget( this, elem );
5993				target.appendChild( elem );
5994			}
5995		} );
5996	},
5997
5998	prepend: function() {
5999		return domManip( this, arguments, function( elem ) {
6000			if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {
6001				var target = manipulationTarget( this, elem );
6002				target.insertBefore( elem, target.firstChild );
6003			}
6004		} );
6005	},
6006
6007	before: function() {
6008		return domManip( this, arguments, function( elem ) {
6009			if ( this.parentNode ) {
6010				this.parentNode.insertBefore( elem, this );
6011			}
6012		} );
6013	},
6014
6015	after: function() {
6016		return domManip( this, arguments, function( elem ) {
6017			if ( this.parentNode ) {
6018				this.parentNode.insertBefore( elem, this.nextSibling );
6019			}
6020		} );
6021	},
6022
6023	empty: function() {
6024		var elem,
6025			i = 0;
6026
6027		for ( ; ( elem = this[ i ] ) != null; i++ ) {
6028			if ( elem.nodeType === 1 ) {
6029
6030				// Prevent memory leaks
6031				jQuery.cleanData( getAll( elem, false ) );
6032
6033				// Remove any remaining nodes
6034				elem.textContent = "";
6035			}
6036		}
6037
6038		return this;
6039	},
6040
6041	clone: function( dataAndEvents, deepDataAndEvents ) {
6042		dataAndEvents = dataAndEvents == null ? false : dataAndEvents;
6043		deepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents;
6044
6045		return this.map( function() {
6046			return jQuery.clone( this, dataAndEvents, deepDataAndEvents );
6047		} );
6048	},
6049
6050	html: function( value ) {
6051		return access( this, function( value ) {
6052			var elem = this[ 0 ] || {},
6053				i = 0,
6054				l = this.length;
6055
6056			if ( value === undefined && elem.nodeType === 1 ) {
6057				return elem.innerHTML;
6058			}
6059
6060			// See if we can take a shortcut and just use innerHTML
6061			if ( typeof value === "string" && !rnoInnerhtml.test( value ) &&
6062				!wrapMap[ ( rtagName.exec( value ) || [ "", "" ] )[ 1 ].toLowerCase() ] ) {
6063
6064				value = jQuery.htmlPrefilter( value );
6065
6066				try {
6067					for ( ; i < l; i++ ) {
6068						elem = this[ i ] || {};
6069
6070						// Remove element nodes and prevent memory leaks
6071						if ( elem.nodeType === 1 ) {
6072							jQuery.cleanData( getAll( elem, false ) );
6073							elem.innerHTML = value;
6074						}
6075					}
6076
6077					elem = 0;
6078
6079				// If using innerHTML throws an exception, use the fallback method
6080				} catch ( e ) {}
6081			}
6082
6083			if ( elem ) {
6084				this.empty().append( value );
6085			}
6086		}, null, value, arguments.length );
6087	},
6088
6089	replaceWith: function() {
6090		var ignored = [];
6091
6092		// Make the changes, replacing each non-ignored context element with the new content
6093		return domManip( this, arguments, function( elem ) {
6094			var parent = this.parentNode;
6095
6096			if ( jQuery.inArray( this, ignored ) < 0 ) {
6097				jQuery.cleanData( getAll( this ) );
6098				if ( parent ) {
6099					parent.replaceChild( elem, this );
6100				}
6101			}
6102
6103		// Force callback invocation
6104		}, ignored );
6105	}
6106} );
6107
6108jQuery.each( {
6109	appendTo: "append",
6110	prependTo: "prepend",
6111	insertBefore: "before",
6112	insertAfter: "after",
6113	replaceAll: "replaceWith"
6114}, function( name, original ) {
6115	jQuery.fn[ name ] = function( selector ) {
6116		var elems,
6117			ret = [],
6118			insert = jQuery( selector ),
6119			last = insert.length - 1,
6120			i = 0;
6121
6122		for ( ; i <= last; i++ ) {
6123			elems = i === last ? this : this.clone( true );
6124			jQuery( insert[ i ] )[ original ]( elems );
6125
6126			// Support: Android <=4.0 only, PhantomJS 1 only
6127			// .get() because push.apply(_, arraylike) throws on ancient WebKit
6128			push.apply( ret, elems.get() );
6129		}
6130
6131		return this.pushStack( ret );
6132	};
6133} );
6134var rmargin = ( /^margin/ );
6135
6136var rnumnonpx = new RegExp( "^(" + pnum + ")(?!px)[a-z%]+$", "i" );
6137
6138var getStyles = function( elem ) {
6139
6140		// Support: IE <=11 only, Firefox <=30 (#15098, #14150)
6141		// IE throws on elements created in popups
6142		// FF meanwhile throws on frame elements through "defaultView.getComputedStyle"
6143		var view = elem.ownerDocument.defaultView;
6144
6145		if ( !view || !view.opener ) {
6146			view = window;
6147		}
6148
6149		return view.getComputedStyle( elem );
6150	};
6151
6152
6153
6154( function() {
6155
6156	// Executing both pixelPosition & boxSizingReliable tests require only one layout
6157	// so they're executed at the same time to save the second computation.
6158	function computeStyleTests() {
6159
6160		// This is a singleton, we need to execute it only once
6161		if ( !div ) {
6162			return;
6163		}
6164
6165		div.style.cssText =
6166			"box-sizing:border-box;" +
6167			"position:relative;display:block;" +
6168			"margin:auto;border:1px;padding:1px;" +
6169			"top:1%;width:50%";
6170		div.innerHTML = "";
6171		documentElement.appendChild( container );
6172
6173		var divStyle = window.getComputedStyle( div );
6174		pixelPositionVal = divStyle.top !== "1%";
6175
6176		// Support: Android 4.0 - 4.3 only, Firefox <=3 - 44
6177		reliableMarginLeftVal = divStyle.marginLeft === "2px";
6178		boxSizingReliableVal = divStyle.width === "4px";
6179
6180		// Support: Android 4.0 - 4.3 only
6181		// Some styles come back with percentage values, even though they shouldn't
6182		div.style.marginRight = "50%";
6183		pixelMarginRightVal = divStyle.marginRight === "4px";
6184
6185		documentElement.removeChild( container );
6186
6187		// Nullify the div so it wouldn't be stored in the memory and
6188		// it will also be a sign that checks already performed
6189		div = null;
6190	}
6191
6192	var pixelPositionVal, boxSizingReliableVal, pixelMarginRightVal, reliableMarginLeftVal,
6193		container = document.createElement( "div" ),
6194		div = document.createElement( "div" );
6195
6196	// Finish early in limited (non-browser) environments
6197	if ( !div.style ) {
6198		return;
6199	}
6200
6201	// Support: IE <=9 - 11 only
6202	// Style of cloned element affects source element cloned (#8908)
6203	div.style.backgroundClip = "content-box";
6204	div.cloneNode( true ).style.backgroundClip = "";
6205	support.clearCloneStyle = div.style.backgroundClip === "content-box";
6206
6207	container.style.cssText = "border:0;width:8px;height:0;top:0;left:-9999px;" +
6208		"padding:0;margin-top:1px;position:absolute";
6209	container.appendChild( div );
6210
6211	jQuery.extend( support, {
6212		pixelPosition: function() {
6213			computeStyleTests();
6214			return pixelPositionVal;
6215		},
6216		boxSizingReliable: function() {
6217			computeStyleTests();
6218			return boxSizingReliableVal;
6219		},
6220		pixelMarginRight: function() {
6221			computeStyleTests();
6222			return pixelMarginRightVal;
6223		},
6224		reliableMarginLeft: function() {
6225			computeStyleTests();
6226			return reliableMarginLeftVal;
6227		}
6228	} );
6229} )();
6230
6231
6232function curCSS( elem, name, computed ) {
6233	var width, minWidth, maxWidth, ret,
6234		style = elem.style;
6235
6236	computed = computed || getStyles( elem );
6237
6238	// Support: IE <=9 only
6239	// getPropertyValue is only needed for .css('filter') (#12537)
6240	if ( computed ) {
6241		ret = computed.getPropertyValue( name ) || computed[ name ];
6242
6243		if ( ret === "" && !jQuery.contains( elem.ownerDocument, elem ) ) {
6244			ret = jQuery.style( elem, name );
6245		}
6246
6247		// A tribute to the "awesome hack by Dean Edwards"
6248		// Android Browser returns percentage for some values,
6249		// but width seems to be reliably pixels.
6250		// This is against the CSSOM draft spec:
6251		// https://drafts.csswg.org/cssom/#resolved-values
6252		if ( !support.pixelMarginRight() && rnumnonpx.test( ret ) && rmargin.test( name ) ) {
6253
6254			// Remember the original values
6255			width = style.width;
6256			minWidth = style.minWidth;
6257			maxWidth = style.maxWidth;
6258
6259			// Put in the new values to get a computed value out
6260			style.minWidth = style.maxWidth = style.width = ret;
6261			ret = computed.width;
6262
6263			// Revert the changed values
6264			style.width = width;
6265			style.minWidth = minWidth;
6266			style.maxWidth = maxWidth;
6267		}
6268	}
6269
6270	return ret !== undefined ?
6271
6272		// Support: IE <=9 - 11 only
6273		// IE returns zIndex value as an integer.
6274		ret + "" :
6275		ret;
6276}
6277
6278
6279function addGetHookIf( conditionFn, hookFn ) {
6280
6281	// Define the hook, we'll check on the first run if it's really needed.
6282	return {
6283		get: function() {
6284			if ( conditionFn() ) {
6285
6286				// Hook not needed (or it's not possible to use it due
6287				// to missing dependency), remove it.
6288				delete this.get;
6289				return;
6290			}
6291
6292			// Hook needed; redefine it so that the support test is not executed again.
6293			return ( this.get = hookFn ).apply( this, arguments );
6294		}
6295	};
6296}
6297
6298
6299var
6300
6301	// Swappable if display is none or starts with table
6302	// except "table", "table-cell", or "table-caption"
6303	// See here for display values: https://developer.mozilla.org/en-US/docs/CSS/display
6304	rdisplayswap = /^(none|table(?!-c[ea]).+)/,
6305	cssShow = { position: "absolute", visibility: "hidden", display: "block" },
6306	cssNormalTransform = {
6307		letterSpacing: "0",
6308		fontWeight: "400"
6309	},
6310
6311	cssPrefixes = [ "Webkit", "Moz", "ms" ],
6312	emptyStyle = document.createElement( "div" ).style;
6313
6314// Return a css property mapped to a potentially vendor prefixed property
6315function vendorPropName( name ) {
6316
6317	// Shortcut for names that are not vendor prefixed
6318	if ( name in emptyStyle ) {
6319		return name;
6320	}
6321
6322	// Check for vendor prefixed names
6323	var capName = name[ 0 ].toUpperCase() + name.slice( 1 ),
6324		i = cssPrefixes.length;
6325
6326	while ( i-- ) {
6327		name = cssPrefixes[ i ] + capName;
6328		if ( name in emptyStyle ) {
6329			return name;
6330		}
6331	}
6332}
6333
6334function setPositiveNumber( elem, value, subtract ) {
6335
6336	// Any relative (+/-) values have already been
6337	// normalized at this point
6338	var matches = rcssNum.exec( value );
6339	return matches ?
6340
6341		// Guard against undefined "subtract", e.g., when used as in cssHooks
6342		Math.max( 0, matches[ 2 ] - ( subtract || 0 ) ) + ( matches[ 3 ] || "px" ) :
6343		value;
6344}
6345
6346function augmentWidthOrHeight( elem, name, extra, isBorderBox, styles ) {
6347	var i,
6348		val = 0;
6349
6350	// If we already have the right measurement, avoid augmentation
6351	if ( extra === ( isBorderBox ? "border" : "content" ) ) {
6352		i = 4;
6353
6354	// Otherwise initialize for horizontal or vertical properties
6355	} else {
6356		i = name === "width" ? 1 : 0;
6357	}
6358
6359	for ( ; i < 4; i += 2 ) {
6360
6361		// Both box models exclude margin, so add it if we want it
6362		if ( extra === "margin" ) {
6363			val += jQuery.css( elem, extra + cssExpand[ i ], true, styles );
6364		}
6365
6366		if ( isBorderBox ) {
6367
6368			// border-box includes padding, so remove it if we want content
6369			if ( extra === "content" ) {
6370				val -= jQuery.css( elem, "padding" + cssExpand[ i ], true, styles );
6371			}
6372
6373			// At this point, extra isn't border nor margin, so remove border
6374			if ( extra !== "margin" ) {
6375				val -= jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles );
6376			}
6377		} else {
6378
6379			// At this point, extra isn't content, so add padding
6380			val += jQuery.css( elem, "padding" + cssExpand[ i ], true, styles );
6381
6382			// At this point, extra isn't content nor padding, so add border
6383			if ( extra !== "padding" ) {
6384				val += jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles );
6385			}
6386		}
6387	}
6388
6389	return val;
6390}
6391
6392function getWidthOrHeight( elem, name, extra ) {
6393
6394	// Start with offset property, which is equivalent to the border-box value
6395	var val,
6396		valueIsBorderBox = true,
6397		styles = getStyles( elem ),
6398		isBorderBox = jQuery.css( elem, "boxSizing", false, styles ) === "border-box";
6399
6400	// Support: IE <=11 only
6401	// Running getBoundingClientRect on a disconnected node
6402	// in IE throws an error.
6403	if ( elem.getClientRects().length ) {
6404		val = elem.getBoundingClientRect()[ name ];
6405	}
6406
6407	// Some non-html elements return undefined for offsetWidth, so check for null/undefined
6408	// svg - https://bugzilla.mozilla.org/show_bug.cgi?id=649285
6409	// MathML - https://bugzilla.mozilla.org/show_bug.cgi?id=491668
6410	if ( val <= 0 || val == null ) {
6411
6412		// Fall back to computed then uncomputed css if necessary
6413		val = curCSS( elem, name, styles );
6414		if ( val < 0 || val == null ) {
6415			val = elem.style[ name ];
6416		}
6417
6418		// Computed unit is not pixels. Stop here and return.
6419		if ( rnumnonpx.test( val ) ) {
6420			return val;
6421		}
6422
6423		// Check for style in case a browser which returns unreliable values
6424		// for getComputedStyle silently falls back to the reliable elem.style
6425		valueIsBorderBox = isBorderBox &&
6426			( support.boxSizingReliable() || val === elem.style[ name ] );
6427
6428		// Normalize "", auto, and prepare for extra
6429		val = parseFloat( val ) || 0;
6430	}
6431
6432	// Use the active box-sizing model to add/subtract irrelevant styles
6433	return ( val +
6434		augmentWidthOrHeight(
6435			elem,
6436			name,
6437			extra || ( isBorderBox ? "border" : "content" ),
6438			valueIsBorderBox,
6439			styles
6440		)
6441	) + "px";
6442}
6443
6444jQuery.extend( {
6445
6446	// Add in style property hooks for overriding the default
6447	// behavior of getting and setting a style property
6448	cssHooks: {
6449		opacity: {
6450			get: function( elem, computed ) {
6451				if ( computed ) {
6452
6453					// We should always get a number back from opacity
6454					var ret = curCSS( elem, "opacity" );
6455					return ret === "" ? "1" : ret;
6456				}
6457			}
6458		}
6459	},
6460
6461	// Don't automatically add "px" to these possibly-unitless properties
6462	cssNumber: {
6463		"animationIterationCount": true,
6464		"columnCount": true,
6465		"fillOpacity": true,
6466		"flexGrow": true,
6467		"flexShrink": true,
6468		"fontWeight": true,
6469		"lineHeight": true,
6470		"opacity": true,
6471		"order": true,
6472		"orphans": true,
6473		"widows": true,
6474		"zIndex": true,
6475		"zoom": true
6476	},
6477
6478	// Add in properties whose names you wish to fix before
6479	// setting or getting the value
6480	cssProps: {
6481		"float": "cssFloat"
6482	},
6483
6484	// Get and set the style property on a DOM Node
6485	style: function( elem, name, value, extra ) {
6486
6487		// Don't set styles on text and comment nodes
6488		if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style ) {
6489			return;
6490		}
6491
6492		// Make sure that we're working with the right name
6493		var ret, type, hooks,
6494			origName = jQuery.camelCase( name ),
6495			style = elem.style;
6496
6497		name = jQuery.cssProps[ origName ] ||
6498			( jQuery.cssProps[ origName ] = vendorPropName( origName ) || origName );
6499
6500		// Gets hook for the prefixed version, then unprefixed version
6501		hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ];
6502
6503		// Check if we're setting a value
6504		if ( value !== undefined ) {
6505			type = typeof value;
6506
6507			// Convert "+=" or "-=" to relative numbers (#7345)
6508			if ( type === "string" && ( ret = rcssNum.exec( value ) ) && ret[ 1 ] ) {
6509				value = adjustCSS( elem, name, ret );
6510
6511				// Fixes bug #9237
6512				type = "number";
6513			}
6514
6515			// Make sure that null and NaN values aren't set (#7116)
6516			if ( value == null || value !== value ) {
6517				return;
6518			}
6519
6520			// If a number was passed in, add the unit (except for certain CSS properties)
6521			if ( type === "number" ) {
6522				value += ret && ret[ 3 ] || ( jQuery.cssNumber[ origName ] ? "" : "px" );
6523			}
6524
6525			// background-* props affect original clone's values
6526			if ( !support.clearCloneStyle && value === "" && name.indexOf( "background" ) === 0 ) {
6527				style[ name ] = "inherit";
6528			}
6529
6530			// If a hook was provided, use that value, otherwise just set the specified value
6531			if ( !hooks || !( "set" in hooks ) ||
6532				( value = hooks.set( elem, value, extra ) ) !== undefined ) {
6533
6534				style[ name ] = value;
6535			}
6536
6537		} else {
6538
6539			// If a hook was provided get the non-computed value from there
6540			if ( hooks && "get" in hooks &&
6541				( ret = hooks.get( elem, false, extra ) ) !== undefined ) {
6542
6543				return ret;
6544			}
6545
6546			// Otherwise just get the value from the style object
6547			return style[ name ];
6548		}
6549	},
6550
6551	css: function( elem, name, extra, styles ) {
6552		var val, num, hooks,
6553			origName = jQuery.camelCase( name );
6554
6555		// Make sure that we're working with the right name
6556		name = jQuery.cssProps[ origName ] ||
6557			( jQuery.cssProps[ origName ] = vendorPropName( origName ) || origName );
6558
6559		// Try prefixed name followed by the unprefixed name
6560		hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ];
6561
6562		// If a hook was provided get the computed value from there
6563		if ( hooks && "get" in hooks ) {
6564			val = hooks.get( elem, true, extra );
6565		}
6566
6567		// Otherwise, if a way to get the computed value exists, use that
6568		if ( val === undefined ) {
6569			val = curCSS( elem, name, styles );
6570		}
6571
6572		// Convert "normal" to computed value
6573		if ( val === "normal" && name in cssNormalTransform ) {
6574			val = cssNormalTransform[ name ];
6575		}
6576
6577		// Make numeric if forced or a qualifier was provided and val looks numeric
6578		if ( extra === "" || extra ) {
6579			num = parseFloat( val );
6580			return extra === true || isFinite( num ) ? num || 0 : val;
6581		}
6582		return val;
6583	}
6584} );
6585
6586jQuery.each( [ "height", "width" ], function( i, name ) {
6587	jQuery.cssHooks[ name ] = {
6588		get: function( elem, computed, extra ) {
6589			if ( computed ) {
6590
6591				// Certain elements can have dimension info if we invisibly show them
6592				// but it must have a current display style that would benefit
6593				return rdisplayswap.test( jQuery.css( elem, "display" ) ) &&
6594
6595					// Support: Safari 8+
6596					// Table columns in Safari have non-zero offsetWidth & zero
6597					// getBoundingClientRect().width unless display is changed.
6598					// Support: IE <=11 only
6599					// Running getBoundingClientRect on a disconnected node
6600					// in IE throws an error.
6601					( !elem.getClientRects().length || !elem.getBoundingClientRect().width ) ?
6602						swap( elem, cssShow, function() {
6603							return getWidthOrHeight( elem, name, extra );
6604						} ) :
6605						getWidthOrHeight( elem, name, extra );
6606			}
6607		},
6608
6609		set: function( elem, value, extra ) {
6610			var matches,
6611				styles = extra && getStyles( elem ),
6612				subtract = extra && augmentWidthOrHeight(
6613					elem,
6614					name,
6615					extra,
6616					jQuery.css( elem, "boxSizing", false, styles ) === "border-box",
6617					styles
6618				);
6619
6620			// Convert to pixels if value adjustment is needed
6621			if ( subtract && ( matches = rcssNum.exec( value ) ) &&
6622				( matches[ 3 ] || "px" ) !== "px" ) {
6623
6624				elem.style[ name ] = value;
6625				value = jQuery.css( elem, name );
6626			}
6627
6628			return setPositiveNumber( elem, value, subtract );
6629		}
6630	};
6631} );
6632
6633jQuery.cssHooks.marginLeft = addGetHookIf( support.reliableMarginLeft,
6634	function( elem, computed ) {
6635		if ( computed ) {
6636			return ( parseFloat( curCSS( elem, "marginLeft" ) ) ||
6637				elem.getBoundingClientRect().left -
6638					swap( elem, { marginLeft: 0 }, function() {
6639						return elem.getBoundingClientRect().left;
6640					} )
6641				) + "px";
6642		}
6643	}
6644);
6645
6646// These hooks are used by animate to expand properties
6647jQuery.each( {
6648	margin: "",
6649	padding: "",
6650	border: "Width"
6651}, function( prefix, suffix ) {
6652	jQuery.cssHooks[ prefix + suffix ] = {
6653		expand: function( value ) {
6654			var i = 0,
6655				expanded = {},
6656
6657				// Assumes a single number if not a string
6658				parts = typeof value === "string" ? value.split( " " ) : [ value ];
6659
6660			for ( ; i < 4; i++ ) {
6661				expanded[ prefix + cssExpand[ i ] + suffix ] =
6662					parts[ i ] || parts[ i - 2 ] || parts[ 0 ];
6663			}
6664
6665			return expanded;
6666		}
6667	};
6668
6669	if ( !rmargin.test( prefix ) ) {
6670		jQuery.cssHooks[ prefix + suffix ].set = setPositiveNumber;
6671	}
6672} );
6673
6674jQuery.fn.extend( {
6675	css: function( name, value ) {
6676		return access( this, function( elem, name, value ) {
6677			var styles, len,
6678				map = {},
6679				i = 0;
6680
6681			if ( jQuery.isArray( name ) ) {
6682				styles = getStyles( elem );
6683				len = name.length;
6684
6685				for ( ; i < len; i++ ) {
6686					map[ name[ i ] ] = jQuery.css( elem, name[ i ], false, styles );
6687				}
6688
6689				return map;
6690			}
6691
6692			return value !== undefined ?
6693				jQuery.style( elem, name, value ) :
6694				jQuery.css( elem, name );
6695		}, name, value, arguments.length > 1 );
6696	}
6697} );
6698
6699
6700function Tween( elem, options, prop, end, easing ) {
6701	return new Tween.prototype.init( elem, options, prop, end, easing );
6702}
6703jQuery.Tween = Tween;
6704
6705Tween.prototype = {
6706	constructor: Tween,
6707	init: function( elem, options, prop, end, easing, unit ) {
6708		this.elem = elem;
6709		this.prop = prop;
6710		this.easing = easing || jQuery.easing._default;
6711		this.options = options;
6712		this.start = this.now = this.cur();
6713		this.end = end;
6714		this.unit = unit || ( jQuery.cssNumber[ prop ] ? "" : "px" );
6715	},
6716	cur: function() {
6717		var hooks = Tween.propHooks[ this.prop ];
6718
6719		return hooks && hooks.get ?
6720			hooks.get( this ) :
6721			Tween.propHooks._default.get( this );
6722	},
6723	run: function( percent ) {
6724		var eased,
6725			hooks = Tween.propHooks[ this.prop ];
6726
6727		if ( this.options.duration ) {
6728			this.pos = eased = jQuery.easing[ this.easing ](
6729				percent, this.options.duration * percent, 0, 1, this.options.duration
6730			);
6731		} else {
6732			this.pos = eased = percent;
6733		}
6734		this.now = ( this.end - this.start ) * eased + this.start;
6735
6736		if ( this.options.step ) {
6737			this.options.step.call( this.elem, this.now, this );
6738		}
6739
6740		if ( hooks && hooks.set ) {
6741			hooks.set( this );
6742		} else {
6743			Tween.propHooks._default.set( this );
6744		}
6745		return this;
6746	}
6747};
6748
6749Tween.prototype.init.prototype = Tween.prototype;
6750
6751Tween.propHooks = {
6752	_default: {
6753		get: function( tween ) {
6754			var result;
6755
6756			// Use a property on the element directly when it is not a DOM element,
6757			// or when there is no matching style property that exists.
6758			if ( tween.elem.nodeType !== 1 ||
6759				tween.elem[ tween.prop ] != null && tween.elem.style[ tween.prop ] == null ) {
6760				return tween.elem[ tween.prop ];
6761			}
6762
6763			// Passing an empty string as a 3rd parameter to .css will automatically
6764			// attempt a parseFloat and fallback to a string if the parse fails.
6765			// Simple values such as "10px" are parsed to Float;
6766			// complex values such as "rotate(1rad)" are returned as-is.
6767			result = jQuery.css( tween.elem, tween.prop, "" );
6768
6769			// Empty strings, null, undefined and "auto" are converted to 0.
6770			return !result || result === "auto" ? 0 : result;
6771		},
6772		set: function( tween ) {
6773
6774			// Use step hook for back compat.
6775			// Use cssHook if its there.
6776			// Use .style if available and use plain properties where available.
6777			if ( jQuery.fx.step[ tween.prop ] ) {
6778				jQuery.fx.step[ tween.prop ]( tween );
6779			} else if ( tween.elem.nodeType === 1 &&
6780				( tween.elem.style[ jQuery.cssProps[ tween.prop ] ] != null ||
6781					jQuery.cssHooks[ tween.prop ] ) ) {
6782				jQuery.style( tween.elem, tween.prop, tween.now + tween.unit );
6783			} else {
6784				tween.elem[ tween.prop ] = tween.now;
6785			}
6786		}
6787	}
6788};
6789
6790// Support: IE <=9 only
6791// Panic based approach to setting things on disconnected nodes
6792Tween.propHooks.scrollTop = Tween.propHooks.scrollLeft = {
6793	set: function( tween ) {
6794		if ( tween.elem.nodeType && tween.elem.parentNode ) {
6795			tween.elem[ tween.prop ] = tween.now;
6796		}
6797	}
6798};
6799
6800jQuery.easing = {
6801	linear: function( p ) {
6802		return p;
6803	},
6804	swing: function( p ) {
6805		return 0.5 - Math.cos( p * Math.PI ) / 2;
6806	},
6807	_default: "swing"
6808};
6809
6810jQuery.fx = Tween.prototype.init;
6811
6812// Back compat <1.8 extension point
6813jQuery.fx.step = {};
6814
6815
6816
6817
6818var
6819	fxNow, timerId,
6820	rfxtypes = /^(?:toggle|show|hide)$/,
6821	rrun = /queueHooks$/;
6822
6823function raf() {
6824	if ( timerId ) {
6825		window.requestAnimationFrame( raf );
6826		jQuery.fx.tick();
6827	}
6828}
6829
6830// Animations created synchronously will run synchronously
6831function createFxNow() {
6832	window.setTimeout( function() {
6833		fxNow = undefined;
6834	} );
6835	return ( fxNow = jQuery.now() );
6836}
6837
6838// Generate parameters to create a standard animation
6839function genFx( type, includeWidth ) {
6840	var which,
6841		i = 0,
6842		attrs = { height: type };
6843
6844	// If we include width, step value is 1 to do all cssExpand values,
6845	// otherwise step value is 2 to skip over Left and Right
6846	includeWidth = includeWidth ? 1 : 0;
6847	for ( ; i < 4; i += 2 - includeWidth ) {
6848		which = cssExpand[ i ];
6849		attrs[ "margin" + which ] = attrs[ "padding" + which ] = type;
6850	}
6851
6852	if ( includeWidth ) {
6853		attrs.opacity = attrs.width = type;
6854	}
6855
6856	return attrs;
6857}
6858
6859function createTween( value, prop, animation ) {
6860	var tween,
6861		collection = ( Animation.tweeners[ prop ] || [] ).concat( Animation.tweeners[ "*" ] ),
6862		index = 0,
6863		length = collection.length;
6864	for ( ; index < length; index++ ) {
6865		if ( ( tween = collection[ index ].call( animation, prop, value ) ) ) {
6866
6867			// We're done with this property
6868			return tween;
6869		}
6870	}
6871}
6872
6873function defaultPrefilter( elem, props, opts ) {
6874	var prop, value, toggle, hooks, oldfire, propTween, restoreDisplay, display,
6875		isBox = "width" in props || "height" in props,
6876		anim = this,
6877		orig = {},
6878		style = elem.style,
6879		hidden = elem.nodeType && isHiddenWithinTree( elem ),
6880		dataShow = dataPriv.get( elem, "fxshow" );
6881
6882	// Queue-skipping animations hijack the fx hooks
6883	if ( !opts.queue ) {
6884		hooks = jQuery._queueHooks( elem, "fx" );
6885		if ( hooks.unqueued == null ) {
6886			hooks.unqueued = 0;
6887			oldfire = hooks.empty.fire;
6888			hooks.empty.fire = function() {
6889				if ( !hooks.unqueued ) {
6890					oldfire();
6891				}
6892			};
6893		}
6894		hooks.unqueued++;
6895
6896		anim.always( function() {
6897
6898			// Ensure the complete handler is called before this completes
6899			anim.always( function() {
6900				hooks.unqueued--;
6901				if ( !jQuery.queue( elem, "fx" ).length ) {
6902					hooks.empty.fire();
6903				}
6904			} );
6905		} );
6906	}
6907
6908	// Detect show/hide animations
6909	for ( prop in props ) {
6910		value = props[ prop ];
6911		if ( rfxtypes.test( value ) ) {
6912			delete props[ prop ];
6913			toggle = toggle || value === "toggle";
6914			if ( value === ( hidden ? "hide" : "show" ) ) {
6915
6916				// Pretend to be hidden if this is a "show" and
6917				// there is still data from a stopped show/hide
6918				if ( value === "show" && dataShow && dataShow[ prop ] !== undefined ) {
6919					hidden = true;
6920
6921				// Ignore all other no-op show/hide data
6922				} else {
6923					continue;
6924				}
6925			}
6926			orig[ prop ] = dataShow && dataShow[ prop ] || jQuery.style( elem, prop );
6927		}
6928	}
6929
6930	// Bail out if this is a no-op like .hide().hide()
6931	propTween = !jQuery.isEmptyObject( props );
6932	if ( !propTween && jQuery.isEmptyObject( orig ) ) {
6933		return;
6934	}
6935
6936	// Restrict "overflow" and "display" styles during box animations
6937	if ( isBox && elem.nodeType === 1 ) {
6938
6939		// Support: IE <=9 - 11, Edge 12 - 13
6940		// Record all 3 overflow attributes because IE does not infer the shorthand
6941		// from identically-valued overflowX and overflowY
6942		opts.overflow = [ style.overflow, style.overflowX, style.overflowY ];
6943
6944		// Identify a display type, preferring old show/hide data over the CSS cascade
6945		restoreDisplay = dataShow && dataShow.display;
6946		if ( restoreDisplay == null ) {
6947			restoreDisplay = dataPriv.get( elem, "display" );
6948		}
6949		display = jQuery.css( elem, "display" );
6950		if ( display === "none" ) {
6951			if ( restoreDisplay ) {
6952				display = restoreDisplay;
6953			} else {
6954
6955				// Get nonempty value(s) by temporarily forcing visibility
6956				showHide( [ elem ], true );
6957				restoreDisplay = elem.style.display || restoreDisplay;
6958				display = jQuery.css( elem, "display" );
6959				showHide( [ elem ] );
6960			}
6961		}
6962
6963		// Animate inline elements as inline-block
6964		if ( display === "inline" || display === "inline-block" && restoreDisplay != null ) {
6965			if ( jQuery.css( elem, "float" ) === "none" ) {
6966
6967				// Restore the original display value at the end of pure show/hide animations
6968				if ( !propTween ) {
6969					anim.done( function() {
6970						style.display = restoreDisplay;
6971					} );
6972					if ( restoreDisplay == null ) {
6973						display = style.display;
6974						restoreDisplay = display === "none" ? "" : display;
6975					}
6976				}
6977				style.display = "inline-block";
6978			}
6979		}
6980	}
6981
6982	if ( opts.overflow ) {
6983		style.overflow = "hidden";
6984		anim.always( function() {
6985			style.overflow = opts.overflow[ 0 ];
6986			style.overflowX = opts.overflow[ 1 ];
6987			style.overflowY = opts.overflow[ 2 ];
6988		} );
6989	}
6990
6991	// Implement show/hide animations
6992	propTween = false;
6993	for ( prop in orig ) {
6994
6995		// General show/hide setup for this element animation
6996		if ( !propTween ) {
6997			if ( dataShow ) {
6998				if ( "hidden" in dataShow ) {
6999					hidden = dataShow.hidden;
7000				}
7001			} else {
7002				dataShow = dataPriv.access( elem, "fxshow", { display: restoreDisplay } );
7003			}
7004
7005			// Store hidden/visible for toggle so `.stop().toggle()` "reverses"
7006			if ( toggle ) {
7007				dataShow.hidden = !hidden;
7008			}
7009
7010			// Show elements before animating them
7011			if ( hidden ) {
7012				showHide( [ elem ], true );
7013			}
7014
7015			/* eslint-disable no-loop-func */
7016
7017			anim.done( function() {
7018
7019			/* eslint-enable no-loop-func */
7020
7021				// The final step of a "hide" animation is actually hiding the element
7022				if ( !hidden ) {
7023					showHide( [ elem ] );
7024				}
7025				dataPriv.remove( elem, "fxshow" );
7026				for ( prop in orig ) {
7027					jQuery.style( elem, prop, orig[ prop ] );
7028				}
7029			} );
7030		}
7031
7032		// Per-property setup
7033		propTween = createTween( hidden ? dataShow[ prop ] : 0, prop, anim );
7034		if ( !( prop in dataShow ) ) {
7035			dataShow[ prop ] = propTween.start;
7036			if ( hidden ) {
7037				propTween.end = propTween.start;
7038				propTween.start = 0;
7039			}
7040		}
7041	}
7042}
7043
7044function propFilter( props, specialEasing ) {
7045	var index, name, easing, value, hooks;
7046
7047	// camelCase, specialEasing and expand cssHook pass
7048	for ( index in props ) {
7049		name = jQuery.camelCase( index );
7050		easing = specialEasing[ name ];
7051		value = props[ index ];
7052		if ( jQuery.isArray( value ) ) {
7053			easing = value[ 1 ];
7054			value = props[ index ] = value[ 0 ];
7055		}
7056
7057		if ( index !== name ) {
7058			props[ name ] = value;
7059			delete props[ index ];
7060		}
7061
7062		hooks = jQuery.cssHooks[ name ];
7063		if ( hooks && "expand" in hooks ) {
7064			value = hooks.expand( value );
7065			delete props[ name ];
7066
7067			// Not quite $.extend, this won't overwrite existing keys.
7068			// Reusing 'index' because we have the correct "name"
7069			for ( index in value ) {
7070				if ( !( index in props ) ) {
7071					props[ index ] = value[ index ];
7072					specialEasing[ index ] = easing;
7073				}
7074			}
7075		} else {
7076			specialEasing[ name ] = easing;
7077		}
7078	}
7079}
7080
7081function Animation( elem, properties, options ) {
7082	var result,
7083		stopped,
7084		index = 0,
7085		length = Animation.prefilters.length,
7086		deferred = jQuery.Deferred().always( function() {
7087
7088			// Don't match elem in the :animated selector
7089			delete tick.elem;
7090		} ),
7091		tick = function() {
7092			if ( stopped ) {
7093				return false;
7094			}
7095			var currentTime = fxNow || createFxNow(),
7096				remaining = Math.max( 0, animation.startTime + animation.duration - currentTime ),
7097
7098				// Support: Android 2.3 only
7099				// Archaic crash bug won't allow us to use `1 - ( 0.5 || 0 )` (#12497)
7100				temp = remaining / animation.duration || 0,
7101				percent = 1 - temp,
7102				index = 0,
7103				length = animation.tweens.length;
7104
7105			for ( ; index < length; index++ ) {
7106				animation.tweens[ index ].run( percent );
7107			}
7108
7109			deferred.notifyWith( elem, [ animation, percent, remaining ] );
7110
7111			if ( percent < 1 && length ) {
7112				return remaining;
7113			} else {
7114				deferred.resolveWith( elem, [ animation ] );
7115				return false;
7116			}
7117		},
7118		animation = deferred.promise( {
7119			elem: elem,
7120			props: jQuery.extend( {}, properties ),
7121			opts: jQuery.extend( true, {
7122				specialEasing: {},
7123				easing: jQuery.easing._default
7124			}, options ),
7125			originalProperties: properties,
7126			originalOptions: options,
7127			startTime: fxNow || createFxNow(),
7128			duration: options.duration,
7129			tweens: [],
7130			createTween: function( prop, end ) {
7131				var tween = jQuery.Tween( elem, animation.opts, prop, end,
7132						animation.opts.specialEasing[ prop ] || animation.opts.easing );
7133				animation.tweens.push( tween );
7134				return tween;
7135			},
7136			stop: function( gotoEnd ) {
7137				var index = 0,
7138
7139					// If we are going to the end, we want to run all the tweens
7140					// otherwise we skip this part
7141					length = gotoEnd ? animation.tweens.length : 0;
7142				if ( stopped ) {
7143					return this;
7144				}
7145				stopped = true;
7146				for ( ; index < length; index++ ) {
7147					animation.tweens[ index ].run( 1 );
7148				}
7149
7150				// Resolve when we played the last frame; otherwise, reject
7151				if ( gotoEnd ) {
7152					deferred.notifyWith( elem, [ animation, 1, 0 ] );
7153					deferred.resolveWith( elem, [ animation, gotoEnd ] );
7154				} else {
7155					deferred.rejectWith( elem, [ animation, gotoEnd ] );
7156				}
7157				return this;
7158			}
7159		} ),
7160		props = animation.props;
7161
7162	propFilter( props, animation.opts.specialEasing );
7163
7164	for ( ; index < length; index++ ) {
7165		result = Animation.prefilters[ index ].call( animation, elem, props, animation.opts );
7166		if ( result ) {
7167			if ( jQuery.isFunction( result.stop ) ) {
7168				jQuery._queueHooks( animation.elem, animation.opts.queue ).stop =
7169					jQuery.proxy( result.stop, result );
7170			}
7171			return result;
7172		}
7173	}
7174
7175	jQuery.map( props, createTween, animation );
7176
7177	if ( jQuery.isFunction( animation.opts.start ) ) {
7178		animation.opts.start.call( elem, animation );
7179	}
7180
7181	jQuery.fx.timer(
7182		jQuery.extend( tick, {
7183			elem: elem,
7184			anim: animation,
7185			queue: animation.opts.queue
7186		} )
7187	);
7188
7189	// attach callbacks from options
7190	return animation.progress( animation.opts.progress )
7191		.done( animation.opts.done, animation.opts.complete )
7192		.fail( animation.opts.fail )
7193		.always( animation.opts.always );
7194}
7195
7196jQuery.Animation = jQuery.extend( Animation, {
7197
7198	tweeners: {
7199		"*": [ function( prop, value ) {
7200			var tween = this.createTween( prop, value );
7201			adjustCSS( tween.elem, prop, rcssNum.exec( value ), tween );
7202			return tween;
7203		} ]
7204	},
7205
7206	tweener: function( props, callback ) {
7207		if ( jQuery.isFunction( props ) ) {
7208			callback = props;
7209			props = [ "*" ];
7210		} else {
7211			props = props.match( rnothtmlwhite );
7212		}
7213
7214		var prop,
7215			index = 0,
7216			length = props.length;
7217
7218		for ( ; index < length; index++ ) {
7219			prop = props[ index ];
7220			Animation.tweeners[ prop ] = Animation.tweeners[ prop ] || [];
7221			Animation.tweeners[ prop ].unshift( callback );
7222		}
7223	},
7224
7225	prefilters: [ defaultPrefilter ],
7226
7227	prefilter: function( callback, prepend ) {
7228		if ( prepend ) {
7229			Animation.prefilters.unshift( callback );
7230		} else {
7231			Animation.prefilters.push( callback );
7232		}
7233	}
7234} );
7235
7236jQuery.speed = function( speed, easing, fn ) {
7237	var opt = speed && typeof speed === "object" ? jQuery.extend( {}, speed ) : {
7238		complete: fn || !fn && easing ||
7239			jQuery.isFunction( speed ) && speed,
7240		duration: speed,
7241		easing: fn && easing || easing && !jQuery.isFunction( easing ) && easing
7242	};
7243
7244	// Go to the end state if fx are off or if document is hidden
7245	if ( jQuery.fx.off || document.hidden ) {
7246		opt.duration = 0;
7247
7248	} else {
7249		if ( typeof opt.duration !== "number" ) {
7250			if ( opt.duration in jQuery.fx.speeds ) {
7251				opt.duration = jQuery.fx.speeds[ opt.duration ];
7252
7253			} else {
7254				opt.duration = jQuery.fx.speeds._default;
7255			}
7256		}
7257	}
7258
7259	// Normalize opt.queue - true/undefined/null -> "fx"
7260	if ( opt.queue == null || opt.queue === true ) {
7261		opt.queue = "fx";
7262	}
7263
7264	// Queueing
7265	opt.old = opt.complete;
7266
7267	opt.complete = function() {
7268		if ( jQuery.isFunction( opt.old ) ) {
7269			opt.old.call( this );
7270		}
7271
7272		if ( opt.queue ) {
7273			jQuery.dequeue( this, opt.queue );
7274		}
7275	};
7276
7277	return opt;
7278};
7279
7280jQuery.fn.extend( {
7281	fadeTo: function( speed, to, easing, callback ) {
7282
7283		// Show any hidden elements after setting opacity to 0
7284		return this.filter( isHiddenWithinTree ).css( "opacity", 0 ).show()
7285
7286			// Animate to the value specified
7287			.end().animate( { opacity: to }, speed, easing, callback );
7288	},
7289	animate: function( prop, speed, easing, callback ) {
7290		var empty = jQuery.isEmptyObject( prop ),
7291			optall = jQuery.speed( speed, easing, callback ),
7292			doAnimation = function() {
7293
7294				// Operate on a copy of prop so per-property easing won't be lost
7295				var anim = Animation( this, jQuery.extend( {}, prop ), optall );
7296
7297				// Empty animations, or finishing resolves immediately
7298				if ( empty || dataPriv.get( this, "finish" ) ) {
7299					anim.stop( true );
7300				}
7301			};
7302			doAnimation.finish = doAnimation;
7303
7304		return empty || optall.queue === false ?
7305			this.each( doAnimation ) :
7306			this.queue( optall.queue, doAnimation );
7307	},
7308	stop: function( type, clearQueue, gotoEnd ) {
7309		var stopQueue = function( hooks ) {
7310			var stop = hooks.stop;
7311			delete hooks.stop;
7312			stop( gotoEnd );
7313		};
7314
7315		if ( typeof type !== "string" ) {
7316			gotoEnd = clearQueue;
7317			clearQueue = type;
7318			type = undefined;
7319		}
7320		if ( clearQueue && type !== false ) {
7321			this.queue( type || "fx", [] );
7322		}
7323
7324		return this.each( function() {
7325			var dequeue = true,
7326				index = type != null && type + "queueHooks",
7327				timers = jQuery.timers,
7328				data = dataPriv.get( this );
7329
7330			if ( index ) {
7331				if ( data[ index ] && data[ index ].stop ) {
7332					stopQueue( data[ index ] );
7333				}
7334			} else {
7335				for ( index in data ) {
7336					if ( data[ index ] && data[ index ].stop && rrun.test( index ) ) {
7337						stopQueue( data[ index ] );
7338					}
7339				}
7340			}
7341
7342			for ( index = timers.length; index--; ) {
7343				if ( timers[ index ].elem === this &&
7344					( type == null || timers[ index ].queue === type ) ) {
7345
7346					timers[ index ].anim.stop( gotoEnd );
7347					dequeue = false;
7348					timers.splice( index, 1 );
7349				}
7350			}
7351
7352			// Start the next in the queue if the last step wasn't forced.
7353			// Timers currently will call their complete callbacks, which
7354			// will dequeue but only if they were gotoEnd.
7355			if ( dequeue || !gotoEnd ) {
7356				jQuery.dequeue( this, type );
7357			}
7358		} );
7359	},
7360	finish: function( type ) {
7361		if ( type !== false ) {
7362			type = type || "fx";
7363		}
7364		return this.each( function() {
7365			var index,
7366				data = dataPriv.get( this ),
7367				queue = data[ type + "queue" ],
7368				hooks = data[ type + "queueHooks" ],
7369				timers = jQuery.timers,
7370				length = queue ? queue.length : 0;
7371
7372			// Enable finishing flag on private data
7373			data.finish = true;
7374
7375			// Empty the queue first
7376			jQuery.queue( this, type, [] );
7377
7378			if ( hooks && hooks.stop ) {
7379				hooks.stop.call( this, true );
7380			}
7381
7382			// Look for any active animations, and finish them
7383			for ( index = timers.length; index--; ) {
7384				if ( timers[ index ].elem === this && timers[ index ].queue === type ) {
7385					timers[ index ].anim.stop( true );
7386					timers.splice( index, 1 );
7387				}
7388			}
7389
7390			// Look for any animations in the old queue and finish them
7391			for ( index = 0; index < length; index++ ) {
7392				if ( queue[ index ] && queue[ index ].finish ) {
7393					queue[ index ].finish.call( this );
7394				}
7395			}
7396
7397			// Turn off finishing flag
7398			delete data.finish;
7399		} );
7400	}
7401} );
7402
7403jQuery.each( [ "toggle", "show", "hide" ], function( i, name ) {
7404	var cssFn = jQuery.fn[ name ];
7405	jQuery.fn[ name ] = function( speed, easing, callback ) {
7406		return speed == null || typeof speed === "boolean" ?
7407			cssFn.apply( this, arguments ) :
7408			this.animate( genFx( name, true ), speed, easing, callback );
7409	};
7410} );
7411
7412// Generate shortcuts for custom animations
7413jQuery.each( {
7414	slideDown: genFx( "show" ),
7415	slideUp: genFx( "hide" ),
7416	slideToggle: genFx( "toggle" ),
7417	fadeIn: { opacity: "show" },
7418	fadeOut: { opacity: "hide" },
7419	fadeToggle: { opacity: "toggle" }
7420}, function( name, props ) {
7421	jQuery.fn[ name ] = function( speed, easing, callback ) {
7422		return this.animate( props, speed, easing, callback );
7423	};
7424} );
7425
7426jQuery.timers = [];
7427jQuery.fx.tick = function() {
7428	var timer,
7429		i = 0,
7430		timers = jQuery.timers;
7431
7432	fxNow = jQuery.now();
7433
7434	for ( ; i < timers.length; i++ ) {
7435		timer = timers[ i ];
7436
7437		// Checks the timer has not already been removed
7438		if ( !timer() && timers[ i ] === timer ) {
7439			timers.splice( i--, 1 );
7440		}
7441	}
7442
7443	if ( !timers.length ) {
7444		jQuery.fx.stop();
7445	}
7446	fxNow = undefined;
7447};
7448
7449jQuery.fx.timer = function( timer ) {
7450	jQuery.timers.push( timer );
7451	if ( timer() ) {
7452		jQuery.fx.start();
7453	} else {
7454		jQuery.timers.pop();
7455	}
7456};
7457
7458jQuery.fx.interval = 13;
7459jQuery.fx.start = function() {
7460	if ( !timerId ) {
7461		timerId = window.requestAnimationFrame ?
7462			window.requestAnimationFrame( raf ) :
7463			window.setInterval( jQuery.fx.tick, jQuery.fx.interval );
7464	}
7465};
7466
7467jQuery.fx.stop = function() {
7468	if ( window.cancelAnimationFrame ) {
7469		window.cancelAnimationFrame( timerId );
7470	} else {
7471		window.clearInterval( timerId );
7472	}
7473
7474	timerId = null;
7475};
7476
7477jQuery.fx.speeds = {
7478	slow: 600,
7479	fast: 200,
7480
7481	// Default speed
7482	_default: 400
7483};
7484
7485
7486// Based off of the plugin by Clint Helfers, with permission.
7487// https://web.archive.org/web/20100324014747/http://blindsignals.com/index.php/2009/07/jquery-delay/
7488jQuery.fn.delay = function( time, type ) {
7489	time = jQuery.fx ? jQuery.fx.speeds[ time ] || time : time;
7490	type = type || "fx";
7491
7492	return this.queue( type, function( next, hooks ) {
7493		var timeout = window.setTimeout( next, time );
7494		hooks.stop = function() {
7495			window.clearTimeout( timeout );
7496		};
7497	} );
7498};
7499
7500
7501( function() {
7502	var input = document.createElement( "input" ),
7503		select = document.createElement( "select" ),
7504		opt = select.appendChild( document.createElement( "option" ) );
7505
7506	input.type = "checkbox";
7507
7508	// Support: Android <=4.3 only
7509	// Default value for a checkbox should be "on"
7510	support.checkOn = input.value !== "";
7511
7512	// Support: IE <=11 only
7513	// Must access selectedIndex to make default options select
7514	support.optSelected = opt.selected;
7515
7516	// Support: IE <=11 only
7517	// An input loses its value after becoming a radio
7518	input = document.createElement( "input" );
7519	input.value = "t";
7520	input.type = "radio";
7521	support.radioValue = input.value === "t";
7522} )();
7523
7524
7525var boolHook,
7526	attrHandle = jQuery.expr.attrHandle;
7527
7528jQuery.fn.extend( {
7529	attr: function( name, value ) {
7530		return access( this, jQuery.attr, name, value, arguments.length > 1 );
7531	},
7532
7533	removeAttr: function( name ) {
7534		return this.each( function() {
7535			jQuery.removeAttr( this, name );
7536		} );
7537	}
7538} );
7539
7540jQuery.extend( {
7541	attr: function( elem, name, value ) {
7542		var ret, hooks,
7543			nType = elem.nodeType;
7544
7545		// Don't get/set attributes on text, comment and attribute nodes
7546		if ( nType === 3 || nType === 8 || nType === 2 ) {
7547			return;
7548		}
7549
7550		// Fallback to prop when attributes are not supported
7551		if ( typeof elem.getAttribute === "undefined" ) {
7552			return jQuery.prop( elem, name, value );
7553		}
7554
7555		// Attribute hooks are determined by the lowercase version
7556		// Grab necessary hook if one is defined
7557		if ( nType !== 1 || !jQuery.isXMLDoc( elem ) ) {
7558			hooks = jQuery.attrHooks[ name.toLowerCase() ] ||
7559				( jQuery.expr.match.bool.test( name ) ? boolHook : undefined );
7560		}
7561
7562		if ( value !== undefined ) {
7563			if ( value === null ) {
7564				jQuery.removeAttr( elem, name );
7565				return;
7566			}
7567
7568			if ( hooks && "set" in hooks &&
7569				( ret = hooks.set( elem, value, name ) ) !== undefined ) {
7570				return ret;
7571			}
7572
7573			elem.setAttribute( name, value + "" );
7574			return value;
7575		}
7576
7577		if ( hooks && "get" in hooks && ( ret = hooks.get( elem, name ) ) !== null ) {
7578			return ret;
7579		}
7580
7581		ret = jQuery.find.attr( elem, name );
7582
7583		// Non-existent attributes return null, we normalize to undefined
7584		return ret == null ? undefined : ret;
7585	},
7586
7587	attrHooks: {
7588		type: {
7589			set: function( elem, value ) {
7590				if ( !support.radioValue && value === "radio" &&
7591					jQuery.nodeName( elem, "input" ) ) {
7592					var val = elem.value;
7593					elem.setAttribute( "type", value );
7594					if ( val ) {
7595						elem.value = val;
7596					}
7597					return value;
7598				}
7599			}
7600		}
7601	},
7602
7603	removeAttr: function( elem, value ) {
7604		var name,
7605			i = 0,
7606
7607			// Attribute names can contain non-HTML whitespace characters
7608			// https://html.spec.whatwg.org/multipage/syntax.html#attributes-2
7609			attrNames = value && value.match( rnothtmlwhite );
7610
7611		if ( attrNames && elem.nodeType === 1 ) {
7612			while ( ( name = attrNames[ i++ ] ) ) {
7613				elem.removeAttribute( name );
7614			}
7615		}
7616	}
7617} );
7618
7619// Hooks for boolean attributes
7620boolHook = {
7621	set: function( elem, value, name ) {
7622		if ( value === false ) {
7623
7624			// Remove boolean attributes when set to false
7625			jQuery.removeAttr( elem, name );
7626		} else {
7627			elem.setAttribute( name, name );
7628		}
7629		return name;
7630	}
7631};
7632
7633jQuery.each( jQuery.expr.match.bool.source.match( /\w+/g ), function( i, name ) {
7634	var getter = attrHandle[ name ] || jQuery.find.attr;
7635
7636	attrHandle[ name ] = function( elem, name, isXML ) {
7637		var ret, handle,
7638			lowercaseName = name.toLowerCase();
7639
7640		if ( !isXML ) {
7641
7642			// Avoid an infinite loop by temporarily removing this function from the getter
7643			handle = attrHandle[ lowercaseName ];
7644			attrHandle[ lowercaseName ] = ret;
7645			ret = getter( elem, name, isXML ) != null ?
7646				lowercaseName :
7647				null;
7648			attrHandle[ lowercaseName ] = handle;
7649		}
7650		return ret;
7651	};
7652} );
7653
7654
7655
7656
7657var rfocusable = /^(?:input|select|textarea|button)$/i,
7658	rclickable = /^(?:a|area)$/i;
7659
7660jQuery.fn.extend( {
7661	prop: function( name, value ) {
7662		return access( this, jQuery.prop, name, value, arguments.length > 1 );
7663	},
7664
7665	removeProp: function( name ) {
7666		return this.each( function() {
7667			delete this[ jQuery.propFix[ name ] || name ];
7668		} );
7669	}
7670} );
7671
7672jQuery.extend( {
7673	prop: function( elem, name, value ) {
7674		var ret, hooks,
7675			nType = elem.nodeType;
7676
7677		// Don't get/set properties on text, comment and attribute nodes
7678		if ( nType === 3 || nType === 8 || nType === 2 ) {
7679			return;
7680		}
7681
7682		if ( nType !== 1 || !jQuery.isXMLDoc( elem ) ) {
7683
7684			// Fix name and attach hooks
7685			name = jQuery.propFix[ name ] || name;
7686			hooks = jQuery.propHooks[ name ];
7687		}
7688
7689		if ( value !== undefined ) {
7690			if ( hooks && "set" in hooks &&
7691				( ret = hooks.set( elem, value, name ) ) !== undefined ) {
7692				return ret;
7693			}
7694
7695			return ( elem[ name ] = value );
7696		}
7697
7698		if ( hooks && "get" in hooks && ( ret = hooks.get( elem, name ) ) !== null ) {
7699			return ret;
7700		}
7701
7702		return elem[ name ];
7703	},
7704
7705	propHooks: {
7706		tabIndex: {
7707			get: function( elem ) {
7708
7709				// Support: IE <=9 - 11 only
7710				// elem.tabIndex doesn't always return the
7711				// correct value when it hasn't been explicitly set
7712				// https://web.archive.org/web/20141116233347/http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/
7713				// Use proper attribute retrieval(#12072)
7714				var tabindex = jQuery.find.attr( elem, "tabindex" );
7715
7716				if ( tabindex ) {
7717					return parseInt( tabindex, 10 );
7718				}
7719
7720				if (
7721					rfocusable.test( elem.nodeName ) ||
7722					rclickable.test( elem.nodeName ) &&
7723					elem.href
7724				) {
7725					return 0;
7726				}
7727
7728				return -1;
7729			}
7730		}
7731	},
7732
7733	propFix: {
7734		"for": "htmlFor",
7735		"class": "className"
7736	}
7737} );
7738
7739// Support: IE <=11 only
7740// Accessing the selectedIndex property
7741// forces the browser to respect setting selected
7742// on the option
7743// The getter ensures a default option is selected
7744// when in an optgroup
7745// eslint rule "no-unused-expressions" is disabled for this code
7746// since it considers such accessions noop
7747if ( !support.optSelected ) {
7748	jQuery.propHooks.selected = {
7749		get: function( elem ) {
7750
7751			/* eslint no-unused-expressions: "off" */
7752
7753			var parent = elem.parentNode;
7754			if ( parent && parent.parentNode ) {
7755				parent.parentNode.selectedIndex;
7756			}
7757			return null;
7758		},
7759		set: function( elem ) {
7760
7761			/* eslint no-unused-expressions: "off" */
7762
7763			var parent = elem.parentNode;
7764			if ( parent ) {
7765				parent.selectedIndex;
7766
7767				if ( parent.parentNode ) {
7768					parent.parentNode.selectedIndex;
7769				}
7770			}
7771		}
7772	};
7773}
7774
7775jQuery.each( [
7776	"tabIndex",
7777	"readOnly",
7778	"maxLength",
7779	"cellSpacing",
7780	"cellPadding",
7781	"rowSpan",
7782	"colSpan",
7783	"useMap",
7784	"frameBorder",
7785	"contentEditable"
7786], function() {
7787	jQuery.propFix[ this.toLowerCase() ] = this;
7788} );
7789
7790
7791
7792
7793	// Strip and collapse whitespace according to HTML spec
7794	// https://html.spec.whatwg.org/multipage/infrastructure.html#strip-and-collapse-whitespace
7795	function stripAndCollapse( value ) {
7796		var tokens = value.match( rnothtmlwhite ) || [];
7797		return tokens.join( " " );
7798	}
7799
7800
7801function getClass( elem ) {
7802	return elem.getAttribute && elem.getAttribute( "class" ) || "";
7803}
7804
7805jQuery.fn.extend( {
7806	addClass: function( value ) {
7807		var classes, elem, cur, curValue, clazz, j, finalValue,
7808			i = 0;
7809
7810		if ( jQuery.isFunction( value ) ) {
7811			return this.each( function( j ) {
7812				jQuery( this ).addClass( value.call( this, j, getClass( this ) ) );
7813			} );
7814		}
7815
7816		if ( typeof value === "string" && value ) {
7817			classes = value.match( rnothtmlwhite ) || [];
7818
7819			while ( ( elem = this[ i++ ] ) ) {
7820				curValue = getClass( elem );
7821				cur = elem.nodeType === 1 && ( " " + stripAndCollapse( curValue ) + " " );
7822
7823				if ( cur ) {
7824					j = 0;
7825					while ( ( clazz = classes[ j++ ] ) ) {
7826						if ( cur.indexOf( " " + clazz + " " ) < 0 ) {
7827							cur += clazz + " ";
7828						}
7829					}
7830
7831					// Only assign if different to avoid unneeded rendering.
7832					finalValue = stripAndCollapse( cur );
7833					if ( curValue !== finalValue ) {
7834						elem.setAttribute( "class", finalValue );
7835					}
7836				}
7837			}
7838		}
7839
7840		return this;
7841	},
7842
7843	removeClass: function( value ) {
7844		var classes, elem, cur, curValue, clazz, j, finalValue,
7845			i = 0;
7846
7847		if ( jQuery.isFunction( value ) ) {
7848			return this.each( function( j ) {
7849				jQuery( this ).removeClass( value.call( this, j, getClass( this ) ) );
7850			} );
7851		}
7852
7853		if ( !arguments.length ) {
7854			return this.attr( "class", "" );
7855		}
7856
7857		if ( typeof value === "string" && value ) {
7858			classes = value.match( rnothtmlwhite ) || [];
7859
7860			while ( ( elem = this[ i++ ] ) ) {
7861				curValue = getClass( elem );
7862
7863				// This expression is here for better compressibility (see addClass)
7864				cur = elem.nodeType === 1 && ( " " + stripAndCollapse( curValue ) + " " );
7865
7866				if ( cur ) {
7867					j = 0;
7868					while ( ( clazz = classes[ j++ ] ) ) {
7869
7870						// Remove *all* instances
7871						while ( cur.indexOf( " " + clazz + " " ) > -1 ) {
7872							cur = cur.replace( " " + clazz + " ", " " );
7873						}
7874					}
7875
7876					// Only assign if different to avoid unneeded rendering.
7877					finalValue = stripAndCollapse( cur );
7878					if ( curValue !== finalValue ) {
7879						elem.setAttribute( "class", finalValue );
7880					}
7881				}
7882			}
7883		}
7884
7885		return this;
7886	},
7887
7888	toggleClass: function( value, stateVal ) {
7889		var type = typeof value;
7890
7891		if ( typeof stateVal === "boolean" && type === "string" ) {
7892			return stateVal ? this.addClass( value ) : this.removeClass( value );
7893		}
7894
7895		if ( jQuery.isFunction( value ) ) {
7896			return this.each( function( i ) {
7897				jQuery( this ).toggleClass(
7898					value.call( this, i, getClass( this ), stateVal ),
7899					stateVal
7900				);
7901			} );
7902		}
7903
7904		return this.each( function() {
7905			var className, i, self, classNames;
7906
7907			if ( type === "string" ) {
7908
7909				// Toggle individual class names
7910				i = 0;
7911				self = jQuery( this );
7912				classNames = value.match( rnothtmlwhite ) || [];
7913
7914				while ( ( className = classNames[ i++ ] ) ) {
7915
7916					// Check each className given, space separated list
7917					if ( self.hasClass( className ) ) {
7918						self.removeClass( className );
7919					} else {
7920						self.addClass( className );
7921					}
7922				}
7923
7924			// Toggle whole class name
7925			} else if ( value === undefined || type === "boolean" ) {
7926				className = getClass( this );
7927				if ( className ) {
7928
7929					// Store className if set
7930					dataPriv.set( this, "__className__", className );
7931				}
7932
7933				// If the element has a class name or if we're passed `false`,
7934				// then remove the whole classname (if there was one, the above saved it).
7935				// Otherwise bring back whatever was previously saved (if anything),
7936				// falling back to the empty string if nothing was stored.
7937				if ( this.setAttribute ) {
7938					this.setAttribute( "class",
7939						className || value === false ?
7940						"" :
7941						dataPriv.get( this, "__className__" ) || ""
7942					);
7943				}
7944			}
7945		} );
7946	},
7947
7948	hasClass: function( selector ) {
7949		var className, elem,
7950			i = 0;
7951
7952		className = " " + selector + " ";
7953		while ( ( elem = this[ i++ ] ) ) {
7954			if ( elem.nodeType === 1 &&
7955				( " " + stripAndCollapse( getClass( elem ) ) + " " ).indexOf( className ) > -1 ) {
7956					return true;
7957			}
7958		}
7959
7960		return false;
7961	}
7962} );
7963
7964
7965
7966
7967var rreturn = /\r/g;
7968
7969jQuery.fn.extend( {
7970	val: function( value ) {
7971		var hooks, ret, isFunction,
7972			elem = this[ 0 ];
7973
7974		if ( !arguments.length ) {
7975			if ( elem ) {
7976				hooks = jQuery.valHooks[ elem.type ] ||
7977					jQuery.valHooks[ elem.nodeName.toLowerCase() ];
7978
7979				if ( hooks &&
7980					"get" in hooks &&
7981					( ret = hooks.get( elem, "value" ) ) !== undefined
7982				) {
7983					return ret;
7984				}
7985
7986				ret = elem.value;
7987
7988				// Handle most common string cases
7989				if ( typeof ret === "string" ) {
7990					return ret.replace( rreturn, "" );
7991				}
7992
7993				// Handle cases where value is null/undef or number
7994				return ret == null ? "" : ret;
7995			}
7996
7997			return;
7998		}
7999
8000		isFunction = jQuery.isFunction( value );
8001
8002		return this.each( function( i ) {
8003			var val;
8004
8005			if ( this.nodeType !== 1 ) {
8006				return;
8007			}
8008
8009			if ( isFunction ) {
8010				val = value.call( this, i, jQuery( this ).val() );
8011			} else {
8012				val = value;
8013			}
8014
8015			// Treat null/undefined as ""; convert numbers to string
8016			if ( val == null ) {
8017				val = "";
8018
8019			} else if ( typeof val === "number" ) {
8020				val += "";
8021
8022			} else if ( jQuery.isArray( val ) ) {
8023				val = jQuery.map( val, function( value ) {
8024					return value == null ? "" : value + "";
8025				} );
8026			}
8027
8028			hooks = jQuery.valHooks[ this.type ] || jQuery.valHooks[ this.nodeName.toLowerCase() ];
8029
8030			// If set returns undefined, fall back to normal setting
8031			if ( !hooks || !( "set" in hooks ) || hooks.set( this, val, "value" ) === undefined ) {
8032				this.value = val;
8033			}
8034		} );
8035	}
8036} );
8037
8038jQuery.extend( {
8039	valHooks: {
8040		option: {
8041			get: function( elem ) {
8042
8043				var val = jQuery.find.attr( elem, "value" );
8044				return val != null ?
8045					val :
8046
8047					// Support: IE <=10 - 11 only
8048					// option.text throws exceptions (#14686, #14858)
8049					// Strip and collapse whitespace
8050					// https://html.spec.whatwg.org/#strip-and-collapse-whitespace
8051					stripAndCollapse( jQuery.text( elem ) );
8052			}
8053		},
8054		select: {
8055			get: function( elem ) {
8056				var value, option, i,
8057					options = elem.options,
8058					index = elem.selectedIndex,
8059					one = elem.type === "select-one",
8060					values = one ? null : [],
8061					max = one ? index + 1 : options.length;
8062
8063				if ( index < 0 ) {
8064					i = max;
8065
8066				} else {
8067					i = one ? index : 0;
8068				}
8069
8070				// Loop through all the selected options
8071				for ( ; i < max; i++ ) {
8072					option = options[ i ];
8073
8074					// Support: IE <=9 only
8075					// IE8-9 doesn't update selected after form reset (#2551)
8076					if ( ( option.selected || i === index ) &&
8077
8078							// Don't return options that are disabled or in a disabled optgroup
8079							!option.disabled &&
8080							( !option.parentNode.disabled ||
8081								!jQuery.nodeName( option.parentNode, "optgroup" ) ) ) {
8082
8083						// Get the specific value for the option
8084						value = jQuery( option ).val();
8085
8086						// We don't need an array for one selects
8087						if ( one ) {
8088							return value;
8089						}
8090
8091						// Multi-Selects return an array
8092						values.push( value );
8093					}
8094				}
8095
8096				return values;
8097			},
8098
8099			set: function( elem, value ) {
8100				var optionSet, option,
8101					options = elem.options,
8102					values = jQuery.makeArray( value ),
8103					i = options.length;
8104
8105				while ( i-- ) {
8106					option = options[ i ];
8107
8108					/* eslint-disable no-cond-assign */
8109
8110					if ( option.selected =
8111						jQuery.inArray( jQuery.valHooks.option.get( option ), values ) > -1
8112					) {
8113						optionSet = true;
8114					}
8115
8116					/* eslint-enable no-cond-assign */
8117				}
8118
8119				// Force browsers to behave consistently when non-matching value is set
8120				if ( !optionSet ) {
8121					elem.selectedIndex = -1;
8122				}
8123				return values;
8124			}
8125		}
8126	}
8127} );
8128
8129// Radios and checkboxes getter/setter
8130jQuery.each( [ "radio", "checkbox" ], function() {
8131	jQuery.valHooks[ this ] = {
8132		set: function( elem, value ) {
8133			if ( jQuery.isArray( value ) ) {
8134				return ( elem.checked = jQuery.inArray( jQuery( elem ).val(), value ) > -1 );
8135			}
8136		}
8137	};
8138	if ( !support.checkOn ) {
8139		jQuery.valHooks[ this ].get = function( elem ) {
8140			return elem.getAttribute( "value" ) === null ? "on" : elem.value;
8141		};
8142	}
8143} );
8144
8145
8146
8147
8148// Return jQuery for attributes-only inclusion
8149
8150
8151var rfocusMorph = /^(?:focusinfocus|focusoutblur)$/;
8152
8153jQuery.extend( jQuery.event, {
8154
8155	trigger: function( event, data, elem, onlyHandlers ) {
8156
8157		var i, cur, tmp, bubbleType, ontype, handle, special,
8158			eventPath = [ elem || document ],
8159			type = hasOwn.call( event, "type" ) ? event.type : event,
8160			namespaces = hasOwn.call( event, "namespace" ) ? event.namespace.split( "." ) : [];
8161
8162		cur = tmp = elem = elem || document;
8163
8164		// Don't do events on text and comment nodes
8165		if ( elem.nodeType === 3 || elem.nodeType === 8 ) {
8166			return;
8167		}
8168
8169		// focus/blur morphs to focusin/out; ensure we're not firing them right now
8170		if ( rfocusMorph.test( type + jQuery.event.triggered ) ) {
8171			return;
8172		}
8173
8174		if ( type.indexOf( "." ) > -1 ) {
8175
8176			// Namespaced trigger; create a regexp to match event type in handle()
8177			namespaces = type.split( "." );
8178			type = namespaces.shift();
8179			namespaces.sort();
8180		}
8181		ontype = type.indexOf( ":" ) < 0 && "on" + type;
8182
8183		// Caller can pass in a jQuery.Event object, Object, or just an event type string
8184		event = event[ jQuery.expando ] ?
8185			event :
8186			new jQuery.Event( type, typeof event === "object" && event );
8187
8188		// Trigger bitmask: & 1 for native handlers; & 2 for jQuery (always true)
8189		event.isTrigger = onlyHandlers ? 2 : 3;
8190		event.namespace = namespaces.join( "." );
8191		event.rnamespace = event.namespace ?
8192			new RegExp( "(^|\\.)" + namespaces.join( "\\.(?:.*\\.|)" ) + "(\\.|$)" ) :
8193			null;
8194
8195		// Clean up the event in case it is being reused
8196		event.result = undefined;
8197		if ( !event.target ) {
8198			event.target = elem;
8199		}
8200
8201		// Clone any incoming data and prepend the event, creating the handler arg list
8202		data = data == null ?
8203			[ event ] :
8204			jQuery.makeArray( data, [ event ] );
8205
8206		// Allow special events to draw outside the lines
8207		special = jQuery.event.special[ type ] || {};
8208		if ( !onlyHandlers && special.trigger && special.trigger.apply( elem, data ) === false ) {
8209			return;
8210		}
8211
8212		// Determine event propagation path in advance, per W3C events spec (#9951)
8213		// Bubble up to document, then to window; watch for a global ownerDocument var (#9724)
8214		if ( !onlyHandlers && !special.noBubble && !jQuery.isWindow( elem ) ) {
8215
8216			bubbleType = special.delegateType || type;
8217			if ( !rfocusMorph.test( bubbleType + type ) ) {
8218				cur = cur.parentNode;
8219			}
8220			for ( ; cur; cur = cur.parentNode ) {
8221				eventPath.push( cur );
8222				tmp = cur;
8223			}
8224
8225			// Only add window if we got to document (e.g., not plain obj or detached DOM)
8226			if ( tmp === ( elem.ownerDocument || document ) ) {
8227				eventPath.push( tmp.defaultView || tmp.parentWindow || window );
8228			}
8229		}
8230
8231		// Fire handlers on the event path
8232		i = 0;
8233		while ( ( cur = eventPath[ i++ ] ) && !event.isPropagationStopped() ) {
8234
8235			event.type = i > 1 ?
8236				bubbleType :
8237				special.bindType || type;
8238
8239			// jQuery handler
8240			handle = ( dataPriv.get( cur, "events" ) || {} )[ event.type ] &&
8241				dataPriv.get( cur, "handle" );
8242			if ( handle ) {
8243				handle.apply( cur, data );
8244			}
8245
8246			// Native handler
8247			handle = ontype && cur[ ontype ];
8248			if ( handle && handle.apply && acceptData( cur ) ) {
8249				event.result = handle.apply( cur, data );
8250				if ( event.result === false ) {
8251					event.preventDefault();
8252				}
8253			}
8254		}
8255		event.type = type;
8256
8257		// If nobody prevented the default action, do it now
8258		if ( !onlyHandlers && !event.isDefaultPrevented() ) {
8259
8260			if ( ( !special._default ||
8261				special._default.apply( eventPath.pop(), data ) === false ) &&
8262				acceptData( elem ) ) {
8263
8264				// Call a native DOM method on the target with the same name as the event.
8265				// Don't do default actions on window, that's where global variables be (#6170)
8266				if ( ontype && jQuery.isFunction( elem[ type ] ) && !jQuery.isWindow( elem ) ) {
8267
8268					// Don't re-trigger an onFOO event when we call its FOO() method
8269					tmp = elem[ ontype ];
8270
8271					if ( tmp ) {
8272						elem[ ontype ] = null;
8273					}
8274
8275					// Prevent re-triggering of the same event, since we already bubbled it above
8276					jQuery.event.triggered = type;
8277					elem[ type ]();
8278					jQuery.event.triggered = undefined;
8279
8280					if ( tmp ) {
8281						elem[ ontype ] = tmp;
8282					}
8283				}
8284			}
8285		}
8286
8287		return event.result;
8288	},
8289
8290	// Piggyback on a donor event to simulate a different one
8291	// Used only for `focus(in | out)` events
8292	simulate: function( type, elem, event ) {
8293		var e = jQuery.extend(
8294			new jQuery.Event(),
8295			event,
8296			{
8297				type: type,
8298				isSimulated: true
8299			}
8300		);
8301
8302		jQuery.event.trigger( e, null, elem );
8303	}
8304
8305} );
8306
8307jQuery.fn.extend( {
8308
8309	trigger: function( type, data ) {
8310		return this.each( function() {
8311			jQuery.event.trigger( type, data, this );
8312		} );
8313	},
8314	triggerHandler: function( type, data ) {
8315		var elem = this[ 0 ];
8316		if ( elem ) {
8317			return jQuery.event.trigger( type, data, elem, true );
8318		}
8319	}
8320} );
8321
8322
8323jQuery.each( ( "blur focus focusin focusout resize scroll click dblclick " +
8324	"mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave " +
8325	"change select submit keydown keypress keyup contextmenu" ).split( " " ),
8326	function( i, name ) {
8327
8328	// Handle event binding
8329	jQuery.fn[ name ] = function( data, fn ) {
8330		return arguments.length > 0 ?
8331			this.on( name, null, data, fn ) :
8332			this.trigger( name );
8333	};
8334} );
8335
8336jQuery.fn.extend( {
8337	hover: function( fnOver, fnOut ) {
8338		return this.mouseenter( fnOver ).mouseleave( fnOut || fnOver );
8339	}
8340} );
8341
8342
8343
8344
8345support.focusin = "onfocusin" in window;
8346
8347
8348// Support: Firefox <=44
8349// Firefox doesn't have focus(in | out) events
8350// Related ticket - https://bugzilla.mozilla.org/show_bug.cgi?id=687787
8351//
8352// Support: Chrome <=48 - 49, Safari <=9.0 - 9.1
8353// focus(in | out) events fire after focus & blur events,
8354// which is spec violation - http://www.w3.org/TR/DOM-Level-3-Events/#events-focusevent-event-order
8355// Related ticket - https://bugs.chromium.org/p/chromium/issues/detail?id=449857
8356if ( !support.focusin ) {
8357	jQuery.each( { focus: "focusin", blur: "focusout" }, function( orig, fix ) {
8358
8359		// Attach a single capturing handler on the document while someone wants focusin/focusout
8360		var handler = function( event ) {
8361			jQuery.event.simulate( fix, event.target, jQuery.event.fix( event ) );
8362		};
8363
8364		jQuery.event.special[ fix ] = {
8365			setup: function() {
8366				var doc = this.ownerDocument || this,
8367					attaches = dataPriv.access( doc, fix );
8368
8369				if ( !attaches ) {
8370					doc.addEventListener( orig, handler, true );
8371				}
8372				dataPriv.access( doc, fix, ( attaches || 0 ) + 1 );
8373			},
8374			teardown: function() {
8375				var doc = this.ownerDocument || this,
8376					attaches = dataPriv.access( doc, fix ) - 1;
8377
8378				if ( !attaches ) {
8379					doc.removeEventListener( orig, handler, true );
8380					dataPriv.remove( doc, fix );
8381
8382				} else {
8383					dataPriv.access( doc, fix, attaches );
8384				}
8385			}
8386		};
8387	} );
8388}
8389var location = window.location;
8390
8391var nonce = jQuery.now();
8392
8393var rquery = ( /\?/ );
8394
8395
8396
8397// Cross-browser xml parsing
8398jQuery.parseXML = function( data ) {
8399	var xml;
8400	if ( !data || typeof data !== "string" ) {
8401		return null;
8402	}
8403
8404	// Support: IE 9 - 11 only
8405	// IE throws on parseFromString with invalid input.
8406	try {
8407		xml = ( new window.DOMParser() ).parseFromString( data, "text/xml" );
8408	} catch ( e ) {
8409		xml = undefined;
8410	}
8411
8412	if ( !xml || xml.getElementsByTagName( "parsererror" ).length ) {
8413		jQuery.error( "Invalid XML: " + data );
8414	}
8415	return xml;
8416};
8417
8418
8419var
8420	rbracket = /\[\]$/,
8421	rCRLF = /\r?\n/g,
8422	rsubmitterTypes = /^(?:submit|button|image|reset|file)$/i,
8423	rsubmittable = /^(?:input|select|textarea|keygen)/i;
8424
8425function buildParams( prefix, obj, traditional, add ) {
8426	var name;
8427
8428	if ( jQuery.isArray( obj ) ) {
8429
8430		// Serialize array item.
8431		jQuery.each( obj, function( i, v ) {
8432			if ( traditional || rbracket.test( prefix ) ) {
8433
8434				// Treat each array item as a scalar.
8435				add( prefix, v );
8436
8437			} else {
8438
8439				// Item is non-scalar (array or object), encode its numeric index.
8440				buildParams(
8441					prefix + "[" + ( typeof v === "object" && v != null ? i : "" ) + "]",
8442					v,
8443					traditional,
8444					add
8445				);
8446			}
8447		} );
8448
8449	} else if ( !traditional && jQuery.type( obj ) === "object" ) {
8450
8451		// Serialize object item.
8452		for ( name in obj ) {
8453			buildParams( prefix + "[" + name + "]", obj[ name ], traditional, add );
8454		}
8455
8456	} else {
8457
8458		// Serialize scalar item.
8459		add( prefix, obj );
8460	}
8461}
8462
8463// Serialize an array of form elements or a set of
8464// key/values into a query string
8465jQuery.param = function( a, traditional ) {
8466	var prefix,
8467		s = [],
8468		add = function( key, valueOrFunction ) {
8469
8470			// If value is a function, invoke it and use its return value
8471			var value = jQuery.isFunction( valueOrFunction ) ?
8472				valueOrFunction() :
8473				valueOrFunction;
8474
8475			s[ s.length ] = encodeURIComponent( key ) + "=" +
8476				encodeURIComponent( value == null ? "" : value );
8477		};
8478
8479	// If an array was passed in, assume that it is an array of form elements.
8480	if ( jQuery.isArray( a ) || ( a.jquery && !jQuery.isPlainObject( a ) ) ) {
8481
8482		// Serialize the form elements
8483		jQuery.each( a, function() {
8484			add( this.name, this.value );
8485		} );
8486
8487	} else {
8488
8489		// If traditional, encode the "old" way (the way 1.3.2 or older
8490		// did it), otherwise encode params recursively.
8491		for ( prefix in a ) {
8492			buildParams( prefix, a[ prefix ], traditional, add );
8493		}
8494	}
8495
8496	// Return the resulting serialization
8497	return s.join( "&" );
8498};
8499
8500jQuery.fn.extend( {
8501	serialize: function() {
8502		return jQuery.param( this.serializeArray() );
8503	},
8504	serializeArray: function() {
8505		return this.map( function() {
8506
8507			// Can add propHook for "elements" to filter or add form elements
8508			var elements = jQuery.prop( this, "elements" );
8509			return elements ? jQuery.makeArray( elements ) : this;
8510		} )
8511		.filter( function() {
8512			var type = this.type;
8513
8514			// Use .is( ":disabled" ) so that fieldset[disabled] works
8515			return this.name && !jQuery( this ).is( ":disabled" ) &&
8516				rsubmittable.test( this.nodeName ) && !rsubmitterTypes.test( type ) &&
8517				( this.checked || !rcheckableType.test( type ) );
8518		} )
8519		.map( function( i, elem ) {
8520			var val = jQuery( this ).val();
8521
8522			if ( val == null ) {
8523				return null;
8524			}
8525
8526			if ( jQuery.isArray( val ) ) {
8527				return jQuery.map( val, function( val ) {
8528					return { name: elem.name, value: val.replace( rCRLF, "\r\n" ) };
8529				} );
8530			}
8531
8532			return { name: elem.name, value: val.replace( rCRLF, "\r\n" ) };
8533		} ).get();
8534	}
8535} );
8536
8537
8538var
8539	r20 = /%20/g,
8540	rhash = /#.*$/,
8541	rantiCache = /([?&])_=[^&]*/,
8542	rheaders = /^(.*?):[ \t]*([^\r\n]*)$/mg,
8543
8544	// #7653, #8125, #8152: local protocol detection
8545	rlocalProtocol = /^(?:about|app|app-storage|.+-extension|file|res|widget):$/,
8546	rnoContent = /^(?:GET|HEAD)$/,
8547	rprotocol = /^\/\//,
8548
8549	/* Prefilters
8550	 * 1) They are useful to introduce custom dataTypes (see ajax/jsonp.js for an example)
8551	 * 2) These are called:
8552	 *    - BEFORE asking for a transport
8553	 *    - AFTER param serialization (s.data is a string if s.processData is true)
8554	 * 3) key is the dataType
8555	 * 4) the catchall symbol "*" can be used
8556	 * 5) execution will start with transport dataType and THEN continue down to "*" if needed
8557	 */
8558	prefilters = {},
8559
8560	/* Transports bindings
8561	 * 1) key is the dataType
8562	 * 2) the catchall symbol "*" can be used
8563	 * 3) selection will start with transport dataType and THEN go to "*" if needed
8564	 */
8565	transports = {},
8566
8567	// Avoid comment-prolog char sequence (#10098); must appease lint and evade compression
8568	allTypes = "*/".concat( "*" ),
8569
8570	// Anchor tag for parsing the document origin
8571	originAnchor = document.createElement( "a" );
8572	originAnchor.href = location.href;
8573
8574// Base "constructor" for jQuery.ajaxPrefilter and jQuery.ajaxTransport
8575function addToPrefiltersOrTransports( structure ) {
8576
8577	// dataTypeExpression is optional and defaults to "*"
8578	return function( dataTypeExpression, func ) {
8579
8580		if ( typeof dataTypeExpression !== "string" ) {
8581			func = dataTypeExpression;
8582			dataTypeExpression = "*";
8583		}
8584
8585		var dataType,
8586			i = 0,
8587			dataTypes = dataTypeExpression.toLowerCase().match( rnothtmlwhite ) || [];
8588
8589		if ( jQuery.isFunction( func ) ) {
8590
8591			// For each dataType in the dataTypeExpression
8592			while ( ( dataType = dataTypes[ i++ ] ) ) {
8593
8594				// Prepend if requested
8595				if ( dataType[ 0 ] === "+" ) {
8596					dataType = dataType.slice( 1 ) || "*";
8597					( structure[ dataType ] = structure[ dataType ] || [] ).unshift( func );
8598
8599				// Otherwise append
8600				} else {
8601					( structure[ dataType ] = structure[ dataType ] || [] ).push( func );
8602				}
8603			}
8604		}
8605	};
8606}
8607
8608// Base inspection function for prefilters and transports
8609function inspectPrefiltersOrTransports( structure, options, originalOptions, jqXHR ) {
8610
8611	var inspected = {},
8612		seekingTransport = ( structure === transports );
8613
8614	function inspect( dataType ) {
8615		var selected;
8616		inspected[ dataType ] = true;
8617		jQuery.each( structure[ dataType ] || [], function( _, prefilterOrFactory ) {
8618			var dataTypeOrTransport = prefilterOrFactory( options, originalOptions, jqXHR );
8619			if ( typeof dataTypeOrTransport === "string" &&
8620				!seekingTransport && !inspected[ dataTypeOrTransport ] ) {
8621
8622				options.dataTypes.unshift( dataTypeOrTransport );
8623				inspect( dataTypeOrTransport );
8624				return false;
8625			} else if ( seekingTransport ) {
8626				return !( selected = dataTypeOrTransport );
8627			}
8628		} );
8629		return selected;
8630	}
8631
8632	return inspect( options.dataTypes[ 0 ] ) || !inspected[ "*" ] && inspect( "*" );
8633}
8634
8635// A special extend for ajax options
8636// that takes "flat" options (not to be deep extended)
8637// Fixes #9887
8638function ajaxExtend( target, src ) {
8639	var key, deep,
8640		flatOptions = jQuery.ajaxSettings.flatOptions || {};
8641
8642	for ( key in src ) {
8643		if ( src[ key ] !== undefined ) {
8644			( flatOptions[ key ] ? target : ( deep || ( deep = {} ) ) )[ key ] = src[ key ];
8645		}
8646	}
8647	if ( deep ) {
8648		jQuery.extend( true, target, deep );
8649	}
8650
8651	return target;
8652}
8653
8654/* Handles responses to an ajax request:
8655 * - finds the right dataType (mediates between content-type and expected dataType)
8656 * - returns the corresponding response
8657 */
8658function ajaxHandleResponses( s, jqXHR, responses ) {
8659
8660	var ct, type, finalDataType, firstDataType,
8661		contents = s.contents,
8662		dataTypes = s.dataTypes;
8663
8664	// Remove auto dataType and get content-type in the process
8665	while ( dataTypes[ 0 ] === "*" ) {
8666		dataTypes.shift();
8667		if ( ct === undefined ) {
8668			ct = s.mimeType || jqXHR.getResponseHeader( "Content-Type" );
8669		}
8670	}
8671
8672	// Check if we're dealing with a known content-type
8673	if ( ct ) {
8674		for ( type in contents ) {
8675			if ( contents[ type ] && contents[ type ].test( ct ) ) {
8676				dataTypes.unshift( type );
8677				break;
8678			}
8679		}
8680	}
8681
8682	// Check to see if we have a response for the expected dataType
8683	if ( dataTypes[ 0 ] in responses ) {
8684		finalDataType = dataTypes[ 0 ];
8685	} else {
8686
8687		// Try convertible dataTypes
8688		for ( type in responses ) {
8689			if ( !dataTypes[ 0 ] || s.converters[ type + " " + dataTypes[ 0 ] ] ) {
8690				finalDataType = type;
8691				break;
8692			}
8693			if ( !firstDataType ) {
8694				firstDataType = type;
8695			}
8696		}
8697
8698		// Or just use first one
8699		finalDataType = finalDataType || firstDataType;
8700	}
8701
8702	// If we found a dataType
8703	// We add the dataType to the list if needed
8704	// and return the corresponding response
8705	if ( finalDataType ) {
8706		if ( finalDataType !== dataTypes[ 0 ] ) {
8707			dataTypes.unshift( finalDataType );
8708		}
8709		return responses[ finalDataType ];
8710	}
8711}
8712
8713/* Chain conversions given the request and the original response
8714 * Also sets the responseXXX fields on the jqXHR instance
8715 */
8716function ajaxConvert( s, response, jqXHR, isSuccess ) {
8717	var conv2, current, conv, tmp, prev,
8718		converters = {},
8719
8720		// Work with a copy of dataTypes in case we need to modify it for conversion
8721		dataTypes = s.dataTypes.slice();
8722
8723	// Create converters map with lowercased keys
8724	if ( dataTypes[ 1 ] ) {
8725		for ( conv in s.converters ) {
8726			converters[ conv.toLowerCase() ] = s.converters[ conv ];
8727		}
8728	}
8729
8730	current = dataTypes.shift();
8731
8732	// Convert to each sequential dataType
8733	while ( current ) {
8734
8735		if ( s.responseFields[ current ] ) {
8736			jqXHR[ s.responseFields[ current ] ] = response;
8737		}
8738
8739		// Apply the dataFilter if provided
8740		if ( !prev && isSuccess && s.dataFilter ) {
8741			response = s.dataFilter( response, s.dataType );
8742		}
8743
8744		prev = current;
8745		current = dataTypes.shift();
8746
8747		if ( current ) {
8748
8749			// There's only work to do if current dataType is non-auto
8750			if ( current === "*" ) {
8751
8752				current = prev;
8753
8754			// Convert response if prev dataType is non-auto and differs from current
8755			} else if ( prev !== "*" && prev !== current ) {
8756
8757				// Seek a direct converter
8758				conv = converters[ prev + " " + current ] || converters[ "* " + current ];
8759
8760				// If none found, seek a pair
8761				if ( !conv ) {
8762					for ( conv2 in converters ) {
8763
8764						// If conv2 outputs current
8765						tmp = conv2.split( " " );
8766						if ( tmp[ 1 ] === current ) {
8767
8768							// If prev can be converted to accepted input
8769							conv = converters[ prev + " " + tmp[ 0 ] ] ||
8770								converters[ "* " + tmp[ 0 ] ];
8771							if ( conv ) {
8772
8773								// Condense equivalence converters
8774								if ( conv === true ) {
8775									conv = converters[ conv2 ];
8776
8777								// Otherwise, insert the intermediate dataType
8778								} else if ( converters[ conv2 ] !== true ) {
8779									current = tmp[ 0 ];
8780									dataTypes.unshift( tmp[ 1 ] );
8781								}
8782								break;
8783							}
8784						}
8785					}
8786				}
8787
8788				// Apply converter (if not an equivalence)
8789				if ( conv !== true ) {
8790
8791					// Unless errors are allowed to bubble, catch and return them
8792					if ( conv && s.throws ) {
8793						response = conv( response );
8794					} else {
8795						try {
8796							response = conv( response );
8797						} catch ( e ) {
8798							return {
8799								state: "parsererror",
8800								error: conv ? e : "No conversion from " + prev + " to " + current
8801							};
8802						}
8803					}
8804				}
8805			}
8806		}
8807	}
8808
8809	return { state: "success", data: response };
8810}
8811
8812jQuery.extend( {
8813
8814	// Counter for holding the number of active queries
8815	active: 0,
8816
8817	// Last-Modified header cache for next request
8818	lastModified: {},
8819	etag: {},
8820
8821	ajaxSettings: {
8822		url: location.href,
8823		type: "GET",
8824		isLocal: rlocalProtocol.test( location.protocol ),
8825		global: true,
8826		processData: true,
8827		async: true,
8828		contentType: "application/x-www-form-urlencoded; charset=UTF-8",
8829
8830		/*
8831		timeout: 0,
8832		data: null,
8833		dataType: null,
8834		username: null,
8835		password: null,
8836		cache: null,
8837		throws: false,
8838		traditional: false,
8839		headers: {},
8840		*/
8841
8842		accepts: {
8843			"*": allTypes,
8844			text: "text/plain",
8845			html: "text/html",
8846			xml: "application/xml, text/xml",
8847			json: "application/json, text/javascript"
8848		},
8849
8850		contents: {
8851			xml: /\bxml\b/,
8852			html: /\bhtml/,
8853			json: /\bjson\b/
8854		},
8855
8856		responseFields: {
8857			xml: "responseXML",
8858			text: "responseText",
8859			json: "responseJSON"
8860		},
8861
8862		// Data converters
8863		// Keys separate source (or catchall "*") and destination types with a single space
8864		converters: {
8865
8866			// Convert anything to text
8867			"* text": String,
8868
8869			// Text to html (true = no transformation)
8870			"text html": true,
8871
8872			// Evaluate text as a json expression
8873			"text json": JSON.parse,
8874
8875			// Parse text as xml
8876			"text xml": jQuery.parseXML
8877		},
8878
8879		// For options that shouldn't be deep extended:
8880		// you can add your own custom options here if
8881		// and when you create one that shouldn't be
8882		// deep extended (see ajaxExtend)
8883		flatOptions: {
8884			url: true,
8885			context: true
8886		}
8887	},
8888
8889	// Creates a full fledged settings object into target
8890	// with both ajaxSettings and settings fields.
8891	// If target is omitted, writes into ajaxSettings.
8892	ajaxSetup: function( target, settings ) {
8893		return settings ?
8894
8895			// Building a settings object
8896			ajaxExtend( ajaxExtend( target, jQuery.ajaxSettings ), settings ) :
8897
8898			// Extending ajaxSettings
8899			ajaxExtend( jQuery.ajaxSettings, target );
8900	},
8901
8902	ajaxPrefilter: addToPrefiltersOrTransports( prefilters ),
8903	ajaxTransport: addToPrefiltersOrTransports( transports ),
8904
8905	// Main method
8906	ajax: function( url, options ) {
8907
8908		// If url is an object, simulate pre-1.5 signature
8909		if ( typeof url === "object" ) {
8910			options = url;
8911			url = undefined;
8912		}
8913
8914		// Force options to be an object
8915		options = options || {};
8916
8917		var transport,
8918
8919			// URL without anti-cache param
8920			cacheURL,
8921
8922			// Response headers
8923			responseHeadersString,
8924			responseHeaders,
8925
8926			// timeout handle
8927			timeoutTimer,
8928
8929			// Url cleanup var
8930			urlAnchor,
8931
8932			// Request state (becomes false upon send and true upon completion)
8933			completed,
8934
8935			// To know if global events are to be dispatched
8936			fireGlobals,
8937
8938			// Loop variable
8939			i,
8940
8941			// uncached part of the url
8942			uncached,
8943
8944			// Create the final options object
8945			s = jQuery.ajaxSetup( {}, options ),
8946
8947			// Callbacks context
8948			callbackContext = s.context || s,
8949
8950			// Context for global events is callbackContext if it is a DOM node or jQuery collection
8951			globalEventContext = s.context &&
8952				( callbackContext.nodeType || callbackContext.jquery ) ?
8953					jQuery( callbackContext ) :
8954					jQuery.event,
8955
8956			// Deferreds
8957			deferred = jQuery.Deferred(),
8958			completeDeferred = jQuery.Callbacks( "once memory" ),
8959
8960			// Status-dependent callbacks
8961			statusCode = s.statusCode || {},
8962
8963			// Headers (they are sent all at once)
8964			requestHeaders = {},
8965			requestHeadersNames = {},
8966
8967			// Default abort message
8968			strAbort = "canceled",
8969
8970			// Fake xhr
8971			jqXHR = {
8972				readyState: 0,
8973
8974				// Builds headers hashtable if needed
8975				getResponseHeader: function( key ) {
8976					var match;
8977					if ( completed ) {
8978						if ( !responseHeaders ) {
8979							responseHeaders = {};
8980							while ( ( match = rheaders.exec( responseHeadersString ) ) ) {
8981								responseHeaders[ match[ 1 ].toLowerCase() ] = match[ 2 ];
8982							}
8983						}
8984						match = responseHeaders[ key.toLowerCase() ];
8985					}
8986					return match == null ? null : match;
8987				},
8988
8989				// Raw string
8990				getAllResponseHeaders: function() {
8991					return completed ? responseHeadersString : null;
8992				},
8993
8994				// Caches the header
8995				setRequestHeader: function( name, value ) {
8996					if ( completed == null ) {
8997						name = requestHeadersNames[ name.toLowerCase() ] =
8998							requestHeadersNames[ name.toLowerCase() ] || name;
8999						requestHeaders[ name ] = value;
9000					}
9001					return this;
9002				},
9003
9004				// Overrides response content-type header
9005				overrideMimeType: function( type ) {
9006					if ( completed == null ) {
9007						s.mimeType = type;
9008					}
9009					return this;
9010				},
9011
9012				// Status-dependent callbacks
9013				statusCode: function( map ) {
9014					var code;
9015					if ( map ) {
9016						if ( completed ) {
9017
9018							// Execute the appropriate callbacks
9019							jqXHR.always( map[ jqXHR.status ] );
9020						} else {
9021
9022							// Lazy-add the new callbacks in a way that preserves old ones
9023							for ( code in map ) {
9024								statusCode[ code ] = [ statusCode[ code ], map[ code ] ];
9025							}
9026						}
9027					}
9028					return this;
9029				},
9030
9031				// Cancel the request
9032				abort: function( statusText ) {
9033					var finalText = statusText || strAbort;
9034					if ( transport ) {
9035						transport.abort( finalText );
9036					}
9037					done( 0, finalText );
9038					return this;
9039				}
9040			};
9041
9042		// Attach deferreds
9043		deferred.promise( jqXHR );
9044
9045		// Add protocol if not provided (prefilters might expect it)
9046		// Handle falsy url in the settings object (#10093: consistency with old signature)
9047		// We also use the url parameter if available
9048		s.url = ( ( url || s.url || location.href ) + "" )
9049			.replace( rprotocol, location.protocol + "//" );
9050
9051		// Alias method option to type as per ticket #12004
9052		s.type = options.method || options.type || s.method || s.type;
9053
9054		// Extract dataTypes list
9055		s.dataTypes = ( s.dataType || "*" ).toLowerCase().match( rnothtmlwhite ) || [ "" ];
9056
9057		// A cross-domain request is in order when the origin doesn't match the current origin.
9058		if ( s.crossDomain == null ) {
9059			urlAnchor = document.createElement( "a" );
9060
9061			// Support: IE <=8 - 11, Edge 12 - 13
9062			// IE throws exception on accessing the href property if url is malformed,
9063			// e.g. http://example.com:80x/
9064			try {
9065				urlAnchor.href = s.url;
9066
9067				// Support: IE <=8 - 11 only
9068				// Anchor's host property isn't correctly set when s.url is relative
9069				urlAnchor.href = urlAnchor.href;
9070				s.crossDomain = originAnchor.protocol + "//" + originAnchor.host !==
9071					urlAnchor.protocol + "//" + urlAnchor.host;
9072			} catch ( e ) {
9073
9074				// If there is an error parsing the URL, assume it is crossDomain,
9075				// it can be rejected by the transport if it is invalid
9076				s.crossDomain = true;
9077			}
9078		}
9079
9080		// Convert data if not already a string
9081		if ( s.data && s.processData && typeof s.data !== "string" ) {
9082			s.data = jQuery.param( s.data, s.traditional );
9083		}
9084
9085		// Apply prefilters
9086		inspectPrefiltersOrTransports( prefilters, s, options, jqXHR );
9087
9088		// If request was aborted inside a prefilter, stop there
9089		if ( completed ) {
9090			return jqXHR;
9091		}
9092
9093		// We can fire global events as of now if asked to
9094		// Don't fire events if jQuery.event is undefined in an AMD-usage scenario (#15118)
9095		fireGlobals = jQuery.event && s.global;
9096
9097		// Watch for a new set of requests
9098		if ( fireGlobals && jQuery.active++ === 0 ) {
9099			jQuery.event.trigger( "ajaxStart" );
9100		}
9101
9102		// Uppercase the type
9103		s.type = s.type.toUpperCase();
9104
9105		// Determine if request has content
9106		s.hasContent = !rnoContent.test( s.type );
9107
9108		// Save the URL in case we're toying with the If-Modified-Since
9109		// and/or If-None-Match header later on
9110		// Remove hash to simplify url manipulation
9111		cacheURL = s.url.replace( rhash, "" );
9112
9113		// More options handling for requests with no content
9114		if ( !s.hasContent ) {
9115
9116			// Remember the hash so we can put it back
9117			uncached = s.url.slice( cacheURL.length );
9118
9119			// If data is available, append data to url
9120			if ( s.data ) {
9121				cacheURL += ( rquery.test( cacheURL ) ? "&" : "?" ) + s.data;
9122
9123				// #9682: remove data so that it's not used in an eventual retry
9124				delete s.data;
9125			}
9126
9127			// Add or update anti-cache param if needed
9128			if ( s.cache === false ) {
9129				cacheURL = cacheURL.replace( rantiCache, "$1" );
9130				uncached = ( rquery.test( cacheURL ) ? "&" : "?" ) + "_=" + ( nonce++ ) + uncached;
9131			}
9132
9133			// Put hash and anti-cache on the URL that will be requested (gh-1732)
9134			s.url = cacheURL + uncached;
9135
9136		// Change '%20' to '+' if this is encoded form body content (gh-2658)
9137		} else if ( s.data && s.processData &&
9138			( s.contentType || "" ).indexOf( "application/x-www-form-urlencoded" ) === 0 ) {
9139			s.data = s.data.replace( r20, "+" );
9140		}
9141
9142		// Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
9143		if ( s.ifModified ) {
9144			if ( jQuery.lastModified[ cacheURL ] ) {
9145				jqXHR.setRequestHeader( "If-Modified-Since", jQuery.lastModified[ cacheURL ] );
9146			}
9147			if ( jQuery.etag[ cacheURL ] ) {
9148				jqXHR.setRequestHeader( "If-None-Match", jQuery.etag[ cacheURL ] );
9149			}
9150		}
9151
9152		// Set the correct header, if data is being sent
9153		if ( s.data && s.hasContent && s.contentType !== false || options.contentType ) {
9154			jqXHR.setRequestHeader( "Content-Type", s.contentType );
9155		}
9156
9157		// Set the Accepts header for the server, depending on the dataType
9158		jqXHR.setRequestHeader(
9159			"Accept",
9160			s.dataTypes[ 0 ] && s.accepts[ s.dataTypes[ 0 ] ] ?
9161				s.accepts[ s.dataTypes[ 0 ] ] +
9162					( s.dataTypes[ 0 ] !== "*" ? ", " + allTypes + "; q=0.01" : "" ) :
9163				s.accepts[ "*" ]
9164		);
9165
9166		// Check for headers option
9167		for ( i in s.headers ) {
9168			jqXHR.setRequestHeader( i, s.headers[ i ] );
9169		}
9170
9171		// Allow custom headers/mimetypes and early abort
9172		if ( s.beforeSend &&
9173			( s.beforeSend.call( callbackContext, jqXHR, s ) === false || completed ) ) {
9174
9175			// Abort if not done already and return
9176			return jqXHR.abort();
9177		}
9178
9179		// Aborting is no longer a cancellation
9180		strAbort = "abort";
9181
9182		// Install callbacks on deferreds
9183		completeDeferred.add( s.complete );
9184		jqXHR.done( s.success );
9185		jqXHR.fail( s.error );
9186
9187		// Get transport
9188		transport = inspectPrefiltersOrTransports( transports, s, options, jqXHR );
9189
9190		// If no transport, we auto-abort
9191		if ( !transport ) {
9192			done( -1, "No Transport" );
9193		} else {
9194			jqXHR.readyState = 1;
9195
9196			// Send global event
9197			if ( fireGlobals ) {
9198				globalEventContext.trigger( "ajaxSend", [ jqXHR, s ] );
9199			}
9200
9201			// If request was aborted inside ajaxSend, stop there
9202			if ( completed ) {
9203				return jqXHR;
9204			}
9205
9206			// Timeout
9207			if ( s.async && s.timeout > 0 ) {
9208				timeoutTimer = window.setTimeout( function() {
9209					jqXHR.abort( "timeout" );
9210				}, s.timeout );
9211			}
9212
9213			try {
9214				completed = false;
9215				transport.send( requestHeaders, done );
9216			} catch ( e ) {
9217
9218				// Rethrow post-completion exceptions
9219				if ( completed ) {
9220					throw e;
9221				}
9222
9223				// Propagate others as results
9224				done( -1, e );
9225			}
9226		}
9227
9228		// Callback for when everything is done
9229		function done( status, nativeStatusText, responses, headers ) {
9230			var isSuccess, success, error, response, modified,
9231				statusText = nativeStatusText;
9232
9233			// Ignore repeat invocations
9234			if ( completed ) {
9235				return;
9236			}
9237
9238			completed = true;
9239
9240			// Clear timeout if it exists
9241			if ( timeoutTimer ) {
9242				window.clearTimeout( timeoutTimer );
9243			}
9244
9245			// Dereference transport for early garbage collection
9246			// (no matter how long the jqXHR object will be used)
9247			transport = undefined;
9248
9249			// Cache response headers
9250			responseHeadersString = headers || "";
9251
9252			// Set readyState
9253			jqXHR.readyState = status > 0 ? 4 : 0;
9254
9255			// Determine if successful
9256			isSuccess = status >= 200 && status < 300 || status === 304;
9257
9258			// Get response data
9259			if ( responses ) {
9260				response = ajaxHandleResponses( s, jqXHR, responses );
9261			}
9262
9263			// Convert no matter what (that way responseXXX fields are always set)
9264			response = ajaxConvert( s, response, jqXHR, isSuccess );
9265
9266			// If successful, handle type chaining
9267			if ( isSuccess ) {
9268
9269				// Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
9270				if ( s.ifModified ) {
9271					modified = jqXHR.getResponseHeader( "Last-Modified" );
9272					if ( modified ) {
9273						jQuery.lastModified[ cacheURL ] = modified;
9274					}
9275					modified = jqXHR.getResponseHeader( "etag" );
9276					if ( modified ) {
9277						jQuery.etag[ cacheURL ] = modified;
9278					}
9279				}
9280
9281				// if no content
9282				if ( status === 204 || s.type === "HEAD" ) {
9283					statusText = "nocontent";
9284
9285				// if not modified
9286				} else if ( status === 304 ) {
9287					statusText = "notmodified";
9288
9289				// If we have data, let's convert it
9290				} else {
9291					statusText = response.state;
9292					success = response.data;
9293					error = response.error;
9294					isSuccess = !error;
9295				}
9296			} else {
9297
9298				// Extract error from statusText and normalize for non-aborts
9299				error = statusText;
9300				if ( status || !statusText ) {
9301					statusText = "error";
9302					if ( status < 0 ) {
9303						status = 0;
9304					}
9305				}
9306			}
9307
9308			// Set data for the fake xhr object
9309			jqXHR.status = status;
9310			jqXHR.statusText = ( nativeStatusText || statusText ) + "";
9311
9312			// Success/Error
9313			if ( isSuccess ) {
9314				deferred.resolveWith( callbackContext, [ success, statusText, jqXHR ] );
9315			} else {
9316				deferred.rejectWith( callbackContext, [ jqXHR, statusText, error ] );
9317			}
9318
9319			// Status-dependent callbacks
9320			jqXHR.statusCode( statusCode );
9321			statusCode = undefined;
9322
9323			if ( fireGlobals ) {
9324				globalEventContext.trigger( isSuccess ? "ajaxSuccess" : "ajaxError",
9325					[ jqXHR, s, isSuccess ? success : error ] );
9326			}
9327
9328			// Complete
9329			completeDeferred.fireWith( callbackContext, [ jqXHR, statusText ] );
9330
9331			if ( fireGlobals ) {
9332				globalEventContext.trigger( "ajaxComplete", [ jqXHR, s ] );
9333
9334				// Handle the global AJAX counter
9335				if ( !( --jQuery.active ) ) {
9336					jQuery.event.trigger( "ajaxStop" );
9337				}
9338			}
9339		}
9340
9341		return jqXHR;
9342	},
9343
9344	getJSON: function( url, data, callback ) {
9345		return jQuery.get( url, data, callback, "json" );
9346	},
9347
9348	getScript: function( url, callback ) {
9349		return jQuery.get( url, undefined, callback, "script" );
9350	}
9351} );
9352
9353jQuery.each( [ "get", "post" ], function( i, method ) {
9354	jQuery[ method ] = function( url, data, callback, type ) {
9355
9356		// Shift arguments if data argument was omitted
9357		if ( jQuery.isFunction( data ) ) {
9358			type = type || callback;
9359			callback = data;
9360			data = undefined;
9361		}
9362
9363		// The url can be an options object (which then must have .url)
9364		return jQuery.ajax( jQuery.extend( {
9365			url: url,
9366			type: method,
9367			dataType: type,
9368			data: data,
9369			success: callback
9370		}, jQuery.isPlainObject( url ) && url ) );
9371	};
9372} );
9373
9374
9375jQuery._evalUrl = function( url ) {
9376	return jQuery.ajax( {
9377		url: url,
9378
9379		// Make this explicit, since user can override this through ajaxSetup (#11264)
9380		type: "GET",
9381		dataType: "script",
9382		cache: true,
9383		async: false,
9384		global: false,
9385		"throws": true
9386	} );
9387};
9388
9389
9390jQuery.fn.extend( {
9391	wrapAll: function( html ) {
9392		var wrap;
9393
9394		if ( this[ 0 ] ) {
9395			if ( jQuery.isFunction( html ) ) {
9396				html = html.call( this[ 0 ] );
9397			}
9398
9399			// The elements to wrap the target around
9400			wrap = jQuery( html, this[ 0 ].ownerDocument ).eq( 0 ).clone( true );
9401
9402			if ( this[ 0 ].parentNode ) {
9403				wrap.insertBefore( this[ 0 ] );
9404			}
9405
9406			wrap.map( function() {
9407				var elem = this;
9408
9409				while ( elem.firstElementChild ) {
9410					elem = elem.firstElementChild;
9411				}
9412
9413				return elem;
9414			} ).append( this );
9415		}
9416
9417		return this;
9418	},
9419
9420	wrapInner: function( html ) {
9421		if ( jQuery.isFunction( html ) ) {
9422			return this.each( function( i ) {
9423				jQuery( this ).wrapInner( html.call( this, i ) );
9424			} );
9425		}
9426
9427		return this.each( function() {
9428			var self = jQuery( this ),
9429				contents = self.contents();
9430
9431			if ( contents.length ) {
9432				contents.wrapAll( html );
9433
9434			} else {
9435				self.append( html );
9436			}
9437		} );
9438	},
9439
9440	wrap: function( html ) {
9441		var isFunction = jQuery.isFunction( html );
9442
9443		return this.each( function( i ) {
9444			jQuery( this ).wrapAll( isFunction ? html.call( this, i ) : html );
9445		} );
9446	},
9447
9448	unwrap: function( selector ) {
9449		this.parent( selector ).not( "body" ).each( function() {
9450			jQuery( this ).replaceWith( this.childNodes );
9451		} );
9452		return this;
9453	}
9454} );
9455
9456
9457jQuery.expr.pseudos.hidden = function( elem ) {
9458	return !jQuery.expr.pseudos.visible( elem );
9459};
9460jQuery.expr.pseudos.visible = function( elem ) {
9461	return !!( elem.offsetWidth || elem.offsetHeight || elem.getClientRects().length );
9462};
9463
9464
9465
9466
9467jQuery.ajaxSettings.xhr = function() {
9468	try {
9469		return new window.XMLHttpRequest();
9470	} catch ( e ) {}
9471};
9472
9473var xhrSuccessStatus = {
9474
9475		// File protocol always yields status code 0, assume 200
9476		0: 200,
9477
9478		// Support: IE <=9 only
9479		// #1450: sometimes IE returns 1223 when it should be 204
9480		1223: 204
9481	},
9482	xhrSupported = jQuery.ajaxSettings.xhr();
9483
9484support.cors = !!xhrSupported && ( "withCredentials" in xhrSupported );
9485support.ajax = xhrSupported = !!xhrSupported;
9486
9487jQuery.ajaxTransport( function( options ) {
9488	var callback, errorCallback;
9489
9490	// Cross domain only allowed if supported through XMLHttpRequest
9491	if ( support.cors || xhrSupported && !options.crossDomain ) {
9492		return {
9493			send: function( headers, complete ) {
9494				var i,
9495					xhr = options.xhr();
9496
9497				xhr.open(
9498					options.type,
9499					options.url,
9500					options.async,
9501					options.username,
9502					options.password
9503				);
9504
9505				// Apply custom fields if provided
9506				if ( options.xhrFields ) {
9507					for ( i in options.xhrFields ) {
9508						xhr[ i ] = options.xhrFields[ i ];
9509					}
9510				}
9511
9512				// Override mime type if needed
9513				if ( options.mimeType && xhr.overrideMimeType ) {
9514					xhr.overrideMimeType( options.mimeType );
9515				}
9516
9517				// X-Requested-With header
9518				// For cross-domain requests, seeing as conditions for a preflight are
9519				// akin to a jigsaw puzzle, we simply never set it to be sure.
9520				// (it can always be set on a per-request basis or even using ajaxSetup)
9521				// For same-domain requests, won't change header if already provided.
9522				if ( !options.crossDomain && !headers[ "X-Requested-With" ] ) {
9523					headers[ "X-Requested-With" ] = "XMLHttpRequest";
9524				}
9525
9526				// Set headers
9527				for ( i in headers ) {
9528					xhr.setRequestHeader( i, headers[ i ] );
9529				}
9530
9531				// Callback
9532				callback = function( type ) {
9533					return function() {
9534						if ( callback ) {
9535							callback = errorCallback = xhr.onload =
9536								xhr.onerror = xhr.onabort = xhr.onreadystatechange = null;
9537
9538							if ( type === "abort" ) {
9539								xhr.abort();
9540							} else if ( type === "error" ) {
9541
9542								// Support: IE <=9 only
9543								// On a manual native abort, IE9 throws
9544								// errors on any property access that is not readyState
9545								if ( typeof xhr.status !== "number" ) {
9546									complete( 0, "error" );
9547								} else {
9548									complete(
9549
9550										// File: protocol always yields status 0; see #8605, #14207
9551										xhr.status,
9552										xhr.statusText
9553									);
9554								}
9555							} else {
9556								complete(
9557									xhrSuccessStatus[ xhr.status ] || xhr.status,
9558									xhr.statusText,
9559
9560									// Support: IE <=9 only
9561									// IE9 has no XHR2 but throws on binary (trac-11426)
9562									// For XHR2 non-text, let the caller handle it (gh-2498)
9563									( xhr.responseType || "text" ) !== "text"  ||
9564									typeof xhr.responseText !== "string" ?
9565										{ binary: xhr.response } :
9566										{ text: xhr.responseText },
9567									xhr.getAllResponseHeaders()
9568								);
9569							}
9570						}
9571					};
9572				};
9573
9574				// Listen to events
9575				xhr.onload = callback();
9576				errorCallback = xhr.onerror = callback( "error" );
9577
9578				// Support: IE 9 only
9579				// Use onreadystatechange to replace onabort
9580				// to handle uncaught aborts
9581				if ( xhr.onabort !== undefined ) {
9582					xhr.onabort = errorCallback;
9583				} else {
9584					xhr.onreadystatechange = function() {
9585
9586						// Check readyState before timeout as it changes
9587						if ( xhr.readyState === 4 ) {
9588
9589							// Allow onerror to be called first,
9590							// but that will not handle a native abort
9591							// Also, save errorCallback to a variable
9592							// as xhr.onerror cannot be accessed
9593							window.setTimeout( function() {
9594								if ( callback ) {
9595									errorCallback();
9596								}
9597							} );
9598						}
9599					};
9600				}
9601
9602				// Create the abort callback
9603				callback = callback( "abort" );
9604
9605				try {
9606
9607					// Do send the request (this may raise an exception)
9608					xhr.send( options.hasContent && options.data || null );
9609				} catch ( e ) {
9610
9611					// #14683: Only rethrow if this hasn't been notified as an error yet
9612					if ( callback ) {
9613						throw e;
9614					}
9615				}
9616			},
9617
9618			abort: function() {
9619				if ( callback ) {
9620					callback();
9621				}
9622			}
9623		};
9624	}
9625} );
9626
9627
9628
9629
9630// Prevent auto-execution of scripts when no explicit dataType was provided (See gh-2432)
9631jQuery.ajaxPrefilter( function( s ) {
9632	if ( s.crossDomain ) {
9633		s.contents.script = false;
9634	}
9635} );
9636
9637// Install script dataType
9638jQuery.ajaxSetup( {
9639	accepts: {
9640		script: "text/javascript, application/javascript, " +
9641			"application/ecmascript, application/x-ecmascript"
9642	},
9643	contents: {
9644		script: /\b(?:java|ecma)script\b/
9645	},
9646	converters: {
9647		"text script": function( text ) {
9648			jQuery.globalEval( text );
9649			return text;
9650		}
9651	}
9652} );
9653
9654// Handle cache's special case and crossDomain
9655jQuery.ajaxPrefilter( "script", function( s ) {
9656	if ( s.cache === undefined ) {
9657		s.cache = false;
9658	}
9659	if ( s.crossDomain ) {
9660		s.type = "GET";
9661	}
9662} );
9663
9664// Bind script tag hack transport
9665jQuery.ajaxTransport( "script", function( s ) {
9666
9667	// This transport only deals with cross domain requests
9668	if ( s.crossDomain ) {
9669		var script, callback;
9670		return {
9671			send: function( _, complete ) {
9672				script = jQuery( "<script>" ).prop( {
9673					charset: s.scriptCharset,
9674					src: s.url
9675				} ).on(
9676					"load error",
9677					callback = function( evt ) {
9678						script.remove();
9679						callback = null;
9680						if ( evt ) {
9681							complete( evt.type === "error" ? 404 : 200, evt.type );
9682						}
9683					}
9684				);
9685
9686				// Use native DOM manipulation to avoid our domManip AJAX trickery
9687				document.head.appendChild( script[ 0 ] );
9688			},
9689			abort: function() {
9690				if ( callback ) {
9691					callback();
9692				}
9693			}
9694		};
9695	}
9696} );
9697
9698
9699
9700
9701var oldCallbacks = [],
9702	rjsonp = /(=)\?(?=&|$)|\?\?/;
9703
9704// Default jsonp settings
9705jQuery.ajaxSetup( {
9706	jsonp: "callback",
9707	jsonpCallback: function() {
9708		var callback = oldCallbacks.pop() || ( jQuery.expando + "_" + ( nonce++ ) );
9709		this[ callback ] = true;
9710		return callback;
9711	}
9712} );
9713
9714// Detect, normalize options and install callbacks for jsonp requests
9715jQuery.ajaxPrefilter( "json jsonp", function( s, originalSettings, jqXHR ) {
9716
9717	var callbackName, overwritten, responseContainer,
9718		jsonProp = s.jsonp !== false && ( rjsonp.test( s.url ) ?
9719			"url" :
9720			typeof s.data === "string" &&
9721				( s.contentType || "" )
9722					.indexOf( "application/x-www-form-urlencoded" ) === 0 &&
9723				rjsonp.test( s.data ) && "data"
9724		);
9725
9726	// Handle iff the expected data type is "jsonp" or we have a parameter to set
9727	if ( jsonProp || s.dataTypes[ 0 ] === "jsonp" ) {
9728
9729		// Get callback name, remembering preexisting value associated with it
9730		callbackName = s.jsonpCallback = jQuery.isFunction( s.jsonpCallback ) ?
9731			s.jsonpCallback() :
9732			s.jsonpCallback;
9733
9734		// Insert callback into url or form data
9735		if ( jsonProp ) {
9736			s[ jsonProp ] = s[ jsonProp ].replace( rjsonp, "$1" + callbackName );
9737		} else if ( s.jsonp !== false ) {
9738			s.url += ( rquery.test( s.url ) ? "&" : "?" ) + s.jsonp + "=" + callbackName;
9739		}
9740
9741		// Use data converter to retrieve json after script execution
9742		s.converters[ "script json" ] = function() {
9743			if ( !responseContainer ) {
9744				jQuery.error( callbackName + " was not called" );
9745			}
9746			return responseContainer[ 0 ];
9747		};
9748
9749		// Force json dataType
9750		s.dataTypes[ 0 ] = "json";
9751
9752		// Install callback
9753		overwritten = window[ callbackName ];
9754		window[ callbackName ] = function() {
9755			responseContainer = arguments;
9756		};
9757
9758		// Clean-up function (fires after converters)
9759		jqXHR.always( function() {
9760
9761			// If previous value didn't exist - remove it
9762			if ( overwritten === undefined ) {
9763				jQuery( window ).removeProp( callbackName );
9764
9765			// Otherwise restore preexisting value
9766			} else {
9767				window[ callbackName ] = overwritten;
9768			}
9769
9770			// Save back as free
9771			if ( s[ callbackName ] ) {
9772
9773				// Make sure that re-using the options doesn't screw things around
9774				s.jsonpCallback = originalSettings.jsonpCallback;
9775
9776				// Save the callback name for future use
9777				oldCallbacks.push( callbackName );
9778			}
9779
9780			// Call if it was a function and we have a response
9781			if ( responseContainer && jQuery.isFunction( overwritten ) ) {
9782				overwritten( responseContainer[ 0 ] );
9783			}
9784
9785			responseContainer = overwritten = undefined;
9786		} );
9787
9788		// Delegate to script
9789		return "script";
9790	}
9791} );
9792
9793
9794
9795
9796// Support: Safari 8 only
9797// In Safari 8 documents created via document.implementation.createHTMLDocument
9798// collapse sibling forms: the second one becomes a child of the first one.
9799// Because of that, this security measure has to be disabled in Safari 8.
9800// https://bugs.webkit.org/show_bug.cgi?id=137337
9801support.createHTMLDocument = ( function() {
9802	var body = document.implementation.createHTMLDocument( "" ).body;
9803	body.innerHTML = "<form></form><form></form>";
9804	return body.childNodes.length === 2;
9805} )();
9806
9807
9808// Argument "data" should be string of html
9809// context (optional): If specified, the fragment will be created in this context,
9810// defaults to document
9811// keepScripts (optional): If true, will include scripts passed in the html string
9812jQuery.parseHTML = function( data, context, keepScripts ) {
9813	if ( typeof data !== "string" ) {
9814		return [];
9815	}
9816	if ( typeof context === "boolean" ) {
9817		keepScripts = context;
9818		context = false;
9819	}
9820
9821	var base, parsed, scripts;
9822
9823	if ( !context ) {
9824
9825		// Stop scripts or inline event handlers from being executed immediately
9826		// by using document.implementation
9827		if ( support.createHTMLDocument ) {
9828			context = document.implementation.createHTMLDocument( "" );
9829
9830			// Set the base href for the created document
9831			// so any parsed elements with URLs
9832			// are based on the document's URL (gh-2965)
9833			base = context.createElement( "base" );
9834			base.href = document.location.href;
9835			context.head.appendChild( base );
9836		} else {
9837			context = document;
9838		}
9839	}
9840
9841	parsed = rsingleTag.exec( data );
9842	scripts = !keepScripts && [];
9843
9844	// Single tag
9845	if ( parsed ) {
9846		return [ context.createElement( parsed[ 1 ] ) ];
9847	}
9848
9849	parsed = buildFragment( [ data ], context, scripts );
9850
9851	if ( scripts && scripts.length ) {
9852		jQuery( scripts ).remove();
9853	}
9854
9855	return jQuery.merge( [], parsed.childNodes );
9856};
9857
9858
9859/**
9860 * Load a url into a page
9861 */
9862jQuery.fn.load = function( url, params, callback ) {
9863	var selector, type, response,
9864		self = this,
9865		off = url.indexOf( " " );
9866
9867	if ( off > -1 ) {
9868		selector = stripAndCollapse( url.slice( off ) );
9869		url = url.slice( 0, off );
9870	}
9871
9872	// If it's a function
9873	if ( jQuery.isFunction( params ) ) {
9874
9875		// We assume that it's the callback
9876		callback = params;
9877		params = undefined;
9878
9879	// Otherwise, build a param string
9880	} else if ( params && typeof params === "object" ) {
9881		type = "POST";
9882	}
9883
9884	// If we have elements to modify, make the request
9885	if ( self.length > 0 ) {
9886		jQuery.ajax( {
9887			url: url,
9888
9889			// If "type" variable is undefined, then "GET" method will be used.
9890			// Make value of this field explicit since
9891			// user can override it through ajaxSetup method
9892			type: type || "GET",
9893			dataType: "html",
9894			data: params
9895		} ).done( function( responseText ) {
9896
9897			// Save response for use in complete callback
9898			response = arguments;
9899
9900			self.html( selector ?
9901
9902				// If a selector was specified, locate the right elements in a dummy div
9903				// Exclude scripts to avoid IE 'Permission Denied' errors
9904				jQuery( "<div>" ).append( jQuery.parseHTML( responseText ) ).find( selector ) :
9905
9906				// Otherwise use the full result
9907				responseText );
9908
9909		// If the request succeeds, this function gets "data", "status", "jqXHR"
9910		// but they are ignored because response was set above.
9911		// If it fails, this function gets "jqXHR", "status", "error"
9912		} ).always( callback && function( jqXHR, status ) {
9913			self.each( function() {
9914				callback.apply( this, response || [ jqXHR.responseText, status, jqXHR ] );
9915			} );
9916		} );
9917	}
9918
9919	return this;
9920};
9921
9922
9923
9924
9925// Attach a bunch of functions for handling common AJAX events
9926jQuery.each( [
9927	"ajaxStart",
9928	"ajaxStop",
9929	"ajaxComplete",
9930	"ajaxError",
9931	"ajaxSuccess",
9932	"ajaxSend"
9933], function( i, type ) {
9934	jQuery.fn[ type ] = function( fn ) {
9935		return this.on( type, fn );
9936	};
9937} );
9938
9939
9940
9941
9942jQuery.expr.pseudos.animated = function( elem ) {
9943	return jQuery.grep( jQuery.timers, function( fn ) {
9944		return elem === fn.elem;
9945	} ).length;
9946};
9947
9948
9949
9950
9951/**
9952 * Gets a window from an element
9953 */
9954function getWindow( elem ) {
9955	return jQuery.isWindow( elem ) ? elem : elem.nodeType === 9 && elem.defaultView;
9956}
9957
9958jQuery.offset = {
9959	setOffset: function( elem, options, i ) {
9960		var curPosition, curLeft, curCSSTop, curTop, curOffset, curCSSLeft, calculatePosition,
9961			position = jQuery.css( elem, "position" ),
9962			curElem = jQuery( elem ),
9963			props = {};
9964
9965		// Set position first, in-case top/left are set even on static elem
9966		if ( position === "static" ) {
9967			elem.style.position = "relative";
9968		}
9969
9970		curOffset = curElem.offset();
9971		curCSSTop = jQuery.css( elem, "top" );
9972		curCSSLeft = jQuery.css( elem, "left" );
9973		calculatePosition = ( position === "absolute" || position === "fixed" ) &&
9974			( curCSSTop + curCSSLeft ).indexOf( "auto" ) > -1;
9975
9976		// Need to be able to calculate position if either
9977		// top or left is auto and position is either absolute or fixed
9978		if ( calculatePosition ) {
9979			curPosition = curElem.position();
9980			curTop = curPosition.top;
9981			curLeft = curPosition.left;
9982
9983		} else {
9984			curTop = parseFloat( curCSSTop ) || 0;
9985			curLeft = parseFloat( curCSSLeft ) || 0;
9986		}
9987
9988		if ( jQuery.isFunction( options ) ) {
9989
9990			// Use jQuery.extend here to allow modification of coordinates argument (gh-1848)
9991			options = options.call( elem, i, jQuery.extend( {}, curOffset ) );
9992		}
9993
9994		if ( options.top != null ) {
9995			props.top = ( options.top - curOffset.top ) + curTop;
9996		}
9997		if ( options.left != null ) {
9998			props.left = ( options.left - curOffset.left ) + curLeft;
9999		}
10000
10001		if ( "using" in options ) {
10002			options.using.call( elem, props );
10003
10004		} else {
10005			curElem.css( props );
10006		}
10007	}
10008};
10009
10010jQuery.fn.extend( {
10011	offset: function( options ) {
10012
10013		// Preserve chaining for setter
10014		if ( arguments.length ) {
10015			return options === undefined ?
10016				this :
10017				this.each( function( i ) {
10018					jQuery.offset.setOffset( this, options, i );
10019				} );
10020		}
10021
10022		var docElem, win, rect, doc,
10023			elem = this[ 0 ];
10024
10025		if ( !elem ) {
10026			return;
10027		}
10028
10029		// Support: IE <=11 only
10030		// Running getBoundingClientRect on a
10031		// disconnected node in IE throws an error
10032		if ( !elem.getClientRects().length ) {
10033			return { top: 0, left: 0 };
10034		}
10035
10036		rect = elem.getBoundingClientRect();
10037
10038		// Make sure element is not hidden (display: none)
10039		if ( rect.width || rect.height ) {
10040			doc = elem.ownerDocument;
10041			win = getWindow( doc );
10042			docElem = doc.documentElement;
10043
10044			return {
10045				top: rect.top + win.pageYOffset - docElem.clientTop,
10046				left: rect.left + win.pageXOffset - docElem.clientLeft
10047			};
10048		}
10049
10050		// Return zeros for disconnected and hidden elements (gh-2310)
10051		return rect;
10052	},
10053
10054	position: function() {
10055		if ( !this[ 0 ] ) {
10056			return;
10057		}
10058
10059		var offsetParent, offset,
10060			elem = this[ 0 ],
10061			parentOffset = { top: 0, left: 0 };
10062
10063		// Fixed elements are offset from window (parentOffset = {top:0, left: 0},
10064		// because it is its only offset parent
10065		if ( jQuery.css( elem, "position" ) === "fixed" ) {
10066
10067			// Assume getBoundingClientRect is there when computed position is fixed
10068			offset = elem.getBoundingClientRect();
10069
10070		} else {
10071
10072			// Get *real* offsetParent
10073			offsetParent = this.offsetParent();
10074
10075			// Get correct offsets
10076			offset = this.offset();
10077			if ( !jQuery.nodeName( offsetParent[ 0 ], "html" ) ) {
10078				parentOffset = offsetParent.offset();
10079			}
10080
10081			// Add offsetParent borders
10082			parentOffset = {
10083				top: parentOffset.top + jQuery.css( offsetParent[ 0 ], "borderTopWidth", true ),
10084				left: parentOffset.left + jQuery.css( offsetParent[ 0 ], "borderLeftWidth", true )
10085			};
10086		}
10087
10088		// Subtract parent offsets and element margins
10089		return {
10090			top: offset.top - parentOffset.top - jQuery.css( elem, "marginTop", true ),
10091			left: offset.left - parentOffset.left - jQuery.css( elem, "marginLeft", true )
10092		};
10093	},
10094
10095	// This method will return documentElement in the following cases:
10096	// 1) For the element inside the iframe without offsetParent, this method will return
10097	//    documentElement of the parent window
10098	// 2) For the hidden or detached element
10099	// 3) For body or html element, i.e. in case of the html node - it will return itself
10100	//
10101	// but those exceptions were never presented as a real life use-cases
10102	// and might be considered as more preferable results.
10103	//
10104	// This logic, however, is not guaranteed and can change at any point in the future
10105	offsetParent: function() {
10106		return this.map( function() {
10107			var offsetParent = this.offsetParent;
10108
10109			while ( offsetParent && jQuery.css( offsetParent, "position" ) === "static" ) {
10110				offsetParent = offsetParent.offsetParent;
10111			}
10112
10113			return offsetParent || documentElement;
10114		} );
10115	}
10116} );
10117
10118// Create scrollLeft and scrollTop methods
10119jQuery.each( { scrollLeft: "pageXOffset", scrollTop: "pageYOffset" }, function( method, prop ) {
10120	var top = "pageYOffset" === prop;
10121
10122	jQuery.fn[ method ] = function( val ) {
10123		return access( this, function( elem, method, val ) {
10124			var win = getWindow( elem );
10125
10126			if ( val === undefined ) {
10127				return win ? win[ prop ] : elem[ method ];
10128			}
10129
10130			if ( win ) {
10131				win.scrollTo(
10132					!top ? val : win.pageXOffset,
10133					top ? val : win.pageYOffset
10134				);
10135
10136			} else {
10137				elem[ method ] = val;
10138			}
10139		}, method, val, arguments.length );
10140	};
10141} );
10142
10143// Support: Safari <=7 - 9.1, Chrome <=37 - 49
10144// Add the top/left cssHooks using jQuery.fn.position
10145// Webkit bug: https://bugs.webkit.org/show_bug.cgi?id=29084
10146// Blink bug: https://bugs.chromium.org/p/chromium/issues/detail?id=589347
10147// getComputedStyle returns percent when specified for top/left/bottom/right;
10148// rather than make the css module depend on the offset module, just check for it here
10149jQuery.each( [ "top", "left" ], function( i, prop ) {
10150	jQuery.cssHooks[ prop ] = addGetHookIf( support.pixelPosition,
10151		function( elem, computed ) {
10152			if ( computed ) {
10153				computed = curCSS( elem, prop );
10154
10155				// If curCSS returns percentage, fallback to offset
10156				return rnumnonpx.test( computed ) ?
10157					jQuery( elem ).position()[ prop ] + "px" :
10158					computed;
10159			}
10160		}
10161	);
10162} );
10163
10164
10165// Create innerHeight, innerWidth, height, width, outerHeight and outerWidth methods
10166jQuery.each( { Height: "height", Width: "width" }, function( name, type ) {
10167	jQuery.each( { padding: "inner" + name, content: type, "": "outer" + name },
10168		function( defaultExtra, funcName ) {
10169
10170		// Margin is only for outerHeight, outerWidth
10171		jQuery.fn[ funcName ] = function( margin, value ) {
10172			var chainable = arguments.length && ( defaultExtra || typeof margin !== "boolean" ),
10173				extra = defaultExtra || ( margin === true || value === true ? "margin" : "border" );
10174
10175			return access( this, function( elem, type, value ) {
10176				var doc;
10177
10178				if ( jQuery.isWindow( elem ) ) {
10179
10180					// $( window ).outerWidth/Height return w/h including scrollbars (gh-1729)
10181					return funcName.indexOf( "outer" ) === 0 ?
10182						elem[ "inner" + name ] :
10183						elem.document.documentElement[ "client" + name ];
10184				}
10185
10186				// Get document width or height
10187				if ( elem.nodeType === 9 ) {
10188					doc = elem.documentElement;
10189
10190					// Either scroll[Width/Height] or offset[Width/Height] or client[Width/Height],
10191					// whichever is greatest
10192					return Math.max(
10193						elem.body[ "scroll" + name ], doc[ "scroll" + name ],
10194						elem.body[ "offset" + name ], doc[ "offset" + name ],
10195						doc[ "client" + name ]
10196					);
10197				}
10198
10199				return value === undefined ?
10200
10201					// Get width or height on the element, requesting but not forcing parseFloat
10202					jQuery.css( elem, type, extra ) :
10203
10204					// Set width or height on the element
10205					jQuery.style( elem, type, value, extra );
10206			}, type, chainable ? margin : undefined, chainable );
10207		};
10208	} );
10209} );
10210
10211
10212jQuery.fn.extend( {
10213
10214	bind: function( types, data, fn ) {
10215		return this.on( types, null, data, fn );
10216	},
10217	unbind: function( types, fn ) {
10218		return this.off( types, null, fn );
10219	},
10220
10221	delegate: function( selector, types, data, fn ) {
10222		return this.on( types, selector, data, fn );
10223	},
10224	undelegate: function( selector, types, fn ) {
10225
10226		// ( namespace ) or ( selector, types [, fn] )
10227		return arguments.length === 1 ?
10228			this.off( selector, "**" ) :
10229			this.off( types, selector || "**", fn );
10230	}
10231} );
10232
10233jQuery.parseJSON = JSON.parse;
10234
10235
10236
10237
10238// Register as a named AMD module, since jQuery can be concatenated with other
10239// files that may use define, but not via a proper concatenation script that
10240// understands anonymous AMD modules. A named AMD is safest and most robust
10241// way to register. Lowercase jquery is used because AMD module names are
10242// derived from file names, and jQuery is normally delivered in a lowercase
10243// file name. Do this after creating the global so that if an AMD module wants
10244// to call noConflict to hide this version of jQuery, it will work.
10245
10246// Note that for maximum portability, libraries that are not jQuery should
10247// declare themselves as anonymous modules, and avoid setting a global if an
10248// AMD loader is present. jQuery is a special case. For more information, see
10249// https://github.com/jrburke/requirejs/wiki/Updating-existing-libraries#wiki-anon
10250
10251if ( true ) {
10252	!(__WEBPACK_AMD_DEFINE_ARRAY__ = [], __WEBPACK_AMD_DEFINE_RESULT__ = function() {
10253		return jQuery;
10254	}.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__),
10255				__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
10256}
10257
10258
10259
10260
10261var
10262
10263	// Map over jQuery in case of overwrite
10264	_jQuery = window.jQuery,
10265
10266	// Map over the $ in case of overwrite
10267	_$ = window.$;
10268
10269jQuery.noConflict = function( deep ) {
10270	if ( window.$ === jQuery ) {
10271		window.$ = _$;
10272	}
10273
10274	if ( deep && window.jQuery === jQuery ) {
10275		window.jQuery = _jQuery;
10276	}
10277
10278	return jQuery;
10279};
10280
10281// Expose jQuery and $ identifiers, even in AMD
10282// (#7102#comment:10, https://github.com/jquery/jquery/pull/557)
10283// and CommonJS for browser emulators (#13566)
10284if ( !noGlobal ) {
10285	window.jQuery = window.$ = jQuery;
10286}
10287
10288
10289
10290
10291
10292return jQuery;
10293} );
10294
10295
10296/***/ }),
10297/* 1 */
10298/***/ (function(module, exports) {
10299
10300/* WEBPACK VAR INJECTION */(function(__webpack_amd_options__) {/* globals __webpack_amd_options__ */
10301module.exports = __webpack_amd_options__;
10302
10303/* WEBPACK VAR INJECTION */}.call(exports, {}))
10304
10305/***/ }),
10306/* 2 */,
10307/* 3 */
10308/***/ (function(module, exports, __webpack_require__) {
10309
10310
10311__webpack_require__(0);
10312__webpack_require__(5);
10313//require('slick-carousel');
10314__webpack_require__(7);
10315//require('velocity-animate');
10316//require('nouislider');
10317//require('modernizr'); WEBPACK ERROR
10318//require('detectizr');
10319//require('gmap3');
10320//require('isotope-layout'); WEBPACK ERROR
10321//require('easy-countdown');
10322//require('magnific-popup');
10323//require('wnumb');
10324__webpack_require__(6);
10325
10326/***/ }),
10327/* 4 */
10328/***/ (function(module, exports) {
10329
10330// removed by extract-text-webpack-plugin
10331
10332/***/ }),
10333/* 5 */
10334/***/ (function(module, exports, __webpack_require__) {
10335
10336/* WEBPACK VAR INJECTION */(function(jQuery) {/*!
10337 * Bootstrap v3.3.7 (http://getbootstrap.com)
10338 * Copyright 2011-2016 Twitter, Inc.
10339 * Licensed under the MIT license
10340 */
10341
10342if (typeof jQuery === 'undefined') {
10343  throw new Error('Bootstrap\'s JavaScript requires jQuery')
10344}
10345
10346+function ($) {
10347  'use strict';
10348  var version = $.fn.jquery.split(' ')[0].split('.')
10349  if ((version[0] < 2 && version[1] < 9) || (version[0] == 1 && version[1] == 9 && version[2] < 1) || (version[0] > 3)) {
10350    throw new Error('Bootstrap\'s JavaScript requires jQuery version 1.9.1 or higher, but lower than version 4')
10351  }
10352}(jQuery);
10353
10354/* ========================================================================
10355 * Bootstrap: transition.js v3.3.7
10356 * http://getbootstrap.com/javascript/#transitions
10357 * ========================================================================
10358 * Copyright 2011-2016 Twitter, Inc.
10359 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
10360 * ======================================================================== */
10361
10362
10363+function ($) {
10364  'use strict';
10365
10366  // CSS TRANSITION SUPPORT (Shoutout: http://www.modernizr.com/)
10367  // ============================================================
10368
10369  function transitionEnd() {
10370    var el = document.createElement('bootstrap')
10371
10372    var transEndEventNames = {
10373      WebkitTransition : 'webkitTransitionEnd',
10374      MozTransition    : 'transitionend',
10375      OTransition      : 'oTransitionEnd otransitionend',
10376      transition       : 'transitionend'
10377    }
10378
10379    for (var name in transEndEventNames) {
10380      if (el.style[name] !== undefined) {
10381        return { end: transEndEventNames[name] }
10382      }
10383    }
10384
10385    return false // explicit for ie8 (  ._.)
10386  }
10387
10388  // http://blog.alexmaccaw.com/css-transitions
10389  $.fn.emulateTransitionEnd = function (duration) {
10390    var called = false
10391    var $el = this
10392    $(this).one('bsTransitionEnd', function () { called = true })
10393    var callback = function () { if (!called) $($el).trigger($.support.transition.end) }
10394    setTimeout(callback, duration)
10395    return this
10396  }
10397
10398  $(function () {
10399    $.support.transition = transitionEnd()
10400
10401    if (!$.support.transition) return
10402
10403    $.event.special.bsTransitionEnd = {
10404      bindType: $.support.transition.end,
10405      delegateType: $.support.transition.end,
10406      handle: function (e) {
10407        if ($(e.target).is(this)) return e.handleObj.handler.apply(this, arguments)
10408      }
10409    }
10410  })
10411
10412}(jQuery);
10413
10414/* ========================================================================
10415 * Bootstrap: alert.js v3.3.7
10416 * http://getbootstrap.com/javascript/#alerts
10417 * ========================================================================
10418 * Copyright 2011-2016 Twitter, Inc.
10419 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
10420 * ======================================================================== */
10421
10422
10423+function ($) {
10424  'use strict';
10425
10426  // ALERT CLASS DEFINITION
10427  // ======================
10428
10429  var dismiss = '[data-dismiss="alert"]'
10430  var Alert   = function (el) {
10431    $(el).on('click', dismiss, this.close)
10432  }
10433
10434  Alert.VERSION = '3.3.7'
10435
10436  Alert.TRANSITION_DURATION = 150
10437
10438  Alert.prototype.close = function (e) {
10439    var $this    = $(this)
10440    var selector = $this.attr('data-target')
10441
10442    if (!selector) {
10443      selector = $this.attr('href')
10444      selector = selector && selector.replace(/.*(?=#[^\s]*$)/, '') // strip for ie7
10445    }
10446
10447    var $parent = $(selector === '#' ? [] : selector)
10448
10449    if (e) e.preventDefault()
10450
10451    if (!$parent.length) {
10452      $parent = $this.closest('.alert')
10453    }
10454
10455    $parent.trigger(e = $.Event('close.bs.alert'))
10456
10457    if (e.isDefaultPrevented()) return
10458
10459    $parent.removeClass('in')
10460
10461    function removeElement() {
10462      // detach from parent, fire event then clean up data
10463      $parent.detach().trigger('closed.bs.alert').remove()
10464    }
10465
10466    $.support.transition && $parent.hasClass('fade') ?
10467      $parent
10468        .one('bsTransitionEnd', removeElement)
10469        .emulateTransitionEnd(Alert.TRANSITION_DURATION) :
10470      removeElement()
10471  }
10472
10473
10474  // ALERT PLUGIN DEFINITION
10475  // =======================
10476
10477  function Plugin(option) {
10478    return this.each(function () {
10479      var $this = $(this)
10480      var data  = $this.data('bs.alert')
10481
10482      if (!data) $this.data('bs.alert', (data = new Alert(this)))
10483      if (typeof option == 'string') data[option].call($this)
10484    })
10485  }
10486
10487  var old = $.fn.alert
10488
10489  $.fn.alert             = Plugin
10490  $.fn.alert.Constructor = Alert
10491
10492
10493  // ALERT NO CONFLICT
10494  // =================
10495
10496  $.fn.alert.noConflict = function () {
10497    $.fn.alert = old
10498    return this
10499  }
10500
10501
10502  // ALERT DATA-API
10503  // ==============
10504
10505  $(document).on('click.bs.alert.data-api', dismiss, Alert.prototype.close)
10506
10507}(jQuery);
10508
10509/* ========================================================================
10510 * Bootstrap: button.js v3.3.7
10511 * http://getbootstrap.com/javascript/#buttons
10512 * ========================================================================
10513 * Copyright 2011-2016 Twitter, Inc.
10514 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
10515 * ======================================================================== */
10516
10517
10518+function ($) {
10519  'use strict';
10520
10521  // BUTTON PUBLIC CLASS DEFINITION
10522  // ==============================
10523
10524  var Button = function (element, options) {
10525    this.$element  = $(element)
10526    this.options   = $.extend({}, Button.DEFAULTS, options)
10527    this.isLoading = false
10528  }
10529
10530  Button.VERSION  = '3.3.7'
10531
10532  Button.DEFAULTS = {
10533    loadingText: 'loading...'
10534  }
10535
10536  Button.prototype.setState = function (state) {
10537    var d    = 'disabled'
10538    var $el  = this.$element
10539    var val  = $el.is('input') ? 'val' : 'html'
10540    var data = $el.data()
10541
10542    state += 'Text'
10543
10544    if (data.resetText == null) $el.data('resetText', $el[val]())
10545
10546    // push to event loop to allow forms to submit
10547    setTimeout($.proxy(function () {
10548      $el[val](data[state] == null ? this.options[state] : data[state])
10549
10550      if (state == 'loadingText') {
10551        this.isLoading = true
10552        $el.addClass(d).attr(d, d).prop(d, true)
10553      } else if (this.isLoading) {
10554        this.isLoading = false
10555        $el.removeClass(d).removeAttr(d).prop(d, false)
10556      }
10557    }, this), 0)
10558  }
10559
10560  Button.prototype.toggle = function () {
10561    var changed = true
10562    var $parent = this.$element.closest('[data-toggle="buttons"]')
10563
10564    if ($parent.length) {
10565      var $input = this.$element.find('input')
10566      if ($input.prop('type') == 'radio') {
10567        if ($input.prop('checked')) changed = false
10568        $parent.find('.active').removeClass('active')
10569        this.$element.addClass('active')
10570      } else if ($input.prop('type') == 'checkbox') {
10571        if (($input.prop('checked')) !== this.$element.hasClass('active')) changed = false
10572        this.$element.toggleClass('active')
10573      }
10574      $input.prop('checked', this.$element.hasClass('active'))
10575      if (changed) $input.trigger('change')
10576    } else {
10577      this.$element.attr('aria-pressed', !this.$element.hasClass('active'))
10578      this.$element.toggleClass('active')
10579    }
10580  }
10581
10582
10583  // BUTTON PLUGIN DEFINITION
10584  // ========================
10585
10586  function Plugin(option) {
10587    return this.each(function () {
10588      var $this   = $(this)
10589      var data    = $this.data('bs.button')
10590      var options = typeof option == 'object' && option
10591
10592      if (!data) $this.data('bs.button', (data = new Button(this, options)))
10593
10594      if (option == 'toggle') data.toggle()
10595      else if (option) data.setState(option)
10596    })
10597  }
10598
10599  var old = $.fn.button
10600
10601  $.fn.button             = Plugin
10602  $.fn.button.Constructor = Button
10603
10604
10605  // BUTTON NO CONFLICT
10606  // ==================
10607
10608  $.fn.button.noConflict = function () {
10609    $.fn.button = old
10610    return this
10611  }
10612
10613
10614  // BUTTON DATA-API
10615  // ===============
10616
10617  $(document)
10618    .on('click.bs.button.data-api', '[data-toggle^="button"]', function (e) {
10619      var $btn = $(e.target).closest('.btn')
10620      Plugin.call($btn, 'toggle')
10621      if (!($(e.target).is('input[type="radio"], input[type="checkbox"]'))) {
10622        // Prevent double click on radios, and the double selections (so cancellation) on checkboxes
10623        e.preventDefault()
10624        // The target component still receive the focus
10625        if ($btn.is('input,button')) $btn.trigger('focus')
10626        else $btn.find('input:visible,button:visible').first().trigger('focus')
10627      }
10628    })
10629    .on('focus.bs.button.data-api blur.bs.button.data-api', '[data-toggle^="button"]', function (e) {
10630      $(e.target).closest('.btn').toggleClass('focus', /^focus(in)?$/.test(e.type))
10631    })
10632
10633}(jQuery);
10634
10635/* ========================================================================
10636 * Bootstrap: carousel.js v3.3.7
10637 * http://getbootstrap.com/javascript/#carousel
10638 * ========================================================================
10639 * Copyright 2011-2016 Twitter, Inc.
10640 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
10641 * ======================================================================== */
10642
10643
10644+function ($) {
10645  'use strict';
10646
10647  // CAROUSEL CLASS DEFINITION
10648  // =========================
10649
10650  var Carousel = function (element, options) {
10651    this.$element    = $(element)
10652    this.$indicators = this.$element.find('.carousel-indicators')
10653    this.options     = options
10654    this.paused      = null
10655    this.sliding     = null
10656    this.interval    = null
10657    this.$active     = null
10658    this.$items      = null
10659
10660    this.options.keyboard && this.$element.on('keydown.bs.carousel', $.proxy(this.keydown, this))
10661
10662    this.options.pause == 'hover' && !('ontouchstart' in document.documentElement) && this.$element
10663      .on('mouseenter.bs.carousel', $.proxy(this.pause, this))
10664      .on('mouseleave.bs.carousel', $.proxy(this.cycle, this))
10665  }
10666
10667  Carousel.VERSION  = '3.3.7'
10668
10669  Carousel.TRANSITION_DURATION = 600
10670
10671  Carousel.DEFAULTS = {
10672    interval: 5000,
10673    pause: 'hover',
10674    wrap: true,
10675    keyboard: true
10676  }
10677
10678  Carousel.prototype.keydown = function (e) {
10679    if (/input|textarea/i.test(e.target.tagName)) return
10680    switch (e.which) {
10681      case 37: this.prev(); break
10682      case 39: this.next(); break
10683      default: return
10684    }
10685
10686    e.preventDefault()
10687  }
10688
10689  Carousel.prototype.cycle = function (e) {
10690    e || (this.paused = false)
10691
10692    this.interval && clearInterval(this.interval)
10693
10694    this.options.interval
10695      && !this.paused
10696      && (this.interval = setInterval($.proxy(this.next, this), this.options.interval))
10697
10698    return this
10699  }
10700
10701  Carousel.prototype.getItemIndex = function (item) {
10702    this.$items = item.parent().children('.item')
10703    return this.$items.index(item || this.$active)
10704  }
10705
10706  Carousel.prototype.getItemForDirection = function (direction, active) {
10707    var activeIndex = this.getItemIndex(active)
10708    var willWrap = (direction == 'prev' && activeIndex === 0)
10709                || (direction == 'next' && activeIndex == (this.$items.length - 1))
10710    if (willWrap && !this.options.wrap) return active
10711    var delta = direction == 'prev' ? -1 : 1
10712    var itemIndex = (activeIndex + delta) % this.$items.length
10713    return this.$items.eq(itemIndex)
10714  }
10715
10716  Carousel.prototype.to = function (pos) {
10717    var that        = this
10718    var activeIndex = this.getItemIndex(this.$active = this.$element.find('.item.active'))
10719
10720    if (pos > (this.$items.length - 1) || pos < 0) return
10721
10722    if (this.sliding)       return this.$element.one('slid.bs.carousel', function () { that.to(pos) }) // yes, "slid"
10723    if (activeIndex == pos) return this.pause().cycle()
10724
10725    return this.slide(pos > activeIndex ? 'next' : 'prev', this.$items.eq(pos))
10726  }
10727
10728  Carousel.prototype.pause = function (e) {
10729    e || (this.paused = true)
10730
10731    if (this.$element.find('.next, .prev').length && $.support.transition) {
10732      this.$element.trigger($.support.transition.end)
10733      this.cycle(true)
10734    }
10735
10736    this.interval = clearInterval(this.interval)
10737
10738    return this
10739  }
10740
10741  Carousel.prototype.next = function () {
10742    if (this.sliding) return
10743    return this.slide('next')
10744  }
10745
10746  Carousel.prototype.prev = function () {
10747    if (this.sliding) return
10748    return this.slide('prev')
10749  }
10750
10751  Carousel.prototype.slide = function (type, next) {
10752    var $active   = this.$element.find('.item.active')
10753    var $next     = next || this.getItemForDirection(type, $active)
10754    var isCycling = this.interval
10755    var direction = type == 'next' ? 'left' : 'right'
10756    var that      = this
10757
10758    if ($next.hasClass('active')) return (this.sliding = false)
10759
10760    var relatedTarget = $next[0]
10761    var slideEvent = $.Event('slide.bs.carousel', {
10762      relatedTarget: relatedTarget,
10763      direction: direction
10764    })
10765    this.$element.trigger(slideEvent)
10766    if (slideEvent.isDefaultPrevented()) return
10767
10768    this.sliding = true
10769
10770    isCycling && this.pause()
10771
10772    if (this.$indicators.length) {
10773      this.$indicators.find('.active').removeClass('active')
10774      var $nextIndicator = $(this.$indicators.children()[this.getItemIndex($next)])
10775      $nextIndicator && $nextIndicator.addClass('active')
10776    }
10777
10778    var slidEvent = $.Event('slid.bs.carousel', { relatedTarget: relatedTarget, direction: direction }) // yes, "slid"
10779    if ($.support.transition && this.$element.hasClass('slide')) {
10780      $next.addClass(type)
10781      $next[0].offsetWidth // force reflow
10782      $active.addClass(direction)
10783      $next.addClass(direction)
10784      $active
10785        .one('bsTransitionEnd', function () {
10786          $next.removeClass([type, direction].join(' ')).addClass('active')
10787          $active.removeClass(['active', direction].join(' '))
10788          that.sliding = false
10789          setTimeout(function () {
10790            that.$element.trigger(slidEvent)
10791          }, 0)
10792        })
10793        .emulateTransitionEnd(Carousel.TRANSITION_DURATION)
10794    } else {
10795      $active.removeClass('active')
10796      $next.addClass('active')
10797      this.sliding = false
10798      this.$element.trigger(slidEvent)
10799    }
10800
10801    isCycling && this.cycle()
10802
10803    return this
10804  }
10805
10806
10807  // CAROUSEL PLUGIN DEFINITION
10808  // ==========================
10809
10810  function Plugin(option) {
10811    return this.each(function () {
10812      var $this   = $(this)
10813      var data    = $this.data('bs.carousel')
10814      var options = $.extend({}, Carousel.DEFAULTS, $this.data(), typeof option == 'object' && option)
10815      var action  = typeof option == 'string' ? option : options.slide
10816
10817      if (!data) $this.data('bs.carousel', (data = new Carousel(this, options)))
10818      if (typeof option == 'number') data.to(option)
10819      else if (action) data[action]()
10820      else if (options.interval) data.pause().cycle()
10821    })
10822  }
10823
10824  var old = $.fn.carousel
10825
10826  $.fn.carousel             = Plugin
10827  $.fn.carousel.Constructor = Carousel
10828
10829
10830  // CAROUSEL NO CONFLICT
10831  // ====================
10832
10833  $.fn.carousel.noConflict = function () {
10834    $.fn.carousel = old
10835    return this
10836  }
10837
10838
10839  // CAROUSEL DATA-API
10840  // =================
10841
10842  var clickHandler = function (e) {
10843    var href
10844    var $this   = $(this)
10845    var $target = $($this.attr('data-target') || (href = $this.attr('href')) && href.replace(/.*(?=#[^\s]+$)/, '')) // strip for ie7
10846    if (!$target.hasClass('carousel')) return
10847    var options = $.extend({}, $target.data(), $this.data())
10848    var slideIndex = $this.attr('data-slide-to')
10849    if (slideIndex) options.interval = false
10850
10851    Plugin.call($target, options)
10852
10853    if (slideIndex) {
10854      $target.data('bs.carousel').to(slideIndex)
10855    }
10856
10857    e.preventDefault()
10858  }
10859
10860  $(document)
10861    .on('click.bs.carousel.data-api', '[data-slide]', clickHandler)
10862    .on('click.bs.carousel.data-api', '[data-slide-to]', clickHandler)
10863
10864  $(window).on('load', function () {
10865    $('[data-ride="carousel"]').each(function () {
10866      var $carousel = $(this)
10867      Plugin.call($carousel, $carousel.data())
10868    })
10869  })
10870
10871}(jQuery);
10872
10873/* ========================================================================
10874 * Bootstrap: collapse.js v3.3.7
10875 * http://getbootstrap.com/javascript/#collapse
10876 * ========================================================================
10877 * Copyright 2011-2016 Twitter, Inc.
10878 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
10879 * ======================================================================== */
10880
10881/* jshint latedef: false */
10882
10883+function ($) {
10884  'use strict';
10885
10886  // COLLAPSE PUBLIC CLASS DEFINITION
10887  // ================================
10888
10889  var Collapse = function (element, options) {
10890    this.$element      = $(element)
10891    this.options       = $.extend({}, Collapse.DEFAULTS, options)
10892    this.$trigger      = $('[data-toggle="collapse"][href="#' + element.id + '"],' +
10893                           '[data-toggle="collapse"][data-target="#' + element.id + '"]')
10894    this.transitioning = null
10895
10896    if (this.options.parent) {
10897      this.$parent = this.getParent()
10898    } else {
10899      this.addAriaAndCollapsedClass(this.$element, this.$trigger)
10900    }
10901
10902    if (this.options.toggle) this.toggle()
10903  }
10904
10905  Collapse.VERSION  = '3.3.7'
10906
10907  Collapse.TRANSITION_DURATION = 350
10908
10909  Collapse.DEFAULTS = {
10910    toggle: true
10911  }
10912
10913  Collapse.prototype.dimension = function () {
10914    var hasWidth = this.$element.hasClass('width')
10915    return hasWidth ? 'width' : 'height'
10916  }
10917
10918  Collapse.prototype.show = function () {
10919    if (this.transitioning || this.$element.hasClass('in')) return
10920
10921    var activesData
10922    var actives = this.$parent && this.$parent.children('.panel').children('.in, .collapsing')
10923
10924    if (actives && actives.length) {
10925      activesData = actives.data('bs.collapse')
10926      if (activesData && activesData.transitioning) return
10927    }
10928
10929    var startEvent = $.Event('show.bs.collapse')
10930    this.$element.trigger(startEvent)
10931    if (startEvent.isDefaultPrevented()) return
10932
10933    if (actives && actives.length) {
10934      Plugin.call(actives, 'hide')
10935      activesData || actives.data('bs.collapse', null)
10936    }
10937
10938    var dimension = this.dimension()
10939
10940    this.$element
10941      .removeClass('collapse')
10942      .addClass('collapsing')[dimension](0)
10943      .attr('aria-expanded', true)
10944
10945    this.$trigger
10946      .removeClass('collapsed')
10947      .attr('aria-expanded', true)
10948
10949    this.transitioning = 1
10950
10951    var complete = function () {
10952      this.$element
10953        .removeClass('collapsing')
10954        .addClass('collapse in')[dimension]('')
10955      this.transitioning = 0
10956      this.$element
10957        .trigger('shown.bs.collapse')
10958    }
10959
10960    if (!$.support.transition) return complete.call(this)
10961
10962    var scrollSize = $.camelCase(['scroll', dimension].join('-'))
10963
10964    this.$element
10965      .one('bsTransitionEnd', $.proxy(complete, this))
10966      .emulateTransitionEnd(Collapse.TRANSITION_DURATION)[dimension](this.$element[0][scrollSize])
10967  }
10968
10969  Collapse.prototype.hide = function () {
10970    if (this.transitioning || !this.$element.hasClass('in')) return
10971
10972    var startEvent = $.Event('hide.bs.collapse')
10973    this.$element.trigger(startEvent)
10974    if (startEvent.isDefaultPrevented()) return
10975
10976    var dimension = this.dimension()
10977
10978    this.$element[dimension](this.$element[dimension]())[0].offsetHeight
10979
10980    this.$element
10981      .addClass('collapsing')
10982      .removeClass('collapse in')
10983      .attr('aria-expanded', false)
10984
10985    this.$trigger
10986      .addClass('collapsed')
10987      .attr('aria-expanded', false)
10988
10989    this.transitioning = 1
10990
10991    var complete = function () {
10992      this.transitioning = 0
10993      this.$element
10994        .removeClass('collapsing')
10995        .addClass('collapse')
10996        .trigger('hidden.bs.collapse')
10997    }
10998
10999    if (!$.support.transition) return complete.call(this)
11000
11001    this.$element
11002      [dimension](0)
11003      .one('bsTransitionEnd', $.proxy(complete, this))
11004      .emulateTransitionEnd(Collapse.TRANSITION_DURATION)
11005  }
11006
11007  Collapse.prototype.toggle = function () {
11008    this[this.$element.hasClass('in') ? 'hide' : 'show']()
11009  }
11010
11011  Collapse.prototype.getParent = function () {
11012    return $(this.options.parent)
11013      .find('[data-toggle="collapse"][data-parent="' + this.options.parent + '"]')
11014      .each($.proxy(function (i, element) {
11015        var $element = $(element)
11016        this.addAriaAndCollapsedClass(getTargetFromTrigger($element), $element)
11017      }, this))
11018      .end()
11019  }
11020
11021  Collapse.prototype.addAriaAndCollapsedClass = function ($element, $trigger) {
11022    var isOpen = $element.hasClass('in')
11023
11024    $element.attr('aria-expanded', isOpen)
11025    $trigger
11026      .toggleClass('collapsed', !isOpen)
11027      .attr('aria-expanded', isOpen)
11028  }
11029
11030  function getTargetFromTrigger($trigger) {
11031    var href
11032    var target = $trigger.attr('data-target')
11033      || (href = $trigger.attr('href')) && href.replace(/.*(?=#[^\s]+$)/, '') // strip for ie7
11034
11035    return $(target)
11036  }
11037
11038
11039  // COLLAPSE PLUGIN DEFINITION
11040  // ==========================
11041
11042  function Plugin(option) {
11043    return this.each(function () {
11044      var $this   = $(this)
11045      var data    = $this.data('bs.collapse')
11046      var options = $.extend({}, Collapse.DEFAULTS, $this.data(), typeof option == 'object' && option)
11047
11048      if (!data && options.toggle && /show|hide/.test(option)) options.toggle = false
11049      if (!data) $this.data('bs.collapse', (data = new Collapse(this, options)))
11050      if (typeof option == 'string') data[option]()
11051    })
11052  }
11053
11054  var old = $.fn.collapse
11055
11056  $.fn.collapse             = Plugin
11057  $.fn.collapse.Constructor = Collapse
11058
11059
11060  // COLLAPSE NO CONFLICT
11061  // ====================
11062
11063  $.fn.collapse.noConflict = function () {
11064    $.fn.collapse = old
11065    return this
11066  }
11067
11068
11069  // COLLAPSE DATA-API
11070  // =================
11071
11072  $(document).on('click.bs.collapse.data-api', '[data-toggle="collapse"]', function (e) {
11073    var $this   = $(this)
11074
11075    if (!$this.attr('data-target')) e.preventDefault()
11076
11077    var $target = getTargetFromTrigger($this)
11078    var data    = $target.data('bs.collapse')
11079    var option  = data ? 'toggle' : $this.data()
11080
11081    Plugin.call($target, option)
11082  })
11083
11084}(jQuery);
11085
11086/* ========================================================================
11087 * Bootstrap: dropdown.js v3.3.7
11088 * http://getbootstrap.com/javascript/#dropdowns
11089 * ========================================================================
11090 * Copyright 2011-2016 Twitter, Inc.
11091 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
11092 * ======================================================================== */
11093
11094
11095+function ($) {
11096  'use strict';
11097
11098  // DROPDOWN CLASS DEFINITION
11099  // =========================
11100
11101  var backdrop = '.dropdown-backdrop'
11102  var toggle   = '[data-toggle="dropdown"]'
11103  var Dropdown = function (element) {
11104    $(element).on('click.bs.dropdown', this.toggle)
11105  }
11106
11107  Dropdown.VERSION = '3.3.7'
11108
11109  function getParent($this) {
11110    var selector = $this.attr('data-target')
11111
11112    if (!selector) {
11113      selector = $this.attr('href')
11114      selector = selector && /#[A-Za-z]/.test(selector) && selector.replace(/.*(?=#[^\s]*$)/, '') // strip for ie7
11115    }
11116
11117    var $parent = selector && $(selector)
11118
11119    return $parent && $parent.length ? $parent : $this.parent()
11120  }
11121
11122  function clearMenus(e) {
11123    if (e && e.which === 3) return
11124    $(backdrop).remove()
11125    $(toggle).each(function () {
11126      var $this         = $(this)
11127      var $parent       = getParent($this)
11128      var relatedTarget = { relatedTarget: this }
11129
11130      if (!$parent.hasClass('open')) return
11131
11132      if (e && e.type == 'click' && /input|textarea/i.test(e.target.tagName) && $.contains($parent[0], e.target)) return
11133
11134      $parent.trigger(e = $.Event('hide.bs.dropdown', relatedTarget))
11135
11136      if (e.isDefaultPrevented()) return
11137
11138      $this.attr('aria-expanded', 'false')
11139      $parent.removeClass('open').trigger($.Event('hidden.bs.dropdown', relatedTarget))
11140    })
11141  }
11142
11143  Dropdown.prototype.toggle = function (e) {
11144    var $this = $(this)
11145
11146    if ($this.is('.disabled, :disabled')) return
11147
11148    var $parent  = getParent($this)
11149    var isActive = $parent.hasClass('open')
11150
11151    clearMenus()
11152
11153    if (!isActive) {
11154      if ('ontouchstart' in document.documentElement && !$parent.closest('.navbar-nav').length) {
11155        // if mobile we use a backdrop because click events don't delegate
11156        $(document.createElement('div'))
11157          .addClass('dropdown-backdrop')
11158          .insertAfter($(this))
11159          .on('click', clearMenus)
11160      }
11161
11162      var relatedTarget = { relatedTarget: this }
11163      $parent.trigger(e = $.Event('show.bs.dropdown', relatedTarget))
11164
11165      if (e.isDefaultPrevented()) return
11166
11167      $this
11168        .trigger('focus')
11169        .attr('aria-expanded', 'true')
11170
11171      $parent
11172        .toggleClass('open')
11173        .trigger($.Event('shown.bs.dropdown', relatedTarget))
11174    }
11175
11176    return false
11177  }
11178
11179  Dropdown.prototype.keydown = function (e) {
11180    if (!/(38|40|27|32)/.test(e.which) || /input|textarea/i.test(e.target.tagName)) return
11181
11182    var $this = $(this)
11183
11184    e.preventDefault()
11185    e.stopPropagation()
11186
11187    if ($this.is('.disabled, :disabled')) return
11188
11189    var $parent  = getParent($this)
11190    var isActive = $parent.hasClass('open')
11191
11192    if (!isActive && e.which != 27 || isActive && e.which == 27) {
11193      if (e.which == 27) $parent.find(toggle).trigger('focus')
11194      return $this.trigger('click')
11195    }
11196
11197    var desc = ' li:not(.disabled):visible a'
11198    var $items = $parent.find('.dropdown-menu' + desc)
11199
11200    if (!$items.length) return
11201
11202    var index = $items.index(e.target)
11203
11204    if (e.which == 38 && index > 0)                 index--         // up
11205    if (e.which == 40 && index < $items.length - 1) index++         // down
11206    if (!~index)                                    index = 0
11207
11208    $items.eq(index).trigger('focus')
11209  }
11210
11211
11212  // DROPDOWN PLUGIN DEFINITION
11213  // ==========================
11214
11215  function Plugin(option) {
11216    return this.each(function () {
11217      var $this = $(this)
11218      var data  = $this.data('bs.dropdown')
11219
11220      if (!data) $this.data('bs.dropdown', (data = new Dropdown(this)))
11221      if (typeof option == 'string') data[option].call($this)
11222    })
11223  }
11224
11225  var old = $.fn.dropdown
11226
11227  $.fn.dropdown             = Plugin
11228  $.fn.dropdown.Constructor = Dropdown
11229
11230
11231  // DROPDOWN NO CONFLICT
11232  // ====================
11233
11234  $.fn.dropdown.noConflict = function () {
11235    $.fn.dropdown = old
11236    return this
11237  }
11238
11239
11240  // APPLY TO STANDARD DROPDOWN ELEMENTS
11241  // ===================================
11242
11243  $(document)
11244    .on('click.bs.dropdown.data-api', clearMenus)
11245    .on('click.bs.dropdown.data-api', '.dropdown form', function (e) { e.stopPropagation() })
11246    .on('click.bs.dropdown.data-api', toggle, Dropdown.prototype.toggle)
11247    .on('keydown.bs.dropdown.data-api', toggle, Dropdown.prototype.keydown)
11248    .on('keydown.bs.dropdown.data-api', '.dropdown-menu', Dropdown.prototype.keydown)
11249
11250}(jQuery);
11251
11252/* ========================================================================
11253 * Bootstrap: modal.js v3.3.7
11254 * http://getbootstrap.com/javascript/#modals
11255 * ========================================================================
11256 * Copyright 2011-2016 Twitter, Inc.
11257 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
11258 * ======================================================================== */
11259
11260
11261+function ($) {
11262  'use strict';
11263
11264  // MODAL CLASS DEFINITION
11265  // ======================
11266
11267  var Modal = function (element, options) {
11268    this.options             = options
11269    this.$body               = $(document.body)
11270    this.$element            = $(element)
11271    this.$dialog             = this.$element.find('.modal-dialog')
11272    this.$backdrop           = null
11273    this.isShown             = null
11274    this.originalBodyPad     = null
11275    this.scrollbarWidth      = 0
11276    this.ignoreBackdropClick = false
11277
11278    if (this.options.remote) {
11279      this.$element
11280        .find('.modal-content')
11281        .load(this.options.remote, $.proxy(function () {
11282          this.$element.trigger('loaded.bs.modal')
11283        }, this))
11284    }
11285  }
11286
11287  Modal.VERSION  = '3.3.7'
11288
11289  Modal.TRANSITION_DURATION = 300
11290  Modal.BACKDROP_TRANSITION_DURATION = 150
11291
11292  Modal.DEFAULTS = {
11293    backdrop: true,
11294    keyboard: true,
11295    show: true
11296  }
11297
11298  Modal.prototype.toggle = function (_relatedTarget) {
11299    return this.isShown ? this.hide() : this.show(_relatedTarget)
11300  }
11301
11302  Modal.prototype.show = function (_relatedTarget) {
11303    var that = this
11304    var e    = $.Event('show.bs.modal', { relatedTarget: _relatedTarget })
11305
11306    this.$element.trigger(e)
11307
11308    if (this.isShown || e.isDefaultPrevented()) return
11309
11310    this.isShown = true
11311
11312    this.checkScrollbar()
11313    this.setScrollbar()
11314    this.$body.addClass('modal-open')
11315
11316    this.escape()
11317    this.resize()
11318
11319    this.$element.on('click.dismiss.bs.modal', '[data-dismiss="modal"]', $.proxy(this.hide, this))
11320
11321    this.$dialog.on('mousedown.dismiss.bs.modal', function () {
11322      that.$element.one('mouseup.dismiss.bs.modal', function (e) {
11323        if ($(e.target).is(that.$element)) that.ignoreBackdropClick = true
11324      })
11325    })
11326
11327    this.backdrop(function () {
11328      var transition = $.support.transition && that.$element.hasClass('fade')
11329
11330      if (!that.$element.parent().length) {
11331        that.$element.appendTo(that.$body) // don't move modals dom position
11332      }
11333
11334      that.$element
11335        .show()
11336        .scrollTop(0)
11337
11338      that.adjustDialog()
11339
11340      if (transition) {
11341        that.$element[0].offsetWidth // force reflow
11342      }
11343
11344      that.$element.addClass('in')
11345
11346      that.enforceFocus()
11347
11348      var e = $.Event('shown.bs.modal', { relatedTarget: _relatedTarget })
11349
11350      transition ?
11351        that.$dialog // wait for modal to slide in
11352          .one('bsTransitionEnd', function () {
11353            that.$element.trigger('focus').trigger(e)
11354          })
11355          .emulateTransitionEnd(Modal.TRANSITION_DURATION) :
11356        that.$element.trigger('focus').trigger(e)
11357    })
11358  }
11359
11360  Modal.prototype.hide = function (e) {
11361    if (e) e.preventDefault()
11362
11363    e = $.Event('hide.bs.modal')
11364
11365    this.$element.trigger(e)
11366
11367    if (!this.isShown || e.isDefaultPrevented()) return
11368
11369    this.isShown = false
11370
11371    this.escape()
11372    this.resize()
11373
11374    $(document).off('focusin.bs.modal')
11375
11376    this.$element
11377      .removeClass('in')
11378      .off('click.dismiss.bs.modal')
11379      .off('mouseup.dismiss.bs.modal')
11380
11381    this.$dialog.off('mousedown.dismiss.bs.modal')
11382
11383    $.support.transition && this.$element.hasClass('fade') ?
11384      this.$element
11385        .one('bsTransitionEnd', $.proxy(this.hideModal, this))
11386        .emulateTransitionEnd(Modal.TRANSITION_DURATION) :
11387      this.hideModal()
11388  }
11389
11390  Modal.prototype.enforceFocus = function () {
11391    $(document)
11392      .off('focusin.bs.modal') // guard against infinite focus loop
11393      .on('focusin.bs.modal', $.proxy(function (e) {
11394        if (document !== e.target &&
11395            this.$element[0] !== e.target &&
11396            !this.$element.has(e.target).length) {
11397          this.$element.trigger('focus')
11398        }
11399      }, this))
11400  }
11401
11402  Modal.prototype.escape = function () {
11403    if (this.isShown && this.options.keyboard) {
11404      this.$element.on('keydown.dismiss.bs.modal', $.proxy(function (e) {
11405        e.which == 27 && this.hide()
11406      }, this))
11407    } else if (!this.isShown) {
11408      this.$element.off('keydown.dismiss.bs.modal')
11409    }
11410  }
11411
11412  Modal.prototype.resize = function () {
11413    if (this.isShown) {
11414      $(window).on('resize.bs.modal', $.proxy(this.handleUpdate, this))
11415    } else {
11416      $(window).off('resize.bs.modal')
11417    }
11418  }
11419
11420  Modal.prototype.hideModal = function () {
11421    var that = this
11422    this.$element.hide()
11423    this.backdrop(function () {
11424      that.$body.removeClass('modal-open')
11425      that.resetAdjustments()
11426      that.resetScrollbar()
11427      that.$element.trigger('hidden.bs.modal')
11428    })
11429  }
11430
11431  Modal.prototype.removeBackdrop = function () {
11432    this.$backdrop && this.$backdrop.remove()
11433    this.$backdrop = null
11434  }
11435
11436  Modal.prototype.backdrop = function (callback) {
11437    var that = this
11438    var animate = this.$element.hasClass('fade') ? 'fade' : ''
11439
11440    if (this.isShown && this.options.backdrop) {
11441      var doAnimate = $.support.transition && animate
11442
11443      this.$backdrop = $(document.createElement('div'))
11444        .addClass('modal-backdrop ' + animate)
11445        .appendTo(this.$body)
11446
11447      this.$element.on('click.dismiss.bs.modal', $.proxy(function (e) {
11448        if (this.ignoreBackdropClick) {
11449          this.ignoreBackdropClick = false
11450          return
11451        }
11452        if (e.target !== e.currentTarget) return
11453        this.options.backdrop == 'static'
11454          ? this.$element[0].focus()
11455          : this.hide()
11456      }, this))
11457
11458      if (doAnimate) this.$backdrop[0].offsetWidth // force reflow
11459
11460      this.$backdrop.addClass('in')
11461
11462      if (!callback) return
11463
11464      doAnimate ?
11465        this.$backdrop
11466          .one('bsTransitionEnd', callback)
11467          .emulateTransitionEnd(Modal.BACKDROP_TRANSITION_DURATION) :
11468        callback()
11469
11470    } else if (!this.isShown && this.$backdrop) {
11471      this.$backdrop.removeClass('in')
11472
11473      var callbackRemove = function () {
11474        that.removeBackdrop()
11475        callback && callback()
11476      }
11477      $.support.transition && this.$element.hasClass('fade') ?
11478        this.$backdrop
11479          .one('bsTransitionEnd', callbackRemove)
11480          .emulateTransitionEnd(Modal.BACKDROP_TRANSITION_DURATION) :
11481        callbackRemove()
11482
11483    } else if (callback) {
11484      callback()
11485    }
11486  }
11487
11488  // these following methods are used to handle overflowing modals
11489
11490  Modal.prototype.handleUpdate = function () {
11491    this.adjustDialog()
11492  }
11493
11494  Modal.prototype.adjustDialog = function () {
11495    var modalIsOverflowing = this.$element[0].scrollHeight > document.documentElement.clientHeight
11496
11497    this.$element.css({
11498      paddingLeft:  !this.bodyIsOverflowing && modalIsOverflowing ? this.scrollbarWidth : '',
11499      paddingRight: this.bodyIsOverflowing && !modalIsOverflowing ? this.scrollbarWidth : ''
11500    })
11501  }
11502
11503  Modal.prototype.resetAdjustments = function () {
11504    this.$element.css({
11505      paddingLeft: '',
11506      paddingRight: ''
11507    })
11508  }
11509
11510  Modal.prototype.checkScrollbar = function () {
11511    var fullWindowWidth = window.innerWidth
11512    if (!fullWindowWidth) { // workaround for missing window.innerWidth in IE8
11513      var documentElementRect = document.documentElement.getBoundingClientRect()
11514      fullWindowWidth = documentElementRect.right - Math.abs(documentElementRect.left)
11515    }
11516    this.bodyIsOverflowing = document.body.clientWidth < fullWindowWidth
11517    this.scrollbarWidth = this.measureScrollbar()
11518  }
11519
11520  Modal.prototype.setScrollbar = function () {
11521    var bodyPad = parseInt((this.$body.css('padding-right') || 0), 10)
11522    this.originalBodyPad = document.body.style.paddingRight || ''
11523    if (this.bodyIsOverflowing) this.$body.css('padding-right', bodyPad + this.scrollbarWidth)
11524  }
11525
11526  Modal.prototype.resetScrollbar = function () {
11527    this.$body.css('padding-right', this.originalBodyPad)
11528  }
11529
11530  Modal.prototype.measureScrollbar = function () { // thx walsh
11531    var scrollDiv = document.createElement('div')
11532    scrollDiv.className = 'modal-scrollbar-measure'
11533    this.$body.append(scrollDiv)
11534    var scrollbarWidth = scrollDiv.offsetWidth - scrollDiv.clientWidth
11535    this.$body[0].removeChild(scrollDiv)
11536    return scrollbarWidth
11537  }
11538
11539
11540  // MODAL PLUGIN DEFINITION
11541  // =======================
11542
11543  function Plugin(option, _relatedTarget) {
11544    return this.each(function () {
11545      var $this   = $(this)
11546      var data    = $this.data('bs.modal')
11547      var options = $.extend({}, Modal.DEFAULTS, $this.data(), typeof option == 'object' && option)
11548
11549      if (!data) $this.data('bs.modal', (data = new Modal(this, options)))
11550      if (typeof option == 'string') data[option](_relatedTarget)
11551      else if (options.show) data.show(_relatedTarget)
11552    })
11553  }
11554
11555  var old = $.fn.modal
11556
11557  $.fn.modal             = Plugin
11558  $.fn.modal.Constructor = Modal
11559
11560
11561  // MODAL NO CONFLICT
11562  // =================
11563
11564  $.fn.modal.noConflict = function () {
11565    $.fn.modal = old
11566    return this
11567  }
11568
11569
11570  // MODAL DATA-API
11571  // ==============
11572
11573  $(document).on('click.bs.modal.data-api', '[data-toggle="modal"]', function (e) {
11574    var $this   = $(this)
11575    var href    = $this.attr('href')
11576    var $target = $($this.attr('data-target') || (href && href.replace(/.*(?=#[^\s]+$)/, ''))) // strip for ie7
11577    var option  = $target.data('bs.modal') ? 'toggle' : $.extend({ remote: !/#/.test(href) && href }, $target.data(), $this.data())
11578
11579    if ($this.is('a')) e.preventDefault()
11580
11581    $target.one('show.bs.modal', function (showEvent) {
11582      if (showEvent.isDefaultPrevented()) return // only register focus restorer if modal will actually get shown
11583      $target.one('hidden.bs.modal', function () {
11584        $this.is(':visible') && $this.trigger('focus')
11585      })
11586    })
11587    Plugin.call($target, option, this)
11588  })
11589
11590}(jQuery);
11591
11592/* ========================================================================
11593 * Bootstrap: tooltip.js v3.3.7
11594 * http://getbootstrap.com/javascript/#tooltip
11595 * Inspired by the original jQuery.tipsy by Jason Frame
11596 * ========================================================================
11597 * Copyright 2011-2016 Twitter, Inc.
11598 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
11599 * ======================================================================== */
11600
11601
11602+function ($) {
11603  'use strict';
11604
11605  // TOOLTIP PUBLIC CLASS DEFINITION
11606  // ===============================
11607
11608  var Tooltip = function (element, options) {
11609    this.type       = null
11610    this.options    = null
11611    this.enabled    = null
11612    this.timeout    = null
11613    this.hoverState = null
11614    this.$element   = null
11615    this.inState    = null
11616
11617    this.init('tooltip', element, options)
11618  }
11619
11620  Tooltip.VERSION  = '3.3.7'
11621
11622  Tooltip.TRANSITION_DURATION = 150
11623
11624  Tooltip.DEFAULTS = {
11625    animation: true,
11626    placement: 'top',
11627    selector: false,
11628    template: '<div class="tooltip" role="tooltip"><div class="tooltip-arrow"></div><div class="tooltip-inner"></div></div>',
11629    trigger: 'hover focus',
11630    title: '',
11631    delay: 0,
11632    html: false,
11633    container: false,
11634    viewport: {
11635      selector: 'body',
11636      padding: 0
11637    }
11638  }
11639
11640  Tooltip.prototype.init = function (type, element, options) {
11641    this.enabled   = true
11642    this.type      = type
11643    this.$element  = $(element)
11644    this.options   = this.getOptions(options)
11645    this.$viewport = this.options.viewport && $($.isFunction(this.options.viewport) ? this.options.viewport.call(this, this.$element) : (this.options.viewport.selector || this.options.viewport))
11646    this.inState   = { click: false, hover: false, focus: false }
11647
11648    if (this.$element[0] instanceof document.constructor && !this.options.selector) {
11649      throw new Error('`selector` option must be specified when initializing ' + this.type + ' on the window.document object!')
11650    }
11651
11652    var triggers = this.options.trigger.split(' ')
11653
11654    for (var i = triggers.length; i--;) {
11655      var trigger = triggers[i]
11656
11657      if (trigger == 'click') {
11658        this.$element.on('click.' + this.type, this.options.selector, $.proxy(this.toggle, this))
11659      } else if (trigger != 'manual') {
11660        var eventIn  = trigger == 'hover' ? 'mouseenter' : 'focusin'
11661        var eventOut = trigger == 'hover' ? 'mouseleave' : 'focusout'
11662
11663        this.$element.on(eventIn  + '.' + this.type, this.options.selector, $.proxy(this.enter, this))
11664        this.$element.on(eventOut + '.' + this.type, this.options.selector, $.proxy(this.leave, this))
11665      }
11666    }
11667
11668    this.options.selector ?
11669      (this._options = $.extend({}, this.options, { trigger: 'manual', selector: '' })) :
11670      this.fixTitle()
11671  }
11672
11673  Tooltip.prototype.getDefaults = function () {
11674    return Tooltip.DEFAULTS
11675  }
11676
11677  Tooltip.prototype.getOptions = function (options) {
11678    options = $.extend({}, this.getDefaults(), this.$element.data(), options)
11679
11680    if (options.delay && typeof options.delay == 'number') {
11681      options.delay = {
11682        show: options.delay,
11683        hide: options.delay
11684      }
11685    }
11686
11687    return options
11688  }
11689
11690  Tooltip.prototype.getDelegateOptions = function () {
11691    var options  = {}
11692    var defaults = this.getDefaults()
11693
11694    this._options && $.each(this._options, function (key, value) {
11695      if (defaults[key] != value) options[key] = value
11696    })
11697
11698    return options
11699  }
11700
11701  Tooltip.prototype.enter = function (obj) {
11702    var self = obj instanceof this.constructor ?
11703      obj : $(obj.currentTarget).data('bs.' + this.type)
11704
11705    if (!self) {
11706      self = new this.constructor(obj.currentTarget, this.getDelegateOptions())
11707      $(obj.currentTarget).data('bs.' + this.type, self)
11708    }
11709
11710    if (obj instanceof $.Event) {
11711      self.inState[obj.type == 'focusin' ? 'focus' : 'hover'] = true
11712    }
11713
11714    if (self.tip().hasClass('in') || self.hoverState == 'in') {
11715      self.hoverState = 'in'
11716      return
11717    }
11718
11719    clearTimeout(self.timeout)
11720
11721    self.hoverState = 'in'
11722
11723    if (!self.options.delay || !self.options.delay.show) return self.show()
11724
11725    self.timeout = setTimeout(function () {
11726      if (self.hoverState == 'in') self.show()
11727    }, self.options.delay.show)
11728  }
11729
11730  Tooltip.prototype.isInStateTrue = function () {
11731    for (var key in this.inState) {
11732      if (this.inState[key]) return true
11733    }
11734
11735    return false
11736  }
11737
11738  Tooltip.prototype.leave = function (obj) {
11739    var self = obj instanceof this.constructor ?
11740      obj : $(obj.currentTarget).data('bs.' + this.type)
11741
11742    if (!self) {
11743      self = new this.constructor(obj.currentTarget, this.getDelegateOptions())
11744      $(obj.currentTarget).data('bs.' + this.type, self)
11745    }
11746
11747    if (obj instanceof $.Event) {
11748      self.inState[obj.type == 'focusout' ? 'focus' : 'hover'] = false
11749    }
11750
11751    if (self.isInStateTrue()) return
11752
11753    clearTimeout(self.timeout)
11754
11755    self.hoverState = 'out'
11756
11757    if (!self.options.delay || !self.options.delay.hide) return self.hide()
11758
11759    self.timeout = setTimeout(function () {
11760      if (self.hoverState == 'out') self.hide()
11761    }, self.options.delay.hide)
11762  }
11763
11764  Tooltip.prototype.show = function () {
11765    var e = $.Event('show.bs.' + this.type)
11766
11767    if (this.hasContent() && this.enabled) {
11768      this.$element.trigger(e)
11769
11770      var inDom = $.contains(this.$element[0].ownerDocument.documentElement, this.$element[0])
11771      if (e.isDefaultPrevented() || !inDom) return
11772      var that = this
11773
11774      var $tip = this.tip()
11775
11776      var tipId = this.getUID(this.type)
11777
11778      this.setContent()
11779      $tip.attr('id', tipId)
11780      this.$element.attr('aria-describedby', tipId)
11781
11782      if (this.options.animation) $tip.addClass('fade')
11783
11784      var placement = typeof this.options.placement == 'function' ?
11785        this.options.placement.call(this, $tip[0], this.$element[0]) :
11786        this.options.placement
11787
11788      var autoToken = /\s?auto?\s?/i
11789      var autoPlace = autoToken.test(placement)
11790      if (autoPlace) placement = placement.replace(autoToken, '') || 'top'
11791
11792      $tip
11793        .detach()
11794        .css({ top: 0, left: 0, display: 'block' })
11795        .addClass(placement)
11796        .data('bs.' + this.type, this)
11797
11798      this.options.container ? $tip.appendTo(this.options.container) : $tip.insertAfter(this.$element)
11799      this.$element.trigger('inserted.bs.' + this.type)
11800
11801      var pos          = this.getPosition()
11802      var actualWidth  = $tip[0].offsetWidth
11803      var actualHeight = $tip[0].offsetHeight
11804
11805      if (autoPlace) {
11806        var orgPlacement = placement
11807        var viewportDim = this.getPosition(this.$viewport)
11808
11809        placement = placement == 'bottom' && pos.bottom + actualHeight > viewportDim.bottom ? 'top'    :
11810                    placement == 'top'    && pos.top    - actualHeight < viewportDim.top    ? 'bottom' :
11811                    placement == 'right'  && pos.right  + actualWidth  > viewportDim.width  ? 'left'   :
11812                    placement == 'left'   && pos.left   - actualWidth  < viewportDim.left   ? 'right'  :
11813                    placement
11814
11815        $tip
11816          .removeClass(orgPlacement)
11817          .addClass(placement)
11818      }
11819
11820      var calculatedOffset = this.getCalculatedOffset(placement, pos, actualWidth, actualHeight)
11821
11822      this.applyPlacement(calculatedOffset, placement)
11823
11824      var complete = function () {
11825        var prevHoverState = that.hoverState
11826        that.$element.trigger('shown.bs.' + that.type)
11827        that.hoverState = null
11828
11829        if (prevHoverState == 'out') that.leave(that)
11830      }
11831
11832      $.support.transition && this.$tip.hasClass('fade') ?
11833        $tip
11834          .one('bsTransitionEnd', complete)
11835          .emulateTransitionEnd(Tooltip.TRANSITION_DURATION) :
11836        complete()
11837    }
11838  }
11839
11840  Tooltip.prototype.applyPlacement = function (offset, placement) {
11841    var $tip   = this.tip()
11842    var width  = $tip[0].offsetWidth
11843    var height = $tip[0].offsetHeight
11844
11845    // manually read margins because getBoundingClientRect includes difference
11846    var marginTop = parseInt($tip.css('margin-top'), 10)
11847    var marginLeft = parseInt($tip.css('margin-left'), 10)
11848
11849    // we must check for NaN for ie 8/9
11850    if (isNaN(marginTop))  marginTop  = 0
11851    if (isNaN(marginLeft)) marginLeft = 0
11852
11853    offset.top  += marginTop
11854    offset.left += marginLeft
11855
11856    // $.fn.offset doesn't round pixel values
11857    // so we use setOffset directly with our own function B-0
11858    $.offset.setOffset($tip[0], $.extend({
11859      using: function (props) {
11860        $tip.css({
11861          top: Math.round(props.top),
11862          left: Math.round(props.left)
11863        })
11864      }
11865    }, offset), 0)
11866
11867    $tip.addClass('in')
11868
11869    // check to see if placing tip in new offset caused the tip to resize itself
11870    var actualWidth  = $tip[0].offsetWidth
11871    var actualHeight = $tip[0].offsetHeight
11872
11873    if (placement == 'top' && actualHeight != height) {
11874      offset.top = offset.top + height - actualHeight
11875    }
11876
11877    var delta = this.getViewportAdjustedDelta(placement, offset, actualWidth, actualHeight)
11878
11879    if (delta.left) offset.left += delta.left
11880    else offset.top += delta.top
11881
11882    var isVertical          = /top|bottom/.test(placement)
11883    var arrowDelta          = isVertical ? delta.left * 2 - width + actualWidth : delta.top * 2 - height + actualHeight
11884    var arrowOffsetPosition = isVertical ? 'offsetWidth' : 'offsetHeight'
11885
11886    $tip.offset(offset)
11887    this.replaceArrow(arrowDelta, $tip[0][arrowOffsetPosition], isVertical)
11888  }
11889
11890  Tooltip.prototype.replaceArrow = function (delta, dimension, isVertical) {
11891    this.arrow()
11892      .css(isVertical ? 'left' : 'top', 50 * (1 - delta / dimension) + '%')
11893      .css(isVertical ? 'top' : 'left', '')
11894  }
11895
11896  Tooltip.prototype.setContent = function () {
11897    var $tip  = this.tip()
11898    var title = this.getTitle()
11899
11900    $tip.find('.tooltip-inner')[this.options.html ? 'html' : 'text'](title)
11901    $tip.removeClass('fade in top bottom left right')
11902  }
11903
11904  Tooltip.prototype.hide = function (callback) {
11905    var that = this
11906    var $tip = $(this.$tip)
11907    var e    = $.Event('hide.bs.' + this.type)
11908
11909    function complete() {
11910      if (that.hoverState != 'in') $tip.detach()
11911      if (that.$element) { // TODO: Check whether guarding this code with this `if` is really necessary.
11912        that.$element
11913          .removeAttr('aria-describedby')
11914          .trigger('hidden.bs.' + that.type)
11915      }
11916      callback && callback()
11917    }
11918
11919    this.$element.trigger(e)
11920
11921    if (e.isDefaultPrevented()) return
11922
11923    $tip.removeClass('in')
11924
11925    $.support.transition && $tip.hasClass('fade') ?
11926      $tip
11927        .one('bsTransitionEnd', complete)
11928        .emulateTransitionEnd(Tooltip.TRANSITION_DURATION) :
11929      complete()
11930
11931    this.hoverState = null
11932
11933    return this
11934  }
11935
11936  Tooltip.prototype.fixTitle = function () {
11937    var $e = this.$element
11938    if ($e.attr('title') || typeof $e.attr('data-original-title') != 'string') {
11939      $e.attr('data-original-title', $e.attr('title') || '').attr('title', '')
11940    }
11941  }
11942
11943  Tooltip.prototype.hasContent = function () {
11944    return this.getTitle()
11945  }
11946
11947  Tooltip.prototype.getPosition = function ($element) {
11948    $element   = $element || this.$element
11949
11950    var el     = $element[0]
11951    var isBody = el.tagName == 'BODY'
11952
11953    var elRect    = el.getBoundingClientRect()
11954    if (elRect.width == null) {
11955      // width and height are missing in IE8, so compute them manually; see https://github.com/twbs/bootstrap/issues/14093
11956      elRect = $.extend({}, elRect, { width: elRect.right - elRect.left, height: elRect.bottom - elRect.top })
11957    }
11958    var isSvg = window.SVGElement && el instanceof window.SVGElement
11959    // Avoid using $.offset() on SVGs since it gives incorrect results in jQuery 3.
11960    // See https://github.com/twbs/bootstrap/issues/20280
11961    var elOffset  = isBody ? { top: 0, left: 0 } : (isSvg ? null : $element.offset())
11962    var scroll    = { scroll: isBody ? document.documentElement.scrollTop || document.body.scrollTop : $element.scrollTop() }
11963    var outerDims = isBody ? { width: $(window).width(), height: $(window).height() } : null
11964
11965    return $.extend({}, elRect, scroll, outerDims, elOffset)
11966  }
11967
11968  Tooltip.prototype.getCalculatedOffset = function (placement, pos, actualWidth, actualHeight) {
11969    return placement == 'bottom' ? { top: pos.top + pos.height,   left: pos.left + pos.width / 2 - actualWidth / 2 } :
11970           placement == 'top'    ? { top: pos.top - actualHeight, left: pos.left + pos.width / 2 - actualWidth / 2 } :
11971           placement == 'left'   ? { top: pos.top + pos.height / 2 - actualHeight / 2, left: pos.left - actualWidth } :
11972        /* placement == 'right' */ { top: pos.top + pos.height / 2 - actualHeight / 2, left: pos.left + pos.width }
11973
11974  }
11975
11976  Tooltip.prototype.getViewportAdjustedDelta = function (placement, pos, actualWidth, actualHeight) {
11977    var delta = { top: 0, left: 0 }
11978    if (!this.$viewport) return delta
11979
11980    var viewportPadding = this.options.viewport && this.options.viewport.padding || 0
11981    var viewportDimensions = this.getPosition(this.$viewport)
11982
11983    if (/right|left/.test(placement)) {
11984      var topEdgeOffset    = pos.top - viewportPadding - viewportDimensions.scroll
11985      var bottomEdgeOffset = pos.top + viewportPadding - viewportDimensions.scroll + actualHeight
11986      if (topEdgeOffset < viewportDimensions.top) { // top overflow
11987        delta.top = viewportDimensions.top - topEdgeOffset
11988      } else if (bottomEdgeOffset > viewportDimensions.top + viewportDimensions.height) { // bottom overflow
11989        delta.top = viewportDimensions.top + viewportDimensions.height - bottomEdgeOffset
11990      }
11991    } else {
11992      var leftEdgeOffset  = pos.left - viewportPadding
11993      var rightEdgeOffset = pos.left + viewportPadding + actualWidth
11994      if (leftEdgeOffset < viewportDimensions.left) { // left overflow
11995        delta.left = viewportDimensions.left - leftEdgeOffset
11996      } else if (rightEdgeOffset > viewportDimensions.right) { // right overflow
11997        delta.left = viewportDimensions.left + viewportDimensions.width - rightEdgeOffset
11998      }
11999    }
12000
12001    return delta
12002  }
12003
12004  Tooltip.prototype.getTitle = function () {
12005    var title
12006    var $e = this.$element
12007    var o  = this.options
12008
12009    title = $e.attr('data-original-title')
12010      || (typeof o.title == 'function' ? o.title.call($e[0]) :  o.title)
12011
12012    return title
12013  }
12014
12015  Tooltip.prototype.getUID = function (prefix) {
12016    do prefix += ~~(Math.random() * 1000000)
12017    while (document.getElementById(prefix))
12018    return prefix
12019  }
12020
12021  Tooltip.prototype.tip = function () {
12022    if (!this.$tip) {
12023      this.$tip = $(this.options.template)
12024      if (this.$tip.length != 1) {
12025        throw new Error(this.type + ' `template` option must consist of exactly 1 top-level element!')
12026      }
12027    }
12028    return this.$tip
12029  }
12030
12031  Tooltip.prototype.arrow = function () {
12032    return (this.$arrow = this.$arrow || this.tip().find('.tooltip-arrow'))
12033  }
12034
12035  Tooltip.prototype.enable = function () {
12036    this.enabled = true
12037  }
12038
12039  Tooltip.prototype.disable = function () {
12040    this.enabled = false
12041  }
12042
12043  Tooltip.prototype.toggleEnabled = function () {
12044    this.enabled = !this.enabled
12045  }
12046
12047  Tooltip.prototype.toggle = function (e) {
12048    var self = this
12049    if (e) {
12050      self = $(e.currentTarget).data('bs.' + this.type)
12051      if (!self) {
12052        self = new this.constructor(e.currentTarget, this.getDelegateOptions())
12053        $(e.currentTarget).data('bs.' + this.type, self)
12054      }
12055    }
12056
12057    if (e) {
12058      self.inState.click = !self.inState.click
12059      if (self.isInStateTrue()) self.enter(self)
12060      else self.leave(self)
12061    } else {
12062      self.tip().hasClass('in') ? self.leave(self) : self.enter(self)
12063    }
12064  }
12065
12066  Tooltip.prototype.destroy = function () {
12067    var that = this
12068    clearTimeout(this.timeout)
12069    this.hide(function () {
12070      that.$element.off('.' + that.type).removeData('bs.' + that.type)
12071      if (that.$tip) {
12072        that.$tip.detach()
12073      }
12074      that.$tip = null
12075      that.$arrow = null
12076      that.$viewport = null
12077      that.$element = null
12078    })
12079  }
12080
12081
12082  // TOOLTIP PLUGIN DEFINITION
12083  // =========================
12084
12085  function Plugin(option) {
12086    return this.each(function () {
12087      var $this   = $(this)
12088      var data    = $this.data('bs.tooltip')
12089      var options = typeof option == 'object' && option
12090
12091      if (!data && /destroy|hide/.test(option)) return
12092      if (!data) $this.data('bs.tooltip', (data = new Tooltip(this, options)))
12093      if (typeof option == 'string') data[option]()
12094    })
12095  }
12096
12097  var old = $.fn.tooltip
12098
12099  $.fn.tooltip             = Plugin
12100  $.fn.tooltip.Constructor = Tooltip
12101
12102
12103  // TOOLTIP NO CONFLICT
12104  // ===================
12105
12106  $.fn.tooltip.noConflict = function () {
12107    $.fn.tooltip = old
12108    return this
12109  }
12110
12111}(jQuery);
12112
12113/* ========================================================================
12114 * Bootstrap: popover.js v3.3.7
12115 * http://getbootstrap.com/javascript/#popovers
12116 * ========================================================================
12117 * Copyright 2011-2016 Twitter, Inc.
12118 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
12119 * ======================================================================== */
12120
12121
12122+function ($) {
12123  'use strict';
12124
12125  // POPOVER PUBLIC CLASS DEFINITION
12126  // ===============================
12127
12128  var Popover = function (element, options) {
12129    this.init('popover', element, options)
12130  }
12131
12132  if (!$.fn.tooltip) throw new Error('Popover requires tooltip.js')
12133
12134  Popover.VERSION  = '3.3.7'
12135
12136  Popover.DEFAULTS = $.extend({}, $.fn.tooltip.Constructor.DEFAULTS, {
12137    placement: 'right',
12138    trigger: 'click',
12139    content: '',
12140    template: '<div class="popover" role="tooltip"><div class="arrow"></div><h3 class="popover-title"></h3><div class="popover-content"></div></div>'
12141  })
12142
12143
12144  // NOTE: POPOVER EXTENDS tooltip.js
12145  // ================================
12146
12147  Popover.prototype = $.extend({}, $.fn.tooltip.Constructor.prototype)
12148
12149  Popover.prototype.constructor = Popover
12150
12151  Popover.prototype.getDefaults = function () {
12152    return Popover.DEFAULTS
12153  }
12154
12155  Popover.prototype.setContent = function () {
12156    var $tip    = this.tip()
12157    var title   = this.getTitle()
12158    var content = this.getContent()
12159
12160    $tip.find('.popover-title')[this.options.html ? 'html' : 'text'](title)
12161    $tip.find('.popover-content').children().detach().end()[ // we use append for html objects to maintain js events
12162      this.options.html ? (typeof content == 'string' ? 'html' : 'append') : 'text'
12163    ](content)
12164
12165    $tip.removeClass('fade top bottom left right in')
12166
12167    // IE8 doesn't accept hiding via the `:empty` pseudo selector, we have to do
12168    // this manually by checking the contents.
12169    if (!$tip.find('.popover-title').html()) $tip.find('.popover-title').hide()
12170  }
12171
12172  Popover.prototype.hasContent = function () {
12173    return this.getTitle() || this.getContent()
12174  }
12175
12176  Popover.prototype.getContent = function () {
12177    var $e = this.$element
12178    var o  = this.options
12179
12180    return $e.attr('data-content')
12181      || (typeof o.content == 'function' ?
12182            o.content.call($e[0]) :
12183            o.content)
12184  }
12185
12186  Popover.prototype.arrow = function () {
12187    return (this.$arrow = this.$arrow || this.tip().find('.arrow'))
12188  }
12189
12190
12191  // POPOVER PLUGIN DEFINITION
12192  // =========================
12193
12194  function Plugin(option) {
12195    return this.each(function () {
12196      var $this   = $(this)
12197      var data    = $this.data('bs.popover')
12198      var options = typeof option == 'object' && option
12199
12200      if (!data && /destroy|hide/.test(option)) return
12201      if (!data) $this.data('bs.popover', (data = new Popover(this, options)))
12202      if (typeof option == 'string') data[option]()
12203    })
12204  }
12205
12206  var old = $.fn.popover
12207
12208  $.fn.popover             = Plugin
12209  $.fn.popover.Constructor = Popover
12210
12211
12212  // POPOVER NO CONFLICT
12213  // ===================
12214
12215  $.fn.popover.noConflict = function () {
12216    $.fn.popover = old
12217    return this
12218  }
12219
12220}(jQuery);
12221
12222/* ========================================================================
12223 * Bootstrap: scrollspy.js v3.3.7
12224 * http://getbootstrap.com/javascript/#scrollspy
12225 * ========================================================================
12226 * Copyright 2011-2016 Twitter, Inc.
12227 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
12228 * ======================================================================== */
12229
12230
12231+function ($) {
12232  'use strict';
12233
12234  // SCROLLSPY CLASS DEFINITION
12235  // ==========================
12236
12237  function ScrollSpy(element, options) {
12238    this.$body          = $(document.body)
12239    this.$scrollElement = $(element).is(document.body) ? $(window) : $(element)
12240    this.options        = $.extend({}, ScrollSpy.DEFAULTS, options)
12241    this.selector       = (this.options.target || '') + ' .nav li > a'
12242    this.offsets        = []
12243    this.targets        = []
12244    this.activeTarget   = null
12245    this.scrollHeight   = 0
12246
12247    this.$scrollElement.on('scroll.bs.scrollspy', $.proxy(this.process, this))
12248    this.refresh()
12249    this.process()
12250  }
12251
12252  ScrollSpy.VERSION  = '3.3.7'
12253
12254  ScrollSpy.DEFAULTS = {
12255    offset: 10
12256  }
12257
12258  ScrollSpy.prototype.getScrollHeight = function () {
12259    return this.$scrollElement[0].scrollHeight || Math.max(this.$body[0].scrollHeight, document.documentElement.scrollHeight)
12260  }
12261
12262  ScrollSpy.prototype.refresh = function () {
12263    var that          = this
12264    var offsetMethod  = 'offset'
12265    var offsetBase    = 0
12266
12267    this.offsets      = []
12268    this.targets      = []
12269    this.scrollHeight = this.getScrollHeight()
12270
12271    if (!$.isWindow(this.$scrollElement[0])) {
12272      offsetMethod = 'position'
12273      offsetBase   = this.$scrollElement.scrollTop()
12274    }
12275
12276    this.$body
12277      .find(this.selector)
12278      .map(function () {
12279        var $el   = $(this)
12280        var href  = $el.data('target') || $el.attr('href')
12281        var $href = /^#./.test(href) && $(href)
12282
12283        return ($href
12284          && $href.length
12285          && $href.is(':visible')
12286          && [[$href[offsetMethod]().top + offsetBase, href]]) || null
12287      })
12288      .sort(function (a, b) { return a[0] - b[0] })
12289      .each(function () {
12290        that.offsets.push(this[0])
12291        that.targets.push(this[1])
12292      })
12293  }
12294
12295  ScrollSpy.prototype.process = function () {
12296    var scrollTop    = this.$scrollElement.scrollTop() + this.options.offset
12297    var scrollHeight = this.getScrollHeight()
12298    var maxScroll    = this.options.offset + scrollHeight - this.$scrollElement.height()
12299    var offsets      = this.offsets
12300    var targets      = this.targets
12301    var activeTarget = this.activeTarget
12302    var i
12303
12304    if (this.scrollHeight != scrollHeight) {
12305      this.refresh()
12306    }
12307
12308    if (scrollTop >= maxScroll) {
12309      return activeTarget != (i = targets[targets.length - 1]) && this.activate(i)
12310    }
12311
12312    if (activeTarget && scrollTop < offsets[0]) {
12313      this.activeTarget = null
12314      return this.clear()
12315    }
12316
12317    for (i = offsets.length; i--;) {
12318      activeTarget != targets[i]
12319        && scrollTop >= offsets[i]
12320        && (offsets[i + 1] === undefined || scrollTop < offsets[i + 1])
12321        && this.activate(targets[i])
12322    }
12323  }
12324
12325  ScrollSpy.prototype.activate = function (target) {
12326    this.activeTarget = target
12327
12328    this.clear()
12329
12330    var selector = this.selector +
12331      '[data-target="' + target + '"],' +
12332      this.selector + '[href="' + target + '"]'
12333
12334    var active = $(selector)
12335      .parents('li')
12336      .addClass('active')
12337
12338    if (active.parent('.dropdown-menu').length) {
12339      active = active
12340        .closest('li.dropdown')
12341        .addClass('active')
12342    }
12343
12344    active.trigger('activate.bs.scrollspy')
12345  }
12346
12347  ScrollSpy.prototype.clear = function () {
12348    $(this.selector)
12349      .parentsUntil(this.options.target, '.active')
12350      .removeClass('active')
12351  }
12352
12353
12354  // SCROLLSPY PLUGIN DEFINITION
12355  // ===========================
12356
12357  function Plugin(option) {
12358    return this.each(function () {
12359      var $this   = $(this)
12360      var data    = $this.data('bs.scrollspy')
12361      var options = typeof option == 'object' && option
12362
12363      if (!data) $this.data('bs.scrollspy', (data = new ScrollSpy(this, options)))
12364      if (typeof option == 'string') data[option]()
12365    })
12366  }
12367
12368  var old = $.fn.scrollspy
12369
12370  $.fn.scrollspy             = Plugin
12371  $.fn.scrollspy.Constructor = ScrollSpy
12372
12373
12374  // SCROLLSPY NO CONFLICT
12375  // =====================
12376
12377  $.fn.scrollspy.noConflict = function () {
12378    $.fn.scrollspy = old
12379    return this
12380  }
12381
12382
12383  // SCROLLSPY DATA-API
12384  // ==================
12385
12386  $(window).on('load.bs.scrollspy.data-api', function () {
12387    $('[data-spy="scroll"]').each(function () {
12388      var $spy = $(this)
12389      Plugin.call($spy, $spy.data())
12390    })
12391  })
12392
12393}(jQuery);
12394
12395/* ========================================================================
12396 * Bootstrap: tab.js v3.3.7
12397 * http://getbootstrap.com/javascript/#tabs
12398 * ========================================================================
12399 * Copyright 2011-2016 Twitter, Inc.
12400 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
12401 * ======================================================================== */
12402
12403
12404+function ($) {
12405  'use strict';
12406
12407  // TAB CLASS DEFINITION
12408  // ====================
12409
12410  var Tab = function (element) {
12411    // jscs:disable requireDollarBeforejQueryAssignment
12412    this.element = $(element)
12413    // jscs:enable requireDollarBeforejQueryAssignment
12414  }
12415
12416  Tab.VERSION = '3.3.7'
12417
12418  Tab.TRANSITION_DURATION = 150
12419
12420  Tab.prototype.show = function () {
12421    var $this    = this.element
12422    var $ul      = $this.closest('ul:not(.dropdown-menu)')
12423    var selector = $this.data('target')
12424
12425    if (!selector) {
12426      selector = $this.attr('href')
12427      selector = selector && selector.replace(/.*(?=#[^\s]*$)/, '') // strip for ie7
12428    }
12429
12430    if ($this.parent('li').hasClass('active')) return
12431
12432    var $previous = $ul.find('.active:last a')
12433    var hideEvent = $.Event('hide.bs.tab', {
12434      relatedTarget: $this[0]
12435    })
12436    var showEvent = $.Event('show.bs.tab', {
12437      relatedTarget: $previous[0]
12438    })
12439
12440    $previous.trigger(hideEvent)
12441    $this.trigger(showEvent)
12442
12443    if (showEvent.isDefaultPrevented() || hideEvent.isDefaultPrevented()) return
12444
12445    var $target = $(selector)
12446
12447    this.activate($this.closest('li'), $ul)
12448    this.activate($target, $target.parent(), function () {
12449      $previous.trigger({
12450        type: 'hidden.bs.tab',
12451        relatedTarget: $this[0]
12452      })
12453      $this.trigger({
12454        type: 'shown.bs.tab',
12455        relatedTarget: $previous[0]
12456      })
12457    })
12458  }
12459
12460  Tab.prototype.activate = function (element, container, callback) {
12461    var $active    = container.find('> .active')
12462    var transition = callback
12463      && $.support.transition
12464      && ($active.length && $active.hasClass('fade') || !!container.find('> .fade').length)
12465
12466    function next() {
12467      $active
12468        .removeClass('active')
12469        .find('> .dropdown-menu > .active')
12470          .removeClass('active')
12471        .end()
12472        .find('[data-toggle="tab"]')
12473          .attr('aria-expanded', false)
12474
12475      element
12476        .addClass('active')
12477        .find('[data-toggle="tab"]')
12478          .attr('aria-expanded', true)
12479
12480      if (transition) {
12481        element[0].offsetWidth // reflow for transition
12482        element.addClass('in')
12483      } else {
12484        element.removeClass('fade')
12485      }
12486
12487      if (element.parent('.dropdown-menu').length) {
12488        element
12489          .closest('li.dropdown')
12490            .addClass('active')
12491          .end()
12492          .find('[data-toggle="tab"]')
12493            .attr('aria-expanded', true)
12494      }
12495
12496      callback && callback()
12497    }
12498
12499    $active.length && transition ?
12500      $active
12501        .one('bsTransitionEnd', next)
12502        .emulateTransitionEnd(Tab.TRANSITION_DURATION) :
12503      next()
12504
12505    $active.removeClass('in')
12506  }
12507
12508
12509  // TAB PLUGIN DEFINITION
12510  // =====================
12511
12512  function Plugin(option) {
12513    return this.each(function () {
12514      var $this = $(this)
12515      var data  = $this.data('bs.tab')
12516
12517      if (!data) $this.data('bs.tab', (data = new Tab(this)))
12518      if (typeof option == 'string') data[option]()
12519    })
12520  }
12521
12522  var old = $.fn.tab
12523
12524  $.fn.tab             = Plugin
12525  $.fn.tab.Constructor = Tab
12526
12527
12528  // TAB NO CONFLICT
12529  // ===============
12530
12531  $.fn.tab.noConflict = function () {
12532    $.fn.tab = old
12533    return this
12534  }
12535
12536
12537  // TAB DATA-API
12538  // ============
12539
12540  var clickHandler = function (e) {
12541    e.preventDefault()
12542    Plugin.call($(this), 'show')
12543  }
12544
12545  $(document)
12546    .on('click.bs.tab.data-api', '[data-toggle="tab"]', clickHandler)
12547    .on('click.bs.tab.data-api', '[data-toggle="pill"]', clickHandler)
12548
12549}(jQuery);
12550
12551/* ========================================================================
12552 * Bootstrap: affix.js v3.3.7
12553 * http://getbootstrap.com/javascript/#affix
12554 * ========================================================================
12555 * Copyright 2011-2016 Twitter, Inc.
12556 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
12557 * ======================================================================== */
12558
12559
12560+function ($) {
12561  'use strict';
12562
12563  // AFFIX CLASS DEFINITION
12564  // ======================
12565
12566  var Affix = function (element, options) {
12567    this.options = $.extend({}, Affix.DEFAULTS, options)
12568
12569    this.$target = $(this.options.target)
12570      .on('scroll.bs.affix.data-api', $.proxy(this.checkPosition, this))
12571      .on('click.bs.affix.data-api',  $.proxy(this.checkPositionWithEventLoop, this))
12572
12573    this.$element     = $(element)
12574    this.affixed      = null
12575    this.unpin        = null
12576    this.pinnedOffset = null
12577
12578    this.checkPosition()
12579  }
12580
12581  Affix.VERSION  = '3.3.7'
12582
12583  Affix.RESET    = 'affix affix-top affix-bottom'
12584
12585  Affix.DEFAULTS = {
12586    offset: 0,
12587    target: window
12588  }
12589
12590  Affix.prototype.getState = function (scrollHeight, height, offsetTop, offsetBottom) {
12591    var scrollTop    = this.$target.scrollTop()
12592    var position     = this.$element.offset()
12593    var targetHeight = this.$target.height()
12594
12595    if (offsetTop != null && this.affixed == 'top') return scrollTop < offsetTop ? 'top' : false
12596
12597    if (this.affixed == 'bottom') {
12598      if (offsetTop != null) return (scrollTop + this.unpin <= position.top) ? false : 'bottom'
12599      return (scrollTop + targetHeight <= scrollHeight - offsetBottom) ? false : 'bottom'
12600    }
12601
12602    var initializing   = this.affixed == null
12603    var colliderTop    = initializing ? scrollTop : position.top
12604    var colliderHeight = initializing ? targetHeight : height
12605
12606    if (offsetTop != null && scrollTop <= offsetTop) return 'top'
12607    if (offsetBottom != null && (colliderTop + colliderHeight >= scrollHeight - offsetBottom)) return 'bottom'
12608
12609    return false
12610  }
12611
12612  Affix.prototype.getPinnedOffset = function () {
12613    if (this.pinnedOffset) return this.pinnedOffset
12614    this.$element.removeClass(Affix.RESET).addClass('affix')
12615    var scrollTop = this.$target.scrollTop()
12616    var position  = this.$element.offset()
12617    return (this.pinnedOffset = position.top - scrollTop)
12618  }
12619
12620  Affix.prototype.checkPositionWithEventLoop = function () {
12621    setTimeout($.proxy(this.checkPosition, this), 1)
12622  }
12623
12624  Affix.prototype.checkPosition = function () {
12625    if (!this.$element.is(':visible')) return
12626
12627    var height       = this.$element.height()
12628    var offset       = this.options.offset
12629    var offsetTop    = offset.top
12630    var offsetBottom = offset.bottom
12631    var scrollHeight = Math.max($(document).height(), $(document.body).height())
12632
12633    if (typeof offset != 'object')         offsetBottom = offsetTop = offset
12634    if (typeof offsetTop == 'function')    offsetTop    = offset.top(this.$element)
12635    if (typeof offsetBottom == 'function') offsetBottom = offset.bottom(this.$element)
12636
12637    var affix = this.getState(scrollHeight, height, offsetTop, offsetBottom)
12638
12639    if (this.affixed != affix) {
12640      if (this.unpin != null) this.$element.css('top', '')
12641
12642      var affixType = 'affix' + (affix ? '-' + affix : '')
12643      var e         = $.Event(affixType + '.bs.affix')
12644
12645      this.$element.trigger(e)
12646
12647      if (e.isDefaultPrevented()) return
12648
12649      this.affixed = affix
12650      this.unpin = affix == 'bottom' ? this.getPinnedOffset() : null
12651
12652      this.$element
12653        .removeClass(Affix.RESET)
12654        .addClass(affixType)
12655        .trigger(affixType.replace('affix', 'affixed') + '.bs.affix')
12656    }
12657
12658    if (affix == 'bottom') {
12659      this.$element.offset({
12660        top: scrollHeight - height - offsetBottom
12661      })
12662    }
12663  }
12664
12665
12666  // AFFIX PLUGIN DEFINITION
12667  // =======================
12668
12669  function Plugin(option) {
12670    return this.each(function () {
12671      var $this   = $(this)
12672      var data    = $this.data('bs.affix')
12673      var options = typeof option == 'object' && option
12674
12675      if (!data) $this.data('bs.affix', (data = new Affix(this, options)))
12676      if (typeof option == 'string') data[option]()
12677    })
12678  }
12679
12680  var old = $.fn.affix
12681
12682  $.fn.affix             = Plugin
12683  $.fn.affix.Constructor = Affix
12684
12685
12686  // AFFIX NO CONFLICT
12687  // =================
12688
12689  $.fn.affix.noConflict = function () {
12690    $.fn.affix = old
12691    return this
12692  }
12693
12694
12695  // AFFIX DATA-API
12696  // ==============
12697
12698  $(window).on('load', function () {
12699    $('[data-spy="affix"]').each(function () {
12700      var $spy = $(this)
12701      var data = $spy.data()
12702
12703      data.offset = data.offset || {}
12704
12705      if (data.offsetBottom != null) data.offset.bottom = data.offsetBottom
12706      if (data.offsetTop    != null) data.offset.top    = data.offsetTop
12707
12708      Plugin.call($spy, data)
12709    })
12710  })
12711
12712}(jQuery);
12713
12714/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0)))
12715
12716/***/ }),
12717/* 6 */
12718/***/ (function(module, exports, __webpack_require__) {
12719
12720/* WEBPACK VAR INJECTION */(function(jQuery) {var __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;(function(a){if("function"==="function"&&__webpack_require__(1)&&__webpack_require__(1).jQuery){!(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(0)], __WEBPACK_AMD_DEFINE_FACTORY__ = (a),
12721				__WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ?
12722				(__WEBPACK_AMD_DEFINE_FACTORY__.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__)) : __WEBPACK_AMD_DEFINE_FACTORY__),
12723				__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__))}else{if(typeof module!=="undefined"&&module.exports){a(__webpack_require__(0))}else{a(jQuery)}}}(function(f){var y="1.6.15",p="left",o="right",e="up",x="down",c="in",A="out",m="none",s="auto",l="swipe",t="pinch",B="tap",j="doubletap",b="longtap",z="hold",E="horizontal",u="vertical",i="all",r=10,g="start",k="move",h="end",q="cancel",a="ontouchstart" in window,v=window.navigator.msPointerEnabled&&!window.navigator.pointerEnabled&&!a,d=(window.navigator.pointerEnabled||window.navigator.msPointerEnabled)&&!a,C="TouchSwipe";var n={fingers:1,threshold:75,cancelThreshold:null,pinchThreshold:20,maxTimeThreshold:null,fingerReleaseThreshold:250,longTapThreshold:500,doubleTapThreshold:200,swipe:null,swipeLeft:null,swipeRight:null,swipeUp:null,swipeDown:null,swipeStatus:null,pinchIn:null,pinchOut:null,pinchStatus:null,click:null,tap:null,doubleTap:null,longTap:null,hold:null,triggerOnTouchEnd:true,triggerOnTouchLeave:false,allowPageScroll:"auto",fallbackToMouseEvents:true,excludedElements:"label, button, input, select, textarea, a, .noSwipe",preventDefaultEvents:true};f.fn.swipe=function(H){var G=f(this),F=G.data(C);if(F&&typeof H==="string"){if(F[H]){return F[H].apply(this,Array.prototype.slice.call(arguments,1))}else{f.error("Method "+H+" does not exist on jQuery.swipe")}}else{if(F&&typeof H==="object"){F.option.apply(this,arguments)}else{if(!F&&(typeof H==="object"||!H)){return w.apply(this,arguments)}}}return G};f.fn.swipe.version=y;f.fn.swipe.defaults=n;f.fn.swipe.phases={PHASE_START:g,PHASE_MOVE:k,PHASE_END:h,PHASE_CANCEL:q};f.fn.swipe.directions={LEFT:p,RIGHT:o,UP:e,DOWN:x,IN:c,OUT:A};f.fn.swipe.pageScroll={NONE:m,HORIZONTAL:E,VERTICAL:u,AUTO:s};f.fn.swipe.fingers={ONE:1,TWO:2,THREE:3,FOUR:4,FIVE:5,ALL:i};function w(F){if(F&&(F.allowPageScroll===undefined&&(F.swipe!==undefined||F.swipeStatus!==undefined))){F.allowPageScroll=m}if(F.click!==undefined&&F.tap===undefined){F.tap=F.click}if(!F){F={}}F=f.extend({},f.fn.swipe.defaults,F);return this.each(function(){var H=f(this);var G=H.data(C);if(!G){G=new D(this,F);H.data(C,G)}})}function D(a5,au){var au=f.extend({},au);var az=(a||d||!au.fallbackToMouseEvents),K=az?(d?(v?"MSPointerDown":"pointerdown"):"touchstart"):"mousedown",ax=az?(d?(v?"MSPointerMove":"pointermove"):"touchmove"):"mousemove",V=az?(d?(v?"MSPointerUp":"pointerup"):"touchend"):"mouseup",T=az?(d?"mouseleave":null):"mouseleave",aD=(d?(v?"MSPointerCancel":"pointercancel"):"touchcancel");var ag=0,aP=null,a2=null,ac=0,a1=0,aZ=0,H=1,ap=0,aJ=0,N=null;var aR=f(a5);var aa="start";var X=0;var aQ={};var U=0,a3=0,a6=0,ay=0,O=0;var aW=null,af=null;try{aR.bind(K,aN);aR.bind(aD,ba)}catch(aj){f.error("events not supported "+K+","+aD+" on jQuery.swipe")}this.enable=function(){aR.bind(K,aN);aR.bind(aD,ba);return aR};this.disable=function(){aK();return aR};this.destroy=function(){aK();aR.data(C,null);aR=null};this.option=function(bd,bc){if(typeof bd==="object"){au=f.extend(au,bd)}else{if(au[bd]!==undefined){if(bc===undefined){return au[bd]}else{au[bd]=bc}}else{if(!bd){return au}else{f.error("Option "+bd+" does not exist on jQuery.swipe.options")}}}return null};function aN(be){if(aB()){return}if(f(be.target).closest(au.excludedElements,aR).length>0){return}var bf=be.originalEvent?be.originalEvent:be;var bd,bg=bf.touches,bc=bg?bg[0]:bf;aa=g;if(bg){X=bg.length}else{if(au.preventDefaultEvents!==false){be.preventDefault()}}ag=0;aP=null;a2=null;aJ=null;ac=0;a1=0;aZ=0;H=1;ap=0;N=ab();S();ai(0,bc);if(!bg||(X===au.fingers||au.fingers===i)||aX()){U=ar();if(X==2){ai(1,bg[1]);a1=aZ=at(aQ[0].start,aQ[1].start)}if(au.swipeStatus||au.pinchStatus){bd=P(bf,aa)}}else{bd=false}if(bd===false){aa=q;P(bf,aa);return bd}else{if(au.hold){af=setTimeout(f.proxy(function(){aR.trigger("hold",[bf.target]);if(au.hold){bd=au.hold.call(aR,bf,bf.target)}},this),au.longTapThreshold)}an(true)}return null}function a4(bf){var bi=bf.originalEvent?bf.originalEvent:bf;if(aa===h||aa===q||al()){return}var be,bj=bi.touches,bd=bj?bj[0]:bi;var bg=aH(bd);a3=ar();if(bj){X=bj.length}if(au.hold){clearTimeout(af)}aa=k;if(X==2){if(a1==0){ai(1,bj[1]);a1=aZ=at(aQ[0].start,aQ[1].start)}else{aH(bj[1]);aZ=at(aQ[0].end,aQ[1].end);aJ=aq(aQ[0].end,aQ[1].end)}H=a8(a1,aZ);ap=Math.abs(a1-aZ)}if((X===au.fingers||au.fingers===i)||!bj||aX()){aP=aL(bg.start,bg.end);a2=aL(bg.last,bg.end);ak(bf,a2);ag=aS(bg.start,bg.end);ac=aM();aI(aP,ag);be=P(bi,aa);if(!au.triggerOnTouchEnd||au.triggerOnTouchLeave){var bc=true;if(au.triggerOnTouchLeave){var bh=aY(this);bc=F(bg.end,bh)}if(!au.triggerOnTouchEnd&&bc){aa=aC(k)}else{if(au.triggerOnTouchLeave&&!bc){aa=aC(h)}}if(aa==q||aa==h){P(bi,aa)}}}else{aa=q;P(bi,aa)}if(be===false){aa=q;P(bi,aa)}}function M(bc){var bd=bc.originalEvent?bc.originalEvent:bc,be=bd.touches;if(be){if(be.length&&!al()){G(bd);return true}else{if(be.length&&al()){return true}}}if(al()){X=ay}a3=ar();ac=aM();if(bb()||!am()){aa=q;P(bd,aa)}else{if(au.triggerOnTouchEnd||(au.triggerOnTouchEnd==false&&aa===k)){if(au.preventDefaultEvents!==false){bc.preventDefault()}aa=h;P(bd,aa)}else{if(!au.triggerOnTouchEnd&&a7()){aa=h;aF(bd,aa,B)}else{if(aa===k){aa=q;P(bd,aa)}}}}an(false);return null}function ba(){X=0;a3=0;U=0;a1=0;aZ=0;H=1;S();an(false)}function L(bc){var bd=bc.originalEvent?bc.originalEvent:bc;if(au.triggerOnTouchLeave){aa=aC(h);P(bd,aa)}}function aK(){aR.unbind(K,aN);aR.unbind(aD,ba);aR.unbind(ax,a4);aR.unbind(V,M);if(T){aR.unbind(T,L)}an(false)}function aC(bg){var bf=bg;var be=aA();var bd=am();var bc=bb();if(!be||bc){bf=q}else{if(bd&&bg==k&&(!au.triggerOnTouchEnd||au.triggerOnTouchLeave)){bf=h}else{if(!bd&&bg==h&&au.triggerOnTouchLeave){bf=q}}}return bf}function P(be,bc){var bd,bf=be.touches;if(J()||W()){bd=aF(be,bc,l)}if((Q()||aX())&&bd!==false){bd=aF(be,bc,t)}if(aG()&&bd!==false){bd=aF(be,bc,j)}else{if(ao()&&bd!==false){bd=aF(be,bc,b)}else{if(ah()&&bd!==false){bd=aF(be,bc,B)}}}if(bc===q){if(W()){bd=aF(be,bc,l)}if(aX()){bd=aF(be,bc,t)}ba(be)}if(bc===h){if(bf){if(!bf.length){ba(be)}}else{ba(be)}}return bd}function aF(bf,bc,be){var bd;if(be==l){aR.trigger("swipeStatus",[bc,aP||null,ag||0,ac||0,X,aQ,a2]);if(au.swipeStatus){bd=au.swipeStatus.call(aR,bf,bc,aP||null,ag||0,ac||0,X,aQ,a2);if(bd===false){return false}}if(bc==h&&aV()){clearTimeout(aW);clearTimeout(af);aR.trigger("swipe",[aP,ag,ac,X,aQ,a2]);if(au.swipe){bd=au.swipe.call(aR,bf,aP,ag,ac,X,aQ,a2);if(bd===false){return false}}switch(aP){case p:aR.trigger("swipeLeft",[aP,ag,ac,X,aQ,a2]);if(au.swipeLeft){bd=au.swipeLeft.call(aR,bf,aP,ag,ac,X,aQ,a2)}break;case o:aR.trigger("swipeRight",[aP,ag,ac,X,aQ,a2]);if(au.swipeRight){bd=au.swipeRight.call(aR,bf,aP,ag,ac,X,aQ,a2)}break;case e:aR.trigger("swipeUp",[aP,ag,ac,X,aQ,a2]);if(au.swipeUp){bd=au.swipeUp.call(aR,bf,aP,ag,ac,X,aQ,a2)}break;case x:aR.trigger("swipeDown",[aP,ag,ac,X,aQ,a2]);if(au.swipeDown){bd=au.swipeDown.call(aR,bf,aP,ag,ac,X,aQ,a2)}break}}}if(be==t){aR.trigger("pinchStatus",[bc,aJ||null,ap||0,ac||0,X,H,aQ]);if(au.pinchStatus){bd=au.pinchStatus.call(aR,bf,bc,aJ||null,ap||0,ac||0,X,H,aQ);if(bd===false){return false}}if(bc==h&&a9()){switch(aJ){case c:aR.trigger("pinchIn",[aJ||null,ap||0,ac||0,X,H,aQ]);if(au.pinchIn){bd=au.pinchIn.call(aR,bf,aJ||null,ap||0,ac||0,X,H,aQ)}break;case A:aR.trigger("pinchOut",[aJ||null,ap||0,ac||0,X,H,aQ]);if(au.pinchOut){bd=au.pinchOut.call(aR,bf,aJ||null,ap||0,ac||0,X,H,aQ)}break}}}if(be==B){if(bc===q||bc===h){clearTimeout(aW);clearTimeout(af);if(Z()&&!I()){O=ar();aW=setTimeout(f.proxy(function(){O=null;aR.trigger("tap",[bf.target]);if(au.tap){bd=au.tap.call(aR,bf,bf.target)}},this),au.doubleTapThreshold)}else{O=null;aR.trigger("tap",[bf.target]);if(au.tap){bd=au.tap.call(aR,bf,bf.target)}}}}else{if(be==j){if(bc===q||bc===h){clearTimeout(aW);clearTimeout(af);O=null;aR.trigger("doubletap",[bf.target]);if(au.doubleTap){bd=au.doubleTap.call(aR,bf,bf.target)}}}else{if(be==b){if(bc===q||bc===h){clearTimeout(aW);O=null;aR.trigger("longtap",[bf.target]);if(au.longTap){bd=au.longTap.call(aR,bf,bf.target)}}}}}return bd}function am(){var bc=true;if(au.threshold!==null){bc=ag>=au.threshold}return bc}function bb(){var bc=false;if(au.cancelThreshold!==null&&aP!==null){bc=(aT(aP)-ag)>=au.cancelThreshold}return bc}function ae(){if(au.pinchThreshold!==null){return ap>=au.pinchThreshold}return true}function aA(){var bc;if(au.maxTimeThreshold){if(ac>=au.maxTimeThreshold){bc=false}else{bc=true}}else{bc=true}return bc}function ak(bc,bd){if(au.preventDefaultEvents===false){return}if(au.allowPageScroll===m){bc.preventDefault()}else{var be=au.allowPageScroll===s;switch(bd){case p:if((au.swipeLeft&&be)||(!be&&au.allowPageScroll!=E)){bc.preventDefault()}break;case o:if((au.swipeRight&&be)||(!be&&au.allowPageScroll!=E)){bc.preventDefault()}break;case e:if((au.swipeUp&&be)||(!be&&au.allowPageScroll!=u)){bc.preventDefault()}break;case x:if((au.swipeDown&&be)||(!be&&au.allowPageScroll!=u)){bc.preventDefault()}break}}}function a9(){var bd=aO();var bc=Y();var be=ae();return bd&&bc&&be}function aX(){return !!(au.pinchStatus||au.pinchIn||au.pinchOut)}function Q(){return !!(a9()&&aX())}function aV(){var bf=aA();var bh=am();var be=aO();var bc=Y();var bd=bb();var bg=!bd&&bc&&be&&bh&&bf;return bg}function W(){return !!(au.swipe||au.swipeStatus||au.swipeLeft||au.swipeRight||au.swipeUp||au.swipeDown)}function J(){return !!(aV()&&W())}function aO(){return((X===au.fingers||au.fingers===i)||!a)}function Y(){return aQ[0].end.x!==0}function a7(){return !!(au.tap)}function Z(){return !!(au.doubleTap)}function aU(){return !!(au.longTap)}function R(){if(O==null){return false}var bc=ar();return(Z()&&((bc-O)<=au.doubleTapThreshold))}function I(){return R()}function aw(){return((X===1||!a)&&(isNaN(ag)||ag<au.threshold))}function a0(){return((ac>au.longTapThreshold)&&(ag<r))}function ah(){return !!(aw()&&a7())}function aG(){return !!(R()&&Z())}function ao(){return !!(a0()&&aU())}function G(bc){a6=ar();ay=bc.touches.length+1}function S(){a6=0;ay=0}function al(){var bc=false;if(a6){var bd=ar()-a6;if(bd<=au.fingerReleaseThreshold){bc=true}}return bc}function aB(){return !!(aR.data(C+"_intouch")===true)}function an(bc){if(!aR){return}if(bc===true){aR.bind(ax,a4);aR.bind(V,M);if(T){aR.bind(T,L)}}else{aR.unbind(ax,a4,false);aR.unbind(V,M,false);if(T){aR.unbind(T,L,false)}}aR.data(C+"_intouch",bc===true)}function ai(be,bc){var bd={start:{x:0,y:0},last:{x:0,y:0},end:{x:0,y:0}};bd.start.x=bd.last.x=bd.end.x=bc.pageX||bc.clientX;bd.start.y=bd.last.y=bd.end.y=bc.pageY||bc.clientY;aQ[be]=bd;return bd}function aH(bc){var be=bc.identifier!==undefined?bc.identifier:0;var bd=ad(be);if(bd===null){bd=ai(be,bc)}bd.last.x=bd.end.x;bd.last.y=bd.end.y;bd.end.x=bc.pageX||bc.clientX;bd.end.y=bc.pageY||bc.clientY;return bd}function ad(bc){return aQ[bc]||null}function aI(bc,bd){bd=Math.max(bd,aT(bc));N[bc].distance=bd}function aT(bc){if(N[bc]){return N[bc].distance}return undefined}function ab(){var bc={};bc[p]=av(p);bc[o]=av(o);bc[e]=av(e);bc[x]=av(x);return bc}function av(bc){return{direction:bc,distance:0}}function aM(){return a3-U}function at(bf,be){var bd=Math.abs(bf.x-be.x);var bc=Math.abs(bf.y-be.y);return Math.round(Math.sqrt(bd*bd+bc*bc))}function a8(bc,bd){var be=(bd/bc)*1;return be.toFixed(2)}function aq(){if(H<1){return A}else{return c}}function aS(bd,bc){return Math.round(Math.sqrt(Math.pow(bc.x-bd.x,2)+Math.pow(bc.y-bd.y,2)))}function aE(bf,bd){var bc=bf.x-bd.x;var bh=bd.y-bf.y;var be=Math.atan2(bh,bc);var bg=Math.round(be*180/Math.PI);if(bg<0){bg=360-Math.abs(bg)}return bg}function aL(bd,bc){var be=aE(bd,bc);if((be<=45)&&(be>=0)){return p}else{if((be<=360)&&(be>=315)){return p}else{if((be>=135)&&(be<=225)){return o}else{if((be>45)&&(be<135)){return x}else{return e}}}}}function ar(){var bc=new Date();return bc.getTime()}function aY(bc){bc=f(bc);var be=bc.offset();var bd={left:be.left,right:be.left+bc.outerWidth(),top:be.top,bottom:be.top+bc.outerHeight()};return bd}function F(bc,bd){return(bc.x>bd.left&&bc.x<bd.right&&bc.y>bd.top&&bc.y<bd.bottom)}}}));
12724/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0)))
12725
12726/***/ }),
12727/* 7 */
12728/***/ (function(module, exports, __webpack_require__) {
12729
12730/* WEBPACK VAR INJECTION */(function($) {/*!
12731 * Slidebars - A jQuery Framework for Off-Canvas Menus and Sidebars
12732 * Version: 2.0.2
12733 * Url: http://www.adchsm.com/slidebars/
12734 * Author: Adam Charles Smith
12735 * Author url: http://www.adchsm.com/
12736 * License: MIT
12737 * License url: http://www.adchsm.com/slidebars/license/
12738 */
12739
12740var slidebars=function(){var t=$("[canvas]"),e={},i=!1,n=!1,s=["top","right","bottom","left"],r=["reveal","push","overlay","shift"],o=function(i){var n=$(),s="0px, 0px",r=1e3*parseFloat(e[i].element.css("transitionDuration"),10);return("reveal"===e[i].style||"push"===e[i].style||"shift"===e[i].style)&&(n=n.add(t)),("push"===e[i].style||"overlay"===e[i].style||"shift"===e[i].style)&&(n=n.add(e[i].element)),e[i].active&&("top"===e[i].side?s="0px, "+e[i].element.css("height"):"right"===e[i].side?s="-"+e[i].element.css("width")+", 0px":"bottom"===e[i].side?s="0px, -"+e[i].element.css("height"):"left"===e[i].side&&(s=e[i].element.css("width")+", 0px")),{elements:n,amount:s,duration:r}},c=function(t,i,n,s){return a(t)?!1:void(e[t]={id:t,side:i,style:n,element:s,active:!1})},a=function(t){return e.hasOwnProperty(t)?!0:!1};this.init=function(t){return i?!1:(n||($("[off-canvas]").each(function(){var t=$(this).attr("off-canvas").split(" ",3);return t&&t[0]&&-1!==s.indexOf(t[1])&&-1!==r.indexOf(t[2])?void c(t[0],t[1],t[2],$(this)):!1}),n=!0),i=!0,this.css(),$(f).trigger("init"),void("function"==typeof t&&t()))},this.exit=function(t){if(!i)return!1;var e=function(){i=!1,$(f).trigger("exit"),"function"==typeof t&&t()};this.getActiveSlidebar()?this.close(e):e()},this.css=function(t){if(!i)return!1;for(var n in e)if(a(n)){var s;s="top"===e[n].side||"bottom"===e[n].side?e[n].element.css("height"):e[n].element.css("width"),("push"===e[n].style||"overlay"===e[n].style||"shift"===e[n].style)&&e[n].element.css("margin-"+e[n].side,"-"+s)}this.getActiveSlidebar()&&this.open(this.getActiveSlidebar()),$(f).trigger("css"),"function"==typeof t&&t()},this.open=function(t,n){if(!i)return!1;if(!t||!a(t))return!1;var s=function(){e[t].active=!0,e[t].element.css("display","block"),$(f).trigger("opening",[e[t].id]);var i=o(t);i.elements.css({"transition-duration":i.duration+"ms",transform:"translate("+i.amount+")"}),setTimeout(function(){$(f).trigger("opened",[e[t].id]),"function"==typeof n&&n()},i.duration)};this.getActiveSlidebar()&&this.getActiveSlidebar()!==t?this.close(s):s()},this.close=function(t,n){if("function"==typeof t&&(n=t,t=null),!i)return!1;if(t&&!a(t))return!1;if(t||(t=this.getActiveSlidebar()),t&&e[t].active){e[t].active=!1,$(f).trigger("closing",[e[t].id]);var s=o(t);s.elements.css("transform",""),setTimeout(function(){s.elements.css("transition-duration",""),e[t].element.css("display",""),$(f).trigger("closed",[e[t].id]),"function"==typeof n&&n()},s.duration)}},this.toggle=function(t,n){return i&&t&&a(t)?void(e[t].active?this.close(t,function(){"function"==typeof n&&n()}):this.open(t,function(){"function"==typeof n&&n()})):!1},this.isActive=function(){return i},this.isActiveSlidebar=function(t){return i&&t&&a(t)?e[t].active:!1},this.getActiveSlidebar=function(){if(!i)return!1;var t=!1;for(var n in e)if(a(n)&&e[n].active){t=e[n].id;break}return t},this.getSlidebars=function(){if(!i)return!1;var t=[];for(var n in e)a(n)&&t.push(e[n].id);return t},this.getSlidebar=function(t){return i&&t&&t&&a(t)?e[t]:!1},this.events={};var f=this.events;$(window).on("resize",this.css.bind(this))};
12741/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(0)))
12742
12743/***/ }),
12744/* 8 */,
12745/* 9 */
12746/***/ (function(module, exports, __webpack_require__) {
12747
12748__webpack_require__(3);
12749module.exports = __webpack_require__(4);
12750
12751
12752/***/ })
12753/******/ ]);