////////////////////////////////////////////////////////////////////////// // // // This is a generated file. You can view the original // // source in your browser if your browser supports source maps. // // // // If you are using Chrome, open the Developer Tools and click the gear // // icon in its lower right corner. In the General Settings panel, turn // // on 'Enable source maps'. // // // // If you are using Firefox 23, go to `about:config` and set the // // `devtools.debugger.source-maps-enabled` preference to true. // // (The preference should be on by default in Firefox 24; versions // // older than 23 do not support source maps.) // // // ////////////////////////////////////////////////////////////////////////// (function () { /* Imports */ var Meteor = Package.meteor.Meteor; /* Package-scope variables */ var $, jQuery; (function () { /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // // // packages/jquery/jquery.js // // // /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // /*! // 1 * jQuery JavaScript Library v1.11.2 // 2 * http://jquery.com/ // 3 * // 4 * Includes Sizzle.js // 5 * http://sizzlejs.com/ // 6 * // 7 * Copyright 2005, 2014 jQuery Foundation, Inc. and other contributors // 8 * Released under the MIT license // 9 * http://jquery.org/license // 10 * // 11 * Date: 2014-12-17T15:27Z // 12 */ // 13 // 14 (function( global, factory ) { // 15 // 16 if ( typeof module === "object" && typeof module.exports === "object" ) { // 17 // For CommonJS and CommonJS-like environments where a proper window is present, // 18 // execute the factory and get jQuery // 19 // For environments that do not inherently posses a window with a document // 20 // (such as Node.js), expose a jQuery-making factory as module.exports // 21 // This accentuates the need for the creation of a real window // 22 // e.g. var jQuery = require("jquery")(window); // 23 // See ticket #14549 for more info // 24 module.exports = global.document ? // 25 factory( global, true ) : // 26 function( w ) { // 27 if ( !w.document ) { // 28 throw new Error( "jQuery requires a window with a document" ); // 29 } // 30 return factory( w ); // 31 }; // 32 } else { // 33 factory( global ); // 34 } // 35 // 36 // Pass this if window is not defined yet // 37 }(typeof window !== "undefined" ? window : this, function( window, noGlobal ) { // 38 // 39 // Can't do this because several apps including ASP.NET trace // 40 // the stack via arguments.caller.callee and Firefox dies if // 41 // you try to trace through "use strict" call chains. (#13335) // 42 // Support: Firefox 18+ // 43 // // 44 // 45 var deletedIds = []; // 46 // 47 var slice = deletedIds.slice; // 48 // 49 var concat = deletedIds.concat; // 50 // 51 var push = deletedIds.push; // 52 // 53 var indexOf = deletedIds.indexOf; // 54 // 55 var class2type = {}; // 56 // 57 var toString = class2type.toString; // 58 // 59 var hasOwn = class2type.hasOwnProperty; // 60 // 61 var support = {}; // 62 // 63 // 64 // 65 var // 66 version = "1.11.2", // 67 // 68 // Define a local copy of jQuery // 69 jQuery = function( selector, context ) { // 70 // The jQuery object is actually just the init constructor 'enhanced' // 71 // Need init if jQuery is called (just allow error to be thrown if not included) // 72 return new jQuery.fn.init( selector, context ); // 73 }, // 74 // 75 // Support: Android<4.1, IE<9 // 76 // Make sure we trim BOM and NBSP // 77 rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, // 78 // 79 // Matches dashed string for camelizing // 80 rmsPrefix = /^-ms-/, // 81 rdashAlpha = /-([\da-z])/gi, // 82 // 83 // Used by jQuery.camelCase as callback to replace() // 84 fcamelCase = function( all, letter ) { // 85 return letter.toUpperCase(); // 86 }; // 87 // 88 jQuery.fn = jQuery.prototype = { // 89 // The current version of jQuery being used // 90 jquery: version, // 91 // 92 constructor: jQuery, // 93 // 94 // Start with an empty selector // 95 selector: "", // 96 // 97 // The default length of a jQuery object is 0 // 98 length: 0, // 99 // 100 toArray: function() { // 101 return slice.call( this ); // 102 }, // 103 // 104 // Get the Nth element in the matched element set OR // 105 // Get the whole matched element set as a clean array // 106 get: function( num ) { // 107 return num != null ? // 108 // 109 // Return just the one element from the set // 110 ( num < 0 ? this[ num + this.length ] : this[ num ] ) : // 111 // 112 // Return all the elements in a clean array // 113 slice.call( this ); // 114 }, // 115 // 116 // Take an array of elements and push it onto the stack // 117 // (returning the new matched element set) // 118 pushStack: function( elems ) { // 119 // 120 // Build a new jQuery matched element set // 121 var ret = jQuery.merge( this.constructor(), elems ); // 122 // 123 // Add the old object onto the stack (as a reference) // 124 ret.prevObject = this; // 125 ret.context = this.context; // 126 // 127 // Return the newly-formed element set // 128 return ret; // 129 }, // 130 // 131 // Execute a callback for every element in the matched set. // 132 // (You can seed the arguments with an array of args, but this is // 133 // only used internally.) // 134 each: function( callback, args ) { // 135 return jQuery.each( this, callback, args ); // 136 }, // 137 // 138 map: function( callback ) { // 139 return this.pushStack( jQuery.map(this, function( elem, i ) { // 140 return callback.call( elem, i, elem ); // 141 })); // 142 }, // 143 // 144 slice: function() { // 145 return this.pushStack( slice.apply( this, arguments ) ); // 146 }, // 147 // 148 first: function() { // 149 return this.eq( 0 ); // 150 }, // 151 // 152 last: function() { // 153 return this.eq( -1 ); // 154 }, // 155 // 156 eq: function( i ) { // 157 var len = this.length, // 158 j = +i + ( i < 0 ? len : 0 ); // 159 return this.pushStack( j >= 0 && j < len ? [ this[j] ] : [] ); // 160 }, // 161 // 162 end: function() { // 163 return this.prevObject || this.constructor(null); // 164 }, // 165 // 166 // For internal use only. // 167 // Behaves like an Array's method, not like a jQuery method. // 168 push: push, // 169 sort: deletedIds.sort, // 170 splice: deletedIds.splice // 171 }; // 172 // 173 jQuery.extend = jQuery.fn.extend = function() { // 174 var src, copyIsArray, copy, name, options, clone, // 175 target = arguments[0] || {}, // 176 i = 1, // 177 length = arguments.length, // 178 deep = false; // 179 // 180 // Handle a deep copy situation // 181 if ( typeof target === "boolean" ) { // 182 deep = target; // 183 // 184 // skip the boolean and the target // 185 target = arguments[ i ] || {}; // 186 i++; // 187 } // 188 // 189 // Handle case when target is a string or something (possible in deep copy) // 190 if ( typeof target !== "object" && !jQuery.isFunction(target) ) { // 191 target = {}; // 192 } // 193 // 194 // extend jQuery itself if only one argument is passed // 195 if ( i === length ) { // 196 target = this; // 197 i--; // 198 } // 199 // 200 for ( ; i < length; i++ ) { // 201 // Only deal with non-null/undefined values // 202 if ( (options = arguments[ i ]) != null ) { // 203 // Extend the base object // 204 for ( name in options ) { // 205 src = target[ name ]; // 206 copy = options[ name ]; // 207 // 208 // Prevent never-ending loop // 209 if ( target === copy ) { // 210 continue; // 211 } // 212 // 213 // Recurse if we're merging plain objects or arrays // 214 if ( deep && copy && ( jQuery.isPlainObject(copy) || (copyIsArray = jQuery.isArray(copy)) ) ) { // 215 if ( copyIsArray ) { // 216 copyIsArray = false; // 217 clone = src && jQuery.isArray(src) ? src : []; // 218 // 219 } else { // 220 clone = src && jQuery.isPlainObject(src) ? src : {}; // 221 } // 222 // 223 // Never move original objects, clone them // 224 target[ name ] = jQuery.extend( deep, clone, copy ); // 225 // 226 // Don't bring in undefined values // 227 } else if ( copy !== undefined ) { // 228 target[ name ] = copy; // 229 } // 230 } // 231 } // 232 } // 233 // 234 // Return the modified object // 235 return target; // 236 }; // 237 // 238 jQuery.extend({ // 239 // Unique for each copy of jQuery on the page // 240 expando: "jQuery" + ( version + Math.random() ).replace( /\D/g, "" ), // 241 // 242 // Assume jQuery is ready without the ready module // 243 isReady: true, // 244 // 245 error: function( msg ) { // 246 throw new Error( msg ); // 247 }, // 248 // 249 noop: function() {}, // 250 // 251 // See test/unit/core.js for details concerning isFunction. // 252 // Since version 1.3, DOM methods and functions like alert // 253 // aren't supported. They return false on IE (#2968). // 254 isFunction: function( obj ) { // 255 return jQuery.type(obj) === "function"; // 256 }, // 257 // 258 isArray: Array.isArray || function( obj ) { // 259 return jQuery.type(obj) === "array"; // 260 }, // 261 // 262 isWindow: function( obj ) { // 263 /* jshint eqeqeq: false */ // 264 return obj != null && obj == obj.window; // 265 }, // 266 // 267 isNumeric: function( obj ) { // 268 // parseFloat NaNs numeric-cast false positives (null|true|false|"") // 269 // ...but misinterprets leading-number strings, particularly hex literals ("0x...") // 270 // subtraction forces infinities to NaN // 271 // adding 1 corrects loss of precision from parseFloat (#15100) // 272 return !jQuery.isArray( obj ) && (obj - parseFloat( obj ) + 1) >= 0; // 273 }, // 274 // 275 isEmptyObject: function( obj ) { // 276 var name; // 277 for ( name in obj ) { // 278 return false; // 279 } // 280 return true; // 281 }, // 282 // 283 isPlainObject: function( obj ) { // 284 var key; // 285 // 286 // Must be an Object. // 287 // Because of IE, we also have to check the presence of the constructor property. // 288 // Make sure that DOM nodes and window objects don't pass through, as well // 289 if ( !obj || jQuery.type(obj) !== "object" || obj.nodeType || jQuery.isWindow( obj ) ) { // 290 return false; // 291 } // 292 // 293 try { // 294 // Not own constructor property must be Object // 295 if ( obj.constructor && // 296 !hasOwn.call(obj, "constructor") && // 297 !hasOwn.call(obj.constructor.prototype, "isPrototypeOf") ) { // 298 return false; // 299 } // 300 } catch ( e ) { // 301 // IE8,9 Will throw exceptions on certain host objects #9897 // 302 return false; // 303 } // 304 // 305 // Support: IE<9 // 306 // Handle iteration over inherited properties before own properties. // 307 if ( support.ownLast ) { // 308 for ( key in obj ) { // 309 return hasOwn.call( obj, key ); // 310 } // 311 } // 312 // 313 // Own properties are enumerated firstly, so to speed up, // 314 // if last one is own, then all properties are own. // 315 for ( key in obj ) {} // 316 // 317 return key === undefined || hasOwn.call( obj, key ); // 318 }, // 319 // 320 type: function( obj ) { // 321 if ( obj == null ) { // 322 return obj + ""; // 323 } // 324 return typeof obj === "object" || typeof obj === "function" ? // 325 class2type[ toString.call(obj) ] || "object" : // 326 typeof obj; // 327 }, // 328 // 329 // Evaluates a script in a global context // 330 // Workarounds based on findings by Jim Driscoll // 331 // http://weblogs.java.net/blog/driscoll/archive/2009/09/08/eval-javascript-global-context // 332 globalEval: function( data ) { // 333 if ( data && jQuery.trim( data ) ) { // 334 // We use execScript on Internet Explorer // 335 // We use an anonymous function so that context is window // 336 // rather than jQuery in Firefox // 337 ( window.execScript || function( data ) { // 338 window[ "eval" ].call( window, data ); // 339 } )( data ); // 340 } // 341 }, // 342 // 343 // Convert dashed to camelCase; used by the css and data modules // 344 // Microsoft forgot to hump their vendor prefix (#9572) // 345 camelCase: function( string ) { // 346 return string.replace( rmsPrefix, "ms-" ).replace( rdashAlpha, fcamelCase ); // 347 }, // 348 // 349 nodeName: function( elem, name ) { // 350 return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase(); // 351 }, // 352 // 353 // args is for internal usage only // 354 each: function( obj, callback, args ) { // 355 var value, // 356 i = 0, // 357 length = obj.length, // 358 isArray = isArraylike( obj ); // 359 // 360 if ( args ) { // 361 if ( isArray ) { // 362 for ( ; i < length; i++ ) { // 363 value = callback.apply( obj[ i ], args ); // 364 // 365 if ( value === false ) { // 366 break; // 367 } // 368 } // 369 } else { // 370 for ( i in obj ) { // 371 value = callback.apply( obj[ i ], args ); // 372 // 373 if ( value === false ) { // 374 break; // 375 } // 376 } // 377 } // 378 // 379 // A special, fast, case for the most common use of each // 380 } else { // 381 if ( isArray ) { // 382 for ( ; i < length; i++ ) { // 383 value = callback.call( obj[ i ], i, obj[ i ] ); // 384 // 385 if ( value === false ) { // 386 break; // 387 } // 388 } // 389 } else { // 390 for ( i in obj ) { // 391 value = callback.call( obj[ i ], i, obj[ i ] ); // 392 // 393 if ( value === false ) { // 394 break; // 395 } // 396 } // 397 } // 398 } // 399 // 400 return obj; // 401 }, // 402 // 403 // Support: Android<4.1, IE<9 // 404 trim: function( text ) { // 405 return text == null ? // 406 "" : // 407 ( text + "" ).replace( rtrim, "" ); // 408 }, // 409 // 410 // results is for internal usage only // 411 makeArray: function( arr, results ) { // 412 var ret = results || []; // 413 // 414 if ( arr != null ) { // 415 if ( isArraylike( Object(arr) ) ) { // 416 jQuery.merge( ret, // 417 typeof arr === "string" ? // 418 [ arr ] : arr // 419 ); // 420 } else { // 421 push.call( ret, arr ); // 422 } // 423 } // 424 // 425 return ret; // 426 }, // 427 // 428 inArray: function( elem, arr, i ) { // 429 var len; // 430 // 431 if ( arr ) { // 432 if ( indexOf ) { // 433 return indexOf.call( arr, elem, i ); // 434 } // 435 // 436 len = arr.length; // 437 i = i ? i < 0 ? Math.max( 0, len + i ) : i : 0; // 438 // 439 for ( ; i < len; i++ ) { // 440 // Skip accessing in sparse arrays // 441 if ( i in arr && arr[ i ] === elem ) { // 442 return i; // 443 } // 444 } // 445 } // 446 // 447 return -1; // 448 }, // 449 // 450 merge: function( first, second ) { // 451 var len = +second.length, // 452 j = 0, // 453 i = first.length; // 454 // 455 while ( j < len ) { // 456 first[ i++ ] = second[ j++ ]; // 457 } // 458 // 459 // Support: IE<9 // 460 // Workaround casting of .length to NaN on otherwise arraylike objects (e.g., NodeLists) // 461 if ( len !== len ) { // 462 while ( second[j] !== undefined ) { // 463 first[ i++ ] = second[ j++ ]; // 464 } // 465 } // 466 // 467 first.length = i; // 468 // 469 return first; // 470 }, // 471 // 472 grep: function( elems, callback, invert ) { // 473 var callbackInverse, // 474 matches = [], // 475 i = 0, // 476 length = elems.length, // 477 callbackExpect = !invert; // 478 // 479 // Go through the array, only saving the items // 480 // that pass the validator function // 481 for ( ; i < length; i++ ) { // 482 callbackInverse = !callback( elems[ i ], i ); // 483 if ( callbackInverse !== callbackExpect ) { // 484 matches.push( elems[ i ] ); // 485 } // 486 } // 487 // 488 return matches; // 489 }, // 490 // 491 // arg is for internal usage only // 492 map: function( elems, callback, arg ) { // 493 var value, // 494 i = 0, // 495 length = elems.length, // 496 isArray = isArraylike( elems ), // 497 ret = []; // 498 // 499 // Go through the array, translating each of the items to their new values // 500 if ( isArray ) { // 501 for ( ; i < length; i++ ) { // 502 value = callback( elems[ i ], i, arg ); // 503 // 504 if ( value != null ) { // 505 ret.push( value ); // 506 } // 507 } // 508 // 509 // Go through every key on the object, // 510 } else { // 511 for ( i in elems ) { // 512 value = callback( elems[ i ], i, arg ); // 513 // 514 if ( value != null ) { // 515 ret.push( value ); // 516 } // 517 } // 518 } // 519 // 520 // Flatten any nested arrays // 521 return concat.apply( [], ret ); // 522 }, // 523 // 524 // A global GUID counter for objects // 525 guid: 1, // 526 // 527 // Bind a function to a context, optionally partially applying any // 528 // arguments. // 529 proxy: function( fn, context ) { // 530 var args, proxy, tmp; // 531 // 532 if ( typeof context === "string" ) { // 533 tmp = fn[ context ]; // 534 context = fn; // 535 fn = tmp; // 536 } // 537 // 538 // Quick check to determine if target is callable, in the spec // 539 // this throws a TypeError, but we will just return undefined. // 540 if ( !jQuery.isFunction( fn ) ) { // 541 return undefined; // 542 } // 543 // 544 // Simulated bind // 545 args = slice.call( arguments, 2 ); // 546 proxy = function() { // 547 return fn.apply( context || this, args.concat( slice.call( arguments ) ) ); // 548 }; // 549 // 550 // Set the guid of unique handler to the same of original handler, so it can be removed // 551 proxy.guid = fn.guid = fn.guid || jQuery.guid++; // 552 // 553 return proxy; // 554 }, // 555 // 556 now: function() { // 557 return +( new Date() ); // 558 }, // 559 // 560 // jQuery.support is not used in Core but other projects attach their // 561 // properties to it so it needs to exist. // 562 support: support // 563 }); // 564 // 565 // Populate the class2type map // 566 jQuery.each("Boolean Number String Function Array Date RegExp Object Error".split(" "), function(i, name) { // 567 class2type[ "[object " + name + "]" ] = name.toLowerCase(); // 568 }); // 569 // 570 function isArraylike( obj ) { // 571 var length = obj.length, // 572 type = jQuery.type( obj ); // 573 // 574 if ( type === "function" || jQuery.isWindow( obj ) ) { // 575 return false; // 576 } // 577 // 578 if ( obj.nodeType === 1 && length ) { // 579 return true; // 580 } // 581 // 582 return type === "array" || length === 0 || // 583 typeof length === "number" && length > 0 && ( length - 1 ) in obj; // 584 } // 585 var Sizzle = // 586 /*! // 587 * Sizzle CSS Selector Engine v2.2.0-pre // 588 * http://sizzlejs.com/ // 589 * // 590 * Copyright 2008, 2014 jQuery Foundation, Inc. and other contributors // 591 * Released under the MIT license // 592 * http://jquery.org/license // 593 * // 594 * Date: 2014-12-16 // 595 */ // 596 (function( window ) { // 597 // 598 var i, // 599 support, // 600 Expr, // 601 getText, // 602 isXML, // 603 tokenize, // 604 compile, // 605 select, // 606 outermostContext, // 607 sortInput, // 608 hasDuplicate, // 609 // 610 // Local document vars // 611 setDocument, // 612 document, // 613 docElem, // 614 documentIsHTML, // 615 rbuggyQSA, // 616 rbuggyMatches, // 617 matches, // 618 contains, // 619 // 620 // Instance-specific data // 621 expando = "sizzle" + 1 * new Date(), // 622 preferredDoc = window.document, // 623 dirruns = 0, // 624 done = 0, // 625 classCache = createCache(), // 626 tokenCache = createCache(), // 627 compilerCache = createCache(), // 628 sortOrder = function( a, b ) { // 629 if ( a === b ) { // 630 hasDuplicate = true; // 631 } // 632 return 0; // 633 }, // 634 // 635 // General-purpose constants // 636 MAX_NEGATIVE = 1 << 31, // 637 // 638 // Instance methods // 639 hasOwn = ({}).hasOwnProperty, // 640 arr = [], // 641 pop = arr.pop, // 642 push_native = arr.push, // 643 push = arr.push, // 644 slice = arr.slice, // 645 // Use a stripped-down indexOf as it's faster than native // 646 // http://jsperf.com/thor-indexof-vs-for/5 // 647 indexOf = function( list, elem ) { // 648 var i = 0, // 649 len = list.length; // 650 for ( ; i < len; i++ ) { // 651 if ( list[i] === elem ) { // 652 return i; // 653 } // 654 } // 655 return -1; // 656 }, // 657 // 658 booleans = "checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped", // 660 // Regular expressions // 661 // 662 // Whitespace characters http://www.w3.org/TR/css3-selectors/#whitespace // 663 whitespace = "[\\x20\\t\\r\\n\\f]", // 664 // http://www.w3.org/TR/css3-syntax/#characters // 665 characterEncoding = "(?:\\\\.|[\\w-]|[^\\x00-\\xa0])+", // 666 // 667 // Loosely modeled on CSS identifier characters // 668 // An unquoted value should be a CSS identifier http://www.w3.org/TR/css3-selectors/#attribute-selectors // 669 // Proper syntax: http://www.w3.org/TR/CSS21/syndata.html#value-def-identifier // 670 identifier = characterEncoding.replace( "w", "w#" ), // 671 // 672 // Attribute selectors: http://www.w3.org/TR/selectors/#attribute-selectors // 673 attributes = "\\[" + whitespace + "*(" + characterEncoding + ")(?:" + whitespace + // 674 // Operator (capture 2) // 675 "*([*^$|!~]?=)" + whitespace + // 676 // "Attribute values must be CSS identifiers [capture 5] or strings [capture 3 or capture 4]" // 677 "*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|(" + identifier + "))|)" + whitespace + // 678 "*\\]", // 679 // 680 pseudos = ":(" + characterEncoding + ")(?:\\((" + // 681 // To reduce the number of selectors needing tokenize in the preFilter, prefer arguments: // 682 // 1. quoted (capture 3; capture 4 or capture 5) // 683 "('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|" + // 684 // 2. simple (capture 6) // 685 "((?:\\\\.|[^\\\\()[\\]]|" + attributes + ")*)|" + // 686 // 3. anything else (capture 2) // 687 ".*" + // 688 ")\\)|)", // 689 // 690 // Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter // 691 rwhitespace = new RegExp( whitespace + "+", "g" ), // 692 rtrim = new RegExp( "^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" + whitespace + "+$", "g" ), // 693 // 694 rcomma = new RegExp( "^" + whitespace + "*," + whitespace + "*" ), // 695 rcombinators = new RegExp( "^" + whitespace + "*([>+~]|" + whitespace + ")" + whitespace + "*" ), // 696 // 697 rattributeQuotes = new RegExp( "=" + whitespace + "*([^\\]'\"]*?)" + whitespace + "*\\]", "g" ), // 698 // 699 rpseudo = new RegExp( pseudos ), // 700 ridentifier = new RegExp( "^" + identifier + "$" ), // 701 // 702 matchExpr = { // 703 "ID": new RegExp( "^#(" + characterEncoding + ")" ), // 704 "CLASS": new RegExp( "^\\.(" + characterEncoding + ")" ), // 705 "TAG": new RegExp( "^(" + characterEncoding.replace( "w", "w*" ) + ")" ), // 706 "ATTR": new RegExp( "^" + attributes ), // 707 "PSEUDO": new RegExp( "^" + pseudos ), // 708 "CHILD": new RegExp( "^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(" + whitespace + // 709 "*(even|odd|(([+-]|)(\\d*)n|)" + whitespace + "*(?:([+-]|)" + whitespace + // 710 "*(\\d+)|))" + whitespace + "*\\)|)", "i" ), // 711 "bool": new RegExp( "^(?:" + booleans + ")$", "i" ), // 712 // For use in libraries implementing .is() // 713 // We use this for POS matching in `select` // 714 "needsContext": new RegExp( "^" + whitespace + "*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(" + // 715 whitespace + "*((?:-\\d)?\\d*)" + whitespace + "*\\)|)(?=[^-]|$)", "i" ) // 716 }, // 717 // 718 rinputs = /^(?:input|select|textarea|button)$/i, // 719 rheader = /^h\d$/i, // 720 // 721 rnative = /^[^{]+\{\s*\[native \w/, // 722 // 723 // Easily-parseable/retrievable ID or TAG or CLASS selectors // 724 rquickExpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/, // 725 // 726 rsibling = /[+~]/, // 727 rescape = /'|\\/g, // 728 // 729 // CSS escapes http://www.w3.org/TR/CSS21/syndata.html#escaped-characters // 730 runescape = new RegExp( "\\\\([\\da-f]{1,6}" + whitespace + "?|(" + whitespace + ")|.)", "ig" ), // 731 funescape = function( _, escaped, escapedWhitespace ) { // 732 var high = "0x" + escaped - 0x10000; // 733 // NaN means non-codepoint // 734 // Support: Firefox<24 // 735 // Workaround erroneous numeric interpretation of +"0x" // 736 return high !== high || escapedWhitespace ? // 737 escaped : // 738 high < 0 ? // 739 // BMP codepoint // 740 String.fromCharCode( high + 0x10000 ) : // 741 // Supplemental Plane codepoint (surrogate pair) // 742 String.fromCharCode( high >> 10 | 0xD800, high & 0x3FF | 0xDC00 ); // 743 }, // 744 // 745 // Used for iframes // 746 // See setDocument() // 747 // Removing the function wrapper causes a "Permission Denied" // 748 // error in IE // 749 unloadHandler = function() { // 750 setDocument(); // 751 }; // 752 // 753 // Optimize for push.apply( _, NodeList ) // 754 try { // 755 push.apply( // 756 (arr = slice.call( preferredDoc.childNodes )), // 757 preferredDoc.childNodes // 758 ); // 759 // Support: Android<4.0 // 760 // Detect silently failing push.apply // 761 arr[ preferredDoc.childNodes.length ].nodeType; // 762 } catch ( e ) { // 763 push = { apply: arr.length ? // 764 // 765 // Leverage slice if possible // 766 function( target, els ) { // 767 push_native.apply( target, slice.call(els) ); // 768 } : // 769 // 770 // Support: IE<9 // 771 // Otherwise append directly // 772 function( target, els ) { // 773 var j = target.length, // 774 i = 0; // 775 // Can't trust NodeList.length // 776 while ( (target[j++] = els[i++]) ) {} // 777 target.length = j - 1; // 778 } // 779 }; // 780 } // 781 // 782 function Sizzle( selector, context, results, seed ) { // 783 var match, elem, m, nodeType, // 784 // QSA vars // 785 i, groups, old, nid, newContext, newSelector; // 786 // 787 if ( ( context ? context.ownerDocument || context : preferredDoc ) !== document ) { // 788 setDocument( context ); // 789 } // 790 // 791 context = context || document; // 792 results = results || []; // 793 nodeType = context.nodeType; // 794 // 795 if ( typeof selector !== "string" || !selector || // 796 nodeType !== 1 && nodeType !== 9 && nodeType !== 11 ) { // 797 // 798 return results; // 799 } // 800 // 801 if ( !seed && documentIsHTML ) { // 802 // 803 // Try to shortcut find operations when possible (e.g., not under DocumentFragment) // 804 if ( nodeType !== 11 && (match = rquickExpr.exec( selector )) ) { // 805 // Speed-up: Sizzle("#ID") // 806 if ( (m = match[1]) ) { // 807 if ( nodeType === 9 ) { // 808 elem = context.getElementById( m ); // 809 // Check parentNode to catch when Blackberry 4.6 returns // 810 // nodes that are no longer in the document (jQuery #6963) // 811 if ( elem && elem.parentNode ) { // 812 // Handle the case where IE, Opera, and Webkit return items // 813 // by name instead of ID // 814 if ( elem.id === m ) { // 815 results.push( elem ); // 816 return results; // 817 } // 818 } else { // 819 return results; // 820 } // 821 } else { // 822 // Context is not a document // 823 if ( context.ownerDocument && (elem = context.ownerDocument.getElementById( m )) && // 824 contains( context, elem ) && elem.id === m ) { // 825 results.push( elem ); // 826 return results; // 827 } // 828 } // 829 // 830 // Speed-up: Sizzle("TAG") // 831 } else if ( match[2] ) { // 832 push.apply( results, context.getElementsByTagName( selector ) ); // 833 return results; // 834 // 835 // Speed-up: Sizzle(".CLASS") // 836 } else if ( (m = match[3]) && support.getElementsByClassName ) { // 837 push.apply( results, context.getElementsByClassName( m ) ); // 838 return results; // 839 } // 840 } // 841 // 842 // QSA path // 843 if ( support.qsa && (!rbuggyQSA || !rbuggyQSA.test( selector )) ) { // 844 nid = old = expando; // 845 newContext = context; // 846 newSelector = nodeType !== 1 && selector; // 847 // 848 // qSA works strangely on Element-rooted queries // 849 // We can work around this by specifying an extra ID on the root // 850 // and working up from there (Thanks to Andrew Dupont for the technique) // 851 // IE 8 doesn't work on object elements // 852 if ( nodeType === 1 && context.nodeName.toLowerCase() !== "object" ) { // 853 groups = tokenize( selector ); // 854 // 855 if ( (old = context.getAttribute("id")) ) { // 856 nid = old.replace( rescape, "\\$&" ); // 857 } else { // 858 context.setAttribute( "id", nid ); // 859 } // 860 nid = "[id='" + nid + "'] "; // 861 // 862 i = groups.length; // 863 while ( i-- ) { // 864 groups[i] = nid + toSelector( groups[i] ); // 865 } // 866 newContext = rsibling.test( selector ) && testContext( context.parentNode ) || context; // 867 newSelector = groups.join(","); // 868 } // 869 // 870 if ( newSelector ) { // 871 try { // 872 push.apply( results, // 873 newContext.querySelectorAll( newSelector ) // 874 ); // 875 return results; // 876 } catch(qsaError) { // 877 } finally { // 878 if ( !old ) { // 879 context.removeAttribute("id"); // 880 } // 881 } // 882 } // 883 } // 884 } // 885 // 886 // All others // 887 return select( selector.replace( rtrim, "$1" ), context, results, seed ); // 888 } // 889 // 890 /** // 891 * Create key-value caches of limited size // 892 * @returns {Function(string, Object)} Returns the Object data after storing it on itself with // 893 * property name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength) // 894 * deleting the oldest entry // 895 */ // 896 function createCache() { // 897 var keys = []; // 898 // 899 function cache( key, value ) { // 900 // Use (key + " ") to avoid collision with native prototype properties (see Issue #157) // 901 if ( keys.push( key + " " ) > Expr.cacheLength ) { // 902 // Only keep the most recent entries // 903 delete cache[ keys.shift() ]; // 904 } // 905 return (cache[ key + " " ] = value); // 906 } // 907 return cache; // 908 } // 909 // 910 /** // 911 * Mark a function for special use by Sizzle // 912 * @param {Function} fn The function to mark // 913 */ // 914 function markFunction( fn ) { // 915 fn[ expando ] = true; // 916 return fn; // 917 } // 918 // 919 /** // 920 * Support testing using an element // 921 * @param {Function} fn Passed the created div and expects a boolean result // 922 */ // 923 function assert( fn ) { // 924 var div = document.createElement("div"); // 925 // 926 try { // 927 return !!fn( div ); // 928 } catch (e) { // 929 return false; // 930 } finally { // 931 // Remove from its parent by default // 932 if ( div.parentNode ) { // 933 div.parentNode.removeChild( div ); // 934 } // 935 // release memory in IE // 936 div = null; // 937 } // 938 } // 939 // 940 /** // 941 * Adds the same handler for all of the specified attrs // 942 * @param {String} attrs Pipe-separated list of attributes // 943 * @param {Function} handler The method that will be applied // 944 */ // 945 function addHandle( attrs, handler ) { // 946 var arr = attrs.split("|"), // 947 i = attrs.length; // 948 // 949 while ( i-- ) { // 950 Expr.attrHandle[ arr[i] ] = handler; // 951 } // 952 } // 953 // 954 /** // 955 * Checks document order of two siblings // 956 * @param {Element} a // 957 * @param {Element} b // 958 * @returns {Number} Returns less than 0 if a precedes b, greater than 0 if a follows b // 959 */ // 960 function siblingCheck( a, b ) { // 961 var cur = b && a, // 962 diff = cur && a.nodeType === 1 && b.nodeType === 1 && // 963 ( ~b.sourceIndex || MAX_NEGATIVE ) - // 964 ( ~a.sourceIndex || MAX_NEGATIVE ); // 965 // 966 // Use IE sourceIndex if available on both nodes // 967 if ( diff ) { // 968 return diff; // 969 } // 970 // 971 // Check if b follows a // 972 if ( cur ) { // 973 while ( (cur = cur.nextSibling) ) { // 974 if ( cur === b ) { // 975 return -1; // 976 } // 977 } // 978 } // 979 // 980 return a ? 1 : -1; // 981 } // 982 // 983 /** // 984 * Returns a function to use in pseudos for input types // 985 * @param {String} type // 986 */ // 987 function createInputPseudo( type ) { // 988 return function( elem ) { // 989 var name = elem.nodeName.toLowerCase(); // 990 return name === "input" && elem.type === type; // 991 }; // 992 } // 993 // 994 /** // 995 * Returns a function to use in pseudos for buttons // 996 * @param {String} type // 997 */ // 998 function createButtonPseudo( type ) { // 999 return function( elem ) { // 1000 var name = elem.nodeName.toLowerCase(); // 1001 return (name === "input" || name === "button") && elem.type === type; // 1002 }; // 1003 } // 1004 // 1005 /** // 1006 * Returns a function to use in pseudos for positionals // 1007 * @param {Function} fn // 1008 */ // 1009 function createPositionalPseudo( fn ) { // 1010 return markFunction(function( argument ) { // 1011 argument = +argument; // 1012 return markFunction(function( seed, matches ) { // 1013 var j, // 1014 matchIndexes = fn( [], seed.length, argument ), // 1015 i = matchIndexes.length; // 1016 // 1017 // Match elements found at the specified indexes // 1018 while ( i-- ) { // 1019 if ( seed[ (j = matchIndexes[i]) ] ) { // 1020 seed[j] = !(matches[j] = seed[j]); // 1021 } // 1022 } // 1023 }); // 1024 }); // 1025 } // 1026 // 1027 /** // 1028 * Checks a node for validity as a Sizzle context // 1029 * @param {Element|Object=} context // 1030 * @returns {Element|Object|Boolean} The input node if acceptable, otherwise a falsy value // 1031 */ // 1032 function testContext( context ) { // 1033 return context && typeof context.getElementsByTagName !== "undefined" && context; // 1034 } // 1035 // 1036 // Expose support vars for convenience // 1037 support = Sizzle.support = {}; // 1038 // 1039 /** // 1040 * Detects XML nodes // 1041 * @param {Element|Object} elem An element or a document // 1042 * @returns {Boolean} True iff elem is a non-HTML XML node // 1043 */ // 1044 isXML = Sizzle.isXML = function( elem ) { // 1045 // documentElement is verified for cases where it doesn't yet exist // 1046 // (such as loading iframes in IE - #4833) // 1047 var documentElement = elem && (elem.ownerDocument || elem).documentElement; // 1048 return documentElement ? documentElement.nodeName !== "HTML" : false; // 1049 }; // 1050 // 1051 /** // 1052 * Sets document-related variables once based on the current document // 1053 * @param {Element|Object} [doc] An element or document object to use to set the document // 1054 * @returns {Object} Returns the current document // 1055 */ // 1056 setDocument = Sizzle.setDocument = function( node ) { // 1057 var hasCompare, parent, // 1058 doc = node ? node.ownerDocument || node : preferredDoc; // 1059 // 1060 // If no document and documentElement is available, return // 1061 if ( doc === document || doc.nodeType !== 9 || !doc.documentElement ) { // 1062 return document; // 1063 } // 1064 // 1065 // Set our document // 1066 document = doc; // 1067 docElem = doc.documentElement; // 1068 parent = doc.defaultView; // 1069 // 1070 // Support: IE>8 // 1071 // If iframe document is assigned to "document" variable and if iframe has been reloaded, // 1072 // IE will throw "permission denied" error when accessing "document" variable, see jQuery #13936 // 1073 // IE6-8 do not support the defaultView property so parent will be undefined // 1074 if ( parent && parent !== parent.top ) { // 1075 // IE11 does not have attachEvent, so all must suffer // 1076 if ( parent.addEventListener ) { // 1077 parent.addEventListener( "unload", unloadHandler, false ); // 1078 } else if ( parent.attachEvent ) { // 1079 parent.attachEvent( "onunload", unloadHandler ); // 1080 } // 1081 } // 1082 // 1083 /* Support tests // 1084 ---------------------------------------------------------------------- */ // 1085 documentIsHTML = !isXML( doc ); // 1086 // 1087 /* Attributes // 1088 ---------------------------------------------------------------------- */ // 1089 // 1090 // Support: IE<8 // 1091 // Verify that getAttribute really returns attributes and not properties // 1092 // (excepting IE8 booleans) // 1093 support.attributes = assert(function( div ) { // 1094 div.className = "i"; // 1095 return !div.getAttribute("className"); // 1096 }); // 1097 // 1098 /* getElement(s)By* // 1099 ---------------------------------------------------------------------- */ // 1100 // 1101 // Check if getElementsByTagName("*") returns only elements // 1102 support.getElementsByTagName = assert(function( div ) { // 1103 div.appendChild( doc.createComment("") ); // 1104 return !div.getElementsByTagName("*").length; // 1105 }); // 1106 // 1107 // Support: IE<9 // 1108 support.getElementsByClassName = rnative.test( doc.getElementsByClassName ); // 1109 // 1110 // Support: IE<10 // 1111 // Check if getElementById returns elements by name // 1112 // The broken getElementById methods don't pick up programatically-set names, // 1113 // so use a roundabout getElementsByName test // 1114 support.getById = assert(function( div ) { // 1115 docElem.appendChild( div ).id = expando; // 1116 return !doc.getElementsByName || !doc.getElementsByName( expando ).length; // 1117 }); // 1118 // 1119 // ID find and filter // 1120 if ( support.getById ) { // 1121 Expr.find["ID"] = function( id, context ) { // 1122 if ( typeof context.getElementById !== "undefined" && documentIsHTML ) { // 1123 var m = context.getElementById( id ); // 1124 // Check parentNode to catch when Blackberry 4.6 returns // 1125 // nodes that are no longer in the document #6963 // 1126 return m && m.parentNode ? [ m ] : []; // 1127 } // 1128 }; // 1129 Expr.filter["ID"] = function( id ) { // 1130 var attrId = id.replace( runescape, funescape ); // 1131 return function( elem ) { // 1132 return elem.getAttribute("id") === attrId; // 1133 }; // 1134 }; // 1135 } else { // 1136 // Support: IE6/7 // 1137 // getElementById is not reliable as a find shortcut // 1138 delete Expr.find["ID"]; // 1139 // 1140 Expr.filter["ID"] = function( id ) { // 1141 var attrId = id.replace( runescape, funescape ); // 1142 return function( elem ) { // 1143 var node = typeof elem.getAttributeNode !== "undefined" && elem.getAttributeNode("id"); // 1144 return node && node.value === attrId; // 1145 }; // 1146 }; // 1147 } // 1148 // 1149 // Tag // 1150 Expr.find["TAG"] = support.getElementsByTagName ? // 1151 function( tag, context ) { // 1152 if ( typeof context.getElementsByTagName !== "undefined" ) { // 1153 return context.getElementsByTagName( tag ); // 1154 // 1155 // DocumentFragment nodes don't have gEBTN // 1156 } else if ( support.qsa ) { // 1157 return context.querySelectorAll( tag ); // 1158 } // 1159 } : // 1160 // 1161 function( tag, context ) { // 1162 var elem, // 1163 tmp = [], // 1164 i = 0, // 1165 // By happy coincidence, a (broken) gEBTN appears on DocumentFragment nodes too // 1166 results = context.getElementsByTagName( tag ); // 1167 // 1168 // Filter out possible comments // 1169 if ( tag === "*" ) { // 1170 while ( (elem = results[i++]) ) { // 1171 if ( elem.nodeType === 1 ) { // 1172 tmp.push( elem ); // 1173 } // 1174 } // 1175 // 1176 return tmp; // 1177 } // 1178 return results; // 1179 }; // 1180 // 1181 // Class // 1182 Expr.find["CLASS"] = support.getElementsByClassName && function( className, context ) { // 1183 if ( documentIsHTML ) { // 1184 return context.getElementsByClassName( className ); // 1185 } // 1186 }; // 1187 // 1188 /* QSA/matchesSelector // 1189 ---------------------------------------------------------------------- */ // 1190 // 1191 // QSA and matchesSelector support // 1192 // 1193 // matchesSelector(:active) reports false when true (IE9/Opera 11.5) // 1194 rbuggyMatches = []; // 1195 // 1196 // qSa(:focus) reports false when true (Chrome 21) // 1197 // We allow this because of a bug in IE8/9 that throws an error // 1198 // whenever `document.activeElement` is accessed on an iframe // 1199 // So, we allow :focus to pass through QSA all the time to avoid the IE error // 1200 // See http://bugs.jquery.com/ticket/13378 // 1201 rbuggyQSA = []; // 1202 // 1203 if ( (support.qsa = rnative.test( doc.querySelectorAll )) ) { // 1204 // Build QSA regex // 1205 // Regex strategy adopted from Diego Perini // 1206 assert(function( div ) { // 1207 // Select is set to empty string on purpose // 1208 // This is to test IE's treatment of not explicitly // 1209 // setting a boolean content attribute, // 1210 // since its presence should be enough // 1211 // http://bugs.jquery.com/ticket/12359 // 1212 docElem.appendChild( div ).innerHTML = "<a id='" + expando + "'></a>" + // 1213 "<select id='" + expando + "-\f]' msallowcapture=''>" + // 1214 "<option selected=''></option></select>"; // 1215 // 1216 // Support: IE8, Opera 11-12.16 // 1217 // Nothing should be selected when empty strings follow ^= or $= or *= // 1218 // The test attribute must be unknown in Opera but "safe" for WinRT // 1219 // http://msdn.microsoft.com/en-us/library/ie/hh465388.aspx#attribute_section // 1220 if ( div.querySelectorAll("[msallowcapture^='']").length ) { // 1221 rbuggyQSA.push( "[*^$]=" + whitespace + "*(?:''|\"\")" ); // 1222 } // 1223 // 1224 // Support: IE8 // 1225 // Boolean attributes and "value" are not treated correctly // 1226 if ( !div.querySelectorAll("[selected]").length ) { // 1227 rbuggyQSA.push( "\\[" + whitespace + "*(?:value|" + booleans + ")" ); // 1228 } // 1229 // 1230 // Support: Chrome<29, Android<4.2+, Safari<7.0+, iOS<7.0+, PhantomJS<1.9.7+ // 1231 if ( !div.querySelectorAll( "[id~=" + expando + "-]" ).length ) { // 1232 rbuggyQSA.push("~="); // 1233 } // 1234 // 1235 // Webkit/Opera - :checked should return selected option elements // 1236 // http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked // 1237 // IE8 throws error here and will not see later tests // 1238 if ( !div.querySelectorAll(":checked").length ) { // 1239 rbuggyQSA.push(":checked"); // 1240 } // 1241 // 1242 // Support: Safari 8+, iOS 8+ // 1243 // https://bugs.webkit.org/show_bug.cgi?id=136851 // 1244 // In-page `selector#id sibing-combinator selector` fails // 1245 if ( !div.querySelectorAll( "a#" + expando + "+*" ).length ) { // 1246 rbuggyQSA.push(".#.+[+~]"); // 1247 } // 1248 }); // 1249 // 1250 assert(function( div ) { // 1251 // Support: Windows 8 Native Apps // 1252 // The type and name attributes are restricted during .innerHTML assignment // 1253 var input = doc.createElement("input"); // 1254 input.setAttribute( "type", "hidden" ); // 1255 div.appendChild( input ).setAttribute( "name", "D" ); // 1256 // 1257 // Support: IE8 // 1258 // Enforce case-sensitivity of name attribute // 1259 if ( div.querySelectorAll("[name=d]").length ) { // 1260 rbuggyQSA.push( "name" + whitespace + "*[*^$|!~]?=" ); // 1261 } // 1262 // 1263 // FF 3.5 - :enabled/:disabled and hidden elements (hidden elements are still enabled) // 1264 // IE8 throws error here and will not see later tests // 1265 if ( !div.querySelectorAll(":enabled").length ) { // 1266 rbuggyQSA.push( ":enabled", ":disabled" ); // 1267 } // 1268 // 1269 // Opera 10-11 does not throw on post-comma invalid pseudos // 1270 div.querySelectorAll("*,:x"); // 1271 rbuggyQSA.push(",.*:"); // 1272 }); // 1273 } // 1274 // 1275 if ( (support.matchesSelector = rnative.test( (matches = docElem.matches || // 1276 docElem.webkitMatchesSelector || // 1277 docElem.mozMatchesSelector || // 1278 docElem.oMatchesSelector || // 1279 docElem.msMatchesSelector) )) ) { // 1280 // 1281 assert(function( div ) { // 1282 // Check to see if it's possible to do matchesSelector // 1283 // on a disconnected node (IE 9) // 1284 support.disconnectedMatch = matches.call( div, "div" ); // 1285 // 1286 // This should fail with an exception // 1287 // Gecko does not error, returns false instead // 1288 matches.call( div, "[s!='']:x" ); // 1289 rbuggyMatches.push( "!=", pseudos ); // 1290 }); // 1291 } // 1292 // 1293 rbuggyQSA = rbuggyQSA.length && new RegExp( rbuggyQSA.join("|") ); // 1294 rbuggyMatches = rbuggyMatches.length && new RegExp( rbuggyMatches.join("|") ); // 1295 // 1296 /* Contains // 1297 ---------------------------------------------------------------------- */ // 1298 hasCompare = rnative.test( docElem.compareDocumentPosition ); // 1299 // 1300 // Element contains another // 1301 // Purposefully does not implement inclusive descendent // 1302 // As in, an element does not contain itself // 1303 contains = hasCompare || rnative.test( docElem.contains ) ? // 1304 function( a, b ) { // 1305 var adown = a.nodeType === 9 ? a.documentElement : a, // 1306 bup = b && b.parentNode; // 1307 return a === bup || !!( bup && bup.nodeType === 1 && ( // 1308 adown.contains ? // 1309 adown.contains( bup ) : // 1310 a.compareDocumentPosition && a.compareDocumentPosition( bup ) & 16 // 1311 )); // 1312 } : // 1313 function( a, b ) { // 1314 if ( b ) { // 1315 while ( (b = b.parentNode) ) { // 1316 if ( b === a ) { // 1317 return true; // 1318 } // 1319 } // 1320 } // 1321 return false; // 1322 }; // 1323 // 1324 /* Sorting // 1325 ---------------------------------------------------------------------- */ // 1326 // 1327 // Document order sorting // 1328 sortOrder = hasCompare ? // 1329 function( a, b ) { // 1330 // 1331 // Flag for duplicate removal // 1332 if ( a === b ) { // 1333 hasDuplicate = true; // 1334 return 0; // 1335 } // 1336 // 1337 // Sort on method existence if only one input has compareDocumentPosition // 1338 var compare = !a.compareDocumentPosition - !b.compareDocumentPosition; // 1339 if ( compare ) { // 1340 return compare; // 1341 } // 1342 // 1343 // Calculate position if both inputs belong to the same document // 1344 compare = ( a.ownerDocument || a ) === ( b.ownerDocument || b ) ? // 1345 a.compareDocumentPosition( b ) : // 1346 // 1347 // Otherwise we know they are disconnected // 1348 1; // 1349 // 1350 // Disconnected nodes // 1351 if ( compare & 1 || // 1352 (!support.sortDetached && b.compareDocumentPosition( a ) === compare) ) { // 1353 // 1354 // Choose the first element that is related to our preferred document // 1355 if ( a === doc || a.ownerDocument === preferredDoc && contains(preferredDoc, a) ) { // 1356 return -1; // 1357 } // 1358 if ( b === doc || b.ownerDocument === preferredDoc && contains(preferredDoc, b) ) { // 1359 return 1; // 1360 } // 1361 // 1362 // Maintain original order // 1363 return sortInput ? // 1364 ( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) : // 1365 0; // 1366 } // 1367 // 1368 return compare & 4 ? -1 : 1; // 1369 } : // 1370 function( a, b ) { // 1371 // Exit early if the nodes are identical // 1372 if ( a === b ) { // 1373 hasDuplicate = true; // 1374 return 0; // 1375 } // 1376 // 1377 var cur, // 1378 i = 0, // 1379 aup = a.parentNode, // 1380 bup = b.parentNode, // 1381 ap = [ a ], // 1382 bp = [ b ]; // 1383 // 1384 // Parentless nodes are either documents or disconnected // 1385 if ( !aup || !bup ) { // 1386 return a === doc ? -1 : // 1387 b === doc ? 1 : // 1388 aup ? -1 : // 1389 bup ? 1 : // 1390 sortInput ? // 1391 ( indexOf( sortInput, a ) - indexOf( sortInput, b ) ) : // 1392 0; // 1393 // 1394 // If the nodes are siblings, we can do a quick check // 1395 } else if ( aup === bup ) { // 1396 return siblingCheck( a, b ); // 1397 } // 1398 // 1399 // Otherwise we need full lists of their ancestors for comparison // 1400 cur = a; // 1401 while ( (cur = cur.parentNode) ) { // 1402 ap.unshift( cur ); // 1403 } // 1404 cur = b; // 1405 while ( (cur = cur.parentNode) ) { // 1406 bp.unshift( cur ); // 1407 } // 1408 // 1409 // Walk down the tree looking for a discrepancy // 1410 while ( ap[i] === bp[i] ) { // 1411 i++; // 1412 } // 1413 // 1414 return i ? // 1415 // Do a sibling check if the nodes have a common ancestor // 1416 siblingCheck( ap[i], bp[i] ) : // 1417 // 1418 // Otherwise nodes in our document sort first // 1419 ap[i] === preferredDoc ? -1 : // 1420 bp[i] === preferredDoc ? 1 : // 1421 0; // 1422 }; // 1423 // 1424 return doc; // 1425 }; // 1426 // 1427 Sizzle.matches = function( expr, elements ) { // 1428 return Sizzle( expr, null, null, elements ); // 1429 }; // 1430 // 1431 Sizzle.matchesSelector = function( elem, expr ) { // 1432 // Set document vars if needed // 1433 if ( ( elem.ownerDocument || elem ) !== document ) { // 1434 setDocument( elem ); // 1435 } // 1436 // 1437 // Make sure that attribute selectors are quoted // 1438 expr = expr.replace( rattributeQuotes, "='$1']" ); // 1439 // 1440 if ( support.matchesSelector && documentIsHTML && // 1441 ( !rbuggyMatches || !rbuggyMatches.test( expr ) ) && // 1442 ( !rbuggyQSA || !rbuggyQSA.test( expr ) ) ) { // 1443 // 1444 try { // 1445 var ret = matches.call( elem, expr ); // 1446 // 1447 // IE 9's matchesSelector returns false on disconnected nodes // 1448 if ( ret || support.disconnectedMatch || // 1449 // As well, disconnected nodes are said to be in a document // 1450 // fragment in IE 9 // 1451 elem.document && elem.document.nodeType !== 11 ) { // 1452 return ret; // 1453 } // 1454 } catch (e) {} // 1455 } // 1456 // 1457 return Sizzle( expr, document, null, [ elem ] ).length > 0; // 1458 }; // 1459 // 1460 Sizzle.contains = function( context, elem ) { // 1461 // Set document vars if needed // 1462 if ( ( context.ownerDocument || context ) !== document ) { // 1463 setDocument( context ); // 1464 } // 1465 return contains( context, elem ); // 1466 }; // 1467 // 1468 Sizzle.attr = function( elem, name ) { // 1469 // Set document vars if needed // 1470 if ( ( elem.ownerDocument || elem ) !== document ) { // 1471 setDocument( elem ); // 1472 } // 1473 // 1474 var fn = Expr.attrHandle[ name.toLowerCase() ], // 1475 // Don't get fooled by Object.prototype properties (jQuery #13807) // 1476 val = fn && hasOwn.call( Expr.attrHandle, name.toLowerCase() ) ? // 1477 fn( elem, name, !documentIsHTML ) : // 1478 undefined; // 1479 // 1480 return val !== undefined ? // 1481 val : // 1482 support.attributes || !documentIsHTML ? // 1483 elem.getAttribute( name ) : // 1484 (val = elem.getAttributeNode(name)) && val.specified ? // 1485 val.value : // 1486 null; // 1487 }; // 1488 // 1489 Sizzle.error = function( msg ) { // 1490 throw new Error( "Syntax error, unrecognized expression: " + msg ); // 1491 }; // 1492 // 1493 /** // 1494 * Document sorting and removing duplicates // 1495 * @param {ArrayLike} results // 1496 */ // 1497 Sizzle.uniqueSort = function( results ) { // 1498 var elem, // 1499 duplicates = [], // 1500 j = 0, // 1501 i = 0; // 1502 // 1503 // Unless we *know* we can detect duplicates, assume their presence // 1504 hasDuplicate = !support.detectDuplicates; // 1505 sortInput = !support.sortStable && results.slice( 0 ); // 1506 results.sort( sortOrder ); // 1507 // 1508 if ( hasDuplicate ) { // 1509 while ( (elem = results[i++]) ) { // 1510 if ( elem === results[ i ] ) { // 1511 j = duplicates.push( i ); // 1512 } // 1513 } // 1514 while ( j-- ) { // 1515 results.splice( duplicates[ j ], 1 ); // 1516 } // 1517 } // 1518 // 1519 // Clear input after sorting to release objects // 1520 // See https://github.com/jquery/sizzle/pull/225 // 1521 sortInput = null; // 1522 // 1523 return results; // 1524 }; // 1525 // 1526 /** // 1527 * Utility function for retrieving the text value of an array of DOM nodes // 1528 * @param {Array|Element} elem // 1529 */ // 1530 getText = Sizzle.getText = function( elem ) { // 1531 var node, // 1532 ret = "", // 1533 i = 0, // 1534 nodeType = elem.nodeType; // 1535 // 1536 if ( !nodeType ) { // 1537 // If no nodeType, this is expected to be an array // 1538 while ( (node = elem[i++]) ) { // 1539 // Do not traverse comment nodes // 1540 ret += getText( node ); // 1541 } // 1542 } else if ( nodeType === 1 || nodeType === 9 || nodeType === 11 ) { // 1543 // Use textContent for elements // 1544 // innerText usage removed for consistency of new lines (jQuery #11153) // 1545 if ( typeof elem.textContent === "string" ) { // 1546 return elem.textContent; // 1547 } else { // 1548 // Traverse its children // 1549 for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) { // 1550 ret += getText( elem ); // 1551 } // 1552 } // 1553 } else if ( nodeType === 3 || nodeType === 4 ) { // 1554 return elem.nodeValue; // 1555 } // 1556 // Do not include comment or processing instruction nodes // 1557 // 1558 return ret; // 1559 }; // 1560 // 1561 Expr = Sizzle.selectors = { // 1562 // 1563 // Can be adjusted by the user // 1564 cacheLength: 50, // 1565 // 1566 createPseudo: markFunction, // 1567 // 1568 match: matchExpr, // 1569 // 1570 attrHandle: {}, // 1571 // 1572 find: {}, // 1573 // 1574 relative: { // 1575 ">": { dir: "parentNode", first: true }, // 1576 " ": { dir: "parentNode" }, // 1577 "+": { dir: "previousSibling", first: true }, // 1578 "~": { dir: "previousSibling" } // 1579 }, // 1580 // 1581 preFilter: { // 1582 "ATTR": function( match ) { // 1583 match[1] = match[1].replace( runescape, funescape ); // 1584 // 1585 // Move the given value to match[3] whether quoted or unquoted // 1586 match[3] = ( match[3] || match[4] || match[5] || "" ).replace( runescape, funescape ); // 1587 // 1588 if ( match[2] === "~=" ) { // 1589 match[3] = " " + match[3] + " "; // 1590 } // 1591 // 1592 return match.slice( 0, 4 ); // 1593 }, // 1594 // 1595 "CHILD": function( match ) { // 1596 /* matches from matchExpr["CHILD"] // 1597 1 type (only|nth|...) // 1598 2 what (child|of-type) // 1599 3 argument (even|odd|\d*|\d*n([+-]\d+)?|...) // 1600 4 xn-component of xn+y argument ([+-]?\d*n|) // 1601 5 sign of xn-component // 1602 6 x of xn-component // 1603 7 sign of y-component // 1604 8 y of y-component // 1605 */ // 1606 match[1] = match[1].toLowerCase(); // 1607 // 1608 if ( match[1].slice( 0, 3 ) === "nth" ) { // 1609 // nth-* requires argument // 1610 if ( !match[3] ) { // 1611 Sizzle.error( match[0] ); // 1612 } // 1613 // 1614 // numeric x and y parameters for Expr.filter.CHILD // 1615 // remember that false/true cast respectively to 0/1 // 1616 match[4] = +( match[4] ? match[5] + (match[6] || 1) : 2 * ( match[3] === "even" || match[3] === "odd" ) ); // 1617 match[5] = +( ( match[7] + match[8] ) || match[3] === "odd" ); // 1618 // 1619 // other types prohibit arguments // 1620 } else if ( match[3] ) { // 1621 Sizzle.error( match[0] ); // 1622 } // 1623 // 1624 return match; // 1625 }, // 1626 // 1627 "PSEUDO": function( match ) { // 1628 var excess, // 1629 unquoted = !match[6] && match[2]; // 1630 // 1631 if ( matchExpr["CHILD"].test( match[0] ) ) { // 1632 return null; // 1633 } // 1634 // 1635 // Accept quoted arguments as-is // 1636 if ( match[3] ) { // 1637 match[2] = match[4] || match[5] || ""; // 1638 // 1639 // Strip excess characters from unquoted arguments // 1640 } else if ( unquoted && rpseudo.test( unquoted ) && // 1641 // Get excess from tokenize (recursively) // 1642 (excess = tokenize( unquoted, true )) && // 1643 // advance to the next closing parenthesis // 1644 (excess = unquoted.indexOf( ")", unquoted.length - excess ) - unquoted.length) ) { // 1645 // 1646 // excess is a negative index // 1647 match[0] = match[0].slice( 0, excess ); // 1648 match[2] = unquoted.slice( 0, excess ); // 1649 } // 1650 // 1651 // Return only captures needed by the pseudo filter method (type and argument) // 1652 return match.slice( 0, 3 ); // 1653 } // 1654 }, // 1655 // 1656 filter: { // 1657 // 1658 "TAG": function( nodeNameSelector ) { // 1659 var nodeName = nodeNameSelector.replace( runescape, funescape ).toLowerCase(); // 1660 return nodeNameSelector === "*" ? // 1661 function() { return true; } : // 1662 function( elem ) { // 1663 return elem.nodeName && elem.nodeName.toLowerCase() === nodeName; // 1664 }; // 1665 }, // 1666 // 1667 "CLASS": function( className ) { // 1668 var pattern = classCache[ className + " " ]; // 1669 // 1670 return pattern || // 1671 (pattern = new RegExp( "(^|" + whitespace + ")" + className + "(" + whitespace + "|$)" )) && // 1672 classCache( className, function( elem ) { // 1673 return pattern.test( typeof elem.className === "string" && elem.className || typeof elem.getAttribute !== "undefined" && elem.getAttribute("class") || "" ); }); // 1675 }, // 1676 // 1677 "ATTR": function( name, operator, check ) { // 1678 return function( elem ) { // 1679 var result = Sizzle.attr( elem, name ); // 1680 // 1681 if ( result == null ) { // 1682 return operator === "!="; // 1683 } // 1684 if ( !operator ) { // 1685 return true; // 1686 } // 1687 // 1688 result += ""; // 1689 // 1690 return operator === "=" ? result === check : // 1691 operator === "!=" ? result !== check : // 1692 operator === "^=" ? check && result.indexOf( check ) === 0 : // 1693 operator === "*=" ? check && result.indexOf( check ) > -1 : // 1694 operator === "$=" ? check && result.slice( -check.length ) === check : // 1695 operator === "~=" ? ( " " + result.replace( rwhitespace, " " ) + " " ).indexOf( check ) > -1 : // 1696 operator === "|=" ? result === check || result.slice( 0, check.length + 1 ) === check + "-" : // 1697 false; // 1698 }; // 1699 }, // 1700 // 1701 "CHILD": function( type, what, argument, first, last ) { // 1702 var simple = type.slice( 0, 3 ) !== "nth", // 1703 forward = type.slice( -4 ) !== "last", // 1704 ofType = what === "of-type"; // 1705 // 1706 return first === 1 && last === 0 ? // 1707 // 1708 // Shortcut for :nth-*(n) // 1709 function( elem ) { // 1710 return !!elem.parentNode; // 1711 } : // 1712 // 1713 function( elem, context, xml ) { // 1714 var cache, outerCache, node, diff, nodeIndex, start, // 1715 dir = simple !== forward ? "nextSibling" : "previousSibling", // 1716 parent = elem.parentNode, // 1717 name = ofType && elem.nodeName.toLowerCase(), // 1718 useCache = !xml && !ofType; // 1719 // 1720 if ( parent ) { // 1721 // 1722 // :(first|last|only)-(child|of-type) // 1723 if ( simple ) { // 1724 while ( dir ) { // 1725 node = elem; // 1726 while ( (node = node[ dir ]) ) { // 1727 if ( ofType ? node.nodeName.toLowerCase() === name : node.nodeType === 1 ) { // 1728 return false; // 1729 } // 1730 } // 1731 // Reverse direction for :only-* (if we haven't yet done so) // 1732 start = dir = type === "only" && !start && "nextSibling"; // 1733 } // 1734 return true; // 1735 } // 1736 // 1737 start = [ forward ? parent.firstChild : parent.lastChild ]; // 1738 // 1739 // non-xml :nth-child(...) stores cache data on `parent` // 1740 if ( forward && useCache ) { // 1741 // Seek `elem` from a previously-cached index // 1742 outerCache = parent[ expando ] || (parent[ expando ] = {}); // 1743 cache = outerCache[ type ] || []; // 1744 nodeIndex = cache[0] === dirruns && cache[1]; // 1745 diff = cache[0] === dirruns && cache[2]; // 1746 node = nodeIndex && parent.childNodes[ nodeIndex ]; // 1747 // 1748 while ( (node = ++nodeIndex && node && node[ dir ] || // 1749 // 1750 // Fallback to seeking `elem` from the start // 1751 (diff = nodeIndex = 0) || start.pop()) ) { // 1752 // 1753 // When found, cache indexes on `parent` and break // 1754 if ( node.nodeType === 1 && ++diff && node === elem ) { // 1755 outerCache[ type ] = [ dirruns, nodeIndex, diff ]; // 1756 break; // 1757 } // 1758 } // 1759 // 1760 // Use previously-cached element index if available // 1761 } else if ( useCache && (cache = (elem[ expando ] || (elem[ expando ] = {}))[ type ]) && cache[0] === dirruns ) { diff = cache[1]; // 1763 // 1764 // xml :nth-child(...) or :nth-last-child(...) or :nth(-last)?-of-type(...) // 1765 } else { // 1766 // Use the same loop as above to seek `elem` from the start // 1767 while ( (node = ++nodeIndex && node && node[ dir ] || // 1768 (diff = nodeIndex = 0) || start.pop()) ) { // 1769 // 1770 if ( ( ofType ? node.nodeName.toLowerCase() === name : node.nodeType === 1 ) && ++diff ) { // 1771 // Cache the index of each encountered element // 1772 if ( useCache ) { // 1773 (node[ expando ] || (node[ expando ] = {}))[ type ] = [ dirruns, diff ]; // 1774 } // 1775 // 1776 if ( node === elem ) { // 1777 break; // 1778 } // 1779 } // 1780 } // 1781 } // 1782 // 1783 // Incorporate the offset, then check against cycle size // 1784 diff -= last; // 1785 return diff === first || ( diff % first === 0 && diff / first >= 0 ); // 1786 } // 1787 }; // 1788 }, // 1789 // 1790 "PSEUDO": function( pseudo, argument ) { // 1791 // pseudo-class names are case-insensitive // 1792 // http://www.w3.org/TR/selectors/#pseudo-classes // 1793 // Prioritize by case sensitivity in case custom pseudos are added with uppercase letters // 1794 // Remember that setFilters inherits from pseudos // 1795 var args, // 1796 fn = Expr.pseudos[ pseudo ] || Expr.setFilters[ pseudo.toLowerCase() ] || // 1797 Sizzle.error( "unsupported pseudo: " + pseudo ); // 1798 // 1799 // The user may use createPseudo to indicate that // 1800 // arguments are needed to create the filter function // 1801 // just as Sizzle does // 1802 if ( fn[ expando ] ) { // 1803 return fn( argument ); // 1804 } // 1805 // 1806 // But maintain support for old signatures // 1807 if ( fn.length > 1 ) { // 1808 args = [ pseudo, pseudo, "", argument ]; // 1809 return Expr.setFilters.hasOwnProperty( pseudo.toLowerCase() ) ? // 1810 markFunction(function( seed, matches ) { // 1811 var idx, // 1812 matched = fn( seed, argument ), // 1813 i = matched.length; // 1814 while ( i-- ) { // 1815 idx = indexOf( seed, matched[i] ); // 1816 seed[ idx ] = !( matches[ idx ] = matched[i] ); // 1817 } // 1818 }) : // 1819 function( elem ) { // 1820 return fn( elem, 0, args ); // 1821 }; // 1822 } // 1823 // 1824 return fn; // 1825 } // 1826 }, // 1827 // 1828 pseudos: { // 1829 // Potentially complex pseudos // 1830 "not": markFunction(function( selector ) { // 1831 // Trim the selector passed to compile // 1832 // to avoid treating leading and trailing // 1833 // spaces as combinators // 1834 var input = [], // 1835 results = [], // 1836 matcher = compile( selector.replace( rtrim, "$1" ) ); // 1837 // 1838 return matcher[ expando ] ? // 1839 markFunction(function( seed, matches, context, xml ) { // 1840 var elem, // 1841 unmatched = matcher( seed, null, xml, [] ), // 1842 i = seed.length; // 1843 // 1844 // Match elements unmatched by `matcher` // 1845 while ( i-- ) { // 1846 if ( (elem = unmatched[i]) ) { // 1847 seed[i] = !(matches[i] = elem); // 1848 } // 1849 } // 1850 }) : // 1851 function( elem, context, xml ) { // 1852 input[0] = elem; // 1853 matcher( input, null, xml, results ); // 1854 // Don't keep the element (issue #299) // 1855 input[0] = null; // 1856 return !results.pop(); // 1857 }; // 1858 }), // 1859 // 1860 "has": markFunction(function( selector ) { // 1861 return function( elem ) { // 1862 return Sizzle( selector, elem ).length > 0; // 1863 }; // 1864 }), // 1865 // 1866 "contains": markFunction(function( text ) { // 1867 text = text.replace( runescape, funescape ); // 1868 return function( elem ) { // 1869 return ( elem.textContent || elem.innerText || getText( elem ) ).indexOf( text ) > -1; // 1870 }; // 1871 }), // 1872 // 1873 // "Whether an element is represented by a :lang() selector // 1874 // is based solely on the element's language value // 1875 // being equal to the identifier C, // 1876 // or beginning with the identifier C immediately followed by "-". // 1877 // The matching of C against the element's language value is performed case-insensitively. // 1878 // The identifier C does not have to be a valid language name." // 1879 // http://www.w3.org/TR/selectors/#lang-pseudo // 1880 "lang": markFunction( function( lang ) { // 1881 // lang value must be a valid identifier // 1882 if ( !ridentifier.test(lang || "") ) { // 1883 Sizzle.error( "unsupported lang: " + lang ); // 1884 } // 1885 lang = lang.replace( runescape, funescape ).toLowerCase(); // 1886 return function( elem ) { // 1887 var elemLang; // 1888 do { // 1889 if ( (elemLang = documentIsHTML ? // 1890 elem.lang : // 1891 elem.getAttribute("xml:lang") || elem.getAttribute("lang")) ) { // 1892 // 1893 elemLang = elemLang.toLowerCase(); // 1894 return elemLang === lang || elemLang.indexOf( lang + "-" ) === 0; // 1895 } // 1896 } while ( (elem = elem.parentNode) && elem.nodeType === 1 ); // 1897 return false; // 1898 }; // 1899 }), // 1900 // 1901 // Miscellaneous // 1902 "target": function( elem ) { // 1903 var hash = window.location && window.location.hash; // 1904 return hash && hash.slice( 1 ) === elem.id; // 1905 }, // 1906 // 1907 "root": function( elem ) { // 1908 return elem === docElem; // 1909 }, // 1910 // 1911 "focus": function( elem ) { // 1912 return elem === document.activeElement && (!document.hasFocus || document.hasFocus()) && !!(elem.type || elem.href || ~elem.tabIndex); }, // 1914 // 1915 // Boolean properties // 1916 "enabled": function( elem ) { // 1917 return elem.disabled === false; // 1918 }, // 1919 // 1920 "disabled": function( elem ) { // 1921 return elem.disabled === true; // 1922 }, // 1923 // 1924 "checked": function( elem ) { // 1925 // In CSS3, :checked should return both checked and selected elements // 1926 // http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked // 1927 var nodeName = elem.nodeName.toLowerCase(); // 1928 return (nodeName === "input" && !!elem.checked) || (nodeName === "option" && !!elem.selected); // 1929 }, // 1930 // 1931 "selected": function( elem ) { // 1932 // Accessing this property makes selected-by-default // 1933 // options in Safari work properly // 1934 if ( elem.parentNode ) { // 1935 elem.parentNode.selectedIndex; // 1936 } // 1937 // 1938 return elem.selected === true; // 1939 }, // 1940 // 1941 // Contents // 1942 "empty": function( elem ) { // 1943 // http://www.w3.org/TR/selectors/#empty-pseudo // 1944 // :empty is negated by element (1) or content nodes (text: 3; cdata: 4; entity ref: 5), // 1945 // but not by others (comment: 8; processing instruction: 7; etc.) // 1946 // nodeType < 6 works because attributes (2) do not appear as children // 1947 for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) { // 1948 if ( elem.nodeType < 6 ) { // 1949 return false; // 1950 } // 1951 } // 1952 return true; // 1953 }, // 1954 // 1955 "parent": function( elem ) { // 1956 return !Expr.pseudos["empty"]( elem ); // 1957 }, // 1958 // 1959 // Element/input types // 1960 "header": function( elem ) { // 1961 return rheader.test( elem.nodeName ); // 1962 }, // 1963 // 1964 "input": function( elem ) { // 1965 return rinputs.test( elem.nodeName ); // 1966 }, // 1967 // 1968 "button": function( elem ) { // 1969 var name = elem.nodeName.toLowerCase(); // 1970 return name === "input" && elem.type === "button" || name === "button"; // 1971 }, // 1972 // 1973 "text": function( elem ) { // 1974 var attr; // 1975 return elem.nodeName.toLowerCase() === "input" && // 1976 elem.type === "text" && // 1977 // 1978 // Support: IE<8 // 1979 // New HTML5 attribute values (e.g., "search") appear with elem.type === "text" // 1980 ( (attr = elem.getAttribute("type")) == null || attr.toLowerCase() === "text" ); // 1981 }, // 1982 // 1983 // Position-in-collection // 1984 "first": createPositionalPseudo(function() { // 1985 return [ 0 ]; // 1986 }), // 1987 // 1988 "last": createPositionalPseudo(function( matchIndexes, length ) { // 1989 return [ length - 1 ]; // 1990 }), // 1991 // 1992 "eq": createPositionalPseudo(function( matchIndexes, length, argument ) { // 1993 return [ argument < 0 ? argument + length : argument ]; // 1994 }), // 1995 // 1996 "even": createPositionalPseudo(function( matchIndexes, length ) { // 1997 var i = 0; // 1998 for ( ; i < length; i += 2 ) { // 1999 matchIndexes.push( i ); // 2000 } // 2001 return matchIndexes; // 2002 }), // 2003 // 2004 "odd": createPositionalPseudo(function( matchIndexes, length ) { // 2005 var i = 1; // 2006 for ( ; i < length; i += 2 ) { // 2007 matchIndexes.push( i ); // 2008 } // 2009 return matchIndexes; // 2010 }), // 2011 // 2012 "lt": createPositionalPseudo(function( matchIndexes, length, argument ) { // 2013 var i = argument < 0 ? argument + length : argument; // 2014 for ( ; --i >= 0; ) { // 2015 matchIndexes.push( i ); // 2016 } // 2017 return matchIndexes; // 2018 }), // 2019 // 2020 "gt": createPositionalPseudo(function( matchIndexes, length, argument ) { // 2021 var i = argument < 0 ? argument + length : argument; // 2022 for ( ; ++i < length; ) { // 2023 matchIndexes.push( i ); // 2024 } // 2025 return matchIndexes; // 2026 }) // 2027 } // 2028 }; // 2029 // 2030 Expr.pseudos["nth"] = Expr.pseudos["eq"]; // 2031 // 2032 // Add button/input type pseudos // 2033 for ( i in { radio: true, checkbox: true, file: true, password: true, image: true } ) { // 2034 Expr.pseudos[ i ] = createInputPseudo( i ); // 2035 } // 2036 for ( i in { submit: true, reset: true } ) { // 2037 Expr.pseudos[ i ] = createButtonPseudo( i ); // 2038 } // 2039 // 2040 // Easy API for creating new setFilters // 2041 function setFilters() {} // 2042 setFilters.prototype = Expr.filters = Expr.pseudos; // 2043 Expr.setFilters = new setFilters(); // 2044 // 2045 tokenize = Sizzle.tokenize = function( selector, parseOnly ) { // 2046 var matched, match, tokens, type, // 2047 soFar, groups, preFilters, // 2048 cached = tokenCache[ selector + " " ]; // 2049 // 2050 if ( cached ) { // 2051 return parseOnly ? 0 : cached.slice( 0 ); // 2052 } // 2053 // 2054 soFar = selector; // 2055 groups = []; // 2056 preFilters = Expr.preFilter; // 2057 // 2058 while ( soFar ) { // 2059 // 2060 // Comma and first run // 2061 if ( !matched || (match = rcomma.exec( soFar )) ) { // 2062 if ( match ) { // 2063 // Don't consume trailing commas as valid // 2064 soFar = soFar.slice( match[0].length ) || soFar; // 2065 } // 2066 groups.push( (tokens = []) ); // 2067 } // 2068 // 2069 matched = false; // 2070 // 2071 // Combinators // 2072 if ( (match = rcombinators.exec( soFar )) ) { // 2073 matched = match.shift(); // 2074 tokens.push({ // 2075 value: matched, // 2076 // Cast descendant combinators to space // 2077 type: match[0].replace( rtrim, " " ) // 2078 }); // 2079 soFar = soFar.slice( matched.length ); // 2080 } // 2081 // 2082 // Filters // 2083 for ( type in Expr.filter ) { // 2084 if ( (match = matchExpr[ type ].exec( soFar )) && (!preFilters[ type ] || // 2085 (match = preFilters[ type ]( match ))) ) { // 2086 matched = match.shift(); // 2087 tokens.push({ // 2088 value: matched, // 2089 type: type, // 2090 matches: match // 2091 }); // 2092 soFar = soFar.slice( matched.length ); // 2093 } // 2094 } // 2095 // 2096 if ( !matched ) { // 2097 break; // 2098 } // 2099 } // 2100 // 2101 // Return the length of the invalid excess // 2102 // if we're just parsing // 2103 // Otherwise, throw an error or return tokens // 2104 return parseOnly ? // 2105 soFar.length : // 2106 soFar ? // 2107 Sizzle.error( selector ) : // 2108 // Cache the tokens // 2109 tokenCache( selector, groups ).slice( 0 ); // 2110 }; // 2111 // 2112 function toSelector( tokens ) { // 2113 var i = 0, // 2114 len = tokens.length, // 2115 selector = ""; // 2116 for ( ; i < len; i++ ) { // 2117 selector += tokens[i].value; // 2118 } // 2119 return selector; // 2120 } // 2121 // 2122 function addCombinator( matcher, combinator, base ) { // 2123 var dir = combinator.dir, // 2124 checkNonElements = base && dir === "parentNode", // 2125 doneName = done++; // 2126 // 2127 return combinator.first ? // 2128 // Check against closest ancestor/preceding element // 2129 function( elem, context, xml ) { // 2130 while ( (elem = elem[ dir ]) ) { // 2131 if ( elem.nodeType === 1 || checkNonElements ) { // 2132 return matcher( elem, context, xml ); // 2133 } // 2134 } // 2135 } : // 2136 // 2137 // Check against all ancestor/preceding elements // 2138 function( elem, context, xml ) { // 2139 var oldCache, outerCache, // 2140 newCache = [ dirruns, doneName ]; // 2141 // 2142 // We can't set arbitrary data on XML nodes, so they don't benefit from dir caching // 2143 if ( xml ) { // 2144 while ( (elem = elem[ dir ]) ) { // 2145 if ( elem.nodeType === 1 || checkNonElements ) { // 2146 if ( matcher( elem, context, xml ) ) { // 2147 return true; // 2148 } // 2149 } // 2150 } // 2151 } else { // 2152 while ( (elem = elem[ dir ]) ) { // 2153 if ( elem.nodeType === 1 || checkNonElements ) { // 2154 outerCache = elem[ expando ] || (elem[ expando ] = {}); // 2155 if ( (oldCache = outerCache[ dir ]) && // 2156 oldCache[ 0 ] === dirruns && oldCache[ 1 ] === doneName ) { // 2157 // 2158 // Assign to newCache so results back-propagate to previous elements // 2159 return (newCache[ 2 ] = oldCache[ 2 ]); // 2160 } else { // 2161 // Reuse newcache so results back-propagate to previous elements // 2162 outerCache[ dir ] = newCache; // 2163 // 2164 // A match means we're done; a fail means we have to keep checking // 2165 if ( (newCache[ 2 ] = matcher( elem, context, xml )) ) { // 2166 return true; // 2167 } // 2168 } // 2169 } // 2170 } // 2171 } // 2172 }; // 2173 } // 2174 // 2175 function elementMatcher( matchers ) { // 2176 return matchers.length > 1 ? // 2177 function( elem, context, xml ) { // 2178 var i = matchers.length; // 2179 while ( i-- ) { // 2180 if ( !matchers[i]( elem, context, xml ) ) { // 2181 return false; // 2182 } // 2183 } // 2184 return true; // 2185 } : // 2186 matchers[0]; // 2187 } // 2188 // 2189 function multipleContexts( selector, contexts, results ) { // 2190 var i = 0, // 2191 len = contexts.length; // 2192 for ( ; i < len; i++ ) { // 2193 Sizzle( selector, contexts[i], results ); // 2194 } // 2195 return results; // 2196 } // 2197 // 2198 function condense( unmatched, map, filter, context, xml ) { // 2199 var elem, // 2200 newUnmatched = [], // 2201 i = 0, // 2202 len = unmatched.length, // 2203 mapped = map != null; // 2204 // 2205 for ( ; i < len; i++ ) { // 2206 if ( (elem = unmatched[i]) ) { // 2207 if ( !filter || filter( elem, context, xml ) ) { // 2208 newUnmatched.push( elem ); // 2209 if ( mapped ) { // 2210 map.push( i ); // 2211 } // 2212 } // 2213 } // 2214 } // 2215 // 2216 return newUnmatched; // 2217 } // 2218 // 2219 function setMatcher( preFilter, selector, matcher, postFilter, postFinder, postSelector ) { // 2220 if ( postFilter && !postFilter[ expando ] ) { // 2221 postFilter = setMatcher( postFilter ); // 2222 } // 2223 if ( postFinder && !postFinder[ expando ] ) { // 2224 postFinder = setMatcher( postFinder, postSelector ); // 2225 } // 2226 return markFunction(function( seed, results, context, xml ) { // 2227 var temp, i, elem, // 2228 preMap = [], // 2229 postMap = [], // 2230 preexisting = results.length, // 2231 // 2232 // Get initial elements from seed or context // 2233 elems = seed || multipleContexts( selector || "*", context.nodeType ? [ context ] : context, [] ), // 2234 // 2235 // Prefilter to get matcher input, preserving a map for seed-results synchronization // 2236 matcherIn = preFilter && ( seed || !selector ) ? // 2237 condense( elems, preMap, preFilter, context, xml ) : // 2238 elems, // 2239 // 2240 matcherOut = matcher ? // 2241 // If we have a postFinder, or filtered seed, or non-seed postFilter or preexisting results, // 2242 postFinder || ( seed ? preFilter : preexisting || postFilter ) ? // 2243 // 2244 // ...intermediate processing is necessary // 2245 [] : // 2246 // 2247 // ...otherwise use results directly // 2248 results : // 2249 matcherIn; // 2250 // 2251 // Find primary matches // 2252 if ( matcher ) { // 2253 matcher( matcherIn, matcherOut, context, xml ); // 2254 } // 2255 // 2256 // Apply postFilter // 2257 if ( postFilter ) { // 2258 temp = condense( matcherOut, postMap ); // 2259 postFilter( temp, [], context, xml ); // 2260 // 2261 // Un-match failing elements by moving them back to matcherIn // 2262 i = temp.length; // 2263 while ( i-- ) { // 2264 if ( (elem = temp[i]) ) { // 2265 matcherOut[ postMap[i] ] = !(matcherIn[ postMap[i] ] = elem); // 2266 } // 2267 } // 2268 } // 2269 // 2270 if ( seed ) { // 2271 if ( postFinder || preFilter ) { // 2272 if ( postFinder ) { // 2273 // Get the final matcherOut by condensing this intermediate into postFinder contexts // 2274 temp = []; // 2275 i = matcherOut.length; // 2276 while ( i-- ) { // 2277 if ( (elem = matcherOut[i]) ) { // 2278 // Restore matcherIn since elem is not yet a final match // 2279 temp.push( (matcherIn[i] = elem) ); // 2280 } // 2281 } // 2282 postFinder( null, (matcherOut = []), temp, xml ); // 2283 } // 2284 // 2285 // Move matched elements from seed to results to keep them synchronized // 2286 i = matcherOut.length; // 2287 while ( i-- ) { // 2288 if ( (elem = matcherOut[i]) && // 2289 (temp = postFinder ? indexOf( seed, elem ) : preMap[i]) > -1 ) { // 2290 // 2291 seed[temp] = !(results[temp] = elem); // 2292 } // 2293 } // 2294 } // 2295 // 2296 // Add elements to results, through postFinder if defined // 2297 } else { // 2298 matcherOut = condense( // 2299 matcherOut === results ? // 2300 matcherOut.splice( preexisting, matcherOut.length ) : // 2301 matcherOut // 2302 ); // 2303 if ( postFinder ) { // 2304 postFinder( null, results, matcherOut, xml ); // 2305 } else { // 2306 push.apply( results, matcherOut ); // 2307 } // 2308 } // 2309 }); // 2310 } // 2311 // 2312 function matcherFromTokens( tokens ) { // 2313 var checkContext, matcher, j, // 2314 len = tokens.length, // 2315 leadingRelative = Expr.relative[ tokens[0].type ], // 2316 implicitRelative = leadingRelative || Expr.relative[" "], // 2317 i = leadingRelative ? 1 : 0, // 2318 // 2319 // The foundational matcher ensures that elements are reachable from top-level context(s) // 2320 matchContext = addCombinator( function( elem ) { // 2321 return elem === checkContext; // 2322 }, implicitRelative, true ), // 2323 matchAnyContext = addCombinator( function( elem ) { // 2324 return indexOf( checkContext, elem ) > -1; // 2325 }, implicitRelative, true ), // 2326 matchers = [ function( elem, context, xml ) { // 2327 var ret = ( !leadingRelative && ( xml || context !== outermostContext ) ) || ( // 2328 (checkContext = context).nodeType ? // 2329 matchContext( elem, context, xml ) : // 2330 matchAnyContext( elem, context, xml ) ); // 2331 // Avoid hanging onto element (issue #299) // 2332 checkContext = null; // 2333 return ret; // 2334 } ]; // 2335 // 2336 for ( ; i < len; i++ ) { // 2337 if ( (matcher = Expr.relative[ tokens[i].type ]) ) { // 2338 matchers = [ addCombinator(elementMatcher( matchers ), matcher) ]; // 2339 } else { // 2340 matcher = Expr.filter[ tokens[i].type ].apply( null, tokens[i].matches ); // 2341 // 2342 // Return special upon seeing a positional matcher // 2343 if ( matcher[ expando ] ) { // 2344 // Find the next relative operator (if any) for proper handling // 2345 j = ++i; // 2346 for ( ; j < len; j++ ) { // 2347 if ( Expr.relative[ tokens[j].type ] ) { // 2348 break; // 2349 } // 2350 } // 2351 return setMatcher( // 2352 i > 1 && elementMatcher( matchers ), // 2353 i > 1 && toSelector( // 2354 // If the preceding token was a descendant combinator, insert an implicit any-element `*` // 2355 tokens.slice( 0, i - 1 ).concat({ value: tokens[ i - 2 ].type === " " ? "*" : "" }) // 2356 ).replace( rtrim, "$1" ), // 2357 matcher, // 2358 i < j && matcherFromTokens( tokens.slice( i, j ) ), // 2359 j < len && matcherFromTokens( (tokens = tokens.slice( j )) ), // 2360 j < len && toSelector( tokens ) // 2361 ); // 2362 } // 2363 matchers.push( matcher ); // 2364 } // 2365 } // 2366 // 2367 return elementMatcher( matchers ); // 2368 } // 2369 // 2370 function matcherFromGroupMatchers( elementMatchers, setMatchers ) { // 2371 var bySet = setMatchers.length > 0, // 2372 byElement = elementMatchers.length > 0, // 2373 superMatcher = function( seed, context, xml, results, outermost ) { // 2374 var elem, j, matcher, // 2375 matchedCount = 0, // 2376 i = "0", // 2377 unmatched = seed && [], // 2378 setMatched = [], // 2379 contextBackup = outermostContext, // 2380 // We must always have either seed elements or outermost context // 2381 elems = seed || byElement && Expr.find["TAG"]( "*", outermost ), // 2382 // Use integer dirruns iff this is the outermost matcher // 2383 dirrunsUnique = (dirruns += contextBackup == null ? 1 : Math.random() || 0.1), // 2384 len = elems.length; // 2385 // 2386 if ( outermost ) { // 2387 outermostContext = context !== document && context; // 2388 } // 2389 // 2390 // Add elements passing elementMatchers directly to results // 2391 // Keep `i` a string if there are no elements so `matchedCount` will be "00" below // 2392 // Support: IE<9, Safari // 2393 // Tolerate NodeList properties (IE: "length"; Safari: <number>) matching elements by id // 2394 for ( ; i !== len && (elem = elems[i]) != null; i++ ) { // 2395 if ( byElement && elem ) { // 2396 j = 0; // 2397 while ( (matcher = elementMatchers[j++]) ) { // 2398 if ( matcher( elem, context, xml ) ) { // 2399 results.push( elem ); // 2400 break; // 2401 } // 2402 } // 2403 if ( outermost ) { // 2404 dirruns = dirrunsUnique; // 2405 } // 2406 } // 2407 // 2408 // Track unmatched elements for set filters // 2409 if ( bySet ) { // 2410 // They will have gone through all possible matchers // 2411 if ( (elem = !matcher && elem) ) { // 2412 matchedCount--; // 2413 } // 2414 // 2415 // Lengthen the array for every element, matched or not // 2416 if ( seed ) { // 2417 unmatched.push( elem ); // 2418 } // 2419 } // 2420 } // 2421 // 2422 // Apply set filters to unmatched elements // 2423 matchedCount += i; // 2424 if ( bySet && i !== matchedCount ) { // 2425 j = 0; // 2426 while ( (matcher = setMatchers[j++]) ) { // 2427 matcher( unmatched, setMatched, context, xml ); // 2428 } // 2429 // 2430 if ( seed ) { // 2431 // Reintegrate element matches to eliminate the need for sorting // 2432 if ( matchedCount > 0 ) { // 2433 while ( i-- ) { // 2434 if ( !(unmatched[i] || setMatched[i]) ) { // 2435 setMatched[i] = pop.call( results ); // 2436 } // 2437 } // 2438 } // 2439 // 2440 // Discard index placeholder values to get only actual matches // 2441 setMatched = condense( setMatched ); // 2442 } // 2443 // 2444 // Add matches to results // 2445 push.apply( results, setMatched ); // 2446 // 2447 // Seedless set matches succeeding multiple successful matchers stipulate sorting // 2448 if ( outermost && !seed && setMatched.length > 0 && // 2449 ( matchedCount + setMatchers.length ) > 1 ) { // 2450 // 2451 Sizzle.uniqueSort( results ); // 2452 } // 2453 } // 2454 // 2455 // Override manipulation of globals by nested matchers // 2456 if ( outermost ) { // 2457 dirruns = dirrunsUnique; // 2458 outermostContext = contextBackup; // 2459 } // 2460 // 2461 return unmatched; // 2462 }; // 2463 // 2464 return bySet ? // 2465 markFunction( superMatcher ) : // 2466 superMatcher; // 2467 } // 2468 // 2469 compile = Sizzle.compile = function( selector, match /* Internal Use Only */ ) { // 2470 var i, // 2471 setMatchers = [], // 2472 elementMatchers = [], // 2473 cached = compilerCache[ selector + " " ]; // 2474 // 2475 if ( !cached ) { // 2476 // Generate a function of recursive functions that can be used to check each element // 2477 if ( !match ) { // 2478 match = tokenize( selector ); // 2479 } // 2480 i = match.length; // 2481 while ( i-- ) { // 2482 cached = matcherFromTokens( match[i] ); // 2483 if ( cached[ expando ] ) { // 2484 setMatchers.push( cached ); // 2485 } else { // 2486 elementMatchers.push( cached ); // 2487 } // 2488 } // 2489 // 2490 // Cache the compiled function // 2491 cached = compilerCache( selector, matcherFromGroupMatchers( elementMatchers, setMatchers ) ); // 2492 // 2493 // Save selector and tokenization // 2494 cached.selector = selector; // 2495 } // 2496 return cached; // 2497 }; // 2498 // 2499 /** // 2500 * A low-level selection function that works with Sizzle's compiled // 2501 * selector functions // 2502 * @param {String|Function} selector A selector or a pre-compiled // 2503 * selector function built with Sizzle.compile // 2504 * @param {Element} context // 2505 * @param {Array} [results] // 2506 * @param {Array} [seed] A set of elements to match against // 2507 */ // 2508 select = Sizzle.select = function( selector, context, results, seed ) { // 2509 var i, tokens, token, type, find, // 2510 compiled = typeof selector === "function" && selector, // 2511 match = !seed && tokenize( (selector = compiled.selector || selector) ); // 2512 // 2513 results = results || []; // 2514 // 2515 // Try to minimize operations if there is no seed and only one group // 2516 if ( match.length === 1 ) { // 2517 // 2518 // Take a shortcut and set the context if the root selector is an ID // 2519 tokens = match[0] = match[0].slice( 0 ); // 2520 if ( tokens.length > 2 && (token = tokens[0]).type === "ID" && // 2521 support.getById && context.nodeType === 9 && documentIsHTML && // 2522 Expr.relative[ tokens[1].type ] ) { // 2523 // 2524 context = ( Expr.find["ID"]( token.matches[0].replace(runescape, funescape), context ) || [] )[0]; // 2525 if ( !context ) { // 2526 return results; // 2527 // 2528 // Precompiled matchers will still verify ancestry, so step up a level // 2529 } else if ( compiled ) { // 2530 context = context.parentNode; // 2531 } // 2532 // 2533 selector = selector.slice( tokens.shift().value.length ); // 2534 } // 2535 // 2536 // Fetch a seed set for right-to-left matching // 2537 i = matchExpr["needsContext"].test( selector ) ? 0 : tokens.length; // 2538 while ( i-- ) { // 2539 token = tokens[i]; // 2540 // 2541 // Abort if we hit a combinator // 2542 if ( Expr.relative[ (type = token.type) ] ) { // 2543 break; // 2544 } // 2545 if ( (find = Expr.find[ type ]) ) { // 2546 // Search, expanding context for leading sibling combinators // 2547 if ( (seed = find( // 2548 token.matches[0].replace( runescape, funescape ), // 2549 rsibling.test( tokens[0].type ) && testContext( context.parentNode ) || context // 2550 )) ) { // 2551 // 2552 // If seed is empty or no tokens remain, we can return early // 2553 tokens.splice( i, 1 ); // 2554 selector = seed.length && toSelector( tokens ); // 2555 if ( !selector ) { // 2556 push.apply( results, seed ); // 2557 return results; // 2558 } // 2559 // 2560 break; // 2561 } // 2562 } // 2563 } // 2564 } // 2565 // 2566 // Compile and execute a filtering function if one is not provided // 2567 // Provide `match` to avoid retokenization if we modified the selector above // 2568 ( compiled || compile( selector, match ) )( // 2569 seed, // 2570 context, // 2571 !documentIsHTML, // 2572 results, // 2573 rsibling.test( selector ) && testContext( context.parentNode ) || context // 2574 ); // 2575 return results; // 2576 }; // 2577 // 2578 // One-time assignments // 2579 // 2580 // Sort stability // 2581 support.sortStable = expando.split("").sort( sortOrder ).join("") === expando; // 2582 // 2583 // Support: Chrome 14-35+ // 2584 // Always assume duplicates if they aren't passed to the comparison function // 2585 support.detectDuplicates = !!hasDuplicate; // 2586 // 2587 // Initialize against the default document // 2588 setDocument(); // 2589 // 2590 // Support: Webkit<537.32 - Safari 6.0.3/Chrome 25 (fixed in Chrome 27) // 2591 // Detached nodes confoundingly follow *each other* // 2592 support.sortDetached = assert(function( div1 ) { // 2593 // Should return 1, but returns 4 (following) // 2594 return div1.compareDocumentPosition( document.createElement("div") ) & 1; // 2595 }); // 2596 // 2597 // Support: IE<8 // 2598 // Prevent attribute/property "interpolation" // 2599 // http://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx // 2600 if ( !assert(function( div ) { // 2601 div.innerHTML = "<a href='#'></a>"; // 2602 return div.firstChild.getAttribute("href") === "#" ; // 2603 }) ) { // 2604 addHandle( "type|href|height|width", function( elem, name, isXML ) { // 2605 if ( !isXML ) { // 2606 return elem.getAttribute( name, name.toLowerCase() === "type" ? 1 : 2 ); // 2607 } // 2608 }); // 2609 } // 2610 // 2611 // Support: IE<9 // 2612 // Use defaultValue in place of getAttribute("value") // 2613 if ( !support.attributes || !assert(function( div ) { // 2614 div.innerHTML = "<input/>"; // 2615 div.firstChild.setAttribute( "value", "" ); // 2616 return div.firstChild.getAttribute( "value" ) === ""; // 2617 }) ) { // 2618 addHandle( "value", function( elem, name, isXML ) { // 2619 if ( !isXML && elem.nodeName.toLowerCase() === "input" ) { // 2620 return elem.defaultValue; // 2621 } // 2622 }); // 2623 } // 2624 // 2625 // Support: IE<9 // 2626 // Use getAttributeNode to fetch booleans when getAttribute lies // 2627 if ( !assert(function( div ) { // 2628 return div.getAttribute("disabled") == null; // 2629 }) ) { // 2630 addHandle( booleans, function( elem, name, isXML ) { // 2631 var val; // 2632 if ( !isXML ) { // 2633 return elem[ name ] === true ? name.toLowerCase() : // 2634 (val = elem.getAttributeNode( name )) && val.specified ? // 2635 val.value : // 2636 null; // 2637 } // 2638 }); // 2639 } // 2640 // 2641 return Sizzle; // 2642 // 2643 })( window ); // 2644 // 2645 // 2646 // 2647 jQuery.find = Sizzle; // 2648 jQuery.expr = Sizzle.selectors; // 2649 jQuery.expr[":"] = jQuery.expr.pseudos; // 2650 jQuery.unique = Sizzle.uniqueSort; // 2651 jQuery.text = Sizzle.getText; // 2652 jQuery.isXMLDoc = Sizzle.isXML; // 2653 jQuery.contains = Sizzle.contains; // 2654 // 2655 // 2656 // 2657 var rneedsContext = jQuery.expr.match.needsContext; // 2658 // 2659 var rsingleTag = (/^<(\w+)\s*\/?>(?:<\/\1>|)$/); // 2660 // 2661 // 2662 // 2663 var risSimple = /^.[^:#\[\.,]*$/; // 2664 // 2665 // Implement the identical functionality for filter and not // 2666 function winnow( elements, qualifier, not ) { // 2667 if ( jQuery.isFunction( qualifier ) ) { // 2668 return jQuery.grep( elements, function( elem, i ) { // 2669 /* jshint -W018 */ // 2670 return !!qualifier.call( elem, i, elem ) !== not; // 2671 }); // 2672 // 2673 } // 2674 // 2675 if ( qualifier.nodeType ) { // 2676 return jQuery.grep( elements, function( elem ) { // 2677 return ( elem === qualifier ) !== not; // 2678 }); // 2679 // 2680 } // 2681 // 2682 if ( typeof qualifier === "string" ) { // 2683 if ( risSimple.test( qualifier ) ) { // 2684 return jQuery.filter( qualifier, elements, not ); // 2685 } // 2686 // 2687 qualifier = jQuery.filter( qualifier, elements ); // 2688 } // 2689 // 2690 return jQuery.grep( elements, function( elem ) { // 2691 return ( jQuery.inArray( elem, qualifier ) >= 0 ) !== not; // 2692 }); // 2693 } // 2694 // 2695 jQuery.filter = function( expr, elems, not ) { // 2696 var elem = elems[ 0 ]; // 2697 // 2698 if ( not ) { // 2699 expr = ":not(" + expr + ")"; // 2700 } // 2701 // 2702 return elems.length === 1 && elem.nodeType === 1 ? // 2703 jQuery.find.matchesSelector( elem, expr ) ? [ elem ] : [] : // 2704 jQuery.find.matches( expr, jQuery.grep( elems, function( elem ) { // 2705 return elem.nodeType === 1; // 2706 })); // 2707 }; // 2708 // 2709 jQuery.fn.extend({ // 2710 find: function( selector ) { // 2711 var i, // 2712 ret = [], // 2713 self = this, // 2714 len = self.length; // 2715 // 2716 if ( typeof selector !== "string" ) { // 2717 return this.pushStack( jQuery( selector ).filter(function() { // 2718 for ( i = 0; i < len; i++ ) { // 2719 if ( jQuery.contains( self[ i ], this ) ) { // 2720 return true; // 2721 } // 2722 } // 2723 }) ); // 2724 } // 2725 // 2726 for ( i = 0; i < len; i++ ) { // 2727 jQuery.find( selector, self[ i ], ret ); // 2728 } // 2729 // 2730 // Needed because $( selector, context ) becomes $( context ).find( selector ) // 2731 ret = this.pushStack( len > 1 ? jQuery.unique( ret ) : ret ); // 2732 ret.selector = this.selector ? this.selector + " " + selector : selector; // 2733 return ret; // 2734 }, // 2735 filter: function( selector ) { // 2736 return this.pushStack( winnow(this, selector || [], false) ); // 2737 }, // 2738 not: function( selector ) { // 2739 return this.pushStack( winnow(this, selector || [], true) ); // 2740 }, // 2741 is: function( selector ) { // 2742 return !!winnow( // 2743 this, // 2744 // 2745 // If this is a positional/relative selector, check membership in the returned set // 2746 // so $("p:first").is("p:last") won't return true for a doc with two "p". // 2747 typeof selector === "string" && rneedsContext.test( selector ) ? // 2748 jQuery( selector ) : // 2749 selector || [], // 2750 false // 2751 ).length; // 2752 } // 2753 }); // 2754 // 2755 // 2756 // Initialize a jQuery object // 2757 // 2758 // 2759 // A central reference to the root jQuery(document) // 2760 var rootjQuery, // 2761 // 2762 // Use the correct document accordingly with window argument (sandbox) // 2763 document = window.document, // 2764 // 2765 // A simple way to check for HTML strings // 2766 // Prioritize #id over <tag> to avoid XSS via location.hash (#9521) // 2767 // Strict HTML recognition (#11290: must start with <) // 2768 rquickExpr = /^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]*))$/, // 2769 // 2770 init = jQuery.fn.init = function( selector, context ) { // 2771 var match, elem; // 2772 // 2773 // HANDLE: $(""), $(null), $(undefined), $(false) // 2774 if ( !selector ) { // 2775 return this; // 2776 } // 2777 // 2778 // Handle HTML strings // 2779 if ( typeof selector === "string" ) { // 2780 if ( selector.charAt(0) === "<" && selector.charAt( selector.length - 1 ) === ">" && selector.length >= 3 ) { // 2781 // Assume that strings that start and end with <> are HTML and skip the regex check // 2782 match = [ null, selector, null ]; // 2783 // 2784 } else { // 2785 match = rquickExpr.exec( selector ); // 2786 } // 2787 // 2788 // Match html or make sure no context is specified for #id // 2789 if ( match && (match[1] || !context) ) { // 2790 // 2791 // HANDLE: $(html) -> $(array) // 2792 if ( match[1] ) { // 2793 context = context instanceof jQuery ? context[0] : context; // 2794 // 2795 // scripts is true for back-compat // 2796 // Intentionally let the error be thrown if parseHTML is not present // 2797 jQuery.merge( this, jQuery.parseHTML( // 2798 match[1], // 2799 context && context.nodeType ? context.ownerDocument || context : document, // 2800 true // 2801 ) ); // 2802 // 2803 // HANDLE: $(html, props) // 2804 if ( rsingleTag.test( match[1] ) && jQuery.isPlainObject( context ) ) { // 2805 for ( match in context ) { // 2806 // Properties of context are called as methods if possible // 2807 if ( jQuery.isFunction( this[ match ] ) ) { // 2808 this[ match ]( context[ match ] ); // 2809 // 2810 // ...and otherwise set as attributes // 2811 } else { // 2812 this.attr( match, context[ match ] ); // 2813 } // 2814 } // 2815 } // 2816 // 2817 return this; // 2818 // 2819 // HANDLE: $(#id) // 2820 } else { // 2821 elem = document.getElementById( match[2] ); // 2822 // 2823 // Check parentNode to catch when Blackberry 4.6 returns // 2824 // nodes that are no longer in the document #6963 // 2825 if ( elem && elem.parentNode ) { // 2826 // Handle the case where IE and Opera return items // 2827 // by name instead of ID // 2828 if ( elem.id !== match[2] ) { // 2829 return rootjQuery.find( selector ); // 2830 } // 2831 // 2832 // Otherwise, we inject the element directly into the jQuery object // 2833 this.length = 1; // 2834 this[0] = elem; // 2835 } // 2836 // 2837 this.context = document; // 2838 this.selector = selector; // 2839 return this; // 2840 } // 2841 // 2842 // HANDLE: $(expr, $(...)) // 2843 } else if ( !context || context.jquery ) { // 2844 return ( context || rootjQuery ).find( selector ); // 2845 // 2846 // HANDLE: $(expr, context) // 2847 // (which is just equivalent to: $(context).find(expr) // 2848 } else { // 2849 return this.constructor( context ).find( selector ); // 2850 } // 2851 // 2852 // HANDLE: $(DOMElement) // 2853 } else if ( selector.nodeType ) { // 2854 this.context = this[0] = selector; // 2855 this.length = 1; // 2856 return this; // 2857 // 2858 // HANDLE: $(function) // 2859 // Shortcut for document ready // 2860 } else if ( jQuery.isFunction( selector ) ) { // 2861 return typeof rootjQuery.ready !== "undefined" ? // 2862 rootjQuery.ready( selector ) : // 2863 // Execute immediately if ready is not present // 2864 selector( jQuery ); // 2865 } // 2866 // 2867 if ( selector.selector !== undefined ) { // 2868 this.selector = selector.selector; // 2869 this.context = selector.context; // 2870 } // 2871 // 2872 return jQuery.makeArray( selector, this ); // 2873 }; // 2874 // 2875 // Give the init function the jQuery prototype for later instantiation // 2876 init.prototype = jQuery.fn; // 2877 // 2878 // Initialize central reference // 2879 rootjQuery = jQuery( document ); // 2880 // 2881 // 2882 var rparentsprev = /^(?:parents|prev(?:Until|All))/, // 2883 // methods guaranteed to produce a unique set when starting from a unique set // 2884 guaranteedUnique = { // 2885 children: true, // 2886 contents: true, // 2887 next: true, // 2888 prev: true // 2889 }; // 2890 // 2891 jQuery.extend({ // 2892 dir: function( elem, dir, until ) { // 2893 var matched = [], // 2894 cur = elem[ dir ]; // 2895 // 2896 while ( cur && cur.nodeType !== 9 && (until === undefined || cur.nodeType !== 1 || !jQuery( cur ).is( until )) ) { // 2897 if ( cur.nodeType === 1 ) { // 2898 matched.push( cur ); // 2899 } // 2900 cur = cur[dir]; // 2901 } // 2902 return matched; // 2903 }, // 2904 // 2905 sibling: function( n, elem ) { // 2906 var r = []; // 2907 // 2908 for ( ; n; n = n.nextSibling ) { // 2909 if ( n.nodeType === 1 && n !== elem ) { // 2910 r.push( n ); // 2911 } // 2912 } // 2913 // 2914 return r; // 2915 } // 2916 }); // 2917 // 2918 jQuery.fn.extend({ // 2919 has: function( target ) { // 2920 var i, // 2921 targets = jQuery( target, this ), // 2922 len = targets.length; // 2923 // 2924 return this.filter(function() { // 2925 for ( i = 0; i < len; i++ ) { // 2926 if ( jQuery.contains( this, targets[i] ) ) { // 2927 return true; // 2928 } // 2929 } // 2930 }); // 2931 }, // 2932 // 2933 closest: function( selectors, context ) { // 2934 var cur, // 2935 i = 0, // 2936 l = this.length, // 2937 matched = [], // 2938 pos = rneedsContext.test( selectors ) || typeof selectors !== "string" ? // 2939 jQuery( selectors, context || this.context ) : // 2940 0; // 2941 // 2942 for ( ; i < l; i++ ) { // 2943 for ( cur = this[i]; cur && cur !== context; cur = cur.parentNode ) { // 2944 // Always skip document fragments // 2945 if ( cur.nodeType < 11 && (pos ? // 2946 pos.index(cur) > -1 : // 2947 // 2948 // Don't pass non-elements to Sizzle // 2949 cur.nodeType === 1 && // 2950 jQuery.find.matchesSelector(cur, selectors)) ) { // 2951 // 2952 matched.push( cur ); // 2953 break; // 2954 } // 2955 } // 2956 } // 2957 // 2958 return this.pushStack( matched.length > 1 ? jQuery.unique( matched ) : matched ); // 2959 }, // 2960 // 2961 // Determine the position of an element within // 2962 // the matched set of elements // 2963 index: function( elem ) { // 2964 // 2965 // No argument, return index in parent // 2966 if ( !elem ) { // 2967 return ( this[0] && this[0].parentNode ) ? this.first().prevAll().length : -1; // 2968 } // 2969 // 2970 // index in selector // 2971 if ( typeof elem === "string" ) { // 2972 return jQuery.inArray( this[0], jQuery( elem ) ); // 2973 } // 2974 // 2975 // Locate the position of the desired element // 2976 return jQuery.inArray( // 2977 // If it receives a jQuery object, the first element is used // 2978 elem.jquery ? elem[0] : elem, this ); // 2979 }, // 2980 // 2981 add: function( selector, context ) { // 2982 return this.pushStack( // 2983 jQuery.unique( // 2984 jQuery.merge( this.get(), jQuery( selector, context ) ) // 2985 ) // 2986 ); // 2987 }, // 2988 // 2989 addBack: function( selector ) { // 2990 return this.add( selector == null ? // 2991 this.prevObject : this.prevObject.filter(selector) // 2992 ); // 2993 } // 2994 }); // 2995 // 2996 function sibling( cur, dir ) { // 2997 do { // 2998 cur = cur[ dir ]; // 2999 } while ( cur && cur.nodeType !== 1 ); // 3000 // 3001 return cur; // 3002 } // 3003 // 3004 jQuery.each({ // 3005 parent: function( elem ) { // 3006 var parent = elem.parentNode; // 3007 return parent && parent.nodeType !== 11 ? parent : null; // 3008 }, // 3009 parents: function( elem ) { // 3010 return jQuery.dir( elem, "parentNode" ); // 3011 }, // 3012 parentsUntil: function( elem, i, until ) { // 3013 return jQuery.dir( elem, "parentNode", until ); // 3014 }, // 3015 next: function( elem ) { // 3016 return sibling( elem, "nextSibling" ); // 3017 }, // 3018 prev: function( elem ) { // 3019 return sibling( elem, "previousSibling" ); // 3020 }, // 3021 nextAll: function( elem ) { // 3022 return jQuery.dir( elem, "nextSibling" ); // 3023 }, // 3024 prevAll: function( elem ) { // 3025 return jQuery.dir( elem, "previousSibling" ); // 3026 }, // 3027 nextUntil: function( elem, i, until ) { // 3028 return jQuery.dir( elem, "nextSibling", until ); // 3029 }, // 3030 prevUntil: function( elem, i, until ) { // 3031 return jQuery.dir( elem, "previousSibling", until ); // 3032 }, // 3033 siblings: function( elem ) { // 3034 return jQuery.sibling( ( elem.parentNode || {} ).firstChild, elem ); // 3035 }, // 3036 children: function( elem ) { // 3037 return jQuery.sibling( elem.firstChild ); // 3038 }, // 3039 contents: function( elem ) { // 3040 return jQuery.nodeName( elem, "iframe" ) ? // 3041 elem.contentDocument || elem.contentWindow.document : // 3042 jQuery.merge( [], elem.childNodes ); // 3043 } // 3044 }, function( name, fn ) { // 3045 jQuery.fn[ name ] = function( until, selector ) { // 3046 var ret = jQuery.map( this, fn, until ); // 3047 // 3048 if ( name.slice( -5 ) !== "Until" ) { // 3049 selector = until; // 3050 } // 3051 // 3052 if ( selector && typeof selector === "string" ) { // 3053 ret = jQuery.filter( selector, ret ); // 3054 } // 3055 // 3056 if ( this.length > 1 ) { // 3057 // Remove duplicates // 3058 if ( !guaranteedUnique[ name ] ) { // 3059 ret = jQuery.unique( ret ); // 3060 } // 3061 // 3062 // Reverse order for parents* and prev-derivatives // 3063 if ( rparentsprev.test( name ) ) { // 3064 ret = ret.reverse(); // 3065 } // 3066 } // 3067 // 3068 return this.pushStack( ret ); // 3069 }; // 3070 }); // 3071 var rnotwhite = (/\S+/g); // 3072 // 3073 // 3074 // 3075 // String to Object options format cache // 3076 var optionsCache = {}; // 3077 // 3078 // Convert String-formatted options into Object-formatted ones and store in cache // 3079 function createOptions( options ) { // 3080 var object = optionsCache[ options ] = {}; // 3081 jQuery.each( options.match( rnotwhite ) || [], function( _, flag ) { // 3082 object[ flag ] = true; // 3083 }); // 3084 return object; // 3085 } // 3086 // 3087 /* // 3088 * Create a callback list using the following parameters: // 3089 * // 3090 * options: an optional list of space-separated options that will change how // 3091 * the callback list behaves or a more traditional option object // 3092 * // 3093 * By default a callback list will act like an event callback list and can be // 3094 * "fired" multiple times. // 3095 * // 3096 * Possible options: // 3097 * // 3098 * once: will ensure the callback list can only be fired once (like a Deferred) // 3099 * // 3100 * memory: will keep track of previous values and will call any callback added // 3101 * after the list has been fired right away with the latest "memorized" // 3102 * values (like a Deferred) // 3103 * // 3104 * unique: will ensure a callback can only be added once (no duplicate in the list) // 3105 * // 3106 * stopOnFalse: interrupt callings when a callback returns false // 3107 * // 3108 */ // 3109 jQuery.Callbacks = function( options ) { // 3110 // 3111 // Convert options from String-formatted to Object-formatted if needed // 3112 // (we check in cache first) // 3113 options = typeof options === "string" ? // 3114 ( optionsCache[ options ] || createOptions( options ) ) : // 3115 jQuery.extend( {}, options ); // 3116 // 3117 var // Flag to know if list is currently firing // 3118 firing, // 3119 // Last fire value (for non-forgettable lists) // 3120 memory, // 3121 // Flag to know if list was already fired // 3122 fired, // 3123 // End of the loop when firing // 3124 firingLength, // 3125 // Index of currently firing callback (modified by remove if needed) // 3126 firingIndex, // 3127 // First callback to fire (used internally by add and fireWith) // 3128 firingStart, // 3129 // Actual callback list // 3130 list = [], // 3131 // Stack of fire calls for repeatable lists // 3132 stack = !options.once && [], // 3133 // Fire callbacks // 3134 fire = function( data ) { // 3135 memory = options.memory && data; // 3136 fired = true; // 3137 firingIndex = firingStart || 0; // 3138 firingStart = 0; // 3139 firingLength = list.length; // 3140 firing = true; // 3141 for ( ; list && firingIndex < firingLength; firingIndex++ ) { // 3142 if ( list[ firingIndex ].apply( data[ 0 ], data[ 1 ] ) === false && options.stopOnFalse ) { // 3143 memory = false; // To prevent further calls using add // 3144 break; // 3145 } // 3146 } // 3147 firing = false; // 3148 if ( list ) { // 3149 if ( stack ) { // 3150 if ( stack.length ) { // 3151 fire( stack.shift() ); // 3152 } // 3153 } else if ( memory ) { // 3154 list = []; // 3155 } else { // 3156 self.disable(); // 3157 } // 3158 } // 3159 }, // 3160 // Actual Callbacks object // 3161 self = { // 3162 // Add a callback or a collection of callbacks to the list // 3163 add: function() { // 3164 if ( list ) { // 3165 // First, we save the current length // 3166 var start = list.length; // 3167 (function add( args ) { // 3168 jQuery.each( args, function( _, arg ) { // 3169 var type = jQuery.type( arg ); // 3170 if ( type === "function" ) { // 3171 if ( !options.unique || !self.has( arg ) ) { // 3172 list.push( arg ); // 3173 } // 3174 } else if ( arg && arg.length && type !== "string" ) { // 3175 // Inspect recursively // 3176 add( arg ); // 3177 } // 3178 }); // 3179 })( arguments ); // 3180 // Do we need to add the callbacks to the // 3181 // current firing batch? // 3182 if ( firing ) { // 3183 firingLength = list.length; // 3184 // With memory, if we're not firing then // 3185 // we should call right away // 3186 } else if ( memory ) { // 3187 firingStart = start; // 3188 fire( memory ); // 3189 } // 3190 } // 3191 return this; // 3192 }, // 3193 // Remove a callback from the list // 3194 remove: function() { // 3195 if ( list ) { // 3196 jQuery.each( arguments, function( _, arg ) { // 3197 var index; // 3198 while ( ( index = jQuery.inArray( arg, list, index ) ) > -1 ) { // 3199 list.splice( index, 1 ); // 3200 // Handle firing indexes // 3201 if ( firing ) { // 3202 if ( index <= firingLength ) { // 3203 firingLength--; // 3204 } // 3205 if ( index <= firingIndex ) { // 3206 firingIndex--; // 3207 } // 3208 } // 3209 } // 3210 }); // 3211 } // 3212 return this; // 3213 }, // 3214 // Check if a given callback is in the list. // 3215 // If no argument is given, return whether or not list has callbacks attached. // 3216 has: function( fn ) { // 3217 return fn ? jQuery.inArray( fn, list ) > -1 : !!( list && list.length ); // 3218 }, // 3219 // Remove all callbacks from the list // 3220 empty: function() { // 3221 list = []; // 3222 firingLength = 0; // 3223 return this; // 3224 }, // 3225 // Have the list do nothing anymore // 3226 disable: function() { // 3227 list = stack = memory = undefined; // 3228 return this; // 3229 }, // 3230 // Is it disabled? // 3231 disabled: function() { // 3232 return !list; // 3233 }, // 3234 // Lock the list in its current state // 3235 lock: function() { // 3236 stack = undefined; // 3237 if ( !memory ) { // 3238 self.disable(); // 3239 } // 3240 return this; // 3241 }, // 3242 // Is it locked? // 3243 locked: function() { // 3244 return !stack; // 3245 }, // 3246 // Call all callbacks with the given context and arguments // 3247 fireWith: function( context, args ) { // 3248 if ( list && ( !fired || stack ) ) { // 3249 args = args || []; // 3250 args = [ context, args.slice ? args.slice() : args ]; // 3251 if ( firing ) { // 3252 stack.push( args ); // 3253 } else { // 3254 fire( args ); // 3255 } // 3256 } // 3257 return this; // 3258 }, // 3259 // Call all the callbacks with the given arguments // 3260 fire: function() { // 3261 self.fireWith( this, arguments ); // 3262 return this; // 3263 }, // 3264 // To know if the callbacks have already been called at least once // 3265 fired: function() { // 3266 return !!fired; // 3267 } // 3268 }; // 3269 // 3270 return self; // 3271 }; // 3272 // 3273 // 3274 jQuery.extend({ // 3275 // 3276 Deferred: function( func ) { // 3277 var tuples = [ // 3278 // action, add listener, listener list, final state // 3279 [ "resolve", "done", jQuery.Callbacks("once memory"), "resolved" ], // 3280 [ "reject", "fail", jQuery.Callbacks("once memory"), "rejected" ], // 3281 [ "notify", "progress", jQuery.Callbacks("memory") ] // 3282 ], // 3283 state = "pending", // 3284 promise = { // 3285 state: function() { // 3286 return state; // 3287 }, // 3288 always: function() { // 3289 deferred.done( arguments ).fail( arguments ); // 3290 return this; // 3291 }, // 3292 then: function( /* fnDone, fnFail, fnProgress */ ) { // 3293 var fns = arguments; // 3294 return jQuery.Deferred(function( newDefer ) { // 3295 jQuery.each( tuples, function( i, tuple ) { // 3296 var fn = jQuery.isFunction( fns[ i ] ) && fns[ i ]; // 3297 // deferred[ done | fail | progress ] for forwarding actions to newDefer // 3298 deferred[ tuple[1] ](function() { // 3299 var returned = fn && fn.apply( this, arguments ); // 3300 if ( returned && jQuery.isFunction( returned.promise ) ) { // 3301 returned.promise() // 3302 .done( newDefer.resolve ) // 3303 .fail( newDefer.reject ) // 3304 .progress( newDefer.notify ); // 3305 } else { // 3306 newDefer[ tuple[ 0 ] + "With" ]( this === promise ? newDefer.promise() : this, fn ? [ returned ] : arguments ); } // 3308 }); // 3309 }); // 3310 fns = null; // 3311 }).promise(); // 3312 }, // 3313 // Get a promise for this deferred // 3314 // If obj is provided, the promise aspect is added to the object // 3315 promise: function( obj ) { // 3316 return obj != null ? jQuery.extend( obj, promise ) : promise; // 3317 } // 3318 }, // 3319 deferred = {}; // 3320 // 3321 // Keep pipe for back-compat // 3322 promise.pipe = promise.then; // 3323 // 3324 // Add list-specific methods // 3325 jQuery.each( tuples, function( i, tuple ) { // 3326 var list = tuple[ 2 ], // 3327 stateString = tuple[ 3 ]; // 3328 // 3329 // promise[ done | fail | progress ] = list.add // 3330 promise[ tuple[1] ] = list.add; // 3331 // 3332 // Handle state // 3333 if ( stateString ) { // 3334 list.add(function() { // 3335 // state = [ resolved | rejected ] // 3336 state = stateString; // 3337 // 3338 // [ reject_list | resolve_list ].disable; progress_list.lock // 3339 }, tuples[ i ^ 1 ][ 2 ].disable, tuples[ 2 ][ 2 ].lock ); // 3340 } // 3341 // 3342 // deferred[ resolve | reject | notify ] // 3343 deferred[ tuple[0] ] = function() { // 3344 deferred[ tuple[0] + "With" ]( this === deferred ? promise : this, arguments ); // 3345 return this; // 3346 }; // 3347 deferred[ tuple[0] + "With" ] = list.fireWith; // 3348 }); // 3349 // 3350 // Make the deferred a promise // 3351 promise.promise( deferred ); // 3352 // 3353 // Call given func if any // 3354 if ( func ) { // 3355 func.call( deferred, deferred ); // 3356 } // 3357 // 3358 // All done! // 3359 return deferred; // 3360 }, // 3361 // 3362 // Deferred helper // 3363 when: function( subordinate /* , ..., subordinateN */ ) { // 3364 var i = 0, // 3365 resolveValues = slice.call( arguments ), // 3366 length = resolveValues.length, // 3367 // 3368 // the count of uncompleted subordinates // 3369 remaining = length !== 1 || ( subordinate && jQuery.isFunction( subordinate.promise ) ) ? length : 0, // 3370 // 3371 // the master Deferred. If resolveValues consist of only a single Deferred, just use that. // 3372 deferred = remaining === 1 ? subordinate : jQuery.Deferred(), // 3373 // 3374 // Update function for both resolve and progress values // 3375 updateFunc = function( i, contexts, values ) { // 3376 return function( value ) { // 3377 contexts[ i ] = this; // 3378 values[ i ] = arguments.length > 1 ? slice.call( arguments ) : value; // 3379 if ( values === progressValues ) { // 3380 deferred.notifyWith( contexts, values ); // 3381 // 3382 } else if ( !(--remaining) ) { // 3383 deferred.resolveWith( contexts, values ); // 3384 } // 3385 }; // 3386 }, // 3387 // 3388 progressValues, progressContexts, resolveContexts; // 3389 // 3390 // add listeners to Deferred subordinates; treat others as resolved // 3391 if ( length > 1 ) { // 3392 progressValues = new Array( length ); // 3393 progressContexts = new Array( length ); // 3394 resolveContexts = new Array( length ); // 3395 for ( ; i < length; i++ ) { // 3396 if ( resolveValues[ i ] && jQuery.isFunction( resolveValues[ i ].promise ) ) { // 3397 resolveValues[ i ].promise() // 3398 .done( updateFunc( i, resolveContexts, resolveValues ) ) // 3399 .fail( deferred.reject ) // 3400 .progress( updateFunc( i, progressContexts, progressValues ) ); // 3401 } else { // 3402 --remaining; // 3403 } // 3404 } // 3405 } // 3406 // 3407 // if we're not waiting on anything, resolve the master // 3408 if ( !remaining ) { // 3409 deferred.resolveWith( resolveContexts, resolveValues ); // 3410 } // 3411 // 3412 return deferred.promise(); // 3413 } // 3414 }); // 3415 // 3416 // 3417 // The deferred used on DOM ready // 3418 var readyList; // 3419 // 3420 jQuery.fn.ready = function( fn ) { // 3421 // Add the callback // 3422 jQuery.ready.promise().done( fn ); // 3423 // 3424 return this; // 3425 }; // 3426 // 3427 jQuery.extend({ // 3428 // Is the DOM ready to be used? Set to true once it occurs. // 3429 isReady: false, // 3430 // 3431 // A counter to track how many items to wait for before // 3432 // the ready event fires. See #6781 // 3433 readyWait: 1, // 3434 // 3435 // Hold (or release) the ready event // 3436 holdReady: function( hold ) { // 3437 if ( hold ) { // 3438 jQuery.readyWait++; // 3439 } else { // 3440 jQuery.ready( true ); // 3441 } // 3442 }, // 3443 // 3444 // Handle when the DOM is ready // 3445 ready: function( wait ) { // 3446 // 3447 // Abort if there are pending holds or we're already ready // 3448 if ( wait === true ? --jQuery.readyWait : jQuery.isReady ) { // 3449 return; // 3450 } // 3451 // 3452 // Make sure body exists, at least, in case IE gets a little overzealous (ticket #5443). // 3453 if ( !document.body ) { // 3454 return setTimeout( jQuery.ready ); // 3455 } // 3456 // 3457 // Remember that the DOM is ready // 3458 jQuery.isReady = true; // 3459 // 3460 // If a normal DOM Ready event fired, decrement, and wait if need be // 3461 if ( wait !== true && --jQuery.readyWait > 0 ) { // 3462 return; // 3463 } // 3464 // 3465 // If there are functions bound, to execute // 3466 readyList.resolveWith( document, [ jQuery ] ); // 3467 // 3468 // Trigger any bound ready events // 3469 if ( jQuery.fn.triggerHandler ) { // 3470 jQuery( document ).triggerHandler( "ready" ); // 3471 jQuery( document ).off( "ready" ); // 3472 } // 3473 } // 3474 }); // 3475 // 3476 /** // 3477 * Clean-up method for dom ready events // 3478 */ // 3479 function detach() { // 3480 if ( document.addEventListener ) { // 3481 document.removeEventListener( "DOMContentLoaded", completed, false ); // 3482 window.removeEventListener( "load", completed, false ); // 3483 // 3484 } else { // 3485 document.detachEvent( "onreadystatechange", completed ); // 3486 window.detachEvent( "onload", completed ); // 3487 } // 3488 } // 3489 // 3490 /** // 3491 * The ready event handler and self cleanup method // 3492 */ // 3493 function completed() { // 3494 // readyState === "complete" is good enough for us to call the dom ready in oldIE // 3495 if ( document.addEventListener || event.type === "load" || document.readyState === "complete" ) { // 3496 detach(); // 3497 jQuery.ready(); // 3498 } // 3499 } // 3500 // 3501 jQuery.ready.promise = function( obj ) { // 3502 if ( !readyList ) { // 3503 // 3504 readyList = jQuery.Deferred(); // 3505 // 3506 // Catch cases where $(document).ready() is called after the browser event has already occurred. // 3507 // we once tried to use readyState "interactive" here, but it caused issues like the one // 3508 // discovered by ChrisS here: http://bugs.jquery.com/ticket/12282#comment:15 // 3509 if ( document.readyState === "complete" ) { // 3510 // Handle it asynchronously to allow scripts the opportunity to delay ready // 3511 setTimeout( jQuery.ready ); // 3512 // 3513 // Standards-based browsers support DOMContentLoaded // 3514 } else if ( document.addEventListener ) { // 3515 // Use the handy event callback // 3516 document.addEventListener( "DOMContentLoaded", completed, false ); // 3517 // 3518 // A fallback to window.onload, that will always work // 3519 window.addEventListener( "load", completed, false ); // 3520 // 3521 // If IE event model is used // 3522 } else { // 3523 // Ensure firing before onload, maybe late but safe also for iframes // 3524 document.attachEvent( "onreadystatechange", completed ); // 3525 // 3526 // A fallback to window.onload, that will always work // 3527 window.attachEvent( "onload", completed ); // 3528 // 3529 // If IE and not a frame // 3530 // continually check to see if the document is ready // 3531 var top = false; // 3532 // 3533 try { // 3534 top = window.frameElement == null && document.documentElement; // 3535 } catch(e) {} // 3536 // 3537 if ( top && top.doScroll ) { // 3538 (function doScrollCheck() { // 3539 if ( !jQuery.isReady ) { // 3540 // 3541 try { // 3542 // Use the trick by Diego Perini // 3543 // http://javascript.nwbox.com/IEContentLoaded/ // 3544 top.doScroll("left"); // 3545 } catch(e) { // 3546 return setTimeout( doScrollCheck, 50 ); // 3547 } // 3548 // 3549 // detach all dom ready events // 3550 detach(); // 3551 // 3552 // and execute any waiting functions // 3553 jQuery.ready(); // 3554 } // 3555 })(); // 3556 } // 3557 } // 3558 } // 3559 return readyList.promise( obj ); // 3560 }; // 3561 // 3562 // 3563 var strundefined = typeof undefined; // 3564 // 3565 // 3566 // 3567 // Support: IE<9 // 3568 // Iteration over object's inherited properties before its own // 3569 var i; // 3570 for ( i in jQuery( support ) ) { // 3571 break; // 3572 } // 3573 support.ownLast = i !== "0"; // 3574 // 3575 // Note: most support tests are defined in their respective modules. // 3576 // false until the test is run // 3577 support.inlineBlockNeedsLayout = false; // 3578 // 3579 // Execute ASAP in case we need to set body.style.zoom // 3580 jQuery(function() { // 3581 // Minified: var a,b,c,d // 3582 var val, div, body, container; // 3583 // 3584 body = document.getElementsByTagName( "body" )[ 0 ]; // 3585 if ( !body || !body.style ) { // 3586 // Return for frameset docs that don't have a body // 3587 return; // 3588 } // 3589 // 3590 // Setup // 3591 div = document.createElement( "div" ); // 3592 container = document.createElement( "div" ); // 3593 container.style.cssText = "position:absolute;border:0;width:0;height:0;top:0;left:-9999px"; // 3594 body.appendChild( container ).appendChild( div ); // 3595 // 3596 if ( typeof div.style.zoom !== strundefined ) { // 3597 // Support: IE<8 // 3598 // Check if natively block-level elements act like inline-block // 3599 // elements when setting their display to 'inline' and giving // 3600 // them layout // 3601 div.style.cssText = "display:inline;margin:0;border:0;padding:1px;width:1px;zoom:1"; // 3602 // 3603 support.inlineBlockNeedsLayout = val = div.offsetWidth === 3; // 3604 if ( val ) { // 3605 // Prevent IE 6 from affecting layout for positioned elements #11048 // 3606 // Prevent IE from shrinking the body in IE 7 mode #12869 // 3607 // Support: IE<8 // 3608 body.style.zoom = 1; // 3609 } // 3610 } // 3611 // 3612 body.removeChild( container ); // 3613 }); // 3614 // 3615 // 3616 // 3617 // 3618 (function() { // 3619 var div = document.createElement( "div" ); // 3620 // 3621 // Execute the test only if not already executed in another module. // 3622 if (support.deleteExpando == null) { // 3623 // Support: IE<9 // 3624 support.deleteExpando = true; // 3625 try { // 3626 delete div.test; // 3627 } catch( e ) { // 3628 support.deleteExpando = false; // 3629 } // 3630 } // 3631 // 3632 // Null elements to avoid leaks in IE. // 3633 div = null; // 3634 })(); // 3635 // 3636 // 3637 /** // 3638 * Determines whether an object can have data // 3639 */ // 3640 jQuery.acceptData = function( elem ) { // 3641 var noData = jQuery.noData[ (elem.nodeName + " ").toLowerCase() ], // 3642 nodeType = +elem.nodeType || 1; // 3643 // 3644 // Do not set data on non-element DOM nodes because it will not be cleared (#8335). // 3645 return nodeType !== 1 && nodeType !== 9 ? // 3646 false : // 3647 // 3648 // Nodes accept data unless otherwise specified; rejection can be conditional // 3649 !noData || noData !== true && elem.getAttribute("classid") === noData; // 3650 }; // 3651 // 3652 // 3653 var rbrace = /^(?:\{[\w\W]*\}|\[[\w\W]*\])$/, // 3654 rmultiDash = /([A-Z])/g; // 3655 // 3656 function dataAttr( elem, key, data ) { // 3657 // If nothing was found internally, try to fetch any // 3658 // data from the HTML5 data-* attribute // 3659 if ( data === undefined && elem.nodeType === 1 ) { // 3660 // 3661 var name = "data-" + key.replace( rmultiDash, "-$1" ).toLowerCase(); // 3662 // 3663 data = elem.getAttribute( name ); // 3664 // 3665 if ( typeof data === "string" ) { // 3666 try { // 3667 data = data === "true" ? true : // 3668 data === "false" ? false : // 3669 data === "null" ? null : // 3670 // Only convert to a number if it doesn't change the string // 3671 +data + "" === data ? +data : // 3672 rbrace.test( data ) ? jQuery.parseJSON( data ) : // 3673 data; // 3674 } catch( e ) {} // 3675 // 3676 // Make sure we set the data so it isn't changed later // 3677 jQuery.data( elem, key, data ); // 3678 // 3679 } else { // 3680 data = undefined; // 3681 } // 3682 } // 3683 // 3684 return data; // 3685 } // 3686 // 3687 // checks a cache object for emptiness // 3688 function isEmptyDataObject( obj ) { // 3689 var name; // 3690 for ( name in obj ) { // 3691 // 3692 // if the public data object is empty, the private is still empty // 3693 if ( name === "data" && jQuery.isEmptyObject( obj[name] ) ) { // 3694 continue; // 3695 } // 3696 if ( name !== "toJSON" ) { // 3697 return false; // 3698 } // 3699 } // 3700 // 3701 return true; // 3702 } // 3703 // 3704 function internalData( elem, name, data, pvt /* Internal Use Only */ ) { // 3705 if ( !jQuery.acceptData( elem ) ) { // 3706 return; // 3707 } // 3708 // 3709 var ret, thisCache, // 3710 internalKey = jQuery.expando, // 3711 // 3712 // We have to handle DOM nodes and JS objects differently because IE6-7 // 3713 // can't GC object references properly across the DOM-JS boundary // 3714 isNode = elem.nodeType, // 3715 // 3716 // Only DOM nodes need the global jQuery cache; JS object data is // 3717 // attached directly to the object so GC can occur automatically // 3718 cache = isNode ? jQuery.cache : elem, // 3719 // 3720 // Only defining an ID for JS objects if its cache already exists allows // 3721 // the code to shortcut on the same path as a DOM node with no cache // 3722 id = isNode ? elem[ internalKey ] : elem[ internalKey ] && internalKey; // 3723 // 3724 // Avoid doing any more work than we need to when trying to get data on an // 3725 // object that has no data at all // 3726 if ( (!id || !cache[id] || (!pvt && !cache[id].data)) && data === undefined && typeof name === "string" ) { // 3727 return; // 3728 } // 3729 // 3730 if ( !id ) { // 3731 // Only DOM nodes need a new unique ID for each element since their data // 3732 // ends up in the global cache // 3733 if ( isNode ) { // 3734 id = elem[ internalKey ] = deletedIds.pop() || jQuery.guid++; // 3735 } else { // 3736 id = internalKey; // 3737 } // 3738 } // 3739 // 3740 if ( !cache[ id ] ) { // 3741 // Avoid exposing jQuery metadata on plain JS objects when the object // 3742 // is serialized using JSON.stringify // 3743 cache[ id ] = isNode ? {} : { toJSON: jQuery.noop }; // 3744 } // 3745 // 3746 // An object can be passed to jQuery.data instead of a key/value pair; this gets // 3747 // shallow copied over onto the existing cache // 3748 if ( typeof name === "object" || typeof name === "function" ) { // 3749 if ( pvt ) { // 3750 cache[ id ] = jQuery.extend( cache[ id ], name ); // 3751 } else { // 3752 cache[ id ].data = jQuery.extend( cache[ id ].data, name ); // 3753 } // 3754 } // 3755 // 3756 thisCache = cache[ id ]; // 3757 // 3758 // jQuery data() is stored in a separate object inside the object's internal data // 3759 // cache in order to avoid key collisions between internal data and user-defined // 3760 // data. // 3761 if ( !pvt ) { // 3762 if ( !thisCache.data ) { // 3763 thisCache.data = {}; // 3764 } // 3765 // 3766 thisCache = thisCache.data; // 3767 } // 3768 // 3769 if ( data !== undefined ) { // 3770 thisCache[ jQuery.camelCase( name ) ] = data; // 3771 } // 3772 // 3773 // Check for both converted-to-camel and non-converted data property names // 3774 // If a data property was specified // 3775 if ( typeof name === "string" ) { // 3776 // 3777 // First Try to find as-is property data // 3778 ret = thisCache[ name ]; // 3779 // 3780 // Test for null|undefined property data // 3781 if ( ret == null ) { // 3782 // 3783 // Try to find the camelCased property // 3784 ret = thisCache[ jQuery.camelCase( name ) ]; // 3785 } // 3786 } else { // 3787 ret = thisCache; // 3788 } // 3789 // 3790 return ret; // 3791 } // 3792 // 3793 function internalRemoveData( elem, name, pvt ) { // 3794 if ( !jQuery.acceptData( elem ) ) { // 3795 return; // 3796 } // 3797 // 3798 var thisCache, i, // 3799 isNode = elem.nodeType, // 3800 // 3801 // See jQuery.data for more information // 3802 cache = isNode ? jQuery.cache : elem, // 3803 id = isNode ? elem[ jQuery.expando ] : jQuery.expando; // 3804 // 3805 // If there is already no cache entry for this object, there is no // 3806 // purpose in continuing // 3807 if ( !cache[ id ] ) { // 3808 return; // 3809 } // 3810 // 3811 if ( name ) { // 3812 // 3813 thisCache = pvt ? cache[ id ] : cache[ id ].data; // 3814 // 3815 if ( thisCache ) { // 3816 // 3817 // Support array or space separated string names for data keys // 3818 if ( !jQuery.isArray( name ) ) { // 3819 // 3820 // try the string as a key before any manipulation // 3821 if ( name in thisCache ) { // 3822 name = [ name ]; // 3823 } else { // 3824 // 3825 // split the camel cased version by spaces unless a key with the spaces exists // 3826 name = jQuery.camelCase( name ); // 3827 if ( name in thisCache ) { // 3828 name = [ name ]; // 3829 } else { // 3830 name = name.split(" "); // 3831 } // 3832 } // 3833 } else { // 3834 // If "name" is an array of keys... // 3835 // When data is initially created, via ("key", "val") signature, // 3836 // keys will be converted to camelCase. // 3837 // Since there is no way to tell _how_ a key was added, remove // 3838 // both plain key and camelCase key. #12786 // 3839 // This will only penalize the array argument path. // 3840 name = name.concat( jQuery.map( name, jQuery.camelCase ) ); // 3841 } // 3842 // 3843 i = name.length; // 3844 while ( i-- ) { // 3845 delete thisCache[ name[i] ]; // 3846 } // 3847 // 3848 // If there is no data left in the cache, we want to continue // 3849 // and let the cache object itself get destroyed // 3850 if ( pvt ? !isEmptyDataObject(thisCache) : !jQuery.isEmptyObject(thisCache) ) { // 3851 return; // 3852 } // 3853 } // 3854 } // 3855 // 3856 // See jQuery.data for more information // 3857 if ( !pvt ) { // 3858 delete cache[ id ].data; // 3859 // 3860 // Don't destroy the parent cache unless the internal data object // 3861 // had been the only thing left in it // 3862 if ( !isEmptyDataObject( cache[ id ] ) ) { // 3863 return; // 3864 } // 3865 } // 3866 // 3867 // Destroy the cache // 3868 if ( isNode ) { // 3869 jQuery.cleanData( [ elem ], true ); // 3870 // 3871 // Use delete when supported for expandos or `cache` is not a window per isWindow (#10080) // 3872 /* jshint eqeqeq: false */ // 3873 } else if ( support.deleteExpando || cache != cache.window ) { // 3874 /* jshint eqeqeq: true */ // 3875 delete cache[ id ]; // 3876 // 3877 // When all else fails, null // 3878 } else { // 3879 cache[ id ] = null; // 3880 } // 3881 } // 3882 // 3883 jQuery.extend({ // 3884 cache: {}, // 3885 // 3886 // The following elements (space-suffixed to avoid Object.prototype collisions) // 3887 // throw uncatchable exceptions if you attempt to set expando properties // 3888 noData: { // 3889 "applet ": true, // 3890 "embed ": true, // 3891 // ...but Flash objects (which have this classid) *can* handle expandos // 3892 "object ": "clsid:D27CDB6E-AE6D-11cf-96B8-444553540000" // 3893 }, // 3894 // 3895 hasData: function( elem ) { // 3896 elem = elem.nodeType ? jQuery.cache[ elem[jQuery.expando] ] : elem[ jQuery.expando ]; // 3897 return !!elem && !isEmptyDataObject( elem ); // 3898 }, // 3899 // 3900 data: function( elem, name, data ) { // 3901 return internalData( elem, name, data ); // 3902 }, // 3903 // 3904 removeData: function( elem, name ) { // 3905 return internalRemoveData( elem, name ); // 3906 }, // 3907 // 3908 // For internal use only. // 3909 _data: function( elem, name, data ) { // 3910 return internalData( elem, name, data, true ); // 3911 }, // 3912 // 3913 _removeData: function( elem, name ) { // 3914 return internalRemoveData( elem, name, true ); // 3915 } // 3916 }); // 3917 // 3918 jQuery.fn.extend({ // 3919 data: function( key, value ) { // 3920 var i, name, data, // 3921 elem = this[0], // 3922 attrs = elem && elem.attributes; // 3923 // 3924 // Special expections of .data basically thwart jQuery.access, // 3925 // so implement the relevant behavior ourselves // 3926 // 3927 // Gets all values // 3928 if ( key === undefined ) { // 3929 if ( this.length ) { // 3930 data = jQuery.data( elem ); // 3931 // 3932 if ( elem.nodeType === 1 && !jQuery._data( elem, "parsedAttrs" ) ) { // 3933 i = attrs.length; // 3934 while ( i-- ) { // 3935 // 3936 // Support: IE11+ // 3937 // The attrs elements can be null (#14894) // 3938 if ( attrs[ i ] ) { // 3939 name = attrs[ i ].name; // 3940 if ( name.indexOf( "data-" ) === 0 ) { // 3941 name = jQuery.camelCase( name.slice(5) ); // 3942 dataAttr( elem, name, data[ name ] ); // 3943 } // 3944 } // 3945 } // 3946 jQuery._data( elem, "parsedAttrs", true ); // 3947 } // 3948 } // 3949 // 3950 return data; // 3951 } // 3952 // 3953 // Sets multiple values // 3954 if ( typeof key === "object" ) { // 3955 return this.each(function() { // 3956 jQuery.data( this, key ); // 3957 }); // 3958 } // 3959 // 3960 return arguments.length > 1 ? // 3961 // 3962 // Sets one value // 3963 this.each(function() { // 3964 jQuery.data( this, key, value ); // 3965 }) : // 3966 // 3967 // Gets one value // 3968 // Try to fetch any internally stored data first // 3969 elem ? dataAttr( elem, key, jQuery.data( elem, key ) ) : undefined; // 3970 }, // 3971 // 3972 removeData: function( key ) { // 3973 return this.each(function() { // 3974 jQuery.removeData( this, key ); // 3975 }); // 3976 } // 3977 }); // 3978 // 3979 // 3980 jQuery.extend({ // 3981 queue: function( elem, type, data ) { // 3982 var queue; // 3983 // 3984 if ( elem ) { // 3985 type = ( type || "fx" ) + "queue"; // 3986 queue = jQuery._data( elem, type ); // 3987 // 3988 // Speed up dequeue by getting out quickly if this is just a lookup // 3989 if ( data ) { // 3990 if ( !queue || jQuery.isArray(data) ) { // 3991 queue = jQuery._data( elem, type, jQuery.makeArray(data) ); // 3992 } else { // 3993 queue.push( data ); // 3994 } // 3995 } // 3996 return queue || []; // 3997 } // 3998 }, // 3999 // 4000 dequeue: function( elem, type ) { // 4001 type = type || "fx"; // 4002 // 4003 var queue = jQuery.queue( elem, type ), // 4004 startLength = queue.length, // 4005 fn = queue.shift(), // 4006 hooks = jQuery._queueHooks( elem, type ), // 4007 next = function() { // 4008 jQuery.dequeue( elem, type ); // 4009 }; // 4010 // 4011 // If the fx queue is dequeued, always remove the progress sentinel // 4012 if ( fn === "inprogress" ) { // 4013 fn = queue.shift(); // 4014 startLength--; // 4015 } // 4016 // 4017 if ( fn ) { // 4018 // 4019 // Add a progress sentinel to prevent the fx queue from being // 4020 // automatically dequeued // 4021 if ( type === "fx" ) { // 4022 queue.unshift( "inprogress" ); // 4023 } // 4024 // 4025 // clear up the last queue stop function // 4026 delete hooks.stop; // 4027 fn.call( elem, next, hooks ); // 4028 } // 4029 // 4030 if ( !startLength && hooks ) { // 4031 hooks.empty.fire(); // 4032 } // 4033 }, // 4034 // 4035 // not intended for public consumption - generates a queueHooks object, or returns the current one // 4036 _queueHooks: function( elem, type ) { // 4037 var key = type + "queueHooks"; // 4038 return jQuery._data( elem, key ) || jQuery._data( elem, key, { // 4039 empty: jQuery.Callbacks("once memory").add(function() { // 4040 jQuery._removeData( elem, type + "queue" ); // 4041 jQuery._removeData( elem, key ); // 4042 }) // 4043 }); // 4044 } // 4045 }); // 4046 // 4047 jQuery.fn.extend({ // 4048 queue: function( type, data ) { // 4049 var setter = 2; // 4050 // 4051 if ( typeof type !== "string" ) { // 4052 data = type; // 4053 type = "fx"; // 4054 setter--; // 4055 } // 4056 // 4057 if ( arguments.length < setter ) { // 4058 return jQuery.queue( this[0], type ); // 4059 } // 4060 // 4061 return data === undefined ? // 4062 this : // 4063 this.each(function() { // 4064 var queue = jQuery.queue( this, type, data ); // 4065 // 4066 // ensure a hooks for this queue // 4067 jQuery._queueHooks( this, type ); // 4068 // 4069 if ( type === "fx" && queue[0] !== "inprogress" ) { // 4070 jQuery.dequeue( this, type ); // 4071 } // 4072 }); // 4073 }, // 4074 dequeue: function( type ) { // 4075 return this.each(function() { // 4076 jQuery.dequeue( this, type ); // 4077 }); // 4078 }, // 4079 clearQueue: function( type ) { // 4080 return this.queue( type || "fx", [] ); // 4081 }, // 4082 // Get a promise resolved when queues of a certain type // 4083 // are emptied (fx is the type by default) // 4084 promise: function( type, obj ) { // 4085 var tmp, // 4086 count = 1, // 4087 defer = jQuery.Deferred(), // 4088 elements = this, // 4089 i = this.length, // 4090 resolve = function() { // 4091 if ( !( --count ) ) { // 4092 defer.resolveWith( elements, [ elements ] ); // 4093 } // 4094 }; // 4095 // 4096 if ( typeof type !== "string" ) { // 4097 obj = type; // 4098 type = undefined; // 4099 } // 4100 type = type || "fx"; // 4101 // 4102 while ( i-- ) { // 4103 tmp = jQuery._data( elements[ i ], type + "queueHooks" ); // 4104 if ( tmp && tmp.empty ) { // 4105 count++; // 4106 tmp.empty.add( resolve ); // 4107 } // 4108 } // 4109 resolve(); // 4110 return defer.promise( obj ); // 4111 } // 4112 }); // 4113 var pnum = (/[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/).source; // 4114 // 4115 var cssExpand = [ "Top", "Right", "Bottom", "Left" ]; // 4116 // 4117 var isHidden = function( elem, el ) { // 4118 // isHidden might be called from jQuery#filter function; // 4119 // in that case, element will be second argument // 4120 elem = el || elem; // 4121 return jQuery.css( elem, "display" ) === "none" || !jQuery.contains( elem.ownerDocument, elem ); // 4122 }; // 4123 // 4124 // 4125 // 4126 // Multifunctional method to get and set values of a collection // 4127 // The value/s can optionally be executed if it's a function // 4128 var access = jQuery.access = function( elems, fn, key, value, chainable, emptyGet, raw ) { // 4129 var i = 0, // 4130 length = elems.length, // 4131 bulk = key == null; // 4132 // 4133 // Sets many values // 4134 if ( jQuery.type( key ) === "object" ) { // 4135 chainable = true; // 4136 for ( i in key ) { // 4137 jQuery.access( elems, fn, i, key[i], true, emptyGet, raw ); // 4138 } // 4139 // 4140 // Sets one value // 4141 } else if ( value !== undefined ) { // 4142 chainable = true; // 4143 // 4144 if ( !jQuery.isFunction( value ) ) { // 4145 raw = true; // 4146 } // 4147 // 4148 if ( bulk ) { // 4149 // Bulk operations run against the entire set // 4150 if ( raw ) { // 4151 fn.call( elems, value ); // 4152 fn = null; // 4153 // 4154 // ...except when executing function values // 4155 } else { // 4156 bulk = fn; // 4157 fn = function( elem, key, value ) { // 4158 return bulk.call( jQuery( elem ), value ); // 4159 }; // 4160 } // 4161 } // 4162 // 4163 if ( fn ) { // 4164 for ( ; i < length; i++ ) { // 4165 fn( elems[i], key, raw ? value : value.call( elems[i], i, fn( elems[i], key ) ) ); // 4166 } // 4167 } // 4168 } // 4169 // 4170 return chainable ? // 4171 elems : // 4172 // 4173 // Gets // 4174 bulk ? // 4175 fn.call( elems ) : // 4176 length ? fn( elems[0], key ) : emptyGet; // 4177 }; // 4178 var rcheckableType = (/^(?:checkbox|radio)$/i); // 4179 // 4180 // 4181 // 4182 (function() { // 4183 // Minified: var a,b,c // 4184 var input = document.createElement( "input" ), // 4185 div = document.createElement( "div" ), // 4186 fragment = document.createDocumentFragment(); // 4187 // 4188 // Setup // 4189 div.innerHTML = " <link/><table></table><a href='/a'>a</a><input type='checkbox'/>"; // 4190 // 4191 // IE strips leading whitespace when .innerHTML is used // 4192 support.leadingWhitespace = div.firstChild.nodeType === 3; // 4193 // 4194 // Make sure that tbody elements aren't automatically inserted // 4195 // IE will insert them into empty tables // 4196 support.tbody = !div.getElementsByTagName( "tbody" ).length; // 4197 // 4198 // Make sure that link elements get serialized correctly by innerHTML // 4199 // This requires a wrapper element in IE // 4200 support.htmlSerialize = !!div.getElementsByTagName( "link" ).length; // 4201 // 4202 // Makes sure cloning an html5 element does not cause problems // 4203 // Where outerHTML is undefined, this still works // 4204 support.html5Clone = // 4205 document.createElement( "nav" ).cloneNode( true ).outerHTML !== "<:nav></:nav>"; // 4206 // 4207 // Check if a disconnected checkbox will retain its checked // 4208 // value of true after appended to the DOM (IE6/7) // 4209 input.type = "checkbox"; // 4210 input.checked = true; // 4211 fragment.appendChild( input ); // 4212 support.appendChecked = input.checked; // 4213 // 4214 // Make sure textarea (and checkbox) defaultValue is properly cloned // 4215 // Support: IE6-IE11+ // 4216 div.innerHTML = "<textarea>x</textarea>"; // 4217 support.noCloneChecked = !!div.cloneNode( true ).lastChild.defaultValue; // 4218 // 4219 // #11217 - WebKit loses check when the name is after the checked attribute // 4220 fragment.appendChild( div ); // 4221 div.innerHTML = "<input type='radio' checked='checked' name='t'/>"; // 4222 // 4223 // Support: Safari 5.1, iOS 5.1, Android 4.x, Android 2.3 // 4224 // old WebKit doesn't clone checked state correctly in fragments // 4225 support.checkClone = div.cloneNode( true ).cloneNode( true ).lastChild.checked; // 4226 // 4227 // Support: IE<9 // 4228 // Opera does not clone events (and typeof div.attachEvent === undefined). // 4229 // IE9-10 clones events bound via attachEvent, but they don't trigger with .click() // 4230 support.noCloneEvent = true; // 4231 if ( div.attachEvent ) { // 4232 div.attachEvent( "onclick", function() { // 4233 support.noCloneEvent = false; // 4234 }); // 4235 // 4236 div.cloneNode( true ).click(); // 4237 } // 4238 // 4239 // Execute the test only if not already executed in another module. // 4240 if (support.deleteExpando == null) { // 4241 // Support: IE<9 // 4242 support.deleteExpando = true; // 4243 try { // 4244 delete div.test; // 4245 } catch( e ) { // 4246 support.deleteExpando = false; // 4247 } // 4248 } // 4249 })(); // 4250 // 4251 // 4252 (function() { // 4253 var i, eventName, // 4254 div = document.createElement( "div" ); // 4255 // 4256 // Support: IE<9 (lack submit/change bubble), Firefox 23+ (lack focusin event) // 4257 for ( i in { submit: true, change: true, focusin: true }) { // 4258 eventName = "on" + i; // 4259 // 4260 if ( !(support[ i + "Bubbles" ] = eventName in window) ) { // 4261 // Beware of CSP restrictions (https://developer.mozilla.org/en/Security/CSP) // 4262 div.setAttribute( eventName, "t" ); // 4263 support[ i + "Bubbles" ] = div.attributes[ eventName ].expando === false; // 4264 } // 4265 } // 4266 // 4267 // Null elements to avoid leaks in IE. // 4268 div = null; // 4269 })(); // 4270 // 4271 // 4272 var rformElems = /^(?:input|select|textarea)$/i, // 4273 rkeyEvent = /^key/, // 4274 rmouseEvent = /^(?:mouse|pointer|contextmenu)|click/, // 4275 rfocusMorph = /^(?:focusinfocus|focusoutblur)$/, // 4276 rtypenamespace = /^([^.]*)(?:\.(.+)|)$/; // 4277 // 4278 function returnTrue() { // 4279 return true; // 4280 } // 4281 // 4282 function returnFalse() { // 4283 return false; // 4284 } // 4285 // 4286 function safeActiveElement() { // 4287 try { // 4288 return document.activeElement; // 4289 } catch ( err ) { } // 4290 } // 4291 // 4292 /* // 4293 * Helper functions for managing events -- not part of the public interface. // 4294 * Props to Dean Edwards' addEvent library for many of the ideas. // 4295 */ // 4296 jQuery.event = { // 4297 // 4298 global: {}, // 4299 // 4300 add: function( elem, types, handler, data, selector ) { // 4301 var tmp, events, t, handleObjIn, // 4302 special, eventHandle, handleObj, // 4303 handlers, type, namespaces, origType, // 4304 elemData = jQuery._data( elem ); // 4305 // 4306 // Don't attach events to noData or text/comment nodes (but allow plain objects) // 4307 if ( !elemData ) { // 4308 return; // 4309 } // 4310 // 4311 // Caller can pass in an object of custom data in lieu of the handler // 4312 if ( handler.handler ) { // 4313 handleObjIn = handler; // 4314 handler = handleObjIn.handler; // 4315 selector = handleObjIn.selector; // 4316 } // 4317 // 4318 // Make sure that the handler has a unique ID, used to find/remove it later // 4319 if ( !handler.guid ) { // 4320 handler.guid = jQuery.guid++; // 4321 } // 4322 // 4323 // Init the element's event structure and main handler, if this is the first // 4324 if ( !(events = elemData.events) ) { // 4325 events = elemData.events = {}; // 4326 } // 4327 if ( !(eventHandle = elemData.handle) ) { // 4328 eventHandle = elemData.handle = function( e ) { // 4329 // Discard the second event of a jQuery.event.trigger() and // 4330 // when an event is called after a page has unloaded // 4331 return typeof jQuery !== strundefined && (!e || jQuery.event.triggered !== e.type) ? // 4332 jQuery.event.dispatch.apply( eventHandle.elem, arguments ) : // 4333 undefined; // 4334 }; // 4335 // Add elem as a property of the handle fn to prevent a memory leak with IE non-native events // 4336 eventHandle.elem = elem; // 4337 } // 4338 // 4339 // Handle multiple events separated by a space // 4340 types = ( types || "" ).match( rnotwhite ) || [ "" ]; // 4341 t = types.length; // 4342 while ( t-- ) { // 4343 tmp = rtypenamespace.exec( types[t] ) || []; // 4344 type = origType = tmp[1]; // 4345 namespaces = ( tmp[2] || "" ).split( "." ).sort(); // 4346 // 4347 // There *must* be a type, no attaching namespace-only handlers // 4348 if ( !type ) { // 4349 continue; // 4350 } // 4351 // 4352 // If event changes its type, use the special event handlers for the changed type // 4353 special = jQuery.event.special[ type ] || {}; // 4354 // 4355 // If selector defined, determine special event api type, otherwise given type // 4356 type = ( selector ? special.delegateType : special.bindType ) || type; // 4357 // 4358 // Update special based on newly reset type // 4359 special = jQuery.event.special[ type ] || {}; // 4360 // 4361 // handleObj is passed to all event handlers // 4362 handleObj = jQuery.extend({ // 4363 type: type, // 4364 origType: origType, // 4365 data: data, // 4366 handler: handler, // 4367 guid: handler.guid, // 4368 selector: selector, // 4369 needsContext: selector && jQuery.expr.match.needsContext.test( selector ), // 4370 namespace: namespaces.join(".") // 4371 }, handleObjIn ); // 4372 // 4373 // Init the event handler queue if we're the first // 4374 if ( !(handlers = events[ type ]) ) { // 4375 handlers = events[ type ] = []; // 4376 handlers.delegateCount = 0; // 4377 // 4378 // Only use addEventListener/attachEvent if the special events handler returns false // 4379 if ( !special.setup || special.setup.call( elem, data, namespaces, eventHandle ) === false ) { // 4380 // Bind the global event handler to the element // 4381 if ( elem.addEventListener ) { // 4382 elem.addEventListener( type, eventHandle, false ); // 4383 // 4384 } else if ( elem.attachEvent ) { // 4385 elem.attachEvent( "on" + type, eventHandle ); // 4386 } // 4387 } // 4388 } // 4389 // 4390 if ( special.add ) { // 4391 special.add.call( elem, handleObj ); // 4392 // 4393 if ( !handleObj.handler.guid ) { // 4394 handleObj.handler.guid = handler.guid; // 4395 } // 4396 } // 4397 // 4398 // Add to the element's handler list, delegates in front // 4399 if ( selector ) { // 4400 handlers.splice( handlers.delegateCount++, 0, handleObj ); // 4401 } else { // 4402 handlers.push( handleObj ); // 4403 } // 4404 // 4405 // Keep track of which events have ever been used, for event optimization // 4406 jQuery.event.global[ type ] = true; // 4407 } // 4408 // 4409 // Nullify elem to prevent memory leaks in IE // 4410 elem = null; // 4411 }, // 4412 // 4413 // Detach an event or set of events from an element // 4414 remove: function( elem, types, handler, selector, mappedTypes ) { // 4415 var j, handleObj, tmp, // 4416 origCount, t, events, // 4417 special, handlers, type, // 4418 namespaces, origType, // 4419 elemData = jQuery.hasData( elem ) && jQuery._data( elem ); // 4420 // 4421 if ( !elemData || !(events = elemData.events) ) { // 4422 return; // 4423 } // 4424 // 4425 // Once for each type.namespace in types; type may be omitted // 4426 types = ( types || "" ).match( rnotwhite ) || [ "" ]; // 4427 t = types.length; // 4428 while ( t-- ) { // 4429 tmp = rtypenamespace.exec( types[t] ) || []; // 4430 type = origType = tmp[1]; // 4431 namespaces = ( tmp[2] || "" ).split( "." ).sort(); // 4432 // 4433 // Unbind all events (on this namespace, if provided) for the element // 4434 if ( !type ) { // 4435 for ( type in events ) { // 4436 jQuery.event.remove( elem, type + types[ t ], handler, selector, true ); // 4437 } // 4438 continue; // 4439 } // 4440 // 4441 special = jQuery.event.special[ type ] || {}; // 4442 type = ( selector ? special.delegateType : special.bindType ) || type; // 4443 handlers = events[ type ] || []; // 4444 tmp = tmp[2] && new RegExp( "(^|\\.)" + namespaces.join("\\.(?:.*\\.|)") + "(\\.|$)" ); // 4445 // 4446 // Remove matching events // 4447 origCount = j = handlers.length; // 4448 while ( j-- ) { // 4449 handleObj = handlers[ j ]; // 4450 // 4451 if ( ( mappedTypes || origType === handleObj.origType ) && // 4452 ( !handler || handler.guid === handleObj.guid ) && // 4453 ( !tmp || tmp.test( handleObj.namespace ) ) && // 4454 ( !selector || selector === handleObj.selector || selector === "**" && handleObj.selector ) ) { // 4455 handlers.splice( j, 1 ); // 4456 // 4457 if ( handleObj.selector ) { // 4458 handlers.delegateCount--; // 4459 } // 4460 if ( special.remove ) { // 4461 special.remove.call( elem, handleObj ); // 4462 } // 4463 } // 4464 } // 4465 // 4466 // Remove generic event handler if we removed something and no more handlers exist // 4467 // (avoids potential for endless recursion during removal of special event handlers) // 4468 if ( origCount && !handlers.length ) { // 4469 if ( !special.teardown || special.teardown.call( elem, namespaces, elemData.handle ) === false ) { // 4470 jQuery.removeEvent( elem, type, elemData.handle ); // 4471 } // 4472 // 4473 delete events[ type ]; // 4474 } // 4475 } // 4476 // 4477 // Remove the expando if it's no longer used // 4478 if ( jQuery.isEmptyObject( events ) ) { // 4479 delete elemData.handle; // 4480 // 4481 // removeData also checks for emptiness and clears the expando if empty // 4482 // so use it instead of delete // 4483 jQuery._removeData( elem, "events" ); // 4484 } // 4485 }, // 4486 // 4487 trigger: function( event, data, elem, onlyHandlers ) { // 4488 var handle, ontype, cur, // 4489 bubbleType, special, tmp, i, // 4490 eventPath = [ elem || document ], // 4491 type = hasOwn.call( event, "type" ) ? event.type : event, // 4492 namespaces = hasOwn.call( event, "namespace" ) ? event.namespace.split(".") : []; // 4493 // 4494 cur = tmp = elem = elem || document; // 4495 // 4496 // Don't do events on text and comment nodes // 4497 if ( elem.nodeType === 3 || elem.nodeType === 8 ) { // 4498 return; // 4499 } // 4500 // 4501 // focus/blur morphs to focusin/out; ensure we're not firing them right now // 4502 if ( rfocusMorph.test( type + jQuery.event.triggered ) ) { // 4503 return; // 4504 } // 4505 // 4506 if ( type.indexOf(".") >= 0 ) { // 4507 // Namespaced trigger; create a regexp to match event type in handle() // 4508 namespaces = type.split("."); // 4509 type = namespaces.shift(); // 4510 namespaces.sort(); // 4511 } // 4512 ontype = type.indexOf(":") < 0 && "on" + type; // 4513 // 4514 // Caller can pass in a jQuery.Event object, Object, or just an event type string // 4515 event = event[ jQuery.expando ] ? // 4516 event : // 4517 new jQuery.Event( type, typeof event === "object" && event ); // 4518 // 4519 // Trigger bitmask: & 1 for native handlers; & 2 for jQuery (always true) // 4520 event.isTrigger = onlyHandlers ? 2 : 3; // 4521 event.namespace = namespaces.join("."); // 4522 event.namespace_re = event.namespace ? // 4523 new RegExp( "(^|\\.)" + namespaces.join("\\.(?:.*\\.|)") + "(\\.|$)" ) : // 4524 null; // 4525 // 4526 // Clean up the event in case it is being reused // 4527 event.result = undefined; // 4528 if ( !event.target ) { // 4529 event.target = elem; // 4530 } // 4531 // 4532 // Clone any incoming data and prepend the event, creating the handler arg list // 4533 data = data == null ? // 4534 [ event ] : // 4535 jQuery.makeArray( data, [ event ] ); // 4536 // 4537 // Allow special events to draw outside the lines // 4538 special = jQuery.event.special[ type ] || {}; // 4539 if ( !onlyHandlers && special.trigger && special.trigger.apply( elem, data ) === false ) { // 4540 return; // 4541 } // 4542 // 4543 // Determine event propagation path in advance, per W3C events spec (#9951) // 4544 // Bubble up to document, then to window; watch for a global ownerDocument var (#9724) // 4545 if ( !onlyHandlers && !special.noBubble && !jQuery.isWindow( elem ) ) { // 4546 // 4547 bubbleType = special.delegateType || type; // 4548 if ( !rfocusMorph.test( bubbleType + type ) ) { // 4549 cur = cur.parentNode; // 4550 } // 4551 for ( ; cur; cur = cur.parentNode ) { // 4552 eventPath.push( cur ); // 4553 tmp = cur; // 4554 } // 4555 // 4556 // Only add window if we got to document (e.g., not plain obj or detached DOM) // 4557 if ( tmp === (elem.ownerDocument || document) ) { // 4558 eventPath.push( tmp.defaultView || tmp.parentWindow || window ); // 4559 } // 4560 } // 4561 // 4562 // Fire handlers on the event path // 4563 i = 0; // 4564 while ( (cur = eventPath[i++]) && !event.isPropagationStopped() ) { // 4565 // 4566 event.type = i > 1 ? // 4567 bubbleType : // 4568 special.bindType || type; // 4569 // 4570 // jQuery handler // 4571 handle = ( jQuery._data( cur, "events" ) || {} )[ event.type ] && jQuery._data( cur, "handle" ); // 4572 if ( handle ) { // 4573 handle.apply( cur, data ); // 4574 } // 4575 // 4576 // Native handler // 4577 handle = ontype && cur[ ontype ]; // 4578 if ( handle && handle.apply && jQuery.acceptData( cur ) ) { // 4579 event.result = handle.apply( cur, data ); // 4580 if ( event.result === false ) { // 4581 event.preventDefault(); // 4582 } // 4583 } // 4584 } // 4585 event.type = type; // 4586 // 4587 // If nobody prevented the default action, do it now // 4588 if ( !onlyHandlers && !event.isDefaultPrevented() ) { // 4589 // 4590 if ( (!special._default || special._default.apply( eventPath.pop(), data ) === false) && // 4591 jQuery.acceptData( elem ) ) { // 4592 // 4593 // Call a native DOM method on the target with the same name name as the event. // 4594 // Can't use an .isFunction() check here because IE6/7 fails that test. // 4595 // Don't do default actions on window, that's where global variables be (#6170) // 4596 if ( ontype && elem[ type ] && !jQuery.isWindow( elem ) ) { // 4597 // 4598 // Don't re-trigger an onFOO event when we call its FOO() method // 4599 tmp = elem[ ontype ]; // 4600 // 4601 if ( tmp ) { // 4602 elem[ ontype ] = null; // 4603 } // 4604 // 4605 // Prevent re-triggering of the same event, since we already bubbled it above // 4606 jQuery.event.triggered = type; // 4607 try { // 4608 elem[ type ](); // 4609 } catch ( e ) { // 4610 // IE<9 dies on focus/blur to hidden element (#1486,#12518) // 4611 // only reproducible on winXP IE8 native, not IE9 in IE8 mode // 4612 } // 4613 jQuery.event.triggered = undefined; // 4614 // 4615 if ( tmp ) { // 4616 elem[ ontype ] = tmp; // 4617 } // 4618 } // 4619 } // 4620 } // 4621 // 4622 return event.result; // 4623 }, // 4624 // 4625 dispatch: function( event ) { // 4626 // 4627 // Make a writable jQuery.Event from the native event object // 4628 event = jQuery.event.fix( event ); // 4629 // 4630 var i, ret, handleObj, matched, j, // 4631 handlerQueue = [], // 4632 args = slice.call( arguments ), // 4633 handlers = ( jQuery._data( this, "events" ) || {} )[ event.type ] || [], // 4634 special = jQuery.event.special[ event.type ] || {}; // 4635 // 4636 // Use the fix-ed jQuery.Event rather than the (read-only) native event // 4637 args[0] = event; // 4638 event.delegateTarget = this; // 4639 // 4640 // Call the preDispatch hook for the mapped type, and let it bail if desired // 4641 if ( special.preDispatch && special.preDispatch.call( this, event ) === false ) { // 4642 return; // 4643 } // 4644 // 4645 // Determine handlers // 4646 handlerQueue = jQuery.event.handlers.call( this, event, handlers ); // 4647 // 4648 // Run delegates first; they may want to stop propagation beneath us // 4649 i = 0; // 4650 while ( (matched = handlerQueue[ i++ ]) && !event.isPropagationStopped() ) { // 4651 event.currentTarget = matched.elem; // 4652 // 4653 j = 0; // 4654 while ( (handleObj = matched.handlers[ j++ ]) && !event.isImmediatePropagationStopped() ) { // 4655 // 4656 // Triggered event must either 1) have no namespace, or // 4657 // 2) have namespace(s) a subset or equal to those in the bound event (both can have no namespace). // 4658 if ( !event.namespace_re || event.namespace_re.test( handleObj.namespace ) ) { // 4659 // 4660 event.handleObj = handleObj; // 4661 event.data = handleObj.data; // 4662 // 4663 ret = ( (jQuery.event.special[ handleObj.origType ] || {}).handle || handleObj.handler ) // 4664 .apply( matched.elem, args ); // 4665 // 4666 if ( ret !== undefined ) { // 4667 if ( (event.result = ret) === false ) { // 4668 event.preventDefault(); // 4669 event.stopPropagation(); // 4670 } // 4671 } // 4672 } // 4673 } // 4674 } // 4675 // 4676 // Call the postDispatch hook for the mapped type // 4677 if ( special.postDispatch ) { // 4678 special.postDispatch.call( this, event ); // 4679 } // 4680 // 4681 return event.result; // 4682 }, // 4683 // 4684 handlers: function( event, handlers ) { // 4685 var sel, handleObj, matches, i, // 4686 handlerQueue = [], // 4687 delegateCount = handlers.delegateCount, // 4688 cur = event.target; // 4689 // 4690 // Find delegate handlers // 4691 // Black-hole SVG <use> instance trees (#13180) // 4692 // Avoid non-left-click bubbling in Firefox (#3861) // 4693 if ( delegateCount && cur.nodeType && (!event.button || event.type !== "click") ) { // 4694 // 4695 /* jshint eqeqeq: false */ // 4696 for ( ; cur != this; cur = cur.parentNode || this ) { // 4697 /* jshint eqeqeq: true */ // 4698 // 4699 // Don't check non-elements (#13208) // 4700 // Don't process clicks on disabled elements (#6911, #8165, #11382, #11764) // 4701 if ( cur.nodeType === 1 && (cur.disabled !== true || event.type !== "click") ) { // 4702 matches = []; // 4703 for ( i = 0; i < delegateCount; i++ ) { // 4704 handleObj = handlers[ i ]; // 4705 // 4706 // Don't conflict with Object.prototype properties (#13203) // 4707 sel = handleObj.selector + " "; // 4708 // 4709 if ( matches[ sel ] === undefined ) { // 4710 matches[ sel ] = handleObj.needsContext ? // 4711 jQuery( sel, this ).index( cur ) >= 0 : // 4712 jQuery.find( sel, this, null, [ cur ] ).length; // 4713 } // 4714 if ( matches[ sel ] ) { // 4715 matches.push( handleObj ); // 4716 } // 4717 } // 4718 if ( matches.length ) { // 4719 handlerQueue.push({ elem: cur, handlers: matches }); // 4720 } // 4721 } // 4722 } // 4723 } // 4724 // 4725 // Add the remaining (directly-bound) handlers // 4726 if ( delegateCount < handlers.length ) { // 4727 handlerQueue.push({ elem: this, handlers: handlers.slice( delegateCount ) }); // 4728 } // 4729 // 4730 return handlerQueue; // 4731 }, // 4732 // 4733 fix: function( event ) { // 4734 if ( event[ jQuery.expando ] ) { // 4735 return event; // 4736 } // 4737 // 4738 // Create a writable copy of the event object and normalize some properties // 4739 var i, prop, copy, // 4740 type = event.type, // 4741 originalEvent = event, // 4742 fixHook = this.fixHooks[ type ]; // 4743 // 4744 if ( !fixHook ) { // 4745 this.fixHooks[ type ] = fixHook = // 4746 rmouseEvent.test( type ) ? this.mouseHooks : // 4747 rkeyEvent.test( type ) ? this.keyHooks : // 4748 {}; // 4749 } // 4750 copy = fixHook.props ? this.props.concat( fixHook.props ) : this.props; // 4751 // 4752 event = new jQuery.Event( originalEvent ); // 4753 // 4754 i = copy.length; // 4755 while ( i-- ) { // 4756 prop = copy[ i ]; // 4757 event[ prop ] = originalEvent[ prop ]; // 4758 } // 4759 // 4760 // Support: IE<9 // 4761 // Fix target property (#1925) // 4762 if ( !event.target ) { // 4763 event.target = originalEvent.srcElement || document; // 4764 } // 4765 // 4766 // Support: Chrome 23+, Safari? // 4767 // Target should not be a text node (#504, #13143) // 4768 if ( event.target.nodeType === 3 ) { // 4769 event.target = event.target.parentNode; // 4770 } // 4771 // 4772 // Support: IE<9 // 4773 // For mouse/key events, metaKey==false if it's undefined (#3368, #11328) // 4774 event.metaKey = !!event.metaKey; // 4775 // 4776 return fixHook.filter ? fixHook.filter( event, originalEvent ) : event; // 4777 }, // 4778 // 4779 // Includes some event props shared by KeyEvent and MouseEvent // 4780 props: "altKey bubbles cancelable ctrlKey currentTarget eventPhase metaKey relatedTarget shiftKey target timeStamp view which".split(" "), // 4782 fixHooks: {}, // 4783 // 4784 keyHooks: { // 4785 props: "char charCode key keyCode".split(" "), // 4786 filter: function( event, original ) { // 4787 // 4788 // Add which for key events // 4789 if ( event.which == null ) { // 4790 event.which = original.charCode != null ? original.charCode : original.keyCode; // 4791 } // 4792 // 4793 return event; // 4794 } // 4795 }, // 4796 // 4797 mouseHooks: { // 4798 props: "button buttons clientX clientY fromElement offsetX offsetY pageX pageY screenX screenY toElement".split(" "), filter: function( event, original ) { // 4800 var body, eventDoc, doc, // 4801 button = original.button, // 4802 fromElement = original.fromElement; // 4803 // 4804 // Calculate pageX/Y if missing and clientX/Y available // 4805 if ( event.pageX == null && original.clientX != null ) { // 4806 eventDoc = event.target.ownerDocument || document; // 4807 doc = eventDoc.documentElement; // 4808 body = eventDoc.body; // 4809 // 4810 event.pageX = original.clientX + ( doc && doc.scrollLeft || body && body.scrollLeft || 0 ) - ( doc && doc.clientLeft || body && body.clientLeft || 0 ); event.pageY = original.clientY + ( doc && doc.scrollTop || body && body.scrollTop || 0 ) - ( doc && doc.clientTop || body && body.clientTop || 0 ); } // 4813 // 4814 // Add relatedTarget, if necessary // 4815 if ( !event.relatedTarget && fromElement ) { // 4816 event.relatedTarget = fromElement === event.target ? original.toElement : fromElement; // 4817 } // 4818 // 4819 // Add which for click: 1 === left; 2 === middle; 3 === right // 4820 // Note: button is not normalized, so don't use it // 4821 if ( !event.which && button !== undefined ) { // 4822 event.which = ( button & 1 ? 1 : ( button & 2 ? 3 : ( button & 4 ? 2 : 0 ) ) ); // 4823 } // 4824 // 4825 return event; // 4826 } // 4827 }, // 4828 // 4829 special: { // 4830 load: { // 4831 // Prevent triggered image.load events from bubbling to window.load // 4832 noBubble: true // 4833 }, // 4834 focus: { // 4835 // Fire native event if possible so blur/focus sequence is correct // 4836 trigger: function() { // 4837 if ( this !== safeActiveElement() && this.focus ) { // 4838 try { // 4839 this.focus(); // 4840 return false; // 4841 } catch ( e ) { // 4842 // Support: IE<9 // 4843 // If we error on focus to hidden element (#1486, #12518), // 4844 // let .trigger() run the handlers // 4845 } // 4846 } // 4847 }, // 4848 delegateType: "focusin" // 4849 }, // 4850 blur: { // 4851 trigger: function() { // 4852 if ( this === safeActiveElement() && this.blur ) { // 4853 this.blur(); // 4854 return false; // 4855 } // 4856 }, // 4857 delegateType: "focusout" // 4858 }, // 4859 click: { // 4860 // For checkbox, fire native event so checked state will be right // 4861 trigger: function() { // 4862 if ( jQuery.nodeName( this, "input" ) && this.type === "checkbox" && this.click ) { // 4863 this.click(); // 4864 return false; // 4865 } // 4866 }, // 4867 // 4868 // For cross-browser consistency, don't fire native .click() on links // 4869 _default: function( event ) { // 4870 return jQuery.nodeName( event.target, "a" ); // 4871 } // 4872 }, // 4873 // 4874 beforeunload: { // 4875 postDispatch: function( event ) { // 4876 // 4877 // Support: Firefox 20+ // 4878 // Firefox doesn't alert if the returnValue field is not set. // 4879 if ( event.result !== undefined && event.originalEvent ) { // 4880 event.originalEvent.returnValue = event.result; // 4881 } // 4882 } // 4883 } // 4884 }, // 4885 // 4886 simulate: function( type, elem, event, bubble ) { // 4887 // Piggyback on a donor event to simulate a different one. // 4888 // Fake originalEvent to avoid donor's stopPropagation, but if the // 4889 // simulated event prevents default then we do the same on the donor. // 4890 var e = jQuery.extend( // 4891 new jQuery.Event(), // 4892 event, // 4893 { // 4894 type: type, // 4895 isSimulated: true, // 4896 originalEvent: {} // 4897 } // 4898 ); // 4899 if ( bubble ) { // 4900 jQuery.event.trigger( e, null, elem ); // 4901 } else { // 4902 jQuery.event.dispatch.call( elem, e ); // 4903 } // 4904 if ( e.isDefaultPrevented() ) { // 4905 event.preventDefault(); // 4906 } // 4907 } // 4908 }; // 4909 // 4910 jQuery.removeEvent = document.removeEventListener ? // 4911 function( elem, type, handle ) { // 4912 if ( elem.removeEventListener ) { // 4913 elem.removeEventListener( type, handle, false ); // 4914 } // 4915 } : // 4916 function( elem, type, handle ) { // 4917 var name = "on" + type; // 4918 // 4919 if ( elem.detachEvent ) { // 4920 // 4921 // #8545, #7054, preventing memory leaks for custom events in IE6-8 // 4922 // detachEvent needed property on element, by name of that event, to properly expose it to GC // 4923 if ( typeof elem[ name ] === strundefined ) { // 4924 elem[ name ] = null; // 4925 } // 4926 // 4927 elem.detachEvent( name, handle ); // 4928 } // 4929 }; // 4930 // 4931 jQuery.Event = function( src, props ) { // 4932 // Allow instantiation without the 'new' keyword // 4933 if ( !(this instanceof jQuery.Event) ) { // 4934 return new jQuery.Event( src, props ); // 4935 } // 4936 // 4937 // Event object // 4938 if ( src && src.type ) { // 4939 this.originalEvent = src; // 4940 this.type = src.type; // 4941 // 4942 // Events bubbling up the document may have been marked as prevented // 4943 // by a handler lower down the tree; reflect the correct value. // 4944 this.isDefaultPrevented = src.defaultPrevented || // 4945 src.defaultPrevented === undefined && // 4946 // Support: IE < 9, Android < 4.0 // 4947 src.returnValue === false ? // 4948 returnTrue : // 4949 returnFalse; // 4950 // 4951 // Event type // 4952 } else { // 4953 this.type = src; // 4954 } // 4955 // 4956 // Put explicitly provided properties onto the event object // 4957 if ( props ) { // 4958 jQuery.extend( this, props ); // 4959 } // 4960 // 4961 // Create a timestamp if incoming event doesn't have one // 4962 this.timeStamp = src && src.timeStamp || jQuery.now(); // 4963 // 4964 // Mark it as fixed // 4965 this[ jQuery.expando ] = true; // 4966 }; // 4967 // 4968 // jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding // 4969 // http://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html // 4970 jQuery.Event.prototype = { // 4971 isDefaultPrevented: returnFalse, // 4972 isPropagationStopped: returnFalse, // 4973 isImmediatePropagationStopped: returnFalse, // 4974 // 4975 preventDefault: function() { // 4976 var e = this.originalEvent; // 4977 // 4978 this.isDefaultPrevented = returnTrue; // 4979 if ( !e ) { // 4980 return; // 4981 } // 4982 // 4983 // If preventDefault exists, run it on the original event // 4984 if ( e.preventDefault ) { // 4985 e.preventDefault(); // 4986 // 4987 // Support: IE // 4988 // Otherwise set the returnValue property of the original event to false // 4989 } else { // 4990 e.returnValue = false; // 4991 } // 4992 }, // 4993 stopPropagation: function() { // 4994 var e = this.originalEvent; // 4995 // 4996 this.isPropagationStopped = returnTrue; // 4997 if ( !e ) { // 4998 return; // 4999 } // 5000 // If stopPropagation exists, run it on the original event // 5001 if ( e.stopPropagation ) { // 5002 e.stopPropagation(); // 5003 } // 5004 // 5005 // Support: IE // 5006 // Set the cancelBubble property of the original event to true // 5007 e.cancelBubble = true; // 5008 }, // 5009 stopImmediatePropagation: function() { // 5010 var e = this.originalEvent; // 5011 // 5012 this.isImmediatePropagationStopped = returnTrue; // 5013 // 5014 if ( e && e.stopImmediatePropagation ) { // 5015 e.stopImmediatePropagation(); // 5016 } // 5017 // 5018 this.stopPropagation(); // 5019 } // 5020 }; // 5021 // 5022 // Create mouseenter/leave events using mouseover/out and event-time checks // 5023 jQuery.each({ // 5024 mouseenter: "mouseover", // 5025 mouseleave: "mouseout", // 5026 pointerenter: "pointerover", // 5027 pointerleave: "pointerout" // 5028 }, function( orig, fix ) { // 5029 jQuery.event.special[ orig ] = { // 5030 delegateType: fix, // 5031 bindType: fix, // 5032 // 5033 handle: function( event ) { // 5034 var ret, // 5035 target = this, // 5036 related = event.relatedTarget, // 5037 handleObj = event.handleObj; // 5038 // 5039 // For mousenter/leave call the handler if related is outside the target. // 5040 // NB: No relatedTarget if the mouse left/entered the browser window // 5041 if ( !related || (related !== target && !jQuery.contains( target, related )) ) { // 5042 event.type = handleObj.origType; // 5043 ret = handleObj.handler.apply( this, arguments ); // 5044 event.type = fix; // 5045 } // 5046 return ret; // 5047 } // 5048 }; // 5049 }); // 5050 // 5051 // IE submit delegation // 5052 if ( !support.submitBubbles ) { // 5053 // 5054 jQuery.event.special.submit = { // 5055 setup: function() { // 5056 // Only need this for delegated form submit events // 5057 if ( jQuery.nodeName( this, "form" ) ) { // 5058 return false; // 5059 } // 5060 // 5061 // Lazy-add a submit handler when a descendant form may potentially be submitted // 5062 jQuery.event.add( this, "click._submit keypress._submit", function( e ) { // 5063 // Node name check avoids a VML-related crash in IE (#9807) // 5064 var elem = e.target, // 5065 form = jQuery.nodeName( elem, "input" ) || jQuery.nodeName( elem, "button" ) ? elem.form : undefined; // 5066 if ( form && !jQuery._data( form, "submitBubbles" ) ) { // 5067 jQuery.event.add( form, "submit._submit", function( event ) { // 5068 event._submit_bubble = true; // 5069 }); // 5070 jQuery._data( form, "submitBubbles", true ); // 5071 } // 5072 }); // 5073 // return undefined since we don't need an event listener // 5074 }, // 5075 // 5076 postDispatch: function( event ) { // 5077 // If form was submitted by the user, bubble the event up the tree // 5078 if ( event._submit_bubble ) { // 5079 delete event._submit_bubble; // 5080 if ( this.parentNode && !event.isTrigger ) { // 5081 jQuery.event.simulate( "submit", this.parentNode, event, true ); // 5082 } // 5083 } // 5084 }, // 5085 // 5086 teardown: function() { // 5087 // Only need this for delegated form submit events // 5088 if ( jQuery.nodeName( this, "form" ) ) { // 5089 return false; // 5090 } // 5091 // 5092 // Remove delegated handlers; cleanData eventually reaps submit handlers attached above // 5093 jQuery.event.remove( this, "._submit" ); // 5094 } // 5095 }; // 5096 } // 5097 // 5098 // IE change delegation and checkbox/radio fix // 5099 if ( !support.changeBubbles ) { // 5100 // 5101 jQuery.event.special.change = { // 5102 // 5103 setup: function() { // 5104 // 5105 if ( rformElems.test( this.nodeName ) ) { // 5106 // IE doesn't fire change on a check/radio until blur; trigger it on click // 5107 // after a propertychange. Eat the blur-change in special.change.handle. // 5108 // This still fires onchange a second time for check/radio after blur. // 5109 if ( this.type === "checkbox" || this.type === "radio" ) { // 5110 jQuery.event.add( this, "propertychange._change", function( event ) { // 5111 if ( event.originalEvent.propertyName === "checked" ) { // 5112 this._just_changed = true; // 5113 } // 5114 }); // 5115 jQuery.event.add( this, "click._change", function( event ) { // 5116 if ( this._just_changed && !event.isTrigger ) { // 5117 this._just_changed = false; // 5118 } // 5119 // Allow triggered, simulated change events (#11500) // 5120 jQuery.event.simulate( "change", this, event, true ); // 5121 }); // 5122 } // 5123 return false; // 5124 } // 5125 // Delegated event; lazy-add a change handler on descendant inputs // 5126 jQuery.event.add( this, "beforeactivate._change", function( e ) { // 5127 var elem = e.target; // 5128 // 5129 if ( rformElems.test( elem.nodeName ) && !jQuery._data( elem, "changeBubbles" ) ) { // 5130 jQuery.event.add( elem, "change._change", function( event ) { // 5131 if ( this.parentNode && !event.isSimulated && !event.isTrigger ) { // 5132 jQuery.event.simulate( "change", this.parentNode, event, true ); // 5133 } // 5134 }); // 5135 jQuery._data( elem, "changeBubbles", true ); // 5136 } // 5137 }); // 5138 }, // 5139 // 5140 handle: function( event ) { // 5141 var elem = event.target; // 5142 // 5143 // Swallow native change events from checkbox/radio, we already triggered them above // 5144 if ( this !== elem || event.isSimulated || event.isTrigger || (elem.type !== "radio" && elem.type !== "checkbox") ) { return event.handleObj.handler.apply( this, arguments ); // 5146 } // 5147 }, // 5148 // 5149 teardown: function() { // 5150 jQuery.event.remove( this, "._change" ); // 5151 // 5152 return !rformElems.test( this.nodeName ); // 5153 } // 5154 }; // 5155 } // 5156 // 5157 // Create "bubbling" focus and blur events // 5158 if ( !support.focusinBubbles ) { // 5159 jQuery.each({ focus: "focusin", blur: "focusout" }, function( orig, fix ) { // 5160 // 5161 // Attach a single capturing handler on the document while someone wants focusin/focusout // 5162 var handler = function( event ) { // 5163 jQuery.event.simulate( fix, event.target, jQuery.event.fix( event ), true ); // 5164 }; // 5165 // 5166 jQuery.event.special[ fix ] = { // 5167 setup: function() { // 5168 var doc = this.ownerDocument || this, // 5169 attaches = jQuery._data( doc, fix ); // 5170 // 5171 if ( !attaches ) { // 5172 doc.addEventListener( orig, handler, true ); // 5173 } // 5174 jQuery._data( doc, fix, ( attaches || 0 ) + 1 ); // 5175 }, // 5176 teardown: function() { // 5177 var doc = this.ownerDocument || this, // 5178 attaches = jQuery._data( doc, fix ) - 1; // 5179 // 5180 if ( !attaches ) { // 5181 doc.removeEventListener( orig, handler, true ); // 5182 jQuery._removeData( doc, fix ); // 5183 } else { // 5184 jQuery._data( doc, fix, attaches ); // 5185 } // 5186 } // 5187 }; // 5188 }); // 5189 } // 5190 // 5191 jQuery.fn.extend({ // 5192 // 5193 on: function( types, selector, data, fn, /*INTERNAL*/ one ) { // 5194 var type, origFn; // 5195 // 5196 // Types can be a map of types/handlers // 5197 if ( typeof types === "object" ) { // 5198 // ( types-Object, selector, data ) // 5199 if ( typeof selector !== "string" ) { // 5200 // ( types-Object, data ) // 5201 data = data || selector; // 5202 selector = undefined; // 5203 } // 5204 for ( type in types ) { // 5205 this.on( type, selector, data, types[ type ], one ); // 5206 } // 5207 return this; // 5208 } // 5209 // 5210 if ( data == null && fn == null ) { // 5211 // ( types, fn ) // 5212 fn = selector; // 5213 data = selector = undefined; // 5214 } else if ( fn == null ) { // 5215 if ( typeof selector === "string" ) { // 5216 // ( types, selector, fn ) // 5217 fn = data; // 5218 data = undefined; // 5219 } else { // 5220 // ( types, data, fn ) // 5221 fn = data; // 5222 data = selector; // 5223 selector = undefined; // 5224 } // 5225 } // 5226 if ( fn === false ) { // 5227 fn = returnFalse; // 5228 } else if ( !fn ) { // 5229 return this; // 5230 } // 5231 // 5232 if ( one === 1 ) { // 5233 origFn = fn; // 5234 fn = function( event ) { // 5235 // Can use an empty set, since event contains the info // 5236 jQuery().off( event ); // 5237 return origFn.apply( this, arguments ); // 5238 }; // 5239 // Use same guid so caller can remove using origFn // 5240 fn.guid = origFn.guid || ( origFn.guid = jQuery.guid++ ); // 5241 } // 5242 return this.each( function() { // 5243 jQuery.event.add( this, types, fn, data, selector ); // 5244 }); // 5245 }, // 5246 one: function( types, selector, data, fn ) { // 5247 return this.on( types, selector, data, fn, 1 ); // 5248 }, // 5249 off: function( types, selector, fn ) { // 5250 var handleObj, type; // 5251 if ( types && types.preventDefault && types.handleObj ) { // 5252 // ( event ) dispatched jQuery.Event // 5253 handleObj = types.handleObj; // 5254 jQuery( types.delegateTarget ).off( // 5255 handleObj.namespace ? handleObj.origType + "." + handleObj.namespace : handleObj.origType, // 5256 handleObj.selector, // 5257 handleObj.handler // 5258 ); // 5259 return this; // 5260 } // 5261 if ( typeof types === "object" ) { // 5262 // ( types-object [, selector] ) // 5263 for ( type in types ) { // 5264 this.off( type, selector, types[ type ] ); // 5265 } // 5266 return this; // 5267 } // 5268 if ( selector === false || typeof selector === "function" ) { // 5269 // ( types [, fn] ) // 5270 fn = selector; // 5271 selector = undefined; // 5272 } // 5273 if ( fn === false ) { // 5274 fn = returnFalse; // 5275 } // 5276 return this.each(function() { // 5277 jQuery.event.remove( this, types, fn, selector ); // 5278 }); // 5279 }, // 5280 // 5281 trigger: function( type, data ) { // 5282 return this.each(function() { // 5283 jQuery.event.trigger( type, data, this ); // 5284 }); // 5285 }, // 5286 triggerHandler: function( type, data ) { // 5287 var elem = this[0]; // 5288 if ( elem ) { // 5289 return jQuery.event.trigger( type, data, elem, true ); // 5290 } // 5291 } // 5292 }); // 5293 // 5294 // 5295 function createSafeFragment( document ) { // 5296 var list = nodeNames.split( "|" ), // 5297 safeFrag = document.createDocumentFragment(); // 5298 // 5299 if ( safeFrag.createElement ) { // 5300 while ( list.length ) { // 5301 safeFrag.createElement( // 5302 list.pop() // 5303 ); // 5304 } // 5305 } // 5306 return safeFrag; // 5307 } // 5308 // 5309 var nodeNames = "abbr|article|aside|audio|bdi|canvas|data|datalist|details|figcaption|figure|footer|" + // 5310 "header|hgroup|mark|meter|nav|output|progress|section|summary|time|video", // 5311 rinlinejQuery = / jQuery\d+="(?:null|\d+)"/g, // 5312 rnoshimcache = new RegExp("<(?:" + nodeNames + ")[\\s/>]", "i"), // 5313 rleadingWhitespace = /^\s+/, // 5314 rxhtmlTag = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:]+)[^>]*)\/>/gi, // 5315 rtagName = /<([\w:]+)/, // 5316 rtbody = /<tbody/i, // 5317 rhtml = /<|&#?\w+;/, // 5318 rnoInnerhtml = /<(?:script|style|link)/i, // 5319 // checked="checked" or checked // 5320 rchecked = /checked\s*(?:[^=]|=\s*.checked.)/i, // 5321 rscriptType = /^$|\/(?:java|ecma)script/i, // 5322 rscriptTypeMasked = /^true\/(.*)/, // 5323 rcleanScript = /^\s*<!(?:\[CDATA\[|--)|(?:\]\]|--)>\s*$/g, // 5324 // 5325 // We have to close these tags to support XHTML (#13200) // 5326 wrapMap = { // 5327 option: [ 1, "<select multiple='multiple'>", "</select>" ], // 5328 legend: [ 1, "<fieldset>", "</fieldset>" ], // 5329 area: [ 1, "<map>", "</map>" ], // 5330 param: [ 1, "<object>", "</object>" ], // 5331 thead: [ 1, "<table>", "</table>" ], // 5332 tr: [ 2, "<table><tbody>", "</tbody></table>" ], // 5333 col: [ 2, "<table><tbody></tbody><colgroup>", "</colgroup></table>" ], // 5334 td: [ 3, "<table><tbody><tr>", "</tr></tbody></table>" ], // 5335 // 5336 // IE6-8 can't serialize link, script, style, or any html5 (NoScope) tags, // 5337 // unless wrapped in a div with non-breaking characters in front of it. // 5338 _default: support.htmlSerialize ? [ 0, "", "" ] : [ 1, "X<div>", "</div>" ] // 5339 }, // 5340 safeFragment = createSafeFragment( document ), // 5341 fragmentDiv = safeFragment.appendChild( document.createElement("div") ); // 5342 // 5343 wrapMap.optgroup = wrapMap.option; // 5344 wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead; // 5345 wrapMap.th = wrapMap.td; // 5346 // 5347 function getAll( context, tag ) { // 5348 var elems, elem, // 5349 i = 0, // 5350 found = typeof context.getElementsByTagName !== strundefined ? context.getElementsByTagName( tag || "*" ) : // 5351 typeof context.querySelectorAll !== strundefined ? context.querySelectorAll( tag || "*" ) : // 5352 undefined; // 5353 // 5354 if ( !found ) { // 5355 for ( found = [], elems = context.childNodes || context; (elem = elems[i]) != null; i++ ) { // 5356 if ( !tag || jQuery.nodeName( elem, tag ) ) { // 5357 found.push( elem ); // 5358 } else { // 5359 jQuery.merge( found, getAll( elem, tag ) ); // 5360 } // 5361 } // 5362 } // 5363 // 5364 return tag === undefined || tag && jQuery.nodeName( context, tag ) ? // 5365 jQuery.merge( [ context ], found ) : // 5366 found; // 5367 } // 5368 // 5369 // Used in buildFragment, fixes the defaultChecked property // 5370 function fixDefaultChecked( elem ) { // 5371 if ( rcheckableType.test( elem.type ) ) { // 5372 elem.defaultChecked = elem.checked; // 5373 } // 5374 } // 5375 // 5376 // Support: IE<8 // 5377 // Manipulating tables requires a tbody // 5378 function manipulationTarget( elem, content ) { // 5379 return jQuery.nodeName( elem, "table" ) && // 5380 jQuery.nodeName( content.nodeType !== 11 ? content : content.firstChild, "tr" ) ? // 5381 // 5382 elem.getElementsByTagName("tbody")[0] || // 5383 elem.appendChild( elem.ownerDocument.createElement("tbody") ) : // 5384 elem; // 5385 } // 5386 // 5387 // Replace/restore the type attribute of script elements for safe DOM manipulation // 5388 function disableScript( elem ) { // 5389 elem.type = (jQuery.find.attr( elem, "type" ) !== null) + "/" + elem.type; // 5390 return elem; // 5391 } // 5392 function restoreScript( elem ) { // 5393 var match = rscriptTypeMasked.exec( elem.type ); // 5394 if ( match ) { // 5395 elem.type = match[1]; // 5396 } else { // 5397 elem.removeAttribute("type"); // 5398 } // 5399 return elem; // 5400 } // 5401 // 5402 // Mark scripts as having already been evaluated // 5403 function setGlobalEval( elems, refElements ) { // 5404 var elem, // 5405 i = 0; // 5406 for ( ; (elem = elems[i]) != null; i++ ) { // 5407 jQuery._data( elem, "globalEval", !refElements || jQuery._data( refElements[i], "globalEval" ) ); // 5408 } // 5409 } // 5410 // 5411 function cloneCopyEvent( src, dest ) { // 5412 // 5413 if ( dest.nodeType !== 1 || !jQuery.hasData( src ) ) { // 5414 return; // 5415 } // 5416 // 5417 var type, i, l, // 5418 oldData = jQuery._data( src ), // 5419 curData = jQuery._data( dest, oldData ), // 5420 events = oldData.events; // 5421 // 5422 if ( events ) { // 5423 delete curData.handle; // 5424 curData.events = {}; // 5425 // 5426 for ( type in events ) { // 5427 for ( i = 0, l = events[ type ].length; i < l; i++ ) { // 5428 jQuery.event.add( dest, type, events[ type ][ i ] ); // 5429 } // 5430 } // 5431 } // 5432 // 5433 // make the cloned public data object a copy from the original // 5434 if ( curData.data ) { // 5435 curData.data = jQuery.extend( {}, curData.data ); // 5436 } // 5437 } // 5438 // 5439 function fixCloneNodeIssues( src, dest ) { // 5440 var nodeName, e, data; // 5441 // 5442 // We do not need to do anything for non-Elements // 5443 if ( dest.nodeType !== 1 ) { // 5444 return; // 5445 } // 5446 // 5447 nodeName = dest.nodeName.toLowerCase(); // 5448 // 5449 // IE6-8 copies events bound via attachEvent when using cloneNode. // 5450 if ( !support.noCloneEvent && dest[ jQuery.expando ] ) { // 5451 data = jQuery._data( dest ); // 5452 // 5453 for ( e in data.events ) { // 5454 jQuery.removeEvent( dest, e, data.handle ); // 5455 } // 5456 // 5457 // Event data gets referenced instead of copied if the expando gets copied too // 5458 dest.removeAttribute( jQuery.expando ); // 5459 } // 5460 // 5461 // IE blanks contents when cloning scripts, and tries to evaluate newly-set text // 5462 if ( nodeName === "script" && dest.text !== src.text ) { // 5463 disableScript( dest ).text = src.text; // 5464 restoreScript( dest ); // 5465 // 5466 // IE6-10 improperly clones children of object elements using classid. // 5467 // IE10 throws NoModificationAllowedError if parent is null, #12132. // 5468 } else if ( nodeName === "object" ) { // 5469 if ( dest.parentNode ) { // 5470 dest.outerHTML = src.outerHTML; // 5471 } // 5472 // 5473 // This path appears unavoidable for IE9. When cloning an object // 5474 // element in IE9, the outerHTML strategy above is not sufficient. // 5475 // If the src has innerHTML and the destination does not, // 5476 // copy the src.innerHTML into the dest.innerHTML. #10324 // 5477 if ( support.html5Clone && ( src.innerHTML && !jQuery.trim(dest.innerHTML) ) ) { // 5478 dest.innerHTML = src.innerHTML; // 5479 } // 5480 // 5481 } else if ( nodeName === "input" && rcheckableType.test( src.type ) ) { // 5482 // IE6-8 fails to persist the checked state of a cloned checkbox // 5483 // or radio button. Worse, IE6-7 fail to give the cloned element // 5484 // a checked appearance if the defaultChecked value isn't also set // 5485 // 5486 dest.defaultChecked = dest.checked = src.checked; // 5487 // 5488 // IE6-7 get confused and end up setting the value of a cloned // 5489 // checkbox/radio button to an empty string instead of "on" // 5490 if ( dest.value !== src.value ) { // 5491 dest.value = src.value; // 5492 } // 5493 // 5494 // IE6-8 fails to return the selected option to the default selected // 5495 // state when cloning options // 5496 } else if ( nodeName === "option" ) { // 5497 dest.defaultSelected = dest.selected = src.defaultSelected; // 5498 // 5499 // IE6-8 fails to set the defaultValue to the correct value when // 5500 // cloning other types of input fields // 5501 } else if ( nodeName === "input" || nodeName === "textarea" ) { // 5502 dest.defaultValue = src.defaultValue; // 5503 } // 5504 } // 5505 // 5506 jQuery.extend({ // 5507 clone: function( elem, dataAndEvents, deepDataAndEvents ) { // 5508 var destElements, node, clone, i, srcElements, // 5509 inPage = jQuery.contains( elem.ownerDocument, elem ); // 5510 // 5511 if ( support.html5Clone || jQuery.isXMLDoc(elem) || !rnoshimcache.test( "<" + elem.nodeName + ">" ) ) { // 5512 clone = elem.cloneNode( true ); // 5513 // 5514 // IE<=8 does not properly clone detached, unknown element nodes // 5515 } else { // 5516 fragmentDiv.innerHTML = elem.outerHTML; // 5517 fragmentDiv.removeChild( clone = fragmentDiv.firstChild ); // 5518 } // 5519 // 5520 if ( (!support.noCloneEvent || !support.noCloneChecked) && // 5521 (elem.nodeType === 1 || elem.nodeType === 11) && !jQuery.isXMLDoc(elem) ) { // 5522 // 5523 // We eschew Sizzle here for performance reasons: http://jsperf.com/getall-vs-sizzle/2 // 5524 destElements = getAll( clone ); // 5525 srcElements = getAll( elem ); // 5526 // 5527 // Fix all IE cloning issues // 5528 for ( i = 0; (node = srcElements[i]) != null; ++i ) { // 5529 // Ensure that the destination node is not null; Fixes #9587 // 5530 if ( destElements[i] ) { // 5531 fixCloneNodeIssues( node, destElements[i] ); // 5532 } // 5533 } // 5534 } // 5535 // 5536 // Copy the events from the original to the clone // 5537 if ( dataAndEvents ) { // 5538 if ( deepDataAndEvents ) { // 5539 srcElements = srcElements || getAll( elem ); // 5540 destElements = destElements || getAll( clone ); // 5541 // 5542 for ( i = 0; (node = srcElements[i]) != null; i++ ) { // 5543 cloneCopyEvent( node, destElements[i] ); // 5544 } // 5545 } else { // 5546 cloneCopyEvent( elem, clone ); // 5547 } // 5548 } // 5549 // 5550 // Preserve script evaluation history // 5551 destElements = getAll( clone, "script" ); // 5552 if ( destElements.length > 0 ) { // 5553 setGlobalEval( destElements, !inPage && getAll( elem, "script" ) ); // 5554 } // 5555 // 5556 destElements = srcElements = node = null; // 5557 // 5558 // Return the cloned set // 5559 return clone; // 5560 }, // 5561 // 5562 buildFragment: function( elems, context, scripts, selection ) { // 5563 var j, elem, contains, // 5564 tmp, tag, tbody, wrap, // 5565 l = elems.length, // 5566 // 5567 // Ensure a safe fragment // 5568 safe = createSafeFragment( context ), // 5569 // 5570 nodes = [], // 5571 i = 0; // 5572 // 5573 for ( ; i < l; i++ ) { // 5574 elem = elems[ i ]; // 5575 // 5576 if ( elem || elem === 0 ) { // 5577 // 5578 // Add nodes directly // 5579 if ( jQuery.type( elem ) === "object" ) { // 5580 jQuery.merge( nodes, elem.nodeType ? [ elem ] : elem ); // 5581 // 5582 // Convert non-html into a text node // 5583 } else if ( !rhtml.test( elem ) ) { // 5584 nodes.push( context.createTextNode( elem ) ); // 5585 // 5586 // Convert html into DOM nodes // 5587 } else { // 5588 tmp = tmp || safe.appendChild( context.createElement("div") ); // 5589 // 5590 // Deserialize a standard representation // 5591 tag = (rtagName.exec( elem ) || [ "", "" ])[ 1 ].toLowerCase(); // 5592 wrap = wrapMap[ tag ] || wrapMap._default; // 5593 // 5594 tmp.innerHTML = wrap[1] + elem.replace( rxhtmlTag, "<$1></$2>" ) + wrap[2]; // 5595 // 5596 // Descend through wrappers to the right content // 5597 j = wrap[0]; // 5598 while ( j-- ) { // 5599 tmp = tmp.lastChild; // 5600 } // 5601 // 5602 // Manually add leading whitespace removed by IE // 5603 if ( !support.leadingWhitespace && rleadingWhitespace.test( elem ) ) { // 5604 nodes.push( context.createTextNode( rleadingWhitespace.exec( elem )[0] ) ); // 5605 } // 5606 // 5607 // Remove IE's autoinserted <tbody> from table fragments // 5608 if ( !support.tbody ) { // 5609 // 5610 // String was a <table>, *may* have spurious <tbody> // 5611 elem = tag === "table" && !rtbody.test( elem ) ? // 5612 tmp.firstChild : // 5613 // 5614 // String was a bare <thead> or <tfoot> // 5615 wrap[1] === "<table>" && !rtbody.test( elem ) ? // 5616 tmp : // 5617 0; // 5618 // 5619 j = elem && elem.childNodes.length; // 5620 while ( j-- ) { // 5621 if ( jQuery.nodeName( (tbody = elem.childNodes[j]), "tbody" ) && !tbody.childNodes.length ) { // 5622 elem.removeChild( tbody ); // 5623 } // 5624 } // 5625 } // 5626 // 5627 jQuery.merge( nodes, tmp.childNodes ); // 5628 // 5629 // Fix #12392 for WebKit and IE > 9 // 5630 tmp.textContent = ""; // 5631 // 5632 // Fix #12392 for oldIE // 5633 while ( tmp.firstChild ) { // 5634 tmp.removeChild( tmp.firstChild ); // 5635 } // 5636 // 5637 // Remember the top-level container for proper cleanup // 5638 tmp = safe.lastChild; // 5639 } // 5640 } // 5641 } // 5642 // 5643 // Fix #11356: Clear elements from fragment // 5644 if ( tmp ) { // 5645 safe.removeChild( tmp ); // 5646 } // 5647 // 5648 // Reset defaultChecked for any radios and checkboxes // 5649 // about to be appended to the DOM in IE 6/7 (#8060) // 5650 if ( !support.appendChecked ) { // 5651 jQuery.grep( getAll( nodes, "input" ), fixDefaultChecked ); // 5652 } // 5653 // 5654 i = 0; // 5655 while ( (elem = nodes[ i++ ]) ) { // 5656 // 5657 // #4087 - If origin and destination elements are the same, and this is // 5658 // that element, do not do anything // 5659 if ( selection && jQuery.inArray( elem, selection ) !== -1 ) { // 5660 continue; // 5661 } // 5662 // 5663 contains = jQuery.contains( elem.ownerDocument, elem ); // 5664 // 5665 // Append to fragment // 5666 tmp = getAll( safe.appendChild( elem ), "script" ); // 5667 // 5668 // Preserve script evaluation history // 5669 if ( contains ) { // 5670 setGlobalEval( tmp ); // 5671 } // 5672 // 5673 // Capture executables // 5674 if ( scripts ) { // 5675 j = 0; // 5676 while ( (elem = tmp[ j++ ]) ) { // 5677 if ( rscriptType.test( elem.type || "" ) ) { // 5678 scripts.push( elem ); // 5679 } // 5680 } // 5681 } // 5682 } // 5683 // 5684 tmp = null; // 5685 // 5686 return safe; // 5687 }, // 5688 // 5689 cleanData: function( elems, /* internal */ acceptData ) { // 5690 var elem, type, id, data, // 5691 i = 0, // 5692 internalKey = jQuery.expando, // 5693 cache = jQuery.cache, // 5694 deleteExpando = support.deleteExpando, // 5695 special = jQuery.event.special; // 5696 // 5697 for ( ; (elem = elems[i]) != null; i++ ) { // 5698 if ( acceptData || jQuery.acceptData( elem ) ) { // 5699 // 5700 id = elem[ internalKey ]; // 5701 data = id && cache[ id ]; // 5702 // 5703 if ( data ) { // 5704 if ( data.events ) { // 5705 for ( type in data.events ) { // 5706 if ( special[ type ] ) { // 5707 jQuery.event.remove( elem, type ); // 5708 // 5709 // This is a shortcut to avoid jQuery.event.remove's overhead // 5710 } else { // 5711 jQuery.removeEvent( elem, type, data.handle ); // 5712 } // 5713 } // 5714 } // 5715 // 5716 // Remove cache only if it was not already removed by jQuery.event.remove // 5717 if ( cache[ id ] ) { // 5718 // 5719 delete cache[ id ]; // 5720 // 5721 // IE does not allow us to delete expando properties from nodes, // 5722 // nor does it have a removeAttribute function on Document nodes; // 5723 // we must handle all of these cases // 5724 if ( deleteExpando ) { // 5725 delete elem[ internalKey ]; // 5726 // 5727 } else if ( typeof elem.removeAttribute !== strundefined ) { // 5728 elem.removeAttribute( internalKey ); // 5729 // 5730 } else { // 5731 elem[ internalKey ] = null; // 5732 } // 5733 // 5734 deletedIds.push( id ); // 5735 } // 5736 } // 5737 } // 5738 } // 5739 } // 5740 }); // 5741 // 5742 jQuery.fn.extend({ // 5743 text: function( value ) { // 5744 return access( this, function( value ) { // 5745 return value === undefined ? // 5746 jQuery.text( this ) : // 5747 this.empty().append( ( this[0] && this[0].ownerDocument || document ).createTextNode( value ) ); // 5748 }, null, value, arguments.length ); // 5749 }, // 5750 // 5751 append: function() { // 5752 return this.domManip( arguments, function( elem ) { // 5753 if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) { // 5754 var target = manipulationTarget( this, elem ); // 5755 target.appendChild( elem ); // 5756 } // 5757 }); // 5758 }, // 5759 // 5760 prepend: function() { // 5761 return this.domManip( arguments, function( elem ) { // 5762 if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) { // 5763 var target = manipulationTarget( this, elem ); // 5764 target.insertBefore( elem, target.firstChild ); // 5765 } // 5766 }); // 5767 }, // 5768 // 5769 before: function() { // 5770 return this.domManip( arguments, function( elem ) { // 5771 if ( this.parentNode ) { // 5772 this.parentNode.insertBefore( elem, this ); // 5773 } // 5774 }); // 5775 }, // 5776 // 5777 after: function() { // 5778 return this.domManip( arguments, function( elem ) { // 5779 if ( this.parentNode ) { // 5780 this.parentNode.insertBefore( elem, this.nextSibling ); // 5781 } // 5782 }); // 5783 }, // 5784 // 5785 remove: function( selector, keepData /* Internal Use Only */ ) { // 5786 var elem, // 5787 elems = selector ? jQuery.filter( selector, this ) : this, // 5788 i = 0; // 5789 // 5790 for ( ; (elem = elems[i]) != null; i++ ) { // 5791 // 5792 if ( !keepData && elem.nodeType === 1 ) { // 5793 jQuery.cleanData( getAll( elem ) ); // 5794 } // 5795 // 5796 if ( elem.parentNode ) { // 5797 if ( keepData && jQuery.contains( elem.ownerDocument, elem ) ) { // 5798 setGlobalEval( getAll( elem, "script" ) ); // 5799 } // 5800 elem.parentNode.removeChild( elem ); // 5801 } // 5802 } // 5803 // 5804 return this; // 5805 }, // 5806 // 5807 empty: function() { // 5808 var elem, // 5809 i = 0; // 5810 // 5811 for ( ; (elem = this[i]) != null; i++ ) { // 5812 // Remove element nodes and prevent memory leaks // 5813 if ( elem.nodeType === 1 ) { // 5814 jQuery.cleanData( getAll( elem, false ) ); // 5815 } // 5816 // 5817 // Remove any remaining nodes // 5818 while ( elem.firstChild ) { // 5819 elem.removeChild( elem.firstChild ); // 5820 } // 5821 // 5822 // If this is a select, ensure that it displays empty (#12336) // 5823 // Support: IE<9 // 5824 if ( elem.options && jQuery.nodeName( elem, "select" ) ) { // 5825 elem.options.length = 0; // 5826 } // 5827 } // 5828 // 5829 return this; // 5830 }, // 5831 // 5832 clone: function( dataAndEvents, deepDataAndEvents ) { // 5833 dataAndEvents = dataAndEvents == null ? false : dataAndEvents; // 5834 deepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents; // 5835 // 5836 return this.map(function() { // 5837 return jQuery.clone( this, dataAndEvents, deepDataAndEvents ); // 5838 }); // 5839 }, // 5840 // 5841 html: function( value ) { // 5842 return access( this, function( value ) { // 5843 var elem = this[ 0 ] || {}, // 5844 i = 0, // 5845 l = this.length; // 5846 // 5847 if ( value === undefined ) { // 5848 return elem.nodeType === 1 ? // 5849 elem.innerHTML.replace( rinlinejQuery, "" ) : // 5850 undefined; // 5851 } // 5852 // 5853 // See if we can take a shortcut and just use innerHTML // 5854 if ( typeof value === "string" && !rnoInnerhtml.test( value ) && // 5855 ( support.htmlSerialize || !rnoshimcache.test( value ) ) && // 5856 ( support.leadingWhitespace || !rleadingWhitespace.test( value ) ) && // 5857 !wrapMap[ (rtagName.exec( value ) || [ "", "" ])[ 1 ].toLowerCase() ] ) { // 5858 // 5859 value = value.replace( rxhtmlTag, "<$1></$2>" ); // 5860 // 5861 try { // 5862 for (; i < l; i++ ) { // 5863 // Remove element nodes and prevent memory leaks // 5864 elem = this[i] || {}; // 5865 if ( elem.nodeType === 1 ) { // 5866 jQuery.cleanData( getAll( elem, false ) ); // 5867 elem.innerHTML = value; // 5868 } // 5869 } // 5870 // 5871 elem = 0; // 5872 // 5873 // If using innerHTML throws an exception, use the fallback method // 5874 } catch(e) {} // 5875 } // 5876 // 5877 if ( elem ) { // 5878 this.empty().append( value ); // 5879 } // 5880 }, null, value, arguments.length ); // 5881 }, // 5882 // 5883 replaceWith: function() { // 5884 var arg = arguments[ 0 ]; // 5885 // 5886 // Make the changes, replacing each context element with the new content // 5887 this.domManip( arguments, function( elem ) { // 5888 arg = this.parentNode; // 5889 // 5890 jQuery.cleanData( getAll( this ) ); // 5891 // 5892 if ( arg ) { // 5893 arg.replaceChild( elem, this ); // 5894 } // 5895 }); // 5896 // 5897 // Force removal if there was no new content (e.g., from empty arguments) // 5898 return arg && (arg.length || arg.nodeType) ? this : this.remove(); // 5899 }, // 5900 // 5901 detach: function( selector ) { // 5902 return this.remove( selector, true ); // 5903 }, // 5904 // 5905 domManip: function( args, callback ) { // 5906 // 5907 // Flatten any nested arrays // 5908 args = concat.apply( [], args ); // 5909 // 5910 var first, node, hasScripts, // 5911 scripts, doc, fragment, // 5912 i = 0, // 5913 l = this.length, // 5914 set = this, // 5915 iNoClone = l - 1, // 5916 value = args[0], // 5917 isFunction = jQuery.isFunction( value ); // 5918 // 5919 // We can't cloneNode fragments that contain checked, in WebKit // 5920 if ( isFunction || // 5921 ( l > 1 && typeof value === "string" && // 5922 !support.checkClone && rchecked.test( value ) ) ) { // 5923 return this.each(function( index ) { // 5924 var self = set.eq( index ); // 5925 if ( isFunction ) { // 5926 args[0] = value.call( this, index, self.html() ); // 5927 } // 5928 self.domManip( args, callback ); // 5929 }); // 5930 } // 5931 // 5932 if ( l ) { // 5933 fragment = jQuery.buildFragment( args, this[ 0 ].ownerDocument, false, this ); // 5934 first = fragment.firstChild; // 5935 // 5936 if ( fragment.childNodes.length === 1 ) { // 5937 fragment = first; // 5938 } // 5939 // 5940 if ( first ) { // 5941 scripts = jQuery.map( getAll( fragment, "script" ), disableScript ); // 5942 hasScripts = scripts.length; // 5943 // 5944 // Use the original fragment for the last item instead of the first because it can end up // 5945 // being emptied incorrectly in certain situations (#8070). // 5946 for ( ; i < l; i++ ) { // 5947 node = fragment; // 5948 // 5949 if ( i !== iNoClone ) { // 5950 node = jQuery.clone( node, true, true ); // 5951 // 5952 // Keep references to cloned scripts for later restoration // 5953 if ( hasScripts ) { // 5954 jQuery.merge( scripts, getAll( node, "script" ) ); // 5955 } // 5956 } // 5957 // 5958 callback.call( this[i], node, i ); // 5959 } // 5960 // 5961 if ( hasScripts ) { // 5962 doc = scripts[ scripts.length - 1 ].ownerDocument; // 5963 // 5964 // Reenable scripts // 5965 jQuery.map( scripts, restoreScript ); // 5966 // 5967 // Evaluate executable scripts on first document insertion // 5968 for ( i = 0; i < hasScripts; i++ ) { // 5969 node = scripts[ i ]; // 5970 if ( rscriptType.test( node.type || "" ) && // 5971 !jQuery._data( node, "globalEval" ) && jQuery.contains( doc, node ) ) { // 5972 // 5973 if ( node.src ) { // 5974 // Optional AJAX dependency, but won't run scripts if not present // 5975 if ( jQuery._evalUrl ) { // 5976 jQuery._evalUrl( node.src ); // 5977 } // 5978 } else { // 5979 jQuery.globalEval( ( node.text || node.textContent || node.innerHTML || "" ).replace( rcleanScript, "" ) ); // 5980 } // 5981 } // 5982 } // 5983 } // 5984 // 5985 // Fix #11809: Avoid leaking memory // 5986 fragment = first = null; // 5987 } // 5988 } // 5989 // 5990 return this; // 5991 } // 5992 }); // 5993 // 5994 jQuery.each({ // 5995 appendTo: "append", // 5996 prependTo: "prepend", // 5997 insertBefore: "before", // 5998 insertAfter: "after", // 5999 replaceAll: "replaceWith" // 6000 }, function( name, original ) { // 6001 jQuery.fn[ name ] = function( selector ) { // 6002 var elems, // 6003 i = 0, // 6004 ret = [], // 6005 insert = jQuery( selector ), // 6006 last = insert.length - 1; // 6007 // 6008 for ( ; i <= last; i++ ) { // 6009 elems = i === last ? this : this.clone(true); // 6010 jQuery( insert[i] )[ original ]( elems ); // 6011 // 6012 // Modern browsers can apply jQuery collections as arrays, but oldIE needs a .get() // 6013 push.apply( ret, elems.get() ); // 6014 } // 6015 // 6016 return this.pushStack( ret ); // 6017 }; // 6018 }); // 6019 // 6020 // 6021 var iframe, // 6022 elemdisplay = {}; // 6023 // 6024 /** // 6025 * Retrieve the actual display of a element // 6026 * @param {String} name nodeName of the element // 6027 * @param {Object} doc Document object // 6028 */ // 6029 // Called only from within defaultDisplay // 6030 function actualDisplay( name, doc ) { // 6031 var style, // 6032 elem = jQuery( doc.createElement( name ) ).appendTo( doc.body ), // 6033 // 6034 // getDefaultComputedStyle might be reliably used only on attached element // 6035 display = window.getDefaultComputedStyle && ( style = window.getDefaultComputedStyle( elem[ 0 ] ) ) ? // 6036 // 6037 // Use of this method is a temporary fix (more like optmization) until something better comes along, // 6038 // since it was removed from specification and supported only in FF // 6039 style.display : jQuery.css( elem[ 0 ], "display" ); // 6040 // 6041 // We don't have any data stored on the element, // 6042 // so use "detach" method as fast way to get rid of the element // 6043 elem.detach(); // 6044 // 6045 return display; // 6046 } // 6047 // 6048 /** // 6049 * Try to determine the default display value of an element // 6050 * @param {String} nodeName // 6051 */ // 6052 function defaultDisplay( nodeName ) { // 6053 var doc = document, // 6054 display = elemdisplay[ nodeName ]; // 6055 // 6056 if ( !display ) { // 6057 display = actualDisplay( nodeName, doc ); // 6058 // 6059 // If the simple way fails, read from inside an iframe // 6060 if ( display === "none" || !display ) { // 6061 // 6062 // Use the already-created iframe if possible // 6063 iframe = (iframe || jQuery( "<iframe frameborder='0' width='0' height='0'/>" )).appendTo( doc.documentElement ); // 6064 // 6065 // Always write a new HTML skeleton so Webkit and Firefox don't choke on reuse // 6066 doc = ( iframe[ 0 ].contentWindow || iframe[ 0 ].contentDocument ).document; // 6067 // 6068 // Support: IE // 6069 doc.write(); // 6070 doc.close(); // 6071 // 6072 display = actualDisplay( nodeName, doc ); // 6073 iframe.detach(); // 6074 } // 6075 // 6076 // Store the correct default display // 6077 elemdisplay[ nodeName ] = display; // 6078 } // 6079 // 6080 return display; // 6081 } // 6082 // 6083 // 6084 (function() { // 6085 var shrinkWrapBlocksVal; // 6086 // 6087 support.shrinkWrapBlocks = function() { // 6088 if ( shrinkWrapBlocksVal != null ) { // 6089 return shrinkWrapBlocksVal; // 6090 } // 6091 // 6092 // Will be changed later if needed. // 6093 shrinkWrapBlocksVal = false; // 6094 // 6095 // Minified: var b,c,d // 6096 var div, body, container; // 6097 // 6098 body = document.getElementsByTagName( "body" )[ 0 ]; // 6099 if ( !body || !body.style ) { // 6100 // Test fired too early or in an unsupported environment, exit. // 6101 return; // 6102 } // 6103 // 6104 // Setup // 6105 div = document.createElement( "div" ); // 6106 container = document.createElement( "div" ); // 6107 container.style.cssText = "position:absolute;border:0;width:0;height:0;top:0;left:-9999px"; // 6108 body.appendChild( container ).appendChild( div ); // 6109 // 6110 // Support: IE6 // 6111 // Check if elements with layout shrink-wrap their children // 6112 if ( typeof div.style.zoom !== strundefined ) { // 6113 // Reset CSS: box-sizing; display; margin; border // 6114 div.style.cssText = // 6115 // Support: Firefox<29, Android 2.3 // 6116 // Vendor-prefix box-sizing // 6117 "-webkit-box-sizing:content-box;-moz-box-sizing:content-box;" + // 6118 "box-sizing:content-box;display:block;margin:0;border:0;" + // 6119 "padding:1px;width:1px;zoom:1"; // 6120 div.appendChild( document.createElement( "div" ) ).style.width = "5px"; // 6121 shrinkWrapBlocksVal = div.offsetWidth !== 3; // 6122 } // 6123 // 6124 body.removeChild( container ); // 6125 // 6126 return shrinkWrapBlocksVal; // 6127 }; // 6128 // 6129 })(); // 6130 var rmargin = (/^margin/); // 6131 // 6132 var rnumnonpx = new RegExp( "^(" + pnum + ")(?!px)[a-z%]+$", "i" ); // 6133 // 6134 // 6135 // 6136 var getStyles, curCSS, // 6137 rposition = /^(top|right|bottom|left)$/; // 6138 // 6139 if ( window.getComputedStyle ) { // 6140 getStyles = function( elem ) { // 6141 // Support: IE<=11+, Firefox<=30+ (#15098, #14150) // 6142 // IE throws on elements created in popups // 6143 // FF meanwhile throws on frame elements through "defaultView.getComputedStyle" // 6144 if ( elem.ownerDocument.defaultView.opener ) { // 6145 return elem.ownerDocument.defaultView.getComputedStyle( elem, null ); // 6146 } // 6147 // 6148 return window.getComputedStyle( elem, null ); // 6149 }; // 6150 // 6151 curCSS = function( elem, name, computed ) { // 6152 var width, minWidth, maxWidth, ret, // 6153 style = elem.style; // 6154 // 6155 computed = computed || getStyles( elem ); // 6156 // 6157 // getPropertyValue is only needed for .css('filter') in IE9, see #12537 // 6158 ret = computed ? computed.getPropertyValue( name ) || computed[ name ] : undefined; // 6159 // 6160 if ( computed ) { // 6161 // 6162 if ( ret === "" && !jQuery.contains( elem.ownerDocument, elem ) ) { // 6163 ret = jQuery.style( elem, name ); // 6164 } // 6165 // 6166 // A tribute to the "awesome hack by Dean Edwards" // 6167 // Chrome < 17 and Safari 5.0 uses "computed value" instead of "used value" for margin-right // 6168 // Safari 5.1.7 (at least) returns percentage for a larger set of values, but width seems to be reliably pixels // 6169 // this is against the CSSOM draft spec: http://dev.w3.org/csswg/cssom/#resolved-values // 6170 if ( rnumnonpx.test( ret ) && rmargin.test( name ) ) { // 6171 // 6172 // Remember the original values // 6173 width = style.width; // 6174 minWidth = style.minWidth; // 6175 maxWidth = style.maxWidth; // 6176 // 6177 // Put in the new values to get a computed value out // 6178 style.minWidth = style.maxWidth = style.width = ret; // 6179 ret = computed.width; // 6180 // 6181 // Revert the changed values // 6182 style.width = width; // 6183 style.minWidth = minWidth; // 6184 style.maxWidth = maxWidth; // 6185 } // 6186 } // 6187 // 6188 // Support: IE // 6189 // IE returns zIndex value as an integer. // 6190 return ret === undefined ? // 6191 ret : // 6192 ret + ""; // 6193 }; // 6194 } else if ( document.documentElement.currentStyle ) { // 6195 getStyles = function( elem ) { // 6196 return elem.currentStyle; // 6197 }; // 6198 // 6199 curCSS = function( elem, name, computed ) { // 6200 var left, rs, rsLeft, ret, // 6201 style = elem.style; // 6202 // 6203 computed = computed || getStyles( elem ); // 6204 ret = computed ? computed[ name ] : undefined; // 6205 // 6206 // Avoid setting ret to empty string here // 6207 // so we don't default to auto // 6208 if ( ret == null && style && style[ name ] ) { // 6209 ret = style[ name ]; // 6210 } // 6211 // 6212 // From the awesome hack by Dean Edwards // 6213 // http://erik.eae.net/archives/2007/07/27/18.54.15/#comment-102291 // 6214 // 6215 // If we're not dealing with a regular pixel number // 6216 // but a number that has a weird ending, we need to convert it to pixels // 6217 // but not position css attributes, as those are proportional to the parent element instead // 6218 // and we can't measure the parent instead because it might trigger a "stacking dolls" problem // 6219 if ( rnumnonpx.test( ret ) && !rposition.test( name ) ) { // 6220 // 6221 // Remember the original values // 6222 left = style.left; // 6223 rs = elem.runtimeStyle; // 6224 rsLeft = rs && rs.left; // 6225 // 6226 // Put in the new values to get a computed value out // 6227 if ( rsLeft ) { // 6228 rs.left = elem.currentStyle.left; // 6229 } // 6230 style.left = name === "fontSize" ? "1em" : ret; // 6231 ret = style.pixelLeft + "px"; // 6232 // 6233 // Revert the changed values // 6234 style.left = left; // 6235 if ( rsLeft ) { // 6236 rs.left = rsLeft; // 6237 } // 6238 } // 6239 // 6240 // Support: IE // 6241 // IE returns zIndex value as an integer. // 6242 return ret === undefined ? // 6243 ret : // 6244 ret + "" || "auto"; // 6245 }; // 6246 } // 6247 // 6248 // 6249 // 6250 // 6251 function addGetHookIf( conditionFn, hookFn ) { // 6252 // Define the hook, we'll check on the first run if it's really needed. // 6253 return { // 6254 get: function() { // 6255 var condition = conditionFn(); // 6256 // 6257 if ( condition == null ) { // 6258 // The test was not ready at this point; screw the hook this time // 6259 // but check again when needed next time. // 6260 return; // 6261 } // 6262 // 6263 if ( condition ) { // 6264 // Hook not needed (or it's not possible to use it due to missing dependency), // 6265 // remove it. // 6266 // Since there are no other hooks for marginRight, remove the whole object. // 6267 delete this.get; // 6268 return; // 6269 } // 6270 // 6271 // Hook needed; redefine it so that the support test is not executed again. // 6272 // 6273 return (this.get = hookFn).apply( this, arguments ); // 6274 } // 6275 }; // 6276 } // 6277 // 6278 // 6279 (function() { // 6280 // Minified: var b,c,d,e,f,g, h,i // 6281 var div, style, a, pixelPositionVal, boxSizingReliableVal, // 6282 reliableHiddenOffsetsVal, reliableMarginRightVal; // 6283 // 6284 // Setup // 6285 div = document.createElement( "div" ); // 6286 div.innerHTML = " <link/><table></table><a href='/a'>a</a><input type='checkbox'/>"; // 6287 a = div.getElementsByTagName( "a" )[ 0 ]; // 6288 style = a && a.style; // 6289 // 6290 // Finish early in limited (non-browser) environments // 6291 if ( !style ) { // 6292 return; // 6293 } // 6294 // 6295 style.cssText = "float:left;opacity:.5"; // 6296 // 6297 // Support: IE<9 // 6298 // Make sure that element opacity exists (as opposed to filter) // 6299 support.opacity = style.opacity === "0.5"; // 6300 // 6301 // Verify style float existence // 6302 // (IE uses styleFloat instead of cssFloat) // 6303 support.cssFloat = !!style.cssFloat; // 6304 // 6305 div.style.backgroundClip = "content-box"; // 6306 div.cloneNode( true ).style.backgroundClip = ""; // 6307 support.clearCloneStyle = div.style.backgroundClip === "content-box"; // 6308 // 6309 // Support: Firefox<29, Android 2.3 // 6310 // Vendor-prefix box-sizing // 6311 support.boxSizing = style.boxSizing === "" || style.MozBoxSizing === "" || // 6312 style.WebkitBoxSizing === ""; // 6313 // 6314 jQuery.extend(support, { // 6315 reliableHiddenOffsets: function() { // 6316 if ( reliableHiddenOffsetsVal == null ) { // 6317 computeStyleTests(); // 6318 } // 6319 return reliableHiddenOffsetsVal; // 6320 }, // 6321 // 6322 boxSizingReliable: function() { // 6323 if ( boxSizingReliableVal == null ) { // 6324 computeStyleTests(); // 6325 } // 6326 return boxSizingReliableVal; // 6327 }, // 6328 // 6329 pixelPosition: function() { // 6330 if ( pixelPositionVal == null ) { // 6331 computeStyleTests(); // 6332 } // 6333 return pixelPositionVal; // 6334 }, // 6335 // 6336 // Support: Android 2.3 // 6337 reliableMarginRight: function() { // 6338 if ( reliableMarginRightVal == null ) { // 6339 computeStyleTests(); // 6340 } // 6341 return reliableMarginRightVal; // 6342 } // 6343 }); // 6344 // 6345 function computeStyleTests() { // 6346 // Minified: var b,c,d,j // 6347 var div, body, container, contents; // 6348 // 6349 body = document.getElementsByTagName( "body" )[ 0 ]; // 6350 if ( !body || !body.style ) { // 6351 // Test fired too early or in an unsupported environment, exit. // 6352 return; // 6353 } // 6354 // 6355 // Setup // 6356 div = document.createElement( "div" ); // 6357 container = document.createElement( "div" ); // 6358 container.style.cssText = "position:absolute;border:0;width:0;height:0;top:0;left:-9999px"; // 6359 body.appendChild( container ).appendChild( div ); // 6360 // 6361 div.style.cssText = // 6362 // Support: Firefox<29, Android 2.3 // 6363 // Vendor-prefix box-sizing // 6364 "-webkit-box-sizing:border-box;-moz-box-sizing:border-box;" + // 6365 "box-sizing:border-box;display:block;margin-top:1%;top:1%;" + // 6366 "border:1px;padding:1px;width:4px;position:absolute"; // 6367 // 6368 // Support: IE<9 // 6369 // Assume reasonable values in the absence of getComputedStyle // 6370 pixelPositionVal = boxSizingReliableVal = false; // 6371 reliableMarginRightVal = true; // 6372 // 6373 // Check for getComputedStyle so that this code is not run in IE<9. // 6374 if ( window.getComputedStyle ) { // 6375 pixelPositionVal = ( window.getComputedStyle( div, null ) || {} ).top !== "1%"; // 6376 boxSizingReliableVal = // 6377 ( window.getComputedStyle( div, null ) || { width: "4px" } ).width === "4px"; // 6378 // 6379 // Support: Android 2.3 // 6380 // Div with explicit width and no margin-right incorrectly // 6381 // gets computed margin-right based on width of container (#3333) // 6382 // WebKit Bug 13343 - getComputedStyle returns wrong value for margin-right // 6383 contents = div.appendChild( document.createElement( "div" ) ); // 6384 // 6385 // Reset CSS: box-sizing; display; margin; border; padding // 6386 contents.style.cssText = div.style.cssText = // 6387 // Support: Firefox<29, Android 2.3 // 6388 // Vendor-prefix box-sizing // 6389 "-webkit-box-sizing:content-box;-moz-box-sizing:content-box;" + // 6390 "box-sizing:content-box;display:block;margin:0;border:0;padding:0"; // 6391 contents.style.marginRight = contents.style.width = "0"; // 6392 div.style.width = "1px"; // 6393 // 6394 reliableMarginRightVal = // 6395 !parseFloat( ( window.getComputedStyle( contents, null ) || {} ).marginRight ); // 6396 // 6397 div.removeChild( contents ); // 6398 } // 6399 // 6400 // Support: IE8 // 6401 // Check if table cells still have offsetWidth/Height when they are set // 6402 // to display:none and there are still other visible table cells in a // 6403 // table row; if so, offsetWidth/Height are not reliable for use when // 6404 // determining if an element has been hidden directly using // 6405 // display:none (it is still safe to use offsets if a parent element is // 6406 // hidden; don safety goggles and see bug #4512 for more information). // 6407 div.innerHTML = "<table><tr><td></td><td>t</td></tr></table>"; // 6408 contents = div.getElementsByTagName( "td" ); // 6409 contents[ 0 ].style.cssText = "margin:0;border:0;padding:0;display:none"; // 6410 reliableHiddenOffsetsVal = contents[ 0 ].offsetHeight === 0; // 6411 if ( reliableHiddenOffsetsVal ) { // 6412 contents[ 0 ].style.display = ""; // 6413 contents[ 1 ].style.display = "none"; // 6414 reliableHiddenOffsetsVal = contents[ 0 ].offsetHeight === 0; // 6415 } // 6416 // 6417 body.removeChild( container ); // 6418 } // 6419 // 6420 })(); // 6421 // 6422 // 6423 // A method for quickly swapping in/out CSS properties to get correct calculations. // 6424 jQuery.swap = function( elem, options, callback, args ) { // 6425 var ret, name, // 6426 old = {}; // 6427 // 6428 // Remember the old values, and insert the new ones // 6429 for ( name in options ) { // 6430 old[ name ] = elem.style[ name ]; // 6431 elem.style[ name ] = options[ name ]; // 6432 } // 6433 // 6434 ret = callback.apply( elem, args || [] ); // 6435 // 6436 // Revert the old values // 6437 for ( name in options ) { // 6438 elem.style[ name ] = old[ name ]; // 6439 } // 6440 // 6441 return ret; // 6442 }; // 6443 // 6444 // 6445 var // 6446 ralpha = /alpha\([^)]*\)/i, // 6447 ropacity = /opacity\s*=\s*([^)]*)/, // 6448 // 6449 // swappable if display is none or starts with table except "table", "table-cell", or "table-caption" // 6450 // see here for display values: https://developer.mozilla.org/en-US/docs/CSS/display // 6451 rdisplayswap = /^(none|table(?!-c[ea]).+)/, // 6452 rnumsplit = new RegExp( "^(" + pnum + ")(.*)$", "i" ), // 6453 rrelNum = new RegExp( "^([+-])=(" + pnum + ")", "i" ), // 6454 // 6455 cssShow = { position: "absolute", visibility: "hidden", display: "block" }, // 6456 cssNormalTransform = { // 6457 letterSpacing: "0", // 6458 fontWeight: "400" // 6459 }, // 6460 // 6461 cssPrefixes = [ "Webkit", "O", "Moz", "ms" ]; // 6462 // 6463 // 6464 // return a css property mapped to a potentially vendor prefixed property // 6465 function vendorPropName( style, name ) { // 6466 // 6467 // shortcut for names that are not vendor prefixed // 6468 if ( name in style ) { // 6469 return name; // 6470 } // 6471 // 6472 // check for vendor prefixed names // 6473 var capName = name.charAt(0).toUpperCase() + name.slice(1), // 6474 origName = name, // 6475 i = cssPrefixes.length; // 6476 // 6477 while ( i-- ) { // 6478 name = cssPrefixes[ i ] + capName; // 6479 if ( name in style ) { // 6480 return name; // 6481 } // 6482 } // 6483 // 6484 return origName; // 6485 } // 6486 // 6487 function showHide( elements, show ) { // 6488 var display, elem, hidden, // 6489 values = [], // 6490 index = 0, // 6491 length = elements.length; // 6492 // 6493 for ( ; index < length; index++ ) { // 6494 elem = elements[ index ]; // 6495 if ( !elem.style ) { // 6496 continue; // 6497 } // 6498 // 6499 values[ index ] = jQuery._data( elem, "olddisplay" ); // 6500 display = elem.style.display; // 6501 if ( show ) { // 6502 // Reset the inline display of this element to learn if it is // 6503 // being hidden by cascaded rules or not // 6504 if ( !values[ index ] && display === "none" ) { // 6505 elem.style.display = ""; // 6506 } // 6507 // 6508 // Set elements which have been overridden with display: none // 6509 // in a stylesheet to whatever the default browser style is // 6510 // for such an element // 6511 if ( elem.style.display === "" && isHidden( elem ) ) { // 6512 values[ index ] = jQuery._data( elem, "olddisplay", defaultDisplay(elem.nodeName) ); // 6513 } // 6514 } else { // 6515 hidden = isHidden( elem ); // 6516 // 6517 if ( display && display !== "none" || !hidden ) { // 6518 jQuery._data( elem, "olddisplay", hidden ? display : jQuery.css( elem, "display" ) ); // 6519 } // 6520 } // 6521 } // 6522 // 6523 // Set the display of most of the elements in a second loop // 6524 // to avoid the constant reflow // 6525 for ( index = 0; index < length; index++ ) { // 6526 elem = elements[ index ]; // 6527 if ( !elem.style ) { // 6528 continue; // 6529 } // 6530 if ( !show || elem.style.display === "none" || elem.style.display === "" ) { // 6531 elem.style.display = show ? values[ index ] || "" : "none"; // 6532 } // 6533 } // 6534 // 6535 return elements; // 6536 } // 6537 // 6538 function setPositiveNumber( elem, value, subtract ) { // 6539 var matches = rnumsplit.exec( value ); // 6540 return matches ? // 6541 // Guard against undefined "subtract", e.g., when used as in cssHooks // 6542 Math.max( 0, matches[ 1 ] - ( subtract || 0 ) ) + ( matches[ 2 ] || "px" ) : // 6543 value; // 6544 } // 6545 // 6546 function augmentWidthOrHeight( elem, name, extra, isBorderBox, styles ) { // 6547 var i = extra === ( isBorderBox ? "border" : "content" ) ? // 6548 // If we already have the right measurement, avoid augmentation // 6549 4 : // 6550 // Otherwise initialize for horizontal or vertical properties // 6551 name === "width" ? 1 : 0, // 6552 // 6553 val = 0; // 6554 // 6555 for ( ; i < 4; i += 2 ) { // 6556 // both box models exclude margin, so add it if we want it // 6557 if ( extra === "margin" ) { // 6558 val += jQuery.css( elem, extra + cssExpand[ i ], true, styles ); // 6559 } // 6560 // 6561 if ( isBorderBox ) { // 6562 // border-box includes padding, so remove it if we want content // 6563 if ( extra === "content" ) { // 6564 val -= jQuery.css( elem, "padding" + cssExpand[ i ], true, styles ); // 6565 } // 6566 // 6567 // at this point, extra isn't border nor margin, so remove border // 6568 if ( extra !== "margin" ) { // 6569 val -= jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles ); // 6570 } // 6571 } else { // 6572 // at this point, extra isn't content, so add padding // 6573 val += jQuery.css( elem, "padding" + cssExpand[ i ], true, styles ); // 6574 // 6575 // at this point, extra isn't content nor padding, so add border // 6576 if ( extra !== "padding" ) { // 6577 val += jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles ); // 6578 } // 6579 } // 6580 } // 6581 // 6582 return val; // 6583 } // 6584 // 6585 function getWidthOrHeight( elem, name, extra ) { // 6586 // 6587 // Start with offset property, which is equivalent to the border-box value // 6588 var valueIsBorderBox = true, // 6589 val = name === "width" ? elem.offsetWidth : elem.offsetHeight, // 6590 styles = getStyles( elem ), // 6591 isBorderBox = support.boxSizing && jQuery.css( elem, "boxSizing", false, styles ) === "border-box"; // 6592 // 6593 // some non-html elements return undefined for offsetWidth, so check for null/undefined // 6594 // svg - https://bugzilla.mozilla.org/show_bug.cgi?id=649285 // 6595 // MathML - https://bugzilla.mozilla.org/show_bug.cgi?id=491668 // 6596 if ( val <= 0 || val == null ) { // 6597 // Fall back to computed then uncomputed css if necessary // 6598 val = curCSS( elem, name, styles ); // 6599 if ( val < 0 || val == null ) { // 6600 val = elem.style[ name ]; // 6601 } // 6602 // 6603 // Computed unit is not pixels. Stop here and return. // 6604 if ( rnumnonpx.test(val) ) { // 6605 return val; // 6606 } // 6607 // 6608 // we need the check for style in case a browser which returns unreliable values // 6609 // for getComputedStyle silently falls back to the reliable elem.style // 6610 valueIsBorderBox = isBorderBox && ( support.boxSizingReliable() || val === elem.style[ name ] ); // 6611 // 6612 // Normalize "", auto, and prepare for extra // 6613 val = parseFloat( val ) || 0; // 6614 } // 6615 // 6616 // use the active box-sizing model to add/subtract irrelevant styles // 6617 return ( val + // 6618 augmentWidthOrHeight( // 6619 elem, // 6620 name, // 6621 extra || ( isBorderBox ? "border" : "content" ), // 6622 valueIsBorderBox, // 6623 styles // 6624 ) // 6625 ) + "px"; // 6626 } // 6627 // 6628 jQuery.extend({ // 6629 // Add in style property hooks for overriding the default // 6630 // behavior of getting and setting a style property // 6631 cssHooks: { // 6632 opacity: { // 6633 get: function( elem, computed ) { // 6634 if ( computed ) { // 6635 // We should always get a number back from opacity // 6636 var ret = curCSS( elem, "opacity" ); // 6637 return ret === "" ? "1" : ret; // 6638 } // 6639 } // 6640 } // 6641 }, // 6642 // 6643 // Don't automatically add "px" to these possibly-unitless properties // 6644 cssNumber: { // 6645 "columnCount": true, // 6646 "fillOpacity": true, // 6647 "flexGrow": true, // 6648 "flexShrink": true, // 6649 "fontWeight": true, // 6650 "lineHeight": true, // 6651 "opacity": true, // 6652 "order": true, // 6653 "orphans": true, // 6654 "widows": true, // 6655 "zIndex": true, // 6656 "zoom": true // 6657 }, // 6658 // 6659 // Add in properties whose names you wish to fix before // 6660 // setting or getting the value // 6661 cssProps: { // 6662 // normalize float css property // 6663 "float": support.cssFloat ? "cssFloat" : "styleFloat" // 6664 }, // 6665 // 6666 // Get and set the style property on a DOM Node // 6667 style: function( elem, name, value, extra ) { // 6668 // Don't set styles on text and comment nodes // 6669 if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style ) { // 6670 return; // 6671 } // 6672 // 6673 // Make sure that we're working with the right name // 6674 var ret, type, hooks, // 6675 origName = jQuery.camelCase( name ), // 6676 style = elem.style; // 6677 // 6678 name = jQuery.cssProps[ origName ] || ( jQuery.cssProps[ origName ] = vendorPropName( style, origName ) ); // 6679 // 6680 // gets hook for the prefixed version // 6681 // followed by the unprefixed version // 6682 hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ]; // 6683 // 6684 // Check if we're setting a value // 6685 if ( value !== undefined ) { // 6686 type = typeof value; // 6687 // 6688 // convert relative number strings (+= or -=) to relative numbers. #7345 // 6689 if ( type === "string" && (ret = rrelNum.exec( value )) ) { // 6690 value = ( ret[1] + 1 ) * ret[2] + parseFloat( jQuery.css( elem, name ) ); // 6691 // Fixes bug #9237 // 6692 type = "number"; // 6693 } // 6694 // 6695 // Make sure that null and NaN values aren't set. See: #7116 // 6696 if ( value == null || value !== value ) { // 6697 return; // 6698 } // 6699 // 6700 // If a number was passed in, add 'px' to the (except for certain CSS properties) // 6701 if ( type === "number" && !jQuery.cssNumber[ origName ] ) { // 6702 value += "px"; // 6703 } // 6704 // 6705 // Fixes #8908, it can be done more correctly by specifing setters in cssHooks, // 6706 // but it would mean to define eight (for every problematic property) identical functions // 6707 if ( !support.clearCloneStyle && value === "" && name.indexOf("background") === 0 ) { // 6708 style[ name ] = "inherit"; // 6709 } // 6710 // 6711 // If a hook was provided, use that value, otherwise just set the specified value // 6712 if ( !hooks || !("set" in hooks) || (value = hooks.set( elem, value, extra )) !== undefined ) { // 6713 // 6714 // Support: IE // 6715 // Swallow errors from 'invalid' CSS values (#5509) // 6716 try { // 6717 style[ name ] = value; // 6718 } catch(e) {} // 6719 } // 6720 // 6721 } else { // 6722 // If a hook was provided get the non-computed value from there // 6723 if ( hooks && "get" in hooks && (ret = hooks.get( elem, false, extra )) !== undefined ) { // 6724 return ret; // 6725 } // 6726 // 6727 // Otherwise just get the value from the style object // 6728 return style[ name ]; // 6729 } // 6730 }, // 6731 // 6732 css: function( elem, name, extra, styles ) { // 6733 var num, val, hooks, // 6734 origName = jQuery.camelCase( name ); // 6735 // 6736 // Make sure that we're working with the right name // 6737 name = jQuery.cssProps[ origName ] || ( jQuery.cssProps[ origName ] = vendorPropName( elem.style, origName ) ); // 6738 // 6739 // gets hook for the prefixed version // 6740 // followed by the unprefixed version // 6741 hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ]; // 6742 // 6743 // If a hook was provided get the computed value from there // 6744 if ( hooks && "get" in hooks ) { // 6745 val = hooks.get( elem, true, extra ); // 6746 } // 6747 // 6748 // Otherwise, if a way to get the computed value exists, use that // 6749 if ( val === undefined ) { // 6750 val = curCSS( elem, name, styles ); // 6751 } // 6752 // 6753 //convert "normal" to computed value // 6754 if ( val === "normal" && name in cssNormalTransform ) { // 6755 val = cssNormalTransform[ name ]; // 6756 } // 6757 // 6758 // Return, converting to number if forced or a qualifier was provided and val looks numeric // 6759 if ( extra === "" || extra ) { // 6760 num = parseFloat( val ); // 6761 return extra === true || jQuery.isNumeric( num ) ? num || 0 : val; // 6762 } // 6763 return val; // 6764 } // 6765 }); // 6766 // 6767 jQuery.each([ "height", "width" ], function( i, name ) { // 6768 jQuery.cssHooks[ name ] = { // 6769 get: function( elem, computed, extra ) { // 6770 if ( computed ) { // 6771 // certain elements can have dimension info if we invisibly show them // 6772 // however, it must have a current display style that would benefit from this // 6773 return rdisplayswap.test( jQuery.css( elem, "display" ) ) && elem.offsetWidth === 0 ? // 6774 jQuery.swap( elem, cssShow, function() { // 6775 return getWidthOrHeight( elem, name, extra ); // 6776 }) : // 6777 getWidthOrHeight( elem, name, extra ); // 6778 } // 6779 }, // 6780 // 6781 set: function( elem, value, extra ) { // 6782 var styles = extra && getStyles( elem ); // 6783 return setPositiveNumber( elem, value, extra ? // 6784 augmentWidthOrHeight( // 6785 elem, // 6786 name, // 6787 extra, // 6788 support.boxSizing && jQuery.css( elem, "boxSizing", false, styles ) === "border-box", // 6789 styles // 6790 ) : 0 // 6791 ); // 6792 } // 6793 }; // 6794 }); // 6795 // 6796 if ( !support.opacity ) { // 6797 jQuery.cssHooks.opacity = { // 6798 get: function( elem, computed ) { // 6799 // IE uses filters for opacity // 6800 return ropacity.test( (computed && elem.currentStyle ? elem.currentStyle.filter : elem.style.filter) || "" ) ? // 6801 ( 0.01 * parseFloat( RegExp.$1 ) ) + "" : // 6802 computed ? "1" : ""; // 6803 }, // 6804 // 6805 set: function( elem, value ) { // 6806 var style = elem.style, // 6807 currentStyle = elem.currentStyle, // 6808 opacity = jQuery.isNumeric( value ) ? "alpha(opacity=" + value * 100 + ")" : "", // 6809 filter = currentStyle && currentStyle.filter || style.filter || ""; // 6810 // 6811 // IE has trouble with opacity if it does not have layout // 6812 // Force it by setting the zoom level // 6813 style.zoom = 1; // 6814 // 6815 // if setting opacity to 1, and no other filters exist - attempt to remove filter attribute #6652 // 6816 // if value === "", then remove inline opacity #12685 // 6817 if ( ( value >= 1 || value === "" ) && // 6818 jQuery.trim( filter.replace( ralpha, "" ) ) === "" && // 6819 style.removeAttribute ) { // 6820 // 6821 // Setting style.filter to null, "" & " " still leave "filter:" in the cssText // 6822 // if "filter:" is present at all, clearType is disabled, we want to avoid this // 6823 // style.removeAttribute is IE Only, but so apparently is this code path... // 6824 style.removeAttribute( "filter" ); // 6825 // 6826 // if there is no filter style applied in a css rule or unset inline opacity, we are done // 6827 if ( value === "" || currentStyle && !currentStyle.filter ) { // 6828 return; // 6829 } // 6830 } // 6831 // 6832 // otherwise, set new filter values // 6833 style.filter = ralpha.test( filter ) ? // 6834 filter.replace( ralpha, opacity ) : // 6835 filter + " " + opacity; // 6836 } // 6837 }; // 6838 } // 6839 // 6840 jQuery.cssHooks.marginRight = addGetHookIf( support.reliableMarginRight, // 6841 function( elem, computed ) { // 6842 if ( computed ) { // 6843 // WebKit Bug 13343 - getComputedStyle returns wrong value for margin-right // 6844 // Work around by temporarily setting element display to inline-block // 6845 return jQuery.swap( elem, { "display": "inline-block" }, // 6846 curCSS, [ elem, "marginRight" ] ); // 6847 } // 6848 } // 6849 ); // 6850 // 6851 // These hooks are used by animate to expand properties // 6852 jQuery.each({ // 6853 margin: "", // 6854 padding: "", // 6855 border: "Width" // 6856 }, function( prefix, suffix ) { // 6857 jQuery.cssHooks[ prefix + suffix ] = { // 6858 expand: function( value ) { // 6859 var i = 0, // 6860 expanded = {}, // 6861 // 6862 // assumes a single number if not a string // 6863 parts = typeof value === "string" ? value.split(" ") : [ value ]; // 6864 // 6865 for ( ; i < 4; i++ ) { // 6866 expanded[ prefix + cssExpand[ i ] + suffix ] = // 6867 parts[ i ] || parts[ i - 2 ] || parts[ 0 ]; // 6868 } // 6869 // 6870 return expanded; // 6871 } // 6872 }; // 6873 // 6874 if ( !rmargin.test( prefix ) ) { // 6875 jQuery.cssHooks[ prefix + suffix ].set = setPositiveNumber; // 6876 } // 6877 }); // 6878 // 6879 jQuery.fn.extend({ // 6880 css: function( name, value ) { // 6881 return access( this, function( elem, name, value ) { // 6882 var styles, len, // 6883 map = {}, // 6884 i = 0; // 6885 // 6886 if ( jQuery.isArray( name ) ) { // 6887 styles = getStyles( elem ); // 6888 len = name.length; // 6889 // 6890 for ( ; i < len; i++ ) { // 6891 map[ name[ i ] ] = jQuery.css( elem, name[ i ], false, styles ); // 6892 } // 6893 // 6894 return map; // 6895 } // 6896 // 6897 return value !== undefined ? // 6898 jQuery.style( elem, name, value ) : // 6899 jQuery.css( elem, name ); // 6900 }, name, value, arguments.length > 1 ); // 6901 }, // 6902 show: function() { // 6903 return showHide( this, true ); // 6904 }, // 6905 hide: function() { // 6906 return showHide( this ); // 6907 }, // 6908 toggle: function( state ) { // 6909 if ( typeof state === "boolean" ) { // 6910 return state ? this.show() : this.hide(); // 6911 } // 6912 // 6913 return this.each(function() { // 6914 if ( isHidden( this ) ) { // 6915 jQuery( this ).show(); // 6916 } else { // 6917 jQuery( this ).hide(); // 6918 } // 6919 }); // 6920 } // 6921 }); // 6922 // 6923 // 6924 function Tween( elem, options, prop, end, easing ) { // 6925 return new Tween.prototype.init( elem, options, prop, end, easing ); // 6926 } // 6927 jQuery.Tween = Tween; // 6928 // 6929 Tween.prototype = { // 6930 constructor: Tween, // 6931 init: function( elem, options, prop, end, easing, unit ) { // 6932 this.elem = elem; // 6933 this.prop = prop; // 6934 this.easing = easing || "swing"; // 6935 this.options = options; // 6936 this.start = this.now = this.cur(); // 6937 this.end = end; // 6938 this.unit = unit || ( jQuery.cssNumber[ prop ] ? "" : "px" ); // 6939 }, // 6940 cur: function() { // 6941 var hooks = Tween.propHooks[ this.prop ]; // 6942 // 6943 return hooks && hooks.get ? // 6944 hooks.get( this ) : // 6945 Tween.propHooks._default.get( this ); // 6946 }, // 6947 run: function( percent ) { // 6948 var eased, // 6949 hooks = Tween.propHooks[ this.prop ]; // 6950 // 6951 if ( this.options.duration ) { // 6952 this.pos = eased = jQuery.easing[ this.easing ]( // 6953 percent, this.options.duration * percent, 0, 1, this.options.duration // 6954 ); // 6955 } else { // 6956 this.pos = eased = percent; // 6957 } // 6958 this.now = ( this.end - this.start ) * eased + this.start; // 6959 // 6960 if ( this.options.step ) { // 6961 this.options.step.call( this.elem, this.now, this ); // 6962 } // 6963 // 6964 if ( hooks && hooks.set ) { // 6965 hooks.set( this ); // 6966 } else { // 6967 Tween.propHooks._default.set( this ); // 6968 } // 6969 return this; // 6970 } // 6971 }; // 6972 // 6973 Tween.prototype.init.prototype = Tween.prototype; // 6974 // 6975 Tween.propHooks = { // 6976 _default: { // 6977 get: function( tween ) { // 6978 var result; // 6979 // 6980 if ( tween.elem[ tween.prop ] != null && // 6981 (!tween.elem.style || tween.elem.style[ tween.prop ] == null) ) { // 6982 return tween.elem[ tween.prop ]; // 6983 } // 6984 // 6985 // passing an empty string as a 3rd parameter to .css will automatically // 6986 // attempt a parseFloat and fallback to a string if the parse fails // 6987 // so, simple values such as "10px" are parsed to Float. // 6988 // complex values such as "rotate(1rad)" are returned as is. // 6989 result = jQuery.css( tween.elem, tween.prop, "" ); // 6990 // Empty strings, null, undefined and "auto" are converted to 0. // 6991 return !result || result === "auto" ? 0 : result; // 6992 }, // 6993 set: function( tween ) { // 6994 // use step hook for back compat - use cssHook if its there - use .style if its // 6995 // available and use plain properties where available // 6996 if ( jQuery.fx.step[ tween.prop ] ) { // 6997 jQuery.fx.step[ tween.prop ]( tween ); // 6998 } else if ( tween.elem.style && ( tween.elem.style[ jQuery.cssProps[ tween.prop ] ] != null || jQuery.cssHooks[ tween.prop ] ) ) { jQuery.style( tween.elem, tween.prop, tween.now + tween.unit ); // 7000 } else { // 7001 tween.elem[ tween.prop ] = tween.now; // 7002 } // 7003 } // 7004 } // 7005 }; // 7006 // 7007 // Support: IE <=9 // 7008 // Panic based approach to setting things on disconnected nodes // 7009 // 7010 Tween.propHooks.scrollTop = Tween.propHooks.scrollLeft = { // 7011 set: function( tween ) { // 7012 if ( tween.elem.nodeType && tween.elem.parentNode ) { // 7013 tween.elem[ tween.prop ] = tween.now; // 7014 } // 7015 } // 7016 }; // 7017 // 7018 jQuery.easing = { // 7019 linear: function( p ) { // 7020 return p; // 7021 }, // 7022 swing: function( p ) { // 7023 return 0.5 - Math.cos( p * Math.PI ) / 2; // 7024 } // 7025 }; // 7026 // 7027 jQuery.fx = Tween.prototype.init; // 7028 // 7029 // Back Compat <1.8 extension point // 7030 jQuery.fx.step = {}; // 7031 // 7032 // 7033 // 7034 // 7035 var // 7036 fxNow, timerId, // 7037 rfxtypes = /^(?:toggle|show|hide)$/, // 7038 rfxnum = new RegExp( "^(?:([+-])=|)(" + pnum + ")([a-z%]*)$", "i" ), // 7039 rrun = /queueHooks$/, // 7040 animationPrefilters = [ defaultPrefilter ], // 7041 tweeners = { // 7042 "*": [ function( prop, value ) { // 7043 var tween = this.createTween( prop, value ), // 7044 target = tween.cur(), // 7045 parts = rfxnum.exec( value ), // 7046 unit = parts && parts[ 3 ] || ( jQuery.cssNumber[ prop ] ? "" : "px" ), // 7047 // 7048 // Starting value computation is required for potential unit mismatches // 7049 start = ( jQuery.cssNumber[ prop ] || unit !== "px" && +target ) && // 7050 rfxnum.exec( jQuery.css( tween.elem, prop ) ), // 7051 scale = 1, // 7052 maxIterations = 20; // 7053 // 7054 if ( start && start[ 3 ] !== unit ) { // 7055 // Trust units reported by jQuery.css // 7056 unit = unit || start[ 3 ]; // 7057 // 7058 // Make sure we update the tween properties later on // 7059 parts = parts || []; // 7060 // 7061 // Iteratively approximate from a nonzero starting point // 7062 start = +target || 1; // 7063 // 7064 do { // 7065 // If previous iteration zeroed out, double until we get *something* // 7066 // Use a string for doubling factor so we don't accidentally see scale as unchanged below // 7067 scale = scale || ".5"; // 7068 // 7069 // Adjust and apply // 7070 start = start / scale; // 7071 jQuery.style( tween.elem, prop, start + unit ); // 7072 // 7073 // Update scale, tolerating zero or NaN from tween.cur() // 7074 // And breaking the loop if scale is unchanged or perfect, or if we've just had enough // 7075 } while ( scale !== (scale = tween.cur() / target) && scale !== 1 && --maxIterations ); // 7076 } // 7077 // 7078 // Update tween properties // 7079 if ( parts ) { // 7080 start = tween.start = +start || +target || 0; // 7081 tween.unit = unit; // 7082 // If a +=/-= token was provided, we're doing a relative animation // 7083 tween.end = parts[ 1 ] ? // 7084 start + ( parts[ 1 ] + 1 ) * parts[ 2 ] : // 7085 +parts[ 2 ]; // 7086 } // 7087 // 7088 return tween; // 7089 } ] // 7090 }; // 7091 // 7092 // Animations created synchronously will run synchronously // 7093 function createFxNow() { // 7094 setTimeout(function() { // 7095 fxNow = undefined; // 7096 }); // 7097 return ( fxNow = jQuery.now() ); // 7098 } // 7099 // 7100 // Generate parameters to create a standard animation // 7101 function genFx( type, includeWidth ) { // 7102 var which, // 7103 attrs = { height: type }, // 7104 i = 0; // 7105 // 7106 // if we include width, step value is 1 to do all cssExpand values, // 7107 // if we don't include width, step value is 2 to skip over Left and Right // 7108 includeWidth = includeWidth ? 1 : 0; // 7109 for ( ; i < 4 ; i += 2 - includeWidth ) { // 7110 which = cssExpand[ i ]; // 7111 attrs[ "margin" + which ] = attrs[ "padding" + which ] = type; // 7112 } // 7113 // 7114 if ( includeWidth ) { // 7115 attrs.opacity = attrs.width = type; // 7116 } // 7117 // 7118 return attrs; // 7119 } // 7120 // 7121 function createTween( value, prop, animation ) { // 7122 var tween, // 7123 collection = ( tweeners[ prop ] || [] ).concat( tweeners[ "*" ] ), // 7124 index = 0, // 7125 length = collection.length; // 7126 for ( ; index < length; index++ ) { // 7127 if ( (tween = collection[ index ].call( animation, prop, value )) ) { // 7128 // 7129 // we're done with this property // 7130 return tween; // 7131 } // 7132 } // 7133 } // 7134 // 7135 function defaultPrefilter( elem, props, opts ) { // 7136 /* jshint validthis: true */ // 7137 var prop, value, toggle, tween, hooks, oldfire, display, checkDisplay, // 7138 anim = this, // 7139 orig = {}, // 7140 style = elem.style, // 7141 hidden = elem.nodeType && isHidden( elem ), // 7142 dataShow = jQuery._data( elem, "fxshow" ); // 7143 // 7144 // handle queue: false promises // 7145 if ( !opts.queue ) { // 7146 hooks = jQuery._queueHooks( elem, "fx" ); // 7147 if ( hooks.unqueued == null ) { // 7148 hooks.unqueued = 0; // 7149 oldfire = hooks.empty.fire; // 7150 hooks.empty.fire = function() { // 7151 if ( !hooks.unqueued ) { // 7152 oldfire(); // 7153 } // 7154 }; // 7155 } // 7156 hooks.unqueued++; // 7157 // 7158 anim.always(function() { // 7159 // doing this makes sure that the complete handler will be called // 7160 // before this completes // 7161 anim.always(function() { // 7162 hooks.unqueued--; // 7163 if ( !jQuery.queue( elem, "fx" ).length ) { // 7164 hooks.empty.fire(); // 7165 } // 7166 }); // 7167 }); // 7168 } // 7169 // 7170 // height/width overflow pass // 7171 if ( elem.nodeType === 1 && ( "height" in props || "width" in props ) ) { // 7172 // Make sure that nothing sneaks out // 7173 // Record all 3 overflow attributes because IE does not // 7174 // change the overflow attribute when overflowX and // 7175 // overflowY are set to the same value // 7176 opts.overflow = [ style.overflow, style.overflowX, style.overflowY ]; // 7177 // 7178 // Set display property to inline-block for height/width // 7179 // animations on inline elements that are having width/height animated // 7180 display = jQuery.css( elem, "display" ); // 7181 // 7182 // Test default display if display is currently "none" // 7183 checkDisplay = display === "none" ? // 7184 jQuery._data( elem, "olddisplay" ) || defaultDisplay( elem.nodeName ) : display; // 7185 // 7186 if ( checkDisplay === "inline" && jQuery.css( elem, "float" ) === "none" ) { // 7187 // 7188 // inline-level elements accept inline-block; // 7189 // block-level elements need to be inline with layout // 7190 if ( !support.inlineBlockNeedsLayout || defaultDisplay( elem.nodeName ) === "inline" ) { // 7191 style.display = "inline-block"; // 7192 } else { // 7193 style.zoom = 1; // 7194 } // 7195 } // 7196 } // 7197 // 7198 if ( opts.overflow ) { // 7199 style.overflow = "hidden"; // 7200 if ( !support.shrinkWrapBlocks() ) { // 7201 anim.always(function() { // 7202 style.overflow = opts.overflow[ 0 ]; // 7203 style.overflowX = opts.overflow[ 1 ]; // 7204 style.overflowY = opts.overflow[ 2 ]; // 7205 }); // 7206 } // 7207 } // 7208 // 7209 // show/hide pass // 7210 for ( prop in props ) { // 7211 value = props[ prop ]; // 7212 if ( rfxtypes.exec( value ) ) { // 7213 delete props[ prop ]; // 7214 toggle = toggle || value === "toggle"; // 7215 if ( value === ( hidden ? "hide" : "show" ) ) { // 7216 // 7217 // If there is dataShow left over from a stopped hide or show and we are going to proceed with show, we should pretend to be hidden if ( value === "show" && dataShow && dataShow[ prop ] !== undefined ) { // 7219 hidden = true; // 7220 } else { // 7221 continue; // 7222 } // 7223 } // 7224 orig[ prop ] = dataShow && dataShow[ prop ] || jQuery.style( elem, prop ); // 7225 // 7226 // Any non-fx value stops us from restoring the original display value // 7227 } else { // 7228 display = undefined; // 7229 } // 7230 } // 7231 // 7232 if ( !jQuery.isEmptyObject( orig ) ) { // 7233 if ( dataShow ) { // 7234 if ( "hidden" in dataShow ) { // 7235 hidden = dataShow.hidden; // 7236 } // 7237 } else { // 7238 dataShow = jQuery._data( elem, "fxshow", {} ); // 7239 } // 7240 // 7241 // store state if its toggle - enables .stop().toggle() to "reverse" // 7242 if ( toggle ) { // 7243 dataShow.hidden = !hidden; // 7244 } // 7245 if ( hidden ) { // 7246 jQuery( elem ).show(); // 7247 } else { // 7248 anim.done(function() { // 7249 jQuery( elem ).hide(); // 7250 }); // 7251 } // 7252 anim.done(function() { // 7253 var prop; // 7254 jQuery._removeData( elem, "fxshow" ); // 7255 for ( prop in orig ) { // 7256 jQuery.style( elem, prop, orig[ prop ] ); // 7257 } // 7258 }); // 7259 for ( prop in orig ) { // 7260 tween = createTween( hidden ? dataShow[ prop ] : 0, prop, anim ); // 7261 // 7262 if ( !( prop in dataShow ) ) { // 7263 dataShow[ prop ] = tween.start; // 7264 if ( hidden ) { // 7265 tween.end = tween.start; // 7266 tween.start = prop === "width" || prop === "height" ? 1 : 0; // 7267 } // 7268 } // 7269 } // 7270 // 7271 // If this is a noop like .hide().hide(), restore an overwritten display value // 7272 } else if ( (display === "none" ? defaultDisplay( elem.nodeName ) : display) === "inline" ) { // 7273 style.display = display; // 7274 } // 7275 } // 7276 // 7277 function propFilter( props, specialEasing ) { // 7278 var index, name, easing, value, hooks; // 7279 // 7280 // camelCase, specialEasing and expand cssHook pass // 7281 for ( index in props ) { // 7282 name = jQuery.camelCase( index ); // 7283 easing = specialEasing[ name ]; // 7284 value = props[ index ]; // 7285 if ( jQuery.isArray( value ) ) { // 7286 easing = value[ 1 ]; // 7287 value = props[ index ] = value[ 0 ]; // 7288 } // 7289 // 7290 if ( index !== name ) { // 7291 props[ name ] = value; // 7292 delete props[ index ]; // 7293 } // 7294 // 7295 hooks = jQuery.cssHooks[ name ]; // 7296 if ( hooks && "expand" in hooks ) { // 7297 value = hooks.expand( value ); // 7298 delete props[ name ]; // 7299 // 7300 // not quite $.extend, this wont overwrite keys already present. // 7301 // also - reusing 'index' from above because we have the correct "name" // 7302 for ( index in value ) { // 7303 if ( !( index in props ) ) { // 7304 props[ index ] = value[ index ]; // 7305 specialEasing[ index ] = easing; // 7306 } // 7307 } // 7308 } else { // 7309 specialEasing[ name ] = easing; // 7310 } // 7311 } // 7312 } // 7313 // 7314 function Animation( elem, properties, options ) { // 7315 var result, // 7316 stopped, // 7317 index = 0, // 7318 length = animationPrefilters.length, // 7319 deferred = jQuery.Deferred().always( function() { // 7320 // don't match elem in the :animated selector // 7321 delete tick.elem; // 7322 }), // 7323 tick = function() { // 7324 if ( stopped ) { // 7325 return false; // 7326 } // 7327 var currentTime = fxNow || createFxNow(), // 7328 remaining = Math.max( 0, animation.startTime + animation.duration - currentTime ), // 7329 // archaic crash bug won't allow us to use 1 - ( 0.5 || 0 ) (#12497) // 7330 temp = remaining / animation.duration || 0, // 7331 percent = 1 - temp, // 7332 index = 0, // 7333 length = animation.tweens.length; // 7334 // 7335 for ( ; index < length ; index++ ) { // 7336 animation.tweens[ index ].run( percent ); // 7337 } // 7338 // 7339 deferred.notifyWith( elem, [ animation, percent, remaining ]); // 7340 // 7341 if ( percent < 1 && length ) { // 7342 return remaining; // 7343 } else { // 7344 deferred.resolveWith( elem, [ animation ] ); // 7345 return false; // 7346 } // 7347 }, // 7348 animation = deferred.promise({ // 7349 elem: elem, // 7350 props: jQuery.extend( {}, properties ), // 7351 opts: jQuery.extend( true, { specialEasing: {} }, options ), // 7352 originalProperties: properties, // 7353 originalOptions: options, // 7354 startTime: fxNow || createFxNow(), // 7355 duration: options.duration, // 7356 tweens: [], // 7357 createTween: function( prop, end ) { // 7358 var tween = jQuery.Tween( elem, animation.opts, prop, end, // 7359 animation.opts.specialEasing[ prop ] || animation.opts.easing ); // 7360 animation.tweens.push( tween ); // 7361 return tween; // 7362 }, // 7363 stop: function( gotoEnd ) { // 7364 var index = 0, // 7365 // if we are going to the end, we want to run all the tweens // 7366 // otherwise we skip this part // 7367 length = gotoEnd ? animation.tweens.length : 0; // 7368 if ( stopped ) { // 7369 return this; // 7370 } // 7371 stopped = true; // 7372 for ( ; index < length ; index++ ) { // 7373 animation.tweens[ index ].run( 1 ); // 7374 } // 7375 // 7376 // resolve when we played the last frame // 7377 // otherwise, reject // 7378 if ( gotoEnd ) { // 7379 deferred.resolveWith( elem, [ animation, gotoEnd ] ); // 7380 } else { // 7381 deferred.rejectWith( elem, [ animation, gotoEnd ] ); // 7382 } // 7383 return this; // 7384 } // 7385 }), // 7386 props = animation.props; // 7387 // 7388 propFilter( props, animation.opts.specialEasing ); // 7389 // 7390 for ( ; index < length ; index++ ) { // 7391 result = animationPrefilters[ index ].call( animation, elem, props, animation.opts ); // 7392 if ( result ) { // 7393 return result; // 7394 } // 7395 } // 7396 // 7397 jQuery.map( props, createTween, animation ); // 7398 // 7399 if ( jQuery.isFunction( animation.opts.start ) ) { // 7400 animation.opts.start.call( elem, animation ); // 7401 } // 7402 // 7403 jQuery.fx.timer( // 7404 jQuery.extend( tick, { // 7405 elem: elem, // 7406 anim: animation, // 7407 queue: animation.opts.queue // 7408 }) // 7409 ); // 7410 // 7411 // attach callbacks from options // 7412 return animation.progress( animation.opts.progress ) // 7413 .done( animation.opts.done, animation.opts.complete ) // 7414 .fail( animation.opts.fail ) // 7415 .always( animation.opts.always ); // 7416 } // 7417 // 7418 jQuery.Animation = jQuery.extend( Animation, { // 7419 tweener: function( props, callback ) { // 7420 if ( jQuery.isFunction( props ) ) { // 7421 callback = props; // 7422 props = [ "*" ]; // 7423 } else { // 7424 props = props.split(" "); // 7425 } // 7426 // 7427 var prop, // 7428 index = 0, // 7429 length = props.length; // 7430 // 7431 for ( ; index < length ; index++ ) { // 7432 prop = props[ index ]; // 7433 tweeners[ prop ] = tweeners[ prop ] || []; // 7434 tweeners[ prop ].unshift( callback ); // 7435 } // 7436 }, // 7437 // 7438 prefilter: function( callback, prepend ) { // 7439 if ( prepend ) { // 7440 animationPrefilters.unshift( callback ); // 7441 } else { // 7442 animationPrefilters.push( callback ); // 7443 } // 7444 } // 7445 }); // 7446 // 7447 jQuery.speed = function( speed, easing, fn ) { // 7448 var opt = speed && typeof speed === "object" ? jQuery.extend( {}, speed ) : { // 7449 complete: fn || !fn && easing || // 7450 jQuery.isFunction( speed ) && speed, // 7451 duration: speed, // 7452 easing: fn && easing || easing && !jQuery.isFunction( easing ) && easing // 7453 }; // 7454 // 7455 opt.duration = jQuery.fx.off ? 0 : typeof opt.duration === "number" ? opt.duration : // 7456 opt.duration in jQuery.fx.speeds ? jQuery.fx.speeds[ opt.duration ] : jQuery.fx.speeds._default; // 7457 // 7458 // normalize opt.queue - true/undefined/null -> "fx" // 7459 if ( opt.queue == null || opt.queue === true ) { // 7460 opt.queue = "fx"; // 7461 } // 7462 // 7463 // Queueing // 7464 opt.old = opt.complete; // 7465 // 7466 opt.complete = function() { // 7467 if ( jQuery.isFunction( opt.old ) ) { // 7468 opt.old.call( this ); // 7469 } // 7470 // 7471 if ( opt.queue ) { // 7472 jQuery.dequeue( this, opt.queue ); // 7473 } // 7474 }; // 7475 // 7476 return opt; // 7477 }; // 7478 // 7479 jQuery.fn.extend({ // 7480 fadeTo: function( speed, to, easing, callback ) { // 7481 // 7482 // show any hidden elements after setting opacity to 0 // 7483 return this.filter( isHidden ).css( "opacity", 0 ).show() // 7484 // 7485 // animate to the value specified // 7486 .end().animate({ opacity: to }, speed, easing, callback ); // 7487 }, // 7488 animate: function( prop, speed, easing, callback ) { // 7489 var empty = jQuery.isEmptyObject( prop ), // 7490 optall = jQuery.speed( speed, easing, callback ), // 7491 doAnimation = function() { // 7492 // Operate on a copy of prop so per-property easing won't be lost // 7493 var anim = Animation( this, jQuery.extend( {}, prop ), optall ); // 7494 // 7495 // Empty animations, or finishing resolves immediately // 7496 if ( empty || jQuery._data( this, "finish" ) ) { // 7497 anim.stop( true ); // 7498 } // 7499 }; // 7500 doAnimation.finish = doAnimation; // 7501 // 7502 return empty || optall.queue === false ? // 7503 this.each( doAnimation ) : // 7504 this.queue( optall.queue, doAnimation ); // 7505 }, // 7506 stop: function( type, clearQueue, gotoEnd ) { // 7507 var stopQueue = function( hooks ) { // 7508 var stop = hooks.stop; // 7509 delete hooks.stop; // 7510 stop( gotoEnd ); // 7511 }; // 7512 // 7513 if ( typeof type !== "string" ) { // 7514 gotoEnd = clearQueue; // 7515 clearQueue = type; // 7516 type = undefined; // 7517 } // 7518 if ( clearQueue && type !== false ) { // 7519 this.queue( type || "fx", [] ); // 7520 } // 7521 // 7522 return this.each(function() { // 7523 var dequeue = true, // 7524 index = type != null && type + "queueHooks", // 7525 timers = jQuery.timers, // 7526 data = jQuery._data( this ); // 7527 // 7528 if ( index ) { // 7529 if ( data[ index ] && data[ index ].stop ) { // 7530 stopQueue( data[ index ] ); // 7531 } // 7532 } else { // 7533 for ( index in data ) { // 7534 if ( data[ index ] && data[ index ].stop && rrun.test( index ) ) { // 7535 stopQueue( data[ index ] ); // 7536 } // 7537 } // 7538 } // 7539 // 7540 for ( index = timers.length; index--; ) { // 7541 if ( timers[ index ].elem === this && (type == null || timers[ index ].queue === type) ) { // 7542 timers[ index ].anim.stop( gotoEnd ); // 7543 dequeue = false; // 7544 timers.splice( index, 1 ); // 7545 } // 7546 } // 7547 // 7548 // start the next in the queue if the last step wasn't forced // 7549 // timers currently will call their complete callbacks, which will dequeue // 7550 // but only if they were gotoEnd // 7551 if ( dequeue || !gotoEnd ) { // 7552 jQuery.dequeue( this, type ); // 7553 } // 7554 }); // 7555 }, // 7556 finish: function( type ) { // 7557 if ( type !== false ) { // 7558 type = type || "fx"; // 7559 } // 7560 return this.each(function() { // 7561 var index, // 7562 data = jQuery._data( this ), // 7563 queue = data[ type + "queue" ], // 7564 hooks = data[ type + "queueHooks" ], // 7565 timers = jQuery.timers, // 7566 length = queue ? queue.length : 0; // 7567 // 7568 // enable finishing flag on private data // 7569 data.finish = true; // 7570 // 7571 // empty the queue first // 7572 jQuery.queue( this, type, [] ); // 7573 // 7574 if ( hooks && hooks.stop ) { // 7575 hooks.stop.call( this, true ); // 7576 } // 7577 // 7578 // look for any active animations, and finish them // 7579 for ( index = timers.length; index--; ) { // 7580 if ( timers[ index ].elem === this && timers[ index ].queue === type ) { // 7581 timers[ index ].anim.stop( true ); // 7582 timers.splice( index, 1 ); // 7583 } // 7584 } // 7585 // 7586 // look for any animations in the old queue and finish them // 7587 for ( index = 0; index < length; index++ ) { // 7588 if ( queue[ index ] && queue[ index ].finish ) { // 7589 queue[ index ].finish.call( this ); // 7590 } // 7591 } // 7592 // 7593 // turn off finishing flag // 7594 delete data.finish; // 7595 }); // 7596 } // 7597 }); // 7598 // 7599 jQuery.each([ "toggle", "show", "hide" ], function( i, name ) { // 7600 var cssFn = jQuery.fn[ name ]; // 7601 jQuery.fn[ name ] = function( speed, easing, callback ) { // 7602 return speed == null || typeof speed === "boolean" ? // 7603 cssFn.apply( this, arguments ) : // 7604 this.animate( genFx( name, true ), speed, easing, callback ); // 7605 }; // 7606 }); // 7607 // 7608 // Generate shortcuts for custom animations // 7609 jQuery.each({ // 7610 slideDown: genFx("show"), // 7611 slideUp: genFx("hide"), // 7612 slideToggle: genFx("toggle"), // 7613 fadeIn: { opacity: "show" }, // 7614 fadeOut: { opacity: "hide" }, // 7615 fadeToggle: { opacity: "toggle" } // 7616 }, function( name, props ) { // 7617 jQuery.fn[ name ] = function( speed, easing, callback ) { // 7618 return this.animate( props, speed, easing, callback ); // 7619 }; // 7620 }); // 7621 // 7622 jQuery.timers = []; // 7623 jQuery.fx.tick = function() { // 7624 var timer, // 7625 timers = jQuery.timers, // 7626 i = 0; // 7627 // 7628 fxNow = jQuery.now(); // 7629 // 7630 for ( ; i < timers.length; i++ ) { // 7631 timer = timers[ i ]; // 7632 // Checks the timer has not already been removed // 7633 if ( !timer() && timers[ i ] === timer ) { // 7634 timers.splice( i--, 1 ); // 7635 } // 7636 } // 7637 // 7638 if ( !timers.length ) { // 7639 jQuery.fx.stop(); // 7640 } // 7641 fxNow = undefined; // 7642 }; // 7643 // 7644 jQuery.fx.timer = function( timer ) { // 7645 jQuery.timers.push( timer ); // 7646 if ( timer() ) { // 7647 jQuery.fx.start(); // 7648 } else { // 7649 jQuery.timers.pop(); // 7650 } // 7651 }; // 7652 // 7653 jQuery.fx.interval = 13; // 7654 // 7655 jQuery.fx.start = function() { // 7656 if ( !timerId ) { // 7657 timerId = setInterval( jQuery.fx.tick, jQuery.fx.interval ); // 7658 } // 7659 }; // 7660 // 7661 jQuery.fx.stop = function() { // 7662 clearInterval( timerId ); // 7663 timerId = null; // 7664 }; // 7665 // 7666 jQuery.fx.speeds = { // 7667 slow: 600, // 7668 fast: 200, // 7669 // Default speed // 7670 _default: 400 // 7671 }; // 7672 // 7673 // 7674 // Based off of the plugin by Clint Helfers, with permission. // 7675 // http://blindsignals.com/index.php/2009/07/jquery-delay/ // 7676 jQuery.fn.delay = function( time, type ) { // 7677 time = jQuery.fx ? jQuery.fx.speeds[ time ] || time : time; // 7678 type = type || "fx"; // 7679 // 7680 return this.queue( type, function( next, hooks ) { // 7681 var timeout = setTimeout( next, time ); // 7682 hooks.stop = function() { // 7683 clearTimeout( timeout ); // 7684 }; // 7685 }); // 7686 }; // 7687 // 7688 // 7689 (function() { // 7690 // Minified: var a,b,c,d,e // 7691 var input, div, select, a, opt; // 7692 // 7693 // Setup // 7694 div = document.createElement( "div" ); // 7695 div.setAttribute( "className", "t" ); // 7696 div.innerHTML = " <link/><table></table><a href='/a'>a</a><input type='checkbox'/>"; // 7697 a = div.getElementsByTagName("a")[ 0 ]; // 7698 // 7699 // First batch of tests. // 7700 select = document.createElement("select"); // 7701 opt = select.appendChild( document.createElement("option") ); // 7702 input = div.getElementsByTagName("input")[ 0 ]; // 7703 // 7704 a.style.cssText = "top:1px"; // 7705 // 7706 // Test setAttribute on camelCase class. If it works, we need attrFixes when doing get/setAttribute (ie6/7) // 7707 support.getSetAttribute = div.className !== "t"; // 7708 // 7709 // Get the style information from getAttribute // 7710 // (IE uses .cssText instead) // 7711 support.style = /top/.test( a.getAttribute("style") ); // 7712 // 7713 // Make sure that URLs aren't manipulated // 7714 // (IE normalizes it by default) // 7715 support.hrefNormalized = a.getAttribute("href") === "/a"; // 7716 // 7717 // Check the default checkbox/radio value ("" on WebKit; "on" elsewhere) // 7718 support.checkOn = !!input.value; // 7719 // 7720 // Make sure that a selected-by-default option has a working selected property. // 7721 // (WebKit defaults to false instead of true, IE too, if it's in an optgroup) // 7722 support.optSelected = opt.selected; // 7723 // 7724 // Tests for enctype support on a form (#6743) // 7725 support.enctype = !!document.createElement("form").enctype; // 7726 // 7727 // Make sure that the options inside disabled selects aren't marked as disabled // 7728 // (WebKit marks them as disabled) // 7729 select.disabled = true; // 7730 support.optDisabled = !opt.disabled; // 7731 // 7732 // Support: IE8 only // 7733 // Check if we can trust getAttribute("value") // 7734 input = document.createElement( "input" ); // 7735 input.setAttribute( "value", "" ); // 7736 support.input = input.getAttribute( "value" ) === ""; // 7737 // 7738 // Check if an input maintains its value after becoming a radio // 7739 input.value = "t"; // 7740 input.setAttribute( "type", "radio" ); // 7741 support.radioValue = input.value === "t"; // 7742 })(); // 7743 // 7744 // 7745 var rreturn = /\r/g; // 7746 // 7747 jQuery.fn.extend({ // 7748 val: function( value ) { // 7749 var hooks, ret, isFunction, // 7750 elem = this[0]; // 7751 // 7752 if ( !arguments.length ) { // 7753 if ( elem ) { // 7754 hooks = jQuery.valHooks[ elem.type ] || jQuery.valHooks[ elem.nodeName.toLowerCase() ]; // 7755 // 7756 if ( hooks && "get" in hooks && (ret = hooks.get( elem, "value" )) !== undefined ) { // 7757 return ret; // 7758 } // 7759 // 7760 ret = elem.value; // 7761 // 7762 return typeof ret === "string" ? // 7763 // handle most common string cases // 7764 ret.replace(rreturn, "") : // 7765 // handle cases where value is null/undef or number // 7766 ret == null ? "" : ret; // 7767 } // 7768 // 7769 return; // 7770 } // 7771 // 7772 isFunction = jQuery.isFunction( value ); // 7773 // 7774 return this.each(function( i ) { // 7775 var val; // 7776 // 7777 if ( this.nodeType !== 1 ) { // 7778 return; // 7779 } // 7780 // 7781 if ( isFunction ) { // 7782 val = value.call( this, i, jQuery( this ).val() ); // 7783 } else { // 7784 val = value; // 7785 } // 7786 // 7787 // Treat null/undefined as ""; convert numbers to string // 7788 if ( val == null ) { // 7789 val = ""; // 7790 } else if ( typeof val === "number" ) { // 7791 val += ""; // 7792 } else if ( jQuery.isArray( val ) ) { // 7793 val = jQuery.map( val, function( value ) { // 7794 return value == null ? "" : value + ""; // 7795 }); // 7796 } // 7797 // 7798 hooks = jQuery.valHooks[ this.type ] || jQuery.valHooks[ this.nodeName.toLowerCase() ]; // 7799 // 7800 // If set returns undefined, fall back to normal setting // 7801 if ( !hooks || !("set" in hooks) || hooks.set( this, val, "value" ) === undefined ) { // 7802 this.value = val; // 7803 } // 7804 }); // 7805 } // 7806 }); // 7807 // 7808 jQuery.extend({ // 7809 valHooks: { // 7810 option: { // 7811 get: function( elem ) { // 7812 var val = jQuery.find.attr( elem, "value" ); // 7813 return val != null ? // 7814 val : // 7815 // Support: IE10-11+ // 7816 // option.text throws exceptions (#14686, #14858) // 7817 jQuery.trim( jQuery.text( elem ) ); // 7818 } // 7819 }, // 7820 select: { // 7821 get: function( elem ) { // 7822 var value, option, // 7823 options = elem.options, // 7824 index = elem.selectedIndex, // 7825 one = elem.type === "select-one" || index < 0, // 7826 values = one ? null : [], // 7827 max = one ? index + 1 : options.length, // 7828 i = index < 0 ? // 7829 max : // 7830 one ? index : 0; // 7831 // 7832 // Loop through all the selected options // 7833 for ( ; i < max; i++ ) { // 7834 option = options[ i ]; // 7835 // 7836 // oldIE doesn't update selected after form reset (#2551) // 7837 if ( ( option.selected || i === index ) && // 7838 // Don't return options that are disabled or in a disabled optgroup // 7839 ( support.optDisabled ? !option.disabled : option.getAttribute("disabled") === null ) && // 7840 ( !option.parentNode.disabled || !jQuery.nodeName( option.parentNode, "optgroup" ) ) ) { // 7841 // 7842 // Get the specific value for the option // 7843 value = jQuery( option ).val(); // 7844 // 7845 // We don't need an array for one selects // 7846 if ( one ) { // 7847 return value; // 7848 } // 7849 // 7850 // Multi-Selects return an array // 7851 values.push( value ); // 7852 } // 7853 } // 7854 // 7855 return values; // 7856 }, // 7857 // 7858 set: function( elem, value ) { // 7859 var optionSet, option, // 7860 options = elem.options, // 7861 values = jQuery.makeArray( value ), // 7862 i = options.length; // 7863 // 7864 while ( i-- ) { // 7865 option = options[ i ]; // 7866 // 7867 if ( jQuery.inArray( jQuery.valHooks.option.get( option ), values ) >= 0 ) { // 7868 // 7869 // Support: IE6 // 7870 // When new option element is added to select box we need to // 7871 // force reflow of newly added node in order to workaround delay // 7872 // of initialization properties // 7873 try { // 7874 option.selected = optionSet = true; // 7875 // 7876 } catch ( _ ) { // 7877 // 7878 // Will be executed only in IE6 // 7879 option.scrollHeight; // 7880 } // 7881 // 7882 } else { // 7883 option.selected = false; // 7884 } // 7885 } // 7886 // 7887 // Force browsers to behave consistently when non-matching value is set // 7888 if ( !optionSet ) { // 7889 elem.selectedIndex = -1; // 7890 } // 7891 // 7892 return options; // 7893 } // 7894 } // 7895 } // 7896 }); // 7897 // 7898 // Radios and checkboxes getter/setter // 7899 jQuery.each([ "radio", "checkbox" ], function() { // 7900 jQuery.valHooks[ this ] = { // 7901 set: function( elem, value ) { // 7902 if ( jQuery.isArray( value ) ) { // 7903 return ( elem.checked = jQuery.inArray( jQuery(elem).val(), value ) >= 0 ); // 7904 } // 7905 } // 7906 }; // 7907 if ( !support.checkOn ) { // 7908 jQuery.valHooks[ this ].get = function( elem ) { // 7909 // Support: Webkit // 7910 // "" is returned instead of "on" if a value isn't specified // 7911 return elem.getAttribute("value") === null ? "on" : elem.value; // 7912 }; // 7913 } // 7914 }); // 7915 // 7916 // 7917 // 7918 // 7919 var nodeHook, boolHook, // 7920 attrHandle = jQuery.expr.attrHandle, // 7921 ruseDefault = /^(?:checked|selected)$/i, // 7922 getSetAttribute = support.getSetAttribute, // 7923 getSetInput = support.input; // 7924 // 7925 jQuery.fn.extend({ // 7926 attr: function( name, value ) { // 7927 return access( this, jQuery.attr, name, value, arguments.length > 1 ); // 7928 }, // 7929 // 7930 removeAttr: function( name ) { // 7931 return this.each(function() { // 7932 jQuery.removeAttr( this, name ); // 7933 }); // 7934 } // 7935 }); // 7936 // 7937 jQuery.extend({ // 7938 attr: function( elem, name, value ) { // 7939 var hooks, ret, // 7940 nType = elem.nodeType; // 7941 // 7942 // don't get/set attributes on text, comment and attribute nodes // 7943 if ( !elem || nType === 3 || nType === 8 || nType === 2 ) { // 7944 return; // 7945 } // 7946 // 7947 // Fallback to prop when attributes are not supported // 7948 if ( typeof elem.getAttribute === strundefined ) { // 7949 return jQuery.prop( elem, name, value ); // 7950 } // 7951 // 7952 // All attributes are lowercase // 7953 // Grab necessary hook if one is defined // 7954 if ( nType !== 1 || !jQuery.isXMLDoc( elem ) ) { // 7955 name = name.toLowerCase(); // 7956 hooks = jQuery.attrHooks[ name ] || // 7957 ( jQuery.expr.match.bool.test( name ) ? boolHook : nodeHook ); // 7958 } // 7959 // 7960 if ( value !== undefined ) { // 7961 // 7962 if ( value === null ) { // 7963 jQuery.removeAttr( elem, name ); // 7964 // 7965 } else if ( hooks && "set" in hooks && (ret = hooks.set( elem, value, name )) !== undefined ) { // 7966 return ret; // 7967 // 7968 } else { // 7969 elem.setAttribute( name, value + "" ); // 7970 return value; // 7971 } // 7972 // 7973 } else if ( hooks && "get" in hooks && (ret = hooks.get( elem, name )) !== null ) { // 7974 return ret; // 7975 // 7976 } else { // 7977 ret = jQuery.find.attr( elem, name ); // 7978 // 7979 // Non-existent attributes return null, we normalize to undefined // 7980 return ret == null ? // 7981 undefined : // 7982 ret; // 7983 } // 7984 }, // 7985 // 7986 removeAttr: function( elem, value ) { // 7987 var name, propName, // 7988 i = 0, // 7989 attrNames = value && value.match( rnotwhite ); // 7990 // 7991 if ( attrNames && elem.nodeType === 1 ) { // 7992 while ( (name = attrNames[i++]) ) { // 7993 propName = jQuery.propFix[ name ] || name; // 7994 // 7995 // Boolean attributes get special treatment (#10870) // 7996 if ( jQuery.expr.match.bool.test( name ) ) { // 7997 // Set corresponding property to false // 7998 if ( getSetInput && getSetAttribute || !ruseDefault.test( name ) ) { // 7999 elem[ propName ] = false; // 8000 // Support: IE<9 // 8001 // Also clear defaultChecked/defaultSelected (if appropriate) // 8002 } else { // 8003 elem[ jQuery.camelCase( "default-" + name ) ] = // 8004 elem[ propName ] = false; // 8005 } // 8006 // 8007 // See #9699 for explanation of this approach (setting first, then removal) // 8008 } else { // 8009 jQuery.attr( elem, name, "" ); // 8010 } // 8011 // 8012 elem.removeAttribute( getSetAttribute ? name : propName ); // 8013 } // 8014 } // 8015 }, // 8016 // 8017 attrHooks: { // 8018 type: { // 8019 set: function( elem, value ) { // 8020 if ( !support.radioValue && value === "radio" && jQuery.nodeName(elem, "input") ) { // 8021 // Setting the type on a radio button after the value resets the value in IE6-9 // 8022 // Reset value to default in case type is set after value during creation // 8023 var val = elem.value; // 8024 elem.setAttribute( "type", value ); // 8025 if ( val ) { // 8026 elem.value = val; // 8027 } // 8028 return value; // 8029 } // 8030 } // 8031 } // 8032 } // 8033 }); // 8034 // 8035 // Hook for boolean attributes // 8036 boolHook = { // 8037 set: function( elem, value, name ) { // 8038 if ( value === false ) { // 8039 // Remove boolean attributes when set to false // 8040 jQuery.removeAttr( elem, name ); // 8041 } else if ( getSetInput && getSetAttribute || !ruseDefault.test( name ) ) { // 8042 // IE<8 needs the *property* name // 8043 elem.setAttribute( !getSetAttribute && jQuery.propFix[ name ] || name, name ); // 8044 // 8045 // Use defaultChecked and defaultSelected for oldIE // 8046 } else { // 8047 elem[ jQuery.camelCase( "default-" + name ) ] = elem[ name ] = true; // 8048 } // 8049 // 8050 return name; // 8051 } // 8052 }; // 8053 // 8054 // Retrieve booleans specially // 8055 jQuery.each( jQuery.expr.match.bool.source.match( /\w+/g ), function( i, name ) { // 8056 // 8057 var getter = attrHandle[ name ] || jQuery.find.attr; // 8058 // 8059 attrHandle[ name ] = getSetInput && getSetAttribute || !ruseDefault.test( name ) ? // 8060 function( elem, name, isXML ) { // 8061 var ret, handle; // 8062 if ( !isXML ) { // 8063 // Avoid an infinite loop by temporarily removing this function from the getter // 8064 handle = attrHandle[ name ]; // 8065 attrHandle[ name ] = ret; // 8066 ret = getter( elem, name, isXML ) != null ? // 8067 name.toLowerCase() : // 8068 null; // 8069 attrHandle[ name ] = handle; // 8070 } // 8071 return ret; // 8072 } : // 8073 function( elem, name, isXML ) { // 8074 if ( !isXML ) { // 8075 return elem[ jQuery.camelCase( "default-" + name ) ] ? // 8076 name.toLowerCase() : // 8077 null; // 8078 } // 8079 }; // 8080 }); // 8081 // 8082 // fix oldIE attroperties // 8083 if ( !getSetInput || !getSetAttribute ) { // 8084 jQuery.attrHooks.value = { // 8085 set: function( elem, value, name ) { // 8086 if ( jQuery.nodeName( elem, "input" ) ) { // 8087 // Does not return so that setAttribute is also used // 8088 elem.defaultValue = value; // 8089 } else { // 8090 // Use nodeHook if defined (#1954); otherwise setAttribute is fine // 8091 return nodeHook && nodeHook.set( elem, value, name ); // 8092 } // 8093 } // 8094 }; // 8095 } // 8096 // 8097 // IE6/7 do not support getting/setting some attributes with get/setAttribute // 8098 if ( !getSetAttribute ) { // 8099 // 8100 // Use this for any attribute in IE6/7 // 8101 // This fixes almost every IE6/7 issue // 8102 nodeHook = { // 8103 set: function( elem, value, name ) { // 8104 // Set the existing or create a new attribute node // 8105 var ret = elem.getAttributeNode( name ); // 8106 if ( !ret ) { // 8107 elem.setAttributeNode( // 8108 (ret = elem.ownerDocument.createAttribute( name )) // 8109 ); // 8110 } // 8111 // 8112 ret.value = value += ""; // 8113 // 8114 // Break association with cloned elements by also using setAttribute (#9646) // 8115 if ( name === "value" || value === elem.getAttribute( name ) ) { // 8116 return value; // 8117 } // 8118 } // 8119 }; // 8120 // 8121 // Some attributes are constructed with empty-string values when not defined // 8122 attrHandle.id = attrHandle.name = attrHandle.coords = // 8123 function( elem, name, isXML ) { // 8124 var ret; // 8125 if ( !isXML ) { // 8126 return (ret = elem.getAttributeNode( name )) && ret.value !== "" ? // 8127 ret.value : // 8128 null; // 8129 } // 8130 }; // 8131 // 8132 // Fixing value retrieval on a button requires this module // 8133 jQuery.valHooks.button = { // 8134 get: function( elem, name ) { // 8135 var ret = elem.getAttributeNode( name ); // 8136 if ( ret && ret.specified ) { // 8137 return ret.value; // 8138 } // 8139 }, // 8140 set: nodeHook.set // 8141 }; // 8142 // 8143 // Set contenteditable to false on removals(#10429) // 8144 // Setting to empty string throws an error as an invalid value // 8145 jQuery.attrHooks.contenteditable = { // 8146 set: function( elem, value, name ) { // 8147 nodeHook.set( elem, value === "" ? false : value, name ); // 8148 } // 8149 }; // 8150 // 8151 // Set width and height to auto instead of 0 on empty string( Bug #8150 ) // 8152 // This is for removals // 8153 jQuery.each([ "width", "height" ], function( i, name ) { // 8154 jQuery.attrHooks[ name ] = { // 8155 set: function( elem, value ) { // 8156 if ( value === "" ) { // 8157 elem.setAttribute( name, "auto" ); // 8158 return value; // 8159 } // 8160 } // 8161 }; // 8162 }); // 8163 } // 8164 // 8165 if ( !support.style ) { // 8166 jQuery.attrHooks.style = { // 8167 get: function( elem ) { // 8168 // Return undefined in the case of empty string // 8169 // Note: IE uppercases css property names, but if we were to .toLowerCase() // 8170 // .cssText, that would destroy case senstitivity in URL's, like in "background" // 8171 return elem.style.cssText || undefined; // 8172 }, // 8173 set: function( elem, value ) { // 8174 return ( elem.style.cssText = value + "" ); // 8175 } // 8176 }; // 8177 } // 8178 // 8179 // 8180 // 8181 // 8182 var rfocusable = /^(?:input|select|textarea|button|object)$/i, // 8183 rclickable = /^(?:a|area)$/i; // 8184 // 8185 jQuery.fn.extend({ // 8186 prop: function( name, value ) { // 8187 return access( this, jQuery.prop, name, value, arguments.length > 1 ); // 8188 }, // 8189 // 8190 removeProp: function( name ) { // 8191 name = jQuery.propFix[ name ] || name; // 8192 return this.each(function() { // 8193 // try/catch handles cases where IE balks (such as removing a property on window) // 8194 try { // 8195 this[ name ] = undefined; // 8196 delete this[ name ]; // 8197 } catch( e ) {} // 8198 }); // 8199 } // 8200 }); // 8201 // 8202 jQuery.extend({ // 8203 propFix: { // 8204 "for": "htmlFor", // 8205 "class": "className" // 8206 }, // 8207 // 8208 prop: function( elem, name, value ) { // 8209 var ret, hooks, notxml, // 8210 nType = elem.nodeType; // 8211 // 8212 // don't get/set properties on text, comment and attribute nodes // 8213 if ( !elem || nType === 3 || nType === 8 || nType === 2 ) { // 8214 return; // 8215 } // 8216 // 8217 notxml = nType !== 1 || !jQuery.isXMLDoc( elem ); // 8218 // 8219 if ( notxml ) { // 8220 // Fix name and attach hooks // 8221 name = jQuery.propFix[ name ] || name; // 8222 hooks = jQuery.propHooks[ name ]; // 8223 } // 8224 // 8225 if ( value !== undefined ) { // 8226 return hooks && "set" in hooks && (ret = hooks.set( elem, value, name )) !== undefined ? // 8227 ret : // 8228 ( elem[ name ] = value ); // 8229 // 8230 } else { // 8231 return hooks && "get" in hooks && (ret = hooks.get( elem, name )) !== null ? // 8232 ret : // 8233 elem[ name ]; // 8234 } // 8235 }, // 8236 // 8237 propHooks: { // 8238 tabIndex: { // 8239 get: function( elem ) { // 8240 // elem.tabIndex doesn't always return the correct value when it hasn't been explicitly set // 8241 // http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/ // 8242 // Use proper attribute retrieval(#12072) // 8243 var tabindex = jQuery.find.attr( elem, "tabindex" ); // 8244 // 8245 return tabindex ? // 8246 parseInt( tabindex, 10 ) : // 8247 rfocusable.test( elem.nodeName ) || rclickable.test( elem.nodeName ) && elem.href ? // 8248 0 : // 8249 -1; // 8250 } // 8251 } // 8252 } // 8253 }); // 8254 // 8255 // Some attributes require a special call on IE // 8256 // http://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx // 8257 if ( !support.hrefNormalized ) { // 8258 // href/src property should get the full normalized URL (#10299/#12915) // 8259 jQuery.each([ "href", "src" ], function( i, name ) { // 8260 jQuery.propHooks[ name ] = { // 8261 get: function( elem ) { // 8262 return elem.getAttribute( name, 4 ); // 8263 } // 8264 }; // 8265 }); // 8266 } // 8267 // 8268 // Support: Safari, IE9+ // 8269 // mis-reports the default selected property of an option // 8270 // Accessing the parent's selectedIndex property fixes it // 8271 if ( !support.optSelected ) { // 8272 jQuery.propHooks.selected = { // 8273 get: function( elem ) { // 8274 var parent = elem.parentNode; // 8275 // 8276 if ( parent ) { // 8277 parent.selectedIndex; // 8278 // 8279 // Make sure that it also works with optgroups, see #5701 // 8280 if ( parent.parentNode ) { // 8281 parent.parentNode.selectedIndex; // 8282 } // 8283 } // 8284 return null; // 8285 } // 8286 }; // 8287 } // 8288 // 8289 jQuery.each([ // 8290 "tabIndex", // 8291 "readOnly", // 8292 "maxLength", // 8293 "cellSpacing", // 8294 "cellPadding", // 8295 "rowSpan", // 8296 "colSpan", // 8297 "useMap", // 8298 "frameBorder", // 8299 "contentEditable" // 8300 ], function() { // 8301 jQuery.propFix[ this.toLowerCase() ] = this; // 8302 }); // 8303 // 8304 // IE6/7 call enctype encoding // 8305 if ( !support.enctype ) { // 8306 jQuery.propFix.enctype = "encoding"; // 8307 } // 8308 // 8309 // 8310 // 8311 // 8312 var rclass = /[\t\r\n\f]/g; // 8313 // 8314 jQuery.fn.extend({ // 8315 addClass: function( value ) { // 8316 var classes, elem, cur, clazz, j, finalValue, // 8317 i = 0, // 8318 len = this.length, // 8319 proceed = typeof value === "string" && value; // 8320 // 8321 if ( jQuery.isFunction( value ) ) { // 8322 return this.each(function( j ) { // 8323 jQuery( this ).addClass( value.call( this, j, this.className ) ); // 8324 }); // 8325 } // 8326 // 8327 if ( proceed ) { // 8328 // The disjunction here is for better compressibility (see removeClass) // 8329 classes = ( value || "" ).match( rnotwhite ) || []; // 8330 // 8331 for ( ; i < len; i++ ) { // 8332 elem = this[ i ]; // 8333 cur = elem.nodeType === 1 && ( elem.className ? // 8334 ( " " + elem.className + " " ).replace( rclass, " " ) : // 8335 " " // 8336 ); // 8337 // 8338 if ( cur ) { // 8339 j = 0; // 8340 while ( (clazz = classes[j++]) ) { // 8341 if ( cur.indexOf( " " + clazz + " " ) < 0 ) { // 8342 cur += clazz + " "; // 8343 } // 8344 } // 8345 // 8346 // only assign if different to avoid unneeded rendering. // 8347 finalValue = jQuery.trim( cur ); // 8348 if ( elem.className !== finalValue ) { // 8349 elem.className = finalValue; // 8350 } // 8351 } // 8352 } // 8353 } // 8354 // 8355 return this; // 8356 }, // 8357 // 8358 removeClass: function( value ) { // 8359 var classes, elem, cur, clazz, j, finalValue, // 8360 i = 0, // 8361 len = this.length, // 8362 proceed = arguments.length === 0 || typeof value === "string" && value; // 8363 // 8364 if ( jQuery.isFunction( value ) ) { // 8365 return this.each(function( j ) { // 8366 jQuery( this ).removeClass( value.call( this, j, this.className ) ); // 8367 }); // 8368 } // 8369 if ( proceed ) { // 8370 classes = ( value || "" ).match( rnotwhite ) || []; // 8371 // 8372 for ( ; i < len; i++ ) { // 8373 elem = this[ i ]; // 8374 // This expression is here for better compressibility (see addClass) // 8375 cur = elem.nodeType === 1 && ( elem.className ? // 8376 ( " " + elem.className + " " ).replace( rclass, " " ) : // 8377 "" // 8378 ); // 8379 // 8380 if ( cur ) { // 8381 j = 0; // 8382 while ( (clazz = classes[j++]) ) { // 8383 // Remove *all* instances // 8384 while ( cur.indexOf( " " + clazz + " " ) >= 0 ) { // 8385 cur = cur.replace( " " + clazz + " ", " " ); // 8386 } // 8387 } // 8388 // 8389 // only assign if different to avoid unneeded rendering. // 8390 finalValue = value ? jQuery.trim( cur ) : ""; // 8391 if ( elem.className !== finalValue ) { // 8392 elem.className = finalValue; // 8393 } // 8394 } // 8395 } // 8396 } // 8397 // 8398 return this; // 8399 }, // 8400 // 8401 toggleClass: function( value, stateVal ) { // 8402 var type = typeof value; // 8403 // 8404 if ( typeof stateVal === "boolean" && type === "string" ) { // 8405 return stateVal ? this.addClass( value ) : this.removeClass( value ); // 8406 } // 8407 // 8408 if ( jQuery.isFunction( value ) ) { // 8409 return this.each(function( i ) { // 8410 jQuery( this ).toggleClass( value.call(this, i, this.className, stateVal), stateVal ); // 8411 }); // 8412 } // 8413 // 8414 return this.each(function() { // 8415 if ( type === "string" ) { // 8416 // toggle individual class names // 8417 var className, // 8418 i = 0, // 8419 self = jQuery( this ), // 8420 classNames = value.match( rnotwhite ) || []; // 8421 // 8422 while ( (className = classNames[ i++ ]) ) { // 8423 // check each className given, space separated list // 8424 if ( self.hasClass( className ) ) { // 8425 self.removeClass( className ); // 8426 } else { // 8427 self.addClass( className ); // 8428 } // 8429 } // 8430 // 8431 // Toggle whole class name // 8432 } else if ( type === strundefined || type === "boolean" ) { // 8433 if ( this.className ) { // 8434 // store className if set // 8435 jQuery._data( this, "__className__", this.className ); // 8436 } // 8437 // 8438 // If the element has a class name or if we're passed "false", // 8439 // then remove the whole classname (if there was one, the above saved it). // 8440 // Otherwise bring back whatever was previously saved (if anything), // 8441 // falling back to the empty string if nothing was stored. // 8442 this.className = this.className || value === false ? "" : jQuery._data( this, "__className__" ) || ""; // 8443 } // 8444 }); // 8445 }, // 8446 // 8447 hasClass: function( selector ) { // 8448 var className = " " + selector + " ", // 8449 i = 0, // 8450 l = this.length; // 8451 for ( ; i < l; i++ ) { // 8452 if ( this[i].nodeType === 1 && (" " + this[i].className + " ").replace(rclass, " ").indexOf( className ) >= 0 ) { // 8453 return true; // 8454 } // 8455 } // 8456 // 8457 return false; // 8458 } // 8459 }); // 8460 // 8461 // 8462 // 8463 // 8464 // Return jQuery for attributes-only inclusion // 8465 // 8466 // 8467 jQuery.each( ("blur focus focusin focusout load resize scroll unload click dblclick " + // 8468 "mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave " + // 8469 "change select submit keydown keypress keyup error contextmenu").split(" "), function( i, name ) { // 8470 // 8471 // Handle event binding // 8472 jQuery.fn[ name ] = function( data, fn ) { // 8473 return arguments.length > 0 ? // 8474 this.on( name, null, data, fn ) : // 8475 this.trigger( name ); // 8476 }; // 8477 }); // 8478 // 8479 jQuery.fn.extend({ // 8480 hover: function( fnOver, fnOut ) { // 8481 return this.mouseenter( fnOver ).mouseleave( fnOut || fnOver ); // 8482 }, // 8483 // 8484 bind: function( types, data, fn ) { // 8485 return this.on( types, null, data, fn ); // 8486 }, // 8487 unbind: function( types, fn ) { // 8488 return this.off( types, null, fn ); // 8489 }, // 8490 // 8491 delegate: function( selector, types, data, fn ) { // 8492 return this.on( types, selector, data, fn ); // 8493 }, // 8494 undelegate: function( selector, types, fn ) { // 8495 // ( namespace ) or ( selector, types [, fn] ) // 8496 return arguments.length === 1 ? this.off( selector, "**" ) : this.off( types, selector || "**", fn ); // 8497 } // 8498 }); // 8499 // 8500 // 8501 var nonce = jQuery.now(); // 8502 // 8503 var rquery = (/\?/); // 8504 // 8505 // 8506 // 8507 var rvalidtokens = /(,)|(\[|{)|(}|])|"(?:[^"\\\r\n]|\\["\\\/bfnrt]|\\u[\da-fA-F]{4})*"\s*:?|true|false|null|-?(?!0\d)\d+(?:\.\d+|)(?:[eE][+-]?\d+|)/g; // 8509 jQuery.parseJSON = function( data ) { // 8510 // Attempt to parse using the native JSON parser first // 8511 if ( window.JSON && window.JSON.parse ) { // 8512 // Support: Android 2.3 // 8513 // Workaround failure to string-cast null input // 8514 return window.JSON.parse( data + "" ); // 8515 } // 8516 // 8517 var requireNonComma, // 8518 depth = null, // 8519 str = jQuery.trim( data + "" ); // 8520 // 8521 // Guard against invalid (and possibly dangerous) input by ensuring that nothing remains // 8522 // after removing valid tokens // 8523 return str && !jQuery.trim( str.replace( rvalidtokens, function( token, comma, open, close ) { // 8524 // 8525 // Force termination if we see a misplaced comma // 8526 if ( requireNonComma && comma ) { // 8527 depth = 0; // 8528 } // 8529 // 8530 // Perform no more replacements after returning to outermost depth // 8531 if ( depth === 0 ) { // 8532 return token; // 8533 } // 8534 // 8535 // Commas must not follow "[", "{", or "," // 8536 requireNonComma = open || comma; // 8537 // 8538 // Determine new depth // 8539 // array/object open ("[" or "{"): depth += true - false (increment) // 8540 // array/object close ("]" or "}"): depth += false - true (decrement) // 8541 // other cases ("," or primitive): depth += true - true (numeric cast) // 8542 depth += !close - !open; // 8543 // 8544 // Remove this token // 8545 return ""; // 8546 }) ) ? // 8547 ( Function( "return " + str ) )() : // 8548 jQuery.error( "Invalid JSON: " + data ); // 8549 }; // 8550 // 8551 // 8552 // Cross-browser xml parsing // 8553 jQuery.parseXML = function( data ) { // 8554 var xml, tmp; // 8555 if ( !data || typeof data !== "string" ) { // 8556 return null; // 8557 } // 8558 try { // 8559 if ( window.DOMParser ) { // Standard // 8560 tmp = new DOMParser(); // 8561 xml = tmp.parseFromString( data, "text/xml" ); // 8562 } else { // IE // 8563 xml = new ActiveXObject( "Microsoft.XMLDOM" ); // 8564 xml.async = "false"; // 8565 xml.loadXML( data ); // 8566 } // 8567 } catch( e ) { // 8568 xml = undefined; // 8569 } // 8570 if ( !xml || !xml.documentElement || xml.getElementsByTagName( "parsererror" ).length ) { // 8571 jQuery.error( "Invalid XML: " + data ); // 8572 } // 8573 return xml; // 8574 }; // 8575 // 8576 // 8577 var // 8578 // Document location // 8579 ajaxLocParts, // 8580 ajaxLocation, // 8581 // 8582 rhash = /#.*$/, // 8583 rts = /([?&])_=[^&]*/, // 8584 rheaders = /^(.*?):[ \t]*([^\r\n]*)\r?$/mg, // IE leaves an \r character at EOL // 8585 // #7653, #8125, #8152: local protocol detection // 8586 rlocalProtocol = /^(?:about|app|app-storage|.+-extension|file|res|widget):$/, // 8587 rnoContent = /^(?:GET|HEAD)$/, // 8588 rprotocol = /^\/\//, // 8589 rurl = /^([\w.+-]+:)(?:\/\/(?:[^\/?#]*@|)([^\/?#:]*)(?::(\d+)|)|)/, // 8590 // 8591 /* Prefilters // 8592 * 1) They are useful to introduce custom dataTypes (see ajax/jsonp.js for an example) // 8593 * 2) These are called: // 8594 * - BEFORE asking for a transport // 8595 * - AFTER param serialization (s.data is a string if s.processData is true) // 8596 * 3) key is the dataType // 8597 * 4) the catchall symbol "*" can be used // 8598 * 5) execution will start with transport dataType and THEN continue down to "*" if needed // 8599 */ // 8600 prefilters = {}, // 8601 // 8602 /* Transports bindings // 8603 * 1) key is the dataType // 8604 * 2) the catchall symbol "*" can be used // 8605 * 3) selection will start with transport dataType and THEN go to "*" if needed // 8606 */ // 8607 transports = {}, // 8608 // 8609 // Avoid comment-prolog char sequence (#10098); must appease lint and evade compression // 8610 allTypes = "*/".concat("*"); // 8611 // 8612 // #8138, IE may throw an exception when accessing // 8613 // a field from window.location if document.domain has been set // 8614 try { // 8615 ajaxLocation = location.href; // 8616 } catch( e ) { // 8617 // Use the href attribute of an A element // 8618 // since IE will modify it given document.location // 8619 ajaxLocation = document.createElement( "a" ); // 8620 ajaxLocation.href = ""; // 8621 ajaxLocation = ajaxLocation.href; // 8622 } // 8623 // 8624 // Segment location into parts // 8625 ajaxLocParts = rurl.exec( ajaxLocation.toLowerCase() ) || []; // 8626 // 8627 // Base "constructor" for jQuery.ajaxPrefilter and jQuery.ajaxTransport // 8628 function addToPrefiltersOrTransports( structure ) { // 8629 // 8630 // dataTypeExpression is optional and defaults to "*" // 8631 return function( dataTypeExpression, func ) { // 8632 // 8633 if ( typeof dataTypeExpression !== "string" ) { // 8634 func = dataTypeExpression; // 8635 dataTypeExpression = "*"; // 8636 } // 8637 // 8638 var dataType, // 8639 i = 0, // 8640 dataTypes = dataTypeExpression.toLowerCase().match( rnotwhite ) || []; // 8641 // 8642 if ( jQuery.isFunction( func ) ) { // 8643 // For each dataType in the dataTypeExpression // 8644 while ( (dataType = dataTypes[i++]) ) { // 8645 // Prepend if requested // 8646 if ( dataType.charAt( 0 ) === "+" ) { // 8647 dataType = dataType.slice( 1 ) || "*"; // 8648 (structure[ dataType ] = structure[ dataType ] || []).unshift( func ); // 8649 // 8650 // Otherwise append // 8651 } else { // 8652 (structure[ dataType ] = structure[ dataType ] || []).push( func ); // 8653 } // 8654 } // 8655 } // 8656 }; // 8657 } // 8658 // 8659 // Base inspection function for prefilters and transports // 8660 function inspectPrefiltersOrTransports( structure, options, originalOptions, jqXHR ) { // 8661 // 8662 var inspected = {}, // 8663 seekingTransport = ( structure === transports ); // 8664 // 8665 function inspect( dataType ) { // 8666 var selected; // 8667 inspected[ dataType ] = true; // 8668 jQuery.each( structure[ dataType ] || [], function( _, prefilterOrFactory ) { // 8669 var dataTypeOrTransport = prefilterOrFactory( options, originalOptions, jqXHR ); // 8670 if ( typeof dataTypeOrTransport === "string" && !seekingTransport && !inspected[ dataTypeOrTransport ] ) { // 8671 options.dataTypes.unshift( dataTypeOrTransport ); // 8672 inspect( dataTypeOrTransport ); // 8673 return false; // 8674 } else if ( seekingTransport ) { // 8675 return !( selected = dataTypeOrTransport ); // 8676 } // 8677 }); // 8678 return selected; // 8679 } // 8680 // 8681 return inspect( options.dataTypes[ 0 ] ) || !inspected[ "*" ] && inspect( "*" ); // 8682 } // 8683 // 8684 // A special extend for ajax options // 8685 // that takes "flat" options (not to be deep extended) // 8686 // Fixes #9887 // 8687 function ajaxExtend( target, src ) { // 8688 var deep, key, // 8689 flatOptions = jQuery.ajaxSettings.flatOptions || {}; // 8690 // 8691 for ( key in src ) { // 8692 if ( src[ key ] !== undefined ) { // 8693 ( flatOptions[ key ] ? target : ( deep || (deep = {}) ) )[ key ] = src[ key ]; // 8694 } // 8695 } // 8696 if ( deep ) { // 8697 jQuery.extend( true, target, deep ); // 8698 } // 8699 // 8700 return target; // 8701 } // 8702 // 8703 /* Handles responses to an ajax request: // 8704 * - finds the right dataType (mediates between content-type and expected dataType) // 8705 * - returns the corresponding response // 8706 */ // 8707 function ajaxHandleResponses( s, jqXHR, responses ) { // 8708 var firstDataType, ct, finalDataType, type, // 8709 contents = s.contents, // 8710 dataTypes = s.dataTypes; // 8711 // 8712 // Remove auto dataType and get content-type in the process // 8713 while ( dataTypes[ 0 ] === "*" ) { // 8714 dataTypes.shift(); // 8715 if ( ct === undefined ) { // 8716 ct = s.mimeType || jqXHR.getResponseHeader("Content-Type"); // 8717 } // 8718 } // 8719 // 8720 // Check if we're dealing with a known content-type // 8721 if ( ct ) { // 8722 for ( type in contents ) { // 8723 if ( contents[ type ] && contents[ type ].test( ct ) ) { // 8724 dataTypes.unshift( type ); // 8725 break; // 8726 } // 8727 } // 8728 } // 8729 // 8730 // Check to see if we have a response for the expected dataType // 8731 if ( dataTypes[ 0 ] in responses ) { // 8732 finalDataType = dataTypes[ 0 ]; // 8733 } else { // 8734 // Try convertible dataTypes // 8735 for ( type in responses ) { // 8736 if ( !dataTypes[ 0 ] || s.converters[ type + " " + dataTypes[0] ] ) { // 8737 finalDataType = type; // 8738 break; // 8739 } // 8740 if ( !firstDataType ) { // 8741 firstDataType = type; // 8742 } // 8743 } // 8744 // Or just use first one // 8745 finalDataType = finalDataType || firstDataType; // 8746 } // 8747 // 8748 // If we found a dataType // 8749 // We add the dataType to the list if needed // 8750 // and return the corresponding response // 8751 if ( finalDataType ) { // 8752 if ( finalDataType !== dataTypes[ 0 ] ) { // 8753 dataTypes.unshift( finalDataType ); // 8754 } // 8755 return responses[ finalDataType ]; // 8756 } // 8757 } // 8758 // 8759 /* Chain conversions given the request and the original response // 8760 * Also sets the responseXXX fields on the jqXHR instance // 8761 */ // 8762 function ajaxConvert( s, response, jqXHR, isSuccess ) { // 8763 var conv2, current, conv, tmp, prev, // 8764 converters = {}, // 8765 // Work with a copy of dataTypes in case we need to modify it for conversion // 8766 dataTypes = s.dataTypes.slice(); // 8767 // 8768 // Create converters map with lowercased keys // 8769 if ( dataTypes[ 1 ] ) { // 8770 for ( conv in s.converters ) { // 8771 converters[ conv.toLowerCase() ] = s.converters[ conv ]; // 8772 } // 8773 } // 8774 // 8775 current = dataTypes.shift(); // 8776 // 8777 // Convert to each sequential dataType // 8778 while ( current ) { // 8779 // 8780 if ( s.responseFields[ current ] ) { // 8781 jqXHR[ s.responseFields[ current ] ] = response; // 8782 } // 8783 // 8784 // Apply the dataFilter if provided // 8785 if ( !prev && isSuccess && s.dataFilter ) { // 8786 response = s.dataFilter( response, s.dataType ); // 8787 } // 8788 // 8789 prev = current; // 8790 current = dataTypes.shift(); // 8791 // 8792 if ( current ) { // 8793 // 8794 // There's only work to do if current dataType is non-auto // 8795 if ( current === "*" ) { // 8796 // 8797 current = prev; // 8798 // 8799 // Convert response if prev dataType is non-auto and differs from current // 8800 } else if ( prev !== "*" && prev !== current ) { // 8801 // 8802 // Seek a direct converter // 8803 conv = converters[ prev + " " + current ] || converters[ "* " + current ]; // 8804 // 8805 // If none found, seek a pair // 8806 if ( !conv ) { // 8807 for ( conv2 in converters ) { // 8808 // 8809 // If conv2 outputs current // 8810 tmp = conv2.split( " " ); // 8811 if ( tmp[ 1 ] === current ) { // 8812 // 8813 // If prev can be converted to accepted input // 8814 conv = converters[ prev + " " + tmp[ 0 ] ] || // 8815 converters[ "* " + tmp[ 0 ] ]; // 8816 if ( conv ) { // 8817 // Condense equivalence converters // 8818 if ( conv === true ) { // 8819 conv = converters[ conv2 ]; // 8820 // 8821 // Otherwise, insert the intermediate dataType // 8822 } else if ( converters[ conv2 ] !== true ) { // 8823 current = tmp[ 0 ]; // 8824 dataTypes.unshift( tmp[ 1 ] ); // 8825 } // 8826 break; // 8827 } // 8828 } // 8829 } // 8830 } // 8831 // 8832 // Apply converter (if not an equivalence) // 8833 if ( conv !== true ) { // 8834 // 8835 // Unless errors are allowed to bubble, catch and return them // 8836 if ( conv && s[ "throws" ] ) { // 8837 response = conv( response ); // 8838 } else { // 8839 try { // 8840 response = conv( response ); // 8841 } catch ( e ) { // 8842 return { state: "parsererror", error: conv ? e : "No conversion from " + prev + " to " + current }; // 8843 } // 8844 } // 8845 } // 8846 } // 8847 } // 8848 } // 8849 // 8850 return { state: "success", data: response }; // 8851 } // 8852 // 8853 jQuery.extend({ // 8854 // 8855 // Counter for holding the number of active queries // 8856 active: 0, // 8857 // 8858 // Last-Modified header cache for next request // 8859 lastModified: {}, // 8860 etag: {}, // 8861 // 8862 ajaxSettings: { // 8863 url: ajaxLocation, // 8864 type: "GET", // 8865 isLocal: rlocalProtocol.test( ajaxLocParts[ 1 ] ), // 8866 global: true, // 8867 processData: true, // 8868 async: true, // 8869 contentType: "application/x-www-form-urlencoded; charset=UTF-8", // 8870 /* // 8871 timeout: 0, // 8872 data: null, // 8873 dataType: null, // 8874 username: null, // 8875 password: null, // 8876 cache: null, // 8877 throws: false, // 8878 traditional: false, // 8879 headers: {}, // 8880 */ // 8881 // 8882 accepts: { // 8883 "*": allTypes, // 8884 text: "text/plain", // 8885 html: "text/html", // 8886 xml: "application/xml, text/xml", // 8887 json: "application/json, text/javascript" // 8888 }, // 8889 // 8890 contents: { // 8891 xml: /xml/, // 8892 html: /html/, // 8893 json: /json/ // 8894 }, // 8895 // 8896 responseFields: { // 8897 xml: "responseXML", // 8898 text: "responseText", // 8899 json: "responseJSON" // 8900 }, // 8901 // 8902 // Data converters // 8903 // Keys separate source (or catchall "*") and destination types with a single space // 8904 converters: { // 8905 // 8906 // Convert anything to text // 8907 "* text": String, // 8908 // 8909 // Text to html (true = no transformation) // 8910 "text html": true, // 8911 // 8912 // Evaluate text as a json expression // 8913 "text json": jQuery.parseJSON, // 8914 // 8915 // Parse text as xml // 8916 "text xml": jQuery.parseXML // 8917 }, // 8918 // 8919 // For options that shouldn't be deep extended: // 8920 // you can add your own custom options here if // 8921 // and when you create one that shouldn't be // 8922 // deep extended (see ajaxExtend) // 8923 flatOptions: { // 8924 url: true, // 8925 context: true // 8926 } // 8927 }, // 8928 // 8929 // Creates a full fledged settings object into target // 8930 // with both ajaxSettings and settings fields. // 8931 // If target is omitted, writes into ajaxSettings. // 8932 ajaxSetup: function( target, settings ) { // 8933 return settings ? // 8934 // 8935 // Building a settings object // 8936 ajaxExtend( ajaxExtend( target, jQuery.ajaxSettings ), settings ) : // 8937 // 8938 // Extending ajaxSettings // 8939 ajaxExtend( jQuery.ajaxSettings, target ); // 8940 }, // 8941 // 8942 ajaxPrefilter: addToPrefiltersOrTransports( prefilters ), // 8943 ajaxTransport: addToPrefiltersOrTransports( transports ), // 8944 // 8945 // Main method // 8946 ajax: function( url, options ) { // 8947 // 8948 // If url is an object, simulate pre-1.5 signature // 8949 if ( typeof url === "object" ) { // 8950 options = url; // 8951 url = undefined; // 8952 } // 8953 // 8954 // Force options to be an object // 8955 options = options || {}; // 8956 // 8957 var // Cross-domain detection vars // 8958 parts, // 8959 // Loop variable // 8960 i, // 8961 // URL without anti-cache param // 8962 cacheURL, // 8963 // Response headers as string // 8964 responseHeadersString, // 8965 // timeout handle // 8966 timeoutTimer, // 8967 // 8968 // To know if global events are to be dispatched // 8969 fireGlobals, // 8970 // 8971 transport, // 8972 // Response headers // 8973 responseHeaders, // 8974 // Create the final options object // 8975 s = jQuery.ajaxSetup( {}, options ), // 8976 // Callbacks context // 8977 callbackContext = s.context || s, // 8978 // Context for global events is callbackContext if it is a DOM node or jQuery collection // 8979 globalEventContext = s.context && ( callbackContext.nodeType || callbackContext.jquery ) ? // 8980 jQuery( callbackContext ) : // 8981 jQuery.event, // 8982 // Deferreds // 8983 deferred = jQuery.Deferred(), // 8984 completeDeferred = jQuery.Callbacks("once memory"), // 8985 // Status-dependent callbacks // 8986 statusCode = s.statusCode || {}, // 8987 // Headers (they are sent all at once) // 8988 requestHeaders = {}, // 8989 requestHeadersNames = {}, // 8990 // The jqXHR state // 8991 state = 0, // 8992 // Default abort message // 8993 strAbort = "canceled", // 8994 // Fake xhr // 8995 jqXHR = { // 8996 readyState: 0, // 8997 // 8998 // Builds headers hashtable if needed // 8999 getResponseHeader: function( key ) { // 9000 var match; // 9001 if ( state === 2 ) { // 9002 if ( !responseHeaders ) { // 9003 responseHeaders = {}; // 9004 while ( (match = rheaders.exec( responseHeadersString )) ) { // 9005 responseHeaders[ match[1].toLowerCase() ] = match[ 2 ]; // 9006 } // 9007 } // 9008 match = responseHeaders[ key.toLowerCase() ]; // 9009 } // 9010 return match == null ? null : match; // 9011 }, // 9012 // 9013 // Raw string // 9014 getAllResponseHeaders: function() { // 9015 return state === 2 ? responseHeadersString : null; // 9016 }, // 9017 // 9018 // Caches the header // 9019 setRequestHeader: function( name, value ) { // 9020 var lname = name.toLowerCase(); // 9021 if ( !state ) { // 9022 name = requestHeadersNames[ lname ] = requestHeadersNames[ lname ] || name; // 9023 requestHeaders[ name ] = value; // 9024 } // 9025 return this; // 9026 }, // 9027 // 9028 // Overrides response content-type header // 9029 overrideMimeType: function( type ) { // 9030 if ( !state ) { // 9031 s.mimeType = type; // 9032 } // 9033 return this; // 9034 }, // 9035 // 9036 // Status-dependent callbacks // 9037 statusCode: function( map ) { // 9038 var code; // 9039 if ( map ) { // 9040 if ( state < 2 ) { // 9041 for ( code in map ) { // 9042 // Lazy-add the new callback in a way that preserves old ones // 9043 statusCode[ code ] = [ statusCode[ code ], map[ code ] ]; // 9044 } // 9045 } else { // 9046 // Execute the appropriate callbacks // 9047 jqXHR.always( map[ jqXHR.status ] ); // 9048 } // 9049 } // 9050 return this; // 9051 }, // 9052 // 9053 // Cancel the request // 9054 abort: function( statusText ) { // 9055 var finalText = statusText || strAbort; // 9056 if ( transport ) { // 9057 transport.abort( finalText ); // 9058 } // 9059 done( 0, finalText ); // 9060 return this; // 9061 } // 9062 }; // 9063 // 9064 // Attach deferreds // 9065 deferred.promise( jqXHR ).complete = completeDeferred.add; // 9066 jqXHR.success = jqXHR.done; // 9067 jqXHR.error = jqXHR.fail; // 9068 // 9069 // Remove hash character (#7531: and string promotion) // 9070 // Add protocol if not provided (#5866: IE7 issue with protocol-less urls) // 9071 // Handle falsy url in the settings object (#10093: consistency with old signature) // 9072 // We also use the url parameter if available // 9073 s.url = ( ( url || s.url || ajaxLocation ) + "" ).replace( rhash, "" ).replace( rprotocol, ajaxLocParts[ 1 ] + "//" ); // 9075 // Alias method option to type as per ticket #12004 // 9076 s.type = options.method || options.type || s.method || s.type; // 9077 // 9078 // Extract dataTypes list // 9079 s.dataTypes = jQuery.trim( s.dataType || "*" ).toLowerCase().match( rnotwhite ) || [ "" ]; // 9080 // 9081 // A cross-domain request is in order when we have a protocol:host:port mismatch // 9082 if ( s.crossDomain == null ) { // 9083 parts = rurl.exec( s.url.toLowerCase() ); // 9084 s.crossDomain = !!( parts && // 9085 ( parts[ 1 ] !== ajaxLocParts[ 1 ] || parts[ 2 ] !== ajaxLocParts[ 2 ] || // 9086 ( parts[ 3 ] || ( parts[ 1 ] === "http:" ? "80" : "443" ) ) !== // 9087 ( ajaxLocParts[ 3 ] || ( ajaxLocParts[ 1 ] === "http:" ? "80" : "443" ) ) ) // 9088 ); // 9089 } // 9090 // 9091 // Convert data if not already a string // 9092 if ( s.data && s.processData && typeof s.data !== "string" ) { // 9093 s.data = jQuery.param( s.data, s.traditional ); // 9094 } // 9095 // 9096 // Apply prefilters // 9097 inspectPrefiltersOrTransports( prefilters, s, options, jqXHR ); // 9098 // 9099 // If request was aborted inside a prefilter, stop there // 9100 if ( state === 2 ) { // 9101 return jqXHR; // 9102 } // 9103 // 9104 // We can fire global events as of now if asked to // 9105 // Don't fire events if jQuery.event is undefined in an AMD-usage scenario (#15118) // 9106 fireGlobals = jQuery.event && s.global; // 9107 // 9108 // Watch for a new set of requests // 9109 if ( fireGlobals && jQuery.active++ === 0 ) { // 9110 jQuery.event.trigger("ajaxStart"); // 9111 } // 9112 // 9113 // Uppercase the type // 9114 s.type = s.type.toUpperCase(); // 9115 // 9116 // Determine if request has content // 9117 s.hasContent = !rnoContent.test( s.type ); // 9118 // 9119 // Save the URL in case we're toying with the If-Modified-Since // 9120 // and/or If-None-Match header later on // 9121 cacheURL = s.url; // 9122 // 9123 // More options handling for requests with no content // 9124 if ( !s.hasContent ) { // 9125 // 9126 // If data is available, append data to url // 9127 if ( s.data ) { // 9128 cacheURL = ( s.url += ( rquery.test( cacheURL ) ? "&" : "?" ) + s.data ); // 9129 // #9682: remove data so that it's not used in an eventual retry // 9130 delete s.data; // 9131 } // 9132 // 9133 // Add anti-cache in url if needed // 9134 if ( s.cache === false ) { // 9135 s.url = rts.test( cacheURL ) ? // 9136 // 9137 // If there is already a '_' parameter, set its value // 9138 cacheURL.replace( rts, "$1_=" + nonce++ ) : // 9139 // 9140 // Otherwise add one to the end // 9141 cacheURL + ( rquery.test( cacheURL ) ? "&" : "?" ) + "_=" + nonce++; // 9142 } // 9143 } // 9144 // 9145 // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode. // 9146 if ( s.ifModified ) { // 9147 if ( jQuery.lastModified[ cacheURL ] ) { // 9148 jqXHR.setRequestHeader( "If-Modified-Since", jQuery.lastModified[ cacheURL ] ); // 9149 } // 9150 if ( jQuery.etag[ cacheURL ] ) { // 9151 jqXHR.setRequestHeader( "If-None-Match", jQuery.etag[ cacheURL ] ); // 9152 } // 9153 } // 9154 // 9155 // Set the correct header, if data is being sent // 9156 if ( s.data && s.hasContent && s.contentType !== false || options.contentType ) { // 9157 jqXHR.setRequestHeader( "Content-Type", s.contentType ); // 9158 } // 9159 // 9160 // Set the Accepts header for the server, depending on the dataType // 9161 jqXHR.setRequestHeader( // 9162 "Accept", // 9163 s.dataTypes[ 0 ] && s.accepts[ s.dataTypes[0] ] ? // 9164 s.accepts[ s.dataTypes[0] ] + ( s.dataTypes[ 0 ] !== "*" ? ", " + allTypes + "; q=0.01" : "" ) : // 9165 s.accepts[ "*" ] // 9166 ); // 9167 // 9168 // Check for headers option // 9169 for ( i in s.headers ) { // 9170 jqXHR.setRequestHeader( i, s.headers[ i ] ); // 9171 } // 9172 // 9173 // Allow custom headers/mimetypes and early abort // 9174 if ( s.beforeSend && ( s.beforeSend.call( callbackContext, jqXHR, s ) === false || state === 2 ) ) { // 9175 // Abort if not done already and return // 9176 return jqXHR.abort(); // 9177 } // 9178 // 9179 // aborting is no longer a cancellation // 9180 strAbort = "abort"; // 9181 // 9182 // Install callbacks on deferreds // 9183 for ( i in { success: 1, error: 1, complete: 1 } ) { // 9184 jqXHR[ i ]( s[ i ] ); // 9185 } // 9186 // 9187 // Get transport // 9188 transport = inspectPrefiltersOrTransports( transports, s, options, jqXHR ); // 9189 // 9190 // If no transport, we auto-abort // 9191 if ( !transport ) { // 9192 done( -1, "No Transport" ); // 9193 } else { // 9194 jqXHR.readyState = 1; // 9195 // 9196 // Send global event // 9197 if ( fireGlobals ) { // 9198 globalEventContext.trigger( "ajaxSend", [ jqXHR, s ] ); // 9199 } // 9200 // Timeout // 9201 if ( s.async && s.timeout > 0 ) { // 9202 timeoutTimer = setTimeout(function() { // 9203 jqXHR.abort("timeout"); // 9204 }, s.timeout ); // 9205 } // 9206 // 9207 try { // 9208 state = 1; // 9209 transport.send( requestHeaders, done ); // 9210 } catch ( e ) { // 9211 // Propagate exception as error if not done // 9212 if ( state < 2 ) { // 9213 done( -1, e ); // 9214 // Simply rethrow otherwise // 9215 } else { // 9216 throw e; // 9217 } // 9218 } // 9219 } // 9220 // 9221 // Callback for when everything is done // 9222 function done( status, nativeStatusText, responses, headers ) { // 9223 var isSuccess, success, error, response, modified, // 9224 statusText = nativeStatusText; // 9225 // 9226 // Called once // 9227 if ( state === 2 ) { // 9228 return; // 9229 } // 9230 // 9231 // State is "done" now // 9232 state = 2; // 9233 // 9234 // Clear timeout if it exists // 9235 if ( timeoutTimer ) { // 9236 clearTimeout( timeoutTimer ); // 9237 } // 9238 // 9239 // Dereference transport for early garbage collection // 9240 // (no matter how long the jqXHR object will be used) // 9241 transport = undefined; // 9242 // 9243 // Cache response headers // 9244 responseHeadersString = headers || ""; // 9245 // 9246 // Set readyState // 9247 jqXHR.readyState = status > 0 ? 4 : 0; // 9248 // 9249 // Determine if successful // 9250 isSuccess = status >= 200 && status < 300 || status === 304; // 9251 // 9252 // Get response data // 9253 if ( responses ) { // 9254 response = ajaxHandleResponses( s, jqXHR, responses ); // 9255 } // 9256 // 9257 // Convert no matter what (that way responseXXX fields are always set) // 9258 response = ajaxConvert( s, response, jqXHR, isSuccess ); // 9259 // 9260 // If successful, handle type chaining // 9261 if ( isSuccess ) { // 9262 // 9263 // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode. // 9264 if ( s.ifModified ) { // 9265 modified = jqXHR.getResponseHeader("Last-Modified"); // 9266 if ( modified ) { // 9267 jQuery.lastModified[ cacheURL ] = modified; // 9268 } // 9269 modified = jqXHR.getResponseHeader("etag"); // 9270 if ( modified ) { // 9271 jQuery.etag[ cacheURL ] = modified; // 9272 } // 9273 } // 9274 // 9275 // if no content // 9276 if ( status === 204 || s.type === "HEAD" ) { // 9277 statusText = "nocontent"; // 9278 // 9279 // if not modified // 9280 } else if ( status === 304 ) { // 9281 statusText = "notmodified"; // 9282 // 9283 // If we have data, let's convert it // 9284 } else { // 9285 statusText = response.state; // 9286 success = response.data; // 9287 error = response.error; // 9288 isSuccess = !error; // 9289 } // 9290 } else { // 9291 // We extract error from statusText // 9292 // then normalize statusText and status for non-aborts // 9293 error = statusText; // 9294 if ( status || !statusText ) { // 9295 statusText = "error"; // 9296 if ( status < 0 ) { // 9297 status = 0; // 9298 } // 9299 } // 9300 } // 9301 // 9302 // Set data for the fake xhr object // 9303 jqXHR.status = status; // 9304 jqXHR.statusText = ( nativeStatusText || statusText ) + ""; // 9305 // 9306 // Success/Error // 9307 if ( isSuccess ) { // 9308 deferred.resolveWith( callbackContext, [ success, statusText, jqXHR ] ); // 9309 } else { // 9310 deferred.rejectWith( callbackContext, [ jqXHR, statusText, error ] ); // 9311 } // 9312 // 9313 // Status-dependent callbacks // 9314 jqXHR.statusCode( statusCode ); // 9315 statusCode = undefined; // 9316 // 9317 if ( fireGlobals ) { // 9318 globalEventContext.trigger( isSuccess ? "ajaxSuccess" : "ajaxError", // 9319 [ jqXHR, s, isSuccess ? success : error ] ); // 9320 } // 9321 // 9322 // Complete // 9323 completeDeferred.fireWith( callbackContext, [ jqXHR, statusText ] ); // 9324 // 9325 if ( fireGlobals ) { // 9326 globalEventContext.trigger( "ajaxComplete", [ jqXHR, s ] ); // 9327 // Handle the global AJAX counter // 9328 if ( !( --jQuery.active ) ) { // 9329 jQuery.event.trigger("ajaxStop"); // 9330 } // 9331 } // 9332 } // 9333 // 9334 return jqXHR; // 9335 }, // 9336 // 9337 getJSON: function( url, data, callback ) { // 9338 return jQuery.get( url, data, callback, "json" ); // 9339 }, // 9340 // 9341 getScript: function( url, callback ) { // 9342 return jQuery.get( url, undefined, callback, "script" ); // 9343 } // 9344 }); // 9345 // 9346 jQuery.each( [ "get", "post" ], function( i, method ) { // 9347 jQuery[ method ] = function( url, data, callback, type ) { // 9348 // shift arguments if data argument was omitted // 9349 if ( jQuery.isFunction( data ) ) { // 9350 type = type || callback; // 9351 callback = data; // 9352 data = undefined; // 9353 } // 9354 // 9355 return jQuery.ajax({ // 9356 url: url, // 9357 type: method, // 9358 dataType: type, // 9359 data: data, // 9360 success: callback // 9361 }); // 9362 }; // 9363 }); // 9364 // 9365 // 9366 jQuery._evalUrl = function( url ) { // 9367 return jQuery.ajax({ // 9368 url: url, // 9369 type: "GET", // 9370 dataType: "script", // 9371 async: false, // 9372 global: false, // 9373 "throws": true // 9374 }); // 9375 }; // 9376 // 9377 // 9378 jQuery.fn.extend({ // 9379 wrapAll: function( html ) { // 9380 if ( jQuery.isFunction( html ) ) { // 9381 return this.each(function(i) { // 9382 jQuery(this).wrapAll( html.call(this, i) ); // 9383 }); // 9384 } // 9385 // 9386 if ( this[0] ) { // 9387 // The elements to wrap the target around // 9388 var wrap = jQuery( html, this[0].ownerDocument ).eq(0).clone(true); // 9389 // 9390 if ( this[0].parentNode ) { // 9391 wrap.insertBefore( this[0] ); // 9392 } // 9393 // 9394 wrap.map(function() { // 9395 var elem = this; // 9396 // 9397 while ( elem.firstChild && elem.firstChild.nodeType === 1 ) { // 9398 elem = elem.firstChild; // 9399 } // 9400 // 9401 return elem; // 9402 }).append( this ); // 9403 } // 9404 // 9405 return this; // 9406 }, // 9407 // 9408 wrapInner: function( html ) { // 9409 if ( jQuery.isFunction( html ) ) { // 9410 return this.each(function(i) { // 9411 jQuery(this).wrapInner( html.call(this, i) ); // 9412 }); // 9413 } // 9414 // 9415 return this.each(function() { // 9416 var self = jQuery( this ), // 9417 contents = self.contents(); // 9418 // 9419 if ( contents.length ) { // 9420 contents.wrapAll( html ); // 9421 // 9422 } else { // 9423 self.append( html ); // 9424 } // 9425 }); // 9426 }, // 9427 // 9428 wrap: function( html ) { // 9429 var isFunction = jQuery.isFunction( html ); // 9430 // 9431 return this.each(function(i) { // 9432 jQuery( this ).wrapAll( isFunction ? html.call(this, i) : html ); // 9433 }); // 9434 }, // 9435 // 9436 unwrap: function() { // 9437 return this.parent().each(function() { // 9438 if ( !jQuery.nodeName( this, "body" ) ) { // 9439 jQuery( this ).replaceWith( this.childNodes ); // 9440 } // 9441 }).end(); // 9442 } // 9443 }); // 9444 // 9445 // 9446 jQuery.expr.filters.hidden = function( elem ) { // 9447 // Support: Opera <= 12.12 // 9448 // Opera reports offsetWidths and offsetHeights less than zero on some elements // 9449 return elem.offsetWidth <= 0 && elem.offsetHeight <= 0 || // 9450 (!support.reliableHiddenOffsets() && // 9451 ((elem.style && elem.style.display) || jQuery.css( elem, "display" )) === "none"); // 9452 }; // 9453 // 9454 jQuery.expr.filters.visible = function( elem ) { // 9455 return !jQuery.expr.filters.hidden( elem ); // 9456 }; // 9457 // 9458 // 9459 // 9460 // 9461 var r20 = /%20/g, // 9462 rbracket = /\[\]$/, // 9463 rCRLF = /\r?\n/g, // 9464 rsubmitterTypes = /^(?:submit|button|image|reset|file)$/i, // 9465 rsubmittable = /^(?:input|select|textarea|keygen)/i; // 9466 // 9467 function buildParams( prefix, obj, traditional, add ) { // 9468 var name; // 9469 // 9470 if ( jQuery.isArray( obj ) ) { // 9471 // Serialize array item. // 9472 jQuery.each( obj, function( i, v ) { // 9473 if ( traditional || rbracket.test( prefix ) ) { // 9474 // Treat each array item as a scalar. // 9475 add( prefix, v ); // 9476 // 9477 } else { // 9478 // Item is non-scalar (array or object), encode its numeric index. // 9479 buildParams( prefix + "[" + ( typeof v === "object" ? i : "" ) + "]", v, traditional, add ); // 9480 } // 9481 }); // 9482 // 9483 } else if ( !traditional && jQuery.type( obj ) === "object" ) { // 9484 // Serialize object item. // 9485 for ( name in obj ) { // 9486 buildParams( prefix + "[" + name + "]", obj[ name ], traditional, add ); // 9487 } // 9488 // 9489 } else { // 9490 // Serialize scalar item. // 9491 add( prefix, obj ); // 9492 } // 9493 } // 9494 // 9495 // Serialize an array of form elements or a set of // 9496 // key/values into a query string // 9497 jQuery.param = function( a, traditional ) { // 9498 var prefix, // 9499 s = [], // 9500 add = function( key, value ) { // 9501 // If value is a function, invoke it and return its value // 9502 value = jQuery.isFunction( value ) ? value() : ( value == null ? "" : value ); // 9503 s[ s.length ] = encodeURIComponent( key ) + "=" + encodeURIComponent( value ); // 9504 }; // 9505 // 9506 // Set traditional to true for jQuery <= 1.3.2 behavior. // 9507 if ( traditional === undefined ) { // 9508 traditional = jQuery.ajaxSettings && jQuery.ajaxSettings.traditional; // 9509 } // 9510 // 9511 // If an array was passed in, assume that it is an array of form elements. // 9512 if ( jQuery.isArray( a ) || ( a.jquery && !jQuery.isPlainObject( a ) ) ) { // 9513 // Serialize the form elements // 9514 jQuery.each( a, function() { // 9515 add( this.name, this.value ); // 9516 }); // 9517 // 9518 } else { // 9519 // If traditional, encode the "old" way (the way 1.3.2 or older // 9520 // did it), otherwise encode params recursively. // 9521 for ( prefix in a ) { // 9522 buildParams( prefix, a[ prefix ], traditional, add ); // 9523 } // 9524 } // 9525 // 9526 // Return the resulting serialization // 9527 return s.join( "&" ).replace( r20, "+" ); // 9528 }; // 9529 // 9530 jQuery.fn.extend({ // 9531 serialize: function() { // 9532 return jQuery.param( this.serializeArray() ); // 9533 }, // 9534 serializeArray: function() { // 9535 return this.map(function() { // 9536 // Can add propHook for "elements" to filter or add form elements // 9537 var elements = jQuery.prop( this, "elements" ); // 9538 return elements ? jQuery.makeArray( elements ) : this; // 9539 }) // 9540 .filter(function() { // 9541 var type = this.type; // 9542 // Use .is(":disabled") so that fieldset[disabled] works // 9543 return this.name && !jQuery( this ).is( ":disabled" ) && // 9544 rsubmittable.test( this.nodeName ) && !rsubmitterTypes.test( type ) && // 9545 ( this.checked || !rcheckableType.test( type ) ); // 9546 }) // 9547 .map(function( i, elem ) { // 9548 var val = jQuery( this ).val(); // 9549 // 9550 return val == null ? // 9551 null : // 9552 jQuery.isArray( val ) ? // 9553 jQuery.map( val, function( val ) { // 9554 return { name: elem.name, value: val.replace( rCRLF, "\r\n" ) }; // 9555 }) : // 9556 { name: elem.name, value: val.replace( rCRLF, "\r\n" ) }; // 9557 }).get(); // 9558 } // 9559 }); // 9560 // 9561 // 9562 // Create the request object // 9563 // (This is still attached to ajaxSettings for backward compatibility) // 9564 jQuery.ajaxSettings.xhr = window.ActiveXObject !== undefined ? // 9565 // Support: IE6+ // 9566 function() { // 9567 // 9568 // XHR cannot access local files, always use ActiveX for that case // 9569 return !this.isLocal && // 9570 // 9571 // Support: IE7-8 // 9572 // oldIE XHR does not support non-RFC2616 methods (#13240) // 9573 // See http://msdn.microsoft.com/en-us/library/ie/ms536648(v=vs.85).aspx // 9574 // and http://www.w3.org/Protocols/rfc2616/rfc2616-sec9.html#sec9 // 9575 // Although this check for six methods instead of eight // 9576 // since IE also does not support "trace" and "connect" // 9577 /^(get|post|head|put|delete|options)$/i.test( this.type ) && // 9578 // 9579 createStandardXHR() || createActiveXHR(); // 9580 } : // 9581 // For all other browsers, use the standard XMLHttpRequest object // 9582 createStandardXHR; // 9583 // 9584 var xhrId = 0, // 9585 xhrCallbacks = {}, // 9586 xhrSupported = jQuery.ajaxSettings.xhr(); // 9587 // 9588 // Support: IE<10 // 9589 // Open requests must be manually aborted on unload (#5280) // 9590 // See https://support.microsoft.com/kb/2856746 for more info // 9591 if ( window.attachEvent ) { // 9592 window.attachEvent( "onunload", function() { // 9593 for ( var key in xhrCallbacks ) { // 9594 xhrCallbacks[ key ]( undefined, true ); // 9595 } // 9596 }); // 9597 } // 9598 // 9599 // Determine support properties // 9600 support.cors = !!xhrSupported && ( "withCredentials" in xhrSupported ); // 9601 xhrSupported = support.ajax = !!xhrSupported; // 9602 // 9603 // Create transport if the browser can provide an xhr // 9604 if ( xhrSupported ) { // 9605 // 9606 jQuery.ajaxTransport(function( options ) { // 9607 // Cross domain only allowed if supported through XMLHttpRequest // 9608 if ( !options.crossDomain || support.cors ) { // 9609 // 9610 var callback; // 9611 // 9612 return { // 9613 send: function( headers, complete ) { // 9614 var i, // 9615 xhr = options.xhr(), // 9616 id = ++xhrId; // 9617 // 9618 // Open the socket // 9619 xhr.open( options.type, options.url, options.async, options.username, options.password ); // 9620 // 9621 // Apply custom fields if provided // 9622 if ( options.xhrFields ) { // 9623 for ( i in options.xhrFields ) { // 9624 xhr[ i ] = options.xhrFields[ i ]; // 9625 } // 9626 } // 9627 // 9628 // Override mime type if needed // 9629 if ( options.mimeType && xhr.overrideMimeType ) { // 9630 xhr.overrideMimeType( options.mimeType ); // 9631 } // 9632 // 9633 // X-Requested-With header // 9634 // For cross-domain requests, seeing as conditions for a preflight are // 9635 // akin to a jigsaw puzzle, we simply never set it to be sure. // 9636 // (it can always be set on a per-request basis or even using ajaxSetup) // 9637 // For same-domain requests, won't change header if already provided. // 9638 if ( !options.crossDomain && !headers["X-Requested-With"] ) { // 9639 headers["X-Requested-With"] = "XMLHttpRequest"; // 9640 } // 9641 // 9642 // Set headers // 9643 for ( i in headers ) { // 9644 // Support: IE<9 // 9645 // IE's ActiveXObject throws a 'Type Mismatch' exception when setting // 9646 // request header to a null-value. // 9647 // // 9648 // To keep consistent with other XHR implementations, cast the value // 9649 // to string and ignore `undefined`. // 9650 if ( headers[ i ] !== undefined ) { // 9651 xhr.setRequestHeader( i, headers[ i ] + "" ); // 9652 } // 9653 } // 9654 // 9655 // Do send the request // 9656 // This may raise an exception which is actually // 9657 // handled in jQuery.ajax (so no try/catch here) // 9658 xhr.send( ( options.hasContent && options.data ) || null ); // 9659 // 9660 // Listener // 9661 callback = function( _, isAbort ) { // 9662 var status, statusText, responses; // 9663 // 9664 // Was never called and is aborted or complete // 9665 if ( callback && ( isAbort || xhr.readyState === 4 ) ) { // 9666 // Clean up // 9667 delete xhrCallbacks[ id ]; // 9668 callback = undefined; // 9669 xhr.onreadystatechange = jQuery.noop; // 9670 // 9671 // Abort manually if needed // 9672 if ( isAbort ) { // 9673 if ( xhr.readyState !== 4 ) { // 9674 xhr.abort(); // 9675 } // 9676 } else { // 9677 responses = {}; // 9678 status = xhr.status; // 9679 // 9680 // Support: IE<10 // 9681 // Accessing binary-data responseText throws an exception // 9682 // (#11426) // 9683 if ( typeof xhr.responseText === "string" ) { // 9684 responses.text = xhr.responseText; // 9685 } // 9686 // 9687 // Firefox throws an exception when accessing // 9688 // statusText for faulty cross-domain requests // 9689 try { // 9690 statusText = xhr.statusText; // 9691 } catch( e ) { // 9692 // We normalize with Webkit giving an empty statusText // 9693 statusText = ""; // 9694 } // 9695 // 9696 // Filter status for non standard behaviors // 9697 // 9698 // If the request is local and we have data: assume a success // 9699 // (success with no data won't get notified, that's the best we // 9700 // can do given current implementations) // 9701 if ( !status && options.isLocal && !options.crossDomain ) { // 9702 status = responses.text ? 200 : 404; // 9703 // IE - #1450: sometimes returns 1223 when it should be 204 // 9704 } else if ( status === 1223 ) { // 9705 status = 204; // 9706 } // 9707 } // 9708 } // 9709 // 9710 // Call complete if needed // 9711 if ( responses ) { // 9712 complete( status, statusText, responses, xhr.getAllResponseHeaders() ); // 9713 } // 9714 }; // 9715 // 9716 if ( !options.async ) { // 9717 // if we're in sync mode we fire the callback // 9718 callback(); // 9719 } else if ( xhr.readyState === 4 ) { // 9720 // (IE6 & IE7) if it's in cache and has been // 9721 // retrieved directly we need to fire the callback // 9722 setTimeout( callback ); // 9723 } else { // 9724 // Add to the list of active xhr callbacks // 9725 xhr.onreadystatechange = xhrCallbacks[ id ] = callback; // 9726 } // 9727 }, // 9728 // 9729 abort: function() { // 9730 if ( callback ) { // 9731 callback( undefined, true ); // 9732 } // 9733 } // 9734 }; // 9735 } // 9736 }); // 9737 } // 9738 // 9739 // Functions to create xhrs // 9740 function createStandardXHR() { // 9741 try { // 9742 return new window.XMLHttpRequest(); // 9743 } catch( e ) {} // 9744 } // 9745 // 9746 function createActiveXHR() { // 9747 try { // 9748 return new window.ActiveXObject( "Microsoft.XMLHTTP" ); // 9749 } catch( e ) {} // 9750 } // 9751 // 9752 // 9753 // 9754 // 9755 // Install script dataType // 9756 jQuery.ajaxSetup({ // 9757 accepts: { // 9758 script: "text/javascript, application/javascript, application/ecmascript, application/x-ecmascript" // 9759 }, // 9760 contents: { // 9761 script: /(?:java|ecma)script/ // 9762 }, // 9763 converters: { // 9764 "text script": function( text ) { // 9765 jQuery.globalEval( text ); // 9766 return text; // 9767 } // 9768 } // 9769 }); // 9770 // 9771 // Handle cache's special case and global // 9772 jQuery.ajaxPrefilter( "script", function( s ) { // 9773 if ( s.cache === undefined ) { // 9774 s.cache = false; // 9775 } // 9776 if ( s.crossDomain ) { // 9777 s.type = "GET"; // 9778 s.global = false; // 9779 } // 9780 }); // 9781 // 9782 // Bind script tag hack transport // 9783 jQuery.ajaxTransport( "script", function(s) { // 9784 // 9785 // This transport only deals with cross domain requests // 9786 if ( s.crossDomain ) { // 9787 // 9788 var script, // 9789 head = document.head || jQuery("head")[0] || document.documentElement; // 9790 // 9791 return { // 9792 // 9793 send: function( _, callback ) { // 9794 // 9795 script = document.createElement("script"); // 9796 // 9797 script.async = true; // 9798 // 9799 if ( s.scriptCharset ) { // 9800 script.charset = s.scriptCharset; // 9801 } // 9802 // 9803 script.src = s.url; // 9804 // 9805 // Attach handlers for all browsers // 9806 script.onload = script.onreadystatechange = function( _, isAbort ) { // 9807 // 9808 if ( isAbort || !script.readyState || /loaded|complete/.test( script.readyState ) ) { // 9809 // 9810 // Handle memory leak in IE // 9811 script.onload = script.onreadystatechange = null; // 9812 // 9813 // Remove the script // 9814 if ( script.parentNode ) { // 9815 script.parentNode.removeChild( script ); // 9816 } // 9817 // 9818 // Dereference the script // 9819 script = null; // 9820 // 9821 // Callback if not abort // 9822 if ( !isAbort ) { // 9823 callback( 200, "success" ); // 9824 } // 9825 } // 9826 }; // 9827 // 9828 // Circumvent IE6 bugs with base elements (#2709 and #4378) by prepending // 9829 // Use native DOM manipulation to avoid our domManip AJAX trickery // 9830 head.insertBefore( script, head.firstChild ); // 9831 }, // 9832 // 9833 abort: function() { // 9834 if ( script ) { // 9835 script.onload( undefined, true ); // 9836 } // 9837 } // 9838 }; // 9839 } // 9840 }); // 9841 // 9842 // 9843 // 9844 // 9845 var oldCallbacks = [], // 9846 rjsonp = /(=)\?(?=&|$)|\?\?/; // 9847 // 9848 // Default jsonp settings // 9849 jQuery.ajaxSetup({ // 9850 jsonp: "callback", // 9851 jsonpCallback: function() { // 9852 var callback = oldCallbacks.pop() || ( jQuery.expando + "_" + ( nonce++ ) ); // 9853 this[ callback ] = true; // 9854 return callback; // 9855 } // 9856 }); // 9857 // 9858 // Detect, normalize options and install callbacks for jsonp requests // 9859 jQuery.ajaxPrefilter( "json jsonp", function( s, originalSettings, jqXHR ) { // 9860 // 9861 var callbackName, overwritten, responseContainer, // 9862 jsonProp = s.jsonp !== false && ( rjsonp.test( s.url ) ? // 9863 "url" : // 9864 typeof s.data === "string" && !( s.contentType || "" ).indexOf("application/x-www-form-urlencoded") && rjsonp.test( s.data ) && "data" ); // 9866 // 9867 // Handle iff the expected data type is "jsonp" or we have a parameter to set // 9868 if ( jsonProp || s.dataTypes[ 0 ] === "jsonp" ) { // 9869 // 9870 // Get callback name, remembering preexisting value associated with it // 9871 callbackName = s.jsonpCallback = jQuery.isFunction( s.jsonpCallback ) ? // 9872 s.jsonpCallback() : // 9873 s.jsonpCallback; // 9874 // 9875 // Insert callback into url or form data // 9876 if ( jsonProp ) { // 9877 s[ jsonProp ] = s[ jsonProp ].replace( rjsonp, "$1" + callbackName ); // 9878 } else if ( s.jsonp !== false ) { // 9879 s.url += ( rquery.test( s.url ) ? "&" : "?" ) + s.jsonp + "=" + callbackName; // 9880 } // 9881 // 9882 // Use data converter to retrieve json after script execution // 9883 s.converters["script json"] = function() { // 9884 if ( !responseContainer ) { // 9885 jQuery.error( callbackName + " was not called" ); // 9886 } // 9887 return responseContainer[ 0 ]; // 9888 }; // 9889 // 9890 // force json dataType // 9891 s.dataTypes[ 0 ] = "json"; // 9892 // 9893 // Install callback // 9894 overwritten = window[ callbackName ]; // 9895 window[ callbackName ] = function() { // 9896 responseContainer = arguments; // 9897 }; // 9898 // 9899 // Clean-up function (fires after converters) // 9900 jqXHR.always(function() { // 9901 // Restore preexisting value // 9902 window[ callbackName ] = overwritten; // 9903 // 9904 // Save back as free // 9905 if ( s[ callbackName ] ) { // 9906 // make sure that re-using the options doesn't screw things around // 9907 s.jsonpCallback = originalSettings.jsonpCallback; // 9908 // 9909 // save the callback name for future use // 9910 oldCallbacks.push( callbackName ); // 9911 } // 9912 // 9913 // Call if it was a function and we have a response // 9914 if ( responseContainer && jQuery.isFunction( overwritten ) ) { // 9915 overwritten( responseContainer[ 0 ] ); // 9916 } // 9917 // 9918 responseContainer = overwritten = undefined; // 9919 }); // 9920 // 9921 // Delegate to script // 9922 return "script"; // 9923 } // 9924 }); // 9925 // 9926 // 9927 // 9928 // 9929 // data: string of html // 9930 // context (optional): If specified, the fragment will be created in this context, defaults to document // 9931 // keepScripts (optional): If true, will include scripts passed in the html string // 9932 jQuery.parseHTML = function( data, context, keepScripts ) { // 9933 if ( !data || typeof data !== "string" ) { // 9934 return null; // 9935 } // 9936 if ( typeof context === "boolean" ) { // 9937 keepScripts = context; // 9938 context = false; // 9939 } // 9940 context = context || document; // 9941 // 9942 var parsed = rsingleTag.exec( data ), // 9943 scripts = !keepScripts && []; // 9944 // 9945 // Single tag // 9946 if ( parsed ) { // 9947 return [ context.createElement( parsed[1] ) ]; // 9948 } // 9949 // 9950 parsed = jQuery.buildFragment( [ data ], context, scripts ); // 9951 // 9952 if ( scripts && scripts.length ) { // 9953 jQuery( scripts ).remove(); // 9954 } // 9955 // 9956 return jQuery.merge( [], parsed.childNodes ); // 9957 }; // 9958 // 9959 // 9960 // Keep a copy of the old load method // 9961 var _load = jQuery.fn.load; // 9962 // 9963 /** // 9964 * Load a url into a page // 9965 */ // 9966 jQuery.fn.load = function( url, params, callback ) { // 9967 if ( typeof url !== "string" && _load ) { // 9968 return _load.apply( this, arguments ); // 9969 } // 9970 // 9971 var selector, response, type, // 9972 self = this, // 9973 off = url.indexOf(" "); // 9974 // 9975 if ( off >= 0 ) { // 9976 selector = jQuery.trim( url.slice( off, url.length ) ); // 9977 url = url.slice( 0, off ); // 9978 } // 9979 // 9980 // If it's a function // 9981 if ( jQuery.isFunction( params ) ) { // 9982 // 9983 // We assume that it's the callback // 9984 callback = params; // 9985 params = undefined; // 9986 // 9987 // Otherwise, build a param string // 9988 } else if ( params && typeof params === "object" ) { // 9989 type = "POST"; // 9990 } // 9991 // 9992 // If we have elements to modify, make the request // 9993 if ( self.length > 0 ) { // 9994 jQuery.ajax({ // 9995 url: url, // 9996 // 9997 // if "type" variable is undefined, then "GET" method will be used // 9998 type: type, // 9999 dataType: "html", // 10000 data: params // 10001 }).done(function( responseText ) { // 10002 // 10003 // Save response for use in complete callback // 10004 response = arguments; // 10005 // 10006 self.html( selector ? // 10007 // 10008 // If a selector was specified, locate the right elements in a dummy div // 10009 // Exclude scripts to avoid IE 'Permission Denied' errors // 10010 jQuery("<div>").append( jQuery.parseHTML( responseText ) ).find( selector ) : // 10011 // 10012 // Otherwise use the full result // 10013 responseText ); // 10014 // 10015 }).complete( callback && function( jqXHR, status ) { // 10016 self.each( callback, response || [ jqXHR.responseText, status, jqXHR ] ); // 10017 }); // 10018 } // 10019 // 10020 return this; // 10021 }; // 10022 // 10023 // 10024 // 10025 // 10026 // Attach a bunch of functions for handling common AJAX events // 10027 jQuery.each( [ "ajaxStart", "ajaxStop", "ajaxComplete", "ajaxError", "ajaxSuccess", "ajaxSend" ], function( i, type ) { jQuery.fn[ type ] = function( fn ) { // 10029 return this.on( type, fn ); // 10030 }; // 10031 }); // 10032 // 10033 // 10034 // 10035 // 10036 jQuery.expr.filters.animated = function( elem ) { // 10037 return jQuery.grep(jQuery.timers, function( fn ) { // 10038 return elem === fn.elem; // 10039 }).length; // 10040 }; // 10041 // 10042 // 10043 // 10044 // 10045 // 10046 var docElem = window.document.documentElement; // 10047 // 10048 /** // 10049 * Gets a window from an element // 10050 */ // 10051 function getWindow( elem ) { // 10052 return jQuery.isWindow( elem ) ? // 10053 elem : // 10054 elem.nodeType === 9 ? // 10055 elem.defaultView || elem.parentWindow : // 10056 false; // 10057 } // 10058 // 10059 jQuery.offset = { // 10060 setOffset: function( elem, options, i ) { // 10061 var curPosition, curLeft, curCSSTop, curTop, curOffset, curCSSLeft, calculatePosition, // 10062 position = jQuery.css( elem, "position" ), // 10063 curElem = jQuery( elem ), // 10064 props = {}; // 10065 // 10066 // set position first, in-case top/left are set even on static elem // 10067 if ( position === "static" ) { // 10068 elem.style.position = "relative"; // 10069 } // 10070 // 10071 curOffset = curElem.offset(); // 10072 curCSSTop = jQuery.css( elem, "top" ); // 10073 curCSSLeft = jQuery.css( elem, "left" ); // 10074 calculatePosition = ( position === "absolute" || position === "fixed" ) && // 10075 jQuery.inArray("auto", [ curCSSTop, curCSSLeft ] ) > -1; // 10076 // 10077 // need to be able to calculate position if either top or left is auto and position is either absolute or fixed // 10078 if ( calculatePosition ) { // 10079 curPosition = curElem.position(); // 10080 curTop = curPosition.top; // 10081 curLeft = curPosition.left; // 10082 } else { // 10083 curTop = parseFloat( curCSSTop ) || 0; // 10084 curLeft = parseFloat( curCSSLeft ) || 0; // 10085 } // 10086 // 10087 if ( jQuery.isFunction( options ) ) { // 10088 options = options.call( elem, i, curOffset ); // 10089 } // 10090 // 10091 if ( options.top != null ) { // 10092 props.top = ( options.top - curOffset.top ) + curTop; // 10093 } // 10094 if ( options.left != null ) { // 10095 props.left = ( options.left - curOffset.left ) + curLeft; // 10096 } // 10097 // 10098 if ( "using" in options ) { // 10099 options.using.call( elem, props ); // 10100 } else { // 10101 curElem.css( props ); // 10102 } // 10103 } // 10104 }; // 10105 // 10106 jQuery.fn.extend({ // 10107 offset: function( options ) { // 10108 if ( arguments.length ) { // 10109 return options === undefined ? // 10110 this : // 10111 this.each(function( i ) { // 10112 jQuery.offset.setOffset( this, options, i ); // 10113 }); // 10114 } // 10115 // 10116 var docElem, win, // 10117 box = { top: 0, left: 0 }, // 10118 elem = this[ 0 ], // 10119 doc = elem && elem.ownerDocument; // 10120 // 10121 if ( !doc ) { // 10122 return; // 10123 } // 10124 // 10125 docElem = doc.documentElement; // 10126 // 10127 // Make sure it's not a disconnected DOM node // 10128 if ( !jQuery.contains( docElem, elem ) ) { // 10129 return box; // 10130 } // 10131 // 10132 // If we don't have gBCR, just use 0,0 rather than error // 10133 // BlackBerry 5, iOS 3 (original iPhone) // 10134 if ( typeof elem.getBoundingClientRect !== strundefined ) { // 10135 box = elem.getBoundingClientRect(); // 10136 } // 10137 win = getWindow( doc ); // 10138 return { // 10139 top: box.top + ( win.pageYOffset || docElem.scrollTop ) - ( docElem.clientTop || 0 ), // 10140 left: box.left + ( win.pageXOffset || docElem.scrollLeft ) - ( docElem.clientLeft || 0 ) // 10141 }; // 10142 }, // 10143 // 10144 position: function() { // 10145 if ( !this[ 0 ] ) { // 10146 return; // 10147 } // 10148 // 10149 var offsetParent, offset, // 10150 parentOffset = { top: 0, left: 0 }, // 10151 elem = this[ 0 ]; // 10152 // 10153 // fixed elements are offset from window (parentOffset = {top:0, left: 0}, because it is its only offset parent // 10154 if ( jQuery.css( elem, "position" ) === "fixed" ) { // 10155 // we assume that getBoundingClientRect is available when computed position is fixed // 10156 offset = elem.getBoundingClientRect(); // 10157 } else { // 10158 // Get *real* offsetParent // 10159 offsetParent = this.offsetParent(); // 10160 // 10161 // Get correct offsets // 10162 offset = this.offset(); // 10163 if ( !jQuery.nodeName( offsetParent[ 0 ], "html" ) ) { // 10164 parentOffset = offsetParent.offset(); // 10165 } // 10166 // 10167 // Add offsetParent borders // 10168 parentOffset.top += jQuery.css( offsetParent[ 0 ], "borderTopWidth", true ); // 10169 parentOffset.left += jQuery.css( offsetParent[ 0 ], "borderLeftWidth", true ); // 10170 } // 10171 // 10172 // Subtract parent offsets and element margins // 10173 // note: when an element has margin: auto the offsetLeft and marginLeft // 10174 // are the same in Safari causing offset.left to incorrectly be 0 // 10175 return { // 10176 top: offset.top - parentOffset.top - jQuery.css( elem, "marginTop", true ), // 10177 left: offset.left - parentOffset.left - jQuery.css( elem, "marginLeft", true) // 10178 }; // 10179 }, // 10180 // 10181 offsetParent: function() { // 10182 return this.map(function() { // 10183 var offsetParent = this.offsetParent || docElem; // 10184 // 10185 while ( offsetParent && ( !jQuery.nodeName( offsetParent, "html" ) && jQuery.css( offsetParent, "position" ) === "static" ) ) { offsetParent = offsetParent.offsetParent; // 10187 } // 10188 return offsetParent || docElem; // 10189 }); // 10190 } // 10191 }); // 10192 // 10193 // Create scrollLeft and scrollTop methods // 10194 jQuery.each( { scrollLeft: "pageXOffset", scrollTop: "pageYOffset" }, function( method, prop ) { // 10195 var top = /Y/.test( prop ); // 10196 // 10197 jQuery.fn[ method ] = function( val ) { // 10198 return access( this, function( elem, method, val ) { // 10199 var win = getWindow( elem ); // 10200 // 10201 if ( val === undefined ) { // 10202 return win ? (prop in win) ? win[ prop ] : // 10203 win.document.documentElement[ method ] : // 10204 elem[ method ]; // 10205 } // 10206 // 10207 if ( win ) { // 10208 win.scrollTo( // 10209 !top ? val : jQuery( win ).scrollLeft(), // 10210 top ? val : jQuery( win ).scrollTop() // 10211 ); // 10212 // 10213 } else { // 10214 elem[ method ] = val; // 10215 } // 10216 }, method, val, arguments.length, null ); // 10217 }; // 10218 }); // 10219 // 10220 // Add the top/left cssHooks using jQuery.fn.position // 10221 // Webkit bug: https://bugs.webkit.org/show_bug.cgi?id=29084 // 10222 // getComputedStyle returns percent when specified for top/left/bottom/right // 10223 // rather than make the css module depend on the offset module, we just check for it here // 10224 jQuery.each( [ "top", "left" ], function( i, prop ) { // 10225 jQuery.cssHooks[ prop ] = addGetHookIf( support.pixelPosition, // 10226 function( elem, computed ) { // 10227 if ( computed ) { // 10228 computed = curCSS( elem, prop ); // 10229 // if curCSS returns percentage, fallback to offset // 10230 return rnumnonpx.test( computed ) ? // 10231 jQuery( elem ).position()[ prop ] + "px" : // 10232 computed; // 10233 } // 10234 } // 10235 ); // 10236 }); // 10237 // 10238 // 10239 // Create innerHeight, innerWidth, height, width, outerHeight and outerWidth methods // 10240 jQuery.each( { Height: "height", Width: "width" }, function( name, type ) { // 10241 jQuery.each( { padding: "inner" + name, content: type, "": "outer" + name }, function( defaultExtra, funcName ) { // 10242 // margin is only for outerHeight, outerWidth // 10243 jQuery.fn[ funcName ] = function( margin, value ) { // 10244 var chainable = arguments.length && ( defaultExtra || typeof margin !== "boolean" ), // 10245 extra = defaultExtra || ( margin === true || value === true ? "margin" : "border" ); // 10246 // 10247 return access( this, function( elem, type, value ) { // 10248 var doc; // 10249 // 10250 if ( jQuery.isWindow( elem ) ) { // 10251 // As of 5/8/2012 this will yield incorrect results for Mobile Safari, but there // 10252 // isn't a whole lot we can do. See pull request at this URL for discussion: // 10253 // https://github.com/jquery/jquery/pull/764 // 10254 return elem.document.documentElement[ "client" + name ]; // 10255 } // 10256 // 10257 // Get document width or height // 10258 if ( elem.nodeType === 9 ) { // 10259 doc = elem.documentElement; // 10260 // 10261 // Either scroll[Width/Height] or offset[Width/Height] or client[Width/Height], whichever is greatest // 10262 // unfortunately, this causes bug #3838 in IE6/8 only, but there is currently no good, small way to fix it. // 10263 return Math.max( // 10264 elem.body[ "scroll" + name ], doc[ "scroll" + name ], // 10265 elem.body[ "offset" + name ], doc[ "offset" + name ], // 10266 doc[ "client" + name ] // 10267 ); // 10268 } // 10269 // 10270 return value === undefined ? // 10271 // Get width or height on the element, requesting but not forcing parseFloat // 10272 jQuery.css( elem, type, extra ) : // 10273 // 10274 // Set width or height on the element // 10275 jQuery.style( elem, type, value, extra ); // 10276 }, type, chainable ? margin : undefined, chainable, null ); // 10277 }; // 10278 }); // 10279 }); // 10280 // 10281 // 10282 // The number of elements contained in the matched element set // 10283 jQuery.fn.size = function() { // 10284 return this.length; // 10285 }; // 10286 // 10287 jQuery.fn.andSelf = jQuery.fn.addBack; // 10288 // 10289 // 10290 // 10291 // 10292 // Register as a named AMD module, since jQuery can be concatenated with other // 10293 // files that may use define, but not via a proper concatenation script that // 10294 // understands anonymous AMD modules. A named AMD is safest and most robust // 10295 // way to register. Lowercase jquery is used because AMD module names are // 10296 // derived from file names, and jQuery is normally delivered in a lowercase // 10297 // file name. Do this after creating the global so that if an AMD module wants // 10298 // to call noConflict to hide this version of jQuery, it will work. // 10299 // 10300 // Note that for maximum portability, libraries that are not jQuery should // 10301 // declare themselves as anonymous modules, and avoid setting a global if an // 10302 // AMD loader is present. jQuery is a special case. For more information, see // 10303 // https://github.com/jrburke/requirejs/wiki/Updating-existing-libraries#wiki-anon // 10304 // 10305 if ( typeof define === "function" && define.amd ) { // 10306 define( "jquery", [], function() { // 10307 return jQuery; // 10308 }); // 10309 } // 10310 // 10311 // 10312 // 10313 // 10314 var // 10315 // Map over jQuery in case of overwrite // 10316 _jQuery = window.jQuery, // 10317 // 10318 // Map over the $ in case of overwrite // 10319 _$ = window.$; // 10320 // 10321 jQuery.noConflict = function( deep ) { // 10322 if ( window.$ === jQuery ) { // 10323 window.$ = _$; // 10324 } // 10325 // 10326 if ( deep && window.jQuery === jQuery ) { // 10327 window.jQuery = _jQuery; // 10328 } // 10329 // 10330 return jQuery; // 10331 }; // 10332 // 10333 // Expose jQuery and $ identifiers, even in // 10334 // AMD (#7102#comment:10, https://github.com/jquery/jquery/pull/557) // 10335 // and CommonJS for browser emulators (#13566) // 10336 if ( typeof noGlobal === strundefined ) { // 10337 window.jQuery = window.$ = jQuery; // 10338 } // 10339 // 10340 // 10341 // 10342 // 10343 return jQuery; // 10344 // 10345 })); // 10346 // 10347 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// }).call(this); (function () { /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // // // packages/jquery/post.js // // // /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // // Put jQuery and $ in our exported package-scope variables and remove window.$. // 1 // (Sadly, we don't call noConflict(true), which would also remove // 2 // window.jQuery, because bootstrap very specifically relies on window.jQuery.) // 3 $ = jQuery = window.jQuery.noConflict(); // 4 // 5 /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// }).call(this); /* Exports */ if (typeof Package === 'undefined') Package = {}; Package.jquery = { $: $, jQuery: jQuery }; })();