docs/_build/html/_static/jquery-3.5.1.js

   1 /*!
   2  * jQuery JavaScript Library v3.5.1
   3  * https://jquery.com/
   4  *
   5  * Includes Sizzle.js
   6  * https://sizzlejs.com/
   7  *
   8  * Copyright JS Foundation and other contributors
   9  * Released under the MIT license
  10  * https://jquery.org/license
  11  *
  12  * Date: 2020-05-04T22:49Z
  13  */
  14 ( function( global, factory ) {
  15
  16         "use strict";
  17
  18         if ( typeof module === "object" && typeof module.exports === "object" ) {
  19
  20                 // For CommonJS and CommonJS-like environments where a proper `window`
  21                 // is present, execute the factory and get jQuery.
  22                 // For environments that do not have a `window` with a `document`
  23                 // (such as Node.js), expose a factory as module.exports.
  24                 // This accentuates the need for the creation of a real `window`.
  25                 // e.g. var jQuery = require("jquery")(window);
  26                 // See ticket #14549 for more info.
  27                 module.exports = global.document ?
  28                         factory( global, true ) :
  29                         function( w ) {
  30                                 if ( !w.document ) {
  31                                         throw new Error( "jQuery requires a window with a document" );
  32                                 }
  33                                 return factory( w );
  34                         };
  35         } else {
  36                 factory( global );
  37         }
  38
  39 // Pass this if window is not defined yet
  40 } )( typeof window !== "undefined" ? window : this, function( window, noGlobal ) {
  41
  42 // Edge <= 12 - 13+, Firefox <=18 - 45+, IE 10 - 11, Safari 5.1 - 9+, iOS 6 - 9.1
  43 // throw exceptions when non-strict code (e.g., ASP.NET 4.5) accesses strict mode
  44 // arguments.callee.caller (trac-13335). But as of jQuery 3.0 (2016), strict mode should be common
  45 // enough that all such attempts are guarded in a try block.
  46 "use strict";
  47
  48 var arr = [];
  49
  50 var getProto = Object.getPrototypeOf;
  51
  52 var slice = arr.slice;
  53
  54 var flat = arr.flat ? function( array ) {
  55         return arr.flat.call( array );
  56 } : function( array ) {
  57         return arr.concat.apply( [], array );
  58 };
  59
  60
  61 var push = arr.push;
  62
  63 var indexOf = arr.indexOf;
  64
  65 var class2type = {};
  66
  67 var toString = class2type.toString;
  68
  69 var hasOwn = class2type.hasOwnProperty;
  70
  71 var fnToString = hasOwn.toString;
  72
  73 var ObjectFunctionString = fnToString.call( Object );
  74
  75 var support = {};
  76
  77 var isFunction = function isFunction( obj ) {
  78
  79       // Support: Chrome <=57, Firefox <=52
  80       // In some browsers, typeof returns "function" for HTML <object> elements
  81       // (i.e., `typeof document.createElement( "object" ) === "function"`).
  82       // We don't want to classify *any* DOM node as a function.
  83       return typeof obj === "function" && typeof obj.nodeType !== "number";
  84   };
  85
  86
  87 var isWindow = function isWindow( obj ) {
  88                 return obj != null && obj === obj.window;
  89         };
  90
  91
  92 var document = window.document;
  93
  94
  95
  96         var preservedScriptAttributes = {
  97                 type: true,
  98                 src: true,
  99                 nonce: true,
 100                 noModule: true
 101         };
 102
 103         function DOMEval( code, node, doc ) {
 104                 doc = doc || document;
 105
 106                 var i, val,
 107                         script = doc.createElement( "script" );
 108
 109                 script.text = code;
 110                 if ( node ) {
 111                         for ( i in preservedScriptAttributes ) {
 112
 113                                 // Support: Firefox 64+, Edge 18+
 114                                 // Some browsers don't support the "nonce" property on scripts.
 115                                 // On the other hand, just using `getAttribute` is not enough as
 116                                 // the `nonce` attribute is reset to an empty string whenever it
 117                                 // becomes browsing-context connected.
 118                                 // See https://github.com/whatwg/html/issues/2369
 119                                 // See https://html.spec.whatwg.org/#nonce-attributes
 120                                 // The `node.getAttribute` check was added for the sake of
 121                                 // `jQuery.globalEval` so that it can fake a nonce-containing node
 122                                 // via an object.
 123                                 val = node[ i ] || node.getAttribute && node.getAttribute( i );
 124                                 if ( val ) {
 125                                         script.setAttribute( i, val );
 126                                 }
 127                         }
 128                 }
 129                 doc.head.appendChild( script ).parentNode.removeChild( script );
 130         }
 131
 132
 133 function toType( obj ) {
 134         if ( obj == null ) {
 135                 return obj + "";
 136         }
 137
 138         // Support: Android <=2.3 only (functionish RegExp)
 139         return typeof obj === "object" || typeof obj === "function" ?
 140                 class2type[ toString.call( obj ) ] || "object" :
 141                 typeof obj;
 142 }
 143 /* global Symbol */
 144 // Defining this global in .eslintrc.json would create a danger of using the global
 145 // unguarded in another place, it seems safer to define global only for this module
 146
 147
 148
 149 var
 150         version = "3.5.1",
 151
 152         // Define a local copy of jQuery
 153         jQuery = function( selector, context ) {
 154
 155                 // The jQuery object is actually just the init constructor 'enhanced'
 156                 // Need init if jQuery is called (just allow error to be thrown if not included)
 157                 return new jQuery.fn.init( selector, context );
 158         };
 159
 160 jQuery.fn = jQuery.prototype = {
 161
 162         // The current version of jQuery being used
 163         jquery: version,
 164
 165         constructor: jQuery,
 166
 167         // The default length of a jQuery object is 0
 168         length: 0,
 169
 170         toArray: function() {
 171                 return slice.call( this );
 172         },
 173
 174         // Get the Nth element in the matched element set OR
 175         // Get the whole matched element set as a clean array
 176         get: function( num ) {
 177
 178                 // Return all the elements in a clean array
 179                 if ( num == null ) {
 180                         return slice.call( this );
 181                 }
 182
 183                 // Return just the one element from the set
 184                 return num < 0 ? this[ num + this.length ] : this[ num ];
 185         },
 186
 187         // Take an array of elements and push it onto the stack
 188         // (returning the new matched element set)
 189         pushStack: function( elems ) {
 190
 191                 // Build a new jQuery matched element set
 192                 var ret = jQuery.merge( this.constructor(), elems );
 193
 194                 // Add the old object onto the stack (as a reference)
 195                 ret.prevObject = this;
 196
 197                 // Return the newly-formed element set
 198                 return ret;
 199         },
 200
 201         // Execute a callback for every element in the matched set.
 202         each: function( callback ) {
 203                 return jQuery.each( this, callback );
 204         },
 205
 206         map: function( callback ) {
 207                 return this.pushStack( jQuery.map( this, function( elem, i ) {
 208                         return callback.call( elem, i, elem );
 209                 } ) );
 210         },
 211
 212         slice: function() {
 213                 return this.pushStack( slice.apply( this, arguments ) );
 214         },
 215
 216         first: function() {
 217                 return this.eq( 0 );
 218         },
 219
 220         last: function() {
 221                 return this.eq( -1 );
 222         },
 223
 224         even: function() {
 225                 return this.pushStack( jQuery.grep( this, function( _elem, i ) {
 226                         return ( i + 1 ) % 2;
 227                 } ) );
 228         },
 229
 230         odd: function() {
 231                 return this.pushStack( jQuery.grep( this, function( _elem, i ) {
 232                         return i % 2;
 233                 } ) );
 234         },
 235
 236         eq: function( i ) {
 237                 var len = this.length,
 238                         j = +i + ( i < 0 ? len : 0 );
 239                 return this.pushStack( j >= 0 && j < len ? [ this[ j ] ] : [] );
 240         },
 241
 242         end: function() {
 243                 return this.prevObject || this.constructor();
 244         },
 245
 246         // For internal use only.
 247         // Behaves like an Array's method, not like a jQuery method.
 248         push: push,
 249         sort: arr.sort,
 250         splice: arr.splice
 251 };
 252
 253 jQuery.extend = jQuery.fn.extend = function() {
 254         var options, name, src, copy, copyIsArray, clone,
 255                 target = arguments[ 0 ] || {},
 256                 i = 1,
 257                 length = arguments.length,
 258                 deep = false;
 259
 260         // Handle a deep copy situation
 261         if ( typeof target === "boolean" ) {
 262                 deep = target;
 263
 264                 // Skip the boolean and the target
 265                 target = arguments[ i ] || {};
 266                 i++;
 267         }
 268
 269         // Handle case when target is a string or something (possible in deep copy)
 270         if ( typeof target !== "object" && !isFunction( target ) ) {
 271                 target = {};
 272         }
 273
 274         // Extend jQuery itself if only one argument is passed
 275         if ( i === length ) {
 276                 target = this;
 277                 i--;
 278         }
 279
 280         for ( ; i < length; i++ ) {
 281
 282                 // Only deal with non-null/undefined values
 283                 if ( ( options = arguments[ i ] ) != null ) {
 284
 285                         // Extend the base object
 286                         for ( name in options ) {
 287                                 copy = options[ name ];
 288
 289                                 // Prevent Object.prototype pollution
 290                                 // Prevent never-ending loop
 291                                 if ( name === "__proto__" || target === copy ) {
 292                                         continue;
 293                                 }
 294
 295                                 // Recurse if we're merging plain objects or arrays
 296                                 if ( deep && copy && ( jQuery.isPlainObject( copy ) ||
 297                                         ( copyIsArray = Array.isArray( copy ) ) ) ) {
 298                                         src = target[ name ];
 299
 300                                         // Ensure proper type for the source value
 301                                         if ( copyIsArray && !Array.isArray( src ) ) {
 302                                                 clone = [];
 303                                         } else if ( !copyIsArray && !jQuery.isPlainObject( src ) ) {
 304                                                 clone = {};
 305                                         } else {
 306                                                 clone = src;
 307                                         }
 308                                         copyIsArray = false;
 309
 310                                         // Never move original objects, clone them
 311                                         target[ name ] = jQuery.extend( deep, clone, copy );
 312
 313                                 // Don't bring in undefined values
 314                                 } else if ( copy !== undefined ) {
 315                                         target[ name ] = copy;
 316                                 }
 317                         }
 318                 }
 319         }
 320
 321         // Return the modified object
 322         return target;
 323 };
 324
 325 jQuery.extend( {
 326
 327         // Unique for each copy of jQuery on the page
 328         expando: "jQuery" + ( version + Math.random() ).replace( /\D/g, "" ),
 329
 330         // Assume jQuery is ready without the ready module
 331         isReady: true,
 332
 333         error: function( msg ) {
 334                 throw new Error( msg );
 335         },
 336
 337         noop: function() {},
 338
 339         isPlainObject: function( obj ) {
 340                 var proto, Ctor;
 341
 342                 // Detect obvious negatives
 343                 // Use toString instead of jQuery.type to catch host objects
 344                 if ( !obj || toString.call( obj ) !== "[object Object]" ) {
 345                         return false;
 346                 }
 347
 348                 proto = getProto( obj );
 349
 350                 // Objects with no prototype (e.g., `Object.create( null )`) are plain
 351                 if ( !proto ) {
 352                         return true;
 353                 }
 354
 355                 // Objects with prototype are plain iff they were constructed by a global Object function
 356                 Ctor = hasOwn.call( proto, "constructor" ) && proto.constructor;
 357                 return typeof Ctor === "function" && fnToString.call( Ctor ) === ObjectFunctionString;
 358         },
 359
 360         isEmptyObject: function( obj ) {
 361                 var name;
 362
 363                 for ( name in obj ) {
 364                         return false;
 365                 }
 366                 return true;
 367         },
 368
 369         // Evaluates a script in a provided context; falls back to the global one
 370         // if not specified.
 371         globalEval: function( code, options, doc ) {
 372                 DOMEval( code, { nonce: options && options.nonce }, doc );
 373         },
 374
 375         each: function( obj, callback ) {
 376                 var length, i = 0;
 377
 378                 if ( isArrayLike( obj ) ) {
 379                         length = obj.length;
 380                         for ( ; i < length; i++ ) {
 381                                 if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {
 382                                         break;
 383                                 }
 384                         }
 385                 } else {
 386                         for ( i in obj ) {
 387                                 if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {
 388                                         break;
 389                                 }
 390                         }
 391                 }
 392
 393                 return obj;
 394         },
 395
 396         // results is for internal usage only
 397         makeArray: function( arr, results ) {
 398                 var ret = results || [];
 399
 400                 if ( arr != null ) {
 401                         if ( isArrayLike( Object( arr ) ) ) {
 402                                 jQuery.merge( ret,
 403                                         typeof arr === "string" ?
 404                                         [ arr ] : arr
 405                                 );
 406                         } else {
 407                                 push.call( ret, arr );
 408                         }
 409                 }
 410
 411                 return ret;
 412         },
 413
 414         inArray: function( elem, arr, i ) {
 415                 return arr == null ? -1 : indexOf.call( arr, elem, i );
 416         },
 417
 418         // Support: Android <=4.0 only, PhantomJS 1 only
 419         // push.apply(_, arraylike) throws on ancient WebKit
 420         merge: function( first, second ) {
 421                 var len = +second.length,
 422                         j = 0,
 423                         i = first.length;
 424
 425                 for ( ; j < len; j++ ) {
 426                         first[ i++ ] = second[ j ];
 427                 }
 428
 429                 first.length = i;
 430
 431                 return first;
 432         },
 433
 434         grep: function( elems, callback, invert ) {
 435                 var callbackInverse,
 436                         matches = [],
 437                         i = 0,
 438                         length = elems.length,
 439                         callbackExpect = !invert;
 440
 441                 // Go through the array, only saving the items
 442                 // that pass the validator function
 443                 for ( ; i < length; i++ ) {
 444                         callbackInverse = !callback( elems[ i ], i );
 445                         if ( callbackInverse !== callbackExpect ) {
 446                                 matches.push( elems[ i ] );
 447                         }
 448                 }
 449
 450                 return matches;
 451         },
 452
 453         // arg is for internal usage only
 454         map: function( elems, callback, arg ) {
 455                 var length, value,
 456                         i = 0,
 457                         ret = [];
 458
 459                 // Go through the array, translating each of the items to their new values
 460                 if ( isArrayLike( elems ) ) {
 461                         length = elems.length;
 462                         for ( ; i < length; i++ ) {
 463                                 value = callback( elems[ i ], i, arg );
 464
 465                                 if ( value != null ) {
 466                                         ret.push( value );
 467                                 }
 468                         }
 469
 470                 // Go through every key on the object,
 471                 } else {
 472                         for ( i in elems ) {
 473                                 value = callback( elems[ i ], i, arg );
 474
 475                                 if ( value != null ) {
 476                                         ret.push( value );
 477                                 }
 478                         }
 479                 }
 480
 481                 // Flatten any nested arrays
 482                 return flat( ret );
 483         },
 484
 485         // A global GUID counter for objects
 486         guid: 1,
 487
 488         // jQuery.support is not used in Core but other projects attach their
 489         // properties to it so it needs to exist.
 490         support: support
 491 } );
 492
 493 if ( typeof Symbol === "function" ) {
 494         jQuery.fn[ Symbol.iterator ] = arr[ Symbol.iterator ];
 495 }
 496
 497 // Populate the class2type map
 498 jQuery.each( "Boolean Number String Function Array Date RegExp Object Error Symbol".split( " " ),
 499 function( _i, name ) {
 500         class2type[ "[object " + name + "]" ] = name.toLowerCase();
 501 } );
 502
 503 function isArrayLike( obj ) {
 504
 505         // Support: real iOS 8.2 only (not reproducible in simulator)
 506         // `in` check used to prevent JIT error (gh-2145)
 507         // hasOwn isn't used here due to false negatives
 508         // regarding Nodelist length in IE
 509         var length = !!obj && "length" in obj && obj.length,
 510                 type = toType( obj );
 511
 512         if ( isFunction( obj ) || isWindow( obj ) ) {
 513                 return false;
 514         }
 515
 516         return type === "array" || length === 0 ||
 517                 typeof length === "number" && length > 0 && ( length - 1 ) in obj;
 518 }
 519 var Sizzle =
 520 /*!
 521  * Sizzle CSS Selector Engine v2.3.5
 522  * https://sizzlejs.com/
 523  *
 524  * Copyright JS Foundation and other contributors
 525  * Released under the MIT license
 526  * https://js.foundation/
 527  *
 528  * Date: 2020-03-14
 529  */
 530 ( function( window ) {
 531 var i,
 532         support,
 533         Expr,
 534         getText,
 535         isXML,
 536         tokenize,
 537         compile,
 538         select,
 539         outermostContext,
 540         sortInput,
 541         hasDuplicate,
 542
 543         // Local document vars
 544         setDocument,
 545         document,
 546         docElem,
 547         documentIsHTML,
 548         rbuggyQSA,
 549         rbuggyMatches,
 550         matches,
 551         contains,
 552
 553         // Instance-specific data
 554         expando = "sizzle" + 1 * new Date(),
 555         preferredDoc = window.document,
 556         dirruns = 0,
 557         done = 0,
 558         classCache = createCache(),
 559         tokenCache = createCache(),
 560         compilerCache = createCache(),
 561         nonnativeSelectorCache = createCache(),
 562         sortOrder = function( a, b ) {
 563                 if ( a === b ) {
 564                         hasDuplicate = true;
 565                 }
 566                 return 0;
 567         },
 568
 569         // Instance methods
 570         hasOwn = ( {} ).hasOwnProperty,
 571         arr = [],
 572         pop = arr.pop,
 573         pushNative = arr.push,
 574         push = arr.push,
 575         slice = arr.slice,
 576
 577         // Use a stripped-down indexOf as it's faster than native
 578         // https://jsperf.com/thor-indexof-vs-for/5
 579         indexOf = function( list, elem ) {
 580                 var i = 0,
 581                         len = list.length;
 582                 for ( ; i < len; i++ ) {
 583                         if ( list[ i ] === elem ) {
 584                                 return i;
 585                         }
 586                 }
 587                 return -1;
 588         },
 589
 590         booleans = "checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|" +
 591                 "ismap|loop|multiple|open|readonly|required|scoped",
 592
 593         // Regular expressions
 594
 595         // http://www.w3.org/TR/css3-selectors/#whitespace
 596         whitespace = "[\\x20\\t\\r\\n\\f]",
 597
 598         // https://www.w3.org/TR/css-syntax-3/#ident-token-diagram
 599         identifier = "(?:\\\\[\\da-fA-F]{1,6}" + whitespace +
 600                 "?|\\\\[^\\r\\n\\f]|[\\w-]|[^\0-\\x7f])+",
 601
 602         // Attribute selectors: http://www.w3.org/TR/selectors/#attribute-selectors
 603         attributes = "\\[" + whitespace + "*(" + identifier + ")(?:" + whitespace +
 604
 605                 // Operator (capture 2)
 606                 "*([*^$|!~]?=)" + whitespace +
 607
 608                 // "Attribute values must be CSS identifiers [capture 5]
 609                 // or strings [capture 3 or capture 4]"
 610                 "*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|(" + identifier + "))|)" +
 611                 whitespace + "*\\]",
 612
 613         pseudos = ":(" + identifier + ")(?:\\((" +
 614
 615                 // To reduce the number of selectors needing tokenize in the preFilter, prefer arguments:
 616                 // 1. quoted (capture 3; capture 4 or capture 5)
 617                 "('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|" +
 618
 619                 // 2. simple (capture 6)
 620                 "((?:\\\\.|[^\\\\()[\\]]|" + attributes + ")*)|" +
 621
 622                 // 3. anything else (capture 2)
 623                 ".*" +
 624                 ")\\)|)",
 625
 626         // Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter
 627         rwhitespace = new RegExp( whitespace + "+", "g" ),
 628         rtrim = new RegExp( "^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" +
 629                 whitespace + "+$", "g" ),
 630
 631         rcomma = new RegExp( "^" + whitespace + "*," + whitespace + "*" ),
 632         rcombinators = new RegExp( "^" + whitespace + "*([>+~]|" + whitespace + ")" + whitespace +
 633                 "*" ),
 634         rdescend = new RegExp( whitespace + "|>" ),
 635
 636         rpseudo = new RegExp( pseudos ),
 637         ridentifier = new RegExp( "^" + identifier + "$" ),
 638
 639         matchExpr = {
 640                 "ID": new RegExp( "^#(" + identifier + ")" ),
 641                 "CLASS": new RegExp( "^\\.(" + identifier + ")" ),
 642                 "TAG": new RegExp( "^(" + identifier + "|[*])" ),
 643                 "ATTR": new RegExp( "^" + attributes ),
 644                 "PSEUDO": new RegExp( "^" + pseudos ),
 645                 "CHILD": new RegExp( "^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(" +
 646                         whitespace + "*(even|odd|(([+-]|)(\\d*)n|)" + whitespace + "*(?:([+-]|)" +
 647                         whitespace + "*(\\d+)|))" + whitespace + "*\\)|)", "i" ),
 648                 "bool": new RegExp( "^(?:" + booleans + ")$", "i" ),
 649
 650                 // For use in libraries implementing .is()
 651                 // We use this for POS matching in `select`
 652                 "needsContext": new RegExp( "^" + whitespace +
 653                         "*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(" + whitespace +
 654                         "*((?:-\\d)?\\d*)" + whitespace + "*\\)|)(?=[^-]|$)", "i" )
 655         },
 656
 657         rhtml = /HTML$/i,
 658         rinputs = /^(?:input|select|textarea|button)$/i,
 659         rheader = /^h\d$/i,
 660
 661         rnative = /^[^{]+\{\s*\[native \w/,
 662
 663         // Easily-parseable/retrievable ID or TAG or CLASS selectors
 664         rquickExpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,
 665
 666         rsibling = /[+~]/,
 667
 668         // CSS escapes
 669         // http://www.w3.org/TR/CSS21/syndata.html#escaped-characters
 670         runescape = new RegExp( "\\\\[\\da-fA-F]{1,6}" + whitespace + "?|\\\\([^\\r\\n\\f])", "g" ),
 671         funescape = function( escape, nonHex ) {
 672                 var high = "0x" + escape.slice( 1 ) - 0x10000;
 673
 674                 return nonHex ?
 675
 676                         // Strip the backslash prefix from a non-hex escape sequence
 677                         nonHex :
 678
 679                         // Replace a hexadecimal escape sequence with the encoded Unicode code point
 680                         // Support: IE <=11+
 681                         // For values outside the Basic Multilingual Plane (BMP), manually construct a
 682                         // surrogate pair
 683                         high < 0 ?
 684                                 String.fromCharCode( high + 0x10000 ) :
 685                                 String.fromCharCode( high >> 10 | 0xD800, high & 0x3FF | 0xDC00 );
 686         },
 687
 688         // CSS string/identifier serialization
 689         // https://drafts.csswg.org/cssom/#common-serializing-idioms
 690         rcssescape = /([\0-\x1f\x7f]|^-?\d)|^-$|[^\0-\x1f\x7f-\uFFFF\w-]/g,
 691         fcssescape = function( ch, asCodePoint ) {
 692                 if ( asCodePoint ) {
 693
 694                         // U+0000 NULL becomes U+FFFD REPLACEMENT CHARACTER
 695                         if ( ch === "\0" ) {
 696                                 return "\uFFFD";
 697                         }
 698
 699                         // Control characters and (dependent upon position) numbers get escaped as code points
 700                         return ch.slice( 0, -1 ) + "\\" +
 701                                 ch.charCodeAt( ch.length - 1 ).toString( 16 ) + " ";
 702                 }
 703
 704                 // Other potentially-special ASCII characters get backslash-escaped
 705                 return "\\" + ch;
 706         },
 707
 708         // Used for iframes
 709         // See setDocument()
 710         // Removing the function wrapper causes a "Permission Denied"
 711         // error in IE
 712         unloadHandler = function() {
 713                 setDocument();
 714         },
 715
 716         inDisabledFieldset = addCombinator(
 717                 function( elem ) {
 718                         return elem.disabled === true && elem.nodeName.toLowerCase() === "fieldset";
 719                 },
 720                 { dir: "parentNode", next: "legend" }
 721         );
 722
 723 // Optimize for push.apply( _, NodeList )
 724 try {
 725         push.apply(
 726                 ( arr = slice.call( preferredDoc.childNodes ) ),
 727                 preferredDoc.childNodes
 728         );
 729
 730         // Support: Android<4.0
 731         // Detect silently failing push.apply
 732         // eslint-disable-next-line no-unused-expressions
 733         arr[ preferredDoc.childNodes.length ].nodeType;
 734 } catch ( e ) {
 735         push = { apply: arr.length ?
 736
 737                 // Leverage slice if possible
 738                 function( target, els ) {
 739                         pushNative.apply( target, slice.call( els ) );
 740                 } :
 741
 742                 // Support: IE<9
 743                 // Otherwise append directly
 744                 function( target, els ) {
 745                         var j = target.length,
 746                                 i = 0;
 747
 748                         // Can't trust NodeList.length
 749                         while ( ( target[ j++ ] = els[ i++ ] ) ) {}
 750                         target.length = j - 1;
 751                 }
 752         };
 753 }
 754
 755 function Sizzle( selector, context, results, seed ) {
 756         var m, i, elem, nid, match, groups, newSelector,
 757                 newContext = context && context.ownerDocument,
 758
 759                 // nodeType defaults to 9, since context defaults to document
 760                 nodeType = context ? context.nodeType : 9;
 761
 762         results = results || [];
 763
 764         // Return early from calls with invalid selector or context
 765         if ( typeof selector !== "string" || !selector ||
 766                 nodeType !== 1 && nodeType !== 9 && nodeType !== 11 ) {
 767
 768                 return results;
 769         }
 770
 771         // Try to shortcut find operations (as opposed to filters) in HTML documents
 772         if ( !seed ) {
 773                 setDocument( context );
 774                 context = context || document;
 775
 776                 if ( documentIsHTML ) {
 777
 778                         // If the selector is sufficiently simple, try using a "get*By*" DOM method
 779                         // (excepting DocumentFragment context, where the methods don't exist)
 780                         if ( nodeType !== 11 && ( match = rquickExpr.exec( selector ) ) ) {
 781
 782                                 // ID selector
 783                                 if ( ( m = match[ 1 ] ) ) {
 784
 785                                         // Document context
 786                                         if ( nodeType === 9 ) {
 787                                                 if ( ( elem = context.getElementById( m ) ) ) {
 788
 789                                                         // Support: IE, Opera, Webkit
 790                                                         // TODO: identify versions
 791                                                         // getElementById can match elements by name instead of ID
 792                                                         if ( elem.id === m ) {
 793                                                                 results.push( elem );
 794                                                                 return results;
 795                                                         }
 796                                                 } else {
 797                                                         return results;
 798                                                 }
 799
 800                                         // Element context
 801                                         } else {
 802
 803                                                 // Support: IE, Opera, Webkit
 804                                                 // TODO: identify versions
 805                                                 // getElementById can match elements by name instead of ID
 806                                                 if ( newContext && ( elem = newContext.getElementById( m ) ) &&
 807                                                         contains( context, elem ) &&
 808                                                         elem.id === m ) {
 809
 810                                                         results.push( elem );
 811                                                         return results;
 812                                                 }
 813                                         }
 814
 815                                 // Type selector
 816                                 } else if ( match[ 2 ] ) {
 817                                         push.apply( results, context.getElementsByTagName( selector ) );
 818                                         return results;
 819
 820                                 // Class selector
 821                                 } else if ( ( m = match[ 3 ] ) && support.getElementsByClassName &&
 822                                         context.getElementsByClassName ) {
 823
 824                                         push.apply( results, context.getElementsByClassName( m ) );
 825                                         return results;
 826                                 }
 827                         }
 828
 829                         // Take advantage of querySelectorAll
 830                         if ( support.qsa &&
 831                                 !nonnativeSelectorCache[ selector + " " ] &&
 832                                 ( !rbuggyQSA || !rbuggyQSA.test( selector ) ) &&
 833
 834                                 // Support: IE 8 only
 835                                 // Exclude object elements
 836                                 ( nodeType !== 1 || context.nodeName.toLowerCase() !== "object" ) ) {
 837
 838                                 newSelector = selector;
 839                                 newContext = context;
 840
 841                                 // qSA considers elements outside a scoping root when evaluating child or
 842                                 // descendant combinators, which is not what we want.
 843                                 // In such cases, we work around the behavior by prefixing every selector in the
 844                                 // list with an ID selector referencing the scope context.
 845                                 // The technique has to be used as well when a leading combinator is used
 846                                 // as such selectors are not recognized by querySelectorAll.
 847                                 // Thanks to Andrew Dupont for this technique.
 848                                 if ( nodeType === 1 &&
 849                                         ( rdescend.test( selector ) || rcombinators.test( selector ) ) ) {
 850
 851                                         // Expand context for sibling selectors
 852                                         newContext = rsibling.test( selector ) && testContext( context.parentNode ) ||
 853                                                 context;
 854
 855                                         // We can use :scope instead of the ID hack if the browser
 856                                         // supports it & if we're not changing the context.
 857                                         if ( newContext !== context || !support.scope ) {
 858
 859                                                 // Capture the context ID, setting it first if necessary
 860                                                 if ( ( nid = context.getAttribute( "id" ) ) ) {
 861                                                         nid = nid.replace( rcssescape, fcssescape );
 862                                                 } else {
 863                                                         context.setAttribute( "id", ( nid = expando ) );
 864                                                 }
 865                                         }
 866
 867                                         // Prefix every selector in the list
 868                                         groups = tokenize( selector );
 869                                         i = groups.length;
 870                                         while ( i-- ) {
 871                                                 groups[ i ] = ( nid ? "#" + nid : ":scope" ) + " " +
 872                                                         toSelector( groups[ i ] );
 873                                         }
 874                                         newSelector = groups.join( "," );
 875                                 }
 876
 877                                 try {
 878                                         push.apply( results,
 879                                                 newContext.querySelectorAll( newSelector )
 880                                         );
 881                                         return results;
 882                                 } catch ( qsaError ) {
 883                                         nonnativeSelectorCache( selector, true );
 884                                 } finally {
 885                                         if ( nid === expando ) {
 886                                                 context.removeAttribute( "id" );
 887                                         }
 888                                 }
 889                         }
 890                 }
 891         }
 892
 893         // All others
 894         return select( selector.replace( rtrim, "$1" ), context, results, seed );
 895 }
 896
 897 /**
 898  * Create key-value caches of limited size
 899  * @returns {function(string, object)} Returns the Object data after storing it on itself with
 900  *      property name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength)
 901  *      deleting the oldest entry
 902  */
 903 function createCache() {
 904         var keys = [];
 905
 906         function cache( key, value ) {
 907
 908                 // Use (key + " ") to avoid collision with native prototype properties (see Issue #157)
 909                 if ( keys.push( key + " " ) > Expr.cacheLength ) {
 910
 911                         // Only keep the most recent entries
 912                         delete cache[ keys.shift() ];
 913                 }
 914                 return ( cache[ key + " " ] = value );
 915         }
 916         return cache;
 917 }
 918
 919 /**
 920  * Mark a function for special use by Sizzle
 921  * @param {Function} fn The function to mark
 922  */
 923 function markFunction( fn ) {
 924         fn[ expando ] = true;
 925         return fn;
 926 }
 927
 928 /**
 929  * Support testing using an element
 930  * @param {Function} fn Passed the created element and returns a boolean result
 931  */
 932 function assert( fn ) {
 933         var el = document.createElement( "fieldset" );
 934
 935         try {
 936                 return !!fn( el );
 937         } catch ( e ) {
 938                 return false;
 939         } finally {
 940
 941                 // Remove from its parent by default
 942                 if ( el.parentNode ) {
 943                         el.parentNode.removeChild( el );
 944                 }
 945
 946                 // release memory in IE
 947                 el = null;
 948         }
 949 }
 950
 951 /**
 952  * Adds the same handler for all of the specified attrs
 953  * @param {String} attrs Pipe-separated list of attributes
 954  * @param {Function} handler The method that will be applied
 955  */
 956 function addHandle( attrs, handler ) {
 957         var arr = attrs.split( "|" ),
 958                 i = arr.length;
 959
 960         while ( i-- ) {
 961                 Expr.attrHandle[ arr[ i ] ] = handler;
 962         }
 963 }
 964
 965 /**
 966  * Checks document order of two siblings
 967  * @param {Element} a
 968  * @param {Element} b
 969  * @returns {Number} Returns less than 0 if a precedes b, greater than 0 if a follows b
 970  */
 971 function siblingCheck( a, b ) {
 972         var cur = b && a,
 973                 diff = cur && a.nodeType === 1 && b.nodeType === 1 &&
 974                         a.sourceIndex - b.sourceIndex;
 975
 976         // Use IE sourceIndex if available on both nodes
 977         if ( diff ) {
 978                 return diff;
 979         }
 980
 981         // Check if b follows a
 982         if ( cur ) {
 983                 while ( ( cur = cur.nextSibling ) ) {
 984                         if ( cur === b ) {
 985                                 return -1;
 986                         }
 987                 }
 988         }
 989
 990         return a ? 1 : -1;
 991 }
 992
 993 /**
 994  * Returns a function to use in pseudos for input types
 995  * @param {String} type
 996  */
 997 function createInputPseudo( type ) {
 998         return function( elem ) {
 999                 var name = elem.nodeName.toLowerCase();
1000                 return name === "input" && elem.type === type;
1001         };
1002 }
1003
1004 /**
1005  * Returns a function to use in pseudos for buttons
1006  * @param {String} type
1007  */
1008 function createButtonPseudo( type ) {
1009         return function( elem ) {
1010                 var name = elem.nodeName.toLowerCase();
1011                 return ( name === "input" || name === "button" ) && elem.type === type;
1012         };
1013 }
1014
1015 /**
1016  * Returns a function to use in pseudos for :enabled/:disabled
1017  * @param {Boolean} disabled true for :disabled; false for :enabled
1018  */
1019 function createDisabledPseudo( disabled ) {
1020
1021         // Known :disabled false positives: fieldset[disabled] > legend:nth-of-type(n+2) :can-disable
1022         return function( elem ) {
1023
1024                 // Only certain elements can match :enabled or :disabled
1025                 // https://html.spec.whatwg.org/multipage/scripting.html#selector-enabled
1026                 // https://html.spec.whatwg.org/multipage/scripting.html#selector-disabled
1027                 if ( "form" in elem ) {
1028
1029                         // Check for inherited disabledness on relevant non-disabled elements:
1030                         // * listed form-associated elements in a disabled fieldset
1031                         //   https://html.spec.whatwg.org/multipage/forms.html#category-listed
1032                         //   https://html.spec.whatwg.org/multipage/forms.html#concept-fe-disabled
1033                         // * option elements in a disabled optgroup
1034                         //   https://html.spec.whatwg.org/multipage/forms.html#concept-option-disabled
1035                         // All such elements have a "form" property.
1036                         if ( elem.parentNode && elem.disabled === false ) {
1037
1038                                 // Option elements defer to a parent optgroup if present
1039                                 if ( "label" in elem ) {
1040                                         if ( "label" in elem.parentNode ) {
1041                                                 return elem.parentNode.disabled === disabled;
1042                                         } else {
1043                                                 return elem.disabled === disabled;
1044                                         }
1045                                 }
1046
1047                                 // Support: IE 6 - 11
1048                                 // Use the isDisabled shortcut property to check for disabled fieldset ancestors
1049                                 return elem.isDisabled === disabled ||
1050
1051                                         // Where there is no isDisabled, check manually
1052                                         /* jshint -W018 */
1053                                         elem.isDisabled !== !disabled &&
1054                                         inDisabledFieldset( elem ) === disabled;
1055                         }
1056
1057                         return elem.disabled === disabled;
1058
1059                 // Try to winnow out elements that can't be disabled before trusting the disabled property.
1060                 // Some victims get caught in our net (label, legend, menu, track), but it shouldn't
1061                 // even exist on them, let alone have a boolean value.
1062                 } else if ( "label" in elem ) {
1063                         return elem.disabled === disabled;
1064                 }
1065
1066                 // Remaining elements are neither :enabled nor :disabled
1067                 return false;
1068         };
1069 }
1070
1071 /**
1072  * Returns a function to use in pseudos for positionals
1073  * @param {Function} fn
1074  */
1075 function createPositionalPseudo( fn ) {
1076         return markFunction( function( argument ) {
1077                 argument = +argument;
1078                 return markFunction( function( seed, matches ) {
1079                         var j,
1080                                 matchIndexes = fn( [], seed.length, argument ),
1081                                 i = matchIndexes.length;
1082
1083                         // Match elements found at the specified indexes
1084                         while ( i-- ) {
1085                                 if ( seed[ ( j = matchIndexes[ i ] ) ] ) {
1086                                         seed[ j ] = !( matches[ j ] = seed[ j ] );
1087                                 }
1088                         }
1089                 } );
1090         } );
1091 }
1092
1093 /**
1094  * Checks a node for validity as a Sizzle context
1095  * @param {Element|Object=} context
1096  * @returns {Element|Object|Boolean} The input node if acceptable, otherwise a falsy value
1097  */
1098 function testContext( context ) {
1099         return context && typeof context.getElementsByTagName !== "undefined" && context;
1100 }
1101
1102 // Expose support vars for convenience
1103 support = Sizzle.support = {};
1104
1105 /**
1106  * Detects XML nodes
1107  * @param {Element|Object} elem An element or a document
1108  * @returns {Boolean} True iff elem is a non-HTML XML node
1109  */
1110 isXML = Sizzle.isXML = function( elem ) {
1111         var namespace = elem.namespaceURI,
1112                 docElem = ( elem.ownerDocument || elem ).documentElement;
1113
1114         // Support: IE <=8
1115         // Assume HTML when documentElement doesn't yet exist, such as inside loading iframes
1116         // https://bugs.jquery.com/ticket/4833
1117         return !rhtml.test( namespace || docElem && docElem.nodeName || "HTML" );
1118 };
1119
1120 /**
1121  * Sets document-related variables once based on the current document
1122  * @param {Element|Object} [doc] An element or document object to use to set the document
1123  * @returns {Object} Returns the current document
1124  */
1125 setDocument = Sizzle.setDocument = function( node ) {
1126         var hasCompare, subWindow,
1127                 doc = node ? node.ownerDocument || node : preferredDoc;
1128
1129         // Return early if doc is invalid or already selected
1130         // Support: IE 11+, Edge 17 - 18+
1131         // IE/Edge sometimes throw a "Permission denied" error when strict-comparing
1132         // two documents; shallow comparisons work.
1133         // eslint-disable-next-line eqeqeq
1134         if ( doc == document || doc.nodeType !== 9 || !doc.documentElement ) {
1135                 return document;
1136         }
1137
1138         // Update global variables
1139         document = doc;
1140         docElem = document.documentElement;
1141         documentIsHTML = !isXML( document );
1142
1143         // Support: IE 9 - 11+, Edge 12 - 18+
1144         // Accessing iframe documents after unload throws "permission denied" errors (jQuery #13936)
1145         // Support: IE 11+, Edge 17 - 18+
1146         // IE/Edge sometimes throw a "Permission denied" error when strict-comparing
1147         // two documents; shallow comparisons work.
1148         // eslint-disable-next-line eqeqeq
1149         if ( preferredDoc != document &&
1150                 ( subWindow = document.defaultView ) && subWindow.top !== subWindow ) {
1151
1152                 // Support: IE 11, Edge
1153                 if ( subWindow.addEventListener ) {
1154                         subWindow.addEventListener( "unload", unloadHandler, false );
1155
1156                 // Support: IE 9 - 10 only
1157                 } else if ( subWindow.attachEvent ) {
1158                         subWindow.attachEvent( "onunload", unloadHandler );
1159                 }
1160         }
1161
1162         // Support: IE 8 - 11+, Edge 12 - 18+, Chrome <=16 - 25 only, Firefox <=3.6 - 31 only,
1163         // Safari 4 - 5 only, Opera <=11.6 - 12.x only
1164         // IE/Edge & older browsers don't support the :scope pseudo-class.
1165         // Support: Safari 6.0 only
1166         // Safari 6.0 supports :scope but it's an alias of :root there.
1167         support.scope = assert( function( el ) {
1168                 docElem.appendChild( el ).appendChild( document.createElement( "div" ) );
1169                 return typeof el.querySelectorAll !== "undefined" &&
1170                         !el.querySelectorAll( ":scope fieldset div" ).length;
1171         } );
1172
1173         /* Attributes
1174         ---------------------------------------------------------------------- */
1175
1176         // Support: IE<8
1177         // Verify that getAttribute really returns attributes and not properties
1178         // (excepting IE8 booleans)
1179         support.attributes = assert( function( el ) {
1180                 el.className = "i";
1181                 return !el.getAttribute( "className" );
1182         } );
1183
1184         /* getElement(s)By*
1185         ---------------------------------------------------------------------- */
1186
1187         // Check if getElementsByTagName("*") returns only elements
1188         support.getElementsByTagName = assert( function( el ) {
1189                 el.appendChild( document.createComment( "" ) );
1190                 return !el.getElementsByTagName( "*" ).length;
1191         } );
1192
1193         // Support: IE<9
1194         support.getElementsByClassName = rnative.test( document.getElementsByClassName );
1195
1196         // Support: IE<10
1197         // Check if getElementById returns elements by name
1198         // The broken getElementById methods don't pick up programmatically-set names,
1199         // so use a roundabout getElementsByName test
1200         support.getById = assert( function( el ) {
1201                 docElem.appendChild( el ).id = expando;
1202                 return !document.getElementsByName || !document.getElementsByName( expando ).length;
1203         } );
1204
1205         // ID filter and find
1206         if ( support.getById ) {
1207                 Expr.filter[ "ID" ] = function( id ) {
1208                         var attrId = id.replace( runescape, funescape );
1209                         return function( elem ) {
1210                                 return elem.getAttribute( "id" ) === attrId;
1211                         };
1212                 };
1213                 Expr.find[ "ID" ] = function( id, context ) {
1214                         if ( typeof context.getElementById !== "undefined" && documentIsHTML ) {
1215                                 var elem = context.getElementById( id );
1216                                 return elem ? [ elem ] : [];
1217                         }
1218                 };
1219         } else {
1220                 Expr.filter[ "ID" ] =  function( id ) {
1221                         var attrId = id.replace( runescape, funescape );
1222                         return function( elem ) {
1223                                 var node = typeof elem.getAttributeNode !== "undefined" &&
1224                                         elem.getAttributeNode( "id" );
1225                                 return node && node.value === attrId;
1226                         };
1227                 };
1228
1229                 // Support: IE 6 - 7 only
1230                 // getElementById is not reliable as a find shortcut
1231                 Expr.find[ "ID" ] = function( id, context ) {
1232                         if ( typeof context.getElementById !== "undefined" && documentIsHTML ) {
1233                                 var node, i, elems,
1234                                         elem = context.getElementById( id );
1235
1236                                 if ( elem ) {
1237
1238                                         // Verify the id attribute
1239                                         node = elem.getAttributeNode( "id" );
1240                                         if ( node && node.value === id ) {
1241                                                 return [ elem ];
1242                                         }
1243
1244                                         // Fall back on getElementsByName
1245                                         elems = context.getElementsByName( id );
1246                                         i = 0;
1247                                         while ( ( elem = elems[ i++ ] ) ) {
1248                                                 node = elem.getAttributeNode( "id" );
1249                                                 if ( node && node.value === id ) {
1250                                                         return [ elem ];
1251                                                 }
1252                                         }
1253                                 }
1254
1255                                 return [];
1256                         }
1257                 };
1258         }
1259
1260         // Tag
1261         Expr.find[ "TAG" ] = support.getElementsByTagName ?
1262                 function( tag, context ) {
1263                         if ( typeof context.getElementsByTagName !== "undefined" ) {
1264                                 return context.getElementsByTagName( tag );
1265
1266                         // DocumentFragment nodes don't have gEBTN
1267                         } else if ( support.qsa ) {
1268                                 return context.querySelectorAll( tag );
1269                         }
1270                 } :
1271
1272                 function( tag, context ) {
1273                         var elem,
1274                                 tmp = [],
1275                                 i = 0,
1276
1277                                 // By happy coincidence, a (broken) gEBTN appears on DocumentFragment nodes too
1278                                 results = context.getElementsByTagName( tag );
1279
1280                         // Filter out possible comments
1281                         if ( tag === "*" ) {
1282                                 while ( ( elem = results[ i++ ] ) ) {
1283                                         if ( elem.nodeType === 1 ) {
1284                                                 tmp.push( elem );
1285                                         }
1286                                 }
1287
1288                                 return tmp;
1289                         }
1290                         return results;
1291                 };
1292
1293         // Class
1294         Expr.find[ "CLASS" ] = support.getElementsByClassName && function( className, context ) {
1295                 if ( typeof context.getElementsByClassName !== "undefined" && documentIsHTML ) {
1296                         return context.getElementsByClassName( className );
1297                 }
1298         };
1299
1300         /* QSA/matchesSelector
1301         ---------------------------------------------------------------------- */
1302
1303         // QSA and matchesSelector support
1304
1305         // matchesSelector(:active) reports false when true (IE9/Opera 11.5)
1306         rbuggyMatches = [];
1307
1308         // qSa(:focus) reports false when true (Chrome 21)
1309         // We allow this because of a bug in IE8/9 that throws an error
1310         // whenever `document.activeElement` is accessed on an iframe
1311         // So, we allow :focus to pass through QSA all the time to avoid the IE error
1312         // See https://bugs.jquery.com/ticket/13378
1313         rbuggyQSA = [];
1314
1315         if ( ( support.qsa = rnative.test( document.querySelectorAll ) ) ) {
1316
1317                 // Build QSA regex
1318                 // Regex strategy adopted from Diego Perini
1319                 assert( function( el ) {
1320
1321                         var input;
1322
1323                         // Select is set to empty string on purpose
1324                         // This is to test IE's treatment of not explicitly
1325                         // setting a boolean content attribute,
1326                         // since its presence should be enough
1327                         // https://bugs.jquery.com/ticket/12359
1328                         docElem.appendChild( el ).innerHTML = "<a id='" + expando + "'></a>" +
1329                                 "<select id='" + expando + "-\r\\' msallowcapture=''>" +
1330                                 "<option selected=''></option></select>";
1331
1332                         // Support: IE8, Opera 11-12.16
1333                         // Nothing should be selected when empty strings follow ^= or $= or *=
1334                         // The test attribute must be unknown in Opera but "safe" for WinRT
1335                         // https://msdn.microsoft.com/en-us/library/ie/hh465388.aspx#attribute_section
1336                         if ( el.querySelectorAll( "[msallowcapture^='']" ).length ) {
1337                                 rbuggyQSA.push( "[*^$]=" + whitespace + "*(?:''|\"\")" );
1338                         }
1339
1340                         // Support: IE8
1341                         // Boolean attributes and "value" are not treated correctly
1342                         if ( !el.querySelectorAll( "[selected]" ).length ) {
1343                                 rbuggyQSA.push( "\\[" + whitespace + "*(?:value|" + booleans + ")" );
1344                         }
1345
1346                         // Support: Chrome<29, Android<4.4, Safari<7.0+, iOS<7.0+, PhantomJS<1.9.8+
1347                         if ( !el.querySelectorAll( "[id~=" + expando + "-]" ).length ) {
1348                                 rbuggyQSA.push( "~=" );
1349                         }
1350
1351                         // Support: IE 11+, Edge 15 - 18+
1352                         // IE 11/Edge don't find elements on a `[name='']` query in some cases.
1353                         // Adding a temporary attribute to the document before the selection works
1354                         // around the issue.
1355                         // Interestingly, IE 10 & older don't seem to have the issue.
1356                         input = document.createElement( "input" );
1357                         input.setAttribute( "name", "" );
1358                         el.appendChild( input );
1359                         if ( !el.querySelectorAll( "[name='']" ).length ) {
1360                                 rbuggyQSA.push( "\\[" + whitespace + "*name" + whitespace + "*=" +
1361                                         whitespace + "*(?:''|\"\")" );
1362                         }
1363
1364                         // Webkit/Opera - :checked should return selected option elements
1365                         // http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
1366                         // IE8 throws error here and will not see later tests
1367                         if ( !el.querySelectorAll( ":checked" ).length ) {
1368                                 rbuggyQSA.push( ":checked" );
1369                         }
1370
1371                         // Support: Safari 8+, iOS 8+
1372                         // https://bugs.webkit.org/show_bug.cgi?id=136851
1373                         // In-page `selector#id sibling-combinator selector` fails
1374                         if ( !el.querySelectorAll( "a#" + expando + "+*" ).length ) {
1375                                 rbuggyQSA.push( ".#.+[+~]" );
1376                         }
1377
1378                         // Support: Firefox <=3.6 - 5 only
1379                         // Old Firefox doesn't throw on a badly-escaped identifier.
1380                         el.querySelectorAll( "\\\f" );
1381                         rbuggyQSA.push( "[\\r\\n\\f]" );
1382                 } );
1383
1384                 assert( function( el ) {
1385                         el.innerHTML = "<a href='' disabled='disabled'></a>" +
1386                                 "<select disabled='disabled'><option/></select>";
1387
1388                         // Support: Windows 8 Native Apps
1389                         // The type and name attributes are restricted during .innerHTML assignment
1390                         var input = document.createElement( "input" );
1391                         input.setAttribute( "type", "hidden" );
1392                         el.appendChild( input ).setAttribute( "name", "D" );
1393
1394                         // Support: IE8
1395                         // Enforce case-sensitivity of name attribute
1396                         if ( el.querySelectorAll( "[name=d]" ).length ) {
1397                                 rbuggyQSA.push( "name" + whitespace + "*[*^$|!~]?=" );
1398                         }
1399
1400                         // FF 3.5 - :enabled/:disabled and hidden elements (hidden elements are still enabled)
1401                         // IE8 throws error here and will not see later tests
1402                         if ( el.querySelectorAll( ":enabled" ).length !== 2 ) {
1403                                 rbuggyQSA.push( ":enabled", ":disabled" );
1404                         }
1405
1406                         // Support: IE9-11+
1407                         // IE's :disabled selector does not pick up the children of disabled fieldsets
1408                         docElem.appendChild( el ).disabled = true;
1409                         if ( el.querySelectorAll( ":disabled" ).length !== 2 ) {
1410                                 rbuggyQSA.push( ":enabled", ":disabled" );
1411                         }
1412
1413                         // Support: Opera 10 - 11 only
1414                         // Opera 10-11 does not throw on post-comma invalid pseudos
1415                         el.querySelectorAll( "*,:x" );
1416                         rbuggyQSA.push( ",.*:" );
1417                 } );
1418         }
1419
1420         if ( ( support.matchesSelector = rnative.test( ( matches = docElem.matches ||
1421                 docElem.webkitMatchesSelector ||
1422                 docElem.mozMatchesSelector ||
1423                 docElem.oMatchesSelector ||
1424                 docElem.msMatchesSelector ) ) ) ) {
1425
1426                 assert( function( el ) {
1427
1428                         // Check to see if it's possible to do matchesSelector
1429                         // on a disconnected node (IE 9)
1430                         support.disconnectedMatch = matches.call( el, "*" );
1431
1432                         // This should fail with an exception
1433                         // Gecko does not error, returns false instead
1434                         matches.call( el, "[s!='']:x" );
1435                         rbuggyMatches.push( "!=", pseudos );
1436                 } );
1437         }
1438
1439         rbuggyQSA = rbuggyQSA.length && new RegExp( rbuggyQSA.join( "|" ) );
1440         rbuggyMatches = rbuggyMatches.length && new RegExp( rbuggyMatches.join( "|" ) );
1441
1442         /* Contains
1443         ---------------------------------------------------------------------- */
1444         hasCompare = rnative.test( docElem.compareDocumentPosition );
1445
1446         // Element contains another
1447         // Purposefully self-exclusive
1448         // As in, an element does not contain itself
1449         contains = hasCompare || rnative.test( docElem.contains ) ?
1450                 function( a, b ) {
1451                         var adown = a.nodeType === 9 ? a.documentElement : a,
1452                                 bup = b && b.parentNode;
1453                         return a === bup || !!( bup && bup.nodeType === 1 && (
1454                                 adown.contains ?
1455                                         adown.contains( bup ) :
1456                                         a.compareDocumentPosition && a.compareDocumentPosition( bup ) & 16
1457                         ) );
1458                 } :
1459                 function( a, b ) {
1460                         if ( b ) {
1461                                 while ( ( b = b.parentNode ) ) {
1462                                         if ( b === a ) {
1463                                                 return true;
1464                                         }
1465                                 }
1466                         }
1467                         return false;
1468                 };
1469
1470         /* Sorting
1471         ---------------------------------------------------------------------- */
1472
1473         // Document order sorting
1474         sortOrder = hasCompare ?
1475         function( a, b ) {
1476
1477                 // Flag for duplicate removal
1478                 if ( a === b ) {
1479                         hasDuplicate = true;
1480                         return 0;
1481                 }
1482
1483                 // Sort on method existence if only one input has compareDocumentPosition
1484                 var compare = !a.compareDocumentPosition - !b.compareDocumentPosition;
1485                 if ( compare ) {
1486                         return compare;
1487                 }
1488
1489                 // Calculate position if both inputs belong to the same document
1490                 // Support: IE 11+, Edge 17 - 18+
1491                 // IE/Edge sometimes throw a "Permission denied" error when strict-comparing
1492                 // two documents; shallow comparisons work.
1493                 // eslint-disable-next-line eqeqeq
1494                 compare = ( a.ownerDocument || a ) == ( b.ownerDocument || b ) ?
1495                         a.compareDocumentPosition( b ) :
1496
1497                         // Otherwise we know they are disconnected
1498                         1;
1499
1500                 // Disconnected nodes
1501                 if ( compare & 1 ||
1502                         ( !support.sortDetached && b.compareDocumentPosition( a ) === compare ) ) {
1503
1504                         // Choose the first element that is related to our preferred document
1505                         // Support: IE 11+, Edge 17 - 18+
1506                         // IE/Edge sometimes throw a "Permission denied" error when strict-comparing
1507                         // two documents; shallow comparisons work.
1508                         // eslint-disable-next-line eqeqeq
1509                         if ( a == document || a.ownerDocument == preferredDoc &&
1510                                 contains( preferredDoc, a ) ) {
1511                                 return -1;
1512                         }
1513
1514                         // Support: IE 11+, Edge 17 - 18+
1515                         // IE/Edge sometimes throw a "Permission denied" error when strict-comparing
1516                         // two documents; shallow comparisons work.
1517                         // eslint-disable-next-line eqeqeq
1518                         if ( b == document || b.ownerDocument == preferredDoc &&
1519                                 contains( preferredDoc, b ) ) {
1520                                 return 1;
1521                         }
1522
1523                         // Maintain original order
1524                         return sortInput ?
1525                                 ( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) :
1526                                 0;
1527                 }
1528
1529                 return compare & 4 ? -1 : 1;
1530         } :
1531         function( a, b ) {
1532
1533                 // Exit early if the nodes are identical
1534                 if ( a === b ) {
1535                         hasDuplicate = true;
1536                         return 0;
1537                 }
1538
1539                 var cur,
1540                         i = 0,
1541                         aup = a.parentNode,
1542                         bup = b.parentNode,
1543                         ap = [ a ],
1544                         bp = [ b ];
1545
1546                 // Parentless nodes are either documents or disconnected
1547                 if ( !aup || !bup ) {
1548
1549                         // Support: IE 11+, Edge 17 - 18+
1550                         // IE/Edge sometimes throw a "Permission denied" error when strict-comparing
1551                         // two documents; shallow comparisons work.
1552                         /* eslint-disable eqeqeq */
1553                         return a == document ? -1 :
1554                                 b == document ? 1 :
1555                                 /* eslint-enable eqeqeq */
1556                                 aup ? -1 :
1557                                 bup ? 1 :
1558                                 sortInput ?
1559                                 ( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) :
1560                                 0;
1561
1562                 // If the nodes are siblings, we can do a quick check
1563                 } else if ( aup === bup ) {
1564                         return siblingCheck( a, b );
1565                 }
1566
1567                 // Otherwise we need full lists of their ancestors for comparison
1568                 cur = a;
1569                 while ( ( cur = cur.parentNode ) ) {
1570                         ap.unshift( cur );
1571                 }
1572                 cur = b;
1573                 while ( ( cur = cur.parentNode ) ) {
1574                         bp.unshift( cur );
1575                 }
1576
1577                 // Walk down the tree looking for a discrepancy
1578                 while ( ap[ i ] === bp[ i ] ) {
1579                         i++;
1580                 }
1581
1582                 return i ?
1583
1584                         // Do a sibling check if the nodes have a common ancestor
1585                         siblingCheck( ap[ i ], bp[ i ] ) :
1586
1587                         // Otherwise nodes in our document sort first
1588                         // Support: IE 11+, Edge 17 - 18+
1589                         // IE/Edge sometimes throw a "Permission denied" error when strict-comparing
1590                         // two documents; shallow comparisons work.
1591                         /* eslint-disable eqeqeq */
1592                         ap[ i ] == preferredDoc ? -1 :
1593                         bp[ i ] == preferredDoc ? 1 :
1594                         /* eslint-enable eqeqeq */
1595                         0;
1596         };
1597
1598         return document;
1599 };
1600
1601 Sizzle.matches = function( expr, elements ) {
1602         return Sizzle( expr, null, null, elements );
1603 };
1604
1605 Sizzle.matchesSelector = function( elem, expr ) {
1606         setDocument( elem );
1607
1608         if ( support.matchesSelector && documentIsHTML &&
1609                 !nonnativeSelectorCache[ expr + " " ] &&
1610                 ( !rbuggyMatches || !rbuggyMatches.test( expr ) ) &&
1611                 ( !rbuggyQSA     || !rbuggyQSA.test( expr ) ) ) {
1612
1613                 try {
1614                         var ret = matches.call( elem, expr );
1615
1616                         // IE 9's matchesSelector returns false on disconnected nodes
1617                         if ( ret || support.disconnectedMatch ||
1618
1619                                 // As well, disconnected nodes are said to be in a document
1620                                 // fragment in IE 9
1621                                 elem.document && elem.document.nodeType !== 11 ) {
1622                                 return ret;
1623                         }
1624                 } catch ( e ) {
1625                         nonnativeSelectorCache( expr, true );
1626                 }
1627         }
1628
1629         return Sizzle( expr, document, null, [ elem ] ).length > 0;
1630 };
1631
1632 Sizzle.contains = function( context, elem ) {
1633
1634         // Set document vars if needed
1635         // Support: IE 11+, Edge 17 - 18+
1636         // IE/Edge sometimes throw a "Permission denied" error when strict-comparing
1637         // two documents; shallow comparisons work.
1638         // eslint-disable-next-line eqeqeq
1639         if ( ( context.ownerDocument || context ) != document ) {
1640                 setDocument( context );
1641         }
1642         return contains( context, elem );
1643 };
1644
1645 Sizzle.attr = function( elem, name ) {
1646
1647         // Set document vars if needed
1648         // Support: IE 11+, Edge 17 - 18+
1649         // IE/Edge sometimes throw a "Permission denied" error when strict-comparing
1650         // two documents; shallow comparisons work.
1651         // eslint-disable-next-line eqeqeq
1652         if ( ( elem.ownerDocument || elem ) != document ) {
1653                 setDocument( elem );
1654         }
1655
1656         var fn = Expr.attrHandle[ name.toLowerCase() ],
1657
1658                 // Don't get fooled by Object.prototype properties (jQuery #13807)
1659                 val = fn && hasOwn.call( Expr.attrHandle, name.toLowerCase() ) ?
1660                         fn( elem, name, !documentIsHTML ) :
1661                         undefined;
1662
1663         return val !== undefined ?
1664                 val :
1665                 support.attributes || !documentIsHTML ?
1666                         elem.getAttribute( name ) :
1667                         ( val = elem.getAttributeNode( name ) ) && val.specified ?
1668                                 val.value :
1669                                 null;
1670 };
1671
1672 Sizzle.escape = function( sel ) {
1673         return ( sel + "" ).replace( rcssescape, fcssescape );
1674 };
1675
1676 Sizzle.error = function( msg ) {
1677         throw new Error( "Syntax error, unrecognized expression: " + msg );
1678 };
1679
1680 /**
1681  * Document sorting and removing duplicates
1682  * @param {ArrayLike} results
1683  */
1684 Sizzle.uniqueSort = function( results ) {
1685         var elem,
1686                 duplicates = [],
1687                 j = 0,
1688                 i = 0;
1689
1690         // Unless we *know* we can detect duplicates, assume their presence
1691         hasDuplicate = !support.detectDuplicates;
1692         sortInput = !support.sortStable && results.slice( 0 );
1693         results.sort( sortOrder );
1694
1695         if ( hasDuplicate ) {
1696                 while ( ( elem = results[ i++ ] ) ) {
1697                         if ( elem === results[ i ] ) {
1698                                 j = duplicates.push( i );
1699                         }
1700                 }
1701                 while ( j-- ) {
1702                         results.splice( duplicates[ j ], 1 );
1703                 }
1704         }
1705
1706         // Clear input after sorting to release objects
1707         // See https://github.com/jquery/sizzle/pull/225
1708         sortInput = null;
1709
1710         return results;
1711 };
1712
1713 /**
1714  * Utility function for retrieving the text value of an array of DOM nodes
1715  * @param {Array|Element} elem
1716  */
1717 getText = Sizzle.getText = function( elem ) {
1718         var node,
1719                 ret = "",
1720                 i = 0,
1721                 nodeType = elem.nodeType;
1722
1723         if ( !nodeType ) {
1724
1725                 // If no nodeType, this is expected to be an array
1726                 while ( ( node = elem[ i++ ] ) ) {
1727
1728                         // Do not traverse comment nodes
1729                         ret += getText( node );
1730                 }
1731         } else if ( nodeType === 1 || nodeType === 9 || nodeType === 11 ) {
1732
1733                 // Use textContent for elements
1734                 // innerText usage removed for consistency of new lines (jQuery #11153)
1735                 if ( typeof elem.textContent === "string" ) {
1736                         return elem.textContent;
1737                 } else {
1738
1739                         // Traverse its children
1740                         for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
1741                                 ret += getText( elem );
1742                         }
1743                 }
1744         } else if ( nodeType === 3 || nodeType === 4 ) {
1745                 return elem.nodeValue;
1746         }
1747
1748         // Do not include comment or processing instruction nodes
1749
1750         return ret;
1751 };
1752
1753 Expr = Sizzle.selectors = {
1754
1755         // Can be adjusted by the user
1756         cacheLength: 50,
1757
1758         createPseudo: markFunction,
1759
1760         match: matchExpr,
1761
1762         attrHandle: {},
1763
1764         find: {},
1765
1766         relative: {
1767                 ">": { dir: "parentNode", first: true },
1768                 " ": { dir: "parentNode" },
1769                 "+": { dir: "previousSibling", first: true },
1770                 "~": { dir: "previousSibling" }
1771         },
1772
1773         preFilter: {
1774                 "ATTR": function( match ) {
1775                         match[ 1 ] = match[ 1 ].replace( runescape, funescape );
1776
1777                         // Move the given value to match[3] whether quoted or unquoted
1778                         match[ 3 ] = ( match[ 3 ] || match[ 4 ] ||
1779                                 match[ 5 ] || "" ).replace( runescape, funescape );
1780
1781                         if ( match[ 2 ] === "~=" ) {
1782                                 match[ 3 ] = " " + match[ 3 ] + " ";
1783                         }
1784
1785                         return match.slice( 0, 4 );
1786                 },
1787
1788                 "CHILD": function( match ) {
1789
1790                         /* matches from matchExpr["CHILD"]
1791                                 1 type (only|nth|...)
1792                                 2 what (child|of-type)
1793                                 3 argument (even|odd|\d*|\d*n([+-]\d+)?|...)
1794                                 4 xn-component of xn+y argument ([+-]?\d*n|)
1795                                 5 sign of xn-component
1796                                 6 x of xn-component
1797                                 7 sign of y-component
1798                                 8 y of y-component
1799                         */
1800                         match[ 1 ] = match[ 1 ].toLowerCase();
1801
1802                         if ( match[ 1 ].slice( 0, 3 ) === "nth" ) {
1803
1804                                 // nth-* requires argument
1805                                 if ( !match[ 3 ] ) {
1806                                         Sizzle.error( match[ 0 ] );
1807                                 }
1808
1809                                 // numeric x and y parameters for Expr.filter.CHILD
1810                                 // remember that false/true cast respectively to 0/1
1811                                 match[ 4 ] = +( match[ 4 ] ?
1812                                         match[ 5 ] + ( match[ 6 ] || 1 ) :
1813                                         2 * ( match[ 3 ] === "even" || match[ 3 ] === "odd" ) );
1814                                 match[ 5 ] = +( ( match[ 7 ] + match[ 8 ] ) || match[ 3 ] === "odd" );
1815
1816                                 // other types prohibit arguments
1817                         } else if ( match[ 3 ] ) {
1818                                 Sizzle.error( match[ 0 ] );
1819                         }
1820
1821                         return match;
1822                 },
1823
1824                 "PSEUDO": function( match ) {
1825                         var excess,
1826                                 unquoted = !match[ 6 ] && match[ 2 ];
1827
1828                         if ( matchExpr[ "CHILD" ].test( match[ 0 ] ) ) {
1829                                 return null;
1830                         }
1831
1832                         // Accept quoted arguments as-is
1833                         if ( match[ 3 ] ) {
1834                                 match[ 2 ] = match[ 4 ] || match[ 5 ] || "";
1835
1836                         // Strip excess characters from unquoted arguments
1837                         } else if ( unquoted && rpseudo.test( unquoted ) &&
1838
1839                                 // Get excess from tokenize (recursively)
1840                                 ( excess = tokenize( unquoted, true ) ) &&
1841
1842                                 // advance to the next closing parenthesis
1843                                 ( excess = unquoted.indexOf( ")", unquoted.length - excess ) - unquoted.length ) ) {
1844
1845                                 // excess is a negative index
1846                                 match[ 0 ] = match[ 0 ].slice( 0, excess );
1847                                 match[ 2 ] = unquoted.slice( 0, excess );
1848                         }
1849
1850                         // Return only captures needed by the pseudo filter method (type and argument)
1851                         return match.slice( 0, 3 );
1852                 }
1853         },
1854
1855         filter: {
1856
1857                 "TAG": function( nodeNameSelector ) {
1858                         var nodeName = nodeNameSelector.replace( runescape, funescape ).toLowerCase();
1859                         return nodeNameSelector === "*" ?
1860                                 function() {
1861                                         return true;
1862                                 } :
1863                                 function( elem ) {
1864                                         return elem.nodeName && elem.nodeName.toLowerCase() === nodeName;
1865                                 };
1866                 },
1867
1868                 "CLASS": function( className ) {
1869                         var pattern = classCache[ className + " " ];
1870
1871                         return pattern ||
1872                                 ( pattern = new RegExp( "(^|" + whitespace +
1873                                         ")" + className + "(" + whitespace + "|$)" ) ) && classCache(
1874                                                 className, function( elem ) {
1875                                                         return pattern.test(
1876                                                                 typeof elem.className === "string" && elem.className ||
1877                                                                 typeof elem.getAttribute !== "undefined" &&
1878                                                                         elem.getAttribute( "class" ) ||
1879                                                                 ""
1880                                                         );
1881                                 } );
1882                 },
1883
1884                 "ATTR": function( name, operator, check ) {
1885                         return function( elem ) {
1886                                 var result = Sizzle.attr( elem, name );
1887
1888                                 if ( result == null ) {
1889                                         return operator === "!=";
1890                                 }
1891                                 if ( !operator ) {
1892                                         return true;
1893                                 }
1894
1895                                 result += "";
1896
1897                                 /* eslint-disable max-len */
1898
1899                                 return operator === "=" ? result === check :
1900                                         operator === "!=" ? result !== check :
1901                                         operator === "^=" ? check && result.indexOf( check ) === 0 :
1902                                         operator === "*=" ? check && result.indexOf( check ) > -1 :
1903                                         operator === "$=" ? check && result.slice( -check.length ) === check :
1904                                         operator === "~=" ? ( " " + result.replace( rwhitespace, " " ) + " " ).indexOf( check ) > -1 :
1905                                         operator === "|=" ? result === check || result.slice( 0, check.length + 1 ) === check + "-" :
1906                                         false;
1907                                 /* eslint-enable max-len */
1908
1909                         };
1910                 },
1911
1912                 "CHILD": function( type, what, _argument, first, last ) {
1913                         var simple = type.slice( 0, 3 ) !== "nth",
1914                                 forward = type.slice( -4 ) !== "last",
1915                                 ofType = what === "of-type";
1916
1917                         return first === 1 && last === 0 ?
1918
1919                                 // Shortcut for :nth-*(n)
1920                                 function( elem ) {
1921                                         return !!elem.parentNode;
1922                                 } :
1923
1924                                 function( elem, _context, xml ) {
1925                                         var cache, uniqueCache, outerCache, node, nodeIndex, start,
1926                                                 dir = simple !== forward ? "nextSibling" : "previousSibling",
1927                                                 parent = elem.parentNode,
1928                                                 name = ofType && elem.nodeName.toLowerCase(),
1929                                                 useCache = !xml && !ofType,
1930                                                 diff = false;
1931
1932                                         if ( parent ) {
1933
1934                                                 // :(first|last|only)-(child|of-type)
1935                                                 if ( simple ) {
1936                                                         while ( dir ) {
1937                                                                 node = elem;
1938                                                                 while ( ( node = node[ dir ] ) ) {
1939                                                                         if ( ofType ?
1940                                                                                 node.nodeName.toLowerCase() === name :
1941                                                                                 node.nodeType === 1 ) {
1942
1943                                                                                 return false;
1944                                                                         }
1945                                                                 }
1946
1947                                                                 // Reverse direction for :only-* (if we haven't yet done so)
1948                                                                 start = dir = type === "only" && !start && "nextSibling";
1949                                                         }
1950                                                         return true;
1951                                                 }
1952
1953                                                 start = [ forward ? parent.firstChild : parent.lastChild ];
1954
1955                                                 // non-xml :nth-child(...) stores cache data on `parent`
1956                                                 if ( forward && useCache ) {
1957
1958                                                         // Seek `elem` from a previously-cached index
1959
1960                                                         // ...in a gzip-friendly way
1961                                                         node = parent;
1962                                                         outerCache = node[ expando ] || ( node[ expando ] = {} );
1963
1964                                                         // Support: IE <9 only
1965                                                         // Defend against cloned attroperties (jQuery gh-1709)
1966                                                         uniqueCache = outerCache[ node.uniqueID ] ||
1967                                                                 ( outerCache[ node.uniqueID ] = {} );
1968
1969                                                         cache = uniqueCache[ type ] || [];
1970                                                         nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ];
1971                                                         diff = nodeIndex && cache[ 2 ];
1972                                                         node = nodeIndex && parent.childNodes[ nodeIndex ];
1973
1974                                                         while ( ( node = ++nodeIndex && node && node[ dir ] ||
1975
1976                                                                 // Fallback to seeking `elem` from the start
1977                                                                 ( diff = nodeIndex = 0 ) || start.pop() ) ) {
1978
1979                                                                 // When found, cache indexes on `parent` and break
1980                                                                 if ( node.nodeType === 1 && ++diff && node === elem ) {
1981                                                                         uniqueCache[ type ] = [ dirruns, nodeIndex, diff ];
1982                                                                         break;
1983                                                                 }
1984                                                         }
1985
1986                                                 } else {
1987
1988                                                         // Use previously-cached element index if available
1989                                                         if ( useCache ) {
1990
1991                                                                 // ...in a gzip-friendly way
1992                                                                 node = elem;
1993                                                                 outerCache = node[ expando ] || ( node[ expando ] = {} );
1994
1995                                                                 // Support: IE <9 only
1996                                                                 // Defend against cloned attroperties (jQuery gh-1709)
1997                                                                 uniqueCache = outerCache[ node.uniqueID ] ||
1998                                                                         ( outerCache[ node.uniqueID ] = {} );
1999
2000                                                                 cache = uniqueCache[ type ] || [];
2001                                                                 nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ];
2002                                                                 diff = nodeIndex;
2003                                                         }
2004
2005                                                         // xml :nth-child(...)
2006                                                         // or :nth-last-child(...) or :nth(-last)?-of-type(...)
2007                                                         if ( diff === false ) {
2008
2009                                                                 // Use the same loop as above to seek `elem` from the start
2010                                                                 while ( ( node = ++nodeIndex && node && node[ dir ] ||
2011                                                                         ( diff = nodeIndex = 0 ) || start.pop() ) ) {
2012
2013                                                                         if ( ( ofType ?
2014                                                                                 node.nodeName.toLowerCase() === name :
2015                                                                                 node.nodeType === 1 ) &&
2016                                                                                 ++diff ) {
2017
2018                                                                                 // Cache the index of each encountered element
2019                                                                                 if ( useCache ) {
2020                                                                                         outerCache = node[ expando ] ||
2021                                                                                                 ( node[ expando ] = {} );
2022
2023                                                                                         // Support: IE <9 only
2024                                                                                         // Defend against cloned attroperties (jQuery gh-1709)
2025                                                                                         uniqueCache = outerCache[ node.uniqueID ] ||
2026                                                                                                 ( outerCache[ node.uniqueID ] = {} );
2027
2028                                                                                         uniqueCache[ type ] = [ dirruns, diff ];
2029                                                                                 }
2030
2031                                                                                 if ( node === elem ) {
2032                                                                                         break;
2033                                                                                 }
2034                                                                         }
2035                                                                 }
2036                                                         }
2037                                                 }
2038
2039                                                 // Incorporate the offset, then check against cycle size
2040                                                 diff -= last;
2041                                                 return diff === first || ( diff % first === 0 && diff / first >= 0 );
2042                                         }
2043                                 };
2044                 },
2045
2046                 "PSEUDO": function( pseudo, argument ) {
2047
2048                         // pseudo-class names are case-insensitive
2049                         // http://www.w3.org/TR/selectors/#pseudo-classes
2050                         // Prioritize by case sensitivity in case custom pseudos are added with uppercase letters
2051                         // Remember that setFilters inherits from pseudos
2052                         var args,
2053                                 fn = Expr.pseudos[ pseudo ] || Expr.setFilters[ pseudo.toLowerCase() ] ||
2054                                         Sizzle.error( "unsupported pseudo: " + pseudo );
2055
2056                         // The user may use createPseudo to indicate that
2057                         // arguments are needed to create the filter function
2058                         // just as Sizzle does
2059                         if ( fn[ expando ] ) {
2060                                 return fn( argument );
2061                         }
2062
2063                         // But maintain support for old signatures
2064                         if ( fn.length > 1 ) {
2065                                 args = [ pseudo, pseudo, "", argument ];
2066                                 return Expr.setFilters.hasOwnProperty( pseudo.toLowerCase() ) ?
2067                                         markFunction( function( seed, matches ) {
2068                                                 var idx,
2069                                                         matched = fn( seed, argument ),
2070                                                         i = matched.length;
2071                                                 while ( i-- ) {
2072                                                         idx = indexOf( seed, matched[ i ] );
2073                                                         seed[ idx ] = !( matches[ idx ] = matched[ i ] );
2074                                                 }
2075                                         } ) :
2076                                         function( elem ) {
2077                                                 return fn( elem, 0, args );
2078                                         };
2079                         }
2080
2081                         return fn;
2082                 }
2083         },
2084
2085         pseudos: {
2086
2087                 // Potentially complex pseudos
2088                 "not": markFunction( function( selector ) {
2089
2090                         // Trim the selector passed to compile
2091                         // to avoid treating leading and trailing
2092                         // spaces as combinators
2093                         var input = [],
2094                                 results = [],
2095                                 matcher = compile( selector.replace( rtrim, "$1" ) );
2096
2097                         return matcher[ expando ] ?
2098                                 markFunction( function( seed, matches, _context, xml ) {
2099                                         var elem,
2100                                                 unmatched = matcher( seed, null, xml, [] ),
2101                                                 i = seed.length;
2102
2103                                         // Match elements unmatched by `matcher`
2104                                         while ( i-- ) {
2105                                                 if ( ( elem = unmatched[ i ] ) ) {
2106                                                         seed[ i ] = !( matches[ i ] = elem );
2107                                                 }
2108                                         }
2109                                 } ) :
2110                                 function( elem, _context, xml ) {
2111                                         input[ 0 ] = elem;
2112                                         matcher( input, null, xml, results );
2113
2114                                         // Don't keep the element (issue #299)
2115                                         input[ 0 ] = null;
2116                                         return !results.pop();
2117                                 };
2118                 } ),
2119
2120                 "has": markFunction( function( selector ) {
2121                         return function( elem ) {
2122                                 return Sizzle( selector, elem ).length > 0;
2123                         };
2124                 } ),
2125
2126                 "contains": markFunction( function( text ) {
2127                         text = text.replace( runescape, funescape );
2128                         return function( elem ) {
2129                                 return ( elem.textContent || getText( elem ) ).indexOf( text ) > -1;
2130                         };
2131                 } ),
2132
2133                 // "Whether an element is represented by a :lang() selector
2134                 // is based solely on the element's language value
2135                 // being equal to the identifier C,
2136                 // or beginning with the identifier C immediately followed by "-".
2137                 // The matching of C against the element's language value is performed case-insensitively.
2138                 // The identifier C does not have to be a valid language name."
2139                 // http://www.w3.org/TR/selectors/#lang-pseudo
2140                 "lang": markFunction( function( lang ) {
2141
2142                         // lang value must be a valid identifier
2143                         if ( !ridentifier.test( lang || "" ) ) {
2144                                 Sizzle.error( "unsupported lang: " + lang );
2145                         }
2146                         lang = lang.replace( runescape, funescape ).toLowerCase();
2147                         return function( elem ) {
2148                                 var elemLang;
2149                                 do {
2150                                         if ( ( elemLang = documentIsHTML ?
2151                                                 elem.lang :
2152                                                 elem.getAttribute( "xml:lang" ) || elem.getAttribute( "lang" ) ) ) {
2153
2154                                                 elemLang = elemLang.toLowerCase();
2155                                                 return elemLang === lang || elemLang.indexOf( lang + "-" ) === 0;
2156                                         }
2157                                 } while ( ( elem = elem.parentNode ) && elem.nodeType === 1 );
2158                                 return false;
2159                         };
2160                 } ),
2161
2162                 // Miscellaneous
2163                 "target": function( elem ) {
2164                         var hash = window.location && window.location.hash;
2165                         return hash && hash.slice( 1 ) === elem.id;
2166                 },
2167
2168                 "root": function( elem ) {
2169                         return elem === docElem;
2170                 },
2171
2172                 "focus": function( elem ) {
2173                         return elem === document.activeElement &&
2174                                 ( !document.hasFocus || document.hasFocus() ) &&
2175                                 !!( elem.type || elem.href || ~elem.tabIndex );
2176                 },
2177
2178                 // Boolean properties
2179                 "enabled": createDisabledPseudo( false ),
2180                 "disabled": createDisabledPseudo( true ),
2181
2182                 "checked": function( elem ) {
2183
2184                         // In CSS3, :checked should return both checked and selected elements
2185                         // http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
2186                         var nodeName = elem.nodeName.toLowerCase();
2187                         return ( nodeName === "input" && !!elem.checked ) ||
2188                                 ( nodeName === "option" && !!elem.selected );
2189                 },
2190
2191                 "selected": function( elem ) {
2192
2193                         // Accessing this property makes selected-by-default
2194                         // options in Safari work properly
2195                         if ( elem.parentNode ) {
2196                                 // eslint-disable-next-line no-unused-expressions
2197                                 elem.parentNode.selectedIndex;
2198                         }
2199
2200                         return elem.selected === true;
2201                 },
2202
2203                 // Contents
2204                 "empty": function( elem ) {
2205
2206                         // http://www.w3.org/TR/selectors/#empty-pseudo
2207                         // :empty is negated by element (1) or content nodes (text: 3; cdata: 4; entity ref: 5),
2208                         //   but not by others (comment: 8; processing instruction: 7; etc.)
2209                         // nodeType < 6 works because attributes (2) do not appear as children
2210                         for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
2211                                 if ( elem.nodeType < 6 ) {
2212                                         return false;
2213                                 }
2214                         }
2215                         return true;
2216                 },
2217
2218                 "parent": function( elem ) {
2219                         return !Expr.pseudos[ "empty" ]( elem );
2220                 },
2221
2222                 // Element/input types
2223                 "header": function( elem ) {
2224                         return rheader.test( elem.nodeName );
2225                 },
2226
2227                 "input": function( elem ) {
2228                         return rinputs.test( elem.nodeName );
2229                 },
2230
2231                 "button": function( elem ) {
2232                         var name = elem.nodeName.toLowerCase();
2233                         return name === "input" && elem.type === "button" || name === "button";
2234                 },
2235
2236                 "text": function( elem ) {
2237                         var attr;
2238                         return elem.nodeName.toLowerCase() === "input" &&
2239                                 elem.type === "text" &&
2240
2241                                 // Support: IE<8
2242                                 // New HTML5 attribute values (e.g., "search") appear with elem.type === "text"
2243                                 ( ( attr = elem.getAttribute( "type" ) ) == null ||
2244                                         attr.toLowerCase() === "text" );
2245                 },
2246
2247                 // Position-in-collection
2248                 "first": createPositionalPseudo( function() {
2249                         return [ 0 ];
2250                 } ),
2251
2252                 "last": createPositionalPseudo( function( _matchIndexes, length ) {
2253                         return [ length - 1 ];
2254                 } ),
2255
2256                 "eq": createPositionalPseudo( function( _matchIndexes, length, argument ) {
2257                         return [ argument < 0 ? argument + length : argument ];
2258                 } ),
2259
2260                 "even": createPositionalPseudo( function( matchIndexes, length ) {
2261                         var i = 0;
2262                         for ( ; i < length; i += 2 ) {
2263                                 matchIndexes.push( i );
2264                         }
2265                         return matchIndexes;
2266                 } ),
2267
2268                 "odd": createPositionalPseudo( function( matchIndexes, length ) {
2269                         var i = 1;
2270                         for ( ; i < length; i += 2 ) {
2271                                 matchIndexes.push( i );
2272                         }
2273                         return matchIndexes;
2274                 } ),
2275
2276                 "lt": createPositionalPseudo( function( matchIndexes, length, argument ) {
2277                         var i = argument < 0 ?
2278                                 argument + length :
2279                                 argument > length ?
2280                                         length :
2281                                         argument;
2282                         for ( ; --i >= 0; ) {
2283                                 matchIndexes.push( i );
2284                         }
2285                         return matchIndexes;
2286                 } ),
2287
2288                 "gt": createPositionalPseudo( function( matchIndexes, length, argument ) {
2289                         var i = argument < 0 ? argument + length : argument;
2290                         for ( ; ++i < length; ) {
2291                                 matchIndexes.push( i );
2292                         }
2293                         return matchIndexes;
2294                 } )
2295         }
2296 };
2297
2298 Expr.pseudos[ "nth" ] = Expr.pseudos[ "eq" ];
2299
2300 // Add button/input type pseudos
2301 for ( i in { radio: true, checkbox: true, file: true, password: true, image: true } ) {
2302         Expr.pseudos[ i ] = createInputPseudo( i );
2303 }
2304 for ( i in { submit: true, reset: true } ) {
2305         Expr.pseudos[ i ] = createButtonPseudo( i );
2306 }
2307
2308 // Easy API for creating new setFilters
2309 function setFilters() {}
2310 setFilters.prototype = Expr.filters = Expr.pseudos;
2311 Expr.setFilters = new setFilters();
2312
2313 tokenize = Sizzle.tokenize = function( selector, parseOnly ) {
2314         var matched, match, tokens, type,
2315                 soFar, groups, preFilters,
2316                 cached = tokenCache[ selector + " " ];
2317
2318         if ( cached ) {
2319                 return parseOnly ? 0 : cached.slice( 0 );
2320         }
2321
2322         soFar = selector;
2323         groups = [];
2324         preFilters = Expr.preFilter;
2325
2326         while ( soFar ) {
2327
2328                 // Comma and first run
2329                 if ( !matched || ( match = rcomma.exec( soFar ) ) ) {
2330                         if ( match ) {
2331
2332                                 // Don't consume trailing commas as valid
2333                                 soFar = soFar.slice( match[ 0 ].length ) || soFar;
2334                         }
2335                         groups.push( ( tokens = [] ) );
2336                 }
2337
2338                 matched = false;
2339
2340                 // Combinators
2341                 if ( ( match = rcombinators.exec( soFar ) ) ) {
2342                         matched = match.shift();
2343                         tokens.push( {
2344                                 value: matched,
2345
2346                                 // Cast descendant combinators to space
2347                                 type: match[ 0 ].replace( rtrim, " " )
2348                         } );
2349                         soFar = soFar.slice( matched.length );
2350                 }
2351
2352                 // Filters
2353                 for ( type in Expr.filter ) {
2354                         if ( ( match = matchExpr[ type ].exec( soFar ) ) && ( !preFilters[ type ] ||
2355                                 ( match = preFilters[ type ]( match ) ) ) ) {
2356                                 matched = match.shift();
2357                                 tokens.push( {
2358                                         value: matched,
2359                                         type: type,
2360                                         matches: match
2361                                 } );
2362                                 soFar = soFar.slice( matched.length );
2363                         }
2364                 }
2365
2366                 if ( !matched ) {
2367                         break;
2368                 }
2369         }
2370
2371         // Return the length of the invalid excess
2372         // if we're just parsing
2373         // Otherwise, throw an error or return tokens
2374         return parseOnly ?
2375                 soFar.length :
2376                 soFar ?
2377                         Sizzle.error( selector ) :
2378
2379                         // Cache the tokens
2380                         tokenCache( selector, groups ).slice( 0 );
2381 };
2382
2383 function toSelector( tokens ) {
2384         var i = 0,
2385                 len = tokens.length,
2386                 selector = "";
2387         for ( ; i < len; i++ ) {
2388                 selector += tokens[ i ].value;
2389         }
2390         return selector;
2391 }
2392
2393 function addCombinator( matcher, combinator, base ) {
2394         var dir = combinator.dir,
2395                 skip = combinator.next,
2396                 key = skip || dir,
2397                 checkNonElements = base && key === "parentNode",
2398                 doneName = done++;
2399
2400         return combinator.first ?
2401
2402                 // Check against closest ancestor/preceding element
2403                 function( elem, context, xml ) {
2404                         while ( ( elem = elem[ dir ] ) ) {
2405                                 if ( elem.nodeType === 1 || checkNonElements ) {
2406                                         return matcher( elem, context, xml );
2407                                 }
2408                         }
2409                         return false;
2410                 } :
2411
2412                 // Check against all ancestor/preceding elements
2413                 function( elem, context, xml ) {
2414                         var oldCache, uniqueCache, outerCache,
2415                                 newCache = [ dirruns, doneName ];
2416
2417                         // We can't set arbitrary data on XML nodes, so they don't benefit from combinator caching
2418                         if ( xml ) {
2419                                 while ( ( elem = elem[ dir ] ) ) {
2420                                         if ( elem.nodeType === 1 || checkNonElements ) {
2421                                                 if ( matcher( elem, context, xml ) ) {
2422                                                         return true;
2423                                                 }
2424                                         }
2425                                 }
2426                         } else {
2427                                 while ( ( elem = elem[ dir ] ) ) {
2428                                         if ( elem.nodeType === 1 || checkNonElements ) {
2429                                                 outerCache = elem[ expando ] || ( elem[ expando ] = {} );
2430
2431                                                 // Support: IE <9 only
2432                                                 // Defend against cloned attroperties (jQuery gh-1709)
2433                                                 uniqueCache = outerCache[ elem.uniqueID ] ||
2434                                                         ( outerCache[ elem.uniqueID ] = {} );
2435
2436                                                 if ( skip && skip === elem.nodeName.toLowerCase() ) {
2437                                                         elem = elem[ dir ] || elem;
2438                                                 } else if ( ( oldCache = uniqueCache[ key ] ) &&
2439                                                         oldCache[ 0 ] === dirruns && oldCache[ 1 ] === doneName ) {
2440
2441                                                         // Assign to newCache so results back-propagate to previous elements
2442                                                         return ( newCache[ 2 ] = oldCache[ 2 ] );
2443                                                 } else {
2444
2445                                                         // Reuse newcache so results back-propagate to previous elements
2446                                                         uniqueCache[ key ] = newCache;
2447
2448                                                         // A match means we're done; a fail means we have to keep checking
2449                                                         if ( ( newCache[ 2 ] = matcher( elem, context, xml ) ) ) {
2450                                                                 return true;
2451                                                         }
2452                                                 }
2453                                         }
2454                                 }
2455                         }
2456                         return false;
2457                 };
2458 }
2459
2460 function elementMatcher( matchers ) {
2461         return matchers.length > 1 ?
2462                 function( elem, context, xml ) {
2463                         var i = matchers.length;
2464                         while ( i-- ) {
2465                                 if ( !matchers[ i ]( elem, context, xml ) ) {
2466                                         return false;
2467                                 }
2468                         }
2469                         return true;
2470                 } :
2471                 matchers[ 0 ];
2472 }
2473
2474 function multipleContexts( selector, contexts, results ) {
2475         var i = 0,
2476                 len = contexts.length;
2477         for ( ; i < len; i++ ) {
2478                 Sizzle( selector, contexts[ i ], results );
2479         }
2480         return results;
2481 }
2482
2483 function condense( unmatched, map, filter, context, xml ) {
2484         var elem,
2485                 newUnmatched = [],
2486                 i = 0,
2487                 len = unmatched.length,
2488                 mapped = map != null;
2489
2490         for ( ; i < len; i++ ) {
2491                 if ( ( elem = unmatched[ i ] ) ) {
2492                         if ( !filter || filter( elem, context, xml ) ) {
2493                                 newUnmatched.push( elem );
2494                                 if ( mapped ) {
2495                                         map.push( i );
2496                                 }
2497                         }
2498                 }
2499         }
2500
2501         return newUnmatched;
2502 }
2503
2504 function setMatcher( preFilter, selector, matcher, postFilter, postFinder, postSelector ) {
2505         if ( postFilter && !postFilter[ expando ] ) {
2506                 postFilter = setMatcher( postFilter );
2507         }
2508         if ( postFinder && !postFinder[ expando ] ) {
2509                 postFinder = setMatcher( postFinder, postSelector );
2510         }
2511         return markFunction( function( seed, results, context, xml ) {
2512                 var temp, i, elem,
2513                         preMap = [],
2514                         postMap = [],
2515                         preexisting = results.length,
2516
2517                         // Get initial elements from seed or context
2518                         elems = seed || multipleContexts(
2519                                 selector || "*",
2520                                 context.nodeType ? [ context ] : context,
2521                                 []
2522                         ),
2523
2524                         // Prefilter to get matcher input, preserving a map for seed-results synchronization
2525                         matcherIn = preFilter && ( seed || !selector ) ?
2526                                 condense( elems, preMap, preFilter, context, xml ) :
2527                                 elems,
2528
2529                         matcherOut = matcher ?
2530
2531                                 // If we have a postFinder, or filtered seed, or non-seed postFilter or preexisting results,
2532                                 postFinder || ( seed ? preFilter : preexisting || postFilter ) ?
2533
2534                                         // ...intermediate processing is necessary
2535                                         [] :
2536
2537                                         // ...otherwise use results directly
2538                                         results :
2539                                 matcherIn;
2540
2541                 // Find primary matches
2542                 if ( matcher ) {
2543                         matcher( matcherIn, matcherOut, context, xml );
2544                 }
2545
2546                 // Apply postFilter
2547                 if ( postFilter ) {
2548                         temp = condense( matcherOut, postMap );
2549                         postFilter( temp, [], context, xml );
2550
2551                         // Un-match failing elements by moving them back to matcherIn
2552                         i = temp.length;
2553                         while ( i-- ) {
2554                                 if ( ( elem = temp[ i ] ) ) {
2555                                         matcherOut[ postMap[ i ] ] = !( matcherIn[ postMap[ i ] ] = elem );
2556                                 }
2557                         }
2558                 }
2559
2560                 if ( seed ) {
2561                         if ( postFinder || preFilter ) {
2562                                 if ( postFinder ) {
2563
2564                                         // Get the final matcherOut by condensing this intermediate into postFinder contexts
2565                                         temp = [];
2566                                         i = matcherOut.length;
2567                                         while ( i-- ) {
2568                                                 if ( ( elem = matcherOut[ i ] ) ) {
2569
2570                                                         // Restore matcherIn since elem is not yet a final match
2571                                                         temp.push( ( matcherIn[ i ] = elem ) );
2572                                                 }
2573                                         }
2574                                         postFinder( null, ( matcherOut = [] ), temp, xml );
2575                                 }
2576
2577                                 // Move matched elements from seed to results to keep them synchronized
2578                                 i = matcherOut.length;
2579                                 while ( i-- ) {
2580                                         if ( ( elem = matcherOut[ i ] ) &&
2581                                                 ( temp = postFinder ? indexOf( seed, elem ) : preMap[ i ] ) > -1 ) {
2582
2583                                                 seed[ temp ] = !( results[ temp ] = elem );
2584                                         }
2585                                 }
2586                         }
2587
2588                 // Add elements to results, through postFinder if defined
2589                 } else {
2590                         matcherOut = condense(
2591                                 matcherOut === results ?
2592                                         matcherOut.splice( preexisting, matcherOut.length ) :
2593                                         matcherOut
2594                         );
2595                         if ( postFinder ) {
2596                                 postFinder( null, results, matcherOut, xml );
2597                         } else {
2598                                 push.apply( results, matcherOut );
2599                         }
2600                 }
2601         } );
2602 }
2603
2604 function matcherFromTokens( tokens ) {
2605         var checkContext, matcher, j,
2606                 len = tokens.length,
2607                 leadingRelative = Expr.relative[ tokens[ 0 ].type ],
2608                 implicitRelative = leadingRelative || Expr.relative[ " " ],
2609                 i = leadingRelative ? 1 : 0,
2610
2611                 // The foundational matcher ensures that elements are reachable from top-level context(s)
2612                 matchContext = addCombinator( function( elem ) {
2613                         return elem === checkContext;
2614                 }, implicitRelative, true ),
2615                 matchAnyContext = addCombinator( function( elem ) {
2616                         return indexOf( checkContext, elem ) > -1;
2617                 }, implicitRelative, true ),
2618                 matchers = [ function( elem, context, xml ) {
2619                         var ret = ( !leadingRelative && ( xml || context !== outermostContext ) ) || (
2620                                 ( checkContext = context ).nodeType ?
2621                                         matchContext( elem, context, xml ) :
2622                                         matchAnyContext( elem, context, xml ) );
2623
2624                         // Avoid hanging onto element (issue #299)
2625                         checkContext = null;
2626                         return ret;
2627                 } ];
2628
2629         for ( ; i < len; i++ ) {
2630                 if ( ( matcher = Expr.relative[ tokens[ i ].type ] ) ) {
2631                         matchers = [ addCombinator( elementMatcher( matchers ), matcher ) ];
2632                 } else {
2633                         matcher = Expr.filter[ tokens[ i ].type ].apply( null, tokens[ i ].matches );
2634
2635                         // Return special upon seeing a positional matcher
2636                         if ( matcher[ expando ] ) {
2637
2638                                 // Find the next relative operator (if any) for proper handling
2639                                 j = ++i;
2640                                 for ( ; j < len; j++ ) {
2641                                         if ( Expr.relative[ tokens[ j ].type ] ) {
2642                                                 break;
2643                                         }
2644                                 }
2645                                 return setMatcher(
2646                                         i > 1 && elementMatcher( matchers ),
2647                                         i > 1 && toSelector(
2648
2649                                         // If the preceding token was a descendant combinator, insert an implicit any-element `*`
2650                                         tokens
2651                                                 .slice( 0, i - 1 )
2652                                                 .concat( { value: tokens[ i - 2 ].type === " " ? "*" : "" } )
2653                                         ).replace( rtrim, "$1" ),
2654                                         matcher,
2655                                         i < j && matcherFromTokens( tokens.slice( i, j ) ),
2656                                         j < len && matcherFromTokens( ( tokens = tokens.slice( j ) ) ),
2657                                         j < len && toSelector( tokens )
2658                                 );
2659                         }
2660                         matchers.push( matcher );
2661                 }
2662         }
2663
2664         return elementMatcher( matchers );
2665 }
2666
2667 function matcherFromGroupMatchers( elementMatchers, setMatchers ) {
2668         var bySet = setMatchers.length > 0,
2669                 byElement = elementMatchers.length > 0,
2670                 superMatcher = function( seed, context, xml, results, outermost ) {
2671                         var elem, j, matcher,
2672                                 matchedCount = 0,
2673                                 i = "0",
2674                                 unmatched = seed && [],
2675                                 setMatched = [],
2676                                 contextBackup = outermostContext,
2677
2678                                 // We must always have either seed elements or outermost context
2679                                 elems = seed || byElement && Expr.find[ "TAG" ]( "*", outermost ),
2680
2681                                 // Use integer dirruns iff this is the outermost matcher
2682                                 dirrunsUnique = ( dirruns += contextBackup == null ? 1 : Math.random() || 0.1 ),
2683                                 len = elems.length;
2684
2685                         if ( outermost ) {
2686
2687                                 // Support: IE 11+, Edge 17 - 18+
2688                                 // IE/Edge sometimes throw a "Permission denied" error when strict-comparing
2689                                 // two documents; shallow comparisons work.
2690                                 // eslint-disable-next-line eqeqeq
2691                                 outermostContext = context == document || context || outermost;
2692                         }
2693
2694                         // Add elements passing elementMatchers directly to results
2695                         // Support: IE<9, Safari
2696                         // Tolerate NodeList properties (IE: "length"; Safari: <number>) matching elements by id
2697                         for ( ; i !== len && ( elem = elems[ i ] ) != null; i++ ) {
2698                                 if ( byElement && elem ) {
2699                                         j = 0;
2700
2701                                         // Support: IE 11+, Edge 17 - 18+
2702                                         // IE/Edge sometimes throw a "Permission denied" error when strict-comparing
2703                                         // two documents; shallow comparisons work.
2704                                         // eslint-disable-next-line eqeqeq
2705                                         if ( !context && elem.ownerDocument != document ) {
2706                                                 setDocument( elem );
2707                                                 xml = !documentIsHTML;
2708                                         }
2709                                         while ( ( matcher = elementMatchers[ j++ ] ) ) {
2710                                                 if ( matcher( elem, context || document, xml ) ) {
2711                                                         results.push( elem );
2712                                                         break;
2713                                                 }
2714                                         }
2715                                         if ( outermost ) {
2716                                                 dirruns = dirrunsUnique;
2717                                         }
2718                                 }
2719
2720                                 // Track unmatched elements for set filters
2721                                 if ( bySet ) {
2722
2723                                         // They will have gone through all possible matchers
2724                                         if ( ( elem = !matcher && elem ) ) {
2725                                                 matchedCount--;
2726                                         }
2727
2728                                         // Lengthen the array for every element, matched or not
2729                                         if ( seed ) {
2730                                                 unmatched.push( elem );
2731                                         }
2732                                 }
2733                         }
2734
2735                         // `i` is now the count of elements visited above, and adding it to `matchedCount`
2736                         // makes the latter nonnegative.
2737                         matchedCount += i;
2738
2739                         // Apply set filters to unmatched elements
2740                         // NOTE: This can be skipped if there are no unmatched elements (i.e., `matchedCount`
2741                         // equals `i`), unless we didn't visit _any_ elements in the above loop because we have
2742                         // no element matchers and no seed.
2743                         // Incrementing an initially-string "0" `i` allows `i` to remain a string only in that
2744                         // case, which will result in a "00" `matchedCount` that differs from `i` but is also
2745                         // numerically zero.
2746                         if ( bySet && i !== matchedCount ) {
2747                                 j = 0;
2748                                 while ( ( matcher = setMatchers[ j++ ] ) ) {
2749                                         matcher( unmatched, setMatched, context, xml );
2750                                 }
2751
2752                                 if ( seed ) {
2753
2754                                         // Reintegrate element matches to eliminate the need for sorting
2755                                         if ( matchedCount > 0 ) {
2756                                                 while ( i-- ) {
2757                                                         if ( !( unmatched[ i ] || setMatched[ i ] ) ) {
2758                                                                 setMatched[ i ] = pop.call( results );
2759                                                         }
2760                                                 }
2761                                         }
2762
2763                                         // Discard index placeholder values to get only actual matches
2764                                         setMatched = condense( setMatched );
2765                                 }
2766
2767                                 // Add matches to results
2768                                 push.apply( results, setMatched );
2769
2770                                 // Seedless set matches succeeding multiple successful matchers stipulate sorting
2771                                 if ( outermost && !seed && setMatched.length > 0 &&
2772                                         ( matchedCount + setMatchers.length ) > 1 ) {
2773
2774                                         Sizzle.uniqueSort( results );
2775                                 }
2776                         }
2777
2778                         // Override manipulation of globals by nested matchers
2779                         if ( outermost ) {
2780                                 dirruns = dirrunsUnique;
2781                                 outermostContext = contextBackup;
2782                         }
2783
2784                         return unmatched;
2785                 };
2786
2787         return bySet ?
2788                 markFunction( superMatcher ) :
2789                 superMatcher;
2790 }
2791
2792 compile = Sizzle.compile = function( selector, match /* Internal Use Only */ ) {
2793         var i,
2794                 setMatchers = [],
2795                 elementMatchers = [],
2796                 cached = compilerCache[ selector + " " ];
2797
2798         if ( !cached ) {
2799
2800                 // Generate a function of recursive functions that can be used to check each element
2801                 if ( !match ) {
2802                         match = tokenize( selector );
2803                 }
2804                 i = match.length;
2805                 while ( i-- ) {
2806                         cached = matcherFromTokens( match[ i ] );
2807                         if ( cached[ expando ] ) {
2808                                 setMatchers.push( cached );
2809                         } else {
2810                                 elementMatchers.push( cached );
2811                         }
2812                 }
2813
2814                 // Cache the compiled function
2815                 cached = compilerCache(
2816                         selector,
2817                         matcherFromGroupMatchers( elementMatchers, setMatchers )
2818                 );
2819
2820                 // Save selector and tokenization
2821                 cached.selector = selector;
2822         }
2823         return cached;
2824 };
2825
2826 /**
2827  * A low-level selection function that works with Sizzle's compiled
2828  *  selector functions
2829  * @param {String|Function} selector A selector or a pre-compiled
2830  *  selector function built with Sizzle.compile
2831  * @param {Element} context
2832  * @param {Array} [results]
2833  * @param {Array} [seed] A set of elements to match against
2834  */
2835 select = Sizzle.select = function( selector, context, results, seed ) {
2836         var i, tokens, token, type, find,
2837                 compiled = typeof selector === "function" && selector,
2838                 match = !seed && tokenize( ( selector = compiled.selector || selector ) );
2839
2840         results = results || [];
2841
2842         // Try to minimize operations if there is only one selector in the list and no seed
2843         // (the latter of which guarantees us context)
2844         if ( match.length === 1 ) {
2845
2846                 // Reduce context if the leading compound selector is an ID
2847                 tokens = match[ 0 ] = match[ 0 ].slice( 0 );
2848                 if ( tokens.length > 2 && ( token = tokens[ 0 ] ).type === "ID" &&
2849                         context.nodeType === 9 && documentIsHTML && Expr.relative[ tokens[ 1 ].type ] ) {
2850
2851                         context = ( Expr.find[ "ID" ]( token.matches[ 0 ]
2852                                 .replace( runescape, funescape ), context ) || [] )[ 0 ];
2853                         if ( !context ) {
2854                                 return results;
2855
2856                         // Precompiled matchers will still verify ancestry, so step up a level
2857                         } else if ( compiled ) {
2858                                 context = context.parentNode;
2859                         }
2860
2861                         selector = selector.slice( tokens.shift().value.length );
2862                 }
2863
2864                 // Fetch a seed set for right-to-left matching
2865                 i = matchExpr[ "needsContext" ].test( selector ) ? 0 : tokens.length;
2866                 while ( i-- ) {
2867                         token = tokens[ i ];
2868
2869                         // Abort if we hit a combinator
2870                         if ( Expr.relative[ ( type = token.type ) ] ) {
2871                                 break;
2872                         }
2873                         if ( ( find = Expr.find[ type ] ) ) {
2874
2875                                 // Search, expanding context for leading sibling combinators
2876                                 if ( ( seed = find(
2877                                         token.matches[ 0 ].replace( runescape, funescape ),
2878                                         rsibling.test( tokens[ 0 ].type ) && testContext( context.parentNode ) ||
2879                                                 context
2880                                 ) ) ) {
2881
2882                                         // If seed is empty or no tokens remain, we can return early
2883                                         tokens.splice( i, 1 );
2884                                         selector = seed.length && toSelector( tokens );
2885                                         if ( !selector ) {
2886                                                 push.apply( results, seed );
2887                                                 return results;
2888                                         }
2889
2890                                         break;
2891                                 }
2892                         }
2893                 }
2894         }
2895
2896         // Compile and execute a filtering function if one is not provided
2897         // Provide `match` to avoid retokenization if we modified the selector above
2898         ( compiled || compile( selector, match ) )(
2899                 seed,
2900                 context,
2901                 !documentIsHTML,
2902                 results,
2903                 !context || rsibling.test( selector ) && testContext( context.parentNode ) || context
2904         );
2905         return results;
2906 };
2907
2908 // One-time assignments
2909
2910 // Sort stability
2911 support.sortStable = expando.split( "" ).sort( sortOrder ).join( "" ) === expando;
2912
2913 // Support: Chrome 14-35+
2914 // Always assume duplicates if they aren't passed to the comparison function
2915 support.detectDuplicates = !!hasDuplicate;
2916
2917 // Initialize against the default document
2918 setDocument();
2919
2920 // Support: Webkit<537.32 - Safari 6.0.3/Chrome 25 (fixed in Chrome 27)
2921 // Detached nodes confoundingly follow *each other*
2922 support.sortDetached = assert( function( el ) {
2923
2924         // Should return 1, but returns 4 (following)
2925         return el.compareDocumentPosition( document.createElement( "fieldset" ) ) & 1;
2926 } );
2927
2928 // Support: IE<8
2929 // Prevent attribute/property "interpolation"
2930 // https://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx
2931 if ( !assert( function( el ) {
2932         el.innerHTML = "<a href='#'></a>";
2933         return el.firstChild.getAttribute( "href" ) === "#";
2934 } ) ) {
2935         addHandle( "type|href|height|width", function( elem, name, isXML ) {
2936                 if ( !isXML ) {
2937                         return elem.getAttribute( name, name.toLowerCase() === "type" ? 1 : 2 );
2938                 }
2939         } );
2940 }
2941
2942 // Support: IE<9
2943 // Use defaultValue in place of getAttribute("value")
2944 if ( !support.attributes || !assert( function( el ) {
2945         el.innerHTML = "<input/>";
2946         el.firstChild.setAttribute( "value", "" );
2947         return el.firstChild.getAttribute( "value" ) === "";
2948 } ) ) {
2949         addHandle( "value", function( elem, _name, isXML ) {
2950                 if ( !isXML && elem.nodeName.toLowerCase() === "input" ) {
2951                         return elem.defaultValue;
2952                 }
2953         } );
2954 }
2955
2956 // Support: IE<9
2957 // Use getAttributeNode to fetch booleans when getAttribute lies
2958 if ( !assert( function( el ) {
2959         return el.getAttribute( "disabled" ) == null;
2960 } ) ) {
2961         addHandle( booleans, function( elem, name, isXML ) {
2962                 var val;
2963                 if ( !isXML ) {
2964                         return elem[ name ] === true ? name.toLowerCase() :
2965                                 ( val = elem.getAttributeNode( name ) ) && val.specified ?
2966                                         val.value :
2967                                         null;
2968                 }
2969         } );
2970 }
2971
2972 return Sizzle;
2973
2974 } )( window );
2975
2976
2977
2978 jQuery.find = Sizzle;
2979 jQuery.expr = Sizzle.selectors;
2980
2981 // Deprecated
2982 jQuery.expr[ ":" ] = jQuery.expr.pseudos;
2983 jQuery.uniqueSort = jQuery.unique = Sizzle.uniqueSort;
2984 jQuery.text = Sizzle.getText;
2985 jQuery.isXMLDoc = Sizzle.isXML;
2986 jQuery.contains = Sizzle.contains;
2987 jQuery.escapeSelector = Sizzle.escape;
2988
2989
2990
2991
2992 var dir = function( elem, dir, until ) {
2993         var matched = [],
2994                 truncate = until !== undefined;
2995
2996         while ( ( elem = elem[ dir ] ) && elem.nodeType !== 9 ) {
2997                 if ( elem.nodeType === 1 ) {
2998                         if ( truncate && jQuery( elem ).is( until ) ) {
2999                                 break;
3000                         }
3001                         matched.push( elem );
3002                 }
3003         }
3004         return matched;
3005 };
3006
3007
3008 var siblings = function( n, elem ) {
3009         var matched = [];
3010
3011         for ( ; n; n = n.nextSibling ) {
3012                 if ( n.nodeType === 1 && n !== elem ) {
3013                         matched.push( n );
3014                 }
3015         }
3016
3017         return matched;
3018 };
3019
3020
3021 var rneedsContext = jQuery.expr.match.needsContext;
3022
3023
3024
3025 function nodeName( elem, name ) {
3026
3027   return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase();
3028
3029 };
3030 var rsingleTag = ( /^<([a-z][^\/\0>:\x20\t\r\n\f]*)[\x20\t\r\n\f]*\/?>(?:<\/\1>|)$/i );
3031
3032
3033
3034 // Implement the identical functionality for filter and not
3035 function winnow( elements, qualifier, not ) {
3036         if ( isFunction( qualifier ) ) {
3037                 return jQuery.grep( elements, function( elem, i ) {
3038                         return !!qualifier.call( elem, i, elem ) !== not;
3039                 } );
3040         }
3041
3042         // Single element
3043         if ( qualifier.nodeType ) {
3044                 return jQuery.grep( elements, function( elem ) {
3045                         return ( elem === qualifier ) !== not;
3046                 } );
3047         }
3048
3049         // Arraylike of elements (jQuery, arguments, Array)
3050         if ( typeof qualifier !== "string" ) {
3051                 return jQuery.grep( elements, function( elem ) {
3052                         return ( indexOf.call( qualifier, elem ) > -1 ) !== not;
3053                 } );
3054         }
3055
3056         // Filtered directly for both simple and complex selectors
3057         return jQuery.filter( qualifier, elements, not );
3058 }
3059
3060 jQuery.filter = function( expr, elems, not ) {
3061         var elem = elems[ 0 ];
3062
3063         if ( not ) {
3064                 expr = ":not(" + expr + ")";
3065         }
3066
3067         if ( elems.length === 1 && elem.nodeType === 1 ) {
3068                 return jQuery.find.matchesSelector( elem, expr ) ? [ elem ] : [];
3069         }
3070
3071         return jQuery.find.matches( expr, jQuery.grep( elems, function( elem ) {
3072                 return elem.nodeType === 1;
3073         } ) );
3074 };
3075
3076 jQuery.fn.extend( {
3077         find: function( selector ) {
3078                 var i, ret,
3079                         len = this.length,
3080                         self = this;
3081
3082                 if ( typeof selector !== "string" ) {
3083                         return this.pushStack( jQuery( selector ).filter( function() {
3084                                 for ( i = 0; i < len; i++ ) {
3085                                         if ( jQuery.contains( self[ i ], this ) ) {
3086                                                 return true;
3087                                         }
3088                                 }
3089                         } ) );
3090                 }
3091
3092                 ret = this.pushStack( [] );
3093
3094                 for ( i = 0; i < len; i++ ) {
3095                         jQuery.find( selector, self[ i ], ret );
3096                 }
3097
3098                 return len > 1 ? jQuery.uniqueSort( ret ) : ret;
3099         },
3100         filter: function( selector ) {
3101                 return this.pushStack( winnow( this, selector || [], false ) );
3102         },
3103         not: function( selector ) {
3104                 return this.pushStack( winnow( this, selector || [], true ) );
3105         },
3106         is: function( selector ) {
3107                 return !!winnow(
3108                         this,
3109
3110                         // If this is a positional/relative selector, check membership in the returned set
3111                         // so $("p:first").is("p:last") won't return true for a doc with two "p".
3112                         typeof selector === "string" && rneedsContext.test( selector ) ?
3113                                 jQuery( selector ) :
3114                                 selector || [],
3115                         false
3116                 ).length;
3117         }
3118 } );
3119
3120
3121 // Initialize a jQuery object
3122
3123
3124 // A central reference to the root jQuery(document)
3125 var rootjQuery,
3126
3127         // A simple way to check for HTML strings
3128         // Prioritize #id over <tag> to avoid XSS via location.hash (#9521)
3129         // Strict HTML recognition (#11290: must start with <)
3130         // Shortcut simple #id case for speed
3131         rquickExpr = /^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]+))$/,
3132
3133         init = jQuery.fn.init = function( selector, context, root ) {
3134                 var match, elem;
3135
3136                 // HANDLE: $(""), $(null), $(undefined), $(false)
3137                 if ( !selector ) {
3138                         return this;
3139                 }
3140
3141                 // Method init() accepts an alternate rootjQuery
3142                 // so migrate can support jQuery.sub (gh-2101)
3143                 root = root || rootjQuery;
3144
3145                 // Handle HTML strings
3146                 if ( typeof selector === "string" ) {
3147                         if ( selector[ 0 ] === "<" &&
3148                                 selector[ selector.length - 1 ] === ">" &&
3149                                 selector.length >= 3 ) {
3150
3151                                 // Assume that strings that start and end with <> are HTML and skip the regex check
3152                                 match = [ null, selector, null ];
3153
3154                         } else {
3155                                 match = rquickExpr.exec( selector );
3156                         }
3157
3158                         // Match html or make sure no context is specified for #id
3159                         if ( match && ( match[ 1 ] || !context ) ) {
3160
3161                                 // HANDLE: $(html) -> $(array)
3162                                 if ( match[ 1 ] ) {
3163                                         context = context instanceof jQuery ? context[ 0 ] : context;
3164
3165                                         // Option to run scripts is true for back-compat
3166                                         // Intentionally let the error be thrown if parseHTML is not present
3167                                         jQuery.merge( this, jQuery.parseHTML(
3168                                                 match[ 1 ],
3169                                                 context && context.nodeType ? context.ownerDocument || context : document,
3170                                                 true
3171                                         ) );
3172
3173                                         // HANDLE: $(html, props)
3174                                         if ( rsingleTag.test( match[ 1 ] ) && jQuery.isPlainObject( context ) ) {
3175                                                 for ( match in context ) {
3176
3177                                                         // Properties of context are called as methods if possible
3178                                                         if ( isFunction( this[ match ] ) ) {
3179                                                                 this[ match ]( context[ match ] );
3180
3181                                                         // ...and otherwise set as attributes
3182                                                         } else {
3183                                                                 this.attr( match, context[ match ] );
3184                                                         }
3185                                                 }
3186                                         }
3187
3188                                         return this;
3189
3190                                 // HANDLE: $(#id)
3191                                 } else {
3192                                         elem = document.getElementById( match[ 2 ] );
3193
3194                                         if ( elem ) {
3195
3196                                                 // Inject the element directly into the jQuery object
3197                                                 this[ 0 ] = elem;
3198                                                 this.length = 1;
3199                                         }
3200                                         return this;
3201                                 }
3202
3203                         // HANDLE: $(expr, $(...))
3204                         } else if ( !context || context.jquery ) {
3205                                 return ( context || root ).find( selector );
3206
3207                         // HANDLE: $(expr, context)
3208                         // (which is just equivalent to: $(context).find(expr)
3209                         } else {
3210                                 return this.constructor( context ).find( selector );
3211                         }
3212
3213                 // HANDLE: $(DOMElement)
3214                 } else if ( selector.nodeType ) {
3215                         this[ 0 ] = selector;
3216                         this.length = 1;
3217                         return this;
3218
3219                 // HANDLE: $(function)
3220                 // Shortcut for document ready
3221                 } else if ( isFunction( selector ) ) {
3222                         return root.ready !== undefined ?
3223                                 root.ready( selector ) :
3224
3225                                 // Execute immediately if ready is not present
3226                                 selector( jQuery );
3227                 }
3228
3229                 return jQuery.makeArray( selector, this );
3230         };
3231
3232 // Give the init function the jQuery prototype for later instantiation
3233 init.prototype = jQuery.fn;
3234
3235 // Initialize central reference
3236 rootjQuery = jQuery( document );
3237
3238
3239 var rparentsprev = /^(?:parents|prev(?:Until|All))/,
3240
3241         // Methods guaranteed to produce a unique set when starting from a unique set
3242         guaranteedUnique = {
3243                 children: true,
3244                 contents: true,
3245                 next: true,
3246                 prev: true
3247         };
3248
3249 jQuery.fn.extend( {
3250         has: function( target ) {
3251                 var targets = jQuery( target, this ),
3252                         l = targets.length;
3253
3254                 return this.filter( function() {
3255                         var i = 0;
3256                         for ( ; i < l; i++ ) {
3257                                 if ( jQuery.contains( this, targets[ i ] ) ) {
3258                                         return true;
3259                                 }
3260                         }
3261                 } );
3262         },
3263
3264         closest: function( selectors, context ) {
3265                 var cur,
3266                         i = 0,
3267                         l = this.length,
3268                         matched = [],
3269                         targets = typeof selectors !== "string" && jQuery( selectors );
3270
3271                 // Positional selectors never match, since there's no _selection_ context
3272                 if ( !rneedsContext.test( selectors ) ) {
3273                         for ( ; i < l; i++ ) {
3274                                 for ( cur = this[ i ]; cur && cur !== context; cur = cur.parentNode ) {
3275
3276                                         // Always skip document fragments
3277                                         if ( cur.nodeType < 11 && ( targets ?
3278                                                 targets.index( cur ) > -1 :
3279
3280                                                 // Don't pass non-elements to Sizzle
3281                                                 cur.nodeType === 1 &&
3282                                                         jQuery.find.matchesSelector( cur, selectors ) ) ) {
3283
3284                                                 matched.push( cur );
3285                                                 break;
3286                                         }
3287                                 }
3288                         }
3289                 }
3290
3291                 return this.pushStack( matched.length > 1 ? jQuery.uniqueSort( matched ) : matched );
3292         },
3293
3294         // Determine the position of an element within the set
3295         index: function( elem ) {
3296
3297                 // No argument, return index in parent
3298                 if ( !elem ) {
3299                         return ( this[ 0 ] && this[ 0 ].parentNode ) ? this.first().prevAll().length : -1;
3300                 }
3301
3302                 // Index in selector
3303                 if ( typeof elem === "string" ) {
3304                         return indexOf.call( jQuery( elem ), this[ 0 ] );
3305                 }
3306
3307                 // Locate the position of the desired element
3308                 return indexOf.call( this,
3309
3310                         // If it receives a jQuery object, the first element is used
3311                         elem.jquery ? elem[ 0 ] : elem
3312                 );
3313         },
3314
3315         add: function( selector, context ) {
3316                 return this.pushStack(
3317                         jQuery.uniqueSort(
3318                                 jQuery.merge( this.get(), jQuery( selector, context ) )
3319                         )
3320                 );
3321         },
3322
3323         addBack: function( selector ) {
3324                 return this.add( selector == null ?
3325                         this.prevObject : this.prevObject.filter( selector )
3326                 );
3327         }
3328 } );
3329
3330 function sibling( cur, dir ) {
3331         while ( ( cur = cur[ dir ] ) && cur.nodeType !== 1 ) {}
3332         return cur;
3333 }
3334
3335 jQuery.each( {
3336         parent: function( elem ) {
3337                 var parent = elem.parentNode;
3338                 return parent && parent.nodeType !== 11 ? parent : null;
3339         },
3340         parents: function( elem ) {
3341                 return dir( elem, "parentNode" );
3342         },
3343         parentsUntil: function( elem, _i, until ) {
3344                 return dir( elem, "parentNode", until );
3345         },
3346         next: function( elem ) {
3347                 return sibling( elem, "nextSibling" );
3348         },
3349         prev: function( elem ) {
3350                 return sibling( elem, "previousSibling" );
3351         },
3352         nextAll: function( elem ) {
3353                 return dir( elem, "nextSibling" );
3354         },
3355         prevAll: function( elem ) {
3356                 return dir( elem, "previousSibling" );
3357         },
3358         nextUntil: function( elem, _i, until ) {
3359                 return dir( elem, "nextSibling", until );
3360         },
3361         prevUntil: function( elem, _i, until ) {
3362                 return dir( elem, "previousSibling", until );
3363         },
3364         siblings: function( elem ) {
3365                 return siblings( ( elem.parentNode || {} ).firstChild, elem );
3366         },
3367         children: function( elem ) {
3368                 return siblings( elem.firstChild );
3369         },
3370         contents: function( elem ) {
3371                 if ( elem.contentDocument != null &&
3372
3373                         // Support: IE 11+
3374                         // <object> elements with no `data` attribute has an object
3375                         // `contentDocument` with a `null` prototype.
3376                         getProto( elem.contentDocument ) ) {
3377
3378                         return elem.contentDocument;
3379                 }
3380
3381                 // Support: IE 9 - 11 only, iOS 7 only, Android Browser <=4.3 only
3382                 // Treat the template element as a regular one in browsers that
3383                 // don't support it.
3384                 if ( nodeName( elem, "template" ) ) {
3385                         elem = elem.content || elem;
3386                 }
3387
3388                 return jQuery.merge( [], elem.childNodes );
3389         }
3390 }, function( name, fn ) {
3391         jQuery.fn[ name ] = function( until, selector ) {
3392                 var matched = jQuery.map( this, fn, until );
3393
3394                 if ( name.slice( -5 ) !== "Until" ) {
3395                         selector = until;
3396                 }
3397
3398                 if ( selector && typeof selector === "string" ) {
3399                         matched = jQuery.filter( selector, matched );
3400                 }
3401
3402                 if ( this.length > 1 ) {
3403
3404                         // Remove duplicates
3405                         if ( !guaranteedUnique[ name ] ) {
3406                                 jQuery.uniqueSort( matched );
3407                         }
3408
3409                         // Reverse order for parents* and prev-derivatives
3410                         if ( rparentsprev.test( name ) ) {
3411                                 matched.reverse();
3412                         }
3413                 }
3414
3415                 return this.pushStack( matched );
3416         };
3417 } );
3418 var rnothtmlwhite = ( /[^\x20\t\r\n\f]+/g );
3419
3420
3421
3422 // Convert String-formatted options into Object-formatted ones
3423 function createOptions( options ) {
3424         var object = {};
3425         jQuery.each( options.match( rnothtmlwhite ) || [], function( _, flag ) {
3426                 object[ flag ] = true;
3427         } );
3428         return object;
3429 }
3430
3431 /*
3432  * Create a callback list using the following parameters:
3433  *
3434  *      options: an optional list of space-separated options that will change how
3435  *                      the callback list behaves or a more traditional option object
3436  *
3437  * By default a callback list will act like an event callback list and can be
3438  * "fired" multiple times.
3439  *
3440  * Possible options:
3441  *
3442  *      once:                   will ensure the callback list can only be fired once (like a Deferred)
3443  *
3444  *      memory:                 will keep track of previous values and will call any callback added
3445  *                                      after the list has been fired right away with the latest "memorized"
3446  *                                      values (like a Deferred)
3447  *
3448  *      unique:                 will ensure a callback can only be added once (no duplicate in the list)
3449  *
3450  *      stopOnFalse:    interrupt callings when a callback returns false
3451  *
3452  */
3453 jQuery.Callbacks = function( options ) {
3454
3455         // Convert options from String-formatted to Object-formatted if needed
3456         // (we check in cache first)
3457         options = typeof options === "string" ?
3458                 createOptions( options ) :
3459                 jQuery.extend( {}, options );
3460
3461         var // Flag to know if list is currently firing
3462                 firing,
3463
3464                 // Last fire value for non-forgettable lists
3465                 memory,
3466
3467                 // Flag to know if list was already fired
3468                 fired,
3469
3470                 // Flag to prevent firing
3471                 locked,
3472
3473                 // Actual callback list
3474                 list = [],
3475
3476                 // Queue of execution data for repeatable lists
3477                 queue = [],
3478
3479                 // Index of currently firing callback (modified by add/remove as needed)
3480                 firingIndex = -1,
3481
3482                 // Fire callbacks
3483                 fire = function() {
3484
3485                         // Enforce single-firing
3486                         locked = locked || options.once;
3487
3488                         // Execute callbacks for all pending executions,
3489                         // respecting firingIndex overrides and runtime changes
3490                         fired = firing = true;
3491                         for ( ; queue.length; firingIndex = -1 ) {
3492                                 memory = queue.shift();
3493                                 while ( ++firingIndex < list.length ) {
3494
3495                                         // Run callback and check for early termination
3496                                         if ( list[ firingIndex ].apply( memory[ 0 ], memory[ 1 ] ) === false &&
3497                                                 options.stopOnFalse ) {
3498
3499                                                 // Jump to end and forget the data so .add doesn't re-fire
3500                                                 firingIndex = list.length;
3501                                                 memory = false;
3502                                         }
3503                                 }
3504                         }
3505
3506                         // Forget the data if we're done with it
3507                         if ( !options.memory ) {
3508                                 memory = false;
3509                         }
3510
3511                         firing = false;
3512
3513                         // Clean up if we're done firing for good
3514                         if ( locked ) {
3515
3516                                 // Keep an empty list if we have data for future add calls
3517                                 if ( memory ) {
3518                                         list = [];
3519
3520                                 // Otherwise, this object is spent
3521                                 } else {
3522                                         list = "";
3523                                 }
3524                         }
3525                 },
3526
3527                 // Actual Callbacks object
3528                 self = {
3529
3530                         // Add a callback or a collection of callbacks to the list
3531                         add: function() {
3532                                 if ( list ) {
3533
3534                                         // If we have memory from a past run, we should fire after adding
3535                                         if ( memory && !firing ) {
3536                                                 firingIndex = list.length - 1;
3537                                                 queue.push( memory );
3538                                         }
3539
3540                                         ( function add( args ) {
3541                                                 jQuery.each( args, function( _, arg ) {
3542                                                         if ( isFunction( arg ) ) {
3543                                                                 if ( !options.unique || !self.has( arg ) ) {
3544                                                                         list.push( arg );
3545                                                                 }
3546                                                         } else if ( arg && arg.length && toType( arg ) !== "string" ) {
3547
3548                                                                 // Inspect recursively
3549                                                                 add( arg );
3550                                                         }
3551                                                 } );
3552                                         } )( arguments );
3553
3554                                         if ( memory && !firing ) {
3555                                                 fire();
3556                                         }
3557                                 }
3558                                 return this;
3559                         },
3560
3561                         // Remove a callback from the list
3562                         remove: function() {
3563                                 jQuery.each( arguments, function( _, arg ) {
3564                                         var index;
3565                                         while ( ( index = jQuery.inArray( arg, list, index ) ) > -1 ) {
3566                                                 list.splice( index, 1 );
3567
3568                                                 // Handle firing indexes
3569                                                 if ( index <= firingIndex ) {
3570                                                         firingIndex--;
3571                                                 }
3572                                         }
3573                                 } );
3574                                 return this;
3575                         },
3576
3577                         // Check if a given callback is in the list.
3578                         // If no argument is given, return whether or not list has callbacks attached.
3579                         has: function( fn ) {
3580                                 return fn ?
3581                                         jQuery.inArray( fn, list ) > -1 :
3582                                         list.length > 0;
3583                         },
3584
3585                         // Remove all callbacks from the list
3586                         empty: function() {
3587                                 if ( list ) {
3588                                         list = [];
3589                                 }
3590                                 return this;
3591                         },
3592
3593                         // Disable .fire and .add
3594                         // Abort any current/pending executions
3595                         // Clear all callbacks and values
3596                         disable: function() {
3597                                 locked = queue = [];
3598                                 list = memory = "";
3599                                 return this;
3600                         },
3601                         disabled: function() {
3602                                 return !list;
3603                         },
3604
3605                         // Disable .fire
3606                         // Also disable .add unless we have memory (since it would have no effect)
3607                         // Abort any pending executions
3608                         lock: function() {
3609                                 locked = queue = [];
3610                                 if ( !memory && !firing ) {
3611                                         list = memory = "";
3612                                 }
3613                                 return this;
3614                         },
3615                         locked: function() {
3616                                 return !!locked;
3617                         },
3618
3619                         // Call all callbacks with the given context and arguments
3620                         fireWith: function( context, args ) {
3621                                 if ( !locked ) {
3622                                         args = args || [];
3623                                         args = [ context, args.slice ? args.slice() : args ];
3624                                         queue.push( args );
3625                                         if ( !firing ) {
3626                                                 fire();
3627                                         }
3628                                 }
3629                                 return this;
3630                         },
3631
3632                         // Call all the callbacks with the given arguments
3633                         fire: function() {
3634                                 self.fireWith( this, arguments );
3635                                 return this;
3636                         },
3637
3638                         // To know if the callbacks have already been called at least once
3639                         fired: function() {
3640                                 return !!fired;
3641                         }
3642                 };
3643
3644         return self;
3645 };
3646
3647
3648 function Identity( v ) {
3649         return v;
3650 }
3651 function Thrower( ex ) {
3652         throw ex;
3653 }
3654
3655 function adoptValue( value, resolve, reject, noValue ) {
3656         var method;
3657
3658         try {
3659
3660                 // Check for promise aspect first to privilege synchronous behavior
3661                 if ( value && isFunction( ( method = value.promise ) ) ) {
3662                         method.call( value ).done( resolve ).fail( reject );
3663
3664                 // Other thenables
3665                 } else if ( value && isFunction( ( method = value.then ) ) ) {
3666                         method.call( value, resolve, reject );
3667
3668                 // Other non-thenables
3669                 } else {
3670
3671                         // Control `resolve` arguments by letting Array#slice cast boolean `noValue` to integer:
3672                         // * false: [ value ].slice( 0 ) => resolve( value )
3673                         // * true: [ value ].slice( 1 ) => resolve()
3674                         resolve.apply( undefined, [ value ].slice( noValue ) );
3675                 }
3676
3677         // For Promises/A+, convert exceptions into rejections
3678         // Since jQuery.when doesn't unwrap thenables, we can skip the extra checks appearing in
3679         // Deferred#then to conditionally suppress rejection.
3680         } catch ( value ) {
3681
3682                 // Support: Android 4.0 only
3683                 // Strict mode functions invoked without .call/.apply get global-object context
3684                 reject.apply( undefined, [ value ] );
3685         }
3686 }
3687
3688 jQuery.extend( {
3689
3690         Deferred: function( func ) {
3691                 var tuples = [
3692
3693                                 // action, add listener, callbacks,
3694                                 // ... .then handlers, argument index, [final state]
3695                                 [ "notify", "progress", jQuery.Callbacks( "memory" ),
3696                                         jQuery.Callbacks( "memory" ), 2 ],
3697                                 [ "resolve", "done", jQuery.Callbacks( "once memory" ),
3698                                         jQuery.Callbacks( "once memory" ), 0, "resolved" ],
3699                                 [ "reject", "fail", jQuery.Callbacks( "once memory" ),
3700                                         jQuery.Callbacks( "once memory" ), 1, "rejected" ]
3701                         ],
3702                         state = "pending",
3703                         promise = {
3704                                 state: function() {
3705                                         return state;
3706                                 },
3707                                 always: function() {
3708                                         deferred.done( arguments ).fail( arguments );
3709                                         return this;
3710                                 },
3711                                 "catch": function( fn ) {
3712                                         return promise.then( null, fn );
3713                                 },
3714
3715                                 // Keep pipe for back-compat
3716                                 pipe: function( /* fnDone, fnFail, fnProgress */ ) {
3717                                         var fns = arguments;
3718
3719                                         return jQuery.Deferred( function( newDefer ) {
3720                                                 jQuery.each( tuples, function( _i, tuple ) {
3721
3722                                                         // Map tuples (progress, done, fail) to arguments (done, fail, progress)
3723                                                         var fn = isFunction( fns[ tuple[ 4 ] ] ) && fns[ tuple[ 4 ] ];
3724
3725                                                         // deferred.progress(function() { bind to newDefer or newDefer.notify })
3726                                                         // deferred.done(function() { bind to newDefer or newDefer.resolve })
3727                                                         // deferred.fail(function() { bind to newDefer or newDefer.reject })
3728                                                         deferred[ tuple[ 1 ] ]( function() {
3729                                                                 var returned = fn && fn.apply( this, arguments );
3730                                                                 if ( returned && isFunction( returned.promise ) ) {
3731                                                                         returned.promise()
3732                                                                                 .progress( newDefer.notify )
3733                                                                                 .done( newDefer.resolve )
3734                                                                                 .fail( newDefer.reject );
3735                                                                 } else {
3736                                                                         newDefer[ tuple[ 0 ] + "With" ](
3737                                                                                 this,
3738                                                                                 fn ? [ returned ] : arguments
3739                                                                         );
3740                                                                 }
3741                                                         } );
3742                                                 } );
3743                                                 fns = null;
3744                                         } ).promise();
3745                                 },
3746                                 then: function( onFulfilled, onRejected, onProgress ) {
3747                                         var maxDepth = 0;
3748                                         function resolve( depth, deferred, handler, special ) {
3749                                                 return function() {
3750                                                         var that = this,
3751                                                                 args = arguments,
3752                                                                 mightThrow = function() {
3753                                                                         var returned, then;
3754
3755                                                                         // Support: Promises/A+ section 2.3.3.3.3
3756                                                                         // https://promisesaplus.com/#point-59
3757                                                                         // Ignore double-resolution attempts
3758                                                                         if ( depth < maxDepth ) {
3759                                                                                 return;
3760                                                                         }
3761
3762                                                                         returned = handler.apply( that, args );
3763
3764                                                                         // Support: Promises/A+ section 2.3.1
3765                                                                         // https://promisesaplus.com/#point-48
3766                                                                         if ( returned === deferred.promise() ) {
3767                                                                                 throw new TypeError( "Thenable self-resolution" );
3768                                                                         }
3769
3770                                                                         // Support: Promises/A+ sections 2.3.3.1, 3.5
3771                                                                         // https://promisesaplus.com/#point-54
3772                                                                         // https://promisesaplus.com/#point-75
3773                                                                         // Retrieve `then` only once
3774                                                                         then = returned &&
3775
3776                                                                                 // Support: Promises/A+ section 2.3.4
3777                                                                                 // https://promisesaplus.com/#point-64
3778                                                                                 // Only check objects and functions for thenability
3779                                                                                 ( typeof returned === "object" ||
3780                                                                                         typeof returned === "function" ) &&
3781                                                                                 returned.then;
3782
3783                                                                         // Handle a returned thenable
3784                                                                         if ( isFunction( then ) ) {
3785
3786                                                                                 // Special processors (notify) just wait for resolution
3787                                                                                 if ( special ) {
3788                                                                                         then.call(
3789                                                                                                 returned,
3790                                                                                                 resolve( maxDepth, deferred, Identity, special ),
3791                                                                                                 resolve( maxDepth, deferred, Thrower, special )
3792                                                                                         );
3793
3794                                                                                 // Normal processors (resolve) also hook into progress
3795                                                                                 } else {
3796
3797                                                                                         // ...and disregard older resolution values
3798                                                                                         maxDepth++;
3799
3800                                                                                         then.call(
3801                                                                                                 returned,
3802                                                                                                 resolve( maxDepth, deferred, Identity, special ),
3803                                                                                                 resolve( maxDepth, deferred, Thrower, special ),
3804                                                                                                 resolve( maxDepth, deferred, Identity,
3805                                                                                                         deferred.notifyWith )
3806                                                                                         );
3807                                                                                 }
3808
3809                                                                         // Handle all other returned values
3810                                                                         } else {
3811
3812                                                                                 // Only substitute handlers pass on context
3813                                                                                 // and multiple values (non-spec behavior)
3814                                                                                 if ( handler !== Identity ) {
3815                                                                                         that = undefined;
3816                                                                                         args = [ returned ];
3817                                                                                 }
3818
3819                                                                                 // Process the value(s)
3820                                                                                 // Default process is resolve
3821                                                                                 ( special || deferred.resolveWith )( that, args );
3822                                                                         }
3823                                                                 },
3824
3825                                                                 // Only normal processors (resolve) catch and reject exceptions
3826                                                                 process = special ?
3827                                                                         mightThrow :
3828                                                                         function() {
3829                                                                                 try {
3830                                                                                         mightThrow();
3831                                                                                 } catch ( e ) {
3832
3833                                                                                         if ( jQuery.Deferred.exceptionHook ) {
3834                                                                                                 jQuery.Deferred.exceptionHook( e,
3835                                                                                                         process.stackTrace );
3836                                                                                         }
3837
3838                                                                                         // Support: Promises/A+ section 2.3.3.3.4.1
3839                                                                                         // https://promisesaplus.com/#point-61
3840                                                                                         // Ignore post-resolution exceptions
3841                                                                                         if ( depth + 1 >= maxDepth ) {
3842
3843                                                                                                 // Only substitute handlers pass on context
3844                                                                                                 // and multiple values (non-spec behavior)
3845                                                                                                 if ( handler !== Thrower ) {
3846                                                                                                         that = undefined;
3847                                                                                                         args = [ e ];
3848                                                                                                 }
3849
3850                                                                                                 deferred.rejectWith( that, args );
3851                                                                                         }
3852                                                                                 }
3853                                                                         };
3854
3855                                                         // Support: Promises/A+ section 2.3.3.3.1
3856                                                         // https://promisesaplus.com/#point-57
3857                                                         // Re-resolve promises immediately to dodge false rejection from
3858                                                         // subsequent errors
3859                                                         if ( depth ) {
3860                                                                 process();
3861                                                         } else {
3862
3863                                                                 // Call an optional hook to record the stack, in case of exception
3864                                                                 // since it's otherwise lost when execution goes async
3865                                                                 if ( jQuery.Deferred.getStackHook ) {
3866                                                                         process.stackTrace = jQuery.Deferred.getStackHook();
3867                                                                 }
3868                                                                 window.setTimeout( process );
3869                                                         }
3870                                                 };
3871                                         }
3872
3873                                         return jQuery.Deferred( function( newDefer ) {
3874
3875                                                 // progress_handlers.add( ... )
3876                                                 tuples[ 0 ][ 3 ].add(
3877                                                         resolve(
3878                                                                 0,
3879                                                                 newDefer,
3880                                                                 isFunction( onProgress ) ?
3881                                                                         onProgress :
3882                                                                         Identity,
3883                                                                 newDefer.notifyWith
3884                                                         )
3885                                                 );
3886
3887                                                 // fulfilled_handlers.add( ... )
3888                                                 tuples[ 1 ][ 3 ].add(
3889                                                         resolve(
3890                                                                 0,
3891                                                                 newDefer,
3892                                                                 isFunction( onFulfilled ) ?
3893                                                                         onFulfilled :
3894                                                                         Identity
3895                                                         )
3896                                                 );
3897
3898                                                 // rejected_handlers.add( ... )
3899                                                 tuples[ 2 ][ 3 ].add(
3900                                                         resolve(
3901                                                                 0,
3902                                                                 newDefer,
3903                                                                 isFunction( onRejected ) ?
3904                                                                         onRejected :
3905                                                                         Thrower
3906                                                         )
3907                                                 );
3908                                         } ).promise();
3909                                 },
3910
3911                                 // Get a promise for this deferred
3912                                 // If obj is provided, the promise aspect is added to the object
3913                                 promise: function( obj ) {
3914                                         return obj != null ? jQuery.extend( obj, promise ) : promise;
3915                                 }
3916                         },
3917                         deferred = {};
3918
3919                 // Add list-specific methods
3920                 jQuery.each( tuples, function( i, tuple ) {
3921                         var list = tuple[ 2 ],
3922                                 stateString = tuple[ 5 ];
3923
3924                         // promise.progress = list.add
3925                         // promise.done = list.add
3926                         // promise.fail = list.add
3927                         promise[ tuple[ 1 ] ] = list.add;
3928
3929                         // Handle state
3930                         if ( stateString ) {
3931                                 list.add(
3932                                         function() {
3933
3934                                                 // state = "resolved" (i.e., fulfilled)
3935                                                 // state = "rejected"
3936                                                 state = stateString;
3937                                         },
3938
3939                                         // rejected_callbacks.disable
3940                                         // fulfilled_callbacks.disable
3941                                         tuples[ 3 - i ][ 2 ].disable,
3942
3943                                         // rejected_handlers.disable
3944                                         // fulfilled_handlers.disable
3945                                         tuples[ 3 - i ][ 3 ].disable,
3946
3947                                         // progress_callbacks.lock
3948                                         tuples[ 0 ][ 2 ].lock,
3949
3950                                         // progress_handlers.lock
3951                                         tuples[ 0 ][ 3 ].lock
3952                                 );
3953                         }
3954
3955                         // progress_handlers.fire
3956                         // fulfilled_handlers.fire
3957                         // rejected_handlers.fire
3958                         list.add( tuple[ 3 ].fire );
3959
3960                         // deferred.notify = function() { deferred.notifyWith(...) }
3961                         // deferred.resolve = function() { deferred.resolveWith(...) }
3962                         // deferred.reject = function() { deferred.rejectWith(...) }
3963                         deferred[ tuple[ 0 ] ] = function() {
3964                                 deferred[ tuple[ 0 ] + "With" ]( this === deferred ? undefined : this, arguments );
3965                                 return this;
3966                         };
3967
3968                         // deferred.notifyWith = list.fireWith
3969                         // deferred.resolveWith = list.fireWith
3970                         // deferred.rejectWith = list.fireWith
3971                         deferred[ tuple[ 0 ] + "With" ] = list.fireWith;
3972                 } );
3973
3974                 // Make the deferred a promise
3975                 promise.promise( deferred );
3976
3977                 // Call given func if any
3978                 if ( func ) {
3979                         func.call( deferred, deferred );
3980                 }
3981
3982                 // All done!
3983                 return deferred;
3984         },
3985
3986         // Deferred helper
3987         when: function( singleValue ) {
3988                 var
3989
3990                         // count of uncompleted subordinates
3991                         remaining = arguments.length,
3992
3993                         // count of unprocessed arguments
3994                         i = remaining,
3995
3996                         // subordinate fulfillment data
3997                         resolveContexts = Array( i ),
3998                         resolveValues = slice.call( arguments ),
3999
4000                         // the master Deferred
4001                         master = jQuery.Deferred(),
4002
4003                         // subordinate callback factory
4004                         updateFunc = function( i ) {
4005                                 return function( value ) {
4006                                         resolveContexts[ i ] = this;
4007                                         resolveValues[ i ] = arguments.length > 1 ? slice.call( arguments ) : value;
4008                                         if ( !( --remaining ) ) {
4009                                                 master.resolveWith( resolveContexts, resolveValues );
4010                                         }
4011                                 };
4012                         };
4013
4014                 // Single- and empty arguments are adopted like Promise.resolve
4015                 if ( remaining <= 1 ) {
4016                         adoptValue( singleValue, master.done( updateFunc( i ) ).resolve, master.reject,
4017                                 !remaining );
4018
4019                         // Use .then() to unwrap secondary thenables (cf. gh-3000)
4020                         if ( master.state() === "pending" ||
4021                                 isFunction( resolveValues[ i ] && resolveValues[ i ].then ) ) {
4022
4023                                 return master.then();
4024                         }
4025                 }
4026
4027                 // Multiple arguments are aggregated like Promise.all array elements
4028                 while ( i-- ) {
4029                         adoptValue( resolveValues[ i ], updateFunc( i ), master.reject );
4030                 }
4031
4032                 return master.promise();
4033         }
4034 } );
4035
4036
4037 // These usually indicate a programmer mistake during development,
4038 // warn about them ASAP rather than swallowing them by default.
4039 var rerrorNames = /^(Eval|Internal|Range|Reference|Syntax|Type|URI)Error$/;
4040
4041 jQuery.Deferred.exceptionHook = function( error, stack ) {
4042
4043         // Support: IE 8 - 9 only
4044         // Console exists when dev tools are open, which can happen at any time
4045         if ( window.console && window.console.warn && error && rerrorNames.test( error.name ) ) {
4046                 window.console.warn( "jQuery.Deferred exception: " + error.message, error.stack, stack );
4047         }
4048 };
4049
4050
4051
4052
4053 jQuery.readyException = function( error ) {
4054         window.setTimeout( function() {
4055                 throw error;
4056         } );
4057 };
4058
4059
4060
4061
4062 // The deferred used on DOM ready
4063 var readyList = jQuery.Deferred();
4064
4065 jQuery.fn.ready = function( fn ) {
4066
4067         readyList
4068                 .then( fn )
4069
4070                 // Wrap jQuery.readyException in a function so that the lookup
4071                 // happens at the time of error handling instead of callback
4072                 // registration.
4073                 .catch( function( error ) {
4074                         jQuery.readyException( error );
4075                 } );
4076
4077         return this;
4078 };
4079
4080 jQuery.extend( {
4081
4082         // Is the DOM ready to be used? Set to true once it occurs.
4083         isReady: false,
4084
4085         // A counter to track how many items to wait for before
4086         // the ready event fires. See #6781
4087         readyWait: 1,
4088
4089         // Handle when the DOM is ready
4090         ready: function( wait ) {
4091
4092                 // Abort if there are pending holds or we're already ready
4093                 if ( wait === true ? --jQuery.readyWait : jQuery.isReady ) {
4094                         return;
4095                 }
4096
4097                 // Remember that the DOM is ready
4098                 jQuery.isReady = true;
4099
4100                 // If a normal DOM Ready event fired, decrement, and wait if need be
4101                 if ( wait !== true && --jQuery.readyWait > 0 ) {
4102                         return;
4103                 }
4104
4105                 // If there are functions bound, to execute
4106                 readyList.resolveWith( document, [ jQuery ] );
4107         }
4108 } );
4109
4110 jQuery.ready.then = readyList.then;
4111
4112 // The ready event handler and self cleanup method
4113 function completed() {
4114         document.removeEventListener( "DOMContentLoaded", completed );
4115         window.removeEventListener( "load", completed );
4116         jQuery.ready();
4117 }
4118
4119 // Catch cases where $(document).ready() is called
4120 // after the browser event has already occurred.
4121 // Support: IE <=9 - 10 only
4122 // Older IE sometimes signals "interactive" too soon
4123 if ( document.readyState === "complete" ||
4124         ( document.readyState !== "loading" && !document.documentElement.doScroll ) ) {
4125
4126         // Handle it asynchronously to allow scripts the opportunity to delay ready
4127         window.setTimeout( jQuery.ready );
4128
4129 } else {
4130
4131         // Use the handy event callback
4132         document.addEventListener( "DOMContentLoaded", completed );
4133
4134         // A fallback to window.onload, that will always work
4135         window.addEventListener( "load", completed );
4136 }
4137
4138
4139
4140
4141 // Multifunctional method to get and set values of a collection
4142 // The value/s can optionally be executed if it's a function
4143 var access = function( elems, fn, key, value, chainable, emptyGet, raw ) {
4144         var i = 0,
4145                 len = elems.length,
4146                 bulk = key == null;
4147
4148         // Sets many values
4149         if ( toType( key ) === "object" ) {
4150                 chainable = true;
4151                 for ( i in key ) {
4152                         access( elems, fn, i, key[ i ], true, emptyGet, raw );
4153                 }
4154
4155         // Sets one value
4156         } else if ( value !== undefined ) {
4157                 chainable = true;
4158
4159                 if ( !isFunction( value ) ) {
4160                         raw = true;
4161                 }
4162
4163                 if ( bulk ) {
4164
4165                         // Bulk operations run against the entire set
4166                         if ( raw ) {
4167                                 fn.call( elems, value );
4168                                 fn = null;
4169
4170                         // ...except when executing function values
4171                         } else {
4172                                 bulk = fn;
4173                                 fn = function( elem, _key, value ) {
4174                                         return bulk.call( jQuery( elem ), value );
4175                                 };
4176                         }
4177                 }
4178
4179                 if ( fn ) {
4180                         for ( ; i < len; i++ ) {
4181                                 fn(
4182                                         elems[ i ], key, raw ?
4183                                         value :
4184                                         value.call( elems[ i ], i, fn( elems[ i ], key ) )
4185                                 );
4186                         }
4187                 }
4188         }
4189
4190         if ( chainable ) {
4191                 return elems;
4192         }
4193
4194         // Gets
4195         if ( bulk ) {
4196                 return fn.call( elems );
4197         }
4198
4199         return len ? fn( elems[ 0 ], key ) : emptyGet;
4200 };
4201
4202
4203 // Matches dashed string for camelizing
4204 var rmsPrefix = /^-ms-/,
4205         rdashAlpha = /-([a-z])/g;
4206
4207 // Used by camelCase as callback to replace()
4208 function fcamelCase( _all, letter ) {
4209         return letter.toUpperCase();
4210 }
4211
4212 // Convert dashed to camelCase; used by the css and data modules
4213 // Support: IE <=9 - 11, Edge 12 - 15
4214 // Microsoft forgot to hump their vendor prefix (#9572)
4215 function camelCase( string ) {
4216         return string.replace( rmsPrefix, "ms-" ).replace( rdashAlpha, fcamelCase );
4217 }
4218 var acceptData = function( owner ) {
4219
4220         // Accepts only:
4221         //  - Node
4222         //    - Node.ELEMENT_NODE
4223         //    - Node.DOCUMENT_NODE
4224         //  - Object
4225         //    - Any
4226         return owner.nodeType === 1 || owner.nodeType === 9 || !( +owner.nodeType );
4227 };
4228
4229
4230
4231
4232 function Data() {
4233         this.expando = jQuery.expando + Data.uid++;
4234 }
4235
4236 Data.uid = 1;
4237
4238 Data.prototype = {
4239
4240         cache: function( owner ) {
4241
4242                 // Check if the owner object already has a cache
4243                 var value = owner[ this.expando ];
4244
4245                 // If not, create one
4246                 if ( !value ) {
4247                         value = {};
4248
4249                         // We can accept data for non-element nodes in modern browsers,
4250                         // but we should not, see #8335.
4251                         // Always return an empty object.
4252                         if ( acceptData( owner ) ) {
4253
4254                                 // If it is a node unlikely to be stringify-ed or looped over
4255                                 // use plain assignment
4256                                 if ( owner.nodeType ) {
4257                                         owner[ this.expando ] = value;
4258
4259                                 // Otherwise secure it in a non-enumerable property
4260                                 // configurable must be true to allow the property to be
4261                                 // deleted when data is removed
4262                                 } else {
4263                                         Object.defineProperty( owner, this.expando, {
4264                                                 value: value,
4265                                                 configurable: true
4266                                         } );
4267                                 }
4268                         }
4269                 }
4270
4271                 return value;
4272         },
4273         set: function( owner, data, value ) {
4274                 var prop,
4275                         cache = this.cache( owner );
4276
4277                 // Handle: [ owner, key, value ] args
4278                 // Always use camelCase key (gh-2257)
4279                 if ( typeof data === "string" ) {
4280                         cache[ camelCase( data ) ] = value;
4281
4282                 // Handle: [ owner, { properties } ] args
4283                 } else {
4284
4285                         // Copy the properties one-by-one to the cache object
4286                         for ( prop in data ) {
4287                                 cache[ camelCase( prop ) ] = data[ prop ];
4288                         }
4289                 }
4290                 return cache;
4291         },
4292         get: function( owner, key ) {
4293                 return key === undefined ?
4294                         this.cache( owner ) :
4295
4296                         // Always use camelCase key (gh-2257)
4297                         owner[ this.expando ] && owner[ this.expando ][ camelCase( key ) ];
4298         },
4299         access: function( owner, key, value ) {
4300
4301                 // In cases where either:
4302                 //
4303                 //   1. No key was specified
4304                 //   2. A string key was specified, but no value provided
4305                 //
4306                 // Take the "read" path and allow the get method to determine
4307                 // which value to return, respectively either:
4308                 //
4309                 //   1. The entire cache object
4310                 //   2. The data stored at the key
4311                 //
4312                 if ( key === undefined ||
4313                                 ( ( key && typeof key === "string" ) && value === undefined ) ) {
4314
4315                         return this.get( owner, key );
4316                 }
4317
4318                 // When the key is not a string, or both a key and value
4319                 // are specified, set or extend (existing objects) with either:
4320                 //
4321                 //   1. An object of properties
4322                 //   2. A key and value
4323                 //
4324                 this.set( owner, key, value );
4325
4326                 // Since the "set" path can have two possible entry points
4327                 // return the expected data based on which path was taken[*]
4328                 return value !== undefined ? value : key;
4329         },
4330         remove: function( owner, key ) {
4331                 var i,
4332                         cache = owner[ this.expando ];
4333
4334                 if ( cache === undefined ) {
4335                         return;
4336                 }
4337
4338                 if ( key !== undefined ) {
4339
4340                         // Support array or space separated string of keys
4341                         if ( Array.isArray( key ) ) {
4342
4343                                 // If key is an array of keys...
4344                                 // We always set camelCase keys, so remove that.
4345                                 key = key.map( camelCase );
4346                         } else {
4347                                 key = camelCase( key );
4348
4349                                 // If a key with the spaces exists, use it.
4350                                 // Otherwise, create an array by matching non-whitespace
4351                                 key = key in cache ?
4352                                         [ key ] :
4353                                         ( key.match( rnothtmlwhite ) || [] );
4354                         }
4355
4356                         i = key.length;
4357
4358                         while ( i-- ) {
4359                                 delete cache[ key[ i ] ];
4360                         }
4361                 }
4362
4363                 // Remove the expando if there's no more data
4364                 if ( key === undefined || jQuery.isEmptyObject( cache ) ) {
4365
4366                         // Support: Chrome <=35 - 45
4367                         // Webkit & Blink performance suffers when deleting properties
4368                         // from DOM nodes, so set to undefined instead
4369                         // https://bugs.chromium.org/p/chromium/issues/detail?id=378607 (bug restricted)
4370                         if ( owner.nodeType ) {
4371                                 owner[ this.expando ] = undefined;
4372                         } else {
4373                                 delete owner[ this.expando ];
4374                         }
4375                 }
4376         },
4377         hasData: function( owner ) {
4378                 var cache = owner[ this.expando ];
4379                 return cache !== undefined && !jQuery.isEmptyObject( cache );
4380         }
4381 };
4382 var dataPriv = new Data();
4383
4384 var dataUser = new Data();
4385
4386
4387
4388 //      Implementation Summary
4389 //
4390 //      1. Enforce API surface and semantic compatibility with 1.9.x branch
4391 //      2. Improve the module's maintainability by reducing the storage
4392 //              paths to a single mechanism.
4393 //      3. Use the same single mechanism to support "private" and "user" data.
4394 //      4. _Never_ expose "private" data to user code (TODO: Drop _data, _removeData)
4395 //      5. Avoid exposing implementation details on user objects (eg. expando properties)
4396 //      6. Provide a clear path for implementation upgrade to WeakMap in 2014
4397
4398 var rbrace = /^(?:\{[\w\W]*\}|\[[\w\W]*\])$/,
4399         rmultiDash = /[A-Z]/g;
4400
4401 function getData( data ) {
4402         if ( data === "true" ) {
4403                 return true;
4404         }
4405
4406         if ( data === "false" ) {
4407                 return false;
4408         }
4409
4410         if ( data === "null" ) {
4411                 return null;
4412         }
4413
4414         // Only convert to a number if it doesn't change the string
4415         if ( data === +data + "" ) {
4416                 return +data;
4417         }
4418
4419         if ( rbrace.test( data ) ) {
4420                 return JSON.parse( data );
4421         }
4422
4423         return data;
4424 }
4425
4426 function dataAttr( elem, key, data ) {
4427         var name;
4428
4429         // If nothing was found internally, try to fetch any
4430         // data from the HTML5 data-* attribute
4431         if ( data === undefined && elem.nodeType === 1 ) {
4432                 name = "data-" + key.replace( rmultiDash, "-$&" ).toLowerCase();
4433                 data = elem.getAttribute( name );
4434
4435                 if ( typeof data === "string" ) {
4436                         try {
4437                                 data = getData( data );
4438                         } catch ( e ) {}
4439
4440                         // Make sure we set the data so it isn't changed later
4441                         dataUser.set( elem, key, data );
4442                 } else {
4443                         data = undefined;
4444                 }
4445         }
4446         return data;
4447 }
4448
4449 jQuery.extend( {
4450         hasData: function( elem ) {
4451                 return dataUser.hasData( elem ) || dataPriv.hasData( elem );
4452         },
4453
4454         data: function( elem, name, data ) {
4455                 return dataUser.access( elem, name, data );
4456         },
4457
4458         removeData: function( elem, name ) {
4459                 dataUser.remove( elem, name );
4460         },
4461
4462         // TODO: Now that all calls to _data and _removeData have been replaced
4463         // with direct calls to dataPriv methods, these can be deprecated.
4464         _data: function( elem, name, data ) {
4465                 return dataPriv.access( elem, name, data );
4466         },
4467
4468         _removeData: function( elem, name ) {
4469                 dataPriv.remove( elem, name );
4470         }
4471 } );
4472
4473 jQuery.fn.extend( {
4474         data: function( key, value ) {
4475                 var i, name, data,
4476                         elem = this[ 0 ],
4477                         attrs = elem && elem.attributes;
4478
4479                 // Gets all values
4480                 if ( key === undefined ) {
4481                         if ( this.length ) {
4482                                 data = dataUser.get( elem );
4483
4484                                 if ( elem.nodeType === 1 && !dataPriv.get( elem, "hasDataAttrs" ) ) {
4485                                         i = attrs.length;
4486                                         while ( i-- ) {
4487
4488                                                 // Support: IE 11 only
4489                                                 // The attrs elements can be null (#14894)
4490                                                 if ( attrs[ i ] ) {
4491                                                         name = attrs[ i ].name;
4492                                                         if ( name.indexOf( "data-" ) === 0 ) {
4493                                                                 name = camelCase( name.slice( 5 ) );
4494                                                                 dataAttr( elem, name, data[ name ] );
4495                                                         }
4496                                                 }
4497                                         }
4498                                         dataPriv.set( elem, "hasDataAttrs", true );
4499                                 }
4500                         }
4501
4502                         return data;
4503                 }
4504
4505                 // Sets multiple values
4506                 if ( typeof key === "object" ) {
4507                         return this.each( function() {
4508                                 dataUser.set( this, key );
4509                         } );
4510                 }
4511
4512                 return access( this, function( value ) {
4513                         var data;
4514
4515                         // The calling jQuery object (element matches) is not empty
4516                         // (and therefore has an element appears at this[ 0 ]) and the
4517                         // `value` parameter was not undefined. An empty jQuery object
4518                         // will result in `undefined` for elem = this[ 0 ] which will
4519                         // throw an exception if an attempt to read a data cache is made.
4520                         if ( elem && value === undefined ) {
4521
4522                                 // Attempt to get data from the cache
4523                                 // The key will always be camelCased in Data
4524                                 data = dataUser.get( elem, key );
4525                                 if ( data !== undefined ) {
4526                                         return data;
4527                                 }
4528
4529                                 // Attempt to "discover" the data in
4530                                 // HTML5 custom data-* attrs
4531                                 data = dataAttr( elem, key );
4532                                 if ( data !== undefined ) {
4533                                         return data;
4534                                 }
4535
4536                                 // We tried really hard, but the data doesn't exist.
4537                                 return;
4538                         }
4539
4540                         // Set the data...
4541                         this.each( function() {
4542
4543                                 // We always store the camelCased key
4544                                 dataUser.set( this, key, value );
4545                         } );
4546                 }, null, value, arguments.length > 1, null, true );
4547         },
4548
4549         removeData: function( key ) {
4550                 return this.each( function() {
4551                         dataUser.remove( this, key );
4552                 } );
4553         }
4554 } );
4555
4556
4557 jQuery.extend( {
4558         queue: function( elem, type, data ) {
4559                 var queue;
4560
4561                 if ( elem ) {
4562                         type = ( type || "fx" ) + "queue";
4563                         queue = dataPriv.get( elem, type );
4564
4565                         // Speed up dequeue by getting out quickly if this is just a lookup
4566                         if ( data ) {
4567                                 if ( !queue || Array.isArray( data ) ) {
4568                                         queue = dataPriv.access( elem, type, jQuery.makeArray( data ) );
4569                                 } else {
4570                                         queue.push( data );
4571                                 }
4572                         }
4573                         return queue || [];
4574                 }
4575         },
4576
4577         dequeue: function( elem, type ) {
4578                 type = type || "fx";
4579
4580                 var queue = jQuery.queue( elem, type ),
4581                         startLength = queue.length,
4582                         fn = queue.shift(),
4583                         hooks = jQuery._queueHooks( elem, type ),
4584                         next = function() {
4585                                 jQuery.dequeue( elem, type );
4586                         };
4587
4588                 // If the fx queue is dequeued, always remove the progress sentinel
4589                 if ( fn === "inprogress" ) {
4590                         fn = queue.shift();
4591                         startLength--;
4592                 }
4593
4594                 if ( fn ) {
4595
4596                         // Add a progress sentinel to prevent the fx queue from being
4597                         // automatically dequeued
4598                         if ( type === "fx" ) {
4599                                 queue.unshift( "inprogress" );
4600                         }
4601
4602                         // Clear up the last queue stop function
4603                         delete hooks.stop;
4604                         fn.call( elem, next, hooks );
4605                 }
4606
4607                 if ( !startLength && hooks ) {
4608                         hooks.empty.fire();
4609                 }
4610         },
4611
4612         // Not public - generate a queueHooks object, or return the current one
4613         _queueHooks: function( elem, type ) {
4614                 var key = type + "queueHooks";
4615                 return dataPriv.get( elem, key ) || dataPriv.access( elem, key, {
4616                         empty: jQuery.Callbacks( "once memory" ).add( function() {
4617                                 dataPriv.remove( elem, [ type + "queue", key ] );
4618                         } )
4619                 } );
4620         }
4621 } );
4622
4623 jQuery.fn.extend( {
4624         queue: function( type, data ) {
4625                 var setter = 2;
4626
4627                 if ( typeof type !== "string" ) {
4628                         data = type;
4629                         type = "fx";
4630                         setter--;
4631                 }
4632
4633                 if ( arguments.length < setter ) {
4634                         return jQuery.queue( this[ 0 ], type );
4635                 }
4636
4637                 return data === undefined ?
4638                         this :
4639                         this.each( function() {
4640                                 var queue = jQuery.queue( this, type, data );
4641
4642                                 // Ensure a hooks for this queue
4643                                 jQuery._queueHooks( this, type );
4644
4645                                 if ( type === "fx" && queue[ 0 ] !== "inprogress" ) {
4646                                         jQuery.dequeue( this, type );
4647                                 }
4648                         } );
4649         },
4650         dequeue: function( type ) {
4651                 return this.each( function() {
4652                         jQuery.dequeue( this, type );
4653                 } );
4654         },
4655         clearQueue: function( type ) {
4656                 return this.queue( type || "fx", [] );
4657         },
4658
4659         // Get a promise resolved when queues of a certain type
4660         // are emptied (fx is the type by default)
4661         promise: function( type, obj ) {
4662                 var tmp,
4663                         count = 1,
4664                         defer = jQuery.Deferred(),
4665                         elements = this,
4666                         i = this.length,
4667                         resolve = function() {
4668                                 if ( !( --count ) ) {
4669                                         defer.resolveWith( elements, [ elements ] );
4670                                 }
4671                         };
4672
4673                 if ( typeof type !== "string" ) {
4674                         obj = type;
4675                         type = undefined;
4676                 }
4677                 type = type || "fx";
4678
4679                 while ( i-- ) {
4680                         tmp = dataPriv.get( elements[ i ], type + "queueHooks" );
4681                         if ( tmp && tmp.empty ) {
4682                                 count++;
4683                                 tmp.empty.add( resolve );
4684                         }
4685                 }
4686                 resolve();
4687                 return defer.promise( obj );
4688         }
4689 } );
4690 var pnum = ( /[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/ ).source;
4691
4692 var rcssNum = new RegExp( "^(?:([+-])=|)(" + pnum + ")([a-z%]*)$", "i" );
4693
4694
4695 var cssExpand = [ "Top", "Right", "Bottom", "Left" ];
4696
4697 var documentElement = document.documentElement;
4698
4699
4700
4701         var isAttached = function( elem ) {
4702                         return jQuery.contains( elem.ownerDocument, elem );
4703                 },
4704                 composed = { composed: true };
4705
4706         // Support: IE 9 - 11+, Edge 12 - 18+, iOS 10.0 - 10.2 only
4707         // Check attachment across shadow DOM boundaries when possible (gh-3504)
4708         // Support: iOS 10.0-10.2 only
4709         // Early iOS 10 versions support `attachShadow` but not `getRootNode`,
4710         // leading to errors. We need to check for `getRootNode`.
4711         if ( documentElement.getRootNode ) {
4712                 isAttached = function( elem ) {
4713                         return jQuery.contains( elem.ownerDocument, elem ) ||
4714                                 elem.getRootNode( composed ) === elem.ownerDocument;
4715                 };
4716         }
4717 var isHiddenWithinTree = function( elem, el ) {
4718
4719                 // isHiddenWithinTree might be called from jQuery#filter function;
4720                 // in that case, element will be second argument
4721                 elem = el || elem;
4722
4723                 // Inline style trumps all
4724                 return elem.style.display === "none" ||
4725                         elem.style.display === "" &&
4726
4727                         // Otherwise, check computed style
4728                         // Support: Firefox <=43 - 45
4729                         // Disconnected elements can have computed display: none, so first confirm that elem is
4730                         // in the document.
4731                         isAttached( elem ) &&
4732
4733                         jQuery.css( elem, "display" ) === "none";
4734         };
4735
4736
4737
4738 function adjustCSS( elem, prop, valueParts, tween ) {
4739         var adjusted, scale,
4740                 maxIterations = 20,
4741                 currentValue = tween ?
4742                         function() {
4743                                 return tween.cur();
4744                         } :
4745                         function() {
4746                                 return jQuery.css( elem, prop, "" );
4747                         },
4748                 initial = currentValue(),
4749                 unit = valueParts && valueParts[ 3 ] || ( jQuery.cssNumber[ prop ] ? "" : "px" ),
4750
4751                 // Starting value computation is required for potential unit mismatches
4752                 initialInUnit = elem.nodeType &&
4753                         ( jQuery.cssNumber[ prop ] || unit !== "px" && +initial ) &&
4754                         rcssNum.exec( jQuery.css( elem, prop ) );
4755
4756         if ( initialInUnit && initialInUnit[ 3 ] !== unit ) {
4757
4758                 // Support: Firefox <=54
4759                 // Halve the iteration target value to prevent interference from CSS upper bounds (gh-2144)
4760                 initial = initial / 2;
4761
4762                 // Trust units reported by jQuery.css
4763                 unit = unit || initialInUnit[ 3 ];
4764
4765                 // Iteratively approximate from a nonzero starting point
4766                 initialInUnit = +initial || 1;
4767
4768                 while ( maxIterations-- ) {
4769
4770                         // Evaluate and update our best guess (doubling guesses that zero out).
4771                         // Finish if the scale equals or crosses 1 (making the old*new product non-positive).
4772                         jQuery.style( elem, prop, initialInUnit + unit );
4773                         if ( ( 1 - scale ) * ( 1 - ( scale = currentValue() / initial || 0.5 ) ) <= 0 ) {
4774                                 maxIterations = 0;
4775                         }
4776                         initialInUnit = initialInUnit / scale;
4777
4778                 }
4779
4780                 initialInUnit = initialInUnit * 2;
4781                 jQuery.style( elem, prop, initialInUnit + unit );
4782
4783                 // Make sure we update the tween properties later on
4784                 valueParts = valueParts || [];
4785         }
4786
4787         if ( valueParts ) {
4788                 initialInUnit = +initialInUnit || +initial || 0;
4789
4790                 // Apply relative offset (+=/-=) if specified
4791                 adjusted = valueParts[ 1 ] ?
4792                         initialInUnit + ( valueParts[ 1 ] + 1 ) * valueParts[ 2 ] :
4793                         +valueParts[ 2 ];
4794                 if ( tween ) {
4795                         tween.unit = unit;
4796                         tween.start = initialInUnit;
4797                         tween.end = adjusted;
4798                 }
4799         }
4800         return adjusted;
4801 }
4802
4803
4804 var defaultDisplayMap = {};
4805
4806 function getDefaultDisplay( elem ) {
4807         var temp,
4808                 doc = elem.ownerDocument,
4809                 nodeName = elem.nodeName,
4810                 display = defaultDisplayMap[ nodeName ];
4811
4812         if ( display ) {
4813                 return display;
4814         }
4815
4816         temp = doc.body.appendChild( doc.createElement( nodeName ) );
4817         display = jQuery.css( temp, "display" );
4818
4819         temp.parentNode.removeChild( temp );
4820
4821         if ( display === "none" ) {
4822                 display = "block";
4823         }
4824         defaultDisplayMap[ nodeName ] = display;
4825
4826         return display;
4827 }
4828
4829 function showHide( elements, show ) {
4830         var display, elem,
4831                 values = [],
4832                 index = 0,
4833                 length = elements.length;
4834
4835         // Determine new display value for elements that need to change
4836         for ( ; index < length; index++ ) {
4837                 elem = elements[ index ];
4838                 if ( !elem.style ) {
4839                         continue;
4840                 }
4841
4842                 display = elem.style.display;
4843                 if ( show ) {
4844
4845                         // Since we force visibility upon cascade-hidden elements, an immediate (and slow)
4846                         // check is required in this first loop unless we have a nonempty display value (either
4847                         // inline or about-to-be-restored)
4848                         if ( display === "none" ) {
4849                                 values[ index ] = dataPriv.get( elem, "display" ) || null;
4850                                 if ( !values[ index ] ) {
4851                                         elem.style.display = "";
4852                                 }
4853                         }
4854                         if ( elem.style.display === "" && isHiddenWithinTree( elem ) ) {
4855                                 values[ index ] = getDefaultDisplay( elem );
4856                         }
4857                 } else {
4858                         if ( display !== "none" ) {
4859                                 values[ index ] = "none";
4860
4861                                 // Remember what we're overwriting
4862                                 dataPriv.set( elem, "display", display );
4863                         }
4864                 }
4865         }
4866
4867         // Set the display of the elements in a second loop to avoid constant reflow
4868         for ( index = 0; index < length; index++ ) {
4869                 if ( values[ index ] != null ) {
4870                         elements[ index ].style.display = values[ index ];
4871                 }
4872         }
4873
4874         return elements;
4875 }
4876
4877 jQuery.fn.extend( {
4878         show: function() {
4879                 return showHide( this, true );
4880         },
4881         hide: function() {
4882                 return showHide( this );
4883         },
4884         toggle: function( state ) {
4885                 if ( typeof state === "boolean" ) {
4886                         return state ? this.show() : this.hide();
4887                 }
4888
4889                 return this.each( function() {
4890                         if ( isHiddenWithinTree( this ) ) {
4891                                 jQuery( this ).show();
4892                         } else {
4893                                 jQuery( this ).hide();
4894                         }
4895                 } );
4896         }
4897 } );
4898 var rcheckableType = ( /^(?:checkbox|radio)$/i );
4899
4900 var rtagName = ( /<([a-z][^\/\0>\x20\t\r\n\f]*)/i );
4901
4902 var rscriptType = ( /^$|^module$|\/(?:java|ecma)script/i );
4903
4904
4905
4906 ( function() {
4907         var fragment = document.createDocumentFragment(),
4908                 div = fragment.appendChild( document.createElement( "div" ) ),
4909                 input = document.createElement( "input" );
4910
4911         // Support: Android 4.0 - 4.3 only
4912         // Check state lost if the name is set (#11217)
4913         // Support: Windows Web Apps (WWA)
4914         // `name` and `type` must use .setAttribute for WWA (#14901)
4915         input.setAttribute( "type", "radio" );
4916         input.setAttribute( "checked", "checked" );
4917         input.setAttribute( "name", "t" );
4918
4919         div.appendChild( input );
4920
4921         // Support: Android <=4.1 only
4922         // Older WebKit doesn't clone checked state correctly in fragments
4923         support.checkClone = div.cloneNode( true ).cloneNode( true ).lastChild.checked;
4924
4925         // Support: IE <=11 only
4926         // Make sure textarea (and checkbox) defaultValue is properly cloned
4927         div.innerHTML = "<textarea>x</textarea>";
4928         support.noCloneChecked = !!div.cloneNode( true ).lastChild.defaultValue;
4929
4930         // Support: IE <=9 only
4931         // IE <=9 replaces <option> tags with their contents when inserted outside of
4932         // the select element.
4933         div.innerHTML = "<option></option>";
4934         support.option = !!div.lastChild;
4935 } )();
4936
4937
4938 // We have to close these tags to support XHTML (#13200)
4939 var wrapMap = {
4940
4941         // XHTML parsers do not magically insert elements in the
4942         // same way that tag soup parsers do. So we cannot shorten
4943         // this by omitting <tbody> or other required elements.
4944         thead: [ 1, "<table>", "</table>" ],
4945         col: [ 2, "<table><colgroup>", "</colgroup></table>" ],
4946         tr: [ 2, "<table><tbody>", "</tbody></table>" ],
4947         td: [ 3, "<table><tbody><tr>", "</tr></tbody></table>" ],
4948
4949         _default: [ 0, "", "" ]
4950 };
4951
4952 wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;
4953 wrapMap.th = wrapMap.td;
4954
4955 // Support: IE <=9 only
4956 if ( !support.option ) {
4957         wrapMap.optgroup = wrapMap.option = [ 1, "<select multiple='multiple'>", "</select>" ];
4958 }
4959
4960
4961 function getAll( context, tag ) {
4962
4963         // Support: IE <=9 - 11 only
4964         // Use typeof to avoid zero-argument method invocation on host objects (#15151)
4965         var ret;
4966
4967         if ( typeof context.getElementsByTagName !== "undefined" ) {
4968                 ret = context.getElementsByTagName( tag || "*" );
4969
4970         } else if ( typeof context.querySelectorAll !== "undefined" ) {
4971                 ret = context.querySelectorAll( tag || "*" );
4972
4973         } else {
4974                 ret = [];
4975         }
4976
4977         if ( tag === undefined || tag && nodeName( context, tag ) ) {
4978                 return jQuery.merge( [ context ], ret );
4979         }
4980
4981         return ret;
4982 }
4983
4984
4985 // Mark scripts as having already been evaluated
4986 function setGlobalEval( elems, refElements ) {
4987         var i = 0,
4988                 l = elems.length;
4989
4990         for ( ; i < l; i++ ) {
4991                 dataPriv.set(
4992                         elems[ i ],
4993                         "globalEval",
4994                         !refElements || dataPriv.get( refElements[ i ], "globalEval" )
4995                 );
4996         }
4997 }
4998
4999
5000 var rhtml = /<|&#?\w+;/;
5001
5002 function buildFragment( elems, context, scripts, selection, ignored ) {
5003         var elem, tmp, tag, wrap, attached, j,
5004                 fragment = context.createDocumentFragment(),
5005                 nodes = [],
5006                 i = 0,
5007                 l = elems.length;
5008
5009         for ( ; i < l; i++ ) {
5010                 elem = elems[ i ];
5011
5012                 if ( elem || elem === 0 ) {
5013
5014                         // Add nodes directly
5015                         if ( toType( elem ) === "object" ) {
5016
5017                                 // Support: Android <=4.0 only, PhantomJS 1 only
5018                                 // push.apply(_, arraylike) throws on ancient WebKit
5019                                 jQuery.merge( nodes, elem.nodeType ? [ elem ] : elem );
5020
5021                         // Convert non-html into a text node
5022                         } else if ( !rhtml.test( elem ) ) {
5023                                 nodes.push( context.createTextNode( elem ) );
5024
5025                         // Convert html into DOM nodes
5026                         } else {
5027                                 tmp = tmp || fragment.appendChild( context.createElement( "div" ) );
5028
5029                                 // Deserialize a standard representation
5030                                 tag = ( rtagName.exec( elem ) || [ "", "" ] )[ 1 ].toLowerCase();
5031                                 wrap = wrapMap[ tag ] || wrapMap._default;
5032                                 tmp.innerHTML = wrap[ 1 ] + jQuery.htmlPrefilter( elem ) + wrap[ 2 ];
5033
5034                                 // Descend through wrappers to the right content
5035                                 j = wrap[ 0 ];
5036                                 while ( j-- ) {
5037                                         tmp = tmp.lastChild;
5038                                 }
5039
5040                                 // Support: Android <=4.0 only, PhantomJS 1 only
5041                                 // push.apply(_, arraylike) throws on ancient WebKit
5042                                 jQuery.merge( nodes, tmp.childNodes );
5043
5044                                 // Remember the top-level container
5045                                 tmp = fragment.firstChild;
5046
5047                                 // Ensure the created nodes are orphaned (#12392)
5048                                 tmp.textContent = "";
5049                         }
5050                 }
5051         }
5052
5053         // Remove wrapper from fragment
5054         fragment.textContent = "";
5055
5056         i = 0;
5057         while ( ( elem = nodes[ i++ ] ) ) {
5058
5059                 // Skip elements already in the context collection (trac-4087)
5060                 if ( selection && jQuery.inArray( elem, selection ) > -1 ) {
5061                         if ( ignored ) {
5062                                 ignored.push( elem );
5063                         }
5064                         continue;
5065                 }
5066
5067                 attached = isAttached( elem );
5068
5069                 // Append to fragment
5070                 tmp = getAll( fragment.appendChild( elem ), "script" );
5071
5072                 // Preserve script evaluation history
5073                 if ( attached ) {
5074                         setGlobalEval( tmp );
5075                 }
5076
5077                 // Capture executables
5078                 if ( scripts ) {
5079                         j = 0;
5080                         while ( ( elem = tmp[ j++ ] ) ) {
5081                                 if ( rscriptType.test( elem.type || "" ) ) {
5082                                         scripts.push( elem );
5083                                 }
5084                         }
5085                 }
5086         }
5087
5088         return fragment;
5089 }
5090
5091
5092 var
5093         rkeyEvent = /^key/,
5094         rmouseEvent = /^(?:mouse|pointer|contextmenu|drag|drop)|click/,
5095         rtypenamespace = /^([^.]*)(?:\.(.+)|)/;
5096
5097 function returnTrue() {
5098         return true;
5099 }
5100
5101 function returnFalse() {
5102         return false;
5103 }
5104
5105 // Support: IE <=9 - 11+
5106 // focus() and blur() are asynchronous, except when they are no-op.
5107 // So expect focus to be synchronous when the element is already active,
5108 // and blur to be synchronous when the element is not already active.
5109 // (focus and blur are always synchronous in other supported browsers,
5110 // this just defines when we can count on it).
5111 function expectSync( elem, type ) {
5112         return ( elem === safeActiveElement() ) === ( type === "focus" );
5113 }
5114
5115 // Support: IE <=9 only
5116 // Accessing document.activeElement can throw unexpectedly
5117 // https://bugs.jquery.com/ticket/13393
5118 function safeActiveElement() {
5119         try {
5120                 return document.activeElement;
5121         } catch ( err ) { }
5122 }
5123
5124 function on( elem, types, selector, data, fn, one ) {
5125         var origFn, type;
5126
5127         // Types can be a map of types/handlers
5128         if ( typeof types === "object" ) {
5129
5130                 // ( types-Object, selector, data )
5131                 if ( typeof selector !== "string" ) {
5132
5133                         // ( types-Object, data )
5134                         data = data || selector;
5135                         selector = undefined;
5136                 }
5137                 for ( type in types ) {
5138                         on( elem, type, selector, data, types[ type ], one );
5139                 }
5140                 return elem;
5141         }
5142
5143         if ( data == null && fn == null ) {
5144
5145                 // ( types, fn )
5146                 fn = selector;
5147                 data = selector = undefined;
5148         } else if ( fn == null ) {
5149                 if ( typeof selector === "string" ) {
5150
5151                         // ( types, selector, fn )
5152                         fn = data;
5153                         data = undefined;
5154                 } else {
5155
5156                         // ( types, data, fn )
5157                         fn = data;
5158                         data = selector;
5159                         selector = undefined;
5160                 }
5161         }
5162         if ( fn === false ) {
5163                 fn = returnFalse;
5164         } else if ( !fn ) {
5165                 return elem;
5166         }
5167
5168         if ( one === 1 ) {
5169                 origFn = fn;
5170                 fn = function( event ) {
5171
5172                         // Can use an empty set, since event contains the info
5173                         jQuery().off( event );
5174                         return origFn.apply( this, arguments );
5175                 };
5176
5177                 // Use same guid so caller can remove using origFn
5178                 fn.guid = origFn.guid || ( origFn.guid = jQuery.guid++ );
5179         }
5180         return elem.each( function() {
5181                 jQuery.event.add( this, types, fn, data, selector );
5182         } );
5183 }
5184
5185 /*
5186  * Helper functions for managing events -- not part of the public interface.
5187  * Props to Dean Edwards' addEvent library for many of the ideas.
5188  */
5189 jQuery.event = {
5190
5191         global: {},
5192
5193         add: function( elem, types, handler, data, selector ) {
5194
5195                 var handleObjIn, eventHandle, tmp,
5196                         events, t, handleObj,
5197                         special, handlers, type, namespaces, origType,
5198                         elemData = dataPriv.get( elem );
5199
5200                 // Only attach events to objects that accept data
5201                 if ( !acceptData( elem ) ) {
5202                         return;
5203                 }
5204
5205                 // Caller can pass in an object of custom data in lieu of the handler
5206                 if ( handler.handler ) {
5207                         handleObjIn = handler;
5208                         handler = handleObjIn.handler;
5209                         selector = handleObjIn.selector;
5210                 }
5211
5212                 // Ensure that invalid selectors throw exceptions at attach time
5213                 // Evaluate against documentElement in case elem is a non-element node (e.g., document)
5214                 if ( selector ) {
5215                         jQuery.find.matchesSelector( documentElement, selector );
5216                 }
5217
5218                 // Make sure that the handler has a unique ID, used to find/remove it later
5219                 if ( !handler.guid ) {
5220                         handler.guid = jQuery.guid++;
5221                 }
5222
5223                 // Init the element's event structure and main handler, if this is the first
5224                 if ( !( events = elemData.events ) ) {
5225                         events = elemData.events = Object.create( null );
5226                 }
5227                 if ( !( eventHandle = elemData.handle ) ) {
5228                         eventHandle = elemData.handle = function( e ) {
5229
5230                                 // Discard the second event of a jQuery.event.trigger() and
5231                                 // when an event is called after a page has unloaded
5232                                 return typeof jQuery !== "undefined" && jQuery.event.triggered !== e.type ?
5233                                         jQuery.event.dispatch.apply( elem, arguments ) : undefined;
5234                         };
5235                 }
5236
5237                 // Handle multiple events separated by a space
5238                 types = ( types || "" ).match( rnothtmlwhite ) || [ "" ];
5239                 t = types.length;
5240                 while ( t-- ) {
5241                         tmp = rtypenamespace.exec( types[ t ] ) || [];
5242                         type = origType = tmp[ 1 ];
5243                         namespaces = ( tmp[ 2 ] || "" ).split( "." ).sort();
5244
5245                         // There *must* be a type, no attaching namespace-only handlers
5246                         if ( !type ) {
5247                                 continue;
5248                         }
5249
5250                         // If event changes its type, use the special event handlers for the changed type
5251                         special = jQuery.event.special[ type ] || {};
5252
5253                         // If selector defined, determine special event api type, otherwise given type
5254                         type = ( selector ? special.delegateType : special.bindType ) || type;
5255
5256                         // Update special based on newly reset type
5257                         special = jQuery.event.special[ type ] || {};
5258
5259                         // handleObj is passed to all event handlers
5260                         handleObj = jQuery.extend( {
5261                                 type: type,
5262                                 origType: origType,
5263                                 data: data,
5264                                 handler: handler,
5265                                 guid: handler.guid,
5266                                 selector: selector,
5267                                 needsContext: selector && jQuery.expr.match.needsContext.test( selector ),
5268                                 namespace: namespaces.join( "." )
5269                         }, handleObjIn );
5270
5271                         // Init the event handler queue if we're the first
5272                         if ( !( handlers = events[ type ] ) ) {
5273                                 handlers = events[ type ] = [];
5274                                 handlers.delegateCount = 0;
5275
5276                                 // Only use addEventListener if the special events handler returns false
5277                                 if ( !special.setup ||
5278                                         special.setup.call( elem, data, namespaces, eventHandle ) === false ) {
5279
5280                                         if ( elem.addEventListener ) {
5281                                                 elem.addEventListener( type, eventHandle );
5282                                         }
5283                                 }
5284                         }
5285
5286                         if ( special.add ) {
5287                                 special.add.call( elem, handleObj );
5288
5289                                 if ( !handleObj.handler.guid ) {
5290                                         handleObj.handler.guid = handler.guid;
5291                                 }
5292                         }
5293
5294                         // Add to the element's handler list, delegates in front
5295                         if ( selector ) {
5296                                 handlers.splice( handlers.delegateCount++, 0, handleObj );
5297                         } else {
5298                                 handlers.push( handleObj );
5299                         }
5300
5301                         // Keep track of which events have ever been used, for event optimization
5302                         jQuery.event.global[ type ] = true;
5303                 }
5304
5305         },
5306
5307         // Detach an event or set of events from an element
5308         remove: function( elem, types, handler, selector, mappedTypes ) {
5309
5310                 var j, origCount, tmp,
5311                         events, t, handleObj,
5312                         special, handlers, type, namespaces, origType,
5313                         elemData = dataPriv.hasData( elem ) && dataPriv.get( elem );
5314
5315                 if ( !elemData || !( events = elemData.events ) ) {
5316                         return;
5317                 }
5318
5319                 // Once for each type.namespace in types; type may be omitted
5320                 types = ( types || "" ).match( rnothtmlwhite ) || [ "" ];
5321                 t = types.length;
5322                 while ( t-- ) {
5323                         tmp = rtypenamespace.exec( types[ t ] ) || [];
5324                         type = origType = tmp[ 1 ];
5325                         namespaces = ( tmp[ 2 ] || "" ).split( "." ).sort();
5326
5327                         // Unbind all events (on this namespace, if provided) for the element
5328                         if ( !type ) {
5329                                 for ( type in events ) {
5330                                         jQuery.event.remove( elem, type + types[ t ], handler, selector, true );
5331                                 }
5332                                 continue;
5333                         }
5334
5335                         special = jQuery.event.special[ type ] || {};
5336                         type = ( selector ? special.delegateType : special.bindType ) || type;
5337                         handlers = events[ type ] || [];
5338                         tmp = tmp[ 2 ] &&
5339                                 new RegExp( "(^|\\.)" + namespaces.join( "\\.(?:.*\\.|)" ) + "(\\.|$)" );
5340
5341                         // Remove matching events
5342                         origCount = j = handlers.length;
5343                         while ( j-- ) {
5344                                 handleObj = handlers[ j ];
5345
5346                                 if ( ( mappedTypes || origType === handleObj.origType ) &&
5347                                         ( !handler || handler.guid === handleObj.guid ) &&
5348                                         ( !tmp || tmp.test( handleObj.namespace ) ) &&
5349                                         ( !selector || selector === handleObj.selector ||
5350                                                 selector === "**" && handleObj.selector ) ) {
5351                                         handlers.splice( j, 1 );
5352
5353                                         if ( handleObj.selector ) {
5354                                                 handlers.delegateCount--;
5355                                         }
5356                                         if ( special.remove ) {
5357                                                 special.remove.call( elem, handleObj );
5358                                         }
5359                                 }
5360                         }
5361
5362                         // Remove generic event handler if we removed something and no more handlers exist
5363                         // (avoids potential for endless recursion during removal of special event handlers)
5364                         if ( origCount && !handlers.length ) {
5365                                 if ( !special.teardown ||
5366                                         special.teardown.call( elem, namespaces, elemData.handle ) === false ) {
5367
5368                                         jQuery.removeEvent( elem, type, elemData.handle );
5369                                 }
5370
5371                                 delete events[ type ];
5372                         }
5373                 }
5374
5375                 // Remove data and the expando if it's no longer used
5376                 if ( jQuery.isEmptyObject( events ) ) {
5377                         dataPriv.remove( elem, "handle events" );
5378                 }
5379         },
5380
5381         dispatch: function( nativeEvent ) {
5382
5383                 var i, j, ret, matched, handleObj, handlerQueue,
5384                         args = new Array( arguments.length ),
5385
5386                         // Make a writable jQuery.Event from the native event object
5387                         event = jQuery.event.fix( nativeEvent ),
5388
5389                         handlers = (
5390                                         dataPriv.get( this, "events" ) || Object.create( null )
5391                                 )[ event.type ] || [],
5392                         special = jQuery.event.special[ event.type ] || {};
5393
5394                 // Use the fix-ed jQuery.Event rather than the (read-only) native event
5395                 args[ 0 ] = event;
5396
5397                 for ( i = 1; i < arguments.length; i++ ) {
5398                         args[ i ] = arguments[ i ];
5399                 }
5400
5401                 event.delegateTarget = this;
5402
5403                 // Call the preDispatch hook for the mapped type, and let it bail if desired
5404                 if ( special.preDispatch && special.preDispatch.call( this, event ) === false ) {
5405                         return;
5406                 }
5407
5408                 // Determine handlers
5409                 handlerQueue = jQuery.event.handlers.call( this, event, handlers );
5410
5411                 // Run delegates first; they may want to stop propagation beneath us
5412                 i = 0;
5413                 while ( ( matched = handlerQueue[ i++ ] ) && !event.isPropagationStopped() ) {
5414                         event.currentTarget = matched.elem;
5415
5416                         j = 0;
5417                         while ( ( handleObj = matched.handlers[ j++ ] ) &&
5418                                 !event.isImmediatePropagationStopped() ) {
5419
5420                                 // If the event is namespaced, then each handler is only invoked if it is
5421                                 // specially universal or its namespaces are a superset of the event's.
5422                                 if ( !event.rnamespace || handleObj.namespace === false ||
5423                                         event.rnamespace.test( handleObj.namespace ) ) {
5424
5425                                         event.handleObj = handleObj;
5426                                         event.data = handleObj.data;
5427
5428                                         ret = ( ( jQuery.event.special[ handleObj.origType ] || {} ).handle ||
5429                                                 handleObj.handler ).apply( matched.elem, args );
5430
5431                                         if ( ret !== undefined ) {
5432                                                 if ( ( event.result = ret ) === false ) {
5433                                                         event.preventDefault();
5434                                                         event.stopPropagation();
5435                                                 }
5436                                         }
5437                                 }
5438                         }
5439                 }
5440
5441                 // Call the postDispatch hook for the mapped type
5442                 if ( special.postDispatch ) {
5443                         special.postDispatch.call( this, event );
5444                 }
5445
5446                 return event.result;
5447         },
5448
5449         handlers: function( event, handlers ) {
5450                 var i, handleObj, sel, matchedHandlers, matchedSelectors,
5451                         handlerQueue = [],
5452                         delegateCount = handlers.delegateCount,
5453                         cur = event.target;
5454
5455                 // Find delegate handlers
5456                 if ( delegateCount &&
5457
5458                         // Support: IE <=9
5459                         // Black-hole SVG <use> instance trees (trac-13180)
5460                         cur.nodeType &&
5461
5462                         // Support: Firefox <=42
5463                         // Suppress spec-violating clicks indicating a non-primary pointer button (trac-3861)
5464                         // https://www.w3.org/TR/DOM-Level-3-Events/#event-type-click
5465                         // Support: IE 11 only
5466                         // ...but not arrow key "clicks" of radio inputs, which can have `button` -1 (gh-2343)
5467                         !( event.type === "click" && event.button >= 1 ) ) {
5468
5469                         for ( ; cur !== this; cur = cur.parentNode || this ) {
5470
5471                                 // Don't check non-elements (#13208)
5472                                 // Don't process clicks on disabled elements (#6911, #8165, #11382, #11764)
5473                                 if ( cur.nodeType === 1 && !( event.type === "click" && cur.disabled === true ) ) {
5474                                         matchedHandlers = [];
5475                                         matchedSelectors = {};
5476                                         for ( i = 0; i < delegateCount; i++ ) {
5477                                                 handleObj = handlers[ i ];
5478
5479                                                 // Don't conflict with Object.prototype properties (#13203)
5480                                                 sel = handleObj.selector + " ";
5481
5482                                                 if ( matchedSelectors[ sel ] === undefined ) {
5483                                                         matchedSelectors[ sel ] = handleObj.needsContext ?
5484                                                                 jQuery( sel, this ).index( cur ) > -1 :
5485                                                                 jQuery.find( sel, this, null, [ cur ] ).length;
5486                                                 }
5487                                                 if ( matchedSelectors[ sel ] ) {
5488                                                         matchedHandlers.push( handleObj );
5489                                                 }
5490                                         }
5491                                         if ( matchedHandlers.length ) {
5492                                                 handlerQueue.push( { elem: cur, handlers: matchedHandlers } );
5493                                         }
5494                                 }
5495                         }
5496                 }
5497
5498                 // Add the remaining (directly-bound) handlers
5499                 cur = this;
5500                 if ( delegateCount < handlers.length ) {
5501                         handlerQueue.push( { elem: cur, handlers: handlers.slice( delegateCount ) } );
5502                 }
5503
5504                 return handlerQueue;
5505         },
5506
5507         addProp: function( name, hook ) {
5508                 Object.defineProperty( jQuery.Event.prototype, name, {
5509                         enumerable: true,
5510                         configurable: true,
5511
5512                         get: isFunction( hook ) ?
5513                                 function() {
5514                                         if ( this.originalEvent ) {
5515                                                         return hook( this.originalEvent );
5516                                         }
5517                                 } :
5518                                 function() {
5519                                         if ( this.originalEvent ) {
5520                                                         return this.originalEvent[ name ];
5521                                         }
5522                                 },
5523
5524                         set: function( value ) {
5525                                 Object.defineProperty( this, name, {
5526                                         enumerable: true,
5527                                         configurable: true,
5528                                         writable: true,
5529                                         value: value
5530                                 } );
5531                         }
5532                 } );
5533         },
5534
5535         fix: function( originalEvent ) {
5536                 return originalEvent[ jQuery.expando ] ?
5537                         originalEvent :
5538                         new jQuery.Event( originalEvent );
5539         },
5540
5541         special: {
5542                 load: {
5543
5544                         // Prevent triggered image.load events from bubbling to window.load
5545                         noBubble: true
5546                 },
5547                 click: {
5548
5549                         // Utilize native event to ensure correct state for checkable inputs
5550                         setup: function( data ) {
5551
5552                                 // For mutual compressibility with _default, replace `this` access with a local var.
5553                                 // `|| data` is dead code meant only to preserve the variable through minification.
5554                                 var el = this || data;
5555
5556                                 // Claim the first handler
5557                                 if ( rcheckableType.test( el.type ) &&
5558                                         el.click && nodeName( el, "input" ) ) {
5559
5560                                         // dataPriv.set( el, "click", ... )
5561                                         leverageNative( el, "click", returnTrue );
5562                                 }
5563
5564                                 // Return false to allow normal processing in the caller
5565                                 return false;
5566                         },
5567                         trigger: function( data ) {
5568
5569                                 // For mutual compressibility with _default, replace `this` access with a local var.
5570                                 // `|| data` is dead code meant only to preserve the variable through minification.
5571                                 var el = this || data;
5572
5573                                 // Force setup before triggering a click
5574                                 if ( rcheckableType.test( el.type ) &&
5575                                         el.click && nodeName( el, "input" ) ) {
5576
5577                                         leverageNative( el, "click" );
5578                                 }
5579
5580                                 // Return non-false to allow normal event-path propagation
5581                                 return true;
5582                         },
5583
5584                         // For cross-browser consistency, suppress native .click() on links
5585                         // Also prevent it if we're currently inside a leveraged native-event stack
5586                         _default: function( event ) {
5587                                 var target = event.target;
5588                                 return rcheckableType.test( target.type ) &&
5589                                         target.click && nodeName( target, "input" ) &&
5590                                         dataPriv.get( target, "click" ) ||
5591                                         nodeName( target, "a" );
5592                         }
5593                 },
5594
5595                 beforeunload: {
5596                         postDispatch: function( event ) {
5597
5598                                 // Support: Firefox 20+
5599                                 // Firefox doesn't alert if the returnValue field is not set.
5600                                 if ( event.result !== undefined && event.originalEvent ) {
5601                                         event.originalEvent.returnValue = event.result;
5602                                 }
5603                         }
5604                 }
5605         }
5606 };
5607
5608 // Ensure the presence of an event listener that handles manually-triggered
5609 // synthetic events by interrupting progress until reinvoked in response to
5610 // *native* events that it fires directly, ensuring that state changes have
5611 // already occurred before other listeners are invoked.
5612 function leverageNative( el, type, expectSync ) {
5613
5614         // Missing expectSync indicates a trigger call, which must force setup through jQuery.event.add
5615         if ( !expectSync ) {
5616                 if ( dataPriv.get( el, type ) === undefined ) {
5617                         jQuery.event.add( el, type, returnTrue );
5618                 }
5619                 return;
5620         }
5621
5622         // Register the controller as a special universal handler for all event namespaces
5623         dataPriv.set( el, type, false );
5624         jQuery.event.add( el, type, {
5625                 namespace: false,
5626                 handler: function( event ) {
5627                         var notAsync, result,
5628                                 saved = dataPriv.get( this, type );
5629
5630                         if ( ( event.isTrigger & 1 ) && this[ type ] ) {
5631
5632                                 // Interrupt processing of the outer synthetic .trigger()ed event
5633                                 // Saved data should be false in such cases, but might be a leftover capture object
5634                                 // from an async native handler (gh-4350)
5635                                 if ( !saved.length ) {
5636
5637                                         // Store arguments for use when handling the inner native event
5638                                         // There will always be at least one argument (an event object), so this array
5639                                         // will not be confused with a leftover capture object.
5640                                         saved = slice.call( arguments );
5641                                         dataPriv.set( this, type, saved );
5642
5643                                         // Trigger the native event and capture its result
5644                                         // Support: IE <=9 - 11+
5645                                         // focus() and blur() are asynchronous
5646                                         notAsync = expectSync( this, type );
5647                                         this[ type ]();
5648                                         result = dataPriv.get( this, type );
5649                                         if ( saved !== result || notAsync ) {
5650                                                 dataPriv.set( this, type, false );
5651                                         } else {
5652                                                 result = {};
5653                                         }
5654                                         if ( saved !== result ) {
5655
5656                                                 // Cancel the outer synthetic event
5657                                                 event.stopImmediatePropagation();
5658                                                 event.preventDefault();
5659                                                 return result.value;
5660                                         }
5661
5662                                 // If this is an inner synthetic event for an event with a bubbling surrogate
5663                                 // (focus or blur), assume that the surrogate already propagated from triggering the
5664                                 // native event and prevent that from happening again here.
5665                                 // This technically gets the ordering wrong w.r.t. to `.trigger()` (in which the
5666                                 // bubbling surrogate propagates *after* the non-bubbling base), but that seems
5667                                 // less bad than duplication.
5668                                 } else if ( ( jQuery.event.special[ type ] || {} ).delegateType ) {
5669                                         event.stopPropagation();
5670                                 }
5671
5672                         // If this is a native event triggered above, everything is now in order
5673                         // Fire an inner synthetic event with the original arguments
5674                         } else if ( saved.length ) {
5675
5676                                 // ...and capture the result
5677                                 dataPriv.set( this, type, {
5678                                         value: jQuery.event.trigger(
5679
5680                                                 // Support: IE <=9 - 11+
5681                                                 // Extend with the prototype to reset the above stopImmediatePropagation()
5682                                                 jQuery.extend( saved[ 0 ], jQuery.Event.prototype ),
5683                                                 saved.slice( 1 ),
5684                                                 this
5685                                         )
5686                                 } );
5687
5688                                 // Abort handling of the native event
5689                                 event.stopImmediatePropagation();
5690                         }
5691                 }
5692         } );
5693 }
5694
5695 jQuery.removeEvent = function( elem, type, handle ) {
5696
5697         // This "if" is needed for plain objects
5698         if ( elem.removeEventListener ) {
5699                 elem.removeEventListener( type, handle );
5700         }
5701 };
5702
5703 jQuery.Event = function( src, props ) {
5704
5705         // Allow instantiation without the 'new' keyword
5706         if ( !( this instanceof jQuery.Event ) ) {
5707                 return new jQuery.Event( src, props );
5708         }
5709
5710         // Event object
5711         if ( src && src.type ) {
5712                 this.originalEvent = src;
5713                 this.type = src.type;
5714
5715                 // Events bubbling up the document may have been marked as prevented
5716                 // by a handler lower down the tree; reflect the correct value.
5717                 this.isDefaultPrevented = src.defaultPrevented ||
5718                                 src.defaultPrevented === undefined &&
5719
5720                                 // Support: Android <=2.3 only
5721                                 src.returnValue === false ?
5722                         returnTrue :
5723                         returnFalse;
5724
5725                 // Create target properties
5726                 // Support: Safari <=6 - 7 only
5727                 // Target should not be a text node (#504, #13143)
5728                 this.target = ( src.target && src.target.nodeType === 3 ) ?
5729                         src.target.parentNode :
5730                         src.target;
5731
5732                 this.currentTarget = src.currentTarget;
5733                 this.relatedTarget = src.relatedTarget;
5734
5735         // Event type
5736         } else {
5737                 this.type = src;
5738         }
5739
5740         // Put explicitly provided properties onto the event object
5741         if ( props ) {
5742                 jQuery.extend( this, props );
5743         }
5744
5745         // Create a timestamp if incoming event doesn't have one
5746         this.timeStamp = src && src.timeStamp || Date.now();
5747
5748         // Mark it as fixed
5749         this[ jQuery.expando ] = true;
5750 };
5751
5752 // jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding
5753 // https://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html
5754 jQuery.Event.prototype = {
5755         constructor: jQuery.Event,
5756         isDefaultPrevented: returnFalse,
5757         isPropagationStopped: returnFalse,
5758         isImmediatePropagationStopped: returnFalse,
5759         isSimulated: false,
5760
5761         preventDefault: function() {
5762                 var e = this.originalEvent;
5763
5764                 this.isDefaultPrevented = returnTrue;
5765
5766                 if ( e && !this.isSimulated ) {
5767                         e.preventDefault();
5768                 }
5769         },
5770         stopPropagation: function() {
5771                 var e = this.originalEvent;
5772
5773                 this.isPropagationStopped = returnTrue;
5774
5775                 if ( e && !this.isSimulated ) {
5776                         e.stopPropagation();
5777                 }
5778         },
5779         stopImmediatePropagation: function() {
5780                 var e = this.originalEvent;
5781
5782                 this.isImmediatePropagationStopped = returnTrue;
5783
5784                 if ( e && !this.isSimulated ) {
5785                         e.stopImmediatePropagation();
5786                 }
5787
5788                 this.stopPropagation();
5789         }
5790 };
5791
5792 // Includes all common event props including KeyEvent and MouseEvent specific props
5793 jQuery.each( {
5794         altKey: true,
5795         bubbles: true,
5796         cancelable: true,
5797         changedTouches: true,
5798         ctrlKey: true,
5799         detail: true,
5800         eventPhase: true,
5801         metaKey: true,
5802         pageX: true,
5803         pageY: true,
5804         shiftKey: true,
5805         view: true,
5806         "char": true,
5807         code: true,
5808         charCode: true,
5809         key: true,
5810         keyCode: true,
5811         button: true,
5812         buttons: true,
5813         clientX: true,
5814         clientY: true,
5815         offsetX: true,
5816         offsetY: true,
5817         pointerId: true,
5818         pointerType: true,
5819         screenX: true,
5820         screenY: true,
5821         targetTouches: true,
5822         toElement: true,
5823         touches: true,
5824
5825         which: function( event ) {
5826                 var button = event.button;
5827
5828                 // Add which for key events
5829                 if ( event.which == null && rkeyEvent.test( event.type ) ) {
5830                         return event.charCode != null ? event.charCode : event.keyCode;
5831                 }
5832
5833                 // Add which for click: 1 === left; 2 === middle; 3 === right
5834                 if ( !event.which && button !== undefined && rmouseEvent.test( event.type ) ) {
5835                         if ( button & 1 ) {
5836                                 return 1;
5837                         }
5838
5839                         if ( button & 2 ) {
5840                                 return 3;
5841                         }
5842
5843                         if ( button & 4 ) {
5844                                 return 2;
5845                         }
5846
5847                         return 0;
5848                 }
5849
5850                 return event.which;
5851         }
5852 }, jQuery.event.addProp );
5853
5854 jQuery.each( { focus: "focusin", blur: "focusout" }, function( type, delegateType ) {
5855         jQuery.event.special[ type ] = {
5856
5857                 // Utilize native event if possible so blur/focus sequence is correct
5858                 setup: function() {
5859
5860                         // Claim the first handler
5861                         // dataPriv.set( this, "focus", ... )
5862                         // dataPriv.set( this, "blur", ... )
5863                         leverageNative( this, type, expectSync );
5864
5865                         // Return false to allow normal processing in the caller
5866                         return false;
5867                 },
5868                 trigger: function() {
5869
5870                         // Force setup before trigger
5871                         leverageNative( this, type );
5872
5873                         // Return non-false to allow normal event-path propagation
5874                         return true;
5875                 },
5876
5877                 delegateType: delegateType
5878         };
5879 } );
5880
5881 // Create mouseenter/leave events using mouseover/out and event-time checks
5882 // so that event delegation works in jQuery.
5883 // Do the same for pointerenter/pointerleave and pointerover/pointerout
5884 //
5885 // Support: Safari 7 only
5886 // Safari sends mouseenter too often; see:
5887 // https://bugs.chromium.org/p/chromium/issues/detail?id=470258
5888 // for the description of the bug (it existed in older Chrome versions as well).
5889 jQuery.each( {
5890         mouseenter: "mouseover",
5891         mouseleave: "mouseout",
5892         pointerenter: "pointerover",
5893         pointerleave: "pointerout"
5894 }, function( orig, fix ) {
5895         jQuery.event.special[ orig ] = {
5896                 delegateType: fix,
5897                 bindType: fix,
5898
5899                 handle: function( event ) {
5900                         var ret,
5901                                 target = this,
5902                                 related = event.relatedTarget,
5903                                 handleObj = event.handleObj;
5904
5905                         // For mouseenter/leave call the handler if related is outside the target.
5906                         // NB: No relatedTarget if the mouse left/entered the browser window
5907                         if ( !related || ( related !== target && !jQuery.contains( target, related ) ) ) {
5908                                 event.type = handleObj.origType;
5909                                 ret = handleObj.handler.apply( this, arguments );
5910                                 event.type = fix;
5911                         }
5912                         return ret;
5913                 }
5914         };
5915 } );
5916
5917 jQuery.fn.extend( {
5918
5919         on: function( types, selector, data, fn ) {
5920                 return on( this, types, selector, data, fn );
5921         },
5922         one: function( types, selector, data, fn ) {
5923                 return on( this, types, selector, data, fn, 1 );
5924         },
5925         off: function( types, selector, fn ) {
5926                 var handleObj, type;
5927                 if ( types && types.preventDefault && types.handleObj ) {
5928
5929                         // ( event )  dispatched jQuery.Event
5930                         handleObj = types.handleObj;
5931                         jQuery( types.delegateTarget ).off(
5932                                 handleObj.namespace ?
5933                                         handleObj.origType + "." + handleObj.namespace :
5934                                         handleObj.origType,
5935                                 handleObj.selector,
5936                                 handleObj.handler
5937                         );
5938                         return this;
5939                 }
5940                 if ( typeof types === "object" ) {
5941
5942                         // ( types-object [, selector] )
5943                         for ( type in types ) {
5944                                 this.off( type, selector, types[ type ] );
5945                         }
5946                         return this;
5947                 }
5948                 if ( selector === false || typeof selector === "function" ) {
5949
5950                         // ( types [, fn] )
5951                         fn = selector;
5952                         selector = undefined;
5953                 }
5954                 if ( fn === false ) {
5955                         fn = returnFalse;
5956                 }
5957                 return this.each( function() {
5958                         jQuery.event.remove( this, types, fn, selector );
5959                 } );
5960         }
5961 } );
5962
5963
5964 var
5965
5966         // Support: IE <=10 - 11, Edge 12 - 13 only
5967         // In IE/Edge using regex groups here causes severe slowdowns.
5968         // See https://connect.microsoft.com/IE/feedback/details/1736512/
5969         rnoInnerhtml = /<script|<style|<link/i,
5970
5971         // checked="checked" or checked
5972         rchecked = /checked\s*(?:[^=]|=\s*.checked.)/i,
5973         rcleanScript = /^\s*<!(?:\[CDATA\[|--)|(?:\]\]|--)>\s*$/g;
5974
5975 // Prefer a tbody over its parent table for containing new rows
5976 function manipulationTarget( elem, content ) {
5977         if ( nodeName( elem, "table" ) &&
5978                 nodeName( content.nodeType !== 11 ? content : content.firstChild, "tr" ) ) {
5979
5980                 return jQuery( elem ).children( "tbody" )[ 0 ] || elem;
5981         }
5982
5983         return elem;
5984 }
5985
5986 // Replace/restore the type attribute of script elements for safe DOM manipulation
5987 function disableScript( elem ) {
5988         elem.type = ( elem.getAttribute( "type" ) !== null ) + "/" + elem.type;
5989         return elem;
5990 }
5991 function restoreScript( elem ) {
5992         if ( ( elem.type || "" ).slice( 0, 5 ) === "true/" ) {
5993                 elem.type = elem.type.slice( 5 );
5994         } else {
5995                 elem.removeAttribute( "type" );
5996         }
5997
5998         return elem;
5999 }
6000
6001 function cloneCopyEvent( src, dest ) {
6002         var i, l, type, pdataOld, udataOld, udataCur, events;
6003
6004         if ( dest.nodeType !== 1 ) {
6005                 return;
6006         }
6007
6008         // 1. Copy private data: events, handlers, etc.
6009         if ( dataPriv.hasData( src ) ) {
6010                 pdataOld = dataPriv.get( src );
6011                 events = pdataOld.events;
6012
6013                 if ( events ) {
6014                         dataPriv.remove( dest, "handle events" );
6015
6016                         for ( type in events ) {
6017                                 for ( i = 0, l = events[ type ].length; i < l; i++ ) {
6018                                         jQuery.event.add( dest, type, events[ type ][ i ] );
6019                                 }
6020                         }
6021                 }
6022         }
6023
6024         // 2. Copy user data
6025         if ( dataUser.hasData( src ) ) {
6026                 udataOld = dataUser.access( src );
6027                 udataCur = jQuery.extend( {}, udataOld );
6028
6029                 dataUser.set( dest, udataCur );
6030         }
6031 }
6032
6033 // Fix IE bugs, see support tests
6034 function fixInput( src, dest ) {
6035         var nodeName = dest.nodeName.toLowerCase();
6036
6037         // Fails to persist the checked state of a cloned checkbox or radio button.
6038         if ( nodeName === "input" && rcheckableType.test( src.type ) ) {
6039                 dest.checked = src.checked;
6040
6041         // Fails to return the selected option to the default selected state when cloning options
6042         } else if ( nodeName === "input" || nodeName === "textarea" ) {
6043                 dest.defaultValue = src.defaultValue;
6044         }
6045 }
6046
6047 function domManip( collection, args, callback, ignored ) {
6048
6049         // Flatten any nested arrays
6050         args = flat( args );
6051
6052         var fragment, first, scripts, hasScripts, node, doc,
6053                 i = 0,
6054                 l = collection.length,
6055                 iNoClone = l - 1,
6056                 value = args[ 0 ],
6057                 valueIsFunction = isFunction( value );
6058
6059         // We can't cloneNode fragments that contain checked, in WebKit
6060         if ( valueIsFunction ||
6061                         ( l > 1 && typeof value === "string" &&
6062                                 !support.checkClone && rchecked.test( value ) ) ) {
6063                 return collection.each( function( index ) {
6064                         var self = collection.eq( index );
6065                         if ( valueIsFunction ) {
6066                                 args[ 0 ] = value.call( this, index, self.html() );
6067                         }
6068                         domManip( self, args, callback, ignored );
6069                 } );
6070         }
6071
6072         if ( l ) {
6073                 fragment = buildFragment( args, collection[ 0 ].ownerDocument, false, collection, ignored );
6074                 first = fragment.firstChild;
6075
6076                 if ( fragment.childNodes.length === 1 ) {
6077                         fragment = first;
6078                 }
6079
6080                 // Require either new content or an interest in ignored elements to invoke the callback
6081                 if ( first || ignored ) {
6082                         scripts = jQuery.map( getAll( fragment, "script" ), disableScript );
6083                         hasScripts = scripts.length;
6084
6085                         // Use the original fragment for the last item
6086                         // instead of the first because it can end up
6087                         // being emptied incorrectly in certain situations (#8070).
6088                         for ( ; i < l; i++ ) {
6089                                 node = fragment;
6090
6091                                 if ( i !== iNoClone ) {
6092                                         node = jQuery.clone( node, true, true );
6093
6094                                         // Keep references to cloned scripts for later restoration
6095                                         if ( hasScripts ) {
6096
6097                                                 // Support: Android <=4.0 only, PhantomJS 1 only
6098                                                 // push.apply(_, arraylike) throws on ancient WebKit
6099                                                 jQuery.merge( scripts, getAll( node, "script" ) );
6100                                         }
6101                                 }
6102
6103                                 callback.call( collection[ i ], node, i );
6104                         }
6105
6106                         if ( hasScripts ) {
6107                                 doc = scripts[ scripts.length - 1 ].ownerDocument;
6108
6109                                 // Reenable scripts
6110                                 jQuery.map( scripts, restoreScript );
6111
6112                                 // Evaluate executable scripts on first document insertion
6113                                 for ( i = 0; i < hasScripts; i++ ) {
6114                                         node = scripts[ i ];
6115                                         if ( rscriptType.test( node.type || "" ) &&
6116                                                 !dataPriv.access( node, "globalEval" ) &&
6117                                                 jQuery.contains( doc, node ) ) {
6118
6119                                                 if ( node.src && ( node.type || "" ).toLowerCase()  !== "module" ) {
6120
6121                                                         // Optional AJAX dependency, but won't run scripts if not present
6122                                                         if ( jQuery._evalUrl && !node.noModule ) {
6123                                                                 jQuery._evalUrl( node.src, {
6124                                                                         nonce: node.nonce || node.getAttribute( "nonce" )
6125                                                                 }, doc );
6126                                                         }
6127                                                 } else {
6128                                                         DOMEval( node.textContent.replace( rcleanScript, "" ), node, doc );
6129                                                 }
6130                                         }
6131                                 }
6132                         }
6133                 }
6134         }
6135
6136         return collection;
6137 }
6138
6139 function remove( elem, selector, keepData ) {
6140         var node,
6141                 nodes = selector ? jQuery.filter( selector, elem ) : elem,
6142                 i = 0;
6143
6144         for ( ; ( node = nodes[ i ] ) != null; i++ ) {
6145                 if ( !keepData && node.nodeType === 1 ) {
6146                         jQuery.cleanData( getAll( node ) );
6147                 }
6148
6149                 if ( node.parentNode ) {
6150                         if ( keepData && isAttached( node ) ) {
6151                                 setGlobalEval( getAll( node, "script" ) );
6152                         }
6153                         node.parentNode.removeChild( node );
6154                 }
6155         }
6156
6157         return elem;
6158 }
6159
6160 jQuery.extend( {
6161         htmlPrefilter: function( html ) {
6162                 return html;
6163         },
6164
6165         clone: function( elem, dataAndEvents, deepDataAndEvents ) {
6166                 var i, l, srcElements, destElements,
6167                         clone = elem.cloneNode( true ),
6168                         inPage = isAttached( elem );
6169
6170                 // Fix IE cloning issues
6171                 if ( !support.noCloneChecked && ( elem.nodeType === 1 || elem.nodeType === 11 ) &&
6172                                 !jQuery.isXMLDoc( elem ) ) {
6173
6174                         // We eschew Sizzle here for performance reasons: https://jsperf.com/getall-vs-sizzle/2
6175                         destElements = getAll( clone );
6176                         srcElements = getAll( elem );
6177
6178                         for ( i = 0, l = srcElements.length; i < l; i++ ) {
6179                                 fixInput( srcElements[ i ], destElements[ i ] );
6180                         }
6181                 }
6182
6183                 // Copy the events from the original to the clone
6184                 if ( dataAndEvents ) {
6185                         if ( deepDataAndEvents ) {
6186                                 srcElements = srcElements || getAll( elem );
6187                                 destElements = destElements || getAll( clone );
6188
6189                                 for ( i = 0, l = srcElements.length; i < l; i++ ) {
6190                                         cloneCopyEvent( srcElements[ i ], destElements[ i ] );
6191                                 }
6192                         } else {
6193                                 cloneCopyEvent( elem, clone );
6194                         }
6195                 }
6196
6197                 // Preserve script evaluation history
6198                 destElements = getAll( clone, "script" );
6199                 if ( destElements.length > 0 ) {
6200                         setGlobalEval( destElements, !inPage && getAll( elem, "script" ) );
6201                 }
6202
6203                 // Return the cloned set
6204                 return clone;
6205         },
6206
6207         cleanData: function( elems ) {
6208                 var data, elem, type,
6209                         special = jQuery.event.special,
6210                         i = 0;
6211
6212                 for ( ; ( elem = elems[ i ] ) !== undefined; i++ ) {
6213                         if ( acceptData( elem ) ) {
6214                                 if ( ( data = elem[ dataPriv.expando ] ) ) {
6215                                         if ( data.events ) {
6216                                                 for ( type in data.events ) {
6217                                                         if ( special[ type ] ) {
6218                                                                 jQuery.event.remove( elem, type );
6219
6220                                                         // This is a shortcut to avoid jQuery.event.remove's overhead
6221                                                         } else {
6222                                                                 jQuery.removeEvent( elem, type, data.handle );
6223                                                         }
6224                                                 }
6225                                         }
6226
6227                                         // Support: Chrome <=35 - 45+
6228                                         // Assign undefined instead of using delete, see Data#remove
6229                                         elem[ dataPriv.expando ] = undefined;
6230                                 }
6231                                 if ( elem[ dataUser.expando ] ) {
6232
6233                                         // Support: Chrome <=35 - 45+
6234                                         // Assign undefined instead of using delete, see Data#remove
6235                                         elem[ dataUser.expando ] = undefined;
6236                                 }
6237                         }
6238                 }
6239         }
6240 } );
6241
6242 jQuery.fn.extend( {
6243         detach: function( selector ) {
6244                 return remove( this, selector, true );
6245         },
6246
6247         remove: function( selector ) {
6248                 return remove( this, selector );
6249         },
6250
6251         text: function( value ) {
6252                 return access( this, function( value ) {
6253                         return value === undefined ?
6254                                 jQuery.text( this ) :
6255                                 this.empty().each( function() {
6256                                         if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {
6257                                                 this.textContent = value;
6258                                         }
6259                                 } );
6260                 }, null, value, arguments.length );
6261         },
6262
6263         append: function() {
6264                 return domManip( this, arguments, function( elem ) {
6265                         if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {
6266                                 var target = manipulationTarget( this, elem );
6267                                 target.appendChild( elem );
6268                         }
6269                 } );
6270         },
6271
6272         prepend: function() {
6273                 return domManip( this, arguments, function( elem ) {
6274                         if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {
6275                                 var target = manipulationTarget( this, elem );
6276                                 target.insertBefore( elem, target.firstChild );
6277                         }
6278                 } );
6279         },
6280
6281         before: function() {
6282                 return domManip( this, arguments, function( elem ) {
6283                         if ( this.parentNode ) {
6284                                 this.parentNode.insertBefore( elem, this );
6285                         }
6286                 } );
6287         },
6288
6289         after: function() {
6290                 return domManip( this, arguments, function( elem ) {
6291                         if ( this.parentNode ) {
6292                                 this.parentNode.insertBefore( elem, this.nextSibling );
6293                         }
6294                 } );
6295         },
6296
6297         empty: function() {
6298                 var elem,
6299                         i = 0;
6300
6301                 for ( ; ( elem = this[ i ] ) != null; i++ ) {
6302                         if ( elem.nodeType === 1 ) {
6303
6304                                 // Prevent memory leaks
6305                                 jQuery.cleanData( getAll( elem, false ) );
6306
6307                                 // Remove any remaining nodes
6308                                 elem.textContent = "";
6309                         }
6310                 }
6311
6312                 return this;
6313         },
6314
6315         clone: function( dataAndEvents, deepDataAndEvents ) {
6316                 dataAndEvents = dataAndEvents == null ? false : dataAndEvents;
6317                 deepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents;
6318
6319                 return this.map( function() {
6320                         return jQuery.clone( this, dataAndEvents, deepDataAndEvents );
6321                 } );
6322         },
6323
6324         html: function( value ) {
6325                 return access( this, function( value ) {
6326                         var elem = this[ 0 ] || {},
6327                                 i = 0,
6328                                 l = this.length;
6329
6330                         if ( value === undefined && elem.nodeType === 1 ) {
6331                                 return elem.innerHTML;
6332                         }
6333
6334                         // See if we can take a shortcut and just use innerHTML
6335                         if ( typeof value === "string" && !rnoInnerhtml.test( value ) &&
6336                                 !wrapMap[ ( rtagName.exec( value ) || [ "", "" ] )[ 1 ].toLowerCase() ] ) {
6337
6338                                 value = jQuery.htmlPrefilter( value );
6339
6340                                 try {
6341                                         for ( ; i < l; i++ ) {
6342                                                 elem = this[ i ] || {};
6343
6344                                                 // Remove element nodes and prevent memory leaks
6345                                                 if ( elem.nodeType === 1 ) {
6346                                                         jQuery.cleanData( getAll( elem, false ) );
6347                                                         elem.innerHTML = value;
6348                                                 }
6349                                         }
6350
6351                                         elem = 0;
6352
6353                                 // If using innerHTML throws an exception, use the fallback method
6354                                 } catch ( e ) {}
6355                         }
6356
6357                         if ( elem ) {
6358                                 this.empty().append( value );
6359                         }
6360                 }, null, value, arguments.length );
6361         },
6362
6363         replaceWith: function() {
6364                 var ignored = [];
6365
6366                 // Make the changes, replacing each non-ignored context element with the new content
6367                 return domManip( this, arguments, function( elem ) {
6368                         var parent = this.parentNode;
6369
6370                         if ( jQuery.inArray( this, ignored ) < 0 ) {
6371                                 jQuery.cleanData( getAll( this ) );
6372                                 if ( parent ) {
6373                                         parent.replaceChild( elem, this );
6374                                 }
6375                         }
6376
6377                 // Force callback invocation
6378                 }, ignored );
6379         }
6380 } );
6381
6382 jQuery.each( {
6383         appendTo: "append",
6384         prependTo: "prepend",
6385         insertBefore: "before",
6386         insertAfter: "after",
6387         replaceAll: "replaceWith"
6388 }, function( name, original ) {
6389         jQuery.fn[ name ] = function( selector ) {
6390                 var elems,
6391                         ret = [],
6392                         insert = jQuery( selector ),
6393                         last = insert.length - 1,
6394                         i = 0;
6395
6396                 for ( ; i <= last; i++ ) {
6397                         elems = i === last ? this : this.clone( true );
6398                         jQuery( insert[ i ] )[ original ]( elems );
6399
6400                         // Support: Android <=4.0 only, PhantomJS 1 only
6401                         // .get() because push.apply(_, arraylike) throws on ancient WebKit
6402                         push.apply( ret, elems.get() );
6403                 }
6404
6405                 return this.pushStack( ret );
6406         };
6407 } );
6408 var rnumnonpx = new RegExp( "^(" + pnum + ")(?!px)[a-z%]+$", "i" );
6409
6410 var getStyles = function( elem ) {
6411
6412                 // Support: IE <=11 only, Firefox <=30 (#15098, #14150)
6413                 // IE throws on elements created in popups
6414                 // FF meanwhile throws on frame elements through "defaultView.getComputedStyle"
6415                 var view = elem.ownerDocument.defaultView;
6416
6417                 if ( !view || !view.opener ) {
6418                         view = window;
6419                 }
6420
6421                 return view.getComputedStyle( elem );
6422         };
6423
6424 var swap = function( elem, options, callback ) {
6425         var ret, name,
6426                 old = {};
6427
6428         // Remember the old values, and insert the new ones
6429         for ( name in options ) {
6430                 old[ name ] = elem.style[ name ];
6431                 elem.style[ name ] = options[ name ];
6432         }
6433
6434         ret = callback.call( elem );
6435
6436         // Revert the old values
6437         for ( name in options ) {
6438                 elem.style[ name ] = old[ name ];
6439         }
6440
6441         return ret;
6442 };
6443
6444
6445 var rboxStyle = new RegExp( cssExpand.join( "|" ), "i" );
6446
6447
6448
6449 ( function() {
6450
6451         // Executing both pixelPosition & boxSizingReliable tests require only one layout
6452         // so they're executed at the same time to save the second computation.
6453         function computeStyleTests() {
6454
6455                 // This is a singleton, we need to execute it only once
6456                 if ( !div ) {
6457                         return;
6458                 }
6459
6460                 container.style.cssText = "position:absolute;left:-11111px;width:60px;" +
6461                         "margin-top:1px;padding:0;border:0";
6462                 div.style.cssText =
6463                         "position:relative;display:block;box-sizing:border-box;overflow:scroll;" +
6464                         "margin:auto;border:1px;padding:1px;" +
6465                         "width:60%;top:1%";
6466                 documentElement.appendChild( container ).appendChild( div );
6467
6468                 var divStyle = window.getComputedStyle( div );
6469                 pixelPositionVal = divStyle.top !== "1%";
6470
6471                 // Support: Android 4.0 - 4.3 only, Firefox <=3 - 44
6472                 reliableMarginLeftVal = roundPixelMeasures( divStyle.marginLeft ) === 12;
6473
6474                 // Support: Android 4.0 - 4.3 only, Safari <=9.1 - 10.1, iOS <=7.0 - 9.3
6475                 // Some styles come back with percentage values, even though they shouldn't
6476                 div.style.right = "60%";
6477                 pixelBoxStylesVal = roundPixelMeasures( divStyle.right ) === 36;
6478
6479                 // Support: IE 9 - 11 only
6480                 // Detect misreporting of content dimensions for box-sizing:border-box elements
6481                 boxSizingReliableVal = roundPixelMeasures( divStyle.width ) === 36;
6482
6483                 // Support: IE 9 only
6484                 // Detect overflow:scroll screwiness (gh-3699)
6485                 // Support: Chrome <=64
6486                 // Don't get tricked when zoom affects offsetWidth (gh-4029)
6487                 div.style.position = "absolute";
6488                 scrollboxSizeVal = roundPixelMeasures( div.offsetWidth / 3 ) === 12;
6489
6490                 documentElement.removeChild( container );
6491
6492                 // Nullify the div so it wouldn't be stored in the memory and
6493                 // it will also be a sign that checks already performed
6494                 div = null;
6495         }
6496
6497         function roundPixelMeasures( measure ) {
6498                 return Math.round( parseFloat( measure ) );
6499         }
6500
6501         var pixelPositionVal, boxSizingReliableVal, scrollboxSizeVal, pixelBoxStylesVal,
6502                 reliableTrDimensionsVal, reliableMarginLeftVal,
6503                 container = document.createElement( "div" ),
6504                 div = document.createElement( "div" );
6505
6506         // Finish early in limited (non-browser) environments
6507         if ( !div.style ) {
6508                 return;
6509         }
6510
6511         // Support: IE <=9 - 11 only
6512         // Style of cloned element affects source element cloned (#8908)
6513         div.style.backgroundClip = "content-box";
6514         div.cloneNode( true ).style.backgroundClip = "";
6515         support.clearCloneStyle = div.style.backgroundClip === "content-box";
6516
6517         jQuery.extend( support, {
6518                 boxSizingReliable: function() {
6519                         computeStyleTests();
6520                         return boxSizingReliableVal;
6521                 },
6522                 pixelBoxStyles: function() {
6523                         computeStyleTests();
6524                         return pixelBoxStylesVal;
6525                 },
6526                 pixelPosition: function() {
6527                         computeStyleTests();
6528                         return pixelPositionVal;
6529                 },
6530                 reliableMarginLeft: function() {
6531                         computeStyleTests();
6532                         return reliableMarginLeftVal;
6533                 },
6534                 scrollboxSize: function() {
6535                         computeStyleTests();
6536                         return scrollboxSizeVal;
6537                 },
6538
6539                 // Support: IE 9 - 11+, Edge 15 - 18+
6540                 // IE/Edge misreport `getComputedStyle` of table rows with width/height
6541                 // set in CSS while `offset*` properties report correct values.
6542                 // Behavior in IE 9 is more subtle than in newer versions & it passes
6543                 // some versions of this test; make sure not to make it pass there!
6544                 reliableTrDimensions: function() {
6545                         var table, tr, trChild, trStyle;
6546                         if ( reliableTrDimensionsVal == null ) {
6547                                 table = document.createElement( "table" );
6548                                 tr = document.createElement( "tr" );
6549                                 trChild = document.createElement( "div" );
6550
6551                                 table.style.cssText = "position:absolute;left:-11111px";
6552                                 tr.style.height = "1px";
6553                                 trChild.style.height = "9px";
6554
6555                                 documentElement
6556                                         .appendChild( table )
6557                                         .appendChild( tr )
6558                                         .appendChild( trChild );
6559
6560                                 trStyle = window.getComputedStyle( tr );
6561                                 reliableTrDimensionsVal = parseInt( trStyle.height ) > 3;
6562
6563                                 documentElement.removeChild( table );
6564                         }
6565                         return reliableTrDimensionsVal;
6566                 }
6567         } );
6568 } )();
6569
6570
6571 function curCSS( elem, name, computed ) {
6572         var width, minWidth, maxWidth, ret,
6573
6574                 // Support: Firefox 51+
6575                 // Retrieving style before computed somehow
6576                 // fixes an issue with getting wrong values
6577                 // on detached elements
6578                 style = elem.style;
6579
6580         computed = computed || getStyles( elem );
6581
6582         // getPropertyValue is needed for:
6583         //   .css('filter') (IE 9 only, #12537)
6584         //   .css('--customProperty) (#3144)
6585         if ( computed ) {
6586                 ret = computed.getPropertyValue( name ) || computed[ name ];
6587
6588                 if ( ret === "" && !isAttached( elem ) ) {
6589                         ret = jQuery.style( elem, name );
6590                 }
6591
6592                 // A tribute to the "awesome hack by Dean Edwards"
6593                 // Android Browser returns percentage for some values,
6594                 // but width seems to be reliably pixels.
6595                 // This is against the CSSOM draft spec:
6596                 // https://drafts.csswg.org/cssom/#resolved-values
6597                 if ( !support.pixelBoxStyles() && rnumnonpx.test( ret ) && rboxStyle.test( name ) ) {
6598
6599                         // Remember the original values
6600                         width = style.width;
6601                         minWidth = style.minWidth;
6602                         maxWidth = style.maxWidth;
6603
6604                         // Put in the new values to get a computed value out
6605                         style.minWidth = style.maxWidth = style.width = ret;
6606                         ret = computed.width;
6607
6608                         // Revert the changed values
6609                         style.width = width;
6610                         style.minWidth = minWidth;
6611                         style.maxWidth = maxWidth;
6612                 }
6613         }
6614
6615         return ret !== undefined ?
6616
6617                 // Support: IE <=9 - 11 only
6618                 // IE returns zIndex value as an integer.
6619                 ret + "" :
6620                 ret;
6621 }
6622
6623
6624 function addGetHookIf( conditionFn, hookFn ) {
6625
6626         // Define the hook, we'll check on the first run if it's really needed.
6627         return {
6628                 get: function() {
6629                         if ( conditionFn() ) {
6630
6631                                 // Hook not needed (or it's not possible to use it due
6632                                 // to missing dependency), remove it.
6633                                 delete this.get;
6634                                 return;
6635                         }
6636
6637                         // Hook needed; redefine it so that the support test is not executed again.
6638                         return ( this.get = hookFn ).apply( this, arguments );
6639                 }
6640         };
6641 }
6642
6643
6644 var cssPrefixes = [ "Webkit", "Moz", "ms" ],
6645         emptyStyle = document.createElement( "div" ).style,
6646         vendorProps = {};
6647
6648 // Return a vendor-prefixed property or undefined
6649 function vendorPropName( name ) {
6650
6651         // Check for vendor prefixed names
6652         var capName = name[ 0 ].toUpperCase() + name.slice( 1 ),
6653                 i = cssPrefixes.length;
6654
6655         while ( i-- ) {
6656                 name = cssPrefixes[ i ] + capName;
6657                 if ( name in emptyStyle ) {
6658                         return name;
6659                 }
6660         }
6661 }
6662
6663 // Return a potentially-mapped jQuery.cssProps or vendor prefixed property
6664 function finalPropName( name ) {
6665         var final = jQuery.cssProps[ name ] || vendorProps[ name ];
6666
6667         if ( final ) {
6668                 return final;
6669         }
6670         if ( name in emptyStyle ) {
6671                 return name;
6672         }
6673         return vendorProps[ name ] = vendorPropName( name ) || name;
6674 }
6675
6676
6677 var
6678
6679         // Swappable if display is none or starts with table
6680         // except "table", "table-cell", or "table-caption"
6681         // See here for display values: https://developer.mozilla.org/en-US/docs/CSS/display
6682         rdisplayswap = /^(none|table(?!-c[ea]).+)/,
6683         rcustomProp = /^--/,
6684         cssShow = { position: "absolute", visibility: "hidden", display: "block" },
6685         cssNormalTransform = {
6686                 letterSpacing: "0",
6687                 fontWeight: "400"
6688         };
6689
6690 function setPositiveNumber( _elem, value, subtract ) {
6691
6692         // Any relative (+/-) values have already been
6693         // normalized at this point
6694         var matches = rcssNum.exec( value );
6695         return matches ?
6696
6697                 // Guard against undefined "subtract", e.g., when used as in cssHooks
6698                 Math.max( 0, matches[ 2 ] - ( subtract || 0 ) ) + ( matches[ 3 ] || "px" ) :
6699                 value;
6700 }
6701
6702 function boxModelAdjustment( elem, dimension, box, isBorderBox, styles, computedVal ) {
6703         var i = dimension === "width" ? 1 : 0,
6704                 extra = 0,
6705                 delta = 0;
6706
6707         // Adjustment may not be necessary
6708         if ( box === ( isBorderBox ? "border" : "content" ) ) {
6709                 return 0;
6710         }
6711
6712         for ( ; i < 4; i += 2 ) {
6713
6714                 // Both box models exclude margin
6715                 if ( box === "margin" ) {
6716                         delta += jQuery.css( elem, box + cssExpand[ i ], true, styles );
6717                 }
6718
6719                 // If we get here with a content-box, we're seeking "padding" or "border" or "margin"
6720                 if ( !isBorderBox ) {
6721
6722                         // Add padding
6723                         delta += jQuery.css( elem, "padding" + cssExpand[ i ], true, styles );
6724
6725                         // For "border" or "margin", add border
6726                         if ( box !== "padding" ) {
6727                                 delta += jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles );
6728
6729                         // But still keep track of it otherwise
6730                         } else {
6731                                 extra += jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles );
6732                         }
6733
6734                 // If we get here with a border-box (content + padding + border), we're seeking "content" or
6735                 // "padding" or "margin"
6736                 } else {
6737
6738                         // For "content", subtract padding
6739                         if ( box === "content" ) {
6740                                 delta -= jQuery.css( elem, "padding" + cssExpand[ i ], true, styles );
6741                         }
6742
6743                         // For "content" or "padding", subtract border
6744                         if ( box !== "margin" ) {
6745                                 delta -= jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles );
6746                         }
6747                 }
6748         }
6749
6750         // Account for positive content-box scroll gutter when requested by providing computedVal
6751         if ( !isBorderBox && computedVal >= 0 ) {
6752
6753                 // offsetWidth/offsetHeight is a rounded sum of content, padding, scroll gutter, and border
6754                 // Assuming integer scroll gutter, subtract the rest and round down
6755                 delta += Math.max( 0, Math.ceil(
6756                         elem[ "offset" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 ) ] -
6757                         computedVal -
6758                         delta -
6759                         extra -
6760                         0.5
6761
6762                 // If offsetWidth/offsetHeight is unknown, then we can't determine content-box scroll gutter
6763                 // Use an explicit zero to avoid NaN (gh-3964)
6764                 ) ) || 0;
6765         }
6766
6767         return delta;
6768 }
6769
6770 function getWidthOrHeight( elem, dimension, extra ) {
6771
6772         // Start with computed style
6773         var styles = getStyles( elem ),
6774
6775                 // To avoid forcing a reflow, only fetch boxSizing if we need it (gh-4322).
6776                 // Fake content-box until we know it's needed to know the true value.
6777                 boxSizingNeeded = !support.boxSizingReliable() || extra,
6778                 isBorderBox = boxSizingNeeded &&
6779                         jQuery.css( elem, "boxSizing", false, styles ) === "border-box",
6780                 valueIsBorderBox = isBorderBox,
6781
6782                 val = curCSS( elem, dimension, styles ),
6783                 offsetProp = "offset" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 );
6784
6785         // Support: Firefox <=54
6786         // Return a confounding non-pixel value or feign ignorance, as appropriate.
6787         if ( rnumnonpx.test( val ) ) {
6788                 if ( !extra ) {
6789                         return val;
6790                 }
6791                 val = "auto";
6792         }
6793
6794
6795         // Support: IE 9 - 11 only
6796         // Use offsetWidth/offsetHeight for when box sizing is unreliable.
6797         // In those cases, the computed value can be trusted to be border-box.
6798         if ( ( !support.boxSizingReliable() && isBorderBox ||
6799
6800                 // Support: IE 10 - 11+, Edge 15 - 18+
6801                 // IE/Edge misreport `getComputedStyle` of table rows with width/height
6802                 // set in CSS while `offset*` properties report correct values.
6803                 // Interestingly, in some cases IE 9 doesn't suffer from this issue.
6804                 !support.reliableTrDimensions() && nodeName( elem, "tr" ) ||
6805
6806                 // Fall back to offsetWidth/offsetHeight when value is "auto"
6807                 // This happens for inline elements with no explicit setting (gh-3571)
6808                 val === "auto" ||
6809
6810                 // Support: Android <=4.1 - 4.3 only
6811                 // Also use offsetWidth/offsetHeight for misreported inline dimensions (gh-3602)
6812                 !parseFloat( val ) && jQuery.css( elem, "display", false, styles ) === "inline" ) &&
6813
6814                 // Make sure the element is visible & connected
6815                 elem.getClientRects().length ) {
6816
6817                 isBorderBox = jQuery.css( elem, "boxSizing", false, styles ) === "border-box";
6818
6819                 // Where available, offsetWidth/offsetHeight approximate border box dimensions.
6820                 // Where not available (e.g., SVG), assume unreliable box-sizing and interpret the
6821                 // retrieved value as a content box dimension.
6822                 valueIsBorderBox = offsetProp in elem;
6823                 if ( valueIsBorderBox ) {
6824                         val = elem[ offsetProp ];
6825                 }
6826         }
6827
6828         // Normalize "" and auto
6829         val = parseFloat( val ) || 0;
6830
6831         // Adjust for the element's box model
6832         return ( val +
6833                 boxModelAdjustment(
6834                         elem,
6835                         dimension,
6836                         extra || ( isBorderBox ? "border" : "content" ),
6837                         valueIsBorderBox,
6838                         styles,
6839
6840                         // Provide the current computed size to request scroll gutter calculation (gh-3589)
6841                         val
6842                 )
6843         ) + "px";
6844 }
6845
6846 jQuery.extend( {
6847
6848         // Add in style property hooks for overriding the default
6849         // behavior of getting and setting a style property
6850         cssHooks: {
6851                 opacity: {
6852                         get: function( elem, computed ) {
6853                                 if ( computed ) {
6854
6855                                         // We should always get a number back from opacity
6856                                         var ret = curCSS( elem, "opacity" );
6857                                         return ret === "" ? "1" : ret;
6858                                 }
6859                         }
6860                 }
6861         },
6862
6863         // Don't automatically add "px" to these possibly-unitless properties
6864         cssNumber: {
6865                 "animationIterationCount": true,
6866                 "columnCount": true,
6867                 "fillOpacity": true,
6868                 "flexGrow": true,
6869                 "flexShrink": true,
6870                 "fontWeight": true,
6871                 "gridArea": true,
6872                 "gridColumn": true,
6873                 "gridColumnEnd": true,
6874                 "gridColumnStart": true,
6875                 "gridRow": true,
6876                 "gridRowEnd": true,
6877                 "gridRowStart": true,
6878                 "lineHeight": true,
6879                 "opacity": true,
6880                 "order": true,
6881                 "orphans": true,
6882                 "widows": true,
6883                 "zIndex": true,
6884                 "zoom": true
6885         },
6886
6887         // Add in properties whose names you wish to fix before
6888         // setting or getting the value
6889         cssProps: {},
6890
6891         // Get and set the style property on a DOM Node
6892         style: function( elem, name, value, extra ) {
6893
6894                 // Don't set styles on text and comment nodes
6895                 if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style ) {
6896                         return;
6897                 }
6898
6899                 // Make sure that we're working with the right name
6900                 var ret, type, hooks,
6901                         origName = camelCase( name ),
6902                         isCustomProp = rcustomProp.test( name ),
6903                         style = elem.style;
6904
6905                 // Make sure that we're working with the right name. We don't
6906                 // want to query the value if it is a CSS custom property
6907                 // since they are user-defined.
6908                 if ( !isCustomProp ) {
6909                         name = finalPropName( origName );
6910                 }
6911
6912                 // Gets hook for the prefixed version, then unprefixed version
6913                 hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ];
6914
6915                 // Check if we're setting a value
6916                 if ( value !== undefined ) {
6917                         type = typeof value;
6918
6919                         // Convert "+=" or "-=" to relative numbers (#7345)
6920                         if ( type === "string" && ( ret = rcssNum.exec( value ) ) && ret[ 1 ] ) {
6921                                 value = adjustCSS( elem, name, ret );
6922
6923                                 // Fixes bug #9237
6924                                 type = "number";
6925                         }
6926
6927                         // Make sure that null and NaN values aren't set (#7116)
6928                         if ( value == null || value !== value ) {
6929                                 return;
6930                         }
6931
6932                         // If a number was passed in, add the unit (except for certain CSS properties)
6933                         // The isCustomProp check can be removed in jQuery 4.0 when we only auto-append
6934                         // "px" to a few hardcoded values.
6935                         if ( type === "number" && !isCustomProp ) {
6936                                 value += ret && ret[ 3 ] || ( jQuery.cssNumber[ origName ] ? "" : "px" );
6937                         }
6938
6939                         // background-* props affect original clone's values
6940                         if ( !support.clearCloneStyle && value === "" && name.indexOf( "background" ) === 0 ) {
6941                                 style[ name ] = "inherit";
6942                         }
6943
6944                         // If a hook was provided, use that value, otherwise just set the specified value
6945                         if ( !hooks || !( "set" in hooks ) ||
6946                                 ( value = hooks.set( elem, value, extra ) ) !== undefined ) {
6947
6948                                 if ( isCustomProp ) {
6949                                         style.setProperty( name, value );
6950                                 } else {
6951                                         style[ name ] = value;
6952                                 }
6953                         }
6954
6955                 } else {
6956
6957                         // If a hook was provided get the non-computed value from there
6958                         if ( hooks && "get" in hooks &&
6959                                 ( ret = hooks.get( elem, false, extra ) ) !== undefined ) {
6960
6961                                 return ret;
6962                         }
6963
6964                         // Otherwise just get the value from the style object
6965                         return style[ name ];
6966                 }
6967         },
6968
6969         css: function( elem, name, extra, styles ) {
6970                 var val, num, hooks,
6971                         origName = camelCase( name ),
6972                         isCustomProp = rcustomProp.test( name );
6973
6974                 // Make sure that we're working with the right name. We don't
6975                 // want to modify the value if it is a CSS custom property
6976                 // since they are user-defined.
6977                 if ( !isCustomProp ) {
6978                         name = finalPropName( origName );
6979                 }
6980
6981                 // Try prefixed name followed by the unprefixed name
6982                 hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ];
6983
6984                 // If a hook was provided get the computed value from there
6985                 if ( hooks && "get" in hooks ) {
6986                         val = hooks.get( elem, true, extra );
6987                 }
6988
6989                 // Otherwise, if a way to get the computed value exists, use that
6990                 if ( val === undefined ) {
6991                         val = curCSS( elem, name, styles );
6992                 }
6993
6994                 // Convert "normal" to computed value
6995                 if ( val === "normal" && name in cssNormalTransform ) {
6996                         val = cssNormalTransform[ name ];
6997                 }
6998
6999                 // Make numeric if forced or a qualifier was provided and val looks numeric
7000                 if ( extra === "" || extra ) {
7001                         num = parseFloat( val );
7002                         return extra === true || isFinite( num ) ? num || 0 : val;
7003                 }
7004
7005                 return val;
7006         }
7007 } );
7008
7009 jQuery.each( [ "height", "width" ], function( _i, dimension ) {
7010         jQuery.cssHooks[ dimension ] = {
7011                 get: function( elem, computed, extra ) {
7012                         if ( computed ) {
7013
7014                                 // Certain elements can have dimension info if we invisibly show them
7015                                 // but it must have a current display style that would benefit
7016                                 return rdisplayswap.test( jQuery.css( elem, "display" ) ) &&
7017
7018                                         // Support: Safari 8+
7019                                         // Table columns in Safari have non-zero offsetWidth & zero
7020                                         // getBoundingClientRect().width unless display is changed.
7021                                         // Support: IE <=11 only
7022                                         // Running getBoundingClientRect on a disconnected node
7023                                         // in IE throws an error.
7024                                         ( !elem.getClientRects().length || !elem.getBoundingClientRect().width ) ?
7025                                                 swap( elem, cssShow, function() {
7026                                                         return getWidthOrHeight( elem, dimension, extra );
7027                                                 } ) :
7028                                                 getWidthOrHeight( elem, dimension, extra );
7029                         }
7030                 },
7031
7032                 set: function( elem, value, extra ) {
7033                         var matches,
7034                                 styles = getStyles( elem ),
7035
7036                                 // Only read styles.position if the test has a chance to fail
7037                                 // to avoid forcing a reflow.
7038                                 scrollboxSizeBuggy = !support.scrollboxSize() &&
7039                                         styles.position === "absolute",
7040
7041                                 // To avoid forcing a reflow, only fetch boxSizing if we need it (gh-3991)
7042                                 boxSizingNeeded = scrollboxSizeBuggy || extra,
7043                                 isBorderBox = boxSizingNeeded &&
7044                                         jQuery.css( elem, "boxSizing", false, styles ) === "border-box",
7045                                 subtract = extra ?
7046                                         boxModelAdjustment(
7047                                                 elem,
7048                                                 dimension,
7049                                                 extra,
7050                                                 isBorderBox,
7051                                                 styles
7052                                         ) :
7053                                         0;
7054
7055                         // Account for unreliable border-box dimensions by comparing offset* to computed and
7056                         // faking a content-box to get border and padding (gh-3699)
7057                         if ( isBorderBox && scrollboxSizeBuggy ) {
7058                                 subtract -= Math.ceil(
7059                                         elem[ "offset" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 ) ] -
7060                                         parseFloat( styles[ dimension ] ) -
7061                                         boxModelAdjustment( elem, dimension, "border", false, styles ) -
7062                                         0.5
7063                                 );
7064                         }
7065
7066                         // Convert to pixels if value adjustment is needed
7067                         if ( subtract && ( matches = rcssNum.exec( value ) ) &&
7068                                 ( matches[ 3 ] || "px" ) !== "px" ) {
7069
7070                                 elem.style[ dimension ] = value;
7071                                 value = jQuery.css( elem, dimension );
7072                         }
7073
7074                         return setPositiveNumber( elem, value, subtract );
7075                 }
7076         };
7077 } );
7078
7079 jQuery.cssHooks.marginLeft = addGetHookIf( support.reliableMarginLeft,
7080         function( elem, computed ) {
7081                 if ( computed ) {
7082                         return ( parseFloat( curCSS( elem, "marginLeft" ) ) ||
7083                                 elem.getBoundingClientRect().left -
7084                                         swap( elem, { marginLeft: 0 }, function() {
7085                                                 return elem.getBoundingClientRect().left;
7086                                         } )
7087                                 ) + "px";
7088                 }
7089         }
7090 );
7091
7092 // These hooks are used by animate to expand properties
7093 jQuery.each( {
7094         margin: "",
7095         padding: "",
7096         border: "Width"
7097 }, function( prefix, suffix ) {
7098         jQuery.cssHooks[ prefix + suffix ] = {
7099                 expand: function( value ) {
7100                         var i = 0,
7101                                 expanded = {},
7102
7103                                 // Assumes a single number if not a string
7104                                 parts = typeof value === "string" ? value.split( " " ) : [ value ];
7105
7106                         for ( ; i < 4; i++ ) {
7107                                 expanded[ prefix + cssExpand[ i ] + suffix ] =
7108                                         parts[ i ] || parts[ i - 2 ] || parts[ 0 ];
7109                         }
7110
7111                         return expanded;
7112                 }
7113         };
7114
7115         if ( prefix !== "margin" ) {
7116                 jQuery.cssHooks[ prefix + suffix ].set = setPositiveNumber;
7117         }
7118 } );
7119
7120 jQuery.fn.extend( {
7121         css: function( name, value ) {
7122                 return access( this, function( elem, name, value ) {
7123                         var styles, len,
7124                                 map = {},
7125                                 i = 0;
7126
7127                         if ( Array.isArray( name ) ) {
7128                                 styles = getStyles( elem );
7129                                 len = name.length;
7130
7131                                 for ( ; i < len; i++ ) {
7132                                         map[ name[ i ] ] = jQuery.css( elem, name[ i ], false, styles );
7133                                 }
7134
7135                                 return map;
7136                         }
7137
7138                         return value !== undefined ?
7139                                 jQuery.style( elem, name, value ) :
7140                                 jQuery.css( elem, name );
7141                 }, name, value, arguments.length > 1 );
7142         }
7143 } );
7144
7145
7146 function Tween( elem, options, prop, end, easing ) {
7147         return new Tween.prototype.init( elem, options, prop, end, easing );
7148 }
7149 jQuery.Tween = Tween;
7150
7151 Tween.prototype = {
7152         constructor: Tween,
7153         init: function( elem, options, prop, end, easing, unit ) {
7154                 this.elem = elem;
7155                 this.prop = prop;
7156                 this.easing = easing || jQuery.easing._default;
7157                 this.options = options;
7158                 this.start = this.now = this.cur();
7159                 this.end = end;
7160                 this.unit = unit || ( jQuery.cssNumber[ prop ] ? "" : "px" );
7161         },
7162         cur: function() {
7163                 var hooks = Tween.propHooks[ this.prop ];
7164
7165                 return hooks && hooks.get ?
7166                         hooks.get( this ) :
7167                         Tween.propHooks._default.get( this );
7168         },
7169         run: function( percent ) {
7170                 var eased,
7171                         hooks = Tween.propHooks[ this.prop ];
7172
7173                 if ( this.options.duration ) {
7174                         this.pos = eased = jQuery.easing[ this.easing ](
7175                                 percent, this.options.duration * percent, 0, 1, this.options.duration
7176                         );
7177                 } else {
7178                         this.pos = eased = percent;
7179                 }
7180                 this.now = ( this.end - this.start ) * eased + this.start;
7181
7182                 if ( this.options.step ) {
7183                         this.options.step.call( this.elem, this.now, this );
7184                 }
7185
7186                 if ( hooks && hooks.set ) {
7187                         hooks.set( this );
7188                 } else {
7189                         Tween.propHooks._default.set( this );
7190                 }
7191                 return this;
7192         }
7193 };
7194
7195 Tween.prototype.init.prototype = Tween.prototype;
7196
7197 Tween.propHooks = {
7198         _default: {
7199                 get: function( tween ) {
7200                         var result;
7201
7202                         // Use a property on the element directly when it is not a DOM element,
7203                         // or when there is no matching style property that exists.
7204                         if ( tween.elem.nodeType !== 1 ||
7205                                 tween.elem[ tween.prop ] != null && tween.elem.style[ tween.prop ] == null ) {
7206                                 return tween.elem[ tween.prop ];
7207                         }
7208
7209                         // Passing an empty string as a 3rd parameter to .css will automatically
7210                         // attempt a parseFloat and fallback to a string if the parse fails.
7211                         // Simple values such as "10px" are parsed to Float;
7212                         // complex values such as "rotate(1rad)" are returned as-is.
7213                         result = jQuery.css( tween.elem, tween.prop, "" );
7214
7215                         // Empty strings, null, undefined and "auto" are converted to 0.
7216                         return !result || result === "auto" ? 0 : result;
7217                 },
7218                 set: function( tween ) {
7219
7220                         // Use step hook for back compat.
7221                         // Use cssHook if its there.
7222                         // Use .style if available and use plain properties where available.
7223                         if ( jQuery.fx.step[ tween.prop ] ) {
7224                                 jQuery.fx.step[ tween.prop ]( tween );
7225                         } else if ( tween.elem.nodeType === 1 && (
7226                                         jQuery.cssHooks[ tween.prop ] ||
7227                                         tween.elem.style[ finalPropName( tween.prop ) ] != null ) ) {
7228                                 jQuery.style( tween.elem, tween.prop, tween.now + tween.unit );
7229                         } else {
7230                                 tween.elem[ tween.prop ] = tween.now;
7231                         }
7232                 }
7233         }
7234 };
7235
7236 // Support: IE <=9 only
7237 // Panic based approach to setting things on disconnected nodes
7238 Tween.propHooks.scrollTop = Tween.propHooks.scrollLeft = {
7239         set: function( tween ) {
7240                 if ( tween.elem.nodeType && tween.elem.parentNode ) {
7241                         tween.elem[ tween.prop ] = tween.now;
7242                 }
7243         }
7244 };
7245
7246 jQuery.easing = {
7247         linear: function( p ) {
7248                 return p;
7249         },
7250         swing: function( p ) {
7251                 return 0.5 - Math.cos( p * Math.PI ) / 2;
7252         },
7253         _default: "swing"
7254 };
7255
7256 jQuery.fx = Tween.prototype.init;
7257
7258 // Back compat <1.8 extension point
7259 jQuery.fx.step = {};
7260
7261
7262
7263
7264 var
7265         fxNow, inProgress,
7266         rfxtypes = /^(?:toggle|show|hide)$/,
7267         rrun = /queueHooks$/;
7268
7269 function schedule() {
7270         if ( inProgress ) {
7271                 if ( document.hidden === false && window.requestAnimationFrame ) {
7272                         window.requestAnimationFrame( schedule );
7273                 } else {
7274                         window.setTimeout( schedule, jQuery.fx.interval );
7275                 }
7276
7277                 jQuery.fx.tick();
7278         }
7279 }
7280
7281 // Animations created synchronously will run synchronously
7282 function createFxNow() {
7283         window.setTimeout( function() {
7284                 fxNow = undefined;
7285         } );
7286         return ( fxNow = Date.now() );
7287 }
7288
7289 // Generate parameters to create a standard animation
7290 function genFx( type, includeWidth ) {
7291         var which,
7292                 i = 0,
7293                 attrs = { height: type };
7294
7295         // If we include width, step value is 1 to do all cssExpand values,
7296         // otherwise step value is 2 to skip over Left and Right
7297         includeWidth = includeWidth ? 1 : 0;
7298         for ( ; i < 4; i += 2 - includeWidth ) {
7299                 which = cssExpand[ i ];
7300                 attrs[ "margin" + which ] = attrs[ "padding" + which ] = type;
7301         }
7302
7303         if ( includeWidth ) {
7304                 attrs.opacity = attrs.width = type;
7305         }
7306
7307         return attrs;
7308 }
7309
7310 function createTween( value, prop, animation ) {
7311         var tween,
7312                 collection = ( Animation.tweeners[ prop ] || [] ).concat( Animation.tweeners[ "*" ] ),
7313                 index = 0,
7314                 length = collection.length;
7315         for ( ; index < length; index++ ) {
7316                 if ( ( tween = collection[ index ].call( animation, prop, value ) ) ) {
7317
7318                         // We're done with this property
7319                         return tween;
7320                 }
7321         }
7322 }
7323
7324 function defaultPrefilter( elem, props, opts ) {
7325         var prop, value, toggle, hooks, oldfire, propTween, restoreDisplay, display,
7326                 isBox = "width" in props || "height" in props,
7327                 anim = this,
7328                 orig = {},
7329                 style = elem.style,
7330                 hidden = elem.nodeType && isHiddenWithinTree( elem ),
7331                 dataShow = dataPriv.get( elem, "fxshow" );
7332
7333         // Queue-skipping animations hijack the fx hooks
7334         if ( !opts.queue ) {
7335                 hooks = jQuery._queueHooks( elem, "fx" );
7336                 if ( hooks.unqueued == null ) {
7337                         hooks.unqueued = 0;
7338                         oldfire = hooks.empty.fire;
7339                         hooks.empty.fire = function() {
7340                                 if ( !hooks.unqueued ) {
7341                                         oldfire();
7342                                 }
7343                         };
7344                 }
7345                 hooks.unqueued++;
7346
7347                 anim.always( function() {
7348
7349                         // Ensure the complete handler is called before this completes
7350                         anim.always( function() {
7351                                 hooks.unqueued--;
7352                                 if ( !jQuery.queue( elem, "fx" ).length ) {
7353                                         hooks.empty.fire();
7354                                 }
7355                         } );
7356                 } );
7357         }
7358
7359         // Detect show/hide animations
7360         for ( prop in props ) {
7361                 value = props[ prop ];
7362                 if ( rfxtypes.test( value ) ) {
7363                         delete props[ prop ];
7364                         toggle = toggle || value === "toggle";
7365                         if ( value === ( hidden ? "hide" : "show" ) ) {
7366
7367                                 // Pretend to be hidden if this is a "show" and
7368                                 // there is still data from a stopped show/hide
7369                                 if ( value === "show" && dataShow && dataShow[ prop ] !== undefined ) {
7370                                         hidden = true;
7371
7372                                 // Ignore all other no-op show/hide data
7373                                 } else {
7374                                         continue;
7375                                 }
7376                         }
7377                         orig[ prop ] = dataShow && dataShow[ prop ] || jQuery.style( elem, prop );
7378                 }
7379         }
7380
7381         // Bail out if this is a no-op like .hide().hide()
7382         propTween = !jQuery.isEmptyObject( props );
7383         if ( !propTween && jQuery.isEmptyObject( orig ) ) {
7384                 return;
7385         }
7386
7387         // Restrict "overflow" and "display" styles during box animations
7388         if ( isBox && elem.nodeType === 1 ) {
7389
7390                 // Support: IE <=9 - 11, Edge 12 - 15
7391                 // Record all 3 overflow attributes because IE does not infer the shorthand
7392                 // from identically-valued overflowX and overflowY and Edge just mirrors
7393                 // the overflowX value there.
7394                 opts.overflow = [ style.overflow, style.overflowX, style.overflowY ];
7395
7396                 // Identify a display type, preferring old show/hide data over the CSS cascade
7397                 restoreDisplay = dataShow && dataShow.display;
7398                 if ( restoreDisplay == null ) {
7399                         restoreDisplay = dataPriv.get( elem, "display" );
7400                 }
7401                 display = jQuery.css( elem, "display" );
7402                 if ( display === "none" ) {
7403                         if ( restoreDisplay ) {
7404                                 display = restoreDisplay;
7405                         } else {
7406
7407                                 // Get nonempty value(s) by temporarily forcing visibility
7408                                 showHide( [ elem ], true );
7409                                 restoreDisplay = elem.style.display || restoreDisplay;
7410                                 display = jQuery.css( elem, "display" );
7411                                 showHide( [ elem ] );
7412                         }
7413                 }
7414
7415                 // Animate inline elements as inline-block
7416                 if ( display === "inline" || display === "inline-block" && restoreDisplay != null ) {
7417                         if ( jQuery.css( elem, "float" ) === "none" ) {
7418
7419                                 // Restore the original display value at the end of pure show/hide animations
7420                                 if ( !propTween ) {
7421                                         anim.done( function() {
7422                                                 style.display = restoreDisplay;
7423                                         } );
7424                                         if ( restoreDisplay == null ) {
7425                                                 display = style.display;
7426                                                 restoreDisplay = display === "none" ? "" : display;
7427                                         }
7428                                 }
7429                                 style.display = "inline-block";
7430                         }
7431                 }
7432         }
7433
7434         if ( opts.overflow ) {
7435                 style.overflow = "hidden";
7436                 anim.always( function() {
7437                         style.overflow = opts.overflow[ 0 ];
7438                         style.overflowX = opts.overflow[ 1 ];
7439                         style.overflowY = opts.overflow[ 2 ];
7440                 } );
7441         }
7442
7443         // Implement show/hide animations
7444         propTween = false;
7445         for ( prop in orig ) {
7446
7447                 // General show/hide setup for this element animation
7448                 if ( !propTween ) {
7449                         if ( dataShow ) {
7450                                 if ( "hidden" in dataShow ) {
7451                                         hidden = dataShow.hidden;
7452                                 }
7453                         } else {
7454                                 dataShow = dataPriv.access( elem, "fxshow", { display: restoreDisplay } );
7455                         }
7456
7457                         // Store hidden/visible for toggle so `.stop().toggle()` "reverses"
7458                         if ( toggle ) {
7459                                 dataShow.hidden = !hidden;
7460                         }
7461
7462                         // Show elements before animating them
7463                         if ( hidden ) {
7464                                 showHide( [ elem ], true );
7465                         }
7466
7467                         /* eslint-disable no-loop-func */
7468
7469                         anim.done( function() {
7470
7471                         /* eslint-enable no-loop-func */
7472
7473                                 // The final step of a "hide" animation is actually hiding the element
7474                                 if ( !hidden ) {
7475                                         showHide( [ elem ] );
7476                                 }
7477                                 dataPriv.remove( elem, "fxshow" );
7478                                 for ( prop in orig ) {
7479                                         jQuery.style( elem, prop, orig[ prop ] );
7480                                 }
7481                         } );
7482                 }
7483
7484                 // Per-property setup
7485                 propTween = createTween( hidden ? dataShow[ prop ] : 0, prop, anim );
7486                 if ( !( prop in dataShow ) ) {
7487                         dataShow[ prop ] = propTween.start;
7488                         if ( hidden ) {
7489                                 propTween.end = propTween.start;
7490                                 propTween.start = 0;
7491                         }
7492                 }
7493         }
7494 }
7495
7496 function propFilter( props, specialEasing ) {
7497         var index, name, easing, value, hooks;
7498
7499         // camelCase, specialEasing and expand cssHook pass
7500         for ( index in props ) {
7501                 name = camelCase( index );
7502                 easing = specialEasing[ name ];
7503                 value = props[ index ];
7504                 if ( Array.isArray( value ) ) {
7505                         easing = value[ 1 ];
7506                         value = props[ index ] = value[ 0 ];
7507                 }
7508
7509                 if ( index !== name ) {
7510                         props[ name ] = value;
7511                         delete props[ index ];
7512                 }
7513
7514                 hooks = jQuery.cssHooks[ name ];
7515                 if ( hooks && "expand" in hooks ) {
7516                         value = hooks.expand( value );
7517                         delete props[ name ];
7518
7519                         // Not quite $.extend, this won't overwrite existing keys.
7520                         // Reusing 'index' because we have the correct "name"
7521                         for ( index in value ) {
7522                                 if ( !( index in props ) ) {
7523                                         props[ index ] = value[ index ];
7524                                         specialEasing[ index ] = easing;
7525                                 }
7526                         }
7527                 } else {
7528                         specialEasing[ name ] = easing;
7529                 }
7530         }
7531 }
7532
7533 function Animation( elem, properties, options ) {
7534         var result,
7535                 stopped,
7536                 index = 0,
7537                 length = Animation.prefilters.length,
7538                 deferred = jQuery.Deferred().always( function() {
7539
7540                         // Don't match elem in the :animated selector
7541                         delete tick.elem;
7542                 } ),
7543                 tick = function() {
7544                         if ( stopped ) {
7545                                 return false;
7546                         }
7547                         var currentTime = fxNow || createFxNow(),
7548                                 remaining = Math.max( 0, animation.startTime + animation.duration - currentTime ),
7549
7550                                 // Support: Android 2.3 only
7551                                 // Archaic crash bug won't allow us to use `1 - ( 0.5 || 0 )` (#12497)
7552                                 temp = remaining / animation.duration || 0,
7553                                 percent = 1 - temp,
7554                                 index = 0,
7555                                 length = animation.tweens.length;
7556
7557                         for ( ; index < length; index++ ) {
7558                                 animation.tweens[ index ].run( percent );
7559                         }
7560
7561                         deferred.notifyWith( elem, [ animation, percent, remaining ] );
7562
7563                         // If there's more to do, yield
7564                         if ( percent < 1 && length ) {
7565                                 return remaining;
7566                         }
7567
7568                         // If this was an empty animation, synthesize a final progress notification
7569                         if ( !length ) {
7570                                 deferred.notifyWith( elem, [ animation, 1, 0 ] );
7571                         }
7572
7573                         // Resolve the animation and report its conclusion
7574                         deferred.resolveWith( elem, [ animation ] );
7575                         return false;
7576                 },
7577                 animation = deferred.promise( {
7578                         elem: elem,
7579                         props: jQuery.extend( {}, properties ),
7580                         opts: jQuery.extend( true, {
7581                                 specialEasing: {},
7582                                 easing: jQuery.easing._default
7583                         }, options ),
7584                         originalProperties: properties,
7585                         originalOptions: options,
7586                         startTime: fxNow || createFxNow(),
7587                         duration: options.duration,
7588                         tweens: [],
7589                         createTween: function( prop, end ) {
7590                                 var tween = jQuery.Tween( elem, animation.opts, prop, end,
7591                                                 animation.opts.specialEasing[ prop ] || animation.opts.easing );
7592                                 animation.tweens.push( tween );
7593                                 return tween;
7594                         },
7595                         stop: function( gotoEnd ) {
7596                                 var index = 0,
7597
7598                                         // If we are going to the end, we want to run all the tweens
7599                                         // otherwise we skip this part
7600                                         length = gotoEnd ? animation.tweens.length : 0;
7601                                 if ( stopped ) {
7602                                         return this;
7603                                 }
7604                                 stopped = true;
7605                                 for ( ; index < length; index++ ) {
7606                                         animation.tweens[ index ].run( 1 );
7607                                 }
7608
7609                                 // Resolve when we played the last frame; otherwise, reject
7610                                 if ( gotoEnd ) {
7611                                         deferred.notifyWith( elem, [ animation, 1, 0 ] );
7612                                         deferred.resolveWith( elem, [ animation, gotoEnd ] );
7613                                 } else {
7614                                         deferred.rejectWith( elem, [ animation, gotoEnd ] );
7615                                 }
7616                                 return this;
7617                         }
7618                 } ),
7619                 props = animation.props;
7620
7621         propFilter( props, animation.opts.specialEasing );
7622
7623         for ( ; index < length; index++ ) {
7624                 result = Animation.prefilters[ index ].call( animation, elem, props, animation.opts );
7625                 if ( result ) {
7626                         if ( isFunction( result.stop ) ) {
7627                                 jQuery._queueHooks( animation.elem, animation.opts.queue ).stop =
7628                                         result.stop.bind( result );
7629                         }
7630                         return result;
7631                 }
7632         }
7633
7634         jQuery.map( props, createTween, animation );
7635
7636         if ( isFunction( animation.opts.start ) ) {
7637                 animation.opts.start.call( elem, animation );
7638         }
7639
7640         // Attach callbacks from options
7641         animation
7642                 .progress( animation.opts.progress )
7643                 .done( animation.opts.done, animation.opts.complete )
7644                 .fail( animation.opts.fail )
7645                 .always( animation.opts.always );
7646
7647         jQuery.fx.timer(
7648                 jQuery.extend( tick, {
7649                         elem: elem,
7650                         anim: animation,
7651                         queue: animation.opts.queue
7652                 } )
7653         );
7654
7655         return animation;
7656 }
7657
7658 jQuery.Animation = jQuery.extend( Animation, {
7659
7660         tweeners: {
7661                 "*": [ function( prop, value ) {
7662                         var tween = this.createTween( prop, value );
7663                         adjustCSS( tween.elem, prop, rcssNum.exec( value ), tween );
7664                         return tween;
7665                 } ]
7666         },
7667
7668         tweener: function( props, callback ) {
7669                 if ( isFunction( props ) ) {
7670                         callback = props;
7671                         props = [ "*" ];
7672                 } else {
7673                         props = props.match( rnothtmlwhite );
7674                 }
7675
7676                 var prop,
7677                         index = 0,
7678                         length = props.length;
7679
7680                 for ( ; index < length; index++ ) {
7681                         prop = props[ index ];
7682                         Animation.tweeners[ prop ] = Animation.tweeners[ prop ] || [];
7683                         Animation.tweeners[ prop ].unshift( callback );
7684                 }
7685         },
7686
7687         prefilters: [ defaultPrefilter ],
7688
7689         prefilter: function( callback, prepend ) {
7690                 if ( prepend ) {
7691                         Animation.prefilters.unshift( callback );
7692                 } else {
7693                         Animation.prefilters.push( callback );
7694                 }
7695         }
7696 } );
7697
7698 jQuery.speed = function( speed, easing, fn ) {
7699         var opt = speed && typeof speed === "object" ? jQuery.extend( {}, speed ) : {
7700                 complete: fn || !fn && easing ||
7701                         isFunction( speed ) && speed,
7702                 duration: speed,
7703                 easing: fn && easing || easing && !isFunction( easing ) && easing
7704         };
7705
7706         // Go to the end state if fx are off
7707         if ( jQuery.fx.off ) {
7708                 opt.duration = 0;
7709
7710         } else {
7711                 if ( typeof opt.duration !== "number" ) {
7712                         if ( opt.duration in jQuery.fx.speeds ) {
7713                                 opt.duration = jQuery.fx.speeds[ opt.duration ];
7714
7715                         } else {
7716                                 opt.duration = jQuery.fx.speeds._default;
7717                         }
7718                 }
7719         }
7720
7721         // Normalize opt.queue - true/undefined/null -> "fx"
7722         if ( opt.queue == null || opt.queue === true ) {
7723                 opt.queue = "fx";
7724         }
7725
7726         // Queueing
7727         opt.old = opt.complete;
7728
7729         opt.complete = function() {
7730                 if ( isFunction( opt.old ) ) {
7731                         opt.old.call( this );
7732                 }
7733
7734                 if ( opt.queue ) {
7735                         jQuery.dequeue( this, opt.queue );
7736                 }
7737         };
7738
7739         return opt;
7740 };
7741
7742 jQuery.fn.extend( {
7743         fadeTo: function( speed, to, easing, callback ) {
7744
7745                 // Show any hidden elements after setting opacity to 0
7746                 return this.filter( isHiddenWithinTree ).css( "opacity", 0 ).show()
7747
7748                         // Animate to the value specified
7749                         .end().animate( { opacity: to }, speed, easing, callback );
7750         },
7751         animate: function( prop, speed, easing, callback ) {
7752                 var empty = jQuery.isEmptyObject( prop ),
7753                         optall = jQuery.speed( speed, easing, callback ),
7754                         doAnimation = function() {
7755
7756                                 // Operate on a copy of prop so per-property easing won't be lost
7757                                 var anim = Animation( this, jQuery.extend( {}, prop ), optall );
7758
7759                                 // Empty animations, or finishing resolves immediately
7760                                 if ( empty || dataPriv.get( this, "finish" ) ) {
7761                                         anim.stop( true );
7762                                 }
7763                         };
7764                         doAnimation.finish = doAnimation;
7765
7766                 return empty || optall.queue === false ?
7767                         this.each( doAnimation ) :
7768                         this.queue( optall.queue, doAnimation );
7769         },
7770         stop: function( type, clearQueue, gotoEnd ) {
7771                 var stopQueue = function( hooks ) {
7772                         var stop = hooks.stop;
7773                         delete hooks.stop;
7774                         stop( gotoEnd );
7775                 };
7776
7777                 if ( typeof type !== "string" ) {
7778                         gotoEnd = clearQueue;
7779                         clearQueue = type;
7780                         type = undefined;
7781                 }
7782                 if ( clearQueue ) {
7783                         this.queue( type || "fx", [] );
7784                 }
7785
7786                 return this.each( function() {
7787                         var dequeue = true,
7788                                 index = type != null && type + "queueHooks",
7789                                 timers = jQuery.timers,
7790                                 data = dataPriv.get( this );
7791
7792                         if ( index ) {
7793                                 if ( data[ index ] && data[ index ].stop ) {
7794                                         stopQueue( data[ index ] );
7795                                 }
7796                         } else {
7797                                 for ( index in data ) {
7798                                         if ( data[ index ] && data[ index ].stop && rrun.test( index ) ) {
7799                                                 stopQueue( data[ index ] );
7800                                         }
7801                                 }
7802                         }
7803
7804                         for ( index = timers.length; index--; ) {
7805                                 if ( timers[ index ].elem === this &&
7806                                         ( type == null || timers[ index ].queue === type ) ) {
7807
7808                                         timers[ index ].anim.stop( gotoEnd );
7809                                         dequeue = false;
7810                                         timers.splice( index, 1 );
7811                                 }
7812                         }
7813
7814                         // Start the next in the queue if the last step wasn't forced.
7815                         // Timers currently will call their complete callbacks, which
7816                         // will dequeue but only if they were gotoEnd.
7817                         if ( dequeue || !gotoEnd ) {
7818                                 jQuery.dequeue( this, type );
7819                         }
7820                 } );
7821         },
7822         finish: function( type ) {
7823                 if ( type !== false ) {
7824                         type = type || "fx";
7825                 }
7826                 return this.each( function() {
7827                         var index,
7828                                 data = dataPriv.get( this ),
7829                                 queue = data[ type + "queue" ],
7830                                 hooks = data[ type + "queueHooks" ],
7831                                 timers = jQuery.timers,
7832                                 length = queue ? queue.length : 0;
7833
7834                         // Enable finishing flag on private data
7835                         data.finish = true;
7836
7837                         // Empty the queue first
7838                         jQuery.queue( this, type, [] );
7839
7840                         if ( hooks && hooks.stop ) {
7841                                 hooks.stop.call( this, true );
7842                         }
7843
7844                         // Look for any active animations, and finish them
7845                         for ( index = timers.length; index--; ) {
7846                                 if ( timers[ index ].elem === this && timers[ index ].queue === type ) {
7847                                         timers[ index ].anim.stop( true );
7848                                         timers.splice( index, 1 );
7849                                 }
7850                         }
7851
7852                         // Look for any animations in the old queue and finish them
7853                         for ( index = 0; index < length; index++ ) {
7854                                 if ( queue[ index ] && queue[ index ].finish ) {
7855                                         queue[ index ].finish.call( this );
7856                                 }
7857                         }
7858
7859                         // Turn off finishing flag
7860                         delete data.finish;
7861                 } );
7862         }
7863 } );
7864
7865 jQuery.each( [ "toggle", "show", "hide" ], function( _i, name ) {
7866         var cssFn = jQuery.fn[ name ];
7867         jQuery.fn[ name ] = function( speed, easing, callback ) {
7868                 return speed == null || typeof speed === "boolean" ?
7869                         cssFn.apply( this, arguments ) :
7870                         this.animate( genFx( name, true ), speed, easing, callback );
7871         };
7872 } );
7873
7874 // Generate shortcuts for custom animations
7875 jQuery.each( {
7876         slideDown: genFx( "show" ),
7877         slideUp: genFx( "hide" ),
7878         slideToggle: genFx( "toggle" ),
7879         fadeIn: { opacity: "show" },
7880         fadeOut: { opacity: "hide" },
7881         fadeToggle: { opacity: "toggle" }
7882 }, function( name, props ) {
7883         jQuery.fn[ name ] = function( speed, easing, callback ) {
7884                 return this.animate( props, speed, easing, callback );
7885         };
7886 } );
7887
7888 jQuery.timers = [];
7889 jQuery.fx.tick = function() {
7890         var timer,
7891                 i = 0,
7892                 timers = jQuery.timers;
7893
7894         fxNow = Date.now();
7895
7896         for ( ; i < timers.length; i++ ) {
7897                 timer = timers[ i ];
7898
7899                 // Run the timer and safely remove it when done (allowing for external removal)
7900                 if ( !timer() && timers[ i ] === timer ) {
7901                         timers.splice( i--, 1 );
7902                 }
7903         }
7904
7905         if ( !timers.length ) {
7906                 jQuery.fx.stop();
7907         }
7908         fxNow = undefined;
7909 };
7910
7911 jQuery.fx.timer = function( timer ) {
7912         jQuery.timers.push( timer );
7913         jQuery.fx.start();
7914 };
7915
7916 jQuery.fx.interval = 13;
7917 jQuery.fx.start = function() {
7918         if ( inProgress ) {
7919                 return;
7920         }
7921
7922         inProgress = true;
7923         schedule();
7924 };
7925
7926 jQuery.fx.stop = function() {
7927         inProgress = null;
7928 };
7929
7930 jQuery.fx.speeds = {
7931         slow: 600,
7932         fast: 200,
7933
7934         // Default speed
7935         _default: 400
7936 };
7937
7938
7939 // Based off of the plugin by Clint Helfers, with permission.
7940 // https://web.archive.org/web/20100324014747/http://blindsignals.com/index.php/2009/07/jquery-delay/
7941 jQuery.fn.delay = function( time, type ) {
7942         time = jQuery.fx ? jQuery.fx.speeds[ time ] || time : time;
7943         type = type || "fx";
7944
7945         return this.queue( type, function( next, hooks ) {
7946                 var timeout = window.setTimeout( next, time );
7947                 hooks.stop = function() {
7948                         window.clearTimeout( timeout );
7949                 };
7950         } );
7951 };
7952
7953
7954 ( function() {
7955         var input = document.createElement( "input" ),
7956                 select = document.createElement( "select" ),
7957                 opt = select.appendChild( document.createElement( "option" ) );
7958
7959         input.type = "checkbox";
7960
7961         // Support: Android <=4.3 only
7962         // Default value for a checkbox should be "on"
7963         support.checkOn = input.value !== "";
7964
7965         // Support: IE <=11 only
7966         // Must access selectedIndex to make default options select
7967         support.optSelected = opt.selected;
7968
7969         // Support: IE <=11 only
7970         // An input loses its value after becoming a radio
7971         input = document.createElement( "input" );
7972         input.value = "t";
7973         input.type = "radio";
7974         support.radioValue = input.value === "t";
7975 } )();
7976
7977
7978 var boolHook,
7979         attrHandle = jQuery.expr.attrHandle;
7980
7981 jQuery.fn.extend( {
7982         attr: function( name, value ) {
7983                 return access( this, jQuery.attr, name, value, arguments.length > 1 );
7984         },
7985
7986         removeAttr: function( name ) {
7987                 return this.each( function() {
7988                         jQuery.removeAttr( this, name );
7989                 } );
7990         }
7991 } );
7992
7993 jQuery.extend( {
7994         attr: function( elem, name, value ) {
7995                 var ret, hooks,
7996                         nType = elem.nodeType;
7997
7998                 // Don't get/set attributes on text, comment and attribute nodes
7999                 if ( nType === 3 || nType === 8 || nType === 2 ) {
8000                         return;
8001                 }
8002
8003                 // Fallback to prop when attributes are not supported
8004                 if ( typeof elem.getAttribute === "undefined" ) {
8005                         return jQuery.prop( elem, name, value );
8006                 }
8007
8008                 // Attribute hooks are determined by the lowercase version
8009                 // Grab necessary hook if one is defined
8010                 if ( nType !== 1 || !jQuery.isXMLDoc( elem ) ) {
8011                         hooks = jQuery.attrHooks[ name.toLowerCase() ] ||
8012                                 ( jQuery.expr.match.bool.test( name ) ? boolHook : undefined );
8013                 }
8014
8015                 if ( value !== undefined ) {
8016                         if ( value === null ) {
8017                                 jQuery.removeAttr( elem, name );
8018                                 return;
8019                         }
8020
8021                         if ( hooks && "set" in hooks &&
8022                                 ( ret = hooks.set( elem, value, name ) ) !== undefined ) {
8023                                 return ret;
8024                         }
8025
8026                         elem.setAttribute( name, value + "" );
8027                         return value;
8028                 }
8029
8030                 if ( hooks && "get" in hooks && ( ret = hooks.get( elem, name ) ) !== null ) {
8031                         return ret;
8032                 }
8033
8034                 ret = jQuery.find.attr( elem, name );
8035
8036                 // Non-existent attributes return null, we normalize to undefined
8037                 return ret == null ? undefined : ret;
8038         },
8039
8040         attrHooks: {
8041                 type: {
8042                         set: function( elem, value ) {
8043                                 if ( !support.radioValue && value === "radio" &&
8044                                         nodeName( elem, "input" ) ) {
8045                                         var val = elem.value;
8046                                         elem.setAttribute( "type", value );
8047                                         if ( val ) {
8048                                                 elem.value = val;
8049                                         }
8050                                         return value;
8051                                 }
8052                         }
8053                 }
8054         },
8055
8056         removeAttr: function( elem, value ) {
8057                 var name,
8058                         i = 0,
8059
8060                         // Attribute names can contain non-HTML whitespace characters
8061                         // https://html.spec.whatwg.org/multipage/syntax.html#attributes-2
8062                         attrNames = value && value.match( rnothtmlwhite );
8063
8064                 if ( attrNames && elem.nodeType === 1 ) {
8065                         while ( ( name = attrNames[ i++ ] ) ) {
8066                                 elem.removeAttribute( name );
8067                         }
8068                 }
8069         }
8070 } );
8071
8072 // Hooks for boolean attributes
8073 boolHook = {
8074         set: function( elem, value, name ) {
8075                 if ( value === false ) {
8076
8077                         // Remove boolean attributes when set to false
8078                         jQuery.removeAttr( elem, name );
8079                 } else {
8080                         elem.setAttribute( name, name );
8081                 }
8082                 return name;
8083         }
8084 };
8085
8086 jQuery.each( jQuery.expr.match.bool.source.match( /\w+/g ), function( _i, name ) {
8087         var getter = attrHandle[ name ] || jQuery.find.attr;
8088
8089         attrHandle[ name ] = function( elem, name, isXML ) {
8090                 var ret, handle,
8091                         lowercaseName = name.toLowerCase();
8092
8093                 if ( !isXML ) {
8094
8095                         // Avoid an infinite loop by temporarily removing this function from the getter
8096                         handle = attrHandle[ lowercaseName ];
8097                         attrHandle[ lowercaseName ] = ret;
8098                         ret = getter( elem, name, isXML ) != null ?
8099                                 lowercaseName :
8100                                 null;
8101                         attrHandle[ lowercaseName ] = handle;
8102                 }
8103                 return ret;
8104         };
8105 } );
8106
8107
8108
8109
8110 var rfocusable = /^(?:input|select|textarea|button)$/i,
8111         rclickable = /^(?:a|area)$/i;
8112
8113 jQuery.fn.extend( {
8114         prop: function( name, value ) {
8115                 return access( this, jQuery.prop, name, value, arguments.length > 1 );
8116         },
8117
8118         removeProp: function( name ) {
8119                 return this.each( function() {
8120                         delete this[ jQuery.propFix[ name ] || name ];
8121                 } );
8122         }
8123 } );
8124
8125 jQuery.extend( {
8126         prop: function( elem, name, value ) {
8127                 var ret, hooks,
8128                         nType = elem.nodeType;
8129
8130                 // Don't get/set properties on text, comment and attribute nodes
8131                 if ( nType === 3 || nType === 8 || nType === 2 ) {
8132                         return;
8133                 }
8134
8135                 if ( nType !== 1 || !jQuery.isXMLDoc( elem ) ) {
8136
8137                         // Fix name and attach hooks
8138                         name = jQuery.propFix[ name ] || name;
8139                         hooks = jQuery.propHooks[ name ];
8140                 }
8141
8142                 if ( value !== undefined ) {
8143                         if ( hooks && "set" in hooks &&
8144                                 ( ret = hooks.set( elem, value, name ) ) !== undefined ) {
8145                                 return ret;
8146                         }
8147
8148                         return ( elem[ name ] = value );
8149                 }
8150
8151                 if ( hooks && "get" in hooks && ( ret = hooks.get( elem, name ) ) !== null ) {
8152                         return ret;
8153                 }
8154
8155                 return elem[ name ];
8156         },
8157
8158         propHooks: {
8159                 tabIndex: {
8160                         get: function( elem ) {
8161
8162                                 // Support: IE <=9 - 11 only
8163                                 // elem.tabIndex doesn't always return the
8164                                 // correct value when it hasn't been explicitly set
8165                                 // https://web.archive.org/web/20141116233347/http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/
8166                                 // Use proper attribute retrieval(#12072)
8167                                 var tabindex = jQuery.find.attr( elem, "tabindex" );
8168
8169                                 if ( tabindex ) {
8170                                         return parseInt( tabindex, 10 );
8171                                 }
8172
8173                                 if (
8174                                         rfocusable.test( elem.nodeName ) ||
8175                                         rclickable.test( elem.nodeName ) &&
8176                                         elem.href
8177                                 ) {
8178                                         return 0;
8179                                 }
8180
8181                                 return -1;
8182                         }
8183                 }
8184         },
8185
8186         propFix: {
8187                 "for": "htmlFor",
8188                 "class": "className"
8189         }
8190 } );
8191
8192 // Support: IE <=11 only
8193 // Accessing the selectedIndex property
8194 // forces the browser to respect setting selected
8195 // on the option
8196 // The getter ensures a default option is selected
8197 // when in an optgroup
8198 // eslint rule "no-unused-expressions" is disabled for this code
8199 // since it considers such accessions noop
8200 if ( !support.optSelected ) {
8201         jQuery.propHooks.selected = {
8202                 get: function( elem ) {
8203
8204                         /* eslint no-unused-expressions: "off" */
8205
8206                         var parent = elem.parentNode;
8207                         if ( parent && parent.parentNode ) {
8208                                 parent.parentNode.selectedIndex;
8209                         }
8210                         return null;
8211                 },
8212                 set: function( elem ) {
8213
8214                         /* eslint no-unused-expressions: "off" */
8215
8216                         var parent = elem.parentNode;
8217                         if ( parent ) {
8218                                 parent.selectedIndex;
8219
8220                                 if ( parent.parentNode ) {
8221                                         parent.parentNode.selectedIndex;
8222                                 }
8223                         }
8224                 }
8225         };
8226 }
8227
8228 jQuery.each( [
8229         "tabIndex",
8230         "readOnly",
8231         "maxLength",
8232         "cellSpacing",
8233         "cellPadding",
8234         "rowSpan",
8235         "colSpan",
8236         "useMap",
8237         "frameBorder",
8238         "contentEditable"
8239 ], function() {
8240         jQuery.propFix[ this.toLowerCase() ] = this;
8241 } );
8242
8243
8244
8245
8246         // Strip and collapse whitespace according to HTML spec
8247         // https://infra.spec.whatwg.org/#strip-and-collapse-ascii-whitespace
8248         function stripAndCollapse( value ) {
8249                 var tokens = value.match( rnothtmlwhite ) || [];
8250                 return tokens.join( " " );
8251         }
8252
8253
8254 function getClass( elem ) {
8255         return elem.getAttribute && elem.getAttribute( "class" ) || "";
8256 }
8257
8258 function classesToArray( value ) {
8259         if ( Array.isArray( value ) ) {
8260                 return value;
8261         }
8262         if ( typeof value === "string" ) {
8263                 return value.match( rnothtmlwhite ) || [];
8264         }
8265         return [];
8266 }
8267
8268 jQuery.fn.extend( {
8269         addClass: function( value ) {
8270                 var classes, elem, cur, curValue, clazz, j, finalValue,
8271                         i = 0;
8272
8273                 if ( isFunction( value ) ) {
8274                         return this.each( function( j ) {
8275                                 jQuery( this ).addClass( value.call( this, j, getClass( this ) ) );
8276                         } );
8277                 }
8278
8279                 classes = classesToArray( value );
8280
8281                 if ( classes.length ) {
8282                         while ( ( elem = this[ i++ ] ) ) {
8283                                 curValue = getClass( elem );
8284                                 cur = elem.nodeType === 1 && ( " " + stripAndCollapse( curValue ) + " " );
8285
8286                                 if ( cur ) {
8287                                         j = 0;
8288                                         while ( ( clazz = classes[ j++ ] ) ) {
8289                                                 if ( cur.indexOf( " " + clazz + " " ) < 0 ) {
8290                                                         cur += clazz + " ";
8291                                                 }
8292                                         }
8293
8294                                         // Only assign if different to avoid unneeded rendering.
8295                                         finalValue = stripAndCollapse( cur );
8296                                         if ( curValue !== finalValue ) {
8297                                                 elem.setAttribute( "class", finalValue );
8298                                         }
8299                                 }
8300                         }
8301                 }
8302
8303                 return this;
8304         },
8305
8306         removeClass: function( value ) {
8307                 var classes, elem, cur, curValue, clazz, j, finalValue,
8308                         i = 0;
8309
8310                 if ( isFunction( value ) ) {
8311                         return this.each( function( j ) {
8312                                 jQuery( this ).removeClass( value.call( this, j, getClass( this ) ) );
8313                         } );
8314                 }
8315
8316                 if ( !arguments.length ) {
8317                         return this.attr( "class", "" );
8318                 }
8319
8320                 classes = classesToArray( value );
8321
8322                 if ( classes.length ) {
8323                         while ( ( elem = this[ i++ ] ) ) {
8324                                 curValue = getClass( elem );
8325
8326                                 // This expression is here for better compressibility (see addClass)
8327                                 cur = elem.nodeType === 1 && ( " " + stripAndCollapse( curValue ) + " " );
8328
8329                                 if ( cur ) {
8330                                         j = 0;
8331                                         while ( ( clazz = classes[ j++ ] ) ) {
8332
8333                                                 // Remove *all* instances
8334                                                 while ( cur.indexOf( " " + clazz + " " ) > -1 ) {
8335                                                         cur = cur.replace( " " + clazz + " ", " " );
8336                                                 }
8337                                         }
8338
8339                                         // Only assign if different to avoid unneeded rendering.
8340                                         finalValue = stripAndCollapse( cur );
8341                                         if ( curValue !== finalValue ) {
8342                                                 elem.setAttribute( "class", finalValue );
8343                                         }
8344                                 }
8345                         }
8346                 }
8347
8348                 return this;
8349         },
8350
8351         toggleClass: function( value, stateVal ) {
8352                 var type = typeof value,
8353                         isValidValue = type === "string" || Array.isArray( value );
8354
8355                 if ( typeof stateVal === "boolean" && isValidValue ) {
8356                         return stateVal ? this.addClass( value ) : this.removeClass( value );
8357                 }
8358
8359                 if ( isFunction( value ) ) {
8360                         return this.each( function( i ) {
8361                                 jQuery( this ).toggleClass(
8362                                         value.call( this, i, getClass( this ), stateVal ),
8363                                         stateVal
8364                                 );
8365                         } );
8366                 }
8367
8368                 return this.each( function() {
8369                         var className, i, self, classNames;
8370
8371                         if ( isValidValue ) {
8372
8373                                 // Toggle individual class names
8374                                 i = 0;
8375                                 self = jQuery( this );
8376                                 classNames = classesToArray( value );
8377
8378                                 while ( ( className = classNames[ i++ ] ) ) {
8379
8380                                         // Check each className given, space separated list
8381                                         if ( self.hasClass( className ) ) {
8382                                                 self.removeClass( className );
8383                                         } else {
8384                                                 self.addClass( className );
8385                                         }
8386                                 }
8387
8388                         // Toggle whole class name
8389                         } else if ( value === undefined || type === "boolean" ) {
8390                                 className = getClass( this );
8391                                 if ( className ) {
8392
8393                                         // Store className if set
8394                                         dataPriv.set( this, "__className__", className );
8395                                 }
8396
8397                                 // If the element has a class name or if we're passed `false`,
8398                                 // then remove the whole classname (if there was one, the above saved it).
8399                                 // Otherwise bring back whatever was previously saved (if anything),
8400                                 // falling back to the empty string if nothing was stored.
8401                                 if ( this.setAttribute ) {
8402                                         this.setAttribute( "class",
8403                                                 className || value === false ?
8404                                                 "" :
8405                                                 dataPriv.get( this, "__className__" ) || ""
8406                                         );
8407                                 }
8408                         }
8409                 } );
8410         },
8411
8412         hasClass: function( selector ) {
8413                 var className, elem,
8414                         i = 0;
8415
8416                 className = " " + selector + " ";
8417                 while ( ( elem = this[ i++ ] ) ) {
8418                         if ( elem.nodeType === 1 &&
8419                                 ( " " + stripAndCollapse( getClass( elem ) ) + " " ).indexOf( className ) > -1 ) {
8420                                         return true;
8421                         }
8422                 }
8423
8424                 return false;
8425         }
8426 } );
8427
8428
8429
8430
8431 var rreturn = /\r/g;
8432
8433 jQuery.fn.extend( {
8434         val: function( value ) {
8435                 var hooks, ret, valueIsFunction,
8436                         elem = this[ 0 ];
8437
8438                 if ( !arguments.length ) {
8439                         if ( elem ) {
8440                                 hooks = jQuery.valHooks[ elem.type ] ||
8441                                         jQuery.valHooks[ elem.nodeName.toLowerCase() ];
8442
8443                                 if ( hooks &&
8444                                         "get" in hooks &&
8445                                         ( ret = hooks.get( elem, "value" ) ) !== undefined
8446                                 ) {
8447                                         return ret;
8448                                 }
8449
8450                                 ret = elem.value;
8451
8452                                 // Handle most common string cases
8453                                 if ( typeof ret === "string" ) {
8454                                         return ret.replace( rreturn, "" );
8455                                 }
8456
8457                                 // Handle cases where value is null/undef or number
8458                                 return ret == null ? "" : ret;
8459                         }
8460
8461                         return;
8462                 }
8463
8464                 valueIsFunction = isFunction( value );
8465
8466                 return this.each( function( i ) {
8467                         var val;
8468
8469                         if ( this.nodeType !== 1 ) {
8470                                 return;
8471                         }
8472
8473                         if ( valueIsFunction ) {
8474                                 val = value.call( this, i, jQuery( this ).val() );
8475                         } else {
8476                                 val = value;
8477                         }
8478
8479                         // Treat null/undefined as ""; convert numbers to string
8480                         if ( val == null ) {
8481                                 val = "";
8482
8483                         } else if ( typeof val === "number" ) {
8484                                 val += "";
8485
8486                         } else if ( Array.isArray( val ) ) {
8487                                 val = jQuery.map( val, function( value ) {
8488                                         return value == null ? "" : value + "";
8489                                 } );
8490                         }
8491
8492                         hooks = jQuery.valHooks[ this.type ] || jQuery.valHooks[ this.nodeName.toLowerCase() ];
8493
8494                         // If set returns undefined, fall back to normal setting
8495                         if ( !hooks || !( "set" in hooks ) || hooks.set( this, val, "value" ) === undefined ) {
8496                                 this.value = val;
8497                         }
8498                 } );
8499         }
8500 } );
8501
8502 jQuery.extend( {
8503         valHooks: {
8504                 option: {
8505                         get: function( elem ) {
8506
8507                                 var val = jQuery.find.attr( elem, "value" );
8508                                 return val != null ?
8509                                         val :
8510
8511                                         // Support: IE <=10 - 11 only
8512                                         // option.text throws exceptions (#14686, #14858)
8513                                         // Strip and collapse whitespace
8514                                         // https://html.spec.whatwg.org/#strip-and-collapse-whitespace
8515                                         stripAndCollapse( jQuery.text( elem ) );
8516                         }
8517                 },
8518                 select: {
8519                         get: function( elem ) {
8520                                 var value, option, i,
8521                                         options = elem.options,
8522                                         index = elem.selectedIndex,
8523                                         one = elem.type === "select-one",
8524                                         values = one ? null : [],
8525                                         max = one ? index + 1 : options.length;
8526
8527                                 if ( index < 0 ) {
8528                                         i = max;
8529
8530                                 } else {
8531                                         i = one ? index : 0;
8532                                 }
8533
8534                                 // Loop through all the selected options
8535                                 for ( ; i < max; i++ ) {
8536                                         option = options[ i ];
8537
8538                                         // Support: IE <=9 only
8539                                         // IE8-9 doesn't update selected after form reset (#2551)
8540                                         if ( ( option.selected || i === index ) &&
8541
8542                                                         // Don't return options that are disabled or in a disabled optgroup
8543                                                         !option.disabled &&
8544                                                         ( !option.parentNode.disabled ||
8545                                                                 !nodeName( option.parentNode, "optgroup" ) ) ) {
8546
8547                                                 // Get the specific value for the option
8548                                                 value = jQuery( option ).val();
8549
8550                                                 // We don't need an array for one selects
8551                                                 if ( one ) {
8552                                                         return value;
8553                                                 }
8554
8555                                                 // Multi-Selects return an array
8556                                                 values.push( value );
8557                                         }
8558                                 }
8559
8560                                 return values;
8561                         },
8562
8563                         set: function( elem, value ) {
8564                                 var optionSet, option,
8565                                         options = elem.options,
8566                                         values = jQuery.makeArray( value ),
8567                                         i = options.length;
8568
8569                                 while ( i-- ) {
8570                                         option = options[ i ];
8571
8572                                         /* eslint-disable no-cond-assign */
8573
8574                                         if ( option.selected =
8575                                                 jQuery.inArray( jQuery.valHooks.option.get( option ), values ) > -1
8576                                         ) {
8577                                                 optionSet = true;
8578                                         }
8579
8580                                         /* eslint-enable no-cond-assign */
8581                                 }
8582
8583                                 // Force browsers to behave consistently when non-matching value is set
8584                                 if ( !optionSet ) {
8585                                         elem.selectedIndex = -1;
8586                                 }
8587                                 return values;
8588                         }
8589                 }
8590         }
8591 } );
8592
8593 // Radios and checkboxes getter/setter
8594 jQuery.each( [ "radio", "checkbox" ], function() {
8595         jQuery.valHooks[ this ] = {
8596                 set: function( elem, value ) {
8597                         if ( Array.isArray( value ) ) {
8598                                 return ( elem.checked = jQuery.inArray( jQuery( elem ).val(), value ) > -1 );
8599                         }
8600                 }
8601         };
8602         if ( !support.checkOn ) {
8603                 jQuery.valHooks[ this ].get = function( elem ) {
8604                         return elem.getAttribute( "value" ) === null ? "on" : elem.value;
8605                 };
8606         }
8607 } );
8608
8609
8610
8611
8612 // Return jQuery for attributes-only inclusion
8613
8614
8615 support.focusin = "onfocusin" in window;
8616
8617
8618 var rfocusMorph = /^(?:focusinfocus|focusoutblur)$/,
8619         stopPropagationCallback = function( e ) {
8620                 e.stopPropagation();
8621         };
8622
8623 jQuery.extend( jQuery.event, {
8624
8625         trigger: function( event, data, elem, onlyHandlers ) {
8626
8627                 var i, cur, tmp, bubbleType, ontype, handle, special, lastElement,
8628                         eventPath = [ elem || document ],
8629                         type = hasOwn.call( event, "type" ) ? event.type : event,
8630                         namespaces = hasOwn.call( event, "namespace" ) ? event.namespace.split( "." ) : [];
8631
8632                 cur = lastElement = tmp = elem = elem || document;
8633
8634                 // Don't do events on text and comment nodes
8635                 if ( elem.nodeType === 3 || elem.nodeType === 8 ) {
8636                         return;
8637                 }
8638
8639                 // focus/blur morphs to focusin/out; ensure we're not firing them right now
8640                 if ( rfocusMorph.test( type + jQuery.event.triggered ) ) {
8641                         return;
8642                 }
8643
8644                 if ( type.indexOf( "." ) > -1 ) {
8645
8646                         // Namespaced trigger; create a regexp to match event type in handle()
8647                         namespaces = type.split( "." );
8648                         type = namespaces.shift();
8649                         namespaces.sort();
8650                 }
8651                 ontype = type.indexOf( ":" ) < 0 && "on" + type;
8652
8653                 // Caller can pass in a jQuery.Event object, Object, or just an event type string
8654                 event = event[ jQuery.expando ] ?
8655                         event :
8656                         new jQuery.Event( type, typeof event === "object" && event );
8657
8658                 // Trigger bitmask: & 1 for native handlers; & 2 for jQuery (always true)
8659                 event.isTrigger = onlyHandlers ? 2 : 3;
8660                 event.namespace = namespaces.join( "." );
8661                 event.rnamespace = event.namespace ?
8662                         new RegExp( "(^|\\.)" + namespaces.join( "\\.(?:.*\\.|)" ) + "(\\.|$)" ) :
8663                         null;
8664
8665                 // Clean up the event in case it is being reused
8666                 event.result = undefined;
8667                 if ( !event.target ) {
8668                         event.target = elem;
8669                 }
8670
8671                 // Clone any incoming data and prepend the event, creating the handler arg list
8672                 data = data == null ?
8673                         [ event ] :
8674                         jQuery.makeArray( data, [ event ] );
8675
8676                 // Allow special events to draw outside the lines
8677                 special = jQuery.event.special[ type ] || {};
8678                 if ( !onlyHandlers && special.trigger && special.trigger.apply( elem, data ) === false ) {
8679                         return;
8680                 }
8681
8682                 // Determine event propagation path in advance, per W3C events spec (#9951)
8683                 // Bubble up to document, then to window; watch for a global ownerDocument var (#9724)
8684                 if ( !onlyHandlers && !special.noBubble && !isWindow( elem ) ) {
8685
8686                         bubbleType = special.delegateType || type;
8687                         if ( !rfocusMorph.test( bubbleType + type ) ) {
8688                                 cur = cur.parentNode;
8689                         }
8690                         for ( ; cur; cur = cur.parentNode ) {
8691                                 eventPath.push( cur );
8692                                 tmp = cur;
8693                         }
8694
8695                         // Only add window if we got to document (e.g., not plain obj or detached DOM)
8696                         if ( tmp === ( elem.ownerDocument || document ) ) {
8697                                 eventPath.push( tmp.defaultView || tmp.parentWindow || window );
8698                         }
8699                 }
8700
8701                 // Fire handlers on the event path
8702                 i = 0;
8703                 while ( ( cur = eventPath[ i++ ] ) && !event.isPropagationStopped() ) {
8704                         lastElement = cur;
8705                         event.type = i > 1 ?
8706                                 bubbleType :
8707                                 special.bindType || type;
8708
8709                         // jQuery handler
8710                         handle = (
8711                                         dataPriv.get( cur, "events" ) || Object.create( null )
8712                                 )[ event.type ] &&
8713                                 dataPriv.get( cur, "handle" );
8714                         if ( handle ) {
8715                                 handle.apply( cur, data );
8716                         }
8717
8718                         // Native handler
8719                         handle = ontype && cur[ ontype ];
8720                         if ( handle && handle.apply && acceptData( cur ) ) {
8721                                 event.result = handle.apply( cur, data );
8722                                 if ( event.result === false ) {
8723                                         event.preventDefault();
8724                                 }
8725                         }
8726                 }
8727                 event.type = type;
8728
8729                 // If nobody prevented the default action, do it now
8730                 if ( !onlyHandlers && !event.isDefaultPrevented() ) {
8731
8732                         if ( ( !special._default ||
8733                                 special._default.apply( eventPath.pop(), data ) === false ) &&
8734                                 acceptData( elem ) ) {
8735
8736                                 // Call a native DOM method on the target with the same name as the event.
8737                                 // Don't do default actions on window, that's where global variables be (#6170)
8738                                 if ( ontype && isFunction( elem[ type ] ) && !isWindow( elem ) ) {
8739
8740                                         // Don't re-trigger an onFOO event when we call its FOO() method
8741                                         tmp = elem[ ontype ];
8742
8743                                         if ( tmp ) {
8744                                                 elem[ ontype ] = null;
8745                                         }
8746
8747                                         // Prevent re-triggering of the same event, since we already bubbled it above
8748                                         jQuery.event.triggered = type;
8749
8750                                         if ( event.isPropagationStopped() ) {
8751                                                 lastElement.addEventListener( type, stopPropagationCallback );
8752                                         }
8753
8754                                         elem[ type ]();
8755
8756                                         if ( event.isPropagationStopped() ) {
8757                                                 lastElement.removeEventListener( type, stopPropagationCallback );
8758                                         }
8759
8760                                         jQuery.event.triggered = undefined;
8761
8762                                         if ( tmp ) {
8763                                                 elem[ ontype ] = tmp;
8764                                         }
8765                                 }
8766                         }
8767                 }
8768
8769                 return event.result;
8770         },
8771
8772         // Piggyback on a donor event to simulate a different one
8773         // Used only for `focus(in | out)` events
8774         simulate: function( type, elem, event ) {
8775                 var e = jQuery.extend(
8776                         new jQuery.Event(),
8777                         event,
8778                         {
8779                                 type: type,
8780                                 isSimulated: true
8781                         }
8782                 );
8783
8784                 jQuery.event.trigger( e, null, elem );
8785         }
8786
8787 } );
8788
8789 jQuery.fn.extend( {
8790
8791         trigger: function( type, data ) {
8792                 return this.each( function() {
8793                         jQuery.event.trigger( type, data, this );
8794                 } );
8795         },
8796         triggerHandler: function( type, data ) {
8797                 var elem = this[ 0 ];
8798                 if ( elem ) {
8799                         return jQuery.event.trigger( type, data, elem, true );
8800                 }
8801         }
8802 } );
8803
8804
8805 // Support: Firefox <=44
8806 // Firefox doesn't have focus(in | out) events
8807 // Related ticket - https://bugzilla.mozilla.org/show_bug.cgi?id=687787
8808 //
8809 // Support: Chrome <=48 - 49, Safari <=9.0 - 9.1
8810 // focus(in | out) events fire after focus & blur events,
8811 // which is spec violation - http://www.w3.org/TR/DOM-Level-3-Events/#events-focusevent-event-order
8812 // Related ticket - https://bugs.chromium.org/p/chromium/issues/detail?id=449857
8813 if ( !support.focusin ) {
8814         jQuery.each( { focus: "focusin", blur: "focusout" }, function( orig, fix ) {
8815
8816                 // Attach a single capturing handler on the document while someone wants focusin/focusout
8817                 var handler = function( event ) {
8818                         jQuery.event.simulate( fix, event.target, jQuery.event.fix( event ) );
8819                 };
8820
8821                 jQuery.event.special[ fix ] = {
8822                         setup: function() {
8823
8824                                 // Handle: regular nodes (via `this.ownerDocument`), window
8825                                 // (via `this.document`) & document (via `this`).
8826                                 var doc = this.ownerDocument || this.document || this,
8827                                         attaches = dataPriv.access( doc, fix );
8828
8829                                 if ( !attaches ) {
8830                                         doc.addEventListener( orig, handler, true );
8831                                 }
8832                                 dataPriv.access( doc, fix, ( attaches || 0 ) + 1 );
8833                         },
8834                         teardown: function() {
8835                                 var doc = this.ownerDocument || this.document || this,
8836                                         attaches = dataPriv.access( doc, fix ) - 1;
8837
8838                                 if ( !attaches ) {
8839                                         doc.removeEventListener( orig, handler, true );
8840                                         dataPriv.remove( doc, fix );
8841
8842                                 } else {
8843                                         dataPriv.access( doc, fix, attaches );
8844                                 }
8845                         }
8846                 };
8847         } );
8848 }
8849 var location = window.location;
8850
8851 var nonce = { guid: Date.now() };
8852
8853 var rquery = ( /\?/ );
8854
8855
8856
8857 // Cross-browser xml parsing
8858 jQuery.parseXML = function( data ) {
8859         var xml;
8860         if ( !data || typeof data !== "string" ) {
8861                 return null;
8862         }
8863
8864         // Support: IE 9 - 11 only
8865         // IE throws on parseFromString with invalid input.
8866         try {
8867                 xml = ( new window.DOMParser() ).parseFromString( data, "text/xml" );
8868         } catch ( e ) {
8869                 xml = undefined;
8870         }
8871
8872         if ( !xml || xml.getElementsByTagName( "parsererror" ).length ) {
8873                 jQuery.error( "Invalid XML: " + data );
8874         }
8875         return xml;
8876 };
8877
8878
8879 var
8880         rbracket = /\[\]$/,
8881         rCRLF = /\r?\n/g,
8882         rsubmitterTypes = /^(?:submit|button|image|reset|file)$/i,
8883         rsubmittable = /^(?:input|select|textarea|keygen)/i;
8884
8885 function buildParams( prefix, obj, traditional, add ) {
8886         var name;
8887
8888         if ( Array.isArray( obj ) ) {
8889
8890                 // Serialize array item.
8891                 jQuery.each( obj, function( i, v ) {
8892                         if ( traditional || rbracket.test( prefix ) ) {
8893
8894                                 // Treat each array item as a scalar.
8895                                 add( prefix, v );
8896
8897                         } else {
8898
8899                                 // Item is non-scalar (array or object), encode its numeric index.
8900                                 buildParams(
8901                                         prefix + "[" + ( typeof v === "object" && v != null ? i : "" ) + "]",
8902                                         v,
8903                                         traditional,
8904                                         add
8905                                 );
8906                         }
8907                 } );
8908
8909         } else if ( !traditional && toType( obj ) === "object" ) {
8910
8911                 // Serialize object item.
8912                 for ( name in obj ) {
8913                         buildParams( prefix + "[" + name + "]", obj[ name ], traditional, add );
8914                 }
8915
8916         } else {
8917
8918                 // Serialize scalar item.
8919                 add( prefix, obj );
8920         }
8921 }
8922
8923 // Serialize an array of form elements or a set of
8924 // key/values into a query string
8925 jQuery.param = function( a, traditional ) {
8926         var prefix,
8927                 s = [],
8928                 add = function( key, valueOrFunction ) {
8929
8930                         // If value is a function, invoke it and use its return value
8931                         var value = isFunction( valueOrFunction ) ?
8932                                 valueOrFunction() :
8933                                 valueOrFunction;
8934
8935                         s[ s.length ] = encodeURIComponent( key ) + "=" +
8936                                 encodeURIComponent( value == null ? "" : value );
8937                 };
8938
8939         if ( a == null ) {
8940                 return "";
8941         }
8942
8943         // If an array was passed in, assume that it is an array of form elements.
8944         if ( Array.isArray( a ) || ( a.jquery && !jQuery.isPlainObject( a ) ) ) {
8945
8946                 // Serialize the form elements
8947                 jQuery.each( a, function() {
8948                         add( this.name, this.value );
8949                 } );
8950
8951         } else {
8952
8953                 // If traditional, encode the "old" way (the way 1.3.2 or older
8954                 // did it), otherwise encode params recursively.
8955                 for ( prefix in a ) {
8956                         buildParams( prefix, a[ prefix ], traditional, add );
8957                 }
8958         }
8959
8960         // Return the resulting serialization
8961         return s.join( "&" );
8962 };
8963
8964 jQuery.fn.extend( {
8965         serialize: function() {
8966                 return jQuery.param( this.serializeArray() );
8967         },
8968         serializeArray: function() {
8969                 return this.map( function() {
8970
8971                         // Can add propHook for "elements" to filter or add form elements
8972                         var elements = jQuery.prop( this, "elements" );
8973                         return elements ? jQuery.makeArray( elements ) : this;
8974                 } )
8975                 .filter( function() {
8976                         var type = this.type;
8977
8978                         // Use .is( ":disabled" ) so that fieldset[disabled] works
8979                         return this.name && !jQuery( this ).is( ":disabled" ) &&
8980                                 rsubmittable.test( this.nodeName ) && !rsubmitterTypes.test( type ) &&
8981                                 ( this.checked || !rcheckableType.test( type ) );
8982                 } )
8983                 .map( function( _i, elem ) {
8984                         var val = jQuery( this ).val();
8985
8986                         if ( val == null ) {
8987                                 return null;
8988                         }
8989
8990                         if ( Array.isArray( val ) ) {
8991                                 return jQuery.map( val, function( val ) {
8992                                         return { name: elem.name, value: val.replace( rCRLF, "\r\n" ) };
8993                                 } );
8994                         }
8995
8996                         return { name: elem.name, value: val.replace( rCRLF, "\r\n" ) };
8997                 } ).get();
8998         }
8999 } );
9000
9001
9002 var
9003         r20 = /%20/g,
9004         rhash = /#.*$/,
9005         rantiCache = /([?&])_=[^&]*/,
9006         rheaders = /^(.*?):[ \t]*([^\r\n]*)$/mg,
9007
9008         // #7653, #8125, #8152: local protocol detection
9009         rlocalProtocol = /^(?:about|app|app-storage|.+-extension|file|res|widget):$/,
9010         rnoContent = /^(?:GET|HEAD)$/,
9011         rprotocol = /^\/\//,
9012
9013         /* Prefilters
9014          * 1) They are useful to introduce custom dataTypes (see ajax/jsonp.js for an example)
9015          * 2) These are called:
9016          *    - BEFORE asking for a transport
9017          *    - AFTER param serialization (s.data is a string if s.processData is true)
9018          * 3) key is the dataType
9019          * 4) the catchall symbol "*" can be used
9020          * 5) execution will start with transport dataType and THEN continue down to "*" if needed
9021          */
9022         prefilters = {},
9023
9024         /* Transports bindings
9025          * 1) key is the dataType
9026          * 2) the catchall symbol "*" can be used
9027          * 3) selection will start with transport dataType and THEN go to "*" if needed
9028          */
9029         transports = {},
9030
9031         // Avoid comment-prolog char sequence (#10098); must appease lint and evade compression
9032         allTypes = "*/".concat( "*" ),
9033
9034         // Anchor tag for parsing the document origin
9035         originAnchor = document.createElement( "a" );
9036         originAnchor.href = location.href;
9037
9038 // Base "constructor" for jQuery.ajaxPrefilter and jQuery.ajaxTransport
9039 function addToPrefiltersOrTransports( structure ) {
9040
9041         // dataTypeExpression is optional and defaults to "*"
9042         return function( dataTypeExpression, func ) {
9043
9044                 if ( typeof dataTypeExpression !== "string" ) {
9045                         func = dataTypeExpression;
9046                         dataTypeExpression = "*";
9047                 }
9048
9049                 var dataType,
9050                         i = 0,
9051                         dataTypes = dataTypeExpression.toLowerCase().match( rnothtmlwhite ) || [];
9052
9053                 if ( isFunction( func ) ) {
9054
9055                         // For each dataType in the dataTypeExpression
9056                         while ( ( dataType = dataTypes[ i++ ] ) ) {
9057
9058                                 // Prepend if requested
9059                                 if ( dataType[ 0 ] === "+" ) {
9060                                         dataType = dataType.slice( 1 ) || "*";
9061                                         ( structure[ dataType ] = structure[ dataType ] || [] ).unshift( func );
9062
9063                                 // Otherwise append
9064                                 } else {
9065                                         ( structure[ dataType ] = structure[ dataType ] || [] ).push( func );
9066                                 }
9067                         }
9068                 }
9069         };
9070 }
9071
9072 // Base inspection function for prefilters and transports
9073 function inspectPrefiltersOrTransports( structure, options, originalOptions, jqXHR ) {
9074
9075         var inspected = {},
9076                 seekingTransport = ( structure === transports );
9077
9078         function inspect( dataType ) {
9079                 var selected;
9080                 inspected[ dataType ] = true;
9081                 jQuery.each( structure[ dataType ] || [], function( _, prefilterOrFactory ) {
9082                         var dataTypeOrTransport = prefilterOrFactory( options, originalOptions, jqXHR );
9083                         if ( typeof dataTypeOrTransport === "string" &&
9084                                 !seekingTransport && !inspected[ dataTypeOrTransport ] ) {
9085
9086                                 options.dataTypes.unshift( dataTypeOrTransport );
9087                                 inspect( dataTypeOrTransport );
9088                                 return false;
9089                         } else if ( seekingTransport ) {
9090                                 return !( selected = dataTypeOrTransport );
9091                         }
9092                 } );
9093                 return selected;
9094         }
9095
9096         return inspect( options.dataTypes[ 0 ] ) || !inspected[ "*" ] && inspect( "*" );
9097 }
9098
9099 // A special extend for ajax options
9100 // that takes "flat" options (not to be deep extended)
9101 // Fixes #9887
9102 function ajaxExtend( target, src ) {
9103         var key, deep,
9104                 flatOptions = jQuery.ajaxSettings.flatOptions || {};
9105
9106         for ( key in src ) {
9107                 if ( src[ key ] !== undefined ) {
9108                         ( flatOptions[ key ] ? target : ( deep || ( deep = {} ) ) )[ key ] = src[ key ];
9109                 }
9110         }
9111         if ( deep ) {
9112                 jQuery.extend( true, target, deep );
9113         }
9114
9115         return target;
9116 }
9117
9118 /* Handles responses to an ajax request:
9119  * - finds the right dataType (mediates between content-type and expected dataType)
9120  * - returns the corresponding response
9121  */
9122 function ajaxHandleResponses( s, jqXHR, responses ) {
9123
9124         var ct, type, finalDataType, firstDataType,
9125                 contents = s.contents,
9126                 dataTypes = s.dataTypes;
9127
9128         // Remove auto dataType and get content-type in the process
9129         while ( dataTypes[ 0 ] === "*" ) {
9130                 dataTypes.shift();
9131                 if ( ct === undefined ) {
9132                         ct = s.mimeType || jqXHR.getResponseHeader( "Content-Type" );
9133                 }
9134         }
9135
9136         // Check if we're dealing with a known content-type
9137         if ( ct ) {
9138                 for ( type in contents ) {
9139                         if ( contents[ type ] && contents[ type ].test( ct ) ) {
9140                                 dataTypes.unshift( type );
9141                                 break;
9142                         }
9143                 }
9144         }
9145
9146         // Check to see if we have a response for the expected dataType
9147         if ( dataTypes[ 0 ] in responses ) {
9148                 finalDataType = dataTypes[ 0 ];
9149         } else {
9150
9151                 // Try convertible dataTypes
9152                 for ( type in responses ) {
9153                         if ( !dataTypes[ 0 ] || s.converters[ type + " " + dataTypes[ 0 ] ] ) {
9154                                 finalDataType = type;
9155                                 break;
9156                         }
9157                         if ( !firstDataType ) {
9158                                 firstDataType = type;
9159                         }
9160                 }
9161
9162                 // Or just use first one
9163                 finalDataType = finalDataType || firstDataType;
9164         }
9165
9166         // If we found a dataType
9167         // We add the dataType to the list if needed
9168         // and return the corresponding response
9169         if ( finalDataType ) {
9170                 if ( finalDataType !== dataTypes[ 0 ] ) {
9171                         dataTypes.unshift( finalDataType );
9172                 }
9173                 return responses[ finalDataType ];
9174         }
9175 }
9176
9177 /* Chain conversions given the request and the original response
9178  * Also sets the responseXXX fields on the jqXHR instance
9179  */
9180 function ajaxConvert( s, response, jqXHR, isSuccess ) {
9181         var conv2, current, conv, tmp, prev,
9182                 converters = {},
9183
9184                 // Work with a copy of dataTypes in case we need to modify it for conversion
9185                 dataTypes = s.dataTypes.slice();
9186
9187         // Create converters map with lowercased keys
9188         if ( dataTypes[ 1 ] ) {
9189                 for ( conv in s.converters ) {
9190                         converters[ conv.toLowerCase() ] = s.converters[ conv ];
9191                 }
9192         }
9193
9194         current = dataTypes.shift();
9195
9196         // Convert to each sequential dataType
9197         while ( current ) {
9198
9199                 if ( s.responseFields[ current ] ) {
9200                         jqXHR[ s.responseFields[ current ] ] = response;
9201                 }
9202
9203                 // Apply the dataFilter if provided
9204                 if ( !prev && isSuccess && s.dataFilter ) {
9205                         response = s.dataFilter( response, s.dataType );
9206                 }
9207
9208                 prev = current;
9209                 current = dataTypes.shift();
9210
9211                 if ( current ) {
9212
9213                         // There's only work to do if current dataType is non-auto
9214                         if ( current === "*" ) {
9215
9216                                 current = prev;
9217
9218                         // Convert response if prev dataType is non-auto and differs from current
9219                         } else if ( prev !== "*" && prev !== current ) {
9220
9221                                 // Seek a direct converter
9222                                 conv = converters[ prev + " " + current ] || converters[ "* " + current ];
9223
9224                                 // If none found, seek a pair
9225                                 if ( !conv ) {
9226                                         for ( conv2 in converters ) {
9227
9228                                                 // If conv2 outputs current
9229                                                 tmp = conv2.split( " " );
9230                                                 if ( tmp[ 1 ] === current ) {
9231
9232                                                         // If prev can be converted to accepted input
9233                                                         conv = converters[ prev + " " + tmp[ 0 ] ] ||
9234                                                                 converters[ "* " + tmp[ 0 ] ];
9235                                                         if ( conv ) {
9236
9237                                                                 // Condense equivalence converters
9238                                                                 if ( conv === true ) {
9239                                                                         conv = converters[ conv2 ];
9240
9241                                                                 // Otherwise, insert the intermediate dataType
9242                                                                 } else if ( converters[ conv2 ] !== true ) {
9243                                                                         current = tmp[ 0 ];
9244                                                                         dataTypes.unshift( tmp[ 1 ] );
9245                                                                 }
9246                                                                 break;
9247                                                         }
9248                                                 }
9249                                         }
9250                                 }
9251
9252                                 // Apply converter (if not an equivalence)
9253                                 if ( conv !== true ) {
9254
9255                                         // Unless errors are allowed to bubble, catch and return them
9256                                         if ( conv && s.throws ) {
9257                                                 response = conv( response );
9258                                         } else {
9259                                                 try {
9260                                                         response = conv( response );
9261                                                 } catch ( e ) {
9262                                                         return {
9263                                                                 state: "parsererror",
9264                                                                 error: conv ? e : "No conversion from " + prev + " to " + current
9265                                                         };
9266                                                 }
9267                                         }
9268                                 }
9269                         }
9270                 }
9271         }
9272
9273         return { state: "success", data: response };
9274 }
9275
9276 jQuery.extend( {
9277
9278         // Counter for holding the number of active queries
9279         active: 0,
9280
9281         // Last-Modified header cache for next request
9282         lastModified: {},
9283         etag: {},
9284
9285         ajaxSettings: {
9286                 url: location.href,
9287                 type: "GET",
9288                 isLocal: rlocalProtocol.test( location.protocol ),
9289                 global: true,
9290                 processData: true,
9291                 async: true,
9292                 contentType: "application/x-www-form-urlencoded; charset=UTF-8",
9293
9294                 /*
9295                 timeout: 0,
9296                 data: null,
9297                 dataType: null,
9298                 username: null,
9299                 password: null,
9300                 cache: null,
9301                 throws: false,
9302                 traditional: false,
9303                 headers: {},
9304                 */
9305
9306                 accepts: {
9307                         "*": allTypes,
9308                         text: "text/plain",
9309                         html: "text/html",
9310                         xml: "application/xml, text/xml",
9311                         json: "application/json, text/javascript"
9312                 },
9313
9314                 contents: {
9315                         xml: /\bxml\b/,
9316                         html: /\bhtml/,
9317                         json: /\bjson\b/
9318                 },
9319
9320                 responseFields: {
9321                         xml: "responseXML",
9322                         text: "responseText",
9323                         json: "responseJSON"
9324                 },
9325
9326                 // Data converters
9327                 // Keys separate source (or catchall "*") and destination types with a single space
9328                 converters: {
9329
9330                         // Convert anything to text
9331                         "* text": String,
9332
9333                         // Text to html (true = no transformation)
9334                         "text html": true,
9335
9336                         // Evaluate text as a json expression
9337                         "text json": JSON.parse,
9338
9339                         // Parse text as xml
9340                         "text xml": jQuery.parseXML
9341                 },
9342
9343                 // For options that shouldn't be deep extended:
9344                 // you can add your own custom options here if
9345                 // and when you create one that shouldn't be
9346                 // deep extended (see ajaxExtend)
9347                 flatOptions: {
9348                         url: true,
9349                         context: true
9350                 }
9351         },
9352
9353         // Creates a full fledged settings object into target
9354         // with both ajaxSettings and settings fields.
9355         // If target is omitted, writes into ajaxSettings.
9356         ajaxSetup: function( target, settings ) {
9357                 return settings ?
9358
9359                         // Building a settings object
9360                         ajaxExtend( ajaxExtend( target, jQuery.ajaxSettings ), settings ) :
9361
9362                         // Extending ajaxSettings
9363                         ajaxExtend( jQuery.ajaxSettings, target );
9364         },
9365
9366         ajaxPrefilter: addToPrefiltersOrTransports( prefilters ),
9367         ajaxTransport: addToPrefiltersOrTransports( transports ),
9368
9369         // Main method
9370         ajax: function( url, options ) {
9371
9372                 // If url is an object, simulate pre-1.5 signature
9373                 if ( typeof url === "object" ) {
9374                         options = url;
9375                         url = undefined;
9376                 }
9377
9378                 // Force options to be an object
9379                 options = options || {};
9380
9381                 var transport,
9382
9383                         // URL without anti-cache param
9384                         cacheURL,
9385
9386                         // Response headers
9387                         responseHeadersString,
9388                         responseHeaders,
9389
9390                         // timeout handle
9391                         timeoutTimer,
9392
9393                         // Url cleanup var
9394                         urlAnchor,
9395
9396                         // Request state (becomes false upon send and true upon completion)
9397                         completed,
9398
9399                         // To know if global events are to be dispatched
9400                         fireGlobals,
9401
9402                         // Loop variable
9403                         i,
9404
9405                         // uncached part of the url
9406                         uncached,
9407
9408                         // Create the final options object
9409                         s = jQuery.ajaxSetup( {}, options ),
9410
9411                         // Callbacks context
9412                         callbackContext = s.context || s,
9413
9414                         // Context for global events is callbackContext if it is a DOM node or jQuery collection
9415                         globalEventContext = s.context &&
9416                                 ( callbackContext.nodeType || callbackContext.jquery ) ?
9417                                         jQuery( callbackContext ) :
9418                                         jQuery.event,
9419
9420                         // Deferreds
9421                         deferred = jQuery.Deferred(),
9422                         completeDeferred = jQuery.Callbacks( "once memory" ),
9423
9424                         // Status-dependent callbacks
9425                         statusCode = s.statusCode || {},
9426
9427                         // Headers (they are sent all at once)
9428                         requestHeaders = {},
9429                         requestHeadersNames = {},
9430
9431                         // Default abort message
9432                         strAbort = "canceled",
9433
9434                         // Fake xhr
9435                         jqXHR = {
9436                                 readyState: 0,
9437
9438                                 // Builds headers hashtable if needed
9439                                 getResponseHeader: function( key ) {
9440                                         var match;
9441                                         if ( completed ) {
9442                                                 if ( !responseHeaders ) {
9443                                                         responseHeaders = {};
9444                                                         while ( ( match = rheaders.exec( responseHeadersString ) ) ) {
9445                                                                 responseHeaders[ match[ 1 ].toLowerCase() + " " ] =
9446                                                                         ( responseHeaders[ match[ 1 ].toLowerCase() + " " ] || [] )
9447                                                                                 .concat( match[ 2 ] );
9448                                                         }
9449                                                 }
9450                                                 match = responseHeaders[ key.toLowerCase() + " " ];
9451                                         }
9452                                         return match == null ? null : match.join( ", " );
9453                                 },
9454
9455                                 // Raw string
9456                                 getAllResponseHeaders: function() {
9457                                         return completed ? responseHeadersString : null;
9458                                 },
9459
9460                                 // Caches the header
9461                                 setRequestHeader: function( name, value ) {
9462                                         if ( completed == null ) {
9463                                                 name = requestHeadersNames[ name.toLowerCase() ] =
9464                                                         requestHeadersNames[ name.toLowerCase() ] || name;
9465                                                 requestHeaders[ name ] = value;
9466                                         }
9467                                         return this;
9468                                 },
9469
9470                                 // Overrides response content-type header
9471                                 overrideMimeType: function( type ) {
9472                                         if ( completed == null ) {
9473                                                 s.mimeType = type;
9474                                         }
9475                                         return this;
9476                                 },
9477
9478                                 // Status-dependent callbacks
9479                                 statusCode: function( map ) {
9480                                         var code;
9481                                         if ( map ) {
9482                                                 if ( completed ) {
9483
9484                                                         // Execute the appropriate callbacks
9485                                                         jqXHR.always( map[ jqXHR.status ] );
9486                                                 } else {
9487
9488                                                         // Lazy-add the new callbacks in a way that preserves old ones
9489                                                         for ( code in map ) {
9490                                                                 statusCode[ code ] = [ statusCode[ code ], map[ code ] ];
9491                                                         }
9492                                                 }
9493                                         }
9494                                         return this;
9495                                 },
9496
9497                                 // Cancel the request
9498                                 abort: function( statusText ) {
9499                                         var finalText = statusText || strAbort;
9500                                         if ( transport ) {
9501                                                 transport.abort( finalText );
9502                                         }
9503                                         done( 0, finalText );
9504                                         return this;
9505                                 }
9506                         };
9507
9508                 // Attach deferreds
9509                 deferred.promise( jqXHR );
9510
9511                 // Add protocol if not provided (prefilters might expect it)
9512                 // Handle falsy url in the settings object (#10093: consistency with old signature)
9513                 // We also use the url parameter if available
9514                 s.url = ( ( url || s.url || location.href ) + "" )
9515                         .replace( rprotocol, location.protocol + "//" );
9516
9517                 // Alias method option to type as per ticket #12004
9518                 s.type = options.method || options.type || s.method || s.type;
9519
9520                 // Extract dataTypes list
9521                 s.dataTypes = ( s.dataType || "*" ).toLowerCase().match( rnothtmlwhite ) || [ "" ];
9522
9523                 // A cross-domain request is in order when the origin doesn't match the current origin.
9524                 if ( s.crossDomain == null ) {
9525                         urlAnchor = document.createElement( "a" );
9526
9527                         // Support: IE <=8 - 11, Edge 12 - 15
9528                         // IE throws exception on accessing the href property if url is malformed,
9529                         // e.g. http://example.com:80x/
9530                         try {
9531                                 urlAnchor.href = s.url;
9532
9533                                 // Support: IE <=8 - 11 only
9534                                 // Anchor's host property isn't correctly set when s.url is relative
9535                                 urlAnchor.href = urlAnchor.href;
9536                                 s.crossDomain = originAnchor.protocol + "//" + originAnchor.host !==
9537                                         urlAnchor.protocol + "//" + urlAnchor.host;
9538                         } catch ( e ) {
9539
9540                                 // If there is an error parsing the URL, assume it is crossDomain,
9541                                 // it can be rejected by the transport if it is invalid
9542                                 s.crossDomain = true;
9543                         }
9544                 }
9545
9546                 // Convert data if not already a string
9547                 if ( s.data && s.processData && typeof s.data !== "string" ) {
9548                         s.data = jQuery.param( s.data, s.traditional );
9549                 }
9550
9551                 // Apply prefilters
9552                 inspectPrefiltersOrTransports( prefilters, s, options, jqXHR );
9553
9554                 // If request was aborted inside a prefilter, stop there
9555                 if ( completed ) {
9556                         return jqXHR;
9557                 }
9558
9559                 // We can fire global events as of now if asked to
9560                 // Don't fire events if jQuery.event is undefined in an AMD-usage scenario (#15118)
9561                 fireGlobals = jQuery.event && s.global;
9562
9563                 // Watch for a new set of requests
9564                 if ( fireGlobals && jQuery.active++ === 0 ) {
9565                         jQuery.event.trigger( "ajaxStart" );
9566                 }
9567
9568                 // Uppercase the type
9569                 s.type = s.type.toUpperCase();
9570
9571                 // Determine if request has content
9572                 s.hasContent = !rnoContent.test( s.type );
9573
9574                 // Save the URL in case we're toying with the If-Modified-Since
9575                 // and/or If-None-Match header later on
9576                 // Remove hash to simplify url manipulation
9577                 cacheURL = s.url.replace( rhash, "" );
9578
9579                 // More options handling for requests with no content
9580                 if ( !s.hasContent ) {
9581
9582                         // Remember the hash so we can put it back
9583                         uncached = s.url.slice( cacheURL.length );
9584
9585                         // If data is available and should be processed, append data to url
9586                         if ( s.data && ( s.processData || typeof s.data === "string" ) ) {
9587                                 cacheURL += ( rquery.test( cacheURL ) ? "&" : "?" ) + s.data;
9588
9589                                 // #9682: remove data so that it's not used in an eventual retry
9590                                 delete s.data;
9591                         }
9592
9593                         // Add or update anti-cache param if needed
9594                         if ( s.cache === false ) {
9595                                 cacheURL = cacheURL.replace( rantiCache, "$1" );
9596                                 uncached = ( rquery.test( cacheURL ) ? "&" : "?" ) + "_=" + ( nonce.guid++ ) +
9597                                         uncached;
9598                         }
9599
9600                         // Put hash and anti-cache on the URL that will be requested (gh-1732)
9601                         s.url = cacheURL + uncached;
9602
9603                 // Change '%20' to '+' if this is encoded form body content (gh-2658)
9604                 } else if ( s.data && s.processData &&
9605                         ( s.contentType || "" ).indexOf( "application/x-www-form-urlencoded" ) === 0 ) {
9606                         s.data = s.data.replace( r20, "+" );
9607                 }
9608
9609                 // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
9610                 if ( s.ifModified ) {
9611                         if ( jQuery.lastModified[ cacheURL ] ) {
9612                                 jqXHR.setRequestHeader( "If-Modified-Since", jQuery.lastModified[ cacheURL ] );
9613                         }
9614                         if ( jQuery.etag[ cacheURL ] ) {
9615                                 jqXHR.setRequestHeader( "If-None-Match", jQuery.etag[ cacheURL ] );
9616                         }
9617                 }
9618
9619                 // Set the correct header, if data is being sent
9620                 if ( s.data && s.hasContent && s.contentType !== false || options.contentType ) {
9621                         jqXHR.setRequestHeader( "Content-Type", s.contentType );
9622                 }
9623
9624                 // Set the Accepts header for the server, depending on the dataType
9625                 jqXHR.setRequestHeader(
9626                         "Accept",
9627                         s.dataTypes[ 0 ] && s.accepts[ s.dataTypes[ 0 ] ] ?
9628                                 s.accepts[ s.dataTypes[ 0 ] ] +
9629                                         ( s.dataTypes[ 0 ] !== "*" ? ", " + allTypes + "; q=0.01" : "" ) :
9630                                 s.accepts[ "*" ]
9631                 );
9632
9633                 // Check for headers option
9634                 for ( i in s.headers ) {
9635                         jqXHR.setRequestHeader( i, s.headers[ i ] );
9636                 }
9637
9638                 // Allow custom headers/mimetypes and early abort
9639                 if ( s.beforeSend &&
9640                         ( s.beforeSend.call( callbackContext, jqXHR, s ) === false || completed ) ) {
9641
9642                         // Abort if not done already and return
9643                         return jqXHR.abort();
9644                 }
9645
9646                 // Aborting is no longer a cancellation
9647                 strAbort = "abort";
9648
9649                 // Install callbacks on deferreds
9650                 completeDeferred.add( s.complete );
9651                 jqXHR.done( s.success );
9652                 jqXHR.fail( s.error );
9653
9654                 // Get transport
9655                 transport = inspectPrefiltersOrTransports( transports, s, options, jqXHR );
9656
9657                 // If no transport, we auto-abort
9658                 if ( !transport ) {
9659                         done( -1, "No Transport" );
9660                 } else {
9661                         jqXHR.readyState = 1;
9662
9663                         // Send global event
9664                         if ( fireGlobals ) {
9665                                 globalEventContext.trigger( "ajaxSend", [ jqXHR, s ] );
9666                         }
9667
9668                         // If request was aborted inside ajaxSend, stop there
9669                         if ( completed ) {
9670                                 return jqXHR;
9671                         }
9672
9673                         // Timeout
9674                         if ( s.async && s.timeout > 0 ) {
9675                                 timeoutTimer = window.setTimeout( function() {
9676                                         jqXHR.abort( "timeout" );
9677                                 }, s.timeout );
9678                         }
9679
9680                         try {
9681                                 completed = false;
9682                                 transport.send( requestHeaders, done );
9683                         } catch ( e ) {
9684
9685                                 // Rethrow post-completion exceptions
9686                                 if ( completed ) {
9687                                         throw e;
9688                                 }
9689
9690                                 // Propagate others as results
9691                                 done( -1, e );
9692                         }
9693                 }
9694
9695                 // Callback for when everything is done
9696                 function done( status, nativeStatusText, responses, headers ) {
9697                         var isSuccess, success, error, response, modified,
9698                                 statusText = nativeStatusText;
9699
9700                         // Ignore repeat invocations
9701                         if ( completed ) {
9702                                 return;
9703                         }
9704
9705                         completed = true;
9706
9707                         // Clear timeout if it exists
9708                         if ( timeoutTimer ) {
9709                                 window.clearTimeout( timeoutTimer );
9710                         }
9711
9712                         // Dereference transport for early garbage collection
9713                         // (no matter how long the jqXHR object will be used)
9714                         transport = undefined;
9715
9716                         // Cache response headers
9717                         responseHeadersString = headers || "";
9718
9719                         // Set readyState
9720                         jqXHR.readyState = status > 0 ? 4 : 0;
9721
9722                         // Determine if successful
9723                         isSuccess = status >= 200 && status < 300 || status === 304;
9724
9725                         // Get response data
9726                         if ( responses ) {
9727                                 response = ajaxHandleResponses( s, jqXHR, responses );
9728                         }
9729
9730                         // Use a noop converter for missing script
9731                         if ( !isSuccess && jQuery.inArray( "script", s.dataTypes ) > -1 ) {
9732                                 s.converters[ "text script" ] = function() {};
9733                         }
9734
9735                         // Convert no matter what (that way responseXXX fields are always set)
9736                         response = ajaxConvert( s, response, jqXHR, isSuccess );
9737
9738                         // If successful, handle type chaining
9739                         if ( isSuccess ) {
9740
9741                                 // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
9742                                 if ( s.ifModified ) {
9743                                         modified = jqXHR.getResponseHeader( "Last-Modified" );
9744                                         if ( modified ) {
9745                                                 jQuery.lastModified[ cacheURL ] = modified;
9746                                         }
9747                                         modified = jqXHR.getResponseHeader( "etag" );
9748                                         if ( modified ) {
9749                                                 jQuery.etag[ cacheURL ] = modified;
9750                                         }
9751                                 }
9752
9753                                 // if no content
9754                                 if ( status === 204 || s.type === "HEAD" ) {
9755                                         statusText = "nocontent";
9756
9757                                 // if not modified
9758                                 } else if ( status === 304 ) {
9759                                         statusText = "notmodified";
9760
9761                                 // If we have data, let's convert it
9762                                 } else {
9763                                         statusText = response.state;
9764                                         success = response.data;
9765                                         error = response.error;
9766                                         isSuccess = !error;
9767                                 }
9768                         } else {
9769
9770                                 // Extract error from statusText and normalize for non-aborts
9771                                 error = statusText;
9772                                 if ( status || !statusText ) {
9773                                         statusText = "error";
9774                                         if ( status < 0 ) {
9775                                                 status = 0;
9776                                         }
9777                                 }
9778                         }
9779
9780                         // Set data for the fake xhr object
9781                         jqXHR.status = status;
9782                         jqXHR.statusText = ( nativeStatusText || statusText ) + "";
9783
9784                         // Success/Error
9785                         if ( isSuccess ) {
9786                                 deferred.resolveWith( callbackContext, [ success, statusText, jqXHR ] );
9787                         } else {
9788                                 deferred.rejectWith( callbackContext, [ jqXHR, statusText, error ] );
9789                         }
9790
9791                         // Status-dependent callbacks
9792                         jqXHR.statusCode( statusCode );
9793                         statusCode = undefined;
9794
9795                         if ( fireGlobals ) {
9796                                 globalEventContext.trigger( isSuccess ? "ajaxSuccess" : "ajaxError",
9797                                         [ jqXHR, s, isSuccess ? success : error ] );
9798                         }
9799
9800                         // Complete
9801                         completeDeferred.fireWith( callbackContext, [ jqXHR, statusText ] );
9802
9803                         if ( fireGlobals ) {
9804                                 globalEventContext.trigger( "ajaxComplete", [ jqXHR, s ] );
9805
9806                                 // Handle the global AJAX counter
9807                                 if ( !( --jQuery.active ) ) {
9808                                         jQuery.event.trigger( "ajaxStop" );
9809                                 }
9810                         }
9811                 }
9812
9813                 return jqXHR;
9814         },
9815
9816         getJSON: function( url, data, callback ) {
9817                 return jQuery.get( url, data, callback, "json" );
9818         },
9819
9820         getScript: function( url, callback ) {
9821                 return jQuery.get( url, undefined, callback, "script" );
9822         }
9823 } );
9824
9825 jQuery.each( [ "get", "post" ], function( _i, method ) {
9826         jQuery[ method ] = function( url, data, callback, type ) {
9827
9828                 // Shift arguments if data argument was omitted
9829                 if ( isFunction( data ) ) {
9830                         type = type || callback;
9831                         callback = data;
9832                         data = undefined;
9833                 }
9834
9835                 // The url can be an options object (which then must have .url)
9836                 return jQuery.ajax( jQuery.extend( {
9837                         url: url,
9838                         type: method,
9839                         dataType: type,
9840                         data: data,
9841                         success: callback
9842                 }, jQuery.isPlainObject( url ) && url ) );
9843         };
9844 } );
9845
9846 jQuery.ajaxPrefilter( function( s ) {
9847         var i;
9848         for ( i in s.headers ) {
9849                 if ( i.toLowerCase() === "content-type" ) {
9850                         s.contentType = s.headers[ i ] || "";
9851                 }
9852         }
9853 } );
9854
9855
9856 jQuery._evalUrl = function( url, options, doc ) {
9857         return jQuery.ajax( {
9858                 url: url,
9859
9860                 // Make this explicit, since user can override this through ajaxSetup (#11264)
9861                 type: "GET",
9862                 dataType: "script",
9863                 cache: true,
9864                 async: false,
9865                 global: false,
9866
9867                 // Only evaluate the response if it is successful (gh-4126)
9868                 // dataFilter is not invoked for failure responses, so using it instead
9869                 // of the default converter is kludgy but it works.
9870                 converters: {
9871                         "text script": function() {}
9872                 },
9873                 dataFilter: function( response ) {
9874                         jQuery.globalEval( response, options, doc );
9875                 }
9876         } );
9877 };
9878
9879
9880 jQuery.fn.extend( {
9881         wrapAll: function( html ) {
9882                 var wrap;
9883
9884                 if ( this[ 0 ] ) {
9885                         if ( isFunction( html ) ) {
9886                                 html = html.call( this[ 0 ] );
9887                         }
9888
9889                         // The elements to wrap the target around
9890                         wrap = jQuery( html, this[ 0 ].ownerDocument ).eq( 0 ).clone( true );
9891
9892                         if ( this[ 0 ].parentNode ) {
9893                                 wrap.insertBefore( this[ 0 ] );
9894                         }
9895
9896                         wrap.map( function() {
9897                                 var elem = this;
9898
9899                                 while ( elem.firstElementChild ) {
9900                                         elem = elem.firstElementChild;
9901                                 }
9902
9903                                 return elem;
9904                         } ).append( this );
9905                 }
9906
9907                 return this;
9908         },
9909
9910         wrapInner: function( html ) {
9911                 if ( isFunction( html ) ) {
9912                         return this.each( function( i ) {
9913                                 jQuery( this ).wrapInner( html.call( this, i ) );
9914                         } );
9915                 }
9916
9917                 return this.each( function() {
9918                         var self = jQuery( this ),
9919                                 contents = self.contents();
9920
9921                         if ( contents.length ) {
9922                                 contents.wrapAll( html );
9923
9924                         } else {
9925                                 self.append( html );
9926                         }
9927                 } );
9928         },
9929
9930         wrap: function( html ) {
9931                 var htmlIsFunction = isFunction( html );
9932
9933                 return this.each( function( i ) {
9934                         jQuery( this ).wrapAll( htmlIsFunction ? html.call( this, i ) : html );
9935                 } );
9936         },
9937
9938         unwrap: function( selector ) {
9939                 this.parent( selector ).not( "body" ).each( function() {
9940                         jQuery( this ).replaceWith( this.childNodes );
9941                 } );
9942                 return this;
9943         }
9944 } );
9945
9946
9947 jQuery.expr.pseudos.hidden = function( elem ) {
9948         return !jQuery.expr.pseudos.visible( elem );
9949 };
9950 jQuery.expr.pseudos.visible = function( elem ) {
9951         return !!( elem.offsetWidth || elem.offsetHeight || elem.getClientRects().length );
9952 };
9953
9954
9955
9956
9957 jQuery.ajaxSettings.xhr = function() {
9958         try {
9959                 return new window.XMLHttpRequest();
9960         } catch ( e ) {}
9961 };
9962
9963 var xhrSuccessStatus = {
9964
9965                 // File protocol always yields status code 0, assume 200
9966                 0: 200,
9967
9968                 // Support: IE <=9 only
9969                 // #1450: sometimes IE returns 1223 when it should be 204
9970                 1223: 204
9971         },
9972         xhrSupported = jQuery.ajaxSettings.xhr();
9973
9974 support.cors = !!xhrSupported && ( "withCredentials" in xhrSupported );
9975 support.ajax = xhrSupported = !!xhrSupported;
9976
9977 jQuery.ajaxTransport( function( options ) {
9978         var callback, errorCallback;
9979
9980         // Cross domain only allowed if supported through XMLHttpRequest
9981         if ( support.cors || xhrSupported && !options.crossDomain ) {
9982                 return {
9983                         send: function( headers, complete ) {
9984                                 var i,
9985                                         xhr = options.xhr();
9986
9987                                 xhr.open(
9988                                         options.type,
9989                                         options.url,
9990                                         options.async,
9991                                         options.username,
9992                                         options.password
9993                                 );
9994
9995                                 // Apply custom fields if provided
9996                                 if ( options.xhrFields ) {
9997                                         for ( i in options.xhrFields ) {
9998                                                 xhr[ i ] = options.xhrFields[ i ];
9999                                         }
10000                                 }
10001
10002                                 // Override mime type if needed
10003                                 if ( options.mimeType && xhr.overrideMimeType ) {
10004                                         xhr.overrideMimeType( options.mimeType );
10005                                 }
10006
10007                                 // X-Requested-With header
10008                                 // For cross-domain requests, seeing as conditions for a preflight are
10009                                 // akin to a jigsaw puzzle, we simply never set it to be sure.
10010                                 // (it can always be set on a per-request basis or even using ajaxSetup)
10011                                 // For same-domain requests, won't change header if already provided.
10012                                 if ( !options.crossDomain && !headers[ "X-Requested-With" ] ) {
10013                                         headers[ "X-Requested-With" ] = "XMLHttpRequest";
10014                                 }
10015
10016                                 // Set headers
10017                                 for ( i in headers ) {
10018                                         xhr.setRequestHeader( i, headers[ i ] );
10019                                 }
10020
10021                                 // Callback
10022                                 callback = function( type ) {
10023                                         return function() {
10024                                                 if ( callback ) {
10025                                                         callback = errorCallback = xhr.onload =
10026                                                                 xhr.onerror = xhr.onabort = xhr.ontimeout =
10027                                                                         xhr.onreadystatechange = null;
10028
10029                                                         if ( type === "abort" ) {
10030                                                                 xhr.abort();
10031                                                         } else if ( type === "error" ) {
10032
10033                                                                 // Support: IE <=9 only
10034                                                                 // On a manual native abort, IE9 throws
10035                                                                 // errors on any property access that is not readyState
10036                                                                 if ( typeof xhr.status !== "number" ) {
10037                                                                         complete( 0, "error" );
10038                                                                 } else {
10039                                                                         complete(
10040
10041                                                                                 // File: protocol always yields status 0; see #8605, #14207
10042                                                                                 xhr.status,
10043                                                                                 xhr.statusText
10044                                                                         );
10045                                                                 }
10046                                                         } else {
10047                                                                 complete(
10048                                                                         xhrSuccessStatus[ xhr.status ] || xhr.status,
10049                                                                         xhr.statusText,
10050
10051                                                                         // Support: IE <=9 only
10052                                                                         // IE9 has no XHR2 but throws on binary (trac-11426)
10053                                                                         // For XHR2 non-text, let the caller handle it (gh-2498)
10054                                                                         ( xhr.responseType || "text" ) !== "text"  ||
10055                                                                         typeof xhr.responseText !== "string" ?
10056                                                                                 { binary: xhr.response } :
10057                                                                                 { text: xhr.responseText },
10058                                                                         xhr.getAllResponseHeaders()
10059                                                                 );
10060                                                         }
10061                                                 }
10062                                         };
10063                                 };
10064
10065                                 // Listen to events
10066                                 xhr.onload = callback();
10067                                 errorCallback = xhr.onerror = xhr.ontimeout = callback( "error" );
10068
10069                                 // Support: IE 9 only
10070                                 // Use onreadystatechange to replace onabort
10071                                 // to handle uncaught aborts
10072                                 if ( xhr.onabort !== undefined ) {
10073                                         xhr.onabort = errorCallback;
10074                                 } else {
10075                                         xhr.onreadystatechange = function() {
10076
10077                                                 // Check readyState before timeout as it changes
10078                                                 if ( xhr.readyState === 4 ) {
10079
10080                                                         // Allow onerror to be called first,
10081                                                         // but that will not handle a native abort
10082                                                         // Also, save errorCallback to a variable
10083                                                         // as xhr.onerror cannot be accessed
10084                                                         window.setTimeout( function() {
10085                                                                 if ( callback ) {
10086                                                                         errorCallback();
10087                                                                 }
10088                                                         } );
10089                                                 }
10090                                         };
10091                                 }
10092
10093                                 // Create the abort callback
10094                                 callback = callback( "abort" );
10095
10096                                 try {
10097
10098                                         // Do send the request (this may raise an exception)
10099                                         xhr.send( options.hasContent && options.data || null );
10100                                 } catch ( e ) {
10101
10102                                         // #14683: Only rethrow if this hasn't been notified as an error yet
10103                                         if ( callback ) {
10104                                                 throw e;
10105                                         }
10106                                 }
10107                         },
10108
10109                         abort: function() {
10110                                 if ( callback ) {
10111                                         callback();
10112                                 }
10113                         }
10114                 };
10115         }
10116 } );
10117
10118
10119
10120
10121 // Prevent auto-execution of scripts when no explicit dataType was provided (See gh-2432)
10122 jQuery.ajaxPrefilter( function( s ) {
10123         if ( s.crossDomain ) {
10124                 s.contents.script = false;
10125         }
10126 } );
10127
10128 // Install script dataType
10129 jQuery.ajaxSetup( {
10130         accepts: {
10131                 script: "text/javascript, application/javascript, " +
10132                         "application/ecmascript, application/x-ecmascript"
10133         },
10134         contents: {
10135                 script: /\b(?:java|ecma)script\b/
10136         },
10137         converters: {
10138                 "text script": function( text ) {
10139                         jQuery.globalEval( text );
10140                         return text;
10141                 }
10142         }
10143 } );
10144
10145 // Handle cache's special case and crossDomain
10146 jQuery.ajaxPrefilter( "script", function( s ) {
10147         if ( s.cache === undefined ) {
10148                 s.cache = false;
10149         }
10150         if ( s.crossDomain ) {
10151                 s.type = "GET";
10152         }
10153 } );
10154
10155 // Bind script tag hack transport
10156 jQuery.ajaxTransport( "script", function( s ) {
10157
10158         // This transport only deals with cross domain or forced-by-attrs requests
10159         if ( s.crossDomain || s.scriptAttrs ) {
10160                 var script, callback;
10161                 return {
10162                         send: function( _, complete ) {
10163                                 script = jQuery( "<script>" )
10164                                         .attr( s.scriptAttrs || {} )
10165                                         .prop( { charset: s.scriptCharset, src: s.url } )
10166                                         .on( "load error", callback = function( evt ) {
10167                                                 script.remove();
10168                                                 callback = null;
10169                                                 if ( evt ) {
10170                                                         complete( evt.type === "error" ? 404 : 200, evt.type );
10171                                                 }
10172                                         } );
10173
10174                                 // Use native DOM manipulation to avoid our domManip AJAX trickery
10175                                 document.head.appendChild( script[ 0 ] );
10176                         },
10177                         abort: function() {
10178                                 if ( callback ) {
10179                                         callback();
10180                                 }
10181                         }
10182                 };
10183         }
10184 } );
10185
10186
10187
10188
10189 var oldCallbacks = [],
10190         rjsonp = /(=)\?(?=&|$)|\?\?/;
10191
10192 // Default jsonp settings
10193 jQuery.ajaxSetup( {
10194         jsonp: "callback",
10195         jsonpCallback: function() {
10196                 var callback = oldCallbacks.pop() || ( jQuery.expando + "_" + ( nonce.guid++ ) );
10197                 this[ callback ] = true;
10198                 return callback;
10199         }
10200 } );
10201
10202 // Detect, normalize options and install callbacks for jsonp requests
10203 jQuery.ajaxPrefilter( "json jsonp", function( s, originalSettings, jqXHR ) {
10204
10205         var callbackName, overwritten, responseContainer,
10206                 jsonProp = s.jsonp !== false && ( rjsonp.test( s.url ) ?
10207                         "url" :
10208                         typeof s.data === "string" &&
10209                                 ( s.contentType || "" )
10210                                         .indexOf( "application/x-www-form-urlencoded" ) === 0 &&
10211                                 rjsonp.test( s.data ) && "data"
10212                 );
10213
10214         // Handle iff the expected data type is "jsonp" or we have a parameter to set
10215         if ( jsonProp || s.dataTypes[ 0 ] === "jsonp" ) {
10216
10217                 // Get callback name, remembering preexisting value associated with it
10218                 callbackName = s.jsonpCallback = isFunction( s.jsonpCallback ) ?
10219                         s.jsonpCallback() :
10220                         s.jsonpCallback;
10221
10222                 // Insert callback into url or form data
10223                 if ( jsonProp ) {
10224                         s[ jsonProp ] = s[ jsonProp ].replace( rjsonp, "$1" + callbackName );
10225                 } else if ( s.jsonp !== false ) {
10226                         s.url += ( rquery.test( s.url ) ? "&" : "?" ) + s.jsonp + "=" + callbackName;
10227                 }
10228
10229                 // Use data converter to retrieve json after script execution
10230                 s.converters[ "script json" ] = function() {
10231                         if ( !responseContainer ) {
10232                                 jQuery.error( callbackName + " was not called" );
10233                         }
10234                         return responseContainer[ 0 ];
10235                 };
10236
10237                 // Force json dataType
10238                 s.dataTypes[ 0 ] = "json";
10239
10240                 // Install callback
10241                 overwritten = window[ callbackName ];
10242                 window[ callbackName ] = function() {
10243                         responseContainer = arguments;
10244                 };
10245
10246                 // Clean-up function (fires after converters)
10247                 jqXHR.always( function() {
10248
10249                         // If previous value didn't exist - remove it
10250                         if ( overwritten === undefined ) {
10251                                 jQuery( window ).removeProp( callbackName );
10252
10253                         // Otherwise restore preexisting value
10254                         } else {
10255                                 window[ callbackName ] = overwritten;
10256                         }
10257
10258                         // Save back as free
10259                         if ( s[ callbackName ] ) {
10260
10261                                 // Make sure that re-using the options doesn't screw things around
10262                                 s.jsonpCallback = originalSettings.jsonpCallback;
10263
10264                                 // Save the callback name for future use
10265                                 oldCallbacks.push( callbackName );
10266                         }
10267
10268                         // Call if it was a function and we have a response
10269                         if ( responseContainer && isFunction( overwritten ) ) {
10270                                 overwritten( responseContainer[ 0 ] );
10271                         }
10272
10273                         responseContainer = overwritten = undefined;
10274                 } );
10275
10276                 // Delegate to script
10277                 return "script";
10278         }
10279 } );
10280
10281
10282
10283
10284 // Support: Safari 8 only
10285 // In Safari 8 documents created via document.implementation.createHTMLDocument
10286 // collapse sibling forms: the second one becomes a child of the first one.
10287 // Because of that, this security measure has to be disabled in Safari 8.
10288 // https://bugs.webkit.org/show_bug.cgi?id=137337
10289 support.createHTMLDocument = ( function() {
10290         var body = document.implementation.createHTMLDocument( "" ).body;
10291         body.innerHTML = "<form></form><form></form>";
10292         return body.childNodes.length === 2;
10293 } )();
10294
10295
10296 // Argument "data" should be string of html
10297 // context (optional): If specified, the fragment will be created in this context,
10298 // defaults to document
10299 // keepScripts (optional): If true, will include scripts passed in the html string
10300 jQuery.parseHTML = function( data, context, keepScripts ) {
10301         if ( typeof data !== "string" ) {
10302                 return [];
10303         }
10304         if ( typeof context === "boolean" ) {
10305                 keepScripts = context;
10306                 context = false;
10307         }
10308
10309         var base, parsed, scripts;
10310
10311         if ( !context ) {
10312
10313                 // Stop scripts or inline event handlers from being executed immediately
10314                 // by using document.implementation
10315                 if ( support.createHTMLDocument ) {
10316                         context = document.implementation.createHTMLDocument( "" );
10317
10318                         // Set the base href for the created document
10319                         // so any parsed elements with URLs
10320                         // are based on the document's URL (gh-2965)
10321                         base = context.createElement( "base" );
10322                         base.href = document.location.href;
10323                         context.head.appendChild( base );
10324                 } else {
10325                         context = document;
10326                 }
10327         }
10328
10329         parsed = rsingleTag.exec( data );
10330         scripts = !keepScripts && [];
10331
10332         // Single tag
10333         if ( parsed ) {
10334                 return [ context.createElement( parsed[ 1 ] ) ];
10335         }
10336
10337         parsed = buildFragment( [ data ], context, scripts );
10338
10339         if ( scripts && scripts.length ) {
10340                 jQuery( scripts ).remove();
10341         }
10342
10343         return jQuery.merge( [], parsed.childNodes );
10344 };
10345
10346
10347 /**
10348  * Load a url into a page
10349  */
10350 jQuery.fn.load = function( url, params, callback ) {
10351         var selector, type, response,
10352                 self = this,
10353                 off = url.indexOf( " " );
10354
10355         if ( off > -1 ) {
10356                 selector = stripAndCollapse( url.slice( off ) );
10357                 url = url.slice( 0, off );
10358         }
10359
10360         // If it's a function
10361         if ( isFunction( params ) ) {
10362
10363                 // We assume that it's the callback
10364                 callback = params;
10365                 params = undefined;
10366
10367         // Otherwise, build a param string
10368         } else if ( params && typeof params === "object" ) {
10369                 type = "POST";
10370         }
10371
10372         // If we have elements to modify, make the request
10373         if ( self.length > 0 ) {
10374                 jQuery.ajax( {
10375                         url: url,
10376
10377                         // If "type" variable is undefined, then "GET" method will be used.
10378                         // Make value of this field explicit since
10379                         // user can override it through ajaxSetup method
10380                         type: type || "GET",
10381                         dataType: "html",
10382                         data: params
10383                 } ).done( function( responseText ) {
10384
10385                         // Save response for use in complete callback
10386                         response = arguments;
10387
10388                         self.html( selector ?
10389
10390                                 // If a selector was specified, locate the right elements in a dummy div
10391                                 // Exclude scripts to avoid IE 'Permission Denied' errors
10392                                 jQuery( "<div>" ).append( jQuery.parseHTML( responseText ) ).find( selector ) :
10393
10394                                 // Otherwise use the full result
10395                                 responseText );
10396
10397                 // If the request succeeds, this function gets "data", "status", "jqXHR"
10398                 // but they are ignored because response was set above.
10399                 // If it fails, this function gets "jqXHR", "status", "error"
10400                 } ).always( callback && function( jqXHR, status ) {
10401                         self.each( function() {
10402                                 callback.apply( this, response || [ jqXHR.responseText, status, jqXHR ] );
10403                         } );
10404                 } );
10405         }
10406
10407         return this;
10408 };
10409
10410
10411
10412
10413 jQuery.expr.pseudos.animated = function( elem ) {
10414         return jQuery.grep( jQuery.timers, function( fn ) {
10415                 return elem === fn.elem;
10416         } ).length;
10417 };
10418
10419
10420
10421
10422 jQuery.offset = {
10423         setOffset: function( elem, options, i ) {
10424                 var curPosition, curLeft, curCSSTop, curTop, curOffset, curCSSLeft, calculatePosition,
10425                         position = jQuery.css( elem, "position" ),
10426                         curElem = jQuery( elem ),
10427                         props = {};
10428
10429                 // Set position first, in-case top/left are set even on static elem
10430                 if ( position === "static" ) {
10431                         elem.style.position = "relative";
10432                 }
10433
10434                 curOffset = curElem.offset();
10435                 curCSSTop = jQuery.css( elem, "top" );
10436                 curCSSLeft = jQuery.css( elem, "left" );
10437                 calculatePosition = ( position === "absolute" || position === "fixed" ) &&
10438                         ( curCSSTop + curCSSLeft ).indexOf( "auto" ) > -1;
10439
10440                 // Need to be able to calculate position if either
10441                 // top or left is auto and position is either absolute or fixed
10442                 if ( calculatePosition ) {
10443                         curPosition = curElem.position();
10444                         curTop = curPosition.top;
10445                         curLeft = curPosition.left;
10446
10447                 } else {
10448                         curTop = parseFloat( curCSSTop ) || 0;
10449                         curLeft = parseFloat( curCSSLeft ) || 0;
10450                 }
10451
10452                 if ( isFunction( options ) ) {
10453
10454                         // Use jQuery.extend here to allow modification of coordinates argument (gh-1848)
10455                         options = options.call( elem, i, jQuery.extend( {}, curOffset ) );
10456                 }
10457
10458                 if ( options.top != null ) {
10459                         props.top = ( options.top - curOffset.top ) + curTop;
10460                 }
10461                 if ( options.left != null ) {
10462                         props.left = ( options.left - curOffset.left ) + curLeft;
10463                 }
10464
10465                 if ( "using" in options ) {
10466                         options.using.call( elem, props );
10467
10468                 } else {
10469                         if ( typeof props.top === "number" ) {
10470                                 props.top += "px";
10471                         }
10472                         if ( typeof props.left === "number" ) {
10473                                 props.left += "px";
10474                         }
10475                         curElem.css( props );
10476                 }
10477         }
10478 };
10479
10480 jQuery.fn.extend( {
10481
10482         // offset() relates an element's border box to the document origin
10483         offset: function( options ) {
10484
10485                 // Preserve chaining for setter
10486                 if ( arguments.length ) {
10487                         return options === undefined ?
10488                                 this :
10489                                 this.each( function( i ) {
10490                                         jQuery.offset.setOffset( this, options, i );
10491                                 } );
10492                 }
10493
10494                 var rect, win,
10495                         elem = this[ 0 ];
10496
10497                 if ( !elem ) {
10498                         return;
10499                 }
10500
10501                 // Return zeros for disconnected and hidden (display: none) elements (gh-2310)
10502                 // Support: IE <=11 only
10503                 // Running getBoundingClientRect on a
10504                 // disconnected node in IE throws an error
10505                 if ( !elem.getClientRects().length ) {
10506                         return { top: 0, left: 0 };
10507                 }
10508
10509                 // Get document-relative position by adding viewport scroll to viewport-relative gBCR
10510                 rect = elem.getBoundingClientRect();
10511                 win = elem.ownerDocument.defaultView;
10512                 return {
10513                         top: rect.top + win.pageYOffset,
10514                         left: rect.left + win.pageXOffset
10515                 };
10516         },
10517
10518         // position() relates an element's margin box to its offset parent's padding box
10519         // This corresponds to the behavior of CSS absolute positioning
10520         position: function() {
10521                 if ( !this[ 0 ] ) {
10522                         return;
10523                 }
10524
10525                 var offsetParent, offset, doc,
10526                         elem = this[ 0 ],
10527                         parentOffset = { top: 0, left: 0 };
10528
10529                 // position:fixed elements are offset from the viewport, which itself always has zero offset
10530                 if ( jQuery.css( elem, "position" ) === "fixed" ) {
10531
10532                         // Assume position:fixed implies availability of getBoundingClientRect
10533                         offset = elem.getBoundingClientRect();
10534
10535                 } else {
10536                         offset = this.offset();
10537
10538                         // Account for the *real* offset parent, which can be the document or its root element
10539                         // when a statically positioned element is identified
10540                         doc = elem.ownerDocument;
10541                         offsetParent = elem.offsetParent || doc.documentElement;
10542                         while ( offsetParent &&
10543                                 ( offsetParent === doc.body || offsetParent === doc.documentElement ) &&
10544                                 jQuery.css( offsetParent, "position" ) === "static" ) {
10545
10546                                 offsetParent = offsetParent.parentNode;
10547                         }
10548                         if ( offsetParent && offsetParent !== elem && offsetParent.nodeType === 1 ) {
10549
10550                                 // Incorporate borders into its offset, since they are outside its content origin
10551                                 parentOffset = jQuery( offsetParent ).offset();
10552                                 parentOffset.top += jQuery.css( offsetParent, "borderTopWidth", true );
10553                                 parentOffset.left += jQuery.css( offsetParent, "borderLeftWidth", true );
10554                         }
10555                 }
10556
10557                 // Subtract parent offsets and element margins
10558                 return {
10559                         top: offset.top - parentOffset.top - jQuery.css( elem, "marginTop", true ),
10560                         left: offset.left - parentOffset.left - jQuery.css( elem, "marginLeft", true )
10561                 };
10562         },
10563
10564         // This method will return documentElement in the following cases:
10565         // 1) For the element inside the iframe without offsetParent, this method will return
10566         //    documentElement of the parent window
10567         // 2) For the hidden or detached element
10568         // 3) For body or html element, i.e. in case of the html node - it will return itself
10569         //
10570         // but those exceptions were never presented as a real life use-cases
10571         // and might be considered as more preferable results.
10572         //
10573         // This logic, however, is not guaranteed and can change at any point in the future
10574         offsetParent: function() {
10575                 return this.map( function() {
10576                         var offsetParent = this.offsetParent;
10577
10578                         while ( offsetParent && jQuery.css( offsetParent, "position" ) === "static" ) {
10579                                 offsetParent = offsetParent.offsetParent;
10580                         }
10581
10582                         return offsetParent || documentElement;
10583                 } );
10584         }
10585 } );
10586
10587 // Create scrollLeft and scrollTop methods
10588 jQuery.each( { scrollLeft: "pageXOffset", scrollTop: "pageYOffset" }, function( method, prop ) {
10589         var top = "pageYOffset" === prop;
10590
10591         jQuery.fn[ method ] = function( val ) {
10592                 return access( this, function( elem, method, val ) {
10593
10594                         // Coalesce documents and windows
10595                         var win;
10596                         if ( isWindow( elem ) ) {
10597                                 win = elem;
10598                         } else if ( elem.nodeType === 9 ) {
10599                                 win = elem.defaultView;
10600                         }
10601
10602                         if ( val === undefined ) {
10603                                 return win ? win[ prop ] : elem[ method ];
10604                         }
10605
10606                         if ( win ) {
10607                                 win.scrollTo(
10608                                         !top ? val : win.pageXOffset,
10609                                         top ? val : win.pageYOffset
10610                                 );
10611
10612                         } else {
10613                                 elem[ method ] = val;
10614                         }
10615                 }, method, val, arguments.length );
10616         };
10617 } );
10618
10619 // Support: Safari <=7 - 9.1, Chrome <=37 - 49
10620 // Add the top/left cssHooks using jQuery.fn.position
10621 // Webkit bug: https://bugs.webkit.org/show_bug.cgi?id=29084
10622 // Blink bug: https://bugs.chromium.org/p/chromium/issues/detail?id=589347
10623 // getComputedStyle returns percent when specified for top/left/bottom/right;
10624 // rather than make the css module depend on the offset module, just check for it here
10625 jQuery.each( [ "top", "left" ], function( _i, prop ) {
10626         jQuery.cssHooks[ prop ] = addGetHookIf( support.pixelPosition,
10627                 function( elem, computed ) {
10628                         if ( computed ) {
10629                                 computed = curCSS( elem, prop );
10630
10631                                 // If curCSS returns percentage, fallback to offset
10632                                 return rnumnonpx.test( computed ) ?
10633                                         jQuery( elem ).position()[ prop ] + "px" :
10634                                         computed;
10635                         }
10636                 }
10637         );
10638 } );
10639
10640
10641 // Create innerHeight, innerWidth, height, width, outerHeight and outerWidth methods
10642 jQuery.each( { Height: "height", Width: "width" }, function( name, type ) {
10643         jQuery.each( { padding: "inner" + name, content: type, "": "outer" + name },
10644                 function( defaultExtra, funcName ) {
10645
10646                 // Margin is only for outerHeight, outerWidth
10647                 jQuery.fn[ funcName ] = function( margin, value ) {
10648                         var chainable = arguments.length && ( defaultExtra || typeof margin !== "boolean" ),
10649                                 extra = defaultExtra || ( margin === true || value === true ? "margin" : "border" );
10650
10651                         return access( this, function( elem, type, value ) {
10652                                 var doc;
10653
10654                                 if ( isWindow( elem ) ) {
10655
10656                                         // $( window ).outerWidth/Height return w/h including scrollbars (gh-1729)
10657                                         return funcName.indexOf( "outer" ) === 0 ?
10658                                                 elem[ "inner" + name ] :
10659                                                 elem.document.documentElement[ "client" + name ];
10660                                 }
10661
10662                                 // Get document width or height
10663                                 if ( elem.nodeType === 9 ) {
10664                                         doc = elem.documentElement;
10665
10666                                         // Either scroll[Width/Height] or offset[Width/Height] or client[Width/Height],
10667                                         // whichever is greatest
10668                                         return Math.max(
10669                                                 elem.body[ "scroll" + name ], doc[ "scroll" + name ],
10670                                                 elem.body[ "offset" + name ], doc[ "offset" + name ],
10671                                                 doc[ "client" + name ]
10672                                         );
10673                                 }
10674
10675                                 return value === undefined ?
10676
10677                                         // Get width or height on the element, requesting but not forcing parseFloat
10678                                         jQuery.css( elem, type, extra ) :
10679
10680                                         // Set width or height on the element
10681                                         jQuery.style( elem, type, value, extra );
10682                         }, type, chainable ? margin : undefined, chainable );
10683                 };
10684         } );
10685 } );
10686
10687
10688 jQuery.each( [
10689         "ajaxStart",
10690         "ajaxStop",
10691         "ajaxComplete",
10692         "ajaxError",
10693         "ajaxSuccess",
10694         "ajaxSend"
10695 ], function( _i, type ) {
10696         jQuery.fn[ type ] = function( fn ) {
10697                 return this.on( type, fn );
10698         };
10699 } );
10700
10701
10702
10703
10704 jQuery.fn.extend( {
10705
10706         bind: function( types, data, fn ) {
10707                 return this.on( types, null, data, fn );
10708         },
10709         unbind: function( types, fn ) {
10710                 return this.off( types, null, fn );
10711         },
10712
10713         delegate: function( selector, types, data, fn ) {
10714                 return this.on( types, selector, data, fn );
10715         },
10716         undelegate: function( selector, types, fn ) {
10717
10718                 // ( namespace ) or ( selector, types [, fn] )
10719                 return arguments.length === 1 ?
10720                         this.off( selector, "**" ) :
10721                         this.off( types, selector || "**", fn );
10722         },
10723
10724         hover: function( fnOver, fnOut ) {
10725                 return this.mouseenter( fnOver ).mouseleave( fnOut || fnOver );
10726         }
10727 } );
10728
10729 jQuery.each( ( "blur focus focusin focusout resize scroll click dblclick " +
10730         "mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave " +
10731         "change select submit keydown keypress keyup contextmenu" ).split( " " ),
10732         function( _i, name ) {
10733
10734                 // Handle event binding
10735                 jQuery.fn[ name ] = function( data, fn ) {
10736                         return arguments.length > 0 ?
10737                                 this.on( name, null, data, fn ) :
10738                                 this.trigger( name );
10739                 };
10740         } );
10741
10742
10743
10744
10745 // Support: Android <=4.0 only
10746 // Make sure we trim BOM and NBSP
10747 var rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g;
10748
10749 // Bind a function to a context, optionally partially applying any
10750 // arguments.
10751 // jQuery.proxy is deprecated to promote standards (specifically Function#bind)
10752 // However, it is not slated for removal any time soon
10753 jQuery.proxy = function( fn, context ) {
10754         var tmp, args, proxy;
10755
10756         if ( typeof context === "string" ) {
10757                 tmp = fn[ context ];
10758                 context = fn;
10759                 fn = tmp;
10760         }
10761
10762         // Quick check to determine if target is callable, in the spec
10763         // this throws a TypeError, but we will just return undefined.
10764         if ( !isFunction( fn ) ) {
10765                 return undefined;
10766         }
10767
10768         // Simulated bind
10769         args = slice.call( arguments, 2 );
10770         proxy = function() {
10771                 return fn.apply( context || this, args.concat( slice.call( arguments ) ) );
10772         };
10773
10774         // Set the guid of unique handler to the same of original handler, so it can be removed
10775         proxy.guid = fn.guid = fn.guid || jQuery.guid++;
10776
10777         return proxy;
10778 };
10779
10780 jQuery.holdReady = function( hold ) {
10781         if ( hold ) {
10782                 jQuery.readyWait++;
10783         } else {
10784                 jQuery.ready( true );
10785         }
10786 };
10787 jQuery.isArray = Array.isArray;
10788 jQuery.parseJSON = JSON.parse;
10789 jQuery.nodeName = nodeName;
10790 jQuery.isFunction = isFunction;
10791 jQuery.isWindow = isWindow;
10792 jQuery.camelCase = camelCase;
10793 jQuery.type = toType;
10794
10795 jQuery.now = Date.now;
10796
10797 jQuery.isNumeric = function( obj ) {
10798
10799         // As of jQuery 3.0, isNumeric is limited to
10800         // strings and numbers (primitives or objects)
10801         // that can be coerced to finite numbers (gh-2662)
10802         var type = jQuery.type( obj );
10803         return ( type === "number" || type === "string" ) &&
10804
10805                 // parseFloat NaNs numeric-cast false positives ("")
10806                 // ...but misinterprets leading-number strings, particularly hex literals ("0x...")
10807                 // subtraction forces infinities to NaN
10808                 !isNaN( obj - parseFloat( obj ) );
10809 };
10810
10811 jQuery.trim = function( text ) {
10812         return text == null ?
10813                 "" :
10814                 ( text + "" ).replace( rtrim, "" );
10815 };
10816
10817
10818
10819 // Register as a named AMD module, since jQuery can be concatenated with other
10820 // files that may use define, but not via a proper concatenation script that
10821 // understands anonymous AMD modules. A named AMD is safest and most robust
10822 // way to register. Lowercase jquery is used because AMD module names are
10823 // derived from file names, and jQuery is normally delivered in a lowercase
10824 // file name. Do this after creating the global so that if an AMD module wants
10825 // to call noConflict to hide this version of jQuery, it will work.
10826
10827 // Note that for maximum portability, libraries that are not jQuery should
10828 // declare themselves as anonymous modules, and avoid setting a global if an
10829 // AMD loader is present. jQuery is a special case. For more information, see
10830 // https://github.com/jrburke/requirejs/wiki/Updating-existing-libraries#wiki-anon
10831
10832 if ( typeof define === "function" && define.amd ) {
10833         define( "jquery", [], function() {
10834                 return jQuery;
10835         } );
10836 }
10837
10838
10839
10840
10841 var
10842
10843         // Map over jQuery in case of overwrite
10844         _jQuery = window.jQuery,
10845
10846         // Map over the $ in case of overwrite
10847         _$ = window.$;
10848
10849 jQuery.noConflict = function( deep ) {
10850         if ( window.$ === jQuery ) {
10851                 window.$ = _$;
10852         }
10853
10854         if ( deep && window.jQuery === jQuery ) {
10855                 window.jQuery = _jQuery;
10856         }
10857
10858         return jQuery;
10859 };
10860
10861 // Expose jQuery and $ identifiers, even in AMD
10862 // (#7102#comment:10, https://github.com/jquery/jquery/pull/557)
10863 // and CommonJS for browser emulators (#13566)
10864 if ( typeof noGlobal === "undefined" ) {
10865         window.jQuery = window.$ = jQuery;
10866 }
10867
10868
10869
10870
10871 return jQuery;
10872 } );