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