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