vendor: 78 bytes, lines 1-3
1/******/ (() => { // webpackBootstrap 2/******/ var __webpack_modules__ = ({ 3
vendor: 285,755 bytes, lines 4-10730
4/***/ "./node_modules/jquery/dist/jquery.js": 5/*!********************************************!*\ 6 !*** ./node_modules/jquery/dist/jquery.js ***! 7 \********************************************/ 8/***/ (function(module, exports) { 9 10var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/*! 11 * jQuery JavaScript Library v3.7.1 12 * https://jquery.com/ 13 * 14 * Copyright OpenJS Foundation and other contributors 15 * Released under the MIT license 16 * https://jquery.org/license 17 * 18 * Date: 2023-08-28T13:37Z 19 */ 20( function( global, factory ) { 21 22 "use strict"; 23 24 if ( true && typeof module.exports === "object" ) { 25 26 // For CommonJS and CommonJS-like environments where a proper `window` 27 // is present, execute the factory and get jQuery. 28 // For environments that do not have a `window` with a `document` 29 // (such as Node.js), expose a factory as module.exports. 30 // This accentuates the need for the creation of a real `window`. 31 // e.g. var jQuery = require("jquery")(window); 32 // See ticket trac-14549 for more info. 33 module.exports = global.document ? 34 factory( global, true ) : 35 function( w ) { 36 if ( !w.document ) { 37 throw new Error( "jQuery requires a window with a document" ); 38 } 39 return factory( w ); 40 }; 41 } else { 42 factory( global ); 43 } 44 45// Pass this if window is not defined yet 46} )( typeof window !== "undefined" ? window : this, function( window, noGlobal ) { 47 48// Edge <= 12 - 13+, Firefox <=18 - 45+, IE 10 - 11, Safari 5.1 - 9+, iOS 6 - 9.1 49// throw exceptions when non-strict code (e.g., ASP.NET 4.5) accesses strict mode 50// arguments.callee.caller (trac-13335). But as of jQuery 3.0 (2016), strict mode should be common 51// enough that all such attempts are guarded in a try block. 52"use strict"; 53 54var arr = []; 55 56var getProto = Object.getPrototypeOf; 57 58var slice = arr.slice; 59 60var flat = arr.flat ? function( array ) { 61 return arr.flat.call( array ); 62} : function( array ) { 63 return arr.concat.apply( [], array ); 64}; 65 66 67var push = arr.push; 68 69var indexOf = arr.indexOf; 70 71var class2type = {}; 72 73var toString = class2type.toString; 74 75var hasOwn = class2type.hasOwnProperty; 76 77var fnToString = hasOwn.toString; 78 79var ObjectFunctionString = fnToString.call( Object ); 80 81var support = {}; 82 83var isFunction = function isFunction( obj ) { 84 85 // Support: Chrome <=57, Firefox <=52 86 // In some browsers, typeof returns "function" for HTML <object> elements 87 // (i.e., `typeof document.createElement( "object" ) === "function"`). 88 // We don't want to classify *any* DOM node as a function. 89 // Support: QtWeb <=3.8.5, WebKit <=534.34, wkhtmltopdf tool <=0.12.5 90 // Plus for old WebKit, typeof returns "function" for HTML collections 91 // (e.g., `typeof document.getElementsByTagName("div") === "function"`). (gh-4756) 92 return typeof obj === "function" && typeof obj.nodeType !== "number" && 93 typeof obj.item !== "function"; 94 }; 95 96 97var isWindow = function isWindow( obj ) { 98 return obj != null && obj === obj.window; 99 }; 100 101 102var document = window.document; 103 104 105 106 var preservedScriptAttributes = { 107 type: true, 108 src: true, 109 nonce: true, 110 noModule: true 111 }; 112 113 function DOMEval( code, node, doc ) { 114 doc = doc || document; 115 116 var i, val, 117 script = doc.createElement( "script" ); 118 119 script.text = code; 120 if ( node ) { 121 for ( i in preservedScriptAttributes ) { 122 123 // Support: Firefox 64+, Edge 18+ 124 // Some browsers don't support the "nonce" property on scripts. 125 // On the other hand, just using `getAttribute` is not enough as 126 // the `nonce` attribute is reset to an empty string whenever it 127 // becomes browsing-context connected. 128 // See https://github.com/whatwg/html/issues/2369 129 // See https://html.spec.whatwg.org/#nonce-attributes 130 // The `node.getAttribute` check was added for the sake of 131 // `jQuery.globalEval` so that it can fake a nonce-containing node 132 // via an object. 133 val = node[ i ] || node.getAttribute && node.getAttribute( i ); 134 if ( val ) { 135 script.setAttribute( i, val ); 136 } 137 } 138 } 139 doc.head.appendChild( script ).parentNode.removeChild( script ); 140 } 141 142 143function toType( obj ) { 144 if ( obj == null ) { 145 return obj + ""; 146 } 147 148 // Support: Android <=2.3 only (functionish RegExp) 149 return typeof obj === "object" || typeof obj === "function" ? 150 class2type[ toString.call( obj ) ] || "object" : 151 typeof obj; 152} 153/* global Symbol */ 154// Defining this global in .eslintrc.json would create a danger of using the global 155// unguarded in another place, it seems safer to define global only for this module 156 157 158 159var version = "3.7.1", 160 161 rhtmlSuffix = /HTML$/i, 162 163 // Define a local copy of jQuery 164 jQuery = function( selector, context ) { 165 166 // The jQuery object is actually just the init constructor 'enhanced' 167 // Need init if jQuery is called (just allow error to be thrown if not included) 168 return new jQuery.fn.init( selector, context ); 169 }; 170 171jQuery.fn = jQuery.prototype = { 172 173 // The current version of jQuery being used 174 jquery: version, 175 176 constructor: jQuery, 177 178 // The default length of a jQuery object is 0 179 length: 0, 180 181 toArray: function() { 182 return slice.call( this ); 183 }, 184 185 // Get the Nth element in the matched element set OR 186 // Get the whole matched element set as a clean array 187 get: function( num ) { 188 189 // Return all the elements in a clean array 190 if ( num == null ) { 191 return slice.call( this ); 192 } 193 194 // Return just the one element from the set 195 return num < 0 ? this[ num + this.length ] : this[ num ]; 196 }, 197 198 // Take an array of elements and push it onto the stack 199 // (returning the new matched element set) 200 pushStack: function( elems ) { 201 202 // Build a new jQuery matched element set 203 var ret = jQuery.merge( this.constructor(), elems ); 204 205 // Add the old object onto the stack (as a reference) 206 ret.prevObject = this; 207 208 // Return the newly-formed element set 209 return ret; 210 }, 211 212 // Execute a callback for every element in the matched set. 213 each: function( callback ) { 214 return jQuery.each( this, callback ); 215 }, 216 217 map: function( callback ) { 218 return this.pushStack( jQuery.map( this, function( elem, i ) { 219 return callback.call( elem, i, elem ); 220 } ) ); 221 }, 222 223 slice: function() { 224 return this.pushStack( slice.apply( this, arguments ) ); 225 }, 226 227 first: function() { 228 return this.eq( 0 ); 229 }, 230 231 last: function() { 232 return this.eq( -1 ); 233 }, 234 235 even: function() { 236 return this.pushStack( jQuery.grep( this, function( _elem, i ) { 237 return ( i + 1 ) % 2; 238 } ) ); 239 }, 240 241 odd: function() { 242 return this.pushStack( jQuery.grep( this, function( _elem, i ) { 243 return i % 2; 244 } ) ); 245 }, 246 247 eq: function( i ) { 248 var len = this.length, 249 j = +i + ( i < 0 ? len : 0 ); 250 return this.pushStack( j >= 0 && j < len ? [ this[ j ] ] : [] ); 251 }, 252 253 end: function() { 254 return this.prevObject || this.constructor(); 255 }, 256 257 // For internal use only. 258 // Behaves like an Array's method, not like a jQuery method. 259 push: push, 260 sort: arr.sort, 261 splice: arr.splice 262}; 263 264jQuery.extend = jQuery.fn.extend = function() { 265 var options, name, src, copy, copyIsArray, clone, 266 target = arguments[ 0 ] || {}, 267 i = 1, 268 length = arguments.length, 269 deep = false; 270 271 // Handle a deep copy situation 272 if ( typeof target === "boolean" ) { 273 deep = target; 274 275 // Skip the boolean and the target 276 target = arguments[ i ] || {}; 277 i++; 278 } 279 280 // Handle case when target is a string or something (possible in deep copy) 281 if ( typeof target !== "object" && !isFunction( target ) ) { 282 target = {}; 283 } 284 285 // Extend jQuery itself if only one argument is passed 286 if ( i === length ) { 287 target = this; 288 i--; 289 } 290 291 for ( ; i < length; i++ ) { 292 293 // Only deal with non-null/undefined values 294 if ( ( options = arguments[ i ] ) != null ) { 295 296 // Extend the base object 297 for ( name in options ) { 298 copy = options[ name ]; 299 300 // Prevent Object.prototype pollution 301 // Prevent never-ending loop 302 if ( name === "__proto__" || target === copy ) { 303 continue; 304 } 305 306 // Recurse if we're merging plain objects or arrays 307 if ( deep && copy && ( jQuery.isPlainObject( copy ) || 308 ( copyIsArray = Array.isArray( copy ) ) ) ) { 309 src = target[ name ]; 310 311 // Ensure proper type for the source value 312 if ( copyIsArray && !Array.isArray( src ) ) { 313 clone = []; 314 } else if ( !copyIsArray && !jQuery.isPlainObject( src ) ) { 315 clone = {}; 316 } else { 317 clone = src; 318 } 319 copyIsArray = false; 320 321 // Never move original objects, clone them 322 target[ name ] = jQuery.extend( deep, clone, copy ); 323 324 // Don't bring in undefined values 325 } else if ( copy !== undefined ) { 326 target[ name ] = copy; 327 } 328 } 329 } 330 } 331 332 // Return the modified object 333 return target; 334}; 335 336jQuery.extend( { 337 338 // Unique for each copy of jQuery on the page 339 expando: "jQuery" + ( version + Math.random() ).replace( /\D/g, "" ), 340 341 // Assume jQuery is ready without the ready module 342 isReady: true, 343 344 error: function( msg ) { 345 throw new Error( msg ); 346 }, 347 348 noop: function() {}, 349 350 isPlainObject: function( obj ) { 351 var proto, Ctor; 352 353 // Detect obvious negatives 354 // Use toString instead of jQuery.type to catch host objects 355 if ( !obj || toString.call( obj ) !== "[object Object]" ) { 356 return false; 357 } 358 359 proto = getProto( obj ); 360 361 // Objects with no prototype (e.g., `Object.create( null )`) are plain 362 if ( !proto ) { 363 return true; 364 } 365 366 // Objects with prototype are plain iff they were constructed by a global Object function 367 Ctor = hasOwn.call( proto, "constructor" ) && proto.constructor; 368 return typeof Ctor === "function" && fnToString.call( Ctor ) === ObjectFunctionString; 369 }, 370 371 isEmptyObject: function( obj ) { 372 var name; 373 374 for ( name in obj ) { 375 return false; 376 } 377 return true; 378 }, 379 380 // Evaluates a script in a provided context; falls back to the global one 381 // if not specified. 382 globalEval: function( code, options, doc ) { 383 DOMEval( code, { nonce: options && options.nonce }, doc ); 384 }, 385 386 each: function( obj, callback ) { 387 var length, i = 0; 388 389 if ( isArrayLike( obj ) ) { 390 length = obj.length; 391 for ( ; i < length; i++ ) { 392 if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) { 393 break; 394 } 395 } 396 } else { 397 for ( i in obj ) { 398 if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) { 399 break; 400 } 401 } 402 } 403 404 return obj; 405 }, 406 407 408 // Retrieve the text value of an array of DOM nodes 409 text: function( elem ) { 410 var node, 411 ret = "", 412 i = 0, 413 nodeType = elem.nodeType; 414 415 if ( !nodeType ) { 416 417 // If no nodeType, this is expected to be an array 418 while ( ( node = elem[ i++ ] ) ) { 419 420 // Do not traverse comment nodes 421 ret += jQuery.text( node ); 422 } 423 } 424 if ( nodeType === 1 || nodeType === 11 ) { 425 return elem.textContent; 426 } 427 if ( nodeType === 9 ) { 428 return elem.documentElement.textContent; 429 } 430 if ( nodeType === 3 || nodeType === 4 ) { 431 return elem.nodeValue; 432 } 433 434 // Do not include comment or processing instruction nodes 435 436 return ret; 437 }, 438 439 // results is for internal usage only 440 makeArray: function( arr, results ) { 441 var ret = results || []; 442 443 if ( arr != null ) { 444 if ( isArrayLike( Object( arr ) ) ) { 445 jQuery.merge( ret, 446 typeof arr === "string" ? 447 [ arr ] : arr 448 ); 449 } else { 450 push.call( ret, arr ); 451 } 452 } 453 454 return ret; 455 }, 456 457 inArray: function( elem, arr, i ) { 458 return arr == null ? -1 : indexOf.call( arr, elem, i ); 459 }, 460 461 isXMLDoc: function( elem ) { 462 var namespace = elem && elem.namespaceURI, 463 docElem = elem && ( elem.ownerDocument || elem ).documentElement; 464 465 // Assume HTML when documentElement doesn't yet exist, such as inside 466 // document fragments. 467 return !rhtmlSuffix.test( namespace || docElem && docElem.nodeName || "HTML" ); 468 }, 469 470 // Support: Android <=4.0 only, PhantomJS 1 only 471 // push.apply(_, arraylike) throws on ancient WebKit 472 merge: function( first, second ) { 473 var len = +second.length, 474 j = 0, 475 i = first.length; 476 477 for ( ; j < len; j++ ) { 478 first[ i++ ] = second[ j ]; 479 } 480 481 first.length = i; 482 483 return first; 484 }, 485 486 grep: function( elems, callback, invert ) { 487 var callbackInverse, 488 matches = [], 489 i = 0, 490 length = elems.length, 491 callbackExpect = !invert; 492 493 // Go through the array, only saving the items 494 // that pass the validator function 495 for ( ; i < length; i++ ) { 496 callbackInverse = !callback( elems[ i ], i ); 497 if ( callbackInverse !== callbackExpect ) { 498 matches.push( elems[ i ] ); 499 } 500 } 501 502 return matches; 503 }, 504 505 // arg is for internal usage only 506 map: function( elems, callback, arg ) { 507 var length, value, 508 i = 0, 509 ret = []; 510 511 // Go through the array, translating each of the items to their new values 512 if ( isArrayLike( elems ) ) { 513 length = elems.length; 514 for ( ; i < length; i++ ) { 515 value = callback( elems[ i ], i, arg ); 516 517 if ( value != null ) { 518 ret.push( value ); 519 } 520 } 521 522 // Go through every key on the object, 523 } else { 524 for ( i in elems ) { 525 value = callback( elems[ i ], i, arg ); 526 527 if ( value != null ) { 528 ret.push( value ); 529 } 530 } 531 } 532 533 // Flatten any nested arrays 534 return flat( ret ); 535 }, 536 537 // A global GUID counter for objects 538 guid: 1, 539 540 // jQuery.support is not used in Core but other projects attach their 541 // properties to it so it needs to exist. 542 support: support 543} ); 544 545if ( typeof Symbol === "function" ) { 546 jQuery.fn[ Symbol.iterator ] = arr[ Symbol.iterator ]; 547} 548 549// Populate the class2type map 550jQuery.each( "Boolean Number String Function Array Date RegExp Object Error Symbol".split( " " ), 551 function( _i, name ) { 552 class2type[ "[object " + name + "]" ] = name.toLowerCase(); 553 } ); 554 555function isArrayLike( obj ) { 556 557 // Support: real iOS 8.2 only (not reproducible in simulator) 558 // `in` check used to prevent JIT error (gh-2145) 559 // hasOwn isn't used here due to false negatives 560 // regarding Nodelist length in IE 561 var length = !!obj && "length" in obj && obj.length, 562 type = toType( obj ); 563 564 if ( isFunction( obj ) || isWindow( obj ) ) { 565 return false; 566 } 567 568 return type === "array" || length === 0 || 569 typeof length === "number" && length > 0 && ( length - 1 ) in obj; 570} 571 572 573function nodeName( elem, name ) { 574 575 return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase(); 576 577} 578var pop = arr.pop; 579 580 581var sort = arr.sort; 582 583 584var splice = arr.splice; 585 586 587var whitespace = "[\\x20\\t\\r\\n\\f]"; 588 589 590var rtrimCSS = new RegExp( 591 "^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" + whitespace + "+$", 592 "g" 593); 594 595 596 597 598// Note: an element does not contain itself 599jQuery.contains = function( a, b ) { 600 var bup = b && b.parentNode; 601 602 return a === bup || !!( bup && bup.nodeType === 1 && ( 603 604 // Support: IE 9 - 11+ 605 // IE doesn't have `contains` on SVG. 606 a.contains ? 607 a.contains( bup ) : 608 a.compareDocumentPosition && a.compareDocumentPosition( bup ) & 16 609 ) ); 610}; 611 612 613 614 615// CSS string/identifier serialization 616// https://drafts.csswg.org/cssom/#common-serializing-idioms 617var rcssescape = /([\0-\x1f\x7f]|^-?\d)|^-$|[^\x80-\uFFFF\w-]/g; 618 619function fcssescape( ch, asCodePoint ) { 620 if ( asCodePoint ) { 621 622 // U+0000 NULL becomes U+FFFD REPLACEMENT CHARACTER 623 if ( ch === "\0" ) { 624 return "\uFFFD"; 625 } 626 627 // Control characters and (dependent upon position) numbers get escaped as code points 628 return ch.slice( 0, -1 ) + "\\" + ch.charCodeAt( ch.length - 1 ).toString( 16 ) + " "; 629 } 630 631 // Other potentially-special ASCII characters get backslash-escaped 632 return "\\" + ch; 633} 634 635jQuery.escapeSelector = function( sel ) { 636 return ( sel + "" ).replace( rcssescape, fcssescape ); 637}; 638 639 640 641 642var preferredDoc = document, 643 pushNative = push; 644 645( function() { 646 647var i, 648 Expr, 649 outermostContext, 650 sortInput, 651 hasDuplicate, 652 push = pushNative, 653 654 // Local document vars 655 document, 656 documentElement, 657 documentIsHTML, 658 rbuggyQSA, 659 matches, 660 661 // Instance-specific data 662 expando = jQuery.expando, 663 dirruns = 0, 664 done = 0, 665 classCache = createCache(), 666 tokenCache = createCache(), 667 compilerCache = createCache(), 668 nonnativeSelectorCache = createCache(), 669 sortOrder = function( a, b ) { 670 if ( a === b ) { 671 hasDuplicate = true; 672 } 673 return 0; 674 }, 675 676 booleans = "checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|" + 677 "loop|multiple|open|readonly|required|scoped", 678 679 // Regular expressions 680 681 // https://www.w3.org/TR/css-syntax-3/#ident-token-diagram 682 identifier = "(?:\\\\[\\da-fA-F]{1,6}" + whitespace + 683 "?|\\\\[^\\r\\n\\f]|[\\w-]|[^\0-\\x7f])+", 684 685 // Attribute selectors: https://www.w3.org/TR/selectors/#attribute-selectors 686 attributes = "\\[" + whitespace + "*(" + identifier + ")(?:" + whitespace + 687 688 // Operator (capture 2) 689 "*([*^$|!~]?=)" + whitespace + 690 691 // "Attribute values must be CSS identifiers [capture 5] or strings [capture 3 or capture 4]" 692 "*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|(" + identifier + "))|)" + 693 whitespace + "*\\]", 694 695 pseudos = ":(" + identifier + ")(?:\\((" + 696 697 // To reduce the number of selectors needing tokenize in the preFilter, prefer arguments: 698 // 1. quoted (capture 3; capture 4 or capture 5) 699 "('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|" + 700 701 // 2. simple (capture 6) 702 "((?:\\\\.|[^\\\\()[\\]]|" + attributes + ")*)|" + 703 704 // 3. anything else (capture 2) 705 ".*" + 706 ")\\)|)", 707 708 // Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter 709 rwhitespace = new RegExp( whitespace + "+", "g" ), 710 711 rcomma = new RegExp( "^" + whitespace + "*," + whitespace + "*" ), 712 rleadingCombinator = new RegExp( "^" + whitespace + "*([>+~]|" + whitespace + ")" + 713 whitespace + "*" ), 714 rdescend = new RegExp( whitespace + "|>" ), 715 716 rpseudo = new RegExp( pseudos ), 717 ridentifier = new RegExp( "^" + identifier + "$" ), 718 719 matchExpr = { 720 ID: new RegExp( "^#(" + identifier + ")" ), 721 CLASS: new RegExp( "^\\.(" + identifier + ")" ), 722 TAG: new RegExp( "^(" + identifier + "|[*])" ), 723 ATTR: new RegExp( "^" + attributes ), 724 PSEUDO: new RegExp( "^" + pseudos ), 725 CHILD: new RegExp( 726 "^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(" + 727 whitespace + "*(even|odd|(([+-]|)(\\d*)n|)" + whitespace + "*(?:([+-]|)" + 728 whitespace + "*(\\d+)|))" + whitespace + "*\\)|)", "i" ), 729 bool: new RegExp( "^(?:" + booleans + ")$", "i" ), 730 731 // For use in libraries implementing .is() 732 // We use this for POS matching in `select` 733 needsContext: new RegExp( "^" + whitespace + 734 "*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(" + whitespace + 735 "*((?:-\\d)?\\d*)" + whitespace + "*\\)|)(?=[^-]|$)", "i" ) 736 }, 737 738 rinputs = /^(?:input|select|textarea|button)$/i, 739 rheader = /^h\d$/i, 740 741 // Easily-parseable/retrievable ID or TAG or CLASS selectors 742 rquickExpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/, 743 744 rsibling = /[+~]/, 745 746 // CSS escapes 747 // https://www.w3.org/TR/CSS21/syndata.html#escaped-characters 748 runescape = new RegExp( "\\\\[\\da-fA-F]{1,6}" + whitespace + 749 "?|\\\\([^\\r\\n\\f])", "g" ), 750 funescape = function( escape, nonHex ) { 751 var high = "0x" + escape.slice( 1 ) - 0x10000; 752 753 if ( nonHex ) { 754 755 // Strip the backslash prefix from a non-hex escape sequence 756 return nonHex; 757 } 758 759 // Replace a hexadecimal escape sequence with the encoded Unicode code point 760 // Support: IE <=11+ 761 // For values outside the Basic Multilingual Plane (BMP), manually construct a 762 // surrogate pair 763 return high < 0 ? 764 String.fromCharCode( high + 0x10000 ) : 765 String.fromCharCode( high >> 10 | 0xD800, high & 0x3FF | 0xDC00 ); 766 }, 767 768 // Used for iframes; see `setDocument`. 769 // Support: IE 9 - 11+, Edge 12 - 18+ 770 // Removing the function wrapper causes a "Permission Denied" 771 // error in IE/Edge. 772 unloadHandler = function() { 773 setDocument(); 774 }, 775 776 inDisabledFieldset = addCombinator( 777 function( elem ) { 778 return elem.disabled === true && nodeName( elem, "fieldset" ); 779 }, 780 { dir: "parentNode", next: "legend" } 781 ); 782 783// Support: IE <=9 only 784// Accessing document.activeElement can throw unexpectedly 785// https://bugs.jquery.com/ticket/13393 786function safeActiveElement() { 787 try { 788 return document.activeElement; 789 } catch ( err ) { } 790} 791 792// Optimize for push.apply( _, NodeList ) 793try { 794 push.apply( 795 ( arr = slice.call( preferredDoc.childNodes ) ), 796 preferredDoc.childNodes 797 ); 798 799 // Support: Android <=4.0 800 // Detect silently failing push.apply 801 // eslint-disable-next-line no-unused-expressions 802 arr[ preferredDoc.childNodes.length ].nodeType; 803} catch ( e ) { 804 push = { 805 apply: function( target, els ) { 806 pushNative.apply( target, slice.call( els ) ); 807 }, 808 call: function( target ) { 809 pushNative.apply( target, slice.call( arguments, 1 ) ); 810 } 811 }; 812} 813 814function find( selector, context, results, seed ) { 815 var m, i, elem, nid, match, groups, newSelector, 816 newContext = context && context.ownerDocument, 817 818 // nodeType defaults to 9, since context defaults to document 819 nodeType = context ? context.nodeType : 9; 820 821 results = results || []; 822 823 // Return early from calls with invalid selector or context 824 if ( typeof selector !== "string" || !selector || 825 nodeType !== 1 && nodeType !== 9 && nodeType !== 11 ) { 826 827 return results; 828 } 829 830 // Try to shortcut find operations (as opposed to filters) in HTML documents 831 if ( !seed ) { 832 setDocument( context ); 833 context = context || document; 834 835 if ( documentIsHTML ) { 836 837 // If the selector is sufficiently simple, try using a "get*By*" DOM method 838 // (excepting DocumentFragment context, where the methods don't exist) 839 if ( nodeType !== 11 && ( match = rquickExpr.exec( selector ) ) ) { 840 841 // ID selector 842 if ( ( m = match[ 1 ] ) ) { 843 844 // Document context 845 if ( nodeType === 9 ) { 846 if ( ( elem = context.getElementById( m ) ) ) { 847 848 // Support: IE 9 only 849 // getElementById can match elements by name instead of ID 850 if ( elem.id === m ) { 851 push.call( results, elem ); 852 return results; 853 } 854 } else { 855 return results; 856 } 857 858 // Element context 859 } else { 860 861 // Support: IE 9 only 862 // getElementById can match elements by name instead of ID 863 if ( newContext && ( elem = newContext.getElementById( m ) ) && 864 find.contains( context, elem ) && 865 elem.id === m ) { 866 867 push.call( results, elem ); 868 return results; 869 } 870 } 871 872 // Type selector 873 } else if ( match[ 2 ] ) { 874 push.apply( results, context.getElementsByTagName( selector ) ); 875 return results; 876 877 // Class selector 878 } else if ( ( m = match[ 3 ] ) && context.getElementsByClassName ) { 879 push.apply( results, context.getElementsByClassName( m ) ); 880 return results; 881 } 882 } 883 884 // Take advantage of querySelectorAll 885 if ( !nonnativeSelectorCache[ selector + " " ] && 886 ( !rbuggyQSA || !rbuggyQSA.test( selector ) ) ) { 887 888 newSelector = selector; 889 newContext = context; 890 891 // qSA considers elements outside a scoping root when evaluating child or 892 // descendant combinators, which is not what we want. 893 // In such cases, we work around the behavior by prefixing every selector in the 894 // list with an ID selector referencing the scope context. 895 // The technique has to be used as well when a leading combinator is used 896 // as such selectors are not recognized by querySelectorAll. 897 // Thanks to Andrew Dupont for this technique. 898 if ( nodeType === 1 && 899 ( rdescend.test( selector ) || rleadingCombinator.test( selector ) ) ) { 900 901 // Expand context for sibling selectors 902 newContext = rsibling.test( selector ) && testContext( context.parentNode ) || 903 context; 904 905 // We can use :scope instead of the ID hack if the browser 906 // supports it & if we're not changing the context. 907 // Support: IE 11+, Edge 17 - 18+ 908 // IE/Edge sometimes throw a "Permission denied" error when 909 // strict-comparing two documents; shallow comparisons work. 910 // eslint-disable-next-line eqeqeq 911 if ( newContext != context || !support.scope ) { 912 913 // Capture the context ID, setting it first if necessary 914 if ( ( nid = context.getAttribute( "id" ) ) ) { 915 nid = jQuery.escapeSelector( nid ); 916 } else { 917 context.setAttribute( "id", ( nid = expando ) ); 918 } 919 } 920 921 // Prefix every selector in the list 922 groups = tokenize( selector ); 923 i = groups.length; 924 while ( i-- ) { 925 groups[ i ] = ( nid ? "#" + nid : ":scope" ) + " " + 926 toSelector( groups[ i ] ); 927 } 928 newSelector = groups.join( "," ); 929 } 930 931 try { 932 push.apply( results, 933 newContext.querySelectorAll( newSelector ) 934 ); 935 return results; 936 } catch ( qsaError ) { 937 nonnativeSelectorCache( selector, true ); 938 } finally { 939 if ( nid === expando ) { 940 context.removeAttribute( "id" ); 941 } 942 } 943 } 944 } 945 } 946 947 // All others 948 return select( selector.replace( rtrimCSS, "$1" ), context, results, seed ); 949} 950 951/** 952 * Create key-value caches of limited size 953 * @returns {function(string, object)} Returns the Object data after storing it on itself with 954 * property name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength) 955 * deleting the oldest entry 956 */ 957function createCache() { 958 var keys = []; 959 960 function cache( key, value ) { 961 962 // Use (key + " ") to avoid collision with native prototype properties 963 // (see https://github.com/jquery/sizzle/issues/157) 964 if ( keys.push( key + " " ) > Expr.cacheLength ) { 965 966 // Only keep the most recent entries 967 delete cache[ keys.shift() ]; 968 } 969 return ( cache[ key + " " ] = value ); 970 } 971 return cache; 972} 973 974/** 975 * Mark a function for special use by jQuery selector module 976 * @param {Function} fn The function to mark 977 */ 978function markFunction( fn ) { 979 fn[ expando ] = true; 980 return fn; 981} 982 983/** 984 * Support testing using an element 985 * @param {Function} fn Passed the created element and returns a boolean result 986 */ 987function assert( fn ) { 988 var el = document.createElement( "fieldset" ); 989 990 try { 991 return !!fn( el ); 992 } catch ( e ) { 993 return false; 994 } finally { 995 996 // Remove from its parent by default 997 if ( el.parentNode ) { 998 el.parentNode.removeChild( el ); 999 } 1000 1001 // release memory in IE 1002 el = null; 1003 } 1004} 1005 1006/** 1007 * Returns a function to use in pseudos for input types 1008 * @param {String} type 1009 */ 1010function createInputPseudo( type ) { 1011 return function( elem ) { 1012 return nodeName( elem, "input" ) && elem.type === type; 1013 }; 1014} 1015 1016/** 1017 * Returns a function to use in pseudos for buttons 1018 * @param {String} type 1019 */ 1020function createButtonPseudo( type ) { 1021 return function( elem ) { 1022 return ( nodeName( elem, "input" ) || nodeName( elem, "button" ) ) && 1023 elem.type === type; 1024 }; 1025} 1026 1027/** 1028 * Returns a function to use in pseudos for :enabled/:disabled 1029 * @param {Boolean} disabled true for :disabled; false for :enabled 1030 */ 1031function createDisabledPseudo( disabled ) { 1032 1033 // Known :disabled false positives: fieldset[disabled] > legend:nth-of-type(n+2) :can-disable 1034 return function( elem ) { 1035 1036 // Only certain elements can match :enabled or :disabled 1037 // https://html.spec.whatwg.org/multipage/scripting.html#selector-enabled 1038 // https://html.spec.whatwg.org/multipage/scripting.html#selector-disabled 1039 if ( "form" in elem ) { 1040 1041 // Check for inherited disabledness on relevant non-disabled elements: 1042 // * listed form-associated elements in a disabled fieldset 1043 // https://html.spec.whatwg.org/multipage/forms.html#category-listed 1044 // https://html.spec.whatwg.org/multipage/forms.html#concept-fe-disabled 1045 // * option elements in a disabled optgroup 1046 // https://html.spec.whatwg.org/multipage/forms.html#concept-option-disabled 1047 // All such elements have a "form" property. 1048 if ( elem.parentNode && elem.disabled === false ) { 1049 1050 // Option elements defer to a parent optgroup if present 1051 if ( "label" in elem ) { 1052 if ( "label" in elem.parentNode ) { 1053 return elem.parentNode.disabled === disabled; 1054 } else { 1055 return elem.disabled === disabled; 1056 } 1057 } 1058 1059 // Support: IE 6 - 11+ 1060 // Use the isDisabled shortcut property to check for disabled fieldset ancestors 1061 return elem.isDisabled === disabled || 1062 1063 // Where there is no isDisabled, check manually 1064 elem.isDisabled !== !disabled && 1065 inDisabledFieldset( elem ) === disabled; 1066 } 1067 1068 return elem.disabled === disabled; 1069 1070 // Try to winnow out elements that can't be disabled before trusting the disabled property. 1071 // Some victims get caught in our net (label, legend, menu, track), but it shouldn't 1072 // even exist on them, let alone have a boolean value. 1073 } else if ( "label" in elem ) { 1074 return elem.disabled === disabled; 1075 } 1076 1077 // Remaining elements are neither :enabled nor :disabled 1078 return false; 1079 }; 1080} 1081 1082/** 1083 * Returns a function to use in pseudos for positionals 1084 * @param {Function} fn 1085 */ 1086function createPositionalPseudo( fn ) { 1087 return markFunction( function( argument ) { 1088 argument = +argument; 1089 return markFunction( function( seed, matches ) { 1090 var j, 1091 matchIndexes = fn( [], seed.length, argument ), 1092 i = matchIndexes.length; 1093 1094 // Match elements found at the specified indexes 1095 while ( i-- ) { 1096 if ( seed[ ( j = matchIndexes[ i ] ) ] ) { 1097 seed[ j ] = !( matches[ j ] = seed[ j ] ); 1098 } 1099 } 1100 } ); 1101 } ); 1102} 1103 1104/** 1105 * Checks a node for validity as a jQuery selector context 1106 * @param {Element|Object=} context 1107 * @returns {Element|Object|Boolean} The input node if acceptable, otherwise a falsy value 1108 */ 1109function testContext( context ) { 1110 return context && typeof context.getElementsByTagName !== "undefined" && context; 1111} 1112 1113/** 1114 * Sets document-related variables once based on the current document 1115 * @param {Element|Object} [node] An element or document object to use to set the document 1116 * @returns {Object} Returns the current document 1117 */ 1118function setDocument( node ) { 1119 var subWindow, 1120 doc = node ? node.ownerDocument || node : preferredDoc; 1121 1122 // Return early if doc is invalid or already selected 1123 // Support: IE 11+, Edge 17 - 18+ 1124 // IE/Edge sometimes throw a "Permission denied" error when strict-comparing 1125 // two documents; shallow comparisons work. 1126 // eslint-disable-next-line eqeqeq 1127 if ( doc == document || doc.nodeType !== 9 || !doc.documentElement ) { 1128 return document; 1129 } 1130 1131 // Update global variables 1132 document = doc; 1133 documentElement = document.documentElement; 1134 documentIsHTML = !jQuery.isXMLDoc( document ); 1135 1136 // Support: iOS 7 only, IE 9 - 11+ 1137 // Older browsers didn't support unprefixed `matches`. 1138 matches = documentElement.matches || 1139 documentElement.webkitMatchesSelector || 1140 documentElement.msMatchesSelector; 1141 1142 // Support: IE 9 - 11+, Edge 12 - 18+ 1143 // Accessing iframe documents after unload throws "permission denied" errors 1144 // (see trac-13936). 1145 // Limit the fix to IE & Edge Legacy; despite Edge 15+ implementing `matches`, 1146 // all IE 9+ and Edge Legacy versions implement `msMatchesSelector` as well. 1147 if ( documentElement.msMatchesSelector && 1148 1149 // Support: IE 11+, Edge 17 - 18+ 1150 // IE/Edge sometimes throw a "Permission denied" error when strict-comparing 1151 // two documents; shallow comparisons work. 1152 // eslint-disable-next-line eqeqeq 1153 preferredDoc != document && 1154 ( subWindow = document.defaultView ) && subWindow.top !== subWindow ) { 1155 1156 // Support: IE 9 - 11+, Edge 12 - 18+ 1157 subWindow.addEventListener( "unload", unloadHandler ); 1158 } 1159 1160 // Support: IE <10 1161 // Check if getElementById returns elements by name 1162 // The broken getElementById methods don't pick up programmatically-set names, 1163 // so use a roundabout getElementsByName test 1164 support.getById = assert( function( el ) { 1165 documentElement.appendChild( el ).id = jQuery.expando; 1166 return !document.getElementsByName || 1167 !document.getElementsByName( jQuery.expando ).length; 1168 } ); 1169 1170 // Support: IE 9 only 1171 // Check to see if it's possible to do matchesSelector 1172 // on a disconnected node. 1173 support.disconnectedMatch = assert( function( el ) { 1174 return matches.call( el, "*" ); 1175 } ); 1176 1177 // Support: IE 9 - 11+, Edge 12 - 18+ 1178 // IE/Edge don't support the :scope pseudo-class. 1179 support.scope = assert( function() { 1180 return document.querySelectorAll( ":scope" ); 1181 } ); 1182 1183 // Support: Chrome 105 - 111 only, Safari 15.4 - 16.3 only 1184 // Make sure the `:has()` argument is parsed unforgivingly. 1185 // We include `*` in the test to detect buggy implementations that are 1186 // _selectively_ forgiving (specifically when the list includes at least 1187 // one valid selector). 1188 // Note that we treat complete lack of support for `:has()` as if it were 1189 // spec-compliant support, which is fine because use of `:has()` in such 1190 // environments will fail in the qSA path and fall back to jQuery traversal 1191 // anyway. 1192 support.cssHas = assert( function() { 1193 try { 1194 document.querySelector( ":has(*,:jqfake)" ); 1195 return false; 1196 } catch ( e ) { 1197 return true; 1198 } 1199 } ); 1200 1201 // ID filter and find 1202 if ( support.getById ) { 1203 Expr.filter.ID = function( id ) { 1204 var attrId = id.replace( runescape, funescape ); 1205 return function( elem ) { 1206 return elem.getAttribute( "id" ) === attrId; 1207 }; 1208 }; 1209 Expr.find.ID = function( id, context ) { 1210 if ( typeof context.getElementById !== "undefined" && documentIsHTML ) { 1211 var elem = context.getElementById( id ); 1212 return elem ? [ elem ] : []; 1213 } 1214 }; 1215 } else { 1216 Expr.filter.ID = function( id ) { 1217 var attrId = id.replace( runescape, funescape ); 1218 return function( elem ) { 1219 var node = typeof elem.getAttributeNode !== "undefined" && 1220 elem.getAttributeNode( "id" ); 1221 return node && node.value === attrId; 1222 }; 1223 }; 1224 1225 // Support: IE 6 - 7 only 1226 // getElementById is not reliable as a find shortcut 1227 Expr.find.ID = function( id, context ) { 1228 if ( typeof context.getElementById !== "undefined" && documentIsHTML ) { 1229 var node, i, elems, 1230 elem = context.getElementById( id ); 1231 1232 if ( elem ) { 1233 1234 // Verify the id attribute 1235 node = elem.getAttributeNode( "id" ); 1236 if ( node && node.value === id ) { 1237 return [ elem ]; 1238 } 1239 1240 // Fall back on getElementsByName 1241 elems = context.getElementsByName( id ); 1242 i = 0; 1243 while ( ( elem = elems[ i++ ] ) ) { 1244 node = elem.getAttributeNode( "id" ); 1245 if ( node && node.value === id ) { 1246 return [ elem ]; 1247 } 1248 } 1249 } 1250 1251 return []; 1252 } 1253 }; 1254 } 1255 1256 // Tag 1257 Expr.find.TAG = function( tag, context ) { 1258 if ( typeof context.getElementsByTagName !== "undefined" ) { 1259 return context.getElementsByTagName( tag ); 1260 1261 // DocumentFragment nodes don't have gEBTN 1262 } else { 1263 return context.querySelectorAll( tag ); 1264 } 1265 }; 1266 1267 // Class 1268 Expr.find.CLASS = function( className, context ) { 1269 if ( typeof context.getElementsByClassName !== "undefined" && documentIsHTML ) { 1270 return context.getElementsByClassName( className ); 1271 } 1272 }; 1273 1274 /* QSA/matchesSelector 1275 ---------------------------------------------------------------------- */ 1276 1277 // QSA and matchesSelector support 1278 1279 rbuggyQSA = []; 1280 1281 // Build QSA regex 1282 // Regex strategy adopted from Diego Perini 1283 assert( function( el ) { 1284 1285 var input; 1286 1287 documentElement.appendChild( el ).innerHTML = 1288 "<a id='" + expando + "' href='' disabled='disabled'></a>" + 1289 "<select id='" + expando + "-\r\\' disabled='disabled'>" + 1290 "<option selected=''></option></select>"; 1291 1292 // Support: iOS <=7 - 8 only 1293 // Boolean attributes and "value" are not treated correctly in some XML documents 1294 if ( !el.querySelectorAll( "[selected]" ).length ) { 1295 rbuggyQSA.push( "\\[" + whitespace + "*(?:value|" + booleans + ")" ); 1296 } 1297 1298 // Support: iOS <=7 - 8 only 1299 if ( !el.querySelectorAll( "[id~=" + expando + "-]" ).length ) { 1300 rbuggyQSA.push( "~=" ); 1301 } 1302 1303 // Support: iOS 8 only 1304 // https://bugs.webkit.org/show_bug.cgi?id=136851 1305 // In-page `selector#id sibling-combinator selector` fails 1306 if ( !el.querySelectorAll( "a#" + expando + "+*" ).length ) { 1307 rbuggyQSA.push( ".#.+[+~]" ); 1308 } 1309 1310 // Support: Chrome <=105+, Firefox <=104+, Safari <=15.4+ 1311 // In some of the document kinds, these selectors wouldn't work natively. 1312 // This is probably OK but for backwards compatibility we want to maintain 1313 // handling them through jQuery traversal in jQuery 3.x. 1314 if ( !el.querySelectorAll( ":checked" ).length ) { 1315 rbuggyQSA.push( ":checked" ); 1316 } 1317 1318 // Support: Windows 8 Native Apps 1319 // The type and name attributes are restricted during .innerHTML assignment 1320 input = document.createElement( "input" ); 1321 input.setAttribute( "type", "hidden" ); 1322 el.appendChild( input ).setAttribute( "name", "D" ); 1323 1324 // Support: IE 9 - 11+ 1325 // IE's :disabled selector does not pick up the children of disabled fieldsets 1326 // Support: Chrome <=105+, Firefox <=104+, Safari <=15.4+ 1327 // In some of the document kinds, these selectors wouldn't work natively. 1328 // This is probably OK but for backwards compatibility we want to maintain 1329 // handling them through jQuery traversal in jQuery 3.x. 1330 documentElement.appendChild( el ).disabled = true; 1331 if ( el.querySelectorAll( ":disabled" ).length !== 2 ) { 1332 rbuggyQSA.push( ":enabled", ":disabled" ); 1333 } 1334 1335 // Support: IE 11+, Edge 15 - 18+ 1336 // IE 11/Edge don't find elements on a `[name='']` query in some cases. 1337 // Adding a temporary attribute to the document before the selection works 1338 // around the issue. 1339 // Interestingly, IE 10 & older don't seem to have the issue. 1340 input = document.createElement( "input" ); 1341 input.setAttribute( "name", "" ); 1342 el.appendChild( input ); 1343 if ( !el.querySelectorAll( "[name='']" ).length ) { 1344 rbuggyQSA.push( "\\[" + whitespace + "*name" + whitespace + "*=" + 1345 whitespace + "*(?:''|\"\")" ); 1346 } 1347 } ); 1348 1349 if ( !support.cssHas ) { 1350 1351 // Support: Chrome 105 - 110+, Safari 15.4 - 16.3+ 1352 // Our regular `try-catch` mechanism fails to detect natively-unsupported 1353 // pseudo-classes inside `:has()` (such as `:has(:contains("Foo"))`) 1354 // in browsers that parse the `:has()` argument as a forgiving selector list. 1355 // https://drafts.csswg.org/selectors/#relational now requires the argument 1356 // to be parsed unforgivingly, but browsers have not yet fully adjusted. 1357 rbuggyQSA.push( ":has" ); 1358 } 1359 1360 rbuggyQSA = rbuggyQSA.length && new RegExp( rbuggyQSA.join( "|" ) ); 1361 1362 /* Sorting 1363 ---------------------------------------------------------------------- */ 1364 1365 // Document order sorting 1366 sortOrder = function( a, b ) { 1367 1368 // Flag for duplicate removal 1369 if ( a === b ) { 1370 hasDuplicate = true; 1371 return 0; 1372 } 1373 1374 // Sort on method existence if only one input has compareDocumentPosition 1375 var compare = !a.compareDocumentPosition - !b.compareDocumentPosition; 1376 if ( compare ) { 1377 return compare; 1378 } 1379 1380 // Calculate position if both inputs belong to the same document 1381 // Support: IE 11+, Edge 17 - 18+ 1382 // IE/Edge sometimes throw a "Permission denied" error when strict-comparing 1383 // two documents; shallow comparisons work. 1384 // eslint-disable-next-line eqeqeq 1385 compare = ( a.ownerDocument || a ) == ( b.ownerDocument || b ) ? 1386 a.compareDocumentPosition( b ) : 1387 1388 // Otherwise we know they are disconnected 1389 1; 1390 1391 // Disconnected nodes 1392 if ( compare & 1 || 1393 ( !support.sortDetached && b.compareDocumentPosition( a ) === compare ) ) { 1394 1395 // Choose the first element that is related to our preferred document 1396 // Support: IE 11+, Edge 17 - 18+ 1397 // IE/Edge sometimes throw a "Permission denied" error when strict-comparing 1398 // two documents; shallow comparisons work. 1399 // eslint-disable-next-line eqeqeq 1400 if ( a === document || a.ownerDocument == preferredDoc && 1401 find.contains( preferredDoc, a ) ) { 1402 return -1; 1403 } 1404 1405 // Support: IE 11+, Edge 17 - 18+ 1406 // IE/Edge sometimes throw a "Permission denied" error when strict-comparing 1407 // two documents; shallow comparisons work. 1408 // eslint-disable-next-line eqeqeq 1409 if ( b === document || b.ownerDocument == preferredDoc && 1410 find.contains( preferredDoc, b ) ) { 1411 return 1; 1412 } 1413 1414 // Maintain original order 1415 return sortInput ? 1416 ( indexOf.call( sortInput, a ) - indexOf.call( sortInput, b ) ) : 1417 0; 1418 } 1419 1420 return compare & 4 ? -1 : 1; 1421 }; 1422 1423 return document; 1424} 1425 1426find.matches = function( expr, elements ) { 1427 return find( expr, null, null, elements ); 1428}; 1429 1430find.matchesSelector = function( elem, expr ) { 1431 setDocument( elem ); 1432 1433 if ( documentIsHTML && 1434 !nonnativeSelectorCache[ expr + " " ] && 1435 ( !rbuggyQSA || !rbuggyQSA.test( expr ) ) ) { 1436 1437 try { 1438 var ret = matches.call( elem, expr ); 1439 1440 // IE 9's matchesSelector returns false on disconnected nodes 1441 if ( ret || support.disconnectedMatch || 1442 1443 // As well, disconnected nodes are said to be in a document 1444 // fragment in IE 9 1445 elem.document && elem.document.nodeType !== 11 ) { 1446 return ret; 1447 } 1448 } catch ( e ) { 1449 nonnativeSelectorCache( expr, true ); 1450 } 1451 } 1452 1453 return find( expr, document, null, [ elem ] ).length > 0; 1454}; 1455 1456find.contains = function( context, elem ) { 1457 1458 // Set document vars if needed 1459 // Support: IE 11+, Edge 17 - 18+ 1460 // IE/Edge sometimes throw a "Permission denied" error when strict-comparing 1461 // two documents; shallow comparisons work. 1462 // eslint-disable-next-line eqeqeq 1463 if ( ( context.ownerDocument || context ) != document ) { 1464 setDocument( context ); 1465 } 1466 return jQuery.contains( context, elem ); 1467}; 1468 1469 1470find.attr = function( elem, name ) { 1471 1472 // Set document vars if needed 1473 // Support: IE 11+, Edge 17 - 18+ 1474 // IE/Edge sometimes throw a "Permission denied" error when strict-comparing 1475 // two documents; shallow comparisons work. 1476 // eslint-disable-next-line eqeqeq 1477 if ( ( elem.ownerDocument || elem ) != document ) { 1478 setDocument( elem ); 1479 } 1480 1481 var fn = Expr.attrHandle[ name.toLowerCase() ], 1482 1483 // Don't get fooled by Object.prototype properties (see trac-13807) 1484 val = fn && hasOwn.call( Expr.attrHandle, name.toLowerCase() ) ? 1485 fn( elem, name, !documentIsHTML ) : 1486 undefined; 1487 1488 if ( val !== undefined ) { 1489 return val; 1490 } 1491 1492 return elem.getAttribute( name ); 1493}; 1494 1495find.error = function( msg ) { 1496 throw new Error( "Syntax error, unrecognized expression: " + msg ); 1497}; 1498 1499/** 1500 * Document sorting and removing duplicates 1501 * @param {ArrayLike} results 1502 */ 1503jQuery.uniqueSort = function( results ) { 1504 var elem, 1505 duplicates = [], 1506 j = 0, 1507 i = 0; 1508 1509 // Unless we *know* we can detect duplicates, assume their presence 1510 // 1511 // Support: Android <=4.0+ 1512 // Testing for detecting duplicates is unpredictable so instead assume we can't 1513 // depend on duplicate detection in all browsers without a stable sort. 1514 hasDuplicate = !support.sortStable; 1515 sortInput = !support.sortStable && slice.call( results, 0 ); 1516 sort.call( results, sortOrder ); 1517 1518 if ( hasDuplicate ) { 1519 while ( ( elem = results[ i++ ] ) ) { 1520 if ( elem === results[ i ] ) { 1521 j = duplicates.push( i ); 1522 } 1523 } 1524 while ( j-- ) { 1525 splice.call( results, duplicates[ j ], 1 ); 1526 } 1527 } 1528 1529 // Clear input after sorting to release objects 1530 // See https://github.com/jquery/sizzle/pull/225 1531 sortInput = null; 1532 1533 return results; 1534}; 1535 1536jQuery.fn.uniqueSort = function() { 1537 return this.pushStack( jQuery.uniqueSort( slice.apply( this ) ) ); 1538}; 1539 1540Expr = jQuery.expr = { 1541 1542 // Can be adjusted by the user 1543 cacheLength: 50, 1544 1545 createPseudo: markFunction, 1546 1547 match: matchExpr, 1548 1549 attrHandle: {}, 1550 1551 find: {}, 1552 1553 relative: { 1554 ">": { dir: "parentNode", first: true }, 1555 " ": { dir: "parentNode" }, 1556 "+": { dir: "previousSibling", first: true }, 1557 "~": { dir: "previousSibling" } 1558 }, 1559 1560 preFilter: { 1561 ATTR: function( match ) { 1562 match[ 1 ] = match[ 1 ].replace( runescape, funescape ); 1563 1564 // Move the given value to match[3] whether quoted or unquoted 1565 match[ 3 ] = ( match[ 3 ] || match[ 4 ] || match[ 5 ] || "" ) 1566 .replace( runescape, funescape ); 1567 1568 if ( match[ 2 ] === "~=" ) { 1569 match[ 3 ] = " " + match[ 3 ] + " "; 1570 } 1571 1572 return match.slice( 0, 4 ); 1573 }, 1574 1575 CHILD: function( match ) { 1576 1577 /* matches from matchExpr["CHILD"] 1578 1 type (only|nth|...) 1579 2 what (child|of-type) 1580 3 argument (even|odd|\d*|\d*n([+-]\d+)?|...) 1581 4 xn-component of xn+y argument ([+-]?\d*n|) 1582 5 sign of xn-component 1583 6 x of xn-component 1584 7 sign of y-component 1585 8 y of y-component 1586 */ 1587 match[ 1 ] = match[ 1 ].toLowerCase(); 1588 1589 if ( match[ 1 ].slice( 0, 3 ) === "nth" ) { 1590 1591 // nth-* requires argument 1592 if ( !match[ 3 ] ) { 1593 find.error( match[ 0 ] ); 1594 } 1595 1596 // numeric x and y parameters for Expr.filter.CHILD 1597 // remember that false/true cast respectively to 0/1 1598 match[ 4 ] = +( match[ 4 ] ? 1599 match[ 5 ] + ( match[ 6 ] || 1 ) : 1600 2 * ( match[ 3 ] === "even" || match[ 3 ] === "odd" ) 1601 ); 1602 match[ 5 ] = +( ( match[ 7 ] + match[ 8 ] ) || match[ 3 ] === "odd" ); 1603 1604 // other types prohibit arguments 1605 } else if ( match[ 3 ] ) { 1606 find.error( match[ 0 ] ); 1607 } 1608 1609 return match; 1610 }, 1611 1612 PSEUDO: function( match ) { 1613 var excess, 1614 unquoted = !match[ 6 ] && match[ 2 ]; 1615 1616 if ( matchExpr.CHILD.test( match[ 0 ] ) ) { 1617 return null; 1618 } 1619 1620 // Accept quoted arguments as-is 1621 if ( match[ 3 ] ) { 1622 match[ 2 ] = match[ 4 ] || match[ 5 ] || ""; 1623 1624 // Strip excess characters from unquoted arguments 1625 } else if ( unquoted && rpseudo.test( unquoted ) && 1626 1627 // Get excess from tokenize (recursively) 1628 ( excess = tokenize( unquoted, true ) ) && 1629 1630 // advance to the next closing parenthesis 1631 ( excess = unquoted.indexOf( ")", unquoted.length - excess ) - unquoted.length ) ) { 1632 1633 // excess is a negative index 1634 match[ 0 ] = match[ 0 ].slice( 0, excess ); 1635 match[ 2 ] = unquoted.slice( 0, excess ); 1636 } 1637 1638 // Return only captures needed by the pseudo filter method (type and argument) 1639 return match.slice( 0, 3 ); 1640 } 1641 }, 1642 1643 filter: { 1644 1645 TAG: function( nodeNameSelector ) { 1646 var expectedNodeName = nodeNameSelector.replace( runescape, funescape ).toLowerCase(); 1647 return nodeNameSelector === "*" ? 1648 function() { 1649 return true; 1650 } : 1651 function( elem ) { 1652 return nodeName( elem, expectedNodeName ); 1653 }; 1654 }, 1655 1656 CLASS: function( className ) { 1657 var pattern = classCache[ className + " " ]; 1658 1659 return pattern || 1660 ( pattern = new RegExp( "(^|" + whitespace + ")" + className + 1661 "(" + whitespace + "|$)" ) ) && 1662 classCache( className, function( elem ) { 1663 return pattern.test( 1664 typeof elem.className === "string" && elem.className || 1665 typeof elem.getAttribute !== "undefined" && 1666 elem.getAttribute( "class" ) || 1667 "" 1668 ); 1669 } ); 1670 }, 1671 1672 ATTR: function( name, operator, check ) { 1673 return function( elem ) { 1674 var result = find.attr( elem, name ); 1675 1676 if ( result == null ) { 1677 return operator === "!="; 1678 } 1679 if ( !operator ) { 1680 return true; 1681 } 1682 1683 result += ""; 1684 1685 if ( operator === "=" ) { 1686 return result === check; 1687 } 1688 if ( operator === "!=" ) { 1689 return result !== check; 1690 } 1691 if ( operator === "^=" ) { 1692 return check && result.indexOf( check ) === 0; 1693 } 1694 if ( operator === "*=" ) { 1695 return check && result.indexOf( check ) > -1; 1696 } 1697 if ( operator === "$=" ) { 1698 return check && result.slice( -check.length ) === check; 1699 } 1700 if ( operator === "~=" ) { 1701 return ( " " + result.replace( rwhitespace, " " ) + " " ) 1702 .indexOf( check ) > -1; 1703 } 1704 if ( operator === "|=" ) { 1705 return result === check || result.slice( 0, check.length + 1 ) === check + "-"; 1706 } 1707 1708 return false; 1709 }; 1710 }, 1711 1712 CHILD: function( type, what, _argument, first, last ) { 1713 var simple = type.slice( 0, 3 ) !== "nth", 1714 forward = type.slice( -4 ) !== "last", 1715 ofType = what === "of-type"; 1716 1717 return first === 1 && last === 0 ? 1718 1719 // Shortcut for :nth-*(n) 1720 function( elem ) { 1721 return !!elem.parentNode; 1722 } : 1723 1724 function( elem, _context, xml ) { 1725 var cache, outerCache, node, nodeIndex, start, 1726 dir = simple !== forward ? "nextSibling" : "previousSibling", 1727 parent = elem.parentNode, 1728 name = ofType && elem.nodeName.toLowerCase(), 1729 useCache = !xml && !ofType, 1730 diff = false; 1731 1732 if ( parent ) { 1733 1734 // :(first|last|only)-(child|of-type) 1735 if ( simple ) { 1736 while ( dir ) { 1737 node = elem; 1738 while ( ( node = node[ dir ] ) ) { 1739 if ( ofType ? 1740 nodeName( node, name ) : 1741 node.nodeType === 1 ) { 1742 1743 return false; 1744 } 1745 } 1746 1747 // Reverse direction for :only-* (if we haven't yet done so) 1748 start = dir = type === "only" && !start && "nextSibling"; 1749 } 1750 return true; 1751 } 1752 1753 start = [ forward ? parent.firstChild : parent.lastChild ]; 1754 1755 // non-xml :nth-child(...) stores cache data on `parent` 1756 if ( forward && useCache ) { 1757 1758 // Seek `elem` from a previously-cached index 1759 outerCache = parent[ expando ] || ( parent[ expando ] = {} ); 1760 cache = outerCache[ type ] || []; 1761 nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ]; 1762 diff = nodeIndex && cache[ 2 ]; 1763 node = nodeIndex && parent.childNodes[ nodeIndex ]; 1764 1765 while ( ( node = ++nodeIndex && node && node[ dir ] || 1766 1767 // Fallback to seeking `elem` from the start 1768 ( diff = nodeIndex = 0 ) || start.pop() ) ) { 1769 1770 // When found, cache indexes on `parent` and break 1771 if ( node.nodeType === 1 && ++diff && node === elem ) { 1772 outerCache[ type ] = [ dirruns, nodeIndex, diff ]; 1773 break; 1774 } 1775 } 1776 1777 } else { 1778 1779 // Use previously-cached element index if available 1780 if ( useCache ) { 1781 outerCache = elem[ expando ] || ( elem[ expando ] = {} ); 1782 cache = outerCache[ type ] || []; 1783 nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ]; 1784 diff = nodeIndex; 1785 } 1786 1787 // xml :nth-child(...) 1788 // or :nth-last-child(...) or :nth(-last)?-of-type(...) 1789 if ( diff === false ) { 1790 1791 // Use the same loop as above to seek `elem` from the start 1792 while ( ( node = ++nodeIndex && node && node[ dir ] || 1793 ( diff = nodeIndex = 0 ) || start.pop() ) ) { 1794 1795 if ( ( ofType ? 1796 nodeName( node, name ) : 1797 node.nodeType === 1 ) && 1798 ++diff ) { 1799 1800 // Cache the index of each encountered element 1801 if ( useCache ) { 1802 outerCache = node[ expando ] || 1803 ( node[ expando ] = {} ); 1804 outerCache[ type ] = [ dirruns, diff ]; 1805 } 1806 1807 if ( node === elem ) { 1808 break; 1809 } 1810 } 1811 } 1812 } 1813 } 1814 1815 // Incorporate the offset, then check against cycle size 1816 diff -= last; 1817 return diff === first || ( diff % first === 0 && diff / first >= 0 ); 1818 } 1819 }; 1820 }, 1821 1822 PSEUDO: function( pseudo, argument ) { 1823 1824 // pseudo-class names are case-insensitive 1825 // https://www.w3.org/TR/selectors/#pseudo-classes 1826 // Prioritize by case sensitivity in case custom pseudos are added with uppercase letters 1827 // Remember that setFilters inherits from pseudos 1828 var args, 1829 fn = Expr.pseudos[ pseudo ] || Expr.setFilters[ pseudo.toLowerCase() ] || 1830 find.error( "unsupported pseudo: " + pseudo ); 1831 1832 // The user may use createPseudo to indicate that 1833 // arguments are needed to create the filter function 1834 // just as jQuery does 1835 if ( fn[ expando ] ) { 1836 return fn( argument ); 1837 } 1838 1839 // But maintain support for old signatures 1840 if ( fn.length > 1 ) { 1841 args = [ pseudo, pseudo, "", argument ]; 1842 return Expr.setFilters.hasOwnProperty( pseudo.toLowerCase() ) ? 1843 markFunction( function( seed, matches ) { 1844 var idx, 1845 matched = fn( seed, argument ), 1846 i = matched.length; 1847 while ( i-- ) { 1848 idx = indexOf.call( seed, matched[ i ] ); 1849 seed[ idx ] = !( matches[ idx ] = matched[ i ] ); 1850 } 1851 } ) : 1852 function( elem ) { 1853 return fn( elem, 0, args ); 1854 }; 1855 } 1856 1857 return fn; 1858 } 1859 }, 1860 1861 pseudos: { 1862 1863 // Potentially complex pseudos 1864 not: markFunction( function( selector ) { 1865 1866 // Trim the selector passed to compile 1867 // to avoid treating leading and trailing 1868 // spaces as combinators 1869 var input = [], 1870 results = [], 1871 matcher = compile( selector.replace( rtrimCSS, "$1" ) ); 1872 1873 return matcher[ expando ] ? 1874 markFunction( function( seed, matches, _context, xml ) { 1875 var elem, 1876 unmatched = matcher( seed, null, xml, [] ), 1877 i = seed.length; 1878 1879 // Match elements unmatched by `matcher` 1880 while ( i-- ) { 1881 if ( ( elem = unmatched[ i ] ) ) { 1882 seed[ i ] = !( matches[ i ] = elem ); 1883 } 1884 } 1885 } ) : 1886 function( elem, _context, xml ) { 1887 input[ 0 ] = elem; 1888 matcher( input, null, xml, results ); 1889 1890 // Don't keep the element 1891 // (see https://github.com/jquery/sizzle/issues/299) 1892 input[ 0 ] = null; 1893 return !results.pop(); 1894 }; 1895 } ), 1896 1897 has: markFunction( function( selector ) { 1898 return function( elem ) { 1899 return find( selector, elem ).length > 0; 1900 }; 1901 } ), 1902 1903 contains: markFunction( function( text ) { 1904 text = text.replace( runescape, funescape ); 1905 return function( elem ) { 1906 return ( elem.textContent || jQuery.text( elem ) ).indexOf( text ) > -1; 1907 }; 1908 } ), 1909 1910 // "Whether an element is represented by a :lang() selector 1911 // is based solely on the element's language value 1912 // being equal to the identifier C, 1913 // or beginning with the identifier C immediately followed by "-". 1914 // The matching of C against the element's language value is performed case-insensitively. 1915 // The identifier C does not have to be a valid language name." 1916 // https://www.w3.org/TR/selectors/#lang-pseudo 1917 lang: markFunction( function( lang ) { 1918 1919 // lang value must be a valid identifier 1920 if ( !ridentifier.test( lang || "" ) ) { 1921 find.error( "unsupported lang: " + lang ); 1922 } 1923 lang = lang.replace( runescape, funescape ).toLowerCase(); 1924 return function( elem ) { 1925 var elemLang; 1926 do { 1927 if ( ( elemLang = documentIsHTML ? 1928 elem.lang : 1929 elem.getAttribute( "xml:lang" ) || elem.getAttribute( "lang" ) ) ) { 1930 1931 elemLang = elemLang.toLowerCase(); 1932 return elemLang === lang || elemLang.indexOf( lang + "-" ) === 0; 1933 } 1934 } while ( ( elem = elem.parentNode ) && elem.nodeType === 1 ); 1935 return false; 1936 }; 1937 } ), 1938 1939 // Miscellaneous 1940 target: function( elem ) { 1941 var hash = window.location && window.location.hash; 1942 return hash && hash.slice( 1 ) === elem.id; 1943 }, 1944 1945 root: function( elem ) { 1946 return elem === documentElement; 1947 }, 1948 1949 focus: function( elem ) { 1950 return elem === safeActiveElement() && 1951 document.hasFocus() && 1952 !!( elem.type || elem.href || ~elem.tabIndex ); 1953 }, 1954 1955 // Boolean properties 1956 enabled: createDisabledPseudo( false ), 1957 disabled: createDisabledPseudo( true ), 1958 1959 checked: function( elem ) { 1960 1961 // In CSS3, :checked should return both checked and selected elements 1962 // https://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked 1963 return ( nodeName( elem, "input" ) && !!elem.checked ) || 1964 ( nodeName( elem, "option" ) && !!elem.selected ); 1965 }, 1966 1967 selected: function( elem ) { 1968 1969 // Support: IE <=11+ 1970 // Accessing the selectedIndex property 1971 // forces the browser to treat the default option as 1972 // selected when in an optgroup. 1973 if ( elem.parentNode ) { 1974 // eslint-disable-next-line no-unused-expressions 1975 elem.parentNode.selectedIndex; 1976 } 1977 1978 return elem.selected === true; 1979 }, 1980 1981 // Contents 1982 empty: function( elem ) { 1983 1984 // https://www.w3.org/TR/selectors/#empty-pseudo 1985 // :empty is negated by element (1) or content nodes (text: 3; cdata: 4; entity ref: 5), 1986 // but not by others (comment: 8; processing instruction: 7; etc.) 1987 // nodeType < 6 works because attributes (2) do not appear as children 1988 for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) { 1989 if ( elem.nodeType < 6 ) { 1990 return false; 1991 } 1992 } 1993 return true; 1994 }, 1995 1996 parent: function( elem ) { 1997 return !Expr.pseudos.empty( elem ); 1998 }, 1999 2000 // Element/input types 2001 header: function( elem ) { 2002 return rheader.test( elem.nodeName ); 2003 }, 2004 2005 input: function( elem ) { 2006 return rinputs.test( elem.nodeName ); 2007 }, 2008 2009 button: function( elem ) { 2010 return nodeName( elem, "input" ) && elem.type === "button" || 2011 nodeName( elem, "button" ); 2012 }, 2013 2014 text: function( elem ) { 2015 var attr; 2016 return nodeName( elem, "input" ) && elem.type === "text" && 2017 2018 // Support: IE <10 only 2019 // New HTML5 attribute values (e.g., "search") appear 2020 // with elem.type === "text" 2021 ( ( attr = elem.getAttribute( "type" ) ) == null || 2022 attr.toLowerCase() === "text" ); 2023 }, 2024 2025 // Position-in-collection 2026 first: createPositionalPseudo( function() { 2027 return [ 0 ]; 2028 } ), 2029 2030 last: createPositionalPseudo( function( _matchIndexes, length ) { 2031 return [ length - 1 ]; 2032 } ), 2033 2034 eq: createPositionalPseudo( function( _matchIndexes, length, argument ) { 2035 return [ argument < 0 ? argument + length : argument ]; 2036 } ), 2037 2038 even: createPositionalPseudo( function( matchIndexes, length ) { 2039 var i = 0; 2040 for ( ; i < length; i += 2 ) { 2041 matchIndexes.push( i ); 2042 } 2043 return matchIndexes; 2044 } ), 2045 2046 odd: createPositionalPseudo( function( matchIndexes, length ) { 2047 var i = 1; 2048 for ( ; i < length; i += 2 ) { 2049 matchIndexes.push( i ); 2050 } 2051 return matchIndexes; 2052 } ), 2053 2054 lt: createPositionalPseudo( function( matchIndexes, length, argument ) { 2055 var i; 2056 2057 if ( argument < 0 ) { 2058 i = argument + length; 2059 } else if ( argument > length ) { 2060 i = length; 2061 } else { 2062 i = argument; 2063 } 2064 2065 for ( ; --i >= 0; ) { 2066 matchIndexes.push( i ); 2067 } 2068 return matchIndexes; 2069 } ), 2070 2071 gt: createPositionalPseudo( function( matchIndexes, length, argument ) { 2072 var i = argument < 0 ? argument + length : argument; 2073 for ( ; ++i < length; ) { 2074 matchIndexes.push( i ); 2075 } 2076 return matchIndexes; 2077 } ) 2078 } 2079}; 2080 2081Expr.pseudos.nth = Expr.pseudos.eq; 2082 2083// Add button/input type pseudos 2084for ( i in { radio: true, checkbox: true, file: true, password: true, image: true } ) { 2085 Expr.pseudos[ i ] = createInputPseudo( i ); 2086} 2087for ( i in { submit: true, reset: true } ) { 2088 Expr.pseudos[ i ] = createButtonPseudo( i ); 2089} 2090 2091// Easy API for creating new setFilters 2092function setFilters() {} 2093setFilters.prototype = Expr.filters = Expr.pseudos; 2094Expr.setFilters = new setFilters(); 2095 2096function tokenize( selector, parseOnly ) { 2097 var matched, match, tokens, type, 2098 soFar, groups, preFilters, 2099 cached = tokenCache[ selector + " " ]; 2100 2101 if ( cached ) { 2102 return parseOnly ? 0 : cached.slice( 0 ); 2103 } 2104 2105 soFar = selector; 2106 groups = []; 2107 preFilters = Expr.preFilter; 2108 2109 while ( soFar ) { 2110 2111 // Comma and first run 2112 if ( !matched || ( match = rcomma.exec( soFar ) ) ) { 2113 if ( match ) { 2114 2115 // Don't consume trailing commas as valid 2116 soFar = soFar.slice( match[ 0 ].length ) || soFar; 2117 } 2118 groups.push( ( tokens = [] ) ); 2119 } 2120 2121 matched = false; 2122 2123 // Combinators 2124 if ( ( match = rleadingCombinator.exec( soFar ) ) ) { 2125 matched = match.shift(); 2126 tokens.push( { 2127 value: matched, 2128 2129 // Cast descendant combinators to space 2130 type: match[ 0 ].replace( rtrimCSS, " " ) 2131 } ); 2132 soFar = soFar.slice( matched.length ); 2133 } 2134 2135 // Filters 2136 for ( type in Expr.filter ) { 2137 if ( ( match = matchExpr[ type ].exec( soFar ) ) && ( !preFilters[ type ] || 2138 ( match = preFilters[ type ]( match ) ) ) ) { 2139 matched = match.shift(); 2140 tokens.push( { 2141 value: matched, 2142 type: type, 2143 matches: match 2144 } ); 2145 soFar = soFar.slice( matched.length ); 2146 } 2147 } 2148 2149 if ( !matched ) { 2150 break; 2151 } 2152 } 2153 2154 // Return the length of the invalid excess 2155 // if we're just parsing 2156 // Otherwise, throw an error or return tokens 2157 if ( parseOnly ) { 2158 return soFar.length; 2159 } 2160 2161 return soFar ? 2162 find.error( selector ) : 2163 2164 // Cache the tokens 2165 tokenCache( selector, groups ).slice( 0 ); 2166} 2167 2168function toSelector( tokens ) { 2169 var i = 0, 2170 len = tokens.length, 2171 selector = ""; 2172 for ( ; i < len; i++ ) { 2173 selector += tokens[ i ].value; 2174 } 2175 return selector; 2176} 2177 2178function addCombinator( matcher, combinator, base ) { 2179 var dir = combinator.dir, 2180 skip = combinator.next, 2181 key = skip || dir, 2182 checkNonElements = base && key === "parentNode", 2183 doneName = done++; 2184 2185 return combinator.first ? 2186 2187 // Check against closest ancestor/preceding element 2188 function( elem, context, xml ) { 2189 while ( ( elem = elem[ dir ] ) ) { 2190 if ( elem.nodeType === 1 || checkNonElements ) { 2191 return matcher( elem, context, xml ); 2192 } 2193 } 2194 return false; 2195 } : 2196 2197 // Check against all ancestor/preceding elements 2198 function( elem, context, xml ) { 2199 var oldCache, outerCache, 2200 newCache = [ dirruns, doneName ]; 2201 2202 // We can't set arbitrary data on XML nodes, so they don't benefit from combinator caching 2203 if ( xml ) { 2204 while ( ( elem = elem[ dir ] ) ) { 2205 if ( elem.nodeType === 1 || checkNonElements ) { 2206 if ( matcher( elem, context, xml ) ) { 2207 return true; 2208 } 2209 } 2210 } 2211 } else { 2212 while ( ( elem = elem[ dir ] ) ) { 2213 if ( elem.nodeType === 1 || checkNonElements ) { 2214 outerCache = elem[ expando ] || ( elem[ expando ] = {} ); 2215 2216 if ( skip && nodeName( elem, skip ) ) { 2217 elem = elem[ dir ] || elem; 2218 } else if ( ( oldCache = outerCache[ key ] ) && 2219 oldCache[ 0 ] === dirruns && oldCache[ 1 ] === doneName ) { 2220 2221 // Assign to newCache so results back-propagate to previous elements 2222 return ( newCache[ 2 ] = oldCache[ 2 ] ); 2223 } else { 2224 2225 // Reuse newcache so results back-propagate to previous elements 2226 outerCache[ key ] = newCache; 2227 2228 // A match means we're done; a fail means we have to keep checking 2229 if ( ( newCache[ 2 ] = matcher( elem, context, xml ) ) ) { 2230 return true; 2231 } 2232 } 2233 } 2234 } 2235 } 2236 return false; 2237 }; 2238} 2239 2240function elementMatcher( matchers ) { 2241 return matchers.length > 1 ? 2242 function( elem, context, xml ) { 2243 var i = matchers.length; 2244 while ( i-- ) { 2245 if ( !matchers[ i ]( elem, context, xml ) ) { 2246 return false; 2247 } 2248 } 2249 return true; 2250 } : 2251 matchers[ 0 ]; 2252} 2253 2254function multipleContexts( selector, contexts, results ) { 2255 var i = 0, 2256 len = contexts.length; 2257 for ( ; i < len; i++ ) { 2258 find( selector, contexts[ i ], results ); 2259 } 2260 return results; 2261} 2262 2263function condense( unmatched, map, filter, context, xml ) { 2264 var elem, 2265 newUnmatched = [], 2266 i = 0, 2267 len = unmatched.length, 2268 mapped = map != null; 2269 2270 for ( ; i < len; i++ ) { 2271 if ( ( elem = unmatched[ i ] ) ) { 2272 if ( !filter || filter( elem, context, xml ) ) { 2273 newUnmatched.push( elem ); 2274 if ( mapped ) { 2275 map.push( i ); 2276 } 2277 } 2278 } 2279 } 2280 2281 return newUnmatched; 2282} 2283 2284function setMatcher( preFilter, selector, matcher, postFilter, postFinder, postSelector ) { 2285 if ( postFilter && !postFilter[ expando ] ) { 2286 postFilter = setMatcher( postFilter ); 2287 } 2288 if ( postFinder && !postFinder[ expando ] ) { 2289 postFinder = setMatcher( postFinder, postSelector ); 2290 } 2291 return markFunction( function( seed, results, context, xml ) { 2292 var temp, i, elem, matcherOut, 2293 preMap = [], 2294 postMap = [], 2295 preexisting = results.length, 2296 2297 // Get initial elements from seed or context 2298 elems = seed || 2299 multipleContexts( selector || "*", 2300 context.nodeType ? [ context ] : context, [] ), 2301 2302 // Prefilter to get matcher input, preserving a map for seed-results synchronization 2303 matcherIn = preFilter && ( seed || !selector ) ? 2304 condense( elems, preMap, preFilter, context, xml ) : 2305 elems; 2306 2307 if ( matcher ) { 2308 2309 // If we have a postFinder, or filtered seed, or non-seed postFilter 2310 // or preexisting results, 2311 matcherOut = postFinder || ( seed ? preFilter : preexisting || postFilter ) ? 2312 2313 // ...intermediate processing is necessary 2314 [] : 2315 2316 // ...otherwise use results directly 2317 results; 2318 2319 // Find primary matches 2320 matcher( matcherIn, matcherOut, context, xml ); 2321 } else { 2322 matcherOut = matcherIn; 2323 } 2324 2325 // Apply postFilter 2326 if ( postFilter ) { 2327 temp = condense( matcherOut, postMap ); 2328 postFilter( temp, [], context, xml ); 2329 2330 // Un-match failing elements by moving them back to matcherIn 2331 i = temp.length; 2332 while ( i-- ) { 2333 if ( ( elem = temp[ i ] ) ) { 2334 matcherOut[ postMap[ i ] ] = !( matcherIn[ postMap[ i ] ] = elem ); 2335 } 2336 } 2337 } 2338 2339 if ( seed ) { 2340 if ( postFinder || preFilter ) { 2341 if ( postFinder ) { 2342 2343 // Get the final matcherOut by condensing this intermediate into postFinder contexts 2344 temp = []; 2345 i = matcherOut.length; 2346 while ( i-- ) { 2347 if ( ( elem = matcherOut[ i ] ) ) { 2348 2349 // Restore matcherIn since elem is not yet a final match 2350 temp.push( ( matcherIn[ i ] = elem ) ); 2351 } 2352 } 2353 postFinder( null, ( matcherOut = [] ), temp, xml ); 2354 } 2355 2356 // Move matched elements from seed to results to keep them synchronized 2357 i = matcherOut.length; 2358 while ( i-- ) { 2359 if ( ( elem = matcherOut[ i ] ) && 2360 ( temp = postFinder ? indexOf.call( seed, elem ) : preMap[ i ] ) > -1 ) { 2361 2362 seed[ temp ] = !( results[ temp ] = elem ); 2363 } 2364 } 2365 } 2366 2367 // Add elements to results, through postFinder if defined 2368 } else { 2369 matcherOut = condense( 2370 matcherOut === results ? 2371 matcherOut.splice( preexisting, matcherOut.length ) : 2372 matcherOut 2373 ); 2374 if ( postFinder ) { 2375 postFinder( null, results, matcherOut, xml ); 2376 } else { 2377 push.apply( results, matcherOut ); 2378 } 2379 } 2380 } ); 2381} 2382 2383function matcherFromTokens( tokens ) { 2384 var checkContext, matcher, j, 2385 len = tokens.length, 2386 leadingRelative = Expr.relative[ tokens[ 0 ].type ], 2387 implicitRelative = leadingRelative || Expr.relative[ " " ], 2388 i = leadingRelative ? 1 : 0, 2389 2390 // The foundational matcher ensures that elements are reachable from top-level context(s) 2391 matchContext = addCombinator( function( elem ) { 2392 return elem === checkContext; 2393 }, implicitRelative, true ), 2394 matchAnyContext = addCombinator( function( elem ) { 2395 return indexOf.call( checkContext, elem ) > -1; 2396 }, implicitRelative, true ), 2397 matchers = [ function( elem, context, xml ) { 2398 2399 // Support: IE 11+, Edge 17 - 18+ 2400 // IE/Edge sometimes throw a "Permission denied" error when strict-comparing 2401 // two documents; shallow comparisons work. 2402 // eslint-disable-next-line eqeqeq 2403 var ret = ( !leadingRelative && ( xml || context != outermostContext ) ) || ( 2404 ( checkContext = context ).nodeType ? 2405 matchContext( elem, context, xml ) : 2406 matchAnyContext( elem, context, xml ) ); 2407 2408 // Avoid hanging onto element 2409 // (see https://github.com/jquery/sizzle/issues/299) 2410 checkContext = null; 2411 return ret; 2412 } ]; 2413 2414 for ( ; i < len; i++ ) { 2415 if ( ( matcher = Expr.relative[ tokens[ i ].type ] ) ) { 2416 matchers = [ addCombinator( elementMatcher( matchers ), matcher ) ]; 2417 } else { 2418 matcher = Expr.filter[ tokens[ i ].type ].apply( null, tokens[ i ].matches ); 2419 2420 // Return special upon seeing a positional matcher 2421 if ( matcher[ expando ] ) { 2422 2423 // Find the next relative operator (if any) for proper handling 2424 j = ++i; 2425 for ( ; j < len; j++ ) { 2426 if ( Expr.relative[ tokens[ j ].type ] ) { 2427 break; 2428 } 2429 } 2430 return setMatcher( 2431 i > 1 && elementMatcher( matchers ), 2432 i > 1 && toSelector( 2433 2434 // If the preceding token was a descendant combinator, insert an implicit any-element `*` 2435 tokens.slice( 0, i - 1 ) 2436 .concat( { value: tokens[ i - 2 ].type === " " ? "*" : "" } ) 2437 ).replace( rtrimCSS, "$1" ), 2438 matcher, 2439 i < j && matcherFromTokens( tokens.slice( i, j ) ), 2440 j < len && matcherFromTokens( ( tokens = tokens.slice( j ) ) ), 2441 j < len && toSelector( tokens ) 2442 ); 2443 } 2444 matchers.push( matcher ); 2445 } 2446 } 2447 2448 return elementMatcher( matchers ); 2449} 2450 2451function matcherFromGroupMatchers( elementMatchers, setMatchers ) { 2452 var bySet = setMatchers.length > 0, 2453 byElement = elementMatchers.length > 0, 2454 superMatcher = function( seed, context, xml, results, outermost ) { 2455 var elem, j, matcher, 2456 matchedCount = 0, 2457 i = "0", 2458 unmatched = seed && [], 2459 setMatched = [], 2460 contextBackup = outermostContext, 2461 2462 // We must always have either seed elements or outermost context 2463 elems = seed || byElement && Expr.find.TAG( "*", outermost ), 2464 2465 // Use integer dirruns iff this is the outermost matcher 2466 dirrunsUnique = ( dirruns += contextBackup == null ? 1 : Math.random() || 0.1 ), 2467 len = elems.length; 2468 2469 if ( outermost ) { 2470 2471 // Support: IE 11+, Edge 17 - 18+ 2472 // IE/Edge sometimes throw a "Permission denied" error when strict-comparing 2473 // two documents; shallow comparisons work. 2474 // eslint-disable-next-line eqeqeq 2475 outermostContext = context == document || context || outermost; 2476 } 2477 2478 // Add elements passing elementMatchers directly to results 2479 // Support: iOS <=7 - 9 only 2480 // Tolerate NodeList properties (IE: "length"; Safari: <number>) matching 2481 // elements by id. (see trac-14142) 2482 for ( ; i !== len && ( elem = elems[ i ] ) != null; i++ ) { 2483 if ( byElement && elem ) { 2484 j = 0; 2485 2486 // Support: IE 11+, Edge 17 - 18+ 2487 // IE/Edge sometimes throw a "Permission denied" error when strict-comparing 2488 // two documents; shallow comparisons work. 2489 // eslint-disable-next-line eqeqeq 2490 if ( !context && elem.ownerDocument != document ) { 2491 setDocument( elem ); 2492 xml = !documentIsHTML; 2493 } 2494 while ( ( matcher = elementMatchers[ j++ ] ) ) { 2495 if ( matcher( elem, context || document, xml ) ) { 2496 push.call( results, elem ); 2497 break; 2498 } 2499 } 2500 if ( outermost ) { 2501 dirruns = dirrunsUnique; 2502 } 2503 } 2504 2505 // Track unmatched elements for set filters 2506 if ( bySet ) { 2507 2508 // They will have gone through all possible matchers 2509 if ( ( elem = !matcher && elem ) ) { 2510 matchedCount--; 2511 } 2512 2513 // Lengthen the array for every element, matched or not 2514 if ( seed ) { 2515 unmatched.push( elem ); 2516 } 2517 } 2518 } 2519 2520 // `i` is now the count of elements visited above, and adding it to `matchedCount` 2521 // makes the latter nonnegative. 2522 matchedCount += i; 2523 2524 // Apply set filters to unmatched elements 2525 // NOTE: This can be skipped if there are no unmatched elements (i.e., `matchedCount` 2526 // equals `i`), unless we didn't visit _any_ elements in the above loop because we have 2527 // no element matchers and no seed. 2528 // Incrementing an initially-string "0" `i` allows `i` to remain a string only in that 2529 // case, which will result in a "00" `matchedCount` that differs from `i` but is also 2530 // numerically zero. 2531 if ( bySet && i !== matchedCount ) { 2532 j = 0; 2533 while ( ( matcher = setMatchers[ j++ ] ) ) { 2534 matcher( unmatched, setMatched, context, xml ); 2535 } 2536 2537 if ( seed ) { 2538 2539 // Reintegrate element matches to eliminate the need for sorting 2540 if ( matchedCount > 0 ) { 2541 while ( i-- ) { 2542 if ( !( unmatched[ i ] || setMatched[ i ] ) ) { 2543 setMatched[ i ] = pop.call( results ); 2544 } 2545 } 2546 } 2547 2548 // Discard index placeholder values to get only actual matches 2549 setMatched = condense( setMatched ); 2550 } 2551 2552 // Add matches to results 2553 push.apply( results, setMatched ); 2554 2555 // Seedless set matches succeeding multiple successful matchers stipulate sorting 2556 if ( outermost && !seed && setMatched.length > 0 && 2557 ( matchedCount + setMatchers.length ) > 1 ) { 2558 2559 jQuery.uniqueSort( results ); 2560 } 2561 } 2562 2563 // Override manipulation of globals by nested matchers 2564 if ( outermost ) { 2565 dirruns = dirrunsUnique; 2566 outermostContext = contextBackup; 2567 } 2568 2569 return unmatched; 2570 }; 2571 2572 return bySet ? 2573 markFunction( superMatcher ) : 2574 superMatcher; 2575} 2576 2577function compile( selector, match /* Internal Use Only */ ) { 2578 var i, 2579 setMatchers = [], 2580 elementMatchers = [], 2581 cached = compilerCache[ selector + " " ]; 2582 2583 if ( !cached ) { 2584 2585 // Generate a function of recursive functions that can be used to check each element 2586 if ( !match ) { 2587 match = tokenize( selector ); 2588 } 2589 i = match.length; 2590 while ( i-- ) { 2591 cached = matcherFromTokens( match[ i ] ); 2592 if ( cached[ expando ] ) { 2593 setMatchers.push( cached ); 2594 } else { 2595 elementMatchers.push( cached ); 2596 } 2597 } 2598 2599 // Cache the compiled function 2600 cached = compilerCache( selector, 2601 matcherFromGroupMatchers( elementMatchers, setMatchers ) ); 2602 2603 // Save selector and tokenization 2604 cached.selector = selector; 2605 } 2606 return cached; 2607} 2608 2609/** 2610 * A low-level selection function that works with jQuery's compiled 2611 * selector functions 2612 * @param {String|Function} selector A selector or a pre-compiled 2613 * selector function built with jQuery selector compile 2614 * @param {Element} context 2615 * @param {Array} [results] 2616 * @param {Array} [seed] A set of elements to match against 2617 */ 2618function select( selector, context, results, seed ) { 2619 var i, tokens, token, type, find, 2620 compiled = typeof selector === "function" && selector, 2621 match = !seed && tokenize( ( selector = compiled.selector || selector ) ); 2622 2623 results = results || []; 2624 2625 // Try to minimize operations if there is only one selector in the list and no seed 2626 // (the latter of which guarantees us context) 2627 if ( match.length === 1 ) { 2628 2629 // Reduce context if the leading compound selector is an ID 2630 tokens = match[ 0 ] = match[ 0 ].slice( 0 ); 2631 if ( tokens.length > 2 && ( token = tokens[ 0 ] ).type === "ID" && 2632 context.nodeType === 9 && documentIsHTML && Expr.relative[ tokens[ 1 ].type ] ) { 2633 2634 context = ( Expr.find.ID( 2635 token.matches[ 0 ].replace( runescape, funescape ), 2636 context 2637 ) || [] )[ 0 ]; 2638 if ( !context ) { 2639 return results; 2640 2641 // Precompiled matchers will still verify ancestry, so step up a level 2642 } else if ( compiled ) { 2643 context = context.parentNode; 2644 } 2645 2646 selector = selector.slice( tokens.shift().value.length ); 2647 } 2648 2649 // Fetch a seed set for right-to-left matching 2650 i = matchExpr.needsContext.test( selector ) ? 0 : tokens.length; 2651 while ( i-- ) { 2652 token = tokens[ i ]; 2653 2654 // Abort if we hit a combinator 2655 if ( Expr.relative[ ( type = token.type ) ] ) { 2656 break; 2657 } 2658 if ( ( find = Expr.find[ type ] ) ) { 2659 2660 // Search, expanding context for leading sibling combinators 2661 if ( ( seed = find( 2662 token.matches[ 0 ].replace( runescape, funescape ), 2663 rsibling.test( tokens[ 0 ].type ) && 2664 testContext( context.parentNode ) || context 2665 ) ) ) { 2666 2667 // If seed is empty or no tokens remain, we can return early 2668 tokens.splice( i, 1 ); 2669 selector = seed.length && toSelector( tokens ); 2670 if ( !selector ) { 2671 push.apply( results, seed ); 2672 return results; 2673 } 2674 2675 break; 2676 } 2677 } 2678 } 2679 } 2680 2681 // Compile and execute a filtering function if one is not provided 2682 // Provide `match` to avoid retokenization if we modified the selector above 2683 ( compiled || compile( selector, match ) )( 2684 seed, 2685 context, 2686 !documentIsHTML, 2687 results, 2688 !context || rsibling.test( selector ) && testContext( context.parentNode ) || context 2689 ); 2690 return results; 2691} 2692 2693// One-time assignments 2694 2695// Support: Android <=4.0 - 4.1+ 2696// Sort stability 2697support.sortStable = expando.split( "" ).sort( sortOrder ).join( "" ) === expando; 2698 2699// Initialize against the default document 2700setDocument(); 2701 2702// Support: Android <=4.0 - 4.1+ 2703// Detached nodes confoundingly follow *each other* 2704support.sortDetached = assert( function( el ) { 2705 2706 // Should return 1, but returns 4 (following) 2707 return el.compareDocumentPosition( document.createElement( "fieldset" ) ) & 1; 2708} ); 2709 2710jQuery.find = find; 2711 2712// Deprecated 2713jQuery.expr[ ":" ] = jQuery.expr.pseudos; 2714jQuery.unique = jQuery.uniqueSort; 2715 2716// These have always been private, but they used to be documented as part of 2717// Sizzle so let's maintain them for now for backwards compatibility purposes. 2718find.compile = compile; 2719find.select = select; 2720find.setDocument = setDocument; 2721find.tokenize = tokenize; 2722 2723find.escape = jQuery.escapeSelector; 2724find.getText = jQuery.text; 2725find.isXML = jQuery.isXMLDoc; 2726find.selectors = jQuery.expr; 2727find.support = jQuery.support; 2728find.uniqueSort = jQuery.uniqueSort; 2729 2730 /* eslint-enable */ 2731 2732} )(); 2733 2734 2735var dir = function( elem, dir, until ) { 2736 var matched = [], 2737 truncate = until !== undefined; 2738 2739 while ( ( elem = elem[ dir ] ) && elem.nodeType !== 9 ) { 2740 if ( elem.nodeType === 1 ) { 2741 if ( truncate && jQuery( elem ).is( until ) ) { 2742 break; 2743 } 2744 matched.push( elem ); 2745 } 2746 } 2747 return matched; 2748}; 2749 2750 2751var siblings = function( n, elem ) { 2752 var matched = []; 2753 2754 for ( ; n; n = n.nextSibling ) { 2755 if ( n.nodeType === 1 && n !== elem ) { 2756 matched.push( n ); 2757 } 2758 } 2759 2760 return matched; 2761}; 2762 2763 2764var rneedsContext = jQuery.expr.match.needsContext; 2765 2766var rsingleTag = ( /^<([a-z][^\/\0>:\x20\t\r\n\f]*)[\x20\t\r\n\f]*\/?>(?:<\/\1>|)$/i ); 2767 2768 2769 2770// Implement the identical functionality for filter and not 2771function winnow( elements, qualifier, not ) { 2772 if ( isFunction( qualifier ) ) { 2773 return jQuery.grep( elements, function( elem, i ) { 2774 return !!qualifier.call( elem, i, elem ) !== not; 2775 } ); 2776 } 2777 2778 // Single element 2779 if ( qualifier.nodeType ) { 2780 return jQuery.grep( elements, function( elem ) { 2781 return ( elem === qualifier ) !== not; 2782 } ); 2783 } 2784 2785 // Arraylike of elements (jQuery, arguments, Array) 2786 if ( typeof qualifier !== "string" ) { 2787 return jQuery.grep( elements, function( elem ) { 2788 return ( indexOf.call( qualifier, elem ) > -1 ) !== not; 2789 } ); 2790 } 2791 2792 // Filtered directly for both simple and complex selectors 2793 return jQuery.filter( qualifier, elements, not ); 2794} 2795 2796jQuery.filter = function( expr, elems, not ) { 2797 var elem = elems[ 0 ]; 2798 2799 if ( not ) { 2800 expr = ":not(" + expr + ")"; 2801 } 2802 2803 if ( elems.length === 1 && elem.nodeType === 1 ) { 2804 return jQuery.find.matchesSelector( elem, expr ) ? [ elem ] : []; 2805 } 2806 2807 return jQuery.find.matches( expr, jQuery.grep( elems, function( elem ) { 2808 return elem.nodeType === 1; 2809 } ) ); 2810}; 2811 2812jQuery.fn.extend( { 2813 find: function( selector ) { 2814 var i, ret, 2815 len = this.length, 2816 self = this; 2817 2818 if ( typeof selector !== "string" ) { 2819 return this.pushStack( jQuery( selector ).filter( function() { 2820 for ( i = 0; i < len; i++ ) { 2821 if ( jQuery.contains( self[ i ], this ) ) { 2822 return true; 2823 } 2824 } 2825 } ) ); 2826 } 2827 2828 ret = this.pushStack( [] ); 2829 2830 for ( i = 0; i < len; i++ ) { 2831 jQuery.find( selector, self[ i ], ret ); 2832 } 2833 2834 return len > 1 ? jQuery.uniqueSort( ret ) : ret; 2835 }, 2836 filter: function( selector ) { 2837 return this.pushStack( winnow( this, selector || [], false ) ); 2838 }, 2839 not: function( selector ) { 2840 return this.pushStack( winnow( this, selector || [], true ) ); 2841 }, 2842 is: function( selector ) { 2843 return !!winnow( 2844 this, 2845 2846 // If this is a positional/relative selector, check membership in the returned set 2847 // so $("p:first").is("p:last") won't return true for a doc with two "p". 2848 typeof selector === "string" && rneedsContext.test( selector ) ? 2849 jQuery( selector ) : 2850 selector || [], 2851 false 2852 ).length; 2853 } 2854} ); 2855 2856 2857// Initialize a jQuery object 2858 2859 2860// A central reference to the root jQuery(document) 2861var rootjQuery, 2862 2863 // A simple way to check for HTML strings 2864 // Prioritize #id over <tag> to avoid XSS via location.hash (trac-9521) 2865 // Strict HTML recognition (trac-11290: must start with <) 2866 // Shortcut simple #id case for speed 2867 rquickExpr = /^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]+))$/, 2868 2869 init = jQuery.fn.init = function( selector, context, root ) { 2870 var match, elem; 2871 2872 // HANDLE: $(""), $(null), $(undefined), $(false) 2873 if ( !selector ) { 2874 return this; 2875 } 2876 2877 // Method init() accepts an alternate rootjQuery 2878 // so migrate can support jQuery.sub (gh-2101) 2879 root = root || rootjQuery; 2880 2881 // Handle HTML strings 2882 if ( typeof selector === "string" ) { 2883 if ( selector[ 0 ] === "<" && 2884 selector[ selector.length - 1 ] === ">" && 2885 selector.length >= 3 ) { 2886 2887 // Assume that strings that start and end with <> are HTML and skip the regex check 2888 match = [ null, selector, null ]; 2889 2890 } else { 2891 match = rquickExpr.exec( selector ); 2892 } 2893 2894 // Match html or make sure no context is specified for #id 2895 if ( match && ( match[ 1 ] || !context ) ) { 2896 2897 // HANDLE: $(html) -> $(array) 2898 if ( match[ 1 ] ) { 2899 context = context instanceof jQuery ? context[ 0 ] : context; 2900 2901 // Option to run scripts is true for back-compat 2902 // Intentionally let the error be thrown if parseHTML is not present 2903 jQuery.merge( this, jQuery.parseHTML( 2904 match[ 1 ], 2905 context && context.nodeType ? context.ownerDocument || context : document, 2906 true 2907 ) ); 2908 2909 // HANDLE: $(html, props) 2910 if ( rsingleTag.test( match[ 1 ] ) && jQuery.isPlainObject( context ) ) { 2911 for ( match in context ) { 2912 2913 // Properties of context are called as methods if possible 2914 if ( isFunction( this[ match ] ) ) { 2915 this[ match ]( context[ match ] ); 2916 2917 // ...and otherwise set as attributes 2918 } else { 2919 this.attr( match, context[ match ] ); 2920 } 2921 } 2922 } 2923 2924 return this; 2925 2926 // HANDLE: $(#id) 2927 } else { 2928 elem = document.getElementById( match[ 2 ] ); 2929 2930 if ( elem ) { 2931 2932 // Inject the element directly into the jQuery object 2933 this[ 0 ] = elem; 2934 this.length = 1; 2935 } 2936 return this; 2937 } 2938 2939 // HANDLE: $(expr, $(...)) 2940 } else if ( !context || context.jquery ) { 2941 return ( context || root ).find( selector ); 2942 2943 // HANDLE: $(expr, context) 2944 // (which is just equivalent to: $(context).find(expr) 2945 } else { 2946 return this.constructor( context ).find( selector ); 2947 } 2948 2949 // HANDLE: $(DOMElement) 2950 } else if ( selector.nodeType ) { 2951 this[ 0 ] = selector; 2952 this.length = 1; 2953 return this; 2954 2955 // HANDLE: $(function) 2956 // Shortcut for document ready 2957 } else if ( isFunction( selector ) ) { 2958 return root.ready !== undefined ? 2959 root.ready( selector ) : 2960 2961 // Execute immediately if ready is not present 2962 selector( jQuery ); 2963 } 2964 2965 return jQuery.makeArray( selector, this ); 2966 }; 2967 2968// Give the init function the jQuery prototype for later instantiation 2969init.prototype = jQuery.fn; 2970 2971// Initialize central reference 2972rootjQuery = jQuery( document ); 2973 2974 2975var rparentsprev = /^(?:parents|prev(?:Until|All))/, 2976 2977 // Methods guaranteed to produce a unique set when starting from a unique set 2978 guaranteedUnique = { 2979 children: true, 2980 contents: true, 2981 next: true, 2982 prev: true 2983 }; 2984 2985jQuery.fn.extend( { 2986 has: function( target ) { 2987 var targets = jQuery( target, this ), 2988 l = targets.length; 2989 2990 return this.filter( function() { 2991 var i = 0; 2992 for ( ; i < l; i++ ) { 2993 if ( jQuery.contains( this, targets[ i ] ) ) { 2994 return true; 2995 } 2996 } 2997 } ); 2998 }, 2999 3000 closest: function( selectors, context ) { 3001 var cur, 3002 i = 0, 3003 l = this.length, 3004 matched = [], 3005 targets = typeof selectors !== "string" && jQuery( selectors ); 3006 3007 // Positional selectors never match, since there's no _selection_ context 3008 if ( !rneedsContext.test( selectors ) ) { 3009 for ( ; i < l; i++ ) { 3010 for ( cur = this[ i ]; cur && cur !== context; cur = cur.parentNode ) { 3011 3012 // Always skip document fragments 3013 if ( cur.nodeType < 11 && ( targets ? 3014 targets.index( cur ) > -1 : 3015 3016 // Don't pass non-elements to jQuery#find 3017 cur.nodeType === 1 && 3018 jQuery.find.matchesSelector( cur, selectors ) ) ) { 3019 3020 matched.push( cur ); 3021 break; 3022 } 3023 } 3024 } 3025 } 3026 3027 return this.pushStack( matched.length > 1 ? jQuery.uniqueSort( matched ) : matched ); 3028 }, 3029 3030 // Determine the position of an element within the set 3031 index: function( elem ) { 3032 3033 // No argument, return index in parent 3034 if ( !elem ) { 3035 return ( this[ 0 ] && this[ 0 ].parentNode ) ? this.first().prevAll().length : -1; 3036 } 3037 3038 // Index in selector 3039 if ( typeof elem === "string" ) { 3040 return indexOf.call( jQuery( elem ), this[ 0 ] ); 3041 } 3042 3043 // Locate the position of the desired element 3044 return indexOf.call( this, 3045 3046 // If it receives a jQuery object, the first element is used 3047 elem.jquery ? elem[ 0 ] : elem 3048 ); 3049 }, 3050 3051 add: function( selector, context ) { 3052 return this.pushStack( 3053 jQuery.uniqueSort( 3054 jQuery.merge( this.get(), jQuery( selector, context ) ) 3055 ) 3056 ); 3057 }, 3058 3059 addBack: function( selector ) { 3060 return this.add( selector == null ? 3061 this.prevObject : this.prevObject.filter( selector ) 3062 ); 3063 } 3064} ); 3065 3066function sibling( cur, dir ) { 3067 while ( ( cur = cur[ dir ] ) && cur.nodeType !== 1 ) {} 3068 return cur; 3069} 3070 3071jQuery.each( { 3072 parent: function( elem ) { 3073 var parent = elem.parentNode; 3074 return parent && parent.nodeType !== 11 ? parent : null; 3075 }, 3076 parents: function( elem ) { 3077 return dir( elem, "parentNode" ); 3078 }, 3079 parentsUntil: function( elem, _i, until ) { 3080 return dir( elem, "parentNode", until ); 3081 }, 3082 next: function( elem ) { 3083 return sibling( elem, "nextSibling" ); 3084 }, 3085 prev: function( elem ) { 3086 return sibling( elem, "previousSibling" ); 3087 }, 3088 nextAll: function( elem ) { 3089 return dir( elem, "nextSibling" ); 3090 }, 3091 prevAll: function( elem ) { 3092 return dir( elem, "previousSibling" ); 3093 }, 3094 nextUntil: function( elem, _i, until ) { 3095 return dir( elem, "nextSibling", until ); 3096 }, 3097 prevUntil: function( elem, _i, until ) { 3098 return dir( elem, "previousSibling", until ); 3099 }, 3100 siblings: function( elem ) { 3101 return siblings( ( elem.parentNode || {} ).firstChild, elem ); 3102 }, 3103 children: function( elem ) { 3104 return siblings( elem.firstChild ); 3105 }, 3106 contents: function( elem ) { 3107 if ( elem.contentDocument != null && 3108 3109 // Support: IE 11+ 3110 // <object> elements with no `data` attribute has an object 3111 // `contentDocument` with a `null` prototype. 3112 getProto( elem.contentDocument ) ) { 3113 3114 return elem.contentDocument; 3115 } 3116 3117 // Support: IE 9 - 11 only, iOS 7 only, Android Browser <=4.3 only 3118 // Treat the template element as a regular one in browsers that 3119 // don't support it. 3120 if ( nodeName( elem, "template" ) ) { 3121 elem = elem.content || elem; 3122 } 3123 3124 return jQuery.merge( [], elem.childNodes ); 3125 } 3126}, function( name, fn ) { 3127 jQuery.fn[ name ] = function( until, selector ) { 3128 var matched = jQuery.map( this, fn, until ); 3129 3130 if ( name.slice( -5 ) !== "Until" ) { 3131 selector = until; 3132 } 3133 3134 if ( selector && typeof selector === "string" ) { 3135 matched = jQuery.filter( selector, matched ); 3136 } 3137 3138 if ( this.length > 1 ) { 3139 3140 // Remove duplicates 3141 if ( !guaranteedUnique[ name ] ) { 3142 jQuery.uniqueSort( matched ); 3143 } 3144 3145 // Reverse order for parents* and prev-derivatives 3146 if ( rparentsprev.test( name ) ) { 3147 matched.reverse(); 3148 } 3149 } 3150 3151 return this.pushStack( matched ); 3152 }; 3153} ); 3154var rnothtmlwhite = ( /[^\x20\t\r\n\f]+/g ); 3155 3156 3157 3158// Convert String-formatted options into Object-formatted ones 3159function createOptions( options ) { 3160 var object = {}; 3161 jQuery.each( options.match( rnothtmlwhite ) || [], function( _, flag ) { 3162 object[ flag ] = true; 3163 } ); 3164 return object; 3165} 3166 3167/* 3168 * Create a callback list using the following parameters: 3169 * 3170 * options: an optional list of space-separated options that will change how 3171 * the callback list behaves or a more traditional option object 3172 * 3173 * By default a callback list will act like an event callback list and can be 3174 * "fired" multiple times. 3175 * 3176 * Possible options: 3177 * 3178 * once: will ensure the callback list can only be fired once (like a Deferred) 3179 * 3180 * memory: will keep track of previous values and will call any callback added 3181 * after the list has been fired right away with the latest "memorized" 3182 * values (like a Deferred) 3183 * 3184 * unique: will ensure a callback can only be added once (no duplicate in the list) 3185 * 3186 * stopOnFalse: interrupt callings when a callback returns false 3187 * 3188 */ 3189jQuery.Callbacks = function( options ) { 3190 3191 // Convert options from String-formatted to Object-formatted if needed 3192 // (we check in cache first) 3193 options = typeof options === "string" ? 3194 createOptions( options ) : 3195 jQuery.extend( {}, options ); 3196 3197 var // Flag to know if list is currently firing 3198 firing, 3199 3200 // Last fire value for non-forgettable lists 3201 memory, 3202 3203 // Flag to know if list was already fired 3204 fired, 3205 3206 // Flag to prevent firing 3207 locked, 3208 3209 // Actual callback list 3210 list = [], 3211 3212 // Queue of execution data for repeatable lists 3213 queue = [], 3214 3215 // Index of currently firing callback (modified by add/remove as needed) 3216 firingIndex = -1, 3217 3218 // Fire callbacks 3219 fire = function() { 3220 3221 // Enforce single-firing 3222 locked = locked || options.once; 3223 3224 // Execute callbacks for all pending executions, 3225 // respecting firingIndex overrides and runtime changes 3226 fired = firing = true; 3227 for ( ; queue.length; firingIndex = -1 ) { 3228 memory = queue.shift(); 3229 while ( ++firingIndex < list.length ) { 3230 3231 // Run callback and check for early termination 3232 if ( list[ firingIndex ].apply( memory[ 0 ], memory[ 1 ] ) === false && 3233 options.stopOnFalse ) { 3234 3235 // Jump to end and forget the data so .add doesn't re-fire 3236 firingIndex = list.length; 3237 memory = false; 3238 } 3239 } 3240 } 3241 3242 // Forget the data if we're done with it 3243 if ( !options.memory ) { 3244 memory = false; 3245 } 3246 3247 firing = false; 3248 3249 // Clean up if we're done firing for good 3250 if ( locked ) { 3251 3252 // Keep an empty list if we have data for future add calls 3253 if ( memory ) { 3254 list = []; 3255 3256 // Otherwise, this object is spent 3257 } else { 3258 list = ""; 3259 } 3260 } 3261 }, 3262 3263 // Actual Callbacks object 3264 self = { 3265 3266 // Add a callback or a collection of callbacks to the list 3267 add: function() { 3268 if ( list ) { 3269 3270 // If we have memory from a past run, we should fire after adding 3271 if ( memory && !firing ) { 3272 firingIndex = list.length - 1; 3273 queue.push( memory ); 3274 } 3275 3276 ( function add( args ) { 3277 jQuery.each( args, function( _, arg ) { 3278 if ( isFunction( arg ) ) { 3279 if ( !options.unique || !self.has( arg ) ) { 3280 list.push( arg ); 3281 } 3282 } else if ( arg && arg.length && toType( arg ) !== "string" ) { 3283 3284 // Inspect recursively 3285 add( arg ); 3286 } 3287 } ); 3288 } )( arguments ); 3289 3290 if ( memory && !firing ) { 3291 fire(); 3292 } 3293 } 3294 return this; 3295 }, 3296 3297 // Remove a callback from the list 3298 remove: function() { 3299 jQuery.each( arguments, function( _, arg ) { 3300 var index; 3301 while ( ( index = jQuery.inArray( arg, list, index ) ) > -1 ) { 3302 list.splice( index, 1 ); 3303 3304 // Handle firing indexes 3305 if ( index <= firingIndex ) { 3306 firingIndex--; 3307 } 3308 } 3309 } ); 3310 return this; 3311 }, 3312 3313 // Check if a given callback is in the list. 3314 // If no argument is given, return whether or not list has callbacks attached. 3315 has: function( fn ) { 3316 return fn ? 3317 jQuery.inArray( fn, list ) > -1 : 3318 list.length > 0; 3319 }, 3320 3321 // Remove all callbacks from the list 3322 empty: function() { 3323 if ( list ) { 3324 list = []; 3325 } 3326 return this; 3327 }, 3328 3329 // Disable .fire and .add 3330 // Abort any current/pending executions 3331 // Clear all callbacks and values 3332 disable: function() { 3333 locked = queue = []; 3334 list = memory = ""; 3335 return this; 3336 }, 3337 disabled: function() { 3338 return !list; 3339 }, 3340 3341 // Disable .fire 3342 // Also disable .add unless we have memory (since it would have no effect) 3343 // Abort any pending executions 3344 lock: function() { 3345 locked = queue = []; 3346 if ( !memory && !firing ) { 3347 list = memory = ""; 3348 } 3349 return this; 3350 }, 3351 locked: function() { 3352 return !!locked; 3353 }, 3354 3355 // Call all callbacks with the given context and arguments 3356 fireWith: function( context, args ) { 3357 if ( !locked ) { 3358 args = args || []; 3359 args = [ context, args.slice ? args.slice() : args ]; 3360 queue.push( args ); 3361 if ( !firing ) { 3362 fire(); 3363 } 3364 } 3365 return this; 3366 }, 3367 3368 // Call all the callbacks with the given arguments 3369 fire: function() { 3370 self.fireWith( this, arguments ); 3371 return this; 3372 }, 3373 3374 // To know if the callbacks have already been called at least once 3375 fired: function() { 3376 return !!fired; 3377 } 3378 }; 3379 3380 return self; 3381}; 3382 3383 3384function Identity( v ) { 3385 return v; 3386} 3387function Thrower( ex ) { 3388 throw ex; 3389} 3390 3391function adoptValue( value, resolve, reject, noValue ) { 3392 var method; 3393 3394 try { 3395 3396 // Check for promise aspect first to privilege synchronous behavior 3397 if ( value && isFunction( ( method = value.promise ) ) ) { 3398 method.call( value ).done( resolve ).fail( reject ); 3399 3400 // Other thenables 3401 } else if ( value && isFunction( ( method = value.then ) ) ) { 3402 method.call( value, resolve, reject ); 3403 3404 // Other non-thenables 3405 } else { 3406 3407 // Control `resolve` arguments by letting Array#slice cast boolean `noValue` to integer: 3408 // * false: [ value ].slice( 0 ) => resolve( value ) 3409 // * true: [ value ].slice( 1 ) => resolve() 3410 resolve.apply( undefined, [ value ].slice( noValue ) ); 3411 } 3412 3413 // For Promises/A+, convert exceptions into rejections 3414 // Since jQuery.when doesn't unwrap thenables, we can skip the extra checks appearing in 3415 // Deferred#then to conditionally suppress rejection. 3416 } catch ( value ) { 3417 3418 // Support: Android 4.0 only 3419 // Strict mode functions invoked without .call/.apply get global-object context 3420 reject.apply( undefined, [ value ] ); 3421 } 3422} 3423 3424jQuery.extend( { 3425 3426 Deferred: function( func ) { 3427 var tuples = [ 3428 3429 // action, add listener, callbacks, 3430 // ... .then handlers, argument index, [final state] 3431 [ "notify", "progress", jQuery.Callbacks( "memory" ), 3432 jQuery.Callbacks( "memory" ), 2 ], 3433 [ "resolve", "done", jQuery.Callbacks( "once memory" ), 3434 jQuery.Callbacks( "once memory" ), 0, "resolved" ], 3435 [ "reject", "fail", jQuery.Callbacks( "once memory" ), 3436 jQuery.Callbacks( "once memory" ), 1, "rejected" ] 3437 ], 3438 state = "pending", 3439 promise = { 3440 state: function() { 3441 return state; 3442 }, 3443 always: function() { 3444 deferred.done( arguments ).fail( arguments ); 3445 return this; 3446 }, 3447 "catch": function( fn ) { 3448 return promise.then( null, fn ); 3449 }, 3450 3451 // Keep pipe for back-compat 3452 pipe: function( /* fnDone, fnFail, fnProgress */ ) { 3453 var fns = arguments; 3454 3455 return jQuery.Deferred( function( newDefer ) { 3456 jQuery.each( tuples, function( _i, tuple ) { 3457 3458 // Map tuples (progress, done, fail) to arguments (done, fail, progress) 3459 var fn = isFunction( fns[ tuple[ 4 ] ] ) && fns[ tuple[ 4 ] ]; 3460 3461 // deferred.progress(function() { bind to newDefer or newDefer.notify }) 3462 // deferred.done(function() { bind to newDefer or newDefer.resolve }) 3463 // deferred.fail(function() { bind to newDefer or newDefer.reject }) 3464 deferred[ tuple[ 1 ] ]( function() { 3465 var returned = fn && fn.apply( this, arguments ); 3466 if ( returned && isFunction( returned.promise ) ) { 3467 returned.promise() 3468 .progress( newDefer.notify ) 3469 .done( newDefer.resolve ) 3470 .fail( newDefer.reject ); 3471 } else { 3472 newDefer[ tuple[ 0 ] + "With" ]( 3473 this, 3474 fn ? [ returned ] : arguments 3475 ); 3476 } 3477 } ); 3478 } ); 3479 fns = null; 3480 } ).promise(); 3481 }, 3482 then: function( onFulfilled, onRejected, onProgress ) { 3483 var maxDepth = 0; 3484 function resolve( depth, deferred, handler, special ) { 3485 return function() { 3486 var that = this, 3487 args = arguments, 3488 mightThrow = function() { 3489 var returned, then; 3490 3491 // Support: Promises/A+ section 2.3.3.3.3 3492 // https://promisesaplus.com/#point-59 3493 // Ignore double-resolution attempts 3494 if ( depth < maxDepth ) { 3495 return; 3496 } 3497 3498 returned = handler.apply( that, args ); 3499 3500 // Support: Promises/A+ section 2.3.1 3501 // https://promisesaplus.com/#point-48 3502 if ( returned === deferred.promise() ) { 3503 throw new TypeError( "Thenable self-resolution" ); 3504 } 3505 3506 // Support: Promises/A+ sections 2.3.3.1, 3.5 3507 // https://promisesaplus.com/#point-54 3508 // https://promisesaplus.com/#point-75 3509 // Retrieve `then` only once 3510 then = returned && 3511 3512 // Support: Promises/A+ section 2.3.4 3513 // https://promisesaplus.com/#point-64 3514 // Only check objects and functions for thenability 3515 ( typeof returned === "object" || 3516 typeof returned === "function" ) && 3517 returned.then; 3518 3519 // Handle a returned thenable 3520 if ( isFunction( then ) ) { 3521 3522 // Special processors (notify) just wait for resolution 3523 if ( special ) { 3524 then.call( 3525 returned, 3526 resolve( maxDepth, deferred, Identity, special ), 3527 resolve( maxDepth, deferred, Thrower, special ) 3528 ); 3529 3530 // Normal processors (resolve) also hook into progress 3531 } else { 3532 3533 // ...and disregard older resolution values 3534 maxDepth++; 3535 3536 then.call( 3537 returned, 3538 resolve( maxDepth, deferred, Identity, special ), 3539 resolve( maxDepth, deferred, Thrower, special ), 3540 resolve( maxDepth, deferred, Identity, 3541 deferred.notifyWith ) 3542 ); 3543 } 3544 3545 // Handle all other returned values 3546 } else { 3547 3548 // Only substitute handlers pass on context 3549 // and multiple values (non-spec behavior) 3550 if ( handler !== Identity ) { 3551 that = undefined; 3552 args = [ returned ]; 3553 } 3554 3555 // Process the value(s) 3556 // Default process is resolve 3557 ( special || deferred.resolveWith )( that, args ); 3558 } 3559 }, 3560 3561 // Only normal processors (resolve) catch and reject exceptions 3562 process = special ? 3563 mightThrow : 3564 function() { 3565 try { 3566 mightThrow(); 3567 } catch ( e ) { 3568 3569 if ( jQuery.Deferred.exceptionHook ) { 3570 jQuery.Deferred.exceptionHook( e, 3571 process.error ); 3572 } 3573 3574 // Support: Promises/A+ section 2.3.3.3.4.1 3575 // https://promisesaplus.com/#point-61 3576 // Ignore post-resolution exceptions 3577 if ( depth + 1 >= maxDepth ) { 3578 3579 // Only substitute handlers pass on context 3580 // and multiple values (non-spec behavior) 3581 if ( handler !== Thrower ) { 3582 that = undefined; 3583 args = [ e ]; 3584 } 3585 3586 deferred.rejectWith( that, args ); 3587 } 3588 } 3589 }; 3590 3591 // Support: Promises/A+ section 2.3.3.3.1 3592 // https://promisesaplus.com/#point-57 3593 // Re-resolve promises immediately to dodge false rejection from 3594 // subsequent errors 3595 if ( depth ) { 3596 process(); 3597 } else { 3598 3599 // Call an optional hook to record the error, in case of exception 3600 // since it's otherwise lost when execution goes async 3601 if ( jQuery.Deferred.getErrorHook ) { 3602 process.error = jQuery.Deferred.getErrorHook(); 3603 3604 // The deprecated alias of the above. While the name suggests 3605 // returning the stack, not an error instance, jQuery just passes 3606 // it directly to `console.warn` so both will work; an instance 3607 // just better cooperates with source maps. 3608 } else if ( jQuery.Deferred.getStackHook ) { 3609 process.error = jQuery.Deferred.getStackHook(); 3610 } 3611 window.setTimeout( process ); 3612 } 3613 }; 3614 } 3615 3616 return jQuery.Deferred( function( newDefer ) { 3617 3618 // progress_handlers.add( ... ) 3619 tuples[ 0 ][ 3 ].add( 3620 resolve( 3621 0, 3622 newDefer, 3623 isFunction( onProgress ) ? 3624 onProgress : 3625 Identity, 3626 newDefer.notifyWith 3627 ) 3628 ); 3629 3630 // fulfilled_handlers.add( ... ) 3631 tuples[ 1 ][ 3 ].add( 3632 resolve( 3633 0, 3634 newDefer, 3635 isFunction( onFulfilled ) ? 3636 onFulfilled : 3637 Identity 3638 ) 3639 ); 3640 3641 // rejected_handlers.add( ... ) 3642 tuples[ 2 ][ 3 ].add( 3643 resolve( 3644 0, 3645 newDefer, 3646 isFunction( onRejected ) ? 3647 onRejected : 3648 Thrower 3649 ) 3650 ); 3651 } ).promise(); 3652 }, 3653 3654 // Get a promise for this deferred 3655 // If obj is provided, the promise aspect is added to the object 3656 promise: function( obj ) { 3657 return obj != null ? jQuery.extend( obj, promise ) : promise; 3658 } 3659 }, 3660 deferred = {}; 3661 3662 // Add list-specific methods 3663 jQuery.each( tuples, function( i, tuple ) { 3664 var list = tuple[ 2 ], 3665 stateString = tuple[ 5 ]; 3666 3667 // promise.progress = list.add 3668 // promise.done = list.add 3669 // promise.fail = list.add 3670 promise[ tuple[ 1 ] ] = list.add; 3671 3672 // Handle state 3673 if ( stateString ) { 3674 list.add( 3675 function() { 3676 3677 // state = "resolved" (i.e., fulfilled) 3678 // state = "rejected" 3679 state = stateString; 3680 }, 3681 3682 // rejected_callbacks.disable 3683 // fulfilled_callbacks.disable 3684 tuples[ 3 - i ][ 2 ].disable, 3685 3686 // rejected_handlers.disable 3687 // fulfilled_handlers.disable 3688 tuples[ 3 - i ][ 3 ].disable, 3689 3690 // progress_callbacks.lock 3691 tuples[ 0 ][ 2 ].lock, 3692 3693 // progress_handlers.lock 3694 tuples[ 0 ][ 3 ].lock 3695 ); 3696 } 3697 3698 // progress_handlers.fire 3699 // fulfilled_handlers.fire 3700 // rejected_handlers.fire 3701 list.add( tuple[ 3 ].fire ); 3702 3703 // deferred.notify = function() { deferred.notifyWith(...) } 3704 // deferred.resolve = function() { deferred.resolveWith(...) } 3705 // deferred.reject = function() { deferred.rejectWith(...) } 3706 deferred[ tuple[ 0 ] ] = function() { 3707 deferred[ tuple[ 0 ] + "With" ]( this === deferred ? undefined : this, arguments ); 3708 return this; 3709 }; 3710 3711 // deferred.notifyWith = list.fireWith 3712 // deferred.resolveWith = list.fireWith 3713 // deferred.rejectWith = list.fireWith 3714 deferred[ tuple[ 0 ] + "With" ] = list.fireWith; 3715 } ); 3716 3717 // Make the deferred a promise 3718 promise.promise( deferred ); 3719 3720 // Call given func if any 3721 if ( func ) { 3722 func.call( deferred, deferred ); 3723 } 3724 3725 // All done! 3726 return deferred; 3727 }, 3728 3729 // Deferred helper 3730 when: function( singleValue ) { 3731 var 3732 3733 // count of uncompleted subordinates 3734 remaining = arguments.length, 3735 3736 // count of unprocessed arguments 3737 i = remaining, 3738 3739 // subordinate fulfillment data 3740 resolveContexts = Array( i ), 3741 resolveValues = slice.call( arguments ), 3742 3743 // the primary Deferred 3744 primary = jQuery.Deferred(), 3745 3746 // subordinate callback factory 3747 updateFunc = function( i ) { 3748 return function( value ) { 3749 resolveContexts[ i ] = this; 3750 resolveValues[ i ] = arguments.length > 1 ? slice.call( arguments ) : value; 3751 if ( !( --remaining ) ) { 3752 primary.resolveWith( resolveContexts, resolveValues ); 3753 } 3754 }; 3755 }; 3756 3757 // Single- and empty arguments are adopted like Promise.resolve 3758 if ( remaining <= 1 ) { 3759 adoptValue( singleValue, primary.done( updateFunc( i ) ).resolve, primary.reject, 3760 !remaining ); 3761 3762 // Use .then() to unwrap secondary thenables (cf. gh-3000) 3763 if ( primary.state() === "pending" || 3764 isFunction( resolveValues[ i ] && resolveValues[ i ].then ) ) { 3765 3766 return primary.then(); 3767 } 3768 } 3769 3770 // Multiple arguments are aggregated like Promise.all array elements 3771 while ( i-- ) { 3772 adoptValue( resolveValues[ i ], updateFunc( i ), primary.reject ); 3773 } 3774 3775 return primary.promise(); 3776 } 3777} ); 3778 3779 3780// These usually indicate a programmer mistake during development, 3781// warn about them ASAP rather than swallowing them by default. 3782var rerrorNames = /^(Eval|Internal|Range|Reference|Syntax|Type|URI)Error$/; 3783 3784// If `jQuery.Deferred.getErrorHook` is defined, `asyncError` is an error 3785// captured before the async barrier to get the original error cause 3786// which may otherwise be hidden. 3787jQuery.Deferred.exceptionHook = function( error, asyncError ) { 3788 3789 // Support: IE 8 - 9 only 3790 // Console exists when dev tools are open, which can happen at any time 3791 if ( window.console && window.console.warn && error && rerrorNames.test( error.name ) ) { 3792 window.console.warn( "jQuery.Deferred exception: " + error.message, 3793 error.stack, asyncError ); 3794 } 3795}; 3796 3797 3798 3799 3800jQuery.readyException = function( error ) { 3801 window.setTimeout( function() { 3802 throw error; 3803 } ); 3804}; 3805 3806 3807 3808 3809// The deferred used on DOM ready 3810var readyList = jQuery.Deferred(); 3811 3812jQuery.fn.ready = function( fn ) { 3813 3814 readyList 3815 .then( fn ) 3816 3817 // Wrap jQuery.readyException in a function so that the lookup 3818 // happens at the time of error handling instead of callback 3819 // registration. 3820 .catch( function( error ) { 3821 jQuery.readyException( error ); 3822 } ); 3823 3824 return this; 3825}; 3826 3827jQuery.extend( { 3828 3829 // Is the DOM ready to be used? Set to true once it occurs. 3830 isReady: false, 3831 3832 // A counter to track how many items to wait for before 3833 // the ready event fires. See trac-6781 3834 readyWait: 1, 3835 3836 // Handle when the DOM is ready 3837 ready: function( wait ) { 3838 3839 // Abort if there are pending holds or we're already ready 3840 if ( wait === true ? --jQuery.readyWait : jQuery.isReady ) { 3841 return; 3842 } 3843 3844 // Remember that the DOM is ready 3845 jQuery.isReady = true; 3846 3847 // If a normal DOM Ready event fired, decrement, and wait if need be 3848 if ( wait !== true && --jQuery.readyWait > 0 ) { 3849 return; 3850 } 3851 3852 // If there are functions bound, to execute 3853 readyList.resolveWith( document, [ jQuery ] ); 3854 } 3855} ); 3856 3857jQuery.ready.then = readyList.then; 3858 3859// The ready event handler and self cleanup method 3860function completed() { 3861 document.removeEventListener( "DOMContentLoaded", completed ); 3862 window.removeEventListener( "load", completed ); 3863 jQuery.ready(); 3864} 3865 3866// Catch cases where $(document).ready() is called 3867// after the browser event has already occurred. 3868// Support: IE <=9 - 10 only 3869// Older IE sometimes signals "interactive" too soon 3870if ( document.readyState === "complete" || 3871 ( document.readyState !== "loading" && !document.documentElement.doScroll ) ) { 3872 3873 // Handle it asynchronously to allow scripts the opportunity to delay ready 3874 window.setTimeout( jQuery.ready ); 3875 3876} else { 3877 3878 // Use the handy event callback 3879 document.addEventListener( "DOMContentLoaded", completed ); 3880 3881 // A fallback to window.onload, that will always work 3882 window.addEventListener( "load", completed ); 3883} 3884 3885 3886 3887 3888// Multifunctional method to get and set values of a collection 3889// The value/s can optionally be executed if it's a function 3890var access = function( elems, fn, key, value, chainable, emptyGet, raw ) { 3891 var i = 0, 3892 len = elems.length, 3893 bulk = key == null; 3894 3895 // Sets many values 3896 if ( toType( key ) === "object" ) { 3897 chainable = true; 3898 for ( i in key ) { 3899 access( elems, fn, i, key[ i ], true, emptyGet, raw ); 3900 } 3901 3902 // Sets one value 3903 } else if ( value !== undefined ) { 3904 chainable = true; 3905 3906 if ( !isFunction( value ) ) { 3907 raw = true; 3908 } 3909 3910 if ( bulk ) { 3911 3912 // Bulk operations run against the entire set 3913 if ( raw ) { 3914 fn.call( elems, value ); 3915 fn = null; 3916 3917 // ...except when executing function values 3918 } else { 3919 bulk = fn; 3920 fn = function( elem, _key, value ) { 3921 return bulk.call( jQuery( elem ), value ); 3922 }; 3923 } 3924 } 3925 3926 if ( fn ) { 3927 for ( ; i < len; i++ ) { 3928 fn( 3929 elems[ i ], key, raw ? 3930 value : 3931 value.call( elems[ i ], i, fn( elems[ i ], key ) ) 3932 ); 3933 } 3934 } 3935 } 3936 3937 if ( chainable ) { 3938 return elems; 3939 } 3940 3941 // Gets 3942 if ( bulk ) { 3943 return fn.call( elems ); 3944 } 3945 3946 return len ? fn( elems[ 0 ], key ) : emptyGet; 3947}; 3948 3949 3950// Matches dashed string for camelizing 3951var rmsPrefix = /^-ms-/, 3952 rdashAlpha = /-([a-z])/g; 3953 3954// Used by camelCase as callback to replace() 3955function fcamelCase( _all, letter ) { 3956 return letter.toUpperCase(); 3957} 3958 3959// Convert dashed to camelCase; used by the css and data modules 3960// Support: IE <=9 - 11, Edge 12 - 15 3961// Microsoft forgot to hump their vendor prefix (trac-9572) 3962function camelCase( string ) { 3963 return string.replace( rmsPrefix, "ms-" ).replace( rdashAlpha, fcamelCase ); 3964} 3965var acceptData = function( owner ) { 3966 3967 // Accepts only: 3968 // - Node 3969 // - Node.ELEMENT_NODE 3970 // - Node.DOCUMENT_NODE 3971 // - Object 3972 // - Any 3973 return owner.nodeType === 1 || owner.nodeType === 9 || !( +owner.nodeType ); 3974}; 3975 3976 3977 3978 3979function Data() { 3980 this.expando = jQuery.expando + Data.uid++; 3981} 3982 3983Data.uid = 1; 3984 3985Data.prototype = { 3986 3987 cache: function( owner ) { 3988 3989 // Check if the owner object already has a cache 3990 var value = owner[ this.expando ]; 3991 3992 // If not, create one 3993 if ( !value ) { 3994 value = {}; 3995 3996 // We can accept data for non-element nodes in modern browsers, 3997 // but we should not, see trac-8335. 3998 // Always return an empty object. 3999 if ( acceptData( owner ) ) { 4000 4001 // If it is a node unlikely to be stringify-ed or looped over 4002 // use plain assignment 4003 if ( owner.nodeType ) { 4004 owner[ this.expando ] = value; 4005 4006 // Otherwise secure it in a non-enumerable property 4007 // configurable must be true to allow the property to be 4008 // deleted when data is removed 4009 } else { 4010 Object.defineProperty( owner, this.expando, { 4011 value: value, 4012 configurable: true 4013 } ); 4014 } 4015 } 4016 } 4017 4018 return value; 4019 }, 4020 set: function( owner, data, value ) { 4021 var prop, 4022 cache = this.cache( owner ); 4023 4024 // Handle: [ owner, key, value ] args 4025 // Always use camelCase key (gh-2257) 4026 if ( typeof data === "string" ) { 4027 cache[ camelCase( data ) ] = value; 4028 4029 // Handle: [ owner, { properties } ] args 4030 } else { 4031 4032 // Copy the properties one-by-one to the cache object 4033 for ( prop in data ) { 4034 cache[ camelCase( prop ) ] = data[ prop ]; 4035 } 4036 } 4037 return cache; 4038 }, 4039 get: function( owner, key ) { 4040 return key === undefined ? 4041 this.cache( owner ) : 4042 4043 // Always use camelCase key (gh-2257) 4044 owner[ this.expando ] && owner[ this.expando ][ camelCase( key ) ]; 4045 }, 4046 access: function( owner, key, value ) { 4047 4048 // In cases where either: 4049 // 4050 // 1. No key was specified 4051 // 2. A string key was specified, but no value provided 4052 // 4053 // Take the "read" path and allow the get method to determine 4054 // which value to return, respectively either: 4055 // 4056 // 1. The entire cache object 4057 // 2. The data stored at the key 4058 // 4059 if ( key === undefined || 4060 ( ( key && typeof key === "string" ) && value === undefined ) ) { 4061 4062 return this.get( owner, key ); 4063 } 4064 4065 // When the key is not a string, or both a key and value 4066 // are specified, set or extend (existing objects) with either: 4067 // 4068 // 1. An object of properties 4069 // 2. A key and value 4070 // 4071 this.set( owner, key, value ); 4072 4073 // Since the "set" path can have two possible entry points 4074 // return the expected data based on which path was taken[*] 4075 return value !== undefined ? value : key; 4076 }, 4077 remove: function( owner, key ) { 4078 var i, 4079 cache = owner[ this.expando ]; 4080 4081 if ( cache === undefined ) { 4082 return; 4083 } 4084 4085 if ( key !== undefined ) { 4086 4087 // Support array or space separated string of keys 4088 if ( Array.isArray( key ) ) { 4089 4090 // If key is an array of keys... 4091 // We always set camelCase keys, so remove that. 4092 key = key.map( camelCase ); 4093 } else { 4094 key = camelCase( key ); 4095 4096 // If a key with the spaces exists, use it. 4097 // Otherwise, create an array by matching non-whitespace 4098 key = key in cache ? 4099 [ key ] : 4100 ( key.match( rnothtmlwhite ) || [] ); 4101 } 4102 4103 i = key.length; 4104 4105 while ( i-- ) { 4106 delete cache[ key[ i ] ]; 4107 } 4108 } 4109 4110 // Remove the expando if there's no more data 4111 if ( key === undefined || jQuery.isEmptyObject( cache ) ) { 4112 4113 // Support: Chrome <=35 - 45 4114 // Webkit & Blink performance suffers when deleting properties 4115 // from DOM nodes, so set to undefined instead 4116 // https://bugs.chromium.org/p/chromium/issues/detail?id=378607 (bug restricted) 4117 if ( owner.nodeType ) { 4118 owner[ this.expando ] = undefined; 4119 } else { 4120 delete owner[ this.expando ]; 4121 } 4122 } 4123 }, 4124 hasData: function( owner ) { 4125 var cache = owner[ this.expando ]; 4126 return cache !== undefined && !jQuery.isEmptyObject( cache ); 4127 } 4128}; 4129var dataPriv = new Data(); 4130 4131var dataUser = new Data(); 4132 4133 4134 4135// Implementation Summary 4136// 4137// 1. Enforce API surface and semantic compatibility with 1.9.x branch 4138// 2. Improve the module's maintainability by reducing the storage 4139// paths to a single mechanism. 4140// 3. Use the same single mechanism to support "private" and "user" data. 4141// 4. _Never_ expose "private" data to user code (TODO: Drop _data, _removeData) 4142// 5. Avoid exposing implementation details on user objects (eg. expando properties) 4143// 6. Provide a clear path for implementation upgrade to WeakMap in 2014 4144 4145var rbrace = /^(?:\{[\w\W]*\}|\[[\w\W]*\])$/, 4146 rmultiDash = /[A-Z]/g; 4147 4148function getData( data ) { 4149 if ( data === "true" ) { 4150 return true; 4151 } 4152 4153 if ( data === "false" ) { 4154 return false; 4155 } 4156 4157 if ( data === "null" ) { 4158 return null; 4159 } 4160 4161 // Only convert to a number if it doesn't change the string 4162 if ( data === +data + "" ) { 4163 return +data; 4164 } 4165 4166 if ( rbrace.test( data ) ) { 4167 return JSON.parse( data ); 4168 } 4169 4170 return data; 4171} 4172 4173function dataAttr( elem, key, data ) { 4174 var name; 4175 4176 // If nothing was found internally, try to fetch any 4177 // data from the HTML5 data-* attribute 4178 if ( data === undefined && elem.nodeType === 1 ) { 4179 name = "data-" + key.replace( rmultiDash, "-$&" ).toLowerCase(); 4180 data = elem.getAttribute( name ); 4181 4182 if ( typeof data === "string" ) { 4183 try { 4184 data = getData( data ); 4185 } catch ( e ) {} 4186 4187 // Make sure we set the data so it isn't changed later 4188 dataUser.set( elem, key, data ); 4189 } else { 4190 data = undefined; 4191 } 4192 } 4193 return data; 4194} 4195 4196jQuery.extend( { 4197 hasData: function( elem ) { 4198 return dataUser.hasData( elem ) || dataPriv.hasData( elem ); 4199 }, 4200 4201 data: function( elem, name, data ) { 4202 return dataUser.access( elem, name, data ); 4203 }, 4204 4205 removeData: function( elem, name ) { 4206 dataUser.remove( elem, name ); 4207 }, 4208 4209 // TODO: Now that all calls to _data and _removeData have been replaced 4210 // with direct calls to dataPriv methods, these can be deprecated. 4211 _data: function( elem, name, data ) { 4212 return dataPriv.access( elem, name, data ); 4213 }, 4214 4215 _removeData: function( elem, name ) { 4216 dataPriv.remove( elem, name ); 4217 } 4218} ); 4219 4220jQuery.fn.extend( { 4221 data: function( key, value ) { 4222 var i, name, data, 4223 elem = this[ 0 ], 4224 attrs = elem && elem.attributes; 4225 4226 // Gets all values 4227 if ( key === undefined ) { 4228 if ( this.length ) { 4229 data = dataUser.get( elem ); 4230 4231 if ( elem.nodeType === 1 && !dataPriv.get( elem, "hasDataAttrs" ) ) { 4232 i = attrs.length; 4233 while ( i-- ) { 4234 4235 // Support: IE 11 only 4236 // The attrs elements can be null (trac-14894) 4237 if ( attrs[ i ] ) { 4238 name = attrs[ i ].name; 4239 if ( name.indexOf( "data-" ) === 0 ) { 4240 name = camelCase( name.slice( 5 ) ); 4241 dataAttr( elem, name, data[ name ] ); 4242 } 4243 } 4244 } 4245 dataPriv.set( elem, "hasDataAttrs", true ); 4246 } 4247 } 4248 4249 return data; 4250 } 4251 4252 // Sets multiple values 4253 if ( typeof key === "object" ) { 4254 return this.each( function() { 4255 dataUser.set( this, key ); 4256 } ); 4257 } 4258 4259 return access( this, function( value ) { 4260 var data; 4261 4262 // The calling jQuery object (element matches) is not empty 4263 // (and therefore has an element appears at this[ 0 ]) and the 4264 // `value` parameter was not undefined. An empty jQuery object 4265 // will result in `undefined` for elem = this[ 0 ] which will 4266 // throw an exception if an attempt to read a data cache is made. 4267 if ( elem && value === undefined ) { 4268 4269 // Attempt to get data from the cache 4270 // The key will always be camelCased in Data 4271 data = dataUser.get( elem, key ); 4272 if ( data !== undefined ) { 4273 return data; 4274 } 4275 4276 // Attempt to "discover" the data in 4277 // HTML5 custom data-* attrs 4278 data = dataAttr( elem, key ); 4279 if ( data !== undefined ) { 4280 return data; 4281 } 4282 4283 // We tried really hard, but the data doesn't exist. 4284 return; 4285 } 4286 4287 // Set the data... 4288 this.each( function() { 4289 4290 // We always store the camelCased key 4291 dataUser.set( this, key, value ); 4292 } ); 4293 }, null, value, arguments.length > 1, null, true ); 4294 }, 4295 4296 removeData: function( key ) { 4297 return this.each( function() { 4298 dataUser.remove( this, key ); 4299 } ); 4300 } 4301} ); 4302 4303 4304jQuery.extend( { 4305 queue: function( elem, type, data ) { 4306 var queue; 4307 4308 if ( elem ) { 4309 type = ( type || "fx" ) + "queue"; 4310 queue = dataPriv.get( elem, type ); 4311 4312 // Speed up dequeue by getting out quickly if this is just a lookup 4313 if ( data ) { 4314 if ( !queue || Array.isArray( data ) ) { 4315 queue = dataPriv.access( elem, type, jQuery.makeArray( data ) ); 4316 } else { 4317 queue.push( data ); 4318 } 4319 } 4320 return queue || []; 4321 } 4322 }, 4323 4324 dequeue: function( elem, type ) { 4325 type = type || "fx"; 4326 4327 var queue = jQuery.queue( elem, type ), 4328 startLength = queue.length, 4329 fn = queue.shift(), 4330 hooks = jQuery._queueHooks( elem, type ), 4331 next = function() { 4332 jQuery.dequeue( elem, type ); 4333 }; 4334 4335 // If the fx queue is dequeued, always remove the progress sentinel 4336 if ( fn === "inprogress" ) { 4337 fn = queue.shift(); 4338 startLength--; 4339 } 4340 4341 if ( fn ) { 4342 4343 // Add a progress sentinel to prevent the fx queue from being 4344 // automatically dequeued 4345 if ( type === "fx" ) { 4346 queue.unshift( "inprogress" ); 4347 } 4348 4349 // Clear up the last queue stop function 4350 delete hooks.stop; 4351 fn.call( elem, next, hooks ); 4352 } 4353 4354 if ( !startLength && hooks ) { 4355 hooks.empty.fire(); 4356 } 4357 }, 4358 4359 // Not public - generate a queueHooks object, or return the current one 4360 _queueHooks: function( elem, type ) { 4361 var key = type + "queueHooks"; 4362 return dataPriv.get( elem, key ) || dataPriv.access( elem, key, { 4363 empty: jQuery.Callbacks( "once memory" ).add( function() { 4364 dataPriv.remove( elem, [ type + "queue", key ] ); 4365 } ) 4366 } ); 4367 } 4368} ); 4369 4370jQuery.fn.extend( { 4371 queue: function( type, data ) { 4372 var setter = 2; 4373 4374 if ( typeof type !== "string" ) { 4375 data = type; 4376 type = "fx"; 4377 setter--; 4378 } 4379 4380 if ( arguments.length < setter ) { 4381 return jQuery.queue( this[ 0 ], type ); 4382 } 4383 4384 return data === undefined ? 4385 this : 4386 this.each( function() { 4387 var queue = jQuery.queue( this, type, data ); 4388 4389 // Ensure a hooks for this queue 4390 jQuery._queueHooks( this, type ); 4391 4392 if ( type === "fx" && queue[ 0 ] !== "inprogress" ) { 4393 jQuery.dequeue( this, type ); 4394 } 4395 } ); 4396 }, 4397 dequeue: function( type ) { 4398 return this.each( function() { 4399 jQuery.dequeue( this, type ); 4400 } ); 4401 }, 4402 clearQueue: function( type ) { 4403 return this.queue( type || "fx", [] ); 4404 }, 4405 4406 // Get a promise resolved when queues of a certain type 4407 // are emptied (fx is the type by default) 4408 promise: function( type, obj ) { 4409 var tmp, 4410 count = 1, 4411 defer = jQuery.Deferred(), 4412 elements = this, 4413 i = this.length, 4414 resolve = function() { 4415 if ( !( --count ) ) { 4416 defer.resolveWith( elements, [ elements ] ); 4417 } 4418 }; 4419 4420 if ( typeof type !== "string" ) { 4421 obj = type; 4422 type = undefined; 4423 } 4424 type = type || "fx"; 4425 4426 while ( i-- ) { 4427 tmp = dataPriv.get( elements[ i ], type + "queueHooks" ); 4428 if ( tmp && tmp.empty ) { 4429 count++; 4430 tmp.empty.add( resolve ); 4431 } 4432 } 4433 resolve(); 4434 return defer.promise( obj ); 4435 } 4436} ); 4437var pnum = ( /[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/ ).source; 4438 4439var rcssNum = new RegExp( "^(?:([+-])=|)(" + pnum + ")([a-z%]*)$", "i" ); 4440 4441 4442var cssExpand = [ "Top", "Right", "Bottom", "Left" ]; 4443 4444var documentElement = document.documentElement; 4445 4446 4447 4448 var isAttached = function( elem ) { 4449 return jQuery.contains( elem.ownerDocument, elem ); 4450 }, 4451 composed = { composed: true }; 4452 4453 // Support: IE 9 - 11+, Edge 12 - 18+, iOS 10.0 - 10.2 only 4454 // Check attachment across shadow DOM boundaries when possible (gh-3504) 4455 // Support: iOS 10.0-10.2 only 4456 // Early iOS 10 versions support `attachShadow` but not `getRootNode`, 4457 // leading to errors. We need to check for `getRootNode`. 4458 if ( documentElement.getRootNode ) { 4459 isAttached = function( elem ) { 4460 return jQuery.contains( elem.ownerDocument, elem ) || 4461 elem.getRootNode( composed ) === elem.ownerDocument; 4462 }; 4463 } 4464var isHiddenWithinTree = function( elem, el ) { 4465 4466 // isHiddenWithinTree might be called from jQuery#filter function; 4467 // in that case, element will be second argument 4468 elem = el || elem; 4469 4470 // Inline style trumps all 4471 return elem.style.display === "none" || 4472 elem.style.display === "" && 4473 4474 // Otherwise, check computed style 4475 // Support: Firefox <=43 - 45 4476 // Disconnected elements can have computed display: none, so first confirm that elem is 4477 // in the document. 4478 isAttached( elem ) && 4479 4480 jQuery.css( elem, "display" ) === "none"; 4481 }; 4482 4483 4484 4485function adjustCSS( elem, prop, valueParts, tween ) { 4486 var adjusted, scale, 4487 maxIterations = 20, 4488 currentValue = tween ? 4489 function() { 4490 return tween.cur(); 4491 } : 4492 function() { 4493 return jQuery.css( elem, prop, "" ); 4494 }, 4495 initial = currentValue(), 4496 unit = valueParts && valueParts[ 3 ] || ( jQuery.cssNumber[ prop ] ? "" : "px" ), 4497 4498 // Starting value computation is required for potential unit mismatches 4499 initialInUnit = elem.nodeType && 4500 ( jQuery.cssNumber[ prop ] || unit !== "px" && +initial ) && 4501 rcssNum.exec( jQuery.css( elem, prop ) ); 4502 4503 if ( initialInUnit && initialInUnit[ 3 ] !== unit ) { 4504 4505 // Support: Firefox <=54 4506 // Halve the iteration target value to prevent interference from CSS upper bounds (gh-2144) 4507 initial = initial / 2; 4508 4509 // Trust units reported by jQuery.css 4510 unit = unit || initialInUnit[ 3 ]; 4511 4512 // Iteratively approximate from a nonzero starting point 4513 initialInUnit = +initial || 1; 4514 4515 while ( maxIterations-- ) { 4516 4517 // Evaluate and update our best guess (doubling guesses that zero out). 4518 // Finish if the scale equals or crosses 1 (making the old*new product non-positive). 4519 jQuery.style( elem, prop, initialInUnit + unit ); 4520 if ( ( 1 - scale ) * ( 1 - ( scale = currentValue() / initial || 0.5 ) ) <= 0 ) { 4521 maxIterations = 0; 4522 } 4523 initialInUnit = initialInUnit / scale; 4524 4525 } 4526 4527 initialInUnit = initialInUnit * 2; 4528 jQuery.style( elem, prop, initialInUnit + unit ); 4529 4530 // Make sure we update the tween properties later on 4531 valueParts = valueParts || []; 4532 } 4533 4534 if ( valueParts ) { 4535 initialInUnit = +initialInUnit || +initial || 0; 4536 4537 // Apply relative offset (+=/-=) if specified 4538 adjusted = valueParts[ 1 ] ? 4539 initialInUnit + ( valueParts[ 1 ] + 1 ) * valueParts[ 2 ] : 4540 +valueParts[ 2 ]; 4541 if ( tween ) { 4542 tween.unit = unit; 4543 tween.start = initialInUnit; 4544 tween.end = adjusted; 4545 } 4546 } 4547 return adjusted; 4548} 4549 4550 4551var defaultDisplayMap = {}; 4552 4553function getDefaultDisplay( elem ) { 4554 var temp, 4555 doc = elem.ownerDocument, 4556 nodeName = elem.nodeName, 4557 display = defaultDisplayMap[ nodeName ]; 4558 4559 if ( display ) { 4560 return display; 4561 } 4562 4563 temp = doc.body.appendChild( doc.createElement( nodeName ) ); 4564 display = jQuery.css( temp, "display" ); 4565 4566 temp.parentNode.removeChild( temp ); 4567 4568 if ( display === "none" ) { 4569 display = "block"; 4570 } 4571 defaultDisplayMap[ nodeName ] = display; 4572 4573 return display; 4574} 4575 4576function showHide( elements, show ) { 4577 var display, elem, 4578 values = [], 4579 index = 0, 4580 length = elements.length; 4581 4582 // Determine new display value for elements that need to change 4583 for ( ; index < length; index++ ) { 4584 elem = elements[ index ]; 4585 if ( !elem.style ) { 4586 continue; 4587 } 4588 4589 display = elem.style.display; 4590 if ( show ) { 4591 4592 // Since we force visibility upon cascade-hidden elements, an immediate (and slow) 4593 // check is required in this first loop unless we have a nonempty display value (either 4594 // inline or about-to-be-restored) 4595 if ( display === "none" ) { 4596 values[ index ] = dataPriv.get( elem, "display" ) || null; 4597 if ( !values[ index ] ) { 4598 elem.style.display = ""; 4599 } 4600 } 4601 if ( elem.style.display === "" && isHiddenWithinTree( elem ) ) { 4602 values[ index ] = getDefaultDisplay( elem ); 4603 } 4604 } else { 4605 if ( display !== "none" ) { 4606 values[ index ] = "none"; 4607 4608 // Remember what we're overwriting 4609 dataPriv.set( elem, "display", display ); 4610 } 4611 } 4612 } 4613 4614 // Set the display of the elements in a second loop to avoid constant reflow 4615 for ( index = 0; index < length; index++ ) { 4616 if ( values[ index ] != null ) { 4617 elements[ index ].style.display = values[ index ]; 4618 } 4619 } 4620 4621 return elements; 4622} 4623 4624jQuery.fn.extend( { 4625 show: function() { 4626 return showHide( this, true ); 4627 }, 4628 hide: function() { 4629 return showHide( this ); 4630 }, 4631 toggle: function( state ) { 4632 if ( typeof state === "boolean" ) { 4633 return state ? this.show() : this.hide(); 4634 } 4635 4636 return this.each( function() { 4637 if ( isHiddenWithinTree( this ) ) { 4638 jQuery( this ).show(); 4639 } else { 4640 jQuery( this ).hide(); 4641 } 4642 } ); 4643 } 4644} ); 4645var rcheckableType = ( /^(?:checkbox|radio)$/i ); 4646 4647var rtagName = ( /<([a-z][^\/\0>\x20\t\r\n\f]*)/i ); 4648 4649var rscriptType = ( /^$|^module$|\/(?:java|ecma)script/i ); 4650 4651 4652 4653( function() { 4654 var fragment = document.createDocumentFragment(), 4655 div = fragment.appendChild( document.createElement( "div" ) ), 4656 input = document.createElement( "input" ); 4657 4658 // Support: Android 4.0 - 4.3 only 4659 // Check state lost if the name is set (trac-11217) 4660 // Support: Windows Web Apps (WWA) 4661 // `name` and `type` must use .setAttribute for WWA (trac-14901) 4662 input.setAttribute( "type", "radio" ); 4663 input.setAttribute( "checked", "checked" ); 4664 input.setAttribute( "name", "t" ); 4665 4666 div.appendChild( input ); 4667 4668 // Support: Android <=4.1 only 4669 // Older WebKit doesn't clone checked state correctly in fragments 4670 support.checkClone = div.cloneNode( true ).cloneNode( true ).lastChild.checked; 4671 4672 // Support: IE <=11 only 4673 // Make sure textarea (and checkbox) defaultValue is properly cloned 4674 div.innerHTML = "<textarea>x</textarea>"; 4675 support.noCloneChecked = !!div.cloneNode( true ).lastChild.defaultValue; 4676 4677 // Support: IE <=9 only 4678 // IE <=9 replaces <option> tags with their contents when inserted outside of 4679 // the select element. 4680 div.innerHTML = "<option></option>"; 4681 support.option = !!div.lastChild; 4682} )(); 4683 4684 4685// We have to close these tags to support XHTML (trac-13200) 4686var wrapMap = { 4687 4688 // XHTML parsers do not magically insert elements in the 4689 // same way that tag soup parsers do. So we cannot shorten 4690 // this by omitting <tbody> or other required elements. 4691 thead: [ 1, "<table>", "</table>" ], 4692 col: [ 2, "<table><colgroup>", "</colgroup></table>" ], 4693 tr: [ 2, "<table><tbody>", "</tbody></table>" ], 4694 td: [ 3, "<table><tbody><tr>", "</tr></tbody></table>" ], 4695 4696 _default: [ 0, "", "" ] 4697}; 4698 4699wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead; 4700wrapMap.th = wrapMap.td; 4701 4702// Support: IE <=9 only 4703if ( !support.option ) { 4704 wrapMap.optgroup = wrapMap.option = [ 1, "<select multiple='multiple'>", "</select>" ]; 4705} 4706 4707 4708function getAll( context, tag ) { 4709 4710 // Support: IE <=9 - 11 only 4711 // Use typeof to avoid zero-argument method invocation on host objects (trac-15151) 4712 var ret; 4713 4714 if ( typeof context.getElementsByTagName !== "undefined" ) { 4715 ret = context.getElementsByTagName( tag || "*" ); 4716 4717 } else if ( typeof context.querySelectorAll !== "undefined" ) { 4718 ret = context.querySelectorAll( tag || "*" ); 4719 4720 } else { 4721 ret = []; 4722 } 4723 4724 if ( tag === undefined || tag && nodeName( context, tag ) ) { 4725 return jQuery.merge( [ context ], ret ); 4726 } 4727 4728 return ret; 4729} 4730 4731 4732// Mark scripts as having already been evaluated 4733function setGlobalEval( elems, refElements ) { 4734 var i = 0, 4735 l = elems.length; 4736 4737 for ( ; i < l; i++ ) { 4738 dataPriv.set( 4739 elems[ i ], 4740 "globalEval", 4741 !refElements || dataPriv.get( refElements[ i ], "globalEval" ) 4742 ); 4743 } 4744} 4745 4746 4747var rhtml = /<|&#?\w+;/; 4748 4749function buildFragment( elems, context, scripts, selection, ignored ) { 4750 var elem, tmp, tag, wrap, attached, j, 4751 fragment = context.createDocumentFragment(), 4752 nodes = [], 4753 i = 0, 4754 l = elems.length; 4755 4756 for ( ; i < l; i++ ) { 4757 elem = elems[ i ]; 4758 4759 if ( elem || elem === 0 ) { 4760 4761 // Add nodes directly 4762 if ( toType( elem ) === "object" ) { 4763 4764 // Support: Android <=4.0 only, PhantomJS 1 only 4765 // push.apply(_, arraylike) throws on ancient WebKit 4766 jQuery.merge( nodes, elem.nodeType ? [ elem ] : elem ); 4767 4768 // Convert non-html into a text node 4769 } else if ( !rhtml.test( elem ) ) { 4770 nodes.push( context.createTextNode( elem ) ); 4771 4772 // Convert html into DOM nodes 4773 } else { 4774 tmp = tmp || fragment.appendChild( context.createElement( "div" ) ); 4775 4776 // Deserialize a standard representation 4777 tag = ( rtagName.exec( elem ) || [ "", "" ] )[ 1 ].toLowerCase(); 4778 wrap = wrapMap[ tag ] || wrapMap._default; 4779 tmp.innerHTML = wrap[ 1 ] + jQuery.htmlPrefilter( elem ) + wrap[ 2 ]; 4780 4781 // Descend through wrappers to the right content 4782 j = wrap[ 0 ]; 4783 while ( j-- ) { 4784 tmp = tmp.lastChild; 4785 } 4786 4787 // Support: Android <=4.0 only, PhantomJS 1 only 4788 // push.apply(_, arraylike) throws on ancient WebKit 4789 jQuery.merge( nodes, tmp.childNodes ); 4790 4791 // Remember the top-level container 4792 tmp = fragment.firstChild; 4793 4794 // Ensure the created nodes are orphaned (trac-12392) 4795 tmp.textContent = ""; 4796 } 4797 } 4798 } 4799 4800 // Remove wrapper from fragment 4801 fragment.textContent = ""; 4802 4803 i = 0; 4804 while ( ( elem = nodes[ i++ ] ) ) { 4805 4806 // Skip elements already in the context collection (trac-4087) 4807 if ( selection && jQuery.inArray( elem, selection ) > -1 ) { 4808 if ( ignored ) { 4809 ignored.push( elem ); 4810 } 4811 continue; 4812 } 4813 4814 attached = isAttached( elem ); 4815 4816 // Append to fragment 4817 tmp = getAll( fragment.appendChild( elem ), "script" ); 4818 4819 // Preserve script evaluation history 4820 if ( attached ) { 4821 setGlobalEval( tmp ); 4822 } 4823 4824 // Capture executables 4825 if ( scripts ) { 4826 j = 0; 4827 while ( ( elem = tmp[ j++ ] ) ) { 4828 if ( rscriptType.test( elem.type || "" ) ) { 4829 scripts.push( elem ); 4830 } 4831 } 4832 } 4833 } 4834 4835 return fragment; 4836} 4837 4838 4839var rtypenamespace = /^([^.]*)(?:\.(.+)|)/; 4840 4841function returnTrue() { 4842 return true; 4843} 4844 4845function returnFalse() { 4846 return false; 4847} 4848 4849function on( elem, types, selector, data, fn, one ) { 4850 var origFn, type; 4851 4852 // Types can be a map of types/handlers 4853 if ( typeof types === "object" ) { 4854 4855 // ( types-Object, selector, data ) 4856 if ( typeof selector !== "string" ) { 4857 4858 // ( types-Object, data ) 4859 data = data || selector; 4860 selector = undefined; 4861 } 4862 for ( type in types ) { 4863 on( elem, type, selector, data, types[ type ], one ); 4864 } 4865 return elem; 4866 } 4867 4868 if ( data == null && fn == null ) { 4869 4870 // ( types, fn ) 4871 fn = selector; 4872 data = selector = undefined; 4873 } else if ( fn == null ) { 4874 if ( typeof selector === "string" ) { 4875 4876 // ( types, selector, fn ) 4877 fn = data; 4878 data = undefined; 4879 } else { 4880 4881 // ( types, data, fn ) 4882 fn = data; 4883 data = selector; 4884 selector = undefined; 4885 } 4886 } 4887 if ( fn === false ) { 4888 fn = returnFalse; 4889 } else if ( !fn ) { 4890 return elem; 4891 } 4892 4893 if ( one === 1 ) { 4894 origFn = fn; 4895 fn = function( event ) { 4896 4897 // Can use an empty set, since event contains the info 4898 jQuery().off( event ); 4899 return origFn.apply( this, arguments ); 4900 }; 4901 4902 // Use same guid so caller can remove using origFn 4903 fn.guid = origFn.guid || ( origFn.guid = jQuery.guid++ ); 4904 } 4905 return elem.each( function() { 4906 jQuery.event.add( this, types, fn, data, selector ); 4907 } ); 4908} 4909 4910/* 4911 * Helper functions for managing events -- not part of the public interface. 4912 * Props to Dean Edwards' addEvent library for many of the ideas. 4913 */ 4914jQuery.event = { 4915 4916 global: {}, 4917 4918 add: function( elem, types, handler, data, selector ) { 4919 4920 var handleObjIn, eventHandle, tmp, 4921 events, t, handleObj, 4922 special, handlers, type, namespaces, origType, 4923 elemData = dataPriv.get( elem ); 4924 4925 // Only attach events to objects that accept data 4926 if ( !acceptData( elem ) ) { 4927 return; 4928 } 4929 4930 // Caller can pass in an object of custom data in lieu of the handler 4931 if ( handler.handler ) { 4932 handleObjIn = handler; 4933 handler = handleObjIn.handler; 4934 selector = handleObjIn.selector; 4935 } 4936 4937 // Ensure that invalid selectors throw exceptions at attach time 4938 // Evaluate against documentElement in case elem is a non-element node (e.g., document) 4939 if ( selector ) { 4940 jQuery.find.matchesSelector( documentElement, selector ); 4941 } 4942 4943 // Make sure that the handler has a unique ID, used to find/remove it later 4944 if ( !handler.guid ) { 4945 handler.guid = jQuery.guid++; 4946 } 4947 4948 // Init the element's event structure and main handler, if this is the first 4949 if ( !( events = elemData.events ) ) { 4950 events = elemData.events = Object.create( null ); 4951 } 4952 if ( !( eventHandle = elemData.handle ) ) { 4953 eventHandle = elemData.handle = function( e ) { 4954 4955 // Discard the second event of a jQuery.event.trigger() and 4956 // when an event is called after a page has unloaded 4957 return typeof jQuery !== "undefined" && jQuery.event.triggered !== e.type ? 4958 jQuery.event.dispatch.apply( elem, arguments ) : undefined; 4959 }; 4960 } 4961 4962 // Handle multiple events separated by a space 4963 types = ( types || "" ).match( rnothtmlwhite ) || [ "" ]; 4964 t = types.length; 4965 while ( t-- ) { 4966 tmp = rtypenamespace.exec( types[ t ] ) || []; 4967 type = origType = tmp[ 1 ]; 4968 namespaces = ( tmp[ 2 ] || "" ).split( "." ).sort(); 4969 4970 // There *must* be a type, no attaching namespace-only handlers 4971 if ( !type ) { 4972 continue; 4973 } 4974 4975 // If event changes its type, use the special event handlers for the changed type 4976 special = jQuery.event.special[ type ] || {}; 4977 4978 // If selector defined, determine special event api type, otherwise given type 4979 type = ( selector ? special.delegateType : special.bindType ) || type; 4980 4981 // Update special based on newly reset type 4982 special = jQuery.event.special[ type ] || {}; 4983 4984 // handleObj is passed to all event handlers 4985 handleObj = jQuery.extend( { 4986 type: type, 4987 origType: origType, 4988 data: data, 4989 handler: handler, 4990 guid: handler.guid, 4991 selector: selector, 4992 needsContext: selector && jQuery.expr.match.needsContext.test( selector ), 4993 namespace: namespaces.join( "." ) 4994 }, handleObjIn ); 4995 4996 // Init the event handler queue if we're the first 4997 if ( !( handlers = events[ type ] ) ) { 4998 handlers = events[ type ] = []; 4999 handlers.delegateCount = 0; 5000 5001 // Only use addEventListener if the special events handler returns false 5002 if ( !special.setup || 5003 special.setup.call( elem, data, namespaces, eventHandle ) === false ) { 5004 5005 if ( elem.addEventListener ) { 5006 elem.addEventListener( type, eventHandle ); 5007 } 5008 } 5009 } 5010 5011 if ( special.add ) { 5012 special.add.call( elem, handleObj ); 5013 5014 if ( !handleObj.handler.guid ) { 5015 handleObj.handler.guid = handler.guid; 5016 } 5017 } 5018 5019 // Add to the element's handler list, delegates in front 5020 if ( selector ) { 5021 handlers.splice( handlers.delegateCount++, 0, handleObj ); 5022 } else { 5023 handlers.push( handleObj ); 5024 } 5025 5026 // Keep track of which events have ever been used, for event optimization 5027 jQuery.event.global[ type ] = true; 5028 } 5029 5030 }, 5031 5032 // Detach an event or set of events from an element 5033 remove: function( elem, types, handler, selector, mappedTypes ) { 5034 5035 var j, origCount, tmp, 5036 events, t, handleObj, 5037 special, handlers, type, namespaces, origType, 5038 elemData = dataPriv.hasData( elem ) && dataPriv.get( elem ); 5039 5040 if ( !elemData || !( events = elemData.events ) ) { 5041 return; 5042 } 5043 5044 // Once for each type.namespace in types; type may be omitted 5045 types = ( types || "" ).match( rnothtmlwhite ) || [ "" ]; 5046 t = types.length; 5047 while ( t-- ) { 5048 tmp = rtypenamespace.exec( types[ t ] ) || []; 5049 type = origType = tmp[ 1 ]; 5050 namespaces = ( tmp[ 2 ] || "" ).split( "." ).sort(); 5051 5052 // Unbind all events (on this namespace, if provided) for the element 5053 if ( !type ) { 5054 for ( type in events ) { 5055 jQuery.event.remove( elem, type + types[ t ], handler, selector, true ); 5056 } 5057 continue; 5058 } 5059 5060 special = jQuery.event.special[ type ] || {}; 5061 type = ( selector ? special.delegateType : special.bindType ) || type; 5062 handlers = events[ type ] || []; 5063 tmp = tmp[ 2 ] && 5064 new RegExp( "(^|\\.)" + namespaces.join( "\\.(?:.*\\.|)" ) + "(\\.|$)" ); 5065 5066 // Remove matching events 5067 origCount = j = handlers.length; 5068 while ( j-- ) { 5069 handleObj = handlers[ j ]; 5070 5071 if ( ( mappedTypes || origType === handleObj.origType ) && 5072 ( !handler || handler.guid === handleObj.guid ) && 5073 ( !tmp || tmp.test( handleObj.namespace ) ) && 5074 ( !selector || selector === handleObj.selector || 5075 selector === "**" && handleObj.selector ) ) { 5076 handlers.splice( j, 1 ); 5077 5078 if ( handleObj.selector ) { 5079 handlers.delegateCount--; 5080 } 5081 if ( special.remove ) { 5082 special.remove.call( elem, handleObj ); 5083 } 5084 } 5085 } 5086 5087 // Remove generic event handler if we removed something and no more handlers exist 5088 // (avoids potential for endless recursion during removal of special event handlers) 5089 if ( origCount && !handlers.length ) { 5090 if ( !special.teardown || 5091 special.teardown.call( elem, namespaces, elemData.handle ) === false ) { 5092 5093 jQuery.removeEvent( elem, type, elemData.handle ); 5094 } 5095 5096 delete events[ type ]; 5097 } 5098 } 5099 5100 // Remove data and the expando if it's no longer used 5101 if ( jQuery.isEmptyObject( events ) ) { 5102 dataPriv.remove( elem, "handle events" ); 5103 } 5104 }, 5105 5106 dispatch: function( nativeEvent ) { 5107 5108 var i, j, ret, matched, handleObj, handlerQueue, 5109 args = new Array( arguments.length ), 5110 5111 // Make a writable jQuery.Event from the native event object 5112 event = jQuery.event.fix( nativeEvent ), 5113 5114 handlers = ( 5115 dataPriv.get( this, "events" ) || Object.create( null ) 5116 )[ event.type ] || [], 5117 special = jQuery.event.special[ event.type ] || {}; 5118 5119 // Use the fix-ed jQuery.Event rather than the (read-only) native event 5120 args[ 0 ] = event; 5121 5122 for ( i = 1; i < arguments.length; i++ ) { 5123 args[ i ] = arguments[ i ]; 5124 } 5125 5126 event.delegateTarget = this; 5127 5128 // Call the preDispatch hook for the mapped type, and let it bail if desired 5129 if ( special.preDispatch && special.preDispatch.call( this, event ) === false ) { 5130 return; 5131 } 5132 5133 // Determine handlers 5134 handlerQueue = jQuery.event.handlers.call( this, event, handlers ); 5135 5136 // Run delegates first; they may want to stop propagation beneath us 5137 i = 0; 5138 while ( ( matched = handlerQueue[ i++ ] ) && !event.isPropagationStopped() ) { 5139 event.currentTarget = matched.elem; 5140 5141 j = 0; 5142 while ( ( handleObj = matched.handlers[ j++ ] ) && 5143 !event.isImmediatePropagationStopped() ) { 5144 5145 // If the event is namespaced, then each handler is only invoked if it is 5146 // specially universal or its namespaces are a superset of the event's. 5147 if ( !event.rnamespace || handleObj.namespace === false || 5148 event.rnamespace.test( handleObj.namespace ) ) { 5149 5150 event.handleObj = handleObj; 5151 event.data = handleObj.data; 5152 5153 ret = ( ( jQuery.event.special[ handleObj.origType ] || {} ).handle || 5154 handleObj.handler ).apply( matched.elem, args ); 5155 5156 if ( ret !== undefined ) { 5157 if ( ( event.result = ret ) === false ) { 5158 event.preventDefault(); 5159 event.stopPropagation(); 5160 } 5161 } 5162 } 5163 } 5164 } 5165 5166 // Call the postDispatch hook for the mapped type 5167 if ( special.postDispatch ) { 5168 special.postDispatch.call( this, event ); 5169 } 5170 5171 return event.result; 5172 }, 5173 5174 handlers: function( event, handlers ) { 5175 var i, handleObj, sel, matchedHandlers, matchedSelectors, 5176 handlerQueue = [], 5177 delegateCount = handlers.delegateCount, 5178 cur = event.target; 5179 5180 // Find delegate handlers 5181 if ( delegateCount && 5182 5183 // Support: IE <=9 5184 // Black-hole SVG <use> instance trees (trac-13180) 5185 cur.nodeType && 5186 5187 // Support: Firefox <=42 5188 // Suppress spec-violating clicks indicating a non-primary pointer button (trac-3861) 5189 // https://www.w3.org/TR/DOM-Level-3-Events/#event-type-click 5190 // Support: IE 11 only 5191 // ...but not arrow key "clicks" of radio inputs, which can have `button` -1 (gh-2343) 5192 !( event.type === "click" && event.button >= 1 ) ) { 5193 5194 for ( ; cur !== this; cur = cur.parentNode || this ) { 5195 5196 // Don't check non-elements (trac-13208) 5197 // Don't process clicks on disabled elements (trac-6911, trac-8165, trac-11382, trac-11764) 5198 if ( cur.nodeType === 1 && !( event.type === "click" && cur.disabled === true ) ) { 5199 matchedHandlers = []; 5200 matchedSelectors = {}; 5201 for ( i = 0; i < delegateCount; i++ ) { 5202 handleObj = handlers[ i ]; 5203 5204 // Don't conflict with Object.prototype properties (trac-13203) 5205 sel = handleObj.selector + " "; 5206 5207 if ( matchedSelectors[ sel ] === undefined ) { 5208 matchedSelectors[ sel ] = handleObj.needsContext ? 5209 jQuery( sel, this ).index( cur ) > -1 : 5210 jQuery.find( sel, this, null, [ cur ] ).length; 5211 } 5212 if ( matchedSelectors[ sel ] ) { 5213 matchedHandlers.push( handleObj ); 5214 } 5215 } 5216 if ( matchedHandlers.length ) { 5217 handlerQueue.push( { elem: cur, handlers: matchedHandlers } ); 5218 } 5219 } 5220 } 5221 } 5222 5223 // Add the remaining (directly-bound) handlers 5224 cur = this; 5225 if ( delegateCount < handlers.length ) { 5226 handlerQueue.push( { elem: cur, handlers: handlers.slice( delegateCount ) } ); 5227 } 5228 5229 return handlerQueue; 5230 }, 5231 5232 addProp: function( name, hook ) { 5233 Object.defineProperty( jQuery.Event.prototype, name, { 5234 enumerable: true, 5235 configurable: true, 5236 5237 get: isFunction( hook ) ? 5238 function() { 5239 if ( this.originalEvent ) { 5240 return hook( this.originalEvent ); 5241 } 5242 } : 5243 function() { 5244 if ( this.originalEvent ) { 5245 return this.originalEvent[ name ]; 5246 } 5247 }, 5248 5249 set: function( value ) { 5250 Object.defineProperty( this, name, { 5251 enumerable: true, 5252 configurable: true, 5253 writable: true, 5254 value: value 5255 } ); 5256 } 5257 } ); 5258 }, 5259 5260 fix: function( originalEvent ) { 5261 return originalEvent[ jQuery.expando ] ? 5262 originalEvent : 5263 new jQuery.Event( originalEvent ); 5264 }, 5265 5266 special: { 5267 load: { 5268 5269 // Prevent triggered image.load events from bubbling to window.load 5270 noBubble: true 5271 }, 5272 click: { 5273 5274 // Utilize native event to ensure correct state for checkable inputs 5275 setup: function( data ) { 5276 5277 // For mutual compressibility with _default, replace `this` access with a local var. 5278 // `|| data` is dead code meant only to preserve the variable through minification. 5279 var el = this || data; 5280 5281 // Claim the first handler 5282 if ( rcheckableType.test( el.type ) && 5283 el.click && nodeName( el, "input" ) ) { 5284 5285 // dataPriv.set( el, "click", ... ) 5286 leverageNative( el, "click", true ); 5287 } 5288 5289 // Return false to allow normal processing in the caller 5290 return false; 5291 }, 5292 trigger: function( data ) { 5293 5294 // For mutual compressibility with _default, replace `this` access with a local var. 5295 // `|| data` is dead code meant only to preserve the variable through minification. 5296 var el = this || data; 5297 5298 // Force setup before triggering a click 5299 if ( rcheckableType.test( el.type ) && 5300 el.click && nodeName( el, "input" ) ) { 5301 5302 leverageNative( el, "click" ); 5303 } 5304 5305 // Return non-false to allow normal event-path propagation 5306 return true; 5307 }, 5308 5309 // For cross-browser consistency, suppress native .click() on links 5310 // Also prevent it if we're currently inside a leveraged native-event stack 5311 _default: function( event ) { 5312 var target = event.target; 5313 return rcheckableType.test( target.type ) && 5314 target.click && nodeName( target, "input" ) && 5315 dataPriv.get( target, "click" ) || 5316 nodeName( target, "a" ); 5317 } 5318 }, 5319 5320 beforeunload: { 5321 postDispatch: function( event ) { 5322 5323 // Support: Firefox 20+ 5324 // Firefox doesn't alert if the returnValue field is not set. 5325 if ( event.result !== undefined && event.originalEvent ) { 5326 event.originalEvent.returnValue = event.result; 5327 } 5328 } 5329 } 5330 } 5331}; 5332 5333// Ensure the presence of an event listener that handles manually-triggered 5334// synthetic events by interrupting progress until reinvoked in response to 5335// *native* events that it fires directly, ensuring that state changes have 5336// already occurred before other listeners are invoked. 5337function leverageNative( el, type, isSetup ) { 5338 5339 // Missing `isSetup` indicates a trigger call, which must force setup through jQuery.event.add 5340 if ( !isSetup ) { 5341 if ( dataPriv.get( el, type ) === undefined ) { 5342 jQuery.event.add( el, type, returnTrue ); 5343 } 5344 return; 5345 } 5346 5347 // Register the controller as a special universal handler for all event namespaces 5348 dataPriv.set( el, type, false ); 5349 jQuery.event.add( el, type, { 5350 namespace: false, 5351 handler: function( event ) { 5352 var result, 5353 saved = dataPriv.get( this, type ); 5354 5355 if ( ( event.isTrigger & 1 ) && this[ type ] ) { 5356 5357 // Interrupt processing of the outer synthetic .trigger()ed event 5358 if ( !saved ) { 5359 5360 // Store arguments for use when handling the inner native event 5361 // There will always be at least one argument (an event object), so this array 5362 // will not be confused with a leftover capture object. 5363 saved = slice.call( arguments ); 5364 dataPriv.set( this, type, saved ); 5365 5366 // Trigger the native event and capture its result 5367 this[ type ](); 5368 result = dataPriv.get( this, type ); 5369 dataPriv.set( this, type, false ); 5370 5371 if ( saved !== result ) { 5372 5373 // Cancel the outer synthetic event 5374 event.stopImmediatePropagation(); 5375 event.preventDefault(); 5376 5377 return result; 5378 } 5379 5380 // If this is an inner synthetic event for an event with a bubbling surrogate 5381 // (focus or blur), assume that the surrogate already propagated from triggering 5382 // the native event and prevent that from happening again here. 5383 // This technically gets the ordering wrong w.r.t. to `.trigger()` (in which the 5384 // bubbling surrogate propagates *after* the non-bubbling base), but that seems 5385 // less bad than duplication. 5386 } else if ( ( jQuery.event.special[ type ] || {} ).delegateType ) { 5387 event.stopPropagation(); 5388 } 5389 5390 // If this is a native event triggered above, everything is now in order 5391 // Fire an inner synthetic event with the original arguments 5392 } else if ( saved ) { 5393 5394 // ...and capture the result 5395 dataPriv.set( this, type, jQuery.event.trigger( 5396 saved[ 0 ], 5397 saved.slice( 1 ), 5398 this 5399 ) ); 5400 5401 // Abort handling of the native event by all jQuery handlers while allowing 5402 // native handlers on the same element to run. On target, this is achieved 5403 // by stopping immediate propagation just on the jQuery event. However, 5404 // the native event is re-wrapped by a jQuery one on each level of the 5405 // propagation so the only way to stop it for jQuery is to stop it for 5406 // everyone via native `stopPropagation()`. This is not a problem for 5407 // focus/blur which don't bubble, but it does also stop click on checkboxes 5408 // and radios. We accept this limitation. 5409 event.stopPropagation(); 5410 event.isImmediatePropagationStopped = returnTrue; 5411 } 5412 } 5413 } ); 5414} 5415 5416jQuery.removeEvent = function( elem, type, handle ) { 5417 5418 // This "if" is needed for plain objects 5419 if ( elem.removeEventListener ) { 5420 elem.removeEventListener( type, handle ); 5421 } 5422}; 5423 5424jQuery.Event = function( src, props ) { 5425 5426 // Allow instantiation without the 'new' keyword 5427 if ( !( this instanceof jQuery.Event ) ) { 5428 return new jQuery.Event( src, props ); 5429 } 5430 5431 // Event object 5432 if ( src && src.type ) { 5433 this.originalEvent = src; 5434 this.type = src.type; 5435 5436 // Events bubbling up the document may have been marked as prevented 5437 // by a handler lower down the tree; reflect the correct value. 5438 this.isDefaultPrevented = src.defaultPrevented || 5439 src.defaultPrevented === undefined && 5440 5441 // Support: Android <=2.3 only 5442 src.returnValue === false ? 5443 returnTrue : 5444 returnFalse; 5445 5446 // Create target properties 5447 // Support: Safari <=6 - 7 only 5448 // Target should not be a text node (trac-504, trac-13143) 5449 this.target = ( src.target && src.target.nodeType === 3 ) ? 5450 src.target.parentNode : 5451 src.target; 5452 5453 this.currentTarget = src.currentTarget; 5454 this.relatedTarget = src.relatedTarget; 5455 5456 // Event type 5457 } else { 5458 this.type = src; 5459 } 5460 5461 // Put explicitly provided properties onto the event object 5462 if ( props ) { 5463 jQuery.extend( this, props ); 5464 } 5465 5466 // Create a timestamp if incoming event doesn't have one 5467 this.timeStamp = src && src.timeStamp || Date.now(); 5468 5469 // Mark it as fixed 5470 this[ jQuery.expando ] = true; 5471}; 5472 5473// jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding 5474// https://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html 5475jQuery.Event.prototype = { 5476 constructor: jQuery.Event, 5477 isDefaultPrevented: returnFalse, 5478 isPropagationStopped: returnFalse, 5479 isImmediatePropagationStopped: returnFalse, 5480 isSimulated: false, 5481 5482 preventDefault: function() { 5483 var e = this.originalEvent; 5484 5485 this.isDefaultPrevented = returnTrue; 5486 5487 if ( e && !this.isSimulated ) { 5488 e.preventDefault(); 5489 } 5490 }, 5491 stopPropagation: function() { 5492 var e = this.originalEvent; 5493 5494 this.isPropagationStopped = returnTrue; 5495 5496 if ( e && !this.isSimulated ) { 5497 e.stopPropagation(); 5498 } 5499 }, 5500 stopImmediatePropagation: function() { 5501 var e = this.originalEvent; 5502 5503 this.isImmediatePropagationStopped = returnTrue; 5504 5505 if ( e && !this.isSimulated ) { 5506 e.stopImmediatePropagation(); 5507 } 5508 5509 this.stopPropagation(); 5510 } 5511}; 5512 5513// Includes all common event props including KeyEvent and MouseEvent specific props 5514jQuery.each( { 5515 altKey: true, 5516 bubbles: true, 5517 cancelable: true, 5518 changedTouches: true, 5519 ctrlKey: true, 5520 detail: true, 5521 eventPhase: true, 5522 metaKey: true, 5523 pageX: true, 5524 pageY: true, 5525 shiftKey: true, 5526 view: true, 5527 "char": true, 5528 code: true, 5529 charCode: true, 5530 key: true, 5531 keyCode: true, 5532 button: true, 5533 buttons: true, 5534 clientX: true, 5535 clientY: true, 5536 offsetX: true, 5537 offsetY: true, 5538 pointerId: true, 5539 pointerType: true, 5540 screenX: true, 5541 screenY: true, 5542 targetTouches: true, 5543 toElement: true, 5544 touches: true, 5545 which: true 5546}, jQuery.event.addProp ); 5547 5548jQuery.each( { focus: "focusin", blur: "focusout" }, function( type, delegateType ) { 5549 5550 function focusMappedHandler( nativeEvent ) { 5551 if ( document.documentMode ) { 5552 5553 // Support: IE 11+ 5554 // Attach a single focusin/focusout handler on the document while someone wants 5555 // focus/blur. This is because the former are synchronous in IE while the latter 5556 // are async. In other browsers, all those handlers are invoked synchronously. 5557 5558 // `handle` from private data would already wrap the event, but we need 5559 // to change the `type` here. 5560 var handle = dataPriv.get( this, "handle" ), 5561 event = jQuery.event.fix( nativeEvent ); 5562 event.type = nativeEvent.type === "focusin" ? "focus" : "blur"; 5563 event.isSimulated = true; 5564 5565 // First, handle focusin/focusout 5566 handle( nativeEvent ); 5567 5568 // ...then, handle focus/blur 5569 // 5570 // focus/blur don't bubble while focusin/focusout do; simulate the former by only 5571 // invoking the handler at the lower level. 5572 if ( event.target === event.currentTarget ) { 5573 5574 // The setup part calls `leverageNative`, which, in turn, calls 5575 // `jQuery.event.add`, so event handle will already have been set 5576 // by this point. 5577 handle( event ); 5578 } 5579 } else { 5580 5581 // For non-IE browsers, attach a single capturing handler on the document 5582 // while someone wants focusin/focusout. 5583 jQuery.event.simulate( delegateType, nativeEvent.target, 5584 jQuery.event.fix( nativeEvent ) ); 5585 } 5586 } 5587 5588 jQuery.event.special[ type ] = { 5589 5590 // Utilize native event if possible so blur/focus sequence is correct 5591 setup: function() { 5592 5593 var attaches; 5594 5595 // Claim the first handler 5596 // dataPriv.set( this, "focus", ... ) 5597 // dataPriv.set( this, "blur", ... ) 5598 leverageNative( this, type, true ); 5599 5600 if ( document.documentMode ) { 5601 5602 // Support: IE 9 - 11+ 5603 // We use the same native handler for focusin & focus (and focusout & blur) 5604 // so we need to coordinate setup & teardown parts between those events. 5605 // Use `delegateType` as the key as `type` is already used by `leverageNative`. 5606 attaches = dataPriv.get( this, delegateType ); 5607 if ( !attaches ) { 5608 this.addEventListener( delegateType, focusMappedHandler ); 5609 } 5610 dataPriv.set( this, delegateType, ( attaches || 0 ) + 1 ); 5611 } else { 5612 5613 // Return false to allow normal processing in the caller 5614 return false; 5615 } 5616 }, 5617 trigger: function() { 5618 5619 // Force setup before trigger 5620 leverageNative( this, type ); 5621 5622 // Return non-false to allow normal event-path propagation 5623 return true; 5624 }, 5625 5626 teardown: function() { 5627 var attaches; 5628 5629 if ( document.documentMode ) { 5630 attaches = dataPriv.get( this, delegateType ) - 1; 5631 if ( !attaches ) { 5632 this.removeEventListener( delegateType, focusMappedHandler ); 5633 dataPriv.remove( this, delegateType ); 5634 } else { 5635 dataPriv.set( this, delegateType, attaches ); 5636 } 5637 } else { 5638 5639 // Return false to indicate standard teardown should be applied 5640 return false; 5641 } 5642 }, 5643 5644 // Suppress native focus or blur if we're currently inside 5645 // a leveraged native-event stack 5646 _default: function( event ) { 5647 return dataPriv.get( event.target, type ); 5648 }, 5649 5650 delegateType: delegateType 5651 }; 5652 5653 // Support: Firefox <=44 5654 // Firefox doesn't have focus(in | out) events 5655 // Related ticket - https://bugzilla.mozilla.org/show_bug.cgi?id=687787 5656 // 5657 // Support: Chrome <=48 - 49, Safari <=9.0 - 9.1 5658 // focus(in | out) events fire after focus & blur events, 5659 // which is spec violation - http://www.w3.org/TR/DOM-Level-3-Events/#events-focusevent-event-order 5660 // Related ticket - https://bugs.chromium.org/p/chromium/issues/detail?id=449857 5661 // 5662 // Support: IE 9 - 11+ 5663 // To preserve relative focusin/focus & focusout/blur event order guaranteed on the 3.x branch, 5664 // attach a single handler for both events in IE. 5665 jQuery.event.special[ delegateType ] = { 5666 setup: function() { 5667 5668 // Handle: regular nodes (via `this.ownerDocument`), window 5669 // (via `this.document`) & document (via `this`). 5670 var doc = this.ownerDocument || this.document || this, 5671 dataHolder = document.documentMode ? this : doc, 5672 attaches = dataPriv.get( dataHolder, delegateType ); 5673 5674 // Support: IE 9 - 11+ 5675 // We use the same native handler for focusin & focus (and focusout & blur) 5676 // so we need to coordinate setup & teardown parts between those events. 5677 // Use `delegateType` as the key as `type` is already used by `leverageNative`. 5678 if ( !attaches ) { 5679 if ( document.documentMode ) { 5680 this.addEventListener( delegateType, focusMappedHandler ); 5681 } else { 5682 doc.addEventListener( type, focusMappedHandler, true ); 5683 } 5684 } 5685 dataPriv.set( dataHolder, delegateType, ( attaches || 0 ) + 1 ); 5686 }, 5687 teardown: function() { 5688 var doc = this.ownerDocument || this.document || this, 5689 dataHolder = document.documentMode ? this : doc, 5690 attaches = dataPriv.get( dataHolder, delegateType ) - 1; 5691 5692 if ( !attaches ) { 5693 if ( document.documentMode ) { 5694 this.removeEventListener( delegateType, focusMappedHandler ); 5695 } else { 5696 doc.removeEventListener( type, focusMappedHandler, true ); 5697 } 5698 dataPriv.remove( dataHolder, delegateType ); 5699 } else { 5700 dataPriv.set( dataHolder, delegateType, attaches ); 5701 } 5702 } 5703 }; 5704} ); 5705 5706// Create mouseenter/leave events using mouseover/out and event-time checks 5707// so that event delegation works in jQuery. 5708// Do the same for pointerenter/pointerleave and pointerover/pointerout 5709// 5710// Support: Safari 7 only 5711// Safari sends mouseenter too often; see: 5712// https://bugs.chromium.org/p/chromium/issues/detail?id=470258 5713// for the description of the bug (it existed in older Chrome versions as well). 5714jQuery.each( { 5715 mouseenter: "mouseover", 5716 mouseleave: "mouseout", 5717 pointerenter: "pointerover", 5718 pointerleave: "pointerout" 5719}, function( orig, fix ) { 5720 jQuery.event.special[ orig ] = { 5721 delegateType: fix, 5722 bindType: fix, 5723 5724 handle: function( event ) { 5725 var ret, 5726 target = this, 5727 related = event.relatedTarget, 5728 handleObj = event.handleObj; 5729 5730 // For mouseenter/leave call the handler if related is outside the target. 5731 // NB: No relatedTarget if the mouse left/entered the browser window 5732 if ( !related || ( related !== target && !jQuery.contains( target, related ) ) ) { 5733 event.type = handleObj.origType; 5734 ret = handleObj.handler.apply( this, arguments ); 5735 event.type = fix; 5736 } 5737 return ret; 5738 } 5739 }; 5740} ); 5741 5742jQuery.fn.extend( { 5743 5744 on: function( types, selector, data, fn ) { 5745 return on( this, types, selector, data, fn ); 5746 }, 5747 one: function( types, selector, data, fn ) { 5748 return on( this, types, selector, data, fn, 1 ); 5749 }, 5750 off: function( types, selector, fn ) { 5751 var handleObj, type; 5752 if ( types && types.preventDefault && types.handleObj ) { 5753 5754 // ( event ) dispatched jQuery.Event 5755 handleObj = types.handleObj; 5756 jQuery( types.delegateTarget ).off( 5757 handleObj.namespace ? 5758 handleObj.origType + "." + handleObj.namespace : 5759 handleObj.origType, 5760 handleObj.selector, 5761 handleObj.handler 5762 ); 5763 return this; 5764 } 5765 if ( typeof types === "object" ) { 5766 5767 // ( types-object [, selector] ) 5768 for ( type in types ) { 5769 this.off( type, selector, types[ type ] ); 5770 } 5771 return this; 5772 } 5773 if ( selector === false || typeof selector === "function" ) { 5774 5775 // ( types [, fn] ) 5776 fn = selector; 5777 selector = undefined; 5778 } 5779 if ( fn === false ) { 5780 fn = returnFalse; 5781 } 5782 return this.each( function() { 5783 jQuery.event.remove( this, types, fn, selector ); 5784 } ); 5785 } 5786} ); 5787 5788 5789var 5790 5791 // Support: IE <=10 - 11, Edge 12 - 13 only 5792 // In IE/Edge using regex groups here causes severe slowdowns. 5793 // See https://connect.microsoft.com/IE/feedback/details/1736512/ 5794 rnoInnerhtml = /<script|<style|<link/i, 5795 5796 // checked="checked" or checked 5797 rchecked = /checked\s*(?:[^=]|=\s*.checked.)/i, 5798 5799 rcleanScript = /^\s*<!\[CDATA\[|\]\]>\s*$/g; 5800 5801// Prefer a tbody over its parent table for containing new rows 5802function manipulationTarget( elem, content ) { 5803 if ( nodeName( elem, "table" ) && 5804 nodeName( content.nodeType !== 11 ? content : content.firstChild, "tr" ) ) { 5805 5806 return jQuery( elem ).children( "tbody" )[ 0 ] || elem; 5807 } 5808 5809 return elem; 5810} 5811 5812// Replace/restore the type attribute of script elements for safe DOM manipulation 5813function disableScript( elem ) { 5814 elem.type = ( elem.getAttribute( "type" ) !== null ) + "/" + elem.type; 5815 return elem; 5816} 5817function restoreScript( elem ) { 5818 if ( ( elem.type || "" ).slice( 0, 5 ) === "true/" ) { 5819 elem.type = elem.type.slice( 5 ); 5820 } else { 5821 elem.removeAttribute( "type" ); 5822 } 5823 5824 return elem; 5825} 5826 5827function cloneCopyEvent( src, dest ) { 5828 var i, l, type, pdataOld, udataOld, udataCur, events; 5829 5830 if ( dest.nodeType !== 1 ) { 5831 return; 5832 } 5833 5834 // 1. Copy private data: events, handlers, etc. 5835 if ( dataPriv.hasData( src ) ) { 5836 pdataOld = dataPriv.get( src ); 5837 events = pdataOld.events; 5838 5839 if ( events ) { 5840 dataPriv.remove( dest, "handle events" ); 5841 5842 for ( type in events ) { 5843 for ( i = 0, l = events[ type ].length; i < l; i++ ) { 5844 jQuery.event.add( dest, type, events[ type ][ i ] ); 5845 } 5846 } 5847 } 5848 } 5849 5850 // 2. Copy user data 5851 if ( dataUser.hasData( src ) ) { 5852 udataOld = dataUser.access( src ); 5853 udataCur = jQuery.extend( {}, udataOld ); 5854 5855 dataUser.set( dest, udataCur ); 5856 } 5857} 5858 5859// Fix IE bugs, see support tests 5860function fixInput( src, dest ) { 5861 var nodeName = dest.nodeName.toLowerCase(); 5862 5863 // Fails to persist the checked state of a cloned checkbox or radio button. 5864 if ( nodeName === "input" && rcheckableType.test( src.type ) ) { 5865 dest.checked = src.checked; 5866 5867 // Fails to return the selected option to the default selected state when cloning options 5868 } else if ( nodeName === "input" || nodeName === "textarea" ) { 5869 dest.defaultValue = src.defaultValue; 5870 } 5871} 5872 5873function domManip( collection, args, callback, ignored ) { 5874 5875 // Flatten any nested arrays 5876 args = flat( args ); 5877 5878 var fragment, first, scripts, hasScripts, node, doc, 5879 i = 0, 5880 l = collection.length, 5881 iNoClone = l - 1, 5882 value = args[ 0 ], 5883 valueIsFunction = isFunction( value ); 5884 5885 // We can't cloneNode fragments that contain checked, in WebKit 5886 if ( valueIsFunction || 5887 ( l > 1 && typeof value === "string" && 5888 !support.checkClone && rchecked.test( value ) ) ) { 5889 return collection.each( function( index ) { 5890 var self = collection.eq( index ); 5891 if ( valueIsFunction ) { 5892 args[ 0 ] = value.call( this, index, self.html() ); 5893 } 5894 domManip( self, args, callback, ignored ); 5895 } ); 5896 } 5897 5898 if ( l ) { 5899 fragment = buildFragment( args, collection[ 0 ].ownerDocument, false, collection, ignored ); 5900 first = fragment.firstChild; 5901 5902 if ( fragment.childNodes.length === 1 ) { 5903 fragment = first; 5904 } 5905 5906 // Require either new content or an interest in ignored elements to invoke the callback 5907 if ( first || ignored ) { 5908 scripts = jQuery.map( getAll( fragment, "script" ), disableScript ); 5909 hasScripts = scripts.length; 5910 5911 // Use the original fragment for the last item 5912 // instead of the first because it can end up 5913 // being emptied incorrectly in certain situations (trac-8070). 5914 for ( ; i < l; i++ ) { 5915 node = fragment; 5916 5917 if ( i !== iNoClone ) { 5918 node = jQuery.clone( node, true, true ); 5919 5920 // Keep references to cloned scripts for later restoration 5921 if ( hasScripts ) { 5922 5923 // Support: Android <=4.0 only, PhantomJS 1 only 5924 // push.apply(_, arraylike) throws on ancient WebKit 5925 jQuery.merge( scripts, getAll( node, "script" ) ); 5926 } 5927 } 5928 5929 callback.call( collection[ i ], node, i ); 5930 } 5931 5932 if ( hasScripts ) { 5933 doc = scripts[ scripts.length - 1 ].ownerDocument; 5934 5935 // Re-enable scripts 5936 jQuery.map( scripts, restoreScript ); 5937 5938 // Evaluate executable scripts on first document insertion 5939 for ( i = 0; i < hasScripts; i++ ) { 5940 node = scripts[ i ]; 5941 if ( rscriptType.test( node.type || "" ) && 5942 !dataPriv.access( node, "globalEval" ) && 5943 jQuery.contains( doc, node ) ) { 5944 5945 if ( node.src && ( node.type || "" ).toLowerCase() !== "module" ) { 5946 5947 // Optional AJAX dependency, but won't run scripts if not present 5948 if ( jQuery._evalUrl && !node.noModule ) { 5949 jQuery._evalUrl( node.src, { 5950 nonce: node.nonce || node.getAttribute( "nonce" ) 5951 }, doc ); 5952 } 5953 } else { 5954 5955 // Unwrap a CDATA section containing script contents. This shouldn't be 5956 // needed as in XML documents they're already not visible when 5957 // inspecting element contents and in HTML documents they have no 5958 // meaning but we're preserving that logic for backwards compatibility. 5959 // This will be removed completely in 4.0. See gh-4904. 5960 DOMEval( node.textContent.replace( rcleanScript, "" ), node, doc ); 5961 } 5962 } 5963 } 5964 } 5965 } 5966 } 5967 5968 return collection; 5969} 5970 5971function remove( elem, selector, keepData ) { 5972 var node, 5973 nodes = selector ? jQuery.filter( selector, elem ) : elem, 5974 i = 0; 5975 5976 for ( ; ( node = nodes[ i ] ) != null; i++ ) { 5977 if ( !keepData && node.nodeType === 1 ) { 5978 jQuery.cleanData( getAll( node ) ); 5979 } 5980 5981 if ( node.parentNode ) { 5982 if ( keepData && isAttached( node ) ) { 5983 setGlobalEval( getAll( node, "script" ) ); 5984 } 5985 node.parentNode.removeChild( node ); 5986 } 5987 } 5988 5989 return elem; 5990} 5991 5992jQuery.extend( { 5993 htmlPrefilter: function( html ) { 5994 return html; 5995 }, 5996 5997 clone: function( elem, dataAndEvents, deepDataAndEvents ) { 5998 var i, l, srcElements, destElements, 5999 clone = elem.cloneNode( true ), 6000 inPage = isAttached( elem ); 6001 6002 // Fix IE cloning issues 6003 if ( !support.noCloneChecked && ( elem.nodeType === 1 || elem.nodeType === 11 ) && 6004 !jQuery.isXMLDoc( elem ) ) { 6005 6006 // We eschew jQuery#find here for performance reasons: 6007 // https://jsperf.com/getall-vs-sizzle/2 6008 destElements = getAll( clone ); 6009 srcElements = getAll( elem ); 6010 6011 for ( i = 0, l = srcElements.length; i < l; i++ ) { 6012 fixInput( srcElements[ i ], destElements[ i ] ); 6013 } 6014 } 6015 6016 // Copy the events from the original to the clone 6017 if ( dataAndEvents ) { 6018 if ( deepDataAndEvents ) { 6019 srcElements = srcElements || getAll( elem ); 6020 destElements = destElements || getAll( clone ); 6021 6022 for ( i = 0, l = srcElements.length; i < l; i++ ) { 6023 cloneCopyEvent( srcElements[ i ], destElements[ i ] ); 6024 } 6025 } else { 6026 cloneCopyEvent( elem, clone ); 6027 } 6028 } 6029 6030 // Preserve script evaluation history 6031 destElements = getAll( clone, "script" ); 6032 if ( destElements.length > 0 ) { 6033 setGlobalEval( destElements, !inPage && getAll( elem, "script" ) ); 6034 } 6035 6036 // Return the cloned set 6037 return clone; 6038 }, 6039 6040 cleanData: function( elems ) { 6041 var data, elem, type, 6042 special = jQuery.event.special, 6043 i = 0; 6044 6045 for ( ; ( elem = elems[ i ] ) !== undefined; i++ ) { 6046 if ( acceptData( elem ) ) { 6047 if ( ( data = elem[ dataPriv.expando ] ) ) { 6048 if ( data.events ) { 6049 for ( type in data.events ) { 6050 if ( special[ type ] ) { 6051 jQuery.event.remove( elem, type ); 6052 6053 // This is a shortcut to avoid jQuery.event.remove's overhead 6054 } else { 6055 jQuery.removeEvent( elem, type, data.handle ); 6056 } 6057 } 6058 } 6059 6060 // Support: Chrome <=35 - 45+ 6061 // Assign undefined instead of using delete, see Data#remove 6062 elem[ dataPriv.expando ] = undefined; 6063 } 6064 if ( elem[ dataUser.expando ] ) { 6065 6066 // Support: Chrome <=35 - 45+ 6067 // Assign undefined instead of using delete, see Data#remove 6068 elem[ dataUser.expando ] = undefined; 6069 } 6070 } 6071 } 6072 } 6073} ); 6074 6075jQuery.fn.extend( { 6076 detach: function( selector ) { 6077 return remove( this, selector, true ); 6078 }, 6079 6080 remove: function( selector ) { 6081 return remove( this, selector ); 6082 }, 6083 6084 text: function( value ) { 6085 return access( this, function( value ) { 6086 return value === undefined ? 6087 jQuery.text( this ) : 6088 this.empty().each( function() { 6089 if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) { 6090 this.textContent = value; 6091 } 6092 } ); 6093 }, null, value, arguments.length ); 6094 }, 6095 6096 append: function() { 6097 return domManip( this, arguments, function( elem ) { 6098 if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) { 6099 var target = manipulationTarget( this, elem ); 6100 target.appendChild( elem ); 6101 } 6102 } ); 6103 }, 6104 6105 prepend: function() { 6106 return domManip( this, arguments, function( elem ) { 6107 if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) { 6108 var target = manipulationTarget( this, elem ); 6109 target.insertBefore( elem, target.firstChild ); 6110 } 6111 } ); 6112 }, 6113 6114 before: function() { 6115 return domManip( this, arguments, function( elem ) { 6116 if ( this.parentNode ) { 6117 this.parentNode.insertBefore( elem, this ); 6118 } 6119 } ); 6120 }, 6121 6122 after: function() { 6123 return domManip( this, arguments, function( elem ) { 6124 if ( this.parentNode ) { 6125 this.parentNode.insertBefore( elem, this.nextSibling ); 6126 } 6127 } ); 6128 }, 6129 6130 empty: function() { 6131 var elem, 6132 i = 0; 6133 6134 for ( ; ( elem = this[ i ] ) != null; i++ ) { 6135 if ( elem.nodeType === 1 ) { 6136 6137 // Prevent memory leaks 6138 jQuery.cleanData( getAll( elem, false ) ); 6139 6140 // Remove any remaining nodes 6141 elem.textContent = ""; 6142 } 6143 } 6144 6145 return this; 6146 }, 6147 6148 clone: function( dataAndEvents, deepDataAndEvents ) { 6149 dataAndEvents = dataAndEvents == null ? false : dataAndEvents; 6150 deepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents; 6151 6152 return this.map( function() { 6153 return jQuery.clone( this, dataAndEvents, deepDataAndEvents ); 6154 } ); 6155 }, 6156 6157 html: function( value ) { 6158 return access( this, function( value ) { 6159 var elem = this[ 0 ] || {}, 6160 i = 0, 6161 l = this.length; 6162 6163 if ( value === undefined && elem.nodeType === 1 ) { 6164 return elem.innerHTML; 6165 } 6166 6167 // See if we can take a shortcut and just use innerHTML 6168 if ( typeof value === "string" && !rnoInnerhtml.test( value ) && 6169 !wrapMap[ ( rtagName.exec( value ) || [ "", "" ] )[ 1 ].toLowerCase() ] ) { 6170 6171 value = jQuery.htmlPrefilter( value ); 6172 6173 try { 6174 for ( ; i < l; i++ ) { 6175 elem = this[ i ] || {}; 6176 6177 // Remove element nodes and prevent memory leaks 6178 if ( elem.nodeType === 1 ) { 6179 jQuery.cleanData( getAll( elem, false ) ); 6180 elem.innerHTML = value; 6181 } 6182 } 6183 6184 elem = 0; 6185 6186 // If using innerHTML throws an exception, use the fallback method 6187 } catch ( e ) {} 6188 } 6189 6190 if ( elem ) { 6191 this.empty().append( value ); 6192 } 6193 }, null, value, arguments.length ); 6194 }, 6195 6196 replaceWith: function() { 6197 var ignored = []; 6198 6199 // Make the changes, replacing each non-ignored context element with the new content 6200 return domManip( this, arguments, function( elem ) { 6201 var parent = this.parentNode; 6202 6203 if ( jQuery.inArray( this, ignored ) < 0 ) { 6204 jQuery.cleanData( getAll( this ) ); 6205 if ( parent ) { 6206 parent.replaceChild( elem, this ); 6207 } 6208 } 6209 6210 // Force callback invocation 6211 }, ignored ); 6212 } 6213} ); 6214 6215jQuery.each( { 6216 appendTo: "append", 6217 prependTo: "prepend", 6218 insertBefore: "before", 6219 insertAfter: "after", 6220 replaceAll: "replaceWith" 6221}, function( name, original ) { 6222 jQuery.fn[ name ] = function( selector ) { 6223 var elems, 6224 ret = [], 6225 insert = jQuery( selector ), 6226 last = insert.length - 1, 6227 i = 0; 6228 6229 for ( ; i <= last; i++ ) { 6230 elems = i === last ? this : this.clone( true ); 6231 jQuery( insert[ i ] )[ original ]( elems ); 6232 6233 // Support: Android <=4.0 only, PhantomJS 1 only 6234 // .get() because push.apply(_, arraylike) throws on ancient WebKit 6235 push.apply( ret, elems.get() ); 6236 } 6237 6238 return this.pushStack( ret ); 6239 }; 6240} ); 6241var rnumnonpx = new RegExp( "^(" + pnum + ")(?!px)[a-z%]+$", "i" ); 6242 6243var rcustomProp = /^--/; 6244 6245 6246var getStyles = function( elem ) { 6247 6248 // Support: IE <=11 only, Firefox <=30 (trac-15098, trac-14150) 6249 // IE throws on elements created in popups 6250 // FF meanwhile throws on frame elements through "defaultView.getComputedStyle" 6251 var view = elem.ownerDocument.defaultView; 6252 6253 if ( !view || !view.opener ) { 6254 view = window; 6255 } 6256 6257 return view.getComputedStyle( elem ); 6258 }; 6259 6260var swap = function( elem, options, callback ) { 6261 var ret, name, 6262 old = {}; 6263 6264 // Remember the old values, and insert the new ones 6265 for ( name in options ) { 6266 old[ name ] = elem.style[ name ]; 6267 elem.style[ name ] = options[ name ]; 6268 } 6269 6270 ret = callback.call( elem ); 6271 6272 // Revert the old values 6273 for ( name in options ) { 6274 elem.style[ name ] = old[ name ]; 6275 } 6276 6277 return ret; 6278}; 6279 6280 6281var rboxStyle = new RegExp( cssExpand.join( "|" ), "i" ); 6282 6283 6284 6285( function() { 6286 6287 // Executing both pixelPosition & boxSizingReliable tests require only one layout 6288 // so they're executed at the same time to save the second computation. 6289 function computeStyleTests() { 6290 6291 // This is a singleton, we need to execute it only once 6292 if ( !div ) { 6293 return; 6294 } 6295 6296 container.style.cssText = "position:absolute;left:-11111px;width:60px;" + 6297 "margin-top:1px;padding:0;border:0"; 6298 div.style.cssText = 6299 "position:relative;display:block;box-sizing:border-box;overflow:scroll;" + 6300 "margin:auto;border:1px;padding:1px;" + 6301 "width:60%;top:1%"; 6302 documentElement.appendChild( container ).appendChild( div ); 6303 6304 var divStyle = window.getComputedStyle( div ); 6305 pixelPositionVal = divStyle.top !== "1%"; 6306 6307 // Support: Android 4.0 - 4.3 only, Firefox <=3 - 44 6308 reliableMarginLeftVal = roundPixelMeasures( divStyle.marginLeft ) === 12; 6309 6310 // Support: Android 4.0 - 4.3 only, Safari <=9.1 - 10.1, iOS <=7.0 - 9.3 6311 // Some styles come back with percentage values, even though they shouldn't 6312 div.style.right = "60%"; 6313 pixelBoxStylesVal = roundPixelMeasures( divStyle.right ) === 36; 6314 6315 // Support: IE 9 - 11 only 6316 // Detect misreporting of content dimensions for box-sizing:border-box elements 6317 boxSizingReliableVal = roundPixelMeasures( divStyle.width ) === 36; 6318 6319 // Support: IE 9 only 6320 // Detect overflow:scroll screwiness (gh-3699) 6321 // Support: Chrome <=64 6322 // Don't get tricked when zoom affects offsetWidth (gh-4029) 6323 div.style.position = "absolute"; 6324 scrollboxSizeVal = roundPixelMeasures( div.offsetWidth / 3 ) === 12; 6325 6326 documentElement.removeChild( container ); 6327 6328 // Nullify the div so it wouldn't be stored in the memory and 6329 // it will also be a sign that checks already performed 6330 div = null; 6331 } 6332 6333 function roundPixelMeasures( measure ) { 6334 return Math.round( parseFloat( measure ) ); 6335 } 6336 6337 var pixelPositionVal, boxSizingReliableVal, scrollboxSizeVal, pixelBoxStylesVal, 6338 reliableTrDimensionsVal, reliableMarginLeftVal, 6339 container = document.createElement( "div" ), 6340 div = document.createElement( "div" ); 6341 6342 // Finish early in limited (non-browser) environments 6343 if ( !div.style ) { 6344 return; 6345 } 6346 6347 // Support: IE <=9 - 11 only 6348 // Style of cloned element affects source element cloned (trac-8908) 6349 div.style.backgroundClip = "content-box"; 6350 div.cloneNode( true ).style.backgroundClip = ""; 6351 support.clearCloneStyle = div.style.backgroundClip === "content-box"; 6352 6353 jQuery.extend( support, { 6354 boxSizingReliable: function() { 6355 computeStyleTests(); 6356 return boxSizingReliableVal; 6357 }, 6358 pixelBoxStyles: function() { 6359 computeStyleTests(); 6360 return pixelBoxStylesVal; 6361 }, 6362 pixelPosition: function() { 6363 computeStyleTests(); 6364 return pixelPositionVal; 6365 }, 6366 reliableMarginLeft: function() { 6367 computeStyleTests(); 6368 return reliableMarginLeftVal; 6369 }, 6370 scrollboxSize: function() { 6371 computeStyleTests(); 6372 return scrollboxSizeVal; 6373 }, 6374 6375 // Support: IE 9 - 11+, Edge 15 - 18+ 6376 // IE/Edge misreport `getComputedStyle` of table rows with width/height 6377 // set in CSS while `offset*` properties report correct values. 6378 // Behavior in IE 9 is more subtle than in newer versions & it passes 6379 // some versions of this test; make sure not to make it pass there! 6380 // 6381 // Support: Firefox 70+ 6382 // Only Firefox includes border widths 6383 // in computed dimensions. (gh-4529) 6384 reliableTrDimensions: function() { 6385 var table, tr, trChild, trStyle; 6386 if ( reliableTrDimensionsVal == null ) { 6387 table = document.createElement( "table" ); 6388 tr = document.createElement( "tr" ); 6389 trChild = document.createElement( "div" ); 6390 6391 table.style.cssText = "position:absolute;left:-11111px;border-collapse:separate"; 6392 tr.style.cssText = "box-sizing:content-box;border:1px solid"; 6393 6394 // Support: Chrome 86+ 6395 // Height set through cssText does not get applied. 6396 // Computed height then comes back as 0. 6397 tr.style.height = "1px"; 6398 trChild.style.height = "9px"; 6399 6400 // Support: Android 8 Chrome 86+ 6401 // In our bodyBackground.html iframe, 6402 // display for all div elements is set to "inline", 6403 // which causes a problem only in Android 8 Chrome 86. 6404 // Ensuring the div is `display: block` 6405 // gets around this issue. 6406 trChild.style.display = "block"; 6407 6408 documentElement 6409 .appendChild( table ) 6410 .appendChild( tr ) 6411 .appendChild( trChild ); 6412 6413 trStyle = window.getComputedStyle( tr ); 6414 reliableTrDimensionsVal = ( parseInt( trStyle.height, 10 ) + 6415 parseInt( trStyle.borderTopWidth, 10 ) + 6416 parseInt( trStyle.borderBottomWidth, 10 ) ) === tr.offsetHeight; 6417 6418 documentElement.removeChild( table ); 6419 } 6420 return reliableTrDimensionsVal; 6421 } 6422 } ); 6423} )(); 6424 6425 6426function curCSS( elem, name, computed ) { 6427 var width, minWidth, maxWidth, ret, 6428 isCustomProp = rcustomProp.test( name ), 6429 6430 // Support: Firefox 51+ 6431 // Retrieving style before computed somehow 6432 // fixes an issue with getting wrong values 6433 // on detached elements 6434 style = elem.style; 6435 6436 computed = computed || getStyles( elem ); 6437 6438 // getPropertyValue is needed for: 6439 // .css('filter') (IE 9 only, trac-12537) 6440 // .css('--customProperty) (gh-3144) 6441 if ( computed ) { 6442 6443 // Support: IE <=9 - 11+ 6444 // IE only supports `"float"` in `getPropertyValue`; in computed styles 6445 // it's only available as `"cssFloat"`. We no longer modify properties 6446 // sent to `.css()` apart from camelCasing, so we need to check both. 6447 // Normally, this would create difference in behavior: if 6448 // `getPropertyValue` returns an empty string, the value returned 6449 // by `.css()` would be `undefined`. This is usually the case for 6450 // disconnected elements. However, in IE even disconnected elements 6451 // with no styles return `"none"` for `getPropertyValue( "float" )` 6452 ret = computed.getPropertyValue( name ) || computed[ name ]; 6453 6454 if ( isCustomProp && ret ) { 6455 6456 // Support: Firefox 105+, Chrome <=105+ 6457 // Spec requires trimming whitespace for custom properties (gh-4926). 6458 // Firefox only trims leading whitespace. Chrome just collapses 6459 // both leading & trailing whitespace to a single space. 6460 // 6461 // Fall back to `undefined` if empty string returned. 6462 // This collapses a missing definition with property defined 6463 // and set to an empty string but there's no standard API 6464 // allowing us to differentiate them without a performance penalty 6465 // and returning `undefined` aligns with older jQuery. 6466 // 6467 // rtrimCSS treats U+000D CARRIAGE RETURN and U+000C FORM FEED 6468 // as whitespace while CSS does not, but this is not a problem 6469 // because CSS preprocessing replaces them with U+000A LINE FEED 6470 // (which *is* CSS whitespace) 6471 // https://www.w3.org/TR/css-syntax-3/#input-preprocessing 6472 ret = ret.replace( rtrimCSS, "$1" ) || undefined; 6473 } 6474 6475 if ( ret === "" && !isAttached( elem ) ) { 6476 ret = jQuery.style( elem, name ); 6477 } 6478 6479 // A tribute to the "awesome hack by Dean Edwards" 6480 // Android Browser returns percentage for some values, 6481 // but width seems to be reliably pixels. 6482 // This is against the CSSOM draft spec: 6483 // https://drafts.csswg.org/cssom/#resolved-values 6484 if ( !support.pixelBoxStyles() && rnumnonpx.test( ret ) && rboxStyle.test( name ) ) { 6485 6486 // Remember the original values 6487 width = style.width; 6488 minWidth = style.minWidth; 6489 maxWidth = style.maxWidth; 6490 6491 // Put in the new values to get a computed value out 6492 style.minWidth = style.maxWidth = style.width = ret; 6493 ret = computed.width; 6494 6495 // Revert the changed values 6496 style.width = width; 6497 style.minWidth = minWidth; 6498 style.maxWidth = maxWidth; 6499 } 6500 } 6501 6502 return ret !== undefined ? 6503 6504 // Support: IE <=9 - 11 only 6505 // IE returns zIndex value as an integer. 6506 ret + "" : 6507 ret; 6508} 6509 6510 6511function addGetHookIf( conditionFn, hookFn ) { 6512 6513 // Define the hook, we'll check on the first run if it's really needed. 6514 return { 6515 get: function() { 6516 if ( conditionFn() ) { 6517 6518 // Hook not needed (or it's not possible to use it due 6519 // to missing dependency), remove it. 6520 delete this.get; 6521 return; 6522 } 6523 6524 // Hook needed; redefine it so that the support test is not executed again. 6525 return ( this.get = hookFn ).apply( this, arguments ); 6526 } 6527 }; 6528} 6529 6530 6531var cssPrefixes = [ "Webkit", "Moz", "ms" ], 6532 emptyStyle = document.createElement( "div" ).style, 6533 vendorProps = {}; 6534 6535// Return a vendor-prefixed property or undefined 6536function vendorPropName( name ) { 6537 6538 // Check for vendor prefixed names 6539 var capName = name[ 0 ].toUpperCase() + name.slice( 1 ), 6540 i = cssPrefixes.length; 6541 6542 while ( i-- ) { 6543 name = cssPrefixes[ i ] + capName; 6544 if ( name in emptyStyle ) { 6545 return name; 6546 } 6547 } 6548} 6549 6550// Return a potentially-mapped jQuery.cssProps or vendor prefixed property 6551function finalPropName( name ) { 6552 var final = jQuery.cssProps[ name ] || vendorProps[ name ]; 6553 6554 if ( final ) { 6555 return final; 6556 } 6557 if ( name in emptyStyle ) { 6558 return name; 6559 } 6560 return vendorProps[ name ] = vendorPropName( name ) || name; 6561} 6562 6563 6564var 6565 6566 // Swappable if display is none or starts with table 6567 // except "table", "table-cell", or "table-caption" 6568 // See here for display values: https://developer.mozilla.org/en-US/docs/CSS/display 6569 rdisplayswap = /^(none|table(?!-c[ea]).+)/, 6570 cssShow = { position: "absolute", visibility: "hidden", display: "block" }, 6571 cssNormalTransform = { 6572 letterSpacing: "0", 6573 fontWeight: "400" 6574 }; 6575 6576function setPositiveNumber( _elem, value, subtract ) { 6577 6578 // Any relative (+/-) values have already been 6579 // normalized at this point 6580 var matches = rcssNum.exec( value ); 6581 return matches ? 6582 6583 // Guard against undefined "subtract", e.g., when used as in cssHooks 6584 Math.max( 0, matches[ 2 ] - ( subtract || 0 ) ) + ( matches[ 3 ] || "px" ) : 6585 value; 6586} 6587 6588function boxModelAdjustment( elem, dimension, box, isBorderBox, styles, computedVal ) { 6589 var i = dimension === "width" ? 1 : 0, 6590 extra = 0, 6591 delta = 0, 6592 marginDelta = 0; 6593 6594 // Adjustment may not be necessary 6595 if ( box === ( isBorderBox ? "border" : "content" ) ) { 6596 return 0; 6597 } 6598 6599 for ( ; i < 4; i += 2 ) { 6600 6601 // Both box models exclude margin 6602 // Count margin delta separately to only add it after scroll gutter adjustment. 6603 // This is needed to make negative margins work with `outerHeight( true )` (gh-3982). 6604 if ( box === "margin" ) { 6605 marginDelta += jQuery.css( elem, box + cssExpand[ i ], true, styles ); 6606 } 6607 6608 // If we get here with a content-box, we're seeking "padding" or "border" or "margin" 6609 if ( !isBorderBox ) { 6610 6611 // Add padding 6612 delta += jQuery.css( elem, "padding" + cssExpand[ i ], true, styles ); 6613 6614 // For "border" or "margin", add border 6615 if ( box !== "padding" ) { 6616 delta += jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles ); 6617 6618 // But still keep track of it otherwise 6619 } else { 6620 extra += jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles ); 6621 } 6622 6623 // If we get here with a border-box (content + padding + border), we're seeking "content" or 6624 // "padding" or "margin" 6625 } else { 6626 6627 // For "content", subtract padding 6628 if ( box === "content" ) { 6629 delta -= jQuery.css( elem, "padding" + cssExpand[ i ], true, styles ); 6630 } 6631 6632 // For "content" or "padding", subtract border 6633 if ( box !== "margin" ) { 6634 delta -= jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles ); 6635 } 6636 } 6637 } 6638 6639 // Account for positive content-box scroll gutter when requested by providing computedVal 6640 if ( !isBorderBox && computedVal >= 0 ) { 6641 6642 // offsetWidth/offsetHeight is a rounded sum of content, padding, scroll gutter, and border 6643 // Assuming integer scroll gutter, subtract the rest and round down 6644 delta += Math.max( 0, Math.ceil( 6645 elem[ "offset" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 ) ] - 6646 computedVal - 6647 delta - 6648 extra - 6649 0.5 6650 6651 // If offsetWidth/offsetHeight is unknown, then we can't determine content-box scroll gutter 6652 // Use an explicit zero to avoid NaN (gh-3964) 6653 ) ) || 0; 6654 } 6655 6656 return delta + marginDelta; 6657} 6658 6659function getWidthOrHeight( elem, dimension, extra ) { 6660 6661 // Start with computed style 6662 var styles = getStyles( elem ), 6663 6664 // To avoid forcing a reflow, only fetch boxSizing if we need it (gh-4322). 6665 // Fake content-box until we know it's needed to know the true value. 6666 boxSizingNeeded = !support.boxSizingReliable() || extra, 6667 isBorderBox = boxSizingNeeded && 6668 jQuery.css( elem, "boxSizing", false, styles ) === "border-box", 6669 valueIsBorderBox = isBorderBox, 6670 6671 val = curCSS( elem, dimension, styles ), 6672 offsetProp = "offset" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 ); 6673 6674 // Support: Firefox <=54 6675 // Return a confounding non-pixel value or feign ignorance, as appropriate. 6676 if ( rnumnonpx.test( val ) ) { 6677 if ( !extra ) { 6678 return val; 6679 } 6680 val = "auto"; 6681 } 6682 6683 6684 // Support: IE 9 - 11 only 6685 // Use offsetWidth/offsetHeight for when box sizing is unreliable. 6686 // In those cases, the computed value can be trusted to be border-box. 6687 if ( ( !support.boxSizingReliable() && isBorderBox || 6688 6689 // Support: IE 10 - 11+, Edge 15 - 18+ 6690 // IE/Edge misreport `getComputedStyle` of table rows with width/height 6691 // set in CSS while `offset*` properties report correct values. 6692 // Interestingly, in some cases IE 9 doesn't suffer from this issue. 6693 !support.reliableTrDimensions() && nodeName( elem, "tr" ) || 6694 6695 // Fall back to offsetWidth/offsetHeight when value is "auto" 6696 // This happens for inline elements with no explicit setting (gh-3571) 6697 val === "auto" || 6698 6699 // Support: Android <=4.1 - 4.3 only 6700 // Also use offsetWidth/offsetHeight for misreported inline dimensions (gh-3602) 6701 !parseFloat( val ) && jQuery.css( elem, "display", false, styles ) === "inline" ) && 6702 6703 // Make sure the element is visible & connected 6704 elem.getClientRects().length ) { 6705 6706 isBorderBox = jQuery.css( elem, "boxSizing", false, styles ) === "border-box"; 6707 6708 // Where available, offsetWidth/offsetHeight approximate border box dimensions. 6709 // Where not available (e.g., SVG), assume unreliable box-sizing and interpret the 6710 // retrieved value as a content box dimension. 6711 valueIsBorderBox = offsetProp in elem; 6712 if ( valueIsBorderBox ) { 6713 val = elem[ offsetProp ]; 6714 } 6715 } 6716 6717 // Normalize "" and auto 6718 val = parseFloat( val ) || 0; 6719 6720 // Adjust for the element's box model 6721 return ( val + 6722 boxModelAdjustment( 6723 elem, 6724 dimension, 6725 extra || ( isBorderBox ? "border" : "content" ), 6726 valueIsBorderBox, 6727 styles, 6728 6729 // Provide the current computed size to request scroll gutter calculation (gh-3589) 6730 val 6731 ) 6732 ) + "px"; 6733} 6734 6735jQuery.extend( { 6736 6737 // Add in style property hooks for overriding the default 6738 // behavior of getting and setting a style property 6739 cssHooks: { 6740 opacity: { 6741 get: function( elem, computed ) { 6742 if ( computed ) { 6743 6744 // We should always get a number back from opacity 6745 var ret = curCSS( elem, "opacity" ); 6746 return ret === "" ? "1" : ret; 6747 } 6748 } 6749 } 6750 }, 6751 6752 // Don't automatically add "px" to these possibly-unitless properties 6753 cssNumber: { 6754 animationIterationCount: true, 6755 aspectRatio: true, 6756 borderImageSlice: true, 6757 columnCount: true, 6758 flexGrow: true, 6759 flexShrink: true, 6760 fontWeight: true, 6761 gridArea: true, 6762 gridColumn: true, 6763 gridColumnEnd: true, 6764 gridColumnStart: true, 6765 gridRow: true, 6766 gridRowEnd: true, 6767 gridRowStart: true, 6768 lineHeight: true, 6769 opacity: true, 6770 order: true, 6771 orphans: true, 6772 scale: true, 6773 widows: true, 6774 zIndex: true, 6775 zoom: true, 6776 6777 // SVG-related 6778 fillOpacity: true, 6779 floodOpacity: true, 6780 stopOpacity: true, 6781 strokeMiterlimit: true, 6782 strokeOpacity: true 6783 }, 6784 6785 // Add in properties whose names you wish to fix before 6786 // setting or getting the value 6787 cssProps: {}, 6788 6789 // Get and set the style property on a DOM Node 6790 style: function( elem, name, value, extra ) { 6791 6792 // Don't set styles on text and comment nodes 6793 if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style ) { 6794 return; 6795 } 6796 6797 // Make sure that we're working with the right name 6798 var ret, type, hooks, 6799 origName = camelCase( name ), 6800 isCustomProp = rcustomProp.test( name ), 6801 style = elem.style; 6802 6803 // Make sure that we're working with the right name. We don't 6804 // want to query the value if it is a CSS custom property 6805 // since they are user-defined. 6806 if ( !isCustomProp ) { 6807 name = finalPropName( origName ); 6808 } 6809 6810 // Gets hook for the prefixed version, then unprefixed version 6811 hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ]; 6812 6813 // Check if we're setting a value 6814 if ( value !== undefined ) { 6815 type = typeof value; 6816 6817 // Convert "+=" or "-=" to relative numbers (trac-7345) 6818 if ( type === "string" && ( ret = rcssNum.exec( value ) ) && ret[ 1 ] ) { 6819 value = adjustCSS( elem, name, ret ); 6820 6821 // Fixes bug trac-9237 6822 type = "number"; 6823 } 6824 6825 // Make sure that null and NaN values aren't set (trac-7116) 6826 if ( value == null || value !== value ) { 6827 return; 6828 } 6829 6830 // If a number was passed in, add the unit (except for certain CSS properties) 6831 // The isCustomProp check can be removed in jQuery 4.0 when we only auto-append 6832 // "px" to a few hardcoded values. 6833 if ( type === "number" && !isCustomProp ) { 6834 value += ret && ret[ 3 ] || ( jQuery.cssNumber[ origName ] ? "" : "px" ); 6835 } 6836 6837 // background-* props affect original clone's values 6838 if ( !support.clearCloneStyle && value === "" && name.indexOf( "background" ) === 0 ) { 6839 style[ name ] = "inherit"; 6840 } 6841 6842 // If a hook was provided, use that value, otherwise just set the specified value 6843 if ( !hooks || !( "set" in hooks ) || 6844 ( value = hooks.set( elem, value, extra ) ) !== undefined ) { 6845 6846 if ( isCustomProp ) { 6847 style.setProperty( name, value ); 6848 } else { 6849 style[ name ] = value; 6850 } 6851 } 6852 6853 } else { 6854 6855 // If a hook was provided get the non-computed value from there 6856 if ( hooks && "get" in hooks && 6857 ( ret = hooks.get( elem, false, extra ) ) !== undefined ) { 6858 6859 return ret; 6860 } 6861 6862 // Otherwise just get the value from the style object 6863 return style[ name ]; 6864 } 6865 }, 6866 6867 css: function( elem, name, extra, styles ) { 6868 var val, num, hooks, 6869 origName = camelCase( name ), 6870 isCustomProp = rcustomProp.test( name ); 6871 6872 // Make sure that we're working with the right name. We don't 6873 // want to modify the value if it is a CSS custom property 6874 // since they are user-defined. 6875 if ( !isCustomProp ) { 6876 name = finalPropName( origName ); 6877 } 6878 6879 // Try prefixed name followed by the unprefixed name 6880 hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ]; 6881 6882 // If a hook was provided get the computed value from there 6883 if ( hooks && "get" in hooks ) { 6884 val = hooks.get( elem, true, extra ); 6885 } 6886 6887 // Otherwise, if a way to get the computed value exists, use that 6888 if ( val === undefined ) { 6889 val = curCSS( elem, name, styles ); 6890 } 6891 6892 // Convert "normal" to computed value 6893 if ( val === "normal" && name in cssNormalTransform ) { 6894 val = cssNormalTransform[ name ]; 6895 } 6896 6897 // Make numeric if forced or a qualifier was provided and val looks numeric 6898 if ( extra === "" || extra ) { 6899 num = parseFloat( val ); 6900 return extra === true || isFinite( num ) ? num || 0 : val; 6901 } 6902 6903 return val; 6904 } 6905} ); 6906 6907jQuery.each( [ "height", "width" ], function( _i, dimension ) { 6908 jQuery.cssHooks[ dimension ] = { 6909 get: function( elem, computed, extra ) { 6910 if ( computed ) { 6911 6912 // Certain elements can have dimension info if we invisibly show them 6913 // but it must have a current display style that would benefit 6914 return rdisplayswap.test( jQuery.css( elem, "display" ) ) && 6915 6916 // Support: Safari 8+ 6917 // Table columns in Safari have non-zero offsetWidth & zero 6918 // getBoundingClientRect().width unless display is changed. 6919 // Support: IE <=11 only 6920 // Running getBoundingClientRect on a disconnected node 6921 // in IE throws an error. 6922 ( !elem.getClientRects().length || !elem.getBoundingClientRect().width ) ? 6923 swap( elem, cssShow, function() { 6924 return getWidthOrHeight( elem, dimension, extra ); 6925 } ) : 6926 getWidthOrHeight( elem, dimension, extra ); 6927 } 6928 }, 6929 6930 set: function( elem, value, extra ) { 6931 var matches, 6932 styles = getStyles( elem ), 6933 6934 // Only read styles.position if the test has a chance to fail 6935 // to avoid forcing a reflow. 6936 scrollboxSizeBuggy = !support.scrollboxSize() && 6937 styles.position === "absolute", 6938 6939 // To avoid forcing a reflow, only fetch boxSizing if we need it (gh-3991) 6940 boxSizingNeeded = scrollboxSizeBuggy || extra, 6941 isBorderBox = boxSizingNeeded && 6942 jQuery.css( elem, "boxSizing", false, styles ) === "border-box", 6943 subtract = extra ? 6944 boxModelAdjustment( 6945 elem, 6946 dimension, 6947 extra, 6948 isBorderBox, 6949 styles 6950 ) : 6951 0; 6952 6953 // Account for unreliable border-box dimensions by comparing offset* to computed and 6954 // faking a content-box to get border and padding (gh-3699) 6955 if ( isBorderBox && scrollboxSizeBuggy ) { 6956 subtract -= Math.ceil( 6957 elem[ "offset" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 ) ] - 6958 parseFloat( styles[ dimension ] ) - 6959 boxModelAdjustment( elem, dimension, "border", false, styles ) - 6960 0.5 6961 ); 6962 } 6963 6964 // Convert to pixels if value adjustment is needed 6965 if ( subtract && ( matches = rcssNum.exec( value ) ) && 6966 ( matches[ 3 ] || "px" ) !== "px" ) { 6967 6968 elem.style[ dimension ] = value; 6969 value = jQuery.css( elem, dimension ); 6970 } 6971 6972 return setPositiveNumber( elem, value, subtract ); 6973 } 6974 }; 6975} ); 6976 6977jQuery.cssHooks.marginLeft = addGetHookIf( support.reliableMarginLeft, 6978 function( elem, computed ) { 6979 if ( computed ) { 6980 return ( parseFloat( curCSS( elem, "marginLeft" ) ) || 6981 elem.getBoundingClientRect().left - 6982 swap( elem, { marginLeft: 0 }, function() { 6983 return elem.getBoundingClientRect().left; 6984 } ) 6985 ) + "px"; 6986 } 6987 } 6988); 6989 6990// These hooks are used by animate to expand properties 6991jQuery.each( { 6992 margin: "", 6993 padding: "", 6994 border: "Width" 6995}, function( prefix, suffix ) { 6996 jQuery.cssHooks[ prefix + suffix ] = { 6997 expand: function( value ) { 6998 var i = 0, 6999 expanded = {}, 7000 7001 // Assumes a single number if not a string 7002 parts = typeof value === "string" ? value.split( " " ) : [ value ]; 7003 7004 for ( ; i < 4; i++ ) { 7005 expanded[ prefix + cssExpand[ i ] + suffix ] = 7006 parts[ i ] || parts[ i - 2 ] || parts[ 0 ]; 7007 } 7008 7009 return expanded; 7010 } 7011 }; 7012 7013 if ( prefix !== "margin" ) { 7014 jQuery.cssHooks[ prefix + suffix ].set = setPositiveNumber; 7015 } 7016} ); 7017 7018jQuery.fn.extend( { 7019 css: function( name, value ) { 7020 return access( this, function( elem, name, value ) { 7021 var styles, len, 7022 map = {}, 7023 i = 0; 7024 7025 if ( Array.isArray( name ) ) { 7026 styles = getStyles( elem ); 7027 len = name.length; 7028 7029 for ( ; i < len; i++ ) { 7030 map[ name[ i ] ] = jQuery.css( elem, name[ i ], false, styles ); 7031 } 7032 7033 return map; 7034 } 7035 7036 return value !== undefined ? 7037 jQuery.style( elem, name, value ) : 7038 jQuery.css( elem, name ); 7039 }, name, value, arguments.length > 1 ); 7040 } 7041} ); 7042 7043 7044function Tween( elem, options, prop, end, easing ) { 7045 return new Tween.prototype.init( elem, options, prop, end, easing ); 7046} 7047jQuery.Tween = Tween; 7048 7049Tween.prototype = { 7050 constructor: Tween, 7051 init: function( elem, options, prop, end, easing, unit ) { 7052 this.elem = elem; 7053 this.prop = prop; 7054 this.easing = easing || jQuery.easing._default; 7055 this.options = options; 7056 this.start = this.now = this.cur(); 7057 this.end = end; 7058 this.unit = unit || ( jQuery.cssNumber[ prop ] ? "" : "px" ); 7059 }, 7060 cur: function() { 7061 var hooks = Tween.propHooks[ this.prop ]; 7062 7063 return hooks && hooks.get ? 7064 hooks.get( this ) : 7065 Tween.propHooks._default.get( this ); 7066 }, 7067 run: function( percent ) { 7068 var eased, 7069 hooks = Tween.propHooks[ this.prop ]; 7070 7071 if ( this.options.duration ) { 7072 this.pos = eased = jQuery.easing[ this.easing ]( 7073 percent, this.options.duration * percent, 0, 1, this.options.duration 7074 ); 7075 } else { 7076 this.pos = eased = percent; 7077 } 7078 this.now = ( this.end - this.start ) * eased + this.start; 7079 7080 if ( this.options.step ) { 7081 this.options.step.call( this.elem, this.now, this ); 7082 } 7083 7084 if ( hooks && hooks.set ) { 7085 hooks.set( this ); 7086 } else { 7087 Tween.propHooks._default.set( this ); 7088 } 7089 return this; 7090 } 7091}; 7092 7093Tween.prototype.init.prototype = Tween.prototype; 7094 7095Tween.propHooks = { 7096 _default: { 7097 get: function( tween ) { 7098 var result; 7099 7100 // Use a property on the element directly when it is not a DOM element, 7101 // or when there is no matching style property that exists. 7102 if ( tween.elem.nodeType !== 1 || 7103 tween.elem[ tween.prop ] != null && tween.elem.style[ tween.prop ] == null ) { 7104 return tween.elem[ tween.prop ]; 7105 } 7106 7107 // Passing an empty string as a 3rd parameter to .css will automatically 7108 // attempt a parseFloat and fallback to a string if the parse fails. 7109 // Simple values such as "10px" are parsed to Float; 7110 // complex values such as "rotate(1rad)" are returned as-is. 7111 result = jQuery.css( tween.elem, tween.prop, "" ); 7112 7113 // Empty strings, null, undefined and "auto" are converted to 0. 7114 return !result || result === "auto" ? 0 : result; 7115 }, 7116 set: function( tween ) { 7117 7118 // Use step hook for back compat. 7119 // Use cssHook if its there. 7120 // Use .style if available and use plain properties where available. 7121 if ( jQuery.fx.step[ tween.prop ] ) { 7122 jQuery.fx.step[ tween.prop ]( tween ); 7123 } else if ( tween.elem.nodeType === 1 && ( 7124 jQuery.cssHooks[ tween.prop ] || 7125 tween.elem.style[ finalPropName( tween.prop ) ] != null ) ) { 7126 jQuery.style( tween.elem, tween.prop, tween.now + tween.unit ); 7127 } else { 7128 tween.elem[ tween.prop ] = tween.now; 7129 } 7130 } 7131 } 7132}; 7133 7134// Support: IE <=9 only 7135// Panic based approach to setting things on disconnected nodes 7136Tween.propHooks.scrollTop = Tween.propHooks.scrollLeft = { 7137 set: function( tween ) { 7138 if ( tween.elem.nodeType && tween.elem.parentNode ) { 7139 tween.elem[ tween.prop ] = tween.now; 7140 } 7141 } 7142}; 7143 7144jQuery.easing = { 7145 linear: function( p ) { 7146 return p; 7147 }, 7148 swing: function( p ) { 7149 return 0.5 - Math.cos( p * Math.PI ) / 2; 7150 }, 7151 _default: "swing" 7152}; 7153 7154jQuery.fx = Tween.prototype.init; 7155 7156// Back compat <1.8 extension point 7157jQuery.fx.step = {}; 7158 7159 7160 7161 7162var 7163 fxNow, inProgress, 7164 rfxtypes = /^(?:toggle|show|hide)$/, 7165 rrun = /queueHooks$/; 7166 7167function schedule() { 7168 if ( inProgress ) { 7169 if ( document.hidden === false && window.requestAnimationFrame ) { 7170 window.requestAnimationFrame( schedule ); 7171 } else { 7172 window.setTimeout( schedule, jQuery.fx.interval ); 7173 } 7174 7175 jQuery.fx.tick(); 7176 } 7177} 7178 7179// Animations created synchronously will run synchronously 7180function createFxNow() { 7181 window.setTimeout( function() { 7182 fxNow = undefined; 7183 } ); 7184 return ( fxNow = Date.now() ); 7185} 7186 7187// Generate parameters to create a standard animation 7188function genFx( type, includeWidth ) { 7189 var which, 7190 i = 0, 7191 attrs = { height: type }; 7192 7193 // If we include width, step value is 1 to do all cssExpand values, 7194 // otherwise step value is 2 to skip over Left and Right 7195 includeWidth = includeWidth ? 1 : 0; 7196 for ( ; i < 4; i += 2 - includeWidth ) { 7197 which = cssExpand[ i ]; 7198 attrs[ "margin" + which ] = attrs[ "padding" + which ] = type; 7199 } 7200 7201 if ( includeWidth ) { 7202 attrs.opacity = attrs.width = type; 7203 } 7204 7205 return attrs; 7206} 7207 7208function createTween( value, prop, animation ) { 7209 var tween, 7210 collection = ( Animation.tweeners[ prop ] || [] ).concat( Animation.tweeners[ "*" ] ), 7211 index = 0, 7212 length = collection.length; 7213 for ( ; index < length; index++ ) { 7214 if ( ( tween = collection[ index ].call( animation, prop, value ) ) ) { 7215 7216 // We're done with this property 7217 return tween; 7218 } 7219 } 7220} 7221 7222function defaultPrefilter( elem, props, opts ) { 7223 var prop, value, toggle, hooks, oldfire, propTween, restoreDisplay, display, 7224 isBox = "width" in props || "height" in props, 7225 anim = this, 7226 orig = {}, 7227 style = elem.style, 7228 hidden = elem.nodeType && isHiddenWithinTree( elem ), 7229 dataShow = dataPriv.get( elem, "fxshow" ); 7230 7231 // Queue-skipping animations hijack the fx hooks 7232 if ( !opts.queue ) { 7233 hooks = jQuery._queueHooks( elem, "fx" ); 7234 if ( hooks.unqueued == null ) { 7235 hooks.unqueued = 0; 7236 oldfire = hooks.empty.fire; 7237 hooks.empty.fire = function() { 7238 if ( !hooks.unqueued ) { 7239 oldfire(); 7240 } 7241 }; 7242 } 7243 hooks.unqueued++; 7244 7245 anim.always( function() { 7246 7247 // Ensure the complete handler is called before this completes 7248 anim.always( function() { 7249 hooks.unqueued--; 7250 if ( !jQuery.queue( elem, "fx" ).length ) { 7251 hooks.empty.fire(); 7252 } 7253 } ); 7254 } ); 7255 } 7256 7257 // Detect show/hide animations 7258 for ( prop in props ) { 7259 value = props[ prop ]; 7260 if ( rfxtypes.test( value ) ) { 7261 delete props[ prop ]; 7262 toggle = toggle || value === "toggle"; 7263 if ( value === ( hidden ? "hide" : "show" ) ) { 7264 7265 // Pretend to be hidden if this is a "show" and 7266 // there is still data from a stopped show/hide 7267 if ( value === "show" && dataShow && dataShow[ prop ] !== undefined ) { 7268 hidden = true; 7269 7270 // Ignore all other no-op show/hide data 7271 } else { 7272 continue; 7273 } 7274 } 7275 orig[ prop ] = dataShow && dataShow[ prop ] || jQuery.style( elem, prop ); 7276 } 7277 } 7278 7279 // Bail out if this is a no-op like .hide().hide() 7280 propTween = !jQuery.isEmptyObject( props ); 7281 if ( !propTween && jQuery.isEmptyObject( orig ) ) { 7282 return; 7283 } 7284 7285 // Restrict "overflow" and "display" styles during box animations 7286 if ( isBox && elem.nodeType === 1 ) { 7287 7288 // Support: IE <=9 - 11, Edge 12 - 15 7289 // Record all 3 overflow attributes because IE does not infer the shorthand 7290 // from identically-valued overflowX and overflowY and Edge just mirrors 7291 // the overflowX value there. 7292 opts.overflow = [ style.overflow, style.overflowX, style.overflowY ]; 7293 7294 // Identify a display type, preferring old show/hide data over the CSS cascade 7295 restoreDisplay = dataShow && dataShow.display; 7296 if ( restoreDisplay == null ) { 7297 restoreDisplay = dataPriv.get( elem, "display" ); 7298 } 7299 display = jQuery.css( elem, "display" ); 7300 if ( display === "none" ) { 7301 if ( restoreDisplay ) { 7302 display = restoreDisplay; 7303 } else { 7304 7305 // Get nonempty value(s) by temporarily forcing visibility 7306 showHide( [ elem ], true ); 7307 restoreDisplay = elem.style.display || restoreDisplay; 7308 display = jQuery.css( elem, "display" ); 7309 showHide( [ elem ] ); 7310 } 7311 } 7312 7313 // Animate inline elements as inline-block 7314 if ( display === "inline" || display === "inline-block" && restoreDisplay != null ) { 7315 if ( jQuery.css( elem, "float" ) === "none" ) { 7316 7317 // Restore the original display value at the end of pure show/hide animations 7318 if ( !propTween ) { 7319 anim.done( function() { 7320 style.display = restoreDisplay; 7321 } ); 7322 if ( restoreDisplay == null ) { 7323 display = style.display; 7324 restoreDisplay = display === "none" ? "" : display; 7325 } 7326 } 7327 style.display = "inline-block"; 7328 } 7329 } 7330 } 7331 7332 if ( opts.overflow ) { 7333 style.overflow = "hidden"; 7334 anim.always( function() { 7335 style.overflow = opts.overflow[ 0 ]; 7336 style.overflowX = opts.overflow[ 1 ]; 7337 style.overflowY = opts.overflow[ 2 ]; 7338 } ); 7339 } 7340 7341 // Implement show/hide animations 7342 propTween = false; 7343 for ( prop in orig ) { 7344 7345 // General show/hide setup for this element animation 7346 if ( !propTween ) { 7347 if ( dataShow ) { 7348 if ( "hidden" in dataShow ) { 7349 hidden = dataShow.hidden; 7350 } 7351 } else { 7352 dataShow = dataPriv.access( elem, "fxshow", { display: restoreDisplay } ); 7353 } 7354 7355 // Store hidden/visible for toggle so `.stop().toggle()` "reverses" 7356 if ( toggle ) { 7357 dataShow.hidden = !hidden; 7358 } 7359 7360 // Show elements before animating them 7361 if ( hidden ) { 7362 showHide( [ elem ], true ); 7363 } 7364 7365 /* eslint-disable no-loop-func */ 7366 7367 anim.done( function() { 7368 7369 /* eslint-enable no-loop-func */ 7370 7371 // The final step of a "hide" animation is actually hiding the element 7372 if ( !hidden ) { 7373 showHide( [ elem ] ); 7374 } 7375 dataPriv.remove( elem, "fxshow" ); 7376 for ( prop in orig ) { 7377 jQuery.style( elem, prop, orig[ prop ] ); 7378 } 7379 } ); 7380 } 7381 7382 // Per-property setup 7383 propTween = createTween( hidden ? dataShow[ prop ] : 0, prop, anim ); 7384 if ( !( prop in dataShow ) ) { 7385 dataShow[ prop ] = propTween.start; 7386 if ( hidden ) { 7387 propTween.end = propTween.start; 7388 propTween.start = 0; 7389 } 7390 } 7391 } 7392} 7393 7394function propFilter( props, specialEasing ) { 7395 var index, name, easing, value, hooks; 7396 7397 // camelCase, specialEasing and expand cssHook pass 7398 for ( index in props ) { 7399 name = camelCase( index ); 7400 easing = specialEasing[ name ]; 7401 value = props[ index ]; 7402 if ( Array.isArray( value ) ) { 7403 easing = value[ 1 ]; 7404 value = props[ index ] = value[ 0 ]; 7405 } 7406 7407 if ( index !== name ) { 7408 props[ name ] = value; 7409 delete props[ index ]; 7410 } 7411 7412 hooks = jQuery.cssHooks[ name ]; 7413 if ( hooks && "expand" in hooks ) { 7414 value = hooks.expand( value ); 7415 delete props[ name ]; 7416 7417 // Not quite $.extend, this won't overwrite existing keys. 7418 // Reusing 'index' because we have the correct "name" 7419 for ( index in value ) { 7420 if ( !( index in props ) ) { 7421 props[ index ] = value[ index ]; 7422 specialEasing[ index ] = easing; 7423 } 7424 } 7425 } else { 7426 specialEasing[ name ] = easing; 7427 } 7428 } 7429} 7430 7431function Animation( elem, properties, options ) { 7432 var result, 7433 stopped, 7434 index = 0, 7435 length = Animation.prefilters.length, 7436 deferred = jQuery.Deferred().always( function() { 7437 7438 // Don't match elem in the :animated selector 7439 delete tick.elem; 7440 } ), 7441 tick = function() { 7442 if ( stopped ) { 7443 return false; 7444 } 7445 var currentTime = fxNow || createFxNow(), 7446 remaining = Math.max( 0, animation.startTime + animation.duration - currentTime ), 7447 7448 // Support: Android 2.3 only 7449 // Archaic crash bug won't allow us to use `1 - ( 0.5 || 0 )` (trac-12497) 7450 temp = remaining / animation.duration || 0, 7451 percent = 1 - temp, 7452 index = 0, 7453 length = animation.tweens.length; 7454 7455 for ( ; index < length; index++ ) { 7456 animation.tweens[ index ].run( percent ); 7457 } 7458 7459 deferred.notifyWith( elem, [ animation, percent, remaining ] ); 7460 7461 // If there's more to do, yield 7462 if ( percent < 1 && length ) { 7463 return remaining; 7464 } 7465 7466 // If this was an empty animation, synthesize a final progress notification 7467 if ( !length ) { 7468 deferred.notifyWith( elem, [ animation, 1, 0 ] ); 7469 } 7470 7471 // Resolve the animation and report its conclusion 7472 deferred.resolveWith( elem, [ animation ] ); 7473 return false; 7474 }, 7475 animation = deferred.promise( { 7476 elem: elem, 7477 props: jQuery.extend( {}, properties ), 7478 opts: jQuery.extend( true, { 7479 specialEasing: {}, 7480 easing: jQuery.easing._default 7481 }, options ), 7482 originalProperties: properties, 7483 originalOptions: options, 7484 startTime: fxNow || createFxNow(), 7485 duration: options.duration, 7486 tweens: [], 7487 createTween: function( prop, end ) { 7488 var tween = jQuery.Tween( elem, animation.opts, prop, end, 7489 animation.opts.specialEasing[ prop ] || animation.opts.easing ); 7490 animation.tweens.push( tween ); 7491 return tween; 7492 }, 7493 stop: function( gotoEnd ) { 7494 var index = 0, 7495 7496 // If we are going to the end, we want to run all the tweens 7497 // otherwise we skip this part 7498 length = gotoEnd ? animation.tweens.length : 0; 7499 if ( stopped ) { 7500 return this; 7501 } 7502 stopped = true; 7503 for ( ; index < length; index++ ) { 7504 animation.tweens[ index ].run( 1 ); 7505 } 7506 7507 // Resolve when we played the last frame; otherwise, reject 7508 if ( gotoEnd ) { 7509 deferred.notifyWith( elem, [ animation, 1, 0 ] ); 7510 deferred.resolveWith( elem, [ animation, gotoEnd ] ); 7511 } else { 7512 deferred.rejectWith( elem, [ animation, gotoEnd ] ); 7513 } 7514 return this; 7515 } 7516 } ), 7517 props = animation.props; 7518 7519 propFilter( props, animation.opts.specialEasing ); 7520 7521 for ( ; index < length; index++ ) { 7522 result = Animation.prefilters[ index ].call( animation, elem, props, animation.opts ); 7523 if ( result ) { 7524 if ( isFunction( result.stop ) ) { 7525 jQuery._queueHooks( animation.elem, animation.opts.queue ).stop = 7526 result.stop.bind( result ); 7527 } 7528 return result; 7529 } 7530 } 7531 7532 jQuery.map( props, createTween, animation ); 7533 7534 if ( isFunction( animation.opts.start ) ) { 7535 animation.opts.start.call( elem, animation ); 7536 } 7537 7538 // Attach callbacks from options 7539 animation 7540 .progress( animation.opts.progress ) 7541 .done( animation.opts.done, animation.opts.complete ) 7542 .fail( animation.opts.fail ) 7543 .always( animation.opts.always ); 7544 7545 jQuery.fx.timer( 7546 jQuery.extend( tick, { 7547 elem: elem, 7548 anim: animation, 7549 queue: animation.opts.queue 7550 } ) 7551 ); 7552 7553 return animation; 7554} 7555 7556jQuery.Animation = jQuery.extend( Animation, { 7557 7558 tweeners: { 7559 "*": [ function( prop, value ) { 7560 var tween = this.createTween( prop, value ); 7561 adjustCSS( tween.elem, prop, rcssNum.exec( value ), tween ); 7562 return tween; 7563 } ] 7564 }, 7565 7566 tweener: function( props, callback ) { 7567 if ( isFunction( props ) ) { 7568 callback = props; 7569 props = [ "*" ]; 7570 } else { 7571 props = props.match( rnothtmlwhite ); 7572 } 7573 7574 var prop, 7575 index = 0, 7576 length = props.length; 7577 7578 for ( ; index < length; index++ ) { 7579 prop = props[ index ]; 7580 Animation.tweeners[ prop ] = Animation.tweeners[ prop ] || []; 7581 Animation.tweeners[ prop ].unshift( callback ); 7582 } 7583 }, 7584 7585 prefilters: [ defaultPrefilter ], 7586 7587 prefilter: function( callback, prepend ) { 7588 if ( prepend ) { 7589 Animation.prefilters.unshift( callback ); 7590 } else { 7591 Animation.prefilters.push( callback ); 7592 } 7593 } 7594} ); 7595 7596jQuery.speed = function( speed, easing, fn ) { 7597 var opt = speed && typeof speed === "object" ? jQuery.extend( {}, speed ) : { 7598 complete: fn || !fn && easing || 7599 isFunction( speed ) && speed, 7600 duration: speed, 7601 easing: fn && easing || easing && !isFunction( easing ) && easing 7602 }; 7603 7604 // Go to the end state if fx are off 7605 if ( jQuery.fx.off ) { 7606 opt.duration = 0; 7607 7608 } else { 7609 if ( typeof opt.duration !== "number" ) { 7610 if ( opt.duration in jQuery.fx.speeds ) { 7611 opt.duration = jQuery.fx.speeds[ opt.duration ]; 7612 7613 } else { 7614 opt.duration = jQuery.fx.speeds._default; 7615 } 7616 } 7617 } 7618 7619 // Normalize opt.queue - true/undefined/null -> "fx" 7620 if ( opt.queue == null || opt.queue === true ) { 7621 opt.queue = "fx"; 7622 } 7623 7624 // Queueing 7625 opt.old = opt.complete; 7626 7627 opt.complete = function() { 7628 if ( isFunction( opt.old ) ) { 7629 opt.old.call( this ); 7630 } 7631 7632 if ( opt.queue ) { 7633 jQuery.dequeue( this, opt.queue ); 7634 } 7635 }; 7636 7637 return opt; 7638}; 7639 7640jQuery.fn.extend( { 7641 fadeTo: function( speed, to, easing, callback ) { 7642 7643 // Show any hidden elements after setting opacity to 0 7644 return this.filter( isHiddenWithinTree ).css( "opacity", 0 ).show() 7645 7646 // Animate to the value specified 7647 .end().animate( { opacity: to }, speed, easing, callback ); 7648 }, 7649 animate: function( prop, speed, easing, callback ) { 7650 var empty = jQuery.isEmptyObject( prop ), 7651 optall = jQuery.speed( speed, easing, callback ), 7652 doAnimation = function() { 7653 7654 // Operate on a copy of prop so per-property easing won't be lost 7655 var anim = Animation( this, jQuery.extend( {}, prop ), optall ); 7656 7657 // Empty animations, or finishing resolves immediately 7658 if ( empty || dataPriv.get( this, "finish" ) ) { 7659 anim.stop( true ); 7660 } 7661 }; 7662 7663 doAnimation.finish = doAnimation; 7664 7665 return empty || optall.queue === false ? 7666 this.each( doAnimation ) : 7667 this.queue( optall.queue, doAnimation ); 7668 }, 7669 stop: function( type, clearQueue, gotoEnd ) { 7670 var stopQueue = function( hooks ) { 7671 var stop = hooks.stop; 7672 delete hooks.stop; 7673 stop( gotoEnd ); 7674 }; 7675 7676 if ( typeof type !== "string" ) { 7677 gotoEnd = clearQueue; 7678 clearQueue = type; 7679 type = undefined; 7680 } 7681 if ( clearQueue ) { 7682 this.queue( type || "fx", [] ); 7683 } 7684 7685 return this.each( function() { 7686 var dequeue = true, 7687 index = type != null && type + "queueHooks", 7688 timers = jQuery.timers, 7689 data = dataPriv.get( this ); 7690 7691 if ( index ) { 7692 if ( data[ index ] && data[ index ].stop ) { 7693 stopQueue( data[ index ] ); 7694 } 7695 } else { 7696 for ( index in data ) { 7697 if ( data[ index ] && data[ index ].stop && rrun.test( index ) ) { 7698 stopQueue( data[ index ] ); 7699 } 7700 } 7701 } 7702 7703 for ( index = timers.length; index--; ) { 7704 if ( timers[ index ].elem === this && 7705 ( type == null || timers[ index ].queue === type ) ) { 7706 7707 timers[ index ].anim.stop( gotoEnd ); 7708 dequeue = false; 7709 timers.splice( index, 1 ); 7710 } 7711 } 7712 7713 // Start the next in the queue if the last step wasn't forced. 7714 // Timers currently will call their complete callbacks, which 7715 // will dequeue but only if they were gotoEnd. 7716 if ( dequeue || !gotoEnd ) { 7717 jQuery.dequeue( this, type ); 7718 } 7719 } ); 7720 }, 7721 finish: function( type ) { 7722 if ( type !== false ) { 7723 type = type || "fx"; 7724 } 7725 return this.each( function() { 7726 var index, 7727 data = dataPriv.get( this ), 7728 queue = data[ type + "queue" ], 7729 hooks = data[ type + "queueHooks" ], 7730 timers = jQuery.timers, 7731 length = queue ? queue.length : 0; 7732 7733 // Enable finishing flag on private data 7734 data.finish = true; 7735 7736 // Empty the queue first 7737 jQuery.queue( this, type, [] ); 7738 7739 if ( hooks && hooks.stop ) { 7740 hooks.stop.call( this, true ); 7741 } 7742 7743 // Look for any active animations, and finish them 7744 for ( index = timers.length; index--; ) { 7745 if ( timers[ index ].elem === this && timers[ index ].queue === type ) { 7746 timers[ index ].anim.stop( true ); 7747 timers.splice( index, 1 ); 7748 } 7749 } 7750 7751 // Look for any animations in the old queue and finish them 7752 for ( index = 0; index < length; index++ ) { 7753 if ( queue[ index ] && queue[ index ].finish ) { 7754 queue[ index ].finish.call( this ); 7755 } 7756 } 7757 7758 // Turn off finishing flag 7759 delete data.finish; 7760 } ); 7761 } 7762} ); 7763 7764jQuery.each( [ "toggle", "show", "hide" ], function( _i, name ) { 7765 var cssFn = jQuery.fn[ name ]; 7766 jQuery.fn[ name ] = function( speed, easing, callback ) { 7767 return speed == null || typeof speed === "boolean" ? 7768 cssFn.apply( this, arguments ) : 7769 this.animate( genFx( name, true ), speed, easing, callback ); 7770 }; 7771} ); 7772 7773// Generate shortcuts for custom animations 7774jQuery.each( { 7775 slideDown: genFx( "show" ), 7776 slideUp: genFx( "hide" ), 7777 slideToggle: genFx( "toggle" ), 7778 fadeIn: { opacity: "show" }, 7779 fadeOut: { opacity: "hide" }, 7780 fadeToggle: { opacity: "toggle" } 7781}, function( name, props ) { 7782 jQuery.fn[ name ] = function( speed, easing, callback ) { 7783 return this.animate( props, speed, easing, callback ); 7784 }; 7785} ); 7786 7787jQuery.timers = []; 7788jQuery.fx.tick = function() { 7789 var timer, 7790 i = 0, 7791 timers = jQuery.timers; 7792 7793 fxNow = Date.now(); 7794 7795 for ( ; i < timers.length; i++ ) { 7796 timer = timers[ i ]; 7797 7798 // Run the timer and safely remove it when done (allowing for external removal) 7799 if ( !timer() && timers[ i ] === timer ) { 7800 timers.splice( i--, 1 ); 7801 } 7802 } 7803 7804 if ( !timers.length ) { 7805 jQuery.fx.stop(); 7806 } 7807 fxNow = undefined; 7808}; 7809 7810jQuery.fx.timer = function( timer ) { 7811 jQuery.timers.push( timer ); 7812 jQuery.fx.start(); 7813}; 7814 7815jQuery.fx.interval = 13; 7816jQuery.fx.start = function() { 7817 if ( inProgress ) { 7818 return; 7819 } 7820 7821 inProgress = true; 7822 schedule(); 7823}; 7824 7825jQuery.fx.stop = function() { 7826 inProgress = null; 7827}; 7828 7829jQuery.fx.speeds = { 7830 slow: 600, 7831 fast: 200, 7832 7833 // Default speed 7834 _default: 400 7835}; 7836 7837 7838// Based off of the plugin by Clint Helfers, with permission. 7839jQuery.fn.delay = function( time, type ) { 7840 time = jQuery.fx ? jQuery.fx.speeds[ time ] || time : time; 7841 type = type || "fx"; 7842 7843 return this.queue( type, function( next, hooks ) { 7844 var timeout = window.setTimeout( next, time ); 7845 hooks.stop = function() { 7846 window.clearTimeout( timeout ); 7847 }; 7848 } ); 7849}; 7850 7851 7852( function() { 7853 var input = document.createElement( "input" ), 7854 select = document.createElement( "select" ), 7855 opt = select.appendChild( document.createElement( "option" ) ); 7856 7857 input.type = "checkbox"; 7858 7859 // Support: Android <=4.3 only 7860 // Default value for a checkbox should be "on" 7861 support.checkOn = input.value !== ""; 7862 7863 // Support: IE <=11 only 7864 // Must access selectedIndex to make default options select 7865 support.optSelected = opt.selected; 7866 7867 // Support: IE <=11 only 7868 // An input loses its value after becoming a radio 7869 input = document.createElement( "input" ); 7870 input.value = "t"; 7871 input.type = "radio"; 7872 support.radioValue = input.value === "t"; 7873} )(); 7874 7875 7876var boolHook, 7877 attrHandle = jQuery.expr.attrHandle; 7878 7879jQuery.fn.extend( { 7880 attr: function( name, value ) { 7881 return access( this, jQuery.attr, name, value, arguments.length > 1 ); 7882 }, 7883 7884 removeAttr: function( name ) { 7885 return this.each( function() { 7886 jQuery.removeAttr( this, name ); 7887 } ); 7888 } 7889} ); 7890 7891jQuery.extend( { 7892 attr: function( elem, name, value ) { 7893 var ret, hooks, 7894 nType = elem.nodeType; 7895 7896 // Don't get/set attributes on text, comment and attribute nodes 7897 if ( nType === 3 || nType === 8 || nType === 2 ) { 7898 return; 7899 } 7900 7901 // Fallback to prop when attributes are not supported 7902 if ( typeof elem.getAttribute === "undefined" ) { 7903 return jQuery.prop( elem, name, value ); 7904 } 7905 7906 // Attribute hooks are determined by the lowercase version 7907 // Grab necessary hook if one is defined 7908 if ( nType !== 1 || !jQuery.isXMLDoc( elem ) ) { 7909 hooks = jQuery.attrHooks[ name.toLowerCase() ] || 7910 ( jQuery.expr.match.bool.test( name ) ? boolHook : undefined ); 7911 } 7912 7913 if ( value !== undefined ) { 7914 if ( value === null ) { 7915 jQuery.removeAttr( elem, name ); 7916 return; 7917 } 7918 7919 if ( hooks && "set" in hooks && 7920 ( ret = hooks.set( elem, value, name ) ) !== undefined ) { 7921 return ret; 7922 } 7923 7924 elem.setAttribute( name, value + "" ); 7925 return value; 7926 } 7927 7928 if ( hooks && "get" in hooks && ( ret = hooks.get( elem, name ) ) !== null ) { 7929 return ret; 7930 } 7931 7932 ret = jQuery.find.attr( elem, name ); 7933 7934 // Non-existent attributes return null, we normalize to undefined 7935 return ret == null ? undefined : ret; 7936 }, 7937 7938 attrHooks: { 7939 type: { 7940 set: function( elem, value ) { 7941 if ( !support.radioValue && value === "radio" && 7942 nodeName( elem, "input" ) ) { 7943 var val = elem.value; 7944 elem.setAttribute( "type", value ); 7945 if ( val ) { 7946 elem.value = val; 7947 } 7948 return value; 7949 } 7950 } 7951 } 7952 }, 7953 7954 removeAttr: function( elem, value ) { 7955 var name, 7956 i = 0, 7957 7958 // Attribute names can contain non-HTML whitespace characters 7959 // https://html.spec.whatwg.org/multipage/syntax.html#attributes-2 7960 attrNames = value && value.match( rnothtmlwhite ); 7961 7962 if ( attrNames && elem.nodeType === 1 ) { 7963 while ( ( name = attrNames[ i++ ] ) ) { 7964 elem.removeAttribute( name ); 7965 } 7966 } 7967 } 7968} ); 7969 7970// Hooks for boolean attributes 7971boolHook = { 7972 set: function( elem, value, name ) { 7973 if ( value === false ) { 7974 7975 // Remove boolean attributes when set to false 7976 jQuery.removeAttr( elem, name ); 7977 } else { 7978 elem.setAttribute( name, name ); 7979 } 7980 return name; 7981 } 7982}; 7983 7984jQuery.each( jQuery.expr.match.bool.source.match( /\w+/g ), function( _i, name ) { 7985 var getter = attrHandle[ name ] || jQuery.find.attr; 7986 7987 attrHandle[ name ] = function( elem, name, isXML ) { 7988 var ret, handle, 7989 lowercaseName = name.toLowerCase(); 7990 7991 if ( !isXML ) { 7992 7993 // Avoid an infinite loop by temporarily removing this function from the getter 7994 handle = attrHandle[ lowercaseName ]; 7995 attrHandle[ lowercaseName ] = ret; 7996 ret = getter( elem, name, isXML ) != null ? 7997 lowercaseName : 7998 null; 7999 attrHandle[ lowercaseName ] = handle; 8000 } 8001 return ret; 8002 }; 8003} ); 8004 8005 8006 8007 8008var rfocusable = /^(?:input|select|textarea|button)$/i, 8009 rclickable = /^(?:a|area)$/i; 8010 8011jQuery.fn.extend( { 8012 prop: function( name, value ) { 8013 return access( this, jQuery.prop, name, value, arguments.length > 1 ); 8014 }, 8015 8016 removeProp: function( name ) { 8017 return this.each( function() { 8018 delete this[ jQuery.propFix[ name ] || name ]; 8019 } ); 8020 } 8021} ); 8022 8023jQuery.extend( { 8024 prop: function( elem, name, value ) { 8025 var ret, hooks, 8026 nType = elem.nodeType; 8027 8028 // Don't get/set properties on text, comment and attribute nodes 8029 if ( nType === 3 || nType === 8 || nType === 2 ) { 8030 return; 8031 } 8032 8033 if ( nType !== 1 || !jQuery.isXMLDoc( elem ) ) { 8034 8035 // Fix name and attach hooks 8036 name = jQuery.propFix[ name ] || name; 8037 hooks = jQuery.propHooks[ name ]; 8038 } 8039 8040 if ( value !== undefined ) { 8041 if ( hooks && "set" in hooks && 8042 ( ret = hooks.set( elem, value, name ) ) !== undefined ) { 8043 return ret; 8044 } 8045 8046 return ( elem[ name ] = value ); 8047 } 8048 8049 if ( hooks && "get" in hooks && ( ret = hooks.get( elem, name ) ) !== null ) { 8050 return ret; 8051 } 8052 8053 return elem[ name ]; 8054 }, 8055 8056 propHooks: { 8057 tabIndex: { 8058 get: function( elem ) { 8059 8060 // Support: IE <=9 - 11 only 8061 // elem.tabIndex doesn't always return the 8062 // correct value when it hasn't been explicitly set 8063 // Use proper attribute retrieval (trac-12072) 8064 var tabindex = jQuery.find.attr( elem, "tabindex" ); 8065 8066 if ( tabindex ) { 8067 return parseInt( tabindex, 10 ); 8068 } 8069 8070 if ( 8071 rfocusable.test( elem.nodeName ) || 8072 rclickable.test( elem.nodeName ) && 8073 elem.href 8074 ) { 8075 return 0; 8076 } 8077 8078 return -1; 8079 } 8080 } 8081 }, 8082 8083 propFix: { 8084 "for": "htmlFor", 8085 "class": "className" 8086 } 8087} ); 8088 8089// Support: IE <=11 only 8090// Accessing the selectedIndex property 8091// forces the browser to respect setting selected 8092// on the option 8093// The getter ensures a default option is selected 8094// when in an optgroup 8095// eslint rule "no-unused-expressions" is disabled for this code 8096// since it considers such accessions noop 8097if ( !support.optSelected ) { 8098 jQuery.propHooks.selected = { 8099 get: function( elem ) { 8100 8101 /* eslint no-unused-expressions: "off" */ 8102 8103 var parent = elem.parentNode; 8104 if ( parent && parent.parentNode ) { 8105 parent.parentNode.selectedIndex; 8106 } 8107 return null; 8108 }, 8109 set: function( elem ) { 8110 8111 /* eslint no-unused-expressions: "off" */ 8112 8113 var parent = elem.parentNode; 8114 if ( parent ) { 8115 parent.selectedIndex; 8116 8117 if ( parent.parentNode ) { 8118 parent.parentNode.selectedIndex; 8119 } 8120 } 8121 } 8122 }; 8123} 8124 8125jQuery.each( [ 8126 "tabIndex", 8127 "readOnly", 8128 "maxLength", 8129 "cellSpacing", 8130 "cellPadding", 8131 "rowSpan", 8132 "colSpan", 8133 "useMap", 8134 "frameBorder", 8135 "contentEditable" 8136], function() { 8137 jQuery.propFix[ this.toLowerCase() ] = this; 8138} ); 8139 8140 8141 8142 8143 // Strip and collapse whitespace according to HTML spec 8144 // https://infra.spec.whatwg.org/#strip-and-collapse-ascii-whitespace 8145 function stripAndCollapse( value ) { 8146 var tokens = value.match( rnothtmlwhite ) || []; 8147 return tokens.join( " " ); 8148 } 8149 8150 8151function getClass( elem ) { 8152 return elem.getAttribute && elem.getAttribute( "class" ) || ""; 8153} 8154 8155function classesToArray( value ) { 8156 if ( Array.isArray( value ) ) { 8157 return value; 8158 } 8159 if ( typeof value === "string" ) { 8160 return value.match( rnothtmlwhite ) || []; 8161 } 8162 return []; 8163} 8164 8165jQuery.fn.extend( { 8166 addClass: function( value ) { 8167 var classNames, cur, curValue, className, i, finalValue; 8168 8169 if ( isFunction( value ) ) { 8170 return this.each( function( j ) { 8171 jQuery( this ).addClass( value.call( this, j, getClass( this ) ) ); 8172 } ); 8173 } 8174 8175 classNames = classesToArray( value ); 8176 8177 if ( classNames.length ) { 8178 return this.each( function() { 8179 curValue = getClass( this ); 8180 cur = this.nodeType === 1 && ( " " + stripAndCollapse( curValue ) + " " ); 8181 8182 if ( cur ) { 8183 for ( i = 0; i < classNames.length; i++ ) { 8184 className = classNames[ i ]; 8185 if ( cur.indexOf( " " + className + " " ) < 0 ) { 8186 cur += className + " "; 8187 } 8188 } 8189 8190 // Only assign if different to avoid unneeded rendering. 8191 finalValue = stripAndCollapse( cur ); 8192 if ( curValue !== finalValue ) { 8193 this.setAttribute( "class", finalValue ); 8194 } 8195 } 8196 } ); 8197 } 8198 8199 return this; 8200 }, 8201 8202 removeClass: function( value ) { 8203 var classNames, cur, curValue, className, i, finalValue; 8204 8205 if ( isFunction( value ) ) { 8206 return this.each( function( j ) { 8207 jQuery( this ).removeClass( value.call( this, j, getClass( this ) ) ); 8208 } ); 8209 } 8210 8211 if ( !arguments.length ) { 8212 return this.attr( "class", "" ); 8213 } 8214 8215 classNames = classesToArray( value ); 8216 8217 if ( classNames.length ) { 8218 return this.each( function() { 8219 curValue = getClass( this ); 8220 8221 // This expression is here for better compressibility (see addClass) 8222 cur = this.nodeType === 1 && ( " " + stripAndCollapse( curValue ) + " " ); 8223 8224 if ( cur ) { 8225 for ( i = 0; i < classNames.length; i++ ) { 8226 className = classNames[ i ]; 8227 8228 // Remove *all* instances 8229 while ( cur.indexOf( " " + className + " " ) > -1 ) { 8230 cur = cur.replace( " " + className + " ", " " ); 8231 } 8232 } 8233 8234 // Only assign if different to avoid unneeded rendering. 8235 finalValue = stripAndCollapse( cur ); 8236 if ( curValue !== finalValue ) { 8237 this.setAttribute( "class", finalValue ); 8238 } 8239 } 8240 } ); 8241 } 8242 8243 return this; 8244 }, 8245 8246 toggleClass: function( value, stateVal ) { 8247 var classNames, className, i, self, 8248 type = typeof value, 8249 isValidValue = type === "string" || Array.isArray( value ); 8250 8251 if ( isFunction( value ) ) { 8252 return this.each( function( i ) { 8253 jQuery( this ).toggleClass( 8254 value.call( this, i, getClass( this ), stateVal ), 8255 stateVal 8256 ); 8257 } ); 8258 } 8259 8260 if ( typeof stateVal === "boolean" && isValidValue ) { 8261 return stateVal ? this.addClass( value ) : this.removeClass( value ); 8262 } 8263 8264 classNames = classesToArray( value ); 8265 8266 return this.each( function() { 8267 if ( isValidValue ) { 8268 8269 // Toggle individual class names 8270 self = jQuery( this ); 8271 8272 for ( i = 0; i < classNames.length; i++ ) { 8273 className = classNames[ i ]; 8274 8275 // Check each className given, space separated list 8276 if ( self.hasClass( className ) ) { 8277 self.removeClass( className ); 8278 } else { 8279 self.addClass( className ); 8280 } 8281 } 8282 8283 // Toggle whole class name 8284 } else if ( value === undefined || type === "boolean" ) { 8285 className = getClass( this ); 8286 if ( className ) { 8287 8288 // Store className if set 8289 dataPriv.set( this, "__className__", className ); 8290 } 8291 8292 // If the element has a class name or if we're passed `false`, 8293 // then remove the whole classname (if there was one, the above saved it). 8294 // Otherwise bring back whatever was previously saved (if anything), 8295 // falling back to the empty string if nothing was stored. 8296 if ( this.setAttribute ) { 8297 this.setAttribute( "class", 8298 className || value === false ? 8299 "" : 8300 dataPriv.get( this, "__className__" ) || "" 8301 ); 8302 } 8303 } 8304 } ); 8305 }, 8306 8307 hasClass: function( selector ) { 8308 var className, elem, 8309 i = 0; 8310 8311 className = " " + selector + " "; 8312 while ( ( elem = this[ i++ ] ) ) { 8313 if ( elem.nodeType === 1 && 8314 ( " " + stripAndCollapse( getClass( elem ) ) + " " ).indexOf( className ) > -1 ) { 8315 return true; 8316 } 8317 } 8318 8319 return false; 8320 } 8321} ); 8322 8323 8324 8325 8326var rreturn = /\r/g; 8327 8328jQuery.fn.extend( { 8329 val: function( value ) { 8330 var hooks, ret, valueIsFunction, 8331 elem = this[ 0 ]; 8332 8333 if ( !arguments.length ) { 8334 if ( elem ) { 8335 hooks = jQuery.valHooks[ elem.type ] || 8336 jQuery.valHooks[ elem.nodeName.toLowerCase() ]; 8337 8338 if ( hooks && 8339 "get" in hooks && 8340 ( ret = hooks.get( elem, "value" ) ) !== undefined 8341 ) { 8342 return ret; 8343 } 8344 8345 ret = elem.value; 8346 8347 // Handle most common string cases 8348 if ( typeof ret === "string" ) { 8349 return ret.replace( rreturn, "" ); 8350 } 8351 8352 // Handle cases where value is null/undef or number 8353 return ret == null ? "" : ret; 8354 } 8355 8356 return; 8357 } 8358 8359 valueIsFunction = isFunction( value ); 8360 8361 return this.each( function( i ) { 8362 var val; 8363 8364 if ( this.nodeType !== 1 ) { 8365 return; 8366 } 8367 8368 if ( valueIsFunction ) { 8369 val = value.call( this, i, jQuery( this ).val() ); 8370 } else { 8371 val = value; 8372 } 8373 8374 // Treat null/undefined as ""; convert numbers to string 8375 if ( val == null ) { 8376 val = ""; 8377 8378 } else if ( typeof val === "number" ) { 8379 val += ""; 8380 8381 } else if ( Array.isArray( val ) ) { 8382 val = jQuery.map( val, function( value ) { 8383 return value == null ? "" : value + ""; 8384 } ); 8385 } 8386 8387 hooks = jQuery.valHooks[ this.type ] || jQuery.valHooks[ this.nodeName.toLowerCase() ]; 8388 8389 // If set returns undefined, fall back to normal setting 8390 if ( !hooks || !( "set" in hooks ) || hooks.set( this, val, "value" ) === undefined ) { 8391 this.value = val; 8392 } 8393 } ); 8394 } 8395} ); 8396 8397jQuery.extend( { 8398 valHooks: { 8399 option: { 8400 get: function( elem ) { 8401 8402 var val = jQuery.find.attr( elem, "value" ); 8403 return val != null ? 8404 val : 8405 8406 // Support: IE <=10 - 11 only 8407 // option.text throws exceptions (trac-14686, trac-14858) 8408 // Strip and collapse whitespace 8409 // https://html.spec.whatwg.org/#strip-and-collapse-whitespace 8410 stripAndCollapse( jQuery.text( elem ) ); 8411 } 8412 }, 8413 select: { 8414 get: function( elem ) { 8415 var value, option, i, 8416 options = elem.options, 8417 index = elem.selectedIndex, 8418 one = elem.type === "select-one", 8419 values = one ? null : [], 8420 max = one ? index + 1 : options.length; 8421 8422 if ( index < 0 ) { 8423 i = max; 8424 8425 } else { 8426 i = one ? index : 0; 8427 } 8428 8429 // Loop through all the selected options 8430 for ( ; i < max; i++ ) { 8431 option = options[ i ]; 8432 8433 // Support: IE <=9 only 8434 // IE8-9 doesn't update selected after form reset (trac-2551) 8435 if ( ( option.selected || i === index ) && 8436 8437 // Don't return options that are disabled or in a disabled optgroup 8438 !option.disabled && 8439 ( !option.parentNode.disabled || 8440 !nodeName( option.parentNode, "optgroup" ) ) ) { 8441 8442 // Get the specific value for the option 8443 value = jQuery( option ).val(); 8444 8445 // We don't need an array for one selects 8446 if ( one ) { 8447 return value; 8448 } 8449 8450 // Multi-Selects return an array 8451 values.push( value ); 8452 } 8453 } 8454 8455 return values; 8456 }, 8457 8458 set: function( elem, value ) { 8459 var optionSet, option, 8460 options = elem.options, 8461 values = jQuery.makeArray( value ), 8462 i = options.length; 8463 8464 while ( i-- ) { 8465 option = options[ i ]; 8466 8467 /* eslint-disable no-cond-assign */ 8468 8469 if ( option.selected = 8470 jQuery.inArray( jQuery.valHooks.option.get( option ), values ) > -1 8471 ) { 8472 optionSet = true; 8473 } 8474 8475 /* eslint-enable no-cond-assign */ 8476 } 8477 8478 // Force browsers to behave consistently when non-matching value is set 8479 if ( !optionSet ) { 8480 elem.selectedIndex = -1; 8481 } 8482 return values; 8483 } 8484 } 8485 } 8486} ); 8487 8488// Radios and checkboxes getter/setter 8489jQuery.each( [ "radio", "checkbox" ], function() { 8490 jQuery.valHooks[ this ] = { 8491 set: function( elem, value ) { 8492 if ( Array.isArray( value ) ) { 8493 return ( elem.checked = jQuery.inArray( jQuery( elem ).val(), value ) > -1 ); 8494 } 8495 } 8496 }; 8497 if ( !support.checkOn ) { 8498 jQuery.valHooks[ this ].get = function( elem ) { 8499 return elem.getAttribute( "value" ) === null ? "on" : elem.value; 8500 }; 8501 } 8502} ); 8503 8504 8505 8506 8507// Return jQuery for attributes-only inclusion 8508var location = window.location; 8509 8510var nonce = { guid: Date.now() }; 8511 8512var rquery = ( /\?/ ); 8513 8514 8515 8516// Cross-browser xml parsing 8517jQuery.parseXML = function( data ) { 8518 var xml, parserErrorElem; 8519 if ( !data || typeof data !== "string" ) { 8520 return null; 8521 } 8522 8523 // Support: IE 9 - 11 only 8524 // IE throws on parseFromString with invalid input. 8525 try { 8526 xml = ( new window.DOMParser() ).parseFromString( data, "text/xml" ); 8527 } catch ( e ) {} 8528 8529 parserErrorElem = xml && xml.getElementsByTagName( "parsererror" )[ 0 ]; 8530 if ( !xml || parserErrorElem ) { 8531 jQuery.error( "Invalid XML: " + ( 8532 parserErrorElem ? 8533 jQuery.map( parserErrorElem.childNodes, function( el ) { 8534 return el.textContent; 8535 } ).join( "\n" ) : 8536 data 8537 ) ); 8538 } 8539 return xml; 8540}; 8541 8542 8543var rfocusMorph = /^(?:focusinfocus|focusoutblur)$/, 8544 stopPropagationCallback = function( e ) { 8545 e.stopPropagation(); 8546 }; 8547 8548jQuery.extend( jQuery.event, { 8549 8550 trigger: function( event, data, elem, onlyHandlers ) { 8551 8552 var i, cur, tmp, bubbleType, ontype, handle, special, lastElement, 8553 eventPath = [ elem || document ], 8554 type = hasOwn.call( event, "type" ) ? event.type : event, 8555 namespaces = hasOwn.call( event, "namespace" ) ? event.namespace.split( "." ) : []; 8556 8557 cur = lastElement = tmp = elem = elem || document; 8558 8559 // Don't do events on text and comment nodes 8560 if ( elem.nodeType === 3 || elem.nodeType === 8 ) { 8561 return; 8562 } 8563 8564 // focus/blur morphs to focusin/out; ensure we're not firing them right now 8565 if ( rfocusMorph.test( type + jQuery.event.triggered ) ) { 8566 return; 8567 } 8568 8569 if ( type.indexOf( "." ) > -1 ) { 8570 8571 // Namespaced trigger; create a regexp to match event type in handle() 8572 namespaces = type.split( "." ); 8573 type = namespaces.shift(); 8574 namespaces.sort(); 8575 } 8576 ontype = type.indexOf( ":" ) < 0 && "on" + type; 8577 8578 // Caller can pass in a jQuery.Event object, Object, or just an event type string 8579 event = event[ jQuery.expando ] ? 8580 event : 8581 new jQuery.Event( type, typeof event === "object" && event ); 8582 8583 // Trigger bitmask: & 1 for native handlers; & 2 for jQuery (always true) 8584 event.isTrigger = onlyHandlers ? 2 : 3; 8585 event.namespace = namespaces.join( "." ); 8586 event.rnamespace = event.namespace ? 8587 new RegExp( "(^|\\.)" + namespaces.join( "\\.(?:.*\\.|)" ) + "(\\.|$)" ) : 8588 null; 8589 8590 // Clean up the event in case it is being reused 8591 event.result = undefined; 8592 if ( !event.target ) { 8593 event.target = elem; 8594 } 8595 8596 // Clone any incoming data and prepend the event, creating the handler arg list 8597 data = data == null ? 8598 [ event ] : 8599 jQuery.makeArray( data, [ event ] ); 8600 8601 // Allow special events to draw outside the lines 8602 special = jQuery.event.special[ type ] || {}; 8603 if ( !onlyHandlers && special.trigger && special.trigger.apply( elem, data ) === false ) { 8604 return; 8605 } 8606 8607 // Determine event propagation path in advance, per W3C events spec (trac-9951) 8608 // Bubble up to document, then to window; watch for a global ownerDocument var (trac-9724) 8609 if ( !onlyHandlers && !special.noBubble && !isWindow( elem ) ) { 8610 8611 bubbleType = special.delegateType || type; 8612 if ( !rfocusMorph.test( bubbleType + type ) ) { 8613 cur = cur.parentNode; 8614 } 8615 for ( ; cur; cur = cur.parentNode ) { 8616 eventPath.push( cur ); 8617 tmp = cur; 8618 } 8619 8620 // Only add window if we got to document (e.g., not plain obj or detached DOM) 8621 if ( tmp === ( elem.ownerDocument || document ) ) { 8622 eventPath.push( tmp.defaultView || tmp.parentWindow || window ); 8623 } 8624 } 8625 8626 // Fire handlers on the event path 8627 i = 0; 8628 while ( ( cur = eventPath[ i++ ] ) && !event.isPropagationStopped() ) { 8629 lastElement = cur; 8630 event.type = i > 1 ? 8631 bubbleType : 8632 special.bindType || type; 8633 8634 // jQuery handler 8635 handle = ( dataPriv.get( cur, "events" ) || Object.create( null ) )[ event.type ] && 8636 dataPriv.get( cur, "handle" ); 8637 if ( handle ) { 8638 handle.apply( cur, data ); 8639 } 8640 8641 // Native handler 8642 handle = ontype && cur[ ontype ]; 8643 if ( handle && handle.apply && acceptData( cur ) ) { 8644 event.result = handle.apply( cur, data ); 8645 if ( event.result === false ) { 8646 event.preventDefault(); 8647 } 8648 } 8649 } 8650 event.type = type; 8651 8652 // If nobody prevented the default action, do it now 8653 if ( !onlyHandlers && !event.isDefaultPrevented() ) { 8654 8655 if ( ( !special._default || 8656 special._default.apply( eventPath.pop(), data ) === false ) && 8657 acceptData( elem ) ) { 8658 8659 // Call a native DOM method on the target with the same name as the event. 8660 // Don't do default actions on window, that's where global variables be (trac-6170) 8661 if ( ontype && isFunction( elem[ type ] ) && !isWindow( elem ) ) { 8662 8663 // Don't re-trigger an onFOO event when we call its FOO() method 8664 tmp = elem[ ontype ]; 8665 8666 if ( tmp ) { 8667 elem[ ontype ] = null; 8668 } 8669 8670 // Prevent re-triggering of the same event, since we already bubbled it above 8671 jQuery.event.triggered = type; 8672 8673 if ( event.isPropagationStopped() ) { 8674 lastElement.addEventListener( type, stopPropagationCallback ); 8675 } 8676 8677 elem[ type ](); 8678 8679 if ( event.isPropagationStopped() ) { 8680 lastElement.removeEventListener( type, stopPropagationCallback ); 8681 } 8682 8683 jQuery.event.triggered = undefined; 8684 8685 if ( tmp ) { 8686 elem[ ontype ] = tmp; 8687 } 8688 } 8689 } 8690 } 8691 8692 return event.result; 8693 }, 8694 8695 // Piggyback on a donor event to simulate a different one 8696 // Used only for `focus(in | out)` events 8697 simulate: function( type, elem, event ) { 8698 var e = jQuery.extend( 8699 new jQuery.Event(), 8700 event, 8701 { 8702 type: type, 8703 isSimulated: true 8704 } 8705 ); 8706 8707 jQuery.event.trigger( e, null, elem ); 8708 } 8709 8710} ); 8711 8712jQuery.fn.extend( { 8713 8714 trigger: function( type, data ) { 8715 return this.each( function() { 8716 jQuery.event.trigger( type, data, this ); 8717 } ); 8718 }, 8719 triggerHandler: function( type, data ) { 8720 var elem = this[ 0 ]; 8721 if ( elem ) { 8722 return jQuery.event.trigger( type, data, elem, true ); 8723 } 8724 } 8725} ); 8726 8727 8728var 8729 rbracket = /\[\]$/, 8730 rCRLF = /\r?\n/g, 8731 rsubmitterTypes = /^(?:submit|button|image|reset|file)$/i, 8732 rsubmittable = /^(?:input|select|textarea|keygen)/i; 8733 8734function buildParams( prefix, obj, traditional, add ) { 8735 var name; 8736 8737 if ( Array.isArray( obj ) ) { 8738 8739 // Serialize array item. 8740 jQuery.each( obj, function( i, v ) { 8741 if ( traditional || rbracket.test( prefix ) ) { 8742 8743 // Treat each array item as a scalar. 8744 add( prefix, v ); 8745 8746 } else { 8747 8748 // Item is non-scalar (array or object), encode its numeric index. 8749 buildParams( 8750 prefix + "[" + ( typeof v === "object" && v != null ? i : "" ) + "]", 8751 v, 8752 traditional, 8753 add 8754 ); 8755 } 8756 } ); 8757 8758 } else if ( !traditional && toType( obj ) === "object" ) { 8759 8760 // Serialize object item. 8761 for ( name in obj ) { 8762 buildParams( prefix + "[" + name + "]", obj[ name ], traditional, add ); 8763 } 8764 8765 } else { 8766 8767 // Serialize scalar item. 8768 add( prefix, obj ); 8769 } 8770} 8771 8772// Serialize an array of form elements or a set of 8773// key/values into a query string 8774jQuery.param = function( a, traditional ) { 8775 var prefix, 8776 s = [], 8777 add = function( key, valueOrFunction ) { 8778 8779 // If value is a function, invoke it and use its return value 8780 var value = isFunction( valueOrFunction ) ? 8781 valueOrFunction() : 8782 valueOrFunction; 8783 8784 s[ s.length ] = encodeURIComponent( key ) + "=" + 8785 encodeURIComponent( value == null ? "" : value ); 8786 }; 8787 8788 if ( a == null ) { 8789 return ""; 8790 } 8791 8792 // If an array was passed in, assume that it is an array of form elements. 8793 if ( Array.isArray( a ) || ( a.jquery && !jQuery.isPlainObject( a ) ) ) { 8794 8795 // Serialize the form elements 8796 jQuery.each( a, function() { 8797 add( this.name, this.value ); 8798 } ); 8799 8800 } else { 8801 8802 // If traditional, encode the "old" way (the way 1.3.2 or older 8803 // did it), otherwise encode params recursively. 8804 for ( prefix in a ) { 8805 buildParams( prefix, a[ prefix ], traditional, add ); 8806 } 8807 } 8808 8809 // Return the resulting serialization 8810 return s.join( "&" ); 8811}; 8812 8813jQuery.fn.extend( { 8814 serialize: function() { 8815 return jQuery.param( this.serializeArray() ); 8816 }, 8817 serializeArray: function() { 8818 return this.map( function() { 8819 8820 // Can add propHook for "elements" to filter or add form elements 8821 var elements = jQuery.prop( this, "elements" ); 8822 return elements ? jQuery.makeArray( elements ) : this; 8823 } ).filter( function() { 8824 var type = this.type; 8825 8826 // Use .is( ":disabled" ) so that fieldset[disabled] works 8827 return this.name && !jQuery( this ).is( ":disabled" ) && 8828 rsubmittable.test( this.nodeName ) && !rsubmitterTypes.test( type ) && 8829 ( this.checked || !rcheckableType.test( type ) ); 8830 } ).map( function( _i, elem ) { 8831 var val = jQuery( this ).val(); 8832 8833 if ( val == null ) { 8834 return null; 8835 } 8836 8837 if ( Array.isArray( val ) ) { 8838 return jQuery.map( val, function( val ) { 8839 return { name: elem.name, value: val.replace( rCRLF, "\r\n" ) }; 8840 } ); 8841 } 8842 8843 return { name: elem.name, value: val.replace( rCRLF, "\r\n" ) }; 8844 } ).get(); 8845 } 8846} ); 8847 8848 8849var 8850 r20 = /%20/g, 8851 rhash = /#.*$/, 8852 rantiCache = /([?&])_=[^&]*/, 8853 rheaders = /^(.*?):[ \t]*([^\r\n]*)$/mg, 8854 8855 // trac-7653, trac-8125, trac-8152: local protocol detection 8856 rlocalProtocol = /^(?:about|app|app-storage|.+-extension|file|res|widget):$/, 8857 rnoContent = /^(?:GET|HEAD)$/, 8858 rprotocol = /^\/\//, 8859 8860 /* Prefilters 8861 * 1) They are useful to introduce custom dataTypes (see ajax/jsonp.js for an example) 8862 * 2) These are called: 8863 * - BEFORE asking for a transport 8864 * - AFTER param serialization (s.data is a string if s.processData is true) 8865 * 3) key is the dataType 8866 * 4) the catchall symbol "*" can be used 8867 * 5) execution will start with transport dataType and THEN continue down to "*" if needed 8868 */ 8869 prefilters = {}, 8870 8871 /* Transports bindings 8872 * 1) key is the dataType 8873 * 2) the catchall symbol "*" can be used 8874 * 3) selection will start with transport dataType and THEN go to "*" if needed 8875 */ 8876 transports = {}, 8877 8878 // Avoid comment-prolog char sequence (trac-10098); must appease lint and evade compression 8879 allTypes = "*/".concat( "*" ), 8880 8881 // Anchor tag for parsing the document origin 8882 originAnchor = document.createElement( "a" ); 8883 8884originAnchor.href = location.href; 8885 8886// Base "constructor" for jQuery.ajaxPrefilter and jQuery.ajaxTransport 8887function addToPrefiltersOrTransports( structure ) { 8888 8889 // dataTypeExpression is optional and defaults to "*" 8890 return function( dataTypeExpression, func ) { 8891 8892 if ( typeof dataTypeExpression !== "string" ) { 8893 func = dataTypeExpression; 8894 dataTypeExpression = "*"; 8895 } 8896 8897 var dataType, 8898 i = 0, 8899 dataTypes = dataTypeExpression.toLowerCase().match( rnothtmlwhite ) || []; 8900 8901 if ( isFunction( func ) ) { 8902 8903 // For each dataType in the dataTypeExpression 8904 while ( ( dataType = dataTypes[ i++ ] ) ) { 8905 8906 // Prepend if requested 8907 if ( dataType[ 0 ] === "+" ) { 8908 dataType = dataType.slice( 1 ) || "*"; 8909 ( structure[ dataType ] = structure[ dataType ] || [] ).unshift( func ); 8910 8911 // Otherwise append 8912 } else { 8913 ( structure[ dataType ] = structure[ dataType ] || [] ).push( func ); 8914 } 8915 } 8916 } 8917 }; 8918} 8919 8920// Base inspection function for prefilters and transports 8921function inspectPrefiltersOrTransports( structure, options, originalOptions, jqXHR ) { 8922 8923 var inspected = {}, 8924 seekingTransport = ( structure === transports ); 8925 8926 function inspect( dataType ) { 8927 var selected; 8928 inspected[ dataType ] = true; 8929 jQuery.each( structure[ dataType ] || [], function( _, prefilterOrFactory ) { 8930 var dataTypeOrTransport = prefilterOrFactory( options, originalOptions, jqXHR ); 8931 if ( typeof dataTypeOrTransport === "string" && 8932 !seekingTransport && !inspected[ dataTypeOrTransport ] ) { 8933 8934 options.dataTypes.unshift( dataTypeOrTransport ); 8935 inspect( dataTypeOrTransport ); 8936 return false; 8937 } else if ( seekingTransport ) { 8938 return !( selected = dataTypeOrTransport ); 8939 } 8940 } ); 8941 return selected; 8942 } 8943 8944 return inspect( options.dataTypes[ 0 ] ) || !inspected[ "*" ] && inspect( "*" ); 8945} 8946 8947// A special extend for ajax options 8948// that takes "flat" options (not to be deep extended) 8949// Fixes trac-9887 8950function ajaxExtend( target, src ) { 8951 var key, deep, 8952 flatOptions = jQuery.ajaxSettings.flatOptions || {}; 8953 8954 for ( key in src ) { 8955 if ( src[ key ] !== undefined ) { 8956 ( flatOptions[ key ] ? target : ( deep || ( deep = {} ) ) )[ key ] = src[ key ]; 8957 } 8958 } 8959 if ( deep ) { 8960 jQuery.extend( true, target, deep ); 8961 } 8962 8963 return target; 8964} 8965 8966/* Handles responses to an ajax request: 8967 * - finds the right dataType (mediates between content-type and expected dataType) 8968 * - returns the corresponding response 8969 */ 8970function ajaxHandleResponses( s, jqXHR, responses ) { 8971 8972 var ct, type, finalDataType, firstDataType, 8973 contents = s.contents, 8974 dataTypes = s.dataTypes; 8975 8976 // Remove auto dataType and get content-type in the process 8977 while ( dataTypes[ 0 ] === "*" ) { 8978 dataTypes.shift(); 8979 if ( ct === undefined ) { 8980 ct = s.mimeType || jqXHR.getResponseHeader( "Content-Type" ); 8981 } 8982 } 8983 8984 // Check if we're dealing with a known content-type 8985 if ( ct ) { 8986 for ( type in contents ) { 8987 if ( contents[ type ] && contents[ type ].test( ct ) ) { 8988 dataTypes.unshift( type ); 8989 break; 8990 } 8991 } 8992 } 8993 8994 // Check to see if we have a response for the expected dataType 8995 if ( dataTypes[ 0 ] in responses ) { 8996 finalDataType = dataTypes[ 0 ]; 8997 } else { 8998 8999 // Try convertible dataTypes 9000 for ( type in responses ) { 9001 if ( !dataTypes[ 0 ] || s.converters[ type + " " + dataTypes[ 0 ] ] ) { 9002 finalDataType = type; 9003 break; 9004 } 9005 if ( !firstDataType ) { 9006 firstDataType = type; 9007 } 9008 } 9009 9010 // Or just use first one 9011 finalDataType = finalDataType || firstDataType; 9012 } 9013 9014 // If we found a dataType 9015 // We add the dataType to the list if needed 9016 // and return the corresponding response 9017 if ( finalDataType ) { 9018 if ( finalDataType !== dataTypes[ 0 ] ) { 9019 dataTypes.unshift( finalDataType ); 9020 } 9021 return responses[ finalDataType ]; 9022 } 9023} 9024 9025/* Chain conversions given the request and the original response 9026 * Also sets the responseXXX fields on the jqXHR instance 9027 */ 9028function ajaxConvert( s, response, jqXHR, isSuccess ) { 9029 var conv2, current, conv, tmp, prev, 9030 converters = {}, 9031 9032 // Work with a copy of dataTypes in case we need to modify it for conversion 9033 dataTypes = s.dataTypes.slice(); 9034 9035 // Create converters map with lowercased keys 9036 if ( dataTypes[ 1 ] ) { 9037 for ( conv in s.converters ) { 9038 converters[ conv.toLowerCase() ] = s.converters[ conv ]; 9039 } 9040 } 9041 9042 current = dataTypes.shift(); 9043 9044 // Convert to each sequential dataType 9045 while ( current ) { 9046 9047 if ( s.responseFields[ current ] ) { 9048 jqXHR[ s.responseFields[ current ] ] = response; 9049 } 9050 9051 // Apply the dataFilter if provided 9052 if ( !prev && isSuccess && s.dataFilter ) { 9053 response = s.dataFilter( response, s.dataType ); 9054 } 9055 9056 prev = current; 9057 current = dataTypes.shift(); 9058 9059 if ( current ) { 9060 9061 // There's only work to do if current dataType is non-auto 9062 if ( current === "*" ) { 9063 9064 current = prev; 9065 9066 // Convert response if prev dataType is non-auto and differs from current 9067 } else if ( prev !== "*" && prev !== current ) { 9068 9069 // Seek a direct converter 9070 conv = converters[ prev + " " + current ] || converters[ "* " + current ]; 9071 9072 // If none found, seek a pair 9073 if ( !conv ) { 9074 for ( conv2 in converters ) { 9075 9076 // If conv2 outputs current 9077 tmp = conv2.split( " " ); 9078 if ( tmp[ 1 ] === current ) { 9079 9080 // If prev can be converted to accepted input 9081 conv = converters[ prev + " " + tmp[ 0 ] ] || 9082 converters[ "* " + tmp[ 0 ] ]; 9083 if ( conv ) { 9084 9085 // Condense equivalence converters 9086 if ( conv === true ) { 9087 conv = converters[ conv2 ]; 9088 9089 // Otherwise, insert the intermediate dataType 9090 } else if ( converters[ conv2 ] !== true ) { 9091 current = tmp[ 0 ]; 9092 dataTypes.unshift( tmp[ 1 ] ); 9093 } 9094 break; 9095 } 9096 } 9097 } 9098 } 9099 9100 // Apply converter (if not an equivalence) 9101 if ( conv !== true ) { 9102 9103 // Unless errors are allowed to bubble, catch and return them 9104 if ( conv && s.throws ) { 9105 response = conv( response ); 9106 } else { 9107 try { 9108 response = conv( response ); 9109 } catch ( e ) { 9110 return { 9111 state: "parsererror", 9112 error: conv ? e : "No conversion from " + prev + " to " + current 9113 }; 9114 } 9115 } 9116 } 9117 } 9118 } 9119 } 9120 9121 return { state: "success", data: response }; 9122} 9123 9124jQuery.extend( { 9125 9126 // Counter for holding the number of active queries 9127 active: 0, 9128 9129 // Last-Modified header cache for next request 9130 lastModified: {}, 9131 etag: {}, 9132 9133 ajaxSettings: { 9134 url: location.href, 9135 type: "GET", 9136 isLocal: rlocalProtocol.test( location.protocol ), 9137 global: true, 9138 processData: true, 9139 async: true, 9140 contentType: "application/x-www-form-urlencoded; charset=UTF-8", 9141 9142 /* 9143 timeout: 0, 9144 data: null, 9145 dataType: null, 9146 username: null, 9147 password: null, 9148 cache: null, 9149 throws: false, 9150 traditional: false, 9151 headers: {}, 9152 */ 9153 9154 accepts: { 9155 "*": allTypes, 9156 text: "text/plain", 9157 html: "text/html", 9158 xml: "application/xml, text/xml", 9159 json: "application/json, text/javascript" 9160 }, 9161 9162 contents: { 9163 xml: /\bxml\b/, 9164 html: /\bhtml/, 9165 json: /\bjson\b/ 9166 }, 9167 9168 responseFields: { 9169 xml: "responseXML", 9170 text: "responseText", 9171 json: "responseJSON" 9172 }, 9173 9174 // Data converters 9175 // Keys separate source (or catchall "*") and destination types with a single space 9176 converters: { 9177 9178 // Convert anything to text 9179 "* text": String, 9180 9181 // Text to html (true = no transformation) 9182 "text html": true, 9183 9184 // Evaluate text as a json expression 9185 "text json": JSON.parse, 9186 9187 // Parse text as xml 9188 "text xml": jQuery.parseXML 9189 }, 9190 9191 // For options that shouldn't be deep extended: 9192 // you can add your own custom options here if 9193 // and when you create one that shouldn't be 9194 // deep extended (see ajaxExtend) 9195 flatOptions: { 9196 url: true, 9197 context: true 9198 } 9199 }, 9200 9201 // Creates a full fledged settings object into target 9202 // with both ajaxSettings and settings fields. 9203 // If target is omitted, writes into ajaxSettings. 9204 ajaxSetup: function( target, settings ) { 9205 return settings ? 9206 9207 // Building a settings object 9208 ajaxExtend( ajaxExtend( target, jQuery.ajaxSettings ), settings ) : 9209 9210 // Extending ajaxSettings 9211 ajaxExtend( jQuery.ajaxSettings, target ); 9212 }, 9213 9214 ajaxPrefilter: addToPrefiltersOrTransports( prefilters ), 9215 ajaxTransport: addToPrefiltersOrTransports( transports ), 9216 9217 // Main method 9218 ajax: function( url, options ) { 9219 9220 // If url is an object, simulate pre-1.5 signature 9221 if ( typeof url === "object" ) { 9222 options = url; 9223 url = undefined; 9224 } 9225 9226 // Force options to be an object 9227 options = options || {}; 9228 9229 var transport, 9230 9231 // URL without anti-cache param 9232 cacheURL, 9233 9234 // Response headers 9235 responseHeadersString, 9236 responseHeaders, 9237 9238 // timeout handle 9239 timeoutTimer, 9240 9241 // Url cleanup var 9242 urlAnchor, 9243 9244 // Request state (becomes false upon send and true upon completion) 9245 completed, 9246 9247 // To know if global events are to be dispatched 9248 fireGlobals, 9249 9250 // Loop variable 9251 i, 9252 9253 // uncached part of the url 9254 uncached, 9255 9256 // Create the final options object 9257 s = jQuery.ajaxSetup( {}, options ), 9258 9259 // Callbacks context 9260 callbackContext = s.context || s, 9261 9262 // Context for global events is callbackContext if it is a DOM node or jQuery collection 9263 globalEventContext = s.context && 9264 ( callbackContext.nodeType || callbackContext.jquery ) ? 9265 jQuery( callbackContext ) : 9266 jQuery.event, 9267 9268 // Deferreds 9269 deferred = jQuery.Deferred(), 9270 completeDeferred = jQuery.Callbacks( "once memory" ), 9271 9272 // Status-dependent callbacks 9273 statusCode = s.statusCode || {}, 9274 9275 // Headers (they are sent all at once) 9276 requestHeaders = {}, 9277 requestHeadersNames = {}, 9278 9279 // Default abort message 9280 strAbort = "canceled", 9281 9282 // Fake xhr 9283 jqXHR = { 9284 readyState: 0, 9285 9286 // Builds headers hashtable if needed 9287 getResponseHeader: function( key ) { 9288 var match; 9289 if ( completed ) { 9290 if ( !responseHeaders ) { 9291 responseHeaders = {}; 9292 while ( ( match = rheaders.exec( responseHeadersString ) ) ) { 9293 responseHeaders[ match[ 1 ].toLowerCase() + " " ] = 9294 ( responseHeaders[ match[ 1 ].toLowerCase() + " " ] || [] ) 9295 .concat( match[ 2 ] ); 9296 } 9297 } 9298 match = responseHeaders[ key.toLowerCase() + " " ]; 9299 } 9300 return match == null ? null : match.join( ", " ); 9301 }, 9302 9303 // Raw string 9304 getAllResponseHeaders: function() { 9305 return completed ? responseHeadersString : null; 9306 }, 9307 9308 // Caches the header 9309 setRequestHeader: function( name, value ) { 9310 if ( completed == null ) { 9311 name = requestHeadersNames[ name.toLowerCase() ] = 9312 requestHeadersNames[ name.toLowerCase() ] || name; 9313 requestHeaders[ name ] = value; 9314 } 9315 return this; 9316 }, 9317 9318 // Overrides response content-type header 9319 overrideMimeType: function( type ) { 9320 if ( completed == null ) { 9321 s.mimeType = type; 9322 } 9323 return this; 9324 }, 9325 9326 // Status-dependent callbacks 9327 statusCode: function( map ) { 9328 var code; 9329 if ( map ) { 9330 if ( completed ) { 9331 9332 // Execute the appropriate callbacks 9333 jqXHR.always( map[ jqXHR.status ] ); 9334 } else { 9335 9336 // Lazy-add the new callbacks in a way that preserves old ones 9337 for ( code in map ) { 9338 statusCode[ code ] = [ statusCode[ code ], map[ code ] ]; 9339 } 9340 } 9341 } 9342 return this; 9343 }, 9344 9345 // Cancel the request 9346 abort: function( statusText ) { 9347 var finalText = statusText || strAbort; 9348 if ( transport ) { 9349 transport.abort( finalText ); 9350 } 9351 done( 0, finalText ); 9352 return this; 9353 } 9354 }; 9355 9356 // Attach deferreds 9357 deferred.promise( jqXHR ); 9358 9359 // Add protocol if not provided (prefilters might expect it) 9360 // Handle falsy url in the settings object (trac-10093: consistency with old signature) 9361 // We also use the url parameter if available 9362 s.url = ( ( url || s.url || location.href ) + "" ) 9363 .replace( rprotocol, location.protocol + "//" ); 9364 9365 // Alias method option to type as per ticket trac-12004 9366 s.type = options.method || options.type || s.method || s.type; 9367 9368 // Extract dataTypes list 9369 s.dataTypes = ( s.dataType || "*" ).toLowerCase().match( rnothtmlwhite ) || [ "" ]; 9370 9371 // A cross-domain request is in order when the origin doesn't match the current origin. 9372 if ( s.crossDomain == null ) { 9373 urlAnchor = document.createElement( "a" ); 9374 9375 // Support: IE <=8 - 11, Edge 12 - 15 9376 // IE throws exception on accessing the href property if url is malformed, 9377 // e.g. http://example.com:80x/ 9378 try { 9379 urlAnchor.href = s.url; 9380 9381 // Support: IE <=8 - 11 only 9382 // Anchor's host property isn't correctly set when s.url is relative 9383 urlAnchor.href = urlAnchor.href; 9384 s.crossDomain = originAnchor.protocol + "//" + originAnchor.host !== 9385 urlAnchor.protocol + "//" + urlAnchor.host; 9386 } catch ( e ) { 9387 9388 // If there is an error parsing the URL, assume it is crossDomain, 9389 // it can be rejected by the transport if it is invalid 9390 s.crossDomain = true; 9391 } 9392 } 9393 9394 // Convert data if not already a string 9395 if ( s.data && s.processData && typeof s.data !== "string" ) { 9396 s.data = jQuery.param( s.data, s.traditional ); 9397 } 9398 9399 // Apply prefilters 9400 inspectPrefiltersOrTransports( prefilters, s, options, jqXHR ); 9401 9402 // If request was aborted inside a prefilter, stop there 9403 if ( completed ) { 9404 return jqXHR; 9405 } 9406 9407 // We can fire global events as of now if asked to 9408 // Don't fire events if jQuery.event is undefined in an AMD-usage scenario (trac-15118) 9409 fireGlobals = jQuery.event && s.global; 9410 9411 // Watch for a new set of requests 9412 if ( fireGlobals && jQuery.active++ === 0 ) { 9413 jQuery.event.trigger( "ajaxStart" ); 9414 } 9415 9416 // Uppercase the type 9417 s.type = s.type.toUpperCase(); 9418 9419 // Determine if request has content 9420 s.hasContent = !rnoContent.test( s.type ); 9421 9422 // Save the URL in case we're toying with the If-Modified-Since 9423 // and/or If-None-Match header later on 9424 // Remove hash to simplify url manipulation 9425 cacheURL = s.url.replace( rhash, "" ); 9426 9427 // More options handling for requests with no content 9428 if ( !s.hasContent ) { 9429 9430 // Remember the hash so we can put it back 9431 uncached = s.url.slice( cacheURL.length ); 9432 9433 // If data is available and should be processed, append data to url 9434 if ( s.data && ( s.processData || typeof s.data === "string" ) ) { 9435 cacheURL += ( rquery.test( cacheURL ) ? "&" : "?" ) + s.data; 9436 9437 // trac-9682: remove data so that it's not used in an eventual retry 9438 delete s.data; 9439 } 9440 9441 // Add or update anti-cache param if needed 9442 if ( s.cache === false ) { 9443 cacheURL = cacheURL.replace( rantiCache, "$1" ); 9444 uncached = ( rquery.test( cacheURL ) ? "&" : "?" ) + "_=" + ( nonce.guid++ ) + 9445 uncached; 9446 } 9447 9448 // Put hash and anti-cache on the URL that will be requested (gh-1732) 9449 s.url = cacheURL + uncached; 9450 9451 // Change '%20' to '+' if this is encoded form body content (gh-2658) 9452 } else if ( s.data && s.processData && 9453 ( s.contentType || "" ).indexOf( "application/x-www-form-urlencoded" ) === 0 ) { 9454 s.data = s.data.replace( r20, "+" ); 9455 } 9456 9457 // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode. 9458 if ( s.ifModified ) { 9459 if ( jQuery.lastModified[ cacheURL ] ) { 9460 jqXHR.setRequestHeader( "If-Modified-Since", jQuery.lastModified[ cacheURL ] ); 9461 } 9462 if ( jQuery.etag[ cacheURL ] ) { 9463 jqXHR.setRequestHeader( "If-None-Match", jQuery.etag[ cacheURL ] ); 9464 } 9465 } 9466 9467 // Set the correct header, if data is being sent 9468 if ( s.data && s.hasContent && s.contentType !== false || options.contentType ) { 9469 jqXHR.setRequestHeader( "Content-Type", s.contentType ); 9470 } 9471 9472 // Set the Accepts header for the server, depending on the dataType 9473 jqXHR.setRequestHeader( 9474 "Accept", 9475 s.dataTypes[ 0 ] && s.accepts[ s.dataTypes[ 0 ] ] ? 9476 s.accepts[ s.dataTypes[ 0 ] ] + 9477 ( s.dataTypes[ 0 ] !== "*" ? ", " + allTypes + "; q=0.01" : "" ) : 9478 s.accepts[ "*" ] 9479 ); 9480 9481 // Check for headers option 9482 for ( i in s.headers ) { 9483 jqXHR.setRequestHeader( i, s.headers[ i ] ); 9484 } 9485 9486 // Allow custom headers/mimetypes and early abort 9487 if ( s.beforeSend && 9488 ( s.beforeSend.call( callbackContext, jqXHR, s ) === false || completed ) ) { 9489 9490 // Abort if not done already and return 9491 return jqXHR.abort(); 9492 } 9493 9494 // Aborting is no longer a cancellation 9495 strAbort = "abort"; 9496 9497 // Install callbacks on deferreds 9498 completeDeferred.add( s.complete ); 9499 jqXHR.done( s.success ); 9500 jqXHR.fail( s.error ); 9501 9502 // Get transport 9503 transport = inspectPrefiltersOrTransports( transports, s, options, jqXHR ); 9504 9505 // If no transport, we auto-abort 9506 if ( !transport ) { 9507 done( -1, "No Transport" ); 9508 } else { 9509 jqXHR.readyState = 1; 9510 9511 // Send global event 9512 if ( fireGlobals ) { 9513 globalEventContext.trigger( "ajaxSend", [ jqXHR, s ] ); 9514 } 9515 9516 // If request was aborted inside ajaxSend, stop there 9517 if ( completed ) { 9518 return jqXHR; 9519 } 9520 9521 // Timeout 9522 if ( s.async && s.timeout > 0 ) { 9523 timeoutTimer = window.setTimeout( function() { 9524 jqXHR.abort( "timeout" ); 9525 }, s.timeout ); 9526 } 9527 9528 try { 9529 completed = false; 9530 transport.send( requestHeaders, done ); 9531 } catch ( e ) { 9532 9533 // Rethrow post-completion exceptions 9534 if ( completed ) { 9535 throw e; 9536 } 9537 9538 // Propagate others as results 9539 done( -1, e ); 9540 } 9541 } 9542 9543 // Callback for when everything is done 9544 function done( status, nativeStatusText, responses, headers ) { 9545 var isSuccess, success, error, response, modified, 9546 statusText = nativeStatusText; 9547 9548 // Ignore repeat invocations 9549 if ( completed ) { 9550 return; 9551 } 9552 9553 completed = true; 9554 9555 // Clear timeout if it exists 9556 if ( timeoutTimer ) { 9557 window.clearTimeout( timeoutTimer ); 9558 } 9559 9560 // Dereference transport for early garbage collection 9561 // (no matter how long the jqXHR object will be used) 9562 transport = undefined; 9563 9564 // Cache response headers 9565 responseHeadersString = headers || ""; 9566 9567 // Set readyState 9568 jqXHR.readyState = status > 0 ? 4 : 0; 9569 9570 // Determine if successful 9571 isSuccess = status >= 200 && status < 300 || status === 304; 9572 9573 // Get response data 9574 if ( responses ) { 9575 response = ajaxHandleResponses( s, jqXHR, responses ); 9576 } 9577 9578 // Use a noop converter for missing script but not if jsonp 9579 if ( !isSuccess && 9580 jQuery.inArray( "script", s.dataTypes ) > -1 && 9581 jQuery.inArray( "json", s.dataTypes ) < 0 ) { 9582 s.converters[ "text script" ] = function() {}; 9583 } 9584 9585 // Convert no matter what (that way responseXXX fields are always set) 9586 response = ajaxConvert( s, response, jqXHR, isSuccess ); 9587 9588 // If successful, handle type chaining 9589 if ( isSuccess ) { 9590 9591 // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode. 9592 if ( s.ifModified ) { 9593 modified = jqXHR.getResponseHeader( "Last-Modified" ); 9594 if ( modified ) { 9595 jQuery.lastModified[ cacheURL ] = modified; 9596 } 9597 modified = jqXHR.getResponseHeader( "etag" ); 9598 if ( modified ) { 9599 jQuery.etag[ cacheURL ] = modified; 9600 } 9601 } 9602 9603 // if no content 9604 if ( status === 204 || s.type === "HEAD" ) { 9605 statusText = "nocontent"; 9606 9607 // if not modified 9608 } else if ( status === 304 ) { 9609 statusText = "notmodified"; 9610 9611 // If we have data, let's convert it 9612 } else { 9613 statusText = response.state; 9614 success = response.data; 9615 error = response.error; 9616 isSuccess = !error; 9617 } 9618 } else { 9619 9620 // Extract error from statusText and normalize for non-aborts 9621 error = statusText; 9622 if ( status || !statusText ) { 9623 statusText = "error"; 9624 if ( status < 0 ) { 9625 status = 0; 9626 } 9627 } 9628 } 9629 9630 // Set data for the fake xhr object 9631 jqXHR.status = status; 9632 jqXHR.statusText = ( nativeStatusText || statusText ) + ""; 9633 9634 // Success/Error 9635 if ( isSuccess ) { 9636 deferred.resolveWith( callbackContext, [ success, statusText, jqXHR ] ); 9637 } else { 9638 deferred.rejectWith( callbackContext, [ jqXHR, statusText, error ] ); 9639 } 9640 9641 // Status-dependent callbacks 9642 jqXHR.statusCode( statusCode ); 9643 statusCode = undefined; 9644 9645 if ( fireGlobals ) { 9646 globalEventContext.trigger( isSuccess ? "ajaxSuccess" : "ajaxError", 9647 [ jqXHR, s, isSuccess ? success : error ] ); 9648 } 9649 9650 // Complete 9651 completeDeferred.fireWith( callbackContext, [ jqXHR, statusText ] ); 9652 9653 if ( fireGlobals ) { 9654 globalEventContext.trigger( "ajaxComplete", [ jqXHR, s ] ); 9655 9656 // Handle the global AJAX counter 9657 if ( !( --jQuery.active ) ) { 9658 jQuery.event.trigger( "ajaxStop" ); 9659 } 9660 } 9661 } 9662 9663 return jqXHR; 9664 }, 9665 9666 getJSON: function( url, data, callback ) { 9667 return jQuery.get( url, data, callback, "json" ); 9668 }, 9669 9670 getScript: function( url, callback ) { 9671 return jQuery.get( url, undefined, callback, "script" ); 9672 } 9673} ); 9674 9675jQuery.each( [ "get", "post" ], function( _i, method ) { 9676 jQuery[ method ] = function( url, data, callback, type ) { 9677 9678 // Shift arguments if data argument was omitted 9679 if ( isFunction( data ) ) { 9680 type = type || callback; 9681 callback = data; 9682 data = undefined; 9683 } 9684 9685 // The url can be an options object (which then must have .url) 9686 return jQuery.ajax( jQuery.extend( { 9687 url: url, 9688 type: method, 9689 dataType: type, 9690 data: data, 9691 success: callback 9692 }, jQuery.isPlainObject( url ) && url ) ); 9693 }; 9694} ); 9695 9696jQuery.ajaxPrefilter( function( s ) { 9697 var i; 9698 for ( i in s.headers ) { 9699 if ( i.toLowerCase() === "content-type" ) { 9700 s.contentType = s.headers[ i ] || ""; 9701 } 9702 } 9703} ); 9704 9705 9706jQuery._evalUrl = function( url, options, doc ) { 9707 return jQuery.ajax( { 9708 url: url, 9709 9710 // Make this explicit, since user can override this through ajaxSetup (trac-11264) 9711 type: "GET", 9712 dataType: "script", 9713 cache: true, 9714 async: false, 9715 global: false, 9716 9717 // Only evaluate the response if it is successful (gh-4126) 9718 // dataFilter is not invoked for failure responses, so using it instead 9719 // of the default converter is kludgy but it works. 9720 converters: { 9721 "text script": function() {} 9722 }, 9723 dataFilter: function( response ) { 9724 jQuery.globalEval( response, options, doc ); 9725 } 9726 } ); 9727}; 9728 9729 9730jQuery.fn.extend( { 9731 wrapAll: function( html ) { 9732 var wrap; 9733 9734 if ( this[ 0 ] ) { 9735 if ( isFunction( html ) ) { 9736 html = html.call( this[ 0 ] ); 9737 } 9738 9739 // The elements to wrap the target around 9740 wrap = jQuery( html, this[ 0 ].ownerDocument ).eq( 0 ).clone( true ); 9741 9742 if ( this[ 0 ].parentNode ) { 9743 wrap.insertBefore( this[ 0 ] ); 9744 } 9745 9746 wrap.map( function() { 9747 var elem = this; 9748 9749 while ( elem.firstElementChild ) { 9750 elem = elem.firstElementChild; 9751 } 9752 9753 return elem; 9754 } ).append( this ); 9755 } 9756 9757 return this; 9758 }, 9759 9760 wrapInner: function( html ) { 9761 if ( isFunction( html ) ) { 9762 return this.each( function( i ) { 9763 jQuery( this ).wrapInner( html.call( this, i ) ); 9764 } ); 9765 } 9766 9767 return this.each( function() { 9768 var self = jQuery( this ), 9769 contents = self.contents(); 9770 9771 if ( contents.length ) { 9772 contents.wrapAll( html ); 9773 9774 } else { 9775 self.append( html ); 9776 } 9777 } ); 9778 }, 9779 9780 wrap: function( html ) { 9781 var htmlIsFunction = isFunction( html ); 9782 9783 return this.each( function( i ) { 9784 jQuery( this ).wrapAll( htmlIsFunction ? html.call( this, i ) : html ); 9785 } ); 9786 }, 9787 9788 unwrap: function( selector ) { 9789 this.parent( selector ).not( "body" ).each( function() { 9790 jQuery( this ).replaceWith( this.childNodes ); 9791 } ); 9792 return this; 9793 } 9794} ); 9795 9796 9797jQuery.expr.pseudos.hidden = function( elem ) { 9798 return !jQuery.expr.pseudos.visible( elem ); 9799}; 9800jQuery.expr.pseudos.visible = function( elem ) { 9801 return !!( elem.offsetWidth || elem.offsetHeight || elem.getClientRects().length ); 9802}; 9803 9804 9805 9806 9807jQuery.ajaxSettings.xhr = function() { 9808 try { 9809 return new window.XMLHttpRequest(); 9810 } catch ( e ) {} 9811}; 9812 9813var xhrSuccessStatus = { 9814 9815 // File protocol always yields status code 0, assume 200 9816 0: 200, 9817 9818 // Support: IE <=9 only 9819 // trac-1450: sometimes IE returns 1223 when it should be 204 9820 1223: 204 9821 }, 9822 xhrSupported = jQuery.ajaxSettings.xhr(); 9823 9824support.cors = !!xhrSupported && ( "withCredentials" in xhrSupported ); 9825support.ajax = xhrSupported = !!xhrSupported; 9826 9827jQuery.ajaxTransport( function( options ) { 9828 var callback, errorCallback; 9829 9830 // Cross domain only allowed if supported through XMLHttpRequest 9831 if ( support.cors || xhrSupported && !options.crossDomain ) { 9832 return { 9833 send: function( headers, complete ) { 9834 var i, 9835 xhr = options.xhr(); 9836 9837 xhr.open( 9838 options.type, 9839 options.url, 9840 options.async, 9841 options.username, 9842 options.password 9843 ); 9844 9845 // Apply custom fields if provided 9846 if ( options.xhrFields ) { 9847 for ( i in options.xhrFields ) { 9848 xhr[ i ] = options.xhrFields[ i ]; 9849 } 9850 } 9851 9852 // Override mime type if needed 9853 if ( options.mimeType && xhr.overrideMimeType ) { 9854 xhr.overrideMimeType( options.mimeType ); 9855 } 9856 9857 // X-Requested-With header 9858 // For cross-domain requests, seeing as conditions for a preflight are 9859 // akin to a jigsaw puzzle, we simply never set it to be sure. 9860 // (it can always be set on a per-request basis or even using ajaxSetup) 9861 // For same-domain requests, won't change header if already provided. 9862 if ( !options.crossDomain && !headers[ "X-Requested-With" ] ) { 9863 headers[ "X-Requested-With" ] = "XMLHttpRequest"; 9864 } 9865 9866 // Set headers 9867 for ( i in headers ) { 9868 xhr.setRequestHeader( i, headers[ i ] ); 9869 } 9870 9871 // Callback 9872 callback = function( type ) { 9873 return function() { 9874 if ( callback ) { 9875 callback = errorCallback = xhr.onload = 9876 xhr.onerror = xhr.onabort = xhr.ontimeout = 9877 xhr.onreadystatechange = null; 9878 9879 if ( type === "abort" ) { 9880 xhr.abort(); 9881 } else if ( type === "error" ) { 9882 9883 // Support: IE <=9 only 9884 // On a manual native abort, IE9 throws 9885 // errors on any property access that is not readyState 9886 if ( typeof xhr.status !== "number" ) { 9887 complete( 0, "error" ); 9888 } else { 9889 complete( 9890 9891 // File: protocol always yields status 0; see trac-8605, trac-14207 9892 xhr.status, 9893 xhr.statusText 9894 ); 9895 } 9896 } else { 9897 complete( 9898 xhrSuccessStatus[ xhr.status ] || xhr.status, 9899 xhr.statusText, 9900 9901 // Support: IE <=9 only 9902 // IE9 has no XHR2 but throws on binary (trac-11426) 9903 // For XHR2 non-text, let the caller handle it (gh-2498) 9904 ( xhr.responseType || "text" ) !== "text" || 9905 typeof xhr.responseText !== "string" ? 9906 { binary: xhr.response } : 9907 { text: xhr.responseText }, 9908 xhr.getAllResponseHeaders() 9909 ); 9910 } 9911 } 9912 }; 9913 }; 9914 9915 // Listen to events 9916 xhr.onload = callback(); 9917 errorCallback = xhr.onerror = xhr.ontimeout = callback( "error" ); 9918 9919 // Support: IE 9 only 9920 // Use onreadystatechange to replace onabort 9921 // to handle uncaught aborts 9922 if ( xhr.onabort !== undefined ) { 9923 xhr.onabort = errorCallback; 9924 } else { 9925 xhr.onreadystatechange = function() { 9926 9927 // Check readyState before timeout as it changes 9928 if ( xhr.readyState === 4 ) { 9929 9930 // Allow onerror to be called first, 9931 // but that will not handle a native abort 9932 // Also, save errorCallback to a variable 9933 // as xhr.onerror cannot be accessed 9934 window.setTimeout( function() { 9935 if ( callback ) { 9936 errorCallback(); 9937 } 9938 } ); 9939 } 9940 }; 9941 } 9942 9943 // Create the abort callback 9944 callback = callback( "abort" ); 9945 9946 try { 9947 9948 // Do send the request (this may raise an exception) 9949 xhr.send( options.hasContent && options.data || null ); 9950 } catch ( e ) { 9951 9952 // trac-14683: Only rethrow if this hasn't been notified as an error yet 9953 if ( callback ) { 9954 throw e; 9955 } 9956 } 9957 }, 9958 9959 abort: function() { 9960 if ( callback ) { 9961 callback(); 9962 } 9963 } 9964 }; 9965 } 9966} ); 9967 9968 9969 9970 9971// Prevent auto-execution of scripts when no explicit dataType was provided (See gh-2432) 9972jQuery.ajaxPrefilter( function( s ) { 9973 if ( s.crossDomain ) { 9974 s.contents.script = false; 9975 } 9976} ); 9977 9978// Install script dataType 9979jQuery.ajaxSetup( { 9980 accepts: { 9981 script: "text/javascript, application/javascript, " + 9982 "application/ecmascript, application/x-ecmascript" 9983 }, 9984 contents: { 9985 script: /\b(?:java|ecma)script\b/ 9986 }, 9987 converters: { 9988 "text script": function( text ) { 9989 jQuery.globalEval( text ); 9990 return text; 9991 } 9992 } 9993} ); 9994 9995// Handle cache's special case and crossDomain 9996jQuery.ajaxPrefilter( "script", function( s ) { 9997 if ( s.cache === undefined ) { 9998 s.cache = false; 9999 } 10000 if ( s.crossDomain ) { 10001 s.type = "GET"; 10002 } 10003} ); 10004 10005// Bind script tag hack transport 10006jQuery.ajaxTransport( "script", function( s ) { 10007 10008 // This transport only deals with cross domain or forced-by-attrs requests 10009 if ( s.crossDomain || s.scriptAttrs ) { 10010 var script, callback; 10011 return { 10012 send: function( _, complete ) { 10013 script = jQuery( "<script>" ) 10014 .attr( s.scriptAttrs || {} ) 10015 .prop( { charset: s.scriptCharset, src: s.url } ) 10016 .on( "load error", callback = function( evt ) { 10017 script.remove(); 10018 callback = null; 10019 if ( evt ) { 10020 complete( evt.type === "error" ? 404 : 200, evt.type ); 10021 } 10022 } ); 10023 10024 // Use native DOM manipulation to avoid our domManip AJAX trickery 10025 document.head.appendChild( script[ 0 ] ); 10026 }, 10027 abort: function() { 10028 if ( callback ) { 10029 callback(); 10030 } 10031 } 10032 }; 10033 } 10034} ); 10035 10036 10037 10038 10039var oldCallbacks = [], 10040 rjsonp = /(=)\?(?=&|$)|\?\?/; 10041 10042// Default jsonp settings 10043jQuery.ajaxSetup( { 10044 jsonp: "callback", 10045 jsonpCallback: function() { 10046 var callback = oldCallbacks.pop() || ( jQuery.expando + "_" + ( nonce.guid++ ) ); 10047 this[ callback ] = true; 10048 return callback; 10049 } 10050} ); 10051 10052// Detect, normalize options and install callbacks for jsonp requests 10053jQuery.ajaxPrefilter( "json jsonp", function( s, originalSettings, jqXHR ) { 10054 10055 var callbackName, overwritten, responseContainer, 10056 jsonProp = s.jsonp !== false && ( rjsonp.test( s.url ) ? 10057 "url" : 10058 typeof s.data === "string" && 10059 ( s.contentType || "" ) 10060 .indexOf( "application/x-www-form-urlencoded" ) === 0 && 10061 rjsonp.test( s.data ) && "data" 10062 ); 10063 10064 // Handle iff the expected data type is "jsonp" or we have a parameter to set 10065 if ( jsonProp || s.dataTypes[ 0 ] === "jsonp" ) { 10066 10067 // Get callback name, remembering preexisting value associated with it 10068 callbackName = s.jsonpCallback = isFunction( s.jsonpCallback ) ? 10069 s.jsonpCallback() : 10070 s.jsonpCallback; 10071 10072 // Insert callback into url or form data 10073 if ( jsonProp ) { 10074 s[ jsonProp ] = s[ jsonProp ].replace( rjsonp, "$1" + callbackName ); 10075 } else if ( s.jsonp !== false ) { 10076 s.url += ( rquery.test( s.url ) ? "&" : "?" ) + s.jsonp + "=" + callbackName; 10077 } 10078 10079 // Use data converter to retrieve json after script execution 10080 s.converters[ "script json" ] = function() { 10081 if ( !responseContainer ) { 10082 jQuery.error( callbackName + " was not called" ); 10083 } 10084 return responseContainer[ 0 ]; 10085 }; 10086 10087 // Force json dataType 10088 s.dataTypes[ 0 ] = "json"; 10089 10090 // Install callback 10091 overwritten = window[ callbackName ]; 10092 window[ callbackName ] = function() { 10093 responseContainer = arguments; 10094 }; 10095 10096 // Clean-up function (fires after converters) 10097 jqXHR.always( function() { 10098 10099 // If previous value didn't exist - remove it 10100 if ( overwritten === undefined ) { 10101 jQuery( window ).removeProp( callbackName ); 10102 10103 // Otherwise restore preexisting value 10104 } else { 10105 window[ callbackName ] = overwritten; 10106 } 10107 10108 // Save back as free 10109 if ( s[ callbackName ] ) { 10110 10111 // Make sure that re-using the options doesn't screw things around 10112 s.jsonpCallback = originalSettings.jsonpCallback; 10113 10114 // Save the callback name for future use 10115 oldCallbacks.push( callbackName ); 10116 } 10117 10118 // Call if it was a function and we have a response 10119 if ( responseContainer && isFunction( overwritten ) ) { 10120 overwritten( responseContainer[ 0 ] ); 10121 } 10122 10123 responseContainer = overwritten = undefined; 10124 } ); 10125 10126 // Delegate to script 10127 return "script"; 10128 } 10129} ); 10130 10131 10132 10133 10134// Support: Safari 8 only 10135// In Safari 8 documents created via document.implementation.createHTMLDocument 10136// collapse sibling forms: the second one becomes a child of the first one. 10137// Because of that, this security measure has to be disabled in Safari 8. 10138// https://bugs.webkit.org/show_bug.cgi?id=137337 10139support.createHTMLDocument = ( function() { 10140 var body = document.implementation.createHTMLDocument( "" ).body; 10141 body.innerHTML = "<form></form><form></form>"; 10142 return body.childNodes.length === 2; 10143} )(); 10144 10145 10146// Argument "data" should be string of html 10147// context (optional): If specified, the fragment will be created in this context, 10148// defaults to document 10149// keepScripts (optional): If true, will include scripts passed in the html string 10150jQuery.parseHTML = function( data, context, keepScripts ) { 10151 if ( typeof data !== "string" ) { 10152 return []; 10153 } 10154 if ( typeof context === "boolean" ) { 10155 keepScripts = context; 10156 context = false; 10157 } 10158 10159 var base, parsed, scripts; 10160 10161 if ( !context ) { 10162 10163 // Stop scripts or inline event handlers from being executed immediately 10164 // by using document.implementation 10165 if ( support.createHTMLDocument ) { 10166 context = document.implementation.createHTMLDocument( "" ); 10167 10168 // Set the base href for the created document 10169 // so any parsed elements with URLs 10170 // are based on the document's URL (gh-2965) 10171 base = context.createElement( "base" ); 10172 base.href = document.location.href; 10173 context.head.appendChild( base ); 10174 } else { 10175 context = document; 10176 } 10177 } 10178 10179 parsed = rsingleTag.exec( data ); 10180 scripts = !keepScripts && []; 10181 10182 // Single tag 10183 if ( parsed ) { 10184 return [ context.createElement( parsed[ 1 ] ) ]; 10185 } 10186 10187 parsed = buildFragment( [ data ], context, scripts ); 10188 10189 if ( scripts && scripts.length ) { 10190 jQuery( scripts ).remove(); 10191 } 10192 10193 return jQuery.merge( [], parsed.childNodes ); 10194}; 10195 10196 10197/** 10198 * Load a url into a page 10199 */ 10200jQuery.fn.load = function( url, params, callback ) { 10201 var selector, type, response, 10202 self = this, 10203 off = url.indexOf( " " ); 10204 10205 if ( off > -1 ) { 10206 selector = stripAndCollapse( url.slice( off ) ); 10207 url = url.slice( 0, off ); 10208 } 10209 10210 // If it's a function 10211 if ( isFunction( params ) ) { 10212 10213 // We assume that it's the callback 10214 callback = params; 10215 params = undefined; 10216 10217 // Otherwise, build a param string 10218 } else if ( params && typeof params === "object" ) { 10219 type = "POST"; 10220 } 10221 10222 // If we have elements to modify, make the request 10223 if ( self.length > 0 ) { 10224 jQuery.ajax( { 10225 url: url, 10226 10227 // If "type" variable is undefined, then "GET" method will be used. 10228 // Make value of this field explicit since 10229 // user can override it through ajaxSetup method 10230 type: type || "GET", 10231 dataType: "html", 10232 data: params 10233 } ).done( function( responseText ) { 10234 10235 // Save response for use in complete callback 10236 response = arguments; 10237 10238 self.html( selector ? 10239 10240 // If a selector was specified, locate the right elements in a dummy div 10241 // Exclude scripts to avoid IE 'Permission Denied' errors 10242 jQuery( "<div>" ).append( jQuery.parseHTML( responseText ) ).find( selector ) : 10243 10244 // Otherwise use the full result 10245 responseText ); 10246 10247 // If the request succeeds, this function gets "data", "status", "jqXHR" 10248 // but they are ignored because response was set above. 10249 // If it fails, this function gets "jqXHR", "status", "error" 10250 } ).always( callback && function( jqXHR, status ) { 10251 self.each( function() { 10252 callback.apply( this, response || [ jqXHR.responseText, status, jqXHR ] ); 10253 } ); 10254 } ); 10255 } 10256 10257 return this; 10258}; 10259 10260 10261 10262 10263jQuery.expr.pseudos.animated = function( elem ) { 10264 return jQuery.grep( jQuery.timers, function( fn ) { 10265 return elem === fn.elem; 10266 } ).length; 10267}; 10268 10269 10270 10271 10272jQuery.offset = { 10273 setOffset: function( elem, options, i ) { 10274 var curPosition, curLeft, curCSSTop, curTop, curOffset, curCSSLeft, calculatePosition, 10275 position = jQuery.css( elem, "position" ), 10276 curElem = jQuery( elem ), 10277 props = {}; 10278 10279 // Set position first, in-case top/left are set even on static elem 10280 if ( position === "static" ) { 10281 elem.style.position = "relative"; 10282 } 10283 10284 curOffset = curElem.offset(); 10285 curCSSTop = jQuery.css( elem, "top" ); 10286 curCSSLeft = jQuery.css( elem, "left" ); 10287 calculatePosition = ( position === "absolute" || position === "fixed" ) && 10288 ( curCSSTop + curCSSLeft ).indexOf( "auto" ) > -1; 10289 10290 // Need to be able to calculate position if either 10291 // top or left is auto and position is either absolute or fixed 10292 if ( calculatePosition ) { 10293 curPosition = curElem.position(); 10294 curTop = curPosition.top; 10295 curLeft = curPosition.left; 10296 10297 } else { 10298 curTop = parseFloat( curCSSTop ) || 0; 10299 curLeft = parseFloat( curCSSLeft ) || 0; 10300 } 10301 10302 if ( isFunction( options ) ) { 10303 10304 // Use jQuery.extend here to allow modification of coordinates argument (gh-1848) 10305 options = options.call( elem, i, jQuery.extend( {}, curOffset ) ); 10306 } 10307 10308 if ( options.top != null ) { 10309 props.top = ( options.top - curOffset.top ) + curTop; 10310 } 10311 if ( options.left != null ) { 10312 props.left = ( options.left - curOffset.left ) + curLeft; 10313 } 10314 10315 if ( "using" in options ) { 10316 options.using.call( elem, props ); 10317 10318 } else { 10319 curElem.css( props ); 10320 } 10321 } 10322}; 10323 10324jQuery.fn.extend( { 10325 10326 // offset() relates an element's border box to the document origin 10327 offset: function( options ) { 10328 10329 // Preserve chaining for setter 10330 if ( arguments.length ) { 10331 return options === undefined ? 10332 this : 10333 this.each( function( i ) { 10334 jQuery.offset.setOffset( this, options, i ); 10335 } ); 10336 } 10337 10338 var rect, win, 10339 elem = this[ 0 ]; 10340 10341 if ( !elem ) { 10342 return; 10343 } 10344 10345 // Return zeros for disconnected and hidden (display: none) elements (gh-2310) 10346 // Support: IE <=11 only 10347 // Running getBoundingClientRect on a 10348 // disconnected node in IE throws an error 10349 if ( !elem.getClientRects().length ) { 10350 return { top: 0, left: 0 }; 10351 } 10352 10353 // Get document-relative position by adding viewport scroll to viewport-relative gBCR 10354 rect = elem.getBoundingClientRect(); 10355 win = elem.ownerDocument.defaultView; 10356 return { 10357 top: rect.top + win.pageYOffset, 10358 left: rect.left + win.pageXOffset 10359 }; 10360 }, 10361 10362 // position() relates an element's margin box to its offset parent's padding box 10363 // This corresponds to the behavior of CSS absolute positioning 10364 position: function() { 10365 if ( !this[ 0 ] ) { 10366 return; 10367 } 10368 10369 var offsetParent, offset, doc, 10370 elem = this[ 0 ], 10371 parentOffset = { top: 0, left: 0 }; 10372 10373 // position:fixed elements are offset from the viewport, which itself always has zero offset 10374 if ( jQuery.css( elem, "position" ) === "fixed" ) { 10375 10376 // Assume position:fixed implies availability of getBoundingClientRect 10377 offset = elem.getBoundingClientRect(); 10378 10379 } else { 10380 offset = this.offset(); 10381 10382 // Account for the *real* offset parent, which can be the document or its root element 10383 // when a statically positioned element is identified 10384 doc = elem.ownerDocument; 10385 offsetParent = elem.offsetParent || doc.documentElement; 10386 while ( offsetParent && 10387 ( offsetParent === doc.body || offsetParent === doc.documentElement ) && 10388 jQuery.css( offsetParent, "position" ) === "static" ) { 10389 10390 offsetParent = offsetParent.parentNode; 10391 } 10392 if ( offsetParent && offsetParent !== elem && offsetParent.nodeType === 1 ) { 10393 10394 // Incorporate borders into its offset, since they are outside its content origin 10395 parentOffset = jQuery( offsetParent ).offset(); 10396 parentOffset.top += jQuery.css( offsetParent, "borderTopWidth", true ); 10397 parentOffset.left += jQuery.css( offsetParent, "borderLeftWidth", true ); 10398 } 10399 } 10400 10401 // Subtract parent offsets and element margins 10402 return { 10403 top: offset.top - parentOffset.top - jQuery.css( elem, "marginTop", true ), 10404 left: offset.left - parentOffset.left - jQuery.css( elem, "marginLeft", true ) 10405 }; 10406 }, 10407 10408 // This method will return documentElement in the following cases: 10409 // 1) For the element inside the iframe without offsetParent, this method will return 10410 // documentElement of the parent window 10411 // 2) For the hidden or detached element 10412 // 3) For body or html element, i.e. in case of the html node - it will return itself 10413 // 10414 // but those exceptions were never presented as a real life use-cases 10415 // and might be considered as more preferable results. 10416 // 10417 // This logic, however, is not guaranteed and can change at any point in the future 10418 offsetParent: function() { 10419 return this.map( function() { 10420 var offsetParent = this.offsetParent; 10421 10422 while ( offsetParent && jQuery.css( offsetParent, "position" ) === "static" ) { 10423 offsetParent = offsetParent.offsetParent; 10424 } 10425 10426 return offsetParent || documentElement; 10427 } ); 10428 } 10429} ); 10430 10431// Create scrollLeft and scrollTop methods 10432jQuery.each( { scrollLeft: "pageXOffset", scrollTop: "pageYOffset" }, function( method, prop ) { 10433 var top = "pageYOffset" === prop; 10434 10435 jQuery.fn[ method ] = function( val ) { 10436 return access( this, function( elem, method, val ) { 10437 10438 // Coalesce documents and windows 10439 var win; 10440 if ( isWindow( elem ) ) { 10441 win = elem; 10442 } else if ( elem.nodeType === 9 ) { 10443 win = elem.defaultView; 10444 } 10445 10446 if ( val === undefined ) { 10447 return win ? win[ prop ] : elem[ method ]; 10448 } 10449 10450 if ( win ) { 10451 win.scrollTo( 10452 !top ? val : win.pageXOffset, 10453 top ? val : win.pageYOffset 10454 ); 10455 10456 } else { 10457 elem[ method ] = val; 10458 } 10459 }, method, val, arguments.length ); 10460 }; 10461} ); 10462 10463// Support: Safari <=7 - 9.1, Chrome <=37 - 49 10464// Add the top/left cssHooks using jQuery.fn.position 10465// Webkit bug: https://bugs.webkit.org/show_bug.cgi?id=29084 10466// Blink bug: https://bugs.chromium.org/p/chromium/issues/detail?id=589347 10467// getComputedStyle returns percent when specified for top/left/bottom/right; 10468// rather than make the css module depend on the offset module, just check for it here 10469jQuery.each( [ "top", "left" ], function( _i, prop ) { 10470 jQuery.cssHooks[ prop ] = addGetHookIf( support.pixelPosition, 10471 function( elem, computed ) { 10472 if ( computed ) { 10473 computed = curCSS( elem, prop ); 10474 10475 // If curCSS returns percentage, fallback to offset 10476 return rnumnonpx.test( computed ) ? 10477 jQuery( elem ).position()[ prop ] + "px" : 10478 computed; 10479 } 10480 } 10481 ); 10482} ); 10483 10484 10485// Create innerHeight, innerWidth, height, width, outerHeight and outerWidth methods 10486jQuery.each( { Height: "height", Width: "width" }, function( name, type ) { 10487 jQuery.each( { 10488 padding: "inner" + name, 10489 content: type, 10490 "": "outer" + name 10491 }, function( defaultExtra, funcName ) { 10492 10493 // Margin is only for outerHeight, outerWidth 10494 jQuery.fn[ funcName ] = function( margin, value ) { 10495 var chainable = arguments.length && ( defaultExtra || typeof margin !== "boolean" ), 10496 extra = defaultExtra || ( margin === true || value === true ? "margin" : "border" ); 10497 10498 return access( this, function( elem, type, value ) { 10499 var doc; 10500 10501 if ( isWindow( elem ) ) { 10502 10503 // $( window ).outerWidth/Height return w/h including scrollbars (gh-1729) 10504 return funcName.indexOf( "outer" ) === 0 ? 10505 elem[ "inner" + name ] : 10506 elem.document.documentElement[ "client" + name ]; 10507 } 10508 10509 // Get document width or height 10510 if ( elem.nodeType === 9 ) { 10511 doc = elem.documentElement; 10512 10513 // Either scroll[Width/Height] or offset[Width/Height] or client[Width/Height], 10514 // whichever is greatest 10515 return Math.max( 10516 elem.body[ "scroll" + name ], doc[ "scroll" + name ], 10517 elem.body[ "offset" + name ], doc[ "offset" + name ], 10518 doc[ "client" + name ] 10519 ); 10520 } 10521 10522 return value === undefined ? 10523 10524 // Get width or height on the element, requesting but not forcing parseFloat 10525 jQuery.css( elem, type, extra ) : 10526 10527 // Set width or height on the element 10528 jQuery.style( elem, type, value, extra ); 10529 }, type, chainable ? margin : undefined, chainable ); 10530 }; 10531 } ); 10532} ); 10533 10534 10535jQuery.each( [ 10536 "ajaxStart", 10537 "ajaxStop", 10538 "ajaxComplete", 10539 "ajaxError", 10540 "ajaxSuccess", 10541 "ajaxSend" 10542], function( _i, type ) { 10543 jQuery.fn[ type ] = function( fn ) { 10544 return this.on( type, fn ); 10545 }; 10546} ); 10547 10548 10549 10550 10551jQuery.fn.extend( { 10552 10553 bind: function( types, data, fn ) { 10554 return this.on( types, null, data, fn ); 10555 }, 10556 unbind: function( types, fn ) { 10557 return this.off( types, null, fn ); 10558 }, 10559 10560 delegate: function( selector, types, data, fn ) { 10561 return this.on( types, selector, data, fn ); 10562 }, 10563 undelegate: function( selector, types, fn ) { 10564 10565 // ( namespace ) or ( selector, types [, fn] ) 10566 return arguments.length === 1 ? 10567 this.off( selector, "**" ) : 10568 this.off( types, selector || "**", fn ); 10569 }, 10570 10571 hover: function( fnOver, fnOut ) { 10572 return this 10573 .on( "mouseenter", fnOver ) 10574 .on( "mouseleave", fnOut || fnOver ); 10575 } 10576} ); 10577 10578jQuery.each( 10579 ( "blur focus focusin focusout resize scroll click dblclick " + 10580 "mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave " + 10581 "change select submit keydown keypress keyup contextmenu" ).split( " " ), 10582 function( _i, name ) { 10583 10584 // Handle event binding 10585 jQuery.fn[ name ] = function( data, fn ) { 10586 return arguments.length > 0 ? 10587 this.on( name, null, data, fn ) : 10588 this.trigger( name ); 10589 }; 10590 } 10591); 10592 10593 10594 10595 10596// Support: Android <=4.0 only 10597// Make sure we trim BOM and NBSP 10598// Require that the "whitespace run" starts from a non-whitespace 10599// to avoid O(N^2) behavior when the engine would try matching "\s+$" at each space position. 10600var rtrim = /^[\s\uFEFF\xA0]+|([^\s\uFEFF\xA0])[\s\uFEFF\xA0]+$/g; 10601 10602// Bind a function to a context, optionally partially applying any 10603// arguments. 10604// jQuery.proxy is deprecated to promote standards (specifically Function#bind) 10605// However, it is not slated for removal any time soon 10606jQuery.proxy = function( fn, context ) { 10607 var tmp, args, proxy; 10608 10609 if ( typeof context === "string" ) { 10610 tmp = fn[ context ]; 10611 context = fn; 10612 fn = tmp; 10613 } 10614 10615 // Quick check to determine if target is callable, in the spec 10616 // this throws a TypeError, but we will just return undefined. 10617 if ( !isFunction( fn ) ) { 10618 return undefined; 10619 } 10620 10621 // Simulated bind 10622 args = slice.call( arguments, 2 ); 10623 proxy = function() { 10624 return fn.apply( context || this, args.concat( slice.call( arguments ) ) ); 10625 }; 10626 10627 // Set the guid of unique handler to the same of original handler, so it can be removed 10628 proxy.guid = fn.guid = fn.guid || jQuery.guid++; 10629 10630 return proxy; 10631}; 10632 10633jQuery.holdReady = function( hold ) { 10634 if ( hold ) { 10635 jQuery.readyWait++; 10636 } else { 10637 jQuery.ready( true ); 10638 } 10639}; 10640jQuery.isArray = Array.isArray; 10641jQuery.parseJSON = JSON.parse; 10642jQuery.nodeName = nodeName; 10643jQuery.isFunction = isFunction; 10644jQuery.isWindow = isWindow; 10645jQuery.camelCase = camelCase; 10646jQuery.type = toType; 10647 10648jQuery.now = Date.now; 10649 10650jQuery.isNumeric = function( obj ) { 10651 10652 // As of jQuery 3.0, isNumeric is limited to 10653 // strings and numbers (primitives or objects) 10654 // that can be coerced to finite numbers (gh-2662) 10655 var type = jQuery.type( obj ); 10656 return ( type === "number" || type === "string" ) && 10657 10658 // parseFloat NaNs numeric-cast false positives ("") 10659 // ...but misinterprets leading-number strings, particularly hex literals ("0x...") 10660 // subtraction forces infinities to NaN 10661 !isNaN( obj - parseFloat( obj ) ); 10662}; 10663 10664jQuery.trim = function( text ) { 10665 return text == null ? 10666 "" : 10667 ( text + "" ).replace( rtrim, "$1" ); 10668}; 10669 10670 10671 10672// Register as a named AMD module, since jQuery can be concatenated with other 10673// files that may use define, but not via a proper concatenation script that 10674// understands anonymous AMD modules. A named AMD is safest and most robust 10675// way to register. Lowercase jquery is used because AMD module names are 10676// derived from file names, and jQuery is normally delivered in a lowercase 10677// file name. Do this after creating the global so that if an AMD module wants 10678// to call noConflict to hide this version of jQuery, it will work. 10679 10680// Note that for maximum portability, libraries that are not jQuery should 10681// declare themselves as anonymous modules, and avoid setting a global if an 10682// AMD loader is present. jQuery is a special case. For more information, see 10683// https://github.com/jrburke/requirejs/wiki/Updating-existing-libraries#wiki-anon 10684 10685if ( true ) { 10686 !(__WEBPACK_AMD_DEFINE_ARRAY__ = [], __WEBPACK_AMD_DEFINE_RESULT__ = (function() { 10687 return jQuery; 10688 }).apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__), 10689 __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); 10690} 10691 10692 10693 10694 10695var 10696 10697 // Map over jQuery in case of overwrite 10698 _jQuery = window.jQuery, 10699 10700 // Map over the $ in case of overwrite 10701 _$ = window.$; 10702 10703jQuery.noConflict = function( deep ) { 10704 if ( window.$ === jQuery ) { 10705 window.$ = _$; 10706 } 10707 10708 if ( deep && window.jQuery === jQuery ) { 10709 window.jQuery = _jQuery; 10710 } 10711 10712 return jQuery; 10713}; 10714 10715// Expose jQuery and $ identifiers, even in AMD 10716// (trac-7102#comment:10, https://github.com/jquery/jquery/pull/557) 10717// and CommonJS for browser emulators (trac-13566) 10718if ( typeof noGlobal === "undefined" ) { 10719 window.jQuery = window.$ = jQuery; 10720} 10721 10722 10723 10724 10725return jQuery; 10726} ); 10727 10728 10729/***/ }), 10730
vendor: 46,192 bytes, lines 10731-12120
10731/***/ "./node_modules/lightgallery/dist/js/lightgallery.js": 10732/*!***********************************************************!*\ 10733 !*** ./node_modules/lightgallery/dist/js/lightgallery.js ***! 10734 \***********************************************************/ 10735/***/ (function(module, exports, __webpack_require__) { 10736 10737var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/*! lightgallery - v1.10.0 - 2020-11-07 10738* http://sachinchoolur.github.io/lightGallery/ 10739* Copyright (c) 2020 Sachin N; Licensed GPLv3 */ 10740(function (root, factory) { 10741 if (true) { 10742 // AMD. Register as an anonymous module unless amdModuleId is set 10743 !(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(/*! jquery */ "./node_modules/jquery/dist/jquery.js")], __WEBPACK_AMD_DEFINE_RESULT__ = (function (a0) { 10744 return (factory(a0)); 10745 }).apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__), 10746 __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); 10747 } else {} 10748}(this, function ($) { 10749 10750(function() { 10751 'use strict'; 10752 10753 var defaults = { 10754 10755 mode: 'lg-slide', 10756 10757 // Ex : 'ease' 10758 cssEasing: 'ease', 10759 10760 //'for jquery animation' 10761 easing: 'linear', 10762 speed: 600, 10763 height: '100%', 10764 width: '100%', 10765 addClass: '', 10766 startClass: 'lg-start-zoom', 10767 backdropDuration: 150, 10768 10769 // Set 0, if u don't want to hide the controls 10770 hideBarsDelay: 6000, 10771 10772 useLeft: false, 10773 10774 // aria-labelledby attribute fot gallery 10775 ariaLabelledby: '', 10776 10777 //aria-describedby attribute for gallery 10778 ariaDescribedby: '', 10779 10780 closable: true, 10781 loop: true, 10782 escKey: true, 10783 keyPress: true, 10784 controls: true, 10785 slideEndAnimatoin: true, 10786 hideControlOnEnd: false, 10787 mousewheel: true, 10788 10789 getCaptionFromTitleOrAlt: true, 10790 10791 // .lg-item || '.lg-sub-html' 10792 appendSubHtmlTo: '.lg-sub-html', 10793 10794 subHtmlSelectorRelative: false, 10795 10796 /** 10797 * @desc number of preload slides 10798 * will execute only after the current slide is fully loaded. 10799 * 10800 * @ex you clicked on 4th image and if preload = 1 then 3rd slide and 5th 10801 * slide will be loaded in the background after the 4th slide is fully loaded.. 10802 * if preload is 2 then 2nd 3rd 5th 6th slides will be preloaded.. ... ... 10803 * 10804 */ 10805 preload: 1, 10806 showAfterLoad: true, 10807 selector: '', 10808 selectWithin: '', 10809 nextHtml: '', 10810 prevHtml: '', 10811 10812 // 0, 1 10813 index: false, 10814 10815 iframeMaxWidth: '100%', 10816 10817 download: true, 10818 counter: true, 10819 appendCounterTo: '.lg-toolbar', 10820 10821 swipeThreshold: 50, 10822 enableSwipe: true, 10823 enableDrag: true, 10824 10825 dynamic: false, 10826 dynamicEl: [], 10827 galleryId: 1, 10828 supportLegacyBrowser: true 10829 }; 10830 10831 function Plugin(element, options) { 10832 10833 // Current lightGallery element 10834 this.el = element; 10835 10836 // Current jquery element 10837 this.$el = $(element); 10838 10839 // lightGallery settings 10840 this.s = $.extend({}, defaults, options); 10841 10842 // When using dynamic mode, ensure dynamicEl is an array 10843 if (this.s.dynamic && this.s.dynamicEl !== 'undefined' && this.s.dynamicEl.constructor === Array && !this.s.dynamicEl.length) { 10844 throw ('When using dynamic mode, you must also define dynamicEl as an Array.'); 10845 } 10846 10847 // lightGallery modules 10848 this.modules = {}; 10849 10850 // false when lightgallery complete first slide; 10851 this.lGalleryOn = false; 10852 10853 this.lgBusy = false; 10854 10855 // Timeout function for hiding controls; 10856 this.hideBarTimeout = false; 10857 10858 // To determine browser supports for touch events; 10859 this.isTouch = ('ontouchstart' in document.documentElement); 10860 10861 // Disable hideControlOnEnd if sildeEndAnimation is true 10862 if (this.s.slideEndAnimatoin) { 10863 this.s.hideControlOnEnd = false; 10864 } 10865 10866 // Gallery items 10867 if (this.s.dynamic) { 10868 this.$items = this.s.dynamicEl; 10869 } else { 10870 if (this.s.selector === 'this') { 10871 this.$items = this.$el; 10872 } else if (this.s.selector !== '') { 10873 if (this.s.selectWithin) { 10874 this.$items = $(this.s.selectWithin).find(this.s.selector); 10875 } else { 10876 this.$items = this.$el.find($(this.s.selector)); 10877 } 10878 } else { 10879 this.$items = this.$el.children(); 10880 } 10881 } 10882 10883 // .lg-item 10884 this.$slide = ''; 10885 10886 // .lg-outer 10887 this.$outer = ''; 10888 10889 this.init(); 10890 10891 return this; 10892 } 10893 10894 Plugin.prototype.init = function() { 10895 10896 var _this = this; 10897 10898 // s.preload should not be more than $item.length 10899 if (_this.s.preload > _this.$items.length) { 10900 _this.s.preload = _this.$items.length; 10901 } 10902 10903 // if dynamic option is enabled execute immediately 10904 var _hash = window.location.hash; 10905 if (_hash.indexOf('lg=' + this.s.galleryId) > 0) { 10906 10907 _this.index = parseInt(_hash.split('&slide=')[1], 10); 10908 10909 $('body').addClass('lg-from-hash'); 10910 if (!$('body').hasClass('lg-on')) { 10911 setTimeout(function() { 10912 _this.build(_this.index); 10913 }); 10914 10915 $('body').addClass('lg-on'); 10916 } 10917 } 10918 10919 if (_this.s.dynamic) { 10920 10921 _this.$el.trigger('onBeforeOpen.lg'); 10922 10923 _this.index = _this.s.index || 0; 10924 10925 // prevent accidental double execution 10926 if (!$('body').hasClass('lg-on')) { 10927 setTimeout(function() { 10928 _this.build(_this.index); 10929 $('body').addClass('lg-on'); 10930 }); 10931 } 10932 } else { 10933 10934 // Using different namespace for click because click event should not unbind if selector is same object('this') 10935 _this.$items.on('click.lgcustom', function(event) { 10936 10937 // For IE8 10938 try { 10939 event.preventDefault(); 10940 event.preventDefault(); 10941 } catch (er) { 10942 event.returnValue = false; 10943 } 10944 10945 _this.$el.trigger('onBeforeOpen.lg'); 10946 10947 _this.index = _this.s.index || _this.$items.index(this); 10948 10949 // prevent accidental double execution 10950 if (!$('body').hasClass('lg-on')) { 10951 _this.build(_this.index); 10952 $('body').addClass('lg-on'); 10953 } 10954 }); 10955 } 10956 10957 }; 10958 10959 Plugin.prototype.build = function(index) { 10960 10961 var _this = this; 10962 10963 _this.structure(); 10964 10965 // module constructor 10966 $.each($.fn.lightGallery.modules, function(key) { 10967 _this.modules[key] = new $.fn.lightGallery.modules[key](_this.el); 10968 }); 10969 10970 // initiate slide function 10971 _this.slide(index, false, false, false); 10972 10973 if (_this.s.keyPress) { 10974 _this.keyPress(); 10975 } 10976 10977 if (_this.$items.length > 1) { 10978 10979 _this.arrow(); 10980 10981 setTimeout(function() { 10982 _this.enableDrag(); 10983 _this.enableSwipe(); 10984 }, 50); 10985 10986 if (_this.s.mousewheel) { 10987 _this.mousewheel(); 10988 } 10989 } else { 10990 _this.$slide.on('click.lg', function() { 10991 _this.$el.trigger('onSlideClick.lg'); 10992 }); 10993 } 10994 10995 _this.counter(); 10996 10997 _this.closeGallery(); 10998 10999 _this.$el.trigger('onAfterOpen.lg'); 11000 11001 // Hide controllers if mouse doesn't move for some period 11002 if (_this.s.hideBarsDelay > 0) { 11003 11004 // Hide controllers if mouse doesn't move for some period 11005 _this.$outer.on('mousemove.lg click.lg touchstart.lg', function () { 11006 _this.$outer.removeClass('lg-hide-items'); 11007 11008 clearTimeout(_this.hideBarTimeout); 11009 11010 // Timeout will be cleared on each slide movement also 11011 _this.hideBarTimeout = setTimeout(function () { 11012 _this.$outer.addClass('lg-hide-items'); 11013 }, _this.s.hideBarsDelay); 11014 11015 }); 11016 } 11017 11018 _this.$outer.trigger('mousemove.lg'); 11019 11020 }; 11021 11022 Plugin.prototype.structure = function() { 11023 var list = ''; 11024 var controls = ''; 11025 var i = 0; 11026 var subHtmlCont = ''; 11027 var template; 11028 var _this = this; 11029 11030 $('body').append('<div class="lg-backdrop"></div>'); 11031 $('.lg-backdrop').css('transition-duration', this.s.backdropDuration + 'ms'); 11032 11033 // Create gallery items 11034 for (i = 0; i < this.$items.length; i++) { 11035 list += '<div class="lg-item"></div>'; 11036 } 11037 11038 // Create controlls 11039 if (this.s.controls && this.$items.length > 1) { 11040 controls = '<div class="lg-actions">' + 11041 '<button type="button" aria-label="Previous slide" class="lg-prev lg-icon">' + this.s.prevHtml + '</button>' + 11042 '<button type="button" aria-label="Next slide" class="lg-next lg-icon">' + this.s.nextHtml + '</button>' + 11043 '</div>'; 11044 } 11045 11046 if (this.s.appendSubHtmlTo === '.lg-sub-html') { 11047 subHtmlCont = '<div role="status" aria-live="polite" class="lg-sub-html"></div>'; 11048 } 11049 11050 var ariaLabelledby = this.s.ariaLabelledby ? 11051 'aria-labelledby="' + this.s.ariaLabelledby + '"' : ''; 11052 var ariaDescribedby = this.s.ariaDescribedby ? 11053 'aria-describedby="' + this.s.ariaDescribedby + '"' : ''; 11054 11055 template = '<div tabindex="-1" aria-modal="true" ' + ariaLabelledby + ' ' + ariaDescribedby + ' role="dialog" class="lg-outer ' + this.s.addClass + ' ' + this.s.startClass + '">' + 11056 '<div class="lg" style="width:' + this.s.width + '; height:' + this.s.height + '">' + 11057 '<div class="lg-inner">' + list + '</div>' + 11058 '<div class="lg-toolbar lg-group">' + 11059 '<button type="button" aria-label="Close gallery" class="lg-close lg-icon"></button>' + 11060 '</div>' + 11061 controls + 11062 subHtmlCont + 11063 '</div>' + 11064 '</div>'; 11065 11066 $('body').append(template); 11067 this.$outer = $('.lg-outer'); 11068 this.$outer.focus(); 11069 this.$slide = this.$outer.find('.lg-item'); 11070 11071 if (this.s.useLeft) { 11072 this.$outer.addClass('lg-use-left'); 11073 11074 // Set mode lg-slide if use left is true; 11075 this.s.mode = 'lg-slide'; 11076 } else { 11077 this.$outer.addClass('lg-use-css3'); 11078 } 11079 11080 // For fixed height gallery 11081 _this.setTop(); 11082 $(window).on('resize.lg orientationchange.lg', function() { 11083 setTimeout(function() { 11084 _this.setTop(); 11085 }, 100); 11086 }); 11087 11088 // add class lg-current to remove initial transition 11089 this.$slide.eq(this.index).addClass('lg-current'); 11090 11091 // add Class for css support and transition mode 11092 if (this.doCss()) { 11093 this.$outer.addClass('lg-css3'); 11094 } else { 11095 this.$outer.addClass('lg-css'); 11096 11097 // Set speed 0 because no animation will happen if browser doesn't support css3 11098 this.s.speed = 0; 11099 } 11100 11101 this.$outer.addClass(this.s.mode); 11102 11103 if (this.s.enableDrag && this.$items.length > 1) { 11104 this.$outer.addClass('lg-grab'); 11105 } 11106 11107 if (this.s.showAfterLoad) { 11108 this.$outer.addClass('lg-show-after-load'); 11109 } 11110 11111 if (this.doCss()) { 11112 var $inner = this.$outer.find('.lg-inner'); 11113 $inner.css('transition-timing-function', this.s.cssEasing); 11114 $inner.css('transition-duration', this.s.speed + 'ms'); 11115 } 11116 11117 setTimeout(function() { 11118 $('.lg-backdrop').addClass('in'); 11119 }); 11120 11121 setTimeout(function() { 11122 _this.$outer.addClass('lg-visible'); 11123 }, this.s.backdropDuration); 11124 11125 if (this.s.download) { 11126 this.$outer.find('.lg-toolbar').append('<a id="lg-download" aria-label="Download" target="_blank" download class="lg-download lg-icon"></a>'); 11127 } 11128 11129 // Store the current scroll top value to scroll back after closing the gallery.. 11130 this.prevScrollTop = $(window).scrollTop(); 11131 11132 }; 11133 11134 // For fixed height gallery 11135 Plugin.prototype.setTop = function() { 11136 if (this.s.height !== '100%') { 11137 var wH = $(window).height(); 11138 var top = (wH - parseInt(this.s.height, 10)) / 2; 11139 var $lGallery = this.$outer.find('.lg'); 11140 if (wH >= parseInt(this.s.height, 10)) { 11141 $lGallery.css('top', top + 'px'); 11142 } else { 11143 $lGallery.css('top', '0px'); 11144 } 11145 } 11146 }; 11147 11148 // Find css3 support 11149 Plugin.prototype.doCss = function() { 11150 // check for css animation support 11151 var support = function() { 11152 var transition = ['transition', 'MozTransition', 'WebkitTransition', 'OTransition', 'msTransition', 'KhtmlTransition']; 11153 var root = document.documentElement; 11154 var i = 0; 11155 for (i = 0; i < transition.length; i++) { 11156 if (transition[i] in root.style) { 11157 return true; 11158 } 11159 } 11160 }; 11161 11162 if (support()) { 11163 return true; 11164 } 11165 11166 return false; 11167 }; 11168 11169 /** 11170 * @desc Check the given src is video 11171 * @param {String} src 11172 * @return {Object} video type 11173 * Ex:{ youtube : ["//www.youtube.com/watch?v=c0asJgSyxcY", "c0asJgSyxcY"] } 11174 */ 11175 Plugin.prototype.isVideo = function(src, index) { 11176 11177 var html; 11178 if (this.s.dynamic) { 11179 html = this.s.dynamicEl[index].html; 11180 } else { 11181 html = this.$items.eq(index).attr('data-html'); 11182 } 11183 11184 if (!src) { 11185 if (html) { 11186 return { 11187 html5: true 11188 }; 11189 } else { 11190 console.error('lightGallery :- data-src is not provided on slide item ' + (index + 1) + '. Please make sure the selector property is properly configured. More info - http://sachinchoolur.github.io/lightGallery/demos/html-markup.html'); 11191 return false; 11192 } 11193 } 11194 11195 var youtube = src.match(/\/\/(?:www\.)?youtu(?:\.be|be\.com|be-nocookie\.com)\/(?:watch\?v=|embed\/)?([a-z0-9\-\_\%]+)/i); 11196 var vimeo = src.match(/\/\/(?:www\.)?(?:player\.)?vimeo.com\/(?:video\/)?([0-9a-z\-_]+)/i); 11197 var dailymotion = src.match(/\/\/(?:www\.)?dai.ly\/([0-9a-z\-_]+)/i); 11198 var vk = src.match(/\/\/(?:www\.)?(?:vk\.com|vkontakte\.ru)\/(?:video_ext\.php\?)(.*)/i); 11199 11200 if (youtube) { 11201 return { 11202 youtube: youtube 11203 }; 11204 } else if (vimeo) { 11205 return { 11206 vimeo: vimeo 11207 }; 11208 } else if (dailymotion) { 11209 return { 11210 dailymotion: dailymotion 11211 }; 11212 } else if (vk) { 11213 return { 11214 vk: vk 11215 }; 11216 } 11217 }; 11218 11219 /** 11220 * @desc Create image counter 11221 * Ex: 1/10 11222 */ 11223 Plugin.prototype.counter = function() { 11224 if (this.s.counter) { 11225 $(this.s.appendCounterTo).append('<div id="lg-counter" role="status" aria-live="polite"><span id="lg-counter-current">' + (parseInt(this.index, 10) + 1) + '</span> / <span id="lg-counter-all">' + this.$items.length + '</span></div>'); 11226 } 11227 }; 11228 11229 /** 11230 * @desc add sub-html into the slide 11231 * @param {Number} index - index of the slide 11232 */ 11233 Plugin.prototype.addHtml = function(index) { 11234 var subHtml = null; 11235 var subHtmlUrl; 11236 var $currentEle; 11237 if (this.s.dynamic) { 11238 if (this.s.dynamicEl[index].subHtmlUrl) { 11239 subHtmlUrl = this.s.dynamicEl[index].subHtmlUrl; 11240 } else { 11241 subHtml = this.s.dynamicEl[index].subHtml; 11242 } 11243 } else { 11244 $currentEle = this.$items.eq(index); 11245 if ($currentEle.attr('data-sub-html-url')) { 11246 subHtmlUrl = $currentEle.attr('data-sub-html-url'); 11247 } else { 11248 subHtml = $currentEle.attr('data-sub-html'); 11249 if (this.s.getCaptionFromTitleOrAlt && !subHtml) { 11250 subHtml = $currentEle.attr('title') || $currentEle.find('img').first().attr('alt'); 11251 } 11252 } 11253 } 11254 11255 if (!subHtmlUrl) { 11256 if (typeof subHtml !== 'undefined' && subHtml !== null) { 11257 11258 // get first letter of subhtml 11259 // if first letter starts with . or # get the html form the jQuery object 11260 var fL = subHtml.substring(0, 1); 11261 if (fL === '.' || fL === '#') { 11262 if (this.s.subHtmlSelectorRelative && !this.s.dynamic) { 11263 subHtml = $currentEle.find(subHtml).html(); 11264 } else { 11265 subHtml = $(subHtml).html(); 11266 } 11267 } 11268 } else { 11269 subHtml = ''; 11270 } 11271 } 11272 11273 if (this.s.appendSubHtmlTo === '.lg-sub-html') { 11274 11275 if (subHtmlUrl) { 11276 this.$outer.find(this.s.appendSubHtmlTo).load(subHtmlUrl); 11277 } else { 11278 this.$outer.find(this.s.appendSubHtmlTo).html(subHtml); 11279 } 11280 11281 } else { 11282 11283 if (subHtmlUrl) { 11284 this.$slide.eq(index).load(subHtmlUrl); 11285 } else { 11286 this.$slide.eq(index).append(subHtml); 11287 } 11288 } 11289 11290 // Add lg-empty-html class if title doesn't exist 11291 if (typeof subHtml !== 'undefined' && subHtml !== null) { 11292 if (subHtml === '') { 11293 this.$outer.find(this.s.appendSubHtmlTo).addClass('lg-empty-html'); 11294 } else { 11295 this.$outer.find(this.s.appendSubHtmlTo).removeClass('lg-empty-html'); 11296 } 11297 } 11298 11299 this.$el.trigger('onAfterAppendSubHtml.lg', [index]); 11300 }; 11301 11302 /** 11303 * @desc Preload slides 11304 * @param {Number} index - index of the slide 11305 */ 11306 Plugin.prototype.preload = function(index) { 11307 var i = 1; 11308 var j = 1; 11309 for (i = 1; i <= this.s.preload; i++) { 11310 if (i >= this.$items.length - index) { 11311 break; 11312 } 11313 11314 this.loadContent(index + i, false, 0); 11315 } 11316 11317 for (j = 1; j <= this.s.preload; j++) { 11318 if (index - j < 0) { 11319 break; 11320 } 11321 11322 this.loadContent(index - j, false, 0); 11323 } 11324 }; 11325 11326 /** 11327 * @desc Load slide content into slide. 11328 * @param {Number} index - index of the slide. 11329 * @param {Boolean} rec - if true call loadcontent() function again. 11330 * @param {Boolean} delay - delay for adding complete class. it is 0 except first time. 11331 */ 11332 Plugin.prototype.loadContent = function(index, rec, delay) { 11333 11334 var _this = this; 11335 var _hasPoster = false; 11336 var _$img; 11337 var _src; 11338 var _poster; 11339 var _srcset; 11340 var _sizes; 11341 var _html; 11342 var _alt; 11343 var getResponsiveSrc = function(srcItms) { 11344 var rsWidth = []; 11345 var rsSrc = []; 11346 for (var i = 0; i < srcItms.length; i++) { 11347 var __src = srcItms[i].split(' '); 11348 11349 // Manage empty space 11350 if (__src[0] === '') { 11351 __src.splice(0, 1); 11352 } 11353 11354 rsSrc.push(__src[0]); 11355 rsWidth.push(__src[1]); 11356 } 11357 11358 var wWidth = $(window).width(); 11359 for (var j = 0; j < rsWidth.length; j++) { 11360 if (parseInt(rsWidth[j], 10) > wWidth) { 11361 _src = rsSrc[j]; 11362 break; 11363 } 11364 } 11365 }; 11366 11367 if (_this.s.dynamic) { 11368 11369 if (_this.s.dynamicEl[index].poster) { 11370 _hasPoster = true; 11371 _poster = _this.s.dynamicEl[index].poster; 11372 } 11373 11374 _html = _this.s.dynamicEl[index].html; 11375 _src = _this.s.dynamicEl[index].src; 11376 _alt = _this.s.dynamicEl[index].alt; 11377 11378 if (_this.s.dynamicEl[index].responsive) { 11379 var srcDyItms = _this.s.dynamicEl[index].responsive.split(','); 11380 getResponsiveSrc(srcDyItms); 11381 } 11382 11383 _srcset = _this.s.dynamicEl[index].srcset; 11384 _sizes = _this.s.dynamicEl[index].sizes; 11385 11386 } else { 11387 var $currentEle = _this.$items.eq(index); 11388 if ($currentEle.attr('data-poster')) { 11389 _hasPoster = true; 11390 _poster = $currentEle.attr('data-poster'); 11391 } 11392 11393 _html = $currentEle.attr('data-html'); 11394 _src = $currentEle.attr('href') || $currentEle.attr('data-src'); 11395 _alt = $currentEle.attr('title') || $currentEle.find('img').first().attr('alt'); 11396 11397 if ($currentEle.attr('data-responsive')) { 11398 var srcItms = $currentEle.attr('data-responsive').split(','); 11399 getResponsiveSrc(srcItms); 11400 } 11401 11402 _srcset = $currentEle.attr('data-srcset'); 11403 _sizes = $currentEle.attr('data-sizes'); 11404 11405 } 11406 11407 //if (_src || _srcset || _sizes || _poster) { 11408 11409 var iframe = false; 11410 if (_this.s.dynamic) { 11411 if (_this.s.dynamicEl[index].iframe) { 11412 iframe = true; 11413 } 11414 } else { 11415 if (_this.$items.eq(index).attr('data-iframe') === 'true') { 11416 iframe = true; 11417 } 11418 } 11419 11420 var _isVideo = _this.isVideo(_src, index); 11421 if (!_this.$slide.eq(index).hasClass('lg-loaded')) { 11422 if (iframe) { 11423 _this.$slide.eq(index).prepend('<div class="lg-video-cont lg-has-iframe" style="max-width:' + _this.s.iframeMaxWidth + '"><div class="lg-video"><iframe class="lg-object" frameborder="0" src="' + _src + '" allowfullscreen="true"></iframe></div></div>'); 11424 } else if (_hasPoster) { 11425 var videoClass = ''; 11426 if (_isVideo && _isVideo.youtube) { 11427 videoClass = 'lg-has-youtube'; 11428 } else if (_isVideo && _isVideo.vimeo) { 11429 videoClass = 'lg-has-vimeo'; 11430 } else { 11431 videoClass = 'lg-has-html5'; 11432 } 11433 11434 _this.$slide.eq(index).prepend('<div class="lg-video-cont ' + videoClass + ' "><div class="lg-video"><span class="lg-video-play"></span><img class="lg-object lg-has-poster" src="' + _poster + '" /></div></div>'); 11435 11436 } else if (_isVideo) { 11437 _this.$slide.eq(index).prepend('<div class="lg-video-cont "><div class="lg-video"></div></div>'); 11438 _this.$el.trigger('hasVideo.lg', [index, _src, _html]); 11439 } else { 11440 _alt = _alt ? 'alt="' + _alt + '"' : ''; 11441 _this.$slide.eq(index).prepend('<div class="lg-img-wrap"><img class="lg-object lg-image" ' + _alt + ' src="' + _src + '" /></div>'); 11442 } 11443 11444 _this.$el.trigger('onAferAppendSlide.lg', [index]); 11445 11446 _$img = _this.$slide.eq(index).find('.lg-object'); 11447 if (_sizes) { 11448 _$img.attr('sizes', _sizes); 11449 } 11450 11451 if (_srcset) { 11452 _$img.attr('srcset', _srcset); 11453 if (this.s.supportLegacyBrowser) { 11454 try { 11455 picturefill({ 11456 elements: [_$img[0]] 11457 }); 11458 } catch (e) { 11459 console.warn('lightGallery :- If you want srcset to be supported for older browser please include picturefil version 2 javascript library in your document.'); 11460 } 11461 } 11462 } 11463 11464 if (this.s.appendSubHtmlTo !== '.lg-sub-html') { 11465 _this.addHtml(index); 11466 } 11467 11468 _this.$slide.eq(index).addClass('lg-loaded'); 11469 } 11470 11471 _this.$slide.eq(index).find('.lg-object').on('load.lg error.lg', function() { 11472 11473 // For first time add some delay for displaying the start animation. 11474 var _speed = 0; 11475 11476 // Do not change the delay value because it is required for zoom plugin. 11477 // If gallery opened from direct url (hash) speed value should be 0 11478 if (delay && !$('body').hasClass('lg-from-hash')) { 11479 _speed = delay; 11480 } 11481 11482 setTimeout(function() { 11483 _this.$slide.eq(index).addClass('lg-complete'); 11484 _this.$el.trigger('onSlideItemLoad.lg', [index, delay || 0]); 11485 }, _speed); 11486 11487 }); 11488 11489 // @todo check load state for html5 videos 11490 if (_isVideo && _isVideo.html5 && !_hasPoster) { 11491 _this.$slide.eq(index).addClass('lg-complete'); 11492 } 11493 11494 if (rec === true) { 11495 if (!_this.$slide.eq(index).hasClass('lg-complete')) { 11496 _this.$slide.eq(index).find('.lg-object').on('load.lg error.lg', function() { 11497 _this.preload(index); 11498 }); 11499 } else { 11500 _this.preload(index); 11501 } 11502 } 11503 11504 //} 11505 }; 11506 11507 /** 11508 * @desc slide function for lightgallery 11509 ** Slide() gets call on start 11510 ** ** Set lg.on true once slide() function gets called. 11511 ** Call loadContent() on slide() function inside setTimeout 11512 ** ** On first slide we do not want any animation like slide of fade 11513 ** ** So on first slide( if lg.on if false that is first slide) loadContent() should start loading immediately 11514 ** ** Else loadContent() should wait for the transition to complete. 11515 ** ** So set timeout s.speed + 50 11516 <=> ** loadContent() will load slide content in to the particular slide 11517 ** ** It has recursion (rec) parameter. if rec === true loadContent() will call preload() function. 11518 ** ** preload will execute only when the previous slide is fully loaded (images iframe) 11519 ** ** avoid simultaneous image load 11520 <=> ** Preload() will check for s.preload value and call loadContent() again accoring to preload value 11521 ** loadContent() <====> Preload(); 11522 11523 * @param {Number} index - index of the slide 11524 * @param {Boolean} fromTouch - true if slide function called via touch event or mouse drag 11525 * @param {Boolean} fromThumb - true if slide function called via thumbnail click 11526 * @param {String} direction - Direction of the slide(next/prev) 11527 */ 11528 Plugin.prototype.slide = function(index, fromTouch, fromThumb, direction) { 11529 11530 var _prevIndex = this.$outer.find('.lg-current').index(); 11531 var _this = this; 11532 11533 // Prevent if multiple call 11534 // Required for hsh plugin 11535 if (_this.lGalleryOn && (_prevIndex === index)) { 11536 return; 11537 } 11538 11539 var _length = this.$slide.length; 11540 var _time = _this.lGalleryOn ? this.s.speed : 0; 11541 11542 if (!_this.lgBusy) { 11543 11544 if (this.s.download) { 11545 var _src; 11546 if (_this.s.dynamic) { 11547 _src = _this.s.dynamicEl[index].downloadUrl !== false && (_this.s.dynamicEl[index].downloadUrl || _this.s.dynamicEl[index].src); 11548 } else { 11549 _src = _this.$items.eq(index).attr('data-download-url') !== 'false' && (_this.$items.eq(index).attr('data-download-url') || _this.$items.eq(index).attr('href') || _this.$items.eq(index).attr('data-src')); 11550 11551 } 11552 11553 if (_src) { 11554 $('#lg-download').attr('href', _src); 11555 _this.$outer.removeClass('lg-hide-download'); 11556 } else { 11557 _this.$outer.addClass('lg-hide-download'); 11558 } 11559 } 11560 11561 this.$el.trigger('onBeforeSlide.lg', [_prevIndex, index, fromTouch, fromThumb]); 11562 11563 _this.lgBusy = true; 11564 11565 clearTimeout(_this.hideBarTimeout); 11566 11567 // Add title if this.s.appendSubHtmlTo === lg-sub-html 11568 if (this.s.appendSubHtmlTo === '.lg-sub-html') { 11569 11570 // wait for slide animation to complete 11571 setTimeout(function() { 11572 _this.addHtml(index); 11573 }, _time); 11574 } 11575 11576 this.arrowDisable(index); 11577 11578 if (!direction) { 11579 if (index < _prevIndex) { 11580 direction = 'prev'; 11581 } else if (index > _prevIndex) { 11582 direction = 'next'; 11583 } 11584 } 11585 11586 if (!fromTouch) { 11587 11588 // remove all transitions 11589 _this.$outer.addClass('lg-no-trans'); 11590 11591 this.$slide.removeClass('lg-prev-slide lg-next-slide'); 11592 11593 if (direction === 'prev') { 11594 11595 //prevslide 11596 this.$slide.eq(index).addClass('lg-prev-slide'); 11597 this.$slide.eq(_prevIndex).addClass('lg-next-slide'); 11598 } else { 11599 11600 // next slide 11601 this.$slide.eq(index).addClass('lg-next-slide'); 11602 this.$slide.eq(_prevIndex).addClass('lg-prev-slide'); 11603 } 11604 11605 // give 50 ms for browser to add/remove class 11606 setTimeout(function() { 11607 _this.$slide.removeClass('lg-current'); 11608 11609 //_this.$slide.eq(_prevIndex).removeClass('lg-current'); 11610 _this.$slide.eq(index).addClass('lg-current'); 11611 11612 // reset all transitions 11613 _this.$outer.removeClass('lg-no-trans'); 11614 }, 50); 11615 } else { 11616 11617 this.$slide.removeClass('lg-prev-slide lg-current lg-next-slide'); 11618 var touchPrev; 11619 var touchNext; 11620 if (_length > 2) { 11621 touchPrev = index - 1; 11622 touchNext = index + 1; 11623 11624 if ((index === 0) && (_prevIndex === _length - 1)) { 11625 11626 // next slide 11627 touchNext = 0; 11628 touchPrev = _length - 1; 11629 } else if ((index === _length - 1) && (_prevIndex === 0)) { 11630 11631 // prev slide 11632 touchNext = 0; 11633 touchPrev = _length - 1; 11634 } 11635 11636 } else { 11637 touchPrev = 0; 11638 touchNext = 1; 11639 } 11640 11641 if (direction === 'prev') { 11642 _this.$slide.eq(touchNext).addClass('lg-next-slide'); 11643 } else { 11644 _this.$slide.eq(touchPrev).addClass('lg-prev-slide'); 11645 } 11646 11647 _this.$slide.eq(index).addClass('lg-current'); 11648 } 11649 11650 if (_this.lGalleryOn) { 11651 setTimeout(function() { 11652 _this.loadContent(index, true, 0); 11653 }, this.s.speed + 50); 11654 11655 setTimeout(function() { 11656 _this.lgBusy = false; 11657 _this.$el.trigger('onAfterSlide.lg', [_prevIndex, index, fromTouch, fromThumb]); 11658 }, this.s.speed); 11659 11660 } else { 11661 _this.loadContent(index, true, _this.s.backdropDuration); 11662 11663 _this.lgBusy = false; 11664 _this.$el.trigger('onAfterSlide.lg', [_prevIndex, index, fromTouch, fromThumb]); 11665 } 11666 11667 _this.lGalleryOn = true; 11668 11669 if (this.s.counter) { 11670 $('#lg-counter-current').text(index + 1); 11671 } 11672 11673 } 11674 _this.index = index; 11675 11676 }; 11677 11678 /** 11679 * @desc Go to next slide 11680 * @param {Boolean} fromTouch - true if slide function called via touch event 11681 */ 11682 Plugin.prototype.goToNextSlide = function(fromTouch) { 11683 var _this = this; 11684 var _loop = _this.s.loop; 11685 if (fromTouch && _this.$slide.length < 3) { 11686 _loop = false; 11687 } 11688 11689 if (!_this.lgBusy) { 11690 if ((_this.index + 1) < _this.$slide.length) { 11691 _this.index++; 11692 _this.$el.trigger('onBeforeNextSlide.lg', [_this.index]); 11693 _this.slide(_this.index, fromTouch, false, 'next'); 11694 } else { 11695 if (_loop) { 11696 _this.index = 0; 11697 _this.$el.trigger('onBeforeNextSlide.lg', [_this.index]); 11698 _this.slide(_this.index, fromTouch, false, 'next'); 11699 } else if (_this.s.slideEndAnimatoin && !fromTouch) { 11700 _this.$outer.addClass('lg-right-end'); 11701 setTimeout(function() { 11702 _this.$outer.removeClass('lg-right-end'); 11703 }, 400); 11704 } 11705 } 11706 } 11707 }; 11708 11709 /** 11710 * @desc Go to previous slide 11711 * @param {Boolean} fromTouch - true if slide function called via touch event 11712 */ 11713 Plugin.prototype.goToPrevSlide = function(fromTouch) { 11714 var _this = this; 11715 var _loop = _this.s.loop; 11716 if (fromTouch && _this.$slide.length < 3) { 11717 _loop = false; 11718 } 11719 11720 if (!_this.lgBusy) { 11721 if (_this.index > 0) { 11722 _this.index--; 11723 _this.$el.trigger('onBeforePrevSlide.lg', [_this.index, fromTouch]); 11724 _this.slide(_this.index, fromTouch, false, 'prev'); 11725 } else { 11726 if (_loop) { 11727 _this.index = _this.$items.length - 1; 11728 _this.$el.trigger('onBeforePrevSlide.lg', [_this.index, fromTouch]); 11729 _this.slide(_this.index, fromTouch, false, 'prev'); 11730 } else if (_this.s.slideEndAnimatoin && !fromTouch) { 11731 _this.$outer.addClass('lg-left-end'); 11732 setTimeout(function() { 11733 _this.$outer.removeClass('lg-left-end'); 11734 }, 400); 11735 } 11736 } 11737 } 11738 }; 11739 11740 Plugin.prototype.keyPress = function() { 11741 var _this = this; 11742 if (this.$items.length > 1) { 11743 $(window).on('keyup.lg', function(e) { 11744 if (_this.$items.length > 1) { 11745 if (e.keyCode === 37) { 11746 e.preventDefault(); 11747 _this.goToPrevSlide(); 11748 } 11749 11750 if (e.keyCode === 39) { 11751 e.preventDefault(); 11752 _this.goToNextSlide(); 11753 } 11754 } 11755 }); 11756 } 11757 11758 $(window).on('keydown.lg', function(e) { 11759 if (_this.s.escKey === true && e.keyCode === 27) { 11760 e.preventDefault(); 11761 if (!_this.$outer.hasClass('lg-thumb-open')) { 11762 _this.destroy(); 11763 } else { 11764 _this.$outer.removeClass('lg-thumb-open'); 11765 } 11766 } 11767 }); 11768 }; 11769 11770 Plugin.prototype.arrow = function() { 11771 var _this = this; 11772 this.$outer.find('.lg-prev').on('click.lg', function() { 11773 _this.goToPrevSlide(); 11774 }); 11775 11776 this.$outer.find('.lg-next').on('click.lg', function() { 11777 _this.goToNextSlide(); 11778 }); 11779 }; 11780 11781 Plugin.prototype.arrowDisable = function(index) { 11782 11783 // Disable arrows if s.hideControlOnEnd is true 11784 if (!this.s.loop && this.s.hideControlOnEnd) { 11785 if ((index + 1) < this.$slide.length) { 11786 this.$outer.find('.lg-next').removeAttr('disabled').removeClass('disabled'); 11787 } else { 11788 this.$outer.find('.lg-next').attr('disabled', 'disabled').addClass('disabled'); 11789 } 11790 11791 if (index > 0) { 11792 this.$outer.find('.lg-prev').removeAttr('disabled').removeClass('disabled'); 11793 } else { 11794 this.$outer.find('.lg-prev').attr('disabled', 'disabled').addClass('disabled'); 11795 } 11796 } 11797 }; 11798 11799 Plugin.prototype.setTranslate = function($el, xValue, yValue) { 11800 // jQuery supports Automatic CSS prefixing since jQuery 1.8.0 11801 if (this.s.useLeft) { 11802 $el.css('left', xValue); 11803 } else { 11804 $el.css({ 11805 transform: 'translate3d(' + (xValue) + 'px, ' + yValue + 'px, 0px)' 11806 }); 11807 } 11808 }; 11809 11810 Plugin.prototype.touchMove = function(startCoords, endCoords) { 11811 11812 var distance = endCoords - startCoords; 11813 11814 if (Math.abs(distance) > 15) { 11815 // reset opacity and transition duration 11816 this.$outer.addClass('lg-dragging'); 11817 11818 // move current slide 11819 this.setTranslate(this.$slide.eq(this.index), distance, 0); 11820 11821 // move next and prev slide with current slide 11822 this.setTranslate($('.lg-prev-slide'), -this.$slide.eq(this.index).width() + distance, 0); 11823 this.setTranslate($('.lg-next-slide'), this.$slide.eq(this.index).width() + distance, 0); 11824 } 11825 }; 11826 11827 Plugin.prototype.touchEnd = function(distance) { 11828 var _this = this; 11829 11830 // keep slide animation for any mode while dragg/swipe 11831 if (_this.s.mode !== 'lg-slide') { 11832 _this.$outer.addClass('lg-slide'); 11833 } 11834 11835 this.$slide.not('.lg-current, .lg-prev-slide, .lg-next-slide').css('opacity', '0'); 11836 11837 // set transition duration 11838 setTimeout(function() { 11839 _this.$outer.removeClass('lg-dragging'); 11840 if ((distance < 0) && (Math.abs(distance) > _this.s.swipeThreshold)) { 11841 _this.goToNextSlide(true); 11842 } else if ((distance > 0) && (Math.abs(distance) > _this.s.swipeThreshold)) { 11843 _this.goToPrevSlide(true); 11844 } else if (Math.abs(distance) < 5) { 11845 11846 // Trigger click if distance is less than 5 pix 11847 _this.$el.trigger('onSlideClick.lg'); 11848 } 11849 11850 _this.$slide.removeAttr('style'); 11851 }); 11852 11853 // remove slide class once drag/swipe is completed if mode is not slide 11854 setTimeout(function() { 11855 if (!_this.$outer.hasClass('lg-dragging') && _this.s.mode !== 'lg-slide') { 11856 _this.$outer.removeClass('lg-slide'); 11857 } 11858 }, _this.s.speed + 100); 11859 11860 }; 11861 11862 Plugin.prototype.enableSwipe = function() { 11863 var _this = this; 11864 var startCoords = 0; 11865 var endCoords = 0; 11866 var isMoved = false; 11867 11868 if (_this.s.enableSwipe && _this.doCss()) { 11869 11870 _this.$slide.on('touchstart.lg', function(e) { 11871 if (!_this.$outer.hasClass('lg-zoomed') && !_this.lgBusy) { 11872 e.preventDefault(); 11873 _this.manageSwipeClass(); 11874 startCoords = e.originalEvent.targetTouches[0].pageX; 11875 } 11876 }); 11877 11878 _this.$slide.on('touchmove.lg', function(e) { 11879 if (!_this.$outer.hasClass('lg-zoomed')) { 11880 e.preventDefault(); 11881 endCoords = e.originalEvent.targetTouches[0].pageX; 11882 _this.touchMove(startCoords, endCoords); 11883 isMoved = true; 11884 } 11885 }); 11886 11887 _this.$slide.on('touchend.lg', function() { 11888 if (!_this.$outer.hasClass('lg-zoomed')) { 11889 if (isMoved) { 11890 isMoved = false; 11891 _this.touchEnd(endCoords - startCoords); 11892 } else { 11893 _this.$el.trigger('onSlideClick.lg'); 11894 } 11895 } 11896 }); 11897 } 11898 11899 }; 11900 11901 Plugin.prototype.enableDrag = function() { 11902 var _this = this; 11903 var startCoords = 0; 11904 var endCoords = 0; 11905 var isDraging = false; 11906 var isMoved = false; 11907 if (_this.s.enableDrag && _this.doCss()) { 11908 _this.$slide.on('mousedown.lg', function(e) { 11909 if (!_this.$outer.hasClass('lg-zoomed') && !_this.lgBusy && !$(e.target).text().trim()) { 11910 e.preventDefault(); 11911 _this.manageSwipeClass(); 11912 startCoords = e.pageX; 11913 isDraging = true; 11914 11915 // ** Fix for webkit cursor issue https://code.google.com/p/chromium/issues/detail?id=26723 11916 _this.$outer.scrollLeft += 1; 11917 _this.$outer.scrollLeft -= 1; 11918 11919 // * 11920 11921 _this.$outer.removeClass('lg-grab').addClass('lg-grabbing'); 11922 11923 _this.$el.trigger('onDragstart.lg'); 11924 } 11925 }); 11926 11927 $(window).on('mousemove.lg', function(e) { 11928 if (isDraging) { 11929 isMoved = true; 11930 endCoords = e.pageX; 11931 _this.touchMove(startCoords, endCoords); 11932 _this.$el.trigger('onDragmove.lg'); 11933 } 11934 }); 11935 11936 $(window).on('mouseup.lg', function(e) { 11937 if (isMoved) { 11938 isMoved = false; 11939 _this.touchEnd(endCoords - startCoords); 11940 _this.$el.trigger('onDragend.lg'); 11941 } else if ($(e.target).hasClass('lg-object') || $(e.target).hasClass('lg-video-play')) { 11942 _this.$el.trigger('onSlideClick.lg'); 11943 } 11944 11945 // Prevent execution on click 11946 if (isDraging) { 11947 isDraging = false; 11948 _this.$outer.removeClass('lg-grabbing').addClass('lg-grab'); 11949 } 11950 }); 11951 11952 } 11953 }; 11954 11955 Plugin.prototype.manageSwipeClass = function() { 11956 var _touchNext = this.index + 1; 11957 var _touchPrev = this.index - 1; 11958 if (this.s.loop && this.$slide.length > 2) { 11959 if (this.index === 0) { 11960 _touchPrev = this.$slide.length - 1; 11961 } else if (this.index === this.$slide.length - 1) { 11962 _touchNext = 0; 11963 } 11964 } 11965 11966 this.$slide.removeClass('lg-next-slide lg-prev-slide'); 11967 if (_touchPrev > -1) { 11968 this.$slide.eq(_touchPrev).addClass('lg-prev-slide'); 11969 } 11970 11971 this.$slide.eq(_touchNext).addClass('lg-next-slide'); 11972 }; 11973 11974 Plugin.prototype.mousewheel = function() { 11975 var _this = this; 11976 _this.$outer.on('mousewheel.lg', function(e) { 11977 11978 if (!e.deltaY) { 11979 return; 11980 } 11981 11982 if (e.deltaY > 0) { 11983 _this.goToPrevSlide(); 11984 } else { 11985 _this.goToNextSlide(); 11986 } 11987 11988 e.preventDefault(); 11989 }); 11990 11991 }; 11992 11993 Plugin.prototype.closeGallery = function() { 11994 11995 var _this = this; 11996 var mousedown = false; 11997 this.$outer.find('.lg-close').on('click.lg', function() { 11998 _this.destroy(); 11999 }); 12000 12001 if (_this.s.closable) { 12002 12003 // If you drag the slide and release outside gallery gets close on chrome 12004 // for preventing this check mousedown and mouseup happened on .lg-item or lg-outer 12005 _this.$outer.on('mousedown.lg', function(e) { 12006 12007 if ($(e.target).is('.lg-outer') || $(e.target).is('.lg-item ') || $(e.target).is('.lg-img-wrap')) { 12008 mousedown = true; 12009 } else { 12010 mousedown = false; 12011 } 12012 12013 }); 12014 12015 _this.$outer.on('mousemove.lg', function() { 12016 mousedown = false; 12017 }); 12018 12019 _this.$outer.on('mouseup.lg', function(e) { 12020 12021 if ($(e.target).is('.lg-outer') || $(e.target).is('.lg-item ') || $(e.target).is('.lg-img-wrap') && mousedown) { 12022 if (!_this.$outer.hasClass('lg-dragging')) { 12023 _this.destroy(); 12024 } 12025 } 12026 12027 }); 12028 12029 } 12030 12031 }; 12032 12033 Plugin.prototype.destroy = function(d) { 12034 12035 var _this = this; 12036 12037 if (!d) { 12038 _this.$el.trigger('onBeforeClose.lg'); 12039 $(window).scrollTop(_this.prevScrollTop); 12040 } 12041 12042 12043 /** 12044 * if d is false or undefined destroy will only close the gallery 12045 * plugins instance remains with the element 12046 * 12047 * if d is true destroy will completely remove the plugin 12048 */ 12049 12050 if (d) { 12051 if (!_this.s.dynamic) { 12052 // only when not using dynamic mode is $items a jquery collection 12053 this.$items.off('click.lg click.lgcustom'); 12054 } 12055 12056 $.removeData(_this.el, 'lightGallery'); 12057 } 12058 12059 // Unbind all events added by lightGallery 12060 this.$el.off('.lg.tm'); 12061 12062 // destroy all lightGallery modules 12063 $.each($.fn.lightGallery.modules, function(key) { 12064 if (_this.modules[key]) { 12065 _this.modules[key].destroy(); 12066 } 12067 }); 12068 12069 this.lGalleryOn = false; 12070 12071 clearTimeout(_this.hideBarTimeout); 12072 this.hideBarTimeout = false; 12073 $(window).off('.lg'); 12074 $('body').removeClass('lg-on lg-from-hash'); 12075 12076 if (_this.$outer) { 12077 _this.$outer.removeClass('lg-visible'); 12078 } 12079 12080 $('.lg-backdrop').removeClass('in'); 12081 12082 setTimeout(function() { 12083 if (_this.$outer) { 12084 _this.$outer.remove(); 12085 } 12086 12087 $('.lg-backdrop').remove(); 12088 12089 if (!d) { 12090 _this.$el.trigger('onCloseAfter.lg'); 12091 } 12092 _this.$el.focus(); 12093 12094 }, _this.s.backdropDuration + 50); 12095 }; 12096 12097 $.fn.lightGallery = function(options) { 12098 return this.each(function() { 12099 if (!$.data(this, 'lightGallery')) { 12100 $.data(this, 'lightGallery', new Plugin(this, options)); 12101 } else { 12102 try { 12103 $(this).data('lightGallery').init(); 12104 } catch (err) { 12105 console.error('lightGallery has not initiated properly', err); 12106 } 12107 } 12108 }); 12109 }; 12110 12111 $.fn.lightGallery.modules = {}; 12112 12113})(); 12114 12115 12116})); 12117 12118 12119/***/ }), 12120
vendor: 14,779 bytes, lines 12121-12480
12121/***/ "./node_modules/lightgallery/modules/lg-video.js": 12122/*!*******************************************************!*\ 12123 !*** ./node_modules/lightgallery/modules/lg-video.js ***! 12124 \*******************************************************/ 12125/***/ (function(module, exports, __webpack_require__) { 12126 12127var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/*! lg-video - v1.4.0 - November-07-2020 12128* http://sachinchoolur.github.io/lightGallery 12129* Copyright (c) 2020 Sachin N; Licensed GPLv3 */ 12130 12131(function (root, factory) { 12132 if (true) { 12133 // AMD. Register as an anonymous module unless amdModuleId is set 12134 !(__WEBPACK_AMD_DEFINE_ARRAY__ = [__webpack_require__(/*! jquery */ "./node_modules/jquery/dist/jquery.js")], __WEBPACK_AMD_DEFINE_RESULT__ = (function (a0) { 12135 return (factory(a0)); 12136 }).apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__), 12137 __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); 12138 } else {} 12139}(this, function ($) { 12140 12141(function() { 12142 12143 'use strict'; 12144 12145 var defaults = { 12146 videoMaxWidth: '855px', 12147 12148 autoplayFirstVideo: true, 12149 12150 youtubePlayerParams: false, 12151 vimeoPlayerParams: false, 12152 dailymotionPlayerParams: false, 12153 vkPlayerParams: false, 12154 12155 videojs: false, 12156 videojsOptions: {} 12157 }; 12158 12159 var Video = function(element) { 12160 12161 this.core = $(element).data('lightGallery'); 12162 12163 this.$el = $(element); 12164 this.core.s = $.extend({}, defaults, this.core.s); 12165 this.videoLoaded = false; 12166 12167 this.init(); 12168 12169 return this; 12170 }; 12171 12172 Video.prototype.init = function() { 12173 var _this = this; 12174 12175 // Event triggered when video url found without poster 12176 _this.core.$el.on('hasVideo.lg.tm', onHasVideo.bind(this)); 12177 12178 // Set max width for video 12179 _this.core.$el.on('onAferAppendSlide.lg.tm', onAferAppendSlide.bind(this)); 12180 12181 if (_this.core.doCss() && (_this.core.$items.length > 1) && (_this.core.s.enableSwipe || _this.core.s.enableDrag)) { 12182 _this.core.$el.on('onSlideClick.lg.tm', function() { 12183 var $el = _this.core.$slide.eq(_this.core.index); 12184 _this.loadVideoOnclick($el); 12185 }); 12186 } else { 12187 12188 // For IE 9 and bellow 12189 _this.core.$slide.on('click.lg', function() { 12190 _this.loadVideoOnclick($(this)); 12191 }); 12192 } 12193 12194 _this.core.$el.on('onBeforeSlide.lg.tm', onBeforeSlide.bind(this)); 12195 12196 _this.core.$el.on('onAfterSlide.lg.tm', function(event, prevIndex) { 12197 _this.core.$slide.eq(prevIndex).removeClass('lg-video-playing'); 12198 }); 12199 12200 if (_this.core.s.autoplayFirstVideo) { 12201 _this.core.$el.on('onAferAppendSlide.lg.tm', function (e, index) { 12202 if (!_this.core.lGalleryOn) { 12203 var $el = _this.core.$slide.eq(index); 12204 setTimeout(function () { 12205 _this.loadVideoOnclick($el); 12206 }, 100); 12207 } 12208 }); 12209 } 12210 }; 12211 12212 Video.prototype.loadVideo = function(src, addClass, noPoster, index, html) { 12213 var _this = this; 12214 var video = ''; 12215 var autoplay = 1; 12216 var a = ''; 12217 var isVideo = this.core.isVideo(src, index) || {}; 12218 var videoTitle; 12219 12220 if (_this.core.s.dynamic) { 12221 videoTitle = _this.core.s.dynamicEl[_this.core.index].title; 12222 } else { 12223 videoTitle = _this.core.$items.eq(_this.core.index).attr('title') || _this.core.$items.eq(_this.core.index).find('img').first().attr('alt'); 12224 } 12225 12226 videoTitle = videoTitle ? 'title="' + videoTitle + '"' : ''; 12227 12228 // Enable autoplay based on setting for first video if poster doesn't exist 12229 if (noPoster) { 12230 if (this.videoLoaded) { 12231 autoplay = 0; 12232 } else { 12233 autoplay = this.core.s.autoplayFirstVideo ? 1 : 0; 12234 } 12235 } 12236 12237 if (isVideo.youtube) { 12238 12239 a = '?wmode=opaque&autoplay=' + autoplay + '&enablejsapi=1'; 12240 if (this.core.s.youtubePlayerParams) { 12241 a = a + '&' + $.param(this.core.s.youtubePlayerParams); 12242 } 12243 12244 video = '<iframe allow="autoplay" class="lg-video-object lg-youtube ' + addClass + '" ' + videoTitle + ' width="560" height="315" src="//www.youtube.com/embed/' + isVideo.youtube[1] + a + '" frameborder="0" allowfullscreen></iframe>'; 12245 12246 } else if (isVideo.vimeo) { 12247 12248 a = '?autoplay=' + autoplay; 12249 if (this.core.s.vimeoPlayerParams) { 12250 a = a + '&' + $.param(this.core.s.vimeoPlayerParams); 12251 } 12252 12253 video = '<iframe allow="autoplay" class="lg-video-object lg-vimeo ' + addClass + '" ' + videoTitle + ' width="560" height="315" src="//player.vimeo.com/video/' + isVideo.vimeo[1] + a + '" frameborder="0" webkitAllowFullScreen mozallowfullscreen allowFullScreen></iframe>'; 12254 12255 } else if (isVideo.dailymotion) { 12256 12257 a = '?wmode=opaque&autoplay=' + autoplay + '&api=postMessage'; 12258 if (this.core.s.dailymotionPlayerParams) { 12259 a = a + '&' + $.param(this.core.s.dailymotionPlayerParams); 12260 } 12261 12262 video = '<iframe allow="autoplay" class="lg-video-object lg-dailymotion ' + addClass + '" ' + videoTitle + ' width="560" height="315" src="//www.dailymotion.com/embed/video/' + isVideo.dailymotion[1] + a + '" frameborder="0" allowfullscreen></iframe>'; 12263 12264 } else if (isVideo.html5) { 12265 var fL = html.substring(0, 1); 12266 if (fL === '.' || fL === '#') { 12267 html = $(html).html(); 12268 } 12269 12270 video = html; 12271 12272 } else if (isVideo.vk) { 12273 12274 a = '&autoplay=' + autoplay; 12275 if (this.core.s.vkPlayerParams) { 12276 a = a + '&' + $.param(this.core.s.vkPlayerParams); 12277 } 12278 12279 video = '<iframe allow="autoplay" class="lg-video-object lg-vk ' + addClass + '" ' + videoTitle + ' width="560" height="315" src="//vk.com/video_ext.php?' + isVideo.vk[1] + a + '" frameborder="0" allowfullscreen></iframe>'; 12280 12281 } 12282 12283 return video; 12284 }; 12285 12286 Video.prototype.loadVideoOnclick = function($el){ 12287 12288 var _this = this; 12289 // check slide has poster 12290 if ($el.find('.lg-object').hasClass('lg-has-poster') && $el.find('.lg-object').is(':visible')) { 12291 12292 // check already video element present 12293 if (!$el.hasClass('lg-has-video')) { 12294 12295 $el.addClass('lg-video-playing lg-has-video'); 12296 12297 var _src; 12298 var _html; 12299 var _loadVideo = function(_src, _html) { 12300 12301 $el.find('.lg-video').append(_this.loadVideo(_src, '', false, _this.core.index, _html)); 12302 12303 if (_html) { 12304 if (_this.core.s.videojs) { 12305 try { 12306 videojs(_this.core.$slide.eq(_this.core.index).find('.lg-html5').get(0), _this.core.s.videojsOptions, function() { 12307 this.play(); 12308 }); 12309 } catch (e) { 12310 console.error('lightGallery:- Make sure you have included videojs'); 12311 } 12312 } else { 12313 _this.core.$slide.eq(_this.core.index).find('.lg-html5').get(0).play(); 12314 } 12315 } 12316 12317 }; 12318 12319 if (_this.core.s.dynamic) { 12320 12321 _src = _this.core.s.dynamicEl[_this.core.index].src; 12322 _html = _this.core.s.dynamicEl[_this.core.index].html; 12323 12324 _loadVideo(_src, _html); 12325 12326 } else { 12327 12328 _src = _this.core.$items.eq(_this.core.index).attr('href') || _this.core.$items.eq(_this.core.index).attr('data-src'); 12329 _html = _this.core.$items.eq(_this.core.index).attr('data-html'); 12330 12331 _loadVideo(_src, _html); 12332 12333 } 12334 12335 var $tempImg = $el.find('.lg-object'); 12336 $el.find('.lg-video').append($tempImg); 12337 12338 // @todo loading icon for html5 videos also 12339 // for showing the loading indicator while loading video 12340 if (!$el.find('.lg-video-object').hasClass('lg-html5')) { 12341 $el.removeClass('lg-complete'); 12342 $el.find('.lg-video-object').on('load.lg error.lg', function() { 12343 $el.addClass('lg-complete'); 12344 }); 12345 } 12346 12347 } else { 12348 12349 var youtubePlayer = $el.find('.lg-youtube').get(0); 12350 var vimeoPlayer = $el.find('.lg-vimeo').get(0); 12351 var dailymotionPlayer = $el.find('.lg-dailymotion').get(0); 12352 var html5Player = $el.find('.lg-html5').get(0); 12353 if (youtubePlayer) { 12354 youtubePlayer.contentWindow.postMessage('{"event":"command","func":"playVideo","args":""}', '*'); 12355 } else if (vimeoPlayer) { 12356 try { 12357 new Vimeo.Player(vimeoPlayer).play().catch(function(error) { 12358 console.error('error playing the video:', error.name); 12359 }); 12360 } catch (e) { 12361 console.warn('lightGallery:- Make sure you have included https://github.com/vimeo/player.js'); 12362 } 12363 } else if (dailymotionPlayer) { 12364 dailymotionPlayer.contentWindow.postMessage('play', '*'); 12365 12366 } else if (html5Player) { 12367 if (_this.core.s.videojs) { 12368 try { 12369 videojs(html5Player).play(); 12370 } catch (e) { 12371 console.error('lightGallery:- Make sure you have included videojs'); 12372 } 12373 } else { 12374 html5Player.play(); 12375 } 12376 } 12377 12378 $el.addClass('lg-video-playing'); 12379 12380 } 12381 } 12382 }; 12383 12384 Video.prototype.destroy = function() { 12385 this.videoLoaded = false; 12386 }; 12387 12388 function onHasVideo(event, index, src, html) { 12389 /*jshint validthis:true */ 12390 var _this = this; 12391 _this.core.$slide.eq(index).find('.lg-video').append(_this.loadVideo(src, 'lg-object', true, index, html)); 12392 if (html) { 12393 if (_this.core.s.videojs) { 12394 try { 12395 videojs(_this.core.$slide.eq(index).find('.lg-html5').get(0), _this.core.s.videojsOptions, function() { 12396 if (!_this.videoLoaded && _this.core.s.autoplayFirstVideo) { 12397 this.play(); 12398 } 12399 }); 12400 } catch (e) { 12401 console.error('lightGallery:- Make sure you have included videojs'); 12402 } 12403 } else { 12404 if(!_this.videoLoaded && _this.core.s.autoplayFirstVideo) { 12405 _this.core.$slide.eq(index).find('.lg-html5').get(0).play(); 12406 } 12407 } 12408 } 12409 } 12410 12411 function onAferAppendSlide(event, index) { 12412 /*jshint validthis:true */ 12413 var $videoCont = this.core.$slide.eq(index).find('.lg-video-cont'); 12414 if (!$videoCont.hasClass('lg-has-iframe')) { 12415 $videoCont.css('max-width', this.core.s.videoMaxWidth); 12416 this.videoLoaded = true; 12417 } 12418 } 12419 12420 function onBeforeSlide(event, prevIndex, index) { 12421 /*jshint validthis:true */ 12422 var _this = this; 12423 12424 var $videoSlide = _this.core.$slide.eq(prevIndex); 12425 var youtubePlayer = $videoSlide.find('.lg-youtube').get(0); 12426 var vimeoPlayer = $videoSlide.find('.lg-vimeo').get(0); 12427 var dailymotionPlayer = $videoSlide.find('.lg-dailymotion').get(0); 12428 var vkPlayer = $videoSlide.find('.lg-vk').get(0); 12429 var html5Player = $videoSlide.find('.lg-html5').get(0); 12430 if (youtubePlayer) { 12431 youtubePlayer.contentWindow.postMessage('{"event":"command","func":"pauseVideo","args":""}', '*'); 12432 } else if (vimeoPlayer) { 12433 try { 12434 new Vimeo.Player(vimeoPlayer).pause().catch(function(error) { 12435 console.error('Unable to pause the video:', error.name); 12436 }); 12437 } catch (e) { 12438 console.warn('lightGallery:- Make sure you have included https://github.com/vimeo/player.js'); 12439 } 12440 } else if (dailymotionPlayer) { 12441 dailymotionPlayer.contentWindow.postMessage('pause', '*'); 12442 12443 } else if (html5Player) { 12444 if (_this.core.s.videojs) { 12445 try { 12446 videojs(html5Player).pause(); 12447 } catch (e) { 12448 console.error('lightGallery:- Make sure you have included videojs'); 12449 } 12450 } else { 12451 html5Player.pause(); 12452 } 12453 } if (vkPlayer) { 12454 $(vkPlayer).attr('src', $(vkPlayer).attr('src').replace('&autoplay', '&noplay')); 12455 } 12456 12457 var _src; 12458 if (_this.core.s.dynamic) { 12459 _src = _this.core.s.dynamicEl[index].src; 12460 } else { 12461 _src = _this.core.$items.eq(index).attr('href') || _this.core.$items.eq(index).attr('data-src'); 12462 12463 } 12464 12465 var _isVideo = _this.core.isVideo(_src, index) || {}; 12466 if (_isVideo.youtube || _isVideo.vimeo || _isVideo.dailymotion || _isVideo.vk) { 12467 _this.core.$outer.addClass('lg-hide-download'); 12468 } 12469 12470 } 12471 12472 $.fn.lightGallery.modules.video = Video; 12473 12474 })(); 12475 12476 12477})); 12478 12479 12480/***/ })
vendor: 4,223 bytes, lines 12480-12574
12480 12481 12482/******/ }); 12483/************************************************************************/ 12484/******/ // The module cache 12485/******/ var __webpack_module_cache__ = {}; 12486/******/ 12487/******/ // The require function 12488/******/ function __webpack_require__(moduleId) { 12489/******/ // Check if module is in cache 12490/******/ var cachedModule = __webpack_module_cache__[moduleId]; 12491/******/ if (cachedModule !== undefined) { 12492/******/ return cachedModule.exports; 12493/******/ } 12494/******/ // Create a new module (and put it into the cache) 12495/******/ var module = __webpack_module_cache__[moduleId] = { 12496/******/ // no module.id needed 12497/******/ // no module.loaded needed 12498/******/ exports: {} 12499/******/ }; 12500/******/ 12501/******/ // Execute the module function 12502/******/ __webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__); 12503/******/ 12504/******/ // Return the exports of the module 12505/******/ return module.exports; 12506/******/ } 12507/******/ 12508/************************************************************************/ 12509/******/ /* webpack/runtime/compat get default export */ 12510/******/ (() => { 12511/******/ // getDefaultExport function for compatibility with non-harmony modules 12512/******/ __webpack_require__.n = (module) => { 12513/******/ var getter = module && module.__esModule ? 12514/******/ () => (module['default']) : 12515/******/ () => (module); 12516/******/ __webpack_require__.d(getter, { a: getter }); 12517/******/ return getter; 12518/******/ }; 12519/******/ })(); 12520/******/ 12521/******/ /* webpack/runtime/define property getters */ 12522/******/ (() => { 12523/******/ // define getter functions for harmony exports 12524/******/ __webpack_require__.d = (exports, definition) => { 12525/******/ for(var key in definition) { 12526/******/ if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) { 12527/******/ Object.defineProperty(exports, key, { enumerable: true, get: definition[key] }); 12528/******/ } 12529/******/ } 12530/******/ }; 12531/******/ })(); 12532/******/ 12533/******/ /* webpack/runtime/hasOwnProperty shorthand */ 12534/******/ (() => { 12535/******/ __webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop)) 12536/******/ })(); 12537/******/ 12538/******/ /* webpack/runtime/make namespace object */ 12539/******/ (() => { 12540/******/ // define __esModule on exports 12541/******/ __webpack_require__.r = (exports) => { 12542/******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) { 12543/******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); 12544/******/ } 12545/******/ Object.defineProperty(exports, '__esModule', { value: true }); 12546/******/ }; 12547/******/ })(); 12548/******/ 12549/************************************************************************/ 12550var __webpack_exports__ = {}; 12551// This entry needs to be wrapped in an IIFE because it needs to be in strict mode. 12552(() => { 12553"use strict"; 12554/*!************************************************!*\ 12555 !*** ./assets/js/inner/lightgallery/script.js ***! 12556 \************************************************/ 12557__webpack_require__.r(__webpack_exports__); 12558/* harmony import */ var lightgallery__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! lightgallery */ "./node_modules/lightgallery/dist/js/lightgallery.js"); 12559/* harmony import */ var lightgallery__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(lightgallery__WEBPACK_IMPORTED_MODULE_0__); 12560/* harmony import */ var lightgallery_modules_lg_video__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! lightgallery/modules/lg-video */ "./node_modules/lightgallery/modules/lg-video.js"); 12561/* harmony import */ var lightgallery_modules_lg_video__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(lightgallery_modules_lg_video__WEBPACK_IMPORTED_MODULE_1__); 12562window.$ = window.jQuery = __webpack_require__(/*! jquery */ "./node_modules/jquery/dist/jquery.js"); 12563 12564 12565window.documentReady(function () { 12566 $('#inner-gallery').lightGallery({ 12567 plugins: [(lightgallery_modules_lg_video__WEBPACK_IMPORTED_MODULE_1___default())] 12568 }); 12569 12570 // lightGallery 12571 var _album_gallery = $('.album-gallery'); 12572 if (_album_gallery.length) { 12573 _album_gallery.each(function () { 12574 $(this).lightGallery({
12575 selector: '.photo-item', 12576 galleryId: $(this).attr('data-id'), 12577 iframeMaxWidth: '50%' 12578 }); 12579 }); 12580 } 12581}); 12582})(); 12583 12584/******/ })() 12585;
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.