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