WordPress.org

Make WordPress Core

Ticket #52647: 52647.2.diff

File 52647.2.diff, 381.3 KB (added by SergeyBiryukov, 3 months ago)
  • Gruntfile.js

     
    187187                                                // Renamed to avoid conflict with jQuery hoverIntent.min.js (after minifying).
    188188                                                [ WORKING_DIR + 'wp-includes/js/hoverintent-js.min.js' ]: [ './node_modules/hoverintent/dist/hoverintent.min.js' ],
    189189                                                [ WORKING_DIR + 'wp-includes/js/imagesloaded.min.js' ]: [ './node_modules/imagesloaded/imagesloaded.pkgd.min.js' ],
     190                                                [ WORKING_DIR + 'wp-includes/js/jquery/jquery.js' ]: [ './node_modules/jquery/dist/jquery.js' ],
     191                                                [ WORKING_DIR + 'wp-includes/js/jquery/jquery.min.js' ]: [ './node_modules/jquery/dist/jquery.min.js' ],
    190192                                                [ WORKING_DIR + 'wp-includes/js/jquery/jquery.form.js' ]: [ './node_modules/jquery-form/src/jquery.form.js' ],
    191193                                                [ WORKING_DIR + 'wp-includes/js/masonry.min.js' ]: [ './node_modules/masonry-layout/dist/masonry.pkgd.min.js' ],
    192194                                                [ WORKING_DIR + 'wp-includes/js/twemoji.js' ]: [ './node_modules/twemoji/dist/twemoji.js' ],
  • package.json

     
    134134                "formdata-polyfill": "3.0.13",
    135135                "hoverintent": "2.2.1",
    136136                "imagesloaded": "4.1.4",
     137                "jquery": "3.5.1",
    137138                "jquery-color": "https://github.com/jquery/jquery-color/archive/2.1.2.tar.gz",
    138139                "jquery-form": "4.2.1",
    139140                "jquery-hoverintent": "1.8.3",
  • src/js/_enqueues/vendor/jquery/jquery.js

     
    1 /*!
    2  * jQuery JavaScript Library v3.5.1
    3  * https://jquery.com/
    4  *
    5  * Includes Sizzle.js
    6  * https://sizzlejs.com/
    7  *
    8  * Copyright JS Foundation and other contributors
    9  * Released under the MIT license
    10  * https://jquery.org/license
    11  *
    12  * Date: 2020-05-04T22:49Z
    13  */
    14 ( function( global, factory ) {
    15 
    16         "use strict";
    17 
    18         if ( typeof module === "object" && typeof module.exports === "object" ) {
    19 
    20                 // For CommonJS and CommonJS-like environments where a proper `window`
    21                 // is present, execute the factory and get jQuery.
    22                 // For environments that do not have a `window` with a `document`
    23                 // (such as Node.js), expose a factory as module.exports.
    24                 // This accentuates the need for the creation of a real `window`.
    25                 // e.g. var jQuery = require("jquery")(window);
    26                 // See ticket #14549 for more info.
    27                 module.exports = global.document ?
    28                         factory( global, true ) :
    29                         function( w ) {
    30                                 if ( !w.document ) {
    31                                         throw new Error( "jQuery requires a window with a document" );
    32                                 }
    33                                 return factory( w );
    34                         };
    35         } else {
    36                 factory( global );
    37         }
    38 
    39 // Pass this if window is not defined yet
    40 } )( typeof window !== "undefined" ? window : this, function( window, noGlobal ) {
    41 
    42 // Edge <= 12 - 13+, Firefox <=18 - 45+, IE 10 - 11, Safari 5.1 - 9+, iOS 6 - 9.1
    43 // throw exceptions when non-strict code (e.g., ASP.NET 4.5) accesses strict mode
    44 // arguments.callee.caller (trac-13335). But as of jQuery 3.0 (2016), strict mode should be common
    45 // enough that all such attempts are guarded in a try block.
    46 "use strict";
    47 
    48 var arr = [];
    49 
    50 var getProto = Object.getPrototypeOf;
    51 
    52 var slice = arr.slice;
    53 
    54 var flat = arr.flat ? function( array ) {
    55         return arr.flat.call( array );
    56 } : function( array ) {
    57         return arr.concat.apply( [], array );
    58 };
    59 
    60 
    61 var push = arr.push;
    62 
    63 var indexOf = arr.indexOf;
    64 
    65 var class2type = {};
    66 
    67 var toString = class2type.toString;
    68 
    69 var hasOwn = class2type.hasOwnProperty;
    70 
    71 var fnToString = hasOwn.toString;
    72 
    73 var ObjectFunctionString = fnToString.call( Object );
    74 
    75 var support = {};
    76 
    77 var isFunction = function isFunction( obj ) {
    78 
    79       // Support: Chrome <=57, Firefox <=52
    80       // In some browsers, typeof returns "function" for HTML <object> elements
    81       // (i.e., `typeof document.createElement( "object" ) === "function"`).
    82       // We don't want to classify *any* DOM node as a function.
    83       return typeof obj === "function" && typeof obj.nodeType !== "number";
    84   };
    85 
    86 
    87 var isWindow = function isWindow( obj ) {
    88                 return obj != null && obj === obj.window;
    89         };
    90 
    91 
    92 var document = window.document;
    93 
    94 
    95 
    96         var preservedScriptAttributes = {
    97                 type: true,
    98                 src: true,
    99                 nonce: true,
    100                 noModule: true
    101         };
    102 
    103         function DOMEval( code, node, doc ) {
    104                 doc = doc || document;
    105 
    106                 var i, val,
    107                         script = doc.createElement( "script" );
    108 
    109                 script.text = code;
    110                 if ( node ) {
    111                         for ( i in preservedScriptAttributes ) {
    112 
    113                                 // Support: Firefox 64+, Edge 18+
    114                                 // Some browsers don't support the "nonce" property on scripts.
    115                                 // On the other hand, just using `getAttribute` is not enough as
    116                                 // the `nonce` attribute is reset to an empty string whenever it
    117                                 // becomes browsing-context connected.
    118                                 // See https://github.com/whatwg/html/issues/2369
    119                                 // See https://html.spec.whatwg.org/#nonce-attributes
    120                                 // The `node.getAttribute` check was added for the sake of
    121                                 // `jQuery.globalEval` so that it can fake a nonce-containing node
    122                                 // via an object.
    123                                 val = node[ i ] || node.getAttribute && node.getAttribute( i );
    124                                 if ( val ) {
    125                                         script.setAttribute( i, val );
    126                                 }
    127                         }
    128                 }
    129                 doc.head.appendChild( script ).parentNode.removeChild( script );
    130         }
    131 
    132 
    133 function toType( obj ) {
    134         if ( obj == null ) {
    135                 return obj + "";
    136         }
    137 
    138         // Support: Android <=2.3 only (functionish RegExp)
    139         return typeof obj === "object" || typeof obj === "function" ?
    140                 class2type[ toString.call( obj ) ] || "object" :
    141                 typeof obj;
    142 }
    143 /* global Symbol */
    144 // Defining this global in .eslintrc.json would create a danger of using the global
    145 // unguarded in another place, it seems safer to define global only for this module
    146 
    147 
    148 
    149 var
    150         version = "3.5.1",
    151 
    152         // Define a local copy of jQuery
    153         jQuery = function( selector, context ) {
    154 
    155                 // The jQuery object is actually just the init constructor 'enhanced'
    156                 // Need init if jQuery is called (just allow error to be thrown if not included)
    157                 return new jQuery.fn.init( selector, context );
    158         };
    159 
    160 jQuery.fn = jQuery.prototype = {
    161 
    162         // The current version of jQuery being used
    163         jquery: version,
    164 
    165         constructor: jQuery,
    166 
    167         // The default length of a jQuery object is 0
    168         length: 0,
    169 
    170         toArray: function() {
    171                 return slice.call( this );
    172         },
    173 
    174         // Get the Nth element in the matched element set OR
    175         // Get the whole matched element set as a clean array
    176         get: function( num ) {
    177 
    178                 // Return all the elements in a clean array
    179                 if ( num == null ) {
    180                         return slice.call( this );
    181                 }
    182 
    183                 // Return just the one element from the set
    184                 return num < 0 ? this[ num + this.length ] : this[ num ];
    185         },
    186 
    187         // Take an array of elements and push it onto the stack
    188         // (returning the new matched element set)
    189         pushStack: function( elems ) {
    190 
    191                 // Build a new jQuery matched element set
    192                 var ret = jQuery.merge( this.constructor(), elems );
    193 
    194                 // Add the old object onto the stack (as a reference)
    195                 ret.prevObject = this;
    196 
    197                 // Return the newly-formed element set
    198                 return ret;
    199         },
    200 
    201         // Execute a callback for every element in the matched set.
    202         each: function( callback ) {
    203                 return jQuery.each( this, callback );
    204         },
    205 
    206         map: function( callback ) {
    207                 return this.pushStack( jQuery.map( this, function( elem, i ) {
    208                         return callback.call( elem, i, elem );
    209                 } ) );
    210         },
    211 
    212         slice: function() {
    213                 return this.pushStack( slice.apply( this, arguments ) );
    214         },
    215 
    216         first: function() {
    217                 return this.eq( 0 );
    218         },
    219 
    220         last: function() {
    221                 return this.eq( -1 );
    222         },
    223 
    224         even: function() {
    225                 return this.pushStack( jQuery.grep( this, function( _elem, i ) {
    226                         return ( i + 1 ) % 2;
    227                 } ) );
    228         },
    229 
    230         odd: function() {
    231                 return this.pushStack( jQuery.grep( this, function( _elem, i ) {
    232                         return i % 2;
    233                 } ) );
    234         },
    235 
    236         eq: function( i ) {
    237                 var len = this.length,
    238                         j = +i + ( i < 0 ? len : 0 );
    239                 return this.pushStack( j >= 0 && j < len ? [ this[ j ] ] : [] );
    240         },
    241 
    242         end: function() {
    243                 return this.prevObject || this.constructor();
    244         },
    245 
    246         // For internal use only.
    247         // Behaves like an Array's method, not like a jQuery method.
    248         push: push,
    249         sort: arr.sort,
    250         splice: arr.splice
    251 };
    252 
    253 jQuery.extend = jQuery.fn.extend = function() {
    254         var options, name, src, copy, copyIsArray, clone,
    255                 target = arguments[ 0 ] || {},
    256                 i = 1,
    257                 length = arguments.length,
    258                 deep = false;
    259 
    260         // Handle a deep copy situation
    261         if ( typeof target === "boolean" ) {
    262                 deep = target;
    263 
    264                 // Skip the boolean and the target
    265                 target = arguments[ i ] || {};
    266                 i++;
    267         }
    268 
    269         // Handle case when target is a string or something (possible in deep copy)
    270         if ( typeof target !== "object" && !isFunction( target ) ) {
    271                 target = {};
    272         }
    273 
    274         // Extend jQuery itself if only one argument is passed
    275         if ( i === length ) {
    276                 target = this;
    277                 i--;
    278         }
    279 
    280         for ( ; i < length; i++ ) {
    281 
    282                 // Only deal with non-null/undefined values
    283                 if ( ( options = arguments[ i ] ) != null ) {
    284 
    285                         // Extend the base object
    286                         for ( name in options ) {
    287                                 copy = options[ name ];
    288 
    289                                 // Prevent Object.prototype pollution
    290                                 // Prevent never-ending loop
    291                                 if ( name === "__proto__" || target === copy ) {
    292                                         continue;
    293                                 }
    294 
    295                                 // Recurse if we're merging plain objects or arrays
    296                                 if ( deep && copy && ( jQuery.isPlainObject( copy ) ||
    297                                         ( copyIsArray = Array.isArray( copy ) ) ) ) {
    298                                         src = target[ name ];
    299 
    300                                         // Ensure proper type for the source value
    301                                         if ( copyIsArray && !Array.isArray( src ) ) {
    302                                                 clone = [];
    303                                         } else if ( !copyIsArray && !jQuery.isPlainObject( src ) ) {
    304                                                 clone = {};
    305                                         } else {
    306                                                 clone = src;
    307                                         }
    308                                         copyIsArray = false;
    309 
    310                                         // Never move original objects, clone them
    311                                         target[ name ] = jQuery.extend( deep, clone, copy );
    312 
    313                                 // Don't bring in undefined values
    314                                 } else if ( copy !== undefined ) {
    315                                         target[ name ] = copy;
    316                                 }
    317                         }
    318                 }
    319         }
    320 
    321         // Return the modified object
    322         return target;
    323 };
    324 
    325 jQuery.extend( {
    326 
    327         // Unique for each copy of jQuery on the page
    328         expando: "jQuery" + ( version + Math.random() ).replace( /\D/g, "" ),
    329 
    330         // Assume jQuery is ready without the ready module
    331         isReady: true,
    332 
    333         error: function( msg ) {
    334                 throw new Error( msg );
    335         },
    336 
    337         noop: function() {},
    338 
    339         isPlainObject: function( obj ) {
    340                 var proto, Ctor;
    341 
    342                 // Detect obvious negatives
    343                 // Use toString instead of jQuery.type to catch host objects
    344                 if ( !obj || toString.call( obj ) !== "[object Object]" ) {
    345                         return false;
    346                 }
    347 
    348                 proto = getProto( obj );
    349 
    350                 // Objects with no prototype (e.g., `Object.create( null )`) are plain
    351                 if ( !proto ) {
    352                         return true;
    353                 }
    354 
    355                 // Objects with prototype are plain iff they were constructed by a global Object function
    356                 Ctor = hasOwn.call( proto, "constructor" ) && proto.constructor;
    357                 return typeof Ctor === "function" && fnToString.call( Ctor ) === ObjectFunctionString;
    358         },
    359 
    360         isEmptyObject: function( obj ) {
    361                 var name;
    362 
    363                 for ( name in obj ) {
    364                         return false;
    365                 }
    366                 return true;
    367         },
    368 
    369         // Evaluates a script in a provided context; falls back to the global one
    370         // if not specified.
    371         globalEval: function( code, options, doc ) {
    372                 DOMEval( code, { nonce: options && options.nonce }, doc );
    373         },
    374 
    375         each: function( obj, callback ) {
    376                 var length, i = 0;
    377 
    378                 if ( isArrayLike( obj ) ) {
    379                         length = obj.length;
    380                         for ( ; i < length; i++ ) {
    381                                 if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {
    382                                         break;
    383                                 }
    384                         }
    385                 } else {
    386                         for ( i in obj ) {
    387                                 if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {
    388                                         break;
    389                                 }
    390                         }
    391                 }
    392 
    393                 return obj;
    394         },
    395 
    396         // results is for internal usage only
    397         makeArray: function( arr, results ) {
    398                 var ret = results || [];
    399 
    400                 if ( arr != null ) {
    401                         if ( isArrayLike( Object( arr ) ) ) {
    402                                 jQuery.merge( ret,
    403                                         typeof arr === "string" ?
    404                                         [ arr ] : arr
    405                                 );
    406                         } else {
    407                                 push.call( ret, arr );
    408                         }
    409                 }
    410 
    411                 return ret;
    412         },
    413 
    414         inArray: function( elem, arr, i ) {
    415                 return arr == null ? -1 : indexOf.call( arr, elem, i );
    416         },
    417 
    418         // Support: Android <=4.0 only, PhantomJS 1 only
    419         // push.apply(_, arraylike) throws on ancient WebKit
    420         merge: function( first, second ) {
    421                 var len = +second.length,
    422                         j = 0,
    423                         i = first.length;
    424 
    425                 for ( ; j < len; j++ ) {
    426                         first[ i++ ] = second[ j ];
    427                 }
    428 
    429                 first.length = i;
    430 
    431                 return first;
    432         },
    433 
    434         grep: function( elems, callback, invert ) {
    435                 var callbackInverse,
    436                         matches = [],
    437                         i = 0,
    438                         length = elems.length,
    439                         callbackExpect = !invert;
    440 
    441                 // Go through the array, only saving the items
    442                 // that pass the validator function
    443                 for ( ; i < length; i++ ) {
    444                         callbackInverse = !callback( elems[ i ], i );
    445                         if ( callbackInverse !== callbackExpect ) {
    446                                 matches.push( elems[ i ] );
    447                         }
    448                 }
    449 
    450                 return matches;
    451         },
    452 
    453         // arg is for internal usage only
    454         map: function( elems, callback, arg ) {
    455                 var length, value,
    456                         i = 0,
    457                         ret = [];
    458 
    459                 // Go through the array, translating each of the items to their new values
    460                 if ( isArrayLike( elems ) ) {
    461                         length = elems.length;
    462                         for ( ; i < length; i++ ) {
    463                                 value = callback( elems[ i ], i, arg );
    464 
    465                                 if ( value != null ) {
    466                                         ret.push( value );
    467                                 }
    468                         }
    469 
    470                 // Go through every key on the object,
    471                 } else {
    472                         for ( i in elems ) {
    473                                 value = callback( elems[ i ], i, arg );
    474 
    475                                 if ( value != null ) {
    476                                         ret.push( value );
    477                                 }
    478                         }
    479                 }
    480 
    481                 // Flatten any nested arrays
    482                 return flat( ret );
    483         },
    484 
    485         // A global GUID counter for objects
    486         guid: 1,
    487 
    488         // jQuery.support is not used in Core but other projects attach their
    489         // properties to it so it needs to exist.
    490         support: support
    491 } );
    492 
    493 if ( typeof Symbol === "function" ) {
    494         jQuery.fn[ Symbol.iterator ] = arr[ Symbol.iterator ];
    495 }
    496 
    497 // Populate the class2type map
    498 jQuery.each( "Boolean Number String Function Array Date RegExp Object Error Symbol".split( " " ),
    499 function( _i, name ) {
    500         class2type[ "[object " + name + "]" ] = name.toLowerCase();
    501 } );
    502 
    503 function isArrayLike( obj ) {
    504 
    505         // Support: real iOS 8.2 only (not reproducible in simulator)
    506         // `in` check used to prevent JIT error (gh-2145)
    507         // hasOwn isn't used here due to false negatives
    508         // regarding Nodelist length in IE
    509         var length = !!obj && "length" in obj && obj.length,
    510                 type = toType( obj );
    511 
    512         if ( isFunction( obj ) || isWindow( obj ) ) {
    513                 return false;
    514         }
    515 
    516         return type === "array" || length === 0 ||
    517                 typeof length === "number" && length > 0 && ( length - 1 ) in obj;
    518 }
    519 var Sizzle =
    520 /*!
    521  * Sizzle CSS Selector Engine v2.3.5
    522  * https://sizzlejs.com/
    523  *
    524  * Copyright JS Foundation and other contributors
    525  * Released under the MIT license
    526  * https://js.foundation/
    527  *
    528  * Date: 2020-03-14
    529  */
    530 ( function( window ) {
    531 var i,
    532         support,
    533         Expr,
    534         getText,
    535         isXML,
    536         tokenize,
    537         compile,
    538         select,
    539         outermostContext,
    540         sortInput,
    541         hasDuplicate,
    542 
    543         // Local document vars
    544         setDocument,
    545         document,
    546         docElem,
    547         documentIsHTML,
    548         rbuggyQSA,
    549         rbuggyMatches,
    550         matches,
    551         contains,
    552 
    553         // Instance-specific data
    554         expando = "sizzle" + 1 * new Date(),
    555         preferredDoc = window.document,
    556         dirruns = 0,
    557         done = 0,
    558         classCache = createCache(),
    559         tokenCache = createCache(),
    560         compilerCache = createCache(),
    561         nonnativeSelectorCache = createCache(),
    562         sortOrder = function( a, b ) {
    563                 if ( a === b ) {
    564                         hasDuplicate = true;
    565                 }
    566                 return 0;
    567         },
    568 
    569         // Instance methods
    570         hasOwn = ( {} ).hasOwnProperty,
    571         arr = [],
    572         pop = arr.pop,
    573         pushNative = arr.push,
    574         push = arr.push,
    575         slice = arr.slice,
    576 
    577         // Use a stripped-down indexOf as it's faster than native
    578         // https://jsperf.com/thor-indexof-vs-for/5
    579         indexOf = function( list, elem ) {
    580                 var i = 0,
    581                         len = list.length;
    582                 for ( ; i < len; i++ ) {
    583                         if ( list[ i ] === elem ) {
    584                                 return i;
    585                         }
    586                 }
    587                 return -1;
    588         },
    589 
    590         booleans = "checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|" +
    591                 "ismap|loop|multiple|open|readonly|required|scoped",
    592 
    593         // Regular expressions
    594 
    595         // http://www.w3.org/TR/css3-selectors/#whitespace
    596         whitespace = "[\\x20\\t\\r\\n\\f]",
    597 
    598         // https://www.w3.org/TR/css-syntax-3/#ident-token-diagram
    599         identifier = "(?:\\\\[\\da-fA-F]{1,6}" + whitespace +
    600                 "?|\\\\[^\\r\\n\\f]|[\\w-]|[^\0-\\x7f])+",
    601 
    602         // Attribute selectors: http://www.w3.org/TR/selectors/#attribute-selectors
    603         attributes = "\\[" + whitespace + "*(" + identifier + ")(?:" + whitespace +
    604 
    605                 // Operator (capture 2)
    606                 "*([*^$|!~]?=)" + whitespace +
    607 
    608                 // "Attribute values must be CSS identifiers [capture 5]
    609                 // or strings [capture 3 or capture 4]"
    610                 "*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|(" + identifier + "))|)" +
    611                 whitespace + "*\\]",
    612 
    613         pseudos = ":(" + identifier + ")(?:\\((" +
    614 
    615                 // To reduce the number of selectors needing tokenize in the preFilter, prefer arguments:
    616                 // 1. quoted (capture 3; capture 4 or capture 5)
    617                 "('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|" +
    618 
    619                 // 2. simple (capture 6)
    620                 "((?:\\\\.|[^\\\\()[\\]]|" + attributes + ")*)|" +
    621 
    622                 // 3. anything else (capture 2)
    623                 ".*" +
    624                 ")\\)|)",
    625 
    626         // Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter
    627         rwhitespace = new RegExp( whitespace + "+", "g" ),
    628         rtrim = new RegExp( "^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" +
    629                 whitespace + "+$", "g" ),
    630 
    631         rcomma = new RegExp( "^" + whitespace + "*," + whitespace + "*" ),
    632         rcombinators = new RegExp( "^" + whitespace + "*([>+~]|" + whitespace + ")" + whitespace +
    633                 "*" ),
    634         rdescend = new RegExp( whitespace + "|>" ),
    635 
    636         rpseudo = new RegExp( pseudos ),
    637         ridentifier = new RegExp( "^" + identifier + "$" ),
    638 
    639         matchExpr = {
    640                 "ID": new RegExp( "^#(" + identifier + ")" ),
    641                 "CLASS": new RegExp( "^\\.(" + identifier + ")" ),
    642                 "TAG": new RegExp( "^(" + identifier + "|[*])" ),
    643                 "ATTR": new RegExp( "^" + attributes ),
    644                 "PSEUDO": new RegExp( "^" + pseudos ),
    645                 "CHILD": new RegExp( "^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(" +
    646                         whitespace + "*(even|odd|(([+-]|)(\\d*)n|)" + whitespace + "*(?:([+-]|)" +
    647                         whitespace + "*(\\d+)|))" + whitespace + "*\\)|)", "i" ),
    648                 "bool": new RegExp( "^(?:" + booleans + ")$", "i" ),
    649 
    650                 // For use in libraries implementing .is()
    651                 // We use this for POS matching in `select`
    652                 "needsContext": new RegExp( "^" + whitespace +
    653                         "*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(" + whitespace +
    654                         "*((?:-\\d)?\\d*)" + whitespace + "*\\)|)(?=[^-]|$)", "i" )
    655         },
    656 
    657         rhtml = /HTML$/i,
    658         rinputs = /^(?:input|select|textarea|button)$/i,
    659         rheader = /^h\d$/i,
    660 
    661         rnative = /^[^{]+\{\s*\[native \w/,
    662 
    663         // Easily-parseable/retrievable ID or TAG or CLASS selectors
    664         rquickExpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,
    665 
    666         rsibling = /[+~]/,
    667 
    668         // CSS escapes
    669         // http://www.w3.org/TR/CSS21/syndata.html#escaped-characters
    670         runescape = new RegExp( "\\\\[\\da-fA-F]{1,6}" + whitespace + "?|\\\\([^\\r\\n\\f])", "g" ),
    671         funescape = function( escape, nonHex ) {
    672                 var high = "0x" + escape.slice( 1 ) - 0x10000;
    673 
    674                 return nonHex ?
    675 
    676                         // Strip the backslash prefix from a non-hex escape sequence
    677                         nonHex :
    678 
    679                         // Replace a hexadecimal escape sequence with the encoded Unicode code point
    680                         // Support: IE <=11+
    681                         // For values outside the Basic Multilingual Plane (BMP), manually construct a
    682                         // surrogate pair
    683                         high < 0 ?
    684                                 String.fromCharCode( high + 0x10000 ) :
    685                                 String.fromCharCode( high >> 10 | 0xD800, high & 0x3FF | 0xDC00 );
    686         },
    687 
    688         // CSS string/identifier serialization
    689         // https://drafts.csswg.org/cssom/#common-serializing-idioms
    690         rcssescape = /([\0-\x1f\x7f]|^-?\d)|^-$|[^\0-\x1f\x7f-\uFFFF\w-]/g,
    691         fcssescape = function( ch, asCodePoint ) {
    692                 if ( asCodePoint ) {
    693 
    694                         // U+0000 NULL becomes U+FFFD REPLACEMENT CHARACTER
    695                         if ( ch === "\0" ) {
    696                                 return "\uFFFD";
    697                         }
    698 
    699                         // Control characters and (dependent upon position) numbers get escaped as code points
    700                         return ch.slice( 0, -1 ) + "\\" +
    701                                 ch.charCodeAt( ch.length - 1 ).toString( 16 ) + " ";
    702                 }
    703 
    704                 // Other potentially-special ASCII characters get backslash-escaped
    705                 return "\\" + ch;
    706         },
    707 
    708         // Used for iframes
    709         // See setDocument()
    710         // Removing the function wrapper causes a "Permission Denied"
    711         // error in IE
    712         unloadHandler = function() {
    713                 setDocument();
    714         },
    715 
    716         inDisabledFieldset = addCombinator(
    717                 function( elem ) {
    718                         return elem.disabled === true && elem.nodeName.toLowerCase() === "fieldset";
    719                 },
    720                 { dir: "parentNode", next: "legend" }
    721         );
    722 
    723 // Optimize for push.apply( _, NodeList )
    724 try {
    725         push.apply(
    726                 ( arr = slice.call( preferredDoc.childNodes ) ),
    727                 preferredDoc.childNodes
    728         );
    729 
    730         // Support: Android<4.0
    731         // Detect silently failing push.apply
    732         // eslint-disable-next-line no-unused-expressions
    733         arr[ preferredDoc.childNodes.length ].nodeType;
    734 } catch ( e ) {
    735         push = { apply: arr.length ?
    736 
    737                 // Leverage slice if possible
    738                 function( target, els ) {
    739                         pushNative.apply( target, slice.call( els ) );
    740                 } :
    741 
    742                 // Support: IE<9
    743                 // Otherwise append directly
    744                 function( target, els ) {
    745                         var j = target.length,
    746                                 i = 0;
    747 
    748                         // Can't trust NodeList.length
    749                         while ( ( target[ j++ ] = els[ i++ ] ) ) {}
    750                         target.length = j - 1;
    751                 }
    752         };
    753 }
    754 
    755 function Sizzle( selector, context, results, seed ) {
    756         var m, i, elem, nid, match, groups, newSelector,
    757                 newContext = context && context.ownerDocument,
    758 
    759                 // nodeType defaults to 9, since context defaults to document
    760                 nodeType = context ? context.nodeType : 9;
    761 
    762         results = results || [];
    763 
    764         // Return early from calls with invalid selector or context
    765         if ( typeof selector !== "string" || !selector ||
    766                 nodeType !== 1 && nodeType !== 9 && nodeType !== 11 ) {
    767 
    768                 return results;
    769         }
    770 
    771         // Try to shortcut find operations (as opposed to filters) in HTML documents
    772         if ( !seed ) {
    773                 setDocument( context );
    774                 context = context || document;
    775 
    776                 if ( documentIsHTML ) {
    777 
    778                         // If the selector is sufficiently simple, try using a "get*By*" DOM method
    779                         // (excepting DocumentFragment context, where the methods don't exist)
    780                         if ( nodeType !== 11 && ( match = rquickExpr.exec( selector ) ) ) {
    781 
    782                                 // ID selector
    783                                 if ( ( m = match[ 1 ] ) ) {
    784 
    785                                         // Document context
    786                                         if ( nodeType === 9 ) {
    787                                                 if ( ( elem = context.getElementById( m ) ) ) {
    788 
    789                                                         // Support: IE, Opera, Webkit
    790                                                         // TODO: identify versions
    791                                                         // getElementById can match elements by name instead of ID
    792                                                         if ( elem.id === m ) {
    793                                                                 results.push( elem );
    794                                                                 return results;
    795                                                         }
    796                                                 } else {
    797                                                         return results;
    798                                                 }
    799 
    800                                         // Element context
    801                                         } else {
    802 
    803                                                 // Support: IE, Opera, Webkit
    804                                                 // TODO: identify versions
    805                                                 // getElementById can match elements by name instead of ID
    806                                                 if ( newContext && ( elem = newContext.getElementById( m ) ) &&
    807                                                         contains( context, elem ) &&
    808                                                         elem.id === m ) {
    809 
    810                                                         results.push( elem );
    811                                                         return results;
    812                                                 }
    813                                         }
    814 
    815                                 // Type selector
    816                                 } else if ( match[ 2 ] ) {
    817                                         push.apply( results, context.getElementsByTagName( selector ) );
    818                                         return results;
    819 
    820                                 // Class selector
    821                                 } else if ( ( m = match[ 3 ] ) && support.getElementsByClassName &&
    822                                         context.getElementsByClassName ) {
    823 
    824                                         push.apply( results, context.getElementsByClassName( m ) );
    825                                         return results;
    826                                 }
    827                         }
    828 
    829                         // Take advantage of querySelectorAll
    830                         if ( support.qsa &&
    831                                 !nonnativeSelectorCache[ selector + " " ] &&
    832                                 ( !rbuggyQSA || !rbuggyQSA.test( selector ) ) &&
    833 
    834                                 // Support: IE 8 only
    835                                 // Exclude object elements
    836                                 ( nodeType !== 1 || context.nodeName.toLowerCase() !== "object" ) ) {
    837 
    838                                 newSelector = selector;
    839                                 newContext = context;
    840 
    841                                 // qSA considers elements outside a scoping root when evaluating child or
    842                                 // descendant combinators, which is not what we want.
    843                                 // In such cases, we work around the behavior by prefixing every selector in the
    844                                 // list with an ID selector referencing the scope context.
    845                                 // The technique has to be used as well when a leading combinator is used
    846                                 // as such selectors are not recognized by querySelectorAll.
    847                                 // Thanks to Andrew Dupont for this technique.
    848                                 if ( nodeType === 1 &&
    849                                         ( rdescend.test( selector ) || rcombinators.test( selector ) ) ) {
    850 
    851                                         // Expand context for sibling selectors
    852                                         newContext = rsibling.test( selector ) && testContext( context.parentNode ) ||
    853                                                 context;
    854 
    855                                         // We can use :scope instead of the ID hack if the browser
    856                                         // supports it & if we're not changing the context.
    857                                         if ( newContext !== context || !support.scope ) {
    858 
    859                                                 // Capture the context ID, setting it first if necessary
    860                                                 if ( ( nid = context.getAttribute( "id" ) ) ) {
    861                                                         nid = nid.replace( rcssescape, fcssescape );
    862                                                 } else {
    863                                                         context.setAttribute( "id", ( nid = expando ) );
    864                                                 }
    865                                         }
    866 
    867                                         // Prefix every selector in the list
    868                                         groups = tokenize( selector );
    869                                         i = groups.length;
    870                                         while ( i-- ) {
    871                                                 groups[ i ] = ( nid ? "#" + nid : ":scope" ) + " " +
    872                                                         toSelector( groups[ i ] );
    873                                         }
    874                                         newSelector = groups.join( "," );
    875                                 }
    876 
    877                                 try {
    878                                         push.apply( results,
    879                                                 newContext.querySelectorAll( newSelector )
    880                                         );
    881                                         return results;
    882                                 } catch ( qsaError ) {
    883                                         nonnativeSelectorCache( selector, true );
    884                                 } finally {
    885                                         if ( nid === expando ) {
    886                                                 context.removeAttribute( "id" );
    887                                         }
    888                                 }
    889                         }
    890                 }
    891         }
    892 
    893         // All others
    894         return select( selector.replace( rtrim, "$1" ), context, results, seed );
    895 }
    896 
    897 /**
    898  * Create key-value caches of limited size
    899  * @returns {function(string, object)} Returns the Object data after storing it on itself with
    900  *      property name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength)
    901  *      deleting the oldest entry
    902  */
    903 function createCache() {
    904         var keys = [];
    905 
    906         function cache( key, value ) {
    907 
    908                 // Use (key + " ") to avoid collision with native prototype properties (see Issue #157)
    909                 if ( keys.push( key + " " ) > Expr.cacheLength ) {
    910 
    911                         // Only keep the most recent entries
    912                         delete cache[ keys.shift() ];
    913                 }
    914                 return ( cache[ key + " " ] = value );
    915         }
    916         return cache;
    917 }
    918 
    919 /**
    920  * Mark a function for special use by Sizzle
    921  * @param {Function} fn The function to mark
    922  */
    923 function markFunction( fn ) {
    924         fn[ expando ] = true;
    925         return fn;
    926 }
    927 
    928 /**
    929  * Support testing using an element
    930  * @param {Function} fn Passed the created element and returns a boolean result
    931  */
    932 function assert( fn ) {
    933         var el = document.createElement( "fieldset" );
    934 
    935         try {
    936                 return !!fn( el );
    937         } catch ( e ) {
    938                 return false;
    939         } finally {
    940 
    941                 // Remove from its parent by default
    942                 if ( el.parentNode ) {
    943                         el.parentNode.removeChild( el );
    944                 }
    945 
    946                 // release memory in IE
    947                 el = null;
    948         }
    949 }
    950 
    951 /**
    952  * Adds the same handler for all of the specified attrs
    953  * @param {String} attrs Pipe-separated list of attributes
    954  * @param {Function} handler The method that will be applied
    955  */
    956 function addHandle( attrs, handler ) {
    957         var arr = attrs.split( "|" ),
    958                 i = arr.length;
    959 
    960         while ( i-- ) {
    961                 Expr.attrHandle[ arr[ i ] ] = handler;
    962         }
    963 }
    964 
    965 /**
    966  * Checks document order of two siblings
    967  * @param {Element} a
    968  * @param {Element} b
    969  * @returns {Number} Returns less than 0 if a precedes b, greater than 0 if a follows b
    970  */
    971 function siblingCheck( a, b ) {
    972         var cur = b && a,
    973                 diff = cur && a.nodeType === 1 && b.nodeType === 1 &&
    974                         a.sourceIndex - b.sourceIndex;
    975 
    976         // Use IE sourceIndex if available on both nodes
    977         if ( diff ) {
    978                 return diff;
    979         }
    980 
    981         // Check if b follows a
    982         if ( cur ) {
    983                 while ( ( cur = cur.nextSibling ) ) {
    984                         if ( cur === b ) {
    985                                 return -1;
    986                         }
    987                 }
    988         }
    989 
    990         return a ? 1 : -1;
    991 }
    992 
    993 /**
    994  * Returns a function to use in pseudos for input types
    995  * @param {String} type
    996  */
    997 function createInputPseudo( type ) {
    998         return function( elem ) {
    999                 var name = elem.nodeName.toLowerCase();
    1000                 return name === "input" && elem.type === type;
    1001         };
    1002 }
    1003 
    1004 /**
    1005  * Returns a function to use in pseudos for buttons
    1006  * @param {String} type
    1007  */
    1008 function createButtonPseudo( type ) {
    1009         return function( elem ) {
    1010                 var name = elem.nodeName.toLowerCase();
    1011                 return ( name === "input" || name === "button" ) && elem.type === type;
    1012         };
    1013 }
    1014 
    1015 /**
    1016  * Returns a function to use in pseudos for :enabled/:disabled
    1017  * @param {Boolean} disabled true for :disabled; false for :enabled
    1018  */
    1019 function createDisabledPseudo( disabled ) {
    1020 
    1021         // Known :disabled false positives: fieldset[disabled] > legend:nth-of-type(n+2) :can-disable
    1022         return function( elem ) {
    1023 
    1024                 // Only certain elements can match :enabled or :disabled
    1025                 // https://html.spec.whatwg.org/multipage/scripting.html#selector-enabled
    1026                 // https://html.spec.whatwg.org/multipage/scripting.html#selector-disabled
    1027                 if ( "form" in elem ) {
    1028 
    1029                         // Check for inherited disabledness on relevant non-disabled elements:
    1030                         // * listed form-associated elements in a disabled fieldset
    1031                         //   https://html.spec.whatwg.org/multipage/forms.html#category-listed
    1032                         //   https://html.spec.whatwg.org/multipage/forms.html#concept-fe-disabled
    1033                         // * option elements in a disabled optgroup
    1034                         //   https://html.spec.whatwg.org/multipage/forms.html#concept-option-disabled
    1035                         // All such elements have a "form" property.
    1036                         if ( elem.parentNode && elem.disabled === false ) {
    1037 
    1038                                 // Option elements defer to a parent optgroup if present
    1039                                 if ( "label" in elem ) {
    1040                                         if ( "label" in elem.parentNode ) {
    1041                                                 return elem.parentNode.disabled === disabled;
    1042                                         } else {
    1043                                                 return elem.disabled === disabled;
    1044                                         }
    1045                                 }
    1046 
    1047                                 // Support: IE 6 - 11
    1048                                 // Use the isDisabled shortcut property to check for disabled fieldset ancestors
    1049                                 return elem.isDisabled === disabled ||
    1050 
    1051                                         // Where there is no isDisabled, check manually
    1052                                         /* jshint -W018 */
    1053                                         elem.isDisabled !== !disabled &&
    1054                                         inDisabledFieldset( elem ) === disabled;
    1055                         }
    1056 
    1057                         return elem.disabled === disabled;
    1058 
    1059                 // Try to winnow out elements that can't be disabled before trusting the disabled property.
    1060                 // Some victims get caught in our net (label, legend, menu, track), but it shouldn't
    1061                 // even exist on them, let alone have a boolean value.
    1062                 } else if ( "label" in elem ) {
    1063                         return elem.disabled === disabled;
    1064                 }
    1065 
    1066                 // Remaining elements are neither :enabled nor :disabled
    1067                 return false;
    1068         };
    1069 }
    1070 
    1071 /**
    1072  * Returns a function to use in pseudos for positionals
    1073  * @param {Function} fn
    1074  */
    1075 function createPositionalPseudo( fn ) {
    1076         return markFunction( function( argument ) {
    1077                 argument = +argument;
    1078                 return markFunction( function( seed, matches ) {
    1079                         var j,
    1080                                 matchIndexes = fn( [], seed.length, argument ),
    1081                                 i = matchIndexes.length;
    1082 
    1083                         // Match elements found at the specified indexes
    1084                         while ( i-- ) {
    1085                                 if ( seed[ ( j = matchIndexes[ i ] ) ] ) {
    1086                                         seed[ j ] = !( matches[ j ] = seed[ j ] );
    1087                                 }
    1088                         }
    1089                 } );
    1090         } );
    1091 }
    1092 
    1093 /**
    1094  * Checks a node for validity as a Sizzle context
    1095  * @param {Element|Object=} context
    1096  * @returns {Element|Object|Boolean} The input node if acceptable, otherwise a falsy value
    1097  */
    1098 function testContext( context ) {
    1099         return context && typeof context.getElementsByTagName !== "undefined" && context;
    1100 }
    1101 
    1102 // Expose support vars for convenience
    1103 support = Sizzle.support = {};
    1104 
    1105 /**
    1106  * Detects XML nodes
    1107  * @param {Element|Object} elem An element or a document
    1108  * @returns {Boolean} True iff elem is a non-HTML XML node
    1109  */
    1110 isXML = Sizzle.isXML = function( elem ) {
    1111         var namespace = elem.namespaceURI,
    1112                 docElem = ( elem.ownerDocument || elem ).documentElement;
    1113 
    1114         // Support: IE <=8
    1115         // Assume HTML when documentElement doesn't yet exist, such as inside loading iframes
    1116         // https://bugs.jquery.com/ticket/4833
    1117         return !rhtml.test( namespace || docElem && docElem.nodeName || "HTML" );
    1118 };
    1119 
    1120 /**
    1121  * Sets document-related variables once based on the current document
    1122  * @param {Element|Object} [doc] An element or document object to use to set the document
    1123  * @returns {Object} Returns the current document
    1124  */
    1125 setDocument = Sizzle.setDocument = function( node ) {
    1126         var hasCompare, subWindow,
    1127                 doc = node ? node.ownerDocument || node : preferredDoc;
    1128 
    1129         // Return early if doc is invalid or already selected
    1130         // Support: IE 11+, Edge 17 - 18+
    1131         // IE/Edge sometimes throw a "Permission denied" error when strict-comparing
    1132         // two documents; shallow comparisons work.
    1133         // eslint-disable-next-line eqeqeq
    1134         if ( doc == document || doc.nodeType !== 9 || !doc.documentElement ) {
    1135                 return document;
    1136         }
    1137 
    1138         // Update global variables
    1139         document = doc;
    1140         docElem = document.documentElement;
    1141         documentIsHTML = !isXML( document );
    1142 
    1143         // Support: IE 9 - 11+, Edge 12 - 18+
    1144         // Accessing iframe documents after unload throws "permission denied" errors (jQuery #13936)
    1145         // Support: IE 11+, Edge 17 - 18+
    1146         // IE/Edge sometimes throw a "Permission denied" error when strict-comparing
    1147         // two documents; shallow comparisons work.
    1148         // eslint-disable-next-line eqeqeq
    1149         if ( preferredDoc != document &&
    1150                 ( subWindow = document.defaultView ) && subWindow.top !== subWindow ) {
    1151 
    1152                 // Support: IE 11, Edge
    1153                 if ( subWindow.addEventListener ) {
    1154                         subWindow.addEventListener( "unload", unloadHandler, false );
    1155 
    1156                 // Support: IE 9 - 10 only
    1157                 } else if ( subWindow.attachEvent ) {
    1158                         subWindow.attachEvent( "onunload", unloadHandler );
    1159                 }
    1160         }
    1161 
    1162         // Support: IE 8 - 11+, Edge 12 - 18+, Chrome <=16 - 25 only, Firefox <=3.6 - 31 only,
    1163         // Safari 4 - 5 only, Opera <=11.6 - 12.x only
    1164         // IE/Edge & older browsers don't support the :scope pseudo-class.
    1165         // Support: Safari 6.0 only
    1166         // Safari 6.0 supports :scope but it's an alias of :root there.
    1167         support.scope = assert( function( el ) {
    1168                 docElem.appendChild( el ).appendChild( document.createElement( "div" ) );
    1169                 return typeof el.querySelectorAll !== "undefined" &&
    1170                         !el.querySelectorAll( ":scope fieldset div" ).length;
    1171         } );
    1172 
    1173         /* Attributes
    1174         ---------------------------------------------------------------------- */
    1175 
    1176         // Support: IE<8
    1177         // Verify that getAttribute really returns attributes and not properties
    1178         // (excepting IE8 booleans)
    1179         support.attributes = assert( function( el ) {
    1180                 el.className = "i";
    1181                 return !el.getAttribute( "className" );
    1182         } );
    1183 
    1184         /* getElement(s)By*
    1185         ---------------------------------------------------------------------- */
    1186 
    1187         // Check if getElementsByTagName("*") returns only elements
    1188         support.getElementsByTagName = assert( function( el ) {
    1189                 el.appendChild( document.createComment( "" ) );
    1190                 return !el.getElementsByTagName( "*" ).length;
    1191         } );
    1192 
    1193         // Support: IE<9
    1194         support.getElementsByClassName = rnative.test( document.getElementsByClassName );
    1195 
    1196         // Support: IE<10
    1197         // Check if getElementById returns elements by name
    1198         // The broken getElementById methods don't pick up programmatically-set names,
    1199         // so use a roundabout getElementsByName test
    1200         support.getById = assert( function( el ) {
    1201                 docElem.appendChild( el ).id = expando;
    1202                 return !document.getElementsByName || !document.getElementsByName( expando ).length;
    1203         } );
    1204 
    1205         // ID filter and find
    1206         if ( support.getById ) {
    1207                 Expr.filter[ "ID" ] = function( id ) {
    1208                         var attrId = id.replace( runescape, funescape );
    1209                         return function( elem ) {
    1210                                 return elem.getAttribute( "id" ) === attrId;
    1211                         };
    1212                 };
    1213                 Expr.find[ "ID" ] = function( id, context ) {
    1214                         if ( typeof context.getElementById !== "undefined" && documentIsHTML ) {
    1215                                 var elem = context.getElementById( id );
    1216                                 return elem ? [ elem ] : [];
    1217                         }
    1218                 };
    1219         } else {
    1220                 Expr.filter[ "ID" ] =  function( id ) {
    1221                         var attrId = id.replace( runescape, funescape );
    1222                         return function( elem ) {
    1223                                 var node = typeof elem.getAttributeNode !== "undefined" &&
    1224                                         elem.getAttributeNode( "id" );
    1225                                 return node && node.value === attrId;
    1226                         };
    1227                 };
    1228 
    1229                 // Support: IE 6 - 7 only
    1230                 // getElementById is not reliable as a find shortcut
    1231                 Expr.find[ "ID" ] = function( id, context ) {
    1232                         if ( typeof context.getElementById !== "undefined" && documentIsHTML ) {
    1233                                 var node, i, elems,
    1234                                         elem = context.getElementById( id );
    1235 
    1236                                 if ( elem ) {
    1237 
    1238                                         // Verify the id attribute
    1239                                         node = elem.getAttributeNode( "id" );
    1240                                         if ( node && node.value === id ) {
    1241                                                 return [ elem ];
    1242                                         }
    1243 
    1244                                         // Fall back on getElementsByName
    1245                                         elems = context.getElementsByName( id );
    1246                                         i = 0;
    1247                                         while ( ( elem = elems[ i++ ] ) ) {
    1248                                                 node = elem.getAttributeNode( "id" );
    1249                                                 if ( node && node.value === id ) {
    1250                                                         return [ elem ];
    1251                                                 }
    1252                                         }
    1253                                 }
    1254 
    1255                                 return [];
    1256                         }
    1257                 };
    1258         }
    1259 
    1260         // Tag
    1261         Expr.find[ "TAG" ] = support.getElementsByTagName ?
    1262                 function( tag, context ) {
    1263                         if ( typeof context.getElementsByTagName !== "undefined" ) {
    1264                                 return context.getElementsByTagName( tag );
    1265 
    1266                         // DocumentFragment nodes don't have gEBTN
    1267                         } else if ( support.qsa ) {
    1268                                 return context.querySelectorAll( tag );
    1269                         }
    1270                 } :
    1271 
    1272                 function( tag, context ) {
    1273                         var elem,
    1274                                 tmp = [],
    1275                                 i = 0,
    1276 
    1277                                 // By happy coincidence, a (broken) gEBTN appears on DocumentFragment nodes too
    1278                                 results = context.getElementsByTagName( tag );
    1279 
    1280                         // Filter out possible comments
    1281                         if ( tag === "*" ) {
    1282                                 while ( ( elem = results[ i++ ] ) ) {
    1283                                         if ( elem.nodeType === 1 ) {
    1284                                                 tmp.push( elem );
    1285                                         }
    1286                                 }
    1287 
    1288                                 return tmp;
    1289                         }
    1290                         return results;
    1291                 };
    1292 
    1293         // Class
    1294         Expr.find[ "CLASS" ] = support.getElementsByClassName && function( className, context ) {
    1295                 if ( typeof context.getElementsByClassName !== "undefined" && documentIsHTML ) {
    1296                         return context.getElementsByClassName( className );
    1297                 }
    1298         };
    1299 
    1300         /* QSA/matchesSelector
    1301         ---------------------------------------------------------------------- */
    1302 
    1303         // QSA and matchesSelector support
    1304 
    1305         // matchesSelector(:active) reports false when true (IE9/Opera 11.5)
    1306         rbuggyMatches = [];
    1307 
    1308         // qSa(:focus) reports false when true (Chrome 21)
    1309         // We allow this because of a bug in IE8/9 that throws an error
    1310         // whenever `document.activeElement` is accessed on an iframe
    1311         // So, we allow :focus to pass through QSA all the time to avoid the IE error
    1312         // See https://bugs.jquery.com/ticket/13378
    1313         rbuggyQSA = [];
    1314 
    1315         if ( ( support.qsa = rnative.test( document.querySelectorAll ) ) ) {
    1316 
    1317                 // Build QSA regex
    1318                 // Regex strategy adopted from Diego Perini
    1319                 assert( function( el ) {
    1320 
    1321                         var input;
    1322 
    1323                         // Select is set to empty string on purpose
    1324                         // This is to test IE's treatment of not explicitly
    1325                         // setting a boolean content attribute,
    1326                         // since its presence should be enough
    1327                         // https://bugs.jquery.com/ticket/12359
    1328                         docElem.appendChild( el ).innerHTML = "<a id='" + expando + "'></a>" +
    1329                                 "<select id='" + expando + "-\r\\' msallowcapture=''>" +
    1330                                 "<option selected=''></option></select>";
    1331 
    1332                         // Support: IE8, Opera 11-12.16
    1333                         // Nothing should be selected when empty strings follow ^= or $= or *=
    1334                         // The test attribute must be unknown in Opera but "safe" for WinRT
    1335                         // https://msdn.microsoft.com/en-us/library/ie/hh465388.aspx#attribute_section
    1336                         if ( el.querySelectorAll( "[msallowcapture^='']" ).length ) {
    1337                                 rbuggyQSA.push( "[*^$]=" + whitespace + "*(?:''|\"\")" );
    1338                         }
    1339 
    1340                         // Support: IE8
    1341                         // Boolean attributes and "value" are not treated correctly
    1342                         if ( !el.querySelectorAll( "[selected]" ).length ) {
    1343                                 rbuggyQSA.push( "\\[" + whitespace + "*(?:value|" + booleans + ")" );
    1344                         }
    1345 
    1346                         // Support: Chrome<29, Android<4.4, Safari<7.0+, iOS<7.0+, PhantomJS<1.9.8+
    1347                         if ( !el.querySelectorAll( "[id~=" + expando + "-]" ).length ) {
    1348                                 rbuggyQSA.push( "~=" );
    1349                         }
    1350 
    1351                         // Support: IE 11+, Edge 15 - 18+
    1352                         // IE 11/Edge don't find elements on a `[name='']` query in some cases.
    1353                         // Adding a temporary attribute to the document before the selection works
    1354                         // around the issue.
    1355                         // Interestingly, IE 10 & older don't seem to have the issue.
    1356                         input = document.createElement( "input" );
    1357                         input.setAttribute( "name", "" );
    1358                         el.appendChild( input );
    1359                         if ( !el.querySelectorAll( "[name='']" ).length ) {
    1360                                 rbuggyQSA.push( "\\[" + whitespace + "*name" + whitespace + "*=" +
    1361                                         whitespace + "*(?:''|\"\")" );
    1362                         }
    1363 
    1364                         // Webkit/Opera - :checked should return selected option elements
    1365                         // http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
    1366                         // IE8 throws error here and will not see later tests
    1367                         if ( !el.querySelectorAll( ":checked" ).length ) {
    1368                                 rbuggyQSA.push( ":checked" );
    1369                         }
    1370 
    1371                         // Support: Safari 8+, iOS 8+
    1372                         // https://bugs.webkit.org/show_bug.cgi?id=136851
    1373                         // In-page `selector#id sibling-combinator selector` fails
    1374                         if ( !el.querySelectorAll( "a#" + expando + "+*" ).length ) {
    1375                                 rbuggyQSA.push( ".#.+[+~]" );
    1376                         }
    1377 
    1378                         // Support: Firefox <=3.6 - 5 only
    1379                         // Old Firefox doesn't throw on a badly-escaped identifier.
    1380                         el.querySelectorAll( "\\\f" );
    1381                         rbuggyQSA.push( "[\\r\\n\\f]" );
    1382                 } );
    1383 
    1384                 assert( function( el ) {
    1385                         el.innerHTML = "<a href='' disabled='disabled'></a>" +
    1386                                 "<select disabled='disabled'><option/></select>";
    1387 
    1388                         // Support: Windows 8 Native Apps
    1389                         // The type and name attributes are restricted during .innerHTML assignment
    1390                         var input = document.createElement( "input" );
    1391                         input.setAttribute( "type", "hidden" );
    1392                         el.appendChild( input ).setAttribute( "name", "D" );
    1393 
    1394                         // Support: IE8
    1395                         // Enforce case-sensitivity of name attribute
    1396                         if ( el.querySelectorAll( "[name=d]" ).length ) {
    1397                                 rbuggyQSA.push( "name" + whitespace + "*[*^$|!~]?=" );
    1398                         }
    1399 
    1400                         // FF 3.5 - :enabled/:disabled and hidden elements (hidden elements are still enabled)
    1401                         // IE8 throws error here and will not see later tests
    1402                         if ( el.querySelectorAll( ":enabled" ).length !== 2 ) {
    1403                                 rbuggyQSA.push( ":enabled", ":disabled" );
    1404                         }
    1405 
    1406                         // Support: IE9-11+
    1407                         // IE's :disabled selector does not pick up the children of disabled fieldsets
    1408                         docElem.appendChild( el ).disabled = true;
    1409                         if ( el.querySelectorAll( ":disabled" ).length !== 2 ) {
    1410                                 rbuggyQSA.push( ":enabled", ":disabled" );
    1411                         }
    1412 
    1413                         // Support: Opera 10 - 11 only
    1414                         // Opera 10-11 does not throw on post-comma invalid pseudos
    1415                         el.querySelectorAll( "*,:x" );
    1416                         rbuggyQSA.push( ",.*:" );
    1417                 } );
    1418         }
    1419 
    1420         if ( ( support.matchesSelector = rnative.test( ( matches = docElem.matches ||
    1421                 docElem.webkitMatchesSelector ||
    1422                 docElem.mozMatchesSelector ||
    1423                 docElem.oMatchesSelector ||
    1424                 docElem.msMatchesSelector ) ) ) ) {
    1425 
    1426                 assert( function( el ) {
    1427 
    1428                         // Check to see if it's possible to do matchesSelector
    1429                         // on a disconnected node (IE 9)
    1430                         support.disconnectedMatch = matches.call( el, "*" );
    1431 
    1432                         // This should fail with an exception
    1433                         // Gecko does not error, returns false instead
    1434                         matches.call( el, "[s!='']:x" );
    1435                         rbuggyMatches.push( "!=", pseudos );
    1436                 } );
    1437         }
    1438 
    1439         rbuggyQSA = rbuggyQSA.length && new RegExp( rbuggyQSA.join( "|" ) );
    1440         rbuggyMatches = rbuggyMatches.length && new RegExp( rbuggyMatches.join( "|" ) );
    1441 
    1442         /* Contains
    1443         ---------------------------------------------------------------------- */
    1444         hasCompare = rnative.test( docElem.compareDocumentPosition );
    1445 
    1446         // Element contains another
    1447         // Purposefully self-exclusive
    1448         // As in, an element does not contain itself
    1449         contains = hasCompare || rnative.test( docElem.contains ) ?
    1450                 function( a, b ) {
    1451                         var adown = a.nodeType === 9 ? a.documentElement : a,
    1452                                 bup = b && b.parentNode;
    1453                         return a === bup || !!( bup && bup.nodeType === 1 && (
    1454                                 adown.contains ?
    1455                                         adown.contains( bup ) :
    1456                                         a.compareDocumentPosition && a.compareDocumentPosition( bup ) & 16
    1457                         ) );
    1458                 } :
    1459                 function( a, b ) {
    1460                         if ( b ) {
    1461                                 while ( ( b = b.parentNode ) ) {
    1462                                         if ( b === a ) {
    1463                                                 return true;
    1464                                         }
    1465                                 }
    1466                         }
    1467                         return false;
    1468                 };
    1469 
    1470         /* Sorting
    1471         ---------------------------------------------------------------------- */
    1472 
    1473         // Document order sorting
    1474         sortOrder = hasCompare ?
    1475         function( a, b ) {
    1476 
    1477                 // Flag for duplicate removal
    1478                 if ( a === b ) {
    1479                         hasDuplicate = true;
    1480                         return 0;
    1481                 }
    1482 
    1483                 // Sort on method existence if only one input has compareDocumentPosition
    1484                 var compare = !a.compareDocumentPosition - !b.compareDocumentPosition;
    1485                 if ( compare ) {
    1486                         return compare;
    1487                 }
    1488 
    1489                 // Calculate position if both inputs belong to the same document
    1490                 // Support: IE 11+, Edge 17 - 18+
    1491                 // IE/Edge sometimes throw a "Permission denied" error when strict-comparing
    1492                 // two documents; shallow comparisons work.
    1493                 // eslint-disable-next-line eqeqeq
    1494                 compare = ( a.ownerDocument || a ) == ( b.ownerDocument || b ) ?
    1495                         a.compareDocumentPosition( b ) :
    1496 
    1497                         // Otherwise we know they are disconnected
    1498                         1;
    1499 
    1500                 // Disconnected nodes
    1501                 if ( compare & 1 ||
    1502                         ( !support.sortDetached && b.compareDocumentPosition( a ) === compare ) ) {
    1503 
    1504                         // Choose the first element that is related to our preferred document
    1505                         // Support: IE 11+, Edge 17 - 18+
    1506                         // IE/Edge sometimes throw a "Permission denied" error when strict-comparing
    1507                         // two documents; shallow comparisons work.
    1508                         // eslint-disable-next-line eqeqeq
    1509                         if ( a == document || a.ownerDocument == preferredDoc &&
    1510                                 contains( preferredDoc, a ) ) {
    1511                                 return -1;
    1512                         }
    1513 
    1514                         // Support: IE 11+, Edge 17 - 18+
    1515                         // IE/Edge sometimes throw a "Permission denied" error when strict-comparing
    1516                         // two documents; shallow comparisons work.
    1517                         // eslint-disable-next-line eqeqeq
    1518                         if ( b == document || b.ownerDocument == preferredDoc &&
    1519                                 contains( preferredDoc, b ) ) {
    1520                                 return 1;
    1521                         }
    1522 
    1523                         // Maintain original order
    1524                         return sortInput ?
    1525                                 ( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) :
    1526                                 0;
    1527                 }
    1528 
    1529                 return compare & 4 ? -1 : 1;
    1530         } :
    1531         function( a, b ) {
    1532 
    1533                 // Exit early if the nodes are identical
    1534                 if ( a === b ) {
    1535                         hasDuplicate = true;
    1536                         return 0;
    1537                 }
    1538 
    1539                 var cur,
    1540                         i = 0,
    1541                         aup = a.parentNode,
    1542                         bup = b.parentNode,
    1543                         ap = [ a ],
    1544                         bp = [ b ];
    1545 
    1546                 // Parentless nodes are either documents or disconnected
    1547                 if ( !aup || !bup ) {
    1548 
    1549                         // Support: IE 11+, Edge 17 - 18+
    1550                         // IE/Edge sometimes throw a "Permission denied" error when strict-comparing
    1551                         // two documents; shallow comparisons work.
    1552                         /* eslint-disable eqeqeq */
    1553                         return a == document ? -1 :
    1554                                 b == document ? 1 :
    1555                                 /* eslint-enable eqeqeq */
    1556                                 aup ? -1 :
    1557                                 bup ? 1 :
    1558                                 sortInput ?
    1559                                 ( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) :
    1560                                 0;
    1561 
    1562                 // If the nodes are siblings, we can do a quick check
    1563                 } else if ( aup === bup ) {
    1564                         return siblingCheck( a, b );
    1565                 }
    1566 
    1567                 // Otherwise we need full lists of their ancestors for comparison
    1568                 cur = a;
    1569                 while ( ( cur = cur.parentNode ) ) {
    1570                         ap.unshift( cur );
    1571                 }
    1572                 cur = b;
    1573                 while ( ( cur = cur.parentNode ) ) {
    1574                         bp.unshift( cur );
    1575                 }
    1576 
    1577                 // Walk down the tree looking for a discrepancy
    1578                 while ( ap[ i ] === bp[ i ] ) {
    1579                         i++;
    1580                 }
    1581 
    1582                 return i ?
    1583 
    1584                         // Do a sibling check if the nodes have a common ancestor
    1585                         siblingCheck( ap[ i ], bp[ i ] ) :
    1586 
    1587                         // Otherwise nodes in our document sort first
    1588                         // Support: IE 11+, Edge 17 - 18+
    1589                         // IE/Edge sometimes throw a "Permission denied" error when strict-comparing
    1590                         // two documents; shallow comparisons work.
    1591                         /* eslint-disable eqeqeq */
    1592                         ap[ i ] == preferredDoc ? -1 :
    1593                         bp[ i ] == preferredDoc ? 1 :
    1594                         /* eslint-enable eqeqeq */
    1595                         0;
    1596         };
    1597 
    1598         return document;
    1599 };
    1600 
    1601 Sizzle.matches = function( expr, elements ) {
    1602         return Sizzle( expr, null, null, elements );
    1603 };
    1604 
    1605 Sizzle.matchesSelector = function( elem, expr ) {
    1606         setDocument( elem );
    1607 
    1608         if ( support.matchesSelector && documentIsHTML &&
    1609                 !nonnativeSelectorCache[ expr + " " ] &&
    1610                 ( !rbuggyMatches || !rbuggyMatches.test( expr ) ) &&
    1611                 ( !rbuggyQSA     || !rbuggyQSA.test( expr ) ) ) {
    1612 
    1613                 try {
    1614                         var ret = matches.call( elem, expr );
    1615 
    1616                         // IE 9's matchesSelector returns false on disconnected nodes
    1617                         if ( ret || support.disconnectedMatch ||
    1618 
    1619                                 // As well, disconnected nodes are said to be in a document
    1620                                 // fragment in IE 9
    1621                                 elem.document && elem.document.nodeType !== 11 ) {
    1622                                 return ret;
    1623                         }
    1624                 } catch ( e ) {
    1625                         nonnativeSelectorCache( expr, true );
    1626                 }
    1627         }
    1628 
    1629         return Sizzle( expr, document, null, [ elem ] ).length > 0;
    1630 };
    1631 
    1632 Sizzle.contains = function( context, elem ) {
    1633 
    1634         // Set document vars if needed
    1635         // Support: IE 11+, Edge 17 - 18+
    1636         // IE/Edge sometimes throw a "Permission denied" error when strict-comparing
    1637         // two documents; shallow comparisons work.
    1638         // eslint-disable-next-line eqeqeq
    1639         if ( ( context.ownerDocument || context ) != document ) {
    1640                 setDocument( context );
    1641         }
    1642         return contains( context, elem );
    1643 };
    1644 
    1645 Sizzle.attr = function( elem, name ) {
    1646 
    1647         // Set document vars if needed
    1648         // Support: IE 11+, Edge 17 - 18+
    1649         // IE/Edge sometimes throw a "Permission denied" error when strict-comparing
    1650         // two documents; shallow comparisons work.
    1651         // eslint-disable-next-line eqeqeq
    1652         if ( ( elem.ownerDocument || elem ) != document ) {
    1653                 setDocument( elem );
    1654         }
    1655 
    1656         var fn = Expr.attrHandle[ name.toLowerCase() ],
    1657 
    1658                 // Don't get fooled by Object.prototype properties (jQuery #13807)
    1659                 val = fn && hasOwn.call( Expr.attrHandle, name.toLowerCase() ) ?
    1660                         fn( elem, name, !documentIsHTML ) :
    1661                         undefined;
    1662 
    1663         return val !== undefined ?
    1664                 val :
    1665                 support.attributes || !documentIsHTML ?
    1666                         elem.getAttribute( name ) :
    1667                         ( val = elem.getAttributeNode( name ) ) && val.specified ?
    1668                                 val.value :
    1669                                 null;
    1670 };
    1671 
    1672 Sizzle.escape = function( sel ) {
    1673         return ( sel + "" ).replace( rcssescape, fcssescape );
    1674 };
    1675 
    1676 Sizzle.error = function( msg ) {
    1677         throw new Error( "Syntax error, unrecognized expression: " + msg );
    1678 };
    1679 
    1680 /**
    1681  * Document sorting and removing duplicates
    1682  * @param {ArrayLike} results
    1683  */
    1684 Sizzle.uniqueSort = function( results ) {
    1685         var elem,
    1686                 duplicates = [],
    1687                 j = 0,
    1688                 i = 0;
    1689 
    1690         // Unless we *know* we can detect duplicates, assume their presence
    1691         hasDuplicate = !support.detectDuplicates;
    1692         sortInput = !support.sortStable && results.slice( 0 );
    1693         results.sort( sortOrder );
    1694 
    1695         if ( hasDuplicate ) {
    1696                 while ( ( elem = results[ i++ ] ) ) {
    1697                         if ( elem === results[ i ] ) {
    1698                                 j = duplicates.push( i );
    1699                         }
    1700                 }
    1701                 while ( j-- ) {
    1702                         results.splice( duplicates[ j ], 1 );
    1703                 }
    1704         }
    1705 
    1706         // Clear input after sorting to release objects
    1707         // See https://github.com/jquery/sizzle/pull/225
    1708         sortInput = null;
    1709 
    1710         return results;
    1711 };
    1712 
    1713 /**
    1714  * Utility function for retrieving the text value of an array of DOM nodes
    1715  * @param {Array|Element} elem
    1716  */
    1717 getText = Sizzle.getText = function( elem ) {
    1718         var node,
    1719                 ret = "",
    1720                 i = 0,
    1721                 nodeType = elem.nodeType;
    1722 
    1723         if ( !nodeType ) {
    1724 
    1725                 // If no nodeType, this is expected to be an array
    1726                 while ( ( node = elem[ i++ ] ) ) {
    1727 
    1728                         // Do not traverse comment nodes
    1729                         ret += getText( node );
    1730                 }
    1731         } else if ( nodeType === 1 || nodeType === 9 || nodeType === 11 ) {
    1732 
    1733                 // Use textContent for elements
    1734                 // innerText usage removed for consistency of new lines (jQuery #11153)
    1735                 if ( typeof elem.textContent === "string" ) {
    1736                         return elem.textContent;
    1737                 } else {
    1738 
    1739                         // Traverse its children
    1740                         for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
    1741                                 ret += getText( elem );
    1742                         }
    1743                 }
    1744         } else if ( nodeType === 3 || nodeType === 4 ) {
    1745                 return elem.nodeValue;
    1746         }
    1747 
    1748         // Do not include comment or processing instruction nodes
    1749 
    1750         return ret;
    1751 };
    1752 
    1753 Expr = Sizzle.selectors = {
    1754 
    1755         // Can be adjusted by the user
    1756         cacheLength: 50,
    1757 
    1758         createPseudo: markFunction,
    1759 
    1760         match: matchExpr,
    1761 
    1762         attrHandle: {},
    1763 
    1764         find: {},
    1765 
    1766         relative: {
    1767                 ">": { dir: "parentNode", first: true },
    1768                 " ": { dir: "parentNode" },
    1769                 "+": { dir: "previousSibling", first: true },
    1770                 "~": { dir: "previousSibling" }
    1771         },
    1772 
    1773         preFilter: {
    1774                 "ATTR": function( match ) {
    1775                         match[ 1 ] = match[ 1 ].replace( runescape, funescape );
    1776 
    1777                         // Move the given value to match[3] whether quoted or unquoted
    1778                         match[ 3 ] = ( match[ 3 ] || match[ 4 ] ||
    1779                                 match[ 5 ] || "" ).replace( runescape, funescape );
    1780 
    1781                         if ( match[ 2 ] === "~=" ) {
    1782                                 match[ 3 ] = " " + match[ 3 ] + " ";
    1783                         }
    1784 
    1785                         return match.slice( 0, 4 );
    1786                 },
    1787 
    1788                 "CHILD": function( match ) {
    1789 
    1790                         /* matches from matchExpr["CHILD"]
    1791                                 1 type (only|nth|...)
    1792                                 2 what (child|of-type)
    1793                                 3 argument (even|odd|\d*|\d*n([+-]\d+)?|...)
    1794                                 4 xn-component of xn+y argument ([+-]?\d*n|)
    1795                                 5 sign of xn-component
    1796                                 6 x of xn-component
    1797                                 7 sign of y-component
    1798                                 8 y of y-component
    1799                         */
    1800                         match[ 1 ] = match[ 1 ].toLowerCase();
    1801 
    1802                         if ( match[ 1 ].slice( 0, 3 ) === "nth" ) {
    1803 
    1804                                 // nth-* requires argument
    1805                                 if ( !match[ 3 ] ) {
    1806                                         Sizzle.error( match[ 0 ] );
    1807                                 }
    1808 
    1809                                 // numeric x and y parameters for Expr.filter.CHILD
    1810                                 // remember that false/true cast respectively to 0/1
    1811                                 match[ 4 ] = +( match[ 4 ] ?
    1812                                         match[ 5 ] + ( match[ 6 ] || 1 ) :
    1813                                         2 * ( match[ 3 ] === "even" || match[ 3 ] === "odd" ) );
    1814                                 match[ 5 ] = +( ( match[ 7 ] + match[ 8 ] ) || match[ 3 ] === "odd" );
    1815 
    1816                                 // other types prohibit arguments
    1817                         } else if ( match[ 3 ] ) {
    1818                                 Sizzle.error( match[ 0 ] );
    1819                         }
    1820 
    1821                         return match;
    1822                 },
    1823 
    1824                 "PSEUDO": function( match ) {
    1825                         var excess,
    1826                                 unquoted = !match[ 6 ] && match[ 2 ];
    1827 
    1828                         if ( matchExpr[ "CHILD" ].test( match[ 0 ] ) ) {
    1829                                 return null;
    1830                         }
    1831 
    1832                         // Accept quoted arguments as-is
    1833                         if ( match[ 3 ] ) {
    1834                                 match[ 2 ] = match[ 4 ] || match[ 5 ] || "";
    1835 
    1836                         // Strip excess characters from unquoted arguments
    1837                         } else if ( unquoted && rpseudo.test( unquoted ) &&
    1838 
    1839                                 // Get excess from tokenize (recursively)
    1840                                 ( excess = tokenize( unquoted, true ) ) &&
    1841 
    1842                                 // advance to the next closing parenthesis
    1843                                 ( excess = unquoted.indexOf( ")", unquoted.length - excess ) - unquoted.length ) ) {
    1844 
    1845                                 // excess is a negative index
    1846                                 match[ 0 ] = match[ 0 ].slice( 0, excess );
    1847                                 match[ 2 ] = unquoted.slice( 0, excess );
    1848                         }
    1849 
    1850                         // Return only captures needed by the pseudo filter method (type and argument)
    1851                         return match.slice( 0, 3 );
    1852                 }
    1853         },
    1854 
    1855         filter: {
    1856 
    1857                 "TAG": function( nodeNameSelector ) {
    1858                         var nodeName = nodeNameSelector.replace( runescape, funescape ).toLowerCase();
    1859                         return nodeNameSelector === "*" ?
    1860                                 function() {
    1861                                         return true;
    1862                                 } :
    1863                                 function( elem ) {
    1864                                         return elem.nodeName && elem.nodeName.toLowerCase() === nodeName;
    1865                                 };
    1866                 },
    1867 
    1868                 "CLASS": function( className ) {
    1869                         var pattern = classCache[ className + " " ];
    1870 
    1871                         return pattern ||
    1872                                 ( pattern = new RegExp( "(^|" + whitespace +
    1873                                         ")" + className + "(" + whitespace + "|$)" ) ) && classCache(
    1874                                                 className, function( elem ) {
    1875                                                         return pattern.test(
    1876                                                                 typeof elem.className === "string" && elem.className ||
    1877                                                                 typeof elem.getAttribute !== "undefined" &&
    1878                                                                         elem.getAttribute( "class" ) ||
    1879                                                                 ""
    1880                                                         );
    1881                                 } );
    1882                 },
    1883 
    1884                 "ATTR": function( name, operator, check ) {
    1885                         return function( elem ) {
    1886                                 var result = Sizzle.attr( elem, name );
    1887 
    1888                                 if ( result == null ) {
    1889                                         return operator === "!=";
    1890                                 }
    1891                                 if ( !operator ) {
    1892                                         return true;
    1893                                 }
    1894 
    1895                                 result += "";
    1896 
    1897                                 /* eslint-disable max-len */
    1898 
    1899                                 return operator === "=" ? result === check :
    1900                                         operator === "!=" ? result !== check :
    1901                                         operator === "^=" ? check && result.indexOf( check ) === 0 :
    1902                                         operator === "*=" ? check && result.indexOf( check ) > -1 :
    1903                                         operator === "$=" ? check && result.slice( -check.length ) === check :
    1904                                         operator === "~=" ? ( " " + result.replace( rwhitespace, " " ) + " " ).indexOf( check ) > -1 :
    1905                                         operator === "|=" ? result === check || result.slice( 0, check.length + 1 ) === check + "-" :
    1906                                         false;
    1907                                 /* eslint-enable max-len */
    1908 
    1909                         };
    1910                 },
    1911 
    1912                 "CHILD": function( type, what, _argument, first, last ) {
    1913                         var simple = type.slice( 0, 3 ) !== "nth",
    1914                                 forward = type.slice( -4 ) !== "last",
    1915                                 ofType = what === "of-type";
    1916 
    1917                         return first === 1 && last === 0 ?
    1918 
    1919                                 // Shortcut for :nth-*(n)
    1920                                 function( elem ) {
    1921                                         return !!elem.parentNode;
    1922                                 } :
    1923 
    1924                                 function( elem, _context, xml ) {
    1925                                         var cache, uniqueCache, outerCache, node, nodeIndex, start,
    1926                                                 dir = simple !== forward ? "nextSibling" : "previousSibling",
    1927                                                 parent = elem.parentNode,
    1928                                                 name = ofType && elem.nodeName.toLowerCase(),
    1929                                                 useCache = !xml && !ofType,
    1930                                                 diff = false;
    1931 
    1932                                         if ( parent ) {
    1933 
    1934                                                 // :(first|last|only)-(child|of-type)
    1935                                                 if ( simple ) {
    1936                                                         while ( dir ) {
    1937                                                                 node = elem;
    1938                                                                 while ( ( node = node[ dir ] ) ) {
    1939                                                                         if ( ofType ?
    1940                                                                                 node.nodeName.toLowerCase() === name :
    1941                                                                                 node.nodeType === 1 ) {
    1942 
    1943                                                                                 return false;
    1944                                                                         }
    1945                                                                 }
    1946 
    1947                                                                 // Reverse direction for :only-* (if we haven't yet done so)
    1948                                                                 start = dir = type === "only" && !start && "nextSibling";
    1949                                                         }
    1950                                                         return true;
    1951                                                 }
    1952 
    1953                                                 start = [ forward ? parent.firstChild : parent.lastChild ];
    1954 
    1955                                                 // non-xml :nth-child(...) stores cache data on `parent`
    1956                                                 if ( forward && useCache ) {
    1957 
    1958                                                         // Seek `elem` from a previously-cached index
    1959 
    1960                                                         // ...in a gzip-friendly way
    1961                                                         node = parent;
    1962                                                         outerCache = node[ expando ] || ( node[ expando ] = {} );
    1963 
    1964                                                         // Support: IE <9 only
    1965                                                         // Defend against cloned attroperties (jQuery gh-1709)
    1966                                                         uniqueCache = outerCache[ node.uniqueID ] ||
    1967                                                                 ( outerCache[ node.uniqueID ] = {} );
    1968 
    1969                                                         cache = uniqueCache[ type ] || [];
    1970                                                         nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ];
    1971                                                         diff = nodeIndex && cache[ 2 ];
    1972                                                         node = nodeIndex && parent.childNodes[ nodeIndex ];
    1973 
    1974                                                         while ( ( node = ++nodeIndex && node && node[ dir ] ||
    1975 
    1976                                                                 // Fallback to seeking `elem` from the start
    1977                                                                 ( diff = nodeIndex = 0 ) || start.pop() ) ) {
    1978 
    1979                                                                 // When found, cache indexes on `parent` and break
    1980                                                                 if ( node.nodeType === 1 && ++diff && node === elem ) {
    1981                                                                         uniqueCache[ type ] = [ dirruns, nodeIndex, diff ];
    1982                                                                         break;
    1983                                                                 }
    1984                                                         }
    1985 
    1986                                                 } else {
    1987 
    1988                                                         // Use previously-cached element index if available
    1989                                                         if ( useCache ) {
    1990 
    1991                                                                 // ...in a gzip-friendly way
    1992                                                                 node = elem;
    1993                                                                 outerCache = node[ expando ] || ( node[ expando ] = {} );
    1994 
    1995                                                                 // Support: IE <9 only
    1996                                                                 // Defend against cloned attroperties (jQuery gh-1709)
    1997                                                                 uniqueCache = outerCache[ node.uniqueID ] ||
    1998                                                                         ( outerCache[ node.uniqueID ] = {} );
    1999 
    2000                                                                 cache = uniqueCache[ type ] || [];
    2001                                                                 nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ];
    2002                                                                 diff = nodeIndex;
    2003                                                         }
    2004 
    2005                                                         // xml :nth-child(...)
    2006                                                         // or :nth-last-child(...) or :nth(-last)?-of-type(...)
    2007                                                         if ( diff === false ) {
    2008 
    2009                                                                 // Use the same loop as above to seek `elem` from the start
    2010                                                                 while ( ( node = ++nodeIndex && node && node[ dir ] ||
    2011                                                                         ( diff = nodeIndex = 0 ) || start.pop() ) ) {
    2012 
    2013                                                                         if ( ( ofType ?
    2014                                                                                 node.nodeName.toLowerCase() === name :
    2015                                                                                 node.nodeType === 1 ) &&
    2016                                                                                 ++diff ) {
    2017 
    2018                                                                                 // Cache the index of each encountered element
    2019                                                                                 if ( useCache ) {
    2020                                                                                         outerCache = node[ expando ] ||
    2021                                                                                                 ( node[ expando ] = {} );
    2022 
    2023                                                                                         // Support: IE <9 only
    2024                                                                                         // Defend against cloned attroperties (jQuery gh-1709)
    2025                                                                                         uniqueCache = outerCache[ node.uniqueID ] ||
    2026                                                                                                 ( outerCache[ node.uniqueID ] = {} );
    2027 
    2028                                                                                         uniqueCache[ type ] = [ dirruns, diff ];
    2029                                                                                 }
    2030 
    2031                                                                                 if ( node === elem ) {
    2032                                                                                         break;
    2033                                                                                 }
    2034                                                                         }
    2035                                                                 }
    2036                                                         }
    2037                                                 }
    2038 
    2039                                                 // Incorporate the offset, then check against cycle size
    2040                                                 diff -= last;
    2041                                                 return diff === first || ( diff % first === 0 && diff / first >= 0 );
    2042                                         }
    2043                                 };
    2044                 },
    2045 
    2046                 "PSEUDO": function( pseudo, argument ) {
    2047 
    2048                         // pseudo-class names are case-insensitive
    2049                         // http://www.w3.org/TR/selectors/#pseudo-classes
    2050                         // Prioritize by case sensitivity in case custom pseudos are added with uppercase letters
    2051                         // Remember that setFilters inherits from pseudos
    2052                         var args,
    2053                                 fn = Expr.pseudos[ pseudo ] || Expr.setFilters[ pseudo.toLowerCase() ] ||
    2054                                         Sizzle.error( "unsupported pseudo: " + pseudo );
    2055 
    2056                         // The user may use createPseudo to indicate that
    2057                         // arguments are needed to create the filter function
    2058                         // just as Sizzle does
    2059                         if ( fn[ expando ] ) {
    2060                                 return fn( argument );
    2061                         }
    2062 
    2063                         // But maintain support for old signatures
    2064                         if ( fn.length > 1 ) {
    2065                                 args = [ pseudo, pseudo, "", argument ];
    2066                                 return Expr.setFilters.hasOwnProperty( pseudo.toLowerCase() ) ?
    2067                                         markFunction( function( seed, matches ) {
    2068                                                 var idx,
    2069                                                         matched = fn( seed, argument ),
    2070                                                         i = matched.length;
    2071                                                 while ( i-- ) {
    2072                                                         idx = indexOf( seed, matched[ i ] );
    2073                                                         seed[ idx ] = !( matches[ idx ] = matched[ i ] );
    2074                                                 }
    2075                                         } ) :
    2076                                         function( elem ) {
    2077                                                 return fn( elem, 0, args );
    2078                                         };
    2079                         }
    2080 
    2081                         return fn;
    2082                 }
    2083         },
    2084 
    2085         pseudos: {
    2086 
    2087                 // Potentially complex pseudos
    2088                 "not": markFunction( function( selector ) {
    2089 
    2090                         // Trim the selector passed to compile
    2091                         // to avoid treating leading and trailing
    2092                         // spaces as combinators
    2093                         var input = [],
    2094                                 results = [],
    2095                                 matcher = compile( selector.replace( rtrim, "$1" ) );
    2096 
    2097                         return matcher[ expando ] ?
    2098                                 markFunction( function( seed, matches, _context, xml ) {
    2099                                         var elem,
    2100                                                 unmatched = matcher( seed, null, xml, [] ),
    2101                                                 i = seed.length;
    2102 
    2103                                         // Match elements unmatched by `matcher`
    2104                                         while ( i-- ) {
    2105                                                 if ( ( elem = unmatched[ i ] ) ) {
    2106                                                         seed[ i ] = !( matches[ i ] = elem );
    2107                                                 }
    2108                                         }
    2109                                 } ) :
    2110                                 function( elem, _context, xml ) {
    2111                                         input[ 0 ] = elem;
    2112                                         matcher( input, null, xml, results );
    2113 
    2114                                         // Don't keep the element (issue #299)
    2115                                         input[ 0 ] = null;
    2116                                         return !results.pop();
    2117                                 };
    2118                 } ),
    2119 
    2120                 "has": markFunction( function( selector ) {
    2121                         return function( elem ) {
    2122                                 return Sizzle( selector, elem ).length > 0;
    2123                         };
    2124                 } ),
    2125 
    2126                 "contains": markFunction( function( text ) {
    2127                         text = text.replace( runescape, funescape );
    2128                         return function( elem ) {
    2129                                 return ( elem.textContent || getText( elem ) ).indexOf( text ) > -1;
    2130                         };
    2131                 } ),
    2132 
    2133                 // "Whether an element is represented by a :lang() selector
    2134                 // is based solely on the element's language value
    2135                 // being equal to the identifier C,
    2136                 // or beginning with the identifier C immediately followed by "-".
    2137                 // The matching of C against the element's language value is performed case-insensitively.
    2138                 // The identifier C does not have to be a valid language name."
    2139                 // http://www.w3.org/TR/selectors/#lang-pseudo
    2140                 "lang": markFunction( function( lang ) {
    2141 
    2142                         // lang value must be a valid identifier
    2143                         if ( !ridentifier.test( lang || "" ) ) {
    2144                                 Sizzle.error( "unsupported lang: " + lang );
    2145                         }
    2146                         lang = lang.replace( runescape, funescape ).toLowerCase();
    2147                         return function( elem ) {
    2148                                 var elemLang;
    2149                                 do {
    2150                                         if ( ( elemLang = documentIsHTML ?
    2151                                                 elem.lang :
    2152                                                 elem.getAttribute( "xml:lang" ) || elem.getAttribute( "lang" ) ) ) {
    2153 
    2154                                                 elemLang = elemLang.toLowerCase();
    2155                                                 return elemLang === lang || elemLang.indexOf( lang + "-" ) === 0;
    2156                                         }
    2157                                 } while ( ( elem = elem.parentNode ) && elem.nodeType === 1 );
    2158                                 return false;
    2159                         };
    2160                 } ),
    2161 
    2162                 // Miscellaneous
    2163                 "target": function( elem ) {
    2164                         var hash = window.location && window.location.hash;
    2165                         return hash && hash.slice( 1 ) === elem.id;
    2166                 },
    2167 
    2168                 "root": function( elem ) {
    2169                         return elem === docElem;
    2170                 },
    2171 
    2172                 "focus": function( elem ) {
    2173                         return elem === document.activeElement &&
    2174                                 ( !document.hasFocus || document.hasFocus() ) &&
    2175                                 !!( elem.type || elem.href || ~elem.tabIndex );
    2176                 },
    2177 
    2178                 // Boolean properties
    2179                 "enabled": createDisabledPseudo( false ),
    2180                 "disabled": createDisabledPseudo( true ),
    2181 
    2182                 "checked": function( elem ) {
    2183 
    2184                         // In CSS3, :checked should return both checked and selected elements
    2185                         // http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
    2186                         var nodeName = elem.nodeName.toLowerCase();
    2187                         return ( nodeName === "input" && !!elem.checked ) ||
    2188                                 ( nodeName === "option" && !!elem.selected );
    2189                 },
    2190 
    2191                 "selected": function( elem ) {
    2192 
    2193                         // Accessing this property makes selected-by-default
    2194                         // options in Safari work properly
    2195                         if ( elem.parentNode ) {
    2196                                 // eslint-disable-next-line no-unused-expressions
    2197                                 elem.parentNode.selectedIndex;
    2198                         }
    2199 
    2200                         return elem.selected === true;
    2201                 },
    2202 
    2203                 // Contents
    2204                 "empty": function( elem ) {
    2205 
    2206                         // http://www.w3.org/TR/selectors/#empty-pseudo
    2207                         // :empty is negated by element (1) or content nodes (text: 3; cdata: 4; entity ref: 5),
    2208                         //   but not by others (comment: 8; processing instruction: 7; etc.)
    2209                         // nodeType < 6 works because attributes (2) do not appear as children
    2210                         for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) {
    2211                                 if ( elem.nodeType < 6 ) {
    2212                                         return false;
    2213                                 }
    2214                         }
    2215                         return true;
    2216                 },
    2217 
    2218                 "parent": function( elem ) {
    2219                         return !Expr.pseudos[ "empty" ]( elem );
    2220                 },
    2221 
    2222                 // Element/input types
    2223                 "header": function( elem ) {
    2224                         return rheader.test( elem.nodeName );
    2225                 },
    2226 
    2227                 "input": function( elem ) {
    2228                         return rinputs.test( elem.nodeName );
    2229                 },
    2230 
    2231                 "button": function( elem ) {
    2232                         var name = elem.nodeName.toLowerCase();
    2233                         return name === "input" && elem.type === "button" || name === "button";
    2234                 },
    2235 
    2236                 "text": function( elem ) {
    2237                         var attr;
    2238                         return elem.nodeName.toLowerCase() === "input" &&
    2239                                 elem.type === "text" &&
    2240 
    2241                                 // Support: IE<8
    2242                                 // New HTML5 attribute values (e.g., "search") appear with elem.type === "text"
    2243                                 ( ( attr = elem.getAttribute( "type" ) ) == null ||
    2244                                         attr.toLowerCase() === "text" );
    2245                 },
    2246 
    2247                 // Position-in-collection
    2248                 "first": createPositionalPseudo( function() {
    2249                         return [ 0 ];
    2250                 } ),
    2251 
    2252                 "last": createPositionalPseudo( function( _matchIndexes, length ) {
    2253                         return [ length - 1 ];
    2254                 } ),
    2255 
    2256                 "eq": createPositionalPseudo( function( _matchIndexes, length, argument ) {
    2257                         return [ argument < 0 ? argument + length : argument ];
    2258                 } ),
    2259 
    2260                 "even": createPositionalPseudo( function( matchIndexes, length ) {
    2261                         var i = 0;
    2262                         for ( ; i < length; i += 2 ) {
    2263                                 matchIndexes.push( i );
    2264                         }
    2265                         return matchIndexes;
    2266                 } ),
    2267 
    2268                 "odd": createPositionalPseudo( function( matchIndexes, length ) {
    2269                         var i = 1;
    2270                         for ( ; i < length; i += 2 ) {
    2271                                 matchIndexes.push( i );
    2272                         }
    2273                         return matchIndexes;
    2274                 } ),
    2275 
    2276                 "lt": createPositionalPseudo( function( matchIndexes, length, argument ) {
    2277                         var i = argument < 0 ?
    2278                                 argument + length :
    2279                                 argument > length ?
    2280                                         length :
    2281                                         argument;
    2282                         for ( ; --i >= 0; ) {
    2283                                 matchIndexes.push( i );
    2284                         }
    2285                         return matchIndexes;
    2286                 } ),
    2287 
    2288                 "gt": createPositionalPseudo( function( matchIndexes, length, argument ) {
    2289                         var i = argument < 0 ? argument + length : argument;
    2290                         for ( ; ++i < length; ) {
    2291                                 matchIndexes.push( i );
    2292                         }
    2293                         return matchIndexes;
    2294                 } )
    2295         }
    2296 };
    2297 
    2298 Expr.pseudos[ "nth" ] = Expr.pseudos[ "eq" ];
    2299 
    2300 // Add button/input type pseudos
    2301 for ( i in { radio: true, checkbox: true, file: true, password: true, image: true } ) {
    2302         Expr.pseudos[ i ] = createInputPseudo( i );
    2303 }
    2304 for ( i in { submit: true, reset: true } ) {
    2305         Expr.pseudos[ i ] = createButtonPseudo( i );
    2306 }
    2307 
    2308 // Easy API for creating new setFilters
    2309 function setFilters() {}
    2310 setFilters.prototype = Expr.filters = Expr.pseudos;
    2311 Expr.setFilters = new setFilters();
    2312 
    2313 tokenize = Sizzle.tokenize = function( selector, parseOnly ) {
    2314         var matched, match, tokens, type,
    2315                 soFar, groups, preFilters,
    2316                 cached = tokenCache[ selector + " " ];
    2317 
    2318         if ( cached ) {
    2319                 return parseOnly ? 0 : cached.slice( 0 );
    2320         }
    2321 
    2322         soFar = selector;
    2323         groups = [];
    2324         preFilters = Expr.preFilter;
    2325 
    2326         while ( soFar ) {
    2327 
    2328                 // Comma and first run
    2329                 if ( !matched || ( match = rcomma.exec( soFar ) ) ) {
    2330                         if ( match ) {
    2331 
    2332                                 // Don't consume trailing commas as valid
    2333                                 soFar = soFar.slice( match[ 0 ].length ) || soFar;
    2334                         }
    2335                         groups.push( ( tokens = [] ) );
    2336                 }
    2337 
    2338                 matched = false;
    2339 
    2340                 // Combinators
    2341                 if ( ( match = rcombinators.exec( soFar ) ) ) {
    2342                         matched = match.shift();
    2343                         tokens.push( {
    2344                                 value: matched,
    2345 
    2346                                 // Cast descendant combinators to space
    2347                                 type: match[ 0 ].replace( rtrim, " " )
    2348                         } );
    2349                         soFar = soFar.slice( matched.length );
    2350                 }
    2351 
    2352                 // Filters
    2353                 for ( type in Expr.filter ) {
    2354                         if ( ( match = matchExpr[ type ].exec( soFar ) ) && ( !preFilters[ type ] ||
    2355                                 ( match = preFilters[ type ]( match ) ) ) ) {
    2356                                 matched = match.shift();
    2357                                 tokens.push( {
    2358                                         value: matched,
    2359                                         type: type,
    2360                                         matches: match
    2361                                 } );
    2362                                 soFar = soFar.slice( matched.length );
    2363                         }
    2364                 }
    2365 
    2366                 if ( !matched ) {
    2367                         break;
    2368                 }
    2369         }
    2370 
    2371         // Return the length of the invalid excess
    2372         // if we're just parsing
    2373         // Otherwise, throw an error or return tokens
    2374         return parseOnly ?
    2375                 soFar.length :
    2376                 soFar ?
    2377                         Sizzle.error( selector ) :
    2378 
    2379                         // Cache the tokens
    2380                         tokenCache( selector, groups ).slice( 0 );
    2381 };
    2382 
    2383 function toSelector( tokens ) {
    2384         var i = 0,
    2385                 len = tokens.length,
    2386                 selector = "";
    2387         for ( ; i < len; i++ ) {
    2388                 selector += tokens[ i ].value;
    2389         }
    2390         return selector;
    2391 }
    2392 
    2393 function addCombinator( matcher, combinator, base ) {
    2394         var dir = combinator.dir,
    2395                 skip = combinator.next,
    2396                 key = skip || dir,
    2397                 checkNonElements = base && key === "parentNode",
    2398                 doneName = done++;
    2399 
    2400         return combinator.first ?
    2401 
    2402                 // Check against closest ancestor/preceding element
    2403                 function( elem, context, xml ) {
    2404                         while ( ( elem = elem[ dir ] ) ) {
    2405                                 if ( elem.nodeType === 1 || checkNonElements ) {
    2406                                         return matcher( elem, context, xml );
    2407                                 }
    2408                         }
    2409                         return false;
    2410                 } :
    2411 
    2412                 // Check against all ancestor/preceding elements
    2413                 function( elem, context, xml ) {
    2414                         var oldCache, uniqueCache, outerCache,
    2415                                 newCache = [ dirruns, doneName ];
    2416 
    2417                         // We can't set arbitrary data on XML nodes, so they don't benefit from combinator caching
    2418                         if ( xml ) {
    2419                                 while ( ( elem = elem[ dir ] ) ) {
    2420                                         if ( elem.nodeType === 1 || checkNonElements ) {
    2421                                                 if ( matcher( elem, context, xml ) ) {
    2422                                                         return true;
    2423                                                 }
    2424                                         }
    2425                                 }
    2426                         } else {
    2427                                 while ( ( elem = elem[ dir ] ) ) {
    2428                                         if ( elem.nodeType === 1 || checkNonElements ) {
    2429                                                 outerCache = elem[ expando ] || ( elem[ expando ] = {} );
    2430 
    2431                                                 // Support: IE <9 only
    2432                                                 // Defend against cloned attroperties (jQuery gh-1709)
    2433                                                 uniqueCache = outerCache[ elem.uniqueID ] ||
    2434                                                         ( outerCache[ elem.uniqueID ] = {} );
    2435 
    2436                                                 if ( skip && skip === elem.nodeName.toLowerCase() ) {
    2437                                                         elem = elem[ dir ] || elem;
    2438                                                 } else if ( ( oldCache = uniqueCache[ key ] ) &&
    2439                                                         oldCache[ 0 ] === dirruns && oldCache[ 1 ] === doneName ) {
    2440 
    2441                                                         // Assign to newCache so results back-propagate to previous elements
    2442                                                         return ( newCache[ 2 ] = oldCache[ 2 ] );
    2443                                                 } else {
    2444 
    2445                                                         // Reuse newcache so results back-propagate to previous elements
    2446                                                         uniqueCache[ key ] = newCache;
    2447 
    2448                                                         // A match means we're done; a fail means we have to keep checking
    2449                                                         if ( ( newCache[ 2 ] = matcher( elem, context, xml ) ) ) {
    2450                                                                 return true;
    2451                                                         }
    2452                                                 }
    2453                                         }
    2454                                 }
    2455                         }
    2456                         return false;
    2457                 };
    2458 }
    2459 
    2460 function elementMatcher( matchers ) {
    2461         return matchers.length > 1 ?
    2462                 function( elem, context, xml ) {
    2463                         var i = matchers.length;
    2464                         while ( i-- ) {
    2465                                 if ( !matchers[ i ]( elem, context, xml ) ) {
    2466                                         return false;
    2467                                 }
    2468                         }
    2469                         return true;
    2470                 } :
    2471                 matchers[ 0 ];
    2472 }
    2473 
    2474 function multipleContexts( selector, contexts, results ) {
    2475         var i = 0,
    2476                 len = contexts.length;
    2477         for ( ; i < len; i++ ) {
    2478                 Sizzle( selector, contexts[ i ], results );
    2479         }
    2480         return results;
    2481 }
    2482 
    2483 function condense( unmatched, map, filter, context, xml ) {
    2484         var elem,
    2485                 newUnmatched = [],
    2486                 i = 0,
    2487                 len = unmatched.length,
    2488                 mapped = map != null;
    2489 
    2490         for ( ; i < len; i++ ) {
    2491                 if ( ( elem = unmatched[ i ] ) ) {
    2492                         if ( !filter || filter( elem, context, xml ) ) {
    2493                                 newUnmatched.push( elem );
    2494                                 if ( mapped ) {
    2495                                         map.push( i );
    2496                                 }
    2497                         }
    2498                 }
    2499         }
    2500 
    2501         return newUnmatched;
    2502 }
    2503 
    2504 function setMatcher( preFilter, selector, matcher, postFilter, postFinder, postSelector ) {
    2505         if ( postFilter && !postFilter[ expando ] ) {
    2506                 postFilter = setMatcher( postFilter );
    2507         }
    2508         if ( postFinder && !postFinder[ expando ] ) {
    2509                 postFinder = setMatcher( postFinder, postSelector );
    2510         }
    2511         return markFunction( function( seed, results, context, xml ) {
    2512                 var temp, i, elem,
    2513                         preMap = [],
    2514                         postMap = [],
    2515                         preexisting = results.length,
    2516 
    2517                         // Get initial elements from seed or context
    2518                         elems = seed || multipleContexts(
    2519                                 selector || "*",
    2520                                 context.nodeType ? [ context ] : context,
    2521                                 []
    2522                         ),
    2523 
    2524                         // Prefilter to get matcher input, preserving a map for seed-results synchronization
    2525                         matcherIn = preFilter && ( seed || !selector ) ?
    2526                                 condense( elems, preMap, preFilter, context, xml ) :
    2527                                 elems,
    2528 
    2529                         matcherOut = matcher ?
    2530 
    2531                                 // If we have a postFinder, or filtered seed, or non-seed postFilter or preexisting results,
    2532                                 postFinder || ( seed ? preFilter : preexisting || postFilter ) ?
    2533 
    2534                                         // ...intermediate processing is necessary
    2535                                         [] :
    2536 
    2537                                         // ...otherwise use results directly
    2538                                         results :
    2539                                 matcherIn;
    2540 
    2541                 // Find primary matches
    2542                 if ( matcher ) {
    2543                         matcher( matcherIn, matcherOut, context, xml );
    2544                 }
    2545 
    2546                 // Apply postFilter
    2547                 if ( postFilter ) {
    2548                         temp = condense( matcherOut, postMap );
    2549                         postFilter( temp, [], context, xml );
    2550 
    2551                         // Un-match failing elements by moving them back to matcherIn
    2552                         i = temp.length;
    2553                         while ( i-- ) {
    2554                                 if ( ( elem = temp[ i ] ) ) {
    2555                                         matcherOut[ postMap[ i ] ] = !( matcherIn[ postMap[ i ] ] = elem );
    2556                                 }
    2557                         }
    2558                 }
    2559 
    2560                 if ( seed ) {
    2561                         if ( postFinder || preFilter ) {
    2562                                 if ( postFinder ) {
    2563 
    2564                                         // Get the final matcherOut by condensing this intermediate into postFinder contexts
    2565                                         temp = [];
    2566                                         i = matcherOut.length;
    2567                                         while ( i-- ) {
    2568                                                 if ( ( elem = matcherOut[ i ] ) ) {
    2569 
    2570                                                         // Restore matcherIn since elem is not yet a final match
    2571                                                         temp.push( ( matcherIn[ i ] = elem ) );
    2572                                                 }
    2573                                         }
    2574                                         postFinder( null, ( matcherOut = [] ), temp, xml );
    2575                                 }
    2576 
    2577                                 // Move matched elements from seed to results to keep them synchronized
    2578                                 i = matcherOut.length;
    2579                                 while ( i-- ) {
    2580                                         if ( ( elem = matcherOut[ i ] ) &&
    2581                                                 ( temp = postFinder ? indexOf( seed, elem ) : preMap[ i ] ) > -1 ) {
    2582 
    2583                                                 seed[ temp ] = !( results[ temp ] = elem );
    2584                                         }
    2585                                 }
    2586                         }
    2587 
    2588                 // Add elements to results, through postFinder if defined
    2589                 } else {
    2590                         matcherOut = condense(
    2591                                 matcherOut === results ?
    2592                                         matcherOut.splice( preexisting, matcherOut.length ) :
    2593                                         matcherOut
    2594                         );
    2595                         if ( postFinder ) {
    2596                                 postFinder( null, results, matcherOut, xml );
    2597                         } else {
    2598                                 push.apply( results, matcherOut );
    2599                         }
    2600                 }
    2601         } );
    2602 }
    2603 
    2604 function matcherFromTokens( tokens ) {
    2605         var checkContext, matcher, j,
    2606                 len = tokens.length,
    2607                 leadingRelative = Expr.relative[ tokens[ 0 ].type ],
    2608                 implicitRelative = leadingRelative || Expr.relative[ " " ],
    2609                 i = leadingRelative ? 1 : 0,
    2610 
    2611                 // The foundational matcher ensures that elements are reachable from top-level context(s)
    2612                 matchContext = addCombinator( function( elem ) {
    2613                         return elem === checkContext;
    2614                 }, implicitRelative, true ),
    2615                 matchAnyContext = addCombinator( function( elem ) {
    2616                         return indexOf( checkContext, elem ) > -1;
    2617                 }, implicitRelative, true ),
    2618                 matchers = [ function( elem, context, xml ) {
    2619                         var ret = ( !leadingRelative && ( xml || context !== outermostContext ) ) || (
    2620                                 ( checkContext = context ).nodeType ?
    2621                                         matchContext( elem, context, xml ) :
    2622                                         matchAnyContext( elem, context, xml ) );
    2623 
    2624                         // Avoid hanging onto element (issue #299)
    2625                         checkContext = null;
    2626                         return ret;
    2627                 } ];
    2628 
    2629         for ( ; i < len; i++ ) {
    2630                 if ( ( matcher = Expr.relative[ tokens[ i ].type ] ) ) {
    2631                         matchers = [ addCombinator( elementMatcher( matchers ), matcher ) ];
    2632                 } else {
    2633                         matcher = Expr.filter[ tokens[ i ].type ].apply( null, tokens[ i ].matches );
    2634 
    2635                         // Return special upon seeing a positional matcher
    2636                         if ( matcher[ expando ] ) {
    2637 
    2638                                 // Find the next relative operator (if any) for proper handling
    2639                                 j = ++i;
    2640                                 for ( ; j < len; j++ ) {
    2641                                         if ( Expr.relative[ tokens[ j ].type ] ) {
    2642                                                 break;
    2643                                         }
    2644                                 }
    2645                                 return setMatcher(
    2646                                         i > 1 && elementMatcher( matchers ),
    2647                                         i > 1 && toSelector(
    2648 
    2649                                         // If the preceding token was a descendant combinator, insert an implicit any-element `*`
    2650                                         tokens
    2651                                                 .slice( 0, i - 1 )
    2652                                                 .concat( { value: tokens[ i - 2 ].type === " " ? "*" : "" } )
    2653                                         ).replace( rtrim, "$1" ),
    2654                                         matcher,
    2655                                         i < j && matcherFromTokens( tokens.slice( i, j ) ),
    2656                                         j < len && matcherFromTokens( ( tokens = tokens.slice( j ) ) ),
    2657                                         j < len && toSelector( tokens )
    2658                                 );
    2659                         }
    2660                         matchers.push( matcher );
    2661                 }
    2662         }
    2663 
    2664         return elementMatcher( matchers );
    2665 }
    2666 
    2667 function matcherFromGroupMatchers( elementMatchers, setMatchers ) {
    2668         var bySet = setMatchers.length > 0,
    2669                 byElement = elementMatchers.length > 0,
    2670                 superMatcher = function( seed, context, xml, results, outermost ) {
    2671                         var elem, j, matcher,
    2672                                 matchedCount = 0,
    2673                                 i = "0",
    2674                                 unmatched = seed && [],
    2675                                 setMatched = [],
    2676                                 contextBackup = outermostContext,
    2677 
    2678                                 // We must always have either seed elements or outermost context
    2679                                 elems = seed || byElement && Expr.find[ "TAG" ]( "*", outermost ),
    2680 
    2681                                 // Use integer dirruns iff this is the outermost matcher
    2682                                 dirrunsUnique = ( dirruns += contextBackup == null ? 1 : Math.random() || 0.1 ),
    2683                                 len = elems.length;
    2684 
    2685                         if ( outermost ) {
    2686 
    2687                                 // Support: IE 11+, Edge 17 - 18+
    2688                                 // IE/Edge sometimes throw a "Permission denied" error when strict-comparing
    2689                                 // two documents; shallow comparisons work.
    2690                                 // eslint-disable-next-line eqeqeq
    2691                                 outermostContext = context == document || context || outermost;
    2692                         }
    2693 
    2694                         // Add elements passing elementMatchers directly to results
    2695                         // Support: IE<9, Safari
    2696                         // Tolerate NodeList properties (IE: "length"; Safari: <number>) matching elements by id
    2697                         for ( ; i !== len && ( elem = elems[ i ] ) != null; i++ ) {
    2698                                 if ( byElement && elem ) {
    2699                                         j = 0;
    2700 
    2701                                         // Support: IE 11+, Edge 17 - 18+
    2702                                         // IE/Edge sometimes throw a "Permission denied" error when strict-comparing
    2703                                         // two documents; shallow comparisons work.
    2704                                         // eslint-disable-next-line eqeqeq
    2705                                         if ( !context && elem.ownerDocument != document ) {
    2706                                                 setDocument( elem );
    2707                                                 xml = !documentIsHTML;
    2708                                         }
    2709                                         while ( ( matcher = elementMatchers[ j++ ] ) ) {
    2710                                                 if ( matcher( elem, context || document, xml ) ) {
    2711                                                         results.push( elem );
    2712                                                         break;
    2713                                                 }
    2714                                         }
    2715                                         if ( outermost ) {
    2716                                                 dirruns = dirrunsUnique;
    2717                                         }
    2718                                 }
    2719 
    2720                                 // Track unmatched elements for set filters
    2721                                 if ( bySet ) {
    2722 
    2723                                         // They will have gone through all possible matchers
    2724                                         if ( ( elem = !matcher && elem ) ) {
    2725                                                 matchedCount--;
    2726                                         }
    2727 
    2728                                         // Lengthen the array for every element, matched or not
    2729                                         if ( seed ) {
    2730                                                 unmatched.push( elem );
    2731                                         }
    2732                                 }
    2733                         }
    2734 
    2735                         // `i` is now the count of elements visited above, and adding it to `matchedCount`
    2736                         // makes the latter nonnegative.
    2737                         matchedCount += i;
    2738 
    2739                         // Apply set filters to unmatched elements
    2740                         // NOTE: This can be skipped if there are no unmatched elements (i.e., `matchedCount`
    2741                         // equals `i`), unless we didn't visit _any_ elements in the above loop because we have
    2742                         // no element matchers and no seed.
    2743                         // Incrementing an initially-string "0" `i` allows `i` to remain a string only in that
    2744                         // case, which will result in a "00" `matchedCount` that differs from `i` but is also
    2745                         // numerically zero.
    2746                         if ( bySet && i !== matchedCount ) {
    2747                                 j = 0;
    2748                                 while ( ( matcher = setMatchers[ j++ ] ) ) {
    2749                                         matcher( unmatched, setMatched, context, xml );
    2750                                 }
    2751 
    2752                                 if ( seed ) {
    2753 
    2754                                         // Reintegrate element matches to eliminate the need for sorting
    2755                                         if ( matchedCount > 0 ) {
    2756                                                 while ( i-- ) {
    2757                                                         if ( !( unmatched[ i ] || setMatched[ i ] ) ) {
    2758                                                                 setMatched[ i ] = pop.call( results );
    2759                                                         }
    2760                                                 }
    2761                                         }
    2762 
    2763                                         // Discard index placeholder values to get only actual matches
    2764                                         setMatched = condense( setMatched );
    2765                                 }
    2766 
    2767                                 // Add matches to results
    2768                                 push.apply( results, setMatched );
    2769 
    2770                                 // Seedless set matches succeeding multiple successful matchers stipulate sorting
    2771                                 if ( outermost && !seed && setMatched.length > 0 &&
    2772                                         ( matchedCount + setMatchers.length ) > 1 ) {
    2773 
    2774                                         Sizzle.uniqueSort( results );
    2775                                 }
    2776                         }
    2777 
    2778                         // Override manipulation of globals by nested matchers
    2779                         if ( outermost ) {
    2780                                 dirruns = dirrunsUnique;
    2781                                 outermostContext = contextBackup;
    2782                         }
    2783 
    2784                         return unmatched;
    2785                 };
    2786 
    2787         return bySet ?
    2788                 markFunction( superMatcher ) :
    2789                 superMatcher;
    2790 }
    2791 
    2792 compile = Sizzle.compile = function( selector, match /* Internal Use Only */ ) {
    2793         var i,
    2794                 setMatchers = [],
    2795                 elementMatchers = [],
    2796                 cached = compilerCache[ selector + " " ];
    2797 
    2798         if ( !cached ) {
    2799 
    2800                 // Generate a function of recursive functions that can be used to check each element
    2801                 if ( !match ) {
    2802                         match = tokenize( selector );
    2803                 }
    2804                 i = match.length;
    2805                 while ( i-- ) {
    2806                         cached = matcherFromTokens( match[ i ] );
    2807                         if ( cached[ expando ] ) {
    2808                                 setMatchers.push( cached );
    2809                         } else {
    2810                                 elementMatchers.push( cached );
    2811                         }
    2812                 }
    2813 
    2814                 // Cache the compiled function
    2815                 cached = compilerCache(
    2816                         selector,
    2817                         matcherFromGroupMatchers( elementMatchers, setMatchers )
    2818                 );
    2819 
    2820                 // Save selector and tokenization
    2821                 cached.selector = selector;
    2822         }
    2823         return cached;
    2824 };
    2825 
    2826 /**
    2827  * A low-level selection function that works with Sizzle's compiled
    2828  *  selector functions
    2829  * @param {String|Function} selector A selector or a pre-compiled
    2830  *  selector function built with Sizzle.compile
    2831  * @param {Element} context
    2832  * @param {Array} [results]
    2833  * @param {Array} [seed] A set of elements to match against
    2834  */
    2835 select = Sizzle.select = function( selector, context, results, seed ) {
    2836         var i, tokens, token, type, find,
    2837                 compiled = typeof selector === "function" && selector,
    2838                 match = !seed && tokenize( ( selector = compiled.selector || selector ) );
    2839 
    2840         results = results || [];
    2841 
    2842         // Try to minimize operations if there is only one selector in the list and no seed
    2843         // (the latter of which guarantees us context)
    2844         if ( match.length === 1 ) {
    2845 
    2846                 // Reduce context if the leading compound selector is an ID
    2847                 tokens = match[ 0 ] = match[ 0 ].slice( 0 );
    2848                 if ( tokens.length > 2 && ( token = tokens[ 0 ] ).type === "ID" &&
    2849                         context.nodeType === 9 && documentIsHTML && Expr.relative[ tokens[ 1 ].type ] ) {
    2850 
    2851                         context = ( Expr.find[ "ID" ]( token.matches[ 0 ]
    2852                                 .replace( runescape, funescape ), context ) || [] )[ 0 ];
    2853                         if ( !context ) {
    2854                                 return results;
    2855 
    2856                         // Precompiled matchers will still verify ancestry, so step up a level
    2857                         } else if ( compiled ) {
    2858                                 context = context.parentNode;
    2859                         }
    2860 
    2861                         selector = selector.slice( tokens.shift().value.length );
    2862                 }
    2863 
    2864                 // Fetch a seed set for right-to-left matching
    2865                 i = matchExpr[ "needsContext" ].test( selector ) ? 0 : tokens.length;
    2866                 while ( i-- ) {
    2867                         token = tokens[ i ];
    2868 
    2869                         // Abort if we hit a combinator
    2870                         if ( Expr.relative[ ( type = token.type ) ] ) {
    2871                                 break;
    2872                         }
    2873                         if ( ( find = Expr.find[ type ] ) ) {
    2874 
    2875                                 // Search, expanding context for leading sibling combinators
    2876                                 if ( ( seed = find(
    2877                                         token.matches[ 0 ].replace( runescape, funescape ),
    2878                                         rsibling.test( tokens[ 0 ].type ) && testContext( context.parentNode ) ||
    2879                                                 context
    2880                                 ) ) ) {
    2881 
    2882                                         // If seed is empty or no tokens remain, we can return early
    2883                                         tokens.splice( i, 1 );
    2884                                         selector = seed.length && toSelector( tokens );
    2885                                         if ( !selector ) {
    2886                                                 push.apply( results, seed );
    2887                                                 return results;
    2888                                         }
    2889 
    2890                                         break;
    2891                                 }
    2892                         }
    2893                 }
    2894         }
    2895 
    2896         // Compile and execute a filtering function if one is not provided
    2897         // Provide `match` to avoid retokenization if we modified the selector above
    2898         ( compiled || compile( selector, match ) )(
    2899                 seed,
    2900                 context,
    2901                 !documentIsHTML,
    2902                 results,
    2903                 !context || rsibling.test( selector ) && testContext( context.parentNode ) || context
    2904         );
    2905         return results;
    2906 };
    2907 
    2908 // One-time assignments
    2909 
    2910 // Sort stability
    2911 support.sortStable = expando.split( "" ).sort( sortOrder ).join( "" ) === expando;
    2912 
    2913 // Support: Chrome 14-35+
    2914 // Always assume duplicates if they aren't passed to the comparison function
    2915 support.detectDuplicates = !!hasDuplicate;
    2916 
    2917 // Initialize against the default document
    2918 setDocument();
    2919 
    2920 // Support: Webkit<537.32 - Safari 6.0.3/Chrome 25 (fixed in Chrome 27)
    2921 // Detached nodes confoundingly follow *each other*
    2922 support.sortDetached = assert( function( el ) {
    2923 
    2924         // Should return 1, but returns 4 (following)
    2925         return el.compareDocumentPosition( document.createElement( "fieldset" ) ) & 1;
    2926 } );
    2927 
    2928 // Support: IE<8
    2929 // Prevent attribute/property "interpolation"
    2930 // https://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx
    2931 if ( !assert( function( el ) {
    2932         el.innerHTML = "<a href='#'></a>";
    2933         return el.firstChild.getAttribute( "href" ) === "#";
    2934 } ) ) {
    2935         addHandle( "type|href|height|width", function( elem, name, isXML ) {
    2936                 if ( !isXML ) {
    2937                         return elem.getAttribute( name, name.toLowerCase() === "type" ? 1 : 2 );
    2938                 }
    2939         } );
    2940 }
    2941 
    2942 // Support: IE<9
    2943 // Use defaultValue in place of getAttribute("value")
    2944 if ( !support.attributes || !assert( function( el ) {
    2945         el.innerHTML = "<input/>";
    2946         el.firstChild.setAttribute( "value", "" );
    2947         return el.firstChild.getAttribute( "value" ) === "";
    2948 } ) ) {
    2949         addHandle( "value", function( elem, _name, isXML ) {
    2950                 if ( !isXML && elem.nodeName.toLowerCase() === "input" ) {
    2951                         return elem.defaultValue;
    2952                 }
    2953         } );
    2954 }
    2955 
    2956 // Support: IE<9
    2957 // Use getAttributeNode to fetch booleans when getAttribute lies
    2958 if ( !assert( function( el ) {
    2959         return el.getAttribute( "disabled" ) == null;
    2960 } ) ) {
    2961         addHandle( booleans, function( elem, name, isXML ) {
    2962                 var val;
    2963                 if ( !isXML ) {
    2964                         return elem[ name ] === true ? name.toLowerCase() :
    2965                                 ( val = elem.getAttributeNode( name ) ) && val.specified ?
    2966                                         val.value :
    2967                                         null;
    2968                 }
    2969         } );
    2970 }
    2971 
    2972 return Sizzle;
    2973 
    2974 } )( window );
    2975 
    2976 
    2977 
    2978 jQuery.find = Sizzle;
    2979 jQuery.expr = Sizzle.selectors;
    2980 
    2981 // Deprecated
    2982 jQuery.expr[ ":" ] = jQuery.expr.pseudos;
    2983 jQuery.uniqueSort = jQuery.unique = Sizzle.uniqueSort;
    2984 jQuery.text = Sizzle.getText;
    2985 jQuery.isXMLDoc = Sizzle.isXML;
    2986 jQuery.contains = Sizzle.contains;
    2987 jQuery.escapeSelector = Sizzle.escape;
    2988 
    2989 
    2990 
    2991 
    2992 var dir = function( elem, dir, until ) {
    2993         var matched = [],
    2994                 truncate = until !== undefined;
    2995 
    2996         while ( ( elem = elem[ dir ] ) && elem.nodeType !== 9 ) {
    2997                 if ( elem.nodeType === 1 ) {
    2998                         if ( truncate && jQuery( elem ).is( until ) ) {
    2999                                 break;
    3000                         }
    3001                         matched.push( elem );
    3002                 }
    3003         }
    3004         return matched;
    3005 };
    3006 
    3007 
    3008 var siblings = function( n, elem ) {
    3009         var matched = [];
    3010 
    3011         for ( ; n; n = n.nextSibling ) {
    3012                 if ( n.nodeType === 1 && n !== elem ) {
    3013                         matched.push( n );
    3014                 }
    3015         }
    3016 
    3017         return matched;
    3018 };
    3019 
    3020 
    3021 var rneedsContext = jQuery.expr.match.needsContext;
    3022 
    3023 
    3024 
    3025 function nodeName( elem, name ) {
    3026 
    3027   return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase();
    3028 
    3029 };
    3030 var rsingleTag = ( /^<([a-z][^\/\0>:\x20\t\r\n\f]*)[\x20\t\r\n\f]*\/?>(?:<\/\1>|)$/i );
    3031 
    3032 
    3033 
    3034 // Implement the identical functionality for filter and not
    3035 function winnow( elements, qualifier, not ) {
    3036         if ( isFunction( qualifier ) ) {
    3037                 return jQuery.grep( elements, function( elem, i ) {
    3038                         return !!qualifier.call( elem, i, elem ) !== not;
    3039                 } );
    3040         }
    3041 
    3042         // Single element
    3043         if ( qualifier.nodeType ) {
    3044                 return jQuery.grep( elements, function( elem ) {
    3045                         return ( elem === qualifier ) !== not;
    3046                 } );
    3047         }
    3048 
    3049         // Arraylike of elements (jQuery, arguments, Array)
    3050         if ( typeof qualifier !== "string" ) {
    3051                 return jQuery.grep( elements, function( elem ) {
    3052                         return ( indexOf.call( qualifier, elem ) > -1 ) !== not;
    3053                 } );
    3054         }
    3055 
    3056         // Filtered directly for both simple and complex selectors
    3057         return jQuery.filter( qualifier, elements, not );
    3058 }
    3059 
    3060 jQuery.filter = function( expr, elems, not ) {
    3061         var elem = elems[ 0 ];
    3062 
    3063         if ( not ) {
    3064                 expr = ":not(" + expr + ")";
    3065         }
    3066 
    3067         if ( elems.length === 1 && elem.nodeType === 1 ) {
    3068                 return jQuery.find.matchesSelector( elem, expr ) ? [ elem ] : [];
    3069         }
    3070 
    3071         return jQuery.find.matches( expr, jQuery.grep( elems, function( elem ) {
    3072                 return elem.nodeType === 1;
    3073         } ) );
    3074 };
    3075 
    3076 jQuery.fn.extend( {
    3077         find: function( selector ) {
    3078                 var i, ret,
    3079                         len = this.length,
    3080                         self = this;
    3081 
    3082                 if ( typeof selector !== "string" ) {
    3083                         return this.pushStack( jQuery( selector ).filter( function() {
    3084                                 for ( i = 0; i < len; i++ ) {
    3085                                         if ( jQuery.contains( self[ i ], this ) ) {
    3086                                                 return true;
    3087                                         }
    3088                                 }
    3089                         } ) );
    3090                 }
    3091 
    3092                 ret = this.pushStack( [] );
    3093 
    3094                 for ( i = 0; i < len; i++ ) {
    3095                         jQuery.find( selector, self[ i ], ret );
    3096                 }
    3097 
    3098                 return len > 1 ? jQuery.uniqueSort( ret ) : ret;
    3099         },
    3100         filter: function( selector ) {
    3101                 return this.pushStack( winnow( this, selector || [], false ) );
    3102         },
    3103         not: function( selector ) {
    3104                 return this.pushStack( winnow( this, selector || [], true ) );
    3105         },
    3106         is: function( selector ) {
    3107                 return !!winnow(
    3108                         this,
    3109 
    3110                         // If this is a positional/relative selector, check membership in the returned set
    3111                         // so $("p:first").is("p:last") won't return true for a doc with two "p".
    3112                         typeof selector === "string" && rneedsContext.test( selector ) ?
    3113                                 jQuery( selector ) :
    3114                                 selector || [],
    3115                         false
    3116                 ).length;
    3117         }
    3118 } );
    3119 
    3120 
    3121 // Initialize a jQuery object
    3122 
    3123 
    3124 // A central reference to the root jQuery(document)
    3125 var rootjQuery,
    3126 
    3127         // A simple way to check for HTML strings
    3128         // Prioritize #id over <tag> to avoid XSS via location.hash (#9521)
    3129         // Strict HTML recognition (#11290: must start with <)
    3130         // Shortcut simple #id case for speed
    3131         rquickExpr = /^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]+))$/,
    3132 
    3133         init = jQuery.fn.init = function( selector, context, root ) {
    3134                 var match, elem;
    3135 
    3136                 // HANDLE: $(""), $(null), $(undefined), $(false)
    3137                 if ( !selector ) {
    3138                         return this;
    3139                 }
    3140 
    3141                 // Method init() accepts an alternate rootjQuery
    3142                 // so migrate can support jQuery.sub (gh-2101)
    3143                 root = root || rootjQuery;
    3144 
    3145                 // Handle HTML strings
    3146                 if ( typeof selector === "string" ) {
    3147                         if ( selector[ 0 ] === "<" &&
    3148                                 selector[ selector.length - 1 ] === ">" &&
    3149                                 selector.length >= 3 ) {
    3150 
    3151                                 // Assume that strings that start and end with <> are HTML and skip the regex check
    3152                                 match = [ null, selector, null ];
    3153 
    3154                         } else {
    3155                                 match = rquickExpr.exec( selector );
    3156                         }
    3157 
    3158                         // Match html or make sure no context is specified for #id
    3159                         if ( match && ( match[ 1 ] || !context ) ) {
    3160 
    3161                                 // HANDLE: $(html) -> $(array)
    3162                                 if ( match[ 1 ] ) {
    3163                                         context = context instanceof jQuery ? context[ 0 ] : context;
    3164 
    3165                                         // Option to run scripts is true for back-compat
    3166                                         // Intentionally let the error be thrown if parseHTML is not present
    3167                                         jQuery.merge( this, jQuery.parseHTML(
    3168                                                 match[ 1 ],
    3169                                                 context && context.nodeType ? context.ownerDocument || context : document,
    3170                                                 true
    3171                                         ) );
    3172 
    3173                                         // HANDLE: $(html, props)
    3174                                         if ( rsingleTag.test( match[ 1 ] ) && jQuery.isPlainObject( context ) ) {
    3175                                                 for ( match in context ) {
    3176 
    3177                                                         // Properties of context are called as methods if possible
    3178                                                         if ( isFunction( this[ match ] ) ) {
    3179                                                                 this[ match ]( context[ match ] );
    3180 
    3181                                                         // ...and otherwise set as attributes
    3182                                                         } else {
    3183                                                                 this.attr( match, context[ match ] );
    3184                                                         }
    3185                                                 }
    3186                                         }
    3187 
    3188                                         return this;
    3189 
    3190                                 // HANDLE: $(#id)
    3191                                 } else {
    3192                                         elem = document.getElementById( match[ 2 ] );
    3193 
    3194                                         if ( elem ) {
    3195 
    3196                                                 // Inject the element directly into the jQuery object
    3197                                                 this[ 0 ] = elem;
    3198                                                 this.length = 1;
    3199                                         }
    3200                                         return this;
    3201                                 }
    3202 
    3203                         // HANDLE: $(expr, $(...))
    3204                         } else if ( !context || context.jquery ) {
    3205                                 return ( context || root ).find( selector );
    3206 
    3207                         // HANDLE: $(expr, context)
    3208                         // (which is just equivalent to: $(context).find(expr)
    3209                         } else {
    3210                                 return this.constructor( context ).find( selector );
    3211                         }
    3212 
    3213                 // HANDLE: $(DOMElement)
    3214                 } else if ( selector.nodeType ) {
    3215                         this[ 0 ] = selector;
    3216                         this.length = 1;
    3217                         return this;
    3218 
    3219                 // HANDLE: $(function)
    3220                 // Shortcut for document ready
    3221                 } else if ( isFunction( selector ) ) {
    3222                         return root.ready !== undefined ?
    3223                                 root.ready( selector ) :
    3224 
    3225                                 // Execute immediately if ready is not present
    3226                                 selector( jQuery );
    3227                 }
    3228 
    3229                 return jQuery.makeArray( selector, this );
    3230         };
    3231 
    3232 // Give the init function the jQuery prototype for later instantiation
    3233 init.prototype = jQuery.fn;
    3234 
    3235 // Initialize central reference
    3236 rootjQuery = jQuery( document );
    3237 
    3238 
    3239 var rparentsprev = /^(?:parents|prev(?:Until|All))/,
    3240 
    3241         // Methods guaranteed to produce a unique set when starting from a unique set
    3242         guaranteedUnique = {
    3243                 children: true,
    3244                 contents: true,
    3245                 next: true,
    3246                 prev: true
    3247         };
    3248 
    3249 jQuery.fn.extend( {
    3250         has: function( target ) {
    3251                 var targets = jQuery( target, this ),
    3252                         l = targets.length;
    3253 
    3254                 return this.filter( function() {
    3255                         var i = 0;
    3256                         for ( ; i < l; i++ ) {
    3257                                 if ( jQuery.contains( this, targets[ i ] ) ) {
    3258                                         return true;
    3259                                 }
    3260                         }
    3261                 } );
    3262         },
    3263 
    3264         closest: function( selectors, context ) {
    3265                 var cur,
    3266                         i = 0,
    3267                         l = this.length,
    3268                         matched = [],
    3269                         targets = typeof selectors !== "string" && jQuery( selectors );
    3270 
    3271                 // Positional selectors never match, since there's no _selection_ context
    3272                 if ( !rneedsContext.test( selectors ) ) {
    3273                         for ( ; i < l; i++ ) {
    3274                                 for ( cur = this[ i ]; cur && cur !== context; cur = cur.parentNode ) {
    3275 
    3276                                         // Always skip document fragments
    3277                                         if ( cur.nodeType < 11 && ( targets ?
    3278                                                 targets.index( cur ) > -1 :
    3279 
    3280                                                 // Don't pass non-elements to Sizzle
    3281                                                 cur.nodeType === 1 &&
    3282                                                         jQuery.find.matchesSelector( cur, selectors ) ) ) {
    3283 
    3284                                                 matched.push( cur );
    3285                                                 break;
    3286                                         }
    3287                                 }
    3288                         }
    3289                 }
    3290 
    3291                 return this.pushStack( matched.length > 1 ? jQuery.uniqueSort( matched ) : matched );
    3292         },
    3293 
    3294         // Determine the position of an element within the set
    3295         index: function( elem ) {
    3296 
    3297                 // No argument, return index in parent
    3298                 if ( !elem ) {
    3299                         return ( this[ 0 ] && this[ 0 ].parentNode ) ? this.first().prevAll().length : -1;
    3300                 }
    3301 
    3302                 // Index in selector
    3303                 if ( typeof elem === "string" ) {
    3304                         return indexOf.call( jQuery( elem ), this[ 0 ] );
    3305                 }
    3306 
    3307                 // Locate the position of the desired element
    3308                 return indexOf.call( this,
    3309 
    3310                         // If it receives a jQuery object, the first element is used
    3311                         elem.jquery ? elem[ 0 ] : elem
    3312                 );
    3313         },
    3314 
    3315         add: function( selector, context ) {
    3316                 return this.pushStack(
    3317                         jQuery.uniqueSort(
    3318                                 jQuery.merge( this.get(), jQuery( selector, context ) )
    3319                         )
    3320                 );
    3321         },
    3322 
    3323         addBack: function( selector ) {
    3324                 return this.add( selector == null ?
    3325                         this.prevObject : this.prevObject.filter( selector )
    3326                 );
    3327         }
    3328 } );
    3329 
    3330 function sibling( cur, dir ) {
    3331         while ( ( cur = cur[ dir ] ) && cur.nodeType !== 1 ) {}
    3332         return cur;
    3333 }
    3334 
    3335 jQuery.each( {
    3336         parent: function( elem ) {
    3337                 var parent = elem.parentNode;
    3338                 return parent && parent.nodeType !== 11 ? parent : null;
    3339         },
    3340         parents: function( elem ) {
    3341                 return dir( elem, "parentNode" );
    3342         },
    3343         parentsUntil: function( elem, _i, until ) {
    3344                 return dir( elem, "parentNode", until );
    3345         },
    3346         next: function( elem ) {
    3347                 return sibling( elem, "nextSibling" );
    3348         },
    3349         prev: function( elem ) {
    3350                 return sibling( elem, "previousSibling" );
    3351         },
    3352         nextAll: function( elem ) {
    3353                 return dir( elem, "nextSibling" );
    3354         },
    3355         prevAll: function( elem ) {
    3356                 return dir( elem, "previousSibling" );
    3357         },
    3358         nextUntil: function( elem, _i, until ) {
    3359                 return dir( elem, "nextSibling", until );
    3360         },
    3361         prevUntil: function( elem, _i, until ) {
    3362                 return dir( elem, "previousSibling", until );
    3363         },
    3364         siblings: function( elem ) {
    3365                 return siblings( ( elem.parentNode || {} ).firstChild, elem );
    3366         },
    3367         children: function( elem ) {
    3368                 return siblings( elem.firstChild );
    3369         },
    3370         contents: function( elem ) {
    3371                 if ( elem.contentDocument != null &&
    3372 
    3373                         // Support: IE 11+
    3374                         // <object> elements with no `data` attribute has an object
    3375                         // `contentDocument` with a `null` prototype.
    3376                         getProto( elem.contentDocument ) ) {
    3377 
    3378                         return elem.contentDocument;
    3379                 }
    3380 
    3381                 // Support: IE 9 - 11 only, iOS 7 only, Android Browser <=4.3 only
    3382                 // Treat the template element as a regular one in browsers that
    3383                 // don't support it.
    3384                 if ( nodeName( elem, "template" ) ) {
    3385                         elem = elem.content || elem;
    3386                 }
    3387 
    3388                 return jQuery.merge( [], elem.childNodes );
    3389         }
    3390 }, function( name, fn ) {
    3391         jQuery.fn[ name ] = function( until, selector ) {
    3392                 var matched = jQuery.map( this, fn, until );
    3393 
    3394                 if ( name.slice( -5 ) !== "Until" ) {
    3395                         selector = until;
    3396                 }
    3397 
    3398                 if ( selector && typeof selector === "string" ) {
    3399                         matched = jQuery.filter( selector, matched );
    3400                 }
    3401 
    3402                 if ( this.length > 1 ) {
    3403 
    3404                         // Remove duplicates
    3405                         if ( !guaranteedUnique[ name ] ) {
    3406                                 jQuery.uniqueSort( matched );
    3407                         }
    3408 
    3409                         // Reverse order for parents* and prev-derivatives
    3410                         if ( rparentsprev.test( name ) ) {
    3411                                 matched.reverse();
    3412                         }
    3413                 }
    3414 
    3415                 return this.pushStack( matched );
    3416         };
    3417 } );
    3418 var rnothtmlwhite = ( /[^\x20\t\r\n\f]+/g );
    3419 
    3420 
    3421 
    3422 // Convert String-formatted options into Object-formatted ones
    3423 function createOptions( options ) {
    3424         var object = {};
    3425         jQuery.each( options.match( rnothtmlwhite ) || [], function( _, flag ) {
    3426                 object[ flag ] = true;
    3427         } );
    3428         return object;
    3429 }
    3430 
    3431 /*
    3432  * Create a callback list using the following parameters:
    3433  *
    3434  *      options: an optional list of space-separated options that will change how
    3435  *                      the callback list behaves or a more traditional option object
    3436  *
    3437  * By default a callback list will act like an event callback list and can be
    3438  * "fired" multiple times.
    3439  *
    3440  * Possible options:
    3441  *
    3442  *      once:                   will ensure the callback list can only be fired once (like a Deferred)
    3443  *
    3444  *      memory:                 will keep track of previous values and will call any callback added
    3445  *                                      after the list has been fired right away with the latest "memorized"
    3446  *                                      values (like a Deferred)
    3447  *
    3448  *      unique:                 will ensure a callback can only be added once (no duplicate in the list)
    3449  *
    3450  *      stopOnFalse:    interrupt callings when a callback returns false
    3451  *
    3452  */
    3453 jQuery.Callbacks = function( options ) {
    3454 
    3455         // Convert options from String-formatted to Object-formatted if needed
    3456         // (we check in cache first)
    3457         options = typeof options === "string" ?
    3458                 createOptions( options ) :
    3459                 jQuery.extend( {}, options );
    3460 
    3461         var // Flag to know if list is currently firing
    3462                 firing,
    3463 
    3464                 // Last fire value for non-forgettable lists
    3465                 memory,
    3466 
    3467                 // Flag to know if list was already fired
    3468                 fired,
    3469 
    3470                 // Flag to prevent firing
    3471                 locked,
    3472 
    3473                 // Actual callback list
    3474                 list = [],
    3475 
    3476                 // Queue of execution data for repeatable lists
    3477                 queue = [],
    3478 
    3479                 // Index of currently firing callback (modified by add/remove as needed)
    3480                 firingIndex = -1,
    3481 
    3482                 // Fire callbacks
    3483                 fire = function() {
    3484 
    3485                         // Enforce single-firing
    3486                         locked = locked || options.once;
    3487 
    3488                         // Execute callbacks for all pending executions,
    3489                         // respecting firingIndex overrides and runtime changes
    3490                         fired = firing = true;
    3491                         for ( ; queue.length; firingIndex = -1 ) {
    3492                                 memory = queue.shift();
    3493                                 while ( ++firingIndex < list.length ) {
    3494 
    3495                                         // Run callback and check for early termination
    3496                                         if ( list[ firingIndex ].apply( memory[ 0 ], memory[ 1 ] ) === false &&
    3497                                                 options.stopOnFalse ) {
    3498 
    3499                                                 // Jump to end and forget the data so .add doesn't re-fire
    3500                                                 firingIndex = list.length;
    3501                                                 memory = false;
    3502                                         }
    3503                                 }
    3504                         }
    3505 
    3506                         // Forget the data if we're done with it
    3507                         if ( !options.memory ) {
    3508                                 memory = false;
    3509                         }
    3510 
    3511                         firing = false;
    3512 
    3513                         // Clean up if we're done firing for good
    3514                         if ( locked ) {
    3515 
    3516                                 // Keep an empty list if we have data for future add calls
    3517                                 if ( memory ) {
    3518                                         list = [];
    3519 
    3520                                 // Otherwise, this object is spent
    3521                                 } else {
    3522                                         list = "";
    3523                                 }
    3524                         }
    3525                 },
    3526 
    3527                 // Actual Callbacks object
    3528                 self = {
    3529 
    3530                         // Add a callback or a collection of callbacks to the list
    3531                         add: function() {
    3532                                 if ( list ) {
    3533 
    3534                                         // If we have memory from a past run, we should fire after adding
    3535                                         if ( memory && !firing ) {
    3536                                                 firingIndex = list.length - 1;
    3537                                                 queue.push( memory );
    3538                                         }
    3539 
    3540                                         ( function add( args ) {
    3541                                                 jQuery.each( args, function( _, arg ) {
    3542                                                         if ( isFunction( arg ) ) {
    3543                                                                 if ( !options.unique || !self.has( arg ) ) {
    3544                                                                         list.push( arg );
    3545                                                                 }
    3546                                                         } else if ( arg && arg.length && toType( arg ) !== "string" ) {
    3547 
    3548                                                                 // Inspect recursively
    3549                                                                 add( arg );
    3550                                                         }
    3551                                                 } );
    3552                                         } )( arguments );
    3553 
    3554                                         if ( memory && !firing ) {
    3555                                                 fire();
    3556                                         }
    3557                                 }
    3558                                 return this;
    3559                         },
    3560 
    3561                         // Remove a callback from the list
    3562                         remove: function() {
    3563                                 jQuery.each( arguments, function( _, arg ) {
    3564                                         var index;
    3565                                         while ( ( index = jQuery.inArray( arg, list, index ) ) > -1 ) {
    3566                                                 list.splice( index, 1 );
    3567 
    3568                                                 // Handle firing indexes
    3569                                                 if ( index <= firingIndex ) {
    3570                                                         firingIndex--;
    3571                                                 }
    3572                                         }
    3573                                 } );
    3574                                 return this;
    3575                         },
    3576 
    3577                         // Check if a given callback is in the list.
    3578                         // If no argument is given, return whether or not list has callbacks attached.
    3579                         has: function( fn ) {
    3580                                 return fn ?
    3581                                         jQuery.inArray( fn, list ) > -1 :
    3582                                         list.length > 0;
    3583                         },
    3584 
    3585                         // Remove all callbacks from the list
    3586                         empty: function() {
    3587                                 if ( list ) {
    3588                                         list = [];
    3589                                 }
    3590                                 return this;
    3591                         },
    3592 
    3593                         // Disable .fire and .add
    3594                         // Abort any current/pending executions
    3595                         // Clear all callbacks and values
    3596                         disable: function() {
    3597                                 locked = queue = [];
    3598                                 list = memory = "";
    3599                                 return this;
    3600                         },
    3601                         disabled: function() {
    3602                                 return !list;
    3603                         },
    3604 
    3605                         // Disable .fire
    3606                         // Also disable .add unless we have memory (since it would have no effect)
    3607                         // Abort any pending executions
    3608                         lock: function() {
    3609                                 locked = queue = [];
    3610                                 if ( !memory && !firing ) {
    3611                                         list = memory = "";
    3612                                 }
    3613                                 return this;
    3614                         },
    3615                         locked: function() {
    3616                                 return !!locked;
    3617                         },
    3618 
    3619                         // Call all callbacks with the given context and arguments
    3620                         fireWith: function( context, args ) {
    3621                                 if ( !locked ) {
    3622                                         args = args || [];
    3623                                         args = [ context, args.slice ? args.slice() : args ];
    3624                                         queue.push( args );
    3625                                         if ( !firing ) {
    3626                                                 fire();
    3627                                         }
    3628                                 }
    3629                                 return this;
    3630                         },
    3631 
    3632                         // Call all the callbacks with the given arguments
    3633                         fire: function() {
    3634                                 self.fireWith( this, arguments );
    3635                                 return this;
    3636                         },
    3637 
    3638                         // To know if the callbacks have already been called at least once
    3639                         fired: function() {
    3640                                 return !!fired;
    3641                         }
    3642                 };
    3643 
    3644         return self;
    3645 };
    3646 
    3647 
    3648 function Identity( v ) {
    3649         return v;
    3650 }
    3651 function Thrower( ex ) {
    3652         throw ex;
    3653 }
    3654 
    3655 function adoptValue( value, resolve, reject, noValue ) {
    3656         var method;
    3657 
    3658         try {
    3659 
    3660                 // Check for promise aspect first to privilege synchronous behavior
    3661                 if ( value && isFunction( ( method = value.promise ) ) ) {
    3662                         method.call( value ).done( resolve ).fail( reject );
    3663 
    3664                 // Other thenables
    3665                 } else if ( value && isFunction( ( method = value.then ) ) ) {
    3666                         method.call( value, resolve, reject );
    3667 
    3668                 // Other non-thenables
    3669                 } else {
    3670 
    3671                         // Control `resolve` arguments by letting Array#slice cast boolean `noValue` to integer:
    3672                         // * false: [ value ].slice( 0 ) => resolve( value )
    3673                         // * true: [ value ].slice( 1 ) => resolve()
    3674                         resolve.apply( undefined, [ value ].slice( noValue ) );
    3675                 }
    3676 
    3677         // For Promises/A+, convert exceptions into rejections
    3678         // Since jQuery.when doesn't unwrap thenables, we can skip the extra checks appearing in
    3679         // Deferred#then to conditionally suppress rejection.
    3680         } catch ( value ) {
    3681 
    3682                 // Support: Android 4.0 only
    3683                 // Strict mode functions invoked without .call/.apply get global-object context
    3684                 reject.apply( undefined, [ value ] );
    3685         }
    3686 }
    3687 
    3688 jQuery.extend( {
    3689 
    3690         Deferred: function( func ) {
    3691                 var tuples = [
    3692 
    3693                                 // action, add listener, callbacks,
    3694                                 // ... .then handlers, argument index, [final state]
    3695                                 [ "notify", "progress", jQuery.Callbacks( "memory" ),
    3696                                         jQuery.Callbacks( "memory" ), 2 ],
    3697                                 [ "resolve", "done", jQuery.Callbacks( "once memory" ),
    3698                                         jQuery.Callbacks( "once memory" ), 0, "resolved" ],
    3699                                 [ "reject", "fail", jQuery.Callbacks( "once memory" ),
    3700                                         jQuery.Callbacks( "once memory" ), 1, "rejected" ]
    3701                         ],
    3702                         state = "pending",
    3703                         promise = {
    3704                                 state: function() {
    3705                                         return state;
    3706                                 },
    3707                                 always: function() {
    3708                                         deferred.done( arguments ).fail( arguments );
    3709                                         return this;
    3710                                 },
    3711                                 "catch": function( fn ) {
    3712                                         return promise.then( null, fn );
    3713                                 },
    3714 
    3715                                 // Keep pipe for back-compat
    3716                                 pipe: function( /* fnDone, fnFail, fnProgress */ ) {
    3717                                         var fns = arguments;
    3718 
    3719                                         return jQuery.Deferred( function( newDefer ) {
    3720                                                 jQuery.each( tuples, function( _i, tuple ) {
    3721 
    3722                                                         // Map tuples (progress, done, fail) to arguments (done, fail, progress)
    3723                                                         var fn = isFunction( fns[ tuple[ 4 ] ] ) && fns[ tuple[ 4 ] ];
    3724 
    3725                                                         // deferred.progress(function() { bind to newDefer or newDefer.notify })
    3726                                                         // deferred.done(function() { bind to newDefer or newDefer.resolve })
    3727                                                         // deferred.fail(function() { bind to newDefer or newDefer.reject })
    3728                                                         deferred[ tuple[ 1 ] ]( function() {
    3729                                                                 var returned = fn && fn.apply( this, arguments );
    3730                                                                 if ( returned && isFunction( returned.promise ) ) {
    3731                                                                         returned.promise()
    3732                                                                                 .progress( newDefer.notify )
    3733                                                                                 .done( newDefer.resolve )
    3734                                                                                 .fail( newDefer.reject );
    3735                                                                 } else {
    3736                                                                         newDefer[ tuple[ 0 ] + "With" ](
    3737                                                                                 this,
    3738                                                                                 fn ? [ returned ] : arguments
    3739                                                                         );
    3740                                                                 }
    3741                                                         } );
    3742                                                 } );
    3743                                                 fns = null;
    3744                                         } ).promise();
    3745                                 },
    3746                                 then: function( onFulfilled, onRejected, onProgress ) {
    3747                                         var maxDepth = 0;
    3748                                         function resolve( depth, deferred, handler, special ) {
    3749                                                 return function() {
    3750                                                         var that = this,
    3751                                                                 args = arguments,
    3752                                                                 mightThrow = function() {
    3753                                                                         var returned, then;
    3754 
    3755                                                                         // Support: Promises/A+ section 2.3.3.3.3
    3756                                                                         // https://promisesaplus.com/#point-59
    3757                                                                         // Ignore double-resolution attempts
    3758                                                                         if ( depth < maxDepth ) {
    3759                                                                                 return;
    3760                                                                         }
    3761 
    3762                                                                         returned = handler.apply( that, args );
    3763 
    3764                                                                         // Support: Promises/A+ section 2.3.1
    3765                                                                         // https://promisesaplus.com/#point-48
    3766                                                                         if ( returned === deferred.promise() ) {
    3767                                                                                 throw new TypeError( "Thenable self-resolution" );
    3768                                                                         }
    3769 
    3770                                                                         // Support: Promises/A+ sections 2.3.3.1, 3.5
    3771                                                                         // https://promisesaplus.com/#point-54
    3772                                                                         // https://promisesaplus.com/#point-75
    3773                                                                         // Retrieve `then` only once
    3774                                                                         then = returned &&
    3775 
    3776                                                                                 // Support: Promises/A+ section 2.3.4
    3777                                                                                 // https://promisesaplus.com/#point-64
    3778                                                                                 // Only check objects and functions for thenability
    3779                                                                                 ( typeof returned === "object" ||
    3780                                                                                         typeof returned === "function" ) &&
    3781                                                                                 returned.then;
    3782 
    3783                                                                         // Handle a returned thenable
    3784                                                                         if ( isFunction( then ) ) {
    3785 
    3786                                                                                 // Special processors (notify) just wait for resolution
    3787                                                                                 if ( special ) {
    3788                                                                                         then.call(
    3789                                                                                                 returned,
    3790                                                                                                 resolve( maxDepth, deferred, Identity, special ),
    3791                                                                                                 resolve( maxDepth, deferred, Thrower, special )
    3792                                                                                         );
    3793 
    3794                                                                                 // Normal processors (resolve) also hook into progress
    3795                                                                                 } else {
    3796 
    3797                                                                                         // ...and disregard older resolution values
    3798                                                                                         maxDepth++;
    3799 
    3800                                                                                         then.call(
    3801                                                                                                 returned,
    3802                                                                                                 resolve( maxDepth, deferred, Identity, special ),
    3803                                                                                                 resolve( maxDepth, deferred, Thrower, special ),
    3804                                                                                                 resolve( maxDepth, deferred, Identity,
    3805                                                                                                         deferred.notifyWith )
    3806                                                                                         );
    3807                                                                                 }
    3808 
    3809                                                                         // Handle all other returned values
    3810                                                                         } else {
    3811 
    3812                                                                                 // Only substitute handlers pass on context
    3813                                                                                 // and multiple values (non-spec behavior)
    3814                                                                                 if ( handler !== Identity ) {
    3815                                                                                         that = undefined;
    3816                                                                                         args = [ returned ];
    3817                                                                                 }
    3818 
    3819                                                                                 // Process the value(s)
    3820                                                                                 // Default process is resolve
    3821                                                                                 ( special || deferred.resolveWith )( that, args );
    3822                                                                         }
    3823                                                                 },
    3824 
    3825                                                                 // Only normal processors (resolve) catch and reject exceptions
    3826                                                                 process = special ?
    3827                                                                         mightThrow :
    3828                                                                         function() {
    3829                                                                                 try {
    3830                                                                                         mightThrow();
    3831                                                                                 } catch ( e ) {
    3832 
    3833                                                                                         if ( jQuery.Deferred.exceptionHook ) {
    3834                                                                                                 jQuery.Deferred.exceptionHook( e,
    3835                                                                                                         process.stackTrace );
    3836                                                                                         }
    3837 
    3838                                                                                         // Support: Promises/A+ section 2.3.3.3.4.1
    3839                                                                                         // https://promisesaplus.com/#point-61
    3840                                                                                         // Ignore post-resolution exceptions
    3841                                                                                         if ( depth + 1 >= maxDepth ) {
    3842 
    3843                                                                                                 // Only substitute handlers pass on context
    3844                                                                                                 // and multiple values (non-spec behavior)
    3845                                                                                                 if ( handler !== Thrower ) {
    3846                                                                                                         that = undefined;
    3847                                                                                                         args = [ e ];
    3848                                                                                                 }
    3849 
    3850                                                                                                 deferred.rejectWith( that, args );
    3851                                                                                         }
    3852                                                                                 }
    3853                                                                         };
    3854 
    3855                                                         // Support: Promises/A+ section 2.3.3.3.1
    3856                                                         // https://promisesaplus.com/#point-57
    3857                                                         // Re-resolve promises immediately to dodge false rejection from
    3858                                                         // subsequent errors
    3859                                                         if ( depth ) {
    3860                                                                 process();
    3861                                                         } else {
    3862 
    3863                                                                 // Call an optional hook to record the stack, in case of exception
    3864                                                                 // since it's otherwise lost when execution goes async
    3865                                                                 if ( jQuery.Deferred.getStackHook ) {
    3866                                                                         process.stackTrace = jQuery.Deferred.getStackHook();
    3867                                                                 }
    3868                                                                 window.setTimeout( process );
    3869                                                         }
    3870                                                 };
    3871                                         }
    3872 
    3873                                         return jQuery.Deferred( function( newDefer ) {
    3874 
    3875                                                 // progress_handlers.add( ... )
    3876                                                 tuples[ 0 ][ 3 ].add(
    3877                                                         resolve(
    3878                                                                 0,
    3879                                                                 newDefer,
    3880                                                                 isFunction( onProgress ) ?
    3881                                                                         onProgress :
    3882                                                                         Identity,
    3883                                                                 newDefer.notifyWith
    3884                                                         )
    3885                                                 );
    3886 
    3887                                                 // fulfilled_handlers.add( ... )
    3888                                                 tuples[ 1 ][ 3 ].add(
    3889                                                         resolve(
    3890                                                                 0,
    3891                                                                 newDefer,
    3892                                                                 isFunction( onFulfilled ) ?
    3893                                                                         onFulfilled :
    3894                                                                         Identity
    3895                                                         )
    3896                                                 );
    3897 
    3898                                                 // rejected_handlers.add( ... )
    3899                                                 tuples[ 2 ][ 3 ].add(
    3900                                                         resolve(
    3901                                                                 0,
    3902                                                                 newDefer,
    3903                                                                 isFunction( onRejected ) ?
    3904                                                                         onRejected :
    3905                                                                         Thrower
    3906                                                         )
    3907                                                 );
    3908                                         } ).promise();
    3909                                 },
    3910 
    3911                                 // Get a promise for this deferred
    3912                                 // If obj is provided, the promise aspect is added to the object
    3913                                 promise: function( obj ) {
    3914                                         return obj != null ? jQuery.extend( obj, promise ) : promise;
    3915                                 }
    3916                         },
    3917                         deferred = {};
    3918 
    3919                 // Add list-specific methods
    3920                 jQuery.each( tuples, function( i, tuple ) {
    3921                         var list = tuple[ 2 ],
    3922                                 stateString = tuple[ 5 ];
    3923 
    3924                         // promise.progress = list.add
    3925                         // promise.done = list.add
    3926                         // promise.fail = list.add
    3927                         promise[ tuple[ 1 ] ] = list.add;
    3928 
    3929                         // Handle state
    3930                         if ( stateString ) {
    3931                                 list.add(
    3932                                         function() {
    3933 
    3934                                                 // state = "resolved" (i.e., fulfilled)
    3935                                                 // state = "rejected"
    3936                                                 state = stateString;
    3937                                         },
    3938 
    3939                                         // rejected_callbacks.disable
    3940                                         // fulfilled_callbacks.disable
    3941                                         tuples[ 3 - i ][ 2 ].disable,
    3942 
    3943                                         // rejected_handlers.disable
    3944                                         // fulfilled_handlers.disable
    3945                                         tuples[ 3 - i ][ 3 ].disable,
    3946 
    3947                                         // progress_callbacks.lock
    3948                                         tuples[ 0 ][ 2 ].lock,
    3949 
    3950                                         // progress_handlers.lock
    3951                                         tuples[ 0 ][ 3 ].lock
    3952                                 );
    3953                         }
    3954 
    3955                         // progress_handlers.fire
    3956                         // fulfilled_handlers.fire
    3957                         // rejected_handlers.fire
    3958                         list.add( tuple[ 3 ].fire );
    3959 
    3960                         // deferred.notify = function() { deferred.notifyWith(...) }
    3961                         // deferred.resolve = function() { deferred.resolveWith(...) }
    3962                         // deferred.reject = function() { deferred.rejectWith(...) }
    3963                         deferred[ tuple[ 0 ] ] = function() {
    3964                                 deferred[ tuple[ 0 ] + "With" ]( this === deferred ? undefined : this, arguments );
    3965                                 return this;
    3966                         };
    3967 
    3968                         // deferred.notifyWith = list.fireWith
    3969                         // deferred.resolveWith = list.fireWith
    3970                         // deferred.rejectWith = list.fireWith
    3971                         deferred[ tuple[ 0 ] + "With" ] = list.fireWith;
    3972                 } );
    3973 
    3974                 // Make the deferred a promise
    3975                 promise.promise( deferred );
    3976 
    3977                 // Call given func if any
    3978                 if ( func ) {
    3979                         func.call( deferred, deferred );
    3980                 }
    3981 
    3982                 // All done!
    3983                 return deferred;
    3984         },
    3985 
    3986         // Deferred helper
    3987         when: function( singleValue ) {
    3988                 var
    3989 
    3990                         // count of uncompleted subordinates
    3991                         remaining = arguments.length,
    3992 
    3993                         // count of unprocessed arguments
    3994                         i = remaining,
    3995 
    3996                         // subordinate fulfillment data
    3997                         resolveContexts = Array( i ),
    3998                         resolveValues = slice.call( arguments ),
    3999 
    4000                         // the master Deferred
    4001                         master = jQuery.Deferred(),
    4002 
    4003                         // subordinate callback factory
    4004                         updateFunc = function( i ) {
    4005                                 return function( value ) {
    4006                                         resolveContexts[ i ] = this;
    4007                                         resolveValues[ i ] = arguments.length > 1 ? slice.call( arguments ) : value;
    4008                                         if ( !( --remaining ) ) {
    4009                                                 master.resolveWith( resolveContexts, resolveValues );
    4010                                         }
    4011                                 };
    4012                         };
    4013 
    4014                 // Single- and empty arguments are adopted like Promise.resolve
    4015                 if ( remaining <= 1 ) {
    4016                         adoptValue( singleValue, master.done( updateFunc( i ) ).resolve, master.reject,
    4017                                 !remaining );
    4018 
    4019                         // Use .then() to unwrap secondary thenables (cf. gh-3000)
    4020                         if ( master.state() === "pending" ||
    4021                                 isFunction( resolveValues[ i ] && resolveValues[ i ].then ) ) {
    4022 
    4023                                 return master.then();
    4024                         }
    4025                 }
    4026 
    4027                 // Multiple arguments are aggregated like Promise.all array elements
    4028                 while ( i-- ) {
    4029                         adoptValue( resolveValues[ i ], updateFunc( i ), master.reject );
    4030                 }
    4031 
    4032                 return master.promise();
    4033         }
    4034 } );
    4035 
    4036 
    4037 // These usually indicate a programmer mistake during development,
    4038 // warn about them ASAP rather than swallowing them by default.
    4039 var rerrorNames = /^(Eval|Internal|Range|Reference|Syntax|Type|URI)Error$/;
    4040 
    4041 jQuery.Deferred.exceptionHook = function( error, stack ) {
    4042 
    4043         // Support: IE 8 - 9 only
    4044         // Console exists when dev tools are open, which can happen at any time
    4045         if ( window.console && window.console.warn && error && rerrorNames.test( error.name ) ) {
    4046                 window.console.warn( "jQuery.Deferred exception: " + error.message, error.stack, stack );
    4047         }
    4048 };
    4049 
    4050 
    4051 
    4052 
    4053 jQuery.readyException = function( error ) {
    4054         window.setTimeout( function() {
    4055                 throw error;
    4056         } );
    4057 };
    4058 
    4059 
    4060 
    4061 
    4062 // The deferred used on DOM ready
    4063 var readyList = jQuery.Deferred();
    4064 
    4065 jQuery.fn.ready = function( fn ) {
    4066 
    4067         readyList
    4068                 .then( fn )
    4069 
    4070                 // Wrap jQuery.readyException in a function so that the lookup
    4071                 // happens at the time of error handling instead of callback
    4072                 // registration.
    4073                 .catch( function( error ) {
    4074                         jQuery.readyException( error );
    4075                 } );
    4076 
    4077         return this;
    4078 };
    4079 
    4080 jQuery.extend( {
    4081 
    4082         // Is the DOM ready to be used? Set to true once it occurs.
    4083         isReady: false,
    4084 
    4085         // A counter to track how many items to wait for before
    4086         // the ready event fires. See #6781
    4087         readyWait: 1,
    4088 
    4089         // Handle when the DOM is ready
    4090         ready: function( wait ) {
    4091 
    4092                 // Abort if there are pending holds or we're already ready
    4093                 if ( wait === true ? --jQuery.readyWait : jQuery.isReady ) {
    4094                         return;
    4095                 }
    4096 
    4097                 // Remember that the DOM is ready
    4098                 jQuery.isReady = true;
    4099 
    4100                 // If a normal DOM Ready event fired, decrement, and wait if need be
    4101                 if ( wait !== true && --jQuery.readyWait > 0 ) {
    4102                         return;
    4103                 }
    4104 
    4105                 // If there are functions bound, to execute
    4106                 readyList.resolveWith( document, [ jQuery ] );
    4107         }
    4108 } );
    4109 
    4110 jQuery.ready.then = readyList.then;
    4111 
    4112 // The ready event handler and self cleanup method
    4113 function completed() {
    4114         document.removeEventListener( "DOMContentLoaded", completed );
    4115         window.removeEventListener( "load", completed );
    4116         jQuery.ready();
    4117 }
    4118 
    4119 // Catch cases where $(document).ready() is called
    4120 // after the browser event has already occurred.
    4121 // Support: IE <=9 - 10 only
    4122 // Older IE sometimes signals "interactive" too soon
    4123 if ( document.readyState === "complete" ||
    4124         ( document.readyState !== "loading" && !document.documentElement.doScroll ) ) {
    4125 
    4126         // Handle it asynchronously to allow scripts the opportunity to delay ready
    4127         window.setTimeout( jQuery.ready );
    4128 
    4129 } else {
    4130 
    4131         // Use the handy event callback
    4132         document.addEventListener( "DOMContentLoaded", completed );
    4133 
    4134         // A fallback to window.onload, that will always work
    4135         window.addEventListener( "load", completed );
    4136 }
    4137 
    4138 
    4139 
    4140 
    4141 // Multifunctional method to get and set values of a collection
    4142 // The value/s can optionally be executed if it's a function
    4143 var access = function( elems, fn, key, value, chainable, emptyGet, raw ) {
    4144         var i = 0,
    4145                 len = elems.length,
    4146                 bulk = key == null;
    4147 
    4148         // Sets many values
    4149         if ( toType( key ) === "object" ) {
    4150                 chainable = true;
    4151                 for ( i in key ) {
    4152                         access( elems, fn, i, key[ i ], true, emptyGet, raw );
    4153                 }
    4154 
    4155         // Sets one value
    4156         } else if ( value !== undefined ) {
    4157                 chainable = true;
    4158 
    4159                 if ( !isFunction( value ) ) {
    4160                         raw = true;
    4161                 }
    4162 
    4163                 if ( bulk ) {
    4164 
    4165                         // Bulk operations run against the entire set
    4166                         if ( raw ) {
    4167                                 fn.call( elems, value );
    4168                                 fn = null;
    4169 
    4170                         // ...except when executing function values
    4171                         } else {
    4172                                 bulk = fn;
    4173                                 fn = function( elem, _key, value ) {
    4174                                         return bulk.call( jQuery( elem ), value );
    4175                                 };
    4176                         }
    4177                 }
    4178 
    4179                 if ( fn ) {
    4180                         for ( ; i < len; i++ ) {
    4181                                 fn(
    4182                                         elems[ i ], key, raw ?
    4183                                         value :
    4184                                         value.call( elems[ i ], i, fn( elems[ i ], key ) )
    4185                                 );
    4186                         }
    4187                 }
    4188         }
    4189 
    4190         if ( chainable ) {
    4191                 return elems;
    4192         }
    4193 
    4194         // Gets
    4195         if ( bulk ) {
    4196                 return fn.call( elems );
    4197         }
    4198 
    4199         return len ? fn( elems[ 0 ], key ) : emptyGet;
    4200 };
    4201 
    4202 
    4203 // Matches dashed string for camelizing
    4204 var rmsPrefix = /^-ms-/,
    4205         rdashAlpha = /-([a-z])/g;
    4206 
    4207 // Used by camelCase as callback to replace()
    4208 function fcamelCase( _all, letter ) {
    4209         return letter.toUpperCase();
    4210 }
    4211 
    4212 // Convert dashed to camelCase; used by the css and data modules
    4213 // Support: IE <=9 - 11, Edge 12 - 15
    4214 // Microsoft forgot to hump their vendor prefix (#9572)
    4215 function camelCase( string ) {
    4216         return string.replace( rmsPrefix, "ms-" ).replace( rdashAlpha, fcamelCase );
    4217 }
    4218 var acceptData = function( owner ) {
    4219 
    4220         // Accepts only:
    4221         //  - Node
    4222         //    - Node.ELEMENT_NODE
    4223         //    - Node.DOCUMENT_NODE
    4224         //  - Object
    4225         //    - Any
    4226         return owner.nodeType === 1 || owner.nodeType === 9 || !( +owner.nodeType );
    4227 };
    4228 
    4229 
    4230 
    4231 
    4232 function Data() {
    4233         this.expando = jQuery.expando + Data.uid++;
    4234 }
    4235 
    4236 Data.uid = 1;
    4237 
    4238 Data.prototype = {
    4239 
    4240         cache: function( owner ) {
    4241 
    4242                 // Check if the owner object already has a cache
    4243                 var value = owner[ this.expando ];
    4244 
    4245                 // If not, create one
    4246                 if ( !value ) {
    4247                         value = {};
    4248 
    4249                         // We can accept data for non-element nodes in modern browsers,
    4250                         // but we should not, see #8335.
    4251                         // Always return an empty object.
    4252                         if ( acceptData( owner ) ) {
    4253 
    4254                                 // If it is a node unlikely to be stringify-ed or looped over
    4255                                 // use plain assignment
    4256                                 if ( owner.nodeType ) {
    4257                                         owner[ this.expando ] = value;
    4258 
    4259                                 // Otherwise secure it in a non-enumerable property
    4260                                 // configurable must be true to allow the property to be
    4261                                 // deleted when data is removed
    4262                                 } else {
    4263                                         Object.defineProperty( owner, this.expando, {
    4264                                                 value: value,
    4265                                                 configurable: true
    4266                                         } );
    4267                                 }
    4268                         }
    4269                 }
    4270 
    4271                 return value;
    4272         },
    4273         set: function( owner, data, value ) {
    4274                 var prop,
    4275                         cache = this.cache( owner );
    4276 
    4277                 // Handle: [ owner, key, value ] args
    4278                 // Always use camelCase key (gh-2257)
    4279                 if ( typeof data === "string" ) {
    4280                         cache[ camelCase( data ) ] = value;
    4281 
    4282                 // Handle: [ owner, { properties } ] args
    4283                 } else {
    4284 
    4285                         // Copy the properties one-by-one to the cache object
    4286                         for ( prop in data ) {
    4287                                 cache[ camelCase( prop ) ] = data[ prop ];
    4288                         }
    4289                 }
    4290                 return cache;
    4291         },
    4292         get: function( owner, key ) {
    4293                 return key === undefined ?
    4294                         this.cache( owner ) :
    4295 
    4296                         // Always use camelCase key (gh-2257)
    4297                         owner[ this.expando ] && owner[ this.expando ][ camelCase( key ) ];
    4298         },
    4299         access: function( owner, key, value ) {
    4300 
    4301                 // In cases where either:
    4302                 //
    4303                 //   1. No key was specified
    4304                 //   2. A string key was specified, but no value provided
    4305                 //
    4306                 // Take the "read" path and allow the get method to determine
    4307                 // which value to return, respectively either:
    4308                 //
    4309                 //   1. The entire cache object
    4310                 //   2. The data stored at the key
    4311                 //
    4312                 if ( key === undefined ||
    4313                                 ( ( key && typeof key === "string" ) && value === undefined ) ) {
    4314 
    4315                         return this.get( owner, key );
    4316                 }
    4317 
    4318                 // When the key is not a string, or both a key and value
    4319                 // are specified, set or extend (existing objects) with either:
    4320                 //
    4321                 //   1. An object of properties
    4322                 //   2. A key and value
    4323                 //
    4324                 this.set( owner, key, value );
    4325 
    4326                 // Since the "set" path can have two possible entry points
    4327                 // return the expected data based on which path was taken[*]
    4328                 return value !== undefined ? value : key;
    4329         },
    4330         remove: function( owner, key ) {
    4331                 var i,
    4332                         cache = owner[ this.expando ];
    4333 
    4334                 if ( cache === undefined ) {
    4335                         return;
    4336                 }
    4337 
    4338                 if ( key !== undefined ) {
    4339 
    4340                         // Support array or space separated string of keys
    4341                         if ( Array.isArray( key ) ) {
    4342 
    4343                                 // If key is an array of keys...
    4344                                 // We always set camelCase keys, so remove that.
    4345                                 key = key.map( camelCase );
    4346                         } else {
    4347                                 key = camelCase( key );
    4348 
    4349                                 // If a key with the spaces exists, use it.
    4350                                 // Otherwise, create an array by matching non-whitespace
    4351                                 key = key in cache ?
    4352                                         [ key ] :
    4353                                         ( key.match( rnothtmlwhite ) || [] );
    4354                         }
    4355 
    4356                         i = key.length;
    4357 
    4358                         while ( i-- ) {
    4359                                 delete cache[ key[ i ] ];
    4360                         }
    4361                 }
    4362 
    4363                 // Remove the expando if there's no more data
    4364                 if ( key === undefined || jQuery.isEmptyObject( cache ) ) {
    4365 
    4366                         // Support: Chrome <=35 - 45
    4367                         // Webkit & Blink performance suffers when deleting properties
    4368                         // from DOM nodes, so set to undefined instead
    4369                         // https://bugs.chromium.org/p/chromium/issues/detail?id=378607 (bug restricted)
    4370                         if ( owner.nodeType ) {
    4371                                 owner[ this.expando ] = undefined;
    4372                         } else {
    4373                                 delete owner[ this.expando ];
    4374                         }
    4375                 }
    4376         },
    4377         hasData: function( owner ) {
    4378                 var cache = owner[ this.expando ];
    4379                 return cache !== undefined && !jQuery.isEmptyObject( cache );
    4380         }
    4381 };
    4382 var dataPriv = new Data();
    4383 
    4384 var dataUser = new Data();
    4385 
    4386 
    4387 
    4388 //      Implementation Summary
    4389 //
    4390 //      1. Enforce API surface and semantic compatibility with 1.9.x branch
    4391 //      2. Improve the module's maintainability by reducing the storage
    4392 //              paths to a single mechanism.
    4393 //      3. Use the same single mechanism to support "private" and "user" data.
    4394 //      4. _Never_ expose "private" data to user code (TODO: Drop _data, _removeData)
    4395 //      5. Avoid exposing implementation details on user objects (eg. expando properties)
    4396 //      6. Provide a clear path for implementation upgrade to WeakMap in 2014
    4397 
    4398 var rbrace = /^(?:\{[\w\W]*\}|\[[\w\W]*\])$/,
    4399         rmultiDash = /[A-Z]/g;
    4400 
    4401 function getData( data ) {
    4402         if ( data === "true" ) {
    4403                 return true;
    4404         }
    4405 
    4406         if ( data === "false" ) {
    4407                 return false;
    4408         }
    4409 
    4410         if ( data === "null" ) {
    4411                 return null;
    4412         }
    4413 
    4414         // Only convert to a number if it doesn't change the string
    4415         if ( data === +data + "" ) {
    4416                 return +data;
    4417         }
    4418 
    4419         if ( rbrace.test( data ) ) {
    4420                 return JSON.parse( data );
    4421         }
    4422 
    4423         return data;
    4424 }
    4425 
    4426 function dataAttr( elem, key, data ) {
    4427         var name;
    4428 
    4429         // If nothing was found internally, try to fetch any
    4430         // data from the HTML5 data-* attribute
    4431         if ( data === undefined && elem.nodeType === 1 ) {
    4432                 name = "data-" + key.replace( rmultiDash, "-$&" ).toLowerCase();
    4433                 data = elem.getAttribute( name );
    4434 
    4435                 if ( typeof data === "string" ) {
    4436                         try {
    4437                                 data = getData( data );
    4438                         } catch ( e ) {}
    4439 
    4440                         // Make sure we set the data so it isn't changed later
    4441                         dataUser.set( elem, key, data );
    4442                 } else {
    4443                         data = undefined;
    4444                 }
    4445         }
    4446         return data;
    4447 }
    4448 
    4449 jQuery.extend( {
    4450         hasData: function( elem ) {
    4451                 return dataUser.hasData( elem ) || dataPriv.hasData( elem );
    4452         },
    4453 
    4454         data: function( elem, name, data ) {
    4455                 return dataUser.access( elem, name, data );
    4456         },
    4457 
    4458         removeData: function( elem, name ) {
    4459                 dataUser.remove( elem, name );
    4460         },
    4461 
    4462         // TODO: Now that all calls to _data and _removeData have been replaced
    4463         // with direct calls to dataPriv methods, these can be deprecated.
    4464         _data: function( elem, name, data ) {
    4465                 return dataPriv.access( elem, name, data );
    4466         },
    4467 
    4468         _removeData: function( elem, name ) {
    4469                 dataPriv.remove( elem, name );
    4470         }
    4471 } );
    4472 
    4473 jQuery.fn.extend( {
    4474         data: function( key, value ) {
    4475                 var i, name, data,
    4476                         elem = this[ 0 ],
    4477                         attrs = elem && elem.attributes;
    4478 
    4479                 // Gets all values
    4480                 if ( key === undefined ) {
    4481                         if ( this.length ) {
    4482                                 data = dataUser.get( elem );
    4483 
    4484                                 if ( elem.nodeType === 1 && !dataPriv.get( elem, "hasDataAttrs" ) ) {
    4485                                         i = attrs.length;
    4486                                         while ( i-- ) {
    4487 
    4488                                                 // Support: IE 11 only
    4489                                                 // The attrs elements can be null (#14894)
    4490                                                 if ( attrs[ i ] ) {
    4491                                                         name = attrs[ i ].name;
    4492                                                         if ( name.indexOf( "data-" ) === 0 ) {
    4493                                                                 name = camelCase( name.slice( 5 ) );
    4494                                                                 dataAttr( elem, name, data[ name ] );
    4495                                                         }
    4496                                                 }
    4497                                         }
    4498                                         dataPriv.set( elem, "hasDataAttrs", true );
    4499                                 }
    4500                         }
    4501 
    4502                         return data;
    4503                 }
    4504 
    4505                 // Sets multiple values
    4506                 if ( typeof key === "object" ) {
    4507                         return this.each( function() {
    4508                                 dataUser.set( this, key );
    4509                         } );
    4510                 }
    4511 
    4512                 return access( this, function( value ) {
    4513                         var data;
    4514 
    4515                         // The calling jQuery object (element matches) is not empty
    4516                         // (and therefore has an element appears at this[ 0 ]) and the
    4517                         // `value` parameter was not undefined. An empty jQuery object
    4518                         // will result in `undefined` for elem = this[ 0 ] which will
    4519                         // throw an exception if an attempt to read a data cache is made.
    4520                         if ( elem && value === undefined ) {
    4521 
    4522                                 // Attempt to get data from the cache
    4523                                 // The key will always be camelCased in Data
    4524                                 data = dataUser.get( elem, key );
    4525                                 if ( data !== undefined ) {
    4526                                         return data;
    4527                                 }
    4528 
    4529                                 // Attempt to "discover" the data in
    4530                                 // HTML5 custom data-* attrs
    4531                                 data = dataAttr( elem, key );
    4532                                 if ( data !== undefined ) {
    4533                                         return data;
    4534                                 }
    4535 
    4536                                 // We tried really hard, but the data doesn't exist.
    4537                                 return;
    4538                         }
    4539 
    4540                         // Set the data...
    4541                         this.each( function() {
    4542 
    4543                                 // We always store the camelCased key
    4544                                 dataUser.set( this, key, value );
    4545                         } );
    4546                 }, null, value, arguments.length > 1, null, true );
    4547         },
    4548 
    4549         removeData: function( key ) {
    4550                 return this.each( function() {
    4551                         dataUser.remove( this, key );
    4552                 } );
    4553         }
    4554 } );
    4555 
    4556 
    4557 jQuery.extend( {
    4558         queue: function( elem, type, data ) {
    4559                 var queue;
    4560 
    4561                 if ( elem ) {
    4562                         type = ( type || "fx" ) + "queue";
    4563                         queue = dataPriv.get( elem, type );
    4564 
    4565                         // Speed up dequeue by getting out quickly if this is just a lookup
    4566                         if ( data ) {
    4567                                 if ( !queue || Array.isArray( data ) ) {
    4568                                         queue = dataPriv.access( elem, type, jQuery.makeArray( data ) );
    4569                                 } else {
    4570                                         queue.push( data );
    4571                                 }
    4572                         }
    4573                         return queue || [];
    4574                 }
    4575         },
    4576 
    4577         dequeue: function( elem, type ) {
    4578                 type = type || "fx";
    4579 
    4580                 var queue = jQuery.queue( elem, type ),
    4581                         startLength = queue.length,
    4582                         fn = queue.shift(),
    4583                         hooks = jQuery._queueHooks( elem, type ),
    4584                         next = function() {
    4585                                 jQuery.dequeue( elem, type );
    4586                         };
    4587 
    4588                 // If the fx queue is dequeued, always remove the progress sentinel
    4589                 if ( fn === "inprogress" ) {
    4590                         fn = queue.shift();
    4591                         startLength--;
    4592                 }
    4593 
    4594                 if ( fn ) {
    4595 
    4596                         // Add a progress sentinel to prevent the fx queue from being
    4597                         // automatically dequeued
    4598                         if ( type === "fx" ) {
    4599                                 queue.unshift( "inprogress" );
    4600                         }
    4601 
    4602                         // Clear up the last queue stop function
    4603                         delete hooks.stop;
    4604                         fn.call( elem, next, hooks );
    4605                 }
    4606 
    4607                 if ( !startLength && hooks ) {
    4608                         hooks.empty.fire();
    4609                 }
    4610         },
    4611 
    4612         // Not public - generate a queueHooks object, or return the current one
    4613         _queueHooks: function( elem, type ) {
    4614                 var key = type + "queueHooks";
    4615                 return dataPriv.get( elem, key ) || dataPriv.access( elem, key, {
    4616                         empty: jQuery.Callbacks( "once memory" ).add( function() {
    4617                                 dataPriv.remove( elem, [ type + "queue", key ] );
    4618                         } )
    4619                 } );
    4620         }
    4621 } );
    4622 
    4623 jQuery.fn.extend( {
    4624         queue: function( type, data ) {
    4625                 var setter = 2;
    4626 
    4627                 if ( typeof type !== "string" ) {
    4628                         data = type;
    4629                         type = "fx";
    4630                         setter--;
    4631                 }
    4632 
    4633                 if ( arguments.length < setter ) {
    4634                         return jQuery.queue( this[ 0 ], type );
    4635                 }
    4636 
    4637                 return data === undefined ?
    4638                         this :
    4639                         this.each( function() {
    4640                                 var queue = jQuery.queue( this, type, data );
    4641 
    4642                                 // Ensure a hooks for this queue
    4643                                 jQuery._queueHooks( this, type );
    4644 
    4645                                 if ( type === "fx" && queue[ 0 ] !== "inprogress" ) {
    4646                                         jQuery.dequeue( this, type );
    4647                                 }
    4648                         } );
    4649         },
    4650         dequeue: function( type ) {
    4651                 return this.each( function() {
    4652                         jQuery.dequeue( this, type );
    4653                 } );
    4654         },
    4655         clearQueue: function( type ) {
    4656                 return this.queue( type || "fx", [] );
    4657         },
    4658 
    4659         // Get a promise resolved when queues of a certain type
    4660         // are emptied (fx is the type by default)
    4661         promise: function( type, obj ) {
    4662                 var tmp,
    4663                         count = 1,
    4664                         defer = jQuery.Deferred(),
    4665                         elements = this,
    4666                         i = this.length,
    4667                         resolve = function() {
    4668                                 if ( !( --count ) ) {
    4669                                         defer.resolveWith( elements, [ elements ] );
    4670                                 }
    4671                         };
    4672 
    4673                 if ( typeof type !== "string" ) {
    4674                         obj = type;
    4675                         type = undefined;
    4676                 }
    4677                 type = type || "fx";
    4678 
    4679                 while ( i-- ) {
    4680                         tmp = dataPriv.get( elements[ i ], type + "queueHooks" );
    4681                         if ( tmp && tmp.empty ) {
    4682                                 count++;
    4683                                 tmp.empty.add( resolve );
    4684                         }
    4685                 }
    4686                 resolve();
    4687                 return defer.promise( obj );
    4688         }
    4689 } );
    4690 var pnum = ( /[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/ ).source;
    4691 
    4692 var rcssNum = new RegExp( "^(?:([+-])=|)(" + pnum + ")([a-z%]*)$", "i" );
    4693 
    4694 
    4695 var cssExpand = [ "Top", "Right", "Bottom", "Left" ];
    4696 
    4697 var documentElement = document.documentElement;
    4698 
    4699 
    4700 
    4701         var isAttached = function( elem ) {
    4702                         return jQuery.contains( elem.ownerDocument, elem );
    4703                 },
    4704                 composed = { composed: true };
    4705 
    4706         // Support: IE 9 - 11+, Edge 12 - 18+, iOS 10.0 - 10.2 only
    4707         // Check attachment across shadow DOM boundaries when possible (gh-3504)
    4708         // Support: iOS 10.0-10.2 only
    4709         // Early iOS 10 versions support `attachShadow` but not `getRootNode`,
    4710         // leading to errors. We need to check for `getRootNode`.
    4711         if ( documentElement.getRootNode ) {
    4712                 isAttached = function( elem ) {
    4713                         return jQuery.contains( elem.ownerDocument, elem ) ||
    4714                                 elem.getRootNode( composed ) === elem.ownerDocument;
    4715                 };
    4716         }
    4717 var isHiddenWithinTree = function( elem, el ) {
    4718 
    4719                 // isHiddenWithinTree might be called from jQuery#filter function;
    4720                 // in that case, element will be second argument
    4721                 elem = el || elem;
    4722 
    4723                 // Inline style trumps all
    4724                 return elem.style.display === "none" ||
    4725                         elem.style.display === "" &&
    4726 
    4727                         // Otherwise, check computed style
    4728                         // Support: Firefox <=43 - 45
    4729                         // Disconnected elements can have computed display: none, so first confirm that elem is
    4730                         // in the document.
    4731                         isAttached( elem ) &&
    4732 
    4733                         jQuery.css( elem, "display" ) === "none";
    4734         };
    4735 
    4736 
    4737 
    4738 function adjustCSS( elem, prop, valueParts, tween ) {
    4739         var adjusted, scale,
    4740                 maxIterations = 20,
    4741                 currentValue = tween ?
    4742                         function() {
    4743                                 return tween.cur();
    4744                         } :
    4745                         function() {
    4746                                 return jQuery.css( elem, prop, "" );
    4747                         },
    4748                 initial = currentValue(),
    4749                 unit = valueParts && valueParts[ 3 ] || ( jQuery.cssNumber[ prop ] ? "" : "px" ),
    4750 
    4751                 // Starting value computation is required for potential unit mismatches
    4752                 initialInUnit = elem.nodeType &&
    4753                         ( jQuery.cssNumber[ prop ] || unit !== "px" && +initial ) &&
    4754                         rcssNum.exec( jQuery.css( elem, prop ) );
    4755 
    4756         if ( initialInUnit && initialInUnit[ 3 ] !== unit ) {
    4757 
    4758                 // Support: Firefox <=54
    4759                 // Halve the iteration target value to prevent interference from CSS upper bounds (gh-2144)
    4760                 initial = initial / 2;
    4761 
    4762                 // Trust units reported by jQuery.css
    4763                 unit = unit || initialInUnit[ 3 ];
    4764 
    4765                 // Iteratively approximate from a nonzero starting point
    4766                 initialInUnit = +initial || 1;
    4767 
    4768                 while ( maxIterations-- ) {
    4769 
    4770                         // Evaluate and update our best guess (doubling guesses that zero out).
    4771                         // Finish if the scale equals or crosses 1 (making the old*new product non-positive).
    4772                         jQuery.style( elem, prop, initialInUnit + unit );
    4773                         if ( ( 1 - scale ) * ( 1 - ( scale = currentValue() / initial || 0.5 ) ) <= 0 ) {
    4774                                 maxIterations = 0;
    4775                         }
    4776                         initialInUnit = initialInUnit / scale;
    4777 
    4778                 }
    4779 
    4780                 initialInUnit = initialInUnit * 2;
    4781                 jQuery.style( elem, prop, initialInUnit + unit );
    4782 
    4783                 // Make sure we update the tween properties later on
    4784                 valueParts = valueParts || [];
    4785         }
    4786 
    4787         if ( valueParts ) {
    4788                 initialInUnit = +initialInUnit || +initial || 0;
    4789 
    4790                 // Apply relative offset (+=/-=) if specified
    4791                 adjusted = valueParts[ 1 ] ?
    4792                         initialInUnit + ( valueParts[ 1 ] + 1 ) * valueParts[ 2 ] :
    4793                         +valueParts[ 2 ];
    4794                 if ( tween ) {
    4795                         tween.unit = unit;
    4796                         tween.start = initialInUnit;
    4797                         tween.end = adjusted;
    4798                 }
    4799         }
    4800         return adjusted;
    4801 }
    4802 
    4803 
    4804 var defaultDisplayMap = {};
    4805 
    4806 function getDefaultDisplay( elem ) {
    4807         var temp,
    4808                 doc = elem.ownerDocument,
    4809                 nodeName = elem.nodeName,
    4810                 display = defaultDisplayMap[ nodeName ];
    4811 
    4812         if ( display ) {
    4813                 return display;
    4814         }
    4815 
    4816         temp = doc.body.appendChild( doc.createElement( nodeName ) );
    4817         display = jQuery.css( temp, "display" );
    4818 
    4819         temp.parentNode.removeChild( temp );
    4820 
    4821         if ( display === "none" ) {
    4822                 display = "block";
    4823         }
    4824         defaultDisplayMap[ nodeName ] = display;
    4825 
    4826         return display;
    4827 }
    4828 
    4829 function showHide( elements, show ) {
    4830         var display, elem,
    4831                 values = [],
    4832                 index = 0,
    4833                 length = elements.length;
    4834 
    4835         // Determine new display value for elements that need to change
    4836         for ( ; index < length; index++ ) {
    4837                 elem = elements[ index ];
    4838                 if ( !elem.style ) {
    4839                         continue;
    4840                 }
    4841 
    4842                 display = elem.style.display;
    4843                 if ( show ) {
    4844 
    4845                         // Since we force visibility upon cascade-hidden elements, an immediate (and slow)
    4846                         // check is required in this first loop unless we have a nonempty display value (either
    4847                         // inline or about-to-be-restored)
    4848                         if ( display === "none" ) {
    4849                                 values[ index ] = dataPriv.get( elem, "display" ) || null;
    4850                                 if ( !values[ index ] ) {
    4851                                         elem.style.display = "";
    4852                                 }
    4853                         }
    4854                         if ( elem.style.display === "" && isHiddenWithinTree( elem ) ) {
    4855                                 values[ index ] = getDefaultDisplay( elem );
    4856                         }
    4857                 } else {
    4858                         if ( display !== "none" ) {
    4859                                 values[ index ] = "none";
    4860 
    4861                                 // Remember what we're overwriting
    4862                                 dataPriv.set( elem, "display", display );
    4863                         }
    4864                 }
    4865         }
    4866 
    4867         // Set the display of the elements in a second loop to avoid constant reflow
    4868         for ( index = 0; index < length; index++ ) {
    4869                 if ( values[ index ] != null ) {
    4870                         elements[ index ].style.display = values[ index ];
    4871                 }
    4872         }
    4873 
    4874         return elements;
    4875 }
    4876 
    4877 jQuery.fn.extend( {
    4878         show: function() {
    4879                 return showHide( this, true );
    4880         },
    4881         hide: function() {
    4882                 return showHide( this );
    4883         },
    4884         toggle: function( state ) {
    4885                 if ( typeof state === "boolean" ) {
    4886                         return state ? this.show() : this.hide();
    4887                 }
    4888 
    4889                 return this.each( function() {
    4890                         if ( isHiddenWithinTree( this ) ) {
    4891                                 jQuery( this ).show();
    4892                         } else {
    4893                                 jQuery( this ).hide();
    4894                         }
    4895                 } );
    4896         }
    4897 } );
    4898 var rcheckableType = ( /^(?:checkbox|radio)$/i );
    4899 
    4900 var rtagName = ( /<([a-z][^\/\0>\x20\t\r\n\f]*)/i );
    4901 
    4902 var rscriptType = ( /^$|^module$|\/(?:java|ecma)script/i );
    4903 
    4904 
    4905 
    4906 ( function() {
    4907         var fragment = document.createDocumentFragment(),
    4908                 div = fragment.appendChild( document.createElement( "div" ) ),
    4909                 input = document.createElement( "input" );
    4910 
    4911         // Support: Android 4.0 - 4.3 only
    4912         // Check state lost if the name is set (#11217)
    4913         // Support: Windows Web Apps (WWA)
    4914         // `name` and `type` must use .setAttribute for WWA (#14901)
    4915         input.setAttribute( "type", "radio" );
    4916         input.setAttribute( "checked", "checked" );
    4917         input.setAttribute( "name", "t" );
    4918 
    4919         div.appendChild( input );
    4920 
    4921         // Support: Android <=4.1 only
    4922         // Older WebKit doesn't clone checked state correctly in fragments
    4923         support.checkClone = div.cloneNode( true ).cloneNode( true ).lastChild.checked;
    4924 
    4925         // Support: IE <=11 only
    4926         // Make sure textarea (and checkbox) defaultValue is properly cloned
    4927         div.innerHTML = "<textarea>x</textarea>";
    4928         support.noCloneChecked = !!div.cloneNode( true ).lastChild.defaultValue;
    4929 
    4930         // Support: IE <=9 only
    4931         // IE <=9 replaces <option> tags with their contents when inserted outside of
    4932         // the select element.
    4933         div.innerHTML = "<option></option>";
    4934         support.option = !!div.lastChild;
    4935 } )();
    4936 
    4937 
    4938 // We have to close these tags to support XHTML (#13200)
    4939 var wrapMap = {
    4940 
    4941         // XHTML parsers do not magically insert elements in the
    4942         // same way that tag soup parsers do. So we cannot shorten
    4943         // this by omitting <tbody> or other required elements.
    4944         thead: [ 1, "<table>", "</table>" ],
    4945         col: [ 2, "<table><colgroup>", "</colgroup></table>" ],
    4946         tr: [ 2, "<table><tbody>", "</tbody></table>" ],
    4947         td: [ 3, "<table><tbody><tr>", "</tr></tbody></table>" ],
    4948 
    4949         _default: [ 0, "", "" ]
    4950 };
    4951 
    4952 wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;
    4953 wrapMap.th = wrapMap.td;
    4954 
    4955 // Support: IE <=9 only
    4956 if ( !support.option ) {
    4957         wrapMap.optgroup = wrapMap.option = [ 1, "<select multiple='multiple'>", "</select>" ];
    4958 }
    4959 
    4960 
    4961 function getAll( context, tag ) {
    4962 
    4963         // Support: IE <=9 - 11 only
    4964         // Use typeof to avoid zero-argument method invocation on host objects (#15151)
    4965         var ret;
    4966 
    4967         if ( typeof context.getElementsByTagName !== "undefined" ) {
    4968                 ret = context.getElementsByTagName( tag || "*" );
    4969 
    4970         } else if ( typeof context.querySelectorAll !== "undefined" ) {
    4971                 ret = context.querySelectorAll( tag || "*" );
    4972 
    4973         } else {
    4974                 ret = [];
    4975         }
    4976 
    4977         if ( tag === undefined || tag && nodeName( context, tag ) ) {
    4978                 return jQuery.merge( [ context ], ret );
    4979         }
    4980 
    4981         return ret;
    4982 }
    4983 
    4984 
    4985 // Mark scripts as having already been evaluated
    4986 function setGlobalEval( elems, refElements ) {
    4987         var i = 0,
    4988                 l = elems.length;
    4989 
    4990         for ( ; i < l; i++ ) {
    4991                 dataPriv.set(
    4992                         elems[ i ],
    4993                         "globalEval",
    4994                         !refElements || dataPriv.get( refElements[ i ], "globalEval" )
    4995                 );
    4996         }
    4997 }
    4998 
    4999 
    5000 var rhtml = /<|&#?\w+;/;
    5001 
    5002 function buildFragment( elems, context, scripts, selection, ignored ) {
    5003         var elem, tmp, tag, wrap, attached, j,
    5004                 fragment = context.createDocumentFragment(),
    5005                 nodes = [],
    5006                 i = 0,
    5007                 l = elems.length;
    5008 
    5009         for ( ; i < l; i++ ) {
    5010                 elem = elems[ i ];
    5011 
    5012                 if ( elem || elem === 0 ) {
    5013 
    5014                         // Add nodes directly
    5015                         if ( toType( elem ) === "object" ) {
    5016 
    5017                                 // Support: Android <=4.0 only, PhantomJS 1 only
    5018                                 // push.apply(_, arraylike) throws on ancient WebKit
    5019                                 jQuery.merge( nodes, elem.nodeType ? [ elem ] : elem );
    5020 
    5021                         // Convert non-html into a text node
    5022                         } else if ( !rhtml.test( elem ) ) {
    5023                                 nodes.push( context.createTextNode( elem ) );
    5024 
    5025                         // Convert html into DOM nodes
    5026                         } else {
    5027                                 tmp = tmp || fragment.appendChild( context.createElement( "div" ) );
    5028 
    5029                                 // Deserialize a standard representation
    5030                                 tag = ( rtagName.exec( elem ) || [ "", "" ] )[ 1 ].toLowerCase();
    5031                                 wrap = wrapMap[ tag ] || wrapMap._default;
    5032                                 tmp.innerHTML = wrap[ 1 ] + jQuery.htmlPrefilter( elem ) + wrap[ 2 ];
    5033 
    5034                                 // Descend through wrappers to the right content
    5035                                 j = wrap[ 0 ];
    5036                                 while ( j-- ) {
    5037                                         tmp = tmp.lastChild;
    5038                                 }
    5039 
    5040                                 // Support: Android <=4.0 only, PhantomJS 1 only
    5041                                 // push.apply(_, arraylike) throws on ancient WebKit
    5042                                 jQuery.merge( nodes, tmp.childNodes );
    5043 
    5044                                 // Remember the top-level container
    5045                                 tmp = fragment.firstChild;
    5046 
    5047                                 // Ensure the created nodes are orphaned (#12392)
    5048                                 tmp.textContent = "";
    5049                         }
    5050                 }
    5051         }
    5052 
    5053         // Remove wrapper from fragment
    5054         fragment.textContent = "";
    5055 
    5056         i = 0;
    5057         while ( ( elem = nodes[ i++ ] ) ) {
    5058 
    5059                 // Skip elements already in the context collection (trac-4087)
    5060                 if ( selection && jQuery.inArray( elem, selection ) > -1 ) {
    5061                         if ( ignored ) {
    5062                                 ignored.push( elem );
    5063                         }
    5064                         continue;
    5065                 }
    5066 
    5067                 attached = isAttached( elem );
    5068 
    5069                 // Append to fragment
    5070                 tmp = getAll( fragment.appendChild( elem ), "script" );
    5071 
    5072                 // Preserve script evaluation history
    5073                 if ( attached ) {
    5074                         setGlobalEval( tmp );
    5075                 }
    5076 
    5077                 // Capture executables
    5078                 if ( scripts ) {
    5079                         j = 0;
    5080                         while ( ( elem = tmp[ j++ ] ) ) {
    5081                                 if ( rscriptType.test( elem.type || "" ) ) {
    5082                                         scripts.push( elem );
    5083                                 }
    5084                         }
    5085                 }
    5086         }
    5087 
    5088         return fragment;
    5089 }
    5090 
    5091 
    5092 var
    5093         rkeyEvent = /^key/,
    5094         rmouseEvent = /^(?:mouse|pointer|contextmenu|drag|drop)|click/,
    5095         rtypenamespace = /^([^.]*)(?:\.(.+)|)/;
    5096 
    5097 function returnTrue() {
    5098         return true;
    5099 }
    5100 
    5101 function returnFalse() {
    5102         return false;
    5103 }
    5104 
    5105 // Support: IE <=9 - 11+
    5106 // focus() and blur() are asynchronous, except when they are no-op.
    5107 // So expect focus to be synchronous when the element is already active,
    5108 // and blur to be synchronous when the element is not already active.
    5109 // (focus and blur are always synchronous in other supported browsers,
    5110 // this just defines when we can count on it).
    5111 function expectSync( elem, type ) {
    5112         return ( elem === safeActiveElement() ) === ( type === "focus" );
    5113 }
    5114 
    5115 // Support: IE <=9 only
    5116 // Accessing document.activeElement can throw unexpectedly
    5117 // https://bugs.jquery.com/ticket/13393
    5118 function safeActiveElement() {
    5119         try {
    5120                 return document.activeElement;
    5121         } catch ( err ) { }
    5122 }
    5123 
    5124 function on( elem, types, selector, data, fn, one ) {
    5125         var origFn, type;
    5126 
    5127         // Types can be a map of types/handlers
    5128         if ( typeof types === "object" ) {
    5129 
    5130                 // ( types-Object, selector, data )
    5131                 if ( typeof selector !== "string" ) {
    5132 
    5133                         // ( types-Object, data )
    5134                         data = data || selector;
    5135                         selector = undefined;
    5136                 }
    5137                 for ( type in types ) {
    5138                         on( elem, type, selector, data, types[ type ], one );
    5139                 }
    5140                 return elem;
    5141         }
    5142 
    5143         if ( data == null && fn == null ) {
    5144 
    5145                 // ( types, fn )
    5146                 fn = selector;
    5147                 data = selector = undefined;
    5148         } else if ( fn == null ) {
    5149                 if ( typeof selector === "string" ) {
    5150 
    5151                         // ( types, selector, fn )
    5152                         fn = data;
    5153                         data = undefined;
    5154                 } else {
    5155 
    5156                         // ( types, data, fn )
    5157                         fn = data;
    5158                         data = selector;
    5159                         selector = undefined;
    5160                 }
    5161         }
    5162         if ( fn === false ) {
    5163                 fn = returnFalse;
    5164         } else if ( !fn ) {
    5165                 return elem;
    5166         }
    5167 
    5168         if ( one === 1 ) {
    5169                 origFn = fn;
    5170                 fn = function( event ) {
    5171 
    5172                         // Can use an empty set, since event contains the info
    5173                         jQuery().off( event );
    5174                         return origFn.apply( this, arguments );
    5175                 };
    5176 
    5177                 // Use same guid so caller can remove using origFn
    5178                 fn.guid = origFn.guid || ( origFn.guid = jQuery.guid++ );
    5179         }
    5180         return elem.each( function() {
    5181                 jQuery.event.add( this, types, fn, data, selector );
    5182         } );
    5183 }
    5184 
    5185 /*
    5186  * Helper functions for managing events -- not part of the public interface.
    5187  * Props to Dean Edwards' addEvent library for many of the ideas.
    5188  */
    5189 jQuery.event = {
    5190 
    5191         global: {},
    5192 
    5193         add: function( elem, types, handler, data, selector ) {
    5194 
    5195                 var handleObjIn, eventHandle, tmp,
    5196                         events, t, handleObj,
    5197                         special, handlers, type, namespaces, origType,
    5198                         elemData = dataPriv.get( elem );
    5199 
    5200                 // Only attach events to objects that accept data
    5201                 if ( !acceptData( elem ) ) {
    5202                         return;
    5203                 }
    5204 
    5205                 // Caller can pass in an object of custom data in lieu of the handler
    5206                 if ( handler.handler ) {
    5207                         handleObjIn = handler;
    5208                         handler = handleObjIn.handler;
    5209                         selector = handleObjIn.selector;
    5210                 }
    5211 
    5212                 // Ensure that invalid selectors throw exceptions at attach time
    5213                 // Evaluate against documentElement in case elem is a non-element node (e.g., document)
    5214                 if ( selector ) {
    5215                         jQuery.find.matchesSelector( documentElement, selector );
    5216                 }
    5217 
    5218                 // Make sure that the handler has a unique ID, used to find/remove it later
    5219                 if ( !handler.guid ) {
    5220                         handler.guid = jQuery.guid++;
    5221                 }
    5222 
    5223                 // Init the element's event structure and main handler, if this is the first
    5224                 if ( !( events = elemData.events ) ) {
    5225                         events = elemData.events = Object.create( null );
    5226                 }
    5227                 if ( !( eventHandle = elemData.handle ) ) {
    5228                         eventHandle = elemData.handle = function( e ) {
    5229 
    5230                                 // Discard the second event of a jQuery.event.trigger() and
    5231                                 // when an event is called after a page has unloaded
    5232                                 return typeof jQuery !== "undefined" && jQuery.event.triggered !== e.type ?
    5233                                         jQuery.event.dispatch.apply( elem, arguments ) : undefined;
    5234                         };
    5235                 }
    5236 
    5237                 // Handle multiple events separated by a space
    5238                 types = ( types || "" ).match( rnothtmlwhite ) || [ "" ];
    5239                 t = types.length;
    5240                 while ( t-- ) {
    5241