[ Index ]

PHP Cross Reference of WordPress

title

Body

[close]

/wp-includes/js/jquery/ -> jquery.js (source)

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