vendor: 4,408 bytes, lines 1-180
1/*! 2 * jQuery JavaScript Library v1.12.3 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-04-05T19:16Z 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.3", 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;
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[ 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 {
vendor: 15,667 bytes, lines 1146-1703
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;
vendor: 6,763 bytes, lines 1732-1949
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;
vendor: 14,389 bytes, lines 2122-2618
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 ( jQuery.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" ) {
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: 5,562 bytes, lines 3019-3237
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 ) {
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 ) {
vendor: 2,750 bytes, lines 4131-4256
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;
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 ) {
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
vendor: 13,833 bytes, lines 4740-5219
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
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 contents = div.getElementsByTagName( "td" ); 6676 contents[ 0 ].style.cssText = "margin:0;border:0;padding:0;display:none"; 6677 reliableHiddenOffsetsVal = contents[ 0 ].offsetHeight === 0; 6678 if ( reliableHiddenOffsetsVal ) { 6679 contents[ 0 ].style.display = ""; 6680 contents[ 1 ].style.display = "none"; 6681 reliableHiddenOffsetsVal = contents[ 0 ].offsetHeight === 0; 6682 } 6683 } 6684 6685 // Teardown 6686 documentElement.removeChild( container ); 6687 } 6688 6689} )(); 6690 6691 6692var getStyles, curCSS, 6693 rposition = /^(top|right|bottom|left)$/; 6694 6695if ( window.getComputedStyle ) { 6696 getStyles = function( elem ) { 6697 6698 // Support: IE<=11+, Firefox<=30+ (#15098, #14150) 6699 // IE throws on elements created in popups 6700 // FF meanwhile throws on frame elements through "defaultView.getComputedStyle" 6701 var view = elem.ownerDocument.defaultView; 6702 6703 if ( !view || !view.opener ) { 6704 view = window; 6705 } 6706 6707 return view.getComputedStyle( elem ); 6708 }; 6709 6710 curCSS = function( elem, name, computed ) { 6711 var width, minWidth, maxWidth, ret, 6712 style = elem.style; 6713 6714 computed = computed || getStyles( elem ); 6715 6716 // getPropertyValue is only needed for .css('filter') in IE9, see #12537 6717 ret = computed ? computed.getPropertyValue( name ) || computed[ name ] : undefined; 6718 6719 // Support: Opera 12.1x only 6720 // Fall back to style even without computed 6721 // computed is undefined for elems on document fragments 6722 if ( ( ret === "" || ret === undefined ) && !jQuery.contains( elem.ownerDocument, elem ) ) { 6723 ret = jQuery.style( elem, name ); 6724 } 6725 6726 if ( computed ) { 6727 6728 // A tribute to the "awesome hack by Dean Edwards" 6729 // Chrome < 17 and Safari 5.0 uses "computed value" 6730 // instead of "used value" for margin-right 6731 // Safari 5.1.7 (at least) returns percentage for a larger set of values, 6732 // but width seems to be reliably pixels 6733 // this is against the CSSOM draft spec: 6734 // http://dev.w3.org/csswg/cssom/#resolved-values 6735 if ( !support.pixelMarginRight() && rnumnonpx.test( ret ) && rmargin.test( name ) ) { 6736 6737 // Remember the original values 6738 width = style.width; 6739 minWidth = style.minWidth; 6740 maxWidth = style.maxWidth; 6741 6742 // Put in the new values to get a computed value out 6743 style.minWidth = style.maxWidth = style.width = ret; 6744 ret = computed.width; 6745 6746 // Revert the changed values 6747 style.width = width; 6748 style.minWidth = minWidth; 6749 style.maxWidth = maxWidth; 6750 } 6751 } 6752
6753 // Support: IE 6754 // IE returns zIndex value as an integer. 6755 return ret === undefined ? 6756 ret : 6757 ret + ""; 6758 }; 6759} else if ( documentElement.currentStyle ) { 6760 getStyles = function( elem ) { 6761 return elem.currentStyle; 6762 }; 6763 6764 curCSS = function( elem, name, computed ) { 6765 var left, rs, rsLeft, ret, 6766 style = elem.style; 6767 6768 computed = computed || getStyles( elem ); 6769 ret = computed ? computed[ name ] : undefined; 6770 6771 // Avoid setting ret to empty string here 6772 // so we don't default to auto 6773 if ( ret == null && style && style[ name ] ) { 6774 ret = style[ name ]; 6775 } 6776 6777 // From the awesome hack by Dean Edwards 6778 // http://erik.eae.net/archives/2007/07/27/18.54.15/#comment-102291 6779 6780 // If we're not dealing with a regular pixel number 6781 // but a number that has a weird ending, we need to convert it to pixels 6782 // but not position css attributes, as those are 6783 // proportional to the parent element instead 6784 // and we can't measure the parent instead because it 6785 // might trigger a "stacking dolls" problem 6786 if ( rnumnonpx.test( ret ) && !rposition.test( name ) ) { 6787 6788 // Remember the original values 6789 left = style.left; 6790 rs = elem.runtimeStyle; 6791 rsLeft = rs && rs.left; 6792 6793 // Put in the new values to get a computed value out 6794 if ( rsLeft ) { 6795 rs.left = elem.currentStyle.left; 6796 } 6797 style.left = name === "fontSize" ? "1em" : ret; 6798 ret = style.pixelLeft + "px"; 6799 6800 // Revert the changed values 6801 style.left = left; 6802 if ( rsLeft ) { 6803 rs.left = rsLeft; 6804 } 6805 } 6806 6807 // Support: IE 6808 // IE returns zIndex value as an integer. 6809 return ret === undefined ? 6810 ret : 6811 ret + "" || "auto"; 6812 }; 6813} 6814 6815 6816 6817 6818function addGetHookIf( conditionFn, hookFn ) { 6819 6820 // Define the hook, we'll check on the first run if it's really needed. 6821 return { 6822 get: function() { 6823 if ( conditionFn() ) { 6824 6825 // Hook not needed (or it's not possible to use it due 6826 // to missing dependency), remove it. 6827 delete this.get; 6828 return; 6829 } 6830 6831 // Hook needed; redefine it so that the support test is not executed again. 6832 return ( this.get = hookFn ).apply( this, arguments ); 6833 } 6834 }; 6835} 6836 6837 6838var 6839 6840 ralpha = /alpha\([^)]*\)/i, 6841 ropacity = /opacity\s*=\s*([^)]*)/i, 6842 6843 // swappable if display is none or starts with table except 6844 // "table", "table-cell", or "table-caption" 6845 // see here for display values: 6846 // https://developer.mozilla.org/en-US/docs/CSS/display 6847 rdisplayswap = /^(none|table(?!-c[ea]).+)/, 6848 rnumsplit = new RegExp( "^(" + pnum + ")(.*)$", "i" ), 6849 6850 cssShow = { position: "absolute", visibility: "hidden", display: "block" }, 6851 cssNormalTransform = { 6852 letterSpacing: "0", 6853 fontWeight: "400" 6854 }, 6855 6856 cssPrefixes = [ "Webkit", "O", "Moz", "ms" ], 6857 emptyStyle = document.createElement( "div" ).style; 6858 6859 6860// return a css property mapped to a potentially vendor prefixed property 6861function vendorPropName( name ) { 6862 6863 // shortcut for names that are not vendor prefixed 6864 if ( name in emptyStyle ) { 6865 return name; 6866 } 6867 6868 // check for vendor prefixed names 6869 var capName = name.charAt( 0 ).toUpperCase() + name.slice( 1 ), 6870 i = cssPrefixes.length; 6871 6872 while ( i-- ) { 6873 name = cssPrefixes[ i ] + capName; 6874 if ( name in emptyStyle ) { 6875 return name; 6876 } 6877 } 6878} 6879 6880function showHide( elements, show ) { 6881 var display, elem, hidden, 6882 values = [], 6883 index = 0, 6884 length = elements.length; 6885 6886 for ( ; index < length; index++ ) { 6887 elem = elements[ index ]; 6888 if ( !elem.style ) { 6889 continue; 6890 } 6891 6892 values[ index ] = jQuery._data( elem, "olddisplay" ); 6893 display = elem.style.display; 6894 if ( show ) { 6895 6896 // Reset the inline display of this element to learn if it is 6897 // being hidden by cascaded rules or not 6898 if ( !values[ index ] && display === "none" ) { 6899 elem.style.display = ""; 6900 } 6901 6902 // Set elements which have been overridden with display: none 6903 // in a stylesheet to whatever the default browser style is 6904 // for such an element 6905 if ( elem.style.display === "" && isHidden( elem ) ) { 6906 values[ index ] = 6907 jQuery._data( elem, "olddisplay", defaultDisplay( elem.nodeName ) ); 6908 } 6909 } else { 6910 hidden = isHidden( elem ); 6911 6912 if ( display && display !== "none" || !hidden ) { 6913 jQuery._data( 6914 elem, 6915 "olddisplay",
6916 hidden ? display : jQuery.css( elem, "display" ) 6917 ); 6918 } 6919 } 6920 } 6921 6922 // Set the display of most of the elements in a second loop 6923 // to avoid the constant reflow 6924 for ( index = 0; index < length; index++ ) { 6925 elem = elements[ index ]; 6926 if ( !elem.style ) { 6927 continue; 6928 } 6929 if ( !show || elem.style.display === "none" || elem.style.display === "" ) { 6930 elem.style.display = show ? values[ index ] || "" : "none"; 6931 } 6932 } 6933 6934 return elements; 6935} 6936 6937function setPositiveNumber( elem, value, subtract ) { 6938 var matches = rnumsplit.exec( value ); 6939 return matches ? 6940 6941 // Guard against undefined "subtract", e.g., when used as in cssHooks 6942 Math.max( 0, matches[ 1 ] - ( subtract || 0 ) ) + ( matches[ 2 ] || "px" ) : 6943 value; 6944} 6945 6946function augmentWidthOrHeight( elem, name, extra, isBorderBox, styles ) { 6947 var i = extra === ( isBorderBox ? "border" : "content" ) ? 6948 6949 // If we already have the right measurement, avoid augmentation 6950 4 : 6951 6952 // Otherwise initialize for horizontal or vertical properties 6953 name === "width" ? 1 : 0, 6954 6955 val = 0; 6956 6957 for ( ; i < 4; i += 2 ) { 6958 6959 // both box models exclude margin, so add it if we want it 6960 if ( extra === "margin" ) { 6961 val += jQuery.css( elem, extra + cssExpand[ i ], true, styles ); 6962 } 6963 6964 if ( isBorderBox ) { 6965 6966 // border-box includes padding, so remove it if we want content 6967 if ( extra === "content" ) { 6968 val -= jQuery.css( elem, "padding" + cssExpand[ i ], true, styles ); 6969 } 6970 6971 // at this point, extra isn't border nor margin, so remove border 6972 if ( extra !== "margin" ) { 6973 val -= jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles ); 6974 } 6975 } else { 6976 6977 // at this point, extra isn't content, so add padding 6978 val += jQuery.css( elem, "padding" + cssExpand[ i ], true, styles ); 6979 6980 // at this point, extra isn't content nor padding, so add border 6981 if ( extra !== "padding" ) { 6982 val += jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles ); 6983 } 6984 } 6985 } 6986 6987 return val; 6988} 6989 6990function getWidthOrHeight( elem, name, extra ) { 6991 6992 // Start with offset property, which is equivalent to the border-box value 6993 var valueIsBorderBox = true, 6994 val = name === "width" ? elem.offsetWidth : elem.offsetHeight, 6995 styles = getStyles( elem ), 6996 isBorderBox = support.boxSizing && 6997 jQuery.css( elem, "boxSizing", false, styles ) === "border-box"; 6998 6999 // Support: IE11 only 7000 // In IE 11 fullscreen elements inside of an iframe have 7001 // 100x too small dimensions (gh-1764). 7002 if ( document.msFullscreenElement && window.top !== window ) { 7003 7004 // Support: IE11 only 7005 // Running getBoundingClientRect on a disconnected node 7006 // in IE throws an error. 7007 if ( elem.getClientRects().length ) { 7008 val = Math.round( elem.getBoundingClientRect()[ name ] * 100 ); 7009 } 7010 } 7011 7012 // some non-html elements return undefined for offsetWidth, so check for null/undefined 7013 // svg - https://bugzilla.mozilla.org/show_bug.cgi?id=649285 7014 // MathML - https://bugzilla.mozilla.org/show_bug.cgi?id=491668 7015 if ( val <= 0 || val == null ) { 7016 7017 // Fall back to computed then uncomputed css if necessary 7018 val = curCSS( elem, name, styles ); 7019 if ( val < 0 || val == null ) { 7020 val = elem.style[ name ]; 7021 } 7022 7023 // Computed unit is not pixels. Stop here and return. 7024 if ( rnumnonpx.test( val ) ) { 7025 return val; 7026 } 7027 7028 // we need the check for style in case a browser which returns unreliable values 7029 // for getComputedStyle silently falls back to the reliable elem.style 7030 valueIsBorderBox = isBorderBox && 7031 ( support.boxSizingReliable() || val === elem.style[ name ] ); 7032 7033 // Normalize "", auto, and prepare for extra 7034 val = parseFloat( val ) || 0; 7035 } 7036 7037 // use the active box-sizing model to add/subtract irrelevant styles 7038 return ( val + 7039 augmentWidthOrHeight( 7040 elem, 7041 name, 7042 extra || ( isBorderBox ? "border" : "content" ), 7043 valueIsBorderBox, 7044 styles 7045 ) 7046 ) + "px"; 7047} 7048 7049jQuery.extend( { 7050 7051 // Add in style property hooks for overriding the default 7052 // behavior of getting and setting a style property 7053 cssHooks: { 7054 opacity: { 7055 get: function( elem, computed ) { 7056 if ( computed ) { 7057 7058 // We should always get a number back from opacity 7059 var ret = curCSS( elem, "opacity" ); 7060 return ret === "" ? "1" : ret; 7061 } 7062 } 7063 } 7064 }, 7065 7066 // Don't automatically add "px" to these possibly-unitless properties 7067 cssNumber: { 7068 "animationIterationCount": true, 7069 "columnCount": true, 7070 "fillOpacity": true, 7071 "flexGrow": true, 7072 "flexShrink": true, 7073 "fontWeight": true, 7074 "lineHeight": true, 7075 "opacity": true, 7076 "order": true, 7077 "orphans": true, 7078 "widows": true, 7079 "zIndex": true, 7080 "zoom": true 7081 }, 7082 7083 // Add in properties whose names you wish to fix before 7084 // setting or getting the value 7085 cssProps: { 7086 7087 // normalize float css property 7088 "float": support.cssFloat ? "cssFloat" : "styleFloat" 7089 }, 7090 7091 // Get and set the style property on a DOM Node 7092 style: function( elem, name, value, extra ) { 7093 7094 // Don't set styles on text and comment nodes 7095 if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style ) { 7096 return; 7097 } 7098 7099 // Make sure that we're working with the right name 7100 var ret, type, hooks, 7101 origName = jQuery.camelCase( name ), 7102 style = elem.style; 7103 7104 name = jQuery.cssProps[ origName ] || 7105 ( jQuery.cssProps[ origName ] = vendorPropName( origName ) || origName ); 7106 7107 // gets hook for the prefixed version 7108 // followed by the unprefixed version 7109 hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ]; 7110 7111 // Check if we're setting a value 7112 if ( value !== undefined ) { 7113 type = typeof value; 7114 7115 // Convert "+=" or "-=" to relative numbers (#7345) 7116 if ( type === "string" && ( ret = rcssNum.exec( value ) ) && ret[ 1 ] ) { 7117 value = adjustCSS( elem, name, ret ); 7118 7119 // Fixes bug #9237 7120 type = "number"; 7121 } 7122 7123 // Make sure that null and NaN values aren't set. See: #7116 7124 if ( value == null || value !== value ) { 7125 return; 7126 } 7127 7128 // If a number was passed in, add the unit (except for certain CSS properties) 7129 if ( type === "number" ) { 7130 value += ret && ret[ 3 ] || ( jQuery.cssNumber[ origName ] ? "" : "px" ); 7131 } 7132 7133 // Fixes #8908, it can be done more correctly by specifing setters in cssHooks, 7134 // but it would mean to define eight 7135 // (for every problematic property) identical functions 7136 if ( !support.clearCloneStyle && value === "" && name.indexOf( "background" ) === 0 ) { 7137 style[ name ] = "inherit"; 7138 } 7139 7140 // If a hook was provided, use that value, otherwise just set the specified value
7141 if ( !hooks || !( "set" in hooks ) || 7142 ( value = hooks.set( elem, value, extra ) ) !== undefined ) { 7143 7144 // Support: IE 7145 // Swallow errors from 'invalid' CSS values (#5509) 7146 try { 7147 style[ name ] = value; 7148 } catch ( e ) {} 7149 } 7150 7151 } else { 7152 7153 // If a hook was provided get the non-computed value from there 7154 if ( hooks && "get" in hooks && 7155 ( ret = hooks.get( elem, false, extra ) ) !== undefined ) { 7156 7157 return ret; 7158 } 7159 7160 // Otherwise just get the value from the style object 7161 return style[ name ]; 7162 } 7163 }, 7164 7165 css: function( elem, name, extra, styles ) { 7166 var num, val, hooks, 7167 origName = jQuery.camelCase( name ); 7168 7169 // Make sure that we're working with the right name 7170 name = jQuery.cssProps[ origName ] || 7171 ( jQuery.cssProps[ origName ] = vendorPropName( origName ) || origName ); 7172 7173 // gets hook for the prefixed version 7174 // followed by the unprefixed version 7175 hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ]; 7176 7177 // If a hook was provided get the computed value from there 7178 if ( hooks && "get" in hooks ) { 7179 val = hooks.get( elem, true, extra ); 7180 } 7181 7182 // Otherwise, if a way to get the computed value exists, use that 7183 if ( val === undefined ) { 7184 val = curCSS( elem, name, styles ); 7185 } 7186 7187 //convert "normal" to computed value 7188 if ( val === "normal" && name in cssNormalTransform ) { 7189 val = cssNormalTransform[ name ]; 7190 } 7191 7192 // Return, converting to number if forced or a qualifier was provided and val looks numeric 7193 if ( extra === "" || extra ) { 7194 num = parseFloat( val ); 7195 return extra === true || isFinite( num ) ? num || 0 : val; 7196 } 7197 return val; 7198 } 7199} ); 7200 7201jQuery.each( [ "height", "width" ], function( i, name ) { 7202 jQuery.cssHooks[ name ] = { 7203 get: function( elem, computed, extra ) { 7204 if ( computed ) { 7205 7206 // certain elements can have dimension info if we invisibly show them 7207 // however, it must have a current display style that would benefit from this 7208 return rdisplayswap.test( jQuery.css( elem, "display" ) ) && 7209 elem.offsetWidth === 0 ? 7210 swap( elem, cssShow, function() { 7211 return getWidthOrHeight( elem, name, extra ); 7212 } ) : 7213 getWidthOrHeight( elem, name, extra ); 7214 } 7215 }, 7216 7217 set: function( elem, value, extra ) { 7218 var styles = extra && getStyles( elem ); 7219 return setPositiveNumber( elem, value, extra ? 7220 augmentWidthOrHeight( 7221 elem, 7222 name, 7223 extra, 7224 support.boxSizing && 7225 jQuery.css( elem, "boxSizing", false, styles ) === "border-box", 7226 styles 7227 ) : 0 7228 ); 7229 } 7230 }; 7231} ); 7232 7233if ( !support.opacity ) { 7234 jQuery.cssHooks.opacity = { 7235 get: function( elem, computed ) { 7236 7237 // IE uses filters for opacity 7238 return ropacity.test( ( computed && elem.currentStyle ? 7239 elem.currentStyle.filter : 7240 elem.style.filter ) || "" ) ? 7241 ( 0.01 * parseFloat( RegExp.$1 ) ) + "" : 7242 computed ? "1" : ""; 7243 }, 7244 7245 set: function( elem, value ) { 7246 var style = elem.style, 7247 currentStyle = elem.currentStyle, 7248 opacity = jQuery.isNumeric( value ) ? "alpha(opacity=" + value * 100 + ")" : "", 7249 filter = currentStyle && currentStyle.filter || style.filter || ""; 7250 7251 // IE has trouble with opacity if it does not have layout 7252 // Force it by setting the zoom level 7253 style.zoom = 1; 7254 7255 // if setting opacity to 1, and no other filters exist - 7256 // attempt to remove filter attribute #6652 7257 // if value === "", then remove inline opacity #12685 7258 if ( ( value >= 1 || value === "" ) && 7259 jQuery.trim( filter.replace( ralpha, "" ) ) === "" && 7260 style.removeAttribute ) { 7261 7262 // Setting style.filter to null, "" & " " still leave "filter:" in the cssText 7263 // if "filter:" is present at all, clearType is disabled, we want to avoid this 7264 // style.removeAttribute is IE Only, but so apparently is this code path... 7265 style.removeAttribute( "filter" ); 7266 7267 // if there is no filter style applied in a css rule 7268 // or unset inline opacity, we are done 7269 if ( value === "" || currentStyle && !currentStyle.filter ) { 7270 return; 7271 } 7272 } 7273 7274 // otherwise, set new filter values 7275 style.filter = ralpha.test( filter ) ? 7276 filter.replace( ralpha, opacity ) : 7277 filter + " " + opacity; 7278 } 7279 }; 7280} 7281 7282jQuery.cssHooks.marginRight = addGetHookIf( support.reliableMarginRight, 7283 function( elem, computed ) { 7284 if ( computed ) { 7285 return swap( elem, { "display": "inline-block" }, 7286 curCSS, [ elem, "marginRight" ] ); 7287 } 7288 } 7289); 7290 7291jQuery.cssHooks.marginLeft = addGetHookIf( support.reliableMarginLeft, 7292 function( elem, computed ) { 7293 if ( computed ) { 7294 return ( 7295 parseFloat( curCSS( elem, "marginLeft" ) ) || 7296
vendor: 4,625 bytes, lines 7297-7475
7297 // Support: IE<=11+ 7298 // Running getBoundingClientRect on a disconnected node in IE throws an error 7299 // Support: IE8 only 7300 // getClientRects() errors on disconnected elems 7301 ( jQuery.contains( elem.ownerDocument, elem ) ? 7302 elem.getBoundingClientRect().left - 7303 swap( elem, { marginLeft: 0 }, function() { 7304 return elem.getBoundingClientRect().left; 7305 } ) : 7306 0 7307 ) 7308 ) + "px"; 7309 } 7310 } 7311); 7312 7313// These hooks are used by animate to expand properties 7314jQuery.each( { 7315 margin: "", 7316 padding: "", 7317 border: "Width" 7318}, function( prefix, suffix ) { 7319 jQuery.cssHooks[ prefix + suffix ] = { 7320 expand: function( value ) { 7321 var i = 0, 7322 expanded = {}, 7323 7324 // assumes a single number if not a string 7325 parts = typeof value === "string" ? value.split( " " ) : [ value ]; 7326 7327 for ( ; i < 4; i++ ) { 7328 expanded[ prefix + cssExpand[ i ] + suffix ] = 7329 parts[ i ] || parts[ i - 2 ] || parts[ 0 ]; 7330 } 7331 7332 return expanded; 7333 } 7334 }; 7335 7336 if ( !rmargin.test( prefix ) ) { 7337 jQuery.cssHooks[ prefix + suffix ].set = setPositiveNumber; 7338 } 7339} ); 7340 7341jQuery.fn.extend( { 7342 css: function( name, value ) { 7343 return access( this, function( elem, name, value ) { 7344 var styles, len, 7345 map = {}, 7346 i = 0; 7347 7348 if ( jQuery.isArray( name ) ) { 7349 styles = getStyles( elem ); 7350 len = name.length; 7351 7352 for ( ; i < len; i++ ) { 7353 map[ name[ i ] ] = jQuery.css( elem, name[ i ], false, styles ); 7354 } 7355 7356 return map; 7357 } 7358 7359 return value !== undefined ? 7360 jQuery.style( elem, name, value ) : 7361 jQuery.css( elem, name ); 7362 }, name, value, arguments.length > 1 ); 7363 }, 7364 show: function() { 7365 return showHide( this, true ); 7366 }, 7367 hide: function() { 7368 return showHide( this ); 7369 }, 7370 toggle: function( state ) { 7371 if ( typeof state === "boolean" ) { 7372 return state ? this.show() : this.hide(); 7373 } 7374 7375 return this.each( function() { 7376 if ( isHidden( this ) ) { 7377 jQuery( this ).show(); 7378 } else { 7379 jQuery( this ).hide(); 7380 } 7381 } ); 7382 } 7383} ); 7384 7385 7386function Tween( elem, options, prop, end, easing ) { 7387 return new Tween.prototype.init( elem, options, prop, end, easing ); 7388} 7389jQuery.Tween = Tween; 7390 7391Tween.prototype = { 7392 constructor: Tween, 7393 init: function( elem, options, prop, end, easing, unit ) { 7394 this.elem = elem; 7395 this.prop = prop; 7396 this.easing = easing || jQuery.easing._default; 7397 this.options = options; 7398 this.start = this.now = this.cur(); 7399 this.end = end; 7400 this.unit = unit || ( jQuery.cssNumber[ prop ] ? "" : "px" ); 7401 }, 7402 cur: function() { 7403 var hooks = Tween.propHooks[ this.prop ]; 7404 7405 return hooks && hooks.get ? 7406 hooks.get( this ) : 7407 Tween.propHooks._default.get( this ); 7408 }, 7409 run: function( percent ) { 7410 var eased, 7411 hooks = Tween.propHooks[ this.prop ]; 7412 7413 if ( this.options.duration ) { 7414 this.pos = eased = jQuery.easing[ this.easing ]( 7415 percent, this.options.duration * percent, 0, 1, this.options.duration 7416 ); 7417 } else { 7418 this.pos = eased = percent; 7419 } 7420 this.now = ( this.end - this.start ) * eased + this.start; 7421 7422 if ( this.options.step ) { 7423 this.options.step.call( this.elem, this.now, this ); 7424 } 7425 7426 if ( hooks && hooks.set ) { 7427 hooks.set( this ); 7428 } else { 7429 Tween.propHooks._default.set( this ); 7430 } 7431 return this; 7432 } 7433}; 7434 7435Tween.prototype.init.prototype = Tween.prototype; 7436 7437Tween.propHooks = { 7438 _default: { 7439 get: function( tween ) { 7440 var result; 7441 7442 // Use a property on the element directly when it is not a DOM element, 7443 // or when there is no matching style property that exists. 7444 if ( tween.elem.nodeType !== 1 || 7445 tween.elem[ tween.prop ] != null && tween.elem.style[ tween.prop ] == null ) { 7446 return tween.elem[ tween.prop ]; 7447 } 7448 7449 // passing an empty string as a 3rd parameter to .css will automatically 7450 // attempt a parseFloat and fallback to a string if the parse fails 7451 // so, simple values such as "10px" are parsed to Float. 7452 // complex values such as "rotate(1rad)" are returned as is. 7453 result = jQuery.css( tween.elem, tween.prop, "" ); 7454 7455 // Empty strings, null, undefined and "auto" are converted to 0. 7456 return !result || result === "auto" ? 0 : result; 7457 }, 7458 set: function( tween ) { 7459 7460 // use step hook for back compat - use cssHook if its there - use .style if its 7461 // available and use plain properties where available 7462 if ( jQuery.fx.step[ tween.prop ] ) { 7463 jQuery.fx.step[ tween.prop ]( tween ); 7464 } else if ( tween.elem.nodeType === 1 && 7465 ( tween.elem.style[ jQuery.cssProps[ tween.prop ] ] != null || 7466 jQuery.cssHooks[ tween.prop ] ) ) { 7467 jQuery.style( tween.elem, tween.prop, tween.now + tween.unit ); 7468 } else { 7469 tween.elem[ tween.prop ] = tween.now; 7470 } 7471 } 7472 } 7473}; 7474 7475// Support: IE <=9
7476// Panic based approach to setting things on disconnected nodes 7477 7478Tween.propHooks.scrollTop = Tween.propHooks.scrollLeft = { 7479 set: function( tween ) { 7480 if ( tween.elem.nodeType && tween.elem.parentNode ) { 7481 tween.elem[ tween.prop ] = tween.now; 7482 } 7483 } 7484}; 7485 7486jQuery.easing = { 7487 linear: function( p ) { 7488 return p; 7489 }, 7490 swing: function( p ) { 7491 return 0.5 - Math.cos( p * Math.PI ) / 2; 7492 }, 7493 _default: "swing" 7494}; 7495 7496jQuery.fx = Tween.prototype.init; 7497 7498// Back Compat <1.8 extension point 7499jQuery.fx.step = {}; 7500 7501 7502 7503 7504var 7505 fxNow, timerId, 7506 rfxtypes = /^(?:toggle|show|hide)$/, 7507 rrun = /queueHooks$/; 7508 7509// Animations created synchronously will run synchronously 7510function createFxNow() { 7511 window.setTimeout( function() { 7512 fxNow = undefined; 7513 } ); 7514 return ( fxNow = jQuery.now() ); 7515} 7516 7517// Generate parameters to create a standard animation 7518function genFx( type, includeWidth ) { 7519 var which, 7520 attrs = { height: type }, 7521 i = 0; 7522 7523 // if we include width, step value is 1 to do all cssExpand values, 7524 // if we don't include width, step value is 2 to skip over Left and Right 7525 includeWidth = includeWidth ? 1 : 0; 7526 for ( ; i < 4 ; i += 2 - includeWidth ) { 7527 which = cssExpand[ i ]; 7528 attrs[ "margin" + which ] = attrs[ "padding" + which ] = type; 7529 } 7530 7531 if ( includeWidth ) { 7532 attrs.opacity = attrs.width = type; 7533 } 7534 7535 return attrs; 7536} 7537 7538function createTween( value, prop, animation ) { 7539 var tween, 7540 collection = ( Animation.tweeners[ prop ] || [] ).concat( Animation.tweeners[ "*" ] ), 7541 index = 0, 7542 length = collection.length; 7543 for ( ; index < length; index++ ) { 7544 if ( ( tween = collection[ index ].call( animation, prop, value ) ) ) { 7545 7546 // we're done with this property 7547 return tween; 7548 } 7549 } 7550} 7551 7552function defaultPrefilter( elem, props, opts ) { 7553 /* jshint validthis: true */ 7554 var prop, value, toggle, tween, hooks, oldfire, display, checkDisplay, 7555 anim = this, 7556 orig = {}, 7557 style = elem.style, 7558 hidden = elem.nodeType && isHidden( elem ), 7559 dataShow = jQuery._data( elem, "fxshow" ); 7560 7561 // handle queue: false promises 7562 if ( !opts.queue ) { 7563 hooks = jQuery._queueHooks( elem, "fx" ); 7564 if ( hooks.unqueued == null ) { 7565 hooks.unqueued = 0; 7566 oldfire = hooks.empty.fire; 7567 hooks.empty.fire = function() { 7568 if ( !hooks.unqueued ) { 7569 oldfire(); 7570 } 7571 }; 7572 } 7573 hooks.unqueued++; 7574 7575 anim.always( function() { 7576 7577 // doing this makes sure that the complete handler will be called 7578 // before this completes 7579 anim.always( function() { 7580 hooks.unqueued--; 7581 if ( !jQuery.queue( elem, "fx" ).length ) { 7582 hooks.empty.fire(); 7583 } 7584 } ); 7585 } ); 7586 } 7587 7588 // height/width overflow pass 7589 if ( elem.nodeType === 1 && ( "height" in props || "width" in props ) ) { 7590 7591 // Make sure that nothing sneaks out 7592 // Record all 3 overflow attributes because IE does not 7593 // change the overflow attribute when overflowX and 7594 // overflowY are set to the same value 7595 opts.overflow = [ style.overflow, style.overflowX, style.overflowY ]; 7596 7597 // Set display property to inline-block for height/width 7598 // animations on inline elements that are having width/height animated 7599 display = jQuery.css( elem, "display" ); 7600 7601 // Test default display if display is currently "none" 7602 checkDisplay = display === "none" ? 7603 jQuery._data( elem, "olddisplay" ) || defaultDisplay( elem.nodeName ) : display; 7604 7605 if ( checkDisplay === "inline" && jQuery.css( elem, "float" ) === "none" ) { 7606 7607 // inline-level elements accept inline-block; 7608 // block-level elements need to be inline with layout 7609 if ( !support.inlineBlockNeedsLayout || defaultDisplay( elem.nodeName ) === "inline" ) { 7610 style.display = "inline-block"; 7611 } else { 7612 style.zoom = 1; 7613 } 7614 } 7615 } 7616 7617 if ( opts.overflow ) { 7618 style.overflow = "hidden"; 7619 if ( !support.shrinkWrapBlocks() ) { 7620 anim.always( function() { 7621 style.overflow = opts.overflow[ 0 ]; 7622 style.overflowX = opts.overflow[ 1 ]; 7623 style.overflowY = opts.overflow[ 2 ]; 7624 } ); 7625 } 7626 } 7627 7628 // show/hide pass 7629 for ( prop in props ) { 7630 value = props[ prop ]; 7631 if ( rfxtypes.exec( value ) ) { 7632 delete props[ prop ]; 7633 toggle = toggle || value === "toggle"; 7634 if ( value === ( hidden ? "hide" : "show" ) ) { 7635 7636 // If there is dataShow left over from a stopped hide or show 7637 // and we are going to proceed with show, we should pretend to be hidden 7638 if ( value === "show" && dataShow && dataShow[ prop ] !== undefined ) { 7639 hidden = true; 7640 } else { 7641 continue; 7642 } 7643 } 7644 orig[ prop ] = dataShow && dataShow[ prop ] || jQuery.style( elem, prop ); 7645 7646 // Any non-fx value stops us from restoring the original display value 7647 } else { 7648 display = undefined; 7649 } 7650 } 7651 7652 if ( !jQuery.isEmptyObject( orig ) ) { 7653 if ( dataShow ) { 7654 if ( "hidden" in dataShow ) { 7655 hidden = dataShow.hidden; 7656 } 7657 } else { 7658 dataShow = jQuery._data( elem, "fxshow", {} ); 7659 } 7660 7661 // store state if its toggle - enables .stop().toggle() to "reverse" 7662 if ( toggle ) { 7663 dataShow.hidden = !hidden; 7664 } 7665 if ( hidden ) { 7666 jQuery( elem ).show(); 7667 } else { 7668 anim.done( function() { 7669 jQuery( elem ).hide(); 7670 } ); 7671 } 7672 anim.done( function() { 7673 var prop; 7674 jQuery._removeData( elem, "fxshow" ); 7675 for ( prop in orig ) { 7676 jQuery.style( elem, prop, orig[ prop ] ); 7677 } 7678 } ); 7679 for ( prop in orig ) { 7680 tween = createTween( hidden ? dataShow[ prop ] : 0, prop, anim ); 7681 7682 if ( !( prop in dataShow ) ) { 7683 dataShow[ prop ] = tween.start; 7684 if ( hidden ) { 7685 tween.end = tween.start; 7686 tween.start = prop === "width" || prop === "height" ? 1 : 0; 7687 } 7688 } 7689 } 7690 7691 // If this is a noop like .hide().hide(), restore an overwritten display value 7692 } else if ( ( display === "none" ? defaultDisplay( elem.nodeName ) : dis
vendor: 10,851 bytes, lines 7692-8124
7692play ) === "inline" ) { 7693 style.display = display; 7694 } 7695} 7696 7697function propFilter( props, specialEasing ) { 7698 var index, name, easing, value, hooks; 7699 7700 // camelCase, specialEasing and expand cssHook pass 7701 for ( index in props ) { 7702 name = jQuery.camelCase( index ); 7703 easing = specialEasing[ name ]; 7704 value = props[ index ]; 7705 if ( jQuery.isArray( value ) ) { 7706 easing = value[ 1 ]; 7707 value = props[ index ] = value[ 0 ]; 7708 } 7709 7710 if ( index !== name ) { 7711 props[ name ] = value; 7712 delete props[ index ]; 7713 } 7714 7715 hooks = jQuery.cssHooks[ name ]; 7716 if ( hooks && "expand" in hooks ) { 7717 value = hooks.expand( value ); 7718 delete props[ name ]; 7719 7720 // not quite $.extend, this wont overwrite keys already present. 7721 // also - reusing 'index' from above because we have the correct "name" 7722 for ( index in value ) { 7723 if ( !( index in props ) ) { 7724 props[ index ] = value[ index ]; 7725 specialEasing[ index ] = easing; 7726 } 7727 } 7728 } else { 7729 specialEasing[ name ] = easing; 7730 } 7731 } 7732} 7733 7734function Animation( elem, properties, options ) { 7735 var result, 7736 stopped, 7737 index = 0, 7738 length = Animation.prefilters.length, 7739 deferred = jQuery.Deferred().always( function() { 7740 7741 // don't match elem in the :animated selector 7742 delete tick.elem; 7743 } ), 7744 tick = function() { 7745 if ( stopped ) { 7746 return false; 7747 } 7748 var currentTime = fxNow || createFxNow(), 7749 remaining = Math.max( 0, animation.startTime + animation.duration - currentTime ), 7750 7751 // Support: Android 2.3 7752 // Archaic crash bug won't allow us to use `1 - ( 0.5 || 0 )` (#12497) 7753 temp = remaining / animation.duration || 0, 7754 percent = 1 - temp, 7755 index = 0, 7756 length = animation.tweens.length; 7757 7758 for ( ; index < length ; index++ ) { 7759 animation.tweens[ index ].run( percent ); 7760 } 7761 7762 deferred.notifyWith( elem, [ animation, percent, remaining ] ); 7763 7764 if ( percent < 1 && length ) { 7765 return remaining; 7766 } else { 7767 deferred.resolveWith( elem, [ animation ] ); 7768 return false; 7769 } 7770 }, 7771 animation = deferred.promise( { 7772 elem: elem, 7773 props: jQuery.extend( {}, properties ), 7774 opts: jQuery.extend( true, { 7775 specialEasing: {}, 7776 easing: jQuery.easing._default 7777 }, options ), 7778 originalProperties: properties, 7779 originalOptions: options, 7780 startTime: fxNow || createFxNow(), 7781 duration: options.duration, 7782 tweens: [], 7783 createTween: function( prop, end ) { 7784 var tween = jQuery.Tween( elem, animation.opts, prop, end, 7785 animation.opts.specialEasing[ prop ] || animation.opts.easing ); 7786 animation.tweens.push( tween ); 7787 return tween; 7788 }, 7789 stop: function( gotoEnd ) { 7790 var index = 0, 7791 7792 // if we are going to the end, we want to run all the tweens 7793 // otherwise we skip this part 7794 length = gotoEnd ? animation.tweens.length : 0; 7795 if ( stopped ) { 7796 return this; 7797 } 7798 stopped = true; 7799 for ( ; index < length ; index++ ) { 7800 animation.tweens[ index ].run( 1 ); 7801 } 7802 7803 // resolve when we played the last frame 7804 // otherwise, reject 7805 if ( gotoEnd ) { 7806 deferred.notifyWith( elem, [ animation, 1, 0 ] ); 7807 deferred.resolveWith( elem, [ animation, gotoEnd ] ); 7808 } else { 7809 deferred.rejectWith( elem, [ animation, gotoEnd ] ); 7810 } 7811 return this; 7812 } 7813 } ), 7814 props = animation.props; 7815 7816 propFilter( props, animation.opts.specialEasing ); 7817 7818 for ( ; index < length ; index++ ) { 7819 result = Animation.prefilters[ index ].call( animation, elem, props, animation.opts ); 7820 if ( result ) { 7821 if ( jQuery.isFunction( result.stop ) ) { 7822 jQuery._queueHooks( animation.elem, animation.opts.queue ).stop = 7823 jQuery.proxy( result.stop, result ); 7824 } 7825 return result; 7826 } 7827 } 7828 7829 jQuery.map( props, createTween, animation ); 7830 7831 if ( jQuery.isFunction( animation.opts.start ) ) { 7832 animation.opts.start.call( elem, animation ); 7833 } 7834 7835 jQuery.fx.timer( 7836 jQuery.extend( tick, { 7837 elem: elem, 7838 anim: animation, 7839 queue: animation.opts.queue 7840 } ) 7841 ); 7842 7843 // attach callbacks from options 7844 return animation.progress( animation.opts.progress ) 7845 .done( animation.opts.done, animation.opts.complete ) 7846 .fail( animation.opts.fail ) 7847 .always( animation.opts.always ); 7848} 7849 7850jQuery.Animation = jQuery.extend( Animation, { 7851 7852 tweeners: { 7853 "*": [ function( prop, value ) { 7854 var tween = this.createTween( prop, value ); 7855 adjustCSS( tween.elem, prop, rcssNum.exec( value ), tween ); 7856 return tween; 7857 } ] 7858 }, 7859 7860 tweener: function( props, callback ) { 7861 if ( jQuery.isFunction( props ) ) { 7862 callback = props; 7863 props = [ "*" ]; 7864 } else { 7865 props = props.match( rnotwhite ); 7866 } 7867 7868 var prop, 7869 index = 0, 7870 length = props.length; 7871 7872 for ( ; index < length ; index++ ) { 7873 prop = props[ index ]; 7874 Animation.tweeners[ prop ] = Animation.tweeners[ prop ] || []; 7875 Animation.tweeners[ prop ].unshift( callback ); 7876 } 7877 }, 7878 7879 prefilters: [ defaultPrefilter ], 7880 7881 prefilter: function( callback, prepend ) { 7882 if ( prepend ) { 7883 Animation.prefilters.unshift( callback ); 7884 } else { 7885 Animation.prefilters.push( callback ); 7886 } 7887 } 7888} ); 7889 7890jQuery.speed = function( speed, easing, fn ) { 7891 var opt = speed && typeof speed === "object" ? jQuery.extend( {}, speed ) : { 7892 complete: fn || !fn && easing || 7893 jQuery.isFunction( speed ) && speed, 7894 duration: speed, 7895 easing: fn && easing || easing && !jQuery.isFunction( easing ) && easing 7896 }; 7897 7898 opt.duration = jQuery.fx.off ? 0 : typeof opt.duration === "number" ? opt.duration : 7899 opt.duration in jQuery.fx.speeds ? 7900 jQuery.fx.speeds[ opt.duration ] : jQuery.fx.speeds._default; 7901 7902 // normalize opt.queue - true/undefined/null -> "fx" 7903 if ( opt.queue == null || opt.queue === true ) { 7904 opt.queue = "fx"; 7905 } 7906 7907 // Queueing 7908 opt.old = opt.complete; 7909 7910 opt.complete = function() { 7911 if ( jQuery.isFunction( opt.old ) ) { 7912 opt.old.call( this ); 7913 } 7914 7915 if ( opt.queue ) { 7916 jQuery.dequeue( this, opt.queue ); 7917 } 7918 }; 7919 7920 return opt; 7921}; 7922 7923jQuery.fn.extend( { 7924 fadeTo: function( speed, to, easing, callback ) { 7925 7926 // show any hidden elements after setting opacity to 0 7927 return this.filter( isHidden ).css( "opacity", 0 ).show() 7928 7929 // animate to the value specified 7930 .end().animate( { opacity: to }, speed, easing, callback ); 7931 }, 7932 animate: function( prop, speed, easing, callback ) { 7933 var empty = jQuery.isEmptyObject( prop ), 7934 optall = jQuery.speed( speed, easing, callback ), 7935 doAnimation = function() { 7936 7937 // Operate on a copy of prop so per-property easing won't be lost 7938 var anim = Animation( this, jQuery.extend( {}, prop ), optall ); 7939 7940 // Empty animations, or finishing resolves immediately 7941 if ( empty || jQuery._data( this, "finish" ) ) { 7942 anim.stop( true ); 7943 } 7944 }; 7945 doAnimation.finish = doAnimation; 7946 7947 return empty || optall.queue === false ? 7948 this.each( doAnimation ) : 7949 this.queue( optall.queue, doAnimation ); 7950 }, 7951 stop: function( type, clearQueue, gotoEnd ) { 7952 var stopQueue = function( hooks ) { 7953 var stop = hooks.stop; 7954 delete hooks.stop; 7955 stop( gotoEnd ); 7956 }; 7957 7958 if ( typeof type !== "string" ) { 7959 gotoEnd = clearQueue; 7960 clearQueue = type; 7961 type = undefined; 7962 } 7963 if ( clearQueue && type !== false ) { 7964 this.queue( type || "fx", [] ); 7965 } 7966 7967 return this.each( function() { 7968 var dequeue = true, 7969 index = type != null && type + "queueHooks", 7970 timers = jQuery.timers, 7971 data = jQuery._data( this ); 7972 7973 if ( index ) { 7974 if ( data[ index ] && data[ index ].stop ) { 7975 stopQueue( data[ index ] ); 7976 } 7977 } else { 7978 for ( index in data ) { 7979 if ( data[ index ] && data[ index ].stop && rrun.test( index ) ) { 7980 stopQueue( data[ index ] ); 7981 } 7982 } 7983 } 7984 7985 for ( index = timers.length; index--; ) { 7986 if ( timers[ index ].elem === this && 7987 ( type == null || timers[ index ].queue === type ) ) { 7988 7989 timers[ index ].anim.stop( gotoEnd ); 7990 dequeue = false; 7991 timers.splice( index, 1 ); 7992 } 7993 } 7994 7995 // start the next in the queue if the last step wasn't forced 7996 // timers currently will call their complete callbacks, which will dequeue 7997 // but only if they were gotoEnd 7998 if ( dequeue || !gotoEnd ) { 7999 jQuery.dequeue( this, type ); 8000 } 8001 } ); 8002 }, 8003 finish: function( type ) { 8004 if ( type !== false ) { 8005 type = type || "fx"; 8006 } 8007 return this.each( function() { 8008 var index, 8009 data = jQuery._data( this ), 8010 queue = data[ type + "queue" ], 8011 hooks = data[ type + "queueHooks" ], 8012 timers = jQuery.timers, 8013 length = queue ? queue.length : 0; 8014 8015 // enable finishing flag on private data 8016 data.finish = true; 8017 8018 // empty the queue first 8019 jQuery.queue( this, type, [] ); 8020 8021 if ( hooks && hooks.stop ) { 8022 hooks.stop.call( this, true ); 8023 } 8024 8025 // look for any active animations, and finish them 8026 for ( index = timers.length; index--; ) { 8027 if ( timers[ index ].elem === this && timers[ index ].queue === type ) { 8028 timers[ index ].anim.stop( true ); 8029 timers.splice( index, 1 ); 8030 } 8031 } 8032 8033 // look for any animations in the old queue and finish them 8034 for ( index = 0; index < length; index++ ) { 8035 if ( queue[ index ] && queue[ index ].finish ) { 8036 queue[ index ].finish.call( this ); 8037 } 8038 } 8039 8040 // turn off finishing flag 8041 delete data.finish; 8042 } ); 8043 } 8044} ); 8045 8046jQuery.each( [ "toggle", "show", "hide" ], function( i, name ) { 8047 var cssFn = jQuery.fn[ name ]; 8048 jQuery.fn[ name ] = function( speed, easing, callback ) { 8049 return speed == null || typeof speed === "boolean" ? 8050 cssFn.apply( this, arguments ) : 8051 this.animate( genFx( name, true ), speed, easing, callback ); 8052 }; 8053} ); 8054 8055// Generate shortcuts for custom animations 8056jQuery.each( { 8057 slideDown: genFx( "show" ), 8058 slideUp: genFx( "hide" ), 8059 slideToggle: genFx( "toggle" ), 8060 fadeIn: { opacity: "show" }, 8061 fadeOut: { opacity: "hide" }, 8062 fadeToggle: { opacity: "toggle" } 8063}, function( name, props ) { 8064 jQuery.fn[ name ] = function( speed, easing, callback ) { 8065 return this.animate( props, speed, easing, callback ); 8066 }; 8067} ); 8068 8069jQuery.timers = []; 8070jQuery.fx.tick = function() { 8071 var timer, 8072 timers = jQuery.timers, 8073 i = 0; 8074 8075 fxNow = jQuery.now(); 8076 8077 for ( ; i < timers.length; i++ ) { 8078 timer = timers[ i ]; 8079 8080 // Checks the timer has not already been removed 8081 if ( !timer() && timers[ i ] === timer ) { 8082 timers.splice( i--, 1 ); 8083 } 8084 } 8085 8086 if ( !timers.length ) { 8087 jQuery.fx.stop(); 8088 } 8089 fxNow = undefined; 8090}; 8091 8092jQuery.fx.timer = function( timer ) { 8093 jQuery.timers.push( timer ); 8094 if ( timer() ) { 8095 jQuery.fx.start(); 8096 } else { 8097 jQuery.timers.pop(); 8098 } 8099}; 8100 8101jQuery.fx.interval = 13; 8102 8103jQuery.fx.start = function() { 8104 if ( !timerId ) { 8105 timerId = window.setInterval( jQuery.fx.tick, jQuery.fx.interval ); 8106 } 8107}; 8108 8109jQuery.fx.stop = function() { 8110 window.clearInterval( timerId ); 8111 timerId = null; 8112}; 8113 8114jQuery.fx.speeds = { 8115 slow: 600, 8116 fast: 200, 8117 8118 // Default speed 8119 _default: 400 8120}; 8121 8122 8123// Based off of the plugin by Clint Helfers, with permission. 8124// http://web.archive.org/web/20100324014747/http://blindsignals.com/index.php/2009/07/jquery-delay/
8125jQuery.fn.delay = function( time, type ) { 8126 time = jQuery.fx ? jQuery.fx.speeds[ time ] || time : time; 8127 type = type || "fx"; 8128 8129 return this.queue( type, function( next, hooks ) { 8130 var timeout = window.setTimeout( next, time ); 8131 hooks.stop = function() { 8132 window.clearTimeout( timeout ); 8133 }; 8134 } ); 8135}; 8136 8137 8138( function() { 8139 var a, 8140 input = document.createElement( "input" ), 8141 div = document.createElement( "div" ), 8142 select = document.createElement( "select" ), 8143 opt = select.appendChild( document.createElement( "option" ) ); 8144 8145 // Setup 8146 div = document.createElement( "div" ); 8147 div.setAttribute( "className", "t" ); 8148 div.innerHTML = " <link/><table></table><a href='/a'>a</a><input type='checkbox'/>"; 8149 a = div.getElementsByTagName( "a" )[ 0 ]; 8150 8151 // Support: Windows Web Apps (WWA) 8152 // `type` must use .setAttribute for WWA (#14901) 8153 input.setAttribute( "type", "checkbox" ); 8154 div.appendChild( input ); 8155 8156 a = div.getElementsByTagName( "a" )[ 0 ]; 8157 8158 // First batch of tests. 8159 a.style.cssText = "top:1px"; 8160 8161 // Test setAttribute on camelCase class. 8162 // If it works, we need attrFixes when doing get/setAttribute (ie6/7)
8163 support.getSetAttribute = div.className !== "t"; 8164 8165 // Get the style information from getAttribute 8166 // (IE uses .cssText instead) 8167 support.style = /top/.test( a.getAttribute( "style" ) ); 8168 8169 // Make sure that URLs aren't manipulated 8170 // (IE normalizes it by default) 8171 support.hrefNormalized = a.getAttribute( "href" ) === "/a"; 8172 8173 // Check the default checkbox/radio value ("" on WebKit; "on" elsewhere) 8174 support.checkOn = !!input.value; 8175 8176 // Make sure that a selected-by-default option has a working selected property. 8177 // (WebKit defaults to false instead of true, IE too, if it's in an optgroup) 8178 support.optSelected = opt.selected; 8179 8180 // Tests for enctype support on a form (#6743) 8181 support.enctype = !!document.createElement( "form" ).enctype; 8182 8183 // Make sure that the options inside disabled selects aren't marked as disabled 8184 // (WebKit marks them as disabled) 8185 select.disabled = true; 8186 support.optDisabled = !opt.disabled; 8187 8188 // Support: IE8 only 8189 // Check if we can trust getAttribute("value") 8190 input = document.createElement( "input" ); 8191 input.setAttribute( "value", "" ); 8192 support.input = input.getAttribute( "value" ) === ""; 8193 8194 // Check if an input maintains its value after becoming a radio 8195 input.value = "t"; 8196 input.setAttribute( "type", "radio" ); 8197 support.radioValue = input.value === "t"; 8198} )(); 8199 8200 8201var rreturn = /\r/g, 8202 rspaces = /[\x20\t\r\n\f]+/g; 8203 8204jQuery.fn.extend( { 8205 val: function( value ) { 8206 var hooks, ret, isFunction, 8207 elem = this[ 0 ]; 8208 8209 if ( !arguments.length ) { 8210 if ( elem ) { 8211 hooks = jQuery.valHooks[ elem.type ] || 8212 jQuery.valHooks[ elem.nodeName.toLowerCase() ]; 8213 8214 if ( 8215 hooks && 8216 "get" in hooks && 8217 ( ret = hooks.get( elem, "value" ) ) !== undefined 8218 ) { 8219 return ret; 8220 } 8221 8222 ret = elem.value; 8223 8224 return typeof ret === "string" ? 8225 8226 // handle most common string cases 8227 ret.replace( rreturn, "" ) : 8228 8229 // handle cases where value is null/undef or number 8230 ret == null ? "" : ret; 8231 } 8232 8233 return; 8234 } 8235 8236 isFunction = jQuery.isFunction( value ); 8237 8238 return this.each( function( i ) { 8239 var val; 8240 8241 if ( this.nodeType !== 1 ) { 8242 return; 8243 } 8244 8245 if ( isFunction ) { 8246 val = value.call( this, i, jQuery( this ).val() ); 8247 } else { 8248 val = value; 8249 } 8250 8251 // Treat null/undefined as ""; convert numbers to string 8252 if ( val == null ) { 8253 val = ""; 8254 } else if ( typeof val === "number" ) { 8255 val += ""; 8256 } else if ( jQuery.isArray( val ) ) { 8257 val = jQuery.map( val, function( value ) { 8258 return value == null ? "" : value + ""; 8259 } ); 8260 } 8261 8262 hooks = jQuery.valHooks[ this.type ] || jQuery.valHooks[ this.nodeName.toLowerCase() ]; 8263 8264 // If set returns undefined, fall back to normal setting
8265 if ( !hooks || !( "set" in hooks ) || hooks.set( this, val, "value" ) === undefined ) { 8266 this.value = val; 8267 } 8268 } ); 8269 } 8270} ); 8271 8272jQuery.extend( { 8273 valHooks: { 8274 option: { 8275 get: function( elem ) { 8276 var val = jQuery.find.attr( elem, "value" ); 8277 return val != null ? 8278 val : 8279 8280 // Support: IE10-11+ 8281 // option.text throws exceptions (#14686, #14858) 8282 // Strip and collapse whitespace 8283 // https://html.spec.whatwg.org/#strip-and-collapse-whitespace 8284 jQuery.trim( jQuery.text( elem ) ).replace( rspaces, " " ); 8285 } 8286 }, 8287 select: { 8288 get: function( elem ) { 8289 var value, option, 8290 options = elem.options, 8291 index = elem.selectedIndex, 8292 one = elem.type === "select-one" || index < 0, 8293 values = one ? null : [], 8294 max = one ? index + 1 : options.length, 8295 i = index < 0 ? 8296 max : 8297 one ? index : 0; 8298 8299 // Loop through all the selected options 8300 for ( ; i < max; i++ ) { 8301 option = options[ i ]; 8302 8303 // oldIE doesn't update selected after form reset (#2551) 8304 if ( ( option.selected || i === index ) && 8305 8306 // Don't return options that are disabled or in a disabled optgroup 8307 ( support.optDisabled ? 8308 !option.disabled : 8309 option.getAttribute( "disabled" ) === null ) && 8310 ( !option.parentNode.disabled || 8311 !jQuery.nodeName( option.parentNode, "optgroup" ) ) ) { 8312 8313 // Get the specific value for the option 8314 value = jQuery( option ).val(); 8315 8316 // We don't need an array for one selects 8317 if ( one ) { 8318 return value; 8319 } 8320 8321 // Multi-Selects return an array 8322 values.push( value ); 8323 } 8324 } 8325 8326 return values; 8327 }, 8328 8329 set: function( elem, value ) { 8330 var optionSet, option, 8331 options = elem.options, 8332 values = jQuery.makeArray( value ), 8333 i = options.length; 8334 8335 while ( i-- ) { 8336 option = options[ i ]; 8337 8338 if ( jQuery.inArray( jQuery.valHooks.option.get( option ), values ) > -1 ) { 8339 8340 // Support: IE6 8341 // When new option element is added to select box we need to 8342 // force reflow of newly added node in order to workaround delay 8343 // of initialization properties 8344 try { 8345 option.selected = optionSet = true; 8346 8347 } catch ( _ ) { 8348 8349 // Will be executed only in IE6 8350 option.scrollHeight; 8351 } 8352 8353 } else { 8354 option.selected = false; 8355 } 8356 } 8357 8358 // Force browsers to behave consistently when non-matching value is set 8359 if ( !optionSet ) { 8360 elem.selectedIndex = -1; 8361 } 8362 8363 return options; 8364 } 8365 } 8366 } 8367} ); 8368 8369// Radios and checkboxes getter/setter 8370jQuery.each( [ "radio", "checkbox" ], function() { 8371 jQuery.valHooks[ this ] = { 8372 set: function( elem, value ) { 8373 if ( jQuery.isArray( value ) ) { 8374 return ( elem.checked = jQuery.inArray( jQuery( elem ).val(), value ) > -1 ); 8375 } 8376 } 8377 }; 8378 if ( !support.checkOn ) { 8379 jQuery.valHooks[ this ].get = function( elem ) { 8380 return elem.getAttribute( "value" ) === null ? "on" : elem.value; 8381 }; 8382 } 8383} ); 8384 8385 8386 8387 8388var nodeHook, boolHook, 8389 attrHandle = jQuery.expr.attrHandle, 8390 ruseDefault = /^(?:checked|selected)$/i, 8391 getSetAttribute = support.getSetAttribute, 8392 getSetInput = support.input; 8393 8394jQuery.fn.extend( { 8395 attr: function( name, value ) { 8396 return access( this, jQuery.attr, name, value, arguments.length > 1 ); 8397 }, 8398 8399 removeAttr: function( name ) { 8400 return this.each( function() { 8401 jQuery.removeAttr( this, name ); 8402 } ); 8403 } 8404} ); 8405 8406jQuery.extend( { 8407 attr: function( elem, name, value ) { 8408 var ret, hooks, 8409 nType = elem.nodeType; 8410 8411 // Don't get/set attributes on text, comment and attribute nodes 8412 if ( nType === 3 || nType === 8 || nType === 2 ) { 8413 return; 8414 } 8415 8416 // Fallback to prop when attributes are not supported 8417 if ( typeof elem.getAttribute === "undefined" ) { 8418 return jQuery.prop( elem, name, value ); 8419 } 8420 8421 // All attributes are lowercase 8422 // Grab necessary hook if one is defined 8423 if ( nType !== 1 || !jQuery.isXMLDoc( elem ) ) { 8424 name = name.toLowerCase(); 8425 hooks = jQuery.attrHooks[ name ] || 8426 ( jQuery.expr.match.bool.test( name ) ? boolHook : nodeHook ); 8427 } 8428 8429 if ( value !== undefined ) { 8430 if ( value === null ) { 8431 jQuery.removeAttr( elem, name ); 8432 return; 8433 } 8434 8435 if ( hooks && "set" in hooks && 8436 ( ret = hooks.set( elem, value, name ) ) !== undefined ) { 8437 return ret; 8438 } 8439 8440 elem.setAttribute( name, value + "" ); 8441 return value; 8442 } 8443 8444 if ( hooks && "get" in hooks && ( ret = hooks.get( elem, name ) ) !== null ) { 8445 return ret; 8446 } 8447 8448 ret = jQuery.find.attr( elem, name ); 8449 8450 // Non-existent attributes return null, we normalize to undefined 8451 return ret == null ? undefined : ret; 8452 }, 8453 8454 attrHooks: { 8455 type: {
8456 set: function( elem, value ) { 8457 if ( !support.radioValue && value === "radio" && 8458 jQuery.nodeName( elem, "input" ) ) { 8459 8460 // Setting the type on a radio button after the value resets the value in IE8-9 8461 // Reset value to default in case type is set after value during creation 8462 var val = elem.value; 8463 elem.setAttribute( "type", value ); 8464 if ( val ) { 8465 elem.value = val; 8466 } 8467 return value; 8468 } 8469 } 8470 } 8471 }, 8472 8473 removeAttr: function( elem, value ) { 8474 var name, propName, 8475 i = 0, 8476 attrNames = value && value.match( rnotwhite ); 8477 8478 if ( attrNames && elem.nodeType === 1 ) { 8479 while ( ( name = attrNames[ i++ ] ) ) { 8480 propName = jQuery.propFix[ name ] || name; 8481 8482 // Boolean attributes get special treatment (#10870) 8483 if ( jQuery.expr.match.bool.test( name ) ) { 8484 8485 // Set corresponding property to false 8486 if ( getSetInput && getSetAttribute || !ruseDefault.test( name ) ) { 8487 elem[ propName ] = false; 8488 8489 // Support: IE<9 8490 // Also clear defaultChecked/defaultSelected (if appropriate) 8491 } else { 8492 elem[ jQuery.camelCase( "default-" + name ) ] = 8493 elem[ propName ] = false; 8494 } 8495 8496 // See #9699 for explanation of this approach (setting first, then removal) 8497 } else { 8498 jQuery.attr( elem, name, "" ); 8499 } 8500 8501 elem.removeAttribute( getSetAttribute ? name : propName ); 8502 } 8503 } 8504 } 8505} ); 8506 8507// Hooks for boolean attributes 8508boolHook = { 8509 set: function( elem, value, name ) { 8510 if ( value === false ) { 8511 8512 // Remove boolean attributes when set to false 8513 jQuery.removeAttr( elem, name ); 8514 } else if ( getSetInput && getSetAttribute || !ruseDefault.test( name ) ) { 8515 8516 // IE<8 needs the *property* name 8517 elem.setAttribute( !getSetAttribute && jQuery.propFix[ name ] || name, name ); 8518 8519 } else { 8520 8521 // Support: IE<9 8522 // Use defaultChecked and defaultSelected for oldIE 8523 elem[ jQuery.camelCase( "default-" + name ) ] = elem[ name ] = true; 8524 } 8525 return name; 8526 } 8527}; 8528 8529jQuery.each( jQuery.expr.match.bool.source.match( /\w+/g ), function( i, name ) { 8530 var getter = attrHandle[ name ] || jQuery.find.attr; 8531 8532 if ( getSetInput && getSetAttribute || !ruseDefault.test( name ) ) { 8533 attrHandle[ name ] = function( elem, name, isXML ) { 8534 var ret, handle; 8535 if ( !isXML ) { 8536 8537 // Avoid an infinite loop by temporarily removing this function from the getter 8538 handle = attrHandle[ name ]; 8539 attrHandle[ name ] = ret; 8540 ret = getter( elem, name, isXML ) != null ? 8541 name.toLowerCase() : 8542 null; 8543 attrHandle[ name ] = handle; 8544 } 8545 return ret; 8546 }; 8547 } else { 8548 attrHandle[ name ] = function( elem, name, isXML ) { 8549 if ( !isXML ) { 8550 return elem[ jQuery.camelCase( "default-" + name ) ] ? 8551 name.toLowerCase() : 8552 null; 8553 } 8554 }; 8555 } 8556} ); 8557 8558// fix oldIE attroperties 8559if ( !getSetInput || !getSetAttribute ) { 8560 jQuery.attrHooks.value = { 8561 set: function( elem, value, name ) { 8562 if ( jQuery.nodeName( elem, "input" ) ) { 8563 8564 // Does not return so that setAttribute is also used 8565 elem.defaultValue = value; 8566 } else { 8567 8568 // Use nodeHook if defined (#1954); otherwise setAttribute is fine 8569 return nodeHook && nodeHook.set( elem, value, name ); 8570 } 8571 } 8572 }; 8573} 8574 8575// IE6/7 do not support getting/setting some attributes with get/setAttribute 8576if ( !getSetAttribute ) { 8577 8578 // Use this for any attribute in IE6/7 8579 // This fixes almost every IE6/7 issue 8580 nodeHook = { 8581 set: function( elem, value, name ) { 8582 8583 // Set the existing or create a new attribute node 8584 var ret = elem.getAttributeNode( name ); 8585 if ( !ret ) { 8586 elem.setAttributeNode( 8587 ( ret = elem.ownerDocument.createAttribute( name ) ) 8588 ); 8589 } 8590 8591 ret.value = value += ""; 8592 8593 // Break association with cloned elements by also using setAttribute (#9646) 8594 if ( name === "value" || value === elem.getAttribute( name ) ) { 8595 return value; 8596 } 8597 } 8598 }; 8599 8600 // Some attributes are constructed with empty-string values when not defined 8601 attrHandle.id = attrHandle.name = attrHandle.coords = 8602 function( elem, name, isXML ) { 8603 var ret; 8604 if ( !isXML ) { 8605 return ( ret = elem.getAttributeNode( name ) ) && ret.value !== "" ? 8606 ret.value : 8607 null; 8608 } 8609 }; 8610 8611 // Fixing value retrieval on a button requires this module 8612 jQuery.valHooks.button = { 8613 get: function( elem, name ) { 8614 var ret = elem.getAttributeNode( name ); 8615 if ( ret && ret.specified ) { 8616 return ret.value; 8617 } 8618 }, 8619 set: nodeHook.set 8620 }; 8621 8622 // Set contenteditable to false on removals(#10429)
8623 // Setting to empty string throws an error as an invalid value 8624 jQuery.attrHooks.contenteditable = { 8625 set: function( elem, value, name ) { 8626 nodeHook.set( elem, value === "" ? false : value, name ); 8627 } 8628 }; 8629 8630 // Set width and height to auto instead of 0 on empty string( Bug #8150 ) 8631 // This is for removals 8632 jQuery.each( [ "width", "height" ], function( i, name ) { 8633 jQuery.attrHooks[ name ] = { 8634 set: function( elem, value ) { 8635 if ( value === "" ) { 8636 elem.setAttribute( name, "auto" ); 8637 return value; 8638 } 8639 } 8640 }; 8641 } ); 8642} 8643 8644if ( !support.style ) { 8645 jQuery.attrHooks.style = { 8646 get: function( elem ) { 8647 8648 // Return undefined in the case of empty string 8649 // Note: IE uppercases css property names, but if we were to .toLowerCase() 8650 // .cssText, that would destroy case sensitivity in URL's, like in "background" 8651 return elem.style.cssText || undefined; 8652 }, 8653 set: function( elem, value ) { 8654 return ( elem.style.cssText = value + "" ); 8655 } 8656 }; 8657} 8658 8659 8660 8661 8662var rfocusable = /^(?:input|select|textarea|button|object)$/i, 8663 rclickable = /^(?:a|area)$/i; 8664 8665jQuery.fn.extend( { 8666 prop: function( name, value ) { 8667 return access( this, jQuery.prop, name, value, arguments.length > 1 ); 8668 }, 8669 8670 removeProp: function( name ) { 8671 name = jQuery.propFix[ name ] || name; 8672 return this.each( function() { 8673 8674 // try/catch handles cases where IE balks (such as removing a property on window) 8675 try { 8676 this[ name ] = undefined; 8677 delete this[ name ]; 8678 } catch ( e ) {} 8679 } ); 8680 } 8681} ); 8682 8683jQuery.extend( { 8684 prop: function( elem, name, value ) { 8685 var ret, hooks, 8686 nType = elem.nodeType; 8687 8688 // Don't get/set properties on text, comment and attribute nodes 8689 if ( nType === 3 || nType === 8 || nType === 2 ) { 8690 return; 8691 } 8692 8693 if ( nType !== 1 || !jQuery.isXMLDoc( elem ) ) { 8694 8695 // Fix name and attach hooks 8696 name = jQuery.propFix[ name ] || name; 8697 hooks = jQuery.propHooks[ name ]; 8698 } 8699 8700 if ( value !== undefined ) { 8701 if ( hooks && "set" in hooks && 8702 ( ret = hooks.set( elem, value, name ) ) !== undefined ) { 8703 return ret; 8704 } 8705 8706 return ( elem[ name ] = value ); 8707 } 8708 8709 if ( hooks && "get" in hooks && ( ret = hooks.get( elem, name ) ) !== null ) { 8710 return ret; 8711 } 8712 8713 return elem[ name ]; 8714 }, 8715 8716 propHooks: { 8717 tabIndex: { 8718 get: function( elem ) { 8719 8720 // elem.tabIndex doesn't always return the 8721 // correct value when it hasn't been explicitly set 8722 // http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/ 8723 // Use proper attribute retrieval(#12072) 8724 var tabindex = jQuery.find.attr( elem, "tabindex" ); 8725 8726 return tabindex ? 8727 parseInt( tabindex, 10 ) : 8728 rfocusable.test( elem.nodeName ) || 8729 rclickable.test( elem.nodeName ) && elem.href ? 8730 0 : 8731 -1; 8732 } 8733 } 8734 }, 8735 8736 propFix: { 8737 "for": "htmlFor", 8738 "class": "className" 8739 } 8740} ); 8741 8742// Some attributes require a special call on IE 8743// http://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx 8744if ( !support.hrefNormalized ) { 8745 8746 // href/src property should get the full normalized URL (#10299/#12915) 8747 jQuery.each( [ "href", "src" ], function( i, name ) { 8748 jQuery.propHooks[ name ] = { 8749 get: function( elem ) { 8750 return elem.getAttribute( name, 4 ); 8751 } 8752 }; 8753 } ); 8754} 8755 8756// Support: Safari, IE9+ 8757// Accessing the selectedIndex property 8758// forces the browser to respect setting selected 8759// on the option 8760// The getter ensures a default option is selected 8761// when in an optgroup 8762if ( !support.optSelected ) { 8763 jQuery.propHooks.selected = { 8764 get: function( elem ) { 8765 var parent = elem.parentNode; 8766 8767 if ( parent ) { 8768 parent.selectedIndex; 8769 8770 // Make sure that it also works with optgroups, see #5701 8771 if ( parent.parentNode ) { 8772 parent.parentNode.selectedIndex; 8773 } 8774 } 8775 return null; 8776 }, 8777 set: function( elem ) { 8778 var parent = elem.parentNode; 8779 if ( parent ) { 8780 parent.selectedIndex; 8781 8782 if ( parent.parentNode ) { 8783 parent.parentNode.selectedIndex; 8784 } 8785 } 8786 } 8787 }; 8788} 8789 8790jQuery.each( [ 8791 "tabIndex", 8792 "readOnly", 8793 "maxLength", 8794 "cellSpacing", 8795 "cellPadding", 8796 "rowSpan", 8797 "colSpan", 8798 "useMap", 8799 "frameBorder", 8800 "contentEditable" 8801], function() { 8802 jQuery.propFix[ this.toLowerCase() ] = this; 8803} ); 8804 8805// IE6/7 call enctype encoding 8806if ( !support.enctype ) { 8807 jQuery.propFix.enctype = "encoding"; 8808} 8809 8810 8811 8812 8813var rclass = /[\t\r\n\f]/g; 8814 8815function getClass( elem ) { 8816 return jQuery.attr( elem, "class" ) || ""; 8817} 8818 8819jQuery.fn.extend( { 8820 addClass: function( value ) { 8821 var classes, elem, cur, curValue, clazz, j, finalValue, 8822 i = 0; 8823 8824 if ( jQuery.isFunction( value ) ) { 8825 return this.each( function( j ) { 8826 jQuery( this ).addClass( value.call( this, j, getClass( this ) ) ); 8827 } ); 8828 } 8829 8830 if ( typeof value === "string" && value ) { 8831 classes = value.match( rnotwhite ) || []; 8832 8833 while ( ( elem = this[ i++ ] ) ) { 8834 curValue = getClass( elem ); 8835 cur = elem.nodeType === 1 && 8836 ( " " + curValue + " " ).replace( rclass, " " ); 8837 8838 if ( cur ) { 8839 j = 0; 8840 while ( ( clazz = classes[ j++ ] ) ) { 8841 if ( cur.indexOf( " " + clazz + " " ) < 0 ) { 8842 cur += clazz + " "; 8843 } 8844 } 8845 8846 // only assign if different to avoid unneeded rendering. 8847 finalValue = jQuery.trim( cur ); 8848 if ( curValue !== finalValue ) { 8849 jQuery.attr( elem, "class", finalValue ); 8850 } 8851 } 8852 } 8853 } 8854 8855 return this; 8856 }, 8857 8858 removeClass: function( value ) { 8859 var classes, elem, cur, curValue, clazz, j, finalValue, 8860 i = 0; 8861 8862 if ( jQuery.isFunction( value ) ) { 8863 return this.each( function( j ) { 8864 jQuery( this ).removeClass( value.call( this, j, getClass( this ) ) ); 8865 } ); 8866 } 8867 8868 if ( !arguments.length ) { 8869 return this.attr( "class", "" ); 8870 } 8871 8872 if ( typeof value === "string" && value ) { 8873 classes = value.match( rnotwhite ) || []; 8874 8875 while ( ( elem = this[ i++ ] ) ) { 8876 curValue = getClass( elem ); 8877 8878 // This expression is here for better compressibility (see addClass) 8879 cur = elem.nodeType === 1 && 8880 ( " " + curValue + " " ).replace( rclass, " " ); 8881 8882 if ( cur ) { 8883 j = 0; 8884 while ( ( clazz = classes[ j++ ] ) ) { 8885
8886 // Remove *all* instances 8887 while ( cur.indexOf( " " + clazz + " " ) > -1 ) { 8888 cur = cur.replace( " " + clazz + " ", " " ); 8889 } 8890 } 8891 8892 // Only assign if different to avoid unneeded rendering. 8893 finalValue = jQuery.trim( cur ); 8894 if ( curValue !== finalValue ) { 8895 jQuery.attr( elem, "class", finalValue ); 8896 } 8897 } 8898 } 8899 } 8900 8901 return this; 8902 }, 8903 8904 toggleClass: function( value, stateVal ) { 8905 var type = typeof value; 8906 8907 if ( typeof stateVal === "boolean" && type === "string" ) { 8908 return stateVal ? this.addClass( value ) : this.removeClass( value ); 8909 } 8910 8911 if ( jQuery.isFunction( value ) ) { 8912 return this.each( function( i ) { 8913 jQuery( this ).toggleClass( 8914 value.call( this, i, getClass( this ), stateVal ), 8915 stateVal 8916 ); 8917 } ); 8918 } 8919 8920 return this.each( function() { 8921 var className, i, self, classNames; 8922 8923 if ( type === "string" ) { 8924 8925 // Toggle individual class names 8926 i = 0; 8927 self = jQuery( this ); 8928 classNames = value.match( rnotwhite ) || []; 8929 8930 while ( ( className = classNames[ i++ ] ) ) { 8931 8932 // Check each className given, space separated list 8933 if ( self.hasClass( className ) ) { 8934 self.removeClass( className ); 8935 } else { 8936 self.addClass( className ); 8937 } 8938 } 8939 8940 // Toggle whole class name 8941 } else if ( value === undefined || type === "boolean" ) { 8942 className = getClass( this ); 8943 if ( className ) { 8944 8945 // store className if set 8946 jQuery._data( this, "__className__", className ); 8947 } 8948 8949 // If the element has a class name or if we're passed "false", 8950 // then remove the whole classname (if there was one, the above saved it). 8951 // Otherwise bring back whatever was previously saved (if anything), 8952 // falling back to the empty string if nothing was stored. 8953 jQuery.attr( this, "class", 8954 className || value === false ? 8955 "" : 8956 jQuery._data( this, "__className__" ) || "" 8957 ); 8958 } 8959 } ); 8960 }, 8961 8962 hasClass: function( selector ) { 8963 var className, elem, 8964 i = 0; 8965 8966 className = " " + selector + " "; 8967 while ( ( elem = this[ i++ ] ) ) { 8968 if ( elem.nodeType === 1 && 8969 ( " " + getClass( elem ) + " " ).replace( rclass, " " ) 8970 .indexOf( className ) > -1 8971 ) { 8972 return true; 8973 } 8974 } 8975 8976 return false; 8977 } 8978} ); 8979 8980 8981 8982 8983// Return jQuery for attributes-only inclusion 8984 8985 8986jQuery.each( ( "blur focus focusin focusout load resize scroll unload click dblclick " + 8987 "mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave " + 8988 "change select submit keydown keypress keyup error contextmenu" ).split( " " ), 8989 function( i, name ) { 8990 8991 // Handle event binding 8992 jQuery.fn[ name ] = function( data, fn ) { 8993 return arguments.length > 0 ? 8994 this.on( name, null, data, fn ) : 8995 this.trigger( name ); 8996 }; 8997} ); 8998 8999jQuery.fn.extend( { 9000 hover: function( fnOver, fnOut ) { 9001 return this.mouseenter( fnOver ).mouseleave( fnOut || fnOver ); 9002 } 9003} ); 9004 9005 9006var location = window.location; 9007 9008var nonce = jQuery.now(); 9009 9010var rquery = ( /\?/ ); 9011 9012 9013 9014var rvalidtokens = /(,)|(\[|{)|(}|])|"(?:[^"\\\r\n]|\\["\\\/bfnrt]|\\u[\da-fA-F]{4})*"\s*:?|true|false|null|-?(?!0\d)\d+(?:\.\d+|)(?:[eE][+-]?\d+|)/g; 9015 9016jQuery.parseJSON = function( data ) { 9017 9018 // Attempt to parse using the native JSON parser first 9019 if ( window.JSON && window.JSON.parse ) { 9020 9021 // Support: Android 2.3 9022 // Workaround failure to string-cast null input 9023 return window.JSON.parse( data + "" ); 9024 } 9025 9026 var requireNonComma, 9027 depth = null, 9028 str = jQuery.trim( data + "" ); 9029 9030 // Guard against invalid (and possibly dangerous) input by ensuring that nothing remains 9031 // after removing valid tokens 9032 return str && !jQuery.trim( str.replace( rvalidtokens, function( token, comma, open, close ) { 9033 9034 // Force termination if we see a misplaced comma 9035 if ( requireNonComma && comma ) { 9036 depth = 0; 9037 } 9038 9039 // Perform no more replacements after returning to outermost depth 9040 if ( depth === 0 ) { 9041 return token; 9042 } 9043 9044 // Commas must not follow "[", "{", or "," 9045 requireNonComma = open || comma; 9046 9047 // Determine new depth 9048 // array/object open ("[" or "{"): depth += true - false (increment) 9049 // array/object close ("]" or "}"): depth += false - true (decrement) 9050 // other cases ("," or primitive): depth += true - true (numeric cast) 9051 depth += !close - !open; 9052 9053 // Remove this token 9054 return ""; 9055 } ) ) ? 9056 ( Function( "return " + str ) )() : 9057 jQuery.error( "Invalid JSON: " + data ); 9058}; 9059 9060 9061// Cross-browser xml parsing
9062jQuery.parseXML = function( data ) { 9063 var xml, tmp; 9064 if ( !data || typeof data !== "string" ) { 9065 return null; 9066 } 9067 try { 9068 if ( window.DOMParser ) { // Standard 9069 tmp = new window.DOMParser(); 9070 xml = tmp.parseFromString( data, "text/xml" ); 9071 } else { // IE 9072 xml = new window.ActiveXObject( "Microsoft.XMLDOM" ); 9073 xml.async = "false"; 9074 xml.loadXML( data ); 9075 } 9076 } catch ( e ) { 9077 xml = undefined; 9078 } 9079 if ( !xml || !xml.documentElement || xml.getElementsByTagName( "parsererror" ).length ) { 9080 jQuery.error( "Invalid XML: " + data ); 9081 } 9082 return xml; 9083}; 9084 9085 9086var 9087 rhash = /#.*$/, 9088 rts = /([?&])_=[^&]*/, 9089 9090 // IE leaves an \r character at EOL 9091 rheaders = /^(.*?):[ \t]*([^\r\n]*)\r?$/mg, 9092 9093 // #7653, #8125, #8152: local protocol detection 9094 rlocalProtocol = /^(?:about|app|app-storage|.+-extension|file|res|widget):$/, 9095 rnoContent = /^(?:GET|HEAD)$/, 9096 rprotocol = /^\/\//, 9097 rurl = /^([\w.+-]+:)(?:\/\/(?:[^\/?#]*@|)([^\/?#:]*)(?::(\d+)|)|)/, 9098 9099 /* Prefilters 9100 * 1) They are useful to introduce custom dataTypes (see ajax/jsonp.js for an example) 9101 * 2) These are called: 9102 * - BEFORE asking for a transport 9103 * - AFTER param serialization (s.data is a string if s.processData is true) 9104 * 3) key is the dataType 9105 * 4) the catchall symbol "*" can be used 9106 * 5) execution will start with transport dataType and THEN continue down to "*" if needed 9107 */ 9108 prefilters = {}, 9109 9110 /* Transports bindings 9111 * 1) key is the dataType 9112 * 2) the catchall symbol "*" can be used 9113 * 3) selection will start with transport dataType and THEN go to "*" if needed 9114 */ 9115 transports = {}, 9116 9117 // Avoid comment-prolog char sequence (#10098); must appease lint and evade compression 9118 allTypes = "*/".concat( "*" ), 9119 9120 // Document location 9121 ajaxLocation = location.href, 9122 9123 // Segment location into parts 9124 ajaxLocParts = rurl.exec( ajaxLocation.toLowerCase() ) || []; 9125 9126// Base "constructor" for jQuery.ajaxPrefilter and jQuery.ajaxTransport 9127function addToPrefiltersOrTransports( structure ) { 9128 9129 // dataTypeExpression is optional and defaults to "*" 9130 return function( dataTypeExpression, func ) { 9131 9132 if ( typeof dataTypeExpression !== "string" ) { 9133 func = dataTypeExpression; 9134 dataTypeExpression = "*"; 9135 } 9136 9137 var dataType, 9138 i = 0, 9139 dataTypes = dataTypeExpression.toLowerCase().match( rnotwhite ) || []; 9140 9141 if ( jQuery.isFunction( func ) ) { 9142 9143 // For each dataType in the dataTypeExpression 9144 while ( ( dataType = dataTypes[ i++ ] ) ) { 9145 9146 // Prepend if requested 9147 if ( dataType.charAt( 0 ) === "+" ) { 9148 dataType = dataType.slice( 1 ) || "*"; 9149 ( structure[ dataType ] = structure[ dataType ] || [] ).unshift( func ); 9150 9151 // Otherwise append 9152 } else { 9153 ( structure[ dataType ] = structure[ dataType ] || [] ).push( func ); 9154 } 9155 } 9156 } 9157 }; 9158} 9159 9160// Base inspection function for prefilters and transports 9161function inspectPrefiltersOrTransports( structure, options, originalOptions, jqXHR ) { 9162 9163 var inspected = {}, 9164 seekingTransport = ( structure === transports ); 9165 9166 function inspect( dataType ) { 9167 var selected; 9168 inspected[ dataType ] = true; 9169 jQuery.each( structure[ dataType ] || [], function( _, prefilterOrFactory ) { 9170 var dataTypeOrTransport = prefilterOrFactory( options, originalOptions, jqXHR ); 9171 if ( typeof dataTypeOrTransport === "string" && 9172 !seekingTransport && !inspected[ dataTypeOrTransport ] ) { 9173 9174 options.dataTypes.unshift( dataTypeOrTransport ); 9175 inspect( dataTypeOrTransport ); 9176 return false; 9177 } else if ( seekingTransport ) { 9178 return !( selected = dataTypeOrTransport ); 9179 } 9180 } ); 9181 return selected; 9182 } 9183 9184 return inspect( options.dataTypes[ 0 ] ) || !inspected[ "*" ] && inspect( "*" ); 9185} 9186 9187// A special extend for ajax options 9188// that takes "flat" options (not to be deep extended) 9189// Fixes #9887 9190function ajaxExtend( target, src ) { 9191 var deep, key, 9192 flatOptions = jQuery.ajaxSettings.flatOptions || {}; 9193 9194 for ( key in src ) { 9195 if ( src[ key ] !== undefined ) { 9196 ( flatOptions[ key ] ? target : ( deep || ( deep = {} ) ) )[ key ] = src[ key ]; 9197 } 9198 } 9199 if ( deep ) { 9200 jQuery.extend( true, target, deep ); 9201 } 9202 9203 return target; 9204} 9205 9206/* Handles responses to an ajax request: 9207 * - finds the right dataType (mediates between content-type and expected dataType) 9208 * - returns the corresponding response 9209 */ 9210function ajaxHandleResponses( s, jqXHR, responses ) { 9211 var firstDataType, ct, finalDataType, type, 9212 contents = s.contents, 9213 dataTypes = s.dataTypes; 9214 9215 // Remove auto dataType and get content-type in the process 9216 while ( dataTypes[ 0 ] === "*" ) { 9217 dataTypes.shift(); 9218 if ( ct === undefined ) { 9219 ct = s.mimeType || jqXHR.getResponseHeader( "Content-Type" ); 9220 } 9221 } 9222 9223 // Check if we're dealing with a known content-type 9224 if ( ct ) { 9225 for ( type in contents ) { 9226 if ( contents[ type ] && contents[ type ].test( ct ) ) { 9227 dataTypes.unshift( type ); 9228 break; 9229 } 9230 } 9231 } 9232 9233 // Check to see if we have a response for the expected dataType 9234 if ( dataTypes[ 0 ] in responses ) { 9235 finalDataType = dataTypes[ 0 ]; 9236 } else { 9237
vendor: 5,407 bytes, lines 9238-9467
9238 // Try convertible dataTypes 9239 for ( type in responses ) { 9240 if ( !dataTypes[ 0 ] || s.converters[ type + " " + dataTypes[ 0 ] ] ) { 9241 finalDataType = type; 9242 break; 9243 } 9244 if ( !firstDataType ) { 9245 firstDataType = type; 9246 } 9247 } 9248 9249 // Or just use first one 9250 finalDataType = finalDataType || firstDataType; 9251 } 9252 9253 // If we found a dataType 9254 // We add the dataType to the list if needed 9255 // and return the corresponding response 9256 if ( finalDataType ) { 9257 if ( finalDataType !== dataTypes[ 0 ] ) { 9258 dataTypes.unshift( finalDataType ); 9259 } 9260 return responses[ finalDataType ]; 9261 } 9262} 9263 9264/* Chain conversions given the request and the original response 9265 * Also sets the responseXXX fields on the jqXHR instance 9266 */ 9267function ajaxConvert( s, response, jqXHR, isSuccess ) { 9268 var conv2, current, conv, tmp, prev, 9269 converters = {}, 9270 9271 // Work with a copy of dataTypes in case we need to modify it for conversion 9272 dataTypes = s.dataTypes.slice(); 9273 9274 // Create converters map with lowercased keys 9275 if ( dataTypes[ 1 ] ) { 9276 for ( conv in s.converters ) { 9277 converters[ conv.toLowerCase() ] = s.converters[ conv ]; 9278 } 9279 } 9280 9281 current = dataTypes.shift(); 9282 9283 // Convert to each sequential dataType 9284 while ( current ) { 9285 9286 if ( s.responseFields[ current ] ) { 9287 jqXHR[ s.responseFields[ current ] ] = response; 9288 } 9289 9290 // Apply the dataFilter if provided 9291 if ( !prev && isSuccess && s.dataFilter ) { 9292 response = s.dataFilter( response, s.dataType ); 9293 } 9294 9295 prev = current; 9296 current = dataTypes.shift(); 9297 9298 if ( current ) { 9299 9300 // There's only work to do if current dataType is non-auto 9301 if ( current === "*" ) { 9302 9303 current = prev; 9304 9305 // Convert response if prev dataType is non-auto and differs from current 9306 } else if ( prev !== "*" && prev !== current ) { 9307 9308 // Seek a direct converter 9309 conv = converters[ prev + " " + current ] || converters[ "* " + current ]; 9310 9311 // If none found, seek a pair 9312 if ( !conv ) { 9313 for ( conv2 in converters ) { 9314 9315 // If conv2 outputs current 9316 tmp = conv2.split( " " ); 9317 if ( tmp[ 1 ] === current ) { 9318 9319 // If prev can be converted to accepted input 9320 conv = converters[ prev + " " + tmp[ 0 ] ] || 9321 converters[ "* " + tmp[ 0 ] ]; 9322 if ( conv ) { 9323 9324 // Condense equivalence converters 9325 if ( conv === true ) { 9326 conv = converters[ conv2 ]; 9327 9328 // Otherwise, insert the intermediate dataType 9329 } else if ( converters[ conv2 ] !== true ) { 9330 current = tmp[ 0 ]; 9331 dataTypes.unshift( tmp[ 1 ] ); 9332 } 9333 break; 9334 } 9335 } 9336 } 9337 } 9338 9339 // Apply converter (if not an equivalence) 9340 if ( conv !== true ) { 9341 9342 // Unless errors are allowed to bubble, catch and return them 9343 if ( conv && s[ "throws" ] ) { // jscs:ignore requireDotNotation 9344 response = conv( response ); 9345 } else { 9346 try { 9347 response = conv( response ); 9348 } catch ( e ) { 9349 return { 9350 state: "parsererror", 9351 error: conv ? e : "No conversion from " + prev + " to " + current 9352 }; 9353 } 9354 } 9355 } 9356 } 9357 } 9358 } 9359 9360 return { state: "success", data: response }; 9361} 9362 9363jQuery.extend( { 9364 9365 // Counter for holding the number of active queries 9366 active: 0, 9367 9368 // Last-Modified header cache for next request 9369 lastModified: {}, 9370 etag: {}, 9371 9372 ajaxSettings: { 9373 url: ajaxLocation, 9374 type: "GET", 9375 isLocal: rlocalProtocol.test( ajaxLocParts[ 1 ] ), 9376 global: true, 9377 processData: true, 9378 async: true, 9379 contentType: "application/x-www-form-urlencoded; charset=UTF-8", 9380 /* 9381 timeout: 0, 9382 data: null, 9383 dataType: null, 9384 username: null, 9385 password: null, 9386 cache: null, 9387 throws: false, 9388 traditional: false, 9389 headers: {}, 9390 */ 9391 9392 accepts: { 9393 "*": allTypes, 9394 text: "text/plain", 9395 html: "text/html", 9396 xml: "application/xml, text/xml", 9397 json: "application/json, text/javascript" 9398 }, 9399 9400 contents: { 9401 xml: /\bxml\b/, 9402 html: /\bhtml/, 9403 json: /\bjson\b/ 9404 }, 9405 9406 responseFields: { 9407 xml: "responseXML", 9408 text: "responseText", 9409 json: "responseJSON" 9410 }, 9411 9412 // Data converters 9413 // Keys separate source (or catchall "*") and destination types with a single space 9414 converters: { 9415 9416 // Convert anything to text 9417 "* text": String, 9418 9419 // Text to html (true = no transformation) 9420 "text html": true, 9421 9422 // Evaluate text as a json expression 9423 "text json": jQuery.parseJSON, 9424 9425 // Parse text as xml 9426 "text xml": jQuery.parseXML 9427 }, 9428 9429 // For options that shouldn't be deep extended: 9430 // you can add your own custom options here if 9431 // and when you create one that shouldn't be 9432 // deep extended (see ajaxExtend) 9433 flatOptions: { 9434 url: true, 9435 context: true 9436 } 9437 }, 9438 9439 // Creates a full fledged settings object into target 9440 // with both ajaxSettings and settings fields. 9441 // If target is omitted, writes into ajaxSettings. 9442 ajaxSetup: function( target, settings ) { 9443 return settings ? 9444 9445 // Building a settings object 9446 ajaxExtend( ajaxExtend( target, jQuery.ajaxSettings ), settings ) : 9447 9448 // Extending ajaxSettings 9449 ajaxExtend( jQuery.ajaxSettings, target ); 9450 }, 9451 9452 ajaxPrefilter: addToPrefiltersOrTransports( prefilters ), 9453 ajaxTransport: addToPrefiltersOrTransports( transports ), 9454 9455 // Main method 9456 ajax: function( url, options ) { 9457 9458 // If url is an object, simulate pre-1.5 signature 9459 if ( typeof url === "object" ) { 9460 options = url; 9461 url = undefined; 9462 } 9463 9464 // Force options to be an object 9465 options = options || {}; 9466 9467 var
9468 9469 // Cross-domain detection vars 9470 parts, 9471 9472 // Loop variable 9473 i, 9474 9475 // URL without anti-cache param 9476 cacheURL, 9477 9478 // Response headers as string 9479 responseHeadersString, 9480 9481 // timeout handle 9482 timeoutTimer, 9483 9484 // To know if global events are to be dispatched 9485 fireGlobals, 9486 9487 transport, 9488 9489 // Response headers 9490 responseHeaders, 9491 9492 // Create the final options object 9493 s = jQuery.ajaxSetup( {}, options ), 9494 9495 // Callbacks context 9496 callbackContext = s.context || s, 9497 9498 // Context for global events is callbackContext if it is a DOM node or jQuery collection 9499 globalEventContext = s.context && 9500 ( callbackContext.nodeType || callbackContext.jquery ) ? 9501 jQuery( callbackContext ) : 9502 jQuery.event, 9503 9504 // Deferreds 9505 deferred = jQuery.Deferred(), 9506 completeDeferred = jQuery.Callbacks( "once memory" ), 9507 9508 // Status-dependent callbacks 9509 statusCode = s.statusCode || {}, 9510 9511 // Headers (they are sent all at once) 9512 requestHeaders = {}, 9513 requestHeadersNames = {}, 9514 9515 // The jqXHR state 9516 state = 0, 9517 9518 // Default abort message 9519 strAbort = "canceled", 9520 9521 // Fake xhr 9522 jqXHR = { 9523 readyState: 0, 9524 9525 // Builds headers hashtable if needed 9526 getResponseHeader: function( key ) { 9527 var match; 9528 if ( state === 2 ) { 9529 if ( !responseHeaders ) { 9530 responseHeaders = {}; 9531 while ( ( match = rheaders.exec( responseHeadersString ) ) ) { 9532 responseHeaders[ match[ 1 ].toLowerCase() ] = match[ 2 ]; 9533 } 9534 } 9535 match = responseHeaders[ key.toLowerCase() ]; 9536 } 9537 return match == null ? null : match; 9538 }, 9539 9540 // Raw string 9541 getAllResponseHeaders: function() { 9542 return state === 2 ? responseHeadersString : null; 9543 }, 9544 9545 // Caches the header 9546 setRequestHeader: function( name, value ) { 9547 var lname = name.toLowerCase(); 9548 if ( !state ) { 9549 name = requestHeadersNames[ lname ] = requestHeadersNames[ lname ] || name; 9550 requestHeaders[ name ] = value; 9551 } 9552 return this; 9553 }, 9554 9555 // Overrides response content-type header 9556 overrideMimeType: function( type ) { 9557 if ( !state ) { 9558 s.mimeType = type; 9559 } 9560 return this; 9561 }, 9562 9563 // Status-dependent callbacks 9564 statusCode: function( map ) { 9565 var code; 9566 if ( map ) { 9567 if ( state < 2 ) { 9568 for ( code in map ) { 9569 9570 // Lazy-add the new callback in a way that preserves old ones 9571 statusCode[ code ] = [ statusCode[ code ], map[ code ] ]; 9572 } 9573 } else { 9574 9575 // Execute the appropriate callbacks 9576 jqXHR.always( map[ jqXHR.status ] ); 9577 } 9578 } 9579 return this; 9580 }, 9581 9582 // Cancel the request 9583 abort: function( statusText ) { 9584 var finalText = statusText || strAbort; 9585 if ( transport ) { 9586 transport.abort( finalText ); 9587 } 9588 done( 0, finalText ); 9589 return this; 9590 } 9591 }; 9592 9593 // Attach deferreds 9594 deferred.promise( jqXHR ).complete = completeDeferred.add; 9595 jqXHR.success = jqXHR.done; 9596 jqXHR.error = jqXHR.fail; 9597 9598 // Remove hash character (#7531: and string promotion) 9599 // Add protocol if not provided (#5866: IE7 issue with protocol-less urls) 9600 // Handle falsy url in the settings object (#10093: consistency with old signature) 9601 // We also use the url parameter if available 9602 s.url = ( ( url || s.url || ajaxLocation ) + "" ) 9603 .replace( rhash, "" ) 9604 .replace( rprotocol, ajaxLocParts[ 1 ] + "//" ); 9605 9606 // Alias method option to type as per ticket #12004 9607 s.type = options.method || options.type || s.method || s.type; 9608 9609 // Extract dataTypes list 9610 s.dataTypes = jQuery.trim( s.dataType || "*" ).toLowerCase().match( rnotwhite ) || [ "" ]; 9611 9612 // A cross-domain request is in order when we have a protocol:host:port mismatch 9613 if ( s.crossDomain == null ) { 9614 parts = rurl.exec( s.url.toLowerCase() ); 9615 s.crossDomain = !!( parts && 9616 ( parts[ 1 ] !== ajaxLocParts[ 1 ] || parts[ 2 ] !== ajaxLocParts[ 2 ] || 9617 ( parts[ 3 ] || ( parts[ 1 ] === "http:" ? "80" : "443" ) ) !== 9618 ( ajaxLocParts[ 3 ] || ( ajaxLocParts[ 1 ] === "http:" ? "80" : "443" ) ) ) 9619 ); 9620 } 9621 9622 // Convert data if not already a string 9623 if ( s.data && s.processData && typeof s.data !== "string" ) { 9624 s.data = jQuery.param( s.data, s.traditional ); 9625 } 9626 9627 // Apply prefilters 9628 inspectPrefiltersOrTransports( prefilters, s, options, jqXHR ); 9629 9630 // If request was aborted inside a prefilter, stop there 9631 if ( state === 2 ) { 9632 return jqXHR; 9633 } 9634 9635 // We can fire global events as of now if asked to 9636 // Don't fire events if jQuery.event is undefined in an AMD-usage scenario (#15118) 9637 fireGlobals = jQuery.event && s.global; 9638 9639 // Watch for a new set of requests 9640 if ( fireGlobals && jQuery.active++ === 0 ) { 9641 jQuery.event.trigger( "ajaxStart" ); 9642 } 9643 9644 // Uppercase the type 9645 s.type = s.type.toUpperCase(); 9646 9647 // Determine if request has content 9648 s.hasContent = !rnoContent.test( s.type ); 9649 9650 // Save the URL in case we're toying with the If-Modified-Since 9651 // and/or If-None-Match header later on 9652 cacheURL = s.url; 9653 9654 // More options handling for requests with no content 9655 if ( !s.hasContent ) { 9656 9657 // If data is available, append data to url 9658 if ( s.data ) {
9659 cacheURL = ( s.url += ( rquery.test( cacheURL ) ? "&" : "?" ) + s.data ); 9660 9661 // #9682: remove data so that it's not used in an eventual retry 9662 delete s.data; 9663 } 9664 9665 // Add anti-cache in url if needed 9666 if ( s.cache === false ) { 9667 s.url = rts.test( cacheURL ) ? 9668 9669 // If there is already a '_' parameter, set its value 9670 cacheURL.replace( rts, "$1_=" + nonce++ ) : 9671 9672 // Otherwise add one to the end 9673 cacheURL + ( rquery.test( cacheURL ) ? "&" : "?" ) + "_=" + nonce++; 9674 } 9675 } 9676 9677 // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode. 9678 if ( s.ifModified ) { 9679 if ( jQuery.lastModified[ cacheURL ] ) { 9680 jqXHR.setRequestHeader( "If-Modified-Since", jQuery.lastModified[ cacheURL ] ); 9681 } 9682 if ( jQuery.etag[ cacheURL ] ) { 9683 jqXHR.setRequestHeader( "If-None-Match", jQuery.etag[ cacheURL ] ); 9684 } 9685 } 9686 9687 // Set the correct header, if data is being sent 9688 if ( s.data && s.hasContent && s.contentType !== false || options.contentType ) { 9689 jqXHR.setRequestHeader( "Content-Type", s.contentType ); 9690 } 9691 9692 // Set the Accepts header for the server, depending on the dataType 9693 jqXHR.setRequestHeader( 9694 "Accept", 9695 s.dataTypes[ 0 ] && s.accepts[ s.dataTypes[ 0 ] ] ? 9696 s.accepts[ s.dataTypes[ 0 ] ] + 9697 ( s.dataTypes[ 0 ] !== "*" ? ", " + allTypes + "; q=0.01" : "" ) : 9698 s.accepts[ "*" ] 9699 ); 9700 9701 // Check for headers option 9702 for ( i in s.headers ) { 9703 jqXHR.setRequestHeader( i, s.headers[ i ] ); 9704 } 9705 9706 // Allow custom headers/mimetypes and early abort 9707 if ( s.beforeSend && 9708 ( s.beforeSend.call( callbackContext, jqXHR, s ) === false || state === 2 ) ) { 9709 9710 // Abort if not done already and return 9711 return jqXHR.abort(); 9712 } 9713 9714 // aborting is no longer a cancellation 9715 strAbort = "abort"; 9716 9717 // Install callbacks on deferreds 9718 for ( i in { success: 1, error: 1, complete: 1 } ) { 9719 jqXHR[ i ]( s[ i ] ); 9720 } 9721 9722 // Get transport 9723 transport = inspectPrefiltersOrTransports( transports, s, options, jqXHR ); 9724 9725 // If no transport, we auto-abort 9726 if ( !transport ) { 9727 done( -1, "No Transport" ); 9728 } else { 9729 jqXHR.readyState = 1; 9730 9731 // Send global event 9732 if ( fireGlobals ) { 9733 globalEventContext.trigger( "ajaxSend", [ jqXHR, s ] ); 9734 } 9735 9736 // If request was aborted inside ajaxSend, stop there 9737 if ( state === 2 ) { 9738 return jqXHR; 9739 } 9740 9741 // Timeout 9742 if ( s.async && s.timeout > 0 ) { 9743 timeoutTimer = window.setTimeout( function() { 9744 jqXHR.abort( "timeout" ); 9745 }, s.timeout ); 9746 } 9747 9748 try { 9749 state = 1; 9750 transport.send( requestHeaders, done ); 9751 } catch ( e ) { 9752 9753 // Propagate exception as error if not done 9754 if ( state < 2 ) { 9755 done( -1, e ); 9756 9757 // Simply rethrow otherwise 9758 } else { 9759 throw e; 9760 } 9761 } 9762 } 9763 9764 // Callback for when everything is done 9765 function done( status, nativeStatusText, responses, headers ) { 9766 var isSuccess, success, error, response, modified, 9767 statusText = nativeStatusText; 9768 9769 // Called once 9770 if ( state === 2 ) { 9771 return; 9772 } 9773 9774 // State is "done" now 9775 state = 2; 9776 9777 // Clear timeout if it exists 9778 if ( timeoutTimer ) { 9779 window.clearTimeout( timeoutTimer ); 9780 } 9781 9782 // Dereference transport for early garbage collection 9783 // (no matter how long the jqXHR object will be used) 9784 transport = undefined; 9785 9786 // Cache response headers 9787 responseHeadersString = headers || ""; 9788 9789 // Set readyState 9790 jqXHR.readyState = status > 0 ? 4 : 0; 9791 9792 // Determine if successful 9793 isSuccess = status >= 200 && status < 300 || status === 304; 9794 9795 // Get response data 9796 if ( responses ) { 9797 response = ajaxHandleResponses( s, jqXHR, responses ); 9798 } 9799 9800 // Convert no matter what (that way responseXXX fields are always set) 9801 response = ajaxConvert( s, response, jqXHR, isSuccess ); 9802 9803 // If successful, handle type chaining 9804 if ( isSuccess ) { 9805 9806 // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode. 9807 if ( s.ifModified ) { 9808 modified = jqXHR.getResponseHeader( "Last-Modified" ); 9809 if ( modified ) { 9810 jQuery.lastModified[ cacheURL ] = modified; 9811 } 9812 modified = jqXHR.getResponseHeader( "etag" ); 9813 if ( modified ) { 9814 jQuery.etag[ cacheURL ] = modified; 9815 } 9816 } 9817 9818 // if no content 9819 if ( status === 204 || s.type === "HEAD" ) { 9820 statusText = "nocontent"; 9821 9822 // if not modified 9823 } else if ( status === 304 ) { 9824 statusText = "notmodified"; 9825 9826 // If we have data, let's convert it 9827 } else { 9828 statusText = response.state; 9829 success = response.data; 9830 error = response.error; 9831 isSuccess = !error; 9832 } 9833 } else { 9834 9835 // We extract error from statusText 9836 // then normalize statusText and status for non-aborts 9837 error = statusText; 9838 if ( status || !statusText ) { 9839 statusText = "error"; 9840 if ( status < 0 ) { 9841 status = 0; 9842 } 9843 } 9844 } 9845 9846 // Set data for the fake xhr object 9847 jqXHR.status = status; 9848 jqXHR.statusText = ( nativeStatusText || statusText ) + ""; 9849 9850 // Success/Error 9851 if ( isSuccess ) { 9852 deferred.resolveWith( callbackContext, [ success, statusText, jqXHR ] ); 9853 } else { 9854 deferred.rejectWith( callbackContext, [ jqXHR, statusText, error ] ); 9855 } 9856 9857 // Status-dependent callbacks 9858 jqXHR.statusCode( statusCode ); 9859 statusCode = undefined; 9860 9861 if ( fireGlobals ) { 9862 globalEventContext.trigger( isSuccess ? "ajaxSuccess" : "ajaxError", 9863 [ jqXHR, s, isSuccess ? success : error ] ); 9864 } 9865 9866 // Complete 9867 completeDeferred.fireWith( callbackContext, [ jqXHR, statusText ] ); 9868 9869 if ( fireGlobals ) { 9870 globalEventContext.trigger( "ajaxComplete", [ jqXHR, s ] ); 9871 9872 // Handle the global AJAX counter 9873 if ( !( --jQuery.active ) ) { 9874 jQuery.event.trigger( "ajaxStop" ); 9875 } 9876 } 9877 } 9878 9879 return jqXHR; 9880 }, 9881 9882 getJSON: function( url, data, callback ) { 9883 return jQuery.get( url, data, callback, "json" ); 9884 }, 9885 9886 getScript: function( url, callback ) { 9887 return jQuery.get( url, undefined, callback, "script" ); 9888 } 9889} ); 9890 9891jQuery.each( [ "get", "post" ], function( i, method ) { 9892 jQuery[ method ] = function( url, data, callback, type ) { 9893 9894 // shift arguments if data argument was omitted 9895 if ( jQuery.isFunction( data ) ) { 9896 type = type || callback; 9897 callback = data; 9898 data = undefined; 9899 } 9900 9901 // The url can be an options object (which then must have .url) 9902 return jQuery.ajax( jQuery.extend( { 9903 url: url, 9904 type: method, 9905 dataType: type, 9906 data: data, 9907 success: callback 9908 }, jQuery.isPlainObject( url ) && url ) ); 9909 }; 9910} ); 9911 9912 9913jQuery._evalUrl = function( url ) { 9914 return jQuery.ajax( { 9915 url: url, 9916 9917 // Make this explicit, since user can override this through ajaxSetup (#11264) 9918 type: "GET", 9919 dataType: "script", 9920 cache: true, 9921 async: false, 9922 global: false, 9923 "throws": true 9924 } ); 9925}; 9926 9927 9928jQuery.fn.extend( { 9929 wrapAll: function( html ) { 9930 if ( jQuery.isFunction( html ) ) { 9931 return this.each( function( i ) { 9932 jQuery( this ).wrapAll( html.call( this, i ) ); 9933 } ); 9934 } 9935 9936 if ( this[ 0 ] ) { 9937 9938 // The elements to wrap the target around 9939 var wrap = jQuery( html, this[ 0 ].ownerDocument ).eq( 0 ).clone( true ); 9940 9941 if ( this[ 0 ].parentNode ) { 9942 wrap.insertBefore( this[ 0 ] ); 9943 } 9944 9945 wrap.map( function() { 9946 var elem = this; 9947 9948 while ( elem.firstChild && elem.firstChild.nodeType === 1 ) { 9949 elem = elem.firstChild; 9950 } 9951 9952 return elem; 9953 } ).append( this ); 9954 } 9955 9956 return this; 9957 }, 9958 9959 wrapInner: function( html ) { 9960 if ( jQuery.isFunction( html ) ) { 9961 return this.each( function( i ) { 9962 jQuery( this ).wrapInner( html.call( this, i ) ); 9963 } ); 9964 } 9965 9966 return this.each( function() { 9967 var self = jQuery( this ), 9968 contents = self.contents(); 9969 9970 if ( contents.length ) { 9971 contents.wrapAll( html ); 9972 9973 } else { 9974 self.append( html ); 9975 } 9976 } ); 9977 }, 9978 9979 wrap: function( html ) { 9980 var isFunction = jQuery.isFunction( html ); 9981 9982 return this.each( function( i ) { 9983 jQuery( this ).wrapAll( isFunction ? html.call( this, i ) : html ); 9984 } ); 9985 }, 9986 9987 unwrap: function() { 9988 return this.parent().each( function() { 9989 if ( !jQuery.nodeName( this, "body" ) ) { 9990 jQuery( this ).replaceWith( this.childNodes ); 9991 } 9992 } ).end(); 9993 } 9994} ); 9995 9996 9997function getDisplay( elem ) { 9998 return elem.style && elem.style.display || jQuery.css( elem, "dis
9998play" ); 9999} 10000 10001function filterHidden( elem ) { 10002 while ( elem && elem.nodeType === 1 ) { 10003 if ( getDisplay( elem ) === "none" || elem.type === "hidden" ) { 10004 return true; 10005 } 10006 elem = elem.parentNode; 10007 } 10008 return false; 10009} 10010 10011jQuery.expr.filters.hidden = function( elem ) { 10012 10013 // Support: Opera <= 12.12 10014 // Opera reports offsetWidths and offsetHeights less than zero on some elements 10015 return support.reliableHiddenOffsets() ? 10016 ( elem.offsetWidth <= 0 && elem.offsetHeight <= 0 && 10017 !elem.getClientRects().length ) : 10018 filterHidden( elem ); 10019}; 10020 10021jQuery.expr.filters.visible = function( elem ) { 10022 return !jQuery.expr.filters.hidden( elem ); 10023}; 10024 10025 10026 10027 10028var r20 = /%20/g, 10029 rbracket = /\[\]$/, 10030 rCRLF = /\r?\n/g, 10031 rsubmitterTypes = /^(?:submit|button|image|reset|file)$/i, 10032 rsubmittable = /^(?:input|select|textarea|keygen)/i; 10033 10034function buildParams( prefix, obj, traditional, add ) { 10035 var name; 10036 10037 if ( jQuery.isArray( obj ) ) { 10038 10039 // Serialize array item. 10040 jQuery.each( obj, function( i, v ) { 10041 if ( traditional || rbracket.test( prefix ) ) { 10042 10043 // Treat each array item as a scalar. 10044 add( prefix, v ); 10045 10046 } else { 10047 10048 // Item is non-scalar (array or object), encode its numeric index. 10049 buildParams( 10050 prefix + "[" + ( typeof v === "object" && v != null ? i : "" ) + "]", 10051 v, 10052 traditional, 10053 add 10054 ); 10055 } 10056 } ); 10057 10058 } else if ( !traditional && jQuery.type( obj ) === "object" ) { 10059 10060 // Serialize object item. 10061 for ( name in obj ) { 10062 buildParams( prefix + "[" + name + "]", obj[ name ], traditional, add ); 10063 } 10064 10065 } else { 10066 10067 // Serialize scalar item. 10068 add( prefix, obj ); 10069 } 10070} 10071 10072// Serialize an array of form elements or a set of 10073// key/values into a query string 10074jQuery.param = function( a, traditional ) { 10075 var prefix, 10076 s = [], 10077 add = function( key, value ) { 10078 10079 // If value is a function, invoke it and return its value 10080 value = jQuery.isFunction( value ) ? value() : ( value == null ? "" : value ); 10081 s[ s.length ] = encodeURIComponent( key ) + "=" + encodeURIComponent( value ); 10082 }; 10083 10084 // Set traditional to true for jQuery <= 1.3.2 behavior. 10085 if ( traditional === undefined ) { 10086 traditional = jQuery.ajaxSettings && jQuery.ajaxSettings.traditional; 10087 } 10088 10089 // If an array was passed in, assume that it is an array of form elements. 10090 if ( jQuery.isArray( a ) || ( a.jquery && !jQuery.isPlainObject( a ) ) ) { 10091 10092 // Serialize the form elements 10093 jQuery.each( a, function() { 10094 add( this.name, this.value ); 10095 } ); 10096 10097 } else { 10098 10099 // If traditional, encode the "old" way (the way 1.3.2 or older 10100 // did it), otherwise encode params recursively. 10101 for ( prefix in a ) { 10102 buildParams( prefix, a[ prefix ], traditional, add ); 10103 } 10104 } 10105 10106 // Return the resulting serialization 10107 return s.join( "&" ).replace( r20, "+" ); 10108}; 10109 10110jQuery.fn.extend( { 10111 serialize: function() { 10112 return jQuery.param( this.serializeArray() ); 10113 }, 10114 serializeArray: function() { 10115 return this.map( function() { 10116 10117 // Can add propHook for "elements" to filter or add form elements 10118 var elements = jQuery.prop( this, "elements" ); 10119 return elements ? jQuery.makeArray( elements ) : this; 10120 } ) 10121 .filter( function() { 10122 var type = this.type; 10123 10124 // Use .is(":disabled") so that fieldset[disabled] works 10125 return this.name && !jQuery( this ).is( ":disabled" ) && 10126 rsubmittable.test( this.nodeName ) && !rsubmitterTypes.test( type ) && 10127 ( this.checked || !rcheckableType.test( type ) ); 10128 } ) 10129 .map( function( i, elem ) { 10130 var val = jQuery( this ).val(); 10131 10132 return val == null ? 10133 null : 10134 jQuery.isArray( val ) ? 10135 jQuery.map( val, function( val ) { 10136 return { name: elem.name, value: val.replace( rCRLF, "\r\n" ) }; 10137 } ) : 10138 { name: elem.name, value: val.replace( rCRLF, "\r\n" ) }; 10139 } ).get(); 10140 } 10141} ); 10142 10143 10144// Create the request object 10145// (This is still attached to ajaxSettings for backward compatibility) 10146jQuery.ajaxSettings.xhr = window.ActiveXObject !== undefined ? 10147 10148 // Support: IE6-IE8 10149 function() { 10150 10151 // XHR cannot access local files, always use ActiveX for that case 10152 if ( this.isLocal ) { 10153 return createActiveXHR(); 10154 } 10155 10156 // Support: IE 9-11 10157 // IE seems to error on cross-domain PATCH requests when ActiveX XHR 10158 // is used. In IE 9+ always use the native XHR. 10159 // Note: this condition won't catch Edge as it doesn't define 10160 // document.documentMode but it also doesn't support ActiveX so it won't 10161 // reach this code. 10162 if ( document.documentMode > 8 ) { 10163 return createStandardXHR(); 10164 } 10165
10166 // Support: IE<9 10167 // oldIE XHR does not support non-RFC2616 methods (#13240) 10168 // See http://msdn.microsoft.com/en-us/library/ie/ms536648(v=vs.85).aspx 10169 // and http://www.w3.org/Protocols/rfc2616/rfc2616-sec9.html#sec9 10170 // Although this check for six methods instead of eight 10171 // since IE also does not support "trace" and "connect" 10172 return /^(get|post|head|put|delete|options)$/i.test( this.type ) && 10173 createStandardXHR() || createActiveXHR(); 10174 } : 10175 10176 // For all other browsers, use the standard XMLHttpRequest object 10177 createStandardXHR; 10178 10179var xhrId = 0, 10180 xhrCallbacks = {}, 10181 xhrSupported = jQuery.ajaxSettings.xhr(); 10182 10183// Support: IE<10 10184// Open requests must be manually aborted on unload (#5280) 10185// See https://support.microsoft.com/kb/2856746 for more info 10186if ( window.attachEvent ) { 10187 window.attachEvent( "onunload", function() { 10188 for ( var key in xhrCallbacks ) { 10189 xhrCallbacks[ key ]( undefined, true ); 10190 } 10191 } ); 10192} 10193 10194// Determine support properties 10195support.cors = !!xhrSupported && ( "withCredentials" in xhrSupported ); 10196xhrSupported = support.ajax = !!xhrSupported; 10197 10198// Create transport if the browser can provide an xhr 10199if ( xhrSupported ) { 10200 10201 jQuery.ajaxTransport( function( options ) { 10202 10203 // Cross domain only allowed if supported through XMLHttpRequest 10204 if ( !options.crossDomain || support.cors ) { 10205 10206 var callback; 10207 10208 return { 10209 send: function( headers, complete ) { 10210 var i, 10211 xhr = options.xhr(), 10212 id = ++xhrId; 10213 10214 // Open the socket 10215 xhr.open( 10216 options.type, 10217 options.url, 10218 options.async, 10219 options.username, 10220 options.password 10221 ); 10222 10223 // Apply custom fields if provided 10224 if ( options.xhrFields ) { 10225 for ( i in options.xhrFields ) { 10226 xhr[ i ] = options.xhrFields[ i ]; 10227 } 10228 } 10229 10230 // Override mime type if needed 10231 if ( options.mimeType && xhr.overrideMimeType ) { 10232 xhr.overrideMimeType( options.mimeType ); 10233 } 10234 10235 // X-Requested-With header 10236 // For cross-domain requests, seeing as conditions for a preflight are 10237 // akin to a jigsaw puzzle, we simply never set it to be sure. 10238 // (it can always be set on a per-request basis or even using ajaxSetup)
10239 // For same-domain requests, won't change header if already provided. 10240 if ( !options.crossDomain && !headers[ "X-Requested-With" ] ) { 10241 headers[ "X-Requested-With" ] = "XMLHttpRequest"; 10242 } 10243 10244 // Set headers 10245 for ( i in headers ) { 10246 10247 // Support: IE<9 10248 // IE's ActiveXObject throws a 'Type Mismatch' exception when setting 10249 // request header to a null-value. 10250 // 10251 // To keep consistent with other XHR implementations, cast the value 10252 // to string and ignore `undefined`. 10253 if ( headers[ i ] !== undefined ) { 10254 xhr.setRequestHeader( i, headers[ i ] + "" ); 10255 } 10256 } 10257 10258 // Do send the request 10259 // This may raise an exception which is actually 10260 // handled in jQuery.ajax (so no try/catch here) 10261 xhr.send( ( options.hasContent && options.data ) || null ); 10262 10263 // Listener 10264 callback = function( _, isAbort ) { 10265 var status, statusText, responses; 10266 10267 // Was never called and is aborted or complete 10268 if ( callback && ( isAbort || xhr.readyState === 4 ) ) { 10269 10270 // Clean up 10271 delete xhrCallbacks[ id ]; 10272 callback = undefined; 10273 xhr.onreadystatechange = jQuery.noop; 10274 10275 // Abort manually if needed 10276 if ( isAbort ) { 10277 if ( xhr.readyState !== 4 ) { 10278 xhr.abort(); 10279 } 10280 } else { 10281 responses = {}; 10282 status = xhr.status; 10283 10284 // Support: IE<10 10285 // Accessing binary-data responseText throws an exception 10286 // (#11426) 10287 if ( typeof xhr.responseText === "string" ) { 10288 responses.text = xhr.responseText; 10289 } 10290 10291 // Firefox throws an exception when accessing 10292 // statusText for faulty cross-domain requests 10293 try { 10294 statusText = xhr.statusText; 10295 } catch ( e ) { 10296 10297 // We normalize with Webkit giving an empty statusText 10298 statusText = ""; 10299 } 10300 10301 // Filter status for non standard behaviors 10302 10303 // If the request is local and we have data: assume a success 10304 // (success with no data won't get notified, that's the best we 10305 // can do given current implementations) 10306 if ( !status && options.isLocal && !options.crossDomain ) { 10307 status = responses.text ? 200 : 404; 10308 10309 // IE - #1450: sometimes returns 1223 when it should be 204 10310 } else if ( status === 1223 ) { 10311 status = 204; 10312 } 10313 } 10314 } 10315 10316 // Call complete if needed 10317 if ( responses ) { 10318 complete( status, statusText, responses, xhr.getAllResponseHeaders() ); 10319 } 10320 }; 10321 10322 // Do send the request 10323 // `xhr.send` may raise an exception, but it will be 10324 // handled in jQuery.ajax (so no try/catch here) 10325 if ( !options.async ) { 10326 10327 // If we're in sync mode we fire the callback 10328 callback(); 10329 } else if ( xhr.readyState === 4 ) { 10330 10331 // (IE6 & IE7) if it's in cache and has been 10332 // retrieved directly we need to fire the callback 10333 window.setTimeout( callback ); 10334 } else { 10335 10336 // Register the callback, but delay it in case `xhr.send` throws 10337 // Add to the list of active xhr callbacks 10338 xhr.onreadystatechange = xhrCallbacks[ id ] = callback; 10339 } 10340 }, 10341 10342 abort: function() { 10343 if ( callback ) { 10344 callback( undefined, true ); 10345 } 10346 } 10347 }; 10348 } 10349 } ); 10350} 10351 10352// Functions to create xhrs 10353function createStandardXHR() { 10354 try { 10355 return new window.XMLHttpRequest(); 10356 } catch ( e ) {} 10357} 10358 10359function createActiveXHR() { 10360 try { 10361 return new window.ActiveXObject( "Microsoft.XMLHTTP" ); 10362 } catch ( e ) {} 10363} 10364 10365 10366 10367 10368// Install script dataType 10369jQuery.ajaxSetup( { 10370 accepts: { 10371 script: "text/javascript, application/javascript, " + 10372 "application/ecmascript, application/x-ecmascript" 10373 }, 10374 contents: { 10375 script: /\b(?:java|ecma)script\b/ 10376 }, 10377 converters: { 10378 "text script": function( text ) { 10379 jQuery.globalEval( text ); 10380 return text; 10381 } 10382 } 10383} ); 10384 10385// Handle cache's special case and global 10386jQuery.ajaxPrefilter( "script", function( s ) { 10387 if ( s.cache === undefined ) { 10388 s.cache = false; 10389 } 10390 if ( s.crossDomain ) { 10391 s.type = "GET"; 10392 s.global = false;
10393 } 10394} ); 10395 10396// Bind script tag hack transport 10397jQuery.ajaxTransport( "script", function( s ) { 10398 10399 // This transport only deals with cross domain requests 10400 if ( s.crossDomain ) { 10401 10402 var script, 10403 head = document.head || jQuery( "head" )[ 0 ] || document.documentElement; 10404 10405 return { 10406 10407 send: function( _, callback ) { 10408 10409 script = document.createElement( "script" ); 10410 10411 script.async = true; 10412 10413 if ( s.scriptCharset ) { 10414 script.charset = s.scriptCharset; 10415 } 10416 10417 script.src = s.url; 10418 10419 // Attach handlers for all browsers 10420 script.onload = script.onreadystatechange = function( _, isAbort ) { 10421 10422 if ( isAbort || !script.readyState || /loaded|complete/.test( script.readyState ) ) { 10423 10424 // Handle memory leak in IE 10425 script.onload = script.onreadystatechange = null; 10426 10427 // Remove the script 10428 if ( script.parentNode ) { 10429 script.parentNode.removeChild( script ); 10430 } 10431 10432 // Dereference the script 10433 script = null; 10434 10435 // Callback if not abort 10436 if ( !isAbort ) { 10437 callback( 200, "success" ); 10438 } 10439 } 10440 }; 10441 10442 // Circumvent IE6 bugs with base elements (#2709 and #4378) by prepending 10443 // Use native DOM manipulation to avoid our domManip AJAX trickery 10444 head.insertBefore( script, head.firstChild ); 10445 }, 10446 10447 abort: function() { 10448 if ( script ) { 10449 script.onload( undefined, true ); 10450 } 10451 } 10452 }; 10453 } 10454} ); 10455 10456 10457 10458 10459var oldCallbacks = [], 10460 rjsonp = /(=)\?(?=&|$)|\?\?/; 10461 10462// Default jsonp settings 10463jQuery.ajaxSetup( { 10464 jsonp: "callback", 10465 jsonpCallback: function() { 10466 var callback = oldCallbacks.pop() || ( jQuery.expando + "_" + ( nonce++ ) ); 10467 this[ callback ] = true; 10468 return callback; 10469 } 10470} ); 10471 10472// Detect, normalize options and install callbacks for jsonp requests 10473jQuery.ajaxPrefilter( "json jsonp", function( s, originalSettings, jqXHR ) { 10474 10475 var callbackName, overwritten, responseContainer, 10476 jsonProp = s.jsonp !== false && ( rjsonp.test( s.url ) ? 10477 "url" : 10478 typeof s.data === "string" && 10479 ( s.contentType || "" ) 10480 .indexOf( "application/x-www-form-urlencoded" ) === 0 && 10481 rjsonp.test( s.data ) && "data" 10482 ); 10483 10484 // Handle iff the expected data type is "jsonp" or we have a parameter to set 10485 if ( jsonProp || s.dataTypes[ 0 ] === "jsonp" ) { 10486 10487 // Get callback name, remembering preexisting value associated with it 10488 callbackName = s.jsonpCallback = jQuery.isFunction( s.jsonpCallback ) ? 10489 s.jsonpCallback() : 10490 s.jsonpCallback; 10491 10492 // Insert callback into url or form data 10493 if ( jsonProp ) { 10494 s[ jsonProp ] = s[ jsonProp ].replace( rjsonp, "$1" + callbackName ); 10495 } else if ( s.jsonp !== false ) { 10496 s.url += ( rquery.test( s.url ) ? "&" : "?" ) + s.jsonp + "=" + callbackName; 10497 } 10498 10499 // Use data converter to retrieve json after script execution 10500 s.converters[ "script json" ] = function() { 10501 if ( !responseContainer ) { 10502 jQuery.error( callbackName + " was not called" ); 10503 } 10504 return responseContainer[ 0 ]; 10505 }; 10506 10507 // force json dataType 10508 s.dataTypes[ 0 ] = "json"; 10509 10510 // Install callback 10511 overwritten = window[ callbackName ]; 10512 window[ callbackName ] = function() { 10513 responseContainer = arguments; 10514 }; 10515 10516 // Clean-up function (fires after converters) 10517 jqXHR.always( function() { 10518 10519 // If previous value didn't exist - remove it 10520 if ( overwritten === undefined ) { 10521 jQuery( window ).removeProp( callbackName ); 10522 10523 // Otherwise restore preexisting value 10524 } else { 10525 window[ callbackName ] = overwritten; 10526 } 10527 10528 // Save back as free 10529 if ( s[ callbackName ] ) { 10530 10531 // make sure that re-using the options doesn't screw things around 10532 s.jsonpCallback = originalSettings.jsonpCallback; 10533 10534 // save the callback name for future use 10535 oldCallbacks.push( callbackName ); 10536 } 10537 10538 // Call if it was a function and we have a response 10539 if ( responseContainer && jQuery.isFunction( overwritten ) ) { 10540 overwritten( responseContainer[ 0 ] ); 10541 } 10542 10543 responseContainer = overwritten = undefined; 10544 } ); 10545 10546 // Delegate to script 10547 return "script"; 10548 } 10549} ); 10550 10551 10552 10553 10554// data: string of html 10555// context (optional): If specified, the fragment will be created in this context, 10556// defaults to document 10557// keepScripts (optional): If true, will include scripts passed in the html string 10558jQuery.parseHTML = function( data, context, keepScripts ) { 10559 if ( !data || typeof data !== "string" ) { 10560 return null; 10561 } 10562 if ( typeof context === "boolean" ) { 10563 keepScripts = context; 10564 context = false;
10565 } 10566 context = context || document; 10567 10568 var parsed = rsingleTag.exec( data ), 10569 scripts = !keepScripts && []; 10570 10571 // Single tag 10572 if ( parsed ) { 10573 return [ context.createElement( parsed[ 1 ] ) ]; 10574 } 10575 10576 parsed = buildFragment( [ data ], context, scripts ); 10577 10578 if ( scripts && scripts.length ) { 10579 jQuery( scripts ).remove(); 10580 } 10581 10582 return jQuery.merge( [], parsed.childNodes ); 10583}; 10584 10585 10586// Keep a copy of the old load method 10587var _load = jQuery.fn.load; 10588 10589/** 10590 * Load a url into a page 10591 */ 10592jQuery.fn.load = function( url, params, callback ) { 10593 if ( typeof url !== "string" && _load ) { 10594 return _load.apply( this, arguments ); 10595 } 10596 10597 var selector, type, response, 10598 self = this, 10599 off = url.indexOf( " " ); 10600 10601 if ( off > -1 ) { 10602 selector = jQuery.trim( url.slice( off, url.length ) ); 10603 url = url.slice( 0, off ); 10604 } 10605 10606 // If it's a function 10607 if ( jQuery.isFunction( params ) ) { 10608 10609 // We assume that it's the callback 10610 callback = params; 10611 params = undefined; 10612 10613 // Otherwise, build a param string 10614 } else if ( params && typeof params === "object" ) { 10615 type = "POST"; 10616 } 10617 10618 // If we have elements to modify, make the request 10619 if ( self.length > 0 ) { 10620 jQuery.ajax( { 10621 url: url, 10622 10623 // If "type" variable is undefined, then "GET" method will be used. 10624 // Make value of this field explicit since 10625 // user can override it through ajaxSetup method 10626 type: type || "GET", 10627 dataType: "html", 10628 data: params 10629 } ).done( function( responseText ) { 10630 10631 // Save response for use in complete callback 10632 response = arguments; 10633 10634 self.html( selector ? 10635 10636 // If a selector was specified, locate the right elements in a dummy div 10637 // Exclude scripts to avoid IE 'Permission Denied' errors 10638 jQuery( "<div>" ).append( jQuery.parseHTML( responseText ) ).find( selector ) : 10639 10640 // Otherwise use the full result 10641 responseText ); 10642 10643 // If the request succeeds, this function gets "data", "status", "jqXHR" 10644 // but they are ignored because response was set above. 10645 // If it fails, this function gets "jqXHR", "status", "error" 10646 } ).always( callback && function( jqXHR, status ) { 10647 self.each( function() { 10648 callback.apply( this, response || [ jqXHR.responseText, status, jqXHR ] ); 10649 } ); 10650 } ); 10651 } 10652 10653 return this; 10654}; 10655 10656 10657 10658 10659// Attach a bunch of functions for handling common AJAX events 10660jQuery.each( [ 10661 "ajaxStart", 10662 "ajaxStop", 10663 "ajaxComplete", 10664 "ajaxError", 10665 "ajaxSuccess", 10666 "ajaxSend" 10667], function( i, type ) { 10668 jQuery.fn[ type ] = function( fn ) { 10669 return this.on( type, fn ); 10670 }; 10671} ); 10672 10673 10674 10675 10676jQuery.expr.filters.animated = function( elem ) { 10677 return jQuery.grep( jQuery.timers, function( fn ) { 10678 return elem === fn.elem; 10679 } ).length; 10680}; 10681 10682 10683 10684 10685 10686/** 10687 * Gets a window from an element 10688 */ 10689function getWindow( elem ) { 10690 return jQuery.isWindow( elem ) ? 10691 elem : 10692 elem.nodeType === 9 ? 10693 elem.defaultView || elem.parentWindow : 10694 false; 10695} 10696 10697jQuery.offset = { 10698 setOffset: function( elem, options, i ) { 10699 var curPosition, curLeft, curCSSTop, curTop, curOffset, curCSSLeft, calculatePosition, 10700 position = jQuery.css( elem, "position" ), 10701 curElem = jQuery( elem ), 10702 props = {}; 10703 10704 // set position first, in-case top/left are set even on static elem 10705 if ( position === "static" ) { 10706 elem.style.position = "relative"; 10707 } 10708 10709 curOffset = curElem.offset(); 10710 curCSSTop = jQuery.css( elem, "top" ); 10711 curCSSLeft = jQuery.css( elem, "left" ); 10712 calculatePosition = ( position === "absolute" || position === "fixed" ) && 10713 jQuery.inArray( "auto", [ curCSSTop, curCSSLeft ] ) > -1; 10714 10715 // need to be able to calculate position if either top or left 10716 // is auto and position is either absolute or fixed 10717 if ( calculatePosition ) { 10718 curPosition = curElem.position(); 10719 curTop = curPosition.top; 10720 curLeft = curPosition.left; 10721 } else { 10722 curTop = parseFloat( curCSSTop ) || 0; 10723 curLeft = parseFloat( curCSSLeft ) || 0; 10724 } 10725 10726 if ( jQuery.isFunction( options ) ) { 10727 10728 // Use jQuery.extend here to allow modification of coordinates argument (gh-1848) 10729 options = options.call( elem, i, jQuery.extend( {}, curOffset ) ); 10730 } 10731 10732 if ( options.top != null ) { 10733 props.top = ( options.top - curOffset.top ) + curTop; 10734 } 10735 if ( options.left != null ) { 10736 props.left = ( options.left - curOffset.left ) + curLeft; 10737 } 10738 10739 if ( "using" in options ) { 10740 options.using.call( elem, props ); 10741 } else { 10742 curElem.css( props ); 10743 } 10744 } 10745}; 10746 10747jQuery.fn.extend( { 10748 offset: function( options ) { 10749 if ( arguments.length ) { 10750 return options === undefined ? 10751 this : 10752 this.each( function( i ) { 10753 jQuery.offset.setOffset( this, options, i ); 10754 } ); 10755 } 10756 10757 var docElem, win, 10758 box = { top: 0, left: 0 }, 10759 elem = this[ 0 ], 10760 doc = elem && elem.ownerDocument; 10761 10762 if ( !doc ) { 10763 return; 10764 } 10765 10766 docElem = doc.documentElement; 10767 10768 // Make sure it's not a disconnected DOM node 10769 if ( !jQuery.contains( docElem, elem ) ) { 10770 return box; 10771 } 10772 10773 // If we don't have gBCR, just use 0,0 rather than error 10774 // BlackBerry 5, iOS 3 (original iPhone) 10775 if ( typeof elem.getBoundingClientRect !== "undefined" ) { 10776 box = elem.getBoundingClientRect(); 10777 } 10778 win = getWindow( doc ); 10779 return { 10780 top: box.top + ( win.pageYOffset || docElem.scrollTop ) - ( docElem.clientTop || 0 ), 10781 left: box.left + ( win.pageXOffset || docElem.scrollLeft ) - ( docElem.clientLeft || 0 ) 10782 }; 10783 }, 10784 10785 position: function() { 10786 if ( !this[ 0 ] ) { 10787 return; 10788 } 10789 10790 var offsetParent, offset, 10791 parentOffset = { top: 0, left: 0 }, 10792 elem = this[ 0 ]; 10793 10794 // Fixed elements are offset from window (parentOffset = {top:0, left
10794: 0}, 10795 // because it is its only offset parent 10796 if ( jQuery.css( elem, "position" ) === "fixed" ) { 10797 10798 // we assume that getBoundingClientRect is available when computed position is fixed 10799 offset = elem.getBoundingClientRect(); 10800 } else { 10801 10802 // Get *real* offsetParent 10803 offsetParent = this.offsetParent(); 10804 10805 // Get correct offsets 10806 offset = this.offset(); 10807 if ( !jQuery.nodeName( offsetParent[ 0 ], "html" ) ) { 10808 parentOffset = offsetParent.offset(); 10809 } 10810 10811 // Add offsetParent borders 10812 parentOffset.top += jQuery.css( offsetParent[ 0 ], "borderTopWidth", true ); 10813 parentOffset.left += jQuery.css( offsetParent[ 0 ], "borderLeftWidth", true ); 10814 } 10815 10816 // Subtract parent offsets and element margins 10817 // note: when an element has margin: auto the offsetLeft and marginLeft 10818 // are the same in Safari causing offset.left to incorrectly be 0 10819 return { 10820 top: offset.top - parentOffset.top - jQuery.css( elem, "marginTop", true ), 10821 left: offset.left - parentOffset.left - jQuery.css( elem, "marginLeft", true ) 10822 }; 10823 }, 10824 10825 offsetParent: function() { 10826 return this.map( function() { 10827 var offsetParent = this.offsetParent; 10828 10829 while ( offsetParent && ( !jQuery.nodeName( offsetParent, "html" ) && 10830 jQuery.css( offsetParent, "position" ) === "static" ) ) { 10831 offsetParent = offsetParent.offsetParent; 10832 } 10833 return offsetParent || documentElement; 10834 } ); 10835 } 10836} ); 10837 10838// Create scrollLeft and scrollTop methods 10839jQuery.each( { scrollLeft: "pageXOffset", scrollTop: "pageYOffset" }, function( method, prop ) { 10840 var top = /Y/.test( prop ); 10841 10842 jQuery.fn[ method ] = function( val ) { 10843 return access( this, function( elem, method, val ) { 10844 var win = getWindow( elem ); 10845 10846 if ( val === undefined ) { 10847 return win ? ( prop in win ) ? win[ prop ] : 10848 win.document.documentElement[ method ] : 10849 elem[ method ]; 10850 } 10851 10852 if ( win ) { 10853 win.scrollTo( 10854 !top ? val : jQuery( win ).scrollLeft(), 10855 top ? val : jQuery( win ).scrollTop() 10856 ); 10857 10858 } else { 10859 elem[ method ] = val; 10860 } 10861 }, method, val, arguments.length, null ); 10862 }; 10863} ); 10864 10865// Support: Safari<7-8+, Chrome<37-44+ 10866// Add the top/left cssHooks using jQuery.fn.position 10867// Webkit bug: https://bugs.webkit.org/show_bug.cgi?id=29084 10868// getComputedStyle returns percent when specified for top/left/bottom/right 10869// rather than make the css module depend on the offset module, we just check for it here 10870jQuery.each( [ "top", "left" ], function( i, prop ) { 10871 jQuery.cssHooks[ prop ] = addGetHookIf( support.pixelPosition, 10872 function( elem, computed ) { 10873 if ( computed ) { 10874 computed = curCSS( elem, prop ); 10875 10876 // if curCSS returns percentage, fallback to offset 10877 return rnumnonpx.test( computed ) ? 10878 jQuery( elem ).position()[ prop ] + "px" : 10879 computed; 10880 } 10881 } 10882 ); 10883} ); 10884 10885 10886// Create innerHeight, innerWidth, height, width, outerHeight and outerWidth methods 10887jQuery.each( { Height: "height", Width: "width" }, function( name, type ) { 10888 jQuery.each( { padding: "inner" + name, content: type, "": "outer" + name }, 10889 function( defaultExtra, funcName ) { 10890 10891 // margin is only for outerHeight, outerWidth 10892 jQuery.fn[ funcName ] = function( margin, value ) { 10893 var chainable = arguments.length && ( defaultExtra || typeof margin !== "boolean" ), 10894 extra = defaultExtra || ( margin === true || value === true ? "margin" : "border" ); 10895 10896 return access( this, function( elem, type, value ) { 10897 var doc; 10898 10899 if ( jQuery.isWindow( elem ) ) { 10900 10901 // As of 5/8/2012 this will yield incorrect results for Mobile Safari, but there 10902 // isn't a whole lot we can do. See pull request at this URL for discussion: 10903 // https://github.com/jquery/jquery/pull/764 10904 return elem.document.documentElement[ "client" + name ]; 10905 } 10906 10907 // Get document width or height 10908 if ( elem.nodeType === 9 ) { 10909 doc = elem.documentElement; 10910 10911 // Either scroll[Width/Height] or offset[Width/Height] or client[Width/Height], 10912 // whichever is greatest 10913 // unfortunately, this causes bug #3838 in IE6/8 only, 10914 // but there is currently no good, small way to fix it. 10915 return Math.max( 10916 elem.body[ "scroll" + name ], doc[ "scroll" + name ], 10917 elem.body[ "offset" + name ], doc[ "offset" + name ], 10918 doc[ "client" + name ] 10919 ); 10920 } 10921 10922 return value === undefined ? 10923 10924 // Get width or height on the element, requesting but not forcing parseFloat 10925 jQuery.css( elem, type, extra ) : 10926 10927 // Set width or height on the element 10928 jQuery.style( elem, type, value, extra ); 10929 }, type, chainable ? margin : undefined, chainable, null ); 10930 }; 10931 } ); 10932} ); 10933 10934 10935jQuery.fn.extend( { 10936 10937 bind: function( types, data, fn ) { 10938 return this.on( types, null, data, fn ); 10939 }, 10940 unbind: function( types, fn ) { 10941 return this.off( types, null, fn ); 10942 }, 10943 10944 delegate: function( selector, types, data, fn ) { 10945 return this.on( types, selector, data, fn ); 10946 }, 10947 undelegate: function( selector, types, fn ) { 10948 10949 // ( namespace ) or ( selector, types [, fn] ) 10950 return arguments.length === 1 ? 10951 this.off( selector, "**" ) : 10952 this.off( types, selector || "**", fn ); 10953 } 10954} ); 10955 10956// The number of elements contained in the matched element set 10957jQuery.fn.size = function() { 10958 return this.length; 10959}; 10960 10961jQuery.fn.andSelf = jQuery.fn.addBack; 10962 10963 10964 10965 10966// Register as a named AMD module, since jQuery can be concatenated with other 10967// files that may use define, but not via a proper concatenation script that 10968// understands anonymous AMD modules. A named AMD is safest and most robust 10969// way to register. Lowercase jquery is used because AMD module names are 10970// derived from file names, and jQuery is normally delivered in a lowercase 10971// file name. Do this after creating the global so that if an AMD module wants 10972// to call noConflict to hide this version of jQuery, it will work. 10973 10974// Note that for maximum portability, libraries that are not jQuery should 10975// declare themselves as anonymous modules, and avoid setting a global if an 10976// AMD loader is present. jQuery is a special case. For more information, see
10977// https://github.com/jrburke/requirejs/wiki/Updating-existing-libraries#wiki-anon 10978 10979if ( typeof define === "function" && define.amd ) { 10980 define( "jquery", [], function() { 10981 return jQuery; 10982 } ); 10983} 10984 10985 10986 10987var 10988 10989 // Map over jQuery in case of overwrite 10990 _jQuery = window.jQuery, 10991 10992 // Map over the $ in case of overwrite 10993 _$ = window.$; 10994 10995jQuery.noConflict = function( deep ) { 10996 if ( window.$ === jQuery ) { 10997 window.$ = _$; 10998 } 10999 11000 if ( deep && window.jQuery === jQuery ) { 11001 window.jQuery = _jQuery; 11002 } 11003 11004 return jQuery; 11005}; 11006 11007// Expose jQuery and $ identifiers, even in 11008// AMD (#7102#comment:10, https://github.com/jquery/jquery/pull/557) 11009// and CommonJS for browser emulators (#13566) 11010if ( !noGlobal ) { 11011 window.jQuery = window.$ = jQuery; 11012} 11013 11014return jQuery; 11015})); 11016 11017/*! 11018 * jQuery Migrate - v1.4.0 - 2016-02-26 11019 * Copyright jQuery Foundation and other contributors 11020 */ 11021(function( jQuery, window, undefined ) { 11022// See http://bugs.jquery.com/ticket/13335 11023// "use strict"; 11024 11025 11026jQuery.migrateVersion = "1.4.0"; 11027 11028 11029var warnedAbout = {}; 11030 11031// List of warnings already given; public read only 11032jQuery.migrateWarnings = []; 11033 11034// Set to true to prevent console output; migrateWarnings still maintained 11035jQuery.migrateMute = true; 11036 11037// Show a message on the console so devs know we're active 11038if ( window.console && window.console.log ) { 11039 window.console.log( "JQMIGRATE: Migrate is installed" + 11040 ( jQuery.migrateMute ? "" : " with logging active" ) + 11041 ", version " + jQuery.migrateVersion ); 11042} 11043 11044// Set to false to disable traces that appear with warnings 11045if ( jQuery.migrateTrace === undefined ) { 11046 jQuery.migrateTrace = true; 11047} 11048 11049// Forget any warnings we've already given; public 11050jQuery.migrateReset = function() { 11051 warnedAbout = {}; 11052 jQuery.migrateWarnings.length = 0; 11053}; 11054 11055function migrateWarn( msg) { 11056 var console = window.console; 11057 if ( !warnedAbout[ msg ] ) { 11058 warnedAbout[ msg ] = true; 11059 jQuery.migrateWarnings.push( msg ); 11060 if ( console && console.warn && !jQuery.migrateMute ) { 11061 console.warn( "JQMIGRATE: " + msg ); 11062 if ( jQuery.migrateTrace && console.trace ) { 11063 console.trace(); 11064 } 11065 } 11066 } 11067} 11068 11069function migrateWarnProp( obj, prop, value, msg ) { 11070 if ( Object.defineProperty ) { 11071 // On ES5 browsers (non-oldIE), warn if the code tries to get prop; 11072 // allow property to be overwritten in case some other plugin wants it 11073 try { 11074 Object.defineProperty( obj, prop, { 11075 configurable: true, 11076 enumerable: true, 11077 get: function() { 11078 migrateWarn( msg ); 11079 return value; 11080 }, 11081 set: function( newValue ) { 11082 migrateWarn( msg ); 11083 value = newValue; 11084 } 11085 }); 11086 return; 11087 } catch( err ) { 11088 // IE8 is a dope about Object.defineProperty, can't warn there 11089 } 11090 } 11091 11092 // Non-ES5 (or broken) browser; just set the property 11093 jQuery._definePropertyBroken = true; 11094 obj[ prop ] = value; 11095} 11096 11097if ( document.compatMode === "BackCompat" ) { 11098 // jQuery has never supported or tested Quirks Mode 11099 migrateWarn( "jQuery is not compatible with Quirks Mode" ); 11100} 11101 11102 11103var attrFn = jQuery( "<input/>", { size: 1 } ).attr("size") && jQuery.attrFn, 11104 oldAttr = jQuery.attr, 11105 valueAttrGet = jQuery.attrHooks.value && jQuery.attrHooks.value.get || 11106 function() { return null; }, 11107 valueAttrSet = jQuery.attrHooks.value && jQuery.attrHooks.value.set || 11108 function() { return undefined; }, 11109 rnoType = /^(?:input|button)$/i, 11110 rnoAttrNodeType = /^[238]$/, 11111 rboolean = /^(?:autofocus|autoplay|async|checked|controls|defer|disabled|hidden|loop|multiple|open|readonly|required|scoped|selected)$/i, 11112 ruseDefault = /^(?:checked|selected)$/i; 11113 11114// jQuery.attrFn 11115migrateWarnProp( jQuery, "attrFn", attrFn || {}, "jQuery.attrFn is deprecated" ); 11116 11117jQuery.attr = function( elem, name, value, pass ) { 11118 var lowerName = name.toLowerCase(), 11119 nType = elem && elem.nodeType; 11120 11121 if ( pass ) { 11122 // Since pass is used internally, we only warn for new jQuery 11123 // versions where there isn't a pass arg in the formal params 11124 if ( oldAttr.length < 4 ) { 11125 migrateWarn("jQuery.fn.attr( props, pass ) is deprecated"); 11126 } 11127 if ( elem && !rnoAttrNodeType.test( nType ) && 11128 (attrFn ? name in attrFn : jQuery.isFunction(jQuery.fn[name])) ) { 11129 return jQuery( elem )[ name ]( value ); 11130 } 11131 } 11132 11133 // Warn if user tries to set `type`, since it breaks on IE 6/7/8; by checking 11134 // for disconnected elements we don't warn on $( "<button>", { type: "button" } ). 11135 if ( name === "type" && value !== undefined && rnoType.test( elem.nodeName ) && elem.parentNode ) { 11136 migrateWarn("Can't change the 'type' of an input or button in IE 6/7/8"); 11137 } 11138 11139 // Restore boolHook for boolean property/attribute synchronization 11140 if ( !jQuery.attrHooks[ lowerName ] && rboolean.test( lowerName ) ) { 11141 jQuery.attrHooks[ lowerName ] = { 11142 get: function( elem, name ) { 11143 // Align boolean attributes with corresponding properties 11144 // Fall back to attribute presence where some booleans are not supported 11145 var attrNode, 11146 property = jQuery.prop( elem, name ); 11147 return property === true || typeof property !== "boolean" && 11148 ( attrNode = elem.getAttributeNode(name) ) && attrNode.nodeValue !== false ? 11149 11150 name.toLowerCase() : 11151 undefined; 11152 },
11153 set: function( elem, value, name ) { 11154 var propName; 11155 if ( value === false ) { 11156 // Remove boolean attributes when set to false 11157 jQuery.removeAttr( elem, name ); 11158 } else { 11159 // value is true since we know at this point it's type boolean and not false 11160 // Set boolean attributes to the same name and set the DOM property 11161 propName = jQuery.propFix[ name ] || name; 11162 if ( propName in elem ) { 11163 // Only set the IDL specifically if it already exists on the element 11164 elem[ propName ] = true; 11165 } 11166 11167 elem.setAttribute( name, name.toLowerCase() ); 11168 } 11169 return name; 11170 } 11171 }; 11172 11173 // Warn only for attributes that can remain distinct from their properties post-1.9 11174 if ( ruseDefault.test( lowerName ) ) { 11175 migrateWarn( "jQuery.fn.attr('" + lowerName + "') might use property instead of attribute" ); 11176 } 11177 } 11178 11179 return oldAttr.call( jQuery, elem, name, value ); 11180}; 11181 11182// attrHooks: value 11183jQuery.attrHooks.value = { 11184 get: function( elem, name ) { 11185 var nodeName = ( elem.nodeName || "" ).toLowerCase(); 11186 if ( nodeName === "button" ) { 11187 return valueAttrGet.apply( this, arguments ); 11188 } 11189 if ( nodeName !== "input" && nodeName !== "option" ) { 11190 migrateWarn("jQuery.fn.attr('value') no longer gets properties"); 11191 } 11192 return name in elem ? 11193 elem.value : 11194 null; 11195 }, 11196 set: function( elem, value ) { 11197 var nodeName = ( elem.nodeName || "" ).toLowerCase(); 11198 if ( nodeName === "button" ) { 11199 return valueAttrSet.apply( this, arguments ); 11200 } 11201 if ( nodeName !== "input" && nodeName !== "option" ) { 11202 migrateWarn("jQuery.fn.attr('value', val) no longer sets properties"); 11203 } 11204 // Does not return so that setAttribute is also used 11205 elem.value = value; 11206 } 11207}; 11208 11209 11210var matched, browser, 11211 oldInit = jQuery.fn.init, 11212 oldParseJSON = jQuery.parseJSON, 11213 rspaceAngle = /^\s*</, 11214 rattrHash = /\[\s*\w+\s*[~|^$*]?=\s*(?![\s'"])[^#\]]*#/, 11215 // Note: XSS check is done below after string is trimmed 11216 rquickExpr = /^([^<]*)(<[\w\W]+>)([^>]*)$/; 11217 11218// $(html) "looks like html" rule change 11219jQuery.fn.init = function( selector, context, rootjQuery ) { 11220 var match, ret; 11221 11222 if ( selector && typeof selector === "string" && !jQuery.isPlainObject( context ) && 11223 (match = rquickExpr.exec( jQuery.trim( selector ) )) && match[ 0 ] ) { 11224 // This is an HTML string according to the "old" rules; is it still? 11225 if ( !rspaceAngle.test( selector ) ) { 11226 migrateWarn("$(html) HTML strings must start with '<' character"); 11227 } 11228 if ( match[ 3 ] ) { 11229 migrateWarn("$(html) HTML text after last tag is ignored"); 11230 } 11231 11232 // Consistently reject any HTML-like string starting with a hash (#9521) 11233 // Note that this may break jQuery 1.6.x code that otherwise would work. 11234 if ( match[ 0 ].charAt( 0 ) === "#" ) { 11235 migrateWarn("HTML string cannot start with a '#' character"); 11236 jQuery.error("JQMIGRATE: Invalid selector string (XSS)"); 11237 } 11238 // Now process using loose rules; let pre-1.8 play too 11239 if ( context && context.context ) { 11240 // jQuery object as context; parseHTML expects a DOM object 11241 context = context.context; 11242 } 11243 if ( jQuery.parseHTML ) { 11244 return oldInit.call( this, 11245 jQuery.parseHTML( match[ 2 ], context && context.ownerDocument || 11246 context || document, true ), context, rootjQuery ); 11247 } 11248 } 11249 11250 if ( selector === "#" ) { 11251 11252 // jQuery( "#" ) is a bogus ID selector, but it returned an empty set before jQuery 3.0 11253 migrateWarn( "jQuery( '#' ) is not a valid selector" ); 11254 selector = []; 11255 11256 } else if ( rattrHash.test( selector ) ) { 11257 11258 // The nonstandard and undocumented unquoted-hash was removed in jQuery 1.12.0 11259 // Note that this doesn't actually fix the selector due to potential false positives 11260 migrateWarn( "Attribute selectors with '#' must be quoted: '" + selector + "'" ); 11261 } 11262 11263 ret = oldInit.apply( this, arguments ); 11264 11265 // Fill in selector and context properties so .live() works 11266 if ( selector && selector.selector !== undefined ) { 11267 // A jQuery object, copy its properties 11268 ret.selector = selector.selector; 11269 ret.context = selector.context; 11270 11271 } else { 11272 ret.selector = typeof selector === "string" ? selector : ""; 11273 if ( selector ) { 11274 ret.context = selector.nodeType? selector : context || document; 11275 } 11276 } 11277 11278 return ret; 11279}; 11280jQuery.fn.init.prototype = jQuery.fn; 11281 11282// Let $.parseJSON(falsy_value) return null 11283jQuery.parseJSON = function( json ) { 11284 if ( !json ) { 11285 migrateWarn("jQuery.parseJSON requires a valid JSON string"); 11286 return null; 11287 } 11288 return oldParseJSON.apply( this, arguments ); 11289}; 11290 11291jQuery.uaMatch = function( ua ) { 11292 ua = ua.toLowerCase(); 11293 11294 var match = /(chrome)[ \/]([\w.]+)/.exec( ua ) || 11295 /(webkit)[ \/]([\w.]+)/.exec( ua ) || 11296 /(opera)(?:.*version|)[ \/]([\w.]+)/.exec( ua ) || 11297 /(msie) ([\w.]+)/.exec( ua ) || 11298 ua.indexOf("compatible") < 0 && /(mozilla)(?:.*? rv:([\w.]+)|)/.exec( ua ) || 11299 []; 11300 11301 return { 11302 browser: match[ 1 ] || "", 11303 version: match[ 2 ] || "0" 11304 }; 11305}; 11306 11307// Don't clobber any existing jQuery.browser in case it's different 11308if ( !jQuery.browser ) { 11309 matched = jQuery.uaMatch( navigator.userAgent ); 11310 browser = {}; 11311 11312 if ( matched.browser ) { 11313 browser[ matched.browser ] = true; 11314 browser.version = matched.version; 11315 } 11316 11317 // Chrome is Webkit, but Webkit is also Safari. 11318 if ( browser.chrome ) { 11319 browser.webkit = true; 11320 } else if ( browser.webkit ) { 11321 browser.safari = true; 11322 } 11323 11324 jQuery.browser = browser; 11325} 11326 11327// Warn if the code tries to get jQuery.browser 11328migrateWarnProp( jQuery, "browser", jQuery.browser, "jQuery.browser is deprecated" ); 11329
11330// jQuery.boxModel deprecated in 1.3, jQuery.support.boxModel deprecated in 1.7 11331jQuery.boxModel = jQuery.support.boxModel = (document.compatMode === "CSS1Compat"); 11332migrateWarnProp( jQuery, "boxModel", jQuery.boxModel, "jQuery.boxModel is deprecated" ); 11333migrateWarnProp( jQuery.support, "boxModel", jQuery.support.boxModel, "jQuery.support.boxModel is deprecated" ); 11334 11335jQuery.sub = function() { 11336 function jQuerySub( selector, context ) { 11337 return new jQuerySub.fn.init( selector, context ); 11338 } 11339 jQuery.extend( true, jQuerySub, this ); 11340 jQuerySub.superclass = this; 11341 jQuerySub.fn = jQuerySub.prototype = this(); 11342 jQuerySub.fn.constructor = jQuerySub; 11343 jQuerySub.sub = this.sub; 11344 jQuerySub.fn.init = function init( selector, context ) { 11345 var instance = jQuery.fn.init.call( this, selector, context, rootjQuerySub ); 11346 return instance instanceof jQuerySub ? 11347 instance : 11348 jQuerySub( instance ); 11349 }; 11350 jQuerySub.fn.init.prototype = jQuerySub.fn; 11351 var rootjQuerySub = jQuerySub(document); 11352 migrateWarn( "jQuery.sub() is deprecated" ); 11353 return jQuerySub; 11354}; 11355 11356// The number of elements contained in the matched element set 11357jQuery.fn.size = function() { 11358 migrateWarn( "jQuery.fn.size() is deprecated; use the .length property" ); 11359 return this.length; 11360}; 11361 11362 11363var internalSwapCall = false; 11364 11365// If this version of jQuery has .swap(), don't false-alarm on internal uses 11366if ( jQuery.swap ) { 11367 jQuery.each( [ "height", "width", "reliableMarginRight" ], function( _, name ) { 11368 var oldHook = jQuery.cssHooks[ name ] && jQuery.cssHooks[ name ].get; 11369 11370 if ( oldHook ) { 11371 jQuery.cssHooks[ name ].get = function() { 11372 var ret; 11373 11374 internalSwapCall = true; 11375 ret = oldHook.apply( this, arguments ); 11376 internalSwapCall = false; 11377 return ret; 11378 }; 11379 } 11380 }); 11381} 11382 11383jQuery.swap = function( elem, options, callback, args ) { 11384 var ret, name, 11385 old = {}; 11386 11387 if ( !internalSwapCall ) { 11388 migrateWarn( "jQuery.swap() is undocumented and deprecated" ); 11389 } 11390 11391 // Remember the old values, and insert the new ones 11392 for ( name in options ) { 11393 old[ name ] = elem.style[ name ]; 11394 elem.style[ name ] = options[ name ]; 11395 } 11396 11397 ret = callback.apply( elem, args || [] ); 11398 11399 // Revert the old values 11400 for ( name in options ) { 11401 elem.style[ name ] = old[ name ]; 11402 } 11403 11404 return ret; 11405}; 11406 11407 11408// Ensure that $.ajax gets the new parseJSON defined in core.js 11409jQuery.ajaxSetup({ 11410 converters: { 11411 "text json": jQuery.parseJSON 11412 } 11413}); 11414 11415 11416var oldFnData = jQuery.fn.data; 11417 11418jQuery.fn.data = function( name ) { 11419 var ret, evt, 11420 elem = this[0]; 11421 11422 // Handles 1.7 which has this behavior and 1.8 which doesn't 11423 if ( elem && name === "events" && arguments.length === 1 ) { 11424 ret = jQuery.data( elem, name ); 11425 evt = jQuery._data( elem, name ); 11426 if ( ( ret === undefined || ret === evt ) && evt !== undefined ) { 11427 migrateWarn("Use of jQuery.fn.data('events') is deprecated"); 11428 return evt; 11429 } 11430 } 11431 return oldFnData.apply( this, arguments ); 11432}; 11433 11434 11435var rscriptType = /\/(java|ecma)script/i; 11436 11437// Since jQuery.clean is used internally on older versions, we only shim if it's missing 11438if ( !jQuery.clean ) { 11439 jQuery.clean = function( elems, context, fragment, scripts ) { 11440 // Set context per 1.8 logic 11441 context = context || document; 11442 context = !context.nodeType && context[0] || context; 11443 context = context.ownerDocument || context; 11444 11445 migrateWarn("jQuery.clean() is deprecated"); 11446 11447 var i, elem, handleScript, jsTags, 11448 ret = []; 11449 11450 jQuery.merge( ret, jQuery.buildFragment( elems, context ).childNodes ); 11451 11452 // Complex logic lifted directly from jQuery 1.8 11453 if ( fragment ) { 11454 // Special handling of each script element 11455 handleScript = function( elem ) { 11456 // Check if we consider it executable 11457 if ( !elem.type || rscriptType.test( elem.type ) ) { 11458 // Detach the script and store it in the scripts array (if provided) or the fragment 11459 // Return truthy to indicate that it has been handled 11460 return scripts ? 11461 scripts.push( elem.parentNode ? elem.parentNode.removeChild( elem ) : elem ) : 11462 fragment.appendChild( elem ); 11463 } 11464 }; 11465 11466 for ( i = 0; (elem = ret[i]) != null; i++ ) { 11467 // Check if we're done after handling an executable script 11468 if ( !( jQuery.nodeName( elem, "script" ) && handleScript( elem ) ) ) { 11469 // Append to fragment and handle embedded scripts 11470 fragment.appendChild( elem ); 11471 if ( typeof elem.getElementsByTagName !== "undefined" ) { 11472 // handleScript alters the DOM, so use jQuery.merge to ensure snapshot iteration 11473 jsTags = jQuery.grep( jQuery.merge( [], elem.getElementsByTagName("script") ), handleScript ); 11474 11475 // Splice the scripts into ret after their former ancestor and advance our index beyond them 11476 ret.splice.apply( ret, [i + 1, 0].concat( jsTags ) ); 11477 i += jsTags.length; 11478 } 11479 } 11480 } 11481 } 11482 11483 return ret; 11484 }; 11485} 11486 11487var eventAdd = jQuery.event.add, 11488 eventRemove = jQuery.event.remove, 11489 eventTrigger = jQuery.event.trigger, 11490 oldToggle = jQuery.fn.toggle, 11491 oldLive = jQuery.fn.live, 11492 oldDie = jQuery.fn.die, 11493 oldLoad = jQuery.fn.load, 11494 ajaxEvents = "ajaxStart|ajaxStop|ajaxSend|ajaxComplete|ajaxError|ajaxSuccess", 11495 rajaxEvent = new RegExp( "\\b(?:" + ajaxEvents + ")\\b" ), 11496 rhoverHack = /(?:^|\s)hover(\.\S+|)\b/, 11497 hoverHack = function( events ) { 11498 if ( typeof( events ) !== "string" || jQuery.event.special.hover ) { 11499 return events; 11500 } 11501 if ( rhoverHack.test( events ) ) { 11502 migrateWarn("'hover' pseudo-event is deprecated, use 'mouseenter mouseleave'"); 11503 } 11504 return events && events.replace( rhoverHack, "mouseenter$1 mouseleave$1" ); 11505 }; 11506 11507// Event props removed in 1.9, put them back if needed; no practical way to warn them 11508if ( jQuery.event.props && jQuery.event.props[ 0 ] !== "attrChange" ) { 11509 jQuery.event.props.unshift( "attrChange", "attrName", "relatedNode", "srcElement" ); 11510} 11511 11512// Undocumented jQuery.event.handle was "deprecated" in jQuery 1.7 11513if ( jQuery.event.dispatch ) { 11514 migrateWarnProp( jQuery.event, "handle", jQuery.event.dispatch, "jQuery.event.handle is undocumented and deprecated" ); 11515} 11516 11517// Support for 'hover' pseudo-event and ajax event warnings 11518jQuery.event.add = function( elem, types, handler, data, selector ){ 11519 if ( elem !== document && rajaxEvent.test( types ) ) { 11520 migrateWarn( "AJAX events should be attached to document: " + types ); 11521 } 11522 eventAdd.call( this, elem, hoverHack( types || "" ), handler, data, selector ); 11523}; 11524jQuery.event.remove = function( elem, types, handler, selector, mappedTypes ){ 11525 eventRemove.call( this, elem, hoverHack( types ) || "", handler, selector, mappedTypes ); 11526}; 11527 11528jQuery.each( [ "load", "unload", "error" ], function( _, name ) { 11529 11530 jQuery.fn[ name ] = function() { 11531 var args = Array.prototype.slice.call( arguments, 0 ); 11532 11533 // If this is an ajax load() the first arg should be the string URL; 11534 // technically this could also be the "Anything" arg of the event .load() 11535 // which just goes to show why this dumb signature has been deprecated! 11536 // jQuery custom builds that exclude the Ajax module justifiably die here. 11537 if ( name === "load" && typeof args[ 0 ] === "string" ) { 11538 return oldLoad.apply( this, args ); 11539 } 11540 11541 migrateWarn( "jQuery.fn." + name + "() is deprecated" ); 11542 11543 args.splice( 0, 0, name ); 11544 if ( arguments.length ) { 11545 return this.bind.apply( this, args ); 11546 } 11547 11548 // Use .triggerHandler here because: 11549 // - load and unload events don't need to bubble, only applied to window or image 11550 // - error event should not bubble to window, although it does pre-1.7 11551 // See http://bugs.jquery.com/ticket/11820 11552 this.triggerHandler.apply( this, args ); 11553 return this; 11554 }; 11555 11556}); 11557 11558jQuery.fn.toggle = function( fn, fn2 ) { 11559 11560 // Don't mess with animation or css toggles 11561 if ( !jQuery.isFunction( fn ) || !jQuery.isFunction( fn2 ) ) { 11562 return oldToggle.apply( this, arguments ); 11563 } 11564 migrateWarn("jQuery.fn.toggle(handler, handler...) is deprecated"); 11565 11566 // Save reference to arguments for access in closure 11567 var args = arguments, 11568 guid = fn.guid || jQuery.guid++, 11569 i = 0, 11570 toggler = function( event ) { 11571 // Figure out which function to execute 11572 var lastToggle = ( jQuery._data( this, "lastToggle" + fn.guid ) || 0 ) % i; 11573 jQuery._data( this, "lastToggle" + fn.guid, lastToggle + 1 ); 11574 11575 // Make sure that clicks stop 11576 event.preventDefault(); 11577 11578 // and execute the function 11579 return args[ lastToggle ].apply( this, arguments ) || false; 11580 }; 11581 11582 // link all the functions, so any of them can unbind this click handler 11583 toggler.guid = guid; 11584 while ( i < args.length ) { 11585 args[ i++ ].guid = guid; 11586 } 11587 11588 return this.click( toggler ); 11589}; 11590 11591jQuery.fn.live = function( types, data, fn ) { 11592 migrateWarn("jQuery.fn.live() is deprecated"); 11593 if ( oldLive ) { 11594 return oldLive.apply( this, arguments ); 11595 } 11596 jQuery( this.context ).on( types, this.selector, data, fn ); 11597 return this; 11598}; 11599 11600jQuery.fn.die = function( types, fn ) { 11601 migrateWarn("jQuery.fn.die() is deprecated"); 11602 if ( oldDie ) { 11603 return oldDie.apply( this, arguments ); 11604 } 11605 jQuery( this.context ).off( types, this.selector || "**", fn ); 11606 return this; 11607}; 11608 11609// Turn global events into document-triggered events 11610jQuery.event.trigger = function( event, data, elem, onlyHandlers ){ 11611 if ( !elem && !rajaxEvent.test( event ) ) { 11612 migrateWarn( "Global events are undocumented and deprecated" ); 11613 } 11614 return eventTrigger.call( this, event, data, elem || document, onlyHandlers ); 11615}; 11616jQuery.each( ajaxEvents.split("|"), 11617 function( _, name ) { 11618 jQuery.event.special[ name ] = { 11619 setup: function() { 11620 var elem = this; 11621 11622 // The document needs no shimming; must be !== for oldIE 11623 if ( elem !== document ) { 11624 jQuery.event.add( document, name + "." + jQuery.guid, function() { 11625 jQuery.event.trigger( name, Array.prototype.slice.call( arguments, 1 ), elem, true ); 11626 }); 11627 jQuery._data( this, name, jQuery.guid++ ); 11628 } 11629 return false;
11630 }, 11631 teardown: function() { 11632 if ( this !== document ) { 11633 jQuery.event.remove( document, name + "." + jQuery._data( this, name ) ); 11634 } 11635 return false; 11636 } 11637 }; 11638 } 11639); 11640 11641jQuery.event.special.ready = { 11642 setup: function() { 11643 if ( this === document ) { 11644 migrateWarn( "'ready' event is deprecated" ); 11645 } 11646 } 11647}; 11648 11649var oldSelf = jQuery.fn.andSelf || jQuery.fn.addBack, 11650 oldFind = jQuery.fn.find; 11651 11652jQuery.fn.andSelf = function() { 11653 migrateWarn("jQuery.fn.andSelf() replaced by jQuery.fn.addBack()"); 11654 return oldSelf.apply( this, arguments ); 11655}; 11656 11657jQuery.fn.find = function( selector ) { 11658 var ret = oldFind.apply( this, arguments ); 11659 ret.context = this.context; 11660 ret.selector = this.selector ? this.selector + " " + selector : selector; 11661 return ret; 11662}; 11663 11664 11665// jQuery 1.6 did not support Callbacks, do not warn there 11666if ( jQuery.Callbacks ) { 11667 11668 var oldDeferred = jQuery.Deferred, 11669 tuples = [ 11670 // action, add listener, callbacks, .then handlers, final state 11671 [ "resolve", "done", jQuery.Callbacks("once memory"), 11672 jQuery.Callbacks("once memory"), "resolved" ], 11673 [ "reject", "fail", jQuery.Callbacks("once memory"), 11674 jQuery.Callbacks("once memory"), "rejected" ], 11675 [ "notify", "progress", jQuery.Callbacks("memory"), 11676 jQuery.Callbacks("memory") ] 11677 ]; 11678 11679 jQuery.Deferred = function( func ) { 11680 var deferred = oldDeferred(), 11681 promise = deferred.promise(); 11682 11683 deferred.pipe = promise.pipe = function( /* fnDone, fnFail, fnProgress */ ) { 11684 var fns = arguments; 11685 11686 migrateWarn( "deferred.pipe() is deprecated" ); 11687 11688 return jQuery.Deferred(function( newDefer ) { 11689 jQuery.each( tuples, function( i, tuple ) { 11690 var fn = jQuery.isFunction( fns[ i ] ) && fns[ i ]; 11691 // deferred.done(function() { bind to newDefer or newDefer.resolve }) 11692 // deferred.fail(function() { bind to newDefer or newDefer.reject }) 11693 // deferred.progress(function() { bind to newDefer or newDefer.notify }) 11694 deferred[ tuple[1] ](function() { 11695 var returned = fn && fn.apply( this, arguments ); 11696 if ( returned && jQuery.isFunction( returned.promise ) ) { 11697 returned.promise() 11698 .done( newDefer.resolve ) 11699 .fail( newDefer.reject ) 11700 .progress( newDefer.notify ); 11701 } else { 11702 newDefer[ tuple[ 0 ] + "With" ]( 11703 this === promise ? newDefer.promise() : this, 11704 fn ? [ returned ] : arguments 11705 ); 11706 } 11707 }); 11708 }); 11709 fns = null; 11710 }).promise(); 11711 11712 }; 11713 11714 deferred.isResolved = function() { 11715 migrateWarn( "deferred.isResolved is deprecated" ); 11716 return deferred.state() === "resolved"; 11717 }; 11718 11719 deferred.isRejected = function() { 11720 migrateWarn( "deferred.isRejected is deprecated" ); 11721 return deferred.state() === "rejected"; 11722 }; 11723 11724 if ( func ) { 11725 func.call( deferred, deferred ); 11726 } 11727 11728 return deferred; 11729 }; 11730 11731} 11732 11733})( jQuery, window ); 11734 11735/*! 11736 * jQuery Cookie Plugin v1.4.0 11737 * https://github.com/carhartl/jquery-cookie 11738 * 11739 * Copyright 2013 Klaus Hartl 11740 * Released under the MIT license 11741 */ 11742(function (factory) { 11743 if (typeof define === 'function' && define.amd) { 11744 // AMD. Register as anonymous module. 11745 define(['jquery'], factory); 11746 } else { 11747 // Browser globals. 11748 factory(jQuery); 11749 } 11750}(function ($) { 11751 11752 var pluses = /\+/g; 11753 11754 function encode(s) { 11755 return config.raw ? s : encodeURIComponent(s); 11756 } 11757 11758 function decode(s) { 11759 return config.raw ? s : decodeURIComponent(s); 11760 } 11761 11762 function stringifyCookieValue(value) { 11763 return encode(config.json ? JSON.stringify(value) : String(value)); 11764 } 11765 11766 function parseCookieValue(s) { 11767 if (s.indexOf('"') === 0) { 11768 // This is a quoted cookie as according to RFC2068, unescape... 11769 s = s.slice(1, -1).replace(/\\"/g, '"').replace(/\\\\/g, '\\'); 11770 } 11771 11772 try { 11773 // Replace server-side written pluses with spaces. 11774 // If we can't decode the cookie, ignore it, it's unusable. 11775 // If we can't parse the cookie, ignore it, it's unusable. 11776 s = decodeURIComponent(s.replace(pluses, ' ')); 11777 return config.json ? JSON.parse(s) : s; 11778 } catch(e) {} 11779 } 11780 11781 function read(s, converter) { 11782 var value = config.raw ? s : parseCookieValue(s); 11783 return $.isFunction(converter) ? converter(value) : value; 11784 } 11785 11786 var config = $.cookie = function (key, value, options) { 11787 11788 // Write 11789 if (value !== undefined && !$.isFunction(value)) { 11790 options = $.extend({}, config.defaults, options); 11791 11792 if (typeof options.expires === 'number') { 11793 var days = options.expires, t = options.expires = new Date(); 11794 t.setDate(t.getDate() + days); 11795 } 11796 11797 return (document.cookie = [ 11798 encode(key), '=', stringifyCookieValue(value), 11799 options.expires ? '; expires=' + options.expires.toUTCString() : '', // use expires attribute, max-age is not supported by IE 11800 options.path ? '; path=' + options.path : '', 11801 options.domain ? '; domain=' + options.domain : '', 11802 options.secure ? '; secure' : '' 11803 ].join('')); 11804 } 11805 11806 // Read 11807 11808 var result = key ? undefined : {}; 11809 11810 // To prevent the for loop in the first place assign an empty array 11811 // in case there are no cookies at all. Also prevents odd result when 11812 // calling $.cookie(). 11813 var cookies = document.cookie ? document.cookie.split('; ') : []; 11814 11815 for (var i = 0, l = cookies.length; i < l; i++) { 11816 var parts = cookies[i].split('='); 11817 var name = decode(parts.shift()); 11818 var cookie = parts.join('='); 11819 11820 if (key && key === name) { 11821 // If second argument (value) is a function it's a converter... 11822 result = read(cookie, value); 11823 break; 11824 } 11825 11826 // Prevent storing a cookie that we couldn't decode. 11827 if (!key && (cookie = read(cookie)) !== undefined) { 11828 result[name] = cookie; 11829 } 11830 } 11831 11832 return result; 11833 }; 11834 11835 config.defaults = {}; 11836 11837 $.removeCookie = function (key, options) { 11838 if ($.cookie(key) === undefined) { 11839 return false;
11840 } 11841 11842 // Must not alter options, thus extending a fresh object... 11843 $.cookie(key, '', $.extend({}, options, { expires: -1 })); 11844 return !$.cookie(key); 11845 }; 11846 11847}));
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.