☰

jquery-extras

Contains jQuery with a bunch of useful extras

Αυτός ο κώδικας δεν πρέπει να εγκατασταθεί άμεσα. Είναι μια βιβλιοθήκη για άλλους κώδικες που περιλαμβάνεται μέσω της οδηγίας meta // @require https://update.greatest.deepsurf.us/scripts/12083/71338/jquery-extras.js 

  1. // ==UserScript==
  2. // @name         jquery-extras
  3. // @version      0.2.0
  4. // @description  Contains jQuery with a bunch of useful extras
  5. // ==/UserScript==
  6.  
  7.  
  8. (function webpackUniversalModuleDefinition(root, factory) {
  9. 	if(typeof exports === 'object' && typeof module === 'object')
  10. 		module.exports = factory();
  11. 	else if(typeof define === 'function' && define.amd)
  12. 		define([], factory);
  13. 	else if(typeof exports === 'object')
  14. 		exports["$"] = factory();
  15. 	else
  16. 		root["$"] = factory();
  17. })(this, function() {
  18. return /******/ (function(modules) { // webpackBootstrap
  19. /******/ 	// The module cache
  20. /******/ 	var installedModules = {};
  21. /******/
  22. /******/ 	// The require function
  23. /******/ 	function __webpack_require__(moduleId) {
  24. /******/
  25. /******/ 		// Check if module is in cache
  26. /******/ 		if(installedModules[moduleId])
  27. /******/ 			return installedModules[moduleId].exports;
  28. /******/
  29. /******/ 		// Create a new module (and put it into the cache)
  30. /******/ 		var module = installedModules[moduleId] = {
  31. /******/ 			exports: {},
  32. /******/ 			id: moduleId,
  33. /******/ 			loaded: false
  34. /******/ 		};
  35. /******/
  36. /******/ 		// Execute the module function
  37. /******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
  38. /******/
  39. /******/ 		// Flag the module as loaded
  40. /******/ 		module.loaded = true;
  41. /******/
  42. /******/ 		// Return the exports of the module
  43. /******/ 		return module.exports;
  44. /******/ 	}
  45. /******/
  46. /******/
  47. /******/ 	// expose the modules object (__webpack_modules__)
  48. /******/ 	__webpack_require__.m = modules;
  49. /******/
  50. /******/ 	// expose the module cache
  51. /******/ 	__webpack_require__.c = installedModules;
  52. /******/
  53. /******/ 	// __webpack_public_path__
  54. /******/ 	__webpack_require__.p = "http://localhost:9000/";
  55. /******/
  56. /******/ 	// Load entry module and return exports
  57. /******/ 	return __webpack_require__(0);
  58. /******/ })
  59. /************************************************************************/
  60. /******/ ([
  61. /* 0 */
  62. /*!***************************!*\
  63.   !*** multi jquery-extras ***!
  64.   \***************************/
  65. /***/ function(module, exports, __webpack_require__) {
  66.  
  67. 	module.exports = __webpack_require__(/*! ./entries/jquery */1);
  68.  
  69.  
  70. /***/ },
  71. /* 1 */
  72. /*!*********************************!*\
  73.   !*** ./entries/jquery/index.js ***!
  74.   \*********************************/
  75. /***/ function(module, exports, __webpack_require__) {
  76.  
  77. 	/* WEBPACK VAR INJECTION */(function(jQuery) {'use strict';
  78. 	
  79. 	var _Object$assign = __webpack_require__(/*! babel-runtime/core-js/object/assign */ 3)['default'];
  80. 	
  81. 	var _interopRequireDefault = __webpack_require__(/*! babel-runtime/helpers/interop-require-default */ 16)['default'];
  82. 	
  83. 	Object.defineProperty(exports, '__esModule', {
  84. 	  value: true
  85. 	});
  86. 	
  87. 	var _jquery = __webpack_require__(/*! jquery */ 2);
  88. 	
  89. 	var _jquery2 = _interopRequireDefault(_jquery);
  90. 	
  91. 	__webpack_require__(/*! jquery-extras */ 17);
  92. 	
  93. 	var _webSelectorObserver = __webpack_require__(/*! web/selector-observer */ 22);
  94. 	
  95. 	var _webSelectorObserver2 = _interopRequireDefault(_webSelectorObserver);
  96. 	
  97. 	// ----------------------------------------------------------------------------
  98. 	
  99. 	jQuery.fn.observe = function (selector, onAdded, onRemoved) {
  100. 	  var options = typeof selector === 'object' ? selector : {
  101. 	    selector: selector,
  102. 	    onAdded: onAdded,
  103. 	    onRemoved: onRemoved
  104. 	  };
  105. 	
  106. 	  _Object$assign(options, {
  107. 	    targets: [this.get()]
  108. 	  });
  109. 	
  110. 	  this.data('observer', new _webSelectorObserver2['default'](options));
  111. 	
  112. 	  return this;
  113. 	};
  114. 	
  115. 	// ----------------------------------------------------------------------------
  116.  
  117. 	exports['default'] = _jquery2['default'];
  118. 	module.exports = exports['default'];
  119. 	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(/*! jquery */ 2)))
  120.  
  121. /***/ },
  122. /* 2 */
  123. /*!*********************************!*\
  124.   !*** ./~/jquery/dist/jquery.js ***!
  125.   \*********************************/
  126. /***/ function(module, exports, __webpack_require__) {
  127.  
  128. 	var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/*!
  129. 	 * jQuery JavaScript Library v2.1.4
  130. 	 * http://jquery.com/
  131. 	 *
  132. 	 * Includes Sizzle.js
  133. 	 * http://sizzlejs.com/
  134. 	 *
  135. 	 * Copyright 2005, 2014 jQuery Foundation, Inc. and other contributors
  136. 	 * Released under the MIT license
  137. 	 * http://jquery.org/license
  138. 	 *
  139. 	 * Date: 2015-04-28T16:01Z
  140. 	 */
  141. 	
  142. 	(function( global, factory ) {
  143. 	
  144. 		if ( typeof module === "object" && typeof module.exports === "object" ) {
  145. 			// For CommonJS and CommonJS-like environments where a proper `window`
  146. 			// is present, execute the factory and get jQuery.
  147. 			// For environments that do not have a `window` with a `document`
  148. 			// (such as Node.js), expose a factory as module.exports.
  149. 			// This accentuates the need for the creation of a real `window`.
  150. 			// e.g. var jQuery = require("jquery")(window);
  151. 			// See ticket #14549 for more info.
  152. 			module.exports = global.document ?
  153. 				factory( global, true ) :
  154. 				function( w ) {
  155. 					if ( !w.document ) {
  156. 						throw new Error( "jQuery requires a window with a document" );
  157. 					}
  158. 					return factory( w );
  159. 				};
  160. 		} else {
  161. 			factory( global );
  162. 		}
  163. 	
  164. 	// Pass this if window is not defined yet
  165. 	}(typeof window !== "undefined" ? window : this, function( window, noGlobal ) {
  166. 	
  167. 	// Support: Firefox 18+
  168. 	// Can't be in strict mode, several libs including ASP.NET trace
  169. 	// the stack via arguments.caller.callee and Firefox dies if
  170. 	// you try to trace through "use strict" call chains. (#13335)
  171. 	//
  172. 	
  173. 	var arr = [];
  174. 	
  175. 	var slice = arr.slice;
  176. 	
  177. 	var concat = arr.concat;
  178. 	
  179. 	var push = arr.push;
  180. 	
  181. 	var indexOf = arr.indexOf;
  182. 	
  183. 	var class2type = {};
  184. 	
  185. 	var toString = class2type.toString;
  186. 	
  187. 	var hasOwn = class2type.hasOwnProperty;
  188. 	
  189. 	var support = {};
  190. 	
  191. 	
  192. 	
  193. 	var
  194. 		// Use the correct document accordingly with window argument (sandbox)
  195. 		document = window.document,
  196. 	
  197. 		version = "2.1.4",
  198. 	
  199. 		// Define a local copy of jQuery
  200. 		jQuery = function( selector, context ) {
  201. 			// The jQuery object is actually just the init constructor 'enhanced'
  202. 			// Need init if jQuery is called (just allow error to be thrown if not included)
  203. 			return new jQuery.fn.init( selector, context );
  204. 		},
  205. 	
  206. 		// Support: Android<4.1
  207. 		// Make sure we trim BOM and NBSP
  208. 		rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g,
  209. 	
  210. 		// Matches dashed string for camelizing
  211. 		rmsPrefix = /^-ms-/,
  212. 		rdashAlpha = /-([\da-z])/gi,
  213. 	
  214. 		// Used by jQuery.camelCase as callback to replace()
  215. 		fcamelCase = function( all, letter ) {
  216. 			return letter.toUpperCase();
  217. 		};
  218. 	
  219. 	jQuery.fn = jQuery.prototype = {
  220. 		// The current version of jQuery being used
  221. 		jquery: version,
  222. 	
  223. 		constructor: jQuery,
  224. 	
  225. 		// Start with an empty selector
  226. 		selector: "",
  227. 	
  228. 		// The default length of a jQuery object is 0
  229. 		length: 0,
  230. 	
  231. 		toArray: function() {
  232. 			return slice.call( this );
  233. 		},
  234. 	
  235. 		// Get the Nth element in the matched element set OR
  236. 		// Get the whole matched element set as a clean array
  237. 		get: function( num ) {
  238. 			return num != null ?
  239. 	
  240. 				// Return just the one element from the set
  241. 				( num < 0 ? this[ num + this.length ] : this[ num ] ) :
  242. 	
  243. 				// Return all the elements in a clean array
  244. 				slice.call( this );
  245. 		},
  246. 	
  247. 		// Take an array of elements and push it onto the stack
  248. 		// (returning the new matched element set)
  249. 		pushStack: function( elems ) {
  250. 	
  251. 			// Build a new jQuery matched element set
  252. 			var ret = jQuery.merge( this.constructor(), elems );
  253. 	
  254. 			// Add the old object onto the stack (as a reference)
  255. 			ret.prevObject = this;
  256. 			ret.context = this.context;
  257. 	
  258. 			// Return the newly-formed element set
  259. 			return ret;
  260. 		},
  261. 	
  262. 		// Execute a callback for every element in the matched set.
  263. 		// (You can seed the arguments with an array of args, but this is
  264. 		// only used internally.)
  265. 		each: function( callback, args ) {
  266. 			return jQuery.each( this, callback, args );
  267. 		},
  268. 	
  269. 		map: function( callback ) {
  270. 			return this.pushStack( jQuery.map(this, function( elem, i ) {
  271. 				return callback.call( elem, i, elem );
  272. 			}));
  273. 		},
  274. 	
  275. 		slice: function() {
  276. 			return this.pushStack( slice.apply( this, arguments ) );
  277. 		},
  278. 	
  279. 		first: function() {
  280. 			return this.eq( 0 );
  281. 		},
  282. 	
  283. 		last: function() {
  284. 			return this.eq( -1 );
  285. 		},
  286. 	
  287. 		eq: function( i ) {
  288. 			var len = this.length,
  289. 				j = +i + ( i < 0 ? len : 0 );
  290. 			return this.pushStack( j >= 0 && j < len ? [ this[j] ] : [] );
  291. 		},
  292. 	
  293. 		end: function() {
  294. 			return this.prevObject || this.constructor(null);
  295. 		},
  296. 	
  297. 		// For internal use only.
  298. 		// Behaves like an Array's method, not like a jQuery method.
  299. 		push: push,
  300. 		sort: arr.sort,
  301. 		splice: arr.splice
  302. 	};
  303. 	
  304. 	jQuery.extend = jQuery.fn.extend = function() {
  305. 		var options, name, src, copy, copyIsArray, clone,
  306. 			target = arguments[0] || {},
  307. 			i = 1,
  308. 			length = arguments.length,
  309. 			deep = false;
  310. 	
  311. 		// Handle a deep copy situation
  312. 		if ( typeof target === "boolean" ) {
  313. 			deep = target;
  314. 	
  315. 			// Skip the boolean and the target
  316. 			target = arguments[ i ] || {};
  317. 			i++;
  318. 		}
  319. 	
  320. 		// Handle case when target is a string or something (possible in deep copy)
  321. 		if ( typeof target !== "object" && !jQuery.isFunction(target) ) {
  322. 			target = {};
  323. 		}
  324. 	
  325. 		// Extend jQuery itself if only one argument is passed
  326. 		if ( i === length ) {
  327. 			target = this;
  328. 			i--;
  329. 		}
  330. 	
  331. 		for ( ; i < length; i++ ) {
  332. 			// Only deal with non-null/undefined values
  333. 			if ( (options = arguments[ i ]) != null ) {
  334. 				// Extend the base object
  335. 				for ( name in options ) {
  336. 					src = target[ name ];
  337. 					copy = options[ name ];
  338. 	
  339. 					// Prevent never-ending loop
  340. 					if ( target === copy ) {
  341. 						continue;
  342. 					}
  343. 	
  344. 					// Recurse if we're merging plain objects or arrays
  345. 					if ( deep && copy && ( jQuery.isPlainObject(copy) || (copyIsArray = jQuery.isArray(copy)) ) ) {
  346. 						if ( copyIsArray ) {
  347. 							copyIsArray = false;
  348. 							clone = src && jQuery.isArray(src) ? src : [];
  349. 	
  350. 						} else {
  351. 							clone = src && jQuery.isPlainObject(src) ? src : {};
  352. 						}
  353. 	
  354. 						// Never move original objects, clone them
  355. 						target[ name ] = jQuery.extend( deep, clone, copy );
  356. 	
  357. 					// Don't bring in undefined values
  358. 					} else if ( copy !== undefined ) {
  359. 						target[ name ] = copy;
  360. 					}
  361. 				}
  362. 			}
  363. 		}
  364. 	
  365. 		// Return the modified object
  366. 		return target;
  367. 	};
  368. 	
  369. 	jQuery.extend({
  370. 		// Unique for each copy of jQuery on the page
  371. 		expando: "jQuery" + ( version + Math.random() ).replace( /\D/g, "" ),
  372. 	
  373. 		// Assume jQuery is ready without the ready module
  374. 		isReady: true,
  375. 	
  376. 		error: function( msg ) {
  377. 			throw new Error( msg );
  378. 		},
  379. 	
  380. 		noop: function() {},
  381. 	
  382. 		isFunction: function( obj ) {
  383. 			return jQuery.type(obj) === "function";
  384. 		},
  385. 	
  386. 		isArray: Array.isArray,
  387. 	
  388. 		isWindow: function( obj ) {
  389. 			return obj != null && obj === obj.window;
  390. 		},
  391. 	
  392. 		isNumeric: function( obj ) {
  393. 			// parseFloat NaNs numeric-cast false positives (null|true|false|"")
  394. 			// ...but misinterprets leading-number strings, particularly hex literals ("0x...")
  395. 			// subtraction forces infinities to NaN
  396. 			// adding 1 corrects loss of precision from parseFloat (#15100)
  397. 			return !jQuery.isArray( obj ) && (obj - parseFloat( obj ) + 1) >= 0;
  398. 		},
  399. 	
  400. 		isPlainObject: function( obj ) {
  401. 			// Not plain objects:
  402. 			// - Any object or value whose internal [[Class]] property is not "[object Object]"
  403. 			// - DOM nodes
  404. 			// - window
  405. 			if ( jQuery.type( obj ) !== "object" || obj.nodeType || jQuery.isWindow( obj ) ) {
  406. 				return false;
  407. 			}
  408. 	
  409. 			if ( obj.constructor &&
  410. 					!hasOwn.call( obj.constructor.prototype, "isPrototypeOf" ) ) {
  411. 				return false;
  412. 			}
  413. 	
  414. 			// If the function hasn't returned already, we're confident that
  415. 			// |obj| is a plain object, created by {} or constructed with new Object
  416. 			return true;
  417. 		},
  418. 	
  419. 		isEmptyObject: function( obj ) {
  420. 			var name;
  421. 			for ( name in obj ) {
  422. 				return false;
  423. 			}
  424. 			return true;
  425. 		},
  426. 	
  427. 		type: function( obj ) {
  428. 			if ( obj == null ) {
  429. 				return obj + "";
  430. 			}
  431. 			// Support: Android<4.0, iOS<6 (functionish RegExp)
  432. 			return typeof obj === "object" || typeof obj === "function" ?
  433. 				class2type[ toString.call(obj) ] || "object" :
  434. 				typeof obj;
  435. 		},
  436. 	
  437. 		// Evaluates a script in a global context
  438. 		globalEval: function( code ) {
  439. 			var script,
  440. 				indirect = eval;
  441. 	
  442. 			code = jQuery.trim( code );
  443. 	
  444. 			if ( code ) {
  445. 				// If the code includes a valid, prologue position
  446. 				// strict mode pragma, execute code by injecting a
  447. 				// script tag into the document.
  448. 				if ( code.indexOf("use strict") === 1 ) {
  449. 					script = document.createElement("script");
  450. 					script.text = code;
  451. 					document.head.appendChild( script ).parentNode.removeChild( script );
  452. 				} else {
  453. 				// Otherwise, avoid the DOM node creation, insertion
  454. 				// and removal by using an indirect global eval
  455. 					indirect( code );
  456. 				}
  457. 			}
  458. 		},
  459. 	
  460. 		// Convert dashed to camelCase; used by the css and data modules
  461. 		// Support: IE9-11+
  462. 		// Microsoft forgot to hump their vendor prefix (#9572)
  463. 		camelCase: function( string ) {
  464. 			return string.replace( rmsPrefix, "ms-" ).replace( rdashAlpha, fcamelCase );
  465. 		},
  466. 	
  467. 		nodeName: function( elem, name ) {
  468. 			return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase();
  469. 		},
  470. 	
  471. 		// args is for internal usage only
  472. 		each: function( obj, callback, args ) {
  473. 			var value,
  474. 				i = 0,
  475. 				length = obj.length,
  476. 				isArray = isArraylike( obj );
  477. 	
  478. 			if ( args ) {
  479. 				if ( isArray ) {
  480. 					for ( ; i < length; i++ ) {
  481. 						value = callback.apply( obj[ i ], args );
  482. 	
  483. 						if ( value === false ) {
  484. 							break;
  485. 						}
  486. 					}
  487. 				} else {
  488. 					for ( i in obj ) {
  489. 						value = callback.apply( obj[ i ], args );
  490. 	
  491. 						if ( value === false ) {
  492. 							break;
  493. 						}
  494. 					}
  495. 				}
  496. 	
  497. 			// A special, fast, case for the most common use of each
  498. 			} else {
  499. 				if ( isArray ) {
  500. 					for ( ; i < length; i++ ) {
  501. 						value = callback.call( obj[ i ], i, obj[ i ] );
  502. 	
  503. 						if ( value === false ) {
  504. 							break;
  505. 						}
  506. 					}
  507. 				} else {
  508. 					for ( i in obj ) {
  509. 						value = callback.call( obj[ i ], i, obj[ i ] );
  510. 	
  511. 						if ( value === false ) {
  512. 							break;
  513. 						}
  514. 					}
  515. 				}
  516. 			}
  517. 	
  518. 			return obj;
  519. 		},
  520. 	
  521. 		// Support: Android<4.1
  522. 		trim: function( text ) {
  523. 			return text == null ?
  524. 				"" :
  525. 				( text + "" ).replace( rtrim, "" );
  526. 		},
  527. 	
  528. 		// results is for internal usage only
  529. 		makeArray: function( arr, results ) {
  530. 			var ret = results || [];
  531. 	
  532. 			if ( arr != null ) {
  533. 				if ( isArraylike( Object(arr) ) ) {
  534. 					jQuery.merge( ret,
  535. 						typeof arr === "string" ?
  536. 						[ arr ] : arr
  537. 					);
  538. 				} else {
  539. 					push.call( ret, arr );
  540. 				}
  541. 			}
  542. 	
  543. 			return ret;
  544. 		},
  545. 	
  546. 		inArray: function( elem, arr, i ) {
  547. 			return arr == null ? -1 : indexOf.call( arr, elem, i );
  548. 		},
  549. 	
  550. 		merge: function( first, second ) {
  551. 			var len = +second.length,
  552. 				j = 0,
  553. 				i = first.length;
  554. 	
  555. 			for ( ; j < len; j++ ) {
  556. 				first[ i++ ] = second[ j ];
  557. 			}
  558. 	
  559. 			first.length = i;
  560. 	
  561. 			return first;
  562. 		},
  563. 	
  564. 		grep: function( elems, callback, invert ) {
  565. 			var callbackInverse,
  566. 				matches = [],
  567. 				i = 0,
  568. 				length = elems.length,
  569. 				callbackExpect = !invert;
  570. 	
  571. 			// Go through the array, only saving the items
  572. 			// that pass the validator function
  573. 			for ( ; i < length; i++ ) {
  574. 				callbackInverse = !callback( elems[ i ], i );
  575. 				if ( callbackInverse !== callbackExpect ) {
  576. 					matches.push( elems[ i ] );
  577. 				}
  578. 			}
  579. 	
  580. 			return matches;
  581. 		},
  582. 	
  583. 		// arg is for internal usage only
  584. 		map: function( elems, callback, arg ) {
  585. 			var value,
  586. 				i = 0,
  587. 				length = elems.length,
  588. 				isArray = isArraylike( elems ),
  589. 				ret = [];
  590. 	
  591. 			// Go through the array, translating each of the items to their new values
  592. 			if ( isArray ) {
  593. 				for ( ; i < length; i++ ) {
  594. 					value = callback( elems[ i ], i, arg );
  595. 	
  596. 					if ( value != null ) {
  597. 						ret.push( value );
  598. 					}
  599. 				}
  600. 	
  601. 			// Go through every key on the object,
  602. 			} else {
  603. 				for ( i in elems ) {
  604. 					value = callback( elems[ i ], i, arg );
  605. 	
  606. 					if ( value != null ) {
  607. 						ret.push( value );
  608. 					}
  609. 				}
  610. 			}
  611. 	
  612. 			// Flatten any nested arrays
  613. 			return concat.apply( [], ret );
  614. 		},
  615. 	
  616. 		// A global GUID counter for objects
  617. 		guid: 1,
  618. 	
  619. 		// Bind a function to a context, optionally partially applying any
  620. 		// arguments.
  621. 		proxy: function( fn, context ) {
  622. 			var tmp, args, proxy;
  623. 	
  624. 			if ( typeof context === "string" ) {
  625. 				tmp = fn[ context ];
  626. 				context = fn;
  627. 				fn = tmp;
  628. 			}
  629. 	
  630. 			// Quick check to determine if target is callable, in the spec
  631. 			// this throws a TypeError, but we will just return undefined.
  632. 			if ( !jQuery.isFunction( fn ) ) {
  633. 				return undefined;
  634. 			}
  635. 	
  636. 			// Simulated bind
  637. 			args = slice.call( arguments, 2 );
  638. 			proxy = function() {
  639. 				return fn.apply( context || this, args.concat( slice.call( arguments ) ) );
  640. 			};
  641. 	
  642. 			// Set the guid of unique handler to the same of original handler, so it can be removed
  643. 			proxy.guid = fn.guid = fn.guid || jQuery.guid++;
  644. 	
  645. 			return proxy;
  646. 		},
  647. 	
  648. 		now: Date.now,
  649. 	
  650. 		// jQuery.support is not used in Core but other projects attach their
  651. 		// properties to it so it needs to exist.
  652. 		support: support
  653. 	});
  654. 	
  655. 	// Populate the class2type map
  656. 	jQuery.each("Boolean Number String Function Array Date RegExp Object Error".split(" "), function(i, name) {
  657. 		class2type[ "[object " + name + "]" ] = name.toLowerCase();
  658. 	});
  659. 	
  660. 	function isArraylike( obj ) {
  661. 	
  662. 		// Support: iOS 8.2 (not reproducible in simulator)
  663. 		// `in` check used to prevent JIT error (gh-2145)
  664. 		// hasOwn isn't used here due to false negatives
  665. 		// regarding Nodelist length in IE
  666. 		var length = "length" in obj && obj.length,
  667. 			type = jQuery.type( obj );
  668. 	
  669. 		if ( type === "function" || jQuery.isWindow( obj ) ) {
  670. 			return false;
  671. 		}
  672. 	
  673. 		if ( obj.nodeType === 1 && length ) {
  674. 			return true;
  675. 		}
  676. 	
  677. 		return type === "array" || length === 0 ||
  678. 			typeof length === "number" && length > 0 && ( length - 1 ) in obj;
  679. 	}
  680. 	var Sizzle =
  681. 	/*!
  682. 	 * Sizzle CSS Selector Engine v2.2.0-pre
  683. 	 * http://sizzlejs.com/
  684. 	 *
  685. 	 * Copyright 2008, 2014 jQuery Foundation, Inc. and other contributors
  686. 	 * Released under the MIT license
  687. 	 * http://jquery.org/license
  688. 	 *
  689. 	 * Date: 2014-12-16
  690. 	 */
  691. 	(function( window ) {
  692. 	
  693. 	var i,
  694. 		support,
  695. 		Expr,
  696. 		getText,
  697. 		isXML,
  698. 		tokenize,
  699. 		compile,
  700. 		select,
  701. 		outermostContext,
  702. 		sortInput,
  703. 		hasDuplicate,
  704. 	
  705. 		// Local document vars
  706. 		setDocument,
  707. 		document,
  708. 		docElem,
  709. 		documentIsHTML,
  710. 		rbuggyQSA,
  711. 		rbuggyMatches,
  712. 		matches,
  713. 		contains,
  714. 	
  715. 		// Instance-specific data
  716. 		expando = "sizzle" + 1 * new Date(),
  717. 		preferredDoc = window.document,
  718. 		dirruns = 0,
  719. 		done = 0,
  720. 		classCache = createCache(),
  721. 		tokenCache = createCache(),
  722. 		compilerCache = createCache(),
  723. 		sortOrder = function( a, b ) {
  724. 			if ( a === b ) {
  725. 				hasDuplicate = true;
  726. 			}
  727. 			return 0;
  728. 		},
  729. 	
  730. 		// General-purpose constants
  731. 		MAX_NEGATIVE = 1 << 31,
  732. 	
  733. 		// Instance methods
  734. 		hasOwn = ({}).hasOwnProperty,
  735. 		arr = [],
  736. 		pop = arr.pop,
  737. 		push_native = arr.push,
  738. 		push = arr.push,
  739. 		slice = arr.slice,
  740. 		// Use a stripped-down indexOf as it's faster than native
  741. 		// http://jsperf.com/thor-indexof-vs-for/5
  742. 		indexOf = function( list, elem ) {
  743. 			var i = 0,
  744. 				len = list.length;
  745. 			for ( ; i < len; i++ ) {
  746. 				if ( list[i] === elem ) {
  747. 					return i;
  748. 				}
  749. 			}
  750. 			return -1;
  751. 		},
  752. 	
  753. 		booleans = "checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped",
  754. 	
  755. 		// Regular expressions
  756. 	
  757. 		// Whitespace characters http://www.w3.org/TR/css3-selectors/#whitespace
  758. 		whitespace = "[\\x20\\t\\r\\n\\f]",
  759. 		// http://www.w3.org/TR/css3-syntax/#characters
  760. 		characterEncoding = "(?:\\\\.|[\\w-]|[^\\x00-\\xa0])+",
  761. 	
  762. 		// Loosely modeled on CSS identifier characters
  763. 		// An unquoted value should be a CSS identifier http://www.w3.org/TR/css3-selectors/#attribute-selectors
  764. 		// Proper syntax: http://www.w3.org/TR/CSS21/syndata.html#value-def-identifier
  765. 		identifier = characterEncoding.replace( "w", "w#" ),
  766. 	
  767. 		// Attribute selectors: http://www.w3.org/TR/selectors/#attribute-selectors
  768. 		attributes = "\\[" + whitespace + "*(" + characterEncoding + ")(?:" + whitespace +
  769. 			// Operator (capture 2)
  770. 			"*([*^$|!~]?=)" + whitespace +
  771. 			// "Attribute values must be CSS identifiers [capture 5] or strings [capture 3 or capture 4]"
  772. 			"*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|(" + identifier + "))|)" + whitespace +
  773. 			"*\\]",
  774. 	
  775. 		pseudos = ":(" + characterEncoding + ")(?:\\((" +
  776. 			// To reduce the number of selectors needing tokenize in the preFilter, prefer arguments:
  777. 			// 1. quoted (capture 3; capture 4 or capture 5)
  778. 			"('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|" +
  779. 			// 2. simple (capture 6)
  780. 			"((?:\\\\.|[^\\\\()[\\]]|" + attributes + ")*)|" +
  781. 			// 3. anything else (capture 2)
  782. 			".*" +
  783. 			")\\)|)",
  784. 	
  785. 		// Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter
  786. 		rwhitespace = new RegExp( whitespace + "+", "g" ),
  787. 		rtrim = new RegExp( "^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" + whitespace + "+$", "g" ),
  788. 	
  789. 		rcomma = new RegExp( "^" + whitespace + "*," + whitespace + "*" ),
  790. 		rcombinators = new RegExp( "^" + whitespace + "*([>+~]|" + whitespace + ")" + whitespace + "*" ),
  791. 	
  792. 		rattributeQuotes = new RegExp( "=" + whitespace + "*([^\\]'\"]*?)" + whitespace + "*\\]", "g" ),
  793. 	
  794. 		rpseudo = new RegExp( pseudos ),
  795. 		ridentifier = new RegExp( "^" + identifier + "$" ),
  796. 	
  797. 		matchExpr = {
  798. 			"ID": new RegExp( "^#(" + characterEncoding + ")" ),
  799. 			"CLASS": new RegExp( "^\\.(" + characterEncoding + ")" ),
  800. 			"TAG": new RegExp( "^(" + characterEncoding.replace( "w", "w*" ) + ")" ),
  801. 			"ATTR": new RegExp( "^" + attributes ),
  802. 			"PSEUDO": new RegExp( "^" + pseudos ),
  803. 			"CHILD": new RegExp( "^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(" + whitespace +
  804. 				"*(even|odd|(([+-]|)(\\d*)n|)" + whitespace + "*(?:([+-]|)" + whitespace +
  805. 				"*(\\d+)|))" + whitespace + "*\\)|)", "i" ),
  806. 			"bool": new RegExp( "^(?:" + booleans + ")$", "i" ),
  807. 			// For use in libraries implementing .is()
  808. 			// We use this for POS matching in `select`
  809. 			"needsContext": new RegExp( "^" + whitespace + "*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(" +
  810. 				whitespace + "*((?:-\\d)?\\d*)" + whitespace + "*\\)|)(?=[^-]|$)", "i" )
  811. 		},
  812. 	
  813. 		rinputs = /^(?:input|select|textarea|button)$/i,
  814. 		rheader = /^h\d$/i,
  815. 	
  816. 		rnative = /^[^{]+\{\s*\[native \w/,
  817. 	
  818. 		// Easily-parseable/retrievable ID or TAG or CLASS selectors
  819. 		rquickExpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,
  820. 	
  821. 		rsibling = /[+~]/,
  822. 		rescape = /'|\\/g,
  823. 	
  824. 		// CSS escapes http://www.w3.org/TR/CSS21/syndata.html#escaped-characters
  825. 		runescape = new RegExp( "\\\\([\\da-f]{1,6}" + whitespace + "?|(" + whitespace + ")|.)", "ig" ),
  826. 		funescape = function( _, escaped, escapedWhitespace ) {
  827. 			var high = "0x" + escaped - 0x10000;
  828. 			// NaN means non-codepoint
  829. 			// Support: Firefox<24
  830. 			// Workaround erroneous numeric interpretation of +"0x"
  831. 			return high !== high || escapedWhitespace ?
  832. 				escaped :
  833. 				high < 0 ?
  834. 					// BMP codepoint
  835. 					String.fromCharCode( high + 0x10000 ) :
  836. 					// Supplemental Plane codepoint (surrogate pair)
  837. 					String.fromCharCode( high >> 10 | 0xD800, high & 0x3FF | 0xDC00 );
  838. 		},
  839. 	
  840. 		// Used for iframes
  841. 		// See setDocument()
  842. 		// Removing the function wrapper causes a "Permission Denied"
  843. 		// error in IE
  844. 		unloadHandler = function() {
  845. 			setDocument();
  846. 		};
  847. 	
  848. 	// Optimize for push.apply( _, NodeList )
  849. 	try {
  850. 		push.apply(
  851. 			(arr = slice.call( preferredDoc.childNodes )),
  852. 			preferredDoc.childNodes
  853. 		);
  854. 		// Support: Android<4.0
  855. 		// Detect silently failing push.apply
  856. 		arr[ preferredDoc.childNodes.length ].nodeType;
  857. 	} catch ( e ) {
  858. 		push = { apply: arr.length ?
  859. 	
  860. 			// Leverage slice if possible
  861. 			function( target, els ) {
  862. 				push_native.apply( target, slice.call(els) );
  863. 			} :
  864. 	
  865. 			// Support: IE<9
  866. 			// Otherwise append directly
  867. 			function( target, els ) {
  868. 				var j = target.length,
  869. 					i = 0;
  870. 				// Can't trust NodeList.length
  871. 				while ( (target[j++] = els[i++]) ) {}
  872. 				target.length = j - 1;
  873. 			}
  874. 		};
  875. 	}
  876. 	
  877. 	function Sizzle( selector, context, results, seed ) {
  878. 		var match, elem, m, nodeType,
  879. 			// QSA vars
  880. 			i, groups, old, nid, newContext, newSelector;
  881. 	
  882. 		if ( ( context ? context.ownerDocument || context : preferredDoc ) !== document ) {
  883. 			setDocument( context );
  884. 		}
  885. 	
  886. 		context = context || document;
  887. 		results = results || [];
  888. 		nodeType = context.nodeType;
  889. 	
  890. 		if ( typeof selector !== "string" || !selector ||
  891. 			nodeType !== 1 && nodeType !== 9 && nodeType !== 11 ) {
  892. 	
  893. 			return results;
  894. 		}
  895. 	
  896. 		if ( !seed && documentIsHTML ) {
  897. 	
  898. 			// Try to shortcut find operations when possible (e.g., not under DocumentFragment)
  899. 			if ( nodeType !== 11 && (match = rquickExpr.exec( selector )) ) {
  900. 				// Speed-up: Sizzle("#ID")
  901. 				if ( (m = match[1]) ) {
  902. 					if ( nodeType === 9 ) {
  903. 						elem = context.getElementById( m );
  904. 						// Check parentNode to catch when Blackberry 4.6 returns
  905. 						// nodes that are no longer in the document (jQuery #6963)
  906. 						if ( elem && elem.parentNode ) {
  907. 							// Handle the case where IE, Opera, and Webkit return items
  908. 							// by name instead of ID
  909. 							if ( elem.id === m ) {
  910. 								results.push( elem );
  911. 								return results;
  912. 							}
  913. 						} else {
  914. 							return results;
  915. 						}
  916. 					} else {
  917. 						// Context is not a document
  918. 						if ( context.ownerDocument && (elem = context.ownerDocument.getElementById( m )) &&
  919. 							contains( context, elem ) && elem.id === m ) {
  920. 							results.push( elem );
  921. 							return results;
  922. 						}
  923. 					}
  924. 	
  925. 				// Speed-up: Sizzle("TAG")
  926. 				} else if ( match[2] ) {
  927. 					push.apply( results, context.getElementsByTagName( selector ) );
  928. 					return results;
  929. 	
  930. 				// Speed-up: Sizzle(".CLASS")
  931. 				} else if ( (m = match[3]) && support.getElementsByClassName ) {
  932. 					push.apply( results, context.getElementsByClassName( m ) );
  933. 					return results;
  934. 				}
  935. 			}
  936. 	
  937. 			// QSA path
  938. 			if ( support.qsa && (!rbuggyQSA || !rbuggyQSA.test( selector )) ) {
  939. 				nid = old = expando;
  940. 				newContext = context;
  941. 				newSelector = nodeType !== 1 && selector;
  942. 	
  943. 				// qSA works strangely on Element-rooted queries
  944. 				// We can work around this by specifying an extra ID on the root
  945. 				// and working up from there (Thanks to Andrew Dupont for the technique)
  946. 				// IE 8 doesn't work on object elements
  947. 				if ( nodeType === 1 && context.nodeName.toLowerCase() !== "object" ) {
  948. 					groups = tokenize( selector );
  949. 	
  950. 					if ( (old = context.getAttribute("id")) ) {
  951. 						nid = old.replace( rescape, "\\$&" );
  952. 					} else {
  953. 						context.setAttribute( "id", nid );
  954. 					}
  955. 					nid = "[id='" + nid + "'] ";
  956. 	
  957. 					i = groups.length;
  958. 					while ( i-- ) {
  959. 						groups[i] = nid + toSelector( groups[i] );
  960. 					}
  961. 					newContext = rsibling.test( selector ) && testContext( context.parentNode ) || context;
  962. 					newSelector = groups.join(",");
  963. 				}
  964. 	
  965. 				if ( newSelector ) {
  966. 					try {
  967. 						push.apply( results,
  968. 							newContext.querySelectorAll( newSelector )
  969. 						);
  970. 						return results;
  971. 					} catch(qsaError) {
  972. 					} finally {
  973. 						if ( !old ) {
  974. 							context.removeAttribute("id");
  975. 						}
  976. 					}
  977. 				}
  978. 			}
  979. 		}
  980. 	
  981. 		// All others
  982. 		return select( selector.replace( rtrim, "$1" ), context, results, seed );
  983. 	}
  984. 	
  985. 	/**
  986. 	 * Create key-value caches of limited size
  987. 	 * @returns {Function(string, Object)} Returns the Object data after storing it on itself with
  988. 	 *	property name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength)
  989. 	 *	deleting the oldest entry
  990. 	 */
  991. 	function createCache() {
  992. 		var keys = [];
  993. 	
  994. 		function cache( key, value ) {
  995. 			// Use (key + " ") to avoid collision with native prototype properties (see Issue #157)
  996. 			if ( keys.push( key + " " ) > Expr.cacheLength ) {
  997. 				// Only keep the most recent entries
  998. 				delete cache[ keys.shift() ];
  999. 			}
  1000. 			return (cache[ key + " " ] = value);
  1001. 		}
  1002. 		return cache;
  1003. 	}
  1004. 	
  1005. 	/**
  1006. 	 * Mark a function for special use by Sizzle
  1007. 	 * @param {Function} fn The function to mark
  1008. 	 */
  1009. 	function markFunction( fn ) {
  1010. 		fn[ expando ] = true;
  1011. 		return fn;
  1012. 	}
  1013. 	
  1014. 	/**
  1015. 	 * Support testing using an element
  1016. 	 * @param {Function} fn Passed the created div and expects a boolean result
  1017. 	 */
  1018. 	function assert( fn ) {
  1019. 		var div = document.createElement("div");
  1020. 	
  1021. 		try {
  1022. 			return !!fn( div );
  1023. 		} catch (e) {
  1024. 			return false;
  1025. 		} finally {
  1026. 			// Remove from its parent by default
  1027. 			if ( div.parentNode ) {
  1028. 				div.parentNode.removeChild( div );
  1029. 			}
  1030. 			// release memory in IE
  1031. 			div = null;
  1032. 		}
  1033. 	}
  1034. 	
  1035. 	/**
  1036. 	 * Adds the same handler for all of the specified attrs
  1037. 	 * @param {String} attrs Pipe-separated list of attributes
  1038. 	 * @param {Function} handler The method that will be applied
  1039. 	 */
  1040. 	function addHandle( attrs, handler ) {
  1041. 		var arr = attrs.split("|"),
  1042. 			i = attrs.length;
  1043. 	
  1044. 		while ( i-- ) {
  1045. 			Expr.attrHandle[ arr[i] ] = handler;
  1046. 		}
  1047. 	}
  1048. 	
  1049. 	/**
  1050. 	 * Checks document order of two siblings
  1051. 	 * @param {Element} a
  1052. 	 * @param {Element} b
  1053. 	 * @returns {Number} Returns less than 0 if a precedes b, greater than 0 if a follows b
  1054. 	 */
  1055. 	function siblingCheck( a, b ) {
  1056. 		var cur = b && a,
  1057. 			diff = cur && a.nodeType === 1 && b.nodeType === 1 &&
  1058. 				( ~b.sourceIndex || MAX_NEGATIVE ) -
  1059. 				( ~a.sourceIndex || MAX_NEGATIVE );
  1060. 	
  1061. 		// Use IE sourceIndex if available on both nodes
  1062. 		if ( diff ) {
  1063. 			return diff;
  1064. 		}
  1065. 	
  1066. 		// Check if b follows a
  1067. 		if ( cur ) {
  1068. 			while ( (cur = cur.nextSibling) ) {
  1069. 				if ( cur === b ) {
  1070. 					return -1;
  1071. 				}
  1072. 			}
  1073. 		}
  1074. 	
  1075. 		return a ? 1 : -1;
  1076. 	}
  1077. 	
  1078. 	/**
  1079. 	 * Returns a function to use in pseudos for input types
  1080. 	 * @param {String} type
  1081. 	 */
  1082. 	function createInputPseudo( type ) {
  1083. 		return function( elem ) {
  1084. 			var name = elem.nodeName.toLowerCase();
  1085. 			return name === "input" && elem.type === type;
  1086. 		};
  1087. 	}
  1088. 	
  1089. 	/**
  1090. 	 * Returns a function to use in pseudos for buttons
  1091. 	 * @param {String} type
  1092. 	 */
  1093. 	function createButtonPseudo( type ) {
  1094. 		return function( elem ) {
  1095. 			var name = elem.nodeName.toLowerCase();
  1096. 			return (name === "input" || name === "button") && elem.type === type;
  1097. 		};
  1098. 	}
  1099. 	
  1100. 	/**
  1101. 	 * Returns a function to use in pseudos for positionals
  1102. 	 * @param {Function} fn
  1103. 	 */
  1104. 	function createPositionalPseudo( fn ) {
  1105. 		return markFunction(function( argument ) {
  1106. 			argument = +argument;
  1107. 			return markFunction(function( seed, matches ) {
  1108. 				var j,
  1109. 					matchIndexes = fn( [], seed.length, argument ),
  1110. 					i = matchIndexes.length;
  1111. 	
  1112. 				// Match elements found at the specified indexes
  1113. 				while ( i-- ) {
  1114. 					if ( seed[ (j = matchIndexes[i]) ] ) {
  1115. 						seed[j] = !(matches[j] = seed[j]);
  1116. 					}
  1117. 				}
  1118. 			});
  1119. 		});
  1120. 	}
  1121. 	
  1122. 	/**
  1123. 	 * Checks a node for validity as a Sizzle context
  1124. 	 * @param {Element|Object=} context
  1125. 	 * @returns {Element|Object|Boolean} The input node if acceptable, otherwise a falsy value
  1126. 	 */
  1127. 	function testContext( context ) {
  1128. 		return context && typeof context.getElementsByTagName !== "undefined" && context;
  1129. 	}
  1130. 	
  1131. 	// Expose support vars for convenience
  1132. 	support = Sizzle.support = {};
  1133. 	
  1134. 	/**
  1135. 	 * Detects XML nodes
  1136. 	 * @param {Element|Object} elem An element or a document
  1137. 	 * @returns {Boolean} True iff elem is a non-HTML XML node
  1138. 	 */
  1139. 	isXML = Sizzle.isXML = function( elem ) {
  1140. 		// documentElement is verified for cases where it doesn't yet exist
  1141. 		// (such as loading iframes in IE - #4833)
  1142. 		var documentElement = elem && (elem.ownerDocument || elem).documentElement;
  1143. 		return documentElement ? documentElement.nodeName !== "HTML" : false;
  1144. 	};
  1145. 	
  1146. 	/**
  1147. 	 * Sets document-related variables once based on the current document
  1148. 	 * @param {Element|Object} [doc] An element or document object to use to set the document
  1149. 	 * @returns {Object} Returns the current document
  1150. 	 */
  1151. 	setDocument = Sizzle.setDocument = function( node ) {
  1152. 		var hasCompare, parent,
  1153. 			doc = node ? node.ownerDocument || node : preferredDoc;
  1154. 	
  1155. 		// If no document and documentElement is available, return
  1156. 		if ( doc === document || doc.nodeType !== 9 || !doc.documentElement ) {
  1157. 			return document;
  1158. 		}
  1159. 	
  1160. 		// Set our document
  1161. 		document = doc;
  1162. 		docElem = doc.documentElement;
  1163. 		parent = doc.defaultView;
  1164. 	
  1165. 		// Support: IE>8
  1166. 		// If iframe document is assigned to "document" variable and if iframe has been reloaded,
  1167. 		// IE will throw "permission denied" error when accessing "document" variable, see jQuery #13936
  1168. 		// IE6-8 do not support the defaultView property so parent will be undefined
  1169. 		if ( parent && parent !== parent.top ) {
  1170. 			// IE11 does not have attachEvent, so all must suffer
  1171. 			if ( parent.addEventListener ) {
  1172. 				parent.addEventListener( "unload", unloadHandler, false );
  1173. 			} else if ( parent.attachEvent ) {
  1174. 				parent.attachEvent( "onunload", unloadHandler );
  1175. 			}
  1176. 		}
  1177. 	
  1178. 		/* Support tests
  1179. 		---------------------------------------------------------------------- */
  1180. 		documentIsHTML = !isXML( doc );
  1181. 	
  1182. 		/* Attributes
  1183. 		---------------------------------------------------------------------- */
  1184. 	
  1185. 		// Support: IE<8
  1186. 		// Verify that getAttribute really returns attributes and not properties
  1187. 		// (excepting IE8 booleans)
  1188. 		support.attributes = assert(function( div ) {
  1189. 			div.className = "i";
  1190. 			return !div.getAttribute("className");
  1191. 		});
  1192. 	
  1193. 		/* getElement(s)By*
  1194. 		---------------------------------------------------------------------- */
  1195. 	
  1196. 		// Check if getElementsByTagName("*") returns only elements
  1197. 		support.getElementsByTagName = assert(function( div ) {
  1198. 			div.appendChild( doc.createComment("") );
  1199. 			return !div.getElementsByTagName("*").length;
  1200. 		});
  1201. 	
  1202. 		// Support: IE<9
  1203. 		support.getElementsByClassName = rnative.test( doc.getElementsByClassName );
  1204. 	
  1205. 		// Support: IE<10
  1206. 		// Check if getElementById returns elements by name
  1207. 		// The broken getElementById methods don't pick up programatically-set names,
  1208. 		// so use a roundabout getElementsByName test
  1209. 		support.getById = assert(function( div ) {
  1210. 			docElem.appendChild( div ).id = expando;
  1211. 			return !doc.getElementsByName || !doc.getElementsByName( expando ).length;
  1212. 		});
  1213. 	
  1214. 		// ID find and filter
  1215. 		if ( support.getById ) {
  1216. 			Expr.find["ID"] = function( id, context ) {
  1217. 				if ( typeof context.getElementById !== "undefined" && documentIsHTML ) {
  1218. 					var m = context.getElementById( id );
  1219. 					// Check parentNode to catch when Blackberry 4.6 returns
  1220. 					// nodes that are no longer in the document #6963
  1221. 					return m && m.parentNode ? [ m ] : [];
  1222. 				}
  1223. 			};
  1224. 			Expr.filter["ID"] = function( id ) {
  1225. 				var attrId = id.replace( runescape, funescape );
  1226. 				return function( elem ) {
  1227. 					return elem.getAttribute("id") === attrId;
  1228. 				};
  1229. 			};
  1230. 		} else {
  1231. 			// Support: IE6/7
  1232. 			// getElementById is not reliable as a find shortcut
  1233. 			delete Expr.find["ID"];
  1234. 	
  1235. 			Expr.filter["ID"] =  function( id ) {
  1236. 				var attrId = id.replace( runescape, funescape );
  1237. 				return function( elem ) {
  1238. 					var node = typeof elem.getAttributeNode !== "undefined" && elem.getAttributeNode("id");
  1239. 					return node && node.value === attrId;
  1240. 				};
  1241. 			};
  1242. 		}
  1243. 	
  1244. 		// Tag
  1245. 		Expr.find["TAG"] = support.getElementsByTagName ?
  1246. 			function( tag, context ) {
  1247. 				if ( typeof context.getElementsByTagName !== "undefined" ) {
  1248. 					return context.getElementsByTagName( tag );
  1249. 	
  1250. 				// DocumentFragment nodes don't have gEBTN
  1251. 				} else if ( support.qsa ) {
  1252. 					return context.querySelectorAll( tag );
  1253. 				}
  1254. 			} :
  1255. 	
  1256. 			function( tag, context ) {
  1257. 				var elem,
  1258. 					tmp = [],
  1259. 					i = 0,
  1260. 					// By happy coincidence, a (broken) gEBTN appears on DocumentFragment nodes too
  1261. 					results = context.getElementsByTagName( tag );
  1262. 	
  1263. 				// Filter out possible comments
  1264. 				if ( tag === "*" ) {
  1265. 					while ( (elem = results[i++]) ) {
  1266. 						if ( elem.nodeType === 1 ) {
  1267. 							tmp.push( elem );
  1268. 						}
  1269. 					}
  1270. 	
  1271. 					return tmp;
  1272. 				}
  1273. 				return results;
  1274. 			};
  1275. 	
  1276. 		// Class
  1277. 		Expr.find["CLASS"] = support.getElementsByClassName && function( className, context ) {
  1278. 			if ( documentIsHTML ) {
  1279. 				return context.getElementsByClassName( className );
  1280. 			}
  1281. 		};
  1282. 	
  1283. 		/* QSA/matchesSelector
  1284. 		---------------------------------------------------------------------- */
  1285. 	
  1286. 		// QSA and matchesSelector support
  1287. 	
  1288. 		// matchesSelector(:active) reports false when true (IE9/Opera 11.5)
  1289. 		rbuggyMatches = [];
  1290. 	
  1291. 		// qSa(:focus) reports false when true (Chrome 21)
  1292. 		// We allow this because of a bug in IE8/9 that throws an error
  1293. 		// whenever `document.activeElement` is accessed on an iframe
  1294. 		// So, we allow :focus to pass through QSA all the time to avoid the IE error
  1295. 		// See http://bugs.jquery.com/ticket/13378
  1296. 		rbuggyQSA = [];
  1297. 	
  1298. 		if ( (support.qsa = rnative.test( doc.querySelectorAll )) ) {
  1299. 			// Build QSA regex
  1300. 			// Regex strategy adopted from Diego Perini
  1301. 			assert(function( div ) {
  1302. 				// Select is set to empty string on purpose
  1303. 				// This is to test IE's treatment of not explicitly
  1304. 				// setting a boolean content attribute,
  1305. 				// since its presence should be enough
  1306. 				// http://bugs.jquery.com/ticket/12359
  1307. 				docElem.appendChild( div ).innerHTML = "<a id='" + expando + "'></a>" +
  1308. 					"<select id='" + expando + "-\f]' msallowcapture=''>" +
  1309. 					"<option selected=''></option></select>";
  1310. 	
  1311. 				// Support: IE8, Opera 11-12.16
  1312. 				// Nothing should be selected when empty strings follow ^= or $= or *=
  1313. 				// The test attribute must be unknown in Opera but "safe" for WinRT
  1314. 				// http://msdn.microsoft.com/en-us/library/ie/hh465388.aspx#attribute_section
  1315. 				if ( div.querySelectorAll("[msallowcapture^='']").length ) {
  1316. 					rbuggyQSA.push( "[*^$]=" + whitespace + "*(?:''|\"\")" );
  1317. 				}
  1318. 	
  1319. 				// Support: IE8
  1320. 				// Boolean attributes and "value" are not treated correctly
  1321. 				if ( !div.querySelectorAll("[selected]").length ) {
  1322. 					rbuggyQSA.push( "\\[" + whitespace + "*(?:value|" + booleans + ")" );
  1323. 				}
  1324. 	
  1325. 				// Support: Chrome<29, Android<4.2+, Safari<7.0+, iOS<7.0+, PhantomJS<1.9.7+
  1326. 				if ( !div.querySelectorAll( "[id~=" + expando + "-]" ).length ) {
  1327. 					rbuggyQSA.push("~=");
  1328. 				}
  1329. 	
  1330. 				// Webkit/Opera - :checked should return selected option elements
  1331. 				// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
  1332. 				// IE8 throws error here and will not see later tests
  1333. 				if ( !div.querySelectorAll(":checked").length ) {
  1334. 					rbuggyQSA.push(":checked");
  1335. 				}
  1336. 	
  1337. 				// Support: Safari 8+, iOS 8+
  1338. 				// https://bugs.webkit.org/show_bug.cgi?id=136851
  1339. 				// In-page `selector#id sibing-combinator selector` fails
  1340. 				if ( !div.querySelectorAll( "a#" + expando + "+*" ).length ) {
  1341. 					rbuggyQSA.push(".#.+[+~]");
  1342. 				}
  1343. 			});
  1344. 	
  1345. 			assert(function( div ) {
  1346. 				// Support: Windows 8 Native Apps
  1347. 				// The type and name attributes are restricted during .innerHTML assignment
  1348. 				var input = doc.createElement("input");
  1349. 				input.setAttribute( "type", "hidden" );
  1350. 				div.appendChild( input ).setAttribute( "name", "D" );
  1351. 	
  1352. 				// Support: IE8
  1353. 				// Enforce case-sensitivity of name attribute
  1354. 				if ( div.querySelectorAll("[name=d]").length ) {
  1355. 					rbuggyQSA.push( "name" + whitespace + "*[*^$|!~]?=" );
  1356. 				}
  1357. 	
  1358. 				// FF 3.5 - :enabled/:disabled and hidden elements (hidden elements are still enabled)
  1359. 				// IE8 throws error here and will not see later tests
  1360. 				if ( !div.querySelectorAll(":enabled").length ) {
  1361. 					rbuggyQSA.push( ":enabled", ":disabled" );
  1362. 				}
  1363. 	
  1364. 				// Opera 10-11 does not throw on post-comma invalid pseudos
  1365. 				div.querySelectorAll("*,:x");
  1366. 				rbuggyQSA.push(",.*:");
  1367. 			});
  1368. 		}
  1369. 	
  1370. 		if ( (support.matchesSelector = rnative.test( (matches = docElem.matches ||
  1371. 			docElem.webkitMatchesSelector ||
  1372. 			docElem.mozMatchesSelector ||
  1373. 			docElem.oMatchesSelector ||
  1374. 			docElem.msMatchesSelector) )) ) {
  1375. 	
  1376. 			assert(function( div ) {
  1377. 				// Check to see if it's possible to do matchesSelector
  1378. 				// on a disconnected node (IE 9)
  1379. 				support.disconnectedMatch = matches.call( div, "div" );
  1380. 	
  1381. 				// This should fail with an exception
  1382. 				// Gecko does not error, returns false instead
  1383. 				matches.call( div, "[s!='']:x" );
  1384. 				rbuggyMatches.push( "!=", pseudos );
  1385. 			});
  1386. 		}
  1387. 	
  1388. 		rbuggyQSA = rbuggyQSA.length && new RegExp( rbuggyQSA.join("|") );
  1389. 		rbuggyMatches = rbuggyMatches.length && new RegExp( rbuggyMatches.join("|") );
  1390. 	
  1391. 		/* Contains
  1392. 		---------------------------------------------------------------------- */
  1393. 		hasCompare = rnative.test( docElem.compareDocumentPosition );
  1394. 	
  1395. 		// Element contains another
  1396. 		// Purposefully does not implement inclusive descendent
  1397. 		// As in, an element does not contain itself
  1398. 		contains = hasCompare || rnative.test( docElem.contains ) ?
  1399. 			function( a, b ) {
  1400. 				var adown = a.nodeType === 9 ? a.documentElement : a,
  1401. 					bup = b && b.parentNode;
  1402. 				return a === bup || !!( bup && bup.nodeType === 1 && (
  1403. 					adown.contains ?
  1404. 						adown.contains( bup ) :
  1405. 						a.compareDocumentPosition && a.compareDocumentPosition( bup ) & 16
  1406. 				));
  1407. 			} :
  1408. 			function( a, b ) {
  1409. 				if ( b ) {
  1410. 					while ( (b = b.parentNode) ) {
  1411. 						if ( b === a ) {
  1412. 							return true;
  1413. 						}
  1414. 					}
  1415. 				}
  1416. 				return false;
  1417. 			};
  1418. 	
  1419. 		/* Sorting
  1420. 		---------------------------------------------------------------------- */
  1421. 	
  1422. 		// Document order sorting
  1423. 		sortOrder = hasCompare ?
  1424. 		function( a, b ) {
  1425. 	
  1426. 			// Flag for duplicate removal
  1427. 			if ( a === b ) {
  1428. 				hasDuplicate = true;
  1429. 				return 0;
  1430. 			}
  1431. 	
  1432. 			// Sort on method existence if only one input has compareDocumentPosition
  1433. 			var compare = !a.compareDocumentPosition - !b.compareDocumentPosition;
  1434. 			if ( compare ) {
  1435. 				return compare;
  1436. 			}
  1437. 	
  1438. 			// Calculate position if both inputs belong to the same document
  1439. 			compare = ( a.ownerDocument || a ) === ( b.ownerDocument || b ) ?
  1440. 				a.compareDocumentPosition( b ) :
  1441. 	
  1442. 				// Otherwise we know they are disconnected
  1443. 				1;
  1444. 	
  1445. 			// Disconnected nodes
  1446. 			if ( compare & 1 ||
  1447. 				(!support.sortDetached && b.compareDocumentPosition( a ) === compare) ) {
  1448. 	
  1449. 				// Choose the first element that is related to our preferred document
  1450. 				if ( a === doc || a.ownerDocument === preferredDoc && contains(preferredDoc, a) ) {
  1451. 					return -1;
  1452. 				}
  1453. 				if ( b === doc || b.ownerDocument === preferredDoc && contains(preferredDoc, b) ) {
  1454. 					return 1;
  1455. 				}
  1456. 	
  1457. 				// Maintain original order
  1458. 				return sortInput ?
  1459. 					( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) :
  1460. 					0;
  1461. 			}
  1462. 	
  1463. 			return compare & 4 ? -1 : 1;
  1464. 		} :
  1465. 		function( a, b ) {
  1466. 			// Exit early if the nodes are identical
  1467. 			if ( a === b ) {
  1468. 				hasDuplicate = true;
  1469. 				return 0;
  1470. 			}
  1471. 	
  1472. 			var cur,
  1473. 				i = 0,
  1474. 				aup = a.parentNode,
  1475. 				bup = b.parentNode,
  1476. 				ap = [ a ],
  1477. 				bp = [ b ];
  1478. 	
  1479. 			// Parentless nodes are either documents or disconnected
  1480. 			if ( !aup || !bup ) {
  1481. 				return a === doc ? -1 :
  1482. 					b === doc ? 1 :
  1483. 					aup ? -1 :
  1484. 					bup ? 1 :
  1485. 					sortInput ?
  1486. 					( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) :
  1487. 					0;
  1488. 	
  1489. 			// If the nodes are siblings, we can do a quick check
  1490. 			} else if ( aup === bup ) {
  1491. 				return siblingCheck( a, b );
  1492. 			}
  1493. 	
  1494. 			// Otherwise we need full lists of their ancestors for comparison
  1495. 			cur = a;
  1496. 			while ( (cur = cur.parentNode) ) {
  1497. 				ap.unshift( cur );
  1498. 			}
  1499. 			cur = b;
  1500. 			while ( (cur = cur.parentNode) ) {
  1501. 				bp.unshift( cur );
  1502. 			}
  1503. 	
  1504. 			// Walk down the tree looking for a discrepancy
  1505. 			while ( ap[i] === bp[i] ) {
  1506. 				i++;
  1507. 			}
  1508. 	
  1509. 			return i ?
  1510. 				// Do a sibling check if the nodes have a common ancestor
  1511. 				siblingCheck( ap[i], bp[i] ) :
  1512. 	
  1513. 				// Otherwise nodes in our document sort first
  1514. 				ap[i] === preferredDoc ? -1 :
  1515. 				bp[i] === preferredDoc ? 1 :
  1516. 				0;
  1517. 		};
  1518. 	
  1519. 		return doc;
  1520. 	};
  1521. 	
  1522. 	Sizzle.matches = function( expr, elements ) {
  1523. 		return Sizzle( expr, null, null, elements );
  1524. 	};
  1525. 	
  1526. 	Sizzle.matchesSelector = function( elem, expr ) {
  1527. 		// Set document vars if needed
  1528. 		if ( ( elem.ownerDocument || elem ) !== document ) {
  1529. 			setDocument( elem );
  1530. 		}
  1531. 	
  1532. 		// Make sure that attribute selectors are quoted
  1533. 		expr = expr.replace( rattributeQuotes, "='$1']" );
  1534. 	
  1535. 		if ( support.matchesSelector && documentIsHTML &&
  1536. 			( !rbuggyMatches || !rbuggyMatches.test( expr ) ) &&
  1537. 			( !rbuggyQSA     || !rbuggyQSA.test( expr ) ) ) {
  1538. 	
  1539. 			try {
  1540. 				var ret = matches.call( elem, expr );
  1541. 	
  1542. 				// IE 9's matchesSelector returns false on disconnected nodes
  1543. 				if ( ret || support.disconnectedMatch ||
  1544. 						// As well, disconnected nodes are said to be in a document
  1545. 						// fragment in IE 9
  1546. 						elem.document && elem.document.nodeType !== 11 ) {
  1547. 					return ret;
  1548. 				}
  1549. 			} catch (e) {}
  1550. 		}
  1551. 	
  1552. 		return Sizzle( expr, document, null, [ elem ] ).length > 0;
  1553. 	};
  1554. 	
  1555. 	Sizzle.contains = function( context, elem ) {
  1556. 		// Set document vars if needed
  1557. 		if ( ( context.ownerDocument || context ) !== document ) {
  1558. 			setDocument( context );
  1559. 		}
  1560. 		return contains( context, elem );
  1561. 	};
  1562. 	
  1563. 	Sizzle.attr = function( elem, name ) {
  1564. 		// Set document vars if needed
  1565. 		if ( ( elem.ownerDocument || elem ) !== document ) {
  1566. 			setDocument( elem );
  1567. 		}
  1568. 	
  1569. 		var fn = Expr.attrHandle[ name.toLowerCase() ],
  1570. 			// Don't get fooled by Object.prototype properties (jQuery #13807)
  1571. 			val = fn && hasOwn.call( Expr.attrHandle, name.toLowerCase() ) ?
  1572. 				fn( elem, name, !documentIsHTML ) :
  1573. 				undefined;
  1574. 	
  1575. 		return val !== undefined ?
  1576. 			val :
  1577. 			support.attributes || !documentIsHTML ?
  1578. 				elem.getAttribute( name ) :
  1579. 				(val = elem.getAttributeNode(name)) && val.specified ?
  1580. 					val.value :
  1581. 					null;
  1582. 	};
  1583. 	
  1584. 	Sizzle.error = function( msg ) {
  1585. 		throw new Error( "Syntax error, unrecognized expression: " + msg );
  1586. 	};
  1587. 	
  1588. 	/**
  1589. 	 * Document sorting and removing duplicates
  1590. 	 * @param {ArrayLike} results
  1591. 	 */
  1592. 	Sizzle.uniqueSort = function( results ) {
  1593. 		var elem,
  1594. 			duplicates = [],
  1595. 			j = 0,
  1596. 			i = 0;
  1597. 	
  1598. 		// Unless we *know* we can detect duplicates, assume their presence
  1599. 		hasDuplicate = !support.detectDuplicates;
  1600. 		sortInput = !support.sortStable && results.slice( 0 );
  1601. 		results.sort( sortOrder );
  1602. 	
  1603. 		if ( hasDuplicate ) {
  1604. 			while ( (elem = results[i++]) ) {
  1605. 				if ( elem === results[ i ] ) {
  1606. 					j = duplicates.push( i );
  1607. 				}
  1608. 			}
  1609. 			while ( j-- ) {
  1610. 				results.splice( duplicates[ j ], 1 );
  1611. 			}
  1612. 		}
  1613. 	
  1614. 		// Clear input after sorting to release objects
  1615. 		// See https://github.com/jquery/sizzle/pull/225
  1616. 		sortInput = null;
  1617. 	
  1618. 		return results;
  1619. 	};
  1620. 	
  1621. 	/**
  1622. 	 * Utility function for retrieving the text value of an array of DOM nodes
  1623. 	 * @param {Array|Element} elem
  1624. 	 */
  1625. 	getText = Sizzle.getText = function( elem ) {
  1626. 		var node,
  1627. 			ret = "",
  1628. 			i = 0,
  1629. 			nodeType = elem.nodeType;
  1630. 	
  1631. 		if ( !nodeType ) {
  1632. 			// If no nodeType, this is expected to be an array
  1633. 			while ( (node = elem[i++]) ) {
  1634. 				// Do not traverse comment nodes
  1635. 				ret += getText( node );
  1636. 			}
  1637. 		} else if ( nodeType === 1 || nodeType === 9 || nodeType === 11 ) {
  1638. 			// Use textContent for elements
  1639. 			// innerText usage removed for consistency of new lines (jQuery #11153)
  1640. 			if ( typeof elem.textContent === "string" ) {
  1641. 				return elem.textContent;
  1642. 			} else {
  1643. 				// Traverse its children
  1644. 				for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
  1645. 					ret += getText( elem );
  1646. 				}
  1647. 			}
  1648. 		} else if ( nodeType === 3 || nodeType === 4 ) {
  1649. 			return elem.nodeValue;
  1650. 		}
  1651. 		// Do not include comment or processing instruction nodes
  1652. 	
  1653. 		return ret;
  1654. 	};
  1655. 	
  1656. 	Expr = Sizzle.selectors = {
  1657. 	
  1658. 		// Can be adjusted by the user
  1659. 		cacheLength: 50,
  1660. 	
  1661. 		createPseudo: markFunction,
  1662. 	
  1663. 		match: matchExpr,
  1664. 	
  1665. 		attrHandle: {},
  1666. 	
  1667. 		find: {},
  1668. 	
  1669. 		relative: {
  1670. 			">": { dir: "parentNode", first: true },
  1671. 			" ": { dir: "parentNode" },
  1672. 			"+": { dir: "previousSibling", first: true },
  1673. 			"~": { dir: "previousSibling" }
  1674. 		},
  1675. 	
  1676. 		preFilter: {
  1677. 			"ATTR": function( match ) {
  1678. 				match[1] = match[1].replace( runescape, funescape );
  1679. 	
  1680. 				// Move the given value to match[3] whether quoted or unquoted
  1681. 				match[3] = ( match[3] || match[4] || match[5] || "" ).replace( runescape, funescape );
  1682. 	
  1683. 				if ( match[2] === "~=" ) {
  1684. 					match[3] = " " + match[3] + " ";
  1685. 				}
  1686. 	
  1687. 				return match.slice( 0, 4 );
  1688. 			},
  1689. 	
  1690. 			"CHILD": function( match ) {
  1691. 				/* matches from matchExpr["CHILD"]
  1692. 					1 type (only|nth|...)
  1693. 					2 what (child|of-type)
  1694. 					3 argument (even|odd|\d*|\d*n([+-]\d+)?|...)
  1695. 					4 xn-component of xn+y argument ([+-]?\d*n|)
  1696. 					5 sign of xn-component
  1697. 					6 x of xn-component
  1698. 					7 sign of y-component
  1699. 					8 y of y-component
  1700. 				*/
  1701. 				match[1] = match[1].toLowerCase();
  1702. 	
  1703. 				if ( match[1].slice( 0, 3 ) === "nth" ) {
  1704. 					// nth-* requires argument
  1705. 					if ( !match[3] ) {
  1706. 						Sizzle.error( match[0] );
  1707. 					}
  1708. 	
  1709. 					// numeric x and y parameters for Expr.filter.CHILD
  1710. 					// remember that false/true cast respectively to 0/1
  1711. 					match[4] = +( match[4] ? match[5] + (match[6] || 1) : 2 * ( match[3] === "even" || match[3] === "odd" ) );
  1712. 					match[5] = +( ( match[7] + match[8] ) || match[3] === "odd" );
  1713. 	
  1714. 				// other types prohibit arguments
  1715. 				} else if ( match[3] ) {
  1716. 					Sizzle.error( match[0] );
  1717. 				}
  1718. 	
  1719. 				return match;
  1720. 			},
  1721. 	
  1722. 			"PSEUDO": function( match ) {
  1723. 				var excess,
  1724. 					unquoted = !match[6] && match[2];
  1725. 	
  1726. 				if ( matchExpr["CHILD"].test( match[0] ) ) {
  1727. 					return null;
  1728. 				}
  1729. 	
  1730. 				// Accept quoted arguments as-is
  1731. 				if ( match[3] ) {
  1732. 					match[2] = match[4] || match[5] || "";
  1733. 	
  1734. 				// Strip excess characters from unquoted arguments
  1735. 				} else if ( unquoted && rpseudo.test( unquoted ) &&
  1736. 					// Get excess from tokenize (recursively)
  1737. 					(excess = tokenize( unquoted, true )) &&
  1738. 					// advance to the next closing parenthesis
  1739. 					(excess = unquoted.indexOf( ")", unquoted.length - excess ) - unquoted.length) ) {
  1740. 	
  1741. 					// excess is a negative index
  1742. 					match[0] = match[0].slice( 0, excess );
  1743. 					match[2] = unquoted.slice( 0, excess );
  1744. 				}
  1745. 	
  1746. 				// Return only captures needed by the pseudo filter method (type and argument)
  1747. 				return match.slice( 0, 3 );
  1748. 			}
  1749. 		},
  1750. 	
  1751. 		filter: {
  1752. 	
  1753. 			"TAG": function( nodeNameSelector ) {
  1754. 				var nodeName = nodeNameSelector.replace( runescape, funescape ).toLowerCase();
  1755. 				return nodeNameSelector === "*" ?
  1756. 					function() { return true; } :
  1757. 					function( elem ) {
  1758. 						return elem.nodeName && elem.nodeName.toLowerCase() === nodeName;
  1759. 					};
  1760. 			},
  1761. 	
  1762. 			"CLASS": function( className ) {
  1763. 				var pattern = classCache[ className + " " ];
  1764. 	
  1765. 				return pattern ||
  1766. 					(pattern = new RegExp( "(^|" + whitespace + ")" + className + "(" + whitespace + "|$)" )) &&
  1767. 					classCache( className, function( elem ) {
  1768. 						return pattern.test( typeof elem.className === "string" && elem.className || typeof elem.getAttribute !== "undefined" && elem.getAttribute("class") || "" );
  1769. 					});
  1770. 			},
  1771. 	
  1772. 			"ATTR": function( name, operator, check ) {
  1773. 				return function( elem ) {
  1774. 					var result = Sizzle.attr( elem, name );
  1775. 	
  1776. 					if ( result == null ) {
  1777. 						return operator === "!=";
  1778. 					}
  1779. 					if ( !operator ) {
  1780. 						return true;
  1781. 					}
  1782. 	
  1783. 					result += "";
  1784. 	
  1785. 					return operator === "=" ? result === check :
  1786. 						operator === "!=" ? result !== check :
  1787. 						operator === "^=" ? check && result.indexOf( check ) === 0 :
  1788. 						operator === "*=" ? check && result.indexOf( check ) > -1 :
  1789. 						operator === "$=" ? check && result.slice( -check.length ) === check :
  1790. 						operator === "~=" ? ( " " + result.replace( rwhitespace, " " ) + " " ).indexOf( check ) > -1 :
  1791. 						operator === "|=" ? result === check || result.slice( 0, check.length + 1 ) === check + "-" :
  1792. 						false;
  1793. 				};
  1794. 			},
  1795. 	
  1796. 			"CHILD": function( type, what, argument, first, last ) {
  1797. 				var simple = type.slice( 0, 3 ) !== "nth",
  1798. 					forward = type.slice( -4 ) !== "last",
  1799. 					ofType = what === "of-type";
  1800. 	
  1801. 				return first === 1 && last === 0 ?
  1802. 	
  1803. 					// Shortcut for :nth-*(n)
  1804. 					function( elem ) {
  1805. 						return !!elem.parentNode;
  1806. 					} :
  1807. 	
  1808. 					function( elem, context, xml ) {
  1809. 						var cache, outerCache, node, diff, nodeIndex, start,
  1810. 							dir = simple !== forward ? "nextSibling" : "previousSibling",
  1811. 							parent = elem.parentNode,
  1812. 							name = ofType && elem.nodeName.toLowerCase(),
  1813. 							useCache = !xml && !ofType;
  1814. 	
  1815. 						if ( parent ) {
  1816. 	
  1817. 							// :(first|last|only)-(child|of-type)
  1818. 							if ( simple ) {
  1819. 								while ( dir ) {
  1820. 									node = elem;
  1821. 									while ( (node = node[ dir ]) ) {
  1822. 										if ( ofType ? node.nodeName.toLowerCase() === name : node.nodeType === 1 ) {
  1823. 											return false;
  1824. 										}
  1825. 									}
  1826. 									// Reverse direction for :only-* (if we haven't yet done so)
  1827. 									start = dir = type === "only" && !start && "nextSibling";
  1828. 								}
  1829. 								return true;
  1830. 							}
  1831. 	
  1832. 							start = [ forward ? parent.firstChild : parent.lastChild ];
  1833. 	
  1834. 							// non-xml :nth-child(...) stores cache data on `parent`
  1835. 							if ( forward && useCache ) {
  1836. 								// Seek `elem` from a previously-cached index
  1837. 								outerCache = parent[ expando ] || (parent[ expando ] = {});
  1838. 								cache = outerCache[ type ] || [];
  1839. 								nodeIndex = cache[0] === dirruns && cache[1];
  1840. 								diff = cache[0] === dirruns && cache[2];
  1841. 								node = nodeIndex && parent.childNodes[ nodeIndex ];
  1842. 	
  1843. 								while ( (node = ++nodeIndex && node && node[ dir ] ||
  1844. 	
  1845. 									// Fallback to seeking `elem` from the start
  1846. 									(diff = nodeIndex = 0) || start.pop()) ) {
  1847. 	
  1848. 									// When found, cache indexes on `parent` and break
  1849. 									if ( node.nodeType === 1 && ++diff && node === elem ) {
  1850. 										outerCache[ type ] = [ dirruns, nodeIndex, diff ];
  1851. 										break;
  1852. 									}
  1853. 								}
  1854. 	
  1855. 							// Use previously-cached element index if available
  1856. 							} else if ( useCache && (cache = (elem[ expando ] || (elem[ expando ] = {}))[ type ]) && cache[0] === dirruns ) {
  1857. 								diff = cache[1];
  1858. 	
  1859. 							// xml :nth-child(...) or :nth-last-child(...) or :nth(-last)?-of-type(...)
  1860. 							} else {
  1861. 								// Use the same loop as above to seek `elem` from the start
  1862. 								while ( (node = ++nodeIndex && node && node[ dir ] ||
  1863. 									(diff = nodeIndex = 0) || start.pop()) ) {
  1864. 	
  1865. 									if ( ( ofType ? node.nodeName.toLowerCase() === name : node.nodeType === 1 ) && ++diff ) {
  1866. 										// Cache the index of each encountered element
  1867. 										if ( useCache ) {
  1868. 											(node[ expando ] || (node[ expando ] = {}))[ type ] = [ dirruns, diff ];
  1869. 										}
  1870. 	
  1871. 										if ( node === elem ) {
  1872. 											break;
  1873. 										}
  1874. 									}
  1875. 								}
  1876. 							}
  1877. 	
  1878. 							// Incorporate the offset, then check against cycle size
  1879. 							diff -= last;
  1880. 							return diff === first || ( diff % first === 0 && diff / first >= 0 );
  1881. 						}
  1882. 					};
  1883. 			},
  1884. 	
  1885. 			"PSEUDO": function( pseudo, argument ) {
  1886. 				// pseudo-class names are case-insensitive
  1887. 				// http://www.w3.org/TR/selectors/#pseudo-classes
  1888. 				// Prioritize by case sensitivity in case custom pseudos are added with uppercase letters
  1889. 				// Remember that setFilters inherits from pseudos
  1890. 				var args,
  1891. 					fn = Expr.pseudos[ pseudo ] || Expr.setFilters[ pseudo.toLowerCase() ] ||
  1892. 						Sizzle.error( "unsupported pseudo: " + pseudo );
  1893. 	
  1894. 				// The user may use createPseudo to indicate that
  1895. 				// arguments are needed to create the filter function
  1896. 				// just as Sizzle does
  1897. 				if ( fn[ expando ] ) {
  1898. 					return fn( argument );
  1899. 				}
  1900. 	
  1901. 				// But maintain support for old signatures
  1902. 				if ( fn.length > 1 ) {
  1903. 					args = [ pseudo, pseudo, "", argument ];
  1904. 					return Expr.setFilters.hasOwnProperty( pseudo.toLowerCase() ) ?
  1905. 						markFunction(function( seed, matches ) {
  1906. 							var idx,
  1907. 								matched = fn( seed, argument ),
  1908. 								i = matched.length;
  1909. 							while ( i-- ) {
  1910. 								idx = indexOf( seed, matched[i] );
  1911. 								seed[ idx ] = !( matches[ idx ] = matched[i] );
  1912. 							}
  1913. 						}) :
  1914. 						function( elem ) {
  1915. 							return fn( elem, 0, args );
  1916. 						};
  1917. 				}
  1918. 	
  1919. 				return fn;
  1920. 			}
  1921. 		},
  1922. 	
  1923. 		pseudos: {
  1924. 			// Potentially complex pseudos
  1925. 			"not": markFunction(function( selector ) {
  1926. 				// Trim the selector passed to compile
  1927. 				// to avoid treating leading and trailing
  1928. 				// spaces as combinators
  1929. 				var input = [],
  1930. 					results = [],
  1931. 					matcher = compile( selector.replace( rtrim, "$1" ) );
  1932. 	
  1933. 				return matcher[ expando ] ?
  1934. 					markFunction(function( seed, matches, context, xml ) {
  1935. 						var elem,
  1936. 							unmatched = matcher( seed, null, xml, [] ),
  1937. 							i = seed.length;
  1938. 	
  1939. 						// Match elements unmatched by `matcher`
  1940. 						while ( i-- ) {
  1941. 							if ( (elem = unmatched[i]) ) {
  1942. 								seed[i] = !(matches[i] = elem);
  1943. 							}
  1944. 						}
  1945. 					}) :
  1946. 					function( elem, context, xml ) {
  1947. 						input[0] = elem;
  1948. 						matcher( input, null, xml, results );
  1949. 						// Don't keep the element (issue #299)
  1950. 						input[0] = null;
  1951. 						return !results.pop();
  1952. 					};
  1953. 			}),
  1954. 	
  1955. 			"has": markFunction(function( selector ) {
  1956. 				return function( elem ) {
  1957. 					return Sizzle( selector, elem ).length > 0;
  1958. 				};
  1959. 			}),
  1960. 	
  1961. 			"contains": markFunction(function( text ) {
  1962. 				text = text.replace( runescape, funescape );
  1963. 				return function( elem ) {
  1964. 					return ( elem.textContent || elem.innerText || getText( elem ) ).indexOf( text ) > -1;
  1965. 				};
  1966. 			}),
  1967. 	
  1968. 			// "Whether an element is represented by a :lang() selector
  1969. 			// is based solely on the element's language value
  1970. 			// being equal to the identifier C,
  1971. 			// or beginning with the identifier C immediately followed by "-".
  1972. 			// The matching of C against the element's language value is performed case-insensitively.
  1973. 			// The identifier C does not have to be a valid language name."
  1974. 			// http://www.w3.org/TR/selectors/#lang-pseudo
  1975. 			"lang": markFunction( function( lang ) {
  1976. 				// lang value must be a valid identifier
  1977. 				if ( !ridentifier.test(lang || "") ) {
  1978. 					Sizzle.error( "unsupported lang: " + lang );
  1979. 				}
  1980. 				lang = lang.replace( runescape, funescape ).toLowerCase();
  1981. 				return function( elem ) {
  1982. 					var elemLang;
  1983. 					do {
  1984. 						if ( (elemLang = documentIsHTML ?
  1985. 							elem.lang :
  1986. 							elem.getAttribute("xml:lang") || elem.getAttribute("lang")) ) {
  1987. 	
  1988. 							elemLang = elemLang.toLowerCase();
  1989. 							return elemLang === lang || elemLang.indexOf( lang + "-" ) === 0;
  1990. 						}
  1991. 					} while ( (elem = elem.parentNode) && elem.nodeType === 1 );
  1992. 					return false;
  1993. 				};
  1994. 			}),
  1995. 	
  1996. 			// Miscellaneous
  1997. 			"target": function( elem ) {
  1998. 				var hash = window.location && window.location.hash;
  1999. 				return hash && hash.slice( 1 ) === elem.id;
  2000. 			},
  2001. 	
  2002. 			"root": function( elem ) {
  2003. 				return elem === docElem;
  2004. 			},
  2005. 	
  2006. 			"focus": function( elem ) {
  2007. 				return elem === document.activeElement && (!document.hasFocus || document.hasFocus()) && !!(elem.type || elem.href || ~elem.tabIndex);
  2008. 			},
  2009. 	
  2010. 			// Boolean properties
  2011. 			"enabled": function( elem ) {
  2012. 				return elem.disabled === false;
  2013. 			},
  2014. 	
  2015. 			"disabled": function( elem ) {
  2016. 				return elem.disabled === true;
  2017. 			},
  2018. 	
  2019. 			"checked": function( elem ) {
  2020. 				// In CSS3, :checked should return both checked and selected elements
  2021. 				// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
  2022. 				var nodeName = elem.nodeName.toLowerCase();
  2023. 				return (nodeName === "input" && !!elem.checked) || (nodeName === "option" && !!elem.selected);
  2024. 			},
  2025. 	
  2026. 			"selected": function( elem ) {
  2027. 				// Accessing this property makes selected-by-default
  2028. 				// options in Safari work properly
  2029. 				if ( elem.parentNode ) {
  2030. 					elem.parentNode.selectedIndex;
  2031. 				}
  2032. 	
  2033. 				return elem.selected === true;
  2034. 			},
  2035. 	
  2036. 			// Contents
  2037. 			"empty": function( elem ) {
  2038. 				// http://www.w3.org/TR/selectors/#empty-pseudo
  2039. 				// :empty is negated by element (1) or content nodes (text: 3; cdata: 4; entity ref: 5),
  2040. 				//   but not by others (comment: 8; processing instruction: 7; etc.)
  2041. 				// nodeType < 6 works because attributes (2) do not appear as children
  2042. 				for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
  2043. 					if ( elem.nodeType < 6 ) {
  2044. 						return false;
  2045. 					}
  2046. 				}
  2047. 				return true;
  2048. 			},
  2049. 	
  2050. 			"parent": function( elem ) {
  2051. 				return !Expr.pseudos["empty"]( elem );
  2052. 			},
  2053. 	
  2054. 			// Element/input types
  2055. 			"header": function( elem ) {
  2056. 				return rheader.test( elem.nodeName );
  2057. 			},
  2058. 	
  2059. 			"input": function( elem ) {
  2060. 				return rinputs.test( elem.nodeName );
  2061. 			},
  2062. 	
  2063. 			"button": function( elem ) {
  2064. 				var name = elem.nodeName.toLowerCase();
  2065. 				return name === "input" && elem.type === "button" || name === "button";
  2066. 			},
  2067. 	
  2068. 			"text": function( elem ) {
  2069. 				var attr;
  2070. 				return elem.nodeName.toLowerCase() === "input" &&
  2071. 					elem.type === "text" &&
  2072. 	
  2073. 					// Support: IE<8
  2074. 					// New HTML5 attribute values (e.g., "search") appear with elem.type === "text"
  2075. 					( (attr = elem.getAttribute("type")) == null || attr.toLowerCase() === "text" );
  2076. 			},
  2077. 	
  2078. 			// Position-in-collection
  2079. 			"first": createPositionalPseudo(function() {
  2080. 				return [ 0 ];
  2081. 			}),
  2082. 	
  2083. 			"last": createPositionalPseudo(function( matchIndexes, length ) {
  2084. 				return [ length - 1 ];
  2085. 			}),
  2086. 	
  2087. 			"eq": createPositionalPseudo(function( matchIndexes, length, argument ) {
  2088. 				return [ argument < 0 ? argument + length : argument ];
  2089. 			}),
  2090. 	
  2091. 			"even": createPositionalPseudo(function( matchIndexes, length ) {
  2092. 				var i = 0;
  2093. 				for ( ; i < length; i += 2 ) {
  2094. 					matchIndexes.push( i );
  2095. 				}
  2096. 				return matchIndexes;
  2097. 			}),
  2098. 	
  2099. 			"odd": createPositionalPseudo(function( matchIndexes, length ) {
  2100. 				var i = 1;
  2101. 				for ( ; i < length; i += 2 ) {
  2102. 					matchIndexes.push( i );
  2103. 				}
  2104. 				return matchIndexes;
  2105. 			}),
  2106. 	
  2107. 			"lt": createPositionalPseudo(function( matchIndexes, length, argument ) {
  2108. 				var i = argument < 0 ? argument + length : argument;
  2109. 				for ( ; --i >= 0; ) {
  2110. 					matchIndexes.push( i );
  2111. 				}
  2112. 				return matchIndexes;
  2113. 			}),
  2114. 	
  2115. 			"gt": createPositionalPseudo(function( matchIndexes, length, argument ) {
  2116. 				var i = argument < 0 ? argument + length : argument;
  2117. 				for ( ; ++i < length; ) {
  2118. 					matchIndexes.push( i );
  2119. 				}
  2120. 				return matchIndexes;
  2121. 			})
  2122. 		}
  2123. 	};
  2124. 	
  2125. 	Expr.pseudos["nth"] = Expr.pseudos["eq"];
  2126. 	
  2127. 	// Add button/input type pseudos
  2128. 	for ( i in { radio: true, checkbox: true, file: true, password: true, image: true } ) {
  2129. 		Expr.pseudos[ i ] = createInputPseudo( i );
  2130. 	}
  2131. 	for ( i in { submit: true, reset: true } ) {
  2132. 		Expr.pseudos[ i ] = createButtonPseudo( i );
  2133. 	}
  2134. 	
  2135. 	// Easy API for creating new setFilters
  2136. 	function setFilters() {}
  2137. 	setFilters.prototype = Expr.filters = Expr.pseudos;
  2138. 	Expr.setFilters = new setFilters();
  2139. 	
  2140. 	tokenize = Sizzle.tokenize = function( selector, parseOnly ) {
  2141. 		var matched, match, tokens, type,
  2142. 			soFar, groups, preFilters,
  2143. 			cached = tokenCache[ selector + " " ];
  2144. 	
  2145. 		if ( cached ) {
  2146. 			return parseOnly ? 0 : cached.slice( 0 );
  2147. 		}
  2148. 	
  2149. 		soFar = selector;
  2150. 		groups = [];
  2151. 		preFilters = Expr.preFilter;
  2152. 	
  2153. 		while ( soFar ) {
  2154. 	
  2155. 			// Comma and first run
  2156. 			if ( !matched || (match = rcomma.exec( soFar )) ) {
  2157. 				if ( match ) {
  2158. 					// Don't consume trailing commas as valid
  2159. 					soFar = soFar.slice( match[0].length ) || soFar;
  2160. 				}
  2161. 				groups.push( (tokens = []) );
  2162. 			}
  2163. 	
  2164. 			matched = false;
  2165. 	
  2166. 			// Combinators
  2167. 			if ( (match = rcombinators.exec( soFar )) ) {
  2168. 				matched = match.shift();
  2169. 				tokens.push({
  2170. 					value: matched,
  2171. 					// Cast descendant combinators to space
  2172. 					type: match[0].replace( rtrim, " " )
  2173. 				});
  2174. 				soFar = soFar.slice( matched.length );
  2175. 			}
  2176. 	
  2177. 			// Filters
  2178. 			for ( type in Expr.filter ) {
  2179. 				if ( (match = matchExpr[ type ].exec( soFar )) && (!preFilters[ type ] ||
  2180. 					(match = preFilters[ type ]( match ))) ) {
  2181. 					matched = match.shift();
  2182. 					tokens.push({
  2183. 						value: matched,
  2184. 						type: type,
  2185. 						matches: match
  2186. 					});
  2187. 					soFar = soFar.slice( matched.length );
  2188. 				}
  2189. 			}
  2190. 	
  2191. 			if ( !matched ) {
  2192. 				break;
  2193. 			}
  2194. 		}
  2195. 	
  2196. 		// Return the length of the invalid excess
  2197. 		// if we're just parsing
  2198. 		// Otherwise, throw an error or return tokens
  2199. 		return parseOnly ?
  2200. 			soFar.length :
  2201. 			soFar ?
  2202. 				Sizzle.error( selector ) :
  2203. 				// Cache the tokens
  2204. 				tokenCache( selector, groups ).slice( 0 );
  2205. 	};
  2206. 	
  2207. 	function toSelector( tokens ) {
  2208. 		var i = 0,
  2209. 			len = tokens.length,
  2210. 			selector = "";
  2211. 		for ( ; i < len; i++ ) {
  2212. 			selector += tokens[i].value;
  2213. 		}
  2214. 		return selector;
  2215. 	}
  2216. 	
  2217. 	function addCombinator( matcher, combinator, base ) {
  2218. 		var dir = combinator.dir,
  2219. 			checkNonElements = base && dir === "parentNode",
  2220. 			doneName = done++;
  2221. 	
  2222. 		return combinator.first ?
  2223. 			// Check against closest ancestor/preceding element
  2224. 			function( elem, context, xml ) {
  2225. 				while ( (elem = elem[ dir ]) ) {
  2226. 					if ( elem.nodeType === 1 || checkNonElements ) {
  2227. 						return matcher( elem, context, xml );
  2228. 					}
  2229. 				}
  2230. 			} :
  2231. 	
  2232. 			// Check against all ancestor/preceding elements
  2233. 			function( elem, context, xml ) {
  2234. 				var oldCache, outerCache,
  2235. 					newCache = [ dirruns, doneName ];
  2236. 	
  2237. 				// We can't set arbitrary data on XML nodes, so they don't benefit from dir caching
  2238. 				if ( xml ) {
  2239. 					while ( (elem = elem[ dir ]) ) {
  2240. 						if ( elem.nodeType === 1 || checkNonElements ) {
  2241. 							if ( matcher( elem, context, xml ) ) {
  2242. 								return true;
  2243. 							}
  2244. 						}
  2245. 					}
  2246. 				} else {
  2247. 					while ( (elem = elem[ dir ]) ) {
  2248. 						if ( elem.nodeType === 1 || checkNonElements ) {
  2249. 							outerCache = elem[ expando ] || (elem[ expando ] = {});
  2250. 							if ( (oldCache = outerCache[ dir ]) &&
  2251. 								oldCache[ 0 ] === dirruns && oldCache[ 1 ] === doneName ) {
  2252. 	
  2253. 								// Assign to newCache so results back-propagate to previous elements
  2254. 								return (newCache[ 2 ] = oldCache[ 2 ]);
  2255. 							} else {
  2256. 								// Reuse newcache so results back-propagate to previous elements
  2257. 								outerCache[ dir ] = newCache;
  2258. 	
  2259. 								// A match means we're done; a fail means we have to keep checking
  2260. 								if ( (newCache[ 2 ] = matcher( elem, context, xml )) ) {
  2261. 									return true;
  2262. 								}
  2263. 							}
  2264. 						}
  2265. 					}
  2266. 				}
  2267. 			};
  2268. 	}
  2269. 	
  2270. 	function elementMatcher( matchers ) {
  2271. 		return matchers.length > 1 ?
  2272. 			function( elem, context, xml ) {
  2273. 				var i = matchers.length;
  2274. 				while ( i-- ) {
  2275. 					if ( !matchers[i]( elem, context, xml ) ) {
  2276. 						return false;
  2277. 					}
  2278. 				}
  2279. 				return true;
  2280. 			} :
  2281. 			matchers[0];
  2282. 	}
  2283. 	
  2284. 	function multipleContexts( selector, contexts, results ) {
  2285. 		var i = 0,
  2286. 			len = contexts.length;
  2287. 		for ( ; i < len; i++ ) {
  2288. 			Sizzle( selector, contexts[i], results );
  2289. 		}
  2290. 		return results;
  2291. 	}
  2292. 	
  2293. 	function condense( unmatched, map, filter, context, xml ) {
  2294. 		var elem,
  2295. 			newUnmatched = [],
  2296. 			i = 0,
  2297. 			len = unmatched.length,
  2298. 			mapped = map != null;
  2299. 	
  2300. 		for ( ; i < len; i++ ) {
  2301. 			if ( (elem = unmatched[i]) ) {
  2302. 				if ( !filter || filter( elem, context, xml ) ) {
  2303. 					newUnmatched.push( elem );
  2304. 					if ( mapped ) {
  2305. 						map.push( i );
  2306. 					}
  2307. 				}
  2308. 			}
  2309. 		}
  2310. 	
  2311. 		return newUnmatched;
  2312. 	}
  2313. 	
  2314. 	function setMatcher( preFilter, selector, matcher, postFilter, postFinder, postSelector ) {
  2315. 		if ( postFilter && !postFilter[ expando ] ) {
  2316. 			postFilter = setMatcher( postFilter );
  2317. 		}
  2318. 		if ( postFinder && !postFinder[ expando ] ) {
  2319. 			postFinder = setMatcher( postFinder, postSelector );
  2320. 		}
  2321. 		return markFunction(function( seed, results, context, xml ) {
  2322. 			var temp, i, elem,
  2323. 				preMap = [],
  2324. 				postMap = [],
  2325. 				preexisting = results.length,
  2326. 	
  2327. 				// Get initial elements from seed or context
  2328. 				elems = seed || multipleContexts( selector || "*", context.nodeType ? [ context ] : context, [] ),
  2329. 	
  2330. 				// Prefilter to get matcher input, preserving a map for seed-results synchronization
  2331. 				matcherIn = preFilter && ( seed || !selector ) ?
  2332. 					condense( elems, preMap, preFilter, context, xml ) :
  2333. 					elems,
  2334. 	
  2335. 				matcherOut = matcher ?
  2336. 					// If we have a postFinder, or filtered seed, or non-seed postFilter or preexisting results,
  2337. 					postFinder || ( seed ? preFilter : preexisting || postFilter ) ?
  2338. 	
  2339. 						// ...intermediate processing is necessary
  2340. 						[] :
  2341. 	
  2342. 						// ...otherwise use results directly
  2343. 						results :
  2344. 					matcherIn;
  2345. 	
  2346. 			// Find primary matches
  2347. 			if ( matcher ) {
  2348. 				matcher( matcherIn, matcherOut, context, xml );
  2349. 			}
  2350. 	
  2351. 			// Apply postFilter
  2352. 			if ( postFilter ) {
  2353. 				temp = condense( matcherOut, postMap );
  2354. 				postFilter( temp, [], context, xml );
  2355. 	
  2356. 				// Un-match failing elements by moving them back to matcherIn
  2357. 				i = temp.length;
  2358. 				while ( i-- ) {
  2359. 					if ( (elem = temp[i]) ) {
  2360. 						matcherOut[ postMap[i] ] = !(matcherIn[ postMap[i] ] = elem);
  2361. 					}
  2362. 				}
  2363. 			}
  2364. 	
  2365. 			if ( seed ) {
  2366. 				if ( postFinder || preFilter ) {
  2367. 					if ( postFinder ) {
  2368. 						// Get the final matcherOut by condensing this intermediate into postFinder contexts
  2369. 						temp = [];
  2370. 						i = matcherOut.length;
  2371. 						while ( i-- ) {
  2372. 							if ( (elem = matcherOut[i]) ) {
  2373. 								// Restore matcherIn since elem is not yet a final match
  2374. 								temp.push( (matcherIn[i] = elem) );
  2375. 							}
  2376. 						}
  2377. 						postFinder( null, (matcherOut = []), temp, xml );
  2378. 					}
  2379. 	
  2380. 					// Move matched elements from seed to results to keep them synchronized
  2381. 					i = matcherOut.length;
  2382. 					while ( i-- ) {
  2383. 						if ( (elem = matcherOut[i]) &&
  2384. 							(temp = postFinder ? indexOf( seed, elem ) : preMap[i]) > -1 ) {
  2385. 	
  2386. 							seed[temp] = !(results[temp] = elem);
  2387. 						}
  2388. 					}
  2389. 				}
  2390. 	
  2391. 			// Add elements to results, through postFinder if defined
  2392. 			} else {
  2393. 				matcherOut = condense(
  2394. 					matcherOut === results ?
  2395. 						matcherOut.splice( preexisting, matcherOut.length ) :
  2396. 						matcherOut
  2397. 				);
  2398. 				if ( postFinder ) {
  2399. 					postFinder( null, results, matcherOut, xml );
  2400. 				} else {
  2401. 					push.apply( results, matcherOut );
  2402. 				}
  2403. 			}
  2404. 		});
  2405. 	}
  2406. 	
  2407. 	function matcherFromTokens( tokens ) {
  2408. 		var checkContext, matcher, j,
  2409. 			len = tokens.length,
  2410. 			leadingRelative = Expr.relative[ tokens[0].type ],
  2411. 			implicitRelative = leadingRelative || Expr.relative[" "],
  2412. 			i = leadingRelative ? 1 : 0,
  2413. 	
  2414. 			// The foundational matcher ensures that elements are reachable from top-level context(s)
  2415. 			matchContext = addCombinator( function( elem ) {
  2416. 				return elem === checkContext;
  2417. 			}, implicitRelative, true ),
  2418. 			matchAnyContext = addCombinator( function( elem ) {
  2419. 				return indexOf( checkContext, elem ) > -1;
  2420. 			}, implicitRelative, true ),
  2421. 			matchers = [ function( elem, context, xml ) {
  2422. 				var ret = ( !leadingRelative && ( xml || context !== outermostContext ) ) || (
  2423. 					(checkContext = context).nodeType ?
  2424. 						matchContext( elem, context, xml ) :
  2425. 						matchAnyContext( elem, context, xml ) );
  2426. 				// Avoid hanging onto element (issue #299)
  2427. 				checkContext = null;
  2428. 				return ret;
  2429. 			} ];
  2430. 	
  2431. 		for ( ; i < len; i++ ) {
  2432. 			if ( (matcher = Expr.relative[ tokens[i].type ]) ) {
  2433. 				matchers = [ addCombinator(elementMatcher( matchers ), matcher) ];
  2434. 			} else {
  2435. 				matcher = Expr.filter[ tokens[i].type ].apply( null, tokens[i].matches );
  2436. 	
  2437. 				// Return special upon seeing a positional matcher
  2438. 				if ( matcher[ expando ] ) {
  2439. 					// Find the next relative operator (if any) for proper handling
  2440. 					j = ++i;
  2441. 					for ( ; j < len; j++ ) {
  2442. 						if ( Expr.relative[ tokens[j].type ] ) {
  2443. 							break;
  2444. 						}
  2445. 					}
  2446. 					return setMatcher(
  2447. 						i > 1 && elementMatcher( matchers ),
  2448. 						i > 1 && toSelector(
  2449. 							// If the preceding token was a descendant combinator, insert an implicit any-element `*`
  2450. 							tokens.slice( 0, i - 1 ).concat({ value: tokens[ i - 2 ].type === " " ? "*" : "" })
  2451. 						).replace( rtrim, "$1" ),
  2452. 						matcher,
  2453. 						i < j && matcherFromTokens( tokens.slice( i, j ) ),
  2454. 						j < len && matcherFromTokens( (tokens = tokens.slice( j )) ),
  2455. 						j < len && toSelector( tokens )
  2456. 					);
  2457. 				}
  2458. 				matchers.push( matcher );
  2459. 			}
  2460. 		}
  2461. 	
  2462. 		return elementMatcher( matchers );
  2463. 	}
  2464. 	
  2465. 	function matcherFromGroupMatchers( elementMatchers, setMatchers ) {
  2466. 		var bySet = setMatchers.length > 0,
  2467. 			byElement = elementMatchers.length > 0,
  2468. 			superMatcher = function( seed, context, xml, results, outermost ) {
  2469. 				var elem, j, matcher,
  2470. 					matchedCount = 0,
  2471. 					i = "0",
  2472. 					unmatched = seed && [],
  2473. 					setMatched = [],
  2474. 					contextBackup = outermostContext,
  2475. 					// We must always have either seed elements or outermost context
  2476. 					elems = seed || byElement && Expr.find["TAG"]( "*", outermost ),
  2477. 					// Use integer dirruns iff this is the outermost matcher
  2478. 					dirrunsUnique = (dirruns += contextBackup == null ? 1 : Math.random() || 0.1),
  2479. 					len = elems.length;
  2480. 	
  2481. 				if ( outermost ) {
  2482. 					outermostContext = context !== document && context;
  2483. 				}
  2484. 	
  2485. 				// Add elements passing elementMatchers directly to results
  2486. 				// Keep `i` a string if there are no elements so `matchedCount` will be "00" below
  2487. 				// Support: IE<9, Safari
  2488. 				// Tolerate NodeList properties (IE: "length"; Safari: <number>) matching elements by id
  2489. 				for ( ; i !== len && (elem = elems[i]) != null; i++ ) {
  2490. 					if ( byElement && elem ) {
  2491. 						j = 0;
  2492. 						while ( (matcher = elementMatchers[j++]) ) {
  2493. 							if ( matcher( elem, context, xml ) ) {
  2494. 								results.push( elem );
  2495. 								break;
  2496. 							}
  2497. 						}
  2498. 						if ( outermost ) {
  2499. 							dirruns = dirrunsUnique;
  2500. 						}
  2501. 					}
  2502. 	
  2503. 					// Track unmatched elements for set filters
  2504. 					if ( bySet ) {
  2505. 						// They will have gone through all possible matchers
  2506. 						if ( (elem = !matcher && elem) ) {
  2507. 							matchedCount--;
  2508. 						}
  2509. 	
  2510. 						// Lengthen the array for every element, matched or not
  2511. 						if ( seed ) {
  2512. 							unmatched.push( elem );
  2513. 						}
  2514. 					}
  2515. 				}
  2516. 	
  2517. 				// Apply set filters to unmatched elements
  2518. 				matchedCount += i;
  2519. 				if ( bySet && i !== matchedCount ) {
  2520. 					j = 0;
  2521. 					while ( (matcher = setMatchers[j++]) ) {
  2522. 						matcher( unmatched, setMatched, context, xml );
  2523. 					}
  2524. 	
  2525. 					if ( seed ) {
  2526. 						// Reintegrate element matches to eliminate the need for sorting
  2527. 						if ( matchedCount > 0 ) {
  2528. 							while ( i-- ) {
  2529. 								if ( !(unmatched[i] || setMatched[i]) ) {
  2530. 									setMatched[i] = pop.call( results );
  2531. 								}
  2532. 							}
  2533. 						}
  2534. 	
  2535. 						// Discard index placeholder values to get only actual matches
  2536. 						setMatched = condense( setMatched );
  2537. 					}
  2538. 	
  2539. 					// Add matches to results
  2540. 					push.apply( results, setMatched );
  2541. 	
  2542. 					// Seedless set matches succeeding multiple successful matchers stipulate sorting
  2543. 					if ( outermost && !seed && setMatched.length > 0 &&
  2544. 						( matchedCount + setMatchers.length ) > 1 ) {
  2545. 	
  2546. 						Sizzle.uniqueSort( results );
  2547. 					}
  2548. 				}
  2549. 	
  2550. 				// Override manipulation of globals by nested matchers
  2551. 				if ( outermost ) {
  2552. 					dirruns = dirrunsUnique;
  2553. 					outermostContext = contextBackup;
  2554. 				}
  2555. 	
  2556. 				return unmatched;
  2557. 			};
  2558. 	
  2559. 		return bySet ?
  2560. 			markFunction( superMatcher ) :
  2561. 			superMatcher;
  2562. 	}
  2563. 	
  2564. 	compile = Sizzle.compile = function( selector, match /* Internal Use Only */ ) {
  2565. 		var i,
  2566. 			setMatchers = [],
  2567. 			elementMatchers = [],
  2568. 			cached = compilerCache[ selector + " " ];
  2569. 	
  2570. 		if ( !cached ) {
  2571. 			// Generate a function of recursive functions that can be used to check each element
  2572. 			if ( !match ) {
  2573. 				match = tokenize( selector );
  2574. 			}
  2575. 			i = match.length;
  2576. 			while ( i-- ) {
  2577. 				cached = matcherFromTokens( match[i] );
  2578. 				if ( cached[ expando ] ) {
  2579. 					setMatchers.push( cached );
  2580. 				} else {
  2581. 					elementMatchers.push( cached );
  2582. 				}
  2583. 			}
  2584. 	
  2585. 			// Cache the compiled function
  2586. 			cached = compilerCache( selector, matcherFromGroupMatchers( elementMatchers, setMatchers ) );
  2587. 	
  2588. 			// Save selector and tokenization
  2589. 			cached.selector = selector;
  2590. 		}
  2591. 		return cached;
  2592. 	};
  2593. 	
  2594. 	/**
  2595. 	 * A low-level selection function that works with Sizzle's compiled
  2596. 	 *  selector functions
  2597. 	 * @param {String|Function} selector A selector or a pre-compiled
  2598. 	 *  selector function built with Sizzle.compile
  2599. 	 * @param {Element} context
  2600. 	 * @param {Array} [results]
  2601. 	 * @param {Array} [seed] A set of elements to match against
  2602. 	 */
  2603. 	select = Sizzle.select = function( selector, context, results, seed ) {
  2604. 		var i, tokens, token, type, find,
  2605. 			compiled = typeof selector === "function" && selector,
  2606. 			match = !seed && tokenize( (selector = compiled.selector || selector) );
  2607. 	
  2608. 		results = results || [];
  2609. 	
  2610. 		// Try to minimize operations if there is no seed and only one group
  2611. 		if ( match.length === 1 ) {
  2612. 	
  2613. 			// Take a shortcut and set the context if the root selector is an ID
  2614. 			tokens = match[0] = match[0].slice( 0 );
  2615. 			if ( tokens.length > 2 && (token = tokens[0]).type === "ID" &&
  2616. 					support.getById && context.nodeType === 9 && documentIsHTML &&
  2617. 					Expr.relative[ tokens[1].type ] ) {
  2618. 	
  2619. 				context = ( Expr.find["ID"]( token.matches[0].replace(runescape, funescape), context ) || [] )[0];
  2620. 				if ( !context ) {
  2621. 					return results;
  2622. 	
  2623. 				// Precompiled matchers will still verify ancestry, so step up a level
  2624. 				} else if ( compiled ) {
  2625. 					context = context.parentNode;
  2626. 				}
  2627. 	
  2628. 				selector = selector.slice( tokens.shift().value.length );
  2629. 			}
  2630. 	
  2631. 			// Fetch a seed set for right-to-left matching
  2632. 			i = matchExpr["needsContext"].test( selector ) ? 0 : tokens.length;
  2633. 			while ( i-- ) {
  2634. 				token = tokens[i];
  2635. 	
  2636. 				// Abort if we hit a combinator
  2637. 				if ( Expr.relative[ (type = token.type) ] ) {
  2638. 					break;
  2639. 				}
  2640. 				if ( (find = Expr.find[ type ]) ) {
  2641. 					// Search, expanding context for leading sibling combinators
  2642. 					if ( (seed = find(
  2643. 						token.matches[0].replace( runescape, funescape ),
  2644. 						rsibling.test( tokens[0].type ) && testContext( context.parentNode ) || context
  2645. 					)) ) {
  2646. 	
  2647. 						// If seed is empty or no tokens remain, we can return early
  2648. 						tokens.splice( i, 1 );
  2649. 						selector = seed.length && toSelector( tokens );
  2650. 						if ( !selector ) {
  2651. 							push.apply( results, seed );
  2652. 							return results;
  2653. 						}
  2654. 	
  2655. 						break;
  2656. 					}
  2657. 				}
  2658. 			}
  2659. 		}
  2660. 	
  2661. 		// Compile and execute a filtering function if one is not provided
  2662. 		// Provide `match` to avoid retokenization if we modified the selector above
  2663. 		( compiled || compile( selector, match ) )(
  2664. 			seed,
  2665. 			context,
  2666. 			!documentIsHTML,
  2667. 			results,
  2668. 			rsibling.test( selector ) && testContext( context.parentNode ) || context
  2669. 		);
  2670. 		return results;
  2671. 	};
  2672. 	
  2673. 	// One-time assignments
  2674. 	
  2675. 	// Sort stability
  2676. 	support.sortStable = expando.split("").sort( sortOrder ).join("") === expando;
  2677. 	
  2678. 	// Support: Chrome 14-35+
  2679. 	// Always assume duplicates if they aren't passed to the comparison function
  2680. 	support.detectDuplicates = !!hasDuplicate;
  2681. 	
  2682. 	// Initialize against the default document
  2683. 	setDocument();
  2684. 	
  2685. 	// Support: Webkit<537.32 - Safari 6.0.3/Chrome 25 (fixed in Chrome 27)
  2686. 	// Detached nodes confoundingly follow *each other*
  2687. 	support.sortDetached = assert(function( div1 ) {
  2688. 		// Should return 1, but returns 4 (following)
  2689. 		return div1.compareDocumentPosition( document.createElement("div") ) & 1;
  2690. 	});
  2691. 	
  2692. 	// Support: IE<8
  2693. 	// Prevent attribute/property "interpolation"
  2694. 	// http://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx
  2695. 	if ( !assert(function( div ) {
  2696. 		div.innerHTML = "<a href='#'></a>";
  2697. 		return div.firstChild.getAttribute("href") === "#" ;
  2698. 	}) ) {
  2699. 		addHandle( "type|href|height|width", function( elem, name, isXML ) {
  2700. 			if ( !isXML ) {
  2701. 				return elem.getAttribute( name, name.toLowerCase() === "type" ? 1 : 2 );
  2702. 			}
  2703. 		});
  2704. 	}
  2705. 	
  2706. 	// Support: IE<9
  2707. 	// Use defaultValue in place of getAttribute("value")
  2708. 	if ( !support.attributes || !assert(function( div ) {
  2709. 		div.innerHTML = "<input/>";
  2710. 		div.firstChild.setAttribute( "value", "" );
  2711. 		return div.firstChild.getAttribute( "value" ) === "";
  2712. 	}) ) {
  2713. 		addHandle( "value", function( elem, name, isXML ) {
  2714. 			if ( !isXML && elem.nodeName.toLowerCase() === "input" ) {
  2715. 				return elem.defaultValue;
  2716. 			}
  2717. 		});
  2718. 	}
  2719. 	
  2720. 	// Support: IE<9
  2721. 	// Use getAttributeNode to fetch booleans when getAttribute lies
  2722. 	if ( !assert(function( div ) {
  2723. 		return div.getAttribute("disabled") == null;
  2724. 	}) ) {
  2725. 		addHandle( booleans, function( elem, name, isXML ) {
  2726. 			var val;
  2727. 			if ( !isXML ) {
  2728. 				return elem[ name ] === true ? name.toLowerCase() :
  2729. 						(val = elem.getAttributeNode( name )) && val.specified ?
  2730. 						val.value :
  2731. 					null;
  2732. 			}
  2733. 		});
  2734. 	}
  2735. 	
  2736. 	return Sizzle;
  2737. 	
  2738. 	})( window );
  2739. 	
  2740. 	
  2741. 	
  2742. 	jQuery.find = Sizzle;
  2743. 	jQuery.expr = Sizzle.selectors;
  2744. 	jQuery.expr[":"] = jQuery.expr.pseudos;
  2745. 	jQuery.unique = Sizzle.uniqueSort;
  2746. 	jQuery.text = Sizzle.getText;
  2747. 	jQuery.isXMLDoc = Sizzle.isXML;
  2748. 	jQuery.contains = Sizzle.contains;
  2749. 	
  2750. 	
  2751. 	
  2752. 	var rneedsContext = jQuery.expr.match.needsContext;
  2753. 	
  2754. 	var rsingleTag = (/^<(\w+)\s*\/?>(?:<\/\1>|)$/);
  2755. 	
  2756. 	
  2757. 	
  2758. 	var risSimple = /^.[^:#\[\.,]*$/;
  2759. 	
  2760. 	// Implement the identical functionality for filter and not
  2761. 	function winnow( elements, qualifier, not ) {
  2762. 		if ( jQuery.isFunction( qualifier ) ) {
  2763. 			return jQuery.grep( elements, function( elem, i ) {
  2764. 				/* jshint -W018 */
  2765. 				return !!qualifier.call( elem, i, elem ) !== not;
  2766. 			});
  2767. 	
  2768. 		}
  2769. 	
  2770. 		if ( qualifier.nodeType ) {
  2771. 			return jQuery.grep( elements, function( elem ) {
  2772. 				return ( elem === qualifier ) !== not;
  2773. 			});
  2774. 	
  2775. 		}
  2776. 	
  2777. 		if ( typeof qualifier === "string" ) {
  2778. 			if ( risSimple.test( qualifier ) ) {
  2779. 				return jQuery.filter( qualifier, elements, not );
  2780. 			}
  2781. 	
  2782. 			qualifier = jQuery.filter( qualifier, elements );
  2783. 		}
  2784. 	
  2785. 		return jQuery.grep( elements, function( elem ) {
  2786. 			return ( indexOf.call( qualifier, elem ) >= 0 ) !== not;
  2787. 		});
  2788. 	}
  2789. 	
  2790. 	jQuery.filter = function( expr, elems, not ) {
  2791. 		var elem = elems[ 0 ];
  2792. 	
  2793. 		if ( not ) {
  2794. 			expr = ":not(" + expr + ")";
  2795. 		}
  2796. 	
  2797. 		return elems.length === 1 && elem.nodeType === 1 ?
  2798. 			jQuery.find.matchesSelector( elem, expr ) ? [ elem ] : [] :
  2799. 			jQuery.find.matches( expr, jQuery.grep( elems, function( elem ) {
  2800. 				return elem.nodeType === 1;
  2801. 			}));
  2802. 	};
  2803. 	
  2804. 	jQuery.fn.extend({
  2805. 		find: function( selector ) {
  2806. 			var i,
  2807. 				len = this.length,
  2808. 				ret = [],
  2809. 				self = this;
  2810. 	
  2811. 			if ( typeof selector !== "string" ) {
  2812. 				return this.pushStack( jQuery( selector ).filter(function() {
  2813. 					for ( i = 0; i < len; i++ ) {
  2814. 						if ( jQuery.contains( self[ i ], this ) ) {
  2815. 							return true;
  2816. 						}
  2817. 					}
  2818. 				}) );
  2819. 			}
  2820. 	
  2821. 			for ( i = 0; i < len; i++ ) {
  2822. 				jQuery.find( selector, self[ i ], ret );
  2823. 			}
  2824. 	
  2825. 			// Needed because $( selector, context ) becomes $( context ).find( selector )
  2826. 			ret = this.pushStack( len > 1 ? jQuery.unique( ret ) : ret );
  2827. 			ret.selector = this.selector ? this.selector + " " + selector : selector;
  2828. 			return ret;
  2829. 		},
  2830. 		filter: function( selector ) {
  2831. 			return this.pushStack( winnow(this, selector || [], false) );
  2832. 		},
  2833. 		not: function( selector ) {
  2834. 			return this.pushStack( winnow(this, selector || [], true) );
  2835. 		},
  2836. 		is: function( selector ) {
  2837. 			return !!winnow(
  2838. 				this,
  2839. 	
  2840. 				// If this is a positional/relative selector, check membership in the returned set
  2841. 				// so $("p:first").is("p:last") won't return true for a doc with two "p".
  2842. 				typeof selector === "string" && rneedsContext.test( selector ) ?
  2843. 					jQuery( selector ) :
  2844. 					selector || [],
  2845. 				false
  2846. 			).length;
  2847. 		}
  2848. 	});
  2849. 	
  2850. 	
  2851. 	// Initialize a jQuery object
  2852. 	
  2853. 	
  2854. 	// A central reference to the root jQuery(document)
  2855. 	var rootjQuery,
  2856. 	
  2857. 		// A simple way to check for HTML strings
  2858. 		// Prioritize #id over <tag> to avoid XSS via location.hash (#9521)
  2859. 		// Strict HTML recognition (#11290: must start with <)
  2860. 		rquickExpr = /^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]*))$/,
  2861. 	
  2862. 		init = jQuery.fn.init = function( selector, context ) {
  2863. 			var match, elem;
  2864. 	
  2865. 			// HANDLE: $(""), $(null), $(undefined), $(false)
  2866. 			if ( !selector ) {
  2867. 				return this;
  2868. 			}
  2869. 	
  2870. 			// Handle HTML strings
  2871. 			if ( typeof selector === "string" ) {
  2872. 				if ( selector[0] === "<" && selector[ selector.length - 1 ] === ">" && selector.length >= 3 ) {
  2873. 					// Assume that strings that start and end with <> are HTML and skip the regex check
  2874. 					match = [ null, selector, null ];
  2875. 	
  2876. 				} else {
  2877. 					match = rquickExpr.exec( selector );
  2878. 				}
  2879. 	
  2880. 				// Match html or make sure no context is specified for #id
  2881. 				if ( match && (match[1] || !context) ) {
  2882. 	
  2883. 					// HANDLE: $(html) -> $(array)
  2884. 					if ( match[1] ) {
  2885. 						context = context instanceof jQuery ? context[0] : context;
  2886. 	
  2887. 						// Option to run scripts is true for back-compat
  2888. 						// Intentionally let the error be thrown if parseHTML is not present
  2889. 						jQuery.merge( this, jQuery.parseHTML(
  2890. 							match[1],
  2891. 							context && context.nodeType ? context.ownerDocument || context : document,
  2892. 							true
  2893. 						) );
  2894. 	
  2895. 						// HANDLE: $(html, props)
  2896. 						if ( rsingleTag.test( match[1] ) && jQuery.isPlainObject( context ) ) {
  2897. 							for ( match in context ) {
  2898. 								// Properties of context are called as methods if possible
  2899. 								if ( jQuery.isFunction( this[ match ] ) ) {
  2900. 									this[ match ]( context[ match ] );
  2901. 	
  2902. 								// ...and otherwise set as attributes
  2903. 								} else {
  2904. 									this.attr( match, context[ match ] );
  2905. 								}
  2906. 							}
  2907. 						}
  2908. 	
  2909. 						return this;
  2910. 	
  2911. 					// HANDLE: $(#id)
  2912. 					} else {
  2913. 						elem = document.getElementById( match[2] );
  2914. 	
  2915. 						// Support: Blackberry 4.6
  2916. 						// gEBID returns nodes no longer in the document (#6963)
  2917. 						if ( elem && elem.parentNode ) {
  2918. 							// Inject the element directly into the jQuery object
  2919. 							this.length = 1;
  2920. 							this[0] = elem;
  2921. 						}
  2922. 	
  2923. 						this.context = document;
  2924. 						this.selector = selector;
  2925. 						return this;
  2926. 					}
  2927. 	
  2928. 				// HANDLE: $(expr, $(...))
  2929. 				} else if ( !context || context.jquery ) {
  2930. 					return ( context || rootjQuery ).find( selector );
  2931. 	
  2932. 				// HANDLE: $(expr, context)
  2933. 				// (which is just equivalent to: $(context).find(expr)
  2934. 				} else {
  2935. 					return this.constructor( context ).find( selector );
  2936. 				}
  2937. 	
  2938. 			// HANDLE: $(DOMElement)
  2939. 			} else if ( selector.nodeType ) {
  2940. 				this.context = this[0] = selector;
  2941. 				this.length = 1;
  2942. 				return this;
  2943. 	
  2944. 			// HANDLE: $(function)
  2945. 			// Shortcut for document ready
  2946. 			} else if ( jQuery.isFunction( selector ) ) {
  2947. 				return typeof rootjQuery.ready !== "undefined" ?
  2948. 					rootjQuery.ready( selector ) :
  2949. 					// Execute immediately if ready is not present
  2950. 					selector( jQuery );
  2951. 			}
  2952. 	
  2953. 			if ( selector.selector !== undefined ) {
  2954. 				this.selector = selector.selector;
  2955. 				this.context = selector.context;
  2956. 			}
  2957. 	
  2958. 			return jQuery.makeArray( selector, this );
  2959. 		};
  2960. 	
  2961. 	// Give the init function the jQuery prototype for later instantiation
  2962. 	init.prototype = jQuery.fn;
  2963. 	
  2964. 	// Initialize central reference
  2965. 	rootjQuery = jQuery( document );
  2966. 	
  2967. 	
  2968. 	var rparentsprev = /^(?:parents|prev(?:Until|All))/,
  2969. 		// Methods guaranteed to produce a unique set when starting from a unique set
  2970. 		guaranteedUnique = {
  2971. 			children: true,
  2972. 			contents: true,
  2973. 			next: true,
  2974. 			prev: true
  2975. 		};
  2976. 	
  2977. 	jQuery.extend({
  2978. 		dir: function( elem, dir, until ) {
  2979. 			var matched = [],
  2980. 				truncate = until !== undefined;
  2981. 	
  2982. 			while ( (elem = elem[ dir ]) && elem.nodeType !== 9 ) {
  2983. 				if ( elem.nodeType === 1 ) {
  2984. 					if ( truncate && jQuery( elem ).is( until ) ) {
  2985. 						break;
  2986. 					}
  2987. 					matched.push( elem );
  2988. 				}
  2989. 			}
  2990. 			return matched;
  2991. 		},
  2992. 	
  2993. 		sibling: function( n, elem ) {
  2994. 			var matched = [];
  2995. 	
  2996. 			for ( ; n; n = n.nextSibling ) {
  2997. 				if ( n.nodeType === 1 && n !== elem ) {
  2998. 					matched.push( n );
  2999. 				}
  3000. 			}
  3001. 	
  3002. 			return matched;
  3003. 		}
  3004. 	});
  3005. 	
  3006. 	jQuery.fn.extend({
  3007. 		has: function( target ) {
  3008. 			var targets = jQuery( target, this ),
  3009. 				l = targets.length;
  3010. 	
  3011. 			return this.filter(function() {
  3012. 				var i = 0;
  3013. 				for ( ; i < l; i++ ) {
  3014. 					if ( jQuery.contains( this, targets[i] ) ) {
  3015. 						return true;
  3016. 					}
  3017. 				}
  3018. 			});
  3019. 		},
  3020. 	
  3021. 		closest: function( selectors, context ) {
  3022. 			var cur,
  3023. 				i = 0,
  3024. 				l = this.length,
  3025. 				matched = [],
  3026. 				pos = rneedsContext.test( selectors ) || typeof selectors !== "string" ?
  3027. 					jQuery( selectors, context || this.context ) :
  3028. 					0;
  3029. 	
  3030. 			for ( ; i < l; i++ ) {
  3031. 				for ( cur = this[i]; cur && cur !== context; cur = cur.parentNode ) {
  3032. 					// Always skip document fragments
  3033. 					if ( cur.nodeType < 11 && (pos ?
  3034. 						pos.index(cur) > -1 :
  3035. 	
  3036. 						// Don't pass non-elements to Sizzle
  3037. 						cur.nodeType === 1 &&
  3038. 							jQuery.find.matchesSelector(cur, selectors)) ) {
  3039. 	
  3040. 						matched.push( cur );
  3041. 						break;
  3042. 					}
  3043. 				}
  3044. 			}
  3045. 	
  3046. 			return this.pushStack( matched.length > 1 ? jQuery.unique( matched ) : matched );
  3047. 		},
  3048. 	
  3049. 		// Determine the position of an element within the set
  3050. 		index: function( elem ) {
  3051. 	
  3052. 			// No argument, return index in parent
  3053. 			if ( !elem ) {
  3054. 				return ( this[ 0 ] && this[ 0 ].parentNode ) ? this.first().prevAll().length : -1;
  3055. 			}
  3056. 	
  3057. 			// Index in selector
  3058. 			if ( typeof elem === "string" ) {
  3059. 				return indexOf.call( jQuery( elem ), this[ 0 ] );
  3060. 			}
  3061. 	
  3062. 			// Locate the position of the desired element
  3063. 			return indexOf.call( this,
  3064. 	
  3065. 				// If it receives a jQuery object, the first element is used
  3066. 				elem.jquery ? elem[ 0 ] : elem
  3067. 			);
  3068. 		},
  3069. 	
  3070. 		add: function( selector, context ) {
  3071. 			return this.pushStack(
  3072. 				jQuery.unique(
  3073. 					jQuery.merge( this.get(), jQuery( selector, context ) )
  3074. 				)
  3075. 			);
  3076. 		},
  3077. 	
  3078. 		addBack: function( selector ) {
  3079. 			return this.add( selector == null ?
  3080. 				this.prevObject : this.prevObject.filter(selector)
  3081. 			);
  3082. 		}
  3083. 	});
  3084. 	
  3085. 	function sibling( cur, dir ) {
  3086. 		while ( (cur = cur[dir]) && cur.nodeType !== 1 ) {}
  3087. 		return cur;
  3088. 	}
  3089. 	
  3090. 	jQuery.each({
  3091. 		parent: function( elem ) {
  3092. 			var parent = elem.parentNode;
  3093. 			return parent && parent.nodeType !== 11 ? parent : null;
  3094. 		},
  3095. 		parents: function( elem ) {
  3096. 			return jQuery.dir( elem, "parentNode" );
  3097. 		},
  3098. 		parentsUntil: function( elem, i, until ) {
  3099. 			return jQuery.dir( elem, "parentNode", until );
  3100. 		},
  3101. 		next: function( elem ) {
  3102. 			return sibling( elem, "nextSibling" );
  3103. 		},
  3104. 		prev: function( elem ) {
  3105. 			return sibling( elem, "previousSibling" );
  3106. 		},
  3107. 		nextAll: function( elem ) {
  3108. 			return jQuery.dir( elem, "nextSibling" );
  3109. 		},
  3110. 		prevAll: function( elem ) {
  3111. 			return jQuery.dir( elem, "previousSibling" );
  3112. 		},
  3113. 		nextUntil: function( elem, i, until ) {
  3114. 			return jQuery.dir( elem, "nextSibling", until );
  3115. 		},
  3116. 		prevUntil: function( elem, i, until ) {
  3117. 			return jQuery.dir( elem, "previousSibling", until );
  3118. 		},
  3119. 		siblings: function( elem ) {
  3120. 			return jQuery.sibling( ( elem.parentNode || {} ).firstChild, elem );
  3121. 		},
  3122. 		children: function( elem ) {
  3123. 			return jQuery.sibling( elem.firstChild );
  3124. 		},
  3125. 		contents: function( elem ) {
  3126. 			return elem.contentDocument || jQuery.merge( [], elem.childNodes );
  3127. 		}
  3128. 	}, function( name, fn ) {
  3129. 		jQuery.fn[ name ] = function( until, selector ) {
  3130. 			var matched = jQuery.map( this, fn, until );
  3131. 	
  3132. 			if ( name.slice( -5 ) !== "Until" ) {
  3133. 				selector = until;
  3134. 			}
  3135. 	
  3136. 			if ( selector && typeof selector === "string" ) {
  3137. 				matched = jQuery.filter( selector, matched );
  3138. 			}
  3139. 	
  3140. 			if ( this.length > 1 ) {
  3141. 				// Remove duplicates
  3142. 				if ( !guaranteedUnique[ name ] ) {
  3143. 					jQuery.unique( matched );
  3144. 				}
  3145. 	
  3146. 				// Reverse order for parents* and prev-derivatives
  3147. 				if ( rparentsprev.test( name ) ) {
  3148. 					matched.reverse();
  3149. 				}
  3150. 			}
  3151. 	
  3152. 			return this.pushStack( matched );
  3153. 		};
  3154. 	});
  3155. 	var rnotwhite = (/\S+/g);
  3156. 	
  3157. 	
  3158. 	
  3159. 	// String to Object options format cache
  3160. 	var optionsCache = {};
  3161. 	
  3162. 	// Convert String-formatted options into Object-formatted ones and store in cache
  3163. 	function createOptions( options ) {
  3164. 		var object = optionsCache[ options ] = {};
  3165. 		jQuery.each( options.match( rnotwhite ) || [], function( _, flag ) {
  3166. 			object[ flag ] = true;
  3167. 		});
  3168. 		return object;
  3169. 	}
  3170. 	
  3171. 	/*
  3172. 	 * Create a callback list using the following parameters:
  3173. 	 *
  3174. 	 *	options: an optional list of space-separated options that will change how
  3175. 	 *			the callback list behaves or a more traditional option object
  3176. 	 *
  3177. 	 * By default a callback list will act like an event callback list and can be
  3178. 	 * "fired" multiple times.
  3179. 	 *
  3180. 	 * Possible options:
  3181. 	 *
  3182. 	 *	once:			will ensure the callback list can only be fired once (like a Deferred)
  3183. 	 *
  3184. 	 *	memory:			will keep track of previous values and will call any callback added
  3185. 	 *					after the list has been fired right away with the latest "memorized"
  3186. 	 *					values (like a Deferred)
  3187. 	 *
  3188. 	 *	unique:			will ensure a callback can only be added once (no duplicate in the list)
  3189. 	 *
  3190. 	 *	stopOnFalse:	interrupt callings when a callback returns false
  3191. 	 *
  3192. 	 */
  3193. 	jQuery.Callbacks = function( options ) {
  3194. 	
  3195. 		// Convert options from String-formatted to Object-formatted if needed
  3196. 		// (we check in cache first)
  3197. 		options = typeof options === "string" ?
  3198. 			( optionsCache[ options ] || createOptions( options ) ) :
  3199. 			jQuery.extend( {}, options );
  3200. 	
  3201. 		var // Last fire value (for non-forgettable lists)
  3202. 			memory,
  3203. 			// Flag to know if list was already fired
  3204. 			fired,
  3205. 			// Flag to know if list is currently firing
  3206. 			firing,
  3207. 			// First callback to fire (used internally by add and fireWith)
  3208. 			firingStart,
  3209. 			// End of the loop when firing
  3210. 			firingLength,
  3211. 			// Index of currently firing callback (modified by remove if needed)
  3212. 			firingIndex,
  3213. 			// Actual callback list
  3214. 			list = [],
  3215. 			// Stack of fire calls for repeatable lists
  3216. 			stack = !options.once && [],
  3217. 			// Fire callbacks
  3218. 			fire = function( data ) {
  3219. 				memory = options.memory && data;
  3220. 				fired = true;
  3221. 				firingIndex = firingStart || 0;
  3222. 				firingStart = 0;
  3223. 				firingLength = list.length;
  3224. 				firing = true;
  3225. 				for ( ; list && firingIndex < firingLength; firingIndex++ ) {
  3226. 					if ( list[ firingIndex ].apply( data[ 0 ], data[ 1 ] ) === false && options.stopOnFalse ) {
  3227. 						memory = false; // To prevent further calls using add
  3228. 						break;
  3229. 					}
  3230. 				}
  3231. 				firing = false;
  3232. 				if ( list ) {
  3233. 					if ( stack ) {
  3234. 						if ( stack.length ) {
  3235. 							fire( stack.shift() );
  3236. 						}
  3237. 					} else if ( memory ) {
  3238. 						list = [];
  3239. 					} else {
  3240. 						self.disable();
  3241. 					}
  3242. 				}
  3243. 			},
  3244. 			// Actual Callbacks object
  3245. 			self = {
  3246. 				// Add a callback or a collection of callbacks to the list
  3247. 				add: function() {
  3248. 					if ( list ) {
  3249. 						// First, we save the current length
  3250. 						var start = list.length;
  3251. 						(function add( args ) {
  3252. 							jQuery.each( args, function( _, arg ) {
  3253. 								var type = jQuery.type( arg );
  3254. 								if ( type === "function" ) {
  3255. 									if ( !options.unique || !self.has( arg ) ) {
  3256. 										list.push( arg );
  3257. 									}
  3258. 								} else if ( arg && arg.length && type !== "string" ) {
  3259. 									// Inspect recursively
  3260. 									add( arg );
  3261. 								}
  3262. 							});
  3263. 						})( arguments );
  3264. 						// Do we need to add the callbacks to the
  3265. 						// current firing batch?
  3266. 						if ( firing ) {
  3267. 							firingLength = list.length;
  3268. 						// With memory, if we're not firing then
  3269. 						// we should call right away
  3270. 						} else if ( memory ) {
  3271. 							firingStart = start;
  3272. 							fire( memory );
  3273. 						}
  3274. 					}
  3275. 					return this;
  3276. 				},
  3277. 				// Remove a callback from the list
  3278. 				remove: function() {
  3279. 					if ( list ) {
  3280. 						jQuery.each( arguments, function( _, arg ) {
  3281. 							var index;
  3282. 							while ( ( index = jQuery.inArray( arg, list, index ) ) > -1 ) {
  3283. 								list.splice( index, 1 );
  3284. 								// Handle firing indexes
  3285. 								if ( firing ) {
  3286. 									if ( index <= firingLength ) {
  3287. 										firingLength--;
  3288. 									}
  3289. 									if ( index <= firingIndex ) {
  3290. 										firingIndex--;
  3291. 									}
  3292. 								}
  3293. 							}
  3294. 						});
  3295. 					}
  3296. 					return this;
  3297. 				},
  3298. 				// Check if a given callback is in the list.
  3299. 				// If no argument is given, return whether or not list has callbacks attached.
  3300. 				has: function( fn ) {
  3301. 					return fn ? jQuery.inArray( fn, list ) > -1 : !!( list && list.length );
  3302. 				},
  3303. 				// Remove all callbacks from the list
  3304. 				empty: function() {
  3305. 					list = [];
  3306. 					firingLength = 0;
  3307. 					return this;
  3308. 				},
  3309. 				// Have the list do nothing anymore
  3310. 				disable: function() {
  3311. 					list = stack = memory = undefined;
  3312. 					return this;
  3313. 				},
  3314. 				// Is it disabled?
  3315. 				disabled: function() {
  3316. 					return !list;
  3317. 				},
  3318. 				// Lock the list in its current state
  3319. 				lock: function() {
  3320. 					stack = undefined;
  3321. 					if ( !memory ) {
  3322. 						self.disable();
  3323. 					}
  3324. 					return this;
  3325. 				},
  3326. 				// Is it locked?
  3327. 				locked: function() {
  3328. 					return !stack;
  3329. 				},
  3330. 				// Call all callbacks with the given context and arguments
  3331. 				fireWith: function( context, args ) {
  3332. 					if ( list && ( !fired || stack ) ) {
  3333. 						args = args || [];
  3334. 						args = [ context, args.slice ? args.slice() : args ];
  3335. 						if ( firing ) {
  3336. 							stack.push( args );
  3337. 						} else {
  3338. 							fire( args );
  3339. 						}
  3340. 					}
  3341. 					return this;
  3342. 				},
  3343. 				// Call all the callbacks with the given arguments
  3344. 				fire: function() {
  3345. 					self.fireWith( this, arguments );
  3346. 					return this;
  3347. 				},
  3348. 				// To know if the callbacks have already been called at least once
  3349. 				fired: function() {
  3350. 					return !!fired;
  3351. 				}
  3352. 			};
  3353. 	
  3354. 		return self;
  3355. 	};
  3356. 	
  3357. 	
  3358. 	jQuery.extend({
  3359. 	
  3360. 		Deferred: function( func ) {
  3361. 			var tuples = [
  3362. 					// action, add listener, listener list, final state
  3363. 					[ "resolve", "done", jQuery.Callbacks("once memory"), "resolved" ],
  3364. 					[ "reject", "fail", jQuery.Callbacks("once memory"), "rejected" ],
  3365. 					[ "notify", "progress", jQuery.Callbacks("memory") ]
  3366. 				],
  3367. 				state = "pending",
  3368. 				promise = {
  3369. 					state: function() {
  3370. 						return state;
  3371. 					},
  3372. 					always: function() {
  3373. 						deferred.done( arguments ).fail( arguments );
  3374. 						return this;
  3375. 					},
  3376. 					then: function( /* fnDone, fnFail, fnProgress */ ) {
  3377. 						var fns = arguments;
  3378. 						return jQuery.Deferred(function( newDefer ) {
  3379. 							jQuery.each( tuples, function( i, tuple ) {
  3380. 								var fn = jQuery.isFunction( fns[ i ] ) && fns[ i ];
  3381. 								// deferred[ done | fail | progress ] for forwarding actions to newDefer
  3382. 								deferred[ tuple[1] ](function() {
  3383. 									var returned = fn && fn.apply( this, arguments );
  3384. 									if ( returned && jQuery.isFunction( returned.promise ) ) {
  3385. 										returned.promise()
  3386. 											.done( newDefer.resolve )
  3387. 											.fail( newDefer.reject )
  3388. 											.progress( newDefer.notify );
  3389. 									} else {
  3390. 										newDefer[ tuple[ 0 ] + "With" ]( this === promise ? newDefer.promise() : this, fn ? [ returned ] : arguments );
  3391. 									}
  3392. 								});
  3393. 							});
  3394. 							fns = null;
  3395. 						}).promise();
  3396. 					},
  3397. 					// Get a promise for this deferred
  3398. 					// If obj is provided, the promise aspect is added to the object
  3399. 					promise: function( obj ) {
  3400. 						return obj != null ? jQuery.extend( obj, promise ) : promise;
  3401. 					}
  3402. 				},
  3403. 				deferred = {};
  3404. 	
  3405. 			// Keep pipe for back-compat
  3406. 			promise.pipe = promise.then;
  3407. 	
  3408. 			// Add list-specific methods
  3409. 			jQuery.each( tuples, function( i, tuple ) {
  3410. 				var list = tuple[ 2 ],
  3411. 					stateString = tuple[ 3 ];
  3412. 	
  3413. 				// promise[ done | fail | progress ] = list.add
  3414. 				promise[ tuple[1] ] = list.add;
  3415. 	
  3416. 				// Handle state
  3417. 				if ( stateString ) {
  3418. 					list.add(function() {
  3419. 						// state = [ resolved | rejected ]
  3420. 						state = stateString;
  3421. 	
  3422. 					// [ reject_list | resolve_list ].disable; progress_list.lock
  3423. 					}, tuples[ i ^ 1 ][ 2 ].disable, tuples[ 2 ][ 2 ].lock );
  3424. 				}
  3425. 	
  3426. 				// deferred[ resolve | reject | notify ]
  3427. 				deferred[ tuple[0] ] = function() {
  3428. 					deferred[ tuple[0] + "With" ]( this === deferred ? promise : this, arguments );
  3429. 					return this;
  3430. 				};
  3431. 				deferred[ tuple[0] + "With" ] = list.fireWith;
  3432. 			});
  3433. 	
  3434. 			// Make the deferred a promise
  3435. 			promise.promise( deferred );
  3436. 	
  3437. 			// Call given func if any
  3438. 			if ( func ) {
  3439. 				func.call( deferred, deferred );
  3440. 			}
  3441. 	
  3442. 			// All done!
  3443. 			return deferred;
  3444. 		},
  3445. 	
  3446. 		// Deferred helper
  3447. 		when: function( subordinate /* , ..., subordinateN */ ) {
  3448. 			var i = 0,
  3449. 				resolveValues = slice.call( arguments ),
  3450. 				length = resolveValues.length,
  3451. 	
  3452. 				// the count of uncompleted subordinates
  3453. 				remaining = length !== 1 || ( subordinate && jQuery.isFunction( subordinate.promise ) ) ? length : 0,
  3454. 	
  3455. 				// the master Deferred. If resolveValues consist of only a single Deferred, just use that.
  3456. 				deferred = remaining === 1 ? subordinate : jQuery.Deferred(),
  3457. 	
  3458. 				// Update function for both resolve and progress values
  3459. 				updateFunc = function( i, contexts, values ) {
  3460. 					return function( value ) {
  3461. 						contexts[ i ] = this;
  3462. 						values[ i ] = arguments.length > 1 ? slice.call( arguments ) : value;
  3463. 						if ( values === progressValues ) {
  3464. 							deferred.notifyWith( contexts, values );
  3465. 						} else if ( !( --remaining ) ) {
  3466. 							deferred.resolveWith( contexts, values );
  3467. 						}
  3468. 					};
  3469. 				},
  3470. 	
  3471. 				progressValues, progressContexts, resolveContexts;
  3472. 	
  3473. 			// Add listeners to Deferred subordinates; treat others as resolved
  3474. 			if ( length > 1 ) {
  3475. 				progressValues = new Array( length );
  3476. 				progressContexts = new Array( length );
  3477. 				resolveContexts = new Array( length );
  3478. 				for ( ; i < length; i++ ) {
  3479. 					if ( resolveValues[ i ] && jQuery.isFunction( resolveValues[ i ].promise ) ) {
  3480. 						resolveValues[ i ].promise()
  3481. 							.done( updateFunc( i, resolveContexts, resolveValues ) )
  3482. 							.fail( deferred.reject )
  3483. 							.progress( updateFunc( i, progressContexts, progressValues ) );
  3484. 					} else {
  3485. 						--remaining;
  3486. 					}
  3487. 				}
  3488. 			}
  3489. 	
  3490. 			// If we're not waiting on anything, resolve the master
  3491. 			if ( !remaining ) {
  3492. 				deferred.resolveWith( resolveContexts, resolveValues );
  3493. 			}
  3494. 	
  3495. 			return deferred.promise();
  3496. 		}
  3497. 	});
  3498. 	
  3499. 	
  3500. 	// The deferred used on DOM ready
  3501. 	var readyList;
  3502. 	
  3503. 	jQuery.fn.ready = function( fn ) {
  3504. 		// Add the callback
  3505. 		jQuery.ready.promise().done( fn );
  3506. 	
  3507. 		return this;
  3508. 	};
  3509. 	
  3510. 	jQuery.extend({
  3511. 		// Is the DOM ready to be used? Set to true once it occurs.
  3512. 		isReady: false,
  3513. 	
  3514. 		// A counter to track how many items to wait for before
  3515. 		// the ready event fires. See #6781
  3516. 		readyWait: 1,
  3517. 	
  3518. 		// Hold (or release) the ready event
  3519. 		holdReady: function( hold ) {
  3520. 			if ( hold ) {
  3521. 				jQuery.readyWait++;
  3522. 			} else {
  3523. 				jQuery.ready( true );
  3524. 			}
  3525. 		},
  3526. 	
  3527. 		// Handle when the DOM is ready
  3528. 		ready: function( wait ) {
  3529. 	
  3530. 			// Abort if there are pending holds or we're already ready
  3531. 			if ( wait === true ? --jQuery.readyWait : jQuery.isReady ) {
  3532. 				return;
  3533. 			}
  3534. 	
  3535. 			// Remember that the DOM is ready
  3536. 			jQuery.isReady = true;
  3537. 	
  3538. 			// If a normal DOM Ready event fired, decrement, and wait if need be
  3539. 			if ( wait !== true && --jQuery.readyWait > 0 ) {
  3540. 				return;
  3541. 			}
  3542. 	
  3543. 			// If there are functions bound, to execute
  3544. 			readyList.resolveWith( document, [ jQuery ] );
  3545. 	
  3546. 			// Trigger any bound ready events
  3547. 			if ( jQuery.fn.triggerHandler ) {
  3548. 				jQuery( document ).triggerHandler( "ready" );
  3549. 				jQuery( document ).off( "ready" );
  3550. 			}
  3551. 		}
  3552. 	});
  3553. 	
  3554. 	/**
  3555. 	 * The ready event handler and self cleanup method
  3556. 	 */
  3557. 	function completed() {
  3558. 		document.removeEventListener( "DOMContentLoaded", completed, false );
  3559. 		window.removeEventListener( "load", completed, false );
  3560. 		jQuery.ready();
  3561. 	}
  3562. 	
  3563. 	jQuery.ready.promise = function( obj ) {
  3564. 		if ( !readyList ) {
  3565. 	
  3566. 			readyList = jQuery.Deferred();
  3567. 	
  3568. 			// Catch cases where $(document).ready() is called after the browser event has already occurred.
  3569. 			// We once tried to use readyState "interactive" here, but it caused issues like the one
  3570. 			// discovered by ChrisS here: http://bugs.jquery.com/ticket/12282#comment:15
  3571. 			if ( document.readyState === "complete" ) {
  3572. 				// Handle it asynchronously to allow scripts the opportunity to delay ready
  3573. 				setTimeout( jQuery.ready );
  3574. 	
  3575. 			} else {
  3576. 	
  3577. 				// Use the handy event callback
  3578. 				document.addEventListener( "DOMContentLoaded", completed, false );
  3579. 	
  3580. 				// A fallback to window.onload, that will always work
  3581. 				window.addEventListener( "load", completed, false );
  3582. 			}
  3583. 		}
  3584. 		return readyList.promise( obj );
  3585. 	};
  3586. 	
  3587. 	// Kick off the DOM ready check even if the user does not
  3588. 	jQuery.ready.promise();
  3589. 	
  3590. 	
  3591. 	
  3592. 	
  3593. 	// Multifunctional method to get and set values of a collection
  3594. 	// The value/s can optionally be executed if it's a function
  3595. 	var access = jQuery.access = function( elems, fn, key, value, chainable, emptyGet, raw ) {
  3596. 		var i = 0,
  3597. 			len = elems.length,
  3598. 			bulk = key == null;
  3599. 	
  3600. 		// Sets many values
  3601. 		if ( jQuery.type( key ) === "object" ) {
  3602. 			chainable = true;
  3603. 			for ( i in key ) {
  3604. 				jQuery.access( elems, fn, i, key[i], true, emptyGet, raw );
  3605. 			}
  3606. 	
  3607. 		// Sets one value
  3608. 		} else if ( value !== undefined ) {
  3609. 			chainable = true;
  3610. 	
  3611. 			if ( !jQuery.isFunction( value ) ) {
  3612. 				raw = true;
  3613. 			}
  3614. 	
  3615. 			if ( bulk ) {
  3616. 				// Bulk operations run against the entire set
  3617. 				if ( raw ) {
  3618. 					fn.call( elems, value );
  3619. 					fn = null;
  3620. 	
  3621. 				// ...except when executing function values
  3622. 				} else {
  3623. 					bulk = fn;
  3624. 					fn = function( elem, key, value ) {
  3625. 						return bulk.call( jQuery( elem ), value );
  3626. 					};
  3627. 				}
  3628. 			}
  3629. 	
  3630. 			if ( fn ) {
  3631. 				for ( ; i < len; i++ ) {
  3632. 					fn( elems[i], key, raw ? value : value.call( elems[i], i, fn( elems[i], key ) ) );
  3633. 				}
  3634. 			}
  3635. 		}
  3636. 	
  3637. 		return chainable ?
  3638. 			elems :
  3639. 	
  3640. 			// Gets
  3641. 			bulk ?
  3642. 				fn.call( elems ) :
  3643. 				len ? fn( elems[0], key ) : emptyGet;
  3644. 	};
  3645. 	
  3646. 	
  3647. 	/**
  3648. 	 * Determines whether an object can have data
  3649. 	 */
  3650. 	jQuery.acceptData = function( owner ) {
  3651. 		// Accepts only:
  3652. 		//  - Node
  3653. 		//    - Node.ELEMENT_NODE
  3654. 		//    - Node.DOCUMENT_NODE
  3655. 		//  - Object
  3656. 		//    - Any
  3657. 		/* jshint -W018 */
  3658. 		return owner.nodeType === 1 || owner.nodeType === 9 || !( +owner.nodeType );
  3659. 	};
  3660. 	
  3661. 	
  3662. 	function Data() {
  3663. 		// Support: Android<4,
  3664. 		// Old WebKit does not have Object.preventExtensions/freeze method,
  3665. 		// return new empty object instead with no [[set]] accessor
  3666. 		Object.defineProperty( this.cache = {}, 0, {
  3667. 			get: function() {
  3668. 				return {};
  3669. 			}
  3670. 		});
  3671. 	
  3672. 		this.expando = jQuery.expando + Data.uid++;
  3673. 	}
  3674. 	
  3675. 	Data.uid = 1;
  3676. 	Data.accepts = jQuery.acceptData;
  3677. 	
  3678. 	Data.prototype = {
  3679. 		key: function( owner ) {
  3680. 			// We can accept data for non-element nodes in modern browsers,
  3681. 			// but we should not, see #8335.
  3682. 			// Always return the key for a frozen object.
  3683. 			if ( !Data.accepts( owner ) ) {
  3684. 				return 0;
  3685. 			}
  3686. 	
  3687. 			var descriptor = {},
  3688. 				// Check if the owner object already has a cache key
  3689. 				unlock = owner[ this.expando ];
  3690. 	
  3691. 			// If not, create one
  3692. 			if ( !unlock ) {
  3693. 				unlock = Data.uid++;
  3694. 	
  3695. 				// Secure it in a non-enumerable, non-writable property
  3696. 				try {
  3697. 					descriptor[ this.expando ] = { value: unlock };
  3698. 					Object.defineProperties( owner, descriptor );
  3699. 	
  3700. 				// Support: Android<4
  3701. 				// Fallback to a less secure definition
  3702. 				} catch ( e ) {
  3703. 					descriptor[ this.expando ] = unlock;
  3704. 					jQuery.extend( owner, descriptor );
  3705. 				}
  3706. 			}
  3707. 	
  3708. 			// Ensure the cache object
  3709. 			if ( !this.cache[ unlock ] ) {
  3710. 				this.cache[ unlock ] = {};
  3711. 			}
  3712. 	
  3713. 			return unlock;
  3714. 		},
  3715. 		set: function( owner, data, value ) {
  3716. 			var prop,
  3717. 				// There may be an unlock assigned to this node,
  3718. 				// if there is no entry for this "owner", create one inline
  3719. 				// and set the unlock as though an owner entry had always existed
  3720. 				unlock = this.key( owner ),
  3721. 				cache = this.cache[ unlock ];
  3722. 	
  3723. 			// Handle: [ owner, key, value ] args
  3724. 			if ( typeof data === "string" ) {
  3725. 				cache[ data ] = value;
  3726. 	
  3727. 			// Handle: [ owner, { properties } ] args
  3728. 			} else {
  3729. 				// Fresh assignments by object are shallow copied
  3730. 				if ( jQuery.isEmptyObject( cache ) ) {
  3731. 					jQuery.extend( this.cache[ unlock ], data );
  3732. 				// Otherwise, copy the properties one-by-one to the cache object
  3733. 				} else {
  3734. 					for ( prop in data ) {
  3735. 						cache[ prop ] = data[ prop ];
  3736. 					}
  3737. 				}
  3738. 			}
  3739. 			return cache;
  3740. 		},
  3741. 		get: function( owner, key ) {
  3742. 			// Either a valid cache is found, or will be created.
  3743. 			// New caches will be created and the unlock returned,
  3744. 			// allowing direct access to the newly created
  3745. 			// empty data object. A valid owner object must be provided.
  3746. 			var cache = this.cache[ this.key( owner ) ];
  3747. 	
  3748. 			return key === undefined ?
  3749. 				cache : cache[ key ];
  3750. 		},
  3751. 		access: function( owner, key, value ) {
  3752. 			var stored;
  3753. 			// In cases where either:
  3754. 			//
  3755. 			//   1. No key was specified
  3756. 			//   2. A string key was specified, but no value provided
  3757. 			//
  3758. 			// Take the "read" path and allow the get method to determine
  3759. 			// which value to return, respectively either:
  3760. 			//
  3761. 			//   1. The entire cache object
  3762. 			//   2. The data stored at the key
  3763. 			//
  3764. 			if ( key === undefined ||
  3765. 					((key && typeof key === "string") && value === undefined) ) {
  3766. 	
  3767. 				stored = this.get( owner, key );
  3768. 	
  3769. 				return stored !== undefined ?
  3770. 					stored : this.get( owner, jQuery.camelCase(key) );
  3771. 			}
  3772. 	
  3773. 			// [*]When the key is not a string, or both a key and value
  3774. 			// are specified, set or extend (existing objects) with either:
  3775. 			//
  3776. 			//   1. An object of properties
  3777. 			//   2. A key and value
  3778. 			//
  3779. 			this.set( owner, key, value );
  3780. 	
  3781. 			// Since the "set" path can have two possible entry points
  3782. 			// return the expected data based on which path was taken[*]
  3783. 			return value !== undefined ? value : key;
  3784. 		},
  3785. 		remove: function( owner, key ) {
  3786. 			var i, name, camel,
  3787. 				unlock = this.key( owner ),
  3788. 				cache = this.cache[ unlock ];
  3789. 	
  3790. 			if ( key === undefined ) {
  3791. 				this.cache[ unlock ] = {};
  3792. 	
  3793. 			} else {
  3794. 				// Support array or space separated string of keys
  3795. 				if ( jQuery.isArray( key ) ) {
  3796. 					// If "name" is an array of keys...
  3797. 					// When data is initially created, via ("key", "val") signature,
  3798. 					// keys will be converted to camelCase.
  3799. 					// Since there is no way to tell _how_ a key was added, remove
  3800. 					// both plain key and camelCase key. #12786
  3801. 					// This will only penalize the array argument path.
  3802. 					name = key.concat( key.map( jQuery.camelCase ) );
  3803. 				} else {
  3804. 					camel = jQuery.camelCase( key );
  3805. 					// Try the string as a key before any manipulation
  3806. 					if ( key in cache ) {
  3807. 						name = [ key, camel ];
  3808. 					} else {
  3809. 						// If a key with the spaces exists, use it.
  3810. 						// Otherwise, create an array by matching non-whitespace
  3811. 						name = camel;
  3812. 						name = name in cache ?
  3813. 							[ name ] : ( name.match( rnotwhite ) || [] );
  3814. 					}
  3815. 				}
  3816. 	
  3817. 				i = name.length;
  3818. 				while ( i-- ) {
  3819. 					delete cache[ name[ i ] ];
  3820. 				}
  3821. 			}
  3822. 		},
  3823. 		hasData: function( owner ) {
  3824. 			return !jQuery.isEmptyObject(
  3825. 				this.cache[ owner[ this.expando ] ] || {}
  3826. 			);
  3827. 		},
  3828. 		discard: function( owner ) {
  3829. 			if ( owner[ this.expando ] ) {
  3830. 				delete this.cache[ owner[ this.expando ] ];
  3831. 			}
  3832. 		}
  3833. 	};
  3834. 	var data_priv = new Data();
  3835. 	
  3836. 	var data_user = new Data();
  3837. 	
  3838. 	
  3839. 	
  3840. 	//	Implementation Summary
  3841. 	//
  3842. 	//	1. Enforce API surface and semantic compatibility with 1.9.x branch
  3843. 	//	2. Improve the module's maintainability by reducing the storage
  3844. 	//		paths to a single mechanism.
  3845. 	//	3. Use the same single mechanism to support "private" and "user" data.
  3846. 	//	4. _Never_ expose "private" data to user code (TODO: Drop _data, _removeData)
  3847. 	//	5. Avoid exposing implementation details on user objects (eg. expando properties)
  3848. 	//	6. Provide a clear path for implementation upgrade to WeakMap in 2014
  3849. 	
  3850. 	var rbrace = /^(?:\{[\w\W]*\}|\[[\w\W]*\])$/,
  3851. 		rmultiDash = /([A-Z])/g;
  3852. 	
  3853. 	function dataAttr( elem, key, data ) {
  3854. 		var name;
  3855. 	
  3856. 		// If nothing was found internally, try to fetch any
  3857. 		// data from the HTML5 data-* attribute
  3858. 		if ( data === undefined && elem.nodeType === 1 ) {
  3859. 			name = "data-" + key.replace( rmultiDash, "-$1" ).toLowerCase();
  3860. 			data = elem.getAttribute( name );
  3861. 	
  3862. 			if ( typeof data === "string" ) {
  3863. 				try {
  3864. 					data = data === "true" ? true :
  3865. 						data === "false" ? false :
  3866. 						data === "null" ? null :
  3867. 						// Only convert to a number if it doesn't change the string
  3868. 						+data + "" === data ? +data :
  3869. 						rbrace.test( data ) ? jQuery.parseJSON( data ) :
  3870. 						data;
  3871. 				} catch( e ) {}
  3872. 	
  3873. 				// Make sure we set the data so it isn't changed later
  3874. 				data_user.set( elem, key, data );
  3875. 			} else {
  3876. 				data = undefined;
  3877. 			}
  3878. 		}
  3879. 		return data;
  3880. 	}
  3881. 	
  3882. 	jQuery.extend({
  3883. 		hasData: function( elem ) {
  3884. 			return data_user.hasData( elem ) || data_priv.hasData( elem );
  3885. 		},
  3886. 	
  3887. 		data: function( elem, name, data ) {
  3888. 			return data_user.access( elem, name, data );
  3889. 		},
  3890. 	
  3891. 		removeData: function( elem, name ) {
  3892. 			data_user.remove( elem, name );
  3893. 		},
  3894. 	
  3895. 		// TODO: Now that all calls to _data and _removeData have been replaced
  3896. 		// with direct calls to data_priv methods, these can be deprecated.
  3897. 		_data: function( elem, name, data ) {
  3898. 			return data_priv.access( elem, name, data );
  3899. 		},
  3900. 	
  3901. 		_removeData: function( elem, name ) {
  3902. 			data_priv.remove( elem, name );
  3903. 		}
  3904. 	});
  3905. 	
  3906. 	jQuery.fn.extend({
  3907. 		data: function( key, value ) {
  3908. 			var i, name, data,
  3909. 				elem = this[ 0 ],
  3910. 				attrs = elem && elem.attributes;
  3911. 	
  3912. 			// Gets all values
  3913. 			if ( key === undefined ) {
  3914. 				if ( this.length ) {
  3915. 					data = data_user.get( elem );
  3916. 	
  3917. 					if ( elem.nodeType === 1 && !data_priv.get( elem, "hasDataAttrs" ) ) {
  3918. 						i = attrs.length;
  3919. 						while ( i-- ) {
  3920. 	
  3921. 							// Support: IE11+
  3922. 							// The attrs elements can be null (#14894)
  3923. 							if ( attrs[ i ] ) {
  3924. 								name = attrs[ i ].name;
  3925. 								if ( name.indexOf( "data-" ) === 0 ) {
  3926. 									name = jQuery.camelCase( name.slice(5) );
  3927. 									dataAttr( elem, name, data[ name ] );
  3928. 								}
  3929. 							}
  3930. 						}
  3931. 						data_priv.set( elem, "hasDataAttrs", true );
  3932. 					}
  3933. 				}
  3934. 	
  3935. 				return data;
  3936. 			}
  3937. 	
  3938. 			// Sets multiple values
  3939. 			if ( typeof key === "object" ) {
  3940. 				return this.each(function() {
  3941. 					data_user.set( this, key );
  3942. 				});
  3943. 			}
  3944. 	
  3945. 			return access( this, function( value ) {
  3946. 				var data,
  3947. 					camelKey = jQuery.camelCase( key );
  3948. 	
  3949. 				// The calling jQuery object (element matches) is not empty
  3950. 				// (and therefore has an element appears at this[ 0 ]) and the
  3951. 				// `value` parameter was not undefined. An empty jQuery object
  3952. 				// will result in `undefined` for elem = this[ 0 ] which will
  3953. 				// throw an exception if an attempt to read a data cache is made.
  3954. 				if ( elem && value === undefined ) {
  3955. 					// Attempt to get data from the cache
  3956. 					// with the key as-is
  3957. 					data = data_user.get( elem, key );
  3958. 					if ( data !== undefined ) {
  3959. 						return data;
  3960. 					}
  3961. 	
  3962. 					// Attempt to get data from the cache
  3963. 					// with the key camelized
  3964. 					data = data_user.get( elem, camelKey );
  3965. 					if ( data !== undefined ) {
  3966. 						return data;
  3967. 					}
  3968. 	
  3969. 					// Attempt to "discover" the data in
  3970. 					// HTML5 custom data-* attrs
  3971. 					data = dataAttr( elem, camelKey, undefined );
  3972. 					if ( data !== undefined ) {
  3973. 						return data;
  3974. 					}
  3975. 	
  3976. 					// We tried really hard, but the data doesn't exist.
  3977. 					return;
  3978. 				}
  3979. 	
  3980. 				// Set the data...
  3981. 				this.each(function() {
  3982. 					// First, attempt to store a copy or reference of any
  3983. 					// data that might've been store with a camelCased key.
  3984. 					var data = data_user.get( this, camelKey );
  3985. 	
  3986. 					// For HTML5 data-* attribute interop, we have to
  3987. 					// store property names with dashes in a camelCase form.
  3988. 					// This might not apply to all properties...*
  3989. 					data_user.set( this, camelKey, value );
  3990. 	
  3991. 					// *... In the case of properties that might _actually_
  3992. 					// have dashes, we need to also store a copy of that
  3993. 					// unchanged property.
  3994. 					if ( key.indexOf("-") !== -1 && data !== undefined ) {
  3995. 						data_user.set( this, key, value );
  3996. 					}
  3997. 				});
  3998. 			}, null, value, arguments.length > 1, null, true );
  3999. 		},
  4000. 	
  4001. 		removeData: function( key ) {
  4002. 			return this.each(function() {
  4003. 				data_user.remove( this, key );
  4004. 			});
  4005. 		}
  4006. 	});
  4007. 	
  4008. 	
  4009. 	jQuery.extend({
  4010. 		queue: function( elem, type, data ) {
  4011. 			var queue;
  4012. 	
  4013. 			if ( elem ) {
  4014. 				type = ( type || "fx" ) + "queue";
  4015. 				queue = data_priv.get( elem, type );
  4016. 	
  4017. 				// Speed up dequeue by getting out quickly if this is just a lookup
  4018. 				if ( data ) {
  4019. 					if ( !queue || jQuery.isArray( data ) ) {
  4020. 						queue = data_priv.access( elem, type, jQuery.makeArray(data) );
  4021. 					} else {
  4022. 						queue.push( data );
  4023. 					}
  4024. 				}
  4025. 				return queue || [];
  4026. 			}
  4027. 		},
  4028. 	
  4029. 		dequeue: function( elem, type ) {
  4030. 			type = type || "fx";
  4031. 	
  4032. 			var queue = jQuery.queue( elem, type ),
  4033. 				startLength = queue.length,
  4034. 				fn = queue.shift(),
  4035. 				hooks = jQuery._queueHooks( elem, type ),
  4036. 				next = function() {
  4037. 					jQuery.dequeue( elem, type );
  4038. 				};
  4039. 	
  4040. 			// If the fx queue is dequeued, always remove the progress sentinel
  4041. 			if ( fn === "inprogress" ) {
  4042. 				fn = queue.shift();
  4043. 				startLength--;
  4044. 			}
  4045. 	
  4046. 			if ( fn ) {
  4047. 	
  4048. 				// Add a progress sentinel to prevent the fx queue from being
  4049. 				// automatically dequeued
  4050. 				if ( type === "fx" ) {
  4051. 					queue.unshift( "inprogress" );
  4052. 				}
  4053. 	
  4054. 				// Clear up the last queue stop function
  4055. 				delete hooks.stop;
  4056. 				fn.call( elem, next, hooks );
  4057. 			}
  4058. 	
  4059. 			if ( !startLength && hooks ) {
  4060. 				hooks.empty.fire();
  4061. 			}
  4062. 		},
  4063. 	
  4064. 		// Not public - generate a queueHooks object, or return the current one
  4065. 		_queueHooks: function( elem, type ) {
  4066. 			var key = type + "queueHooks";
  4067. 			return data_priv.get( elem, key ) || data_priv.access( elem, key, {
  4068. 				empty: jQuery.Callbacks("once memory").add(function() {
  4069. 					data_priv.remove( elem, [ type + "queue", key ] );
  4070. 				})
  4071. 			});
  4072. 		}
  4073. 	});
  4074. 	
  4075. 	jQuery.fn.extend({
  4076. 		queue: function( type, data ) {
  4077. 			var setter = 2;
  4078. 	
  4079. 			if ( typeof type !== "string" ) {
  4080. 				data = type;
  4081. 				type = "fx";
  4082. 				setter--;
  4083. 			}
  4084. 	
  4085. 			if ( arguments.length < setter ) {
  4086. 				return jQuery.queue( this[0], type );
  4087. 			}
  4088. 	
  4089. 			return data === undefined ?
  4090. 				this :
  4091. 				this.each(function() {
  4092. 					var queue = jQuery.queue( this, type, data );
  4093. 	
  4094. 					// Ensure a hooks for this queue
  4095. 					jQuery._queueHooks( this, type );
  4096. 	
  4097. 					if ( type === "fx" && queue[0] !== "inprogress" ) {
  4098. 						jQuery.dequeue( this, type );
  4099. 					}
  4100. 				});
  4101. 		},
  4102. 		dequeue: function( type ) {
  4103. 			return this.each(function() {
  4104. 				jQuery.dequeue( this, type );
  4105. 			});
  4106. 		},
  4107. 		clearQueue: function( type ) {
  4108. 			return this.queue( type || "fx", [] );
  4109. 		},
  4110. 		// Get a promise resolved when queues of a certain type
  4111. 		// are emptied (fx is the type by default)
  4112. 		promise: function( type, obj ) {
  4113. 			var tmp,
  4114. 				count = 1,
  4115. 				defer = jQuery.Deferred(),
  4116. 				elements = this,
  4117. 				i = this.length,
  4118. 				resolve = function() {
  4119. 					if ( !( --count ) ) {
  4120. 						defer.resolveWith( elements, [ elements ] );
  4121. 					}
  4122. 				};
  4123. 	
  4124. 			if ( typeof type !== "string" ) {
  4125. 				obj = type;
  4126. 				type = undefined;
  4127. 			}
  4128. 			type = type || "fx";
  4129. 	
  4130. 			while ( i-- ) {
  4131. 				tmp = data_priv.get( elements[ i ], type + "queueHooks" );
  4132. 				if ( tmp && tmp.empty ) {
  4133. 					count++;
  4134. 					tmp.empty.add( resolve );
  4135. 				}
  4136. 			}
  4137. 			resolve();
  4138. 			return defer.promise( obj );
  4139. 		}
  4140. 	});
  4141. 	var pnum = (/[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/).source;
  4142. 	
  4143. 	var cssExpand = [ "Top", "Right", "Bottom", "Left" ];
  4144. 	
  4145. 	var isHidden = function( elem, el ) {
  4146. 			// isHidden might be called from jQuery#filter function;
  4147. 			// in that case, element will be second argument
  4148. 			elem = el || elem;
  4149. 			return jQuery.css( elem, "display" ) === "none" || !jQuery.contains( elem.ownerDocument, elem );
  4150. 		};
  4151. 	
  4152. 	var rcheckableType = (/^(?:checkbox|radio)$/i);
  4153. 	
  4154. 	
  4155. 	
  4156. 	(function() {
  4157. 		var fragment = document.createDocumentFragment(),
  4158. 			div = fragment.appendChild( document.createElement( "div" ) ),
  4159. 			input = document.createElement( "input" );
  4160. 	
  4161. 		// Support: Safari<=5.1
  4162. 		// Check state lost if the name is set (#11217)
  4163. 		// Support: Windows Web Apps (WWA)
  4164. 		// `name` and `type` must use .setAttribute for WWA (#14901)
  4165. 		input.setAttribute( "type", "radio" );
  4166. 		input.setAttribute( "checked", "checked" );
  4167. 		input.setAttribute( "name", "t" );
  4168. 	
  4169. 		div.appendChild( input );
  4170. 	
  4171. 		// Support: Safari<=5.1, Android<4.2
  4172. 		// Older WebKit doesn't clone checked state correctly in fragments
  4173. 		support.checkClone = div.cloneNode( true ).cloneNode( true ).lastChild.checked;
  4174. 	
  4175. 		// Support: IE<=11+
  4176. 		// Make sure textarea (and checkbox) defaultValue is properly cloned
  4177. 		div.innerHTML = "<textarea>x</textarea>";
  4178. 		support.noCloneChecked = !!div.cloneNode( true ).lastChild.defaultValue;
  4179. 	})();
  4180. 	var strundefined = typeof undefined;
  4181. 	
  4182. 	
  4183. 	
  4184. 	support.focusinBubbles = "onfocusin" in window;
  4185. 	
  4186. 	
  4187. 	var
  4188. 		rkeyEvent = /^key/,
  4189. 		rmouseEvent = /^(?:mouse|pointer|contextmenu)|click/,
  4190. 		rfocusMorph = /^(?:focusinfocus|focusoutblur)$/,
  4191. 		rtypenamespace = /^([^.]*)(?:\.(.+)|)$/;
  4192. 	
  4193. 	function returnTrue() {
  4194. 		return true;
  4195. 	}
  4196. 	
  4197. 	function returnFalse() {
  4198. 		return false;
  4199. 	}
  4200. 	
  4201. 	function safeActiveElement() {
  4202. 		try {
  4203. 			return document.activeElement;
  4204. 		} catch ( err ) { }
  4205. 	}
  4206. 	
  4207. 	/*
  4208. 	 * Helper functions for managing events -- not part of the public interface.
  4209. 	 * Props to Dean Edwards' addEvent library for many of the ideas.
  4210. 	 */
  4211. 	jQuery.event = {
  4212. 	
  4213. 		global: {},
  4214. 	
  4215. 		add: function( elem, types, handler, data, selector ) {
  4216. 	
  4217. 			var handleObjIn, eventHandle, tmp,
  4218. 				events, t, handleObj,
  4219. 				special, handlers, type, namespaces, origType,
  4220. 				elemData = data_priv.get( elem );
  4221. 	
  4222. 			// Don't attach events to noData or text/comment nodes (but allow plain objects)
  4223. 			if ( !elemData ) {
  4224. 				return;
  4225. 			}
  4226. 	
  4227. 			// Caller can pass in an object of custom data in lieu of the handler
  4228. 			if ( handler.handler ) {
  4229. 				handleObjIn = handler;
  4230. 				handler = handleObjIn.handler;
  4231. 				selector = handleObjIn.selector;
  4232. 			}
  4233. 	
  4234. 			// Make sure that the handler has a unique ID, used to find/remove it later
  4235. 			if ( !handler.guid ) {
  4236. 				handler.guid = jQuery.guid++;
  4237. 			}
  4238. 	
  4239. 			// Init the element's event structure and main handler, if this is the first
  4240. 			if ( !(events = elemData.events) ) {
  4241. 				events = elemData.events = {};
  4242. 			}
  4243. 			if ( !(eventHandle = elemData.handle) ) {
  4244. 				eventHandle = elemData.handle = function( e ) {
  4245. 					// Discard the second event of a jQuery.event.trigger() and
  4246. 					// when an event is called after a page has unloaded
  4247. 					return typeof jQuery !== strundefined && jQuery.event.triggered !== e.type ?
  4248. 						jQuery.event.dispatch.apply( elem, arguments ) : undefined;
  4249. 				};
  4250. 			}
  4251. 	
  4252. 			// Handle multiple events separated by a space
  4253. 			types = ( types || "" ).match( rnotwhite ) || [ "" ];
  4254. 			t = types.length;
  4255. 			while ( t-- ) {
  4256. 				tmp = rtypenamespace.exec( types[t] ) || [];
  4257. 				type = origType = tmp[1];
  4258. 				namespaces = ( tmp[2] || "" ).split( "." ).sort();
  4259. 	
  4260. 				// There *must* be a type, no attaching namespace-only handlers
  4261. 				if ( !type ) {
  4262. 					continue;
  4263. 				}
  4264. 	
  4265. 				// If event changes its type, use the special event handlers for the changed type
  4266. 				special = jQuery.event.special[ type ] || {};
  4267. 	
  4268. 				// If selector defined, determine special event api type, otherwise given type
  4269. 				type = ( selector ? special.delegateType : special.bindType ) || type;
  4270. 	
  4271. 				// Update special based on newly reset type
  4272. 				special = jQuery.event.special[ type ] || {};
  4273. 	
  4274. 				// handleObj is passed to all event handlers
  4275. 				handleObj = jQuery.extend({
  4276. 					type: type,
  4277. 					origType: origType,
  4278. 					data: data,
  4279. 					handler: handler,
  4280. 					guid: handler.guid,
  4281. 					selector: selector,
  4282. 					needsContext: selector && jQuery.expr.match.needsContext.test( selector ),
  4283. 					namespace: namespaces.join(".")
  4284. 				}, handleObjIn );
  4285. 	
  4286. 				// Init the event handler queue if we're the first
  4287. 				if ( !(handlers = events[ type ]) ) {
  4288. 					handlers = events[ type ] = [];
  4289. 					handlers.delegateCount = 0;
  4290. 	
  4291. 					// Only use addEventListener if the special events handler returns false
  4292. 					if ( !special.setup || special.setup.call( elem, data, namespaces, eventHandle ) === false ) {
  4293. 						if ( elem.addEventListener ) {
  4294. 							elem.addEventListener( type, eventHandle, false );
  4295. 						}
  4296. 					}
  4297. 				}
  4298. 	
  4299. 				if ( special.add ) {
  4300. 					special.add.call( elem, handleObj );
  4301. 	
  4302. 					if ( !handleObj.handler.guid ) {
  4303. 						handleObj.handler.guid = handler.guid;
  4304. 					}
  4305. 				}
  4306. 	
  4307. 				// Add to the element's handler list, delegates in front
  4308. 				if ( selector ) {
  4309. 					handlers.splice( handlers.delegateCount++, 0, handleObj );
  4310. 				} else {
  4311. 					handlers.push( handleObj );
  4312. 				}
  4313. 	
  4314. 				// Keep track of which events have ever been used, for event optimization
  4315. 				jQuery.event.global[ type ] = true;
  4316. 			}
  4317. 	
  4318. 		},
  4319. 	
  4320. 		// Detach an event or set of events from an element
  4321. 		remove: function( elem, types, handler, selector, mappedTypes ) {
  4322. 	
  4323. 			var j, origCount, tmp,
  4324. 				events, t, handleObj,
  4325. 				special, handlers, type, namespaces, origType,
  4326. 				elemData = data_priv.hasData( elem ) && data_priv.get( elem );
  4327. 	
  4328. 			if ( !elemData || !(events = elemData.events) ) {
  4329. 				return;
  4330. 			}
  4331. 	
  4332. 			// Once for each type.namespace in types; type may be omitted
  4333. 			types = ( types || "" ).match( rnotwhite ) || [ "" ];
  4334. 			t = types.length;
  4335. 			while ( t-- ) {
  4336. 				tmp = rtypenamespace.exec( types[t] ) || [];
  4337. 				type = origType = tmp[1];
  4338. 				namespaces = ( tmp[2] || "" ).split( "." ).sort();
  4339. 	
  4340. 				// Unbind all events (on this namespace, if provided) for the element
  4341. 				if ( !type ) {
  4342. 					for ( type in events ) {
  4343. 						jQuery.event.remove( elem, type + types[ t ], handler, selector, true );
  4344. 					}
  4345. 					continue;
  4346. 				}
  4347. 	
  4348. 				special = jQuery.event.special[ type ] || {};
  4349. 				type = ( selector ? special.delegateType : special.bindType ) || type;
  4350. 				handlers = events[ type ] || [];
  4351. 				tmp = tmp[2] && new RegExp( "(^|\\.)" + namespaces.join("\\.(?:.*\\.|)") + "(\\.|$)" );
  4352. 	
  4353. 				// Remove matching events
  4354. 				origCount = j = handlers.length;
  4355. 				while ( j-- ) {
  4356. 					handleObj = handlers[ j ];
  4357. 	
  4358. 					if ( ( mappedTypes || origType === handleObj.origType ) &&
  4359. 						( !handler || handler.guid === handleObj.guid ) &&
  4360. 						( !tmp || tmp.test( handleObj.namespace ) ) &&
  4361. 						( !selector || selector === handleObj.selector || selector === "**" && handleObj.selector ) ) {
  4362. 						handlers.splice( j, 1 );
  4363. 	
  4364. 						if ( handleObj.selector ) {
  4365. 							handlers.delegateCount--;
  4366. 						}
  4367. 						if ( special.remove ) {
  4368. 							special.remove.call( elem, handleObj );
  4369. 						}
  4370. 					}
  4371. 				}
  4372. 	
  4373. 				// Remove generic event handler if we removed something and no more handlers exist
  4374. 				// (avoids potential for endless recursion during removal of special event handlers)
  4375. 				if ( origCount && !handlers.length ) {
  4376. 					if ( !special.teardown || special.teardown.call( elem, namespaces, elemData.handle ) === false ) {
  4377. 						jQuery.removeEvent( elem, type, elemData.handle );
  4378. 					}
  4379. 	
  4380. 					delete events[ type ];
  4381. 				}
  4382. 			}
  4383. 	
  4384. 			// Remove the expando if it's no longer used
  4385. 			if ( jQuery.isEmptyObject( events ) ) {
  4386. 				delete elemData.handle;
  4387. 				data_priv.remove( elem, "events" );
  4388. 			}
  4389. 		},
  4390. 	
  4391. 		trigger: function( event, data, elem, onlyHandlers ) {
  4392. 	
  4393. 			var i, cur, tmp, bubbleType, ontype, handle, special,
  4394. 				eventPath = [ elem || document ],
  4395. 				type = hasOwn.call( event, "type" ) ? event.type : event,
  4396. 				namespaces = hasOwn.call( event, "namespace" ) ? event.namespace.split(".") : [];
  4397. 	
  4398. 			cur = tmp = elem = elem || document;
  4399. 	
  4400. 			// Don't do events on text and comment nodes
  4401. 			if ( elem.nodeType === 3 || elem.nodeType === 8 ) {
  4402. 				return;
  4403. 			}
  4404. 	
  4405. 			// focus/blur morphs to focusin/out; ensure we're not firing them right now
  4406. 			if ( rfocusMorph.test( type + jQuery.event.triggered ) ) {
  4407. 				return;
  4408. 			}
  4409. 	
  4410. 			if ( type.indexOf(".") >= 0 ) {
  4411. 				// Namespaced trigger; create a regexp to match event type in handle()
  4412. 				namespaces = type.split(".");
  4413. 				type = namespaces.shift();
  4414. 				namespaces.sort();
  4415. 			}
  4416. 			ontype = type.indexOf(":") < 0 && "on" + type;
  4417. 	
  4418. 			// Caller can pass in a jQuery.Event object, Object, or just an event type string
  4419. 			event = event[ jQuery.expando ] ?
  4420. 				event :
  4421. 				new jQuery.Event( type, typeof event === "object" && event );
  4422. 	
  4423. 			// Trigger bitmask: & 1 for native handlers; & 2 for jQuery (always true)
  4424. 			event.isTrigger = onlyHandlers ? 2 : 3;
  4425. 			event.namespace = namespaces.join(".");
  4426. 			event.namespace_re = event.namespace ?
  4427. 				new RegExp( "(^|\\.)" + namespaces.join("\\.(?:.*\\.|)") + "(\\.|$)" ) :
  4428. 				null;
  4429. 	
  4430. 			// Clean up the event in case it is being reused
  4431. 			event.result = undefined;
  4432. 			if ( !event.target ) {
  4433. 				event.target = elem;
  4434. 			}
  4435. 	
  4436. 			// Clone any incoming data and prepend the event, creating the handler arg list
  4437. 			data = data == null ?
  4438. 				[ event ] :
  4439. 				jQuery.makeArray( data, [ event ] );
  4440. 	
  4441. 			// Allow special events to draw outside the lines
  4442. 			special = jQuery.event.special[ type ] || {};
  4443. 			if ( !onlyHandlers && special.trigger && special.trigger.apply( elem, data ) === false ) {
  4444. 				return;
  4445. 			}
  4446. 	
  4447. 			// Determine event propagation path in advance, per W3C events spec (#9951)
  4448. 			// Bubble up to document, then to window; watch for a global ownerDocument var (#9724)
  4449. 			if ( !onlyHandlers && !special.noBubble && !jQuery.isWindow( elem ) ) {
  4450. 	
  4451. 				bubbleType = special.delegateType || type;
  4452. 				if ( !rfocusMorph.test( bubbleType + type ) ) {
  4453. 					cur = cur.parentNode;
  4454. 				}
  4455. 				for ( ; cur; cur = cur.parentNode ) {
  4456. 					eventPath.push( cur );
  4457. 					tmp = cur;
  4458. 				}
  4459. 	
  4460. 				// Only add window if we got to document (e.g., not plain obj or detached DOM)
  4461. 				if ( tmp === (elem.ownerDocument || document) ) {
  4462. 					eventPath.push( tmp.defaultView || tmp.parentWindow || window );
  4463. 				}
  4464. 			}
  4465. 	
  4466. 			// Fire handlers on the event path
  4467. 			i = 0;
  4468. 			while ( (cur = eventPath[i++]) && !event.isPropagationStopped() ) {
  4469. 	
  4470. 				event.type = i > 1 ?
  4471. 					bubbleType :
  4472. 					special.bindType || type;
  4473. 	
  4474. 				// jQuery handler
  4475. 				handle = ( data_priv.get( cur, "events" ) || {} )[ event.type ] && data_priv.get( cur, "handle" );
  4476. 				if ( handle ) {
  4477. 					handle.apply( cur, data );
  4478. 				}
  4479. 	
  4480. 				// Native handler
  4481. 				handle = ontype && cur[ ontype ];
  4482. 				if ( handle && handle.apply && jQuery.acceptData( cur ) ) {
  4483. 					event.result = handle.apply( cur, data );
  4484. 					if ( event.result === false ) {
  4485. 						event.preventDefault();
  4486. 					}
  4487. 				}
  4488. 			}
  4489. 			event.type = type;
  4490. 	
  4491. 			// If nobody prevented the default action, do it now
  4492. 			if ( !onlyHandlers && !event.isDefaultPrevented() ) {
  4493. 	
  4494. 				if ( (!special._default || special._default.apply( eventPath.pop(), data ) === false) &&
  4495. 					jQuery.acceptData( elem ) ) {
  4496. 	
  4497. 					// Call a native DOM method on the target with the same name name as the event.
  4498. 					// Don't do default actions on window, that's where global variables be (#6170)
  4499. 					if ( ontype && jQuery.isFunction( elem[ type ] ) && !jQuery.isWindow( elem ) ) {
  4500. 	
  4501. 						// Don't re-trigger an onFOO event when we call its FOO() method
  4502. 						tmp = elem[ ontype ];
  4503. 	
  4504. 						if ( tmp ) {
  4505. 							elem[ ontype ] = null;
  4506. 						}
  4507. 	
  4508. 						// Prevent re-triggering of the same event, since we already bubbled it above
  4509. 						jQuery.event.triggered = type;
  4510. 						elem[ type ]();
  4511. 						jQuery.event.triggered = undefined;
  4512. 	
  4513. 						if ( tmp ) {
  4514. 							elem[ ontype ] = tmp;
  4515. 						}
  4516. 					}
  4517. 				}
  4518. 			}
  4519. 	
  4520. 			return event.result;
  4521. 		},
  4522. 	
  4523. 		dispatch: function( event ) {
  4524. 	
  4525. 			// Make a writable jQuery.Event from the native event object
  4526. 			event = jQuery.event.fix( event );
  4527. 	
  4528. 			var i, j, ret, matched, handleObj,
  4529. 				handlerQueue = [],
  4530. 				args = slice.call( arguments ),
  4531. 				handlers = ( data_priv.get( this, "events" ) || {} )[ event.type ] || [],
  4532. 				special = jQuery.event.special[ event.type ] || {};
  4533. 	
  4534. 			// Use the fix-ed jQuery.Event rather than the (read-only) native event
  4535. 			args[0] = event;
  4536. 			event.delegateTarget = this;
  4537. 	
  4538. 			// Call the preDispatch hook for the mapped type, and let it bail if desired
  4539. 			if ( special.preDispatch && special.preDispatch.call( this, event ) === false ) {
  4540. 				return;
  4541. 			}
  4542. 	
  4543. 			// Determine handlers
  4544. 			handlerQueue = jQuery.event.handlers.call( this, event, handlers );
  4545. 	
  4546. 			// Run delegates first; they may want to stop propagation beneath us
  4547. 			i = 0;
  4548. 			while ( (matched = handlerQueue[ i++ ]) && !event.isPropagationStopped() ) {
  4549. 				event.currentTarget = matched.elem;
  4550. 	
  4551. 				j = 0;
  4552. 				while ( (handleObj = matched.handlers[ j++ ]) && !event.isImmediatePropagationStopped() ) {
  4553. 	
  4554. 					// Triggered event must either 1) have no namespace, or 2) have namespace(s)
  4555. 					// a subset or equal to those in the bound event (both can have no namespace).
  4556. 					if ( !event.namespace_re || event.namespace_re.test( handleObj.namespace ) ) {
  4557. 	
  4558. 						event.handleObj = handleObj;
  4559. 						event.data = handleObj.data;
  4560. 	
  4561. 						ret = ( (jQuery.event.special[ handleObj.origType ] || {}).handle || handleObj.handler )
  4562. 								.apply( matched.elem, args );
  4563. 	
  4564. 						if ( ret !== undefined ) {
  4565. 							if ( (event.result = ret) === false ) {
  4566. 								event.preventDefault();
  4567. 								event.stopPropagation();
  4568. 							}
  4569. 						}
  4570. 					}
  4571. 				}
  4572. 			}
  4573. 	
  4574. 			// Call the postDispatch hook for the mapped type
  4575. 			if ( special.postDispatch ) {
  4576. 				special.postDispatch.call( this, event );
  4577. 			}
  4578. 	
  4579. 			return event.result;
  4580. 		},
  4581. 	
  4582. 		handlers: function( event, handlers ) {
  4583. 			var i, matches, sel, handleObj,
  4584. 				handlerQueue = [],
  4585. 				delegateCount = handlers.delegateCount,
  4586. 				cur = event.target;
  4587. 	
  4588. 			// Find delegate handlers
  4589. 			// Black-hole SVG <use> instance trees (#13180)
  4590. 			// Avoid non-left-click bubbling in Firefox (#3861)
  4591. 			if ( delegateCount && cur.nodeType && (!event.button || event.type !== "click") ) {
  4592. 	
  4593. 				for ( ; cur !== this; cur = cur.parentNode || this ) {
  4594. 	
  4595. 					// Don't process clicks on disabled elements (#6911, #8165, #11382, #11764)
  4596. 					if ( cur.disabled !== true || event.type !== "click" ) {
  4597. 						matches = [];
  4598. 						for ( i = 0; i < delegateCount; i++ ) {
  4599. 							handleObj = handlers[ i ];
  4600. 	
  4601. 							// Don't conflict with Object.prototype properties (#13203)
  4602. 							sel = handleObj.selector + " ";
  4603. 	
  4604. 							if ( matches[ sel ] === undefined ) {
  4605. 								matches[ sel ] = handleObj.needsContext ?
  4606. 									jQuery( sel, this ).index( cur ) >= 0 :
  4607. 									jQuery.find( sel, this, null, [ cur ] ).length;
  4608. 							}
  4609. 							if ( matches[ sel ] ) {
  4610. 								matches.push( handleObj );
  4611. 							}
  4612. 						}
  4613. 						if ( matches.length ) {
  4614. 							handlerQueue.push({ elem: cur, handlers: matches });
  4615. 						}
  4616. 					}
  4617. 				}
  4618. 			}
  4619. 	
  4620. 			// Add the remaining (directly-bound) handlers
  4621. 			if ( delegateCount < handlers.length ) {
  4622. 				handlerQueue.push({ elem: this, handlers: handlers.slice( delegateCount ) });
  4623. 			}
  4624. 	
  4625. 			return handlerQueue;
  4626. 		},
  4627. 	
  4628. 		// Includes some event props shared by KeyEvent and MouseEvent
  4629. 		props: "altKey bubbles cancelable ctrlKey currentTarget eventPhase metaKey relatedTarget shiftKey target timeStamp view which".split(" "),
  4630. 	
  4631. 		fixHooks: {},
  4632. 	
  4633. 		keyHooks: {
  4634. 			props: "char charCode key keyCode".split(" "),
  4635. 			filter: function( event, original ) {
  4636. 	
  4637. 				// Add which for key events
  4638. 				if ( event.which == null ) {
  4639. 					event.which = original.charCode != null ? original.charCode : original.keyCode;
  4640. 				}
  4641. 	
  4642. 				return event;
  4643. 			}
  4644. 		},
  4645. 	
  4646. 		mouseHooks: {
  4647. 			props: "button buttons clientX clientY offsetX offsetY pageX pageY screenX screenY toElement".split(" "),
  4648. 			filter: function( event, original ) {
  4649. 				var eventDoc, doc, body,
  4650. 					button = original.button;
  4651. 	
  4652. 				// Calculate pageX/Y if missing and clientX/Y available
  4653. 				if ( event.pageX == null && original.clientX != null ) {
  4654. 					eventDoc = event.target.ownerDocument || document;
  4655. 					doc = eventDoc.documentElement;
  4656. 					body = eventDoc.body;
  4657. 	
  4658. 					event.pageX = original.clientX + ( doc && doc.scrollLeft || body && body.scrollLeft || 0 ) - ( doc && doc.clientLeft || body && body.clientLeft || 0 );
  4659. 					event.pageY = original.clientY + ( doc && doc.scrollTop  || body && body.scrollTop  || 0 ) - ( doc && doc.clientTop  || body && body.clientTop  || 0 );
  4660. 				}
  4661. 	
  4662. 				// Add which for click: 1 === left; 2 === middle; 3 === right
  4663. 				// Note: button is not normalized, so don't use it
  4664. 				if ( !event.which && button !== undefined ) {
  4665. 					event.which = ( button & 1 ? 1 : ( button & 2 ? 3 : ( button & 4 ? 2 : 0 ) ) );
  4666. 				}
  4667. 	
  4668. 				return event;
  4669. 			}
  4670. 		},
  4671. 	
  4672. 		fix: function( event ) {
  4673. 			if ( event[ jQuery.expando ] ) {
  4674. 				return event;
  4675. 			}
  4676. 	
  4677. 			// Create a writable copy of the event object and normalize some properties
  4678. 			var i, prop, copy,
  4679. 				type = event.type,
  4680. 				originalEvent = event,
  4681. 				fixHook = this.fixHooks[ type ];
  4682. 	
  4683. 			if ( !fixHook ) {
  4684. 				this.fixHooks[ type ] = fixHook =
  4685. 					rmouseEvent.test( type ) ? this.mouseHooks :
  4686. 					rkeyEvent.test( type ) ? this.keyHooks :
  4687. 					{};
  4688. 			}
  4689. 			copy = fixHook.props ? this.props.concat( fixHook.props ) : this.props;
  4690. 	
  4691. 			event = new jQuery.Event( originalEvent );
  4692. 	
  4693. 			i = copy.length;
  4694. 			while ( i-- ) {
  4695. 				prop = copy[ i ];
  4696. 				event[ prop ] = originalEvent[ prop ];
  4697. 			}
  4698. 	
  4699. 			// Support: Cordova 2.5 (WebKit) (#13255)
  4700. 			// All events should have a target; Cordova deviceready doesn't
  4701. 			if ( !event.target ) {
  4702. 				event.target = document;
  4703. 			}
  4704. 	
  4705. 			// Support: Safari 6.0+, Chrome<28
  4706. 			// Target should not be a text node (#504, #13143)
  4707. 			if ( event.target.nodeType === 3 ) {
  4708. 				event.target = event.target.parentNode;
  4709. 			}
  4710. 	
  4711. 			return fixHook.filter ? fixHook.filter( event, originalEvent ) : event;
  4712. 		},
  4713. 	
  4714. 		special: {
  4715. 			load: {
  4716. 				// Prevent triggered image.load events from bubbling to window.load
  4717. 				noBubble: true
  4718. 			},
  4719. 			focus: {
  4720. 				// Fire native event if possible so blur/focus sequence is correct
  4721. 				trigger: function() {
  4722. 					if ( this !== safeActiveElement() && this.focus ) {
  4723. 						this.focus();
  4724. 						return false;
  4725. 					}
  4726. 				},
  4727. 				delegateType: "focusin"
  4728. 			},
  4729. 			blur: {
  4730. 				trigger: function() {
  4731. 					if ( this === safeActiveElement() && this.blur ) {
  4732. 						this.blur();
  4733. 						return false;
  4734. 					}
  4735. 				},
  4736. 				delegateType: "focusout"
  4737. 			},
  4738. 			click: {
  4739. 				// For checkbox, fire native event so checked state will be right
  4740. 				trigger: function() {
  4741. 					if ( this.type === "checkbox" && this.click && jQuery.nodeName( this, "input" ) ) {
  4742. 						this.click();
  4743. 						return false;
  4744. 					}
  4745. 				},
  4746. 	
  4747. 				// For cross-browser consistency, don't fire native .click() on links
  4748. 				_default: function( event ) {
  4749. 					return jQuery.nodeName( event.target, "a" );
  4750. 				}
  4751. 			},
  4752. 	
  4753. 			beforeunload: {
  4754. 				postDispatch: function( event ) {
  4755. 	
  4756. 					// Support: Firefox 20+
  4757. 					// Firefox doesn't alert if the returnValue field is not set.
  4758. 					if ( event.result !== undefined && event.originalEvent ) {
  4759. 						event.originalEvent.returnValue = event.result;
  4760. 					}
  4761. 				}
  4762. 			}
  4763. 		},
  4764. 	
  4765. 		simulate: function( type, elem, event, bubble ) {
  4766. 			// Piggyback on a donor event to simulate a different one.
  4767. 			// Fake originalEvent to avoid donor's stopPropagation, but if the
  4768. 			// simulated event prevents default then we do the same on the donor.
  4769. 			var e = jQuery.extend(
  4770. 				new jQuery.Event(),
  4771. 				event,
  4772. 				{
  4773. 					type: type,
  4774. 					isSimulated: true,
  4775. 					originalEvent: {}
  4776. 				}
  4777. 			);
  4778. 			if ( bubble ) {
  4779. 				jQuery.event.trigger( e, null, elem );
  4780. 			} else {
  4781. 				jQuery.event.dispatch.call( elem, e );
  4782. 			}
  4783. 			if ( e.isDefaultPrevented() ) {
  4784. 				event.preventDefault();
  4785. 			}
  4786. 		}
  4787. 	};
  4788. 	
  4789. 	jQuery.removeEvent = function( elem, type, handle ) {
  4790. 		if ( elem.removeEventListener ) {
  4791. 			elem.removeEventListener( type, handle, false );
  4792. 		}
  4793. 	};
  4794. 	
  4795. 	jQuery.Event = function( src, props ) {
  4796. 		// Allow instantiation without the 'new' keyword
  4797. 		if ( !(this instanceof jQuery.Event) ) {
  4798. 			return new jQuery.Event( src, props );
  4799. 		}
  4800. 	
  4801. 		// Event object
  4802. 		if ( src && src.type ) {
  4803. 			this.originalEvent = src;
  4804. 			this.type = src.type;
  4805. 	
  4806. 			// Events bubbling up the document may have been marked as prevented
  4807. 			// by a handler lower down the tree; reflect the correct value.
  4808. 			this.isDefaultPrevented = src.defaultPrevented ||
  4809. 					src.defaultPrevented === undefined &&
  4810. 					// Support: Android<4.0
  4811. 					src.returnValue === false ?
  4812. 				returnTrue :
  4813. 				returnFalse;
  4814. 	
  4815. 		// Event type
  4816. 		} else {
  4817. 			this.type = src;
  4818. 		}
  4819. 	
  4820. 		// Put explicitly provided properties onto the event object
  4821. 		if ( props ) {
  4822. 			jQuery.extend( this, props );
  4823. 		}
  4824. 	
  4825. 		// Create a timestamp if incoming event doesn't have one
  4826. 		this.timeStamp = src && src.timeStamp || jQuery.now();
  4827. 	
  4828. 		// Mark it as fixed
  4829. 		this[ jQuery.expando ] = true;
  4830. 	};
  4831. 	
  4832. 	// jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding
  4833. 	// http://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html
  4834. 	jQuery.Event.prototype = {
  4835. 		isDefaultPrevented: returnFalse,
  4836. 		isPropagationStopped: returnFalse,
  4837. 		isImmediatePropagationStopped: returnFalse,
  4838. 	
  4839. 		preventDefault: function() {
  4840. 			var e = this.originalEvent;
  4841. 	
  4842. 			this.isDefaultPrevented = returnTrue;
  4843. 	
  4844. 			if ( e && e.preventDefault ) {
  4845. 				e.preventDefault();
  4846. 			}
  4847. 		},
  4848. 		stopPropagation: function() {
  4849. 			var e = this.originalEvent;
  4850. 	
  4851. 			this.isPropagationStopped = returnTrue;
  4852. 	
  4853. 			if ( e && e.stopPropagation ) {
  4854. 				e.stopPropagation();
  4855. 			}
  4856. 		},
  4857. 		stopImmediatePropagation: function() {
  4858. 			var e = this.originalEvent;
  4859. 	
  4860. 			this.isImmediatePropagationStopped = returnTrue;
  4861. 	
  4862. 			if ( e && e.stopImmediatePropagation ) {
  4863. 				e.stopImmediatePropagation();
  4864. 			}
  4865. 	
  4866. 			this.stopPropagation();
  4867. 		}
  4868. 	};
  4869. 	
  4870. 	// Create mouseenter/leave events using mouseover/out and event-time checks
  4871. 	// Support: Chrome 15+
  4872. 	jQuery.each({
  4873. 		mouseenter: "mouseover",
  4874. 		mouseleave: "mouseout",
  4875. 		pointerenter: "pointerover",
  4876. 		pointerleave: "pointerout"
  4877. 	}, function( orig, fix ) {
  4878. 		jQuery.event.special[ orig ] = {
  4879. 			delegateType: fix,
  4880. 			bindType: fix,
  4881. 	
  4882. 			handle: function( event ) {
  4883. 				var ret,
  4884. 					target = this,
  4885. 					related = event.relatedTarget,
  4886. 					handleObj = event.handleObj;
  4887. 	
  4888. 				// For mousenter/leave call the handler if related is outside the target.
  4889. 				// NB: No relatedTarget if the mouse left/entered the browser window
  4890. 				if ( !related || (related !== target && !jQuery.contains( target, related )) ) {
  4891. 					event.type = handleObj.origType;
  4892. 					ret = handleObj.handler.apply( this, arguments );
  4893. 					event.type = fix;
  4894. 				}
  4895. 				return ret;
  4896. 			}
  4897. 		};
  4898. 	});
  4899. 	
  4900. 	// Support: Firefox, Chrome, Safari
  4901. 	// Create "bubbling" focus and blur events
  4902. 	if ( !support.focusinBubbles ) {
  4903. 		jQuery.each({ focus: "focusin", blur: "focusout" }, function( orig, fix ) {
  4904. 	
  4905. 			// Attach a single capturing handler on the document while someone wants focusin/focusout
  4906. 			var handler = function( event ) {
  4907. 					jQuery.event.simulate( fix, event.target, jQuery.event.fix( event ), true );
  4908. 				};
  4909. 	
  4910. 			jQuery.event.special[ fix ] = {
  4911. 				setup: function() {
  4912. 					var doc = this.ownerDocument || this,
  4913. 						attaches = data_priv.access( doc, fix );
  4914. 	
  4915. 					if ( !attaches ) {
  4916. 						doc.addEventListener( orig, handler, true );
  4917. 					}
  4918. 					data_priv.access( doc, fix, ( attaches || 0 ) + 1 );
  4919. 				},
  4920. 				teardown: function() {
  4921. 					var doc = this.ownerDocument || this,
  4922. 						attaches = data_priv.access( doc, fix ) - 1;
  4923. 	
  4924. 					if ( !attaches ) {
  4925. 						doc.removeEventListener( orig, handler, true );
  4926. 						data_priv.remove( doc, fix );
  4927. 	
  4928. 					} else {
  4929. 						data_priv.access( doc, fix, attaches );
  4930. 					}
  4931. 				}
  4932. 			};
  4933. 		});
  4934. 	}
  4935. 	
  4936. 	jQuery.fn.extend({
  4937. 	
  4938. 		on: function( types, selector, data, fn, /*INTERNAL*/ one ) {
  4939. 			var origFn, type;
  4940. 	
  4941. 			// Types can be a map of types/handlers
  4942. 			if ( typeof types === "object" ) {
  4943. 				// ( types-Object, selector, data )
  4944. 				if ( typeof selector !== "string" ) {
  4945. 					// ( types-Object, data )
  4946. 					data = data || selector;
  4947. 					selector = undefined;
  4948. 				}
  4949. 				for ( type in types ) {
  4950. 					this.on( type, selector, data, types[ type ], one );
  4951. 				}
  4952. 				return this;
  4953. 			}
  4954. 	
  4955. 			if ( data == null && fn == null ) {
  4956. 				// ( types, fn )
  4957. 				fn = selector;
  4958. 				data = selector = undefined;
  4959. 			} else if ( fn == null ) {
  4960. 				if ( typeof selector === "string" ) {
  4961. 					// ( types, selector, fn )
  4962. 					fn = data;
  4963. 					data = undefined;
  4964. 				} else {
  4965. 					// ( types, data, fn )
  4966. 					fn = data;
  4967. 					data = selector;
  4968. 					selector = undefined;
  4969. 				}
  4970. 			}
  4971. 			if ( fn === false ) {
  4972. 				fn = returnFalse;
  4973. 			} else if ( !fn ) {
  4974. 				return this;
  4975. 			}
  4976. 	
  4977. 			if ( one === 1 ) {
  4978. 				origFn = fn;
  4979. 				fn = function( event ) {
  4980. 					// Can use an empty set, since event contains the info
  4981. 					jQuery().off( event );
  4982. 					return origFn.apply( this, arguments );
  4983. 				};
  4984. 				// Use same guid so caller can remove using origFn
  4985. 				fn.guid = origFn.guid || ( origFn.guid = jQuery.guid++ );
  4986. 			}
  4987. 			return this.each( function() {
  4988. 				jQuery.event.add( this, types, fn, data, selector );
  4989. 			});
  4990. 		},
  4991. 		one: function( types, selector, data, fn ) {
  4992. 			return this.on( types, selector, data, fn, 1 );
  4993. 		},
  4994. 		off: function( types, selector, fn ) {
  4995. 			var handleObj, type;
  4996. 			if ( types && types.preventDefault && types.handleObj ) {
  4997. 				// ( event )  dispatched jQuery.Event
  4998. 				handleObj = types.handleObj;
  4999. 				jQuery( types.delegateTarget ).off(
  5000. 					handleObj.namespace ? handleObj.origType + "." + handleObj.namespace : handleObj.origType,
  5001. 					handleObj.selector,
  5002. 					handleObj.handler
  5003. 				);
  5004. 				return this;
  5005. 			}
  5006. 			if ( typeof types === "object" ) {
  5007. 				// ( types-object [, selector] )
  5008. 				for ( type in types ) {
  5009. 					this.off( type, selector, types[ type ] );
  5010. 				}
  5011. 				return this;
  5012. 			}
  5013. 			if ( selector === false || typeof selector === "function" ) {
  5014. 				// ( types [, fn] )
  5015. 				fn = selector;
  5016. 				selector = undefined;
  5017. 			}
  5018. 			if ( fn === false ) {
  5019. 				fn = returnFalse;
  5020. 			}
  5021. 			return this.each(function() {
  5022. 				jQuery.event.remove( this, types, fn, selector );
  5023. 			});
  5024. 		},
  5025. 	
  5026. 		trigger: function( type, data ) {
  5027. 			return this.each(function() {
  5028. 				jQuery.event.trigger( type, data, this );
  5029. 			});
  5030. 		},
  5031. 		triggerHandler: function( type, data ) {
  5032. 			var elem = this[0];
  5033. 			if ( elem ) {
  5034. 				return jQuery.event.trigger( type, data, elem, true );
  5035. 			}
  5036. 		}
  5037. 	});
  5038. 	
  5039. 	
  5040. 	var
  5041. 		rxhtmlTag = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:]+)[^>]*)\/>/gi,
  5042. 		rtagName = /<([\w:]+)/,
  5043. 		rhtml = /<|&#?\w+;/,
  5044. 		rnoInnerhtml = /<(?:script|style|link)/i,
  5045. 		// checked="checked" or checked
  5046. 		rchecked = /checked\s*(?:[^=]|=\s*.checked.)/i,
  5047. 		rscriptType = /^$|\/(?:java|ecma)script/i,
  5048. 		rscriptTypeMasked = /^true\/(.*)/,
  5049. 		rcleanScript = /^\s*<!(?:\[CDATA\[|--)|(?:\]\]|--)>\s*$/g,
  5050. 	
  5051. 		// We have to close these tags to support XHTML (#13200)
  5052. 		wrapMap = {
  5053. 	
  5054. 			// Support: IE9
  5055. 			option: [ 1, "<select multiple='multiple'>", "</select>" ],
  5056. 	
  5057. 			thead: [ 1, "<table>", "</table>" ],
  5058. 			col: [ 2, "<table><colgroup>", "</colgroup></table>" ],
  5059. 			tr: [ 2, "<table><tbody>", "</tbody></table>" ],
  5060. 			td: [ 3, "<table><tbody><tr>", "</tr></tbody></table>" ],
  5061. 	
  5062. 			_default: [ 0, "", "" ]
  5063. 		};
  5064. 	
  5065. 	// Support: IE9
  5066. 	wrapMap.optgroup = wrapMap.option;
  5067. 	
  5068. 	wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;
  5069. 	wrapMap.th = wrapMap.td;
  5070. 	
  5071. 	// Support: 1.x compatibility
  5072. 	// Manipulating tables requires a tbody
  5073. 	function manipulationTarget( elem, content ) {
  5074. 		return jQuery.nodeName( elem, "table" ) &&
  5075. 			jQuery.nodeName( content.nodeType !== 11 ? content : content.firstChild, "tr" ) ?
  5076. 	
  5077. 			elem.getElementsByTagName("tbody")[0] ||
  5078. 				elem.appendChild( elem.ownerDocument.createElement("tbody") ) :
  5079. 			elem;
  5080. 	}
  5081. 	
  5082. 	// Replace/restore the type attribute of script elements for safe DOM manipulation
  5083. 	function disableScript( elem ) {
  5084. 		elem.type = (elem.getAttribute("type") !== null) + "/" + elem.type;
  5085. 		return elem;
  5086. 	}
  5087. 	function restoreScript( elem ) {
  5088. 		var match = rscriptTypeMasked.exec( elem.type );
  5089. 	
  5090. 		if ( match ) {
  5091. 			elem.type = match[ 1 ];
  5092. 		} else {
  5093. 			elem.removeAttribute("type");
  5094. 		}
  5095. 	
  5096. 		return elem;
  5097. 	}
  5098. 	
  5099. 	// Mark scripts as having already been evaluated
  5100. 	function setGlobalEval( elems, refElements ) {
  5101. 		var i = 0,
  5102. 			l = elems.length;
  5103. 	
  5104. 		for ( ; i < l; i++ ) {
  5105. 			data_priv.set(
  5106. 				elems[ i ], "globalEval", !refElements || data_priv.get( refElements[ i ], "globalEval" )
  5107. 			);
  5108. 		}
  5109. 	}
  5110. 	
  5111. 	function cloneCopyEvent( src, dest ) {
  5112. 		var i, l, type, pdataOld, pdataCur, udataOld, udataCur, events;
  5113. 	
  5114. 		if ( dest.nodeType !== 1 ) {
  5115. 			return;
  5116. 		}
  5117. 	
  5118. 		// 1. Copy private data: events, handlers, etc.
  5119. 		if ( data_priv.hasData( src ) ) {
  5120. 			pdataOld = data_priv.access( src );
  5121. 			pdataCur = data_priv.set( dest, pdataOld );
  5122. 			events = pdataOld.events;
  5123. 	
  5124. 			if ( events ) {
  5125. 				delete pdataCur.handle;
  5126. 				pdataCur.events = {};
  5127. 	
  5128. 				for ( type in events ) {
  5129. 					for ( i = 0, l = events[ type ].length; i < l; i++ ) {
  5130. 						jQuery.event.add( dest, type, events[ type ][ i ] );
  5131. 					}
  5132. 				}
  5133. 			}
  5134. 		}
  5135. 	
  5136. 		// 2. Copy user data
  5137. 		if ( data_user.hasData( src ) ) {
  5138. 			udataOld = data_user.access( src );
  5139. 			udataCur = jQuery.extend( {}, udataOld );
  5140. 	
  5141. 			data_user.set( dest, udataCur );
  5142. 		}
  5143. 	}
  5144. 	
  5145. 	function getAll( context, tag ) {
  5146. 		var ret = context.getElementsByTagName ? context.getElementsByTagName( tag || "*" ) :
  5147. 				context.querySelectorAll ? context.querySelectorAll( tag || "*" ) :
  5148. 				[];
  5149. 	
  5150. 		return tag === undefined || tag && jQuery.nodeName( context, tag ) ?
  5151. 			jQuery.merge( [ context ], ret ) :
  5152. 			ret;
  5153. 	}
  5154. 	
  5155. 	// Fix IE bugs, see support tests
  5156. 	function fixInput( src, dest ) {
  5157. 		var nodeName = dest.nodeName.toLowerCase();
  5158. 	
  5159. 		// Fails to persist the checked state of a cloned checkbox or radio button.
  5160. 		if ( nodeName === "input" && rcheckableType.test( src.type ) ) {
  5161. 			dest.checked = src.checked;
  5162. 	
  5163. 		// Fails to return the selected option to the default selected state when cloning options
  5164. 		} else if ( nodeName === "input" || nodeName === "textarea" ) {
  5165. 			dest.defaultValue = src.defaultValue;
  5166. 		}
  5167. 	}
  5168. 	
  5169. 	jQuery.extend({
  5170. 		clone: function( elem, dataAndEvents, deepDataAndEvents ) {
  5171. 			var i, l, srcElements, destElements,
  5172. 				clone = elem.cloneNode( true ),
  5173. 				inPage = jQuery.contains( elem.ownerDocument, elem );
  5174. 	
  5175. 			// Fix IE cloning issues
  5176. 			if ( !support.noCloneChecked && ( elem.nodeType === 1 || elem.nodeType === 11 ) &&
  5177. 					!jQuery.isXMLDoc( elem ) ) {
  5178. 	
  5179. 				// We eschew Sizzle here for performance reasons: http://jsperf.com/getall-vs-sizzle/2
  5180. 				destElements = getAll( clone );
  5181. 				srcElements = getAll( elem );
  5182. 	
  5183. 				for ( i = 0, l = srcElements.length; i < l; i++ ) {
  5184. 					fixInput( srcElements[ i ], destElements[ i ] );
  5185. 				}
  5186. 			}
  5187. 	
  5188. 			// Copy the events from the original to the clone
  5189. 			if ( dataAndEvents ) {
  5190. 				if ( deepDataAndEvents ) {
  5191. 					srcElements = srcElements || getAll( elem );
  5192. 					destElements = destElements || getAll( clone );
  5193. 	
  5194. 					for ( i = 0, l = srcElements.length; i < l; i++ ) {
  5195. 						cloneCopyEvent( srcElements[ i ], destElements[ i ] );
  5196. 					}
  5197. 				} else {
  5198. 					cloneCopyEvent( elem, clone );
  5199. 				}
  5200. 			}
  5201. 	
  5202. 			// Preserve script evaluation history
  5203. 			destElements = getAll( clone, "script" );
  5204. 			if ( destElements.length > 0 ) {
  5205. 				setGlobalEval( destElements, !inPage && getAll( elem, "script" ) );
  5206. 			}
  5207. 	
  5208. 			// Return the cloned set
  5209. 			return clone;
  5210. 		},
  5211. 	
  5212. 		buildFragment: function( elems, context, scripts, selection ) {
  5213. 			var elem, tmp, tag, wrap, contains, j,
  5214. 				fragment = context.createDocumentFragment(),
  5215. 				nodes = [],
  5216. 				i = 0,
  5217. 				l = elems.length;
  5218. 	
  5219. 			for ( ; i < l; i++ ) {
  5220. 				elem = elems[ i ];
  5221. 	
  5222. 				if ( elem || elem === 0 ) {
  5223. 	
  5224. 					// Add nodes directly
  5225. 					if ( jQuery.type( elem ) === "object" ) {
  5226. 						// Support: QtWebKit, PhantomJS
  5227. 						// push.apply(_, arraylike) throws on ancient WebKit
  5228. 						jQuery.merge( nodes, elem.nodeType ? [ elem ] : elem );
  5229. 	
  5230. 					// Convert non-html into a text node
  5231. 					} else if ( !rhtml.test( elem ) ) {
  5232. 						nodes.push( context.createTextNode( elem ) );
  5233. 	
  5234. 					// Convert html into DOM nodes
  5235. 					} else {
  5236. 						tmp = tmp || fragment.appendChild( context.createElement("div") );
  5237. 	
  5238. 						// Deserialize a standard representation
  5239. 						tag = ( rtagName.exec( elem ) || [ "", "" ] )[ 1 ].toLowerCase();
  5240. 						wrap = wrapMap[ tag ] || wrapMap._default;
  5241. 						tmp.innerHTML = wrap[ 1 ] + elem.replace( rxhtmlTag, "<$1></$2>" ) + wrap[ 2 ];
  5242. 	
  5243. 						// Descend through wrappers to the right content
  5244. 						j = wrap[ 0 ];
  5245. 						while ( j-- ) {
  5246. 							tmp = tmp.lastChild;
  5247. 						}
  5248. 	
  5249. 						// Support: QtWebKit, PhantomJS
  5250. 						// push.apply(_, arraylike) throws on ancient WebKit
  5251. 						jQuery.merge( nodes, tmp.childNodes );
  5252. 	
  5253. 						// Remember the top-level container
  5254. 						tmp = fragment.firstChild;
  5255. 	
  5256. 						// Ensure the created nodes are orphaned (#12392)
  5257. 						tmp.textContent = "";
  5258. 					}
  5259. 				}
  5260. 			}
  5261. 	
  5262. 			// Remove wrapper from fragment
  5263. 			fragment.textContent = "";
  5264. 	
  5265. 			i = 0;
  5266. 			while ( (elem = nodes[ i++ ]) ) {
  5267. 	
  5268. 				// #4087 - If origin and destination elements are the same, and this is
  5269. 				// that element, do not do anything
  5270. 				if ( selection && jQuery.inArray( elem, selection ) !== -1 ) {
  5271. 					continue;
  5272. 				}
  5273. 	
  5274. 				contains = jQuery.contains( elem.ownerDocument, elem );
  5275. 	
  5276. 				// Append to fragment
  5277. 				tmp = getAll( fragment.appendChild( elem ), "script" );
  5278. 	
  5279. 				// Preserve script evaluation history
  5280. 				if ( contains ) {
  5281. 					setGlobalEval( tmp );
  5282. 				}
  5283. 	
  5284. 				// Capture executables
  5285. 				if ( scripts ) {
  5286. 					j = 0;
  5287. 					while ( (elem = tmp[ j++ ]) ) {
  5288. 						if ( rscriptType.test( elem.type || "" ) ) {
  5289. 							scripts.push( elem );
  5290. 						}
  5291. 					}
  5292. 				}
  5293. 			}
  5294. 	
  5295. 			return fragment;
  5296. 		},
  5297. 	
  5298. 		cleanData: function( elems ) {
  5299. 			var data, elem, type, key,
  5300. 				special = jQuery.event.special,
  5301. 				i = 0;
  5302. 	
  5303. 			for ( ; (elem = elems[ i ]) !== undefined; i++ ) {
  5304. 				if ( jQuery.acceptData( elem ) ) {
  5305. 					key = elem[ data_priv.expando ];
  5306. 	
  5307. 					if ( key && (data = data_priv.cache[ key ]) ) {
  5308. 						if ( data.events ) {
  5309. 							for ( type in data.events ) {
  5310. 								if ( special[ type ] ) {
  5311. 									jQuery.event.remove( elem, type );
  5312. 	
  5313. 								// This is a shortcut to avoid jQuery.event.remove's overhead
  5314. 								} else {
  5315. 									jQuery.removeEvent( elem, type, data.handle );
  5316. 								}
  5317. 							}
  5318. 						}
  5319. 						if ( data_priv.cache[ key ] ) {
  5320. 							// Discard any remaining `private` data
  5321. 							delete data_priv.cache[ key ];
  5322. 						}
  5323. 					}
  5324. 				}
  5325. 				// Discard any remaining `user` data
  5326. 				delete data_user.cache[ elem[ data_user.expando ] ];
  5327. 			}
  5328. 		}
  5329. 	});
  5330. 	
  5331. 	jQuery.fn.extend({
  5332. 		text: function( value ) {
  5333. 			return access( this, function( value ) {
  5334. 				return value === undefined ?
  5335. 					jQuery.text( this ) :
  5336. 					this.empty().each(function() {
  5337. 						if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {
  5338. 							this.textContent = value;
  5339. 						}
  5340. 					});
  5341. 			}, null, value, arguments.length );
  5342. 		},
  5343. 	
  5344. 		append: function() {
  5345. 			return this.domManip( arguments, function( elem ) {
  5346. 				if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {
  5347. 					var target = manipulationTarget( this, elem );
  5348. 					target.appendChild( elem );
  5349. 				}
  5350. 			});
  5351. 		},
  5352. 	
  5353. 		prepend: function() {
  5354. 			return this.domManip( arguments, function( elem ) {
  5355. 				if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {
  5356. 					var target = manipulationTarget( this, elem );
  5357. 					target.insertBefore( elem, target.firstChild );
  5358. 				}
  5359. 			});
  5360. 		},
  5361. 	
  5362. 		before: function() {
  5363. 			return this.domManip( arguments, function( elem ) {
  5364. 				if ( this.parentNode ) {
  5365. 					this.parentNode.insertBefore( elem, this );
  5366. 				}
  5367. 			});
  5368. 		},
  5369. 	
  5370. 		after: function() {
  5371. 			return this.domManip( arguments, function( elem ) {
  5372. 				if ( this.parentNode ) {
  5373. 					this.parentNode.insertBefore( elem, this.nextSibling );
  5374. 				}
  5375. 			});
  5376. 		},
  5377. 	
  5378. 		remove: function( selector, keepData /* Internal Use Only */ ) {
  5379. 			var elem,
  5380. 				elems = selector ? jQuery.filter( selector, this ) : this,
  5381. 				i = 0;
  5382. 	
  5383. 			for ( ; (elem = elems[i]) != null; i++ ) {
  5384. 				if ( !keepData && elem.nodeType === 1 ) {
  5385. 					jQuery.cleanData( getAll( elem ) );
  5386. 				}
  5387. 	
  5388. 				if ( elem.parentNode ) {
  5389. 					if ( keepData && jQuery.contains( elem.ownerDocument, elem ) ) {
  5390. 						setGlobalEval( getAll( elem, "script" ) );
  5391. 					}
  5392. 					elem.parentNode.removeChild( elem );
  5393. 				}
  5394. 			}
  5395. 	
  5396. 			return this;
  5397. 		},
  5398. 	
  5399. 		empty: function() {
  5400. 			var elem,
  5401. 				i = 0;
  5402. 	
  5403. 			for ( ; (elem = this[i]) != null; i++ ) {
  5404. 				if ( elem.nodeType === 1 ) {
  5405. 	
  5406. 					// Prevent memory leaks
  5407. 					jQuery.cleanData( getAll( elem, false ) );
  5408. 	
  5409. 					// Remove any remaining nodes
  5410. 					elem.textContent = "";
  5411. 				}
  5412. 			}
  5413. 	
  5414. 			return this;
  5415. 		},
  5416. 	
  5417. 		clone: function( dataAndEvents, deepDataAndEvents ) {
  5418. 			dataAndEvents = dataAndEvents == null ? false : dataAndEvents;
  5419. 			deepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents;
  5420. 	
  5421. 			return this.map(function() {
  5422. 				return jQuery.clone( this, dataAndEvents, deepDataAndEvents );
  5423. 			});
  5424. 		},
  5425. 	
  5426. 		html: function( value ) {
  5427. 			return access( this, function( value ) {
  5428. 				var elem = this[ 0 ] || {},
  5429. 					i = 0,
  5430. 					l = this.length;
  5431. 	
  5432. 				if ( value === undefined && elem.nodeType === 1 ) {
  5433. 					return elem.innerHTML;
  5434. 				}
  5435. 	
  5436. 				// See if we can take a shortcut and just use innerHTML
  5437. 				if ( typeof value === "string" && !rnoInnerhtml.test( value ) &&
  5438. 					!wrapMap[ ( rtagName.exec( value ) || [ "", "" ] )[ 1 ].toLowerCase() ] ) {
  5439. 	
  5440. 					value = value.replace( rxhtmlTag, "<$1></$2>" );
  5441. 	
  5442. 					try {
  5443. 						for ( ; i < l; i++ ) {
  5444. 							elem = this[ i ] || {};
  5445. 	
  5446. 							// Remove element nodes and prevent memory leaks
  5447. 							if ( elem.nodeType === 1 ) {
  5448. 								jQuery.cleanData( getAll( elem, false ) );
  5449. 								elem.innerHTML = value;
  5450. 							}
  5451. 						}
  5452. 	
  5453. 						elem = 0;
  5454. 	
  5455. 					// If using innerHTML throws an exception, use the fallback method
  5456. 					} catch( e ) {}
  5457. 				}
  5458. 	
  5459. 				if ( elem ) {
  5460. 					this.empty().append( value );
  5461. 				}
  5462. 			}, null, value, arguments.length );
  5463. 		},
  5464. 	
  5465. 		replaceWith: function() {
  5466. 			var arg = arguments[ 0 ];
  5467. 	
  5468. 			// Make the changes, replacing each context element with the new content
  5469. 			this.domManip( arguments, function( elem ) {
  5470. 				arg = this.parentNode;
  5471. 	
  5472. 				jQuery.cleanData( getAll( this ) );
  5473. 	
  5474. 				if ( arg ) {
  5475. 					arg.replaceChild( elem, this );
  5476. 				}
  5477. 			});
  5478. 	
  5479. 			// Force removal if there was no new content (e.g., from empty arguments)
  5480. 			return arg && (arg.length || arg.nodeType) ? this : this.remove();
  5481. 		},
  5482. 	
  5483. 		detach: function( selector ) {
  5484. 			return this.remove( selector, true );
  5485. 		},
  5486. 	
  5487. 		domManip: function( args, callback ) {
  5488. 	
  5489. 			// Flatten any nested arrays
  5490. 			args = concat.apply( [], args );
  5491. 	
  5492. 			var fragment, first, scripts, hasScripts, node, doc,
  5493. 				i = 0,
  5494. 				l = this.length,
  5495. 				set = this,
  5496. 				iNoClone = l - 1,
  5497. 				value = args[ 0 ],
  5498. 				isFunction = jQuery.isFunction( value );
  5499. 	
  5500. 			// We can't cloneNode fragments that contain checked, in WebKit
  5501. 			if ( isFunction ||
  5502. 					( l > 1 && typeof value === "string" &&
  5503. 						!support.checkClone && rchecked.test( value ) ) ) {
  5504. 				return this.each(function( index ) {
  5505. 					var self = set.eq( index );
  5506. 					if ( isFunction ) {
  5507. 						args[ 0 ] = value.call( this, index, self.html() );
  5508. 					}
  5509. 					self.domManip( args, callback );
  5510. 				});
  5511. 			}
  5512. 	
  5513. 			if ( l ) {
  5514. 				fragment = jQuery.buildFragment( args, this[ 0 ].ownerDocument, false, this );
  5515. 				first = fragment.firstChild;
  5516. 	
  5517. 				if ( fragment.childNodes.length === 1 ) {
  5518. 					fragment = first;
  5519. 				}
  5520. 	
  5521. 				if ( first ) {
  5522. 					scripts = jQuery.map( getAll( fragment, "script" ), disableScript );
  5523. 					hasScripts = scripts.length;
  5524. 	
  5525. 					// Use the original fragment for the last item instead of the first because it can end up
  5526. 					// being emptied incorrectly in certain situations (#8070).
  5527. 					for ( ; i < l; i++ ) {
  5528. 						node = fragment;
  5529. 	
  5530. 						if ( i !== iNoClone ) {
  5531. 							node = jQuery.clone( node, true, true );
  5532. 	
  5533. 							// Keep references to cloned scripts for later restoration
  5534. 							if ( hasScripts ) {
  5535. 								// Support: QtWebKit
  5536. 								// jQuery.merge because push.apply(_, arraylike) throws
  5537. 								jQuery.merge( scripts, getAll( node, "script" ) );
  5538. 							}
  5539. 						}
  5540. 	
  5541. 						callback.call( this[ i ], node, i );
  5542. 					}
  5543. 	
  5544. 					if ( hasScripts ) {
  5545. 						doc = scripts[ scripts.length - 1 ].ownerDocument;
  5546. 	
  5547. 						// Reenable scripts
  5548. 						jQuery.map( scripts, restoreScript );
  5549. 	
  5550. 						// Evaluate executable scripts on first document insertion
  5551. 						for ( i = 0; i < hasScripts; i++ ) {
  5552. 							node = scripts[ i ];
  5553. 							if ( rscriptType.test( node.type || "" ) &&
  5554. 								!data_priv.access( node, "globalEval" ) && jQuery.contains( doc, node ) ) {
  5555. 	
  5556. 								if ( node.src ) {
  5557. 									// Optional AJAX dependency, but won't run scripts if not present
  5558. 									if ( jQuery._evalUrl ) {
  5559. 										jQuery._evalUrl( node.src );
  5560. 									}
  5561. 								} else {
  5562. 									jQuery.globalEval( node.textContent.replace( rcleanScript, "" ) );
  5563. 								}
  5564. 							}
  5565. 						}
  5566. 					}
  5567. 				}
  5568. 			}
  5569. 	
  5570. 			return this;
  5571. 		}
  5572. 	});
  5573. 	
  5574. 	jQuery.each({
  5575. 		appendTo: "append",
  5576. 		prependTo: "prepend",
  5577. 		insertBefore: "before",
  5578. 		insertAfter: "after",
  5579. 		replaceAll: "replaceWith"
  5580. 	}, function( name, original ) {
  5581. 		jQuery.fn[ name ] = function( selector ) {
  5582. 			var elems,
  5583. 				ret = [],
  5584. 				insert = jQuery( selector ),
  5585. 				last = insert.length - 1,
  5586. 				i = 0;
  5587. 	
  5588. 			for ( ; i <= last; i++ ) {
  5589. 				elems = i === last ? this : this.clone( true );
  5590. 				jQuery( insert[ i ] )[ original ]( elems );
  5591. 	
  5592. 				// Support: QtWebKit
  5593. 				// .get() because push.apply(_, arraylike) throws
  5594. 				push.apply( ret, elems.get() );
  5595. 			}
  5596. 	
  5597. 			return this.pushStack( ret );
  5598. 		};
  5599. 	});
  5600. 	
  5601. 	
  5602. 	var iframe,
  5603. 		elemdisplay = {};
  5604. 	
  5605. 	/**
  5606. 	 * Retrieve the actual display of a element
  5607. 	 * @param {String} name nodeName of the element
  5608. 	 * @param {Object} doc Document object
  5609. 	 */
  5610. 	// Called only from within defaultDisplay
  5611. 	function actualDisplay( name, doc ) {
  5612. 		var style,
  5613. 			elem = jQuery( doc.createElement( name ) ).appendTo( doc.body ),
  5614. 	
  5615. 			// getDefaultComputedStyle might be reliably used only on attached element
  5616. 			display = window.getDefaultComputedStyle && ( style = window.getDefaultComputedStyle( elem[ 0 ] ) ) ?
  5617. 	
  5618. 				// Use of this method is a temporary fix (more like optimization) until something better comes along,
  5619. 				// since it was removed from specification and supported only in FF
  5620. 				style.display : jQuery.css( elem[ 0 ], "display" );
  5621. 	
  5622. 		// We don't have any data stored on the element,
  5623. 		// so use "detach" method as fast way to get rid of the element
  5624. 		elem.detach();
  5625. 	
  5626. 		return display;
  5627. 	}
  5628. 	
  5629. 	/**
  5630. 	 * Try to determine the default display value of an element
  5631. 	 * @param {String} nodeName
  5632. 	 */
  5633. 	function defaultDisplay( nodeName ) {
  5634. 		var doc = document,
  5635. 			display = elemdisplay[ nodeName ];
  5636. 	
  5637. 		if ( !display ) {
  5638. 			display = actualDisplay( nodeName, doc );
  5639. 	
  5640. 			// If the simple way fails, read from inside an iframe
  5641. 			if ( display === "none" || !display ) {
  5642. 	
  5643. 				// Use the already-created iframe if possible
  5644. 				iframe = (iframe || jQuery( "<iframe frameborder='0' width='0' height='0'/>" )).appendTo( doc.documentElement );
  5645. 	
  5646. 				// Always write a new HTML skeleton so Webkit and Firefox don't choke on reuse
  5647. 				doc = iframe[ 0 ].contentDocument;
  5648. 	
  5649. 				// Support: IE
  5650. 				doc.write();
  5651. 				doc.close();
  5652. 	
  5653. 				display = actualDisplay( nodeName, doc );
  5654. 				iframe.detach();
  5655. 			}
  5656. 	
  5657. 			// Store the correct default display
  5658. 			elemdisplay[ nodeName ] = display;
  5659. 		}
  5660. 	
  5661. 		return display;
  5662. 	}
  5663. 	var rmargin = (/^margin/);
  5664. 	
  5665. 	var rnumnonpx = new RegExp( "^(" + pnum + ")(?!px)[a-z%]+$", "i" );
  5666. 	
  5667. 	var getStyles = function( elem ) {
  5668. 			// Support: IE<=11+, Firefox<=30+ (#15098, #14150)
  5669. 			// IE throws on elements created in popups
  5670. 			// FF meanwhile throws on frame elements through "defaultView.getComputedStyle"
  5671. 			if ( elem.ownerDocument.defaultView.opener ) {
  5672. 				return elem.ownerDocument.defaultView.getComputedStyle( elem, null );
  5673. 			}
  5674. 	
  5675. 			return window.getComputedStyle( elem, null );
  5676. 		};
  5677. 	
  5678. 	
  5679. 	
  5680. 	function curCSS( elem, name, computed ) {
  5681. 		var width, minWidth, maxWidth, ret,
  5682. 			style = elem.style;
  5683. 	
  5684. 		computed = computed || getStyles( elem );
  5685. 	
  5686. 		// Support: IE9
  5687. 		// getPropertyValue is only needed for .css('filter') (#12537)
  5688. 		if ( computed ) {
  5689. 			ret = computed.getPropertyValue( name ) || computed[ name ];
  5690. 		}
  5691. 	
  5692. 		if ( computed ) {
  5693. 	
  5694. 			if ( ret === "" && !jQuery.contains( elem.ownerDocument, elem ) ) {
  5695. 				ret = jQuery.style( elem, name );
  5696. 			}
  5697. 	
  5698. 			// Support: iOS < 6
  5699. 			// A tribute to the "awesome hack by Dean Edwards"
  5700. 			// iOS < 6 (at least) returns percentage for a larger set of values, but width seems to be reliably pixels
  5701. 			// this is against the CSSOM draft spec: http://dev.w3.org/csswg/cssom/#resolved-values
  5702. 			if ( rnumnonpx.test( ret ) && rmargin.test( name ) ) {
  5703. 	
  5704. 				// Remember the original values
  5705. 				width = style.width;
  5706. 				minWidth = style.minWidth;
  5707. 				maxWidth = style.maxWidth;
  5708. 	
  5709. 				// Put in the new values to get a computed value out
  5710. 				style.minWidth = style.maxWidth = style.width = ret;
  5711. 				ret = computed.width;
  5712. 	
  5713. 				// Revert the changed values
  5714. 				style.width = width;
  5715. 				style.minWidth = minWidth;
  5716. 				style.maxWidth = maxWidth;
  5717. 			}
  5718. 		}
  5719. 	
  5720. 		return ret !== undefined ?
  5721. 			// Support: IE
  5722. 			// IE returns zIndex value as an integer.
  5723. 			ret + "" :
  5724. 			ret;
  5725. 	}
  5726. 	
  5727. 	
  5728. 	function addGetHookIf( conditionFn, hookFn ) {
  5729. 		// Define the hook, we'll check on the first run if it's really needed.
  5730. 		return {
  5731. 			get: function() {
  5732. 				if ( conditionFn() ) {
  5733. 					// Hook not needed (or it's not possible to use it due
  5734. 					// to missing dependency), remove it.
  5735. 					delete this.get;
  5736. 					return;
  5737. 				}
  5738. 	
  5739. 				// Hook needed; redefine it so that the support test is not executed again.
  5740. 				return (this.get = hookFn).apply( this, arguments );
  5741. 			}
  5742. 		};
  5743. 	}
  5744. 	
  5745. 	
  5746. 	(function() {
  5747. 		var pixelPositionVal, boxSizingReliableVal,
  5748. 			docElem = document.documentElement,
  5749. 			container = document.createElement( "div" ),
  5750. 			div = document.createElement( "div" );
  5751. 	
  5752. 		if ( !div.style ) {
  5753. 			return;
  5754. 		}
  5755. 	
  5756. 		// Support: IE9-11+
  5757. 		// Style of cloned element affects source element cloned (#8908)
  5758. 		div.style.backgroundClip = "content-box";
  5759. 		div.cloneNode( true ).style.backgroundClip = "";
  5760. 		support.clearCloneStyle = div.style.backgroundClip === "content-box";
  5761. 	
  5762. 		container.style.cssText = "border:0;width:0;height:0;top:0;left:-9999px;margin-top:1px;" +
  5763. 			"position:absolute";
  5764. 		container.appendChild( div );
  5765. 	
  5766. 		// Executing both pixelPosition & boxSizingReliable tests require only one layout
  5767. 		// so they're executed at the same time to save the second computation.
  5768. 		function computePixelPositionAndBoxSizingReliable() {
  5769. 			div.style.cssText =
  5770. 				// Support: Firefox<29, Android 2.3
  5771. 				// Vendor-prefix box-sizing
  5772. 				"-webkit-box-sizing:border-box;-moz-box-sizing:border-box;" +
  5773. 				"box-sizing:border-box;display:block;margin-top:1%;top:1%;" +
  5774. 				"border:1px;padding:1px;width:4px;position:absolute";
  5775. 			div.innerHTML = "";
  5776. 			docElem.appendChild( container );
  5777. 	
  5778. 			var divStyle = window.getComputedStyle( div, null );
  5779. 			pixelPositionVal = divStyle.top !== "1%";
  5780. 			boxSizingReliableVal = divStyle.width === "4px";
  5781. 	
  5782. 			docElem.removeChild( container );
  5783. 		}
  5784. 	
  5785. 		// Support: node.js jsdom
  5786. 		// Don't assume that getComputedStyle is a property of the global object
  5787. 		if ( window.getComputedStyle ) {
  5788. 			jQuery.extend( support, {
  5789. 				pixelPosition: function() {
  5790. 	
  5791. 					// This test is executed only once but we still do memoizing
  5792. 					// since we can use the boxSizingReliable pre-computing.
  5793. 					// No need to check if the test was already performed, though.
  5794. 					computePixelPositionAndBoxSizingReliable();
  5795. 					return pixelPositionVal;
  5796. 				},
  5797. 				boxSizingReliable: function() {
  5798. 					if ( boxSizingReliableVal == null ) {
  5799. 						computePixelPositionAndBoxSizingReliable();
  5800. 					}
  5801. 					return boxSizingReliableVal;
  5802. 				},
  5803. 				reliableMarginRight: function() {
  5804. 	
  5805. 					// Support: Android 2.3
  5806. 					// Check if div with explicit width and no margin-right incorrectly
  5807. 					// gets computed margin-right based on width of container. (#3333)
  5808. 					// WebKit Bug 13343 - getComputedStyle returns wrong value for margin-right
  5809. 					// This support function is only executed once so no memoizing is needed.
  5810. 					var ret,
  5811. 						marginDiv = div.appendChild( document.createElement( "div" ) );
  5812. 	
  5813. 					// Reset CSS: box-sizing; display; margin; border; padding
  5814. 					marginDiv.style.cssText = div.style.cssText =
  5815. 						// Support: Firefox<29, Android 2.3
  5816. 						// Vendor-prefix box-sizing
  5817. 						"-webkit-box-sizing:content-box;-moz-box-sizing:content-box;" +
  5818. 						"box-sizing:content-box;display:block;margin:0;border:0;padding:0";
  5819. 					marginDiv.style.marginRight = marginDiv.style.width = "0";
  5820. 					div.style.width = "1px";
  5821. 					docElem.appendChild( container );
  5822. 	
  5823. 					ret = !parseFloat( window.getComputedStyle( marginDiv, null ).marginRight );
  5824. 	
  5825. 					docElem.removeChild( container );
  5826. 					div.removeChild( marginDiv );
  5827. 	
  5828. 					return ret;
  5829. 				}
  5830. 			});
  5831. 		}
  5832. 	})();
  5833. 	
  5834. 	
  5835. 	// A method for quickly swapping in/out CSS properties to get correct calculations.
  5836. 	jQuery.swap = function( elem, options, callback, args ) {
  5837. 		var ret, name,
  5838. 			old = {};
  5839. 	
  5840. 		// Remember the old values, and insert the new ones
  5841. 		for ( name in options ) {
  5842. 			old[ name ] = elem.style[ name ];
  5843. 			elem.style[ name ] = options[ name ];
  5844. 		}
  5845. 	
  5846. 		ret = callback.apply( elem, args || [] );
  5847. 	
  5848. 		// Revert the old values
  5849. 		for ( name in options ) {
  5850. 			elem.style[ name ] = old[ name ];
  5851. 		}
  5852. 	
  5853. 		return ret;
  5854. 	};
  5855. 	
  5856. 	
  5857. 	var
  5858. 		// Swappable if display is none or starts with table except "table", "table-cell", or "table-caption"
  5859. 		// See here for display values: https://developer.mozilla.org/en-US/docs/CSS/display
  5860. 		rdisplayswap = /^(none|table(?!-c[ea]).+)/,
  5861. 		rnumsplit = new RegExp( "^(" + pnum + ")(.*)$", "i" ),
  5862. 		rrelNum = new RegExp( "^([+-])=(" + pnum + ")", "i" ),
  5863. 	
  5864. 		cssShow = { position: "absolute", visibility: "hidden", display: "block" },
  5865. 		cssNormalTransform = {
  5866. 			letterSpacing: "0",
  5867. 			fontWeight: "400"
  5868. 		},
  5869. 	
  5870. 		cssPrefixes = [ "Webkit", "O", "Moz", "ms" ];
  5871. 	
  5872. 	// Return a css property mapped to a potentially vendor prefixed property
  5873. 	function vendorPropName( style, name ) {
  5874. 	
  5875. 		// Shortcut for names that are not vendor prefixed
  5876. 		if ( name in style ) {
  5877. 			return name;
  5878. 		}
  5879. 	
  5880. 		// Check for vendor prefixed names
  5881. 		var capName = name[0].toUpperCase() + name.slice(1),
  5882. 			origName = name,
  5883. 			i = cssPrefixes.length;
  5884. 	
  5885. 		while ( i-- ) {
  5886. 			name = cssPrefixes[ i ] + capName;
  5887. 			if ( name in style ) {
  5888. 				return name;
  5889. 			}
  5890. 		}
  5891. 	
  5892. 		return origName;
  5893. 	}
  5894. 	
  5895. 	function setPositiveNumber( elem, value, subtract ) {
  5896. 		var matches = rnumsplit.exec( value );
  5897. 		return matches ?
  5898. 			// Guard against undefined "subtract", e.g., when used as in cssHooks
  5899. 			Math.max( 0, matches[ 1 ] - ( subtract || 0 ) ) + ( matches[ 2 ] || "px" ) :
  5900. 			value;
  5901. 	}
  5902. 	
  5903. 	function augmentWidthOrHeight( elem, name, extra, isBorderBox, styles ) {
  5904. 		var i = extra === ( isBorderBox ? "border" : "content" ) ?
  5905. 			// If we already have the right measurement, avoid augmentation
  5906. 			4 :
  5907. 			// Otherwise initialize for horizontal or vertical properties
  5908. 			name === "width" ? 1 : 0,
  5909. 	
  5910. 			val = 0;
  5911. 	
  5912. 		for ( ; i < 4; i += 2 ) {
  5913. 			// Both box models exclude margin, so add it if we want it
  5914. 			if ( extra === "margin" ) {
  5915. 				val += jQuery.css( elem, extra + cssExpand[ i ], true, styles );
  5916. 			}
  5917. 	
  5918. 			if ( isBorderBox ) {
  5919. 				// border-box includes padding, so remove it if we want content
  5920. 				if ( extra === "content" ) {
  5921. 					val -= jQuery.css( elem, "padding" + cssExpand[ i ], true, styles );
  5922. 				}
  5923. 	
  5924. 				// At this point, extra isn't border nor margin, so remove border
  5925. 				if ( extra !== "margin" ) {
  5926. 					val -= jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles );
  5927. 				}
  5928. 			} else {
  5929. 				// At this point, extra isn't content, so add padding
  5930. 				val += jQuery.css( elem, "padding" + cssExpand[ i ], true, styles );
  5931. 	
  5932. 				// At this point, extra isn't content nor padding, so add border
  5933. 				if ( extra !== "padding" ) {
  5934. 					val += jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles );
  5935. 				}
  5936. 			}
  5937. 		}
  5938. 	
  5939. 		return val;
  5940. 	}
  5941. 	
  5942. 	function getWidthOrHeight( elem, name, extra ) {
  5943. 	
  5944. 		// Start with offset property, which is equivalent to the border-box value
  5945. 		var valueIsBorderBox = true,
  5946. 			val = name === "width" ? elem.offsetWidth : elem.offsetHeight,
  5947. 			styles = getStyles( elem ),
  5948. 			isBorderBox = jQuery.css( elem, "boxSizing", false, styles ) === "border-box";
  5949. 	
  5950. 		// Some non-html elements return undefined for offsetWidth, so check for null/undefined
  5951. 		// svg - https://bugzilla.mozilla.org/show_bug.cgi?id=649285
  5952. 		// MathML - https://bugzilla.mozilla.org/show_bug.cgi?id=491668
  5953. 		if ( val <= 0 || val == null ) {
  5954. 			// Fall back to computed then uncomputed css if necessary
  5955. 			val = curCSS( elem, name, styles );
  5956. 			if ( val < 0 || val == null ) {
  5957. 				val = elem.style[ name ];
  5958. 			}
  5959. 	
  5960. 			// Computed unit is not pixels. Stop here and return.
  5961. 			if ( rnumnonpx.test(val) ) {
  5962. 				return val;
  5963. 			}
  5964. 	
  5965. 			// Check for style in case a browser which returns unreliable values
  5966. 			// for getComputedStyle silently falls back to the reliable elem.style
  5967. 			valueIsBorderBox = isBorderBox &&
  5968. 				( support.boxSizingReliable() || val === elem.style[ name ] );
  5969. 	
  5970. 			// Normalize "", auto, and prepare for extra
  5971. 			val = parseFloat( val ) || 0;
  5972. 		}
  5973. 	
  5974. 		// Use the active box-sizing model to add/subtract irrelevant styles
  5975. 		return ( val +
  5976. 			augmentWidthOrHeight(
  5977. 				elem,
  5978. 				name,
  5979. 				extra || ( isBorderBox ? "border" : "content" ),
  5980. 				valueIsBorderBox,
  5981. 				styles
  5982. 			)
  5983. 		) + "px";
  5984. 	}
  5985. 	
  5986. 	function showHide( elements, show ) {
  5987. 		var display, elem, hidden,
  5988. 			values = [],
  5989. 			index = 0,
  5990. 			length = elements.length;
  5991. 	
  5992. 		for ( ; index < length; index++ ) {
  5993. 			elem = elements[ index ];
  5994. 			if ( !elem.style ) {
  5995. 				continue;
  5996. 			}
  5997. 	
  5998. 			values[ index ] = data_priv.get( elem, "olddisplay" );
  5999. 			display = elem.style.display;
  6000. 			if ( show ) {
  6001. 				// Reset the inline display of this element to learn if it is
  6002. 				// being hidden by cascaded rules or not
  6003. 				if ( !values[ index ] && display === "none" ) {
  6004. 					elem.style.display = "";
  6005. 				}
  6006. 	
  6007. 				// Set elements which have been overridden with display: none
  6008. 				// in a stylesheet to whatever the default browser style is
  6009. 				// for such an element
  6010. 				if ( elem.style.display === "" && isHidden( elem ) ) {
  6011. 					values[ index ] = data_priv.access( elem, "olddisplay", defaultDisplay(elem.nodeName) );
  6012. 				}
  6013. 			} else {
  6014. 				hidden = isHidden( elem );
  6015. 	
  6016. 				if ( display !== "none" || !hidden ) {
  6017. 					data_priv.set( elem, "olddisplay", hidden ? display : jQuery.css( elem, "display" ) );
  6018. 				}
  6019. 			}
  6020. 		}
  6021. 	
  6022. 		// Set the display of most of the elements in a second loop
  6023. 		// to avoid the constant reflow
  6024. 		for ( index = 0; index < length; index++ ) {
  6025. 			elem = elements[ index ];
  6026. 			if ( !elem.style ) {
  6027. 				continue;
  6028. 			}
  6029. 			if ( !show || elem.style.display === "none" || elem.style.display === "" ) {
  6030. 				elem.style.display = show ? values[ index ] || "" : "none";
  6031. 			}
  6032. 		}
  6033. 	
  6034. 		return elements;
  6035. 	}
  6036. 	
  6037. 	jQuery.extend({
  6038. 	
  6039. 		// Add in style property hooks for overriding the default
  6040. 		// behavior of getting and setting a style property
  6041. 		cssHooks: {
  6042. 			opacity: {
  6043. 				get: function( elem, computed ) {
  6044. 					if ( computed ) {
  6045. 	
  6046. 						// We should always get a number back from opacity
  6047. 						var ret = curCSS( elem, "opacity" );
  6048. 						return ret === "" ? "1" : ret;
  6049. 					}
  6050. 				}
  6051. 			}
  6052. 		},
  6053. 	
  6054. 		// Don't automatically add "px" to these possibly-unitless properties
  6055. 		cssNumber: {
  6056. 			"columnCount": true,
  6057. 			"fillOpacity": true,
  6058. 			"flexGrow": true,
  6059. 			"flexShrink": true,
  6060. 			"fontWeight": true,
  6061. 			"lineHeight": true,
  6062. 			"opacity": true,
  6063. 			"order": true,
  6064. 			"orphans": true,
  6065. 			"widows": true,
  6066. 			"zIndex": true,
  6067. 			"zoom": true
  6068. 		},
  6069. 	
  6070. 		// Add in properties whose names you wish to fix before
  6071. 		// setting or getting the value
  6072. 		cssProps: {
  6073. 			"float": "cssFloat"
  6074. 		},
  6075. 	
  6076. 		// Get and set the style property on a DOM Node
  6077. 		style: function( elem, name, value, extra ) {
  6078. 	
  6079. 			// Don't set styles on text and comment nodes
  6080. 			if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style ) {
  6081. 				return;
  6082. 			}
  6083. 	
  6084. 			// Make sure that we're working with the right name
  6085. 			var ret, type, hooks,
  6086. 				origName = jQuery.camelCase( name ),
  6087. 				style = elem.style;
  6088. 	
  6089. 			name = jQuery.cssProps[ origName ] || ( jQuery.cssProps[ origName ] = vendorPropName( style, origName ) );
  6090. 	
  6091. 			// Gets hook for the prefixed version, then unprefixed version
  6092. 			hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ];
  6093. 	
  6094. 			// Check if we're setting a value
  6095. 			if ( value !== undefined ) {
  6096. 				type = typeof value;
  6097. 	
  6098. 				// Convert "+=" or "-=" to relative numbers (#7345)
  6099. 				if ( type === "string" && (ret = rrelNum.exec( value )) ) {
  6100. 					value = ( ret[1] + 1 ) * ret[2] + parseFloat( jQuery.css( elem, name ) );
  6101. 					// Fixes bug #9237
  6102. 					type = "number";
  6103. 				}
  6104. 	
  6105. 				// Make sure that null and NaN values aren't set (#7116)
  6106. 				if ( value == null || value !== value ) {
  6107. 					return;
  6108. 				}
  6109. 	
  6110. 				// If a number, add 'px' to the (except for certain CSS properties)
  6111. 				if ( type === "number" && !jQuery.cssNumber[ origName ] ) {
  6112. 					value += "px";
  6113. 				}
  6114. 	
  6115. 				// Support: IE9-11+
  6116. 				// background-* props affect original clone's values
  6117. 				if ( !support.clearCloneStyle && value === "" && name.indexOf( "background" ) === 0 ) {
  6118. 					style[ name ] = "inherit";
  6119. 				}
  6120. 	
  6121. 				// If a hook was provided, use that value, otherwise just set the specified value
  6122. 				if ( !hooks || !("set" in hooks) || (value = hooks.set( elem, value, extra )) !== undefined ) {
  6123. 					style[ name ] = value;
  6124. 				}
  6125. 	
  6126. 			} else {
  6127. 				// If a hook was provided get the non-computed value from there
  6128. 				if ( hooks && "get" in hooks && (ret = hooks.get( elem, false, extra )) !== undefined ) {
  6129. 					return ret;
  6130. 				}
  6131. 	
  6132. 				// Otherwise just get the value from the style object
  6133. 				return style[ name ];
  6134. 			}
  6135. 		},
  6136. 	
  6137. 		css: function( elem, name, extra, styles ) {
  6138. 			var val, num, hooks,
  6139. 				origName = jQuery.camelCase( name );
  6140. 	
  6141. 			// Make sure that we're working with the right name
  6142. 			name = jQuery.cssProps[ origName ] || ( jQuery.cssProps[ origName ] = vendorPropName( elem.style, origName ) );
  6143. 	
  6144. 			// Try prefixed name followed by the unprefixed name
  6145. 			hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ];
  6146. 	
  6147. 			// If a hook was provided get the computed value from there
  6148. 			if ( hooks && "get" in hooks ) {
  6149. 				val = hooks.get( elem, true, extra );
  6150. 			}
  6151. 	
  6152. 			// Otherwise, if a way to get the computed value exists, use that
  6153. 			if ( val === undefined ) {
  6154. 				val = curCSS( elem, name, styles );
  6155. 			}
  6156. 	
  6157. 			// Convert "normal" to computed value
  6158. 			if ( val === "normal" && name in cssNormalTransform ) {
  6159. 				val = cssNormalTransform[ name ];
  6160. 			}
  6161. 	
  6162. 			// Make numeric if forced or a qualifier was provided and val looks numeric
  6163. 			if ( extra === "" || extra ) {
  6164. 				num = parseFloat( val );
  6165. 				return extra === true || jQuery.isNumeric( num ) ? num || 0 : val;
  6166. 			}
  6167. 			return val;
  6168. 		}
  6169. 	});
  6170. 	
  6171. 	jQuery.each([ "height", "width" ], function( i, name ) {
  6172. 		jQuery.cssHooks[ name ] = {
  6173. 			get: function( elem, computed, extra ) {
  6174. 				if ( computed ) {
  6175. 	
  6176. 					// Certain elements can have dimension info if we invisibly show them
  6177. 					// but it must have a current display style that would benefit
  6178. 					return rdisplayswap.test( jQuery.css( elem, "display" ) ) && elem.offsetWidth === 0 ?
  6179. 						jQuery.swap( elem, cssShow, function() {
  6180. 							return getWidthOrHeight( elem, name, extra );
  6181. 						}) :
  6182. 						getWidthOrHeight( elem, name, extra );
  6183. 				}
  6184. 			},
  6185. 	
  6186. 			set: function( elem, value, extra ) {
  6187. 				var styles = extra && getStyles( elem );
  6188. 				return setPositiveNumber( elem, value, extra ?
  6189. 					augmentWidthOrHeight(
  6190. 						elem,
  6191. 						name,
  6192. 						extra,
  6193. 						jQuery.css( elem, "boxSizing", false, styles ) === "border-box",
  6194. 						styles
  6195. 					) : 0
  6196. 				);
  6197. 			}
  6198. 		};
  6199. 	});
  6200. 	
  6201. 	// Support: Android 2.3
  6202. 	jQuery.cssHooks.marginRight = addGetHookIf( support.reliableMarginRight,
  6203. 		function( elem, computed ) {
  6204. 			if ( computed ) {
  6205. 				return jQuery.swap( elem, { "display": "inline-block" },
  6206. 					curCSS, [ elem, "marginRight" ] );
  6207. 			}
  6208. 		}
  6209. 	);
  6210. 	
  6211. 	// These hooks are used by animate to expand properties
  6212. 	jQuery.each({
  6213. 		margin: "",
  6214. 		padding: "",
  6215. 		border: "Width"
  6216. 	}, function( prefix, suffix ) {
  6217. 		jQuery.cssHooks[ prefix + suffix ] = {
  6218. 			expand: function( value ) {
  6219. 				var i = 0,
  6220. 					expanded = {},
  6221. 	
  6222. 					// Assumes a single number if not a string
  6223. 					parts = typeof value === "string" ? value.split(" ") : [ value ];
  6224. 	
  6225. 				for ( ; i < 4; i++ ) {
  6226. 					expanded[ prefix + cssExpand[ i ] + suffix ] =
  6227. 						parts[ i ] || parts[ i - 2 ] || parts[ 0 ];
  6228. 				}
  6229. 	
  6230. 				return expanded;
  6231. 			}
  6232. 		};
  6233. 	
  6234. 		if ( !rmargin.test( prefix ) ) {
  6235. 			jQuery.cssHooks[ prefix + suffix ].set = setPositiveNumber;
  6236. 		}
  6237. 	});
  6238. 	
  6239. 	jQuery.fn.extend({
  6240. 		css: function( name, value ) {
  6241. 			return access( this, function( elem, name, value ) {
  6242. 				var styles, len,
  6243. 					map = {},
  6244. 					i = 0;
  6245. 	
  6246. 				if ( jQuery.isArray( name ) ) {
  6247. 					styles = getStyles( elem );
  6248. 					len = name.length;
  6249. 	
  6250. 					for ( ; i < len; i++ ) {
  6251. 						map[ name[ i ] ] = jQuery.css( elem, name[ i ], false, styles );
  6252. 					}
  6253. 	
  6254. 					return map;
  6255. 				}
  6256. 	
  6257. 				return value !== undefined ?
  6258. 					jQuery.style( elem, name, value ) :
  6259. 					jQuery.css( elem, name );
  6260. 			}, name, value, arguments.length > 1 );
  6261. 		},
  6262. 		show: function() {
  6263. 			return showHide( this, true );
  6264. 		},
  6265. 		hide: function() {
  6266. 			return showHide( this );
  6267. 		},
  6268. 		toggle: function( state ) {
  6269. 			if ( typeof state === "boolean" ) {
  6270. 				return state ? this.show() : this.hide();
  6271. 			}
  6272. 	
  6273. 			return this.each(function() {
  6274. 				if ( isHidden( this ) ) {
  6275. 					jQuery( this ).show();
  6276. 				} else {
  6277. 					jQuery( this ).hide();
  6278. 				}
  6279. 			});
  6280. 		}
  6281. 	});
  6282. 	
  6283. 	
  6284. 	function Tween( elem, options, prop, end, easing ) {
  6285. 		return new Tween.prototype.init( elem, options, prop, end, easing );
  6286. 	}
  6287. 	jQuery.Tween = Tween;
  6288. 	
  6289. 	Tween.prototype = {
  6290. 		constructor: Tween,
  6291. 		init: function( elem, options, prop, end, easing, unit ) {
  6292. 			this.elem = elem;
  6293. 			this.prop = prop;
  6294. 			this.easing = easing || "swing";
  6295. 			this.options = options;
  6296. 			this.start = this.now = this.cur();
  6297. 			this.end = end;
  6298. 			this.unit = unit || ( jQuery.cssNumber[ prop ] ? "" : "px" );
  6299. 		},
  6300. 		cur: function() {
  6301. 			var hooks = Tween.propHooks[ this.prop ];
  6302. 	
  6303. 			return hooks && hooks.get ?
  6304. 				hooks.get( this ) :
  6305. 				Tween.propHooks._default.get( this );
  6306. 		},
  6307. 		run: function( percent ) {
  6308. 			var eased,
  6309. 				hooks = Tween.propHooks[ this.prop ];
  6310. 	
  6311. 			if ( this.options.duration ) {
  6312. 				this.pos = eased = jQuery.easing[ this.easing ](
  6313. 					percent, this.options.duration * percent, 0, 1, this.options.duration
  6314. 				);
  6315. 			} else {
  6316. 				this.pos = eased = percent;
  6317. 			}
  6318. 			this.now = ( this.end - this.start ) * eased + this.start;
  6319. 	
  6320. 			if ( this.options.step ) {
  6321. 				this.options.step.call( this.elem, this.now, this );
  6322. 			}
  6323. 	
  6324. 			if ( hooks && hooks.set ) {
  6325. 				hooks.set( this );
  6326. 			} else {
  6327. 				Tween.propHooks._default.set( this );
  6328. 			}
  6329. 			return this;
  6330. 		}
  6331. 	};
  6332. 	
  6333. 	Tween.prototype.init.prototype = Tween.prototype;
  6334. 	
  6335. 	Tween.propHooks = {
  6336. 		_default: {
  6337. 			get: function( tween ) {
  6338. 				var result;
  6339. 	
  6340. 				if ( tween.elem[ tween.prop ] != null &&
  6341. 					(!tween.elem.style || tween.elem.style[ tween.prop ] == null) ) {
  6342. 					return tween.elem[ tween.prop ];
  6343. 				}
  6344. 	
  6345. 				// Passing an empty string as a 3rd parameter to .css will automatically
  6346. 				// attempt a parseFloat and fallback to a string if the parse fails.
  6347. 				// Simple values such as "10px" are parsed to Float;
  6348. 				// complex values such as "rotate(1rad)" are returned as-is.
  6349. 				result = jQuery.css( tween.elem, tween.prop, "" );
  6350. 				// Empty strings, null, undefined and "auto" are converted to 0.
  6351. 				return !result || result === "auto" ? 0 : result;
  6352. 			},
  6353. 			set: function( tween ) {
  6354. 				// Use step hook for back compat.
  6355. 				// Use cssHook if its there.
  6356. 				// Use .style if available and use plain properties where available.
  6357. 				if ( jQuery.fx.step[ tween.prop ] ) {
  6358. 					jQuery.fx.step[ tween.prop ]( tween );
  6359. 				} else if ( tween.elem.style && ( tween.elem.style[ jQuery.cssProps[ tween.prop ] ] != null || jQuery.cssHooks[ tween.prop ] ) ) {
  6360. 					jQuery.style( tween.elem, tween.prop, tween.now + tween.unit );
  6361. 				} else {
  6362. 					tween.elem[ tween.prop ] = tween.now;
  6363. 				}
  6364. 			}
  6365. 		}
  6366. 	};
  6367. 	
  6368. 	// Support: IE9
  6369. 	// Panic based approach to setting things on disconnected nodes
  6370. 	Tween.propHooks.scrollTop = Tween.propHooks.scrollLeft = {
  6371. 		set: function( tween ) {
  6372. 			if ( tween.elem.nodeType && tween.elem.parentNode ) {
  6373. 				tween.elem[ tween.prop ] = tween.now;
  6374. 			}
  6375. 		}
  6376. 	};
  6377. 	
  6378. 	jQuery.easing = {
  6379. 		linear: function( p ) {
  6380. 			return p;
  6381. 		},
  6382. 		swing: function( p ) {
  6383. 			return 0.5 - Math.cos( p * Math.PI ) / 2;
  6384. 		}
  6385. 	};
  6386. 	
  6387. 	jQuery.fx = Tween.prototype.init;
  6388. 	
  6389. 	// Back Compat <1.8 extension point
  6390. 	jQuery.fx.step = {};
  6391. 	
  6392. 	
  6393. 	
  6394. 	
  6395. 	var
  6396. 		fxNow, timerId,
  6397. 		rfxtypes = /^(?:toggle|show|hide)$/,
  6398. 		rfxnum = new RegExp( "^(?:([+-])=|)(" + pnum + ")([a-z%]*)$", "i" ),
  6399. 		rrun = /queueHooks$/,
  6400. 		animationPrefilters = [ defaultPrefilter ],
  6401. 		tweeners = {
  6402. 			"*": [ function( prop, value ) {
  6403. 				var tween = this.createTween( prop, value ),
  6404. 					target = tween.cur(),
  6405. 					parts = rfxnum.exec( value ),
  6406. 					unit = parts && parts[ 3 ] || ( jQuery.cssNumber[ prop ] ? "" : "px" ),
  6407. 	
  6408. 					// Starting value computation is required for potential unit mismatches
  6409. 					start = ( jQuery.cssNumber[ prop ] || unit !== "px" && +target ) &&
  6410. 						rfxnum.exec( jQuery.css( tween.elem, prop ) ),
  6411. 					scale = 1,
  6412. 					maxIterations = 20;
  6413. 	
  6414. 				if ( start && start[ 3 ] !== unit ) {
  6415. 					// Trust units reported by jQuery.css
  6416. 					unit = unit || start[ 3 ];
  6417. 	
  6418. 					// Make sure we update the tween properties later on
  6419. 					parts = parts || [];
  6420. 	
  6421. 					// Iteratively approximate from a nonzero starting point
  6422. 					start = +target || 1;
  6423. 	
  6424. 					do {
  6425. 						// If previous iteration zeroed out, double until we get *something*.
  6426. 						// Use string for doubling so we don't accidentally see scale as unchanged below
  6427. 						scale = scale || ".5";
  6428. 	
  6429. 						// Adjust and apply
  6430. 						start = start / scale;
  6431. 						jQuery.style( tween.elem, prop, start + unit );
  6432. 	
  6433. 					// Update scale, tolerating zero or NaN from tween.cur(),
  6434. 					// break the loop if scale is unchanged or perfect, or if we've just had enough
  6435. 					} while ( scale !== (scale = tween.cur() / target) && scale !== 1 && --maxIterations );
  6436. 				}
  6437. 	
  6438. 				// Update tween properties
  6439. 				if ( parts ) {
  6440. 					start = tween.start = +start || +target || 0;
  6441. 					tween.unit = unit;
  6442. 					// If a +=/-= token was provided, we're doing a relative animation
  6443. 					tween.end = parts[ 1 ] ?
  6444. 						start + ( parts[ 1 ] + 1 ) * parts[ 2 ] :
  6445. 						+parts[ 2 ];
  6446. 				}
  6447. 	
  6448. 				return tween;
  6449. 			} ]
  6450. 		};
  6451. 	
  6452. 	// Animations created synchronously will run synchronously
  6453. 	function createFxNow() {
  6454. 		setTimeout(function() {
  6455. 			fxNow = undefined;
  6456. 		});
  6457. 		return ( fxNow = jQuery.now() );
  6458. 	}
  6459. 	
  6460. 	// Generate parameters to create a standard animation
  6461. 	function genFx( type, includeWidth ) {
  6462. 		var which,
  6463. 			i = 0,
  6464. 			attrs = { height: type };
  6465. 	
  6466. 		// If we include width, step value is 1 to do all cssExpand values,
  6467. 		// otherwise step value is 2 to skip over Left and Right
  6468. 		includeWidth = includeWidth ? 1 : 0;
  6469. 		for ( ; i < 4 ; i += 2 - includeWidth ) {
  6470. 			which = cssExpand[ i ];
  6471. 			attrs[ "margin" + which ] = attrs[ "padding" + which ] = type;
  6472. 		}
  6473. 	
  6474. 		if ( includeWidth ) {
  6475. 			attrs.opacity = attrs.width = type;
  6476. 		}
  6477. 	
  6478. 		return attrs;
  6479. 	}
  6480. 	
  6481. 	function createTween( value, prop, animation ) {
  6482. 		var tween,
  6483. 			collection = ( tweeners[ prop ] || [] ).concat( tweeners[ "*" ] ),
  6484. 			index = 0,
  6485. 			length = collection.length;
  6486. 		for ( ; index < length; index++ ) {
  6487. 			if ( (tween = collection[ index ].call( animation, prop, value )) ) {
  6488. 	
  6489. 				// We're done with this property
  6490. 				return tween;
  6491. 			}
  6492. 		}
  6493. 	}
  6494. 	
  6495. 	function defaultPrefilter( elem, props, opts ) {
  6496. 		/* jshint validthis: true */
  6497. 		var prop, value, toggle, tween, hooks, oldfire, display, checkDisplay,
  6498. 			anim = this,
  6499. 			orig = {},
  6500. 			style = elem.style,
  6501. 			hidden = elem.nodeType && isHidden( elem ),
  6502. 			dataShow = data_priv.get( elem, "fxshow" );
  6503. 	
  6504. 		// Handle queue: false promises
  6505. 		if ( !opts.queue ) {
  6506. 			hooks = jQuery._queueHooks( elem, "fx" );
  6507. 			if ( hooks.unqueued == null ) {
  6508. 				hooks.unqueued = 0;
  6509. 				oldfire = hooks.empty.fire;
  6510. 				hooks.empty.fire = function() {
  6511. 					if ( !hooks.unqueued ) {
  6512. 						oldfire();
  6513. 					}
  6514. 				};
  6515. 			}
  6516. 			hooks.unqueued++;
  6517. 	
  6518. 			anim.always(function() {
  6519. 				// Ensure the complete handler is called before this completes
  6520. 				anim.always(function() {
  6521. 					hooks.unqueued--;
  6522. 					if ( !jQuery.queue( elem, "fx" ).length ) {
  6523. 						hooks.empty.fire();
  6524. 					}
  6525. 				});
  6526. 			});
  6527. 		}
  6528. 	
  6529. 		// Height/width overflow pass
  6530. 		if ( elem.nodeType === 1 && ( "height" in props || "width" in props ) ) {
  6531. 			// Make sure that nothing sneaks out
  6532. 			// Record all 3 overflow attributes because IE9-10 do not
  6533. 			// change the overflow attribute when overflowX and
  6534. 			// overflowY are set to the same value
  6535. 			opts.overflow = [ style.overflow, style.overflowX, style.overflowY ];
  6536. 	
  6537. 			// Set display property to inline-block for height/width
  6538. 			// animations on inline elements that are having width/height animated
  6539. 			display = jQuery.css( elem, "display" );
  6540. 	
  6541. 			// Test default display if display is currently "none"
  6542. 			checkDisplay = display === "none" ?
  6543. 				data_priv.get( elem, "olddisplay" ) || defaultDisplay( elem.nodeName ) : display;
  6544. 	
  6545. 			if ( checkDisplay === "inline" && jQuery.css( elem, "float" ) === "none" ) {
  6546. 				style.display = "inline-block";
  6547. 			}
  6548. 		}
  6549. 	
  6550. 		if ( opts.overflow ) {
  6551. 			style.overflow = "hidden";
  6552. 			anim.always(function() {
  6553. 				style.overflow = opts.overflow[ 0 ];
  6554. 				style.overflowX = opts.overflow[ 1 ];
  6555. 				style.overflowY = opts.overflow[ 2 ];
  6556. 			});
  6557. 		}
  6558. 	
  6559. 		// show/hide pass
  6560. 		for ( prop in props ) {
  6561. 			value = props[ prop ];
  6562. 			if ( rfxtypes.exec( value ) ) {
  6563. 				delete props[ prop ];
  6564. 				toggle = toggle || value === "toggle";
  6565. 				if ( value === ( hidden ? "hide" : "show" ) ) {
  6566. 	
  6567. 					// If there is dataShow left over from a stopped hide or show and we are going to proceed with show, we should pretend to be hidden
  6568. 					if ( value === "show" && dataShow && dataShow[ prop ] !== undefined ) {
  6569. 						hidden = true;
  6570. 					} else {
  6571. 						continue;
  6572. 					}
  6573. 				}
  6574. 				orig[ prop ] = dataShow && dataShow[ prop ] || jQuery.style( elem, prop );
  6575. 	
  6576. 			// Any non-fx value stops us from restoring the original display value
  6577. 			} else {
  6578. 				display = undefined;
  6579. 			}
  6580. 		}
  6581. 	
  6582. 		if ( !jQuery.isEmptyObject( orig ) ) {
  6583. 			if ( dataShow ) {
  6584. 				if ( "hidden" in dataShow ) {
  6585. 					hidden = dataShow.hidden;
  6586. 				}
  6587. 			} else {
  6588. 				dataShow = data_priv.access( elem, "fxshow", {} );
  6589. 			}
  6590. 	
  6591. 			// Store state if its toggle - enables .stop().toggle() to "reverse"
  6592. 			if ( toggle ) {
  6593. 				dataShow.hidden = !hidden;
  6594. 			}
  6595. 			if ( hidden ) {
  6596. 				jQuery( elem ).show();
  6597. 			} else {
  6598. 				anim.done(function() {
  6599. 					jQuery( elem ).hide();
  6600. 				});
  6601. 			}
  6602. 			anim.done(function() {
  6603. 				var prop;
  6604. 	
  6605. 				data_priv.remove( elem, "fxshow" );
  6606. 				for ( prop in orig ) {
  6607. 					jQuery.style( elem, prop, orig[ prop ] );
  6608. 				}
  6609. 			});
  6610. 			for ( prop in orig ) {
  6611. 				tween = createTween( hidden ? dataShow[ prop ] : 0, prop, anim );
  6612. 	
  6613. 				if ( !( prop in dataShow ) ) {
  6614. 					dataShow[ prop ] = tween.start;
  6615. 					if ( hidden ) {
  6616. 						tween.end = tween.start;
  6617. 						tween.start = prop === "width" || prop === "height" ? 1 : 0;
  6618. 					}
  6619. 				}
  6620. 			}
  6621. 	
  6622. 		// If this is a noop like .hide().hide(), restore an overwritten display value
  6623. 		} else if ( (display === "none" ? defaultDisplay( elem.nodeName ) : display) === "inline" ) {
  6624. 			style.display = display;
  6625. 		}
  6626. 	}
  6627. 	
  6628. 	function propFilter( props, specialEasing ) {
  6629. 		var index, name, easing, value, hooks;
  6630. 	
  6631. 		// camelCase, specialEasing and expand cssHook pass
  6632. 		for ( index in props ) {
  6633. 			name = jQuery.camelCase( index );
  6634. 			easing = specialEasing[ name ];
  6635. 			value = props[ index ];
  6636. 			if ( jQuery.isArray( value ) ) {
  6637. 				easing = value[ 1 ];
  6638. 				value = props[ index ] = value[ 0 ];
  6639. 			}
  6640. 	
  6641. 			if ( index !== name ) {
  6642. 				props[ name ] = value;
  6643. 				delete props[ index ];
  6644. 			}
  6645. 	
  6646. 			hooks = jQuery.cssHooks[ name ];
  6647. 			if ( hooks && "expand" in hooks ) {
  6648. 				value = hooks.expand( value );
  6649. 				delete props[ name ];
  6650. 	
  6651. 				// Not quite $.extend, this won't overwrite existing keys.
  6652. 				// Reusing 'index' because we have the correct "name"
  6653. 				for ( index in value ) {
  6654. 					if ( !( index in props ) ) {
  6655. 						props[ index ] = value[ index ];
  6656. 						specialEasing[ index ] = easing;
  6657. 					}
  6658. 				}
  6659. 			} else {
  6660. 				specialEasing[ name ] = easing;
  6661. 			}
  6662. 		}
  6663. 	}
  6664. 	
  6665. 	function Animation( elem, properties, options ) {
  6666. 		var result,
  6667. 			stopped,
  6668. 			index = 0,
  6669. 			length = animationPrefilters.length,
  6670. 			deferred = jQuery.Deferred().always( function() {
  6671. 				// Don't match elem in the :animated selector
  6672. 				delete tick.elem;
  6673. 			}),
  6674. 			tick = function() {
  6675. 				if ( stopped ) {
  6676. 					return false;
  6677. 				}
  6678. 				var currentTime = fxNow || createFxNow(),
  6679. 					remaining = Math.max( 0, animation.startTime + animation.duration - currentTime ),
  6680. 					// Support: Android 2.3
  6681. 					// Archaic crash bug won't allow us to use `1 - ( 0.5 || 0 )` (#12497)
  6682. 					temp = remaining / animation.duration || 0,
  6683. 					percent = 1 - temp,
  6684. 					index = 0,
  6685. 					length = animation.tweens.length;
  6686. 	
  6687. 				for ( ; index < length ; index++ ) {
  6688. 					animation.tweens[ index ].run( percent );
  6689. 				}
  6690. 	
  6691. 				deferred.notifyWith( elem, [ animation, percent, remaining ]);
  6692. 	
  6693. 				if ( percent < 1 && length ) {
  6694. 					return remaining;
  6695. 				} else {
  6696. 					deferred.resolveWith( elem, [ animation ] );
  6697. 					return false;
  6698. 				}
  6699. 			},
  6700. 			animation = deferred.promise({
  6701. 				elem: elem,
  6702. 				props: jQuery.extend( {}, properties ),
  6703. 				opts: jQuery.extend( true, { specialEasing: {} }, options ),
  6704. 				originalProperties: properties,
  6705. 				originalOptions: options,
  6706. 				startTime: fxNow || createFxNow(),
  6707. 				duration: options.duration,
  6708. 				tweens: [],
  6709. 				createTween: function( prop, end ) {
  6710. 					var tween = jQuery.Tween( elem, animation.opts, prop, end,
  6711. 							animation.opts.specialEasing[ prop ] || animation.opts.easing );
  6712. 					animation.tweens.push( tween );
  6713. 					return tween;
  6714. 				},
  6715. 				stop: function( gotoEnd ) {
  6716. 					var index = 0,
  6717. 						// If we are going to the end, we want to run all the tweens
  6718. 						// otherwise we skip this part
  6719. 						length = gotoEnd ? animation.tweens.length : 0;
  6720. 					if ( stopped ) {
  6721. 						return this;
  6722. 					}
  6723. 					stopped = true;
  6724. 					for ( ; index < length ; index++ ) {
  6725. 						animation.tweens[ index ].run( 1 );
  6726. 					}
  6727. 	
  6728. 					// Resolve when we played the last frame; otherwise, reject
  6729. 					if ( gotoEnd ) {
  6730. 						deferred.resolveWith( elem, [ animation, gotoEnd ] );
  6731. 					} else {
  6732. 						deferred.rejectWith( elem, [ animation, gotoEnd ] );
  6733. 					}
  6734. 					return this;
  6735. 				}
  6736. 			}),
  6737. 			props = animation.props;
  6738. 	
  6739. 		propFilter( props, animation.opts.specialEasing );
  6740. 	
  6741. 		for ( ; index < length ; index++ ) {
  6742. 			result = animationPrefilters[ index ].call( animation, elem, props, animation.opts );
  6743. 			if ( result ) {
  6744. 				return result;
  6745. 			}
  6746. 		}
  6747. 	
  6748. 		jQuery.map( props, createTween, animation );
  6749. 	
  6750. 		if ( jQuery.isFunction( animation.opts.start ) ) {
  6751. 			animation.opts.start.call( elem, animation );
  6752. 		}
  6753. 	
  6754. 		jQuery.fx.timer(
  6755. 			jQuery.extend( tick, {
  6756. 				elem: elem,
  6757. 				anim: animation,
  6758. 				queue: animation.opts.queue
  6759. 			})
  6760. 		);
  6761. 	
  6762. 		// attach callbacks from options
  6763. 		return animation.progress( animation.opts.progress )
  6764. 			.done( animation.opts.done, animation.opts.complete )
  6765. 			.fail( animation.opts.fail )
  6766. 			.always( animation.opts.always );
  6767. 	}
  6768. 	
  6769. 	jQuery.Animation = jQuery.extend( Animation, {
  6770. 	
  6771. 		tweener: function( props, callback ) {
  6772. 			if ( jQuery.isFunction( props ) ) {
  6773. 				callback = props;
  6774. 				props = [ "*" ];
  6775. 			} else {
  6776. 				props = props.split(" ");
  6777. 			}
  6778. 	
  6779. 			var prop,
  6780. 				index = 0,
  6781. 				length = props.length;
  6782. 	
  6783. 			for ( ; index < length ; index++ ) {
  6784. 				prop = props[ index ];
  6785. 				tweeners[ prop ] = tweeners[ prop ] || [];
  6786. 				tweeners[ prop ].unshift( callback );
  6787. 			}
  6788. 		},
  6789. 	
  6790. 		prefilter: function( callback, prepend ) {
  6791. 			if ( prepend ) {
  6792. 				animationPrefilters.unshift( callback );
  6793. 			} else {
  6794. 				animationPrefilters.push( callback );
  6795. 			}
  6796. 		}
  6797. 	});
  6798. 	
  6799. 	jQuery.speed = function( speed, easing, fn ) {
  6800. 		var opt = speed && typeof speed === "object" ? jQuery.extend( {}, speed ) : {
  6801. 			complete: fn || !fn && easing ||
  6802. 				jQuery.isFunction( speed ) && speed,
  6803. 			duration: speed,
  6804. 			easing: fn && easing || easing && !jQuery.isFunction( easing ) && easing
  6805. 		};
  6806. 	
  6807. 		opt.duration = jQuery.fx.off ? 0 : typeof opt.duration === "number" ? opt.duration :
  6808. 			opt.duration in jQuery.fx.speeds ? jQuery.fx.speeds[ opt.duration ] : jQuery.fx.speeds._default;
  6809. 	
  6810. 		// Normalize opt.queue - true/undefined/null -> "fx"
  6811. 		if ( opt.queue == null || opt.queue === true ) {
  6812. 			opt.queue = "fx";
  6813. 		}
  6814. 	
  6815. 		// Queueing
  6816. 		opt.old = opt.complete;
  6817. 	
  6818. 		opt.complete = function() {
  6819. 			if ( jQuery.isFunction( opt.old ) ) {
  6820. 				opt.old.call( this );
  6821. 			}
  6822. 	
  6823. 			if ( opt.queue ) {
  6824. 				jQuery.dequeue( this, opt.queue );
  6825. 			}
  6826. 		};
  6827. 	
  6828. 		return opt;
  6829. 	};
  6830. 	
  6831. 	jQuery.fn.extend({
  6832. 		fadeTo: function( speed, to, easing, callback ) {
  6833. 	
  6834. 			// Show any hidden elements after setting opacity to 0
  6835. 			return this.filter( isHidden ).css( "opacity", 0 ).show()
  6836. 	
  6837. 				// Animate to the value specified
  6838. 				.end().animate({ opacity: to }, speed, easing, callback );
  6839. 		},
  6840. 		animate: function( prop, speed, easing, callback ) {
  6841. 			var empty = jQuery.isEmptyObject( prop ),
  6842. 				optall = jQuery.speed( speed, easing, callback ),
  6843. 				doAnimation = function() {
  6844. 					// Operate on a copy of prop so per-property easing won't be lost
  6845. 					var anim = Animation( this, jQuery.extend( {}, prop ), optall );
  6846. 	
  6847. 					// Empty animations, or finishing resolves immediately
  6848. 					if ( empty || data_priv.get( this, "finish" ) ) {
  6849. 						anim.stop( true );
  6850. 					}
  6851. 				};
  6852. 				doAnimation.finish = doAnimation;
  6853. 	
  6854. 			return empty || optall.queue === false ?
  6855. 				this.each( doAnimation ) :
  6856. 				this.queue( optall.queue, doAnimation );
  6857. 		},
  6858. 		stop: function( type, clearQueue, gotoEnd ) {
  6859. 			var stopQueue = function( hooks ) {
  6860. 				var stop = hooks.stop;
  6861. 				delete hooks.stop;
  6862. 				stop( gotoEnd );
  6863. 			};
  6864. 	
  6865. 			if ( typeof type !== "string" ) {
  6866. 				gotoEnd = clearQueue;
  6867. 				clearQueue = type;
  6868. 				type = undefined;
  6869. 			}
  6870. 			if ( clearQueue && type !== false ) {
  6871. 				this.queue( type || "fx", [] );
  6872. 			}
  6873. 	
  6874. 			return this.each(function() {
  6875. 				var dequeue = true,
  6876. 					index = type != null && type + "queueHooks",
  6877. 					timers = jQuery.timers,
  6878. 					data = data_priv.get( this );
  6879. 	
  6880. 				if ( index ) {
  6881. 					if ( data[ index ] && data[ index ].stop ) {
  6882. 						stopQueue( data[ index ] );
  6883. 					}
  6884. 				} else {
  6885. 					for ( index in data ) {
  6886. 						if ( data[ index ] && data[ index ].stop && rrun.test( index ) ) {
  6887. 							stopQueue( data[ index ] );
  6888. 						}
  6889. 					}
  6890. 				}
  6891. 	
  6892. 				for ( index = timers.length; index--; ) {
  6893. 					if ( timers[ index ].elem === this && (type == null || timers[ index ].queue === type) ) {
  6894. 						timers[ index ].anim.stop( gotoEnd );
  6895. 						dequeue = false;
  6896. 						timers.splice( index, 1 );
  6897. 					}
  6898. 				}
  6899. 	
  6900. 				// Start the next in the queue if the last step wasn't forced.
  6901. 				// Timers currently will call their complete callbacks, which
  6902. 				// will dequeue but only if they were gotoEnd.
  6903. 				if ( dequeue || !gotoEnd ) {
  6904. 					jQuery.dequeue( this, type );
  6905. 				}
  6906. 			});
  6907. 		},
  6908. 		finish: function( type ) {
  6909. 			if ( type !== false ) {
  6910. 				type = type || "fx";
  6911. 			}
  6912. 			return this.each(function() {
  6913. 				var index,
  6914. 					data = data_priv.get( this ),
  6915. 					queue = data[ type + "queue" ],
  6916. 					hooks = data[ type + "queueHooks" ],
  6917. 					timers = jQuery.timers,
  6918. 					length = queue ? queue.length : 0;
  6919. 	
  6920. 				// Enable finishing flag on private data
  6921. 				data.finish = true;
  6922. 	
  6923. 				// Empty the queue first
  6924. 				jQuery.queue( this, type, [] );
  6925. 	
  6926. 				if ( hooks && hooks.stop ) {
  6927. 					hooks.stop.call( this, true );
  6928. 				}
  6929. 	
  6930. 				// Look for any active animations, and finish them
  6931. 				for ( index = timers.length; index--; ) {
  6932. 					if ( timers[ index ].elem === this && timers[ index ].queue === type ) {
  6933. 						timers[ index ].anim.stop( true );
  6934. 						timers.splice( index, 1 );
  6935. 					}
  6936. 				}
  6937. 	
  6938. 				// Look for any animations in the old queue and finish them
  6939. 				for ( index = 0; index < length; index++ ) {
  6940. 					if ( queue[ index ] && queue[ index ].finish ) {
  6941. 						queue[ index ].finish.call( this );
  6942. 					}
  6943. 				}
  6944. 	
  6945. 				// Turn off finishing flag
  6946. 				delete data.finish;
  6947. 			});
  6948. 		}
  6949. 	});
  6950. 	
  6951. 	jQuery.each([ "toggle", "show", "hide" ], function( i, name ) {
  6952. 		var cssFn = jQuery.fn[ name ];
  6953. 		jQuery.fn[ name ] = function( speed, easing, callback ) {
  6954. 			return speed == null || typeof speed === "boolean" ?
  6955. 				cssFn.apply( this, arguments ) :
  6956. 				this.animate( genFx( name, true ), speed, easing, callback );
  6957. 		};
  6958. 	});
  6959. 	
  6960. 	// Generate shortcuts for custom animations
  6961. 	jQuery.each({
  6962. 		slideDown: genFx("show"),
  6963. 		slideUp: genFx("hide"),
  6964. 		slideToggle: genFx("toggle"),
  6965. 		fadeIn: { opacity: "show" },
  6966. 		fadeOut: { opacity: "hide" },
  6967. 		fadeToggle: { opacity: "toggle" }
  6968. 	}, function( name, props ) {
  6969. 		jQuery.fn[ name ] = function( speed, easing, callback ) {
  6970. 			return this.animate( props, speed, easing, callback );
  6971. 		};
  6972. 	});
  6973. 	
  6974. 	jQuery.timers = [];
  6975. 	jQuery.fx.tick = function() {
  6976. 		var timer,
  6977. 			i = 0,
  6978. 			timers = jQuery.timers;
  6979. 	
  6980. 		fxNow = jQuery.now();
  6981. 	
  6982. 		for ( ; i < timers.length; i++ ) {
  6983. 			timer = timers[ i ];
  6984. 			// Checks the timer has not already been removed
  6985. 			if ( !timer() && timers[ i ] === timer ) {
  6986. 				timers.splice( i--, 1 );
  6987. 			}
  6988. 		}
  6989. 	
  6990. 		if ( !timers.length ) {
  6991. 			jQuery.fx.stop();
  6992. 		}
  6993. 		fxNow = undefined;
  6994. 	};
  6995. 	
  6996. 	jQuery.fx.timer = function( timer ) {
  6997. 		jQuery.timers.push( timer );
  6998. 		if ( timer() ) {
  6999. 			jQuery.fx.start();
  7000. 		} else {
  7001. 			jQuery.timers.pop();
  7002. 		}
  7003. 	};
  7004. 	
  7005. 	jQuery.fx.interval = 13;
  7006. 	
  7007. 	jQuery.fx.start = function() {
  7008. 		if ( !timerId ) {
  7009. 			timerId = setInterval( jQuery.fx.tick, jQuery.fx.interval );
  7010. 		}
  7011. 	};
  7012. 	
  7013. 	jQuery.fx.stop = function() {
  7014. 		clearInterval( timerId );
  7015. 		timerId = null;
  7016. 	};
  7017. 	
  7018. 	jQuery.fx.speeds = {
  7019. 		slow: 600,
  7020. 		fast: 200,
  7021. 		// Default speed
  7022. 		_default: 400
  7023. 	};
  7024. 	
  7025. 	
  7026. 	// Based off of the plugin by Clint Helfers, with permission.
  7027. 	// http://blindsignals.com/index.php/2009/07/jquery-delay/
  7028. 	jQuery.fn.delay = function( time, type ) {
  7029. 		time = jQuery.fx ? jQuery.fx.speeds[ time ] || time : time;
  7030. 		type = type || "fx";
  7031. 	
  7032. 		return this.queue( type, function( next, hooks ) {
  7033. 			var timeout = setTimeout( next, time );
  7034. 			hooks.stop = function() {
  7035. 				clearTimeout( timeout );
  7036. 			};
  7037. 		});
  7038. 	};
  7039. 	
  7040. 	
  7041. 	(function() {
  7042. 		var input = document.createElement( "input" ),
  7043. 			select = document.createElement( "select" ),
  7044. 			opt = select.appendChild( document.createElement( "option" ) );
  7045. 	
  7046. 		input.type = "checkbox";
  7047. 	
  7048. 		// Support: iOS<=5.1, Android<=4.2+
  7049. 		// Default value for a checkbox should be "on"
  7050. 		support.checkOn = input.value !== "";
  7051. 	
  7052. 		// Support: IE<=11+
  7053. 		// Must access selectedIndex to make default options select
  7054. 		support.optSelected = opt.selected;
  7055. 	
  7056. 		// Support: Android<=2.3
  7057. 		// Options inside disabled selects are incorrectly marked as disabled
  7058. 		select.disabled = true;
  7059. 		support.optDisabled = !opt.disabled;
  7060. 	
  7061. 		// Support: IE<=11+
  7062. 		// An input loses its value after becoming a radio
  7063. 		input = document.createElement( "input" );
  7064. 		input.value = "t";
  7065. 		input.type = "radio";
  7066. 		support.radioValue = input.value === "t";
  7067. 	})();
  7068. 	
  7069. 	
  7070. 	var nodeHook, boolHook,
  7071. 		attrHandle = jQuery.expr.attrHandle;
  7072. 	
  7073. 	jQuery.fn.extend({
  7074. 		attr: function( name, value ) {
  7075. 			return access( this, jQuery.attr, name, value, arguments.length > 1 );
  7076. 		},
  7077. 	
  7078. 		removeAttr: function( name ) {
  7079. 			return this.each(function() {
  7080. 				jQuery.removeAttr( this, name );
  7081. 			});
  7082. 		}
  7083. 	});
  7084. 	
  7085. 	jQuery.extend({
  7086. 		attr: function( elem, name, value ) {
  7087. 			var hooks, ret,
  7088. 				nType = elem.nodeType;
  7089. 	
  7090. 			// don't get/set attributes on text, comment and attribute nodes
  7091. 			if ( !elem || nType === 3 || nType === 8 || nType === 2 ) {
  7092. 				return;
  7093. 			}
  7094. 	
  7095. 			// Fallback to prop when attributes are not supported
  7096. 			if ( typeof elem.getAttribute === strundefined ) {
  7097. 				return jQuery.prop( elem, name, value );
  7098. 			}
  7099. 	
  7100. 			// All attributes are lowercase
  7101. 			// Grab necessary hook if one is defined
  7102. 			if ( nType !== 1 || !jQuery.isXMLDoc( elem ) ) {
  7103. 				name = name.toLowerCase();
  7104. 				hooks = jQuery.attrHooks[ name ] ||
  7105. 					( jQuery.expr.match.bool.test( name ) ? boolHook : nodeHook );
  7106. 			}
  7107. 	
  7108. 			if ( value !== undefined ) {
  7109. 	
  7110. 				if ( value === null ) {
  7111. 					jQuery.removeAttr( elem, name );
  7112. 	
  7113. 				} else if ( hooks && "set" in hooks && (ret = hooks.set( elem, value, name )) !== undefined ) {
  7114. 					return ret;
  7115. 	
  7116. 				} else {
  7117. 					elem.setAttribute( name, value + "" );
  7118. 					return value;
  7119. 				}
  7120. 	
  7121. 			} else if ( hooks && "get" in hooks && (ret = hooks.get( elem, name )) !== null ) {
  7122. 				return ret;
  7123. 	
  7124. 			} else {
  7125. 				ret = jQuery.find.attr( elem, name );
  7126. 	
  7127. 				// Non-existent attributes return null, we normalize to undefined
  7128. 				return ret == null ?
  7129. 					undefined :
  7130. 					ret;
  7131. 			}
  7132. 		},
  7133. 	
  7134. 		removeAttr: function( elem, value ) {
  7135. 			var name, propName,
  7136. 				i = 0,
  7137. 				attrNames = value && value.match( rnotwhite );
  7138. 	
  7139. 			if ( attrNames && elem.nodeType === 1 ) {
  7140. 				while ( (name = attrNames[i++]) ) {
  7141. 					propName = jQuery.propFix[ name ] || name;
  7142. 	
  7143. 					// Boolean attributes get special treatment (#10870)
  7144. 					if ( jQuery.expr.match.bool.test( name ) ) {
  7145. 						// Set corresponding property to false
  7146. 						elem[ propName ] = false;
  7147. 					}
  7148. 	
  7149. 					elem.removeAttribute( name );
  7150. 				}
  7151. 			}
  7152. 		},
  7153. 	
  7154. 		attrHooks: {
  7155. 			type: {
  7156. 				set: function( elem, value ) {
  7157. 					if ( !support.radioValue && value === "radio" &&
  7158. 						jQuery.nodeName( elem, "input" ) ) {
  7159. 						var val = elem.value;
  7160. 						elem.setAttribute( "type", value );
  7161. 						if ( val ) {
  7162. 							elem.value = val;
  7163. 						}
  7164. 						return value;
  7165. 					}
  7166. 				}
  7167. 			}
  7168. 		}
  7169. 	});
  7170. 	
  7171. 	// Hooks for boolean attributes
  7172. 	boolHook = {
  7173. 		set: function( elem, value, name ) {
  7174. 			if ( value === false ) {
  7175. 				// Remove boolean attributes when set to false
  7176. 				jQuery.removeAttr( elem, name );
  7177. 			} else {
  7178. 				elem.setAttribute( name, name );
  7179. 			}
  7180. 			return name;
  7181. 		}
  7182. 	};
  7183. 	jQuery.each( jQuery.expr.match.bool.source.match( /\w+/g ), function( i, name ) {
  7184. 		var getter = attrHandle[ name ] || jQuery.find.attr;
  7185. 	
  7186. 		attrHandle[ name ] = function( elem, name, isXML ) {
  7187. 			var ret, handle;
  7188. 			if ( !isXML ) {
  7189. 				// Avoid an infinite loop by temporarily removing this function from the getter
  7190. 				handle = attrHandle[ name ];
  7191. 				attrHandle[ name ] = ret;
  7192. 				ret = getter( elem, name, isXML ) != null ?
  7193. 					name.toLowerCase() :
  7194. 					null;
  7195. 				attrHandle[ name ] = handle;
  7196. 			}
  7197. 			return ret;
  7198. 		};
  7199. 	});
  7200. 	
  7201. 	
  7202. 	
  7203. 	
  7204. 	var rfocusable = /^(?:input|select|textarea|button)$/i;
  7205. 	
  7206. 	jQuery.fn.extend({
  7207. 		prop: function( name, value ) {
  7208. 			return access( this, jQuery.prop, name, value, arguments.length > 1 );
  7209. 		},
  7210. 	
  7211. 		removeProp: function( name ) {
  7212. 			return this.each(function() {
  7213. 				delete this[ jQuery.propFix[ name ] || name ];
  7214. 			});
  7215. 		}
  7216. 	});
  7217. 	
  7218. 	jQuery.extend({
  7219. 		propFix: {
  7220. 			"for": "htmlFor",
  7221. 			"class": "className"
  7222. 		},
  7223. 	
  7224. 		prop: function( elem, name, value ) {
  7225. 			var ret, hooks, notxml,
  7226. 				nType = elem.nodeType;
  7227. 	
  7228. 			// Don't get/set properties on text, comment and attribute nodes
  7229. 			if ( !elem || nType === 3 || nType === 8 || nType === 2 ) {
  7230. 				return;
  7231. 			}
  7232. 	
  7233. 			notxml = nType !== 1 || !jQuery.isXMLDoc( elem );
  7234. 	
  7235. 			if ( notxml ) {
  7236. 				// Fix name and attach hooks
  7237. 				name = jQuery.propFix[ name ] || name;
  7238. 				hooks = jQuery.propHooks[ name ];
  7239. 			}
  7240. 	
  7241. 			if ( value !== undefined ) {
  7242. 				return hooks && "set" in hooks && (ret = hooks.set( elem, value, name )) !== undefined ?
  7243. 					ret :
  7244. 					( elem[ name ] = value );
  7245. 	
  7246. 			} else {
  7247. 				return hooks && "get" in hooks && (ret = hooks.get( elem, name )) !== null ?
  7248. 					ret :
  7249. 					elem[ name ];
  7250. 			}
  7251. 		},
  7252. 	
  7253. 		propHooks: {
  7254. 			tabIndex: {
  7255. 				get: function( elem ) {
  7256. 					return elem.hasAttribute( "tabindex" ) || rfocusable.test( elem.nodeName ) || elem.href ?
  7257. 						elem.tabIndex :
  7258. 						-1;
  7259. 				}
  7260. 			}
  7261. 		}
  7262. 	});
  7263. 	
  7264. 	if ( !support.optSelected ) {
  7265. 		jQuery.propHooks.selected = {
  7266. 			get: function( elem ) {
  7267. 				var parent = elem.parentNode;
  7268. 				if ( parent && parent.parentNode ) {
  7269. 					parent.parentNode.selectedIndex;
  7270. 				}
  7271. 				return null;
  7272. 			}
  7273. 		};
  7274. 	}
  7275. 	
  7276. 	jQuery.each([
  7277. 		"tabIndex",
  7278. 		"readOnly",
  7279. 		"maxLength",
  7280. 		"cellSpacing",
  7281. 		"cellPadding",
  7282. 		"rowSpan",
  7283. 		"colSpan",
  7284. 		"useMap",
  7285. 		"frameBorder",
  7286. 		"contentEditable"
  7287. 	], function() {
  7288. 		jQuery.propFix[ this.toLowerCase() ] = this;
  7289. 	});
  7290. 	
  7291. 	
  7292. 	
  7293. 	
  7294. 	var rclass = /[\t\r\n\f]/g;
  7295. 	
  7296. 	jQuery.fn.extend({
  7297. 		addClass: function( value ) {
  7298. 			var classes, elem, cur, clazz, j, finalValue,
  7299. 				proceed = typeof value === "string" && value,
  7300. 				i = 0,
  7301. 				len = this.length;
  7302. 	
  7303. 			if ( jQuery.isFunction( value ) ) {
  7304. 				return this.each(function( j ) {
  7305. 					jQuery( this ).addClass( value.call( this, j, this.className ) );
  7306. 				});
  7307. 			}
  7308. 	
  7309. 			if ( proceed ) {
  7310. 				// The disjunction here is for better compressibility (see removeClass)
  7311. 				classes = ( value || "" ).match( rnotwhite ) || [];
  7312. 	
  7313. 				for ( ; i < len; i++ ) {
  7314. 					elem = this[ i ];
  7315. 					cur = elem.nodeType === 1 && ( elem.className ?
  7316. 						( " " + elem.className + " " ).replace( rclass, " " ) :
  7317. 						" "
  7318. 					);
  7319. 	
  7320. 					if ( cur ) {
  7321. 						j = 0;
  7322. 						while ( (clazz = classes[j++]) ) {
  7323. 							if ( cur.indexOf( " " + clazz + " " ) < 0 ) {
  7324. 								cur += clazz + " ";
  7325. 							}
  7326. 						}
  7327. 	
  7328. 						// only assign if different to avoid unneeded rendering.
  7329. 						finalValue = jQuery.trim( cur );
  7330. 						if ( elem.className !== finalValue ) {
  7331. 							elem.className = finalValue;
  7332. 						}
  7333. 					}
  7334. 				}
  7335. 			}
  7336. 	
  7337. 			return this;
  7338. 		},
  7339. 	
  7340. 		removeClass: function( value ) {
  7341. 			var classes, elem, cur, clazz, j, finalValue,
  7342. 				proceed = arguments.length === 0 || typeof value === "string" && value,
  7343. 				i = 0,
  7344. 				len = this.length;
  7345. 	
  7346. 			if ( jQuery.isFunction( value ) ) {
  7347. 				return this.each(function( j ) {
  7348. 					jQuery( this ).removeClass( value.call( this, j, this.className ) );
  7349. 				});
  7350. 			}
  7351. 			if ( proceed ) {
  7352. 				classes = ( value || "" ).match( rnotwhite ) || [];
  7353. 	
  7354. 				for ( ; i < len; i++ ) {
  7355. 					elem = this[ i ];
  7356. 					// This expression is here for better compressibility (see addClass)
  7357. 					cur = elem.nodeType === 1 && ( elem.className ?
  7358. 						( " " + elem.className + " " ).replace( rclass, " " ) :
  7359. 						""
  7360. 					);
  7361. 	
  7362. 					if ( cur ) {
  7363. 						j = 0;
  7364. 						while ( (clazz = classes[j++]) ) {
  7365. 							// Remove *all* instances
  7366. 							while ( cur.indexOf( " " + clazz + " " ) >= 0 ) {
  7367. 								cur = cur.replace( " " + clazz + " ", " " );
  7368. 							}
  7369. 						}
  7370. 	
  7371. 						// Only assign if different to avoid unneeded rendering.
  7372. 						finalValue = value ? jQuery.trim( cur ) : "";
  7373. 						if ( elem.className !== finalValue ) {
  7374. 							elem.className = finalValue;
  7375. 						}
  7376. 					}
  7377. 				}
  7378. 			}
  7379. 	
  7380. 			return this;
  7381. 		},
  7382. 	
  7383. 		toggleClass: function( value, stateVal ) {
  7384. 			var type = typeof value;
  7385. 	
  7386. 			if ( typeof stateVal === "boolean" && type === "string" ) {
  7387. 				return stateVal ? this.addClass( value ) : this.removeClass( value );
  7388. 			}
  7389. 	
  7390. 			if ( jQuery.isFunction( value ) ) {
  7391. 				return this.each(function( i ) {
  7392. 					jQuery( this ).toggleClass( value.call(this, i, this.className, stateVal), stateVal );
  7393. 				});
  7394. 			}
  7395. 	
  7396. 			return this.each(function() {
  7397. 				if ( type === "string" ) {
  7398. 					// Toggle individual class names
  7399. 					var className,
  7400. 						i = 0,
  7401. 						self = jQuery( this ),
  7402. 						classNames = value.match( rnotwhite ) || [];
  7403. 	
  7404. 					while ( (className = classNames[ i++ ]) ) {
  7405. 						// Check each className given, space separated list
  7406. 						if ( self.hasClass( className ) ) {
  7407. 							self.removeClass( className );
  7408. 						} else {
  7409. 							self.addClass( className );
  7410. 						}
  7411. 					}
  7412. 	
  7413. 				// Toggle whole class name
  7414. 				} else if ( type === strundefined || type === "boolean" ) {
  7415. 					if ( this.className ) {
  7416. 						// store className if set
  7417. 						data_priv.set( this, "__className__", this.className );
  7418. 					}
  7419. 	
  7420. 					// If the element has a class name or if we're passed `false`,
  7421. 					// then remove the whole classname (if there was one, the above saved it).
  7422. 					// Otherwise bring back whatever was previously saved (if anything),
  7423. 					// falling back to the empty string if nothing was stored.
  7424. 					this.className = this.className || value === false ? "" : data_priv.get( this, "__className__" ) || "";
  7425. 				}
  7426. 			});
  7427. 		},
  7428. 	
  7429. 		hasClass: function( selector ) {
  7430. 			var className = " " + selector + " ",
  7431. 				i = 0,
  7432. 				l = this.length;
  7433. 			for ( ; i < l; i++ ) {
  7434. 				if ( this[i].nodeType === 1 && (" " + this[i].className + " ").replace(rclass, " ").indexOf( className ) >= 0 ) {
  7435. 					return true;
  7436. 				}
  7437. 			}
  7438. 	
  7439. 			return false;
  7440. 		}
  7441. 	});
  7442. 	
  7443. 	
  7444. 	
  7445. 	
  7446. 	var rreturn = /\r/g;
  7447. 	
  7448. 	jQuery.fn.extend({
  7449. 		val: function( value ) {
  7450. 			var hooks, ret, isFunction,
  7451. 				elem = this[0];
  7452. 	
  7453. 			if ( !arguments.length ) {
  7454. 				if ( elem ) {
  7455. 					hooks = jQuery.valHooks[ elem.type ] || jQuery.valHooks[ elem.nodeName.toLowerCase() ];
  7456. 	
  7457. 					if ( hooks && "get" in hooks && (ret = hooks.get( elem, "value" )) !== undefined ) {
  7458. 						return ret;
  7459. 					}
  7460. 	
  7461. 					ret = elem.value;
  7462. 	
  7463. 					return typeof ret === "string" ?
  7464. 						// Handle most common string cases
  7465. 						ret.replace(rreturn, "") :
  7466. 						// Handle cases where value is null/undef or number
  7467. 						ret == null ? "" : ret;
  7468. 				}
  7469. 	
  7470. 				return;
  7471. 			}
  7472. 	
  7473. 			isFunction = jQuery.isFunction( value );
  7474. 	
  7475. 			return this.each(function( i ) {
  7476. 				var val;
  7477. 	
  7478. 				if ( this.nodeType !== 1 ) {
  7479. 					return;
  7480. 				}
  7481. 	
  7482. 				if ( isFunction ) {
  7483. 					val = value.call( this, i, jQuery( this ).val() );
  7484. 				} else {
  7485. 					val = value;
  7486. 				}
  7487. 	
  7488. 				// Treat null/undefined as ""; convert numbers to string
  7489. 				if ( val == null ) {
  7490. 					val = "";
  7491. 	
  7492. 				} else if ( typeof val === "number" ) {
  7493. 					val += "";
  7494. 	
  7495. 				} else if ( jQuery.isArray( val ) ) {
  7496. 					val = jQuery.map( val, function( value ) {
  7497. 						return value == null ? "" : value + "";
  7498. 					});
  7499. 				}
  7500. 	
  7501. 				hooks = jQuery.valHooks[ this.type ] || jQuery.valHooks[ this.nodeName.toLowerCase() ];
  7502. 	
  7503. 				// If set returns undefined, fall back to normal setting
  7504. 				if ( !hooks || !("set" in hooks) || hooks.set( this, val, "value" ) === undefined ) {
  7505. 					this.value = val;
  7506. 				}
  7507. 			});
  7508. 		}
  7509. 	});
  7510. 	
  7511. 	jQuery.extend({
  7512. 		valHooks: {
  7513. 			option: {
  7514. 				get: function( elem ) {
  7515. 					var val = jQuery.find.attr( elem, "value" );
  7516. 					return val != null ?
  7517. 						val :
  7518. 						// Support: IE10-11+
  7519. 						// option.text throws exceptions (#14686, #14858)
  7520. 						jQuery.trim( jQuery.text( elem ) );
  7521. 				}
  7522. 			},
  7523. 			select: {
  7524. 				get: function( elem ) {
  7525. 					var value, option,
  7526. 						options = elem.options,
  7527. 						index = elem.selectedIndex,
  7528. 						one = elem.type === "select-one" || index < 0,
  7529. 						values = one ? null : [],
  7530. 						max = one ? index + 1 : options.length,
  7531. 						i = index < 0 ?
  7532. 							max :
  7533. 							one ? index : 0;
  7534. 	
  7535. 					// Loop through all the selected options
  7536. 					for ( ; i < max; i++ ) {
  7537. 						option = options[ i ];
  7538. 	
  7539. 						// IE6-9 doesn't update selected after form reset (#2551)
  7540. 						if ( ( option.selected || i === index ) &&
  7541. 								// Don't return options that are disabled or in a disabled optgroup
  7542. 								( support.optDisabled ? !option.disabled : option.getAttribute( "disabled" ) === null ) &&
  7543. 								( !option.parentNode.disabled || !jQuery.nodeName( option.parentNode, "optgroup" ) ) ) {
  7544. 	
  7545. 							// Get the specific value for the option
  7546. 							value = jQuery( option ).val();
  7547. 	
  7548. 							// We don't need an array for one selects
  7549. 							if ( one ) {
  7550. 								return value;
  7551. 							}
  7552. 	
  7553. 							// Multi-Selects return an array
  7554. 							values.push( value );
  7555. 						}
  7556. 					}
  7557. 	
  7558. 					return values;
  7559. 				},
  7560. 	
  7561. 				set: function( elem, value ) {
  7562. 					var optionSet, option,
  7563. 						options = elem.options,
  7564. 						values = jQuery.makeArray( value ),
  7565. 						i = options.length;
  7566. 	
  7567. 					while ( i-- ) {
  7568. 						option = options[ i ];
  7569. 						if ( (option.selected = jQuery.inArray( option.value, values ) >= 0) ) {
  7570. 							optionSet = true;
  7571. 						}
  7572. 					}
  7573. 	
  7574. 					// Force browsers to behave consistently when non-matching value is set
  7575. 					if ( !optionSet ) {
  7576. 						elem.selectedIndex = -1;
  7577. 					}
  7578. 					return values;
  7579. 				}
  7580. 			}
  7581. 		}
  7582. 	});
  7583. 	
  7584. 	// Radios and checkboxes getter/setter
  7585. 	jQuery.each([ "radio", "checkbox" ], function() {
  7586. 		jQuery.valHooks[ this ] = {
  7587. 			set: function( elem, value ) {
  7588. 				if ( jQuery.isArray( value ) ) {
  7589. 					return ( elem.checked = jQuery.inArray( jQuery(elem).val(), value ) >= 0 );
  7590. 				}
  7591. 			}
  7592. 		};
  7593. 		if ( !support.checkOn ) {
  7594. 			jQuery.valHooks[ this ].get = function( elem ) {
  7595. 				return elem.getAttribute("value") === null ? "on" : elem.value;
  7596. 			};
  7597. 		}
  7598. 	});
  7599. 	
  7600. 	
  7601. 	
  7602. 	
  7603. 	// Return jQuery for attributes-only inclusion
  7604. 	
  7605. 	
  7606. 	jQuery.each( ("blur focus focusin focusout load resize scroll unload click dblclick " +
  7607. 		"mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave " +
  7608. 		"change select submit keydown keypress keyup error contextmenu").split(" "), function( i, name ) {
  7609. 	
  7610. 		// Handle event binding
  7611. 		jQuery.fn[ name ] = function( data, fn ) {
  7612. 			return arguments.length > 0 ?
  7613. 				this.on( name, null, data, fn ) :
  7614. 				this.trigger( name );
  7615. 		};
  7616. 	});
  7617. 	
  7618. 	jQuery.fn.extend({
  7619. 		hover: function( fnOver, fnOut ) {
  7620. 			return this.mouseenter( fnOver ).mouseleave( fnOut || fnOver );
  7621. 		},
  7622. 	
  7623. 		bind: function( types, data, fn ) {
  7624. 			return this.on( types, null, data, fn );
  7625. 		},
  7626. 		unbind: function( types, fn ) {
  7627. 			return this.off( types, null, fn );
  7628. 		},
  7629. 	
  7630. 		delegate: function( selector, types, data, fn ) {
  7631. 			return this.on( types, selector, data, fn );
  7632. 		},
  7633. 		undelegate: function( selector, types, fn ) {
  7634. 			// ( namespace ) or ( selector, types [, fn] )
  7635. 			return arguments.length === 1 ? this.off( selector, "**" ) : this.off( types, selector || "**", fn );
  7636. 		}
  7637. 	});
  7638. 	
  7639. 	
  7640. 	var nonce = jQuery.now();
  7641. 	
  7642. 	var rquery = (/\?/);
  7643. 	
  7644. 	
  7645. 	
  7646. 	// Support: Android 2.3
  7647. 	// Workaround failure to string-cast null input
  7648. 	jQuery.parseJSON = function( data ) {
  7649. 		return JSON.parse( data + "" );
  7650. 	};
  7651. 	
  7652. 	
  7653. 	// Cross-browser xml parsing
  7654. 	jQuery.parseXML = function( data ) {
  7655. 		var xml, tmp;
  7656. 		if ( !data || typeof data !== "string" ) {
  7657. 			return null;
  7658. 		}
  7659. 	
  7660. 		// Support: IE9
  7661. 		try {
  7662. 			tmp = new DOMParser();
  7663. 			xml = tmp.parseFromString( data, "text/xml" );
  7664. 		} catch ( e ) {
  7665. 			xml = undefined;
  7666. 		}
  7667. 	
  7668. 		if ( !xml || xml.getElementsByTagName( "parsererror" ).length ) {
  7669. 			jQuery.error( "Invalid XML: " + data );
  7670. 		}
  7671. 		return xml;
  7672. 	};
  7673. 	
  7674. 	
  7675. 	var
  7676. 		rhash = /#.*$/,
  7677. 		rts = /([?&])_=[^&]*/,
  7678. 		rheaders = /^(.*?):[ \t]*([^\r\n]*)$/mg,
  7679. 		// #7653, #8125, #8152: local protocol detection
  7680. 		rlocalProtocol = /^(?:about|app|app-storage|.+-extension|file|res|widget):$/,
  7681. 		rnoContent = /^(?:GET|HEAD)$/,
  7682. 		rprotocol = /^\/\//,
  7683. 		rurl = /^([\w.+-]+:)(?:\/\/(?:[^\/?#]*@|)([^\/?#:]*)(?::(\d+)|)|)/,
  7684. 	
  7685. 		/* Prefilters
  7686. 		 * 1) They are useful to introduce custom dataTypes (see ajax/jsonp.js for an example)
  7687. 		 * 2) These are called:
  7688. 		 *    - BEFORE asking for a transport
  7689. 		 *    - AFTER param serialization (s.data is a string if s.processData is true)
  7690. 		 * 3) key is the dataType
  7691. 		 * 4) the catchall symbol "*" can be used
  7692. 		 * 5) execution will start with transport dataType and THEN continue down to "*" if needed
  7693. 		 */
  7694. 		prefilters = {},
  7695. 	
  7696. 		/* Transports bindings
  7697. 		 * 1) key is the dataType
  7698. 		 * 2) the catchall symbol "*" can be used
  7699. 		 * 3) selection will start with transport dataType and THEN go to "*" if needed
  7700. 		 */
  7701. 		transports = {},
  7702. 	
  7703. 		// Avoid comment-prolog char sequence (#10098); must appease lint and evade compression
  7704. 		allTypes = "*/".concat( "*" ),
  7705. 	
  7706. 		// Document location
  7707. 		ajaxLocation = window.location.href,
  7708. 	
  7709. 		// Segment location into parts
  7710. 		ajaxLocParts = rurl.exec( ajaxLocation.toLowerCase() ) || [];
  7711. 	
  7712. 	// Base "constructor" for jQuery.ajaxPrefilter and jQuery.ajaxTransport
  7713. 	function addToPrefiltersOrTransports( structure ) {
  7714. 	
  7715. 		// dataTypeExpression is optional and defaults to "*"
  7716. 		return function( dataTypeExpression, func ) {
  7717. 	
  7718. 			if ( typeof dataTypeExpression !== "string" ) {
  7719. 				func = dataTypeExpression;
  7720. 				dataTypeExpression = "*";
  7721. 			}
  7722. 	
  7723. 			var dataType,
  7724. 				i = 0,
  7725. 				dataTypes = dataTypeExpression.toLowerCase().match( rnotwhite ) || [];
  7726. 	
  7727. 			if ( jQuery.isFunction( func ) ) {
  7728. 				// For each dataType in the dataTypeExpression
  7729. 				while ( (dataType = dataTypes[i++]) ) {
  7730. 					// Prepend if requested
  7731. 					if ( dataType[0] === "+" ) {
  7732. 						dataType = dataType.slice( 1 ) || "*";
  7733. 						(structure[ dataType ] = structure[ dataType ] || []).unshift( func );
  7734. 	
  7735. 					// Otherwise append
  7736. 					} else {
  7737. 						(structure[ dataType ] = structure[ dataType ] || []).push( func );
  7738. 					}
  7739. 				}
  7740. 			}
  7741. 		};
  7742. 	}
  7743. 	
  7744. 	// Base inspection function for prefilters and transports
  7745. 	function inspectPrefiltersOrTransports( structure, options, originalOptions, jqXHR ) {
  7746. 	
  7747. 		var inspected = {},
  7748. 			seekingTransport = ( structure === transports );
  7749. 	
  7750. 		function inspect( dataType ) {
  7751. 			var selected;
  7752. 			inspected[ dataType ] = true;
  7753. 			jQuery.each( structure[ dataType ] || [], function( _, prefilterOrFactory ) {
  7754. 				var dataTypeOrTransport = prefilterOrFactory( options, originalOptions, jqXHR );
  7755. 				if ( typeof dataTypeOrTransport === "string" && !seekingTransport && !inspected[ dataTypeOrTransport ] ) {
  7756. 					options.dataTypes.unshift( dataTypeOrTransport );
  7757. 					inspect( dataTypeOrTransport );
  7758. 					return false;
  7759. 				} else if ( seekingTransport ) {
  7760. 					return !( selected = dataTypeOrTransport );
  7761. 				}
  7762. 			});
  7763. 			return selected;
  7764. 		}
  7765. 	
  7766. 		return inspect( options.dataTypes[ 0 ] ) || !inspected[ "*" ] && inspect( "*" );
  7767. 	}
  7768. 	
  7769. 	// A special extend for ajax options
  7770. 	// that takes "flat" options (not to be deep extended)
  7771. 	// Fixes #9887
  7772. 	function ajaxExtend( target, src ) {
  7773. 		var key, deep,
  7774. 			flatOptions = jQuery.ajaxSettings.flatOptions || {};
  7775. 	
  7776. 		for ( key in src ) {
  7777. 			if ( src[ key ] !== undefined ) {
  7778. 				( flatOptions[ key ] ? target : ( deep || (deep = {}) ) )[ key ] = src[ key ];
  7779. 			}
  7780. 		}
  7781. 		if ( deep ) {
  7782. 			jQuery.extend( true, target, deep );
  7783. 		}
  7784. 	
  7785. 		return target;
  7786. 	}
  7787. 	
  7788. 	/* Handles responses to an ajax request:
  7789. 	 * - finds the right dataType (mediates between content-type and expected dataType)
  7790. 	 * - returns the corresponding response
  7791. 	 */
  7792. 	function ajaxHandleResponses( s, jqXHR, responses ) {
  7793. 	
  7794. 		var ct, type, finalDataType, firstDataType,
  7795. 			contents = s.contents,
  7796. 			dataTypes = s.dataTypes;
  7797. 	
  7798. 		// Remove auto dataType and get content-type in the process
  7799. 		while ( dataTypes[ 0 ] === "*" ) {
  7800. 			dataTypes.shift();
  7801. 			if ( ct === undefined ) {
  7802. 				ct = s.mimeType || jqXHR.getResponseHeader("Content-Type");
  7803. 			}
  7804. 		}
  7805. 	
  7806. 		// Check if we're dealing with a known content-type
  7807. 		if ( ct ) {
  7808. 			for ( type in contents ) {
  7809. 				if ( contents[ type ] && contents[ type ].test( ct ) ) {
  7810. 					dataTypes.unshift( type );
  7811. 					break;
  7812. 				}
  7813. 			}
  7814. 		}
  7815. 	
  7816. 		// Check to see if we have a response for the expected dataType
  7817. 		if ( dataTypes[ 0 ] in responses ) {
  7818. 			finalDataType = dataTypes[ 0 ];
  7819. 		} else {
  7820. 			// Try convertible dataTypes
  7821. 			for ( type in responses ) {
  7822. 				if ( !dataTypes[ 0 ] || s.converters[ type + " " + dataTypes[0] ] ) {
  7823. 					finalDataType = type;
  7824. 					break;
  7825. 				}
  7826. 				if ( !firstDataType ) {
  7827. 					firstDataType = type;
  7828. 				}
  7829. 			}
  7830. 			// Or just use first one
  7831. 			finalDataType = finalDataType || firstDataType;
  7832. 		}
  7833. 	
  7834. 		// If we found a dataType
  7835. 		// We add the dataType to the list if needed
  7836. 		// and return the corresponding response
  7837. 		if ( finalDataType ) {
  7838. 			if ( finalDataType !== dataTypes[ 0 ] ) {
  7839. 				dataTypes.unshift( finalDataType );
  7840. 			}
  7841. 			return responses[ finalDataType ];
  7842. 		}
  7843. 	}
  7844. 	
  7845. 	/* Chain conversions given the request and the original response
  7846. 	 * Also sets the responseXXX fields on the jqXHR instance
  7847. 	 */
  7848. 	function ajaxConvert( s, response, jqXHR, isSuccess ) {
  7849. 		var conv2, current, conv, tmp, prev,
  7850. 			converters = {},
  7851. 			// Work with a copy of dataTypes in case we need to modify it for conversion
  7852. 			dataTypes = s.dataTypes.slice();
  7853. 	
  7854. 		// Create converters map with lowercased keys
  7855. 		if ( dataTypes[ 1 ] ) {
  7856. 			for ( conv in s.converters ) {
  7857. 				converters[ conv.toLowerCase() ] = s.converters[ conv ];
  7858. 			}
  7859. 		}
  7860. 	
  7861. 		current = dataTypes.shift();
  7862. 	
  7863. 		// Convert to each sequential dataType
  7864. 		while ( current ) {
  7865. 	
  7866. 			if ( s.responseFields[ current ] ) {
  7867. 				jqXHR[ s.responseFields[ current ] ] = response;
  7868. 			}
  7869. 	
  7870. 			// Apply the dataFilter if provided
  7871. 			if ( !prev && isSuccess && s.dataFilter ) {
  7872. 				response = s.dataFilter( response, s.dataType );
  7873. 			}
  7874. 	
  7875. 			prev = current;
  7876. 			current = dataTypes.shift();
  7877. 	
  7878. 			if ( current ) {
  7879. 	
  7880. 			// There's only work to do if current dataType is non-auto
  7881. 				if ( current === "*" ) {
  7882. 	
  7883. 					current = prev;
  7884. 	
  7885. 				// Convert response if prev dataType is non-auto and differs from current
  7886. 				} else if ( prev !== "*" && prev !== current ) {
  7887. 	
  7888. 					// Seek a direct converter
  7889. 					conv = converters[ prev + " " + current ] || converters[ "* " + current ];
  7890. 	
  7891. 					// If none found, seek a pair
  7892. 					if ( !conv ) {
  7893. 						for ( conv2 in converters ) {
  7894. 	
  7895. 							// If conv2 outputs current
  7896. 							tmp = conv2.split( " " );
  7897. 							if ( tmp[ 1 ] === current ) {
  7898. 	
  7899. 								// If prev can be converted to accepted input
  7900. 								conv = converters[ prev + " " + tmp[ 0 ] ] ||
  7901. 									converters[ "* " + tmp[ 0 ] ];
  7902. 								if ( conv ) {
  7903. 									// Condense equivalence converters
  7904. 									if ( conv === true ) {
  7905. 										conv = converters[ conv2 ];
  7906. 	
  7907. 									// Otherwise, insert the intermediate dataType
  7908. 									} else if ( converters[ conv2 ] !== true ) {
  7909. 										current = tmp[ 0 ];
  7910. 										dataTypes.unshift( tmp[ 1 ] );
  7911. 									}
  7912. 									break;
  7913. 								}
  7914. 							}
  7915. 						}
  7916. 					}
  7917. 	
  7918. 					// Apply converter (if not an equivalence)
  7919. 					if ( conv !== true ) {
  7920. 	
  7921. 						// Unless errors are allowed to bubble, catch and return them
  7922. 						if ( conv && s[ "throws" ] ) {
  7923. 							response = conv( response );
  7924. 						} else {
  7925. 							try {
  7926. 								response = conv( response );
  7927. 							} catch ( e ) {
  7928. 								return { state: "parsererror", error: conv ? e : "No conversion from " + prev + " to " + current };
  7929. 							}
  7930. 						}
  7931. 					}
  7932. 				}
  7933. 			}
  7934. 		}
  7935. 	
  7936. 		return { state: "success", data: response };
  7937. 	}
  7938. 	
  7939. 	jQuery.extend({
  7940. 	
  7941. 		// Counter for holding the number of active queries
  7942. 		active: 0,
  7943. 	
  7944. 		// Last-Modified header cache for next request
  7945. 		lastModified: {},
  7946. 		etag: {},
  7947. 	
  7948. 		ajaxSettings: {
  7949. 			url: ajaxLocation,
  7950. 			type: "GET",
  7951. 			isLocal: rlocalProtocol.test( ajaxLocParts[ 1 ] ),
  7952. 			global: true,
  7953. 			processData: true,
  7954. 			async: true,
  7955. 			contentType: "application/x-www-form-urlencoded; charset=UTF-8",
  7956. 			/*
  7957. 			timeout: 0,
  7958. 			data: null,
  7959. 			dataType: null,
  7960. 			username: null,
  7961. 			password: null,
  7962. 			cache: null,
  7963. 			throws: false,
  7964. 			traditional: false,
  7965. 			headers: {},
  7966. 			*/
  7967. 	
  7968. 			accepts: {
  7969. 				"*": allTypes,
  7970. 				text: "text/plain",
  7971. 				html: "text/html",
  7972. 				xml: "application/xml, text/xml",
  7973. 				json: "application/json, text/javascript"
  7974. 			},
  7975. 	
  7976. 			contents: {
  7977. 				xml: /xml/,
  7978. 				html: /html/,
  7979. 				json: /json/
  7980. 			},
  7981. 	
  7982. 			responseFields: {
  7983. 				xml: "responseXML",
  7984. 				text: "responseText",
  7985. 				json: "responseJSON"
  7986. 			},
  7987. 	
  7988. 			// Data converters
  7989. 			// Keys separate source (or catchall "*") and destination types with a single space
  7990. 			converters: {
  7991. 	
  7992. 				// Convert anything to text
  7993. 				"* text": String,
  7994. 	
  7995. 				// Text to html (true = no transformation)
  7996. 				"text html": true,
  7997. 	
  7998. 				// Evaluate text as a json expression
  7999. 				"text json": jQuery.parseJSON,
  8000. 	
  8001. 				// Parse text as xml
  8002. 				"text xml": jQuery.parseXML
  8003. 			},
  8004. 	
  8005. 			// For options that shouldn't be deep extended:
  8006. 			// you can add your own custom options here if
  8007. 			// and when you create one that shouldn't be
  8008. 			// deep extended (see ajaxExtend)
  8009. 			flatOptions: {
  8010. 				url: true,
  8011. 				context: true
  8012. 			}
  8013. 		},
  8014. 	
  8015. 		// Creates a full fledged settings object into target
  8016. 		// with both ajaxSettings and settings fields.
  8017. 		// If target is omitted, writes into ajaxSettings.
  8018. 		ajaxSetup: function( target, settings ) {
  8019. 			return settings ?
  8020. 	
  8021. 				// Building a settings object
  8022. 				ajaxExtend( ajaxExtend( target, jQuery.ajaxSettings ), settings ) :
  8023. 	
  8024. 				// Extending ajaxSettings
  8025. 				ajaxExtend( jQuery.ajaxSettings, target );
  8026. 		},
  8027. 	
  8028. 		ajaxPrefilter: addToPrefiltersOrTransports( prefilters ),
  8029. 		ajaxTransport: addToPrefiltersOrTransports( transports ),
  8030. 	
  8031. 		// Main method
  8032. 		ajax: function( url, options ) {
  8033. 	
  8034. 			// If url is an object, simulate pre-1.5 signature
  8035. 			if ( typeof url === "object" ) {
  8036. 				options = url;
  8037. 				url = undefined;
  8038. 			}
  8039. 	
  8040. 			// Force options to be an object
  8041. 			options = options || {};
  8042. 	
  8043. 			var transport,
  8044. 				// URL without anti-cache param
  8045. 				cacheURL,
  8046. 				// Response headers
  8047. 				responseHeadersString,
  8048. 				responseHeaders,
  8049. 				// timeout handle
  8050. 				timeoutTimer,
  8051. 				// Cross-domain detection vars
  8052. 				parts,
  8053. 				// To know if global events are to be dispatched
  8054. 				fireGlobals,
  8055. 				// Loop variable
  8056. 				i,
  8057. 				// Create the final options object
  8058. 				s = jQuery.ajaxSetup( {}, options ),
  8059. 				// Callbacks context
  8060. 				callbackContext = s.context || s,
  8061. 				// Context for global events is callbackContext if it is a DOM node or jQuery collection
  8062. 				globalEventContext = s.context && ( callbackContext.nodeType || callbackContext.jquery ) ?
  8063. 					jQuery( callbackContext ) :
  8064. 					jQuery.event,
  8065. 				// Deferreds
  8066. 				deferred = jQuery.Deferred(),
  8067. 				completeDeferred = jQuery.Callbacks("once memory"),
  8068. 				// Status-dependent callbacks
  8069. 				statusCode = s.statusCode || {},
  8070. 				// Headers (they are sent all at once)
  8071. 				requestHeaders = {},
  8072. 				requestHeadersNames = {},
  8073. 				// The jqXHR state
  8074. 				state = 0,
  8075. 				// Default abort message
  8076. 				strAbort = "canceled",
  8077. 				// Fake xhr
  8078. 				jqXHR = {
  8079. 					readyState: 0,
  8080. 	
  8081. 					// Builds headers hashtable if needed
  8082. 					getResponseHeader: function( key ) {
  8083. 						var match;
  8084. 						if ( state === 2 ) {
  8085. 							if ( !responseHeaders ) {
  8086. 								responseHeaders = {};
  8087. 								while ( (match = rheaders.exec( responseHeadersString )) ) {
  8088. 									responseHeaders[ match[1].toLowerCase() ] = match[ 2 ];
  8089. 								}
  8090. 							}
  8091. 							match = responseHeaders[ key.toLowerCase() ];
  8092. 						}
  8093. 						return match == null ? null : match;
  8094. 					},
  8095. 	
  8096. 					// Raw string
  8097. 					getAllResponseHeaders: function() {
  8098. 						return state === 2 ? responseHeadersString : null;
  8099. 					},
  8100. 	
  8101. 					// Caches the header
  8102. 					setRequestHeader: function( name, value ) {
  8103. 						var lname = name.toLowerCase();
  8104. 						if ( !state ) {
  8105. 							name = requestHeadersNames[ lname ] = requestHeadersNames[ lname ] || name;
  8106. 							requestHeaders[ name ] = value;
  8107. 						}
  8108. 						return this;
  8109. 					},
  8110. 	
  8111. 					// Overrides response content-type header
  8112. 					overrideMimeType: function( type ) {
  8113. 						if ( !state ) {
  8114. 							s.mimeType = type;
  8115. 						}
  8116. 						return this;
  8117. 					},
  8118. 	
  8119. 					// Status-dependent callbacks
  8120. 					statusCode: function( map ) {
  8121. 						var code;
  8122. 						if ( map ) {
  8123. 							if ( state < 2 ) {
  8124. 								for ( code in map ) {
  8125. 									// Lazy-add the new callback in a way that preserves old ones
  8126. 									statusCode[ code ] = [ statusCode[ code ], map[ code ] ];
  8127. 								}
  8128. 							} else {
  8129. 								// Execute the appropriate callbacks
  8130. 								jqXHR.always( map[ jqXHR.status ] );
  8131. 							}
  8132. 						}
  8133. 						return this;
  8134. 					},
  8135. 	
  8136. 					// Cancel the request
  8137. 					abort: function( statusText ) {
  8138. 						var finalText = statusText || strAbort;
  8139. 						if ( transport ) {
  8140. 							transport.abort( finalText );
  8141. 						}
  8142. 						done( 0, finalText );
  8143. 						return this;
  8144. 					}
  8145. 				};
  8146. 	
  8147. 			// Attach deferreds
  8148. 			deferred.promise( jqXHR ).complete = completeDeferred.add;
  8149. 			jqXHR.success = jqXHR.done;
  8150. 			jqXHR.error = jqXHR.fail;
  8151. 	
  8152. 			// Remove hash character (#7531: and string promotion)
  8153. 			// Add protocol if not provided (prefilters might expect it)
  8154. 			// Handle falsy url in the settings object (#10093: consistency with old signature)
  8155. 			// We also use the url parameter if available
  8156. 			s.url = ( ( url || s.url || ajaxLocation ) + "" ).replace( rhash, "" )
  8157. 				.replace( rprotocol, ajaxLocParts[ 1 ] + "//" );
  8158. 	
  8159. 			// Alias method option to type as per ticket #12004
  8160. 			s.type = options.method || options.type || s.method || s.type;
  8161. 	
  8162. 			// Extract dataTypes list
  8163. 			s.dataTypes = jQuery.trim( s.dataType || "*" ).toLowerCase().match( rnotwhite ) || [ "" ];
  8164. 	
  8165. 			// A cross-domain request is in order when we have a protocol:host:port mismatch
  8166. 			if ( s.crossDomain == null ) {
  8167. 				parts = rurl.exec( s.url.toLowerCase() );
  8168. 				s.crossDomain = !!( parts &&
  8169. 					( parts[ 1 ] !== ajaxLocParts[ 1 ] || parts[ 2 ] !== ajaxLocParts[ 2 ] ||
  8170. 						( parts[ 3 ] || ( parts[ 1 ] === "http:" ? "80" : "443" ) ) !==
  8171. 							( ajaxLocParts[ 3 ] || ( ajaxLocParts[ 1 ] === "http:" ? "80" : "443" ) ) )
  8172. 				);
  8173. 			}
  8174. 	
  8175. 			// Convert data if not already a string
  8176. 			if ( s.data && s.processData && typeof s.data !== "string" ) {
  8177. 				s.data = jQuery.param( s.data, s.traditional );
  8178. 			}
  8179. 	
  8180. 			// Apply prefilters
  8181. 			inspectPrefiltersOrTransports( prefilters, s, options, jqXHR );
  8182. 	
  8183. 			// If request was aborted inside a prefilter, stop there
  8184. 			if ( state === 2 ) {
  8185. 				return jqXHR;
  8186. 			}
  8187. 	
  8188. 			// We can fire global events as of now if asked to
  8189. 			// Don't fire events if jQuery.event is undefined in an AMD-usage scenario (#15118)
  8190. 			fireGlobals = jQuery.event && s.global;
  8191. 	
  8192. 			// Watch for a new set of requests
  8193. 			if ( fireGlobals && jQuery.active++ === 0 ) {
  8194. 				jQuery.event.trigger("ajaxStart");
  8195. 			}
  8196. 	
  8197. 			// Uppercase the type
  8198. 			s.type = s.type.toUpperCase();
  8199. 	
  8200. 			// Determine if request has content
  8201. 			s.hasContent = !rnoContent.test( s.type );
  8202. 	
  8203. 			// Save the URL in case we're toying with the If-Modified-Since
  8204. 			// and/or If-None-Match header later on
  8205. 			cacheURL = s.url;
  8206. 	
  8207. 			// More options handling for requests with no content
  8208. 			if ( !s.hasContent ) {
  8209. 	
  8210. 				// If data is available, append data to url
  8211. 				if ( s.data ) {
  8212. 					cacheURL = ( s.url += ( rquery.test( cacheURL ) ? "&" : "?" ) + s.data );
  8213. 					// #9682: remove data so that it's not used in an eventual retry
  8214. 					delete s.data;
  8215. 				}
  8216. 	
  8217. 				// Add anti-cache in url if needed
  8218. 				if ( s.cache === false ) {
  8219. 					s.url = rts.test( cacheURL ) ?
  8220. 	
  8221. 						// If there is already a '_' parameter, set its value
  8222. 						cacheURL.replace( rts, "$1_=" + nonce++ ) :
  8223. 	
  8224. 						// Otherwise add one to the end
  8225. 						cacheURL + ( rquery.test( cacheURL ) ? "&" : "?" ) + "_=" + nonce++;
  8226. 				}
  8227. 			}
  8228. 	
  8229. 			// Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
  8230. 			if ( s.ifModified ) {
  8231. 				if ( jQuery.lastModified[ cacheURL ] ) {
  8232. 					jqXHR.setRequestHeader( "If-Modified-Since", jQuery.lastModified[ cacheURL ] );
  8233. 				}
  8234. 				if ( jQuery.etag[ cacheURL ] ) {
  8235. 					jqXHR.setRequestHeader( "If-None-Match", jQuery.etag[ cacheURL ] );
  8236. 				}
  8237. 			}
  8238. 	
  8239. 			// Set the correct header, if data is being sent
  8240. 			if ( s.data && s.hasContent && s.contentType !== false || options.contentType ) {
  8241. 				jqXHR.setRequestHeader( "Content-Type", s.contentType );
  8242. 			}
  8243. 	
  8244. 			// Set the Accepts header for the server, depending on the dataType
  8245. 			jqXHR.setRequestHeader(
  8246. 				"Accept",
  8247. 				s.dataTypes[ 0 ] && s.accepts[ s.dataTypes[0] ] ?
  8248. 					s.accepts[ s.dataTypes[0] ] + ( s.dataTypes[ 0 ] !== "*" ? ", " + allTypes + "; q=0.01" : "" ) :
  8249. 					s.accepts[ "*" ]
  8250. 			);
  8251. 	
  8252. 			// Check for headers option
  8253. 			for ( i in s.headers ) {
  8254. 				jqXHR.setRequestHeader( i, s.headers[ i ] );
  8255. 			}
  8256. 	
  8257. 			// Allow custom headers/mimetypes and early abort
  8258. 			if ( s.beforeSend && ( s.beforeSend.call( callbackContext, jqXHR, s ) === false || state === 2 ) ) {
  8259. 				// Abort if not done already and return
  8260. 				return jqXHR.abort();
  8261. 			}
  8262. 	
  8263. 			// Aborting is no longer a cancellation
  8264. 			strAbort = "abort";
  8265. 	
  8266. 			// Install callbacks on deferreds
  8267. 			for ( i in { success: 1, error: 1, complete: 1 } ) {
  8268. 				jqXHR[ i ]( s[ i ] );
  8269. 			}
  8270. 	
  8271. 			// Get transport
  8272. 			transport = inspectPrefiltersOrTransports( transports, s, options, jqXHR );
  8273. 	
  8274. 			// If no transport, we auto-abort
  8275. 			if ( !transport ) {
  8276. 				done( -1, "No Transport" );
  8277. 			} else {
  8278. 				jqXHR.readyState = 1;
  8279. 	
  8280. 				// Send global event
  8281. 				if ( fireGlobals ) {
  8282. 					globalEventContext.trigger( "ajaxSend", [ jqXHR, s ] );
  8283. 				}
  8284. 				// Timeout
  8285. 				if ( s.async && s.timeout > 0 ) {
  8286. 					timeoutTimer = setTimeout(function() {
  8287. 						jqXHR.abort("timeout");
  8288. 					}, s.timeout );
  8289. 				}
  8290. 	
  8291. 				try {
  8292. 					state = 1;
  8293. 					transport.send( requestHeaders, done );
  8294. 				} catch ( e ) {
  8295. 					// Propagate exception as error if not done
  8296. 					if ( state < 2 ) {
  8297. 						done( -1, e );
  8298. 					// Simply rethrow otherwise
  8299. 					} else {
  8300. 						throw e;
  8301. 					}
  8302. 				}
  8303. 			}
  8304. 	
  8305. 			// Callback for when everything is done
  8306. 			function done( status, nativeStatusText, responses, headers ) {
  8307. 				var isSuccess, success, error, response, modified,
  8308. 					statusText = nativeStatusText;
  8309. 	
  8310. 				// Called once
  8311. 				if ( state === 2 ) {
  8312. 					return;
  8313. 				}
  8314. 	
  8315. 				// State is "done" now
  8316. 				state = 2;
  8317. 	
  8318. 				// Clear timeout if it exists
  8319. 				if ( timeoutTimer ) {
  8320. 					clearTimeout( timeoutTimer );
  8321. 				}
  8322. 	
  8323. 				// Dereference transport for early garbage collection
  8324. 				// (no matter how long the jqXHR object will be used)
  8325. 				transport = undefined;
  8326. 	
  8327. 				// Cache response headers
  8328. 				responseHeadersString = headers || "";
  8329. 	
  8330. 				// Set readyState
  8331. 				jqXHR.readyState = status > 0 ? 4 : 0;
  8332. 	
  8333. 				// Determine if successful
  8334. 				isSuccess = status >= 200 && status < 300 || status === 304;
  8335. 	
  8336. 				// Get response data
  8337. 				if ( responses ) {
  8338. 					response = ajaxHandleResponses( s, jqXHR, responses );
  8339. 				}
  8340. 	
  8341. 				// Convert no matter what (that way responseXXX fields are always set)
  8342. 				response = ajaxConvert( s, response, jqXHR, isSuccess );
  8343. 	
  8344. 				// If successful, handle type chaining
  8345. 				if ( isSuccess ) {
  8346. 	
  8347. 					// Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
  8348. 					if ( s.ifModified ) {
  8349. 						modified = jqXHR.getResponseHeader("Last-Modified");
  8350. 						if ( modified ) {
  8351. 							jQuery.lastModified[ cacheURL ] = modified;
  8352. 						}
  8353. 						modified = jqXHR.getResponseHeader("etag");
  8354. 						if ( modified ) {
  8355. 							jQuery.etag[ cacheURL ] = modified;
  8356. 						}
  8357. 					}
  8358. 	
  8359. 					// if no content
  8360. 					if ( status === 204 || s.type === "HEAD" ) {
  8361. 						statusText = "nocontent";
  8362. 	
  8363. 					// if not modified
  8364. 					} else if ( status === 304 ) {
  8365. 						statusText = "notmodified";
  8366. 	
  8367. 					// If we have data, let's convert it
  8368. 					} else {
  8369. 						statusText = response.state;
  8370. 						success = response.data;
  8371. 						error = response.error;
  8372. 						isSuccess = !error;
  8373. 					}
  8374. 				} else {
  8375. 					// Extract error from statusText and normalize for non-aborts
  8376. 					error = statusText;
  8377. 					if ( status || !statusText ) {
  8378. 						statusText = "error";
  8379. 						if ( status < 0 ) {
  8380. 							status = 0;
  8381. 						}
  8382. 					}
  8383. 				}
  8384. 	
  8385. 				// Set data for the fake xhr object
  8386. 				jqXHR.status = status;
  8387. 				jqXHR.statusText = ( nativeStatusText || statusText ) + "";
  8388. 	
  8389. 				// Success/Error
  8390. 				if ( isSuccess ) {
  8391. 					deferred.resolveWith( callbackContext, [ success, statusText, jqXHR ] );
  8392. 				} else {
  8393. 					deferred.rejectWith( callbackContext, [ jqXHR, statusText, error ] );
  8394. 				}
  8395. 	
  8396. 				// Status-dependent callbacks
  8397. 				jqXHR.statusCode( statusCode );
  8398. 				statusCode = undefined;
  8399. 	
  8400. 				if ( fireGlobals ) {
  8401. 					globalEventContext.trigger( isSuccess ? "ajaxSuccess" : "ajaxError",
  8402. 						[ jqXHR, s, isSuccess ? success : error ] );
  8403. 				}
  8404. 	
  8405. 				// Complete
  8406. 				completeDeferred.fireWith( callbackContext, [ jqXHR, statusText ] );
  8407. 	
  8408. 				if ( fireGlobals ) {
  8409. 					globalEventContext.trigger( "ajaxComplete", [ jqXHR, s ] );
  8410. 					// Handle the global AJAX counter
  8411. 					if ( !( --jQuery.active ) ) {
  8412. 						jQuery.event.trigger("ajaxStop");
  8413. 					}
  8414. 				}
  8415. 			}
  8416. 	
  8417. 			return jqXHR;
  8418. 		},
  8419. 	
  8420. 		getJSON: function( url, data, callback ) {
  8421. 			return jQuery.get( url, data, callback, "json" );
  8422. 		},
  8423. 	
  8424. 		getScript: function( url, callback ) {
  8425. 			return jQuery.get( url, undefined, callback, "script" );
  8426. 		}
  8427. 	});
  8428. 	
  8429. 	jQuery.each( [ "get", "post" ], function( i, method ) {
  8430. 		jQuery[ method ] = function( url, data, callback, type ) {
  8431. 			// Shift arguments if data argument was omitted
  8432. 			if ( jQuery.isFunction( data ) ) {
  8433. 				type = type || callback;
  8434. 				callback = data;
  8435. 				data = undefined;
  8436. 			}
  8437. 	
  8438. 			return jQuery.ajax({
  8439. 				url: url,
  8440. 				type: method,
  8441. 				dataType: type,
  8442. 				data: data,
  8443. 				success: callback
  8444. 			});
  8445. 		};
  8446. 	});
  8447. 	
  8448. 	
  8449. 	jQuery._evalUrl = function( url ) {
  8450. 		return jQuery.ajax({
  8451. 			url: url,
  8452. 			type: "GET",
  8453. 			dataType: "script",
  8454. 			async: false,
  8455. 			global: false,
  8456. 			"throws": true
  8457. 		});
  8458. 	};
  8459. 	
  8460. 	
  8461. 	jQuery.fn.extend({
  8462. 		wrapAll: function( html ) {
  8463. 			var wrap;
  8464. 	
  8465. 			if ( jQuery.isFunction( html ) ) {
  8466. 				return this.each(function( i ) {
  8467. 					jQuery( this ).wrapAll( html.call(this, i) );
  8468. 				});
  8469. 			}
  8470. 	
  8471. 			if ( this[ 0 ] ) {
  8472. 	
  8473. 				// The elements to wrap the target around
  8474. 				wrap = jQuery( html, this[ 0 ].ownerDocument ).eq( 0 ).clone( true );
  8475. 	
  8476. 				if ( this[ 0 ].parentNode ) {
  8477. 					wrap.insertBefore( this[ 0 ] );
  8478. 				}
  8479. 	
  8480. 				wrap.map(function() {
  8481. 					var elem = this;
  8482. 	
  8483. 					while ( elem.firstElementChild ) {
  8484. 						elem = elem.firstElementChild;
  8485. 					}
  8486. 	
  8487. 					return elem;
  8488. 				}).append( this );
  8489. 			}
  8490. 	
  8491. 			return this;
  8492. 		},
  8493. 	
  8494. 		wrapInner: function( html ) {
  8495. 			if ( jQuery.isFunction( html ) ) {
  8496. 				return this.each(function( i ) {
  8497. 					jQuery( this ).wrapInner( html.call(this, i) );
  8498. 				});
  8499. 			}
  8500. 	
  8501. 			return this.each(function() {
  8502. 				var self = jQuery( this ),
  8503. 					contents = self.contents();
  8504. 	
  8505. 				if ( contents.length ) {
  8506. 					contents.wrapAll( html );
  8507. 	
  8508. 				} else {
  8509. 					self.append( html );
  8510. 				}
  8511. 			});
  8512. 		},
  8513. 	
  8514. 		wrap: function( html ) {
  8515. 			var isFunction = jQuery.isFunction( html );
  8516. 	
  8517. 			return this.each(function( i ) {
  8518. 				jQuery( this ).wrapAll( isFunction ? html.call(this, i) : html );
  8519. 			});
  8520. 		},
  8521. 	
  8522. 		unwrap: function() {
  8523. 			return this.parent().each(function() {
  8524. 				if ( !jQuery.nodeName( this, "body" ) ) {
  8525. 					jQuery( this ).replaceWith( this.childNodes );
  8526. 				}
  8527. 			}).end();
  8528. 		}
  8529. 	});
  8530. 	
  8531. 	
  8532. 	jQuery.expr.filters.hidden = function( elem ) {
  8533. 		// Support: Opera <= 12.12
  8534. 		// Opera reports offsetWidths and offsetHeights less than zero on some elements
  8535. 		return elem.offsetWidth <= 0 && elem.offsetHeight <= 0;
  8536. 	};
  8537. 	jQuery.expr.filters.visible = function( elem ) {
  8538. 		return !jQuery.expr.filters.hidden( elem );
  8539. 	};
  8540. 	
  8541. 	
  8542. 	
  8543. 	
  8544. 	var r20 = /%20/g,
  8545. 		rbracket = /\[\]$/,
  8546. 		rCRLF = /\r?\n/g,
  8547. 		rsubmitterTypes = /^(?:submit|button|image|reset|file)$/i,
  8548. 		rsubmittable = /^(?:input|select|textarea|keygen)/i;
  8549. 	
  8550. 	function buildParams( prefix, obj, traditional, add ) {
  8551. 		var name;
  8552. 	
  8553. 		if ( jQuery.isArray( obj ) ) {
  8554. 			// Serialize array item.
  8555. 			jQuery.each( obj, function( i, v ) {
  8556. 				if ( traditional || rbracket.test( prefix ) ) {
  8557. 					// Treat each array item as a scalar.
  8558. 					add( prefix, v );
  8559. 	
  8560. 				} else {
  8561. 					// Item is non-scalar (array or object), encode its numeric index.
  8562. 					buildParams( prefix + "[" + ( typeof v === "object" ? i : "" ) + "]", v, traditional, add );
  8563. 				}
  8564. 			});
  8565. 	
  8566. 		} else if ( !traditional && jQuery.type( obj ) === "object" ) {
  8567. 			// Serialize object item.
  8568. 			for ( name in obj ) {
  8569. 				buildParams( prefix + "[" + name + "]", obj[ name ], traditional, add );
  8570. 			}
  8571. 	
  8572. 		} else {
  8573. 			// Serialize scalar item.
  8574. 			add( prefix, obj );
  8575. 		}
  8576. 	}
  8577. 	
  8578. 	// Serialize an array of form elements or a set of
  8579. 	// key/values into a query string
  8580. 	jQuery.param = function( a, traditional ) {
  8581. 		var prefix,
  8582. 			s = [],
  8583. 			add = function( key, value ) {
  8584. 				// If value is a function, invoke it and return its value
  8585. 				value = jQuery.isFunction( value ) ? value() : ( value == null ? "" : value );
  8586. 				s[ s.length ] = encodeURIComponent( key ) + "=" + encodeURIComponent( value );
  8587. 			};
  8588. 	
  8589. 		// Set traditional to true for jQuery <= 1.3.2 behavior.
  8590. 		if ( traditional === undefined ) {
  8591. 			traditional = jQuery.ajaxSettings && jQuery.ajaxSettings.traditional;
  8592. 		}
  8593. 	
  8594. 		// If an array was passed in, assume that it is an array of form elements.
  8595. 		if ( jQuery.isArray( a ) || ( a.jquery && !jQuery.isPlainObject( a ) ) ) {
  8596. 			// Serialize the form elements
  8597. 			jQuery.each( a, function() {
  8598. 				add( this.name, this.value );
  8599. 			});
  8600. 	
  8601. 		} else {
  8602. 			// If traditional, encode the "old" way (the way 1.3.2 or older
  8603. 			// did it), otherwise encode params recursively.
  8604. 			for ( prefix in a ) {
  8605. 				buildParams( prefix, a[ prefix ], traditional, add );
  8606. 			}
  8607. 		}
  8608. 	
  8609. 		// Return the resulting serialization
  8610. 		return s.join( "&" ).replace( r20, "+" );
  8611. 	};
  8612. 	
  8613. 	jQuery.fn.extend({
  8614. 		serialize: function() {
  8615. 			return jQuery.param( this.serializeArray() );
  8616. 		},
  8617. 		serializeArray: function() {
  8618. 			return this.map(function() {
  8619. 				// Can add propHook for "elements" to filter or add form elements
  8620. 				var elements = jQuery.prop( this, "elements" );
  8621. 				return elements ? jQuery.makeArray( elements ) : this;
  8622. 			})
  8623. 			.filter(function() {
  8624. 				var type = this.type;
  8625. 	
  8626. 				// Use .is( ":disabled" ) so that fieldset[disabled] works
  8627. 				return this.name && !jQuery( this ).is( ":disabled" ) &&
  8628. 					rsubmittable.test( this.nodeName ) && !rsubmitterTypes.test( type ) &&
  8629. 					( this.checked || !rcheckableType.test( type ) );
  8630. 			})
  8631. 			.map(function( i, elem ) {
  8632. 				var val = jQuery( this ).val();
  8633. 	
  8634. 				return val == null ?
  8635. 					null :
  8636. 					jQuery.isArray( val ) ?
  8637. 						jQuery.map( val, function( val ) {
  8638. 							return { name: elem.name, value: val.replace( rCRLF, "\r\n" ) };
  8639. 						}) :
  8640. 						{ name: elem.name, value: val.replace( rCRLF, "\r\n" ) };
  8641. 			}).get();
  8642. 		}
  8643. 	});
  8644. 	
  8645. 	
  8646. 	jQuery.ajaxSettings.xhr = function() {
  8647. 		try {
  8648. 			return new XMLHttpRequest();
  8649. 		} catch( e ) {}
  8650. 	};
  8651. 	
  8652. 	var xhrId = 0,
  8653. 		xhrCallbacks = {},
  8654. 		xhrSuccessStatus = {
  8655. 			// file protocol always yields status code 0, assume 200
  8656. 			0: 200,
  8657. 			// Support: IE9
  8658. 			// #1450: sometimes IE returns 1223 when it should be 204
  8659. 			1223: 204
  8660. 		},
  8661. 		xhrSupported = jQuery.ajaxSettings.xhr();
  8662. 	
  8663. 	// Support: IE9
  8664. 	// Open requests must be manually aborted on unload (#5280)
  8665. 	// See https://support.microsoft.com/kb/2856746 for more info
  8666. 	if ( window.attachEvent ) {
  8667. 		window.attachEvent( "onunload", function() {
  8668. 			for ( var key in xhrCallbacks ) {
  8669. 				xhrCallbacks[ key ]();
  8670. 			}
  8671. 		});
  8672. 	}
  8673. 	
  8674. 	support.cors = !!xhrSupported && ( "withCredentials" in xhrSupported );
  8675. 	support.ajax = xhrSupported = !!xhrSupported;
  8676. 	
  8677. 	jQuery.ajaxTransport(function( options ) {
  8678. 		var callback;
  8679. 	
  8680. 		// Cross domain only allowed if supported through XMLHttpRequest
  8681. 		if ( support.cors || xhrSupported && !options.crossDomain ) {
  8682. 			return {
  8683. 				send: function( headers, complete ) {
  8684. 					var i,
  8685. 						xhr = options.xhr(),
  8686. 						id = ++xhrId;
  8687. 	
  8688. 					xhr.open( options.type, options.url, options.async, options.username, options.password );
  8689. 	
  8690. 					// Apply custom fields if provided
  8691. 					if ( options.xhrFields ) {
  8692. 						for ( i in options.xhrFields ) {
  8693. 							xhr[ i ] = options.xhrFields[ i ];
  8694. 						}
  8695. 					}
  8696. 	
  8697. 					// Override mime type if needed
  8698. 					if ( options.mimeType && xhr.overrideMimeType ) {
  8699. 						xhr.overrideMimeType( options.mimeType );
  8700. 					}
  8701. 	
  8702. 					// X-Requested-With header
  8703. 					// For cross-domain requests, seeing as conditions for a preflight are
  8704. 					// akin to a jigsaw puzzle, we simply never set it to be sure.
  8705. 					// (it can always be set on a per-request basis or even using ajaxSetup)
  8706. 					// For same-domain requests, won't change header if already provided.
  8707. 					if ( !options.crossDomain && !headers["X-Requested-With"] ) {
  8708. 						headers["X-Requested-With"] = "XMLHttpRequest";
  8709. 					}
  8710. 	
  8711. 					// Set headers
  8712. 					for ( i in headers ) {
  8713. 						xhr.setRequestHeader( i, headers[ i ] );
  8714. 					}
  8715. 	
  8716. 					// Callback
  8717. 					callback = function( type ) {
  8718. 						return function() {
  8719. 							if ( callback ) {
  8720. 								delete xhrCallbacks[ id ];
  8721. 								callback = xhr.onload = xhr.onerror = null;
  8722. 	
  8723. 								if ( type === "abort" ) {
  8724. 									xhr.abort();
  8725. 								} else if ( type === "error" ) {
  8726. 									complete(
  8727. 										// file: protocol always yields status 0; see #8605, #14207
  8728. 										xhr.status,
  8729. 										xhr.statusText
  8730. 									);
  8731. 								} else {
  8732. 									complete(
  8733. 										xhrSuccessStatus[ xhr.status ] || xhr.status,
  8734. 										xhr.statusText,
  8735. 										// Support: IE9
  8736. 										// Accessing binary-data responseText throws an exception
  8737. 										// (#11426)
  8738. 										typeof xhr.responseText === "string" ? {
  8739. 											text: xhr.responseText
  8740. 										} : undefined,
  8741. 										xhr.getAllResponseHeaders()
  8742. 									);
  8743. 								}
  8744. 							}
  8745. 						};
  8746. 					};
  8747. 	
  8748. 					// Listen to events
  8749. 					xhr.onload = callback();
  8750. 					xhr.onerror = callback("error");
  8751. 	
  8752. 					// Create the abort callback
  8753. 					callback = xhrCallbacks[ id ] = callback("abort");
  8754. 	
  8755. 					try {
  8756. 						// Do send the request (this may raise an exception)
  8757. 						xhr.send( options.hasContent && options.data || null );
  8758. 					} catch ( e ) {
  8759. 						// #14683: Only rethrow if this hasn't been notified as an error yet
  8760. 						if ( callback ) {
  8761. 							throw e;
  8762. 						}
  8763. 					}
  8764. 				},
  8765. 	
  8766. 				abort: function() {
  8767. 					if ( callback ) {
  8768. 						callback();
  8769. 					}
  8770. 				}
  8771. 			};
  8772. 		}
  8773. 	});
  8774. 	
  8775. 	
  8776. 	
  8777. 	
  8778. 	// Install script dataType
  8779. 	jQuery.ajaxSetup({
  8780. 		accepts: {
  8781. 			script: "text/javascript, application/javascript, application/ecmascript, application/x-ecmascript"
  8782. 		},
  8783. 		contents: {
  8784. 			script: /(?:java|ecma)script/
  8785. 		},
  8786. 		converters: {
  8787. 			"text script": function( text ) {
  8788. 				jQuery.globalEval( text );
  8789. 				return text;
  8790. 			}
  8791. 		}
  8792. 	});
  8793. 	
  8794. 	// Handle cache's special case and crossDomain
  8795. 	jQuery.ajaxPrefilter( "script", function( s ) {
  8796. 		if ( s.cache === undefined ) {
  8797. 			s.cache = false;
  8798. 		}
  8799. 		if ( s.crossDomain ) {
  8800. 			s.type = "GET";
  8801. 		}
  8802. 	});
  8803. 	
  8804. 	// Bind script tag hack transport
  8805. 	jQuery.ajaxTransport( "script", function( s ) {
  8806. 		// This transport only deals with cross domain requests
  8807. 		if ( s.crossDomain ) {
  8808. 			var script, callback;
  8809. 			return {
  8810. 				send: function( _, complete ) {
  8811. 					script = jQuery("<script>").prop({
  8812. 						async: true,
  8813. 						charset: s.scriptCharset,
  8814. 						src: s.url
  8815. 					}).on(
  8816. 						"load error",
  8817. 						callback = function( evt ) {
  8818. 							script.remove();
  8819. 							callback = null;
  8820. 							if ( evt ) {
  8821. 								complete( evt.type === "error" ? 404 : 200, evt.type );
  8822. 							}
  8823. 						}
  8824. 					);
  8825. 					document.head.appendChild( script[ 0 ] );
  8826. 				},
  8827. 				abort: function() {
  8828. 					if ( callback ) {
  8829. 						callback();
  8830. 					}
  8831. 				}
  8832. 			};
  8833. 		}
  8834. 	});
  8835. 	
  8836. 	
  8837. 	
  8838. 	
  8839. 	var oldCallbacks = [],
  8840. 		rjsonp = /(=)\?(?=&|$)|\?\?/;
  8841. 	
  8842. 	// Default jsonp settings
  8843. 	jQuery.ajaxSetup({
  8844. 		jsonp: "callback",
  8845. 		jsonpCallback: function() {
  8846. 			var callback = oldCallbacks.pop() || ( jQuery.expando + "_" + ( nonce++ ) );
  8847. 			this[ callback ] = true;
  8848. 			return callback;
  8849. 		}
  8850. 	});
  8851. 	
  8852. 	// Detect, normalize options and install callbacks for jsonp requests
  8853. 	jQuery.ajaxPrefilter( "json jsonp", function( s, originalSettings, jqXHR ) {
  8854. 	
  8855. 		var callbackName, overwritten, responseContainer,
  8856. 			jsonProp = s.jsonp !== false && ( rjsonp.test( s.url ) ?
  8857. 				"url" :
  8858. 				typeof s.data === "string" && !( s.contentType || "" ).indexOf("application/x-www-form-urlencoded") && rjsonp.test( s.data ) && "data"
  8859. 			);
  8860. 	
  8861. 		// Handle iff the expected data type is "jsonp" or we have a parameter to set
  8862. 		if ( jsonProp || s.dataTypes[ 0 ] === "jsonp" ) {
  8863. 	
  8864. 			// Get callback name, remembering preexisting value associated with it
  8865. 			callbackName = s.jsonpCallback = jQuery.isFunction( s.jsonpCallback ) ?
  8866. 				s.jsonpCallback() :
  8867. 				s.jsonpCallback;
  8868. 	
  8869. 			// Insert callback into url or form data
  8870. 			if ( jsonProp ) {
  8871. 				s[ jsonProp ] = s[ jsonProp ].replace( rjsonp, "$1" + callbackName );
  8872. 			} else if ( s.jsonp !== false ) {
  8873. 				s.url += ( rquery.test( s.url ) ? "&" : "?" ) + s.jsonp + "=" + callbackName;
  8874. 			}
  8875. 	
  8876. 			// Use data converter to retrieve json after script execution
  8877. 			s.converters["script json"] = function() {
  8878. 				if ( !responseContainer ) {
  8879. 					jQuery.error( callbackName + " was not called" );
  8880. 				}
  8881. 				return responseContainer[ 0 ];
  8882. 			};
  8883. 	
  8884. 			// force json dataType
  8885. 			s.dataTypes[ 0 ] = "json";
  8886. 	
  8887. 			// Install callback
  8888. 			overwritten = window[ callbackName ];
  8889. 			window[ callbackName ] = function() {
  8890. 				responseContainer = arguments;
  8891. 			};
  8892. 	
  8893. 			// Clean-up function (fires after converters)
  8894. 			jqXHR.always(function() {
  8895. 				// Restore preexisting value
  8896. 				window[ callbackName ] = overwritten;
  8897. 	
  8898. 				// Save back as free
  8899. 				if ( s[ callbackName ] ) {
  8900. 					// make sure that re-using the options doesn't screw things around
  8901. 					s.jsonpCallback = originalSettings.jsonpCallback;
  8902. 	
  8903. 					// save the callback name for future use
  8904. 					oldCallbacks.push( callbackName );
  8905. 				}
  8906. 	
  8907. 				// Call if it was a function and we have a response
  8908. 				if ( responseContainer && jQuery.isFunction( overwritten ) ) {
  8909. 					overwritten( responseContainer[ 0 ] );
  8910. 				}
  8911. 	
  8912. 				responseContainer = overwritten = undefined;
  8913. 			});
  8914. 	
  8915. 			// Delegate to script
  8916. 			return "script";
  8917. 		}
  8918. 	});
  8919. 	
  8920. 	
  8921. 	
  8922. 	
  8923. 	// data: string of html
  8924. 	// context (optional): If specified, the fragment will be created in this context, defaults to document
  8925. 	// keepScripts (optional): If true, will include scripts passed in the html string
  8926. 	jQuery.parseHTML = function( data, context, keepScripts ) {
  8927. 		if ( !data || typeof data !== "string" ) {
  8928. 			return null;
  8929. 		}
  8930. 		if ( typeof context === "boolean" ) {
  8931. 			keepScripts = context;
  8932. 			context = false;
  8933. 		}
  8934. 		context = context || document;
  8935. 	
  8936. 		var parsed = rsingleTag.exec( data ),
  8937. 			scripts = !keepScripts && [];
  8938. 	
  8939. 		// Single tag
  8940. 		if ( parsed ) {
  8941. 			return [ context.createElement( parsed[1] ) ];
  8942. 		}
  8943. 	
  8944. 		parsed = jQuery.buildFragment( [ data ], context, scripts );
  8945. 	
  8946. 		if ( scripts && scripts.length ) {
  8947. 			jQuery( scripts ).remove();
  8948. 		}
  8949. 	
  8950. 		return jQuery.merge( [], parsed.childNodes );
  8951. 	};
  8952. 	
  8953. 	
  8954. 	// Keep a copy of the old load method
  8955. 	var _load = jQuery.fn.load;
  8956. 	
  8957. 	/**
  8958. 	 * Load a url into a page
  8959. 	 */
  8960. 	jQuery.fn.load = function( url, params, callback ) {
  8961. 		if ( typeof url !== "string" && _load ) {
  8962. 			return _load.apply( this, arguments );
  8963. 		}
  8964. 	
  8965. 		var selector, type, response,
  8966. 			self = this,
  8967. 			off = url.indexOf(" ");
  8968. 	
  8969. 		if ( off >= 0 ) {
  8970. 			selector = jQuery.trim( url.slice( off ) );
  8971. 			url = url.slice( 0, off );
  8972. 		}
  8973. 	
  8974. 		// If it's a function
  8975. 		if ( jQuery.isFunction( params ) ) {
  8976. 	
  8977. 			// We assume that it's the callback
  8978. 			callback = params;
  8979. 			params = undefined;
  8980. 	
  8981. 		// Otherwise, build a param string
  8982. 		} else if ( params && typeof params === "object" ) {
  8983. 			type = "POST";
  8984. 		}
  8985. 	
  8986. 		// If we have elements to modify, make the request
  8987. 		if ( self.length > 0 ) {
  8988. 			jQuery.ajax({
  8989. 				url: url,
  8990. 	
  8991. 				// if "type" variable is undefined, then "GET" method will be used
  8992. 				type: type,
  8993. 				dataType: "html",
  8994. 				data: params
  8995. 			}).done(function( responseText ) {
  8996. 	
  8997. 				// Save response for use in complete callback
  8998. 				response = arguments;
  8999. 	
  9000. 				self.html( selector ?
  9001. 	
  9002. 					// If a selector was specified, locate the right elements in a dummy div
  9003. 					// Exclude scripts to avoid IE 'Permission Denied' errors
  9004. 					jQuery("<div>").append( jQuery.parseHTML( responseText ) ).find( selector ) :
  9005. 	
  9006. 					// Otherwise use the full result
  9007. 					responseText );
  9008. 	
  9009. 			}).complete( callback && function( jqXHR, status ) {
  9010. 				self.each( callback, response || [ jqXHR.responseText, status, jqXHR ] );
  9011. 			});
  9012. 		}
  9013. 	
  9014. 		return this;
  9015. 	};
  9016. 	
  9017. 	
  9018. 	
  9019. 	
  9020. 	// Attach a bunch of functions for handling common AJAX events
  9021. 	jQuery.each( [ "ajaxStart", "ajaxStop", "ajaxComplete", "ajaxError", "ajaxSuccess", "ajaxSend" ], function( i, type ) {
  9022. 		jQuery.fn[ type ] = function( fn ) {
  9023. 			return this.on( type, fn );
  9024. 		};
  9025. 	});
  9026. 	
  9027. 	
  9028. 	
  9029. 	
  9030. 	jQuery.expr.filters.animated = function( elem ) {
  9031. 		return jQuery.grep(jQuery.timers, function( fn ) {
  9032. 			return elem === fn.elem;
  9033. 		}).length;
  9034. 	};
  9035. 	
  9036. 	
  9037. 	
  9038. 	
  9039. 	var docElem = window.document.documentElement;
  9040. 	
  9041. 	/**
  9042. 	 * Gets a window from an element
  9043. 	 */
  9044. 	function getWindow( elem ) {
  9045. 		return jQuery.isWindow( elem ) ? elem : elem.nodeType === 9 && elem.defaultView;
  9046. 	}
  9047. 	
  9048. 	jQuery.offset = {
  9049. 		setOffset: function( elem, options, i ) {
  9050. 			var curPosition, curLeft, curCSSTop, curTop, curOffset, curCSSLeft, calculatePosition,
  9051. 				position = jQuery.css( elem, "position" ),
  9052. 				curElem = jQuery( elem ),
  9053. 				props = {};
  9054. 	
  9055. 			// Set position first, in-case top/left are set even on static elem
  9056. 			if ( position === "static" ) {
  9057. 				elem.style.position = "relative";
  9058. 			}
  9059. 	
  9060. 			curOffset = curElem.offset();
  9061. 			curCSSTop = jQuery.css( elem, "top" );
  9062. 			curCSSLeft = jQuery.css( elem, "left" );
  9063. 			calculatePosition = ( position === "absolute" || position === "fixed" ) &&
  9064. 				( curCSSTop + curCSSLeft ).indexOf("auto") > -1;
  9065. 	
  9066. 			// Need to be able to calculate position if either
  9067. 			// top or left is auto and position is either absolute or fixed
  9068. 			if ( calculatePosition ) {
  9069. 				curPosition = curElem.position();
  9070. 				curTop = curPosition.top;
  9071. 				curLeft = curPosition.left;
  9072. 	
  9073. 			} else {
  9074. 				curTop = parseFloat( curCSSTop ) || 0;
  9075. 				curLeft = parseFloat( curCSSLeft ) || 0;
  9076. 			}
  9077. 	
  9078. 			if ( jQuery.isFunction( options ) ) {
  9079. 				options = options.call( elem, i, curOffset );
  9080. 			}
  9081. 	
  9082. 			if ( options.top != null ) {
  9083. 				props.top = ( options.top - curOffset.top ) + curTop;
  9084. 			}
  9085. 			if ( options.left != null ) {
  9086. 				props.left = ( options.left - curOffset.left ) + curLeft;
  9087. 			}
  9088. 	
  9089. 			if ( "using" in options ) {
  9090. 				options.using.call( elem, props );
  9091. 	
  9092. 			} else {
  9093. 				curElem.css( props );
  9094. 			}
  9095. 		}
  9096. 	};
  9097. 	
  9098. 	jQuery.fn.extend({
  9099. 		offset: function( options ) {
  9100. 			if ( arguments.length ) {
  9101. 				return options === undefined ?
  9102. 					this :
  9103. 					this.each(function( i ) {
  9104. 						jQuery.offset.setOffset( this, options, i );
  9105. 					});
  9106. 			}
  9107. 	
  9108. 			var docElem, win,
  9109. 				elem = this[ 0 ],
  9110. 				box = { top: 0, left: 0 },
  9111. 				doc = elem && elem.ownerDocument;
  9112. 	
  9113. 			if ( !doc ) {
  9114. 				return;
  9115. 			}
  9116. 	
  9117. 			docElem = doc.documentElement;
  9118. 	
  9119. 			// Make sure it's not a disconnected DOM node
  9120. 			if ( !jQuery.contains( docElem, elem ) ) {
  9121. 				return box;
  9122. 			}
  9123. 	
  9124. 			// Support: BlackBerry 5, iOS 3 (original iPhone)
  9125. 			// If we don't have gBCR, just use 0,0 rather than error
  9126. 			if ( typeof elem.getBoundingClientRect !== strundefined ) {
  9127. 				box = elem.getBoundingClientRect();
  9128. 			}
  9129. 			win = getWindow( doc );
  9130. 			return {
  9131. 				top: box.top + win.pageYOffset - docElem.clientTop,
  9132. 				left: box.left + win.pageXOffset - docElem.clientLeft
  9133. 			};
  9134. 		},
  9135. 	
  9136. 		position: function() {
  9137. 			if ( !this[ 0 ] ) {
  9138. 				return;
  9139. 			}
  9140. 	
  9141. 			var offsetParent, offset,
  9142. 				elem = this[ 0 ],
  9143. 				parentOffset = { top: 0, left: 0 };
  9144. 	
  9145. 			// Fixed elements are offset from window (parentOffset = {top:0, left: 0}, because it is its only offset parent
  9146. 			if ( jQuery.css( elem, "position" ) === "fixed" ) {
  9147. 				// Assume getBoundingClientRect is there when computed position is fixed
  9148. 				offset = elem.getBoundingClientRect();
  9149. 	
  9150. 			} else {
  9151. 				// Get *real* offsetParent
  9152. 				offsetParent = this.offsetParent();
  9153. 	
  9154. 				// Get correct offsets
  9155. 				offset = this.offset();
  9156. 				if ( !jQuery.nodeName( offsetParent[ 0 ], "html" ) ) {
  9157. 					parentOffset = offsetParent.offset();
  9158. 				}
  9159. 	
  9160. 				// Add offsetParent borders
  9161. 				parentOffset.top += jQuery.css( offsetParent[ 0 ], "borderTopWidth", true );
  9162. 				parentOffset.left += jQuery.css( offsetParent[ 0 ], "borderLeftWidth", true );
  9163. 			}
  9164. 	
  9165. 			// Subtract parent offsets and element margins
  9166. 			return {
  9167. 				top: offset.top - parentOffset.top - jQuery.css( elem, "marginTop", true ),
  9168. 				left: offset.left - parentOffset.left - jQuery.css( elem, "marginLeft", true )
  9169. 			};
  9170. 		},
  9171. 	
  9172. 		offsetParent: function() {
  9173. 			return this.map(function() {
  9174. 				var offsetParent = this.offsetParent || docElem;
  9175. 	
  9176. 				while ( offsetParent && ( !jQuery.nodeName( offsetParent, "html" ) && jQuery.css( offsetParent, "position" ) === "static" ) ) {
  9177. 					offsetParent = offsetParent.offsetParent;
  9178. 				}
  9179. 	
  9180. 				return offsetParent || docElem;
  9181. 			});
  9182. 		}
  9183. 	});
  9184. 	
  9185. 	// Create scrollLeft and scrollTop methods
  9186. 	jQuery.each( { scrollLeft: "pageXOffset", scrollTop: "pageYOffset" }, function( method, prop ) {
  9187. 		var top = "pageYOffset" === prop;
  9188. 	
  9189. 		jQuery.fn[ method ] = function( val ) {
  9190. 			return access( this, function( elem, method, val ) {
  9191. 				var win = getWindow( elem );
  9192. 	
  9193. 				if ( val === undefined ) {
  9194. 					return win ? win[ prop ] : elem[ method ];
  9195. 				}
  9196. 	
  9197. 				if ( win ) {
  9198. 					win.scrollTo(
  9199. 						!top ? val : window.pageXOffset,
  9200. 						top ? val : window.pageYOffset
  9201. 					);
  9202. 	
  9203. 				} else {
  9204. 					elem[ method ] = val;
  9205. 				}
  9206. 			}, method, val, arguments.length, null );
  9207. 		};
  9208. 	});
  9209. 	
  9210. 	// Support: Safari<7+, Chrome<37+
  9211. 	// Add the top/left cssHooks using jQuery.fn.position
  9212. 	// Webkit bug: https://bugs.webkit.org/show_bug.cgi?id=29084
  9213. 	// Blink bug: https://code.google.com/p/chromium/issues/detail?id=229280
  9214. 	// getComputedStyle returns percent when specified for top/left/bottom/right;
  9215. 	// rather than make the css module depend on the offset module, just check for it here
  9216. 	jQuery.each( [ "top", "left" ], function( i, prop ) {
  9217. 		jQuery.cssHooks[ prop ] = addGetHookIf( support.pixelPosition,
  9218. 			function( elem, computed ) {
  9219. 				if ( computed ) {
  9220. 					computed = curCSS( elem, prop );
  9221. 					// If curCSS returns percentage, fallback to offset
  9222. 					return rnumnonpx.test( computed ) ?
  9223. 						jQuery( elem ).position()[ prop ] + "px" :
  9224. 						computed;
  9225. 				}
  9226. 			}
  9227. 		);
  9228. 	});
  9229. 	
  9230. 	
  9231. 	// Create innerHeight, innerWidth, height, width, outerHeight and outerWidth methods
  9232. 	jQuery.each( { Height: "height", Width: "width" }, function( name, type ) {
  9233. 		jQuery.each( { padding: "inner" + name, content: type, "": "outer" + name }, function( defaultExtra, funcName ) {
  9234. 			// Margin is only for outerHeight, outerWidth
  9235. 			jQuery.fn[ funcName ] = function( margin, value ) {
  9236. 				var chainable = arguments.length && ( defaultExtra || typeof margin !== "boolean" ),
  9237. 					extra = defaultExtra || ( margin === true || value === true ? "margin" : "border" );
  9238. 	
  9239. 				return access( this, function( elem, type, value ) {
  9240. 					var doc;
  9241. 	
  9242. 					if ( jQuery.isWindow( elem ) ) {
  9243. 						// As of 5/8/2012 this will yield incorrect results for Mobile Safari, but there
  9244. 						// isn't a whole lot we can do. See pull request at this URL for discussion:
  9245. 						// https://github.com/jquery/jquery/pull/764
  9246. 						return elem.document.documentElement[ "client" + name ];
  9247. 					}
  9248. 	
  9249. 					// Get document width or height
  9250. 					if ( elem.nodeType === 9 ) {
  9251. 						doc = elem.documentElement;
  9252. 	
  9253. 						// Either scroll[Width/Height] or offset[Width/Height] or client[Width/Height],
  9254. 						// whichever is greatest
  9255. 						return Math.max(
  9256. 							elem.body[ "scroll" + name ], doc[ "scroll" + name ],
  9257. 							elem.body[ "offset" + name ], doc[ "offset" + name ],
  9258. 							doc[ "client" + name ]
  9259. 						);
  9260. 					}
  9261. 	
  9262. 					return value === undefined ?
  9263. 						// Get width or height on the element, requesting but not forcing parseFloat
  9264. 						jQuery.css( elem, type, extra ) :
  9265. 	
  9266. 						// Set width or height on the element
  9267. 						jQuery.style( elem, type, value, extra );
  9268. 				}, type, chainable ? margin : undefined, chainable, null );
  9269. 			};
  9270. 		});
  9271. 	});
  9272. 	
  9273. 	
  9274. 	// The number of elements contained in the matched element set
  9275. 	jQuery.fn.size = function() {
  9276. 		return this.length;
  9277. 	};
  9278. 	
  9279. 	jQuery.fn.andSelf = jQuery.fn.addBack;
  9280. 	
  9281. 	
  9282. 	
  9283. 	
  9284. 	// Register as a named AMD module, since jQuery can be concatenated with other
  9285. 	// files that may use define, but not via a proper concatenation script that
  9286. 	// understands anonymous AMD modules. A named AMD is safest and most robust
  9287. 	// way to register. Lowercase jquery is used because AMD module names are
  9288. 	// derived from file names, and jQuery is normally delivered in a lowercase
  9289. 	// file name. Do this after creating the global so that if an AMD module wants
  9290. 	// to call noConflict to hide this version of jQuery, it will work.
  9291. 	
  9292. 	// Note that for maximum portability, libraries that are not jQuery should
  9293. 	// declare themselves as anonymous modules, and avoid setting a global if an
  9294. 	// AMD loader is present. jQuery is a special case. For more information, see
  9295. 	// https://github.com/jrburke/requirejs/wiki/Updating-existing-libraries#wiki-anon
  9296. 	
  9297. 	if ( true ) {
  9298. 		!(__WEBPACK_AMD_DEFINE_ARRAY__ = [], __WEBPACK_AMD_DEFINE_RESULT__ = function() {
  9299. 			return jQuery;
  9300. 		}.apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
  9301. 	}
  9302. 	
  9303. 	
  9304. 	
  9305. 	
  9306. 	var
  9307. 		// Map over jQuery in case of overwrite
  9308. 		_jQuery = window.jQuery,
  9309. 	
  9310. 		// Map over the $ in case of overwrite
  9311. 		_$ = window.$;
  9312. 	
  9313. 	jQuery.noConflict = function( deep ) {
  9314. 		if ( window.$ === jQuery ) {
  9315. 			window.$ = _$;
  9316. 		}
  9317. 	
  9318. 		if ( deep && window.jQuery === jQuery ) {
  9319. 			window.jQuery = _jQuery;
  9320. 		}
  9321. 	
  9322. 		return jQuery;
  9323. 	};
  9324. 	
  9325. 	// Expose jQuery and $ identifiers, even in AMD
  9326. 	// (#7102#comment:10, https://github.com/jquery/jquery/pull/557)
  9327. 	// and CommonJS for browser emulators (#13566)
  9328. 	if ( typeof noGlobal === strundefined ) {
  9329. 		window.jQuery = window.$ = jQuery;
  9330. 	}
  9331. 	
  9332. 	
  9333. 	
  9334. 	
  9335. 	return jQuery;
  9336. 	
  9337. 	}));
  9338.  
  9339.  
  9340. /***/ },
  9341. /* 3 */
  9342. /*!**************************************************!*\
  9343.   !*** ./~/babel-runtime/core-js/object/assign.js ***!
  9344.   \**************************************************/
  9345. /***/ function(module, exports, __webpack_require__) {
  9346.  
  9347. 	module.exports = { "default": __webpack_require__(/*! core-js/library/fn/object/assign */ 4), __esModule: true };
  9348.  
  9349. /***/ },
  9350. /* 4 */
  9351. /*!***************************************************************!*\
  9352.   !*** ./~/babel-runtime/~/core-js/library/fn/object/assign.js ***!
  9353.   \***************************************************************/
  9354. /***/ function(module, exports, __webpack_require__) {
  9355.  
  9356. 	__webpack_require__(/*! ../../modules/es6.object.assign */ 5);
  9357. 	module.exports = __webpack_require__(/*! ../../modules/$.core */ 8).Object.assign;
  9358.  
  9359. /***/ },
  9360. /* 5 */
  9361. /*!************************************************************************!*\
  9362.   !*** ./~/babel-runtime/~/core-js/library/modules/es6.object.assign.js ***!
  9363.   \************************************************************************/
  9364. /***/ function(module, exports, __webpack_require__) {
  9365.  
  9366. 	// 19.1.3.1 Object.assign(target, source)
  9367. 	var $def = __webpack_require__(/*! ./$.def */ 6);
  9368. 	$def($def.S, 'Object', {assign: __webpack_require__(/*! ./$.assign */ 9)});
  9369.  
  9370. /***/ },
  9371. /* 6 */
  9372. /*!************************************************************!*\
  9373.   !*** ./~/babel-runtime/~/core-js/library/modules/$.def.js ***!
  9374.   \************************************************************/
  9375. /***/ function(module, exports, __webpack_require__) {
  9376.  
  9377. 	var global    = __webpack_require__(/*! ./$.global */ 7)
  9378. 	  , core      = __webpack_require__(/*! ./$.core */ 8)
  9379. 	  , PROTOTYPE = 'prototype';
  9380. 	var ctx = function(fn, that){
  9381. 	  return function(){
  9382. 	    return fn.apply(that, arguments);
  9383. 	  };
  9384. 	};
  9385. 	var $def = function(type, name, source){
  9386. 	  var key, own, out, exp
  9387. 	    , isGlobal = type & $def.G
  9388. 	    , isProto  = type & $def.P
  9389. 	    , target   = isGlobal ? global : type & $def.S
  9390. 	        ? global[name] : (global[name] || {})[PROTOTYPE]
  9391. 	    , exports  = isGlobal ? core : core[name] || (core[name] = {});
  9392. 	  if(isGlobal)source = name;
  9393. 	  for(key in source){
  9394. 	    // contains in native
  9395. 	    own = !(type & $def.F) && target && key in target;
  9396. 	    if(own && key in exports)continue;
  9397. 	    // export native or passed
  9398. 	    out = own ? target[key] : source[key];
  9399. 	    // prevent global pollution for namespaces
  9400. 	    if(isGlobal && typeof target[key] != 'function')exp = source[key];
  9401. 	    // bind timers to global for call from export context
  9402. 	    else if(type & $def.B && own)exp = ctx(out, global);
  9403. 	    // wrap global constructors for prevent change them in library
  9404. 	    else if(type & $def.W && target[key] == out)!function(C){
  9405. 	      exp = function(param){
  9406. 	        return this instanceof C ? new C(param) : C(param);
  9407. 	      };
  9408. 	      exp[PROTOTYPE] = C[PROTOTYPE];
  9409. 	    }(out);
  9410. 	    else exp = isProto && typeof out == 'function' ? ctx(Function.call, out) : out;
  9411. 	    // export
  9412. 	    exports[key] = exp;
  9413. 	    if(isProto)(exports[PROTOTYPE] || (exports[PROTOTYPE] = {}))[key] = out;
  9414. 	  }
  9415. 	};
  9416. 	// type bitmap
  9417. 	$def.F = 1;  // forced
  9418. 	$def.G = 2;  // global
  9419. 	$def.S = 4;  // static
  9420. 	$def.P = 8;  // proto
  9421. 	$def.B = 16; // bind
  9422. 	$def.W = 32; // wrap
  9423. 	module.exports = $def;
  9424.  
  9425. /***/ },
  9426. /* 7 */
  9427. /*!***************************************************************!*\
  9428.   !*** ./~/babel-runtime/~/core-js/library/modules/$.global.js ***!
  9429.   \***************************************************************/
  9430. /***/ function(module, exports) {
  9431.  
  9432. 	var global = typeof self != 'undefined' && self.Math == Math ? self : Function('return this')();
  9433. 	module.exports = global;
  9434. 	if(typeof __g == 'number')__g = global; // eslint-disable-line no-undef
  9435.  
  9436. /***/ },
  9437. /* 8 */
  9438. /*!*************************************************************!*\
  9439.   !*** ./~/babel-runtime/~/core-js/library/modules/$.core.js ***!
  9440.   \*************************************************************/
  9441. /***/ function(module, exports) {
  9442.  
  9443. 	var core = module.exports = {};
  9444. 	if(typeof __e == 'number')__e = core; // eslint-disable-line no-undef
  9445.  
  9446. /***/ },
  9447. /* 9 */
  9448. /*!***************************************************************!*\
  9449.   !*** ./~/babel-runtime/~/core-js/library/modules/$.assign.js ***!
  9450.   \***************************************************************/
  9451. /***/ function(module, exports, __webpack_require__) {
  9452.  
  9453. 	// 19.1.2.1 Object.assign(target, source, ...)
  9454. 	var toObject = __webpack_require__(/*! ./$.to-object */ 10)
  9455. 	  , IObject  = __webpack_require__(/*! ./$.iobject */ 12)
  9456. 	  , enumKeys = __webpack_require__(/*! ./$.enum-keys */ 14);
  9457. 	/* eslint-disable no-unused-vars */
  9458. 	module.exports = Object.assign || function assign(target, source){
  9459. 	/* eslint-enable no-unused-vars */
  9460. 	  var T = toObject(target)
  9461. 	    , l = arguments.length
  9462. 	    , i = 1;
  9463. 	  while(l > i){
  9464. 	    var S      = IObject(arguments[i++])
  9465. 	      , keys   = enumKeys(S)
  9466. 	      , length = keys.length
  9467. 	      , j      = 0
  9468. 	      , key;
  9469. 	    while(length > j)T[key = keys[j++]] = S[key];
  9470. 	  }
  9471. 	  return T;
  9472. 	};
  9473.  
  9474. /***/ },
  9475. /* 10 */
  9476. /*!******************************************************************!*\
  9477.   !*** ./~/babel-runtime/~/core-js/library/modules/$.to-object.js ***!
  9478.   \******************************************************************/
  9479. /***/ function(module, exports, __webpack_require__) {
  9480.  
  9481. 	// 7.1.13 ToObject(argument)
  9482. 	var defined = __webpack_require__(/*! ./$.defined */ 11);
  9483. 	module.exports = function(it){
  9484. 	  return Object(defined(it));
  9485. 	};
  9486.  
  9487. /***/ },
  9488. /* 11 */
  9489. /*!****************************************************************!*\
  9490.   !*** ./~/babel-runtime/~/core-js/library/modules/$.defined.js ***!
  9491.   \****************************************************************/
  9492. /***/ function(module, exports) {
  9493.  
  9494. 	// 7.2.1 RequireObjectCoercible(argument)
  9495. 	module.exports = function(it){
  9496. 	  if(it == undefined)throw TypeError("Can't call method on  " + it);
  9497. 	  return it;
  9498. 	};
  9499.  
  9500. /***/ },
  9501. /* 12 */
  9502. /*!****************************************************************!*\
  9503.   !*** ./~/babel-runtime/~/core-js/library/modules/$.iobject.js ***!
  9504.   \****************************************************************/
  9505. /***/ function(module, exports, __webpack_require__) {
  9506.  
  9507. 	// indexed object, fallback for non-array-like ES3 strings
  9508. 	var cof = __webpack_require__(/*! ./$.cof */ 13);
  9509. 	module.exports = 0 in Object('z') ? Object : function(it){
  9510. 	  return cof(it) == 'String' ? it.split('') : Object(it);
  9511. 	};
  9512.  
  9513. /***/ },
  9514. /* 13 */
  9515. /*!************************************************************!*\
  9516.   !*** ./~/babel-runtime/~/core-js/library/modules/$.cof.js ***!
  9517.   \************************************************************/
  9518. /***/ function(module, exports) {
  9519.  
  9520. 	var toString = {}.toString;
  9521. 	
  9522. 	module.exports = function(it){
  9523. 	  return toString.call(it).slice(8, -1);
  9524. 	};
  9525.  
  9526. /***/ },
  9527. /* 14 */
  9528. /*!******************************************************************!*\
  9529.   !*** ./~/babel-runtime/~/core-js/library/modules/$.enum-keys.js ***!
  9530.   \******************************************************************/
  9531. /***/ function(module, exports, __webpack_require__) {
  9532.  
  9533. 	// all enumerable object keys, includes symbols
  9534. 	var $ = __webpack_require__(/*! ./$ */ 15);
  9535. 	module.exports = function(it){
  9536. 	  var keys       = $.getKeys(it)
  9537. 	    , getSymbols = $.getSymbols;
  9538. 	  if(getSymbols){
  9539. 	    var symbols = getSymbols(it)
  9540. 	      , isEnum  = $.isEnum
  9541. 	      , i       = 0
  9542. 	      , key;
  9543. 	    while(symbols.length > i)if(isEnum.call(it, key = symbols[i++]))keys.push(key);
  9544. 	  }
  9545. 	  return keys;
  9546. 	};
  9547.  
  9548. /***/ },
  9549. /* 15 */
  9550. /*!********************************************************!*\
  9551.   !*** ./~/babel-runtime/~/core-js/library/modules/$.js ***!
  9552.   \********************************************************/
  9553. /***/ function(module, exports) {
  9554.  
  9555. 	var $Object = Object;
  9556. 	module.exports = {
  9557. 	  create:     $Object.create,
  9558. 	  getProto:   $Object.getPrototypeOf,
  9559. 	  isEnum:     {}.propertyIsEnumerable,
  9560. 	  getDesc:    $Object.getOwnPropertyDescriptor,
  9561. 	  setDesc:    $Object.defineProperty,
  9562. 	  setDescs:   $Object.defineProperties,
  9563. 	  getKeys:    $Object.keys,
  9564. 	  getNames:   $Object.getOwnPropertyNames,
  9565. 	  getSymbols: $Object.getOwnPropertySymbols,
  9566. 	  each:       [].forEach
  9567. 	};
  9568.  
  9569. /***/ },
  9570. /* 16 */
  9571. /*!************************************************************!*\
  9572.   !*** ./~/babel-runtime/helpers/interop-require-default.js ***!
  9573.   \************************************************************/
  9574. /***/ function(module, exports) {
  9575.  
  9576. 	"use strict";
  9577. 	
  9578. 	exports["default"] = function (obj) {
  9579. 	  return obj && obj.__esModule ? obj : {
  9580. 	    "default": obj
  9581. 	  };
  9582. 	};
  9583. 	
  9584. 	exports.__esModule = true;
  9585.  
  9586. /***/ },
  9587. /* 17 */
  9588. /*!********************************************!*\
  9589.   !*** ./src/scripts/jquery-extras/index.js ***!
  9590.   \********************************************/
  9591. /***/ function(module, exports, __webpack_require__) {
  9592.  
  9593. 	/* WEBPACK VAR INJECTION */(function(process) {'use strict';
  9594. 	
  9595. 	var _interopRequireDefault = __webpack_require__(/*! babel-runtime/helpers/interop-require-default */ 16)['default'];
  9596. 	
  9597. 	var _jquery = __webpack_require__(/*! jquery */ 2);
  9598. 	
  9599. 	var _jquery2 = _interopRequireDefault(_jquery);
  9600. 	
  9601. 	__webpack_require__(/*! ./plugins */ 19);
  9602. 	
  9603. 	// ----------------------------------------------------------------------------
  9604. 	
  9605. 	_jquery2['default'].extras = {
  9606. 	  _build_environment: process.env.NODE_ENV || 'development'
  9607. 	};
  9608. 	/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(/*! (webpack)/~/node-libs-browser/~/process/browser.js */ 18)))
  9609.  
  9610. /***/ },
  9611. /* 18 */
  9612. /*!**********************************************************!*\
  9613.   !*** (webpack)/~/node-libs-browser/~/process/browser.js ***!
  9614.   \**********************************************************/
  9615. /***/ function(module, exports) {
  9616.  
  9617. 	// shim for using process in browser
  9618. 	
  9619. 	var process = module.exports = {};
  9620. 	var queue = [];
  9621. 	var draining = false;
  9622. 	var currentQueue;
  9623. 	var queueIndex = -1;
  9624. 	
  9625. 	function cleanUpNextTick() {
  9626. 	    draining = false;
  9627. 	    if (currentQueue.length) {
  9628. 	        queue = currentQueue.concat(queue);
  9629. 	    } else {
  9630. 	        queueIndex = -1;
  9631. 	    }
  9632. 	    if (queue.length) {
  9633. 	        drainQueue();
  9634. 	    }
  9635. 	}
  9636. 	
  9637. 	function drainQueue() {
  9638. 	    if (draining) {
  9639. 	        return;
  9640. 	    }
  9641. 	    var timeout = setTimeout(cleanUpNextTick);
  9642. 	    draining = true;
  9643. 	
  9644. 	    var len = queue.length;
  9645. 	    while(len) {
  9646. 	        currentQueue = queue;
  9647. 	        queue = [];
  9648. 	        while (++queueIndex < len) {
  9649. 	            currentQueue[queueIndex].run();
  9650. 	        }
  9651. 	        queueIndex = -1;
  9652. 	        len = queue.length;
  9653. 	    }
  9654. 	    currentQueue = null;
  9655. 	    draining = false;
  9656. 	    clearTimeout(timeout);
  9657. 	}
  9658. 	
  9659. 	process.nextTick = function (fun) {
  9660. 	    var args = new Array(arguments.length - 1);
  9661. 	    if (arguments.length > 1) {
  9662. 	        for (var i = 1; i < arguments.length; i++) {
  9663. 	            args[i - 1] = arguments[i];
  9664. 	        }
  9665. 	    }
  9666. 	    queue.push(new Item(fun, args));
  9667. 	    if (queue.length === 1 && !draining) {
  9668. 	        setTimeout(drainQueue, 0);
  9669. 	    }
  9670. 	};
  9671. 	
  9672. 	// v8 likes predictible objects
  9673. 	function Item(fun, array) {
  9674. 	    this.fun = fun;
  9675. 	    this.array = array;
  9676. 	}
  9677. 	Item.prototype.run = function () {
  9678. 	    this.fun.apply(null, this.array);
  9679. 	};
  9680. 	process.title = 'browser';
  9681. 	process.browser = true;
  9682. 	process.env = {};
  9683. 	process.argv = [];
  9684. 	process.version = ''; // empty string to avoid regexp issues
  9685. 	process.versions = {};
  9686. 	
  9687. 	function noop() {}
  9688. 	
  9689. 	process.on = noop;
  9690. 	process.addListener = noop;
  9691. 	process.once = noop;
  9692. 	process.off = noop;
  9693. 	process.removeListener = noop;
  9694. 	process.removeAllListeners = noop;
  9695. 	process.emit = noop;
  9696. 	
  9697. 	process.binding = function (name) {
  9698. 	    throw new Error('process.binding is not supported');
  9699. 	};
  9700. 	
  9701. 	// TODO(shtylman)
  9702. 	process.cwd = function () { return '/' };
  9703. 	process.chdir = function (dir) {
  9704. 	    throw new Error('process.chdir is not supported');
  9705. 	};
  9706. 	process.umask = function() { return 0; };
  9707.  
  9708.  
  9709. /***/ },
  9710. /* 19 */
  9711. /*!****************************************************!*\
  9712.   !*** ./src/scripts/jquery-extras/plugins/index.js ***!
  9713.   \****************************************************/
  9714. /***/ function(module, exports, __webpack_require__) {
  9715.  
  9716. 	'use strict';
  9717. 	
  9718. 	__webpack_require__(/*! ./outer-html */ 20);
  9719. 	
  9720. 	__webpack_require__(/*! ./sort */ 21);
  9721.  
  9722. /***/ },
  9723. /* 20 */
  9724. /*!*********************************************************!*\
  9725.   !*** ./src/scripts/jquery-extras/plugins/outer-html.js ***!
  9726.   \*********************************************************/
  9727. /***/ function(module, exports, __webpack_require__) {
  9728.  
  9729. 	'use strict';
  9730. 	
  9731. 	var _interopRequireDefault = __webpack_require__(/*! babel-runtime/helpers/interop-require-default */ 16)['default'];
  9732. 	
  9733. 	var _jquery = __webpack_require__(/*! jquery */ 2);
  9734. 	
  9735. 	var _jquery2 = _interopRequireDefault(_jquery);
  9736. 	
  9737. 	// ----------------------------------------------------------------------------
  9738. 	
  9739. 	_jquery2['default'].fn.extend({
  9740. 	
  9741. 	  outer: function outer() {
  9742. 	    if (this.length > 0 && this[0].nodeName) {
  9743. 	      return this[0].outerHTML;
  9744. 	    }
  9745. 	  }
  9746. 	
  9747. 	});
  9748.  
  9749. /***/ },
  9750. /* 21 */
  9751. /*!***************************************************!*\
  9752.   !*** ./src/scripts/jquery-extras/plugins/sort.js ***!
  9753.   \***************************************************/
  9754. /***/ function(module, exports, __webpack_require__) {
  9755.  
  9756. 	'use strict';
  9757. 	
  9758. 	var _interopRequireDefault = __webpack_require__(/*! babel-runtime/helpers/interop-require-default */ 16)['default'];
  9759. 	
  9760. 	var _jquery = __webpack_require__(/*! jquery */ 2);
  9761. 	
  9762. 	var _jquery2 = _interopRequireDefault(_jquery);
  9763. 	
  9764. 	// ----------------------------------------------------------------------------
  9765. 	
  9766. 	_jquery2['default'].fn.extend({
  9767. 	
  9768. 	  sort: function sort(key) {
  9769. 	    if (typeof key !== 'function') {
  9770. 	      key = function (el) {
  9771. 	        return el[key];
  9772. 	      };
  9773. 	    }
  9774. 	
  9775. 	    return this.each(function () {
  9776. 	      var $container = (0, _jquery2['default'])(this),
  9777. 	          $items = $container.children(),
  9778. 	          items = $items.get();
  9779. 	
  9780. 	      items.sort(function (a, b) {
  9781. 	        var av = key(a),
  9782. 	            bv = key(b);
  9783. 	
  9784. 	        return typeof av === 'number' ? av - bv : av.localeCompare(bv);
  9785. 	      });
  9786. 	
  9787. 	      $container.empty().append(items);
  9788. 	    });
  9789. 	  }
  9790. 	
  9791. 	});
  9792. 	
  9793. 	/*
  9794. 	  'use strict';
  9795.  
  9796. 	  key = typeof key === 'function' ? key : el => el[key]
  9797.  
  9798. 	  let $elem = $(this),
  9799. 	      items = $elem.children().get()
  9800.  
  9801. 	  items.sort((a, b) => {
  9802. 	    let av = key(a),
  9803. 	        bv = key(b)
  9804. 	    return typeof av === 'number' ? av - bv : av.localeCompare(bv)
  9805. 	  })
  9806.  
  9807. 	  $elem
  9808. 	    .empty()
  9809. 	    .append(items)
  9810.  
  9811. 	  return this
  9812. 	}
  9813.  
  9814. 	jQuery.fn.sort = function(key) {
  9815. 	  'use strict';
  9816.  
  9817. 	  key = typeof key === 'function' ? key : function(el) { return el[key] }
  9818.  
  9819. 	  var $elem = $(this),
  9820. 	      items = $elem.children().get()
  9821.  
  9822. 	  items.sort(function(a, b) {
  9823. 	    var av = key(a),
  9824. 	        bv = key(b)
  9825. 	    return typeof av === 'number' ? av - bv : av.localeCompare(bv)
  9826. 	  })
  9827.  
  9828. 	  $elem
  9829. 	    .empty()
  9830. 	    .append(items)
  9831.  
  9832. 	  return this
  9833. 	}
  9834. 	*/
  9835.  
  9836. /***/ },
  9837. /* 22 */
  9838. /*!**********************************************!*\
  9839.   !*** ./src/scripts/web/selector-observer.js ***!
  9840.   \**********************************************/
  9841. /***/ function(module, exports, __webpack_require__) {
  9842.  
  9843. 	/* jshint asi: true, esnext: true */
  9844. 	
  9845. 	'use strict';
  9846. 	
  9847. 	var _classCallCheck = __webpack_require__(/*! babel-runtime/helpers/class-call-check */ 23)['default'];
  9848. 	
  9849. 	var _createClass = __webpack_require__(/*! babel-runtime/helpers/create-class */ 24)['default'];
  9850. 	
  9851. 	var _toConsumableArray = __webpack_require__(/*! babel-runtime/helpers/to-consumable-array */ 27)['default'];
  9852. 	
  9853. 	var _Object$assign = __webpack_require__(/*! babel-runtime/core-js/object/assign */ 3)['default'];
  9854. 	
  9855. 	var _Array$from = __webpack_require__(/*! babel-runtime/core-js/array/from */ 28)['default'];
  9856. 	
  9857. 	var _interopRequireDefault = __webpack_require__(/*! babel-runtime/helpers/interop-require-default */ 16)['default'];
  9858. 	
  9859. 	Object.defineProperty(exports, '__esModule', {
  9860. 	  value: true
  9861. 	});
  9862. 	
  9863. 	var _nodeSet = __webpack_require__(/*! ./node-set */ 59);
  9864. 	
  9865. 	var _nodeSet2 = _interopRequireDefault(_nodeSet);
  9866. 	
  9867. 	var _funcDebounce = __webpack_require__(/*! ../func/debounce */ 89);
  9868. 	
  9869. 	var _funcDebounce2 = _interopRequireDefault(_funcDebounce);
  9870. 	
  9871. 	// ----------------------------------------------------------------------------
  9872. 	
  9873. 	var NodeAddedChange = function NodeAddedChange(node) {
  9874. 	  _classCallCheck(this, NodeAddedChange);
  9875. 	
  9876. 	  this.node = node;
  9877. 	}
  9878. 	
  9879. 	// ----------------------------------------------------------------------------
  9880. 	
  9881. 	;
  9882. 	
  9883. 	var SelectorObserver = (function () {
  9884. 	  function SelectorObserver(selector, onAdded, onRemoved, onTextChanged, onAttributeChanged) {
  9885. 	    var _this = this;
  9886. 	
  9887. 	    _classCallCheck(this, SelectorObserver);
  9888. 	
  9889. 	    _Object$assign(this, {
  9890. 	      targets: [document.body],
  9891. 	      selector: '.',
  9892. 	      filterMovedElements: true,
  9893. 	      applyToExisting: true,
  9894. 	      selfOnly: false,
  9895. 	      childrenOnly: false,
  9896. 	      singleCallback: false,
  9897. 	      debug: false
  9898. 	    }, typeof selector === 'object' ? selector : { selector: selector, onAdded: onAdded, onRemoved: onRemoved, onTextChanged: onTextChanged, onAttributeChanged: onAttributeChanged });
  9899. 	
  9900. 	    this.targets = this._expandTargets(this.targets);
  9901. 	
  9902. 	    if (this.selector === '.') {
  9903. 	      this.selfOnly = true;
  9904. 	    } else if (this.selector.match(/^>\s*/)) {
  9905. 	      this.childrenOnly = true;
  9906. 	      this.selector = this.selector.replace(/^>\s*/, '');
  9907. 	    }
  9908. 	
  9909. 	    if (this.debug) {
  9910. 	      console.info(this.toString());
  9911. 	    }
  9912. 	
  9913. 	    this.addedNodes = new _nodeSet2['default']();
  9914. 	    this.removedNodes = new _nodeSet2['default']();
  9915. 	    this.textChangedNodes = [];
  9916. 	    this.attrChangedNodes = [];
  9917. 	
  9918. 	    this.observer = new MutationObserver(function (mutations) {
  9919. 	      mutations.forEach(function (mutation) {
  9920. 	        if (_this.debug) {
  9921. 	          console.dir(mutation);
  9922. 	        }
  9923. 	
  9924. 	        if (mutation.type === 'childList') {
  9925. 	          _Array$from(mutation.addedNodes).forEach(function (node) {
  9926. 	            if (node.nodeType === Document.TEXT_NODE) {
  9927. 	              if (_this._matches(mutation.target)) {
  9928. 	                _this.textChangedNodes.push({
  9929. 	                  node: mutation.target,
  9930. 	                  oldValue: '',
  9931. 	                  value: node.textContent
  9932. 	                });
  9933. 	              } else {
  9934. 	                _this.addedNodes.add(_this._findInclusive(node));
  9935. 	              }
  9936. 	            }
  9937. 	          });
  9938. 	
  9939. 	          _Array$from(mutation.removedNodes).forEach(function (node) {
  9940. 	            _this.removedNodes.add(_this._findInclusive(node));
  9941. 	          });
  9942. 	        } else if (_this._matches(mutation.target)) {
  9943. 	          if (mutation.type === 'characterData' && _this.onTextChanged) {
  9944. 	            _this.textChangedNodes.push({
  9945. 	              node: mutation.target,
  9946. 	              oldValue: mutation.oldValue,
  9947. 	              value: mutation.target.textContent
  9948. 	            });
  9949. 	          } else if (mutation.type === 'attributes' && _this.onAttributeChanged) {
  9950. 	            _this.attrChangedNodes.push({
  9951. 	              node: mutation.target,
  9952. 	              attribute: mutation.attributeName,
  9953. 	              namespace: mutation.attributeNamespace,
  9954. 	              oldValue: mutation.oldValue,
  9955. 	              value: mutation.target.getAttribute(mutation.attributeName)
  9956. 	            });
  9957. 	          }
  9958. 	        }
  9959. 	      });
  9960. 	
  9961. 	      _this.handle();
  9962. 	    });
  9963. 	
  9964. 	    if (this.applyToExisting) {
  9965. 	      var matchingNodes = this._getMatchingNodes();
  9966. 	
  9967. 	      if (this.onAdded) {
  9968. 	        this._apply(matchingNodes, this.onAdded);
  9969. 	      }
  9970. 	      if (this.onTextChanged) {
  9971. 	        this._apply(matchingNodes.map(function (node) {
  9972. 	          return {
  9973. 	            node: node,
  9974. 	            oldValue: '',
  9975. 	            value: node.textContent
  9976. 	          };
  9977. 	        }), this.onTextChanged);
  9978. 	      }
  9979. 	    }
  9980. 	
  9981. 	    this.observe();
  9982. 	  }
  9983. 	
  9984. 	  _createClass(SelectorObserver, [{
  9985. 	    key: 'toString',
  9986. 	    value: function toString() {
  9987. 	      var _this2 = this;
  9988. 	
  9989. 	      var al = function al(attrs) {
  9990. 	        return attrs.split(' ').filter(function (a) {
  9991. 	          return !!_this2[a];
  9992. 	        }).join('+');
  9993. 	      };
  9994. 	
  9995. 	      return 'SelectorObserver(selector: "' + this.selector + '", targets: ' + [].concat(_toConsumableArray(this.targets)).join(',') + ',\nhandlers: ' + al('onAdded onRemoved onTextChanged onAttributeChanged onMoved') + ',\noptions: ' + al('filterMovedElements applyToExisting selfOnly childrenOnly singleCallback debug') + ')';
  9996. 	    }
  9997. 	  }, {
  9998. 	    key: 'observe',
  9999. 	    value: function observe() {
  10000. 	      var _this3 = this;
  10001. 	
  10002. 	      this.targets.forEach(function (target) {
  10003. 	        _this3.observer.observe(target, {
  10004. 	          childList: _this3.onAdded || _this3.onRemoved,
  10005. 	          subtree: true, // this.onAdded || this.onRemoved,
  10006. 	          attributes: _this3.onAttributeChanged,
  10007. 	          attributeOldValue: _this3.onAttributeChanged,
  10008. 	          characterData: _this3.onTextChanged,
  10009. 	          characterDataOldValue: _this3.onTextChanged
  10010. 	        });
  10011. 	      });
  10012. 	    }
  10013. 	  }, {
  10014. 	    key: 'disconnect',
  10015. 	    value: function disconnect() {
  10016. 	      this.observer.disconnect();
  10017. 	    }
  10018. 	  }, {
  10019. 	    key: 'handle',
  10020. 	    value: function handle() {
  10021. 	      var matchedElements = this._getMatchingNodes();
  10022. 	
  10023. 	      if (this.debug) {
  10024. 	        console.group('SelectorObserver.handle()');
  10025. 	        console.info('matchedElements:', [].concat(_toConsumableArray(matchedElements)));
  10026. 	        console.info('addedNodes:', [].concat(_toConsumableArray(this.addedNodes)));
  10027. 	        console.info('removedNodes:', [].concat(_toConsumableArray(this.removedNodes)));
  10028. 	        console.info('textChangedNodes:', this.textChangedNodes);
  10029. 	        console.info('attributeChangedNodes:', this.attrChangedNodes);
  10030. 	        console.groupEnd();
  10031. 	      }
  10032. 	
  10033. 	      if (this.filterMovedElements) {
  10034. 	        var moved = this.addedNodes.intersection(this.removedNodes);
  10035. 	
  10036. 	        if (moved.length) {
  10037. 	          this.addedNodes.remove(moved);
  10038. 	          this.removedNodes.remove(moved);
  10039. 	
  10040. 	          this._apply(matchedElements.intersection(moved), this.onMoved);
  10041. 	        }
  10042. 	      }
  10043. 	
  10044. 	      this._apply(matchedElements.intersection(this.addedNodes), this.onAdded);
  10045. 	      this._apply(matchedElements.intersection(this.removedNodes), this.onRemoved);
  10046. 	
  10047. 	      function intersect(items) {
  10048. 	        return items.filter(function (item) {
  10049. 	          return matchedElements.has(item.node);
  10050. 	        });
  10051. 	      }
  10052. 	
  10053. 	      this._apply(intersect(this.textChangedNodes), this.onTextChanged);
  10054. 	      this._apply(intersect(this.attrChangedNodes), this.onAttributeChanged);
  10055. 	
  10056. 	      this.addedNodes.take();
  10057. 	      this.removedNodes.take();
  10058. 	      this.textChangedNodes = [];
  10059. 	      this.attrChangedNodes = [];
  10060. 	    }
  10061. 	  }, {
  10062. 	    key: '_findInclusive',
  10063. 	    value: function _findInclusive(node) {
  10064. 	      var res = new _nodeSet2['default']();
  10065. 	
  10066. 	      if (node.nodeType === Document.ELEMENT_NODE) {
  10067. 	        if (this._matches(node)) {
  10068. 	          res.add(node);
  10069. 	        }
  10070. 	
  10071. 	        res.add(node.querySelectorAll(this.selector));
  10072. 	      }
  10073. 	
  10074. 	      return res;
  10075. 	    }
  10076. 	  }, {
  10077. 	    key: '_matches',
  10078. 	    value: function _matches(node) {
  10079. 	      return node.matches(this.selector);
  10080. 	    }
  10081. 	  }, {
  10082. 	    key: '_apply',
  10083. 	    value: function _apply(nodes, func) {
  10084. 	      if (typeof func !== 'function') {
  10085. 	        return;
  10086. 	      }
  10087. 	
  10088. 	      if (this.singleCallback) {
  10089. 	        func(nodes);
  10090. 	      } else {
  10091. 	        nodes.forEach(function (node) {
  10092. 	          func.call(typeof node === 'object' ? node.node : node, node);
  10093. 	        });
  10094. 	      }
  10095. 	    }
  10096. 	  }, {
  10097. 	    key: '_expandTargets',
  10098. 	    value: function _expandTargets(targets) {
  10099. 	      var res = new _nodeSet2['default']();
  10100. 	
  10101. 	      if (typeof targets === 'string') {
  10102. 	        res.add(document.querySelectorAll(targets));
  10103. 	      } else if (targets instanceof NodeList) {
  10104. 	        res.add(targets);
  10105. 	      } else {
  10106. 	        targets.forEach(function (target) {
  10107. 	          if (typeof target === 'string') {
  10108. 	            res.add(document.querySelectorAll(target));
  10109. 	          } else {
  10110. 	            res.add(target);
  10111. 	          }
  10112. 	        });
  10113. 	      }
  10114. 	
  10115. 	      return res;
  10116. 	    }
  10117. 	  }, {
  10118. 	    key: '_getMatchingNodes',
  10119. 	    value: function _getMatchingNodes() {
  10120. 	      var _this4 = this;
  10121. 	
  10122. 	      var nodes = new _nodeSet2['default']();
  10123. 	
  10124. 	      this.targets.forEach(function (target) {
  10125. 	        if (_this4._matches(target)) {
  10126. 	          nodes.add(target);
  10127. 	        }
  10128. 	
  10129. 	        if (!_this4.selfOnly) {
  10130. 	          if (_this4.childrenOnly) {
  10131. 	            nodes.add(_Array$from(target.children).filter(function (n) {
  10132. 	              return n.matches(_this4.selector);
  10133. 	            }));
  10134. 	          } else {
  10135. 	            nodes.add(target.querySelectorAll(_this4.selector));
  10136. 	          }
  10137. 	        }
  10138. 	      });
  10139. 	
  10140. 	      return nodes;
  10141. 	    }
  10142. 	  }]);
  10143. 	
  10144. 	  return SelectorObserver;
  10145. 	})();
  10146. 	
  10147. 	exports['default'] = SelectorObserver;
  10148. 	
  10149. 	SelectorObserver.prototype.handle = (0, _funcDebounce2['default'])(SelectorObserver.prototype.handle, 250);
  10150. 	
  10151. 	// ----------------------------------------------------------------------------
  10152. 	
  10153. 	if (typeof HTMLDocument !== 'undefined') {
  10154. 	  HTMLDocument.prototype.observe = function (selector, onAdded, onRemoved) {
  10155. 	    var options = typeof selector === 'object' ? selector : {
  10156. 	      selector: selector,
  10157. 	      onAdded: onAdded,
  10158. 	      onRemoved: onRemoved
  10159. 	    };
  10160. 	
  10161. 	    return new SelectorObserver(options);
  10162. 	  };
  10163. 	}
  10164. 	
  10165. 	if (typeof HTMLElement !== 'undefined') {
  10166. 	  HTMLElement.prototype.observe = function (selector, onAdded, onRemoved) {
  10167. 	    var options = typeof selector === 'object' ? selector : {
  10168. 	      selector: selector,
  10169. 	      onAdded: onAdded,
  10170. 	      onRemoved: onRemoved
  10171. 	    };
  10172. 	
  10173. 	    _Object$assign(options, {
  10174. 	      targets: [this]
  10175. 	    });
  10176. 	
  10177. 	    return new SelectorObserver(options);
  10178. 	  };
  10179. 	}
  10180. 	module.exports = exports['default'];
  10181.  
  10182. /***/ },
  10183. /* 23 */
  10184. /*!*****************************************************!*\
  10185.   !*** ./~/babel-runtime/helpers/class-call-check.js ***!
  10186.   \*****************************************************/
  10187. /***/ function(module, exports) {
  10188.  
  10189. 	"use strict";
  10190. 	
  10191. 	exports["default"] = function (instance, Constructor) {
  10192. 	  if (!(instance instanceof Constructor)) {
  10193. 	    throw new TypeError("Cannot call a class as a function");
  10194. 	  }
  10195. 	};
  10196. 	
  10197. 	exports.__esModule = true;
  10198.  
  10199. /***/ },
  10200. /* 24 */
  10201. /*!*************************************************!*\
  10202.   !*** ./~/babel-runtime/helpers/create-class.js ***!
  10203.   \*************************************************/
  10204. /***/ function(module, exports, __webpack_require__) {
  10205.  
  10206. 	"use strict";
  10207. 	
  10208. 	var _Object$defineProperty = __webpack_require__(/*! babel-runtime/core-js/object/define-property */ 25)["default"];
  10209. 	
  10210. 	exports["default"] = (function () {
  10211. 	  function defineProperties(target, props) {
  10212. 	    for (var i = 0; i < props.length; i++) {
  10213. 	      var descriptor = props[i];
  10214. 	      descriptor.enumerable = descriptor.enumerable || false;
  10215. 	      descriptor.configurable = true;
  10216. 	      if ("value" in descriptor) descriptor.writable = true;
  10217. 	
  10218. 	      _Object$defineProperty(target, descriptor.key, descriptor);
  10219. 	    }
  10220. 	  }
  10221. 	
  10222. 	  return function (Constructor, protoProps, staticProps) {
  10223. 	    if (protoProps) defineProperties(Constructor.prototype, protoProps);
  10224. 	    if (staticProps) defineProperties(Constructor, staticProps);
  10225. 	    return Constructor;
  10226. 	  };
  10227. 	})();
  10228. 	
  10229. 	exports.__esModule = true;
  10230.  
  10231. /***/ },
  10232. /* 25 */
  10233. /*!***********************************************************!*\
  10234.   !*** ./~/babel-runtime/core-js/object/define-property.js ***!
  10235.   \***********************************************************/
  10236. /***/ function(module, exports, __webpack_require__) {
  10237.  
  10238. 	module.exports = { "default": __webpack_require__(/*! core-js/library/fn/object/define-property */ 26), __esModule: true };
  10239.  
  10240. /***/ },
  10241. /* 26 */
  10242. /*!************************************************************************!*\
  10243.   !*** ./~/babel-runtime/~/core-js/library/fn/object/define-property.js ***!
  10244.   \************************************************************************/
  10245. /***/ function(module, exports, __webpack_require__) {
  10246.  
  10247. 	var $ = __webpack_require__(/*! ../../modules/$ */ 15);
  10248. 	module.exports = function defineProperty(it, key, desc){
  10249. 	  return $.setDesc(it, key, desc);
  10250. 	};
  10251.  
  10252. /***/ },
  10253. /* 27 */
  10254. /*!********************************************************!*\
  10255.   !*** ./~/babel-runtime/helpers/to-consumable-array.js ***!
  10256.   \********************************************************/
  10257. /***/ function(module, exports, __webpack_require__) {
  10258.  
  10259. 	"use strict";
  10260. 	
  10261. 	var _Array$from = __webpack_require__(/*! babel-runtime/core-js/array/from */ 28)["default"];
  10262. 	
  10263. 	exports["default"] = function (arr) {
  10264. 	  if (Array.isArray(arr)) {
  10265. 	    for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) arr2[i] = arr[i];
  10266. 	
  10267. 	    return arr2;
  10268. 	  } else {
  10269. 	    return _Array$from(arr);
  10270. 	  }
  10271. 	};
  10272. 	
  10273. 	exports.__esModule = true;
  10274.  
  10275. /***/ },
  10276. /* 28 */
  10277. /*!***********************************************!*\
  10278.   !*** ./~/babel-runtime/core-js/array/from.js ***!
  10279.   \***********************************************/
  10280. /***/ function(module, exports, __webpack_require__) {
  10281.  
  10282. 	module.exports = { "default": __webpack_require__(/*! core-js/library/fn/array/from */ 29), __esModule: true };
  10283.  
  10284. /***/ },
  10285. /* 29 */
  10286. /*!************************************************************!*\
  10287.   !*** ./~/babel-runtime/~/core-js/library/fn/array/from.js ***!
  10288.   \************************************************************/
  10289. /***/ function(module, exports, __webpack_require__) {
  10290.  
  10291. 	__webpack_require__(/*! ../../modules/es6.string.iterator */ 30);
  10292. 	__webpack_require__(/*! ../../modules/es6.array.from */ 48);
  10293. 	module.exports = __webpack_require__(/*! ../../modules/$.core */ 8).Array.from;
  10294.  
  10295. /***/ },
  10296. /* 30 */
  10297. /*!**************************************************************************!*\
  10298.   !*** ./~/babel-runtime/~/core-js/library/modules/es6.string.iterator.js ***!
  10299.   \**************************************************************************/
  10300. /***/ function(module, exports, __webpack_require__) {
  10301.  
  10302. 	'use strict';
  10303. 	var $at  = __webpack_require__(/*! ./$.string-at */ 31)(true);
  10304. 	
  10305. 	// 21.1.3.27 String.prototype[@@iterator]()
  10306. 	__webpack_require__(/*! ./$.iter-define */ 33)(String, 'String', function(iterated){
  10307. 	  this._t = String(iterated); // target
  10308. 	  this._i = 0;                // next index
  10309. 	// 21.1.5.2.1 %StringIteratorPrototype%.next()
  10310. 	}, function(){
  10311. 	  var O     = this._t
  10312. 	    , index = this._i
  10313. 	    , point;
  10314. 	  if(index >= O.length)return {value: undefined, done: true};
  10315. 	  point = $at(O, index);
  10316. 	  this._i += point.length;
  10317. 	  return {value: point, done: false};
  10318. 	});
  10319.  
  10320. /***/ },
  10321. /* 31 */
  10322. /*!******************************************************************!*\
  10323.   !*** ./~/babel-runtime/~/core-js/library/modules/$.string-at.js ***!
  10324.   \******************************************************************/
  10325. /***/ function(module, exports, __webpack_require__) {
  10326.  
  10327. 	// true  -> String#at
  10328. 	// false -> String#codePointAt
  10329. 	var toInteger = __webpack_require__(/*! ./$.to-integer */ 32)
  10330. 	  , defined   = __webpack_require__(/*! ./$.defined */ 11);
  10331. 	module.exports = function(TO_STRING){
  10332. 	  return function(that, pos){
  10333. 	    var s = String(defined(that))
  10334. 	      , i = toInteger(pos)
  10335. 	      , l = s.length
  10336. 	      , a, b;
  10337. 	    if(i < 0 || i >= l)return TO_STRING ? '' : undefined;
  10338. 	    a = s.charCodeAt(i);
  10339. 	    return a < 0xd800 || a > 0xdbff || i + 1 === l
  10340. 	      || (b = s.charCodeAt(i + 1)) < 0xdc00 || b > 0xdfff
  10341. 	        ? TO_STRING ? s.charAt(i) : a
  10342. 	        : TO_STRING ? s.slice(i, i + 2) : (a - 0xd800 << 10) + (b - 0xdc00) + 0x10000;
  10343. 	  };
  10344. 	};
  10345.  
  10346. /***/ },
  10347. /* 32 */
  10348. /*!*******************************************************************!*\
  10349.   !*** ./~/babel-runtime/~/core-js/library/modules/$.to-integer.js ***!
  10350.   \*******************************************************************/
  10351. /***/ function(module, exports) {
  10352.  
  10353. 	// 7.1.4 ToInteger
  10354. 	var ceil  = Math.ceil
  10355. 	  , floor = Math.floor;
  10356. 	module.exports = function(it){
  10357. 	  return isNaN(it = +it) ? 0 : (it > 0 ? floor : ceil)(it);
  10358. 	};
  10359.  
  10360. /***/ },
  10361. /* 33 */
  10362. /*!********************************************************************!*\
  10363.   !*** ./~/babel-runtime/~/core-js/library/modules/$.iter-define.js ***!
  10364.   \********************************************************************/
  10365. /***/ function(module, exports, __webpack_require__) {
  10366.  
  10367. 	'use strict';
  10368. 	var LIBRARY         = __webpack_require__(/*! ./$.library */ 34)
  10369. 	  , $def            = __webpack_require__(/*! ./$.def */ 6)
  10370. 	  , $redef          = __webpack_require__(/*! ./$.redef */ 35)
  10371. 	  , hide            = __webpack_require__(/*! ./$.hide */ 36)
  10372. 	  , has             = __webpack_require__(/*! ./$.has */ 40)
  10373. 	  , SYMBOL_ITERATOR = __webpack_require__(/*! ./$.wks */ 41)('iterator')
  10374. 	  , Iterators       = __webpack_require__(/*! ./$.iterators */ 44)
  10375. 	  , FF_ITERATOR     = '@@iterator'
  10376. 	  , KEYS            = 'keys'
  10377. 	  , VALUES          = 'values';
  10378. 	var returnThis = function(){ return this; };
  10379. 	module.exports = function(Base, NAME, Constructor, next, DEFAULT, IS_SET, FORCE){
  10380. 	  __webpack_require__(/*! ./$.iter-create */ 45)(Constructor, NAME, next);
  10381. 	  var createMethod = function(kind){
  10382. 	    switch(kind){
  10383. 	      case KEYS: return function keys(){ return new Constructor(this, kind); };
  10384. 	      case VALUES: return function values(){ return new Constructor(this, kind); };
  10385. 	    } return function entries(){ return new Constructor(this, kind); };
  10386. 	  };
  10387. 	  var TAG      = NAME + ' Iterator'
  10388. 	    , proto    = Base.prototype
  10389. 	    , _native  = proto[SYMBOL_ITERATOR] || proto[FF_ITERATOR] || DEFAULT && proto[DEFAULT]
  10390. 	    , _default = _native || createMethod(DEFAULT)
  10391. 	    , methods, key;
  10392. 	  // Fix native
  10393. 	  if(_native){
  10394. 	    var IteratorPrototype = __webpack_require__(/*! ./$ */ 15).getProto(_default.call(new Base));
  10395. 	    // Set @@toStringTag to native iterators
  10396. 	    __webpack_require__(/*! ./$.tag */ 46)(IteratorPrototype, TAG, true);
  10397. 	    // FF fix
  10398. 	    if(!LIBRARY && has(proto, FF_ITERATOR))hide(IteratorPrototype, SYMBOL_ITERATOR, returnThis);
  10399. 	  }
  10400. 	  // Define iterator
  10401. 	  if(!LIBRARY || FORCE)hide(proto, SYMBOL_ITERATOR, _default);
  10402. 	  // Plug for library
  10403. 	  Iterators[NAME] = _default;
  10404. 	  Iterators[TAG]  = returnThis;
  10405. 	  if(DEFAULT){
  10406. 	    methods = {
  10407. 	      keys:    IS_SET            ? _default : createMethod(KEYS),
  10408. 	      values:  DEFAULT == VALUES ? _default : createMethod(VALUES),
  10409. 	      entries: DEFAULT != VALUES ? _default : createMethod('entries')
  10410. 	    };
  10411. 	    if(FORCE)for(key in methods){
  10412. 	      if(!(key in proto))$redef(proto, key, methods[key]);
  10413. 	    } else $def($def.P + $def.F * __webpack_require__(/*! ./$.iter-buggy */ 47), NAME, methods);
  10414. 	  }
  10415. 	};
  10416.  
  10417. /***/ },
  10418. /* 34 */
  10419. /*!****************************************************************!*\
  10420.   !*** ./~/babel-runtime/~/core-js/library/modules/$.library.js ***!
  10421.   \****************************************************************/
  10422. /***/ function(module, exports) {
  10423.  
  10424. 	module.exports = true;
  10425.  
  10426. /***/ },
  10427. /* 35 */
  10428. /*!**************************************************************!*\
  10429.   !*** ./~/babel-runtime/~/core-js/library/modules/$.redef.js ***!
  10430.   \**************************************************************/
  10431. /***/ function(module, exports, __webpack_require__) {
  10432.  
  10433. 	module.exports = __webpack_require__(/*! ./$.hide */ 36);
  10434.  
  10435. /***/ },
  10436. /* 36 */
  10437. /*!*************************************************************!*\
  10438.   !*** ./~/babel-runtime/~/core-js/library/modules/$.hide.js ***!
  10439.   \*************************************************************/
  10440. /***/ function(module, exports, __webpack_require__) {
  10441.  
  10442. 	var $          = __webpack_require__(/*! ./$ */ 15)
  10443. 	  , createDesc = __webpack_require__(/*! ./$.property-desc */ 37);
  10444. 	module.exports = __webpack_require__(/*! ./$.support-desc */ 38) ? function(object, key, value){
  10445. 	  return $.setDesc(object, key, createDesc(1, value));
  10446. 	} : function(object, key, value){
  10447. 	  object[key] = value;
  10448. 	  return object;
  10449. 	};
  10450.  
  10451. /***/ },
  10452. /* 37 */
  10453. /*!**********************************************************************!*\
  10454.   !*** ./~/babel-runtime/~/core-js/library/modules/$.property-desc.js ***!
  10455.   \**********************************************************************/
  10456. /***/ function(module, exports) {
  10457.  
  10458. 	module.exports = function(bitmap, value){
  10459. 	  return {
  10460. 	    enumerable  : !(bitmap & 1),
  10461. 	    configurable: !(bitmap & 2),
  10462. 	    writable    : !(bitmap & 4),
  10463. 	    value       : value
  10464. 	  };
  10465. 	};
  10466.  
  10467. /***/ },
  10468. /* 38 */
  10469. /*!*********************************************************************!*\
  10470.   !*** ./~/babel-runtime/~/core-js/library/modules/$.support-desc.js ***!
  10471.   \*********************************************************************/
  10472. /***/ function(module, exports, __webpack_require__) {
  10473.  
  10474. 	// Thank's IE8 for his funny defineProperty
  10475. 	module.exports = !__webpack_require__(/*! ./$.fails */ 39)(function(){
  10476. 	  return Object.defineProperty({}, 'a', {get: function(){ return 7; }}).a != 7;
  10477. 	});
  10478.  
  10479. /***/ },
  10480. /* 39 */
  10481. /*!**************************************************************!*\
  10482.   !*** ./~/babel-runtime/~/core-js/library/modules/$.fails.js ***!
  10483.   \**************************************************************/
  10484. /***/ function(module, exports) {
  10485.  
  10486. 	module.exports = function(exec){
  10487. 	  try {
  10488. 	    return !!exec();
  10489. 	  } catch(e){
  10490. 	    return true;
  10491. 	  }
  10492. 	};
  10493.  
  10494. /***/ },
  10495. /* 40 */
  10496. /*!************************************************************!*\
  10497.   !*** ./~/babel-runtime/~/core-js/library/modules/$.has.js ***!
  10498.   \************************************************************/
  10499. /***/ function(module, exports) {
  10500.  
  10501. 	var hasOwnProperty = {}.hasOwnProperty;
  10502. 	module.exports = function(it, key){
  10503. 	  return hasOwnProperty.call(it, key);
  10504. 	};
  10505.  
  10506. /***/ },
  10507. /* 41 */
  10508. /*!************************************************************!*\
  10509.   !*** ./~/babel-runtime/~/core-js/library/modules/$.wks.js ***!
  10510.   \************************************************************/
  10511. /***/ function(module, exports, __webpack_require__) {
  10512.  
  10513. 	var store  = __webpack_require__(/*! ./$.shared */ 42)('wks')
  10514. 	  , Symbol = __webpack_require__(/*! ./$.global */ 7).Symbol;
  10515. 	module.exports = function(name){
  10516. 	  return store[name] || (store[name] =
  10517. 	    Symbol && Symbol[name] || (Symbol || __webpack_require__(/*! ./$.uid */ 43))('Symbol.' + name));
  10518. 	};
  10519.  
  10520. /***/ },
  10521. /* 42 */
  10522. /*!***************************************************************!*\
  10523.   !*** ./~/babel-runtime/~/core-js/library/modules/$.shared.js ***!
  10524.   \***************************************************************/
  10525. /***/ function(module, exports, __webpack_require__) {
  10526.  
  10527. 	var global = __webpack_require__(/*! ./$.global */ 7)
  10528. 	  , SHARED = '__core-js_shared__'
  10529. 	  , store  = global[SHARED] || (global[SHARED] = {});
  10530. 	module.exports = function(key){
  10531. 	  return store[key] || (store[key] = {});
  10532. 	};
  10533.  
  10534. /***/ },
  10535. /* 43 */
  10536. /*!************************************************************!*\
  10537.   !*** ./~/babel-runtime/~/core-js/library/modules/$.uid.js ***!
  10538.   \************************************************************/
  10539. /***/ function(module, exports) {
  10540.  
  10541. 	var id = 0
  10542. 	  , px = Math.random();
  10543. 	module.exports = function(key){
  10544. 	  return 'Symbol('.concat(key === undefined ? '' : key, ')_', (++id + px).toString(36));
  10545. 	};
  10546.  
  10547. /***/ },
  10548. /* 44 */
  10549. /*!******************************************************************!*\
  10550.   !*** ./~/babel-runtime/~/core-js/library/modules/$.iterators.js ***!
  10551.   \******************************************************************/
  10552. /***/ function(module, exports) {
  10553.  
  10554. 	module.exports = {};
  10555.  
  10556. /***/ },
  10557. /* 45 */
  10558. /*!********************************************************************!*\
  10559.   !*** ./~/babel-runtime/~/core-js/library/modules/$.iter-create.js ***!
  10560.   \********************************************************************/
  10561. /***/ function(module, exports, __webpack_require__) {
  10562.  
  10563. 	'use strict';
  10564. 	var $ = __webpack_require__(/*! ./$ */ 15)
  10565. 	  , IteratorPrototype = {};
  10566. 	
  10567. 	// 25.1.2.1.1 %IteratorPrototype%[@@iterator]()
  10568. 	__webpack_require__(/*! ./$.hide */ 36)(IteratorPrototype, __webpack_require__(/*! ./$.wks */ 41)('iterator'), function(){ return this; });
  10569. 	
  10570. 	module.exports = function(Constructor, NAME, next){
  10571. 	  Constructor.prototype = $.create(IteratorPrototype, {next: __webpack_require__(/*! ./$.property-desc */ 37)(1,next)});
  10572. 	  __webpack_require__(/*! ./$.tag */ 46)(Constructor, NAME + ' Iterator');
  10573. 	};
  10574.  
  10575. /***/ },
  10576. /* 46 */
  10577. /*!************************************************************!*\
  10578.   !*** ./~/babel-runtime/~/core-js/library/modules/$.tag.js ***!
  10579.   \************************************************************/
  10580. /***/ function(module, exports, __webpack_require__) {
  10581.  
  10582. 	var has  = __webpack_require__(/*! ./$.has */ 40)
  10583. 	  , hide = __webpack_require__(/*! ./$.hide */ 36)
  10584. 	  , TAG  = __webpack_require__(/*! ./$.wks */ 41)('toStringTag');
  10585. 	
  10586. 	module.exports = function(it, tag, stat){
  10587. 	  if(it && !has(it = stat ? it : it.prototype, TAG))hide(it, TAG, tag);
  10588. 	};
  10589.  
  10590. /***/ },
  10591. /* 47 */
  10592. /*!*******************************************************************!*\
  10593.   !*** ./~/babel-runtime/~/core-js/library/modules/$.iter-buggy.js ***!
  10594.   \*******************************************************************/
  10595. /***/ function(module, exports) {
  10596.  
  10597. 	// Safari has buggy iterators w/o `next`
  10598. 	module.exports = 'keys' in [] && !('next' in [].keys());
  10599.  
  10600. /***/ },
  10601. /* 48 */
  10602. /*!*********************************************************************!*\
  10603.   !*** ./~/babel-runtime/~/core-js/library/modules/es6.array.from.js ***!
  10604.   \*********************************************************************/
  10605. /***/ function(module, exports, __webpack_require__) {
  10606.  
  10607. 	'use strict';
  10608. 	var ctx         = __webpack_require__(/*! ./$.ctx */ 49)
  10609. 	  , $def        = __webpack_require__(/*! ./$.def */ 6)
  10610. 	  , toObject    = __webpack_require__(/*! ./$.to-object */ 10)
  10611. 	  , call        = __webpack_require__(/*! ./$.iter-call */ 51)
  10612. 	  , isArrayIter = __webpack_require__(/*! ./$.is-array-iter */ 54)
  10613. 	  , toLength    = __webpack_require__(/*! ./$.to-length */ 55)
  10614. 	  , getIterFn   = __webpack_require__(/*! ./core.get-iterator-method */ 56);
  10615. 	$def($def.S + $def.F * !__webpack_require__(/*! ./$.iter-detect */ 58)(function(iter){ Array.from(iter); }), 'Array', {
  10616. 	  // 22.1.2.1 Array.from(arrayLike, mapfn = undefined, thisArg = undefined)
  10617. 	  from: function from(arrayLike/*, mapfn = undefined, thisArg = undefined*/){
  10618. 	    var O       = toObject(arrayLike)
  10619. 	      , C       = typeof this == 'function' ? this : Array
  10620. 	      , mapfn   = arguments[1]
  10621. 	      , mapping = mapfn !== undefined
  10622. 	      , index   = 0
  10623. 	      , iterFn  = getIterFn(O)
  10624. 	      , length, result, step, iterator;
  10625. 	    if(mapping)mapfn = ctx(mapfn, arguments[2], 2);
  10626. 	    // if object isn't iterable or it's array with default iterator - use simple case
  10627. 	    if(iterFn != undefined && !(C == Array && isArrayIter(iterFn))){
  10628. 	      for(iterator = iterFn.call(O), result = new C; !(step = iterator.next()).done; index++){
  10629. 	        result[index] = mapping ? call(iterator, mapfn, [step.value, index], true) : step.value;
  10630. 	      }
  10631. 	    } else {
  10632. 	      for(result = new C(length = toLength(O.length)); length > index; index++){
  10633. 	        result[index] = mapping ? mapfn(O[index], index) : O[index];
  10634. 	      }
  10635. 	    }
  10636. 	    result.length = index;
  10637. 	    return result;
  10638. 	  }
  10639. 	});
  10640.  
  10641. /***/ },
  10642. /* 49 */
  10643. /*!************************************************************!*\
  10644.   !*** ./~/babel-runtime/~/core-js/library/modules/$.ctx.js ***!
  10645.   \************************************************************/
  10646. /***/ function(module, exports, __webpack_require__) {
  10647.  
  10648. 	// optional / simple context binding
  10649. 	var aFunction = __webpack_require__(/*! ./$.a-function */ 50);
  10650. 	module.exports = function(fn, that, length){
  10651. 	  aFunction(fn);
  10652. 	  if(that === undefined)return fn;
  10653. 	  switch(length){
  10654. 	    case 1: return function(a){
  10655. 	      return fn.call(that, a);
  10656. 	    };
  10657. 	    case 2: return function(a, b){
  10658. 	      return fn.call(that, a, b);
  10659. 	    };
  10660. 	    case 3: return function(a, b, c){
  10661. 	      return fn.call(that, a, b, c);
  10662. 	    };
  10663. 	  } return function(/* ...args */){
  10664. 	      return fn.apply(that, arguments);
  10665. 	    };
  10666. 	};
  10667.  
  10668. /***/ },
  10669. /* 50 */
  10670. /*!*******************************************************************!*\
  10671.   !*** ./~/babel-runtime/~/core-js/library/modules/$.a-function.js ***!
  10672.   \*******************************************************************/
  10673. /***/ function(module, exports) {
  10674.  
  10675. 	module.exports = function(it){
  10676. 	  if(typeof it != 'function')throw TypeError(it + ' is not a function!');
  10677. 	  return it;
  10678. 	};
  10679.  
  10680. /***/ },
  10681. /* 51 */
  10682. /*!******************************************************************!*\
  10683.   !*** ./~/babel-runtime/~/core-js/library/modules/$.iter-call.js ***!
  10684.   \******************************************************************/
  10685. /***/ function(module, exports, __webpack_require__) {
  10686.  
  10687. 	// call something on iterator step with safe closing on error
  10688. 	var anObject = __webpack_require__(/*! ./$.an-object */ 52);
  10689. 	module.exports = function(iterator, fn, value, entries){
  10690. 	  try {
  10691. 	    return entries ? fn(anObject(value)[0], value[1]) : fn(value);
  10692. 	  // 7.4.6 IteratorClose(iterator, completion)
  10693. 	  } catch(e){
  10694. 	    var ret = iterator['return'];
  10695. 	    if(ret !== undefined)anObject(ret.call(iterator));
  10696. 	    throw e;
  10697. 	  }
  10698. 	};
  10699.  
  10700. /***/ },
  10701. /* 52 */
  10702. /*!******************************************************************!*\
  10703.   !*** ./~/babel-runtime/~/core-js/library/modules/$.an-object.js ***!
  10704.   \******************************************************************/
  10705. /***/ function(module, exports, __webpack_require__) {
  10706.  
  10707. 	var isObject = __webpack_require__(/*! ./$.is-object */ 53);
  10708. 	module.exports = function(it){
  10709. 	  if(!isObject(it))throw TypeError(it + ' is not an object!');
  10710. 	  return it;
  10711. 	};
  10712.  
  10713. /***/ },
  10714. /* 53 */
  10715. /*!******************************************************************!*\
  10716.   !*** ./~/babel-runtime/~/core-js/library/modules/$.is-object.js ***!
  10717.   \******************************************************************/
  10718. /***/ function(module, exports) {
  10719.  
  10720. 	// http://jsperf.com/core-js-isobject
  10721. 	module.exports = function(it){
  10722. 	  return it !== null && (typeof it == 'object' || typeof it == 'function');
  10723. 	};
  10724.  
  10725. /***/ },
  10726. /* 54 */
  10727. /*!**********************************************************************!*\
  10728.   !*** ./~/babel-runtime/~/core-js/library/modules/$.is-array-iter.js ***!
  10729.   \**********************************************************************/
  10730. /***/ function(module, exports, __webpack_require__) {
  10731.  
  10732. 	// check on default Array iterator
  10733. 	var Iterators = __webpack_require__(/*! ./$.iterators */ 44)
  10734. 	  , ITERATOR  = __webpack_require__(/*! ./$.wks */ 41)('iterator');
  10735. 	module.exports = function(it){
  10736. 	  return (Iterators.Array || Array.prototype[ITERATOR]) === it;
  10737. 	};
  10738.  
  10739. /***/ },
  10740. /* 55 */
  10741. /*!******************************************************************!*\
  10742.   !*** ./~/babel-runtime/~/core-js/library/modules/$.to-length.js ***!
  10743.   \******************************************************************/
  10744. /***/ function(module, exports, __webpack_require__) {
  10745.  
  10746. 	// 7.1.15 ToLength
  10747. 	var toInteger = __webpack_require__(/*! ./$.to-integer */ 32)
  10748. 	  , min       = Math.min;
  10749. 	module.exports = function(it){
  10750. 	  return it > 0 ? min(toInteger(it), 0x1fffffffffffff) : 0; // pow(2, 53) - 1 == 9007199254740991
  10751. 	};
  10752.  
  10753. /***/ },
  10754. /* 56 */
  10755. /*!*******************************************************************************!*\
  10756.   !*** ./~/babel-runtime/~/core-js/library/modules/core.get-iterator-method.js ***!
  10757.   \*******************************************************************************/
  10758. /***/ function(module, exports, __webpack_require__) {
  10759.  
  10760. 	var classof   = __webpack_require__(/*! ./$.classof */ 57)
  10761. 	  , ITERATOR  = __webpack_require__(/*! ./$.wks */ 41)('iterator')
  10762. 	  , Iterators = __webpack_require__(/*! ./$.iterators */ 44);
  10763. 	module.exports = __webpack_require__(/*! ./$.core */ 8).getIteratorMethod = function(it){
  10764. 	  if(it != undefined)return it[ITERATOR] || it['@@iterator'] || Iterators[classof(it)];
  10765. 	};
  10766.  
  10767. /***/ },
  10768. /* 57 */
  10769. /*!****************************************************************!*\
  10770.   !*** ./~/babel-runtime/~/core-js/library/modules/$.classof.js ***!
  10771.   \****************************************************************/
  10772. /***/ function(module, exports, __webpack_require__) {
  10773.  
  10774. 	// getting tag from 19.1.3.6 Object.prototype.toString()
  10775. 	var cof = __webpack_require__(/*! ./$.cof */ 13)
  10776. 	  , TAG = __webpack_require__(/*! ./$.wks */ 41)('toStringTag')
  10777. 	  // ES3 wrong here
  10778. 	  , ARG = cof(function(){ return arguments; }()) == 'Arguments';
  10779. 	
  10780. 	module.exports = function(it){
  10781. 	  var O, T, B;
  10782. 	  return it === undefined ? 'Undefined' : it === null ? 'Null'
  10783. 	    // @@toStringTag case
  10784. 	    : typeof (T = (O = Object(it))[TAG]) == 'string' ? T
  10785. 	    // builtinTag case
  10786. 	    : ARG ? cof(O)
  10787. 	    // ES3 arguments fallback
  10788. 	    : (B = cof(O)) == 'Object' && typeof O.callee == 'function' ? 'Arguments' : B;
  10789. 	};
  10790.  
  10791. /***/ },
  10792. /* 58 */
  10793. /*!********************************************************************!*\
  10794.   !*** ./~/babel-runtime/~/core-js/library/modules/$.iter-detect.js ***!
  10795.   \********************************************************************/
  10796. /***/ function(module, exports, __webpack_require__) {
  10797.  
  10798. 	var SYMBOL_ITERATOR = __webpack_require__(/*! ./$.wks */ 41)('iterator')
  10799. 	  , SAFE_CLOSING    = false;
  10800. 	try {
  10801. 	  var riter = [7][SYMBOL_ITERATOR]();
  10802. 	  riter['return'] = function(){ SAFE_CLOSING = true; };
  10803. 	  Array.from(riter, function(){ throw 2; });
  10804. 	} catch(e){ /* empty */ }
  10805. 	module.exports = function(exec){
  10806. 	  if(!SAFE_CLOSING)return false;
  10807. 	  var safe = false;
  10808. 	  try {
  10809. 	    var arr  = [7]
  10810. 	      , iter = arr[SYMBOL_ITERATOR]();
  10811. 	    iter.next = function(){ safe = true; };
  10812. 	    arr[SYMBOL_ITERATOR] = function(){ return iter; };
  10813. 	    exec(arr);
  10814. 	  } catch(e){ /* empty */ }
  10815. 	  return safe;
  10816. 	};
  10817.  
  10818. /***/ },
  10819. /* 59 */
  10820. /*!*************************************!*\
  10821.   !*** ./src/scripts/web/node-set.js ***!
  10822.   \*************************************/
  10823. /***/ function(module, exports, __webpack_require__) {
  10824.  
  10825. 	
  10826. 	
  10827. 	// ----------------------------------------------------------------------------
  10828. 	
  10829. 	"use strict";
  10830. 	
  10831. 	var _get = __webpack_require__(/*! babel-runtime/helpers/get */ 60)["default"];
  10832. 	
  10833. 	var _inherits = __webpack_require__(/*! babel-runtime/helpers/inherits */ 66)["default"];
  10834. 	
  10835. 	var _createClass = __webpack_require__(/*! babel-runtime/helpers/create-class */ 24)["default"];
  10836. 	
  10837. 	var _classCallCheck = __webpack_require__(/*! babel-runtime/helpers/class-call-check */ 23)["default"];
  10838. 	
  10839. 	var _toConsumableArray = __webpack_require__(/*! babel-runtime/helpers/to-consumable-array */ 27)["default"];
  10840. 	
  10841. 	var _Array$from = __webpack_require__(/*! babel-runtime/core-js/array/from */ 28)["default"];
  10842. 	
  10843. 	var _Set2 = __webpack_require__(/*! babel-runtime/core-js/set */ 73)["default"];
  10844. 	
  10845. 	Object.defineProperty(exports, "__esModule", {
  10846. 	  value: true
  10847. 	});
  10848. 	
  10849. 	var NodeSet = (function (_Set) {
  10850. 	  _inherits(NodeSet, _Set);
  10851. 	
  10852. 	  function NodeSet() {
  10853. 	    _classCallCheck(this, NodeSet);
  10854. 	
  10855. 	    _get(Object.getPrototypeOf(NodeSet.prototype), "constructor", this).call(this);
  10856. 	
  10857. 	    this.add.apply(this, arguments);
  10858. 	  }
  10859. 	
  10860. 	  _createClass(NodeSet, [{
  10861. 	    key: "add",
  10862. 	    value: function add() {
  10863. 	      var _this = this;
  10864. 	
  10865. 	      for (var _len = arguments.length, items = Array(_len), _key = 0; _key < _len; _key++) {
  10866. 	        items[_key] = arguments[_key];
  10867. 	      }
  10868. 	
  10869. 	      items.forEach(function (item) {
  10870. 	        if (Array.isArray(item)) {
  10871. 	          _this.add.apply(_this, _toConsumableArray(item));
  10872. 	        } else if (item instanceof NodeSet) {
  10873. 	          _this.add.apply(_this, _toConsumableArray(item));
  10874. 	        } else if (item instanceof NodeList) {
  10875. 	          _this.add.apply(_this, _toConsumableArray(_Array$from(item)));
  10876. 	        } else {
  10877. 	          _get(Object.getPrototypeOf(NodeSet.prototype), "add", _this).call(_this, item);
  10878. 	        }
  10879. 	      });
  10880. 	
  10881. 	      return this;
  10882. 	    }
  10883. 	  }, {
  10884. 	    key: "remove",
  10885. 	    value: function remove() {
  10886. 	      var _this2 = this;
  10887. 	
  10888. 	      for (var _len2 = arguments.length, items = Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
  10889. 	        items[_key2] = arguments[_key2];
  10890. 	      }
  10891. 	
  10892. 	      items.forEach(function (item) {
  10893. 	        if (Array.isArray(item)) {
  10894. 	          _this2.remove.apply(_this2, _toConsumableArray(item));
  10895. 	        } else if (item instanceof NodeSet) {
  10896. 	          _this2.remove.apply(_this2, _toConsumableArray(item));
  10897. 	        } else if (item instanceof NodeList) {
  10898. 	          _this2.remove.apply(_this2, _toConsumableArray(_Array$from(item)));
  10899. 	        } else {
  10900. 	          _get(Object.getPrototypeOf(NodeSet.prototype), "delete", _this2).call(_this2, item);
  10901. 	        }
  10902. 	      });
  10903. 	
  10904. 	      return this;
  10905. 	    }
  10906. 	  }, {
  10907. 	    key: "intersection",
  10908. 	    value: function intersection(other) {
  10909. 	      var set = Array.isArray(other) ? new NodeSet([].concat(_toConsumableArray(other))) : other;
  10910. 	
  10911. 	      return new NodeSet([].concat(_toConsumableArray(this)).filter(function (v) {
  10912. 	        return set.has(v);
  10913. 	      }));
  10914. 	    }
  10915. 	  }, {
  10916. 	    key: "forEach",
  10917. 	    value: function forEach(func) {
  10918. 	      [].concat(_toConsumableArray(this)).forEach(func);
  10919. 	
  10920. 	      return this;
  10921. 	    }
  10922. 	  }, {
  10923. 	    key: "map",
  10924. 	    value: function map(func) {
  10925. 	      return [].concat(_toConsumableArray(this)).map(func);
  10926. 	    }
  10927. 	  }, {
  10928. 	    key: "take",
  10929. 	    value: function take() {
  10930. 	      var items = [].concat(_toConsumableArray(this));
  10931. 	
  10932. 	      _get(Object.getPrototypeOf(NodeSet.prototype), "clear", this).call(this);
  10933. 	
  10934. 	      return items;
  10935. 	    }
  10936. 	  }, {
  10937. 	    key: "length",
  10938. 	    get: function get() {
  10939. 	      return _get(Object.getPrototypeOf(NodeSet.prototype), "size", this);
  10940. 	    }
  10941. 	  }]);
  10942. 	
  10943. 	  return NodeSet;
  10944. 	})(_Set2);
  10945. 	
  10946. 	exports["default"] = NodeSet;
  10947. 	module.exports = exports["default"];
  10948.  
  10949. /***/ },
  10950. /* 60 */
  10951. /*!****************************************!*\
  10952.   !*** ./~/babel-runtime/helpers/get.js ***!
  10953.   \****************************************/
  10954. /***/ function(module, exports, __webpack_require__) {
  10955.  
  10956. 	"use strict";
  10957. 	
  10958. 	var _Object$getOwnPropertyDescriptor = __webpack_require__(/*! babel-runtime/core-js/object/get-own-property-descriptor */ 61)["default"];
  10959. 	
  10960. 	exports["default"] = function get(_x, _x2, _x3) {
  10961. 	  var _again = true;
  10962. 	
  10963. 	  _function: while (_again) {
  10964. 	    var object = _x,
  10965. 	        property = _x2,
  10966. 	        receiver = _x3;
  10967. 	    desc = parent = getter = undefined;
  10968. 	    _again = false;
  10969. 	    if (object === null) object = Function.prototype;
  10970. 	
  10971. 	    var desc = _Object$getOwnPropertyDescriptor(object, property);
  10972. 	
  10973. 	    if (desc === undefined) {
  10974. 	      var parent = Object.getPrototypeOf(object);
  10975. 	
  10976. 	      if (parent === null) {
  10977. 	        return undefined;
  10978. 	      } else {
  10979. 	        _x = parent;
  10980. 	        _x2 = property;
  10981. 	        _x3 = receiver;
  10982. 	        _again = true;
  10983. 	        continue _function;
  10984. 	      }
  10985. 	    } else if ("value" in desc) {
  10986. 	      return desc.value;
  10987. 	    } else {
  10988. 	      var getter = desc.get;
  10989. 	
  10990. 	      if (getter === undefined) {
  10991. 	        return undefined;
  10992. 	      }
  10993. 	
  10994. 	      return getter.call(receiver);
  10995. 	    }
  10996. 	  }
  10997. 	};
  10998. 	
  10999. 	exports.__esModule = true;
  11000.  
  11001. /***/ },
  11002. /* 61 */
  11003. /*!***********************************************************************!*\
  11004.   !*** ./~/babel-runtime/core-js/object/get-own-property-descriptor.js ***!
  11005.   \***********************************************************************/
  11006. /***/ function(module, exports, __webpack_require__) {
  11007.  
  11008. 	module.exports = { "default": __webpack_require__(/*! core-js/library/fn/object/get-own-property-descriptor */ 62), __esModule: true };
  11009.  
  11010. /***/ },
  11011. /* 62 */
  11012. /*!************************************************************************************!*\
  11013.   !*** ./~/babel-runtime/~/core-js/library/fn/object/get-own-property-descriptor.js ***!
  11014.   \************************************************************************************/
  11015. /***/ function(module, exports, __webpack_require__) {
  11016.  
  11017. 	var $ = __webpack_require__(/*! ../../modules/$ */ 15);
  11018. 	__webpack_require__(/*! ../../modules/es6.object.get-own-property-descriptor */ 63);
  11019. 	module.exports = function getOwnPropertyDescriptor(it, key){
  11020. 	  return $.getDesc(it, key);
  11021. 	};
  11022.  
  11023. /***/ },
  11024. /* 63 */
  11025. /*!*********************************************************************************************!*\
  11026.   !*** ./~/babel-runtime/~/core-js/library/modules/es6.object.get-own-property-descriptor.js ***!
  11027.   \*********************************************************************************************/
  11028. /***/ function(module, exports, __webpack_require__) {
  11029.  
  11030. 	// 19.1.2.6 Object.getOwnPropertyDescriptor(O, P)
  11031. 	var toIObject = __webpack_require__(/*! ./$.to-iobject */ 64);
  11032. 	
  11033. 	__webpack_require__(/*! ./$.object-sap */ 65)('getOwnPropertyDescriptor', function($getOwnPropertyDescriptor){
  11034. 	  return function getOwnPropertyDescriptor(it, key){
  11035. 	    return $getOwnPropertyDescriptor(toIObject(it), key);
  11036. 	  };
  11037. 	});
  11038.  
  11039. /***/ },
  11040. /* 64 */
  11041. /*!*******************************************************************!*\
  11042.   !*** ./~/babel-runtime/~/core-js/library/modules/$.to-iobject.js ***!
  11043.   \*******************************************************************/
  11044. /***/ function(module, exports, __webpack_require__) {
  11045.  
  11046. 	// to indexed object, toObject with fallback for non-array-like ES3 strings
  11047. 	var IObject = __webpack_require__(/*! ./$.iobject */ 12)
  11048. 	  , defined = __webpack_require__(/*! ./$.defined */ 11);
  11049. 	module.exports = function(it){
  11050. 	  return IObject(defined(it));
  11051. 	};
  11052.  
  11053. /***/ },
  11054. /* 65 */
  11055. /*!*******************************************************************!*\
  11056.   !*** ./~/babel-runtime/~/core-js/library/modules/$.object-sap.js ***!
  11057.   \*******************************************************************/
  11058. /***/ function(module, exports, __webpack_require__) {
  11059.  
  11060. 	// most Object methods by ES6 should accept primitives
  11061. 	module.exports = function(KEY, exec){
  11062. 	  var $def = __webpack_require__(/*! ./$.def */ 6)
  11063. 	    , fn   = (__webpack_require__(/*! ./$.core */ 8).Object || {})[KEY] || Object[KEY]
  11064. 	    , exp  = {};
  11065. 	  exp[KEY] = exec(fn);
  11066. 	  $def($def.S + $def.F * __webpack_require__(/*! ./$.fails */ 39)(function(){ fn(1); }), 'Object', exp);
  11067. 	};
  11068.  
  11069. /***/ },
  11070. /* 66 */
  11071. /*!*********************************************!*\
  11072.   !*** ./~/babel-runtime/helpers/inherits.js ***!
  11073.   \*********************************************/
  11074. /***/ function(module, exports, __webpack_require__) {
  11075.  
  11076. 	"use strict";
  11077. 	
  11078. 	var _Object$create = __webpack_require__(/*! babel-runtime/core-js/object/create */ 67)["default"];
  11079. 	
  11080. 	var _Object$setPrototypeOf = __webpack_require__(/*! babel-runtime/core-js/object/set-prototype-of */ 69)["default"];
  11081. 	
  11082. 	exports["default"] = function (subClass, superClass) {
  11083. 	  if (typeof superClass !== "function" && superClass !== null) {
  11084. 	    throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
  11085. 	  }
  11086. 	
  11087. 	  subClass.prototype = _Object$create(superClass && superClass.prototype, {
  11088. 	    constructor: {
  11089. 	      value: subClass,
  11090. 	      enumerable: false,
  11091. 	      writable: true,
  11092. 	      configurable: true
  11093. 	    }
  11094. 	  });
  11095. 	  if (superClass) _Object$setPrototypeOf ? _Object$setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
  11096. 	};
  11097. 	
  11098. 	exports.__esModule = true;
  11099.  
  11100. /***/ },
  11101. /* 67 */
  11102. /*!**************************************************!*\
  11103.   !*** ./~/babel-runtime/core-js/object/create.js ***!
  11104.   \**************************************************/
  11105. /***/ function(module, exports, __webpack_require__) {
  11106.  
  11107. 	module.exports = { "default": __webpack_require__(/*! core-js/library/fn/object/create */ 68), __esModule: true };
  11108.  
  11109. /***/ },
  11110. /* 68 */
  11111. /*!***************************************************************!*\
  11112.   !*** ./~/babel-runtime/~/core-js/library/fn/object/create.js ***!
  11113.   \***************************************************************/
  11114. /***/ function(module, exports, __webpack_require__) {
  11115.  
  11116. 	var $ = __webpack_require__(/*! ../../modules/$ */ 15);
  11117. 	module.exports = function create(P, D){
  11118. 	  return $.create(P, D);
  11119. 	};
  11120.  
  11121. /***/ },
  11122. /* 69 */
  11123. /*!************************************************************!*\
  11124.   !*** ./~/babel-runtime/core-js/object/set-prototype-of.js ***!
  11125.   \************************************************************/
  11126. /***/ function(module, exports, __webpack_require__) {
  11127.  
  11128. 	module.exports = { "default": __webpack_require__(/*! core-js/library/fn/object/set-prototype-of */ 70), __esModule: true };
  11129.  
  11130. /***/ },
  11131. /* 70 */
  11132. /*!*************************************************************************!*\
  11133.   !*** ./~/babel-runtime/~/core-js/library/fn/object/set-prototype-of.js ***!
  11134.   \*************************************************************************/
  11135. /***/ function(module, exports, __webpack_require__) {
  11136.  
  11137. 	__webpack_require__(/*! ../../modules/es6.object.set-prototype-of */ 71);
  11138. 	module.exports = __webpack_require__(/*! ../../modules/$.core */ 8).Object.setPrototypeOf;
  11139.  
  11140. /***/ },
  11141. /* 71 */
  11142. /*!**********************************************************************************!*\
  11143.   !*** ./~/babel-runtime/~/core-js/library/modules/es6.object.set-prototype-of.js ***!
  11144.   \**********************************************************************************/
  11145. /***/ function(module, exports, __webpack_require__) {
  11146.  
  11147. 	// 19.1.3.19 Object.setPrototypeOf(O, proto)
  11148. 	var $def = __webpack_require__(/*! ./$.def */ 6);
  11149. 	$def($def.S, 'Object', {setPrototypeOf: __webpack_require__(/*! ./$.set-proto */ 72).set});
  11150.  
  11151. /***/ },
  11152. /* 72 */
  11153. /*!******************************************************************!*\
  11154.   !*** ./~/babel-runtime/~/core-js/library/modules/$.set-proto.js ***!
  11155.   \******************************************************************/
  11156. /***/ function(module, exports, __webpack_require__) {
  11157.  
  11158. 	// Works with __proto__ only. Old v8 can't work with null proto objects.
  11159. 	/* eslint-disable no-proto */
  11160. 	var getDesc  = __webpack_require__(/*! ./$ */ 15).getDesc
  11161. 	  , isObject = __webpack_require__(/*! ./$.is-object */ 53)
  11162. 	  , anObject = __webpack_require__(/*! ./$.an-object */ 52);
  11163. 	var check = function(O, proto){
  11164. 	  anObject(O);
  11165. 	  if(!isObject(proto) && proto !== null)throw TypeError(proto + ": can't set as prototype!");
  11166. 	};
  11167. 	module.exports = {
  11168. 	  set: Object.setPrototypeOf || ('__proto__' in {} // eslint-disable-line
  11169. 	    ? function(buggy, set){
  11170. 	        try {
  11171. 	          set = __webpack_require__(/*! ./$.ctx */ 49)(Function.call, getDesc(Object.prototype, '__proto__').set, 2);
  11172. 	          set({}, []);
  11173. 	        } catch(e){ buggy = true; }
  11174. 	        return function setPrototypeOf(O, proto){
  11175. 	          check(O, proto);
  11176. 	          if(buggy)O.__proto__ = proto;
  11177. 	          else set(O, proto);
  11178. 	          return O;
  11179. 	        };
  11180. 	      }()
  11181. 	    : undefined),
  11182. 	  check: check
  11183. 	};
  11184.  
  11185. /***/ },
  11186. /* 73 */
  11187. /*!****************************************!*\
  11188.   !*** ./~/babel-runtime/core-js/set.js ***!
  11189.   \****************************************/
  11190. /***/ function(module, exports, __webpack_require__) {
  11191.  
  11192. 	module.exports = { "default": __webpack_require__(/*! core-js/library/fn/set */ 74), __esModule: true };
  11193.  
  11194. /***/ },
  11195. /* 74 */
  11196. /*!*****************************************************!*\
  11197.   !*** ./~/babel-runtime/~/core-js/library/fn/set.js ***!
  11198.   \*****************************************************/
  11199. /***/ function(module, exports, __webpack_require__) {
  11200.  
  11201. 	__webpack_require__(/*! ../modules/es6.object.to-string */ 75);
  11202. 	__webpack_require__(/*! ../modules/es6.string.iterator */ 30);
  11203. 	__webpack_require__(/*! ../modules/web.dom.iterable */ 76);
  11204. 	__webpack_require__(/*! ../modules/es6.set */ 80);
  11205. 	__webpack_require__(/*! ../modules/es7.set.to-json */ 87);
  11206. 	module.exports = __webpack_require__(/*! ../modules/$.core */ 8).Set;
  11207.  
  11208. /***/ },
  11209. /* 75 */
  11210. /*!***************************************************************************!*\
  11211.   !*** ./~/babel-runtime/~/core-js/library/modules/es6.object.to-string.js ***!
  11212.   \***************************************************************************/
  11213. /***/ function(module, exports) {
  11214.  
  11215.  
  11216.  
  11217. /***/ },
  11218. /* 76 */
  11219. /*!***********************************************************************!*\
  11220.   !*** ./~/babel-runtime/~/core-js/library/modules/web.dom.iterable.js ***!
  11221.   \***********************************************************************/
  11222. /***/ function(module, exports, __webpack_require__) {
  11223.  
  11224. 	__webpack_require__(/*! ./es6.array.iterator */ 77);
  11225. 	var Iterators = __webpack_require__(/*! ./$.iterators */ 44);
  11226. 	Iterators.NodeList = Iterators.HTMLCollection = Iterators.Array;
  11227.  
  11228. /***/ },
  11229. /* 77 */
  11230. /*!*************************************************************************!*\
  11231.   !*** ./~/babel-runtime/~/core-js/library/modules/es6.array.iterator.js ***!
  11232.   \*************************************************************************/
  11233. /***/ function(module, exports, __webpack_require__) {
  11234.  
  11235. 	'use strict';
  11236. 	var setUnscope = __webpack_require__(/*! ./$.unscope */ 78)
  11237. 	  , step       = __webpack_require__(/*! ./$.iter-step */ 79)
  11238. 	  , Iterators  = __webpack_require__(/*! ./$.iterators */ 44)
  11239. 	  , toIObject  = __webpack_require__(/*! ./$.to-iobject */ 64);
  11240. 	
  11241. 	// 22.1.3.4 Array.prototype.entries()
  11242. 	// 22.1.3.13 Array.prototype.keys()
  11243. 	// 22.1.3.29 Array.prototype.values()
  11244. 	// 22.1.3.30 Array.prototype[@@iterator]()
  11245. 	__webpack_require__(/*! ./$.iter-define */ 33)(Array, 'Array', function(iterated, kind){
  11246. 	  this._t = toIObject(iterated); // target
  11247. 	  this._i = 0;                   // next index
  11248. 	  this._k = kind;                // kind
  11249. 	// 22.1.5.2.1 %ArrayIteratorPrototype%.next()
  11250. 	}, function(){
  11251. 	  var O     = this._t
  11252. 	    , kind  = this._k
  11253. 	    , index = this._i++;
  11254. 	  if(!O || index >= O.length){
  11255. 	    this._t = undefined;
  11256. 	    return step(1);
  11257. 	  }
  11258. 	  if(kind == 'keys'  )return step(0, index);
  11259. 	  if(kind == 'values')return step(0, O[index]);
  11260. 	  return step(0, [index, O[index]]);
  11261. 	}, 'values');
  11262. 	
  11263. 	// argumentsList[@@iterator] is %ArrayProto_values% (9.4.4.6, 9.4.4.7)
  11264. 	Iterators.Arguments = Iterators.Array;
  11265. 	
  11266. 	setUnscope('keys');
  11267. 	setUnscope('values');
  11268. 	setUnscope('entries');
  11269.  
  11270. /***/ },
  11271. /* 78 */
  11272. /*!****************************************************************!*\
  11273.   !*** ./~/babel-runtime/~/core-js/library/modules/$.unscope.js ***!
  11274.   \****************************************************************/
  11275. /***/ function(module, exports) {
  11276.  
  11277. 	module.exports = function(){ /* empty */ };
  11278.  
  11279. /***/ },
  11280. /* 79 */
  11281. /*!******************************************************************!*\
  11282.   !*** ./~/babel-runtime/~/core-js/library/modules/$.iter-step.js ***!
  11283.   \******************************************************************/
  11284. /***/ function(module, exports) {
  11285.  
  11286. 	module.exports = function(done, value){
  11287. 	  return {value: value, done: !!done};
  11288. 	};
  11289.  
  11290. /***/ },
  11291. /* 80 */
  11292. /*!**************************************************************!*\
  11293.   !*** ./~/babel-runtime/~/core-js/library/modules/es6.set.js ***!
  11294.   \**************************************************************/
  11295. /***/ function(module, exports, __webpack_require__) {
  11296.  
  11297. 	'use strict';
  11298. 	var strong = __webpack_require__(/*! ./$.collection-strong */ 81);
  11299. 	
  11300. 	// 23.2 Set Objects
  11301. 	__webpack_require__(/*! ./$.collection */ 86)('Set', function(get){
  11302. 	  return function Set(){ return get(this, arguments[0]); };
  11303. 	}, {
  11304. 	  // 23.2.3.1 Set.prototype.add(value)
  11305. 	  add: function add(value){
  11306. 	    return strong.def(this, value = value === 0 ? 0 : value, value);
  11307. 	  }
  11308. 	}, strong);
  11309.  
  11310. /***/ },
  11311. /* 81 */
  11312. /*!**************************************************************************!*\
  11313.   !*** ./~/babel-runtime/~/core-js/library/modules/$.collection-strong.js ***!
  11314.   \**************************************************************************/
  11315. /***/ function(module, exports, __webpack_require__) {
  11316.  
  11317. 	'use strict';
  11318. 	var $            = __webpack_require__(/*! ./$ */ 15)
  11319. 	  , hide         = __webpack_require__(/*! ./$.hide */ 36)
  11320. 	  , ctx          = __webpack_require__(/*! ./$.ctx */ 49)
  11321. 	  , species      = __webpack_require__(/*! ./$.species */ 82)
  11322. 	  , strictNew    = __webpack_require__(/*! ./$.strict-new */ 83)
  11323. 	  , defined      = __webpack_require__(/*! ./$.defined */ 11)
  11324. 	  , forOf        = __webpack_require__(/*! ./$.for-of */ 84)
  11325. 	  , step         = __webpack_require__(/*! ./$.iter-step */ 79)
  11326. 	  , ID           = __webpack_require__(/*! ./$.uid */ 43)('id')
  11327. 	  , $has         = __webpack_require__(/*! ./$.has */ 40)
  11328. 	  , isObject     = __webpack_require__(/*! ./$.is-object */ 53)
  11329. 	  , isExtensible = Object.isExtensible || isObject
  11330. 	  , SUPPORT_DESC = __webpack_require__(/*! ./$.support-desc */ 38)
  11331. 	  , SIZE         = SUPPORT_DESC ? '_s' : 'size'
  11332. 	  , id           = 0;
  11333. 	
  11334. 	var fastKey = function(it, create){
  11335. 	  // return primitive with prefix
  11336. 	  if(!isObject(it))return typeof it == 'symbol' ? it : (typeof it == 'string' ? 'S' : 'P') + it;
  11337. 	  if(!$has(it, ID)){
  11338. 	    // can't set id to frozen object
  11339. 	    if(!isExtensible(it))return 'F';
  11340. 	    // not necessary to add id
  11341. 	    if(!create)return 'E';
  11342. 	    // add missing object id
  11343. 	    hide(it, ID, ++id);
  11344. 	  // return object id with prefix
  11345. 	  } return 'O' + it[ID];
  11346. 	};
  11347. 	
  11348. 	var getEntry = function(that, key){
  11349. 	  // fast case
  11350. 	  var index = fastKey(key), entry;
  11351. 	  if(index !== 'F')return that._i[index];
  11352. 	  // frozen object case
  11353. 	  for(entry = that._f; entry; entry = entry.n){
  11354. 	    if(entry.k == key)return entry;
  11355. 	  }
  11356. 	};
  11357. 	
  11358. 	module.exports = {
  11359. 	  getConstructor: function(wrapper, NAME, IS_MAP, ADDER){
  11360. 	    var C = wrapper(function(that, iterable){
  11361. 	      strictNew(that, C, NAME);
  11362. 	      that._i = $.create(null); // index
  11363. 	      that._f = undefined;      // first entry
  11364. 	      that._l = undefined;      // last entry
  11365. 	      that[SIZE] = 0;           // size
  11366. 	      if(iterable != undefined)forOf(iterable, IS_MAP, that[ADDER], that);
  11367. 	    });
  11368. 	    __webpack_require__(/*! ./$.mix */ 85)(C.prototype, {
  11369. 	      // 23.1.3.1 Map.prototype.clear()
  11370. 	      // 23.2.3.2 Set.prototype.clear()
  11371. 	      clear: function clear(){
  11372. 	        for(var that = this, data = that._i, entry = that._f; entry; entry = entry.n){
  11373. 	          entry.r = true;
  11374. 	          if(entry.p)entry.p = entry.p.n = undefined;
  11375. 	          delete data[entry.i];
  11376. 	        }
  11377. 	        that._f = that._l = undefined;
  11378. 	        that[SIZE] = 0;
  11379. 	      },
  11380. 	      // 23.1.3.3 Map.prototype.delete(key)
  11381. 	      // 23.2.3.4 Set.prototype.delete(value)
  11382. 	      'delete': function(key){
  11383. 	        var that  = this
  11384. 	          , entry = getEntry(that, key);
  11385. 	        if(entry){
  11386. 	          var next = entry.n
  11387. 	            , prev = entry.p;
  11388. 	          delete that._i[entry.i];
  11389. 	          entry.r = true;
  11390. 	          if(prev)prev.n = next;
  11391. 	          if(next)next.p = prev;
  11392. 	          if(that._f == entry)that._f = next;
  11393. 	          if(that._l == entry)that._l = prev;
  11394. 	          that[SIZE]--;
  11395. 	        } return !!entry;
  11396. 	      },
  11397. 	      // 23.2.3.6 Set.prototype.forEach(callbackfn, thisArg = undefined)
  11398. 	      // 23.1.3.5 Map.prototype.forEach(callbackfn, thisArg = undefined)
  11399. 	      forEach: function forEach(callbackfn /*, that = undefined */){
  11400. 	        var f = ctx(callbackfn, arguments[1], 3)
  11401. 	          , entry;
  11402. 	        while(entry = entry ? entry.n : this._f){
  11403. 	          f(entry.v, entry.k, this);
  11404. 	          // revert to the last existing entry
  11405. 	          while(entry && entry.r)entry = entry.p;
  11406. 	        }
  11407. 	      },
  11408. 	      // 23.1.3.7 Map.prototype.has(key)
  11409. 	      // 23.2.3.7 Set.prototype.has(value)
  11410. 	      has: function has(key){
  11411. 	        return !!getEntry(this, key);
  11412. 	      }
  11413. 	    });
  11414. 	    if(SUPPORT_DESC)$.setDesc(C.prototype, 'size', {
  11415. 	      get: function(){
  11416. 	        return defined(this[SIZE]);
  11417. 	      }
  11418. 	    });
  11419. 	    return C;
  11420. 	  },
  11421. 	  def: function(that, key, value){
  11422. 	    var entry = getEntry(that, key)
  11423. 	      , prev, index;
  11424. 	    // change existing entry
  11425. 	    if(entry){
  11426. 	      entry.v = value;
  11427. 	    // create new entry
  11428. 	    } else {
  11429. 	      that._l = entry = {
  11430. 	        i: index = fastKey(key, true), // <- index
  11431. 	        k: key,                        // <- key
  11432. 	        v: value,                      // <- value
  11433. 	        p: prev = that._l,             // <- previous entry
  11434. 	        n: undefined,                  // <- next entry
  11435. 	        r: false                       // <- removed
  11436. 	      };
  11437. 	      if(!that._f)that._f = entry;
  11438. 	      if(prev)prev.n = entry;
  11439. 	      that[SIZE]++;
  11440. 	      // add to index
  11441. 	      if(index !== 'F')that._i[index] = entry;
  11442. 	    } return that;
  11443. 	  },
  11444. 	  getEntry: getEntry,
  11445. 	  setStrong: function(C, NAME, IS_MAP){
  11446. 	    // add .keys, .values, .entries, [@@iterator]
  11447. 	    // 23.1.3.4, 23.1.3.8, 23.1.3.11, 23.1.3.12, 23.2.3.5, 23.2.3.8, 23.2.3.10, 23.2.3.11
  11448. 	    __webpack_require__(/*! ./$.iter-define */ 33)(C, NAME, function(iterated, kind){
  11449. 	      this._t = iterated;  // target
  11450. 	      this._k = kind;      // kind
  11451. 	      this._l = undefined; // previous
  11452. 	    }, function(){
  11453. 	      var that  = this
  11454. 	        , kind  = that._k
  11455. 	        , entry = that._l;
  11456. 	      // revert to the last existing entry
  11457. 	      while(entry && entry.r)entry = entry.p;
  11458. 	      // get next entry
  11459. 	      if(!that._t || !(that._l = entry = entry ? entry.n : that._t._f)){
  11460. 	        // or finish the iteration
  11461. 	        that._t = undefined;
  11462. 	        return step(1);
  11463. 	      }
  11464. 	      // return step by kind
  11465. 	      if(kind == 'keys'  )return step(0, entry.k);
  11466. 	      if(kind == 'values')return step(0, entry.v);
  11467. 	      return step(0, [entry.k, entry.v]);
  11468. 	    }, IS_MAP ? 'entries' : 'values' , !IS_MAP, true);
  11469. 	
  11470. 	    // add [@@species], 23.1.2.2, 23.2.2.2
  11471. 	    species(C);
  11472. 	    species(__webpack_require__(/*! ./$.core */ 8)[NAME]); // for wrapper
  11473. 	  }
  11474. 	};
  11475.  
  11476. /***/ },
  11477. /* 82 */
  11478. /*!****************************************************************!*\
  11479.   !*** ./~/babel-runtime/~/core-js/library/modules/$.species.js ***!
  11480.   \****************************************************************/
  11481. /***/ function(module, exports, __webpack_require__) {
  11482.  
  11483. 	'use strict';
  11484. 	var $       = __webpack_require__(/*! ./$ */ 15)
  11485. 	  , SPECIES = __webpack_require__(/*! ./$.wks */ 41)('species');
  11486. 	module.exports = function(C){
  11487. 	  if(__webpack_require__(/*! ./$.support-desc */ 38) && !(SPECIES in C))$.setDesc(C, SPECIES, {
  11488. 	    configurable: true,
  11489. 	    get: function(){ return this; }
  11490. 	  });
  11491. 	};
  11492.  
  11493. /***/ },
  11494. /* 83 */
  11495. /*!*******************************************************************!*\
  11496.   !*** ./~/babel-runtime/~/core-js/library/modules/$.strict-new.js ***!
  11497.   \*******************************************************************/
  11498. /***/ function(module, exports) {
  11499.  
  11500. 	module.exports = function(it, Constructor, name){
  11501. 	  if(!(it instanceof Constructor))throw TypeError(name + ": use the 'new' operator!");
  11502. 	  return it;
  11503. 	};
  11504.  
  11505. /***/ },
  11506. /* 84 */
  11507. /*!***************************************************************!*\
  11508.   !*** ./~/babel-runtime/~/core-js/library/modules/$.for-of.js ***!
  11509.   \***************************************************************/
  11510. /***/ function(module, exports, __webpack_require__) {
  11511.  
  11512. 	var ctx         = __webpack_require__(/*! ./$.ctx */ 49)
  11513. 	  , call        = __webpack_require__(/*! ./$.iter-call */ 51)
  11514. 	  , isArrayIter = __webpack_require__(/*! ./$.is-array-iter */ 54)
  11515. 	  , anObject    = __webpack_require__(/*! ./$.an-object */ 52)
  11516. 	  , toLength    = __webpack_require__(/*! ./$.to-length */ 55)
  11517. 	  , getIterFn   = __webpack_require__(/*! ./core.get-iterator-method */ 56);
  11518. 	module.exports = function(iterable, entries, fn, that){
  11519. 	  var iterFn = getIterFn(iterable)
  11520. 	    , f      = ctx(fn, that, entries ? 2 : 1)
  11521. 	    , index  = 0
  11522. 	    , length, step, iterator;
  11523. 	  if(typeof iterFn != 'function')throw TypeError(iterable + ' is not iterable!');
  11524. 	  // fast case for arrays with default iterator
  11525. 	  if(isArrayIter(iterFn))for(length = toLength(iterable.length); length > index; index++){
  11526. 	    entries ? f(anObject(step = iterable[index])[0], step[1]) : f(iterable[index]);
  11527. 	  } else for(iterator = iterFn.call(iterable); !(step = iterator.next()).done; ){
  11528. 	    call(iterator, f, step.value, entries);
  11529. 	  }
  11530. 	};
  11531.  
  11532. /***/ },
  11533. /* 85 */
  11534. /*!************************************************************!*\
  11535.   !*** ./~/babel-runtime/~/core-js/library/modules/$.mix.js ***!
  11536.   \************************************************************/
  11537. /***/ function(module, exports, __webpack_require__) {
  11538.  
  11539. 	var $redef = __webpack_require__(/*! ./$.redef */ 35);
  11540. 	module.exports = function(target, src){
  11541. 	  for(var key in src)$redef(target, key, src[key]);
  11542. 	  return target;
  11543. 	};
  11544.  
  11545. /***/ },
  11546. /* 86 */
  11547. /*!*******************************************************************!*\
  11548.   !*** ./~/babel-runtime/~/core-js/library/modules/$.collection.js ***!
  11549.   \*******************************************************************/
  11550. /***/ function(module, exports, __webpack_require__) {
  11551.  
  11552. 	'use strict';
  11553. 	var $          = __webpack_require__(/*! ./$ */ 15)
  11554. 	  , $def       = __webpack_require__(/*! ./$.def */ 6)
  11555. 	  , hide       = __webpack_require__(/*! ./$.hide */ 36)
  11556. 	  , BUGGY      = __webpack_require__(/*! ./$.iter-buggy */ 47)
  11557. 	  , forOf      = __webpack_require__(/*! ./$.for-of */ 84)
  11558. 	  , strictNew  = __webpack_require__(/*! ./$.strict-new */ 83);
  11559. 	
  11560. 	module.exports = function(NAME, wrapper, methods, common, IS_MAP, IS_WEAK){
  11561. 	  var Base  = __webpack_require__(/*! ./$.global */ 7)[NAME]
  11562. 	    , C     = Base
  11563. 	    , ADDER = IS_MAP ? 'set' : 'add'
  11564. 	    , proto = C && C.prototype
  11565. 	    , O     = {};
  11566. 	  if(!__webpack_require__(/*! ./$.support-desc */ 38) || typeof C != 'function'
  11567. 	    || !(IS_WEAK || !BUGGY && proto.forEach && proto.entries)){
  11568. 	    // create collection constructor
  11569. 	    C = common.getConstructor(wrapper, NAME, IS_MAP, ADDER);
  11570. 	    __webpack_require__(/*! ./$.mix */ 85)(C.prototype, methods);
  11571. 	  } else {
  11572. 	    C = wrapper(function(target, iterable){
  11573. 	      strictNew(target, C, NAME);
  11574. 	      target._c = new Base;
  11575. 	      if(iterable != undefined)forOf(iterable, IS_MAP, target[ADDER], target);
  11576. 	    });
  11577. 	    $.each.call('add,clear,delete,forEach,get,has,set,keys,values,entries'.split(','),function(KEY){
  11578. 	      var chain = KEY == 'add' || KEY == 'set';
  11579. 	      if(KEY in proto && !(IS_WEAK && KEY == 'clear'))hide(C.prototype, KEY, function(a, b){
  11580. 	        var result = this._c[KEY](a === 0 ? 0 : a, b);
  11581. 	        return chain ? this : result;
  11582. 	      });
  11583. 	    });
  11584. 	    if('size' in proto)$.setDesc(C.prototype, 'size', {
  11585. 	      get: function(){
  11586. 	        return this._c.size;
  11587. 	      }
  11588. 	    });
  11589. 	  }
  11590. 	
  11591. 	  __webpack_require__(/*! ./$.tag */ 46)(C, NAME);
  11592. 	
  11593. 	  O[NAME] = C;
  11594. 	  $def($def.G + $def.W + $def.F, O);
  11595. 	
  11596. 	  if(!IS_WEAK)common.setStrong(C, NAME, IS_MAP);
  11597. 	
  11598. 	  return C;
  11599. 	};
  11600.  
  11601. /***/ },
  11602. /* 87 */
  11603. /*!**********************************************************************!*\
  11604.   !*** ./~/babel-runtime/~/core-js/library/modules/es7.set.to-json.js ***!
  11605.   \**********************************************************************/
  11606. /***/ function(module, exports, __webpack_require__) {
  11607.  
  11608. 	// https://github.com/DavidBruant/Map-Set.prototype.toJSON
  11609. 	var $def  = __webpack_require__(/*! ./$.def */ 6);
  11610. 	
  11611. 	$def($def.P, 'Set', {toJSON: __webpack_require__(/*! ./$.collection-to-json */ 88)('Set')});
  11612.  
  11613. /***/ },
  11614. /* 88 */
  11615. /*!***************************************************************************!*\
  11616.   !*** ./~/babel-runtime/~/core-js/library/modules/$.collection-to-json.js ***!
  11617.   \***************************************************************************/
  11618. /***/ function(module, exports, __webpack_require__) {
  11619.  
  11620. 	// https://github.com/DavidBruant/Map-Set.prototype.toJSON
  11621. 	var forOf   = __webpack_require__(/*! ./$.for-of */ 84)
  11622. 	  , classof = __webpack_require__(/*! ./$.classof */ 57);
  11623. 	module.exports = function(NAME){
  11624. 	  return function toJSON(){
  11625. 	    if(classof(this) != NAME)throw TypeError(NAME + "#toJSON isn't generic");
  11626. 	    var arr = [];
  11627. 	    forOf(this, false, arr.push, arr);
  11628. 	    return arr;
  11629. 	  };
  11630. 	};
  11631.  
  11632. /***/ },
  11633. /* 89 */
  11634. /*!**************************************!*\
  11635.   !*** ./src/scripts/func/debounce.js ***!
  11636.   \**************************************/
  11637. /***/ function(module, exports) {
  11638.  
  11639. 	
  11640. 	
  11641. 	// ----------------------------------------------------------------------------
  11642. 	
  11643. 	/**
  11644. 	 * Wait until threshold ms has elapsed between function calls to
  11645. 	 * call the function i.e. delay until after calls have stopped.
  11646. 	 *
  11647. 	 * If immediate, instead call the function on the first call, then
  11648. 	 * ignore further calls until delay ms after further calls have
  11649. 	 * stopped.
  11650. 	 */
  11651. 	'use strict';
  11652. 	
  11653. 	Object.defineProperty(exports, '__esModule', {
  11654. 	  value: true
  11655. 	});
  11656. 	exports['default'] = debounce;
  11657. 	
  11658. 	function debounce(func, threshold, immediate) {
  11659. 	  threshold = typeof threshold === 'number' ? threshold : 100;
  11660. 	
  11661. 	  var timeout = null;
  11662. 	
  11663. 	  return function debounced() {
  11664. 	    for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
  11665. 	      args[_key] = arguments[_key];
  11666. 	    }
  11667. 	
  11668. 	    var fn = func.bind(this);
  11669. 	
  11670. 	    function afterthreshold() {
  11671. 	      if (!immediate) {
  11672. 	        fn.apply(undefined, args);
  11673. 	      }
  11674. 	
  11675. 	      timeout = null;
  11676. 	    }
  11677. 	
  11678. 	    var callNow = immediate && !timeout;
  11679. 	
  11680. 	    clearTimeout(timeout);
  11681. 	    timeout = setTimeout(afterthreshold, threshold);
  11682. 	
  11683. 	    if (callNow) {
  11684. 	      fn.apply(undefined, args);
  11685. 	    }
  11686. 	  };
  11687. 	}
  11688. 	
  11689. 	module.exports = exports['default'];
  11690.  
  11691. /***/ }
  11692. /******/ ])
  11693. });
  11694. ;
  11695. //# sourceMappingURL=jquery-extras.js.map