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