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