1/******/ (() => { // webpackBootstrap 2/******/ var __webpack_modules__ = ({ 3 4/***/ 755: 5/***/ (function
vendor: 12,488 bytes, lines 5-514
5(module, exports) { 6 7var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/*! 8 * jQuery JavaScript Library v3.7.1 9 * https://jquery.com/ 10 * 11 * Copyright OpenJS Foundation and other contributors 12 * Released under the MIT license 13 * https://jquery.org/license 14 * 15 * Date: 2023-08-28T13:37Z 16 */ 17( function( global, factory ) { 18 19 "use strict"; 20 21 if ( true && typeof module.exports === "object" ) { 22 23 // For CommonJS and CommonJS-like environments where a proper `window` 24 // is present, execute the factory and get jQuery. 25 // For environments that do not have a `window` with a `document` 26 // (such as Node.js), expose a factory as module.exports. 27 // This accentuates the need for the creation of a real `window`. 28 // e.g. var jQuery = require("jquery")(window); 29 // See ticket trac-14549 for more info. 30 module.exports = global.document ? 31 factory( global, true ) : 32 function( w ) { 33 if ( !w.document ) { 34 throw new Error( "jQuery requires a window with a document" ); 35 } 36 return factory( w ); 37 }; 38 } else { 39 factory( global ); 40 } 41 42// Pass this if window is not defined yet 43} )( typeof window !== "undefined" ? window : this, function( window, noGlobal ) { 44 45// Edge <= 12 - 13+, Firefox <=18 - 45+, IE 10 - 11, Safari 5.1 - 9+, iOS 6 - 9.1 46// throw exceptions when non-strict code (e.g., ASP.NET 4.5) accesses strict mode 47// arguments.callee.caller (trac-13335). But as of jQuery 3.0 (2016), strict mode should be common 48// enough that all such attempts are guarded in a try block. 49"use strict"; 50 51var arr = []; 52 53var getProto = Object.getPrototypeOf; 54 55var slice = arr.slice; 56 57var flat = arr.flat ? function( array ) { 58 return arr.flat.call( array ); 59} : function( array ) { 60 return arr.concat.apply( [], array ); 61}; 62 63 64var push = arr.push; 65 66var indexOf = arr.indexOf; 67 68var class2type = {}; 69 70var toString = class2type.toString; 71 72var hasOwn = class2type.hasOwnProperty; 73 74var fnToString = hasOwn.toString; 75 76var ObjectFunctionString = fnToString.call( Object ); 77 78var support = {}; 79 80var isFunction = function isFunction( obj ) { 81 82 // Support: Chrome <=57, Firefox <=52 83 // In some browsers, typeof returns "function" for HTML <object> elements 84 // (i.e., `typeof document.createElement( "object" ) === "function"`). 85 // We don't want to classify *any* DOM node as a function. 86 // Support: QtWeb <=3.8.5, WebKit <=534.34, wkhtmltopdf tool <=0.12.5 87 // Plus for old WebKit, typeof returns "function" for HTML collections 88 // (e.g., `typeof document.getElementsByTagName("div") === "function"`). (gh-4756) 89 return typeof obj === "function" && typeof obj.nodeType !== "number" && 90 typeof obj.item !== "function"; 91 }; 92 93 94var isWindow = function isWindow( obj ) { 95 return obj != null && obj === obj.window; 96 }; 97 98 99var document = window.document; 100 101 102 103 var preservedScriptAttributes = { 104 type: true, 105 src: true, 106 nonce: true, 107 noModule: true 108 }; 109 110 function DOMEval( code, node, doc ) { 111 doc = doc || document; 112 113 var i, val, 114 script = doc.createElement( "script" ); 115 116 script.text = code; 117 if ( node ) { 118 for ( i in preservedScriptAttributes ) { 119 120 // Support: Firefox 64+, Edge 18+ 121 // Some browsers don't support the "nonce" property on scripts. 122 // On the other hand, just using `getAttribute` is not enough as 123 // the `nonce` attribute is reset to an empty string whenever it 124 // becomes browsing-context connected. 125 // See https://github.com/whatwg/html/issues/2369 126 // See https://html.spec.whatwg.org/#nonce-attributes 127 // The `node.getAttribute` check was added for the sake of 128 // `jQuery.globalEval` so that it can fake a nonce-containing node 129 // via an object. 130 val = node[ i ] || node.getAttribute && node.getAttribute( i ); 131 if ( val ) { 132 script.setAttribute( i, val ); 133 } 134 } 135 } 136 doc.head.appendChild( script ).parentNode.removeChild( script ); 137 } 138 139 140function toType( obj ) { 141 if ( obj == null ) { 142 return obj + ""; 143 } 144 145 // Support: Android <=2.3 only (functionish RegExp) 146 return typeof obj === "object" || typeof obj === "function" ? 147 class2type[ toString.call( obj ) ] || "object" : 148 typeof obj; 149} 150/* global Symbol */ 151// Defining this global in .eslintrc.json would create a danger of using the global 152// unguarded in another place, it seems safer to define global only for this module 153 154 155 156var version = "3.7.1", 157 158 rhtmlSuffix = /HTML$/i, 159 160 // Define a local copy of jQuery 161 jQuery = function( selector, context ) { 162 163 // The jQuery object is actually just the init constructor 'enhanced' 164 // Need init if jQuery is called (just allow error to be thrown if not included) 165 return new jQuery.fn.init( selector, context ); 166 }; 167 168jQuery.fn = jQuery.prototype = { 169 170 // The current version of jQuery being used 171 jquery: version, 172 173 constructor: jQuery, 174 175 // The default length of a jQuery object is 0 176 length: 0, 177 178 toArray: function() { 179 return slice.call( this ); 180 }, 181 182 // Get the Nth element in the matched element set OR 183 // Get the whole matched element set as a clean array 184 get: function( num ) { 185 186 // Return all the elements in a clean array 187 if ( num == null ) { 188 return slice.call( this ); 189 } 190 191 // Return just the one element from the set 192 return num < 0 ? this[ num + this.length ] : this[ num ]; 193 }, 194 195 // Take an array of elements and push it onto the stack 196 // (returning the new matched element set) 197 pushStack: function( elems ) { 198 199 // Build a new jQuery matched element set 200 var ret = jQuery.merge( this.constructor(), elems ); 201 202 // Add the old object onto the stack (as a reference) 203 ret.prevObject = this; 204 205 // Return the newly-formed element set 206 return ret; 207 }, 208 209 // Execute a callback for every element in the matched set. 210 each: function( callback ) { 211 return jQuery.each( this, callback ); 212 }, 213 214 map: function( callback ) { 215 return this.pushStack( jQuery.map( this, function( elem, i ) { 216 return callback.call( elem, i, elem ); 217 } ) ); 218 }, 219 220 slice: function() { 221 return this.pushStack( slice.apply( this, arguments ) ); 222 }, 223 224 first: function() { 225 return this.eq( 0 ); 226 }, 227 228 last: function() { 229 return this.eq( -1 ); 230 }, 231 232 even: function() { 233 return this.pushStack( jQuery.grep( this, function( _elem, i ) { 234 return ( i + 1 ) % 2; 235 } ) ); 236 }, 237 238 odd: function() { 239 return this.pushStack( jQuery.grep( this, function( _elem, i ) { 240 return i % 2; 241 } ) ); 242 }, 243 244 eq: function( i ) { 245 var len = this.length, 246 j = +i + ( i < 0 ? len : 0 ); 247 return this.pushStack( j >= 0 && j < len ? [ this[ j ] ] : [] ); 248 }, 249 250 end: function() { 251 return this.prevObject || this.constructor(); 252 }, 253 254 // For internal use only. 255 // Behaves like an Array's method, not like a jQuery method. 256 push: push, 257 sort: arr.sort, 258 splice: arr.splice 259}; 260 261jQuery.extend = jQuery.fn.extend = function() { 262 var options, name, src, copy, copyIsArray, clone, 263 target = arguments[ 0 ] || {}, 264 i = 1, 265 length = arguments.length, 266 deep = false; 267 268 // Handle a deep copy situation 269 if ( typeof target === "boolean" ) { 270 deep = target; 271 272 // Skip the boolean and the target 273 target = arguments[ i ] || {}; 274 i++; 275 } 276 277 // Handle case when target is a string or something (possible in deep copy) 278 if ( typeof target !== "object" && !isFunction( target ) ) { 279 target = {}; 280 } 281 282 // Extend jQuery itself if only one argument is passed 283 if ( i === length ) { 284 target = this; 285 i--; 286 } 287 288 for ( ; i < length; i++ ) { 289 290 // Only deal with non-null/undefined values 291 if ( ( options = arguments[ i ] ) != null ) { 292 293 // Extend the base object 294 for ( name in options ) { 295 copy = options[ name ]; 296 297 // Prevent Object.prototype pollution 298 // Prevent never-ending loop 299 if ( name === "__proto__" || target === copy ) { 300 continue; 301 } 302 303 // Recurse if we're merging plain objects or arrays 304 if ( deep && copy && ( jQuery.isPlainObject( copy ) || 305 ( copyIsArray = Array.isArray( copy ) ) ) ) { 306 src = target[ name ]; 307 308 // Ensure proper type for the source value 309 if ( copyIsArray && !Array.isArray( src ) ) { 310 clone = []; 311 } else if ( !copyIsArray && !jQuery.isPlainObject( src ) ) { 312 clone = {}; 313 } else { 314 clone = src; 315 } 316 copyIsArray = false; 317 318 // Never move original objects, clone them 319 target[ name ] = jQuery.extend( deep, clone, copy ); 320 321 // Don't bring in undefined values 322 } else if ( copy !== undefined ) { 323 target[ name ] = copy; 324 } 325 } 326 } 327 } 328 329 // Return the modified object 330 return target; 331}; 332 333jQuery.extend( { 334 335 // Unique for each copy of jQuery on the page 336 expando: "jQuery" + ( version + Math.random() ).replace( /\D/g, "" ), 337 338 // Assume jQuery is ready without the ready module 339 isReady: true, 340 341 error: function( msg ) { 342 throw new Error( msg ); 343 }, 344 345 noop: function() {}, 346 347 isPlainObject: function( obj ) { 348 var proto, Ctor; 349 350 // Detect obvious negatives 351 // Use toString instead of jQuery.type to catch host objects 352 if ( !obj || toString.call( obj ) !== "[object Object]" ) { 353 return false; 354 } 355 356 proto = getProto( obj ); 357 358 // Objects with no prototype (e.g., `Object.create( null )`) are plain 359 if ( !proto ) { 360 return true; 361 } 362 363 // Objects with prototype are plain iff they were constructed by a global Object function 364 Ctor = hasOwn.call( proto, "constructor" ) && proto.constructor; 365 return typeof Ctor === "function" && fnToString.call( Ctor ) === ObjectFunctionString; 366 }, 367 368 isEmptyObject: function( obj ) { 369 var name; 370 371 for ( name in obj ) { 372 return false; 373 } 374 return true; 375 }, 376 377 // Evaluates a script in a provided context; falls back to the global one 378 // if not specified. 379 globalEval: function( code, options, doc ) { 380 DOMEval( code, { nonce: options && options.nonce }, doc ); 381 }, 382 383 each: function( obj, callback ) { 384 var length, i = 0; 385 386 if ( isArrayLike( obj ) ) { 387 length = obj.length; 388 for ( ; i < length; i++ ) { 389 if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) { 390 break; 391 } 392 } 393 } else { 394 for ( i in obj ) { 395 if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) { 396 break; 397 } 398 } 399 } 400 401 return obj; 402 }, 403 404 405 // Retrieve the text value of an array of DOM nodes 406 text: function( elem ) { 407 var node, 408 ret = "", 409 i = 0, 410 nodeType = elem.nodeType; 411 412 if ( !nodeType ) { 413 414 // If no nodeType, this is expected to be an array 415 while ( ( node = elem[ i++ ] ) ) { 416 417 // Do not traverse comment nodes 418 ret += jQuery.text( node ); 419 } 420 } 421 if ( nodeType === 1 || nodeType === 11 ) { 422 return elem.textContent; 423 } 424 if ( nodeType === 9 ) { 425 return elem.documentElement.textContent; 426 } 427 if ( nodeType === 3 || nodeType === 4 ) { 428 return elem.nodeValue; 429 } 430 431 // Do not include comment or processing instruction nodes 432 433 return ret; 434 }, 435 436 // results is for internal usage only 437 makeArray: function( arr, results ) { 438 var ret = results || []; 439 440 if ( arr != null ) { 441 if ( isArrayLike( Object( arr ) ) ) { 442 jQuery.merge( ret, 443 typeof arr === "string" ? 444 [ arr ] : arr 445 ); 446 } else { 447 push.call( ret, arr ); 448 } 449 } 450 451 return ret; 452 }, 453 454 inArray: function( elem, arr, i ) { 455 return arr == null ? -1 : indexOf.call( arr, elem, i ); 456 }, 457 458 isXMLDoc: function( elem ) { 459 var namespace = elem && elem.namespaceURI, 460 docElem = elem && ( elem.ownerDocument || elem ).documentElement; 461 462 // Assume HTML when documentElement doesn't yet exist, such as inside 463 // document fragments. 464 return !rhtmlSuffix.test( namespace || docElem && docElem.nodeName || "HTML" ); 465 }, 466 467 // Support: Android <=4.0 only, PhantomJS 1 only 468 // push.apply(_, arraylike) throws on ancient WebKit 469 merge: function( first, second ) { 470 var len = +second.length, 471 j = 0, 472 i = first.length; 473 474 for ( ; j < len; j++ ) { 475 first[ i++ ] = second[ j ]; 476 } 477 478 first.length = i; 479 480 return first; 481 }, 482 483 grep: function( elems, callback, invert ) { 484 var callbackInverse, 485 matches = [], 486 i = 0, 487 length = elems.length, 488 callbackExpect = !invert; 489 490 // Go through the array, only saving the items 491 // that pass the validator function 492 for ( ; i < length; i++ ) { 493 callbackInverse = !callback( elems[ i ], i ); 494 if ( callbackInverse !== callbackExpect ) { 495 matches.push( elems[ i ] ); 496 } 497 } 498 499 return matches; 500 }, 501 502 // arg is for internal usage only 503 map: function( elems, callback, arg ) { 504 var length, value, 505 i = 0, 506 ret = []; 507 508 // Go through the array, translating each of the items to their new values 509 if ( isArrayLike( elems ) ) { 510 length = elems.length; 511 for ( ; i < length; i++ ) { 512 value = callback( elems[ i ], i, arg ); 513 514 if ( value != null ) {
vendor: 17,514 bytes, lines 515-1136
515 ret.push( value ); 516 } 517 } 518 519 // Go through every key on the object, 520 } else { 521 for ( i in elems ) { 522 value = callback( elems[ i ], i, arg ); 523 524 if ( value != null ) { 525 ret.push( value ); 526 } 527 } 528 } 529 530 // Flatten any nested arrays 531 return flat( ret ); 532 }, 533 534 // A global GUID counter for objects 535 guid: 1, 536 537 // jQuery.support is not used in Core but other projects attach their 538 // properties to it so it needs to exist. 539 support: support 540} ); 541 542if ( typeof Symbol === "function" ) { 543 jQuery.fn[ Symbol.iterator ] = arr[ Symbol.iterator ]; 544} 545 546// Populate the class2type map 547jQuery.each( "Boolean Number String Function Array Date RegExp Object Error Symbol".split( " " ), 548 function( _i, name ) { 549 class2type[ "[object " + name + "]" ] = name.toLowerCase(); 550 } ); 551 552function isArrayLike( obj ) { 553 554 // Support: real iOS 8.2 only (not reproducible in simulator) 555 // `in` check used to prevent JIT error (gh-2145) 556 // hasOwn isn't used here due to false negatives 557 // regarding Nodelist length in IE 558 var length = !!obj && "length" in obj && obj.length, 559 type = toType( obj ); 560 561 if ( isFunction( obj ) || isWindow( obj ) ) { 562 return false; 563 } 564 565 return type === "array" || length === 0 || 566 typeof length === "number" && length > 0 && ( length - 1 ) in obj; 567} 568 569 570function nodeName( elem, name ) { 571 572 return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase(); 573 574} 575var pop = arr.pop; 576 577 578var sort = arr.sort; 579 580 581var splice = arr.splice; 582 583 584var whitespace = "[\\x20\\t\\r\\n\\f]"; 585 586 587var rtrimCSS = new RegExp( 588 "^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" + whitespace + "+$", 589 "g" 590); 591 592 593 594 595// Note: an element does not contain itself 596jQuery.contains = function( a, b ) { 597 var bup = b && b.parentNode; 598 599 return a === bup || !!( bup && bup.nodeType === 1 && ( 600 601 // Support: IE 9 - 11+ 602 // IE doesn't have `contains` on SVG. 603 a.contains ? 604 a.contains( bup ) : 605 a.compareDocumentPosition && a.compareDocumentPosition( bup ) & 16 606 ) ); 607}; 608 609 610 611 612// CSS string/identifier serialization 613// https://drafts.csswg.org/cssom/#common-serializing-idioms 614var rcssescape = /([\0-\x1f\x7f]|^-?\d)|^-$|[^\x80-\uFFFF\w-]/g; 615 616function fcssescape( ch, asCodePoint ) { 617 if ( asCodePoint ) { 618 619 // U+0000 NULL becomes U+FFFD REPLACEMENT CHARACTER 620 if ( ch === "\0" ) { 621 return "\uFFFD"; 622 } 623 624 // Control characters and (dependent upon position) numbers get escaped as code points 625 return ch.slice( 0, -1 ) + "\\" + ch.charCodeAt( ch.length - 1 ).toString( 16 ) + " "; 626 } 627 628 // Other potentially-special ASCII characters get backslash-escaped 629 return "\\" + ch; 630} 631 632jQuery.escapeSelector = function( sel ) { 633 return ( sel + "" ).replace( rcssescape, fcssescape ); 634}; 635 636 637 638 639var preferredDoc = document, 640 pushNative = push; 641 642( function() { 643 644var i, 645 Expr, 646 outermostContext, 647 sortInput, 648 hasDuplicate, 649 push = pushNative, 650 651 // Local document vars 652 document, 653 documentElement, 654 documentIsHTML, 655 rbuggyQSA, 656 matches, 657 658 // Instance-specific data 659 expando = jQuery.expando, 660 dirruns = 0, 661 done = 0, 662 classCache = createCache(), 663 tokenCache = createCache(), 664 compilerCache = createCache(), 665 nonnativeSelectorCache = createCache(), 666 sortOrder = function( a, b ) { 667 if ( a === b ) { 668 hasDuplicate = true; 669 } 670 return 0; 671 }, 672 673 booleans = "checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|" + 674 "loop|multiple|open|readonly|required|scoped", 675 676 // Regular expressions 677 678 // https://www.w3.org/TR/css-syntax-3/#ident-token-diagram 679 identifier = "(?:\\\\[\\da-fA-F]{1,6}" + whitespace + 680 "?|\\\\[^\\r\\n\\f]|[\\w-]|[^\0-\\x7f])+", 681 682 // Attribute selectors: https://www.w3.org/TR/selectors/#attribute-selectors 683 attributes = "\\[" + whitespace + "*(" + identifier + ")(?:" + whitespace + 684 685 // Operator (capture 2) 686 "*([*^$|!~]?=)" + whitespace + 687 688 // "Attribute values must be CSS identifiers [capture 5] or strings [capture 3 or capture 4]" 689 "*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|(" + identifier + "))|)" + 690 whitespace + "*\\]", 691 692 pseudos = ":(" + identifier + ")(?:\\((" + 693 694 // To reduce the number of selectors needing tokenize in the preFilter, prefer arguments: 695 // 1. quoted (capture 3; capture 4 or capture 5) 696 "('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|" + 697 698 // 2. simple (capture 6) 699 "((?:\\\\.|[^\\\\()[\\]]|" + attributes + ")*)|" + 700 701 // 3. anything else (capture 2) 702 ".*" + 703 ")\\)|)", 704 705 // Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter 706 rwhitespace = new RegExp( whitespace + "+", "g" ), 707 708 rcomma = new RegExp( "^" + whitespace + "*," + whitespace + "*" ), 709 rleadingCombinator = new RegExp( "^" + whitespace + "*([>+~]|" + whitespace + ")" + 710 whitespace + "*" ), 711 rdescend = new RegExp( whitespace + "|>" ), 712 713 rpseudo = new RegExp( pseudos ), 714 ridentifier = new RegExp( "^" + identifier + "$" ), 715 716 matchExpr = { 717 ID: new RegExp( "^#(" + identifier + ")" ), 718 CLASS: new RegExp( "^\\.(" + identifier + ")" ), 719 TAG: new RegExp( "^(" + identifier + "|[*])" ), 720 ATTR: new RegExp( "^" + attributes ), 721 PSEUDO: new RegExp( "^" + pseudos ), 722 CHILD: new RegExp( 723 "^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(" + 724 whitespace + "*(even|odd|(([+-]|)(\\d*)n|)" + whitespace + "*(?:([+-]|)" + 725 whitespace + "*(\\d+)|))" + whitespace + "*\\)|)", "i" ), 726 bool: new RegExp( "^(?:" + booleans + ")$", "i" ), 727 728 // For use in libraries implementing .is() 729 // We use this for POS matching in `select` 730 needsContext: new RegExp( "^" + whitespace + 731 "*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(" + whitespace + 732 "*((?:-\\d)?\\d*)" + whitespace + "*\\)|)(?=[^-]|$)", "i" ) 733 }, 734 735 rinputs = /^(?:input|select|textarea|button)$/i, 736 rheader = /^h\d$/i, 737 738 // Easily-parseable/retrievable ID or TAG or CLASS selectors 739 rquickExpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/, 740 741 rsibling = /[+~]/, 742 743 // CSS escapes 744 // https://www.w3.org/TR/CSS21/syndata.html#escaped-characters 745 runescape = new RegExp( "\\\\[\\da-fA-F]{1,6}" + whitespace + 746 "?|\\\\([^\\r\\n\\f])", "g" ), 747 funescape = function( escape, nonHex ) { 748 var high = "0x" + escape.slice( 1 ) - 0x10000; 749 750 if ( nonHex ) { 751 752 // Strip the backslash prefix from a non-hex escape sequence 753 return nonHex; 754 } 755 756 // Replace a hexadecimal escape sequence with the encoded Unicode code point 757 // Support: IE <=11+ 758 // For values outside the Basic Multilingual Plane (BMP), manually construct a 759 // surrogate pair 760 return high < 0 ? 761 String.fromCharCode( high + 0x10000 ) : 762 String.fromCharCode( high >> 10 | 0xD800, high & 0x3FF | 0xDC00 ); 763 }, 764 765 // Used for iframes; see `setDocument`. 766 // Support: IE 9 - 11+, Edge 12 - 18+ 767 // Removing the function wrapper causes a "Permission Denied" 768 // error in IE/Edge. 769 unloadHandler = function() { 770 setDocument(); 771 }, 772 773 inDisabledFieldset = addCombinator( 774 function( elem ) { 775 return elem.disabled === true && nodeName( elem, "fieldset" ); 776 }, 777 { dir: "parentNode", next: "legend" } 778 ); 779 780// Support: IE <=9 only 781// Accessing document.activeElement can throw unexpectedly 782// https://bugs.jquery.com/ticket/13393 783function safeActiveElement() { 784 try { 785 return document.activeElement; 786 } catch ( err ) { } 787} 788 789// Optimize for push.apply( _, NodeList ) 790try { 791 push.apply( 792 ( arr = slice.call( preferredDoc.childNodes ) ), 793 preferredDoc.childNodes 794 ); 795 796 // Support: Android <=4.0 797 // Detect silently failing push.apply 798 // eslint-disable-next-line no-unused-expressions 799 arr[ preferredDoc.childNodes.length ].nodeType; 800} catch ( e ) { 801 push = { 802 apply: function( target, els ) { 803 pushNative.apply( target, slice.call( els ) ); 804 }, 805 call: function( target ) { 806 pushNative.apply( target, slice.call( arguments, 1 ) ); 807 } 808 }; 809} 810 811function find( selector, context, results, seed ) { 812 var m, i, elem, nid, match, groups, newSelector, 813 newContext = context && context.ownerDocument, 814 815 // nodeType defaults to 9, since context defaults to document 816 nodeType = context ? context.nodeType : 9; 817 818 results = results || []; 819 820 // Return early from calls with invalid selector or context 821 if ( typeof selector !== "string" || !selector || 822 nodeType !== 1 && nodeType !== 9 && nodeType !== 11 ) { 823 824 return results; 825 } 826 827 // Try to shortcut find operations (as opposed to filters) in HTML documents 828 if ( !seed ) { 829 setDocument( context ); 830 context = context || document; 831 832 if ( documentIsHTML ) { 833 834 // If the selector is sufficiently simple, try using a "get*By*" DOM method 835 // (excepting DocumentFragment context, where the methods don't exist) 836 if ( nodeType !== 11 && ( match = rquickExpr.exec( selector ) ) ) { 837 838 // ID selector 839 if ( ( m = match[ 1 ] ) ) { 840 841 // Document context 842 if ( nodeType === 9 ) { 843 if ( ( elem = context.getElementById( m ) ) ) { 844 845 // Support: IE 9 only 846 // getElementById can match elements by name instead of ID 847 if ( elem.id === m ) { 848 push.call( results, elem ); 849 return results; 850 } 851 } else { 852 return results; 853 } 854 855 // Element context 856 } else { 857 858 // Support: IE 9 only 859 // getElementById can match elements by name instead of ID 860 if ( newContext && ( elem = newContext.getElementById( m ) ) && 861 find.contains( context, elem ) && 862 elem.id === m ) { 863 864 push.call( results, elem ); 865 return results; 866 } 867 } 868 869 // Type selector 870 } else if ( match[ 2 ] ) { 871 push.apply( results, context.getElementsByTagName( selector ) ); 872 return results; 873 874 // Class selector 875 } else if ( ( m = match[ 3 ] ) && context.getElementsByClassName ) { 876 push.apply( results, context.getElementsByClassName( m ) ); 877 return results; 878 } 879 } 880 881 // Take advantage of querySelectorAll 882 if ( !nonnativeSelectorCache[ selector + " " ] && 883 ( !rbuggyQSA || !rbuggyQSA.test( selector ) ) ) { 884 885 newSelector = selector; 886 newContext = context; 887 888 // qSA considers elements outside a scoping root when evaluating child or 889 // descendant combinators, which is not what we want. 890 // In such cases, we work around the behavior by prefixing every selector in the 891 // list with an ID selector referencing the scope context. 892 // The technique has to be used as well when a leading combinator is used 893 // as such selectors are not recognized by querySelectorAll. 894 // Thanks to Andrew Dupont for this technique. 895 if ( nodeType === 1 && 896 ( rdescend.test( selector ) || rleadingCombinator.test( selector ) ) ) { 897 898 // Expand context for sibling selectors 899 newContext = rsibling.test( selector ) && testContext( context.parentNode ) || 900 context; 901 902 // We can use :scope instead of the ID hack if the browser 903 // supports it & if we're not changing the context. 904 // Support: IE 11+, Edge 17 - 18+ 905 // IE/Edge sometimes throw a "Permission denied" error when 906 // strict-comparing two documents; shallow comparisons work. 907 // eslint-disable-next-line eqeqeq 908 if ( newContext != context || !support.scope ) { 909 910 // Capture the context ID, setting it first if necessary 911 if ( ( nid = context.getAttribute( "id" ) ) ) { 912 nid = jQuery.escapeSelector( nid ); 913 } else { 914 context.setAttribute( "id", ( nid = expando ) ); 915 } 916 } 917 918 // Prefix every selector in the list 919 groups = tokenize( selector ); 920 i = groups.length; 921 while ( i-- ) { 922 groups[ i ] = ( nid ? "#" + nid : ":scope" ) + " " + 923 toSelector( groups[ i ] ); 924 } 925 newSelector = groups.join( "," ); 926 } 927 928 try { 929 push.apply( results, 930 newContext.querySelectorAll( newSelector ) 931 ); 932 return results; 933 } catch ( qsaError ) { 934 nonnativeSelectorCache( selector, true ); 935 } finally { 936 if ( nid === expando ) { 937 context.removeAttribute( "id" ); 938 } 939 } 940 } 941 } 942 } 943 944 // All others 945 return select( selector.replace( rtrimCSS, "$1" ), context, results, seed ); 946} 947 948/** 949 * Create key-value caches of limited size 950 * @returns {function(string, object)} Returns the Object data after storing it on itself with 951 * property name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength) 952 * deleting the oldest entry 953 */ 954function createCache() { 955 var keys = []; 956 957 function cache( key, value ) { 958 959 // Use (key + " ") to avoid collision with native prototype properties 960 // (see https://github.com/jquery/sizzle/issues/157) 961 if ( keys.push( key + " " ) > Expr.cacheLength ) { 962 963 // Only keep the most recent entries 964 delete cache[ keys.shift() ]; 965 } 966 return ( cache[ key + " " ] = value ); 967 } 968 return cache; 969} 970 971/** 972 * Mark a function for special use by jQuery selector module 973 * @param {Function} fn The function to mark 974 */ 975function markFunction( fn ) { 976 fn[ expando ] = true; 977 return fn; 978} 979 980/** 981 * Support testing using an element 982 * @param {Function} fn Passed the created element and returns a boolean result 983 */ 984function assert( fn ) { 985 var el = document.createElement( "fieldset" ); 986 987 try { 988 return !!fn( el ); 989 } catch ( e ) { 990 return false; 991 } finally { 992 993 // Remove from its parent by default 994 if ( el.parentNode ) { 995 el.parentNode.removeChild( el ); 996 } 997 998 // release memory in IE 999 el = null; 1000 } 1001} 1002 1003/** 1004 * Returns a function to use in pseudos for input types 1005 * @param {String} type 1006 */ 1007function createInputPseudo( type ) { 1008 return function( elem ) { 1009 return nodeName( elem, "input" ) && elem.type === type; 1010 }; 1011} 1012 1013/** 1014 * Returns a function to use in pseudos for buttons 1015 * @param {String} type 1016 */ 1017function createButtonPseudo( type ) { 1018 return function( elem ) { 1019 return ( nodeName( elem, "input" ) || nodeName( elem, "button" ) ) && 1020 elem.type === type; 1021 }; 1022} 1023 1024/** 1025 * Returns a function to use in pseudos for :enabled/:disabled 1026 * @param {Boolean} disabled true for :disabled; false for :enabled 1027 */ 1028function createDisabledPseudo( disabled ) { 1029 1030 // Known :disabled false positives: fieldset[disabled] > legend:nth-of-type(n+2) :can-disable 1031 return function( elem ) { 1032 1033 // Only certain elements can match :enabled or :disabled 1034 // https://html.spec.whatwg.org/multipage/scripting.html#selector-enabled 1035 // https://html.spec.whatwg.org/multipage/scripting.html#selector-disabled 1036 if ( "form" in elem ) { 1037 1038 // Check for inherited disabledness on relevant non-disabled elements: 1039 // * listed form-associated elements in a disabled fieldset 1040 // https://html.spec.whatwg.org/multipage/forms.html#category-listed 1041 // https://html.spec.whatwg.org/multipage/forms.html#concept-fe-disabled 1042 // * option elements in a disabled optgroup 1043 // https://html.spec.whatwg.org/multipage/forms.html#concept-option-disabled 1044 // All such elements have a "form" property. 1045 if ( elem.parentNode && elem.disabled === false ) { 1046 1047 // Option elements defer to a parent optgroup if present 1048 if ( "label" in elem ) { 1049 if ( "label" in elem.parentNode ) { 1050 return elem.parentNode.disabled === disabled; 1051 } else { 1052 return elem.disabled === disabled; 1053 } 1054 } 1055 1056 // Support: IE 6 - 11+ 1057 // Use the isDisabled shortcut property to check for disabled fieldset ancestors 1058 return elem.isDisabled === disabled || 1059 1060 // Where there is no isDisabled, check manually 1061 elem.isDisabled !== !disabled && 1062 inDisabledFieldset( elem ) === disabled; 1063 } 1064 1065 return elem.disabled === disabled; 1066 1067 // Try to winnow out elements that can't be disabled before trusting the disabled property. 1068 // Some victims get caught in our net (label, legend, menu, track), but it shouldn't 1069 // even exist on them, let alone have a boolean value. 1070 } else if ( "label" in elem ) { 1071 return elem.disabled === disabled; 1072 } 1073 1074 // Remaining elements are neither :enabled nor :disabled 1075 return false; 1076 }; 1077} 1078 1079/** 1080 * Returns a function to use in pseudos for positionals 1081 * @param {Function} fn 1082 */ 1083function createPositionalPseudo( fn ) { 1084 return markFunction( function( argument ) { 1085 argument = +argument; 1086 return markFunction( function( seed, matches ) { 1087 var j, 1088 matchIndexes = fn( [], seed.length, argument ), 1089 i = matchIndexes.length; 1090 1091 // Match elements found at the specified indexes 1092 while ( i-- ) { 1093 if ( seed[ ( j = matchIndexes[ i ] ) ] ) { 1094 seed[ j ] = !( matches[ j ] = seed[ j ] ); 1095 } 1096 } 1097 } ); 1098 } ); 1099} 1100 1101/** 1102 * Checks a node for validity as a jQuery selector context 1103 * @param {Element|Object=} context 1104 * @returns {Element|Object|Boolean} The input node if acceptable, otherwise a falsy value 1105 */ 1106function testContext( context ) { 1107 return context && typeof context.getElementsByTagName !== "undefined" && context; 1108} 1109 1110/** 1111 * Sets document-related variables once based on the current document 1112 * @param {Element|Object} [node] An element or document object to use to set the document 1113 * @returns {Object} Returns the current document 1114 */ 1115function setDocument( node ) { 1116 var subWindow, 1117 doc = node ? node.ownerDocument || node : preferredDoc; 1118 1119 // Return early if doc is invalid or already selected 1120 // Support: IE 11+, Edge 17 - 18+ 1121 // IE/Edge sometimes throw a "Permission denied" error when strict-comparing 1122 // two documents; shallow comparisons work. 1123 // eslint-disable-next-line eqeqeq 1124 if ( doc == document || doc.nodeType !== 9 || !doc.documentElement ) { 1125 return document; 1126 } 1127 1128 // Update global variables 1129 document = doc; 1130 documentElement = document.documentElement; 1131 documentIsHTML = !jQuery.isXMLDoc( document ); 1132 1133 // Support: iOS 7 only, IE 9 - 11+ 1134 // Older browsers didn't support unprefixed `matches`. 1135 matches = documentElement.matches || 1136 documentElement.webkitMatchesSelector ||
vendor: 4,667 bytes, lines 1137-1288
1137 documentElement.msMatchesSelector; 1138 1139 // Support: IE 9 - 11+, Edge 12 - 18+ 1140 // Accessing iframe documents after unload throws "permission denied" errors 1141 // (see trac-13936). 1142 // Limit the fix to IE & Edge Legacy; despite Edge 15+ implementing `matches`, 1143 // all IE 9+ and Edge Legacy versions implement `msMatchesSelector` as well. 1144 if ( documentElement.msMatchesSelector && 1145 1146 // Support: IE 11+, Edge 17 - 18+ 1147 // IE/Edge sometimes throw a "Permission denied" error when strict-comparing 1148 // two documents; shallow comparisons work. 1149 // eslint-disable-next-line eqeqeq 1150 preferredDoc != document && 1151 ( subWindow = document.defaultView ) && subWindow.top !== subWindow ) { 1152 1153 // Support: IE 9 - 11+, Edge 12 - 18+ 1154 subWindow.addEventListener( "unload", unloadHandler ); 1155 } 1156 1157 // Support: IE <10 1158 // Check if getElementById returns elements by name 1159 // The broken getElementById methods don't pick up programmatically-set names, 1160 // so use a roundabout getElementsByName test 1161 support.getById = assert( function( el ) { 1162 documentElement.appendChild( el ).id = jQuery.expando; 1163 return !document.getElementsByName || 1164 !document.getElementsByName( jQuery.expando ).length; 1165 } ); 1166 1167 // Support: IE 9 only 1168 // Check to see if it's possible to do matchesSelector 1169 // on a disconnected node. 1170 support.disconnectedMatch = assert( function( el ) { 1171 return matches.call( el, "*" ); 1172 } ); 1173 1174 // Support: IE 9 - 11+, Edge 12 - 18+ 1175 // IE/Edge don't support the :scope pseudo-class. 1176 support.scope = assert( function() { 1177 return document.querySelectorAll( ":scope" ); 1178 } ); 1179 1180 // Support: Chrome 105 - 111 only, Safari 15.4 - 16.3 only 1181 // Make sure the `:has()` argument is parsed unforgivingly. 1182 // We include `*` in the test to detect buggy implementations that are 1183 // _selectively_ forgiving (specifically when the list includes at least 1184 // one valid selector). 1185 // Note that we treat complete lack of support for `:has()` as if it were 1186 // spec-compliant support, which is fine because use of `:has()` in such 1187 // environments will fail in the qSA path and fall back to jQuery traversal 1188 // anyway. 1189 support.cssHas = assert( function() { 1190 try { 1191 document.querySelector( ":has(*,:jqfake)" ); 1192 return false; 1193 } catch ( e ) { 1194 return true; 1195 } 1196 } ); 1197 1198 // ID filter and find 1199 if ( support.getById ) { 1200 Expr.filter.ID = function( id ) { 1201 var attrId = id.replace( runescape, funescape ); 1202 return function( elem ) { 1203 return elem.getAttribute( "id" ) === attrId; 1204 }; 1205 }; 1206 Expr.find.ID = function( id, context ) { 1207 if ( typeof context.getElementById !== "undefined" && documentIsHTML ) { 1208 var elem = context.getElementById( id ); 1209 return elem ? [ elem ] : []; 1210 } 1211 }; 1212 } else { 1213 Expr.filter.ID = function( id ) { 1214 var attrId = id.replace( runescape, funescape ); 1215 return function( elem ) { 1216 var node = typeof elem.getAttributeNode !== "undefined" && 1217 elem.getAttributeNode( "id" ); 1218 return node && node.value === attrId; 1219 }; 1220 }; 1221 1222 // Support: IE 6 - 7 only 1223 // getElementById is not reliable as a find shortcut 1224 Expr.find.ID = function( id, context ) { 1225 if ( typeof context.getElementById !== "undefined" && documentIsHTML ) { 1226 var node, i, elems, 1227 elem = context.getElementById( id ); 1228 1229 if ( elem ) { 1230 1231 // Verify the id attribute 1232 node = elem.getAttributeNode( "id" ); 1233 if ( node && node.value === id ) { 1234 return [ elem ]; 1235 } 1236 1237 // Fall back on getElementsByName 1238 elems = context.getElementsByName( id ); 1239 i = 0; 1240 while ( ( elem = elems[ i++ ] ) ) { 1241 node = elem.getAttributeNode( "id" ); 1242 if ( node && node.value === id ) { 1243 return [ elem ]; 1244 } 1245 } 1246 } 1247 1248 return []; 1249 } 1250 }; 1251 } 1252 1253 // Tag 1254 Expr.find.TAG = function( tag, context ) { 1255 if ( typeof context.getElementsByTagName !== "undefined" ) { 1256 return context.getElementsByTagName( tag ); 1257 1258 // DocumentFragment nodes don't have gEBTN 1259 } else { 1260 return context.querySelectorAll( tag ); 1261 } 1262 }; 1263 1264 // Class 1265 Expr.find.CLASS = function( className, context ) { 1266 if ( typeof context.getElementsByClassName !== "undefined" && documentIsHTML ) { 1267 return context.getElementsByClassName( className ); 1268 } 1269 }; 1270 1271 /* QSA/matchesSelector 1272 ---------------------------------------------------------------------- */ 1273 1274 // QSA and matchesSelector support 1275 1276 rbuggyQSA = []; 1277 1278 // Build QSA regex 1279 // Regex strategy adopted from Diego Perini 1280 assert( function( el ) { 1281 1282 var input; 1283 1284 documentElement.appendChild( el ).innerHTML = 1285 "<a id='" + expando + "' href='' disabled='disabled'></a>" + 1286 "<select id='" + expando + "-\r\\' disabled='disabled'>" + 1287 "<option selected=''></option></select>"; 1288
vendor: 38,614 bytes, lines 1289-2660
1289 // Support: iOS <=7 - 8 only 1290 // Boolean attributes and "value" are not treated correctly in some XML documents 1291 if ( !el.querySelectorAll( "[selected]" ).length ) { 1292 rbuggyQSA.push( "\\[" + whitespace + "*(?:value|" + booleans + ")" ); 1293 } 1294 1295 // Support: iOS <=7 - 8 only 1296 if ( !el.querySelectorAll( "[id~=" + expando + "-]" ).length ) { 1297 rbuggyQSA.push( "~=" ); 1298 } 1299 1300 // Support: iOS 8 only 1301 // https://bugs.webkit.org/show_bug.cgi?id=136851 1302 // In-page `selector#id sibling-combinator selector` fails 1303 if ( !el.querySelectorAll( "a#" + expando + "+*" ).length ) { 1304 rbuggyQSA.push( ".#.+[+~]" ); 1305 } 1306 1307 // Support: Chrome <=105+, Firefox <=104+, Safari <=15.4+ 1308 // In some of the document kinds, these selectors wouldn't work natively. 1309 // This is probably OK but for backwards compatibility we want to maintain 1310 // handling them through jQuery traversal in jQuery 3.x. 1311 if ( !el.querySelectorAll( ":checked" ).length ) { 1312 rbuggyQSA.push( ":checked" ); 1313 } 1314 1315 // Support: Windows 8 Native Apps 1316 // The type and name attributes are restricted during .innerHTML assignment 1317 input = document.createElement( "input" ); 1318 input.setAttribute( "type", "hidden" ); 1319 el.appendChild( input ).setAttribute( "name", "D" ); 1320 1321 // Support: IE 9 - 11+ 1322 // IE's :disabled selector does not pick up the children of disabled fieldsets 1323 // Support: Chrome <=105+, Firefox <=104+, Safari <=15.4+ 1324 // In some of the document kinds, these selectors wouldn't work natively. 1325 // This is probably OK but for backwards compatibility we want to maintain 1326 // handling them through jQuery traversal in jQuery 3.x. 1327 documentElement.appendChild( el ).disabled = true; 1328 if ( el.querySelectorAll( ":disabled" ).length !== 2 ) { 1329 rbuggyQSA.push( ":enabled", ":disabled" ); 1330 } 1331 1332 // Support: IE 11+, Edge 15 - 18+ 1333 // IE 11/Edge don't find elements on a `[name='']` query in some cases. 1334 // Adding a temporary attribute to the document before the selection works 1335 // around the issue. 1336 // Interestingly, IE 10 & older don't seem to have the issue. 1337 input = document.createElement( "input" ); 1338 input.setAttribute( "name", "" ); 1339 el.appendChild( input ); 1340 if ( !el.querySelectorAll( "[name='']" ).length ) { 1341 rbuggyQSA.push( "\\[" + whitespace + "*name" + whitespace + "*=" + 1342 whitespace + "*(?:''|\"\")" ); 1343 } 1344 } ); 1345 1346 if ( !support.cssHas ) { 1347 1348 // Support: Chrome 105 - 110+, Safari 15.4 - 16.3+ 1349 // Our regular `try-catch` mechanism fails to detect natively-unsupported 1350 // pseudo-classes inside `:has()` (such as `:has(:contains("Foo"))`) 1351 // in browsers that parse the `:has()` argument as a forgiving selector list. 1352 // https://drafts.csswg.org/selectors/#relational now requires the argument 1353 // to be parsed unforgivingly, but browsers have not yet fully adjusted. 1354 rbuggyQSA.push( ":has" ); 1355 } 1356 1357 rbuggyQSA = rbuggyQSA.length && new RegExp( rbuggyQSA.join( "|" ) ); 1358 1359 /* Sorting 1360 ---------------------------------------------------------------------- */ 1361 1362 // Document order sorting 1363 sortOrder = function( a, b ) { 1364 1365 // Flag for duplicate removal 1366 if ( a === b ) { 1367 hasDuplicate = true; 1368 return 0; 1369 } 1370 1371 // Sort on method existence if only one input has compareDocumentPosition 1372 var compare = !a.compareDocumentPosition - !b.compareDocumentPosition; 1373 if ( compare ) { 1374 return compare; 1375 } 1376 1377 // Calculate position if both inputs belong to the same document 1378 // Support: IE 11+, Edge 17 - 18+ 1379 // IE/Edge sometimes throw a "Permission denied" error when strict-comparing 1380 // two documents; shallow comparisons work. 1381 // eslint-disable-next-line eqeqeq 1382 compare = ( a.ownerDocument || a ) == ( b.ownerDocument || b ) ? 1383 a.compareDocumentPosition( b ) : 1384 1385 // Otherwise we know they are disconnected 1386 1; 1387 1388 // Disconnected nodes 1389 if ( compare & 1 || 1390 ( !support.sortDetached && b.compareDocumentPosition( a ) === compare ) ) { 1391 1392 // Choose the first element that is related to our preferred document 1393 // Support: IE 11+, Edge 17 - 18+ 1394 // IE/Edge sometimes throw a "Permission denied" error when strict-comparing 1395 // two documents; shallow comparisons work. 1396 // eslint-disable-next-line eqeqeq 1397 if ( a === document || a.ownerDocument == preferredDoc && 1398 find.contains( preferredDoc, a ) ) { 1399 return -1; 1400 } 1401 1402 // Support: IE 11+, Edge 17 - 18+ 1403 // IE/Edge sometimes throw a "Permission denied" error when strict-comparing 1404 // two documents; shallow comparisons work. 1405 // eslint-disable-next-line eqeqeq 1406 if ( b === document || b.ownerDocument == preferredDoc && 1407 find.contains( preferredDoc, b ) ) { 1408 return 1; 1409 } 1410 1411 // Maintain original order 1412 return sortInput ? 1413 ( indexOf.call( sortInput, a ) - indexOf.call( sortInput, b ) ) : 1414 0; 1415 } 1416 1417 return compare & 4 ? -1 : 1; 1418 }; 1419 1420 return document; 1421} 1422 1423find.matches = function( expr, elements ) { 1424 return find( expr, null, null, elements ); 1425}; 1426 1427find.matchesSelector = function( elem, expr ) { 1428 setDocument( elem ); 1429 1430 if ( documentIsHTML && 1431 !nonnativeSelectorCache[ expr + " " ] && 1432 ( !rbuggyQSA || !rbuggyQSA.test( expr ) ) ) { 1433 1434 try { 1435 var ret = matches.call( elem, expr ); 1436 1437 // IE 9's matchesSelector returns false on disconnected nodes 1438 if ( ret || support.disconnectedMatch || 1439 1440 // As well, disconnected nodes are said to be in a document 1441 // fragment in IE 9 1442 elem.document && elem.document.nodeType !== 11 ) { 1443 return ret; 1444 } 1445 } catch ( e ) { 1446 nonnativeSelectorCache( expr, true ); 1447 } 1448 } 1449 1450 return find( expr, document, null, [ elem ] ).length > 0; 1451}; 1452 1453find.contains = function( context, elem ) { 1454 1455 // Set document vars if needed 1456 // Support: IE 11+, Edge 17 - 18+ 1457 // IE/Edge sometimes throw a "Permission denied" error when strict-comparing 1458 // two documents; shallow comparisons work. 1459 // eslint-disable-next-line eqeqeq 1460 if ( ( context.ownerDocument || context ) != document ) { 1461 setDocument( context ); 1462 } 1463 return jQuery.contains( context, elem ); 1464}; 1465 1466 1467find.attr = function( elem, name ) { 1468 1469 // Set document vars if needed 1470 // Support: IE 11+, Edge 17 - 18+ 1471 // IE/Edge sometimes throw a "Permission denied" error when strict-comparing 1472 // two documents; shallow comparisons work. 1473 // eslint-disable-next-line eqeqeq 1474 if ( ( elem.ownerDocument || elem ) != document ) { 1475 setDocument( elem ); 1476 } 1477 1478 var fn = Expr.attrHandle[ name.toLowerCase() ], 1479 1480 // Don't get fooled by Object.prototype properties (see trac-13807) 1481 val = fn && hasOwn.call( Expr.attrHandle, name.toLowerCase() ) ? 1482 fn( elem, name, !documentIsHTML ) : 1483 undefined; 1484 1485 if ( val !== undefined ) { 1486 return val; 1487 } 1488 1489 return elem.getAttribute( name ); 1490}; 1491 1492find.error = function( msg ) { 1493 throw new Error( "Syntax error, unrecognized expression: " + msg ); 1494}; 1495 1496/** 1497 * Document sorting and removing duplicates 1498 * @param {ArrayLike} results 1499 */ 1500jQuery.uniqueSort = function( results ) { 1501 var elem, 1502 duplicates = [], 1503 j = 0, 1504 i = 0; 1505 1506 // Unless we *know* we can detect duplicates, assume their presence 1507 // 1508 // Support: Android <=4.0+ 1509 // Testing for detecting duplicates is unpredictable so instead assume we can't 1510 // depend on duplicate detection in all browsers without a stable sort. 1511 hasDuplicate = !support.sortStable; 1512 sortInput = !support.sortStable && slice.call( results, 0 ); 1513 sort.call( results, sortOrder ); 1514 1515 if ( hasDuplicate ) { 1516 while ( ( elem = results[ i++ ] ) ) { 1517 if ( elem === results[ i ] ) { 1518 j = duplicates.push( i ); 1519 } 1520 } 1521 while ( j-- ) { 1522 splice.call( results, duplicates[ j ], 1 ); 1523 } 1524 } 1525 1526 // Clear input after sorting to release objects 1527 // See https://github.com/jquery/sizzle/pull/225 1528 sortInput = null; 1529 1530 return results; 1531}; 1532 1533jQuery.fn.uniqueSort = function() { 1534 return this.pushStack( jQuery.uniqueSort( slice.apply( this ) ) ); 1535}; 1536 1537Expr = jQuery.expr = { 1538 1539 // Can be adjusted by the user 1540 cacheLength: 50, 1541 1542 createPseudo: markFunction, 1543 1544 match: matchExpr, 1545 1546 attrHandle: {}, 1547 1548 find: {}, 1549 1550 relative: { 1551 ">": { dir: "parentNode", first: true }, 1552 " ": { dir: "parentNode" }, 1553 "+": { dir: "previousSibling", first: true }, 1554 "~": { dir: "previousSibling" } 1555 }, 1556 1557 preFilter: { 1558 ATTR: function( match ) { 1559 match[ 1 ] = match[ 1 ].replace( runescape, funescape ); 1560 1561 // Move the given value to match[3] whether quoted or unquoted 1562 match[ 3 ] = ( match[ 3 ] || match[ 4 ] || match[ 5 ] || "" ) 1563 .replace( runescape, funescape ); 1564 1565 if ( match[ 2 ] === "~=" ) { 1566 match[ 3 ] = " " + match[ 3 ] + " "; 1567 } 1568 1569 return match.slice( 0, 4 ); 1570 }, 1571 1572 CHILD: function( match ) { 1573 1574 /* matches from matchExpr["CHILD"] 1575 1 type (only|nth|...) 1576 2 what (child|of-type) 1577 3 argument (even|odd|\d*|\d*n([+-]\d+)?|...) 1578 4 xn-component of xn+y argument ([+-]?\d*n|) 1579 5 sign of xn-component 1580 6 x of xn-component 1581 7 sign of y-component 1582 8 y of y-component 1583 */ 1584 match[ 1 ] = match[ 1 ].toLowerCase(); 1585 1586 if ( match[ 1 ].slice( 0, 3 ) === "nth" ) { 1587 1588 // nth-* requires argument 1589 if ( !match[ 3 ] ) { 1590 find.error( match[ 0 ] ); 1591 } 1592 1593 // numeric x and y parameters for Expr.filter.CHILD 1594 // remember that false/true cast respectively to 0/1 1595 match[ 4 ] = +( match[ 4 ] ? 1596 match[ 5 ] + ( match[ 6 ] || 1 ) : 1597 2 * ( match[ 3 ] === "even" || match[ 3 ] === "odd" ) 1598 ); 1599 match[ 5 ] = +( ( match[ 7 ] + match[ 8 ] ) || match[ 3 ] === "odd" ); 1600 1601 // other types prohibit arguments 1602 } else if ( match[ 3 ] ) { 1603 find.error( match[ 0 ] ); 1604 } 1605 1606 return match; 1607 }, 1608 1609 PSEUDO: function( match ) { 1610 var excess, 1611 unquoted = !match[ 6 ] && match[ 2 ]; 1612 1613 if ( matchExpr.CHILD.test( match[ 0 ] ) ) { 1614 return null; 1615 } 1616 1617 // Accept quoted arguments as-is 1618 if ( match[ 3 ] ) { 1619 match[ 2 ] = match[ 4 ] || match[ 5 ] || ""; 1620 1621 // Strip excess characters from unquoted arguments 1622 } else if ( unquoted && rpseudo.test( unquoted ) && 1623 1624 // Get excess from tokenize (recursively) 1625 ( excess = tokenize( unquoted, true ) ) && 1626 1627 // advance to the next closing parenthesis 1628 ( excess = unquoted.indexOf( ")", unquoted.length - excess ) - unquoted.length ) ) { 1629 1630 // excess is a negative index 1631 match[ 0 ] = match[ 0 ].slice( 0, excess ); 1632 match[ 2 ] = unquoted.slice( 0, excess ); 1633 } 1634 1635 // Return only captures needed by the pseudo filter method (type and argument) 1636 return match.slice( 0, 3 ); 1637 } 1638 }, 1639 1640 filter: { 1641 1642 TAG: function( nodeNameSelector ) { 1643 var expectedNodeName = nodeNameSelector.replace( runescape, funescape ).toLowerCase(); 1644 return nodeNameSelector === "*" ? 1645 function() { 1646 return true; 1647 } : 1648 function( elem ) { 1649 return nodeName( elem, expectedNodeName ); 1650 }; 1651 }, 1652 1653 CLASS: function( className ) { 1654 var pattern = classCache[ className + " " ]; 1655 1656 return pattern || 1657 ( pattern = new RegExp( "(^|" + whitespace + ")" + className + 1658 "(" + whitespace + "|$)" ) ) && 1659 classCache( className, function( elem ) { 1660 return pattern.test( 1661 typeof elem.className === "string" && elem.className || 1662 typeof elem.getAttribute !== "undefined" && 1663 elem.getAttribute( "class" ) || 1664 "" 1665 ); 1666 } ); 1667 }, 1668 1669 ATTR: function( name, operator, check ) { 1670 return function( elem ) { 1671 var result = find.attr( elem, name ); 1672 1673 if ( result == null ) { 1674 return operator === "!="; 1675 } 1676 if ( !operator ) { 1677 return true; 1678 } 1679 1680 result += ""; 1681 1682 if ( operator === "=" ) { 1683 return result === check; 1684 } 1685 if ( operator === "!=" ) { 1686 return result !== check; 1687 } 1688 if ( operator === "^=" ) { 1689 return check && result.indexOf( check ) === 0; 1690 } 1691 if ( operator === "*=" ) { 1692 return check && result.indexOf( check ) > -1; 1693 } 1694 if ( operator === "$=" ) { 1695 return check && result.slice( -check.length ) === check; 1696 } 1697 if ( operator === "~=" ) { 1698 return ( " " + result.replace( rwhitespace, " " ) + " " ) 1699 .indexOf( check ) > -1; 1700 } 1701 if ( operator === "|=" ) { 1702 return result === check || result.slice( 0, check.length + 1 ) === check + "-"; 1703 } 1704 1705 return false; 1706 }; 1707 }, 1708 1709 CHILD: function( type, what, _argument, first, last ) { 1710 var simple = type.slice( 0, 3 ) !== "nth", 1711 forward = type.slice( -4 ) !== "last", 1712 ofType = what === "of-type"; 1713 1714 return first === 1 && last === 0 ? 1715 1716 // Shortcut for :nth-*(n) 1717 function( elem ) { 1718 return !!elem.parentNode; 1719 } : 1720 1721 function( elem, _context, xml ) { 1722 var cache, outerCache, node, nodeIndex, start, 1723 dir = simple !== forward ? "nextSibling" : "previousSibling", 1724 parent = elem.parentNode, 1725 name = ofType && elem.nodeName.toLowerCase(), 1726 useCache = !xml && !ofType, 1727 diff = false; 1728 1729 if ( parent ) { 1730 1731 // :(first|last|only)-(child|of-type) 1732 if ( simple ) { 1733 while ( dir ) { 1734 node = elem; 1735 while ( ( node = node[ dir ] ) ) { 1736 if ( ofType ? 1737 nodeName( node, name ) : 1738 node.nodeType === 1 ) { 1739 1740 return false; 1741 } 1742 } 1743 1744 // Reverse direction for :only-* (if we haven't yet done so) 1745 start = dir = type === "only" && !start && "nextSibling"; 1746 } 1747 return true; 1748 } 1749 1750 start = [ forward ? parent.firstChild : parent.lastChild ]; 1751 1752 // non-xml :nth-child(...) stores cache data on `parent` 1753 if ( forward && useCache ) { 1754 1755 // Seek `elem` from a previously-cached index 1756 outerCache = parent[ expando ] || ( parent[ expando ] = {} ); 1757 cache = outerCache[ type ] || []; 1758 nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ]; 1759 diff = nodeIndex && cache[ 2 ]; 1760 node = nodeIndex && parent.childNodes[ nodeIndex ]; 1761 1762 while ( ( node = ++nodeIndex && node && node[ dir ] || 1763 1764 // Fallback to seeking `elem` from the start 1765 ( diff = nodeIndex = 0 ) || start.pop() ) ) { 1766 1767 // When found, cache indexes on `parent` and break 1768 if ( node.nodeType === 1 && ++diff && node === elem ) { 1769 outerCache[ type ] = [ dirruns, nodeIndex, diff ]; 1770 break; 1771 } 1772 } 1773 1774 } else { 1775 1776 // Use previously-cached element index if available 1777 if ( useCache ) { 1778 outerCache = elem[ expando ] || ( elem[ expando ] = {} ); 1779 cache = outerCache[ type ] || []; 1780 nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ]; 1781 diff = nodeIndex; 1782 } 1783 1784 // xml :nth-child(...) 1785 // or :nth-last-child(...) or :nth(-last)?-of-type(...) 1786 if ( diff === false ) { 1787 1788 // Use the same loop as above to seek `elem` from the start 1789 while ( ( node = ++nodeIndex && node && node[ dir ] || 1790 ( diff = nodeIndex = 0 ) || start.pop() ) ) { 1791 1792 if ( ( ofType ? 1793 nodeName( node, name ) : 1794 node.nodeType === 1 ) && 1795 ++diff ) { 1796 1797 // Cache the index of each encountered element 1798 if ( useCache ) { 1799 outerCache = node[ expando ] || 1800 ( node[ expando ] = {} ); 1801 outerCache[ type ] = [ dirruns, diff ]; 1802 } 1803 1804 if ( node === elem ) { 1805 break; 1806 } 1807 } 1808 } 1809 } 1810 } 1811 1812 // Incorporate the offset, then check against cycle size 1813 diff -= last; 1814 return diff === first || ( diff % first === 0 && diff / first >= 0 ); 1815 } 1816 }; 1817 }, 1818 1819 PSEUDO: function( pseudo, argument ) { 1820 1821 // pseudo-class names are case-insensitive 1822 // https://www.w3.org/TR/selectors/#pseudo-classes 1823 // Prioritize by case sensitivity in case custom pseudos are added with uppercase letters 1824 // Remember that setFilters inherits from pseudos 1825 var args, 1826 fn = Expr.pseudos[ pseudo ] || Expr.setFilters[ pseudo.toLowerCase() ] || 1827 find.error( "unsupported pseudo: " + pseudo ); 1828 1829 // The user may use createPseudo to indicate that 1830 // arguments are needed to create the filter function 1831 // just as jQuery does 1832 if ( fn[ expando ] ) { 1833 return fn( argument ); 1834 } 1835 1836 // But maintain support for old signatures 1837 if ( fn.length > 1 ) { 1838 args = [ pseudo, pseudo, "", argument ]; 1839 return Expr.setFilters.hasOwnProperty( pseudo.toLowerCase() ) ? 1840 markFunction( function( seed, matches ) { 1841 var idx, 1842 matched = fn( seed, argument ), 1843 i = matched.length; 1844 while ( i-- ) { 1845 idx = indexOf.call( seed, matched[ i ] ); 1846 seed[ idx ] = !( matches[ idx ] = matched[ i ] ); 1847 } 1848 } ) : 1849 function( elem ) { 1850 return fn( elem, 0, args ); 1851 }; 1852 } 1853 1854 return fn; 1855 } 1856 }, 1857 1858 pseudos: { 1859 1860 // Potentially complex pseudos 1861 not: markFunction( function( selector ) { 1862 1863 // Trim the selector passed to compile 1864 // to avoid treating leading and trailing 1865 // spaces as combinators 1866 var input = [], 1867 results = [], 1868 matcher = compile( selector.replace( rtrimCSS, "$1" ) ); 1869 1870 return matcher[ expando ] ? 1871 markFunction( function( seed, matches, _context, xml ) { 1872 var elem, 1873 unmatched = matcher( seed, null, xml, [] ), 1874 i = seed.length; 1875 1876 // Match elements unmatched by `matcher` 1877 while ( i-- ) { 1878 if ( ( elem = unmatched[ i ] ) ) { 1879 seed[ i ] = !( matches[ i ] = elem ); 1880 } 1881 } 1882 } ) : 1883 function( elem, _context, xml ) { 1884 input[ 0 ] = elem; 1885 matcher( input, null, xml, results ); 1886 1887 // Don't keep the element 1888 // (see https://github.com/jquery/sizzle/issues/299) 1889 input[ 0 ] = null; 1890 return !results.pop(); 1891 }; 1892 } ), 1893 1894 has: markFunction( function( selector ) { 1895 return function( elem ) { 1896 return find( selector, elem ).length > 0; 1897 }; 1898 } ), 1899 1900 contains: markFunction( function( text ) { 1901 text = text.replace( runescape, funescape ); 1902 return function( elem ) { 1903 return ( elem.textContent || jQuery.text( elem ) ).indexOf( text ) > -1; 1904 }; 1905 } ), 1906 1907 // "Whether an element is represented by a :lang() selector 1908 // is based solely on the element's language value 1909 // being equal to the identifier C, 1910 // or beginning with the identifier C immediately followed by "-". 1911 // The matching of C against the element's language value is performed case-insensitively. 1912 // The identifier C does not have to be a valid language name." 1913 // https://www.w3.org/TR/selectors/#lang-pseudo 1914 lang: markFunction( function( lang ) { 1915 1916 // lang value must be a valid identifier 1917 if ( !ridentifier.test( lang || "" ) ) { 1918 find.error( "unsupported lang: " + lang ); 1919 } 1920 lang = lang.replace( runescape, funescape ).toLowerCase(); 1921 return function( elem ) { 1922 var elemLang; 1923 do { 1924 if ( ( elemLang = documentIsHTML ? 1925 elem.lang : 1926 elem.getAttribute( "xml:lang" ) || elem.getAttribute( "lang" ) ) ) { 1927 1928 elemLang = elemLang.toLowerCase(); 1929 return elemLang === lang || elemLang.indexOf( lang + "-" ) === 0; 1930 } 1931 } while ( ( elem = elem.parentNode ) && elem.nodeType === 1 ); 1932 return false; 1933 }; 1934 } ), 1935 1936 // Miscellaneous 1937 target: function( elem ) { 1938 var hash = window.location && window.location.hash; 1939 return hash && hash.slice( 1 ) === elem.id; 1940 }, 1941 1942 root: function( elem ) { 1943 return elem === documentElement; 1944 }, 1945 1946 focus: function( elem ) { 1947 return elem === safeActiveElement() && 1948 document.hasFocus() && 1949 !!( elem.type || elem.href || ~elem.tabIndex ); 1950 }, 1951 1952 // Boolean properties 1953 enabled: createDisabledPseudo( false ), 1954 disabled: createDisabledPseudo( true ), 1955 1956 checked: function( elem ) { 1957 1958 // In CSS3, :checked should return both checked and selected elements 1959 // https://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked 1960 return ( nodeName( elem, "input" ) && !!elem.checked ) || 1961 ( nodeName( elem, "option" ) && !!elem.selected ); 1962 }, 1963 1964 selected: function( elem ) { 1965 1966 // Support: IE <=11+ 1967 // Accessing the selectedIndex property 1968 // forces the browser to treat the default option as 1969 // selected when in an optgroup. 1970 if ( elem.parentNode ) { 1971 // eslint-disable-next-line no-unused-expressions 1972 elem.parentNode.selectedIndex; 1973 } 1974 1975 return elem.selected === true; 1976 }, 1977 1978 // Contents 1979 empty: function( elem ) { 1980 1981 // https://www.w3.org/TR/selectors/#empty-pseudo 1982 // :empty is negated by element (1) or content nodes (text: 3; cdata: 4; entity ref: 5), 1983 // but not by others (comment: 8; processing instruction: 7; etc.) 1984 // nodeType < 6 works because attributes (2) do not appear as children 1985 for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) { 1986 if ( elem.nodeType < 6 ) { 1987 return false; 1988 } 1989 } 1990 return true; 1991 }, 1992 1993 parent: function( elem ) { 1994 return !Expr.pseudos.empty( elem ); 1995 }, 1996 1997 // Element/input types 1998 header: function( elem ) { 1999 return rheader.test( elem.nodeName ); 2000 }, 2001 2002 input: function( elem ) { 2003 return rinputs.test( elem.nodeName ); 2004 }, 2005 2006 button: function( elem ) { 2007 return nodeName( elem, "input" ) && elem.type === "button" || 2008 nodeName( elem, "button" ); 2009 }, 2010 2011 text: function( elem ) { 2012 var attr; 2013 return nodeName( elem, "input" ) && elem.type === "text" && 2014 2015 // Support: IE <10 only 2016 // New HTML5 attribute values (e.g., "search") appear 2017 // with elem.type === "text" 2018 ( ( attr = elem.getAttribute( "type" ) ) == null || 2019 attr.toLowerCase() === "text" ); 2020 }, 2021 2022 // Position-in-collection 2023 first: createPositionalPseudo( function() { 2024 return [ 0 ]; 2025 } ), 2026 2027 last: createPositionalPseudo( function( _matchIndexes, length ) { 2028 return [ length - 1 ]; 2029 } ), 2030 2031 eq: createPositionalPseudo( function( _matchIndexes, length, argument ) { 2032 return [ argument < 0 ? argument + length : argument ]; 2033 } ), 2034 2035 even: createPositionalPseudo( function( matchIndexes, length ) { 2036 var i = 0; 2037 for ( ; i < length; i += 2 ) { 2038 matchIndexes.push( i ); 2039 } 2040 return matchIndexes; 2041 } ), 2042 2043 odd: createPositionalPseudo( function( matchIndexes, length ) { 2044 var i = 1; 2045 for ( ; i < length; i += 2 ) { 2046 matchIndexes.push( i ); 2047 } 2048 return matchIndexes; 2049 } ), 2050 2051 lt: createPositionalPseudo( function( matchIndexes, length, argument ) { 2052 var i; 2053 2054 if ( argument < 0 ) { 2055 i = argument + length; 2056 } else if ( argument > length ) { 2057 i = length; 2058 } else { 2059 i = argument; 2060 } 2061 2062 for ( ; --i >= 0; ) { 2063 matchIndexes.push( i ); 2064 } 2065 return matchIndexes; 2066 } ), 2067 2068 gt: createPositionalPseudo( function( matchIndexes, length, argument ) { 2069 var i = argument < 0 ? argument + length : argument; 2070 for ( ; ++i < length; ) { 2071 matchIndexes.push( i ); 2072 } 2073 return matchIndexes; 2074 } ) 2075 } 2076}; 2077 2078Expr.pseudos.nth = Expr.pseudos.eq; 2079 2080// Add button/input type pseudos 2081for ( i in { radio: true, checkbox: true, file: true, password: true, image: true } ) { 2082 Expr.pseudos[ i ] = createInputPseudo( i ); 2083} 2084for ( i in { submit: true, reset: true } ) { 2085 Expr.pseudos[ i ] = createButtonPseudo( i ); 2086} 2087 2088// Easy API for creating new setFilters 2089function setFilters() {} 2090setFilters.prototype = Expr.filters = Expr.pseudos; 2091Expr.setFilters = new setFilters(); 2092 2093function tokenize( selector, parseOnly ) { 2094 var matched, match, tokens, type, 2095 soFar, groups, preFilters, 2096 cached = tokenCache[ selector + " " ]; 2097 2098 if ( cached ) { 2099 return parseOnly ? 0 : cached.slice( 0 ); 2100 } 2101 2102 soFar = selector; 2103 groups = []; 2104 preFilters = Expr.preFilter; 2105 2106 while ( soFar ) { 2107 2108 // Comma and first run 2109 if ( !matched || ( match = rcomma.exec( soFar ) ) ) { 2110 if ( match ) { 2111 2112 // Don't consume trailing commas as valid 2113 soFar = soFar.slice( match[ 0 ].length ) || soFar; 2114 } 2115 groups.push( ( tokens = [] ) ); 2116 } 2117 2118 matched = false; 2119 2120 // Combinators 2121 if ( ( match = rleadingCombinator.exec( soFar ) ) ) { 2122 matched = match.shift(); 2123 tokens.push( { 2124 value: matched, 2125 2126 // Cast descendant combinators to space 2127 type: match[ 0 ].replace( rtrimCSS, " " ) 2128 } ); 2129 soFar = soFar.slice( matched.length ); 2130 } 2131 2132 // Filters 2133 for ( type in Expr.filter ) { 2134 if ( ( match = matchExpr[ type ].exec( soFar ) ) && ( !preFilters[ type ] || 2135 ( match = preFilters[ type ]( match ) ) ) ) { 2136 matched = match.shift(); 2137 tokens.push( { 2138 value: matched, 2139 type: type, 2140 matches: match 2141 } ); 2142 soFar = soFar.slice( matched.length ); 2143 } 2144 } 2145 2146 if ( !matched ) { 2147 break; 2148 } 2149 } 2150 2151 // Return the length of the invalid excess 2152 // if we're just parsing 2153 // Otherwise, throw an error or return tokens 2154 if ( parseOnly ) { 2155 return soFar.length; 2156 } 2157 2158 return soFar ? 2159 find.error( selector ) : 2160 2161 // Cache the tokens 2162 tokenCache( selector, groups ).slice( 0 ); 2163} 2164 2165function toSelector( tokens ) { 2166 var i = 0, 2167 len = tokens.length, 2168 selector = ""; 2169 for ( ; i < len; i++ ) { 2170 selector += tokens[ i ].value; 2171 } 2172 return selector; 2173} 2174 2175function addCombinator( matcher, combinator, base ) { 2176 var dir = combinator.dir, 2177 skip = combinator.next, 2178 key = skip || dir, 2179 checkNonElements = base && key === "parentNode", 2180 doneName = done++; 2181 2182 return combinator.first ? 2183 2184 // Check against closest ancestor/preceding element 2185 function( elem, context, xml ) { 2186 while ( ( elem = elem[ dir ] ) ) { 2187 if ( elem.nodeType === 1 || checkNonElements ) { 2188 return matcher( elem, context, xml ); 2189 } 2190 } 2191 return false; 2192 } : 2193 2194 // Check against all ancestor/preceding elements 2195 function( elem, context, xml ) { 2196 var oldCache, outerCache, 2197 newCache = [ dirruns, doneName ]; 2198 2199 // We can't set arbitrary data on XML nodes, so they don't benefit from combinator caching 2200 if ( xml ) { 2201 while ( ( elem = elem[ dir ] ) ) { 2202 if ( elem.nodeType === 1 || checkNonElements ) { 2203 if ( matcher( elem, context, xml ) ) { 2204 return true; 2205 } 2206 } 2207 } 2208 } else { 2209 while ( ( elem = elem[ dir ] ) ) { 2210 if ( elem.nodeType === 1 || checkNonElements ) { 2211 outerCache = elem[ expando ] || ( elem[ expando ] = {} ); 2212 2213 if ( skip && nodeName( elem, skip ) ) { 2214 elem = elem[ dir ] || elem; 2215 } else if ( ( oldCache = outerCache[ key ] ) && 2216 oldCache[ 0 ] === dirruns && oldCache[ 1 ] === doneName ) { 2217 2218 // Assign to newCache so results back-propagate to previous elements 2219 return ( newCache[ 2 ] = oldCache[ 2 ] ); 2220 } else { 2221 2222 // Reuse newcache so results back-propagate to previous elements 2223 outerCache[ key ] = newCache; 2224 2225 // A match means we're done; a fail means we have to keep checking 2226 if ( ( newCache[ 2 ] = matcher( elem, context, xml ) ) ) { 2227 return true; 2228 } 2229 } 2230 } 2231 } 2232 } 2233 return false; 2234 }; 2235} 2236 2237function elementMatcher( matchers ) { 2238 return matchers.length > 1 ? 2239 function( elem, context, xml ) { 2240 var i = matchers.length; 2241 while ( i-- ) { 2242 if ( !matchers[ i ]( elem, context, xml ) ) { 2243 return false; 2244 } 2245 } 2246 return true; 2247 } : 2248 matchers[ 0 ]; 2249} 2250 2251function multipleContexts( selector, contexts, results ) { 2252 var i = 0, 2253 len = contexts.length; 2254 for ( ; i < len; i++ ) { 2255 find( selector, contexts[ i ], results ); 2256 } 2257 return results; 2258} 2259 2260function condense( unmatched, map, filter, context, xml ) { 2261 var elem, 2262 newUnmatched = [], 2263 i = 0, 2264 len = unmatched.length, 2265 mapped = map != null; 2266 2267 for ( ; i < len; i++ ) { 2268 if ( ( elem = unmatched[ i ] ) ) { 2269 if ( !filter || filter( elem, context, xml ) ) { 2270 newUnmatched.push( elem ); 2271 if ( mapped ) { 2272 map.push( i ); 2273 } 2274 } 2275 } 2276 } 2277 2278 return newUnmatched; 2279} 2280 2281function setMatcher( preFilter, selector, matcher, postFilter, postFinder, postSelector ) { 2282 if ( postFilter && !postFilter[ expando ] ) { 2283 postFilter = setMatcher( postFilter ); 2284 } 2285 if ( postFinder && !postFinder[ expando ] ) { 2286 postFinder = setMatcher( postFinder, postSelector ); 2287 } 2288 return markFunction( function( seed, results, context, xml ) { 2289 var temp, i, elem, matcherOut, 2290 preMap = [], 2291 postMap = [], 2292 preexisting = results.length, 2293 2294 // Get initial elements from seed or context 2295 elems = seed || 2296 multipleContexts( selector || "*", 2297 context.nodeType ? [ context ] : context, [] ), 2298 2299 // Prefilter to get matcher input, preserving a map for seed-results synchronization 2300 matcherIn = preFilter && ( seed || !selector ) ? 2301 condense( elems, preMap, preFilter, context, xml ) : 2302 elems; 2303 2304 if ( matcher ) { 2305 2306 // If we have a postFinder, or filtered seed, or non-seed postFilter 2307 // or preexisting results, 2308 matcherOut = postFinder || ( seed ? preFilter : preexisting || postFilter ) ? 2309 2310 // ...intermediate processing is necessary 2311 [] : 2312 2313 // ...otherwise use results directly 2314 results; 2315 2316 // Find primary matches 2317 matcher( matcherIn, matcherOut, context, xml ); 2318 } else { 2319 matcherOut = matcherIn; 2320 } 2321 2322 // Apply postFilter 2323 if ( postFilter ) { 2324 temp = condense( matcherOut, postMap ); 2325 postFilter( temp, [], context, xml ); 2326 2327 // Un-match failing elements by moving them back to matcherIn 2328 i = temp.length; 2329 while ( i-- ) { 2330 if ( ( elem = temp[ i ] ) ) { 2331 matcherOut[ postMap[ i ] ] = !( matcherIn[ postMap[ i ] ] = elem ); 2332 } 2333 } 2334 } 2335 2336 if ( seed ) { 2337 if ( postFinder || preFilter ) { 2338 if ( postFinder ) { 2339 2340 // Get the final matcherOut by condensing this intermediate into postFinder contexts 2341 temp = []; 2342 i = matcherOut.length; 2343 while ( i-- ) { 2344 if ( ( elem = matcherOut[ i ] ) ) { 2345 2346 // Restore matcherIn since elem is not yet a final match 2347 temp.push( ( matcherIn[ i ] = elem ) ); 2348 } 2349 } 2350 postFinder( null, ( matcherOut = [] ), temp, xml ); 2351 } 2352 2353 // Move matched elements from seed to results to keep them synchronized 2354 i = matcherOut.length; 2355 while ( i-- ) { 2356 if ( ( elem = matcherOut[ i ] ) && 2357 ( temp = postFinder ? indexOf.call( seed, elem ) : preMap[ i ] ) > -1 ) { 2358 2359 seed[ temp ] = !( results[ temp ] = elem ); 2360 } 2361 } 2362 } 2363 2364 // Add elements to results, through postFinder if defined 2365 } else { 2366 matcherOut = condense( 2367 matcherOut === results ? 2368 matcherOut.splice( preexisting, matcherOut.length ) : 2369 matcherOut 2370 ); 2371 if ( postFinder ) { 2372 postFinder( null, results, matcherOut, xml ); 2373 } else { 2374 push.apply( results, matcherOut ); 2375 } 2376 } 2377 } ); 2378} 2379 2380function matcherFromTokens( tokens ) { 2381 var checkContext, matcher, j, 2382 len = tokens.length, 2383 leadingRelative = Expr.relative[ tokens[ 0 ].type ], 2384 implicitRelative = leadingRelative || Expr.relative[ " " ], 2385 i = leadingRelative ? 1 : 0, 2386 2387 // The foundational matcher ensures that elements are reachable from top-level context(s) 2388 matchContext = addCombinator( function( elem ) { 2389 return elem === checkContext; 2390 }, implicitRelative, true ), 2391 matchAnyContext = addCombinator( function( elem ) { 2392 return indexOf.call( checkContext, elem ) > -1; 2393 }, implicitRelative, true ), 2394 matchers = [ function( elem, context, xml ) { 2395 2396 // Support: IE 11+, Edge 17 - 18+ 2397 // IE/Edge sometimes throw a "Permission denied" error when strict-comparing 2398 // two documents; shallow comparisons work. 2399 // eslint-disable-next-line eqeqeq 2400 var ret = ( !leadingRelative && ( xml || context != outermostContext ) ) || ( 2401 ( checkContext = context ).nodeType ? 2402 matchContext( elem, context, xml ) : 2403 matchAnyContext( elem, context, xml ) ); 2404 2405 // Avoid hanging onto element 2406 // (see https://github.com/jquery/sizzle/issues/299) 2407 checkContext = null; 2408 return ret; 2409 } ]; 2410 2411 for ( ; i < len; i++ ) { 2412 if ( ( matcher = Expr.relative[ tokens[ i ].type ] ) ) { 2413 matchers = [ addCombinator( elementMatcher( matchers ), matcher ) ]; 2414 } else { 2415 matcher = Expr.filter[ tokens[ i ].type ].apply( null, tokens[ i ].matches ); 2416 2417 // Return special upon seeing a positional matcher 2418 if ( matcher[ expando ] ) { 2419 2420 // Find the next relative operator (if any) for proper handling 2421 j = ++i; 2422 for ( ; j < len; j++ ) { 2423 if ( Expr.relative[ tokens[ j ].type ] ) { 2424 break; 2425 } 2426 } 2427 return setMatcher( 2428 i > 1 && elementMatcher( matchers ), 2429 i > 1 && toSelector( 2430 2431 // If the preceding token was a descendant combinator, insert an implicit any-element `*` 2432 tokens.slice( 0, i - 1 ) 2433 .concat( { value: tokens[ i - 2 ].type === " " ? "*" : "" } ) 2434 ).replace( rtrimCSS, "$1" ), 2435 matcher, 2436 i < j && matcherFromTokens( tokens.slice( i, j ) ), 2437 j < len && matcherFromTokens( ( tokens = tokens.slice( j ) ) ), 2438 j < len && toSelector( tokens ) 2439 ); 2440 } 2441 matchers.push( matcher ); 2442 } 2443 } 2444 2445 return elementMatcher( matchers ); 2446} 2447 2448function matcherFromGroupMatchers( elementMatchers, setMatchers ) { 2449 var bySet = setMatchers.length > 0, 2450 byElement = elementMatchers.length > 0, 2451 superMatcher = function( seed, context, xml, results, outermost ) { 2452 var elem, j, matcher, 2453 matchedCount = 0, 2454 i = "0", 2455 unmatched = seed && [], 2456 setMatched = [], 2457 contextBackup = outermostContext, 2458 2459 // We must always have either seed elements or outermost context 2460 elems = seed || byElement && Expr.find.TAG( "*", outermost ), 2461 2462 // Use integer dirruns iff this is the outermost matcher 2463 dirrunsUnique = ( dirruns += contextBackup == null ? 1 : Math.random() || 0.1 ), 2464 len = elems.length; 2465 2466 if ( outermost ) { 2467 2468 // Support: IE 11+, Edge 17 - 18+ 2469 // IE/Edge sometimes throw a "Permission denied" error when strict-comparing 2470 // two documents; shallow comparisons work. 2471 // eslint-disable-next-line eqeqeq 2472 outermostContext = context == document || context || outermost; 2473 } 2474 2475 // Add elements passing elementMatchers directly to results 2476 // Support: iOS <=7 - 9 only 2477 // Tolerate NodeList properties (IE: "length"; Safari: <number>) matching 2478 // elements by id. (see trac-14142) 2479 for ( ; i !== len && ( elem = elems[ i ] ) != null; i++ ) { 2480 if ( byElement && elem ) { 2481 j = 0; 2482 2483 // Support: IE 11+, Edge 17 - 18+ 2484 // IE/Edge sometimes throw a "Permission denied" error when strict-comparing 2485 // two documents; shallow comparisons work. 2486 // eslint-disable-next-line eqeqeq 2487 if ( !context && elem.ownerDocument != document ) { 2488 setDocument( elem ); 2489 xml = !documentIsHTML; 2490 } 2491 while ( ( matcher = elementMatchers[ j++ ] ) ) { 2492 if ( matcher( elem, context || document, xml ) ) { 2493 push.call( results, elem ); 2494 break; 2495 } 2496 } 2497 if ( outermost ) { 2498 dirruns = dirrunsUnique; 2499 } 2500 } 2501 2502 // Track unmatched elements for set filters 2503 if ( bySet ) { 2504 2505 // They will have gone through all possible matchers 2506 if ( ( elem = !matcher && elem ) ) { 2507 matchedCount--; 2508 } 2509 2510 // Lengthen the array for every element, matched or not 2511 if ( seed ) { 2512 unmatched.push( elem ); 2513 } 2514 } 2515 } 2516 2517 // `i` is now the count of elements visited above, and adding it to `matchedCount` 2518 // makes the latter nonnegative. 2519 matchedCount += i; 2520 2521 // Apply set filters to unmatched elements 2522 // NOTE: This can be skipped if there are no unmatched elements (i.e., `matchedCount` 2523 // equals `i`), unless we didn't visit _any_ elements in the above loop because we have 2524 // no element matchers and no seed. 2525 // Incrementing an initially-string "0" `i` allows `i` to remain a string only in that 2526 // case, which will result in a "00" `matchedCount` that differs from `i` but is also 2527 // numerically zero. 2528 if ( bySet && i !== matchedCount ) { 2529 j = 0; 2530 while ( ( matcher = setMatchers[ j++ ] ) ) { 2531 matcher( unmatched, setMatched, context, xml ); 2532 } 2533 2534 if ( seed ) { 2535 2536 // Reintegrate element matches to eliminate the need for sorting 2537 if ( matchedCount > 0 ) { 2538 while ( i-- ) { 2539 if ( !( unmatched[ i ] || setMatched[ i ] ) ) { 2540 setMatched[ i ] = pop.call( results ); 2541 } 2542 } 2543 } 2544 2545 // Discard index placeholder values to get only actual matches 2546 setMatched = condense( setMatched ); 2547 } 2548 2549 // Add matches to results 2550 push.apply( results, setMatched ); 2551 2552 // Seedless set matches succeeding multiple successful matchers stipulate sorting 2553 if ( outermost && !seed && setMatched.length > 0 && 2554 ( matchedCount + setMatchers.length ) > 1 ) { 2555 2556 jQuery.uniqueSort( results ); 2557 } 2558 } 2559 2560 // Override manipulation of globals by nested matchers 2561 if ( outermost ) { 2562 dirruns = dirrunsUnique; 2563 outermostContext = contextBackup; 2564 } 2565 2566 return unmatched; 2567 }; 2568 2569 return bySet ? 2570 markFunction( superMatcher ) : 2571 superMatcher; 2572} 2573 2574function compile( selector, match /* Internal Use Only */ ) { 2575 var i, 2576 setMatchers = [], 2577 elementMatchers = [], 2578 cached = compilerCache[ selector + " " ]; 2579 2580 if ( !cached ) { 2581 2582 // Generate a function of recursive functions that can be used to check each element 2583 if ( !match ) { 2584 match = tokenize( selector ); 2585 } 2586 i = match.length; 2587 while ( i-- ) { 2588 cached = matcherFromTokens( match[ i ] ); 2589 if ( cached[ expando ] ) { 2590 setMatchers.push( cached ); 2591 } else { 2592 elementMatchers.push( cached ); 2593 } 2594 } 2595 2596 // Cache the compiled function 2597 cached = compilerCache( selector, 2598 matcherFromGroupMatchers( elementMatchers, setMatchers ) ); 2599 2600 // Save selector and tokenization 2601 cached.selector = selector; 2602 } 2603 return cached; 2604} 2605 2606/** 2607 * A low-level selection function that works with jQuery's compiled 2608 * selector functions 2609 * @param {String|Function} selector A selector or a pre-compiled 2610 * selector function built with jQuery selector compile 2611 * @param {Element} context 2612 * @param {Array} [results] 2613 * @param {Array} [seed] A set of elements to match against 2614 */ 2615function select( selector, context, results, seed ) { 2616 var i, tokens, token, type, find, 2617 compiled = typeof selector === "function" && selector, 2618 match = !seed && tokenize( ( selector = compiled.selector || selector ) ); 2619 2620 results = results || []; 2621 2622 // Try to minimize operations if there is only one selector in the list and no seed 2623 // (the latter of which guarantees us context) 2624 if ( match.length === 1 ) { 2625 2626 // Reduce context if the leading compound selector is an ID 2627 tokens = match[ 0 ] = match[ 0 ].slice( 0 ); 2628 if ( tokens.length > 2 && ( token = tokens[ 0 ] ).type === "ID" && 2629 context.nodeType === 9 && documentIsHTML && Expr.relative[ tokens[ 1 ].type ] ) { 2630 2631 context = ( Expr.find.ID( 2632 token.matches[ 0 ].replace( runescape, funescape ), 2633 context 2634 ) || [] )[ 0 ]; 2635 if ( !context ) { 2636 return results; 2637 2638 // Precompiled matchers will still verify ancestry, so step up a level 2639 } else if ( compiled ) { 2640 context = context.parentNode; 2641 } 2642 2643 selector = selector.slice( tokens.shift().value.length ); 2644 } 2645 2646 // Fetch a seed set for right-to-left matching 2647 i = matchExpr.needsContext.test( selector ) ? 0 : tokens.length; 2648 while ( i-- ) { 2649 token = tokens[ i ]; 2650 2651 // Abort if we hit a combinator 2652 if ( Expr.relative[ ( type = token.type ) ] ) { 2653 break; 2654 } 2655 if ( ( find = Expr.find[ type ] ) ) { 2656 2657 // Search, expanding context for leading sibling combinators 2658 if ( ( seed = find( 2659 token.matches[ 0 ].replace( runescape, funescape ), 2660 rsibling.test( tokens[ 0 ].type ) &&
vendor: 4,497 bytes, lines 2661-2845
2661 testContext( context.parentNode ) || context 2662 ) ) ) { 2663 2664 // If seed is empty or no tokens remain, we can return early 2665 tokens.splice( i, 1 ); 2666 selector = seed.length && toSelector( tokens ); 2667 if ( !selector ) { 2668 push.apply( results, seed ); 2669 return results; 2670 } 2671 2672 break; 2673 } 2674 } 2675 } 2676 } 2677 2678 // Compile and execute a filtering function if one is not provided 2679 // Provide `match` to avoid retokenization if we modified the selector above 2680 ( compiled || compile( selector, match ) )( 2681 seed, 2682 context, 2683 !documentIsHTML, 2684 results, 2685 !context || rsibling.test( selector ) && testContext( context.parentNode ) || context 2686 ); 2687 return results; 2688} 2689 2690// One-time assignments 2691 2692// Support: Android <=4.0 - 4.1+ 2693// Sort stability 2694support.sortStable = expando.split( "" ).sort( sortOrder ).join( "" ) === expando; 2695 2696// Initialize against the default document 2697setDocument(); 2698 2699// Support: Android <=4.0 - 4.1+ 2700// Detached nodes confoundingly follow *each other* 2701support.sortDetached = assert( function( el ) { 2702 2703 // Should return 1, but returns 4 (following) 2704 return el.compareDocumentPosition( document.createElement( "fieldset" ) ) & 1; 2705} ); 2706 2707jQuery.find = find; 2708 2709// Deprecated 2710jQuery.expr[ ":" ] = jQuery.expr.pseudos; 2711jQuery.unique = jQuery.uniqueSort; 2712 2713// These have always been private, but they used to be documented as part of 2714// Sizzle so let's maintain them for now for backwards compatibility purposes. 2715find.compile = compile; 2716find.select = select; 2717find.setDocument = setDocument; 2718find.tokenize = tokenize; 2719 2720find.escape = jQuery.escapeSelector; 2721find.getText = jQuery.text; 2722find.isXML = jQuery.isXMLDoc; 2723find.selectors = jQuery.expr; 2724find.support = jQuery.support; 2725find.uniqueSort = jQuery.uniqueSort; 2726 2727 /* eslint-enable */ 2728 2729} )(); 2730 2731 2732var dir = function( elem, dir, until ) { 2733 var matched = [], 2734 truncate = until !== undefined; 2735 2736 while ( ( elem = elem[ dir ] ) && elem.nodeType !== 9 ) { 2737 if ( elem.nodeType === 1 ) { 2738 if ( truncate && jQuery( elem ).is( until ) ) { 2739 break; 2740 } 2741 matched.push( elem ); 2742 } 2743 } 2744 return matched; 2745}; 2746 2747 2748var siblings = function( n, elem ) { 2749 var matched = []; 2750 2751 for ( ; n; n = n.nextSibling ) { 2752 if ( n.nodeType === 1 && n !== elem ) { 2753 matched.push( n ); 2754 } 2755 } 2756 2757 return matched; 2758}; 2759 2760 2761var rneedsContext = jQuery.expr.match.needsContext; 2762 2763var rsingleTag = ( /^<([a-z][^\/\0>:\x20\t\r\n\f]*)[\x20\t\r\n\f]*\/?>(?:<\/\1>|)$/i ); 2764 2765 2766 2767// Implement the identical functionality for filter and not 2768function winnow( elements, qualifier, not ) { 2769 if ( isFunction( qualifier ) ) { 2770 return jQuery.grep( elements, function( elem, i ) { 2771 return !!qualifier.call( elem, i, elem ) !== not; 2772 } ); 2773 } 2774 2775 // Single element 2776 if ( qualifier.nodeType ) { 2777 return jQuery.grep( elements, function( elem ) { 2778 return ( elem === qualifier ) !== not; 2779 } ); 2780 } 2781 2782 // Arraylike of elements (jQuery, arguments, Array) 2783 if ( typeof qualifier !== "string" ) { 2784 return jQuery.grep( elements, function( elem ) { 2785 return ( indexOf.call( qualifier, elem ) > -1 ) !== not; 2786 } ); 2787 } 2788 2789 // Filtered directly for both simple and complex selectors 2790 return jQuery.filter( qualifier, elements, not ); 2791} 2792 2793jQuery.filter = function( expr, elems, not ) { 2794 var elem = elems[ 0 ]; 2795 2796 if ( not ) { 2797 expr = ":not(" + expr + ")"; 2798 } 2799 2800 if ( elems.length === 1 && elem.nodeType === 1 ) { 2801 return jQuery.find.matchesSelector( elem, expr ) ? [ elem ] : []; 2802 } 2803 2804 return jQuery.find.matches( expr, jQuery.grep( elems, function( elem ) { 2805 return elem.nodeType === 1; 2806 } ) ); 2807}; 2808 2809jQuery.fn.extend( { 2810 find: function( selector ) { 2811 var i, ret, 2812 len = this.length, 2813 self = this; 2814 2815 if ( typeof selector !== "string" ) { 2816 return this.pushStack( jQuery( selector ).filter( function() { 2817 for ( i = 0; i < len; i++ ) { 2818 if ( jQuery.contains( self[ i ], this ) ) { 2819 return true; 2820 } 2821 } 2822 } ) ); 2823 } 2824 2825 ret = this.pushStack( [] ); 2826 2827 for ( i = 0; i < len; i++ ) { 2828 jQuery.find( selector, self[ i ], ret ); 2829 } 2830 2831 return len > 1 ? jQuery.uniqueSort( ret ) : ret; 2832 }, 2833 filter: function( selector ) { 2834 return this.pushStack( winnow( this, selector || [], false ) ); 2835 }, 2836 not: function( selector ) { 2837 return this.pushStack( winnow( this, selector || [], true ) ); 2838 }, 2839 is: function( selector ) { 2840 return !!winnow( 2841 this, 2842 2843 // If this is a positional/relative selector, check membership in the returned set 2844 // so $("p:first").is("p:last") won't return true for a doc with two "p". 2845 typeof selector === "string" && rneedsContext.test( selector ) ?
vendor: 9,941 bytes, lines 2846-3234
2846 jQuery( selector ) : 2847 selector || [], 2848 false 2849 ).length; 2850 } 2851} ); 2852 2853 2854// Initialize a jQuery object 2855 2856 2857// A central reference to the root jQuery(document) 2858var rootjQuery, 2859 2860 // A simple way to check for HTML strings 2861 // Prioritize #id over <tag> to avoid XSS via location.hash (trac-9521) 2862 // Strict HTML recognition (trac-11290: must start with <) 2863 // Shortcut simple #id case for speed 2864 rquickExpr = /^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]+))$/, 2865 2866 init = jQuery.fn.init = function( selector, context, root ) { 2867 var match, elem; 2868 2869 // HANDLE: $(""), $(null), $(undefined), $(false) 2870 if ( !selector ) { 2871 return this; 2872 } 2873 2874 // Method init() accepts an alternate rootjQuery 2875 // so migrate can support jQuery.sub (gh-2101) 2876 root = root || rootjQuery; 2877 2878 // Handle HTML strings 2879 if ( typeof selector === "string" ) { 2880 if ( selector[ 0 ] === "<" && 2881 selector[ selector.length - 1 ] === ">" && 2882 selector.length >= 3 ) { 2883 2884 // Assume that strings that start and end with <> are HTML and skip the regex check 2885 match = [ null, selector, null ]; 2886 2887 } else { 2888 match = rquickExpr.exec( selector ); 2889 } 2890 2891 // Match html or make sure no context is specified for #id 2892 if ( match && ( match[ 1 ] || !context ) ) { 2893 2894 // HANDLE: $(html) -> $(array) 2895 if ( match[ 1 ] ) { 2896 context = context instanceof jQuery ? context[ 0 ] : context; 2897 2898 // Option to run scripts is true for back-compat 2899 // Intentionally let the error be thrown if parseHTML is not present 2900 jQuery.merge( this, jQuery.parseHTML( 2901 match[ 1 ], 2902 context && context.nodeType ? context.ownerDocument || context : document, 2903 true 2904 ) ); 2905 2906 // HANDLE: $(html, props) 2907 if ( rsingleTag.test( match[ 1 ] ) && jQuery.isPlainObject( context ) ) { 2908 for ( match in context ) { 2909 2910 // Properties of context are called as methods if possible 2911 if ( isFunction( this[ match ] ) ) { 2912 this[ match ]( context[ match ] ); 2913 2914 // ...and otherwise set as attributes 2915 } else { 2916 this.attr( match, context[ match ] ); 2917 } 2918 } 2919 } 2920 2921 return this; 2922 2923 // HANDLE: $(#id) 2924 } else { 2925 elem = document.getElementById( match[ 2 ] ); 2926 2927 if ( elem ) { 2928 2929 // Inject the element directly into the jQuery object 2930 this[ 0 ] = elem; 2931 this.length = 1; 2932 } 2933 return this; 2934 } 2935 2936 // HANDLE: $(expr, $(...)) 2937 } else if ( !context || context.jquery ) { 2938 return ( context || root ).find( selector ); 2939 2940 // HANDLE: $(expr, context) 2941 // (which is just equivalent to: $(context).find(expr) 2942 } else { 2943 return this.constructor( context ).find( selector ); 2944 } 2945 2946 // HANDLE: $(DOMElement) 2947 } else if ( selector.nodeType ) { 2948 this[ 0 ] = selector; 2949 this.length = 1; 2950 return this; 2951 2952 // HANDLE: $(function) 2953 // Shortcut for document ready 2954 } else if ( isFunction( selector ) ) { 2955 return root.ready !== undefined ? 2956 root.ready( selector ) : 2957 2958 // Execute immediately if ready is not present 2959 selector( jQuery ); 2960 } 2961 2962 return jQuery.makeArray( selector, this ); 2963 }; 2964 2965// Give the init function the jQuery prototype for later instantiation 2966init.prototype = jQuery.fn; 2967 2968// Initialize central reference 2969rootjQuery = jQuery( document ); 2970 2971 2972var rparentsprev = /^(?:parents|prev(?:Until|All))/, 2973 2974 // Methods guaranteed to produce a unique set when starting from a unique set 2975 guaranteedUnique = { 2976 children: true, 2977 contents: true, 2978 next: true, 2979 prev: true 2980 }; 2981 2982jQuery.fn.extend( { 2983 has: function( target ) { 2984 var targets = jQuery( target, this ), 2985 l = targets.length; 2986 2987 return this.filter( function() { 2988 var i = 0; 2989 for ( ; i < l; i++ ) { 2990 if ( jQuery.contains( this, targets[ i ] ) ) { 2991 return true; 2992 } 2993 } 2994 } ); 2995 }, 2996 2997 closest: function( selectors, context ) { 2998 var cur, 2999 i = 0, 3000 l = this.length, 3001 matched = [], 3002 targets = typeof selectors !== "string" && jQuery( selectors ); 3003 3004 // Positional selectors never match, since there's no _selection_ context 3005 if ( !rneedsContext.test( selectors ) ) { 3006 for ( ; i < l; i++ ) { 3007 for ( cur = this[ i ]; cur && cur !== context; cur = cur.parentNode ) { 3008 3009 // Always skip document fragments 3010 if ( cur.nodeType < 11 && ( targets ? 3011 targets.index( cur ) > -1 : 3012 3013 // Don't pass non-elements to jQuery#find 3014 cur.nodeType === 1 && 3015 jQuery.find.matchesSelector( cur, selectors ) ) ) { 3016 3017 matched.push( cur ); 3018 break; 3019 } 3020 } 3021 } 3022 } 3023 3024 return this.pushStack( matched.length > 1 ? jQuery.uniqueSort( matched ) : matched ); 3025 }, 3026 3027 // Determine the position of an element within the set 3028 index: function( elem ) { 3029 3030 // No argument, return index in parent 3031 if ( !elem ) { 3032 return ( this[ 0 ] && this[ 0 ].parentNode ) ? this.first().prevAll().length : -1; 3033 } 3034 3035 // Index in selector 3036 if ( typeof elem === "string" ) { 3037 return indexOf.call( jQuery( elem ), this[ 0 ] ); 3038 } 3039 3040 // Locate the position of the desired element 3041 return indexOf.call( this, 3042 3043 // If it receives a jQuery object, the first element is used 3044 elem.jquery ? elem[ 0 ] : elem 3045 ); 3046 }, 3047 3048 add: function( selector, context ) { 3049 return this.pushStack( 3050 jQuery.uniqueSort( 3051 jQuery.merge( this.get(), jQuery( selector, context ) ) 3052 ) 3053 ); 3054 }, 3055 3056 addBack: function( selector ) { 3057 return this.add( selector == null ? 3058 this.prevObject : this.prevObject.filter( selector ) 3059 ); 3060 } 3061} ); 3062 3063function sibling( cur, dir ) { 3064 while ( ( cur = cur[ dir ] ) && cur.nodeType !== 1 ) {} 3065 return cur; 3066} 3067 3068jQuery.each( { 3069 parent: function( elem ) { 3070 var parent = elem.parentNode; 3071 return parent && parent.nodeType !== 11 ? parent : null; 3072 }, 3073 parents: function( elem ) { 3074 return dir( elem, "parentNode" ); 3075 }, 3076 parentsUntil: function( elem, _i, until ) { 3077 return dir( elem, "parentNode", until ); 3078 }, 3079 next: function( elem ) { 3080 return sibling( elem, "nextSibling" ); 3081 }, 3082 prev: function( elem ) { 3083 return sibling( elem, "previousSibling" ); 3084 }, 3085 nextAll: function( elem ) { 3086 return dir( elem, "nextSibling" ); 3087 }, 3088 prevAll: function( elem ) { 3089 return dir( elem, "previousSibling" ); 3090 }, 3091 nextUntil: function( elem, _i, until ) { 3092 return dir( elem, "nextSibling", until ); 3093 }, 3094 prevUntil: function( elem, _i, until ) { 3095 return dir( elem, "previousSibling", until ); 3096 }, 3097 siblings: function( elem ) { 3098 return siblings( ( elem.parentNode || {} ).firstChild, elem ); 3099 }, 3100 children: function( elem ) { 3101 return siblings( elem.firstChild ); 3102 }, 3103 contents: function( elem ) { 3104 if ( elem.contentDocument != null && 3105 3106 // Support: IE 11+ 3107 // <object> elements with no `data` attribute has an object 3108 // `contentDocument` with a `null` prototype. 3109 getProto( elem.contentDocument ) ) { 3110 3111 return elem.contentDocument; 3112 } 3113 3114 // Support: IE 9 - 11 only, iOS 7 only, Android Browser <=4.3 only 3115 // Treat the template element as a regular one in browsers that 3116 // don't support it. 3117 if ( nodeName( elem, "template" ) ) { 3118 elem = elem.content || elem; 3119 } 3120 3121 return jQuery.merge( [], elem.childNodes ); 3122 } 3123}, function( name, fn ) { 3124 jQuery.fn[ name ] = function( until, selector ) { 3125 var matched = jQuery.map( this, fn, until ); 3126 3127 if ( name.slice( -5 ) !== "Until" ) { 3128 selector = until; 3129 } 3130 3131 if ( selector && typeof selector === "string" ) { 3132 matched = jQuery.filter( selector, matched ); 3133 } 3134 3135 if ( this.length > 1 ) { 3136 3137 // Remove duplicates 3138 if ( !guaranteedUnique[ name ] ) { 3139 jQuery.uniqueSort( matched ); 3140 } 3141 3142 // Reverse order for parents* and prev-derivatives 3143 if ( rparentsprev.test( name ) ) { 3144 matched.reverse(); 3145 } 3146 } 3147 3148 return this.pushStack( matched ); 3149 }; 3150} ); 3151var rnothtmlwhite = ( /[^\x20\t\r\n\f]+/g ); 3152 3153 3154 3155// Convert String-formatted options into Object-formatted ones 3156function createOptions( options ) { 3157 var object = {}; 3158 jQuery.each( options.match( rnothtmlwhite ) || [], function( _, flag ) { 3159 object[ flag ] = true; 3160 } ); 3161 return object; 3162} 3163 3164/* 3165 * Create a callback list using the following parameters: 3166 * 3167 * options: an optional list of space-separated options that will change how 3168 * the callback list behaves or a more traditional option object 3169 * 3170 * By default a callback list will act like an event callback list and can be 3171 * "fired" multiple times. 3172 * 3173 * Possible options: 3174 * 3175 * once: will ensure the callback list can only be fired once (like a Deferred) 3176 * 3177 * memory: will keep track of previous values and will call any callback added 3178 * after the list has been fired right away with the latest "memorized" 3179 * values (like a Deferred) 3180 * 3181 * unique: will ensure a callback can only be added once (no duplicate in the list) 3182 * 3183 * stopOnFalse: interrupt callings when a callback returns false 3184 * 3185 */ 3186jQuery.Callbacks = function( options ) { 3187 3188 // Convert options from String-formatted to Object-formatted if needed 3189 // (we check in cache first) 3190 options = typeof options === "string" ? 3191 createOptions( options ) : 3192 jQuery.extend( {}, options ); 3193 3194 var // Flag to know if list is currently firing 3195 firing, 3196 3197 // Last fire value for non-forgettable lists 3198 memory, 3199 3200 // Flag to know if list was already fired 3201 fired, 3202 3203 // Flag to prevent firing 3204 locked, 3205 3206 // Actual callback list 3207 list = [], 3208 3209 // Queue of execution data for repeatable lists 3210 queue = [], 3211 3212 // Index of currently firing callback (modified by add/remove as needed) 3213 firingIndex = -1, 3214 3215 // Fire callbacks 3216 fire = function() { 3217 3218 // Enforce single-firing 3219 locked = locked || options.once; 3220 3221 // Execute callbacks for all pending executions, 3222 // respecting firingIndex overrides and runtime changes 3223 fired = firing = true; 3224 for ( ; queue.length; firingIndex = -1 ) { 3225 memory = queue.shift(); 3226 while ( ++firingIndex < list.length ) { 3227 3228 // Run callback and check for early termination 3229 if ( list[ firingIndex ].apply( memory[ 0 ], memory[ 1 ] ) === false && 3230 options.stopOnFalse ) { 3231 3232 // Jump to end and forget the data so .add doesn't re-fire 3233 firingIndex = list.length; 3234 memory = false;
vendor: 4,918 bytes, lines 3235-3444
3235 } 3236 } 3237 } 3238 3239 // Forget the data if we're done with it 3240 if ( !options.memory ) { 3241 memory = false; 3242 } 3243 3244 firing = false; 3245 3246 // Clean up if we're done firing for good 3247 if ( locked ) { 3248 3249 // Keep an empty list if we have data for future add calls 3250 if ( memory ) { 3251 list = []; 3252 3253 // Otherwise, this object is spent 3254 } else { 3255 list = ""; 3256 } 3257 } 3258 }, 3259 3260 // Actual Callbacks object 3261 self = { 3262 3263 // Add a callback or a collection of callbacks to the list 3264 add: function() { 3265 if ( list ) { 3266 3267 // If we have memory from a past run, we should fire after adding 3268 if ( memory && !firing ) { 3269 firingIndex = list.length - 1; 3270 queue.push( memory ); 3271 } 3272 3273 ( function add( args ) { 3274 jQuery.each( args, function( _, arg ) { 3275 if ( isFunction( arg ) ) { 3276 if ( !options.unique || !self.has( arg ) ) { 3277 list.push( arg ); 3278 } 3279 } else if ( arg && arg.length && toType( arg ) !== "string" ) { 3280 3281 // Inspect recursively 3282 add( arg ); 3283 } 3284 } ); 3285 } )( arguments ); 3286 3287 if ( memory && !firing ) { 3288 fire(); 3289 } 3290 } 3291 return this; 3292 }, 3293 3294 // Remove a callback from the list 3295 remove: function() { 3296 jQuery.each( arguments, function( _, arg ) { 3297 var index; 3298 while ( ( index = jQuery.inArray( arg, list, index ) ) > -1 ) { 3299 list.splice( index, 1 ); 3300 3301 // Handle firing indexes 3302 if ( index <= firingIndex ) { 3303 firingIndex--; 3304 } 3305 } 3306 } ); 3307 return this; 3308 }, 3309 3310 // Check if a given callback is in the list. 3311 // If no argument is given, return whether or not list has callbacks attached. 3312 has: function( fn ) { 3313 return fn ? 3314 jQuery.inArray( fn, list ) > -1 : 3315 list.length > 0; 3316 }, 3317 3318 // Remove all callbacks from the list 3319 empty: function() { 3320 if ( list ) { 3321 list = []; 3322 } 3323 return this; 3324 }, 3325 3326 // Disable .fire and .add 3327 // Abort any current/pending executions 3328 // Clear all callbacks and values 3329 disable: function() { 3330 locked = queue = []; 3331 list = memory = ""; 3332 return this; 3333 }, 3334 disabled: function() { 3335 return !list; 3336 }, 3337 3338 // Disable .fire 3339 // Also disable .add unless we have memory (since it would have no effect) 3340 // Abort any pending executions 3341 lock: function() { 3342 locked = queue = []; 3343 if ( !memory && !firing ) { 3344 list = memory = ""; 3345 } 3346 return this; 3347 }, 3348 locked: function() { 3349 return !!locked; 3350 }, 3351 3352 // Call all callbacks with the given context and arguments 3353 fireWith: function( context, args ) { 3354 if ( !locked ) { 3355 args = args || []; 3356 args = [ context, args.slice ? args.slice() : args ]; 3357 queue.push( args ); 3358 if ( !firing ) { 3359 fire(); 3360 } 3361 } 3362 return this; 3363 }, 3364 3365 // Call all the callbacks with the given arguments 3366 fire: function() { 3367 self.fireWith( this, arguments ); 3368 return this; 3369 }, 3370 3371 // To know if the callbacks have already been called at least once 3372 fired: function() { 3373 return !!fired; 3374 } 3375 }; 3376 3377 return self; 3378}; 3379 3380 3381function Identity( v ) { 3382 return v; 3383} 3384function Thrower( ex ) { 3385 throw ex; 3386} 3387 3388function adoptValue( value, resolve, reject, noValue ) { 3389 var method; 3390 3391 try { 3392 3393 // Check for promise aspect first to privilege synchronous behavior 3394 if ( value && isFunction( ( method = value.promise ) ) ) { 3395 method.call( value ).done( resolve ).fail( reject ); 3396 3397 // Other thenables 3398 } else if ( value && isFunction( ( method = value.then ) ) ) { 3399 method.call( value, resolve, reject ); 3400 3401 // Other non-thenables 3402 } else { 3403 3404 // Control `resolve` arguments by letting Array#slice cast boolean `noValue` to integer: 3405 // * false: [ value ].slice( 0 ) => resolve( value ) 3406 // * true: [ value ].slice( 1 ) => resolve() 3407 resolve.apply( undefined, [ value ].slice( noValue ) ); 3408 } 3409 3410 // For Promises/A+, convert exceptions into rejections 3411 // Since jQuery.when doesn't unwrap thenables, we can skip the extra checks appearing in 3412 // Deferred#then to conditionally suppress rejection. 3413 } catch ( value ) { 3414 3415 // Support: Android 4.0 only 3416 // Strict mode functions invoked without .call/.apply get global-object context 3417 reject.apply( undefined, [ value ] ); 3418 } 3419} 3420 3421jQuery.extend( { 3422 3423 Deferred: function( func ) { 3424 var tuples = [ 3425 3426 // action, add listener, callbacks, 3427 // ... .then handlers, argument index, [final state] 3428 [ "notify", "progress", jQuery.Callbacks( "memory" ), 3429 jQuery.Callbacks( "memory" ), 2 ], 3430 [ "resolve", "done", jQuery.Callbacks( "once memory" ), 3431 jQuery.Callbacks( "once memory" ), 0, "resolved" ], 3432 [ "reject", "fail", jQuery.Callbacks( "once memory" ), 3433 jQuery.Callbacks( "once memory" ), 1, "rejected" ] 3434 ], 3435 state = "pending", 3436 promise = { 3437 state: function() { 3438 return state; 3439 }, 3440 always: function() { 3441 deferred.done( arguments ).fail( arguments ); 3442 return this; 3443 }, 3444 "catch": function( fn ) {
vendor: 28,472 bytes, lines 3445-4556
3445 return promise.then( null, fn ); 3446 }, 3447 3448 // Keep pipe for back-compat 3449 pipe: function( /* fnDone, fnFail, fnProgress */ ) { 3450 var fns = arguments; 3451 3452 return jQuery.Deferred( function( newDefer ) { 3453 jQuery.each( tuples, function( _i, tuple ) { 3454 3455 // Map tuples (progress, done, fail) to arguments (done, fail, progress) 3456 var fn = isFunction( fns[ tuple[ 4 ] ] ) && fns[ tuple[ 4 ] ]; 3457 3458 // deferred.progress(function() { bind to newDefer or newDefer.notify }) 3459 // deferred.done(function() { bind to newDefer or newDefer.resolve }) 3460 // deferred.fail(function() { bind to newDefer or newDefer.reject }) 3461 deferred[ tuple[ 1 ] ]( function() { 3462 var returned = fn && fn.apply( this, arguments ); 3463 if ( returned && isFunction( returned.promise ) ) { 3464 returned.promise() 3465 .progress( newDefer.notify ) 3466 .done( newDefer.resolve ) 3467 .fail( newDefer.reject ); 3468 } else { 3469 newDefer[ tuple[ 0 ] + "With" ]( 3470 this, 3471 fn ? [ returned ] : arguments 3472 ); 3473 } 3474 } ); 3475 } ); 3476 fns = null; 3477 } ).promise(); 3478 }, 3479 then: function( onFulfilled, onRejected, onProgress ) { 3480 var maxDepth = 0; 3481 function resolve( depth, deferred, handler, special ) { 3482 return function() { 3483 var that = this, 3484 args = arguments, 3485 mightThrow = function() { 3486 var returned, then; 3487 3488 // Support: Promises/A+ section 2.3.3.3.3 3489 // https://promisesaplus.com/#point-59 3490 // Ignore double-resolution attempts 3491 if ( depth < maxDepth ) { 3492 return; 3493 } 3494 3495 returned = handler.apply( that, args ); 3496 3497 // Support: Promises/A+ section 2.3.1 3498 // https://promisesaplus.com/#point-48 3499 if ( returned === deferred.promise() ) { 3500 throw new TypeError( "Thenable self-resolution" ); 3501 } 3502 3503 // Support: Promises/A+ sections 2.3.3.1, 3.5 3504 // https://promisesaplus.com/#point-54 3505 // https://promisesaplus.com/#point-75 3506 // Retrieve `then` only once 3507 then = returned && 3508 3509 // Support: Promises/A+ section 2.3.4 3510 // https://promisesaplus.com/#point-64 3511 // Only check objects and functions for thenability 3512 ( typeof returned === "object" || 3513 typeof returned === "function" ) && 3514 returned.then; 3515 3516 // Handle a returned thenable 3517 if ( isFunction( then ) ) { 3518 3519 // Special processors (notify) just wait for resolution 3520 if ( special ) { 3521 then.call( 3522 returned, 3523 resolve( maxDepth, deferred, Identity, special ), 3524 resolve( maxDepth, deferred, Thrower, special ) 3525 ); 3526 3527 // Normal processors (resolve) also hook into progress 3528 } else { 3529 3530 // ...and disregard older resolution values 3531 maxDepth++; 3532 3533 then.call( 3534 returned, 3535 resolve( maxDepth, deferred, Identity, special ), 3536 resolve( maxDepth, deferred, Thrower, special ), 3537 resolve( maxDepth, deferred, Identity, 3538 deferred.notifyWith ) 3539 ); 3540 } 3541 3542 // Handle all other returned values 3543 } else { 3544 3545 // Only substitute handlers pass on context 3546 // and multiple values (non-spec behavior) 3547 if ( handler !== Identity ) { 3548 that = undefined; 3549 args = [ returned ]; 3550 } 3551 3552 // Process the value(s) 3553 // Default process is resolve 3554 ( special || deferred.resolveWith )( that, args ); 3555 } 3556 }, 3557 3558 // Only normal processors (resolve) catch and reject exceptions 3559 process = special ? 3560 mightThrow : 3561 function() { 3562 try { 3563 mightThrow(); 3564 } catch ( e ) { 3565 3566 if ( jQuery.Deferred.exceptionHook ) { 3567 jQuery.Deferred.exceptionHook( e, 3568 process.error ); 3569 } 3570 3571 // Support: Promises/A+ section 2.3.3.3.4.1 3572 // https://promisesaplus.com/#point-61 3573 // Ignore post-resolution exceptions 3574 if ( depth + 1 >= maxDepth ) { 3575 3576 // Only substitute handlers pass on context 3577 // and multiple values (non-spec behavior) 3578 if ( handler !== Thrower ) { 3579 that = undefined; 3580 args = [ e ]; 3581 } 3582 3583 deferred.rejectWith( that, args ); 3584 } 3585 } 3586 }; 3587 3588 // Support: Promises/A+ section 2.3.3.3.1 3589 // https://promisesaplus.com/#point-57 3590 // Re-resolve promises immediately to dodge false rejection from 3591 // subsequent errors 3592 if ( depth ) { 3593 process(); 3594 } else { 3595 3596 // Call an optional hook to record the error, in case of exception 3597 // since it's otherwise lost when execution goes async 3598 if ( jQuery.Deferred.getErrorHook ) { 3599 process.error = jQuery.Deferred.getErrorHook(); 3600 3601 // The deprecated alias of the above. While the name suggests 3602 // returning the stack, not an error instance, jQuery just passes 3603 // it directly to `console.warn` so both will work; an instance 3604 // just better cooperates with source maps. 3605 } else if ( jQuery.Deferred.getStackHook ) { 3606 process.error = jQuery.Deferred.getStackHook(); 3607 } 3608 window.setTimeout( process ); 3609 } 3610 }; 3611 } 3612 3613 return jQuery.Deferred( function( newDefer ) { 3614 3615 // progress_handlers.add( ... ) 3616 tuples[ 0 ][ 3 ].add( 3617 resolve( 3618 0, 3619 newDefer, 3620 isFunction( onProgress ) ? 3621 onProgress : 3622 Identity, 3623 newDefer.notifyWith 3624 ) 3625 ); 3626 3627 // fulfilled_handlers.add( ... ) 3628 tuples[ 1 ][ 3 ].add( 3629 resolve( 3630 0, 3631 newDefer, 3632 isFunction( onFulfilled ) ? 3633 onFulfilled : 3634 Identity 3635 ) 3636 ); 3637 3638 // rejected_handlers.add( ... ) 3639 tuples[ 2 ][ 3 ].add( 3640 resolve( 3641 0, 3642 newDefer, 3643 isFunction( onRejected ) ? 3644 onRejected : 3645 Thrower 3646 ) 3647 ); 3648 } ).promise(); 3649 }, 3650 3651 // Get a promise for this deferred 3652 // If obj is provided, the promise aspect is added to the object 3653 promise: function( obj ) { 3654 return obj != null ? jQuery.extend( obj, promise ) : promise; 3655 } 3656 }, 3657 deferred = {}; 3658 3659 // Add list-specific methods 3660 jQuery.each( tuples, function( i, tuple ) { 3661 var list = tuple[ 2 ], 3662 stateString = tuple[ 5 ]; 3663 3664 // promise.progress = list.add 3665 // promise.done = list.add 3666 // promise.fail = list.add 3667 promise[ tuple[ 1 ] ] = list.add; 3668 3669 // Handle state 3670 if ( stateString ) { 3671 list.add( 3672 function() { 3673 3674 // state = "resolved" (i.e., fulfilled) 3675 // state = "rejected" 3676 state = stateString; 3677 }, 3678 3679 // rejected_callbacks.disable 3680 // fulfilled_callbacks.disable 3681 tuples[ 3 - i ][ 2 ].disable, 3682 3683 // rejected_handlers.disable 3684 // fulfilled_handlers.disable 3685 tuples[ 3 - i ][ 3 ].disable, 3686 3687 // progress_callbacks.lock 3688 tuples[ 0 ][ 2 ].lock, 3689 3690 // progress_handlers.lock 3691 tuples[ 0 ][ 3 ].lock 3692 ); 3693 } 3694 3695 // progress_handlers.fire 3696 // fulfilled_handlers.fire 3697 // rejected_handlers.fire 3698 list.add( tuple[ 3 ].fire ); 3699 3700 // deferred.notify = function() { deferred.notifyWith(...) } 3701 // deferred.resolve = function() { deferred.resolveWith(...) } 3702 // deferred.reject = function() { deferred.rejectWith(...) } 3703 deferred[ tuple[ 0 ] ] = function() { 3704 deferred[ tuple[ 0 ] + "With" ]( this === deferred ? undefined : this, arguments ); 3705 return this; 3706 }; 3707 3708 // deferred.notifyWith = list.fireWith 3709 // deferred.resolveWith = list.fireWith 3710 // deferred.rejectWith = list.fireWith 3711 deferred[ tuple[ 0 ] + "With" ] = list.fireWith; 3712 } ); 3713 3714 // Make the deferred a promise 3715 promise.promise( deferred ); 3716 3717 // Call given func if any 3718 if ( func ) { 3719 func.call( deferred, deferred ); 3720 } 3721 3722 // All done! 3723 return deferred; 3724 }, 3725 3726 // Deferred helper 3727 when: function( singleValue ) { 3728 var 3729 3730 // count of uncompleted subordinates 3731 remaining = arguments.length, 3732 3733 // count of unprocessed arguments 3734 i = remaining, 3735 3736 // subordinate fulfillment data 3737 resolveContexts = Array( i ), 3738 resolveValues = slice.call( arguments ), 3739 3740 // the primary Deferred 3741 primary = jQuery.Deferred(), 3742 3743 // subordinate callback factory 3744 updateFunc = function( i ) { 3745 return function( value ) { 3746 resolveContexts[ i ] = this; 3747 resolveValues[ i ] = arguments.length > 1 ? slice.call( arguments ) : value; 3748 if ( !( --remaining ) ) { 3749 primary.resolveWith( resolveContexts, resolveValues ); 3750 } 3751 }; 3752 }; 3753 3754 // Single- and empty arguments are adopted like Promise.resolve 3755 if ( remaining <= 1 ) { 3756 adoptValue( singleValue, primary.done( updateFunc( i ) ).resolve, primary.reject, 3757 !remaining ); 3758 3759 // Use .then() to unwrap secondary thenables (cf. gh-3000) 3760 if ( primary.state() === "pending" || 3761 isFunction( resolveValues[ i ] && resolveValues[ i ].then ) ) { 3762 3763 return primary.then(); 3764 } 3765 } 3766 3767 // Multiple arguments are aggregated like Promise.all array elements 3768 while ( i-- ) { 3769 adoptValue( resolveValues[ i ], updateFunc( i ), primary.reject ); 3770 } 3771 3772 return primary.promise(); 3773 } 3774} ); 3775 3776 3777// These usually indicate a programmer mistake during development, 3778// warn about them ASAP rather than swallowing them by default. 3779var rerrorNames = /^(Eval|Internal|Range|Reference|Syntax|Type|URI)Error$/; 3780 3781// If `jQuery.Deferred.getErrorHook` is defined, `asyncError` is an error 3782// captured before the async barrier to get the original error cause 3783// which may otherwise be hidden. 3784jQuery.Deferred.exceptionHook = function( error, asyncError ) { 3785 3786 // Support: IE 8 - 9 only 3787 // Console exists when dev tools are open, which can happen at any time 3788 if ( window.console && window.console.warn && error && rerrorNames.test( error.name ) ) { 3789 window.console.warn( "jQuery.Deferred exception: " + error.message, 3790 error.stack, asyncError ); 3791 } 3792}; 3793 3794 3795 3796 3797jQuery.readyException = function( error ) { 3798 window.setTimeout( function() { 3799 throw error; 3800 } ); 3801}; 3802 3803 3804 3805 3806// The deferred used on DOM ready 3807var readyList = jQuery.Deferred(); 3808 3809jQuery.fn.ready = function( fn ) { 3810 3811 readyList 3812 .then( fn ) 3813 3814 // Wrap jQuery.readyException in a function so that the lookup 3815 // happens at the time of error handling instead of callback 3816 // registration. 3817 .catch( function( error ) { 3818 jQuery.readyException( error ); 3819 } ); 3820 3821 return this; 3822}; 3823 3824jQuery.extend( { 3825 3826 // Is the DOM ready to be used? Set to true once it occurs. 3827 isReady: false, 3828 3829 // A counter to track how many items to wait for before 3830 // the ready event fires. See trac-6781 3831 readyWait: 1, 3832 3833 // Handle when the DOM is ready 3834 ready: function( wait ) { 3835 3836 // Abort if there are pending holds or we're already ready 3837 if ( wait === true ? --jQuery.readyWait : jQuery.isReady ) { 3838 return; 3839 } 3840 3841 // Remember that the DOM is ready 3842 jQuery.isReady = true; 3843 3844 // If a normal DOM Ready event fired, decrement, and wait if need be 3845 if ( wait !== true && --jQuery.readyWait > 0 ) { 3846 return; 3847 } 3848 3849 // If there are functions bound, to execute 3850 readyList.resolveWith( document, [ jQuery ] ); 3851 } 3852} ); 3853 3854jQuery.ready.then = readyList.then; 3855 3856// The ready event handler and self cleanup method 3857function completed() { 3858 document.removeEventListener( "DOMContentLoaded", completed ); 3859 window.removeEventListener( "load", completed ); 3860 jQuery.ready(); 3861} 3862 3863// Catch cases where $(document).ready() is called 3864// after the browser event has already occurred. 3865// Support: IE <=9 - 10 only 3866// Older IE sometimes signals "interactive" too soon 3867if ( document.readyState === "complete" || 3868 ( document.readyState !== "loading" && !document.documentElement.doScroll ) ) { 3869 3870 // Handle it asynchronously to allow scripts the opportunity to delay ready 3871 window.setTimeout( jQuery.ready ); 3872 3873} else { 3874 3875 // Use the handy event callback 3876 document.addEventListener( "DOMContentLoaded", completed ); 3877 3878 // A fallback to window.onload, that will always work 3879 window.addEventListener( "load", completed ); 3880} 3881 3882 3883 3884 3885// Multifunctional method to get and set values of a collection 3886// The value/s can optionally be executed if it's a function 3887var access = function( elems, fn, key, value, chainable, emptyGet, raw ) { 3888 var i = 0, 3889 len = elems.length, 3890 bulk = key == null; 3891 3892 // Sets many values 3893 if ( toType( key ) === "object" ) { 3894 chainable = true; 3895 for ( i in key ) { 3896 access( elems, fn, i, key[ i ], true, emptyGet, raw ); 3897 } 3898 3899 // Sets one value 3900 } else if ( value !== undefined ) { 3901 chainable = true; 3902 3903 if ( !isFunction( value ) ) { 3904 raw = true; 3905 } 3906 3907 if ( bulk ) { 3908 3909 // Bulk operations run against the entire set 3910 if ( raw ) { 3911 fn.call( elems, value ); 3912 fn = null; 3913 3914 // ...except when executing function values 3915 } else { 3916 bulk = fn; 3917 fn = function( elem, _key, value ) { 3918 return bulk.call( jQuery( elem ), value ); 3919 }; 3920 } 3921 } 3922 3923 if ( fn ) { 3924 for ( ; i < len; i++ ) { 3925 fn( 3926 elems[ i ], key, raw ? 3927 value : 3928 value.call( elems[ i ], i, fn( elems[ i ], key ) ) 3929 ); 3930 } 3931 } 3932 } 3933 3934 if ( chainable ) { 3935 return elems; 3936 } 3937 3938 // Gets 3939 if ( bulk ) { 3940 return fn.call( elems ); 3941 } 3942 3943 return len ? fn( elems[ 0 ], key ) : emptyGet; 3944}; 3945 3946 3947// Matches dashed string for camelizing 3948var rmsPrefix = /^-ms-/, 3949 rdashAlpha = /-([a-z])/g; 3950 3951// Used by camelCase as callback to replace() 3952function fcamelCase( _all, letter ) { 3953 return letter.toUpperCase(); 3954} 3955 3956// Convert dashed to camelCase; used by the css and data modules 3957// Support: IE <=9 - 11, Edge 12 - 15 3958// Microsoft forgot to hump their vendor prefix (trac-9572) 3959function camelCase( string ) { 3960 return string.replace( rmsPrefix, "ms-" ).replace( rdashAlpha, fcamelCase ); 3961} 3962var acceptData = function( owner ) { 3963 3964 // Accepts only: 3965 // - Node 3966 // - Node.ELEMENT_NODE 3967 // - Node.DOCUMENT_NODE 3968 // - Object 3969 // - Any 3970 return owner.nodeType === 1 || owner.nodeType === 9 || !( +owner.nodeType ); 3971}; 3972 3973 3974 3975 3976function Data() { 3977 this.expando = jQuery.expando + Data.uid++; 3978} 3979 3980Data.uid = 1; 3981 3982Data.prototype = { 3983 3984 cache: function( owner ) { 3985 3986 // Check if the owner object already has a cache 3987 var value = owner[ this.expando ]; 3988 3989 // If not, create one 3990 if ( !value ) { 3991 value = {}; 3992 3993 // We can accept data for non-element nodes in modern browsers, 3994 // but we should not, see trac-8335. 3995 // Always return an empty object. 3996 if ( acceptData( owner ) ) { 3997 3998 // If it is a node unlikely to be stringify-ed or looped over 3999 // use plain assignment 4000 if ( owner.nodeType ) { 4001 owner[ this.expando ] = value; 4002 4003 // Otherwise secure it in a non-enumerable property 4004 // configurable must be true to allow the property to be 4005 // deleted when data is removed 4006 } else { 4007 Object.defineProperty( owner, this.expando, { 4008 value: value, 4009 configurable: true 4010 } ); 4011 } 4012 } 4013 } 4014 4015 return value; 4016 }, 4017 set: function( owner, data, value ) { 4018 var prop, 4019 cache = this.cache( owner ); 4020 4021 // Handle: [ owner, key, value ] args 4022 // Always use camelCase key (gh-2257) 4023 if ( typeof data === "string" ) { 4024 cache[ camelCase( data ) ] = value; 4025 4026 // Handle: [ owner, { properties } ] args 4027 } else { 4028 4029 // Copy the properties one-by-one to the cache object 4030 for ( prop in data ) { 4031 cache[ camelCase( prop ) ] = data[ prop ]; 4032 } 4033 } 4034 return cache; 4035 }, 4036 get: function( owner, key ) { 4037 return key === undefined ? 4038 this.cache( owner ) : 4039 4040 // Always use camelCase key (gh-2257) 4041 owner[ this.expando ] && owner[ this.expando ][ camelCase( key ) ]; 4042 }, 4043 access: function( owner, key, value ) { 4044 4045 // In cases where either: 4046 // 4047 // 1. No key was specified 4048 // 2. A string key was specified, but no value provided 4049 // 4050 // Take the "read" path and allow the get method to determine 4051 // which value to return, respectively either: 4052 // 4053 // 1. The entire cache object 4054 // 2. The data stored at the key 4055 // 4056 if ( key === undefined || 4057 ( ( key && typeof key === "string" ) && value === undefined ) ) { 4058 4059 return this.get( owner, key ); 4060 } 4061 4062 // When the key is not a string, or both a key and value 4063 // are specified, set or extend (existing objects) with either: 4064 // 4065 // 1. An object of properties 4066 // 2. A key and value 4067 // 4068 this.set( owner, key, value ); 4069 4070 // Since the "set" path can have two possible entry points 4071 // return the expected data based on which path was taken[*] 4072 return value !== undefined ? value : key; 4073 }, 4074 remove: function( owner, key ) { 4075 var i, 4076 cache = owner[ this.expando ]; 4077 4078 if ( cache === undefined ) { 4079 return; 4080 } 4081 4082 if ( key !== undefined ) { 4083 4084 // Support array or space separated string of keys 4085 if ( Array.isArray( key ) ) { 4086 4087 // If key is an array of keys... 4088 // We always set camelCase keys, so remove that. 4089 key = key.map( camelCase ); 4090 } else { 4091 key = camelCase( key ); 4092 4093 // If a key with the spaces exists, use it. 4094 // Otherwise, create an array by matching non-whitespace 4095 key = key in cache ? 4096 [ key ] : 4097 ( key.match( rnothtmlwhite ) || [] ); 4098 } 4099 4100 i = key.length; 4101 4102 while ( i-- ) { 4103 delete cache[ key[ i ] ]; 4104 } 4105 } 4106 4107 // Remove the expando if there's no more data 4108 if ( key === undefined || jQuery.isEmptyObject( cache ) ) { 4109 4110 // Support: Chrome <=35 - 45 4111 // Webkit & Blink performance suffers when deleting properties 4112 // from DOM nodes, so set to undefined instead 4113 // https://bugs.chromium.org/p/chromium/issues/detail?id=378607 (bug restricted) 4114 if ( owner.nodeType ) { 4115 owner[ this.expando ] = undefined; 4116 } else { 4117 delete owner[ this.expando ]; 4118 } 4119 } 4120 }, 4121 hasData: function( owner ) { 4122 var cache = owner[ this.expando ]; 4123 return cache !== undefined && !jQuery.isEmptyObject( cache ); 4124 } 4125}; 4126var dataPriv = new Data(); 4127 4128var dataUser = new Data(); 4129 4130 4131 4132// Implementation Summary 4133// 4134// 1. Enforce API surface and semantic compatibility with 1.9.x branch 4135// 2. Improve the module's maintainability by reducing the storage 4136// paths to a single mechanism. 4137// 3. Use the same single mechanism to support "private" and "user" data. 4138// 4. _Never_ expose "private" data to user code (TODO: Drop _data, _removeData) 4139// 5. Avoid exposing implementation details on user objects (eg. expando properties) 4140// 6. Provide a clear path for implementation upgrade to WeakMap in 2014 4141 4142var rbrace = /^(?:\{[\w\W]*\}|\[[\w\W]*\])$/, 4143 rmultiDash = /[A-Z]/g; 4144 4145function getData( data ) { 4146 if ( data === "true" ) { 4147 return true; 4148 } 4149 4150 if ( data === "false" ) { 4151 return false; 4152 } 4153 4154 if ( data === "null" ) { 4155 return null; 4156 } 4157 4158 // Only convert to a number if it doesn't change the string 4159 if ( data === +data + "" ) { 4160 return +data; 4161 } 4162 4163 if ( rbrace.test( data ) ) { 4164 return JSON.parse( data ); 4165 } 4166 4167 return data; 4168} 4169 4170function dataAttr( elem, key, data ) { 4171 var name; 4172 4173 // If nothing was found internally, try to fetch any 4174 // data from the HTML5 data-* attribute 4175 if ( data === undefined && elem.nodeType === 1 ) { 4176 name = "data-" + key.replace( rmultiDash, "-$&" ).toLowerCase(); 4177 data = elem.getAttribute( name ); 4178 4179 if ( typeof data === "string" ) { 4180 try { 4181 data = getData( data ); 4182 } catch ( e ) {} 4183 4184 // Make sure we set the data so it isn't changed later 4185 dataUser.set( elem, key, data ); 4186 } else { 4187 data = undefined; 4188 } 4189 } 4190 return data; 4191} 4192 4193jQuery.extend( { 4194 hasData: function( elem ) { 4195 return dataUser.hasData( elem ) || dataPriv.hasData( elem ); 4196 }, 4197 4198 data: function( elem, name, data ) { 4199 return dataUser.access( elem, name, data ); 4200 }, 4201 4202 removeData: function( elem, name ) { 4203 dataUser.remove( elem, name ); 4204 }, 4205 4206 // TODO: Now that all calls to _data and _removeData have been replaced 4207 // with direct calls to dataPriv methods, these can be deprecated. 4208 _data: function( elem, name, data ) { 4209 return dataPriv.access( elem, name, data ); 4210 }, 4211 4212 _removeData: function( elem, name ) { 4213 dataPriv.remove( elem, name ); 4214 } 4215} ); 4216 4217jQuery.fn.extend( { 4218 data: function( key, value ) { 4219 var i, name, data, 4220 elem = this[ 0 ], 4221 attrs = elem && elem.attributes; 4222 4223 // Gets all values 4224 if ( key === undefined ) { 4225 if ( this.length ) { 4226 data = dataUser.get( elem ); 4227 4228 if ( elem.nodeType === 1 && !dataPriv.get( elem, "hasDataAttrs" ) ) { 4229 i = attrs.length; 4230 while ( i-- ) { 4231 4232 // Support: IE 11 only 4233 // The attrs elements can be null (trac-14894) 4234 if ( attrs[ i ] ) { 4235 name = attrs[ i ].name; 4236 if ( name.indexOf( "data-" ) === 0 ) { 4237 name = camelCase( name.slice( 5 ) ); 4238 dataAttr( elem, name, data[ name ] ); 4239 } 4240 } 4241 } 4242 dataPriv.set( elem, "hasDataAttrs", true ); 4243 } 4244 } 4245 4246 return data; 4247 } 4248 4249 // Sets multiple values 4250 if ( typeof key === "object" ) { 4251 return this.each( function() { 4252 dataUser.set( this, key ); 4253 } ); 4254 } 4255 4256 return access( this, function( value ) { 4257 var data; 4258 4259 // The calling jQuery object (element matches) is not empty 4260 // (and therefore has an element appears at this[ 0 ]) and the 4261 // `value` parameter was not undefined. An empty jQuery object 4262 // will result in `undefined` for elem = this[ 0 ] which will 4263 // throw an exception if an attempt to read a data cache is made. 4264 if ( elem && value === undefined ) { 4265 4266 // Attempt to get data from the cache 4267 // The key will always be camelCased in Data 4268 data = dataUser.get( elem, key ); 4269 if ( data !== undefined ) { 4270 return data; 4271 } 4272 4273 // Attempt to "discover" the data in 4274 // HTML5 custom data-* attrs 4275 data = dataAttr( elem, key ); 4276 if ( data !== undefined ) { 4277 return data; 4278 } 4279 4280 // We tried really hard, but the data doesn't exist. 4281 return; 4282 } 4283 4284 // Set the data... 4285 this.each( function() { 4286 4287 // We always store the camelCased key 4288 dataUser.set( this, key, value ); 4289 } ); 4290 }, null, value, arguments.length > 1, null, true ); 4291 }, 4292 4293 removeData: function( key ) { 4294 return this.each( function() { 4295 dataUser.remove( this, key ); 4296 } ); 4297 } 4298} ); 4299 4300 4301jQuery.extend( { 4302 queue: function( elem, type, data ) { 4303 var queue; 4304 4305 if ( elem ) { 4306 type = ( type || "fx" ) + "queue"; 4307 queue = dataPriv.get( elem, type ); 4308 4309 // Speed up dequeue by getting out quickly if this is just a lookup 4310 if ( data ) { 4311 if ( !queue || Array.isArray( data ) ) { 4312 queue = dataPriv.access( elem, type, jQuery.makeArray( data ) ); 4313 } else { 4314 queue.push( data ); 4315 } 4316 } 4317 return queue || []; 4318 } 4319 }, 4320 4321 dequeue: function( elem, type ) { 4322 type = type || "fx"; 4323 4324 var queue = jQuery.queue( elem, type ), 4325 startLength = queue.length, 4326 fn = queue.shift(), 4327 hooks = jQuery._queueHooks( elem, type ), 4328 next = function() { 4329 jQuery.dequeue( elem, type ); 4330 }; 4331 4332 // If the fx queue is dequeued, always remove the progress sentinel 4333 if ( fn === "inprogress" ) { 4334 fn = queue.shift(); 4335 startLength--; 4336 } 4337 4338 if ( fn ) { 4339 4340 // Add a progress sentinel to prevent the fx queue from being 4341 // automatically dequeued 4342 if ( type === "fx" ) { 4343 queue.unshift( "inprogress" ); 4344 } 4345 4346 // Clear up the last queue stop function 4347 delete hooks.stop; 4348 fn.call( elem, next, hooks ); 4349 } 4350 4351 if ( !startLength && hooks ) { 4352 hooks.empty.fire(); 4353 } 4354 }, 4355 4356 // Not public - generate a queueHooks object, or return the current one 4357 _queueHooks: function( elem, type ) { 4358 var key = type + "queueHooks"; 4359 return dataPriv.get( elem, key ) || dataPriv.access( elem, key, { 4360 empty: jQuery.Callbacks( "once memory" ).add( function() { 4361 dataPriv.remove( elem, [ type + "queue", key ] ); 4362 } ) 4363 } ); 4364 } 4365} ); 4366 4367jQuery.fn.extend( { 4368 queue: function( type, data ) { 4369 var setter = 2; 4370 4371 if ( typeof type !== "string" ) { 4372 data = type; 4373 type = "fx"; 4374 setter--; 4375 } 4376 4377 if ( arguments.length < setter ) { 4378 return jQuery.queue( this[ 0 ], type ); 4379 } 4380 4381 return data === undefined ? 4382 this : 4383 this.each( function() { 4384 var queue = jQuery.queue( this, type, data ); 4385 4386 // Ensure a hooks for this queue 4387 jQuery._queueHooks( this, type ); 4388 4389 if ( type === "fx" && queue[ 0 ] !== "inprogress" ) { 4390 jQuery.dequeue( this, type ); 4391 } 4392 } ); 4393 }, 4394 dequeue: function( type ) { 4395 return this.each( function() { 4396 jQuery.dequeue( this, type ); 4397 } ); 4398 }, 4399 clearQueue: function( type ) { 4400 return this.queue( type || "fx", [] ); 4401 }, 4402 4403 // Get a promise resolved when queues of a certain type 4404 // are emptied (fx is the type by default) 4405 promise: function( type, obj ) { 4406 var tmp, 4407 count = 1, 4408 defer = jQuery.Deferred(), 4409 elements = this, 4410 i = this.length, 4411 resolve = function() { 4412 if ( !( --count ) ) { 4413 defer.resolveWith( elements, [ elements ] ); 4414 } 4415 }; 4416 4417 if ( typeof type !== "string" ) { 4418 obj = type; 4419 type = undefined; 4420 } 4421 type = type || "fx"; 4422 4423 while ( i-- ) { 4424 tmp = dataPriv.get( elements[ i ], type + "queueHooks" ); 4425 if ( tmp && tmp.empty ) { 4426 count++; 4427 tmp.empty.add( resolve ); 4428 } 4429 } 4430 resolve(); 4431 return defer.promise( obj ); 4432 } 4433} ); 4434var pnum = ( /[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/ ).source; 4435 4436var rcssNum = new RegExp( "^(?:([+-])=|)(" + pnum + ")([a-z%]*)$", "i" ); 4437 4438 4439var cssExpand = [ "Top", "Right", "Bottom", "Left" ]; 4440 4441var documentElement = document.documentElement; 4442 4443 4444 4445 var isAttached = function( elem ) { 4446 return jQuery.contains( elem.ownerDocument, elem ); 4447 }, 4448 composed = { composed: true }; 4449 4450 // Support: IE 9 - 11+, Edge 12 - 18+, iOS 10.0 - 10.2 only 4451 // Check attachment across shadow DOM boundaries when possible (gh-3504) 4452 // Support: iOS 10.0-10.2 only 4453 // Early iOS 10 versions support `attachShadow` but not `getRootNode`, 4454 // leading to errors. We need to check for `getRootNode`. 4455 if ( documentElement.getRootNode ) { 4456 isAttached = function( elem ) { 4457 return jQuery.contains( elem.ownerDocument, elem ) || 4458 elem.getRootNode( composed ) === elem.ownerDocument; 4459 }; 4460 } 4461var isHiddenWithinTree = function( elem, el ) { 4462 4463 // isHiddenWithinTree might be called from jQuery#filter function; 4464 // in that case, element will be second argument 4465 elem = el || elem; 4466 4467 // Inline style trumps all 4468 return elem.style.display === "none" || 4469 elem.style.display === "" && 4470 4471 // Otherwise, check computed style 4472 // Support: Firefox <=43 - 45 4473 // Disconnected elements can have computed display: none, so first confirm that elem is 4474 // in the document. 4475 isAttached( elem ) && 4476 4477 jQuery.css( elem, "display" ) === "none"; 4478 }; 4479 4480 4481 4482function adjustCSS( elem, prop, valueParts, tween ) { 4483 var adjusted, scale, 4484 maxIterations = 20, 4485 currentValue = tween ? 4486 function() { 4487 return tween.cur(); 4488 } : 4489 function() { 4490 return jQuery.css( elem, prop, "" ); 4491 }, 4492 initial = currentValue(), 4493 unit = valueParts && valueParts[ 3 ] || ( jQuery.cssNumber[ prop ] ? "" : "px" ), 4494 4495 // Starting value computation is required for potential unit mismatches 4496 initialInUnit = elem.nodeType && 4497 ( jQuery.cssNumber[ prop ] || unit !== "px" && +initial ) && 4498 rcssNum.exec( jQuery.css( elem, prop ) ); 4499 4500 if ( initialInUnit && initialInUnit[ 3 ] !== unit ) { 4501 4502 // Support: Firefox <=54 4503 // Halve the iteration target value to prevent interference from CSS upper bounds (gh-2144) 4504 initial = initial / 2; 4505 4506 // Trust units reported by jQuery.css 4507 unit = unit || initialInUnit[ 3 ]; 4508 4509 // Iteratively approximate from a nonzero starting point 4510 initialInUnit = +initial || 1; 4511 4512 while ( maxIterations-- ) { 4513 4514 // Evaluate and update our best guess (doubling guesses that zero out). 4515 // Finish if the scale equals or crosses 1 (making the old*new product non-positive). 4516 jQuery.style( elem, prop, initialInUnit + unit ); 4517 if ( ( 1 - scale ) * ( 1 - ( scale = currentValue() / initial || 0.5 ) ) <= 0 ) { 4518 maxIterations = 0; 4519 } 4520 initialInUnit = initialInUnit / scale; 4521 4522 } 4523 4524 initialInUnit = initialInUnit * 2; 4525 jQuery.style( elem, prop, initialInUnit + unit ); 4526 4527 // Make sure we update the tween properties later on 4528 valueParts = valueParts || []; 4529 } 4530 4531 if ( valueParts ) { 4532 initialInUnit = +initialInUnit || +initial || 0; 4533 4534 // Apply relative offset (+=/-=) if specified 4535 adjusted = valueParts[ 1 ] ? 4536 initialInUnit + ( valueParts[ 1 ] + 1 ) * valueParts[ 2 ] : 4537 +valueParts[ 2 ]; 4538 if ( tween ) { 4539 tween.unit = unit; 4540 tween.start = initialInUnit; 4541 tween.end = adjusted; 4542 } 4543 } 4544 return adjusted; 4545} 4546 4547 4548var defaultDisplayMap = {}; 4549 4550function getDefaultDisplay( elem ) { 4551 var temp, 4552 doc = elem.ownerDocument, 4553 nodeName = elem.nodeName, 4554 display = defaultDisplayMap[ nodeName ]; 4555 4556 if ( display ) {
vendor: 2,317 bytes, lines 4557-4655
4557 return display; 4558 } 4559 4560 temp = doc.body.appendChild( doc.createElement( nodeName ) ); 4561 display = jQuery.css( temp, "display" ); 4562 4563 temp.parentNode.removeChild( temp ); 4564 4565 if ( display === "none" ) { 4566 display = "block"; 4567 } 4568 defaultDisplayMap[ nodeName ] = display; 4569 4570 return display; 4571} 4572 4573function showHide( elements, show ) { 4574 var display, elem, 4575 values = [], 4576 index = 0, 4577 length = elements.length; 4578 4579 // Determine new display value for elements that need to change 4580 for ( ; index < length; index++ ) { 4581 elem = elements[ index ]; 4582 if ( !elem.style ) { 4583 continue; 4584 } 4585 4586 display = elem.style.display; 4587 if ( show ) { 4588 4589 // Since we force visibility upon cascade-hidden elements, an immediate (and slow) 4590 // check is required in this first loop unless we have a nonempty display value (either 4591 // inline or about-to-be-restored) 4592 if ( display === "none" ) { 4593 values[ index ] = dataPriv.get( elem, "display" ) || null; 4594 if ( !values[ index ] ) { 4595 elem.style.display = ""; 4596 } 4597 } 4598 if ( elem.style.display === "" && isHiddenWithinTree( elem ) ) { 4599 values[ index ] = getDefaultDisplay( elem ); 4600 } 4601 } else { 4602 if ( display !== "none" ) { 4603 values[ index ] = "none"; 4604 4605 // Remember what we're overwriting 4606 dataPriv.set( elem, "display", display ); 4607 } 4608 } 4609 } 4610 4611 // Set the display of the elements in a second loop to avoid constant reflow 4612 for ( index = 0; index < length; index++ ) { 4613 if ( values[ index ] != null ) { 4614 elements[ index ].style.display = values[ index ]; 4615 } 4616 } 4617 4618 return elements; 4619} 4620 4621jQuery.fn.extend( { 4622 show: function() { 4623 return showHide( this, true ); 4624 }, 4625 hide: function() { 4626 return showHide( this ); 4627 }, 4628 toggle: function( state ) { 4629 if ( typeof state === "boolean" ) { 4630 return state ? this.show() : this.hide(); 4631 } 4632 4633 return this.each( function() { 4634 if ( isHiddenWithinTree( this ) ) { 4635 jQuery( this ).show(); 4636 } else { 4637 jQuery( this ).hide(); 4638 } 4639 } ); 4640 } 4641} ); 4642var rcheckableType = ( /^(?:checkbox|radio)$/i ); 4643 4644var rtagName = ( /<([a-z][^\/\0>\x20\t\r\n\f]*)/i ); 4645 4646var rscriptType = ( /^$|^module$|\/(?:java|ecma)script/i ); 4647 4648 4649 4650( function() { 4651 var fragment = document.createDocumentFragment(), 4652 div = fragment.appendChild( document.createElement( "div" ) ), 4653 input = document.createElement( "input" ); 4654 4655 // Support: Android 4.0 - 4.3 only
vendor: 10,092 bytes, lines 4656-5040
4656 // Check state lost if the name is set (trac-11217) 4657 // Support: Windows Web Apps (WWA) 4658 // `name` and `type` must use .setAttribute for WWA (trac-14901) 4659 input.setAttribute( "type", "radio" ); 4660 input.setAttribute( "checked", "checked" ); 4661 input.setAttribute( "name", "t" ); 4662 4663 div.appendChild( input ); 4664 4665 // Support: Android <=4.1 only 4666 // Older WebKit doesn't clone checked state correctly in fragments 4667 support.checkClone = div.cloneNode( true ).cloneNode( true ).lastChild.checked; 4668 4669 // Support: IE <=11 only 4670 // Make sure textarea (and checkbox) defaultValue is properly cloned 4671 div.innerHTML = "<textarea>x</textarea>"; 4672 support.noCloneChecked = !!div.cloneNode( true ).lastChild.defaultValue; 4673 4674 // Support: IE <=9 only 4675 // IE <=9 replaces <option> tags with their contents when inserted outside of 4676 // the select element. 4677 div.innerHTML = "<option></option>"; 4678 support.option = !!div.lastChild; 4679} )(); 4680 4681 4682// We have to close these tags to support XHTML (trac-13200) 4683var wrapMap = { 4684 4685 // XHTML parsers do not magically insert elements in the 4686 // same way that tag soup parsers do. So we cannot shorten 4687 // this by omitting <tbody> or other required elements. 4688 thead: [ 1, "<table>", "</table>" ], 4689 col: [ 2, "<table><colgroup>", "</colgroup></table>" ], 4690 tr: [ 2, "<table><tbody>", "</tbody></table>" ], 4691 td: [ 3, "<table><tbody><tr>", "</tr></tbody></table>" ], 4692 4693 _default: [ 0, "", "" ] 4694}; 4695 4696wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead; 4697wrapMap.th = wrapMap.td; 4698 4699// Support: IE <=9 only 4700if ( !support.option ) { 4701 wrapMap.optgroup = wrapMap.option = [ 1, "<select multiple='multiple'>", "</select>" ]; 4702} 4703 4704 4705function getAll( context, tag ) { 4706 4707 // Support: IE <=9 - 11 only 4708 // Use typeof to avoid zero-argument method invocation on host objects (trac-15151) 4709 var ret; 4710 4711 if ( typeof context.getElementsByTagName !== "undefined" ) { 4712 ret = context.getElementsByTagName( tag || "*" ); 4713 4714 } else if ( typeof context.querySelectorAll !== "undefined" ) { 4715 ret = context.querySelectorAll( tag || "*" ); 4716 4717 } else { 4718 ret = []; 4719 } 4720 4721 if ( tag === undefined || tag && nodeName( context, tag ) ) { 4722 return jQuery.merge( [ context ], ret ); 4723 } 4724 4725 return ret; 4726} 4727 4728 4729// Mark scripts as having already been evaluated 4730function setGlobalEval( elems, refElements ) { 4731 var i = 0, 4732 l = elems.length; 4733 4734 for ( ; i < l; i++ ) { 4735 dataPriv.set( 4736 elems[ i ], 4737 "globalEval", 4738 !refElements || dataPriv.get( refElements[ i ], "globalEval" ) 4739 ); 4740 } 4741} 4742 4743 4744var rhtml = /<|&#?\w+;/; 4745 4746function buildFragment( elems, context, scripts, selection, ignored ) { 4747 var elem, tmp, tag, wrap, attached, j, 4748 fragment = context.createDocumentFragment(), 4749 nodes = [], 4750 i = 0, 4751 l = elems.length; 4752 4753 for ( ; i < l; i++ ) { 4754 elem = elems[ i ]; 4755 4756 if ( elem || elem === 0 ) { 4757 4758 // Add nodes directly 4759 if ( toType( elem ) === "object" ) { 4760 4761 // Support: Android <=4.0 only, PhantomJS 1 only 4762 // push.apply(_, arraylike) throws on ancient WebKit 4763 jQuery.merge( nodes, elem.nodeType ? [ elem ] : elem ); 4764 4765 // Convert non-html into a text node 4766 } else if ( !rhtml.test( elem ) ) { 4767 nodes.push( context.createTextNode( elem ) ); 4768 4769 // Convert html into DOM nodes 4770 } else { 4771 tmp = tmp || fragment.appendChild( context.createElement( "div" ) ); 4772 4773 // Deserialize a standard representation 4774 tag = ( rtagName.exec( elem ) || [ "", "" ] )[ 1 ].toLowerCase(); 4775 wrap = wrapMap[ tag ] || wrapMap._default; 4776 tmp.innerHTML = wrap[ 1 ] + jQuery.htmlPrefilter( elem ) + wrap[ 2 ]; 4777 4778 // Descend through wrappers to the right content 4779 j = wrap[ 0 ]; 4780 while ( j-- ) { 4781 tmp = tmp.lastChild; 4782 } 4783 4784 // Support: Android <=4.0 only, PhantomJS 1 only 4785 // push.apply(_, arraylike) throws on ancient WebKit 4786 jQuery.merge( nodes, tmp.childNodes ); 4787 4788 // Remember the top-level container 4789 tmp = fragment.firstChild; 4790 4791 // Ensure the created nodes are orphaned (trac-12392) 4792 tmp.textContent = ""; 4793 } 4794 } 4795 } 4796 4797 // Remove wrapper from fragment 4798 fragment.textContent = ""; 4799 4800 i = 0; 4801 while ( ( elem = nodes[ i++ ] ) ) { 4802 4803 // Skip elements already in the context collection (trac-4087) 4804 if ( selection && jQuery.inArray( elem, selection ) > -1 ) { 4805 if ( ignored ) { 4806 ignored.push( elem ); 4807 } 4808 continue; 4809 } 4810 4811 attached = isAttached( elem ); 4812 4813 // Append to fragment 4814 tmp = getAll( fragment.appendChild( elem ), "script" ); 4815 4816 // Preserve script evaluation history 4817 if ( attached ) { 4818 setGlobalEval( tmp ); 4819 } 4820 4821 // Capture executables 4822 if ( scripts ) { 4823 j = 0; 4824 while ( ( elem = tmp[ j++ ] ) ) { 4825 if ( rscriptType.test( elem.type || "" ) ) { 4826 scripts.push( elem ); 4827 } 4828 } 4829 } 4830 } 4831 4832 return fragment; 4833} 4834 4835 4836var rtypenamespace = /^([^.]*)(?:\.(.+)|)/; 4837 4838function returnTrue() { 4839 return true; 4840} 4841 4842function returnFalse() { 4843 return false; 4844} 4845 4846function on( elem, types, selector, data, fn, one ) { 4847 var origFn, type; 4848 4849 // Types can be a map of types/handlers 4850 if ( typeof types === "object" ) { 4851 4852 // ( types-Object, selector, data ) 4853 if ( typeof selector !== "string" ) { 4854 4855 // ( types-Object, data ) 4856 data = data || selector; 4857 selector = undefined; 4858 } 4859 for ( type in types ) { 4860 on( elem, type, selector, data, types[ type ], one ); 4861 } 4862 return elem; 4863 } 4864 4865 if ( data == null && fn == null ) { 4866 4867 // ( types, fn ) 4868 fn = selector; 4869 data = selector = undefined; 4870 } else if ( fn == null ) { 4871 if ( typeof selector === "string" ) { 4872 4873 // ( types, selector, fn ) 4874 fn = data; 4875 data = undefined; 4876 } else { 4877 4878 // ( types, data, fn ) 4879 fn = data; 4880 data = selector; 4881 selector = undefined; 4882 } 4883 } 4884 if ( fn === false ) { 4885 fn = returnFalse; 4886 } else if ( !fn ) { 4887 return elem; 4888 } 4889 4890 if ( one === 1 ) { 4891 origFn = fn; 4892 fn = function( event ) { 4893 4894 // Can use an empty set, since event contains the info 4895 jQuery().off( event ); 4896 return origFn.apply( this, arguments ); 4897 }; 4898 4899 // Use same guid so caller can remove using origFn 4900 fn.guid = origFn.guid || ( origFn.guid = jQuery.guid++ ); 4901 } 4902 return elem.each( function() { 4903 jQuery.event.add( this, types, fn, data, selector ); 4904 } ); 4905} 4906 4907/* 4908 * Helper functions for managing events -- not part of the public interface. 4909 * Props to Dean Edwards' addEvent library for many of the ideas. 4910 */ 4911jQuery.event = { 4912 4913 global: {}, 4914 4915 add: function( elem, types, handler, data, selector ) { 4916 4917 var handleObjIn, eventHandle, tmp, 4918 events, t, handleObj, 4919 special, handlers, type, namespaces, origType, 4920 elemData = dataPriv.get( elem ); 4921 4922 // Only attach events to objects that accept data 4923 if ( !acceptData( elem ) ) { 4924 return; 4925 } 4926 4927 // Caller can pass in an object of custom data in lieu of the handler 4928 if ( handler.handler ) { 4929 handleObjIn = handler; 4930 handler = handleObjIn.handler; 4931 selector = handleObjIn.selector; 4932 } 4933 4934 // Ensure that invalid selectors throw exceptions at attach time 4935 // Evaluate against documentElement in case elem is a non-element node (e.g., document) 4936 if ( selector ) { 4937 jQuery.find.matchesSelector( documentElement, selector ); 4938 } 4939 4940 // Make sure that the handler has a unique ID, used to find/remove it later 4941 if ( !handler.guid ) { 4942 handler.guid = jQuery.guid++; 4943 } 4944 4945 // Init the element's event structure and main handler, if this is the first 4946 if ( !( events = elemData.events ) ) { 4947 events = elemData.events = Object.create( null ); 4948 } 4949 if ( !( eventHandle = elemData.handle ) ) { 4950 eventHandle = elemData.handle = function( e ) { 4951 4952 // Discard the second event of a jQuery.event.trigger() and 4953 // when an event is called after a page has unloaded 4954 return typeof jQuery !== "undefined" && jQuery.event.triggered !== e.type ? 4955 jQuery.event.dispatch.apply( elem, arguments ) : undefined; 4956 }; 4957 } 4958 4959 // Handle multiple events separated by a space 4960 types = ( types || "" ).match( rnothtmlwhite ) || [ "" ]; 4961 t = types.length; 4962 while ( t-- ) { 4963 tmp = rtypenamespace.exec( types[ t ] ) || []; 4964 type = origType = tmp[ 1 ]; 4965 namespaces = ( tmp[ 2 ] || "" ).split( "." ).sort(); 4966 4967 // There *must* be a type, no attaching namespace-only handlers 4968 if ( !type ) { 4969 continue; 4970 } 4971 4972 // If event changes its type, use the special event handlers for the changed type 4973 special = jQuery.event.special[ type ] || {}; 4974 4975 // If selector defined, determine special event api type, otherwise given type 4976 type = ( selector ? special.delegateType : special.bindType ) || type; 4977 4978 // Update special based on newly reset type 4979 special = jQuery.event.special[ type ] || {}; 4980 4981 // handleObj is passed to all event handlers 4982 handleObj = jQuery.extend( { 4983 type: type, 4984 origType: origType, 4985 data: data, 4986 handler: handler, 4987 guid: handler.guid, 4988 selector: selector, 4989 needsContext: selector && jQuery.expr.match.needsContext.test( selector ), 4990 namespace: namespaces.join( "." ) 4991 }, handleObjIn ); 4992 4993 // Init the event handler queue if we're the first 4994 if ( !( handlers = events[ type ] ) ) { 4995 handlers = events[ type ] = []; 4996 handlers.delegateCount = 0; 4997 4998 // Only use addEventListener if the special events handler returns false 4999 if ( !special.setup || 5000 special.setup.call( elem, data, namespaces, eventHandle ) === false ) { 5001 5002 if ( elem.addEventListener ) { 5003 elem.addEventListener( type, eventHandle ); 5004 } 5005 } 5006 } 5007 5008 if ( special.add ) { 5009 special.add.call( elem, handleObj ); 5010 5011 if ( !handleObj.handler.guid ) { 5012 handleObj.handler.guid = handler.guid; 5013 } 5014 } 5015 5016 // Add to the element's handler list, delegates in front 5017 if ( selector ) { 5018 handlers.splice( handlers.delegateCount++, 0, handleObj ); 5019 } else { 5020 handlers.push( handleObj ); 5021 } 5022 5023 // Keep track of which events have ever been used, for event optimization 5024 jQuery.event.global[ type ] = true; 5025 } 5026 5027 }, 5028 5029 // Detach an event or set of events from an element 5030 remove: function( elem, types, handler, selector, mappedTypes ) { 5031 5032 var j, origCount, tmp, 5033 events, t, handleObj, 5034 special, handlers, type, namespaces, origType, 5035 elemData = dataPriv.hasData( elem ) && dataPriv.get( elem ); 5036 5037 if ( !elemData || !( events = elemData.events ) ) { 5038 return; 5039 } 5040
vendor: 4,197 bytes, lines 5041-5179
5041 // Once for each type.namespace in types; type may be omitted 5042 types = ( types || "" ).match( rnothtmlwhite ) || [ "" ]; 5043 t = types.length; 5044 while ( t-- ) { 5045 tmp = rtypenamespace.exec( types[ t ] ) || []; 5046 type = origType = tmp[ 1 ]; 5047 namespaces = ( tmp[ 2 ] || "" ).split( "." ).sort(); 5048 5049 // Unbind all events (on this namespace, if provided) for the element 5050 if ( !type ) { 5051 for ( type in events ) { 5052 jQuery.event.remove( elem, type + types[ t ], handler, selector, true ); 5053 } 5054 continue; 5055 } 5056 5057 special = jQuery.event.special[ type ] || {}; 5058 type = ( selector ? special.delegateType : special.bindType ) || type; 5059 handlers = events[ type ] || []; 5060 tmp = tmp[ 2 ] && 5061 new RegExp( "(^|\\.)" + namespaces.join( "\\.(?:.*\\.|)" ) + "(\\.|$)" ); 5062 5063 // Remove matching events 5064 origCount = j = handlers.length; 5065 while ( j-- ) { 5066 handleObj = handlers[ j ]; 5067 5068 if ( ( mappedTypes || origType === handleObj.origType ) && 5069 ( !handler || handler.guid === handleObj.guid ) && 5070 ( !tmp || tmp.test( handleObj.namespace ) ) && 5071 ( !selector || selector === handleObj.selector || 5072 selector === "**" && handleObj.selector ) ) { 5073 handlers.splice( j, 1 ); 5074 5075 if ( handleObj.selector ) { 5076 handlers.delegateCount--; 5077 } 5078 if ( special.remove ) { 5079 special.remove.call( elem, handleObj ); 5080 } 5081 } 5082 } 5083 5084 // Remove generic event handler if we removed something and no more handlers exist 5085 // (avoids potential for endless recursion during removal of special event handlers) 5086 if ( origCount && !handlers.length ) { 5087 if ( !special.teardown || 5088 special.teardown.call( elem, namespaces, elemData.handle ) === false ) { 5089 5090 jQuery.removeEvent( elem, type, elemData.handle ); 5091 } 5092 5093 delete events[ type ]; 5094 } 5095 } 5096 5097 // Remove data and the expando if it's no longer used 5098 if ( jQuery.isEmptyObject( events ) ) { 5099 dataPriv.remove( elem, "handle events" ); 5100 } 5101 }, 5102 5103 dispatch: function( nativeEvent ) { 5104 5105 var i, j, ret, matched, handleObj, handlerQueue, 5106 args = new Array( arguments.length ), 5107 5108 // Make a writable jQuery.Event from the native event object 5109 event = jQuery.event.fix( nativeEvent ), 5110 5111 handlers = ( 5112 dataPriv.get( this, "events" ) || Object.create( null ) 5113 )[ event.type ] || [], 5114 special = jQuery.event.special[ event.type ] || {}; 5115 5116 // Use the fix-ed jQuery.Event rather than the (read-only) native event 5117 args[ 0 ] = event; 5118 5119 for ( i = 1; i < arguments.length; i++ ) { 5120 args[ i ] = arguments[ i ]; 5121 } 5122 5123 event.delegateTarget = this; 5124 5125 // Call the preDispatch hook for the mapped type, and let it bail if desired 5126 if ( special.preDispatch && special.preDispatch.call( this, event ) === false ) { 5127 return; 5128 } 5129 5130 // Determine handlers 5131 handlerQueue = jQuery.event.handlers.call( this, event, handlers ); 5132 5133 // Run delegates first; they may want to stop propagation beneath us 5134 i = 0; 5135 while ( ( matched = handlerQueue[ i++ ] ) && !event.isPropagationStopped() ) { 5136 event.currentTarget = matched.elem; 5137 5138 j = 0; 5139 while ( ( handleObj = matched.handlers[ j++ ] ) && 5140 !event.isImmediatePropagationStopped() ) { 5141 5142 // If the event is namespaced, then each handler is only invoked if it is 5143 // specially universal or its namespaces are a superset of the event's. 5144 if ( !event.rnamespace || handleObj.namespace === false || 5145 event.rnamespace.test( handleObj.namespace ) ) { 5146 5147 event.handleObj = handleObj; 5148 event.data = handleObj.data; 5149 5150 ret = ( ( jQuery.event.special[ handleObj.origType ] || {} ).handle || 5151 handleObj.handler ).apply( matched.elem, args ); 5152 5153 if ( ret !== undefined ) { 5154 if ( ( event.result = ret ) === false ) { 5155 event.preventDefault(); 5156 event.stopPropagation(); 5157 } 5158 } 5159 } 5160 } 5161 } 5162 5163 // Call the postDispatch hook for the mapped type 5164 if ( special.postDispatch ) { 5165 special.postDispatch.call( this, event ); 5166 } 5167 5168 return event.result; 5169 }, 5170 5171 handlers: function( event, handlers ) { 5172 var i, handleObj, sel, matchedHandlers, matchedSelectors, 5173 handlerQueue = [], 5174 delegateCount = handlers.delegateCount, 5175 cur = event.target; 5176 5177 // Find delegate handlers 5178 if ( delegateCount && 5179
vendor: 19,034 bytes, lines 5180-5826
5180 // Support: IE <=9 5181 // Black-hole SVG <use> instance trees (trac-13180) 5182 cur.nodeType && 5183 5184 // Support: Firefox <=42 5185 // Suppress spec-violating clicks indicating a non-primary pointer button (trac-3861) 5186 // https://www.w3.org/TR/DOM-Level-3-Events/#event-type-click 5187 // Support: IE 11 only 5188 // ...but not arrow key "clicks" of radio inputs, which can have `button` -1 (gh-2343) 5189 !( event.type === "click" && event.button >= 1 ) ) { 5190 5191 for ( ; cur !== this; cur = cur.parentNode || this ) { 5192 5193 // Don't check non-elements (trac-13208) 5194 // Don't process clicks on disabled elements (trac-6911, trac-8165, trac-11382, trac-11764) 5195 if ( cur.nodeType === 1 && !( event.type === "click" && cur.disabled === true ) ) { 5196 matchedHandlers = []; 5197 matchedSelectors = {}; 5198 for ( i = 0; i < delegateCount; i++ ) { 5199 handleObj = handlers[ i ]; 5200 5201 // Don't conflict with Object.prototype properties (trac-13203) 5202 sel = handleObj.selector + " "; 5203 5204 if ( matchedSelectors[ sel ] === undefined ) { 5205 matchedSelectors[ sel ] = handleObj.needsContext ? 5206 jQuery( sel, this ).index( cur ) > -1 : 5207 jQuery.find( sel, this, null, [ cur ] ).length; 5208 } 5209 if ( matchedSelectors[ sel ] ) { 5210 matchedHandlers.push( handleObj ); 5211 } 5212 } 5213 if ( matchedHandlers.length ) { 5214 handlerQueue.push( { elem: cur, handlers: matchedHandlers } ); 5215 } 5216 } 5217 } 5218 } 5219 5220 // Add the remaining (directly-bound) handlers 5221 cur = this; 5222 if ( delegateCount < handlers.length ) { 5223 handlerQueue.push( { elem: cur, handlers: handlers.slice( delegateCount ) } ); 5224 } 5225 5226 return handlerQueue; 5227 }, 5228 5229 addProp: function( name, hook ) { 5230 Object.defineProperty( jQuery.Event.prototype, name, { 5231 enumerable: true, 5232 configurable: true, 5233 5234 get: isFunction( hook ) ? 5235 function() { 5236 if ( this.originalEvent ) { 5237 return hook( this.originalEvent ); 5238 } 5239 } : 5240 function() { 5241 if ( this.originalEvent ) { 5242 return this.originalEvent[ name ]; 5243 } 5244 }, 5245 5246 set: function( value ) { 5247 Object.defineProperty( this, name, { 5248 enumerable: true, 5249 configurable: true, 5250 writable: true, 5251 value: value 5252 } ); 5253 } 5254 } ); 5255 }, 5256 5257 fix: function( originalEvent ) { 5258 return originalEvent[ jQuery.expando ] ? 5259 originalEvent : 5260 new jQuery.Event( originalEvent ); 5261 }, 5262 5263 special: { 5264 load: { 5265 5266 // Prevent triggered image.load events from bubbling to window.load 5267 noBubble: true 5268 }, 5269 click: { 5270 5271 // Utilize native event to ensure correct state for checkable inputs 5272 setup: function( data ) { 5273 5274 // For mutual compressibility with _default, replace `this` access with a local var. 5275 // `|| data` is dead code meant only to preserve the variable through minification. 5276 var el = this || data; 5277 5278 // Claim the first handler 5279 if ( rcheckableType.test( el.type ) && 5280 el.click && nodeName( el, "input" ) ) { 5281 5282 // dataPriv.set( el, "click", ... ) 5283 leverageNative( el, "click", true ); 5284 } 5285 5286 // Return false to allow normal processing in the caller 5287 return false; 5288 }, 5289 trigger: function( data ) { 5290 5291 // For mutual compressibility with _default, replace `this` access with a local var. 5292 // `|| data` is dead code meant only to preserve the variable through minification. 5293 var el = this || data; 5294 5295 // Force setup before triggering a click 5296 if ( rcheckableType.test( el.type ) && 5297 el.click && nodeName( el, "input" ) ) { 5298 5299 leverageNative( el, "click" ); 5300 } 5301 5302 // Return non-false to allow normal event-path propagation 5303 return true; 5304 }, 5305 5306 // For cross-browser consistency, suppress native .click() on links 5307 // Also prevent it if we're currently inside a leveraged native-event stack 5308 _default: function( event ) { 5309 var target = event.target; 5310 return rcheckableType.test( target.type ) && 5311 target.click && nodeName( target, "input" ) && 5312 dataPriv.get( target, "click" ) || 5313 nodeName( target, "a" ); 5314 } 5315 }, 5316 5317 beforeunload: { 5318 postDispatch: function( event ) { 5319 5320 // Support: Firefox 20+ 5321 // Firefox doesn't alert if the returnValue field is not set. 5322 if ( event.result !== undefined && event.originalEvent ) { 5323 event.originalEvent.returnValue = event.result; 5324 } 5325 } 5326 } 5327 } 5328}; 5329 5330// Ensure the presence of an event listener that handles manually-triggered 5331// synthetic events by interrupting progress until reinvoked in response to 5332// *native* events that it fires directly, ensuring that state changes have 5333// already occurred before other listeners are invoked. 5334function leverageNative( el, type, isSetup ) { 5335 5336 // Missing `isSetup` indicates a trigger call, which must force setup through jQuery.event.add 5337 if ( !isSetup ) { 5338 if ( dataPriv.get( el, type ) === undefined ) { 5339 jQuery.event.add( el, type, returnTrue ); 5340 } 5341 return; 5342 } 5343 5344 // Register the controller as a special universal handler for all event namespaces 5345 dataPriv.set( el, type, false ); 5346 jQuery.event.add( el, type, { 5347 namespace: false, 5348 handler: function( event ) { 5349 var result, 5350 saved = dataPriv.get( this, type ); 5351 5352 if ( ( event.isTrigger & 1 ) && this[ type ] ) { 5353 5354 // Interrupt processing of the outer synthetic .trigger()ed event 5355 if ( !saved ) { 5356 5357 // Store arguments for use when handling the inner native event 5358 // There will always be at least one argument (an event object), so this array 5359 // will not be confused with a leftover capture object. 5360 saved = slice.call( arguments ); 5361 dataPriv.set( this, type, saved ); 5362 5363 // Trigger the native event and capture its result 5364 this[ type ](); 5365 result = dataPriv.get( this, type ); 5366 dataPriv.set( this, type, false ); 5367 5368 if ( saved !== result ) { 5369 5370 // Cancel the outer synthetic event 5371 event.stopImmediatePropagation(); 5372 event.preventDefault(); 5373 5374 return result; 5375 } 5376 5377 // If this is an inner synthetic event for an event with a bubbling surrogate 5378 // (focus or blur), assume that the surrogate already propagated from triggering 5379 // the native event and prevent that from happening again here. 5380 // This technically gets the ordering wrong w.r.t. to `.trigger()` (in which the 5381 // bubbling surrogate propagates *after* the non-bubbling base), but that seems 5382 // less bad than duplication. 5383 } else if ( ( jQuery.event.special[ type ] || {} ).delegateType ) { 5384 event.stopPropagation(); 5385 } 5386 5387 // If this is a native event triggered above, everything is now in order 5388 // Fire an inner synthetic event with the original arguments 5389 } else if ( saved ) { 5390 5391 // ...and capture the result 5392 dataPriv.set( this, type, jQuery.event.trigger( 5393 saved[ 0 ], 5394 saved.slice( 1 ), 5395 this 5396 ) ); 5397 5398 // Abort handling of the native event by all jQuery handlers while allowing 5399 // native handlers on the same element to run. On target, this is achieved 5400 // by stopping immediate propagation just on the jQuery event. However, 5401 // the native event is re-wrapped by a jQuery one on each level of the 5402 // propagation so the only way to stop it for jQuery is to stop it for 5403 // everyone via native `stopPropagation()`. This is not a problem for 5404 // focus/blur which don't bubble, but it does also stop click on checkboxes 5405 // and radios. We accept this limitation. 5406 event.stopPropagation(); 5407 event.isImmediatePropagationStopped = returnTrue; 5408 } 5409 } 5410 } ); 5411} 5412 5413jQuery.removeEvent = function( elem, type, handle ) { 5414 5415 // This "if" is needed for plain objects 5416 if ( elem.removeEventListener ) { 5417 elem.removeEventListener( type, handle ); 5418 } 5419}; 5420 5421jQuery.Event = function( src, props ) { 5422 5423 // Allow instantiation without the 'new' keyword 5424 if ( !( this instanceof jQuery.Event ) ) { 5425 return new jQuery.Event( src, props ); 5426 } 5427 5428 // Event object 5429 if ( src && src.type ) { 5430 this.originalEvent = src; 5431 this.type = src.type; 5432 5433 // Events bubbling up the document may have been marked as prevented 5434 // by a handler lower down the tree; reflect the correct value. 5435 this.isDefaultPrevented = src.defaultPrevented || 5436 src.defaultPrevented === undefined && 5437 5438 // Support: Android <=2.3 only 5439 src.returnValue === false ? 5440 returnTrue : 5441 returnFalse; 5442 5443 // Create target properties 5444 // Support: Safari <=6 - 7 only 5445 // Target should not be a text node (trac-504, trac-13143) 5446 this.target = ( src.target && src.target.nodeType === 3 ) ? 5447 src.target.parentNode : 5448 src.target; 5449 5450 this.currentTarget = src.currentTarget; 5451 this.relatedTarget = src.relatedTarget; 5452 5453 // Event type 5454 } else { 5455 this.type = src; 5456 } 5457 5458 // Put explicitly provided properties onto the event object 5459 if ( props ) { 5460 jQuery.extend( this, props ); 5461 } 5462 5463 // Create a timestamp if incoming event doesn't have one 5464 this.timeStamp = src && src.timeStamp || Date.now(); 5465 5466 // Mark it as fixed 5467 this[ jQuery.expando ] = true; 5468}; 5469 5470// jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding 5471// https://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html 5472jQuery.Event.prototype = { 5473 constructor: jQuery.Event, 5474 isDefaultPrevented: returnFalse, 5475 isPropagationStopped: returnFalse, 5476 isImmediatePropagationStopped: returnFalse, 5477 isSimulated: false, 5478 5479 preventDefault: function() { 5480 var e = this.originalEvent; 5481 5482 this.isDefaultPrevented = returnTrue; 5483 5484 if ( e && !this.isSimulated ) { 5485 e.preventDefault(); 5486 } 5487 }, 5488 stopPropagation: function() { 5489 var e = this.originalEvent; 5490 5491 this.isPropagationStopped = returnTrue; 5492 5493 if ( e && !this.isSimulated ) { 5494 e.stopPropagation(); 5495 } 5496 }, 5497 stopImmediatePropagation: function() { 5498 var e = this.originalEvent; 5499 5500 this.isImmediatePropagationStopped = returnTrue; 5501 5502 if ( e && !this.isSimulated ) { 5503 e.stopImmediatePropagation(); 5504 } 5505 5506 this.stopPropagation(); 5507 } 5508}; 5509 5510// Includes all common event props including KeyEvent and MouseEvent specific props 5511jQuery.each( { 5512 altKey: true, 5513 bubbles: true, 5514 cancelable: true, 5515 changedTouches: true, 5516 ctrlKey: true, 5517 detail: true, 5518 eventPhase: true, 5519 metaKey: true, 5520 pageX: true, 5521 pageY: true, 5522 shiftKey: true, 5523 view: true, 5524 "char": true, 5525 code: true, 5526 charCode: true, 5527 key: true, 5528 keyCode: true, 5529 button: true, 5530 buttons: true, 5531 clientX: true, 5532 clientY: true, 5533 offsetX: true, 5534 offsetY: true, 5535 pointerId: true, 5536 pointerType: true, 5537 screenX: true, 5538 screenY: true, 5539 targetTouches: true, 5540 toElement: true, 5541 touches: true, 5542 which: true 5543}, jQuery.event.addProp ); 5544 5545jQuery.each( { focus: "focusin", blur: "focusout" }, function( type, delegateType ) { 5546 5547 function focusMappedHandler( nativeEvent ) { 5548 if ( document.documentMode ) { 5549 5550 // Support: IE 11+ 5551 // Attach a single focusin/focusout handler on the document while someone wants 5552 // focus/blur. This is because the former are synchronous in IE while the latter 5553 // are async. In other browsers, all those handlers are invoked synchronously. 5554 5555 // `handle` from private data would already wrap the event, but we need 5556 // to change the `type` here. 5557 var handle = dataPriv.get( this, "handle" ), 5558 event = jQuery.event.fix( nativeEvent ); 5559 event.type = nativeEvent.type === "focusin" ? "focus" : "blur"; 5560 event.isSimulated = true; 5561 5562 // First, handle focusin/focusout 5563 handle( nativeEvent ); 5564 5565 // ...then, handle focus/blur 5566 // 5567 // focus/blur don't bubble while focusin/focusout do; simulate the former by only 5568 // invoking the handler at the lower level. 5569 if ( event.target === event.currentTarget ) { 5570 5571 // The setup part calls `leverageNative`, which, in turn, calls 5572 // `jQuery.event.add`, so event handle will already have been set 5573 // by this point. 5574 handle( event ); 5575 } 5576 } else { 5577 5578 // For non-IE browsers, attach a single capturing handler on the document 5579 // while someone wants focusin/focusout. 5580 jQuery.event.simulate( delegateType, nativeEvent.target, 5581 jQuery.event.fix( nativeEvent ) ); 5582 } 5583 } 5584 5585 jQuery.event.special[ type ] = { 5586 5587 // Utilize native event if possible so blur/focus sequence is correct 5588 setup: function() { 5589 5590 var attaches; 5591 5592 // Claim the first handler 5593 // dataPriv.set( this, "focus", ... ) 5594 // dataPriv.set( this, "blur", ... ) 5595 leverageNative( this, type, true ); 5596 5597 if ( document.documentMode ) { 5598 5599 // Support: IE 9 - 11+ 5600 // We use the same native handler for focusin & focus (and focusout & blur) 5601 // so we need to coordinate setup & teardown parts between those events. 5602 // Use `delegateType` as the key as `type` is already used by `leverageNative`. 5603 attaches = dataPriv.get( this, delegateType ); 5604 if ( !attaches ) { 5605 this.addEventListener( delegateType, focusMappedHandler ); 5606 } 5607 dataPriv.set( this, delegateType, ( attaches || 0 ) + 1 ); 5608 } else { 5609 5610 // Return false to allow normal processing in the caller 5611 return false; 5612 } 5613 }, 5614 trigger: function() { 5615 5616 // Force setup before trigger 5617 leverageNative( this, type ); 5618 5619 // Return non-false to allow normal event-path propagation 5620 return true; 5621 }, 5622 5623 teardown: function() { 5624 var attaches; 5625 5626 if ( document.documentMode ) { 5627 attaches = dataPriv.get( this, delegateType ) - 1; 5628 if ( !attaches ) { 5629 this.removeEventListener( delegateType, focusMappedHandler ); 5630 dataPriv.remove( this, delegateType ); 5631 } else { 5632 dataPriv.set( this, delegateType, attaches ); 5633 } 5634 } else { 5635 5636 // Return false to indicate standard teardown should be applied 5637 return false; 5638 } 5639 }, 5640 5641 // Suppress native focus or blur if we're currently inside 5642 // a leveraged native-event stack 5643 _default: function( event ) { 5644 return dataPriv.get( event.target, type ); 5645 }, 5646 5647 delegateType: delegateType 5648 }; 5649 5650 // Support: Firefox <=44 5651 // Firefox doesn't have focus(in | out) events 5652 // Related ticket - https://bugzilla.mozilla.org/show_bug.cgi?id=687787 5653 // 5654 // Support: Chrome <=48 - 49, Safari <=9.0 - 9.1 5655 // focus(in | out) events fire after focus & blur events, 5656 // which is spec violation - http://www.w3.org/TR/DOM-Level-3-Events/#events-focusevent-event-order 5657 // Related ticket - https://bugs.chromium.org/p/chromium/issues/detail?id=449857 5658 // 5659 // Support: IE 9 - 11+ 5660 // To preserve relative focusin/focus & focusout/blur event order guaranteed on the 3.x branch, 5661 // attach a single handler for both events in IE. 5662 jQuery.event.special[ delegateType ] = { 5663 setup: function() { 5664 5665 // Handle: regular nodes (via `this.ownerDocument`), window 5666 // (via `this.document`) & document (via `this`). 5667 var doc = this.ownerDocument || this.document || this, 5668 dataHolder = document.documentMode ? this : doc, 5669 attaches = dataPriv.get( dataHolder, delegateType ); 5670 5671 // Support: IE 9 - 11+ 5672 // We use the same native handler for focusin & focus (and focusout & blur) 5673 // so we need to coordinate setup & teardown parts between those events. 5674 // Use `delegateType` as the key as `type` is already used by `leverageNative`. 5675 if ( !attaches ) { 5676 if ( document.documentMode ) { 5677 this.addEventListener( delegateType, focusMappedHandler ); 5678 } else { 5679 doc.addEventListener( type, focusMappedHandler, true ); 5680 } 5681 } 5682 dataPriv.set( dataHolder, delegateType, ( attaches || 0 ) + 1 ); 5683 }, 5684 teardown: function() { 5685 var doc = this.ownerDocument || this.document || this, 5686 dataHolder = document.documentMode ? this : doc, 5687 attaches = dataPriv.get( dataHolder, delegateType ) - 1; 5688 5689 if ( !attaches ) { 5690 if ( document.documentMode ) { 5691 this.removeEventListener( delegateType, focusMappedHandler ); 5692 } else { 5693 doc.removeEventListener( type, focusMappedHandler, true ); 5694 } 5695 dataPriv.remove( dataHolder, delegateType ); 5696 } else { 5697 dataPriv.set( dataHolder, delegateType, attaches ); 5698 } 5699 } 5700 }; 5701} ); 5702 5703// Create mouseenter/leave events using mouseover/out and event-time checks 5704// so that event delegation works in jQuery. 5705// Do the same for pointerenter/pointerleave and pointerover/pointerout 5706// 5707// Support: Safari 7 only 5708// Safari sends mouseenter too often; see: 5709// https://bugs.chromium.org/p/chromium/issues/detail?id=470258 5710// for the description of the bug (it existed in older Chrome versions as well). 5711jQuery.each( { 5712 mouseenter: "mouseover", 5713 mouseleave: "mouseout", 5714 pointerenter: "pointerover", 5715 pointerleave: "pointerout" 5716}, function( orig, fix ) { 5717 jQuery.event.special[ orig ] = { 5718 delegateType: fix, 5719 bindType: fix, 5720 5721 handle: function( event ) { 5722 var ret, 5723 target = this, 5724 related = event.relatedTarget, 5725 handleObj = event.handleObj; 5726 5727 // For mouseenter/leave call the handler if related is outside the target. 5728 // NB: No relatedTarget if the mouse left/entered the browser window 5729 if ( !related || ( related !== target && !jQuery.contains( target, related ) ) ) { 5730 event.type = handleObj.origType; 5731 ret = handleObj.handler.apply( this, arguments ); 5732 event.type = fix; 5733 } 5734 return ret; 5735 } 5736 }; 5737} ); 5738 5739jQuery.fn.extend( { 5740 5741 on: function( types, selector, data, fn ) { 5742 return on( this, types, selector, data, fn ); 5743 }, 5744 one: function( types, selector, data, fn ) { 5745 return on( this, types, selector, data, fn, 1 ); 5746 }, 5747 off: function( types, selector, fn ) { 5748 var handleObj, type; 5749 if ( types && types.preventDefault && types.handleObj ) { 5750 5751 // ( event ) dispatched jQuery.Event 5752 handleObj = types.handleObj; 5753 jQuery( types.delegateTarget ).off( 5754 handleObj.namespace ? 5755 handleObj.origType + "." + handleObj.namespace : 5756 handleObj.origType, 5757 handleObj.selector, 5758 handleObj.handler 5759 ); 5760 return this; 5761 } 5762 if ( typeof types === "object" ) { 5763 5764 // ( types-object [, selector] ) 5765 for ( type in types ) { 5766 this.off( type, selector, types[ type ] ); 5767 } 5768 return this; 5769 } 5770 if ( selector === false || typeof selector === "function" ) { 5771 5772 // ( types [, fn] ) 5773 fn = selector; 5774 selector = undefined; 5775 } 5776 if ( fn === false ) { 5777 fn = returnFalse; 5778 } 5779 return this.each( function() { 5780 jQuery.event.remove( this, types, fn, selector ); 5781 } ); 5782 } 5783} ); 5784 5785 5786var 5787 5788 // Support: IE <=10 - 11, Edge 12 - 13 only 5789 // In IE/Edge using regex groups here causes severe slowdowns. 5790 // See https://connect.microsoft.com/IE/feedback/details/1736512/ 5791 rnoInnerhtml = /<script|<style|<link/i, 5792 5793 // checked="checked" or checked 5794 rchecked = /checked\s*(?:[^=]|=\s*.checked.)/i, 5795 5796 rcleanScript = /^\s*<!\[CDATA\[|\]\]>\s*$/g; 5797 5798// Prefer a tbody over its parent table for containing new rows 5799function manipulationTarget( elem, content ) { 5800 if ( nodeName( elem, "table" ) && 5801 nodeName( content.nodeType !== 11 ? content : content.firstChild, "tr" ) ) { 5802 5803 return jQuery( elem ).children( "tbody" )[ 0 ] || elem; 5804 } 5805 5806 return elem; 5807} 5808 5809// Replace/restore the type attribute of script elements for safe DOM manipulation 5810function disableScript( elem ) { 5811 elem.type = ( elem.getAttribute( "type" ) !== null ) + "/" + elem.type; 5812 return elem; 5813} 5814function restoreScript( elem ) { 5815 if ( ( elem.type || "" ).slice( 0, 5 ) === "true/" ) { 5816 elem.type = elem.type.slice( 5 ); 5817 } else { 5818 elem.removeAttribute( "type" ); 5819 } 5820 5821 return elem; 5822} 5823 5824function cloneCopyEvent( src, dest ) { 5825 var i, l, type, pdataOld, udataOld, udataCur, events; 5826
vendor: 6,382 bytes, lines 5827-6056
5827 if ( dest.nodeType !== 1 ) { 5828 return; 5829 } 5830 5831 // 1. Copy private data: events, handlers, etc. 5832 if ( dataPriv.hasData( src ) ) { 5833 pdataOld = dataPriv.get( src ); 5834 events = pdataOld.events; 5835 5836 if ( events ) { 5837 dataPriv.remove( dest, "handle events" ); 5838 5839 for ( type in events ) { 5840 for ( i = 0, l = events[ type ].length; i < l; i++ ) { 5841 jQuery.event.add( dest, type, events[ type ][ i ] ); 5842 } 5843 } 5844 } 5845 } 5846 5847 // 2. Copy user data 5848 if ( dataUser.hasData( src ) ) { 5849 udataOld = dataUser.access( src ); 5850 udataCur = jQuery.extend( {}, udataOld ); 5851 5852 dataUser.set( dest, udataCur ); 5853 } 5854} 5855 5856// Fix IE bugs, see support tests 5857function fixInput( src, dest ) { 5858 var nodeName = dest.nodeName.toLowerCase(); 5859 5860 // Fails to persist the checked state of a cloned checkbox or radio button. 5861 if ( nodeName === "input" && rcheckableType.test( src.type ) ) { 5862 dest.checked = src.checked; 5863 5864 // Fails to return the selected option to the default selected state when cloning options 5865 } else if ( nodeName === "input" || nodeName === "textarea" ) { 5866 dest.defaultValue = src.defaultValue; 5867 } 5868} 5869 5870function domManip( collection, args, callback, ignored ) { 5871 5872 // Flatten any nested arrays 5873 args = flat( args ); 5874 5875 var fragment, first, scripts, hasScripts, node, doc, 5876 i = 0, 5877 l = collection.length, 5878 iNoClone = l - 1, 5879 value = args[ 0 ], 5880 valueIsFunction = isFunction( value ); 5881 5882 // We can't cloneNode fragments that contain checked, in WebKit 5883 if ( valueIsFunction || 5884 ( l > 1 && typeof value === "string" && 5885 !support.checkClone && rchecked.test( value ) ) ) { 5886 return collection.each( function( index ) { 5887 var self = collection.eq( index ); 5888 if ( valueIsFunction ) { 5889 args[ 0 ] = value.call( this, index, self.html() ); 5890 } 5891 domManip( self, args, callback, ignored ); 5892 } ); 5893 } 5894 5895 if ( l ) { 5896 fragment = buildFragment( args, collection[ 0 ].ownerDocument, false, collection, ignored ); 5897 first = fragment.firstChild; 5898 5899 if ( fragment.childNodes.length === 1 ) { 5900 fragment = first; 5901 } 5902 5903 // Require either new content or an interest in ignored elements to invoke the callback 5904 if ( first || ignored ) { 5905 scripts = jQuery.map( getAll( fragment, "script" ), disableScript ); 5906 hasScripts = scripts.length; 5907 5908 // Use the original fragment for the last item 5909 // instead of the first because it can end up 5910 // being emptied incorrectly in certain situations (trac-8070). 5911 for ( ; i < l; i++ ) { 5912 node = fragment; 5913 5914 if ( i !== iNoClone ) { 5915 node = jQuery.clone( node, true, true ); 5916 5917 // Keep references to cloned scripts for later restoration 5918 if ( hasScripts ) { 5919 5920 // Support: Android <=4.0 only, PhantomJS 1 only 5921 // push.apply(_, arraylike) throws on ancient WebKit 5922 jQuery.merge( scripts, getAll( node, "script" ) ); 5923 } 5924 } 5925 5926 callback.call( collection[ i ], node, i ); 5927 } 5928 5929 if ( hasScripts ) { 5930 doc = scripts[ scripts.length - 1 ].ownerDocument; 5931 5932 // Re-enable scripts 5933 jQuery.map( scripts, restoreScript ); 5934 5935 // Evaluate executable scripts on first document insertion 5936 for ( i = 0; i < hasScripts; i++ ) { 5937 node = scripts[ i ]; 5938 if ( rscriptType.test( node.type || "" ) && 5939 !dataPriv.access( node, "globalEval" ) && 5940 jQuery.contains( doc, node ) ) { 5941 5942 if ( node.src && ( node.type || "" ).toLowerCase() !== "module" ) { 5943 5944 // Optional AJAX dependency, but won't run scripts if not present 5945 if ( jQuery._evalUrl && !node.noModule ) { 5946 jQuery._evalUrl( node.src, { 5947 nonce: node.nonce || node.getAttribute( "nonce" ) 5948 }, doc ); 5949 } 5950 } else { 5951 5952 // Unwrap a CDATA section containing script contents. This shouldn't be 5953 // needed as in XML documents they're already not visible when 5954 // inspecting element contents and in HTML documents they have no 5955 // meaning but we're preserving that logic for backwards compatibility. 5956 // This will be removed completely in 4.0. See gh-4904. 5957 DOMEval( node.textContent.replace( rcleanScript, "" ), node, doc ); 5958 } 5959 } 5960 } 5961 } 5962 } 5963 } 5964 5965 return collection; 5966} 5967 5968function remove( elem, selector, keepData ) { 5969 var node, 5970 nodes = selector ? jQuery.filter( selector, elem ) : elem, 5971 i = 0; 5972 5973 for ( ; ( node = nodes[ i ] ) != null; i++ ) { 5974 if ( !keepData && node.nodeType === 1 ) { 5975 jQuery.cleanData( getAll( node ) ); 5976 } 5977 5978 if ( node.parentNode ) { 5979 if ( keepData && isAttached( node ) ) { 5980 setGlobalEval( getAll( node, "script" ) ); 5981 } 5982 node.parentNode.removeChild( node ); 5983 } 5984 } 5985 5986 return elem; 5987} 5988 5989jQuery.extend( { 5990 htmlPrefilter: function( html ) { 5991 return html; 5992 }, 5993 5994 clone: function( elem, dataAndEvents, deepDataAndEvents ) { 5995 var i, l, srcElements, destElements, 5996 clone = elem.cloneNode( true ), 5997 inPage = isAttached( elem ); 5998 5999 // Fix IE cloning issues 6000 if ( !support.noCloneChecked && ( elem.nodeType === 1 || elem.nodeType === 11 ) && 6001 !jQuery.isXMLDoc( elem ) ) { 6002 6003 // We eschew jQuery#find here for performance reasons: 6004 // https://jsperf.com/getall-vs-sizzle/2 6005 destElements = getAll( clone ); 6006 srcElements = getAll( elem ); 6007 6008 for ( i = 0, l = srcElements.length; i < l; i++ ) { 6009 fixInput( srcElements[ i ], destElements[ i ] ); 6010 } 6011 } 6012 6013 // Copy the events from the original to the clone 6014 if ( dataAndEvents ) { 6015 if ( deepDataAndEvents ) { 6016 srcElements = srcElements || getAll( elem ); 6017 destElements = destElements || getAll( clone ); 6018 6019 for ( i = 0, l = srcElements.length; i < l; i++ ) { 6020 cloneCopyEvent( srcElements[ i ], destElements[ i ] ); 6021 } 6022 } else { 6023 cloneCopyEvent( elem, clone ); 6024 } 6025 } 6026 6027 // Preserve script evaluation history 6028 destElements = getAll( clone, "script" ); 6029 if ( destElements.length > 0 ) { 6030 setGlobalEval( destElements, !inPage && getAll( elem, "script" ) ); 6031 } 6032 6033 // Return the cloned set 6034 return clone; 6035 }, 6036 6037 cleanData: function( elems ) { 6038 var data, elem, type, 6039 special = jQuery.event.special, 6040 i = 0; 6041 6042 for ( ; ( elem = elems[ i ] ) !== undefined; i++ ) { 6043 if ( acceptData( elem ) ) { 6044 if ( ( data = elem[ dataPriv.expando ] ) ) { 6045 if ( data.events ) { 6046 for ( type in data.events ) { 6047 if ( special[ type ] ) { 6048 jQuery.event.remove( elem, type ); 6049 6050 // This is a shortcut to avoid jQuery.event.remove's overhead 6051 } else { 6052 jQuery.removeEvent( elem, type, data.handle ); 6053 } 6054 } 6055 } 6056
vendor: 1,119 bytes, lines 6057-6101
6057 // Support: Chrome <=35 - 45+ 6058 // Assign undefined instead of using delete, see Data#remove 6059 elem[ dataPriv.expando ] = undefined; 6060 } 6061 if ( elem[ dataUser.expando ] ) { 6062 6063 // Support: Chrome <=35 - 45+ 6064 // Assign undefined instead of using delete, see Data#remove 6065 elem[ dataUser.expando ] = undefined; 6066 } 6067 } 6068 } 6069 } 6070} ); 6071 6072jQuery.fn.extend( { 6073 detach: function( selector ) { 6074 return remove( this, selector, true ); 6075 }, 6076 6077 remove: function( selector ) { 6078 return remove( this, selector ); 6079 }, 6080 6081 text: function( value ) { 6082 return access( this, function( value ) { 6083 return value === undefined ? 6084 jQuery.text( this ) : 6085 this.empty().each( function() { 6086 if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) { 6087 this.textContent = value; 6088 } 6089 } ); 6090 }, null, value, arguments.length ); 6091 }, 6092 6093 append: function() { 6094 return domManip( this, arguments, function( elem ) { 6095 if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) { 6096 var target = manipulationTarget( this, elem ); 6097 target.appendChild( elem ); 6098 } 6099 } ); 6100 }, 6101
vendor: 4,514 bytes, lines 6102-6293
6102 prepend: function() { 6103 return domManip( this, arguments, function( elem ) { 6104 if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) { 6105 var target = manipulationTarget( this, elem ); 6106 target.insertBefore( elem, target.firstChild ); 6107 } 6108 } ); 6109 }, 6110 6111 before: function() { 6112 return domManip( this, arguments, function( elem ) { 6113 if ( this.parentNode ) { 6114 this.parentNode.insertBefore( elem, this ); 6115 } 6116 } ); 6117 }, 6118 6119 after: function() { 6120 return domManip( this, arguments, function( elem ) { 6121 if ( this.parentNode ) { 6122 this.parentNode.insertBefore( elem, this.nextSibling ); 6123 } 6124 } ); 6125 }, 6126 6127 empty: function() { 6128 var elem, 6129 i = 0; 6130 6131 for ( ; ( elem = this[ i ] ) != null; i++ ) { 6132 if ( elem.nodeType === 1 ) { 6133 6134 // Prevent memory leaks 6135 jQuery.cleanData( getAll( elem, false ) ); 6136 6137 // Remove any remaining nodes 6138 elem.textContent = ""; 6139 } 6140 } 6141 6142 return this; 6143 }, 6144 6145 clone: function( dataAndEvents, deepDataAndEvents ) { 6146 dataAndEvents = dataAndEvents == null ? false : dataAndEvents; 6147 deepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents; 6148 6149 return this.map( function() { 6150 return jQuery.clone( this, dataAndEvents, deepDataAndEvents ); 6151 } ); 6152 }, 6153 6154 html: function( value ) { 6155 return access( this, function( value ) { 6156 var elem = this[ 0 ] || {}, 6157 i = 0, 6158 l = this.length; 6159 6160 if ( value === undefined && elem.nodeType === 1 ) { 6161 return elem.innerHTML; 6162 } 6163 6164 // See if we can take a shortcut and just use innerHTML 6165 if ( typeof value === "string" && !rnoInnerhtml.test( value ) && 6166 !wrapMap[ ( rtagName.exec( value ) || [ "", "" ] )[ 1 ].toLowerCase() ] ) { 6167 6168 value = jQuery.htmlPrefilter( value ); 6169 6170 try { 6171 for ( ; i < l; i++ ) { 6172 elem = this[ i ] || {}; 6173 6174 // Remove element nodes and prevent memory leaks 6175 if ( elem.nodeType === 1 ) { 6176 jQuery.cleanData( getAll( elem, false ) ); 6177 elem.innerHTML = value; 6178 } 6179 } 6180 6181 elem = 0; 6182 6183 // If using innerHTML throws an exception, use the fallback method 6184 } catch ( e ) {} 6185 } 6186 6187 if ( elem ) { 6188 this.empty().append( value ); 6189 } 6190 }, null, value, arguments.length ); 6191 }, 6192 6193 replaceWith: function() { 6194 var ignored = []; 6195 6196 // Make the changes, replacing each non-ignored context element with the new content 6197 return domManip( this, arguments, function( elem ) { 6198 var parent = this.parentNode; 6199 6200 if ( jQuery.inArray( this, ignored ) < 0 ) { 6201 jQuery.cleanData( getAll( this ) ); 6202 if ( parent ) { 6203 parent.replaceChild( elem, this ); 6204 } 6205 } 6206 6207 // Force callback invocation 6208 }, ignored ); 6209 } 6210} ); 6211 6212jQuery.each( { 6213 appendTo: "append", 6214 prependTo: "prepend", 6215 insertBefore: "before", 6216 insertAfter: "after", 6217 replaceAll: "replaceWith" 6218}, function( name, original ) { 6219 jQuery.fn[ name ] = function( selector ) { 6220 var elems, 6221 ret = [], 6222 insert = jQuery( selector ), 6223 last = insert.length - 1, 6224 i = 0; 6225 6226 for ( ; i <= last; i++ ) { 6227 elems = i === last ? this : this.clone( true ); 6228 jQuery( insert[ i ] )[ original ]( elems ); 6229 6230 // Support: Android <=4.0 only, PhantomJS 1 only 6231 // .get() because push.apply(_, arraylike) throws on ancient WebKit 6232 push.apply( ret, elems.get() ); 6233 } 6234 6235 return this.pushStack( ret ); 6236 }; 6237} ); 6238var rnumnonpx = new RegExp( "^(" + pnum + ")(?!px)[a-z%]+$", "i" ); 6239 6240var rcustomProp = /^--/; 6241 6242 6243var getStyles = function( elem ) { 6244 6245 // Support: IE <=11 only, Firefox <=30 (trac-15098, trac-14150) 6246 // IE throws on elements created in popups 6247 // FF meanwhile throws on frame elements through "defaultView.getComputedStyle" 6248 var view = elem.ownerDocument.defaultView; 6249 6250 if ( !view || !view.opener ) { 6251 view = window; 6252 } 6253 6254 return view.getComputedStyle( elem ); 6255 }; 6256 6257var swap = function( elem, options, callback ) { 6258 var ret, name, 6259 old = {}; 6260 6261 // Remember the old values, and insert the new ones 6262 for ( name in options ) { 6263 old[ name ] = elem.style[ name ]; 6264 elem.style[ name ] = options[ name ]; 6265 } 6266 6267 ret = callback.call( elem ); 6268 6269 // Revert the old values 6270 for ( name in options ) { 6271 elem.style[ name ] = old[ name ]; 6272 } 6273 6274 return ret; 6275}; 6276 6277 6278var rboxStyle = new RegExp( cssExpand.join( "|" ), "i" ); 6279 6280 6281 6282( function() { 6283 6284 // Executing both pixelPosition & boxSizingReliable tests require only one layout 6285 // so they're executed at the same time to save the second computation. 6286 function computeStyleTests() { 6287 6288 // This is a singleton, we need to execute it only once 6289 if ( !div ) { 6290 return; 6291 } 6292 6293 container.style.cssText = "position:absolute;
vendor: 4,156 bytes, lines 6293-6412
6293left:-11111px;width:60px;" + 6294 "margin-top:1px;padding:0;border:0"; 6295 div.style.cssText = 6296 "position:relative;display:block;box-sizing:border-box;overflow:scroll;" + 6297 "margin:auto;border:1px;padding:1px;" + 6298 "width:60%;top:1%"; 6299 documentElement.appendChild( container ).appendChild( div ); 6300 6301 var divStyle = window.getComputedStyle( div ); 6302 pixelPositionVal = divStyle.top !== "1%"; 6303 6304 // Support: Android 4.0 - 4.3 only, Firefox <=3 - 44 6305 reliableMarginLeftVal = roundPixelMeasures( divStyle.marginLeft ) === 12; 6306 6307 // Support: Android 4.0 - 4.3 only, Safari <=9.1 - 10.1, iOS <=7.0 - 9.3 6308 // Some styles come back with percentage values, even though they shouldn't 6309 div.style.right = "60%"; 6310 pixelBoxStylesVal = roundPixelMeasures( divStyle.right ) === 36; 6311 6312 // Support: IE 9 - 11 only 6313 // Detect misreporting of content dimensions for box-sizing:border-box elements 6314 boxSizingReliableVal = roundPixelMeasures( divStyle.width ) === 36; 6315 6316 // Support: IE 9 only 6317 // Detect overflow:scroll screwiness (gh-3699) 6318 // Support: Chrome <=64 6319 // Don't get tricked when zoom affects offsetWidth (gh-4029) 6320 div.style.position = "absolute"; 6321 scrollboxSizeVal = roundPixelMeasures( div.offsetWidth / 3 ) === 12; 6322 6323 documentElement.removeChild( container ); 6324 6325 // Nullify the div so it wouldn't be stored in the memory and 6326 // it will also be a sign that checks already performed 6327 div = null; 6328 } 6329 6330 function roundPixelMeasures( measure ) { 6331 return Math.round( parseFloat( measure ) ); 6332 } 6333 6334 var pixelPositionVal, boxSizingReliableVal, scrollboxSizeVal, pixelBoxStylesVal, 6335 reliableTrDimensionsVal, reliableMarginLeftVal, 6336 container = document.createElement( "div" ), 6337 div = document.createElement( "div" ); 6338 6339 // Finish early in limited (non-browser) environments 6340 if ( !div.style ) { 6341 return; 6342 } 6343 6344 // Support: IE <=9 - 11 only 6345 // Style of cloned element affects source element cloned (trac-8908) 6346 div.style.backgroundClip = "content-box"; 6347 div.cloneNode( true ).style.backgroundClip = ""; 6348 support.clearCloneStyle = div.style.backgroundClip === "content-box"; 6349 6350 jQuery.extend( support, { 6351 boxSizingReliable: function() { 6352 computeStyleTests(); 6353 return boxSizingReliableVal; 6354 }, 6355 pixelBoxStyles: function() { 6356 computeStyleTests(); 6357 return pixelBoxStylesVal; 6358 }, 6359 pixelPosition: function() { 6360 computeStyleTests(); 6361 return pixelPositionVal; 6362 }, 6363 reliableMarginLeft: function() { 6364 computeStyleTests(); 6365 return reliableMarginLeftVal; 6366 }, 6367 scrollboxSize: function() { 6368 computeStyleTests(); 6369 return scrollboxSizeVal; 6370 }, 6371 6372 // Support: IE 9 - 11+, Edge 15 - 18+ 6373 // IE/Edge misreport `getComputedStyle` of table rows with width/height 6374 // set in CSS while `offset*` properties report correct values. 6375 // Behavior in IE 9 is more subtle than in newer versions & it passes 6376 // some versions of this test; make sure not to make it pass there! 6377 // 6378 // Support: Firefox 70+ 6379 // Only Firefox includes border widths 6380 // in computed dimensions. (gh-4529) 6381 reliableTrDimensions: function() { 6382 var table, tr, trChild, trStyle; 6383 if ( reliableTrDimensionsVal == null ) { 6384 table = document.createElement( "table" ); 6385 tr = document.createElement( "tr" ); 6386 trChild = document.createElement( "div" ); 6387 6388 table.style.cssText = "position:absolute;left:-11111px;border-collapse:separate"; 6389 tr.style.cssText = "box-sizing:content-box;border:1px solid"; 6390 6391 // Support: Chrome 86+ 6392 // Height set through cssText does not get applied. 6393 // Computed height then comes back as 0. 6394 tr.style.height = "1px"; 6395 trChild.style.height = "9px"; 6396 6397 // Support: Android 8 Chrome 86+ 6398 // In our bodyBackground.html iframe, 6399 // display for all div elements is set to "inline", 6400 // which causes a problem only in Android 8 Chrome 86. 6401 // Ensuring the div is `display: block` 6402 // gets around this issue. 6403 trChild.style.display = "block"; 6404 6405 documentElement 6406 .appendChild( table ) 6407 .appendChild( tr ) 6408 .appendChild( trChild ); 6409 6410 trStyle = window.getComputedStyle( tr ); 6411 reliableTrDimensionsVal = ( parseInt( trStyle.height, 10 ) + 6412 parseInt( trStyle.borderTopWidth, 10 ) +
vendor: 12,879 bytes, lines 6413-6839
6413 parseInt( trStyle.borderBottomWidth, 10 ) ) === tr.offsetHeight; 6414 6415 documentElement.removeChild( table ); 6416 } 6417 return reliableTrDimensionsVal; 6418 } 6419 } ); 6420} )(); 6421 6422 6423function curCSS( elem, name, computed ) { 6424 var width, minWidth, maxWidth, ret, 6425 isCustomProp = rcustomProp.test( name ), 6426 6427 // Support: Firefox 51+ 6428 // Retrieving style before computed somehow 6429 // fixes an issue with getting wrong values 6430 // on detached elements 6431 style = elem.style; 6432 6433 computed = computed || getStyles( elem ); 6434 6435 // getPropertyValue is needed for: 6436 // .css('filter') (IE 9 only, trac-12537) 6437 // .css('--customProperty) (gh-3144) 6438 if ( computed ) { 6439 6440 // Support: IE <=9 - 11+ 6441 // IE only supports `"float"` in `getPropertyValue`; in computed styles 6442 // it's only available as `"cssFloat"`. We no longer modify properties 6443 // sent to `.css()` apart from camelCasing, so we need to check both. 6444 // Normally, this would create difference in behavior: if 6445 // `getPropertyValue` returns an empty string, the value returned 6446 // by `.css()` would be `undefined`. This is usually the case for 6447 // disconnected elements. However, in IE even disconnected elements 6448 // with no styles return `"none"` for `getPropertyValue( "float" )` 6449 ret = computed.getPropertyValue( name ) || computed[ name ]; 6450 6451 if ( isCustomProp && ret ) { 6452 6453 // Support: Firefox 105+, Chrome <=105+ 6454 // Spec requires trimming whitespace for custom properties (gh-4926). 6455 // Firefox only trims leading whitespace. Chrome just collapses 6456 // both leading & trailing whitespace to a single space. 6457 // 6458 // Fall back to `undefined` if empty string returned. 6459 // This collapses a missing definition with property defined 6460 // and set to an empty string but there's no standard API 6461 // allowing us to differentiate them without a performance penalty 6462 // and returning `undefined` aligns with older jQuery. 6463 // 6464 // rtrimCSS treats U+000D CARRIAGE RETURN and U+000C FORM FEED 6465 // as whitespace while CSS does not, but this is not a problem 6466 // because CSS preprocessing replaces them with U+000A LINE FEED 6467 // (which *is* CSS whitespace) 6468 // https://www.w3.org/TR/css-syntax-3/#input-preprocessing 6469 ret = ret.replace( rtrimCSS, "$1" ) || undefined; 6470 } 6471 6472 if ( ret === "" && !isAttached( elem ) ) { 6473 ret = jQuery.style( elem, name ); 6474 } 6475 6476 // A tribute to the "awesome hack by Dean Edwards" 6477 // Android Browser returns percentage for some values, 6478 // but width seems to be reliably pixels. 6479 // This is against the CSSOM draft spec: 6480 // https://drafts.csswg.org/cssom/#resolved-values 6481 if ( !support.pixelBoxStyles() && rnumnonpx.test( ret ) && rboxStyle.test( name ) ) { 6482 6483 // Remember the original values 6484 width = style.width; 6485 minWidth = style.minWidth; 6486 maxWidth = style.maxWidth; 6487 6488 // Put in the new values to get a computed value out 6489 style.minWidth = style.maxWidth = style.width = ret; 6490 ret = computed.width; 6491 6492 // Revert the changed values 6493 style.width = width; 6494 style.minWidth = minWidth; 6495 style.maxWidth = maxWidth; 6496 } 6497 } 6498 6499 return ret !== undefined ? 6500 6501 // Support: IE <=9 - 11 only 6502 // IE returns zIndex value as an integer. 6503 ret + "" : 6504 ret; 6505} 6506 6507 6508function addGetHookIf( conditionFn, hookFn ) { 6509 6510 // Define the hook, we'll check on the first run if it's really needed. 6511 return { 6512 get: function() { 6513 if ( conditionFn() ) { 6514 6515 // Hook not needed (or it's not possible to use it due 6516 // to missing dependency), remove it. 6517 delete this.get; 6518 return; 6519 } 6520 6521 // Hook needed; redefine it so that the support test is not executed again. 6522 return ( this.get = hookFn ).apply( this, arguments ); 6523 } 6524 }; 6525} 6526 6527 6528var cssPrefixes = [ "Webkit", "Moz", "ms" ], 6529 emptyStyle = document.createElement( "div" ).style, 6530 vendorProps = {}; 6531 6532// Return a vendor-prefixed property or undefined 6533function vendorPropName( name ) { 6534 6535 // Check for vendor prefixed names 6536 var capName = name[ 0 ].toUpperCase() + name.slice( 1 ), 6537 i = cssPrefixes.length; 6538 6539 while ( i-- ) { 6540 name = cssPrefixes[ i ] + capName; 6541 if ( name in emptyStyle ) { 6542 return name; 6543 } 6544 } 6545} 6546 6547// Return a potentially-mapped jQuery.cssProps or vendor prefixed property 6548function finalPropName( name ) { 6549 var final = jQuery.cssProps[ name ] || vendorProps[ name ]; 6550 6551 if ( final ) { 6552 return final; 6553 } 6554 if ( name in emptyStyle ) { 6555 return name; 6556 } 6557 return vendorProps[ name ] = vendorPropName( name ) || name; 6558} 6559 6560 6561var 6562 6563 // Swappable if display is none or starts with table 6564 // except "table", "table-cell", or "table-caption" 6565 // See here for display values: https://developer.mozilla.org/en-US/docs/CSS/display 6566 rdisplayswap = /^(none|table(?!-c[ea]).+)/, 6567 cssShow = { position: "absolute", visibility: "hidden", display: "block" }, 6568 cssNormalTransform = { 6569 letterSpacing: "0", 6570 fontWeight: "400" 6571 }; 6572 6573function setPositiveNumber( _elem, value, subtract ) { 6574 6575 // Any relative (+/-) values have already been 6576 // normalized at this point 6577 var matches = rcssNum.exec( value ); 6578 return matches ? 6579 6580 // Guard against undefined "subtract", e.g., when used as in cssHooks 6581 Math.max( 0, matches[ 2 ] - ( subtract || 0 ) ) + ( matches[ 3 ] || "px" ) : 6582 value; 6583} 6584 6585function boxModelAdjustment( elem, dimension, box, isBorderBox, styles, computedVal ) { 6586 var i = dimension === "width" ? 1 : 0, 6587 extra = 0, 6588 delta = 0, 6589 marginDelta = 0; 6590 6591 // Adjustment may not be necessary 6592 if ( box === ( isBorderBox ? "border" : "content" ) ) { 6593 return 0; 6594 } 6595 6596 for ( ; i < 4; i += 2 ) { 6597 6598 // Both box models exclude margin 6599 // Count margin delta separately to only add it after scroll gutter adjustment. 6600 // This is needed to make negative margins work with `outerHeight( true )` (gh-3982). 6601 if ( box === "margin" ) { 6602 marginDelta += jQuery.css( elem, box + cssExpand[ i ], true, styles ); 6603 } 6604 6605 // If we get here with a content-box, we're seeking "padding" or "border" or "margin" 6606 if ( !isBorderBox ) { 6607 6608 // Add padding 6609 delta += jQuery.css( elem, "padding" + cssExpand[ i ], true, styles ); 6610 6611 // For "border" or "margin", add border 6612 if ( box !== "padding" ) { 6613 delta += jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles ); 6614 6615 // But still keep track of it otherwise 6616 } else { 6617 extra += jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles ); 6618 } 6619 6620 // If we get here with a border-box (content + padding + border), we're seeking "content" or 6621 // "padding" or "margin" 6622 } else { 6623 6624 // For "content", subtract padding 6625 if ( box === "content" ) { 6626 delta -= jQuery.css( elem, "padding" + cssExpand[ i ], true, styles ); 6627 } 6628 6629 // For "content" or "padding", subtract border 6630 if ( box !== "margin" ) { 6631 delta -= jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles ); 6632 } 6633 } 6634 } 6635 6636 // Account for positive content-box scroll gutter when requested by providing computedVal 6637 if ( !isBorderBox && computedVal >= 0 ) { 6638 6639 // offsetWidth/offsetHeight is a rounded sum of content, padding, scroll gutter, and border 6640 // Assuming integer scroll gutter, subtract the rest and round down 6641 delta += Math.max( 0, Math.ceil( 6642 elem[ "offset" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 ) ] - 6643 computedVal - 6644 delta - 6645 extra - 6646 0.5 6647 6648 // If offsetWidth/offsetHeight is unknown, then we can't determine content-box scroll gutter 6649 // Use an explicit zero to avoid NaN (gh-3964) 6650 ) ) || 0; 6651 } 6652 6653 return delta + marginDelta; 6654} 6655 6656function getWidthOrHeight( elem, dimension, extra ) { 6657 6658 // Start with computed style 6659 var styles = getStyles( elem ), 6660 6661 // To avoid forcing a reflow, only fetch boxSizing if we need it (gh-4322). 6662 // Fake content-box until we know it's needed to know the true value. 6663 boxSizingNeeded = !support.boxSizingReliable() || extra, 6664 isBorderBox = boxSizingNeeded && 6665 jQuery.css( elem, "boxSizing", false, styles ) === "border-box", 6666 valueIsBorderBox = isBorderBox, 6667 6668 val = curCSS( elem, dimension, styles ), 6669 offsetProp = "offset" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 ); 6670 6671 // Support: Firefox <=54 6672 // Return a confounding non-pixel value or feign ignorance, as appropriate. 6673 if ( rnumnonpx.test( val ) ) { 6674 if ( !extra ) { 6675 return val; 6676 } 6677 val = "auto"; 6678 } 6679 6680 6681 // Support: IE 9 - 11 only 6682 // Use offsetWidth/offsetHeight for when box sizing is unreliable. 6683 // In those cases, the computed value can be trusted to be border-box. 6684 if ( ( !support.boxSizingReliable() && isBorderBox || 6685 6686 // Support: IE 10 - 11+, Edge 15 - 18+ 6687 // IE/Edge misreport `getComputedStyle` of table rows with width/height 6688 // set in CSS while `offset*` properties report correct values. 6689 // Interestingly, in some cases IE 9 doesn't suffer from this issue. 6690 !support.reliableTrDimensions() && nodeName( elem, "tr" ) || 6691 6692 // Fall back to offsetWidth/offsetHeight when value is "auto" 6693 // This happens for inline elements with no explicit setting (gh-3571) 6694 val === "auto" || 6695 6696 // Support: Android <=4.1 - 4.3 only 6697 // Also use offsetWidth/offsetHeight for misreported inline dimensions (gh-3602) 6698 !parseFloat( val ) && jQuery.css( elem, "display", false, styles ) === "inline" ) && 6699 6700 // Make sure the element is visible & connected 6701 elem.getClientRects().length ) { 6702 6703 isBorderBox = jQuery.css( elem, "boxSizing", false, styles ) === "border-box"; 6704 6705 // Where available, offsetWidth/offsetHeight approximate border box dimensions. 6706 // Where not available (e.g., SVG), assume unreliable box-sizing and interpret the 6707 // retrieved value as a content box dimension. 6708 valueIsBorderBox = offsetProp in elem; 6709 if ( valueIsBorderBox ) { 6710 val = elem[ offsetProp ]; 6711 } 6712 } 6713 6714 // Normalize "" and auto 6715 val = parseFloat( val ) || 0; 6716 6717 // Adjust for the element's box model 6718 return ( val + 6719 boxModelAdjustment( 6720 elem, 6721 dimension, 6722 extra || ( isBorderBox ? "border" : "content" ), 6723 valueIsBorderBox, 6724 styles, 6725 6726 // Provide the current computed size to request scroll gutter calculation (gh-3589) 6727 val 6728 ) 6729 ) + "px"; 6730} 6731 6732jQuery.extend( { 6733 6734 // Add in style property hooks for overriding the default 6735 // behavior of getting and setting a style property 6736 cssHooks: { 6737 opacity: { 6738 get: function( elem, computed ) { 6739 if ( computed ) { 6740 6741 // We should always get a number back from opacity 6742 var ret = curCSS( elem, "opacity" ); 6743 return ret === "" ? "1" : ret; 6744 } 6745 } 6746 } 6747 }, 6748 6749 // Don't automatically add "px" to these possibly-unitless properties 6750 cssNumber: { 6751 animationIterationCount: true, 6752 aspectRatio: true, 6753 borderImageSlice: true, 6754 columnCount: true, 6755 flexGrow: true, 6756 flexShrink: true, 6757 fontWeight: true, 6758 gridArea: true, 6759 gridColumn: true, 6760 gridColumnEnd: true, 6761 gridColumnStart: true, 6762 gridRow: true, 6763 gridRowEnd: true, 6764 gridRowStart: true, 6765 lineHeight: true, 6766 opacity: true, 6767 order: true, 6768 orphans: true, 6769 scale: true, 6770 widows: true, 6771 zIndex: true, 6772 zoom: true, 6773 6774 // SVG-related 6775 fillOpacity: true, 6776 floodOpacity: true, 6777 stopOpacity: true, 6778 strokeMiterlimit: true, 6779 strokeOpacity: true 6780 }, 6781 6782 // Add in properties whose names you wish to fix before 6783 // setting or getting the value 6784 cssProps: {}, 6785 6786 // Get and set the style property on a DOM Node 6787 style: function( elem, name, value, extra ) { 6788 6789 // Don't set styles on text and comment nodes 6790 if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style ) { 6791 return; 6792 } 6793 6794 // Make sure that we're working with the right name 6795 var ret, type, hooks, 6796 origName = camelCase( name ), 6797 isCustomProp = rcustomProp.test( name ), 6798 style = elem.style; 6799 6800 // Make sure that we're working with the right name. We don't 6801 // want to query the value if it is a CSS custom property 6802 // since they are user-defined. 6803 if ( !isCustomProp ) { 6804 name = finalPropName( origName ); 6805 } 6806 6807 // Gets hook for the prefixed version, then unprefixed version 6808 hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ]; 6809 6810 // Check if we're setting a value 6811 if ( value !== undefined ) { 6812 type = typeof value; 6813 6814 // Convert "+=" or "-=" to relative numbers (trac-7345) 6815 if ( type === "string" && ( ret = rcssNum.exec( value ) ) && ret[ 1 ] ) { 6816 value = adjustCSS( elem, name, ret ); 6817 6818 // Fixes bug trac-9237 6819 type = "number"; 6820 } 6821 6822 // Make sure that null and NaN values aren't set (trac-7116) 6823 if ( value == null || value !== value ) { 6824 return; 6825 } 6826 6827 // If a number was passed in, add the unit (except for certain CSS properties) 6828 // The isCustomProp check can be removed in jQuery 4.0 when we only auto-append 6829 // "px" to a few hardcoded values. 6830 if ( type === "number" && !isCustomProp ) { 6831 value += ret && ret[ 3 ] || ( jQuery.cssNumber[ origName ] ? "" : "px" ); 6832 } 6833 6834 // background-* props affect original clone's values 6835 if ( !support.clearCloneStyle && value === "" && name.indexOf( "background" ) === 0 ) { 6836 style[ name ] = "inherit"; 6837 } 6838 6839 // If a hook was provided, use that value, otherwise just set the specified value
vendor: 16,052 bytes, lines 6840-7444
6840 if ( !hooks || !( "set" in hooks ) || 6841 ( value = hooks.set( elem, value, extra ) ) !== undefined ) { 6842 6843 if ( isCustomProp ) { 6844 style.setProperty( name, value ); 6845 } else { 6846 style[ name ] = value; 6847 } 6848 } 6849 6850 } else { 6851 6852 // If a hook was provided get the non-computed value from there 6853 if ( hooks && "get" in hooks && 6854 ( ret = hooks.get( elem, false, extra ) ) !== undefined ) { 6855 6856 return ret; 6857 } 6858 6859 // Otherwise just get the value from the style object 6860 return style[ name ]; 6861 } 6862 }, 6863 6864 css: function( elem, name, extra, styles ) { 6865 var val, num, hooks, 6866 origName = camelCase( name ), 6867 isCustomProp = rcustomProp.test( name ); 6868 6869 // Make sure that we're working with the right name. We don't 6870 // want to modify the value if it is a CSS custom property 6871 // since they are user-defined. 6872 if ( !isCustomProp ) { 6873 name = finalPropName( origName ); 6874 } 6875 6876 // Try prefixed name followed by the unprefixed name 6877 hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ]; 6878 6879 // If a hook was provided get the computed value from there 6880 if ( hooks && "get" in hooks ) { 6881 val = hooks.get( elem, true, extra ); 6882 } 6883 6884 // Otherwise, if a way to get the computed value exists, use that 6885 if ( val === undefined ) { 6886 val = curCSS( elem, name, styles ); 6887 } 6888 6889 // Convert "normal" to computed value 6890 if ( val === "normal" && name in cssNormalTransform ) { 6891 val = cssNormalTransform[ name ]; 6892 } 6893 6894 // Make numeric if forced or a qualifier was provided and val looks numeric 6895 if ( extra === "" || extra ) { 6896 num = parseFloat( val ); 6897 return extra === true || isFinite( num ) ? num || 0 : val; 6898 } 6899 6900 return val; 6901 } 6902} ); 6903 6904jQuery.each( [ "height", "width" ], function( _i, dimension ) { 6905 jQuery.cssHooks[ dimension ] = { 6906 get: function( elem, computed, extra ) { 6907 if ( computed ) { 6908 6909 // Certain elements can have dimension info if we invisibly show them 6910 // but it must have a current display style that would benefit 6911 return rdisplayswap.test( jQuery.css( elem, "display" ) ) && 6912 6913 // Support: Safari 8+ 6914 // Table columns in Safari have non-zero offsetWidth & zero 6915 // getBoundingClientRect().width unless display is changed. 6916 // Support: IE <=11 only 6917 // Running getBoundingClientRect on a disconnected node 6918 // in IE throws an error. 6919 ( !elem.getClientRects().length || !elem.getBoundingClientRect().width ) ? 6920 swap( elem, cssShow, function() { 6921 return getWidthOrHeight( elem, dimension, extra ); 6922 } ) : 6923 getWidthOrHeight( elem, dimension, extra ); 6924 } 6925 }, 6926 6927 set: function( elem, value, extra ) { 6928 var matches, 6929 styles = getStyles( elem ), 6930 6931 // Only read styles.position if the test has a chance to fail 6932 // to avoid forcing a reflow. 6933 scrollboxSizeBuggy = !support.scrollboxSize() && 6934 styles.position === "absolute", 6935 6936 // To avoid forcing a reflow, only fetch boxSizing if we need it (gh-3991) 6937 boxSizingNeeded = scrollboxSizeBuggy || extra, 6938 isBorderBox = boxSizingNeeded && 6939 jQuery.css( elem, "boxSizing", false, styles ) === "border-box", 6940 subtract = extra ? 6941 boxModelAdjustment( 6942 elem, 6943 dimension, 6944 extra, 6945 isBorderBox, 6946 styles 6947 ) : 6948 0; 6949 6950 // Account for unreliable border-box dimensions by comparing offset* to computed and 6951 // faking a content-box to get border and padding (gh-3699) 6952 if ( isBorderBox && scrollboxSizeBuggy ) { 6953 subtract -= Math.ceil( 6954 elem[ "offset" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 ) ] - 6955 parseFloat( styles[ dimension ] ) - 6956 boxModelAdjustment( elem, dimension, "border", false, styles ) - 6957 0.5 6958 ); 6959 } 6960 6961 // Convert to pixels if value adjustment is needed 6962 if ( subtract && ( matches = rcssNum.exec( value ) ) && 6963 ( matches[ 3 ] || "px" ) !== "px" ) { 6964 6965 elem.style[ dimension ] = value; 6966 value = jQuery.css( elem, dimension ); 6967 } 6968 6969 return setPositiveNumber( elem, value, subtract ); 6970 } 6971 }; 6972} ); 6973 6974jQuery.cssHooks.marginLeft = addGetHookIf( support.reliableMarginLeft, 6975 function( elem, computed ) { 6976 if ( computed ) { 6977 return ( parseFloat( curCSS( elem, "marginLeft" ) ) || 6978 elem.getBoundingClientRect().left - 6979 swap( elem, { marginLeft: 0 }, function() { 6980 return elem.getBoundingClientRect().left; 6981 } ) 6982 ) + "px"; 6983 } 6984 } 6985); 6986 6987// These hooks are used by animate to expand properties 6988jQuery.each( { 6989 margin: "", 6990 padding: "", 6991 border: "Width" 6992}, function( prefix, suffix ) { 6993 jQuery.cssHooks[ prefix + suffix ] = { 6994 expand: function( value ) { 6995 var i = 0, 6996 expanded = {}, 6997 6998 // Assumes a single number if not a string 6999 parts = typeof value === "string" ? value.split( " " ) : [ value ]; 7000 7001 for ( ; i < 4; i++ ) { 7002 expanded[ prefix + cssExpand[ i ] + suffix ] = 7003 parts[ i ] || parts[ i - 2 ] || parts[ 0 ]; 7004 } 7005 7006 return expanded; 7007 } 7008 }; 7009 7010 if ( prefix !== "margin" ) { 7011 jQuery.cssHooks[ prefix + suffix ].set = setPositiveNumber; 7012 } 7013} ); 7014 7015jQuery.fn.extend( { 7016 css: function( name, value ) { 7017 return access( this, function( elem, name, value ) { 7018 var styles, len, 7019 map = {}, 7020 i = 0; 7021 7022 if ( Array.isArray( name ) ) { 7023 styles = getStyles( elem ); 7024 len = name.length; 7025 7026 for ( ; i < len; i++ ) { 7027 map[ name[ i ] ] = jQuery.css( elem, name[ i ], false, styles ); 7028 } 7029 7030 return map; 7031 } 7032 7033 return value !== undefined ? 7034 jQuery.style( elem, name, value ) : 7035 jQuery.css( elem, name ); 7036 }, name, value, arguments.length > 1 ); 7037 } 7038} ); 7039 7040 7041function Tween( elem, options, prop, end, easing ) { 7042 return new Tween.prototype.init( elem, options, prop, end, easing ); 7043} 7044jQuery.Tween = Tween; 7045 7046Tween.prototype = { 7047 constructor: Tween, 7048 init: function( elem, options, prop, end, easing, unit ) { 7049 this.elem = elem; 7050 this.prop = prop; 7051 this.easing = easing || jQuery.easing._default; 7052 this.options = options; 7053 this.start = this.now = this.cur(); 7054 this.end = end; 7055 this.unit = unit || ( jQuery.cssNumber[ prop ] ? "" : "px" ); 7056 }, 7057 cur: function() { 7058 var hooks = Tween.propHooks[ this.prop ]; 7059 7060 return hooks && hooks.get ? 7061 hooks.get( this ) : 7062 Tween.propHooks._default.get( this ); 7063 }, 7064 run: function( percent ) { 7065 var eased, 7066 hooks = Tween.propHooks[ this.prop ]; 7067 7068 if ( this.options.duration ) { 7069 this.pos = eased = jQuery.easing[ this.easing ]( 7070 percent, this.options.duration * percent, 0, 1, this.options.duration 7071 ); 7072 } else { 7073 this.pos = eased = percent; 7074 } 7075 this.now = ( this.end - this.start ) * eased + this.start; 7076 7077 if ( this.options.step ) { 7078 this.options.step.call( this.elem, this.now, this ); 7079 } 7080 7081 if ( hooks && hooks.set ) { 7082 hooks.set( this ); 7083 } else { 7084 Tween.propHooks._default.set( this ); 7085 } 7086 return this; 7087 } 7088}; 7089 7090Tween.prototype.init.prototype = Tween.prototype; 7091 7092Tween.propHooks = { 7093 _default: { 7094 get: function( tween ) { 7095 var result; 7096 7097 // Use a property on the element directly when it is not a DOM element, 7098 // or when there is no matching style property that exists. 7099 if ( tween.elem.nodeType !== 1 || 7100 tween.elem[ tween.prop ] != null && tween.elem.style[ tween.prop ] == null ) { 7101 return tween.elem[ tween.prop ]; 7102 } 7103 7104 // Passing an empty string as a 3rd parameter to .css will automatically 7105 // attempt a parseFloat and fallback to a string if the parse fails. 7106 // Simple values such as "10px" are parsed to Float; 7107 // complex values such as "rotate(1rad)" are returned as-is. 7108 result = jQuery.css( tween.elem, tween.prop, "" ); 7109 7110 // Empty strings, null, undefined and "auto" are converted to 0. 7111 return !result || result === "auto" ? 0 : result; 7112 }, 7113 set: function( tween ) { 7114 7115 // Use step hook for back compat. 7116 // Use cssHook if its there. 7117 // Use .style if available and use plain properties where available. 7118 if ( jQuery.fx.step[ tween.prop ] ) { 7119 jQuery.fx.step[ tween.prop ]( tween ); 7120 } else if ( tween.elem.nodeType === 1 && ( 7121 jQuery.cssHooks[ tween.prop ] || 7122 tween.elem.style[ finalPropName( tween.prop ) ] != null ) ) { 7123 jQuery.style( tween.elem, tween.prop, tween.now + tween.unit ); 7124 } else { 7125 tween.elem[ tween.prop ] = tween.now; 7126 } 7127 } 7128 } 7129}; 7130 7131// Support: IE <=9 only 7132// Panic based approach to setting things on disconnected nodes 7133Tween.propHooks.scrollTop = Tween.propHooks.scrollLeft = { 7134 set: function( tween ) { 7135 if ( tween.elem.nodeType && tween.elem.parentNode ) { 7136 tween.elem[ tween.prop ] = tween.now; 7137 } 7138 } 7139}; 7140 7141jQuery.easing = { 7142 linear: function( p ) { 7143 return p; 7144 }, 7145 swing: function( p ) { 7146 return 0.5 - Math.cos( p * Math.PI ) / 2; 7147 }, 7148 _default: "swing" 7149}; 7150 7151jQuery.fx = Tween.prototype.init; 7152 7153// Back compat <1.8 extension point 7154jQuery.fx.step = {}; 7155 7156 7157 7158 7159var 7160 fxNow, inProgress, 7161 rfxtypes = /^(?:toggle|show|hide)$/, 7162 rrun = /queueHooks$/; 7163 7164function schedule() { 7165 if ( inProgress ) { 7166 if ( document.hidden === false && window.requestAnimationFrame ) { 7167 window.requestAnimationFrame( schedule ); 7168 } else { 7169 window.setTimeout( schedule, jQuery.fx.interval ); 7170 } 7171 7172 jQuery.fx.tick(); 7173 } 7174} 7175 7176// Animations created synchronously will run synchronously 7177function createFxNow() { 7178 window.setTimeout( function() { 7179 fxNow = undefined; 7180 } ); 7181 return ( fxNow = Date.now() ); 7182} 7183 7184// Generate parameters to create a standard animation 7185function genFx( type, includeWidth ) { 7186 var which, 7187 i = 0, 7188 attrs = { height: type }; 7189 7190 // If we include width, step value is 1 to do all cssExpand values, 7191 // otherwise step value is 2 to skip over Left and Right 7192 includeWidth = includeWidth ? 1 : 0; 7193 for ( ; i < 4; i += 2 - includeWidth ) { 7194 which = cssExpand[ i ]; 7195 attrs[ "margin" + which ] = attrs[ "padding" + which ] = type; 7196 } 7197 7198 if ( includeWidth ) { 7199 attrs.opacity = attrs.width = type; 7200 } 7201 7202 return attrs; 7203} 7204 7205function createTween( value, prop, animation ) { 7206 var tween, 7207 collection = ( Animation.tweeners[ prop ] || [] ).concat( Animation.tweeners[ "*" ] ), 7208 index = 0, 7209 length = collection.length; 7210 for ( ; index < length; index++ ) { 7211 if ( ( tween = collection[ index ].call( animation, prop, value ) ) ) { 7212 7213 // We're done with this property 7214 return tween; 7215 } 7216 } 7217} 7218 7219function defaultPrefilter( elem, props, opts ) { 7220 var prop, value, toggle, hooks, oldfire, propTween, restoreDisplay, display, 7221 isBox = "width" in props || "height" in props, 7222 anim = this, 7223 orig = {}, 7224 style = elem.style, 7225 hidden = elem.nodeType && isHiddenWithinTree( elem ), 7226 dataShow = dataPriv.get( elem, "fxshow" ); 7227 7228 // Queue-skipping animations hijack the fx hooks 7229 if ( !opts.queue ) { 7230 hooks = jQuery._queueHooks( elem, "fx" ); 7231 if ( hooks.unqueued == null ) { 7232 hooks.unqueued = 0; 7233 oldfire = hooks.empty.fire; 7234 hooks.empty.fire = function() { 7235 if ( !hooks.unqueued ) { 7236 oldfire(); 7237 } 7238 }; 7239 } 7240 hooks.unqueued++; 7241 7242 anim.always( function() { 7243 7244 // Ensure the complete handler is called before this completes 7245 anim.always( function() { 7246 hooks.unqueued--; 7247 if ( !jQuery.queue( elem, "fx" ).length ) { 7248 hooks.empty.fire(); 7249 } 7250 } ); 7251 } ); 7252 } 7253 7254 // Detect show/hide animations 7255 for ( prop in props ) { 7256 value = props[ prop ]; 7257 if ( rfxtypes.test( value ) ) { 7258 delete props[ prop ]; 7259 toggle = toggle || value === "toggle"; 7260 if ( value === ( hidden ? "hide" : "show" ) ) { 7261 7262 // Pretend to be hidden if this is a "show" and 7263 // there is still data from a stopped show/hide 7264 if ( value === "show" && dataShow && dataShow[ prop ] !== undefined ) { 7265 hidden = true; 7266 7267 // Ignore all other no-op show/hide data 7268 } else { 7269 continue; 7270 } 7271 } 7272 orig[ prop ] = dataShow && dataShow[ prop ] || jQuery.style( elem, prop ); 7273 } 7274 } 7275 7276 // Bail out if this is a no-op like .hide().hide() 7277 propTween = !jQuery.isEmptyObject( props ); 7278 if ( !propTween && jQuery.isEmptyObject( orig ) ) { 7279 return; 7280 } 7281 7282 // Restrict "overflow" and "display" styles during box animations 7283 if ( isBox && elem.nodeType === 1 ) { 7284 7285 // Support: IE <=9 - 11, Edge 12 - 15 7286 // Record all 3 overflow attributes because IE does not infer the shorthand 7287 // from identically-valued overflowX and overflowY and Edge just mirrors 7288 // the overflowX value there. 7289 opts.overflow = [ style.overflow, style.overflowX, style.overflowY ]; 7290 7291 // Identify a display type, preferring old show/hide data over the CSS cascade 7292 restoreDisplay = dataShow && dataShow.display; 7293 if ( restoreDisplay == null ) { 7294 restoreDisplay = dataPriv.get( elem, "display" ); 7295 } 7296 display = jQuery.css( elem, "display" ); 7297 if ( display === "none" ) { 7298 if ( restoreDisplay ) { 7299 display = restoreDisplay; 7300 } else { 7301 7302 // Get nonempty value(s) by temporarily forcing visibility 7303 showHide( [ elem ], true ); 7304 restoreDisplay = elem.style.display || restoreDisplay; 7305 display = jQuery.css( elem, "display" ); 7306 showHide( [ elem ] ); 7307 } 7308 } 7309 7310 // Animate inline elements as inline-block 7311 if ( display === "inline" || display === "inline-block" && restoreDisplay != null ) { 7312 if ( jQuery.css( elem, "float" ) === "none" ) { 7313 7314 // Restore the original display value at the end of pure show/hide animations 7315 if ( !propTween ) { 7316 anim.done( function() { 7317 style.display = restoreDisplay; 7318 } ); 7319 if ( restoreDisplay == null ) { 7320 display = style.display; 7321 restoreDisplay = display === "none" ? "" : display; 7322 } 7323 } 7324 style.display = "inline-block"; 7325 } 7326 } 7327 } 7328 7329 if ( opts.overflow ) { 7330 style.overflow = "hidden"; 7331 anim.always( function() { 7332 style.overflow = opts.overflow[ 0 ]; 7333 style.overflowX = opts.overflow[ 1 ]; 7334 style.overflowY = opts.overflow[ 2 ]; 7335 } ); 7336 } 7337 7338 // Implement show/hide animations 7339 propTween = false; 7340 for ( prop in orig ) { 7341 7342 // General show/hide setup for this element animation 7343 if ( !propTween ) { 7344 if ( dataShow ) { 7345 if ( "hidden" in dataShow ) { 7346 hidden = dataShow.hidden; 7347 } 7348 } else { 7349 dataShow = dataPriv.access( elem, "fxshow", { display: restoreDisplay } ); 7350 } 7351 7352 // Store hidden/visible for toggle so `.stop().toggle()` "reverses" 7353 if ( toggle ) { 7354 dataShow.hidden = !hidden; 7355 } 7356 7357 // Show elements before animating them 7358 if ( hidden ) { 7359 showHide( [ elem ], true ); 7360 } 7361 7362 /* eslint-disable no-loop-func */ 7363 7364 anim.done( function() { 7365 7366 /* eslint-enable no-loop-func */ 7367 7368 // The final step of a "hide" animation is actually hiding the element 7369 if ( !hidden ) { 7370 showHide( [ elem ] ); 7371 } 7372 dataPriv.remove( elem, "fxshow" ); 7373 for ( prop in orig ) { 7374 jQuery.style( elem, prop, orig[ prop ] ); 7375 } 7376 } ); 7377 } 7378 7379 // Per-property setup 7380 propTween = createTween( hidden ? dataShow[ prop ] : 0, prop, anim ); 7381 if ( !( prop in dataShow ) ) { 7382 dataShow[ prop ] = propTween.start; 7383 if ( hidden ) { 7384 propTween.end = propTween.start; 7385 propTween.start = 0; 7386 } 7387 } 7388 } 7389} 7390 7391function propFilter( props, specialEasing ) { 7392 var index, name, easing, value, hooks; 7393 7394 // camelCase, specialEasing and expand cssHook pass 7395 for ( index in props ) { 7396 name = camelCase( index ); 7397 easing = specialEasing[ name ]; 7398 value = props[ index ]; 7399 if ( Array.isArray( value ) ) { 7400 easing = value[ 1 ]; 7401 value = props[ index ] = value[ 0 ]; 7402 } 7403 7404 if ( index !== name ) { 7405 props[ name ] = value; 7406 delete props[ index ]; 7407 } 7408 7409 hooks = jQuery.cssHooks[ name ]; 7410 if ( hooks && "expand" in hooks ) { 7411 value = hooks.expand( value ); 7412 delete props[ name ]; 7413 7414 // Not quite $.extend, this won't overwrite existing keys. 7415 // Reusing 'index' because we have the correct "name" 7416 for ( index in value ) { 7417 if ( !( index in props ) ) { 7418 props[ index ] = value[ index ]; 7419 specialEasing[ index ] = easing; 7420 } 7421 } 7422 } else { 7423 specialEasing[ name ] = easing; 7424 } 7425 } 7426} 7427 7428function Animation( elem, properties, options ) { 7429 var result, 7430 stopped, 7431 index = 0, 7432 length = Animation.prefilters.length, 7433 deferred = jQuery.Deferred().always( function() { 7434 7435 // Don't match elem in the :animated selector 7436 delete tick.elem; 7437 } ), 7438 tick = function() { 7439 if ( stopped ) { 7440 return false; 7441 } 7442 var currentTime = fxNow || createFxNow(), 7443 remaining = Math.max( 0, animation.startTime + animation.duration - currentTime ), 7444
vendor: 9,542 bytes, lines 7445-7835
7445 // Support: Android 2.3 only 7446 // Archaic crash bug won't allow us to use `1 - ( 0.5 || 0 )` (trac-12497) 7447 temp = remaining / animation.duration || 0, 7448 percent = 1 - temp, 7449 index = 0, 7450 length = animation.tweens.length; 7451 7452 for ( ; index < length; index++ ) { 7453 animation.tweens[ index ].run( percent ); 7454 } 7455 7456 deferred.notifyWith( elem, [ animation, percent, remaining ] ); 7457 7458 // If there's more to do, yield 7459 if ( percent < 1 && length ) { 7460 return remaining; 7461 } 7462 7463 // If this was an empty animation, synthesize a final progress notification 7464 if ( !length ) { 7465 deferred.notifyWith( elem, [ animation, 1, 0 ] ); 7466 } 7467 7468 // Resolve the animation and report its conclusion 7469 deferred.resolveWith( elem, [ animation ] ); 7470 return false; 7471 }, 7472 animation = deferred.promise( { 7473 elem: elem, 7474 props: jQuery.extend( {}, properties ), 7475 opts: jQuery.extend( true, { 7476 specialEasing: {}, 7477 easing: jQuery.easing._default 7478 }, options ), 7479 originalProperties: properties, 7480 originalOptions: options, 7481 startTime: fxNow || createFxNow(), 7482 duration: options.duration, 7483 tweens: [], 7484 createTween: function( prop, end ) { 7485 var tween = jQuery.Tween( elem, animation.opts, prop, end, 7486 animation.opts.specialEasing[ prop ] || animation.opts.easing ); 7487 animation.tweens.push( tween ); 7488 return tween; 7489 }, 7490 stop: function( gotoEnd ) { 7491 var index = 0, 7492 7493 // If we are going to the end, we want to run all the tweens 7494 // otherwise we skip this part 7495 length = gotoEnd ? animation.tweens.length : 0; 7496 if ( stopped ) { 7497 return this; 7498 } 7499 stopped = true; 7500 for ( ; index < length; index++ ) { 7501 animation.tweens[ index ].run( 1 ); 7502 } 7503 7504 // Resolve when we played the last frame; otherwise, reject 7505 if ( gotoEnd ) { 7506 deferred.notifyWith( elem, [ animation, 1, 0 ] ); 7507 deferred.resolveWith( elem, [ animation, gotoEnd ] ); 7508 } else { 7509 deferred.rejectWith( elem, [ animation, gotoEnd ] ); 7510 } 7511 return this; 7512 } 7513 } ), 7514 props = animation.props; 7515 7516 propFilter( props, animation.opts.specialEasing ); 7517 7518 for ( ; index < length; index++ ) { 7519 result = Animation.prefilters[ index ].call( animation, elem, props, animation.opts ); 7520 if ( result ) { 7521 if ( isFunction( result.stop ) ) { 7522 jQuery._queueHooks( animation.elem, animation.opts.queue ).stop = 7523 result.stop.bind( result ); 7524 } 7525 return result; 7526 } 7527 } 7528 7529 jQuery.map( props, createTween, animation ); 7530 7531 if ( isFunction( animation.opts.start ) ) { 7532 animation.opts.start.call( elem, animation ); 7533 } 7534 7535 // Attach callbacks from options 7536 animation 7537 .progress( animation.opts.progress ) 7538 .done( animation.opts.done, animation.opts.complete ) 7539 .fail( animation.opts.fail ) 7540 .always( animation.opts.always ); 7541 7542 jQuery.fx.timer( 7543 jQuery.extend( tick, { 7544 elem: elem, 7545 anim: animation, 7546 queue: animation.opts.queue 7547 } ) 7548 ); 7549 7550 return animation; 7551} 7552 7553jQuery.Animation = jQuery.extend( Animation, { 7554 7555 tweeners: { 7556 "*": [ function( prop, value ) { 7557 var tween = this.createTween( prop, value ); 7558 adjustCSS( tween.elem, prop, rcssNum.exec( value ), tween ); 7559 return tween; 7560 } ] 7561 }, 7562 7563 tweener: function( props, callback ) { 7564 if ( isFunction( props ) ) { 7565 callback = props; 7566 props = [ "*" ]; 7567 } else { 7568 props = props.match( rnothtmlwhite ); 7569 } 7570 7571 var prop, 7572 index = 0, 7573 length = props.length; 7574 7575 for ( ; index < length; index++ ) { 7576 prop = props[ index ]; 7577 Animation.tweeners[ prop ] = Animation.tweeners[ prop ] || []; 7578 Animation.tweeners[ prop ].unshift( callback ); 7579 } 7580 }, 7581 7582 prefilters: [ defaultPrefilter ], 7583 7584 prefilter: function( callback, prepend ) { 7585 if ( prepend ) { 7586 Animation.prefilters.unshift( callback ); 7587 } else { 7588 Animation.prefilters.push( callback ); 7589 } 7590 } 7591} ); 7592 7593jQuery.speed = function( speed, easing, fn ) { 7594 var opt = speed && typeof speed === "object" ? jQuery.extend( {}, speed ) : { 7595 complete: fn || !fn && easing || 7596 isFunction( speed ) && speed, 7597 duration: speed, 7598 easing: fn && easing || easing && !isFunction( easing ) && easing 7599 }; 7600 7601 // Go to the end state if fx are off 7602 if ( jQuery.fx.off ) { 7603 opt.duration = 0; 7604 7605 } else { 7606 if ( typeof opt.duration !== "number" ) { 7607 if ( opt.duration in jQuery.fx.speeds ) { 7608 opt.duration = jQuery.fx.speeds[ opt.duration ]; 7609 7610 } else { 7611 opt.duration = jQuery.fx.speeds._default; 7612 } 7613 } 7614 } 7615 7616 // Normalize opt.queue - true/undefined/null -> "fx" 7617 if ( opt.queue == null || opt.queue === true ) { 7618 opt.queue = "fx"; 7619 } 7620 7621 // Queueing 7622 opt.old = opt.complete; 7623 7624 opt.complete = function() { 7625 if ( isFunction( opt.old ) ) { 7626 opt.old.call( this ); 7627 } 7628 7629 if ( opt.queue ) { 7630 jQuery.dequeue( this, opt.queue ); 7631 } 7632 }; 7633 7634 return opt; 7635}; 7636 7637jQuery.fn.extend( { 7638 fadeTo: function( speed, to, easing, callback ) { 7639 7640 // Show any hidden elements after setting opacity to 0 7641 return this.filter( isHiddenWithinTree ).css( "opacity", 0 ).show() 7642 7643 // Animate to the value specified 7644 .end().animate( { opacity: to }, speed, easing, callback ); 7645 }, 7646 animate: function( prop, speed, easing, callback ) { 7647 var empty = jQuery.isEmptyObject( prop ), 7648 optall = jQuery.speed( speed, easing, callback ), 7649 doAnimation = function() { 7650 7651 // Operate on a copy of prop so per-property easing won't be lost 7652 var anim = Animation( this, jQuery.extend( {}, prop ), optall ); 7653 7654 // Empty animations, or finishing resolves immediately 7655 if ( empty || dataPriv.get( this, "finish" ) ) { 7656 anim.stop( true ); 7657 } 7658 }; 7659 7660 doAnimation.finish = doAnimation; 7661 7662 return empty || optall.queue === false ? 7663 this.each( doAnimation ) : 7664 this.queue( optall.queue, doAnimation ); 7665 }, 7666 stop: function( type, clearQueue, gotoEnd ) { 7667 var stopQueue = function( hooks ) { 7668 var stop = hooks.stop; 7669 delete hooks.stop; 7670 stop( gotoEnd ); 7671 }; 7672 7673 if ( typeof type !== "string" ) { 7674 gotoEnd = clearQueue; 7675 clearQueue = type; 7676 type = undefined; 7677 } 7678 if ( clearQueue ) { 7679 this.queue( type || "fx", [] ); 7680 } 7681 7682 return this.each( function() { 7683 var dequeue = true, 7684 index = type != null && type + "queueHooks", 7685 timers = jQuery.timers, 7686 data = dataPriv.get( this ); 7687 7688 if ( index ) { 7689 if ( data[ index ] && data[ index ].stop ) { 7690 stopQueue( data[ index ] ); 7691 } 7692 } else { 7693 for ( index in data ) { 7694 if ( data[ index ] && data[ index ].stop && rrun.test( index ) ) { 7695 stopQueue( data[ index ] ); 7696 } 7697 } 7698 } 7699 7700 for ( index = timers.length; index--; ) { 7701 if ( timers[ index ].elem === this && 7702 ( type == null || timers[ index ].queue === type ) ) { 7703 7704 timers[ index ].anim.stop( gotoEnd ); 7705 dequeue = false; 7706 timers.splice( index, 1 ); 7707 } 7708 } 7709 7710 // Start the next in the queue if the last step wasn't forced. 7711 // Timers currently will call their complete callbacks, which 7712 // will dequeue but only if they were gotoEnd. 7713 if ( dequeue || !gotoEnd ) { 7714 jQuery.dequeue( this, type ); 7715 } 7716 } ); 7717 }, 7718 finish: function( type ) { 7719 if ( type !== false ) { 7720 type = type || "fx"; 7721 } 7722 return this.each( function() { 7723 var index, 7724 data = dataPriv.get( this ), 7725 queue = data[ type + "queue" ], 7726 hooks = data[ type + "queueHooks" ], 7727 timers = jQuery.timers, 7728 length = queue ? queue.length : 0; 7729 7730 // Enable finishing flag on private data 7731 data.finish = true; 7732 7733 // Empty the queue first 7734 jQuery.queue( this, type, [] ); 7735 7736 if ( hooks && hooks.stop ) { 7737 hooks.stop.call( this, true ); 7738 } 7739 7740 // Look for any active animations, and finish them 7741 for ( index = timers.length; index--; ) { 7742 if ( timers[ index ].elem === this && timers[ index ].queue === type ) { 7743 timers[ index ].anim.stop( true ); 7744 timers.splice( index, 1 ); 7745 } 7746 } 7747 7748 // Look for any animations in the old queue and finish them 7749 for ( index = 0; index < length; index++ ) { 7750 if ( queue[ index ] && queue[ index ].finish ) { 7751 queue[ index ].finish.call( this ); 7752 } 7753 } 7754 7755 // Turn off finishing flag 7756 delete data.finish; 7757 } ); 7758 } 7759} ); 7760 7761jQuery.each( [ "toggle", "show", "hide" ], function( _i, name ) { 7762 var cssFn = jQuery.fn[ name ]; 7763 jQuery.fn[ name ] = function( speed, easing, callback ) { 7764 return speed == null || typeof speed === "boolean" ? 7765 cssFn.apply( this, arguments ) : 7766 this.animate( genFx( name, true ), speed, easing, callback ); 7767 }; 7768} ); 7769 7770// Generate shortcuts for custom animations 7771jQuery.each( { 7772 slideDown: genFx( "show" ), 7773 slideUp: genFx( "hide" ), 7774 slideToggle: genFx( "toggle" ), 7775 fadeIn: { opacity: "show" }, 7776 fadeOut: { opacity: "hide" }, 7777 fadeToggle: { opacity: "toggle" } 7778}, function( name, props ) { 7779 jQuery.fn[ name ] = function( speed, easing, callback ) { 7780 return this.animate( props, speed, easing, callback ); 7781 }; 7782} ); 7783 7784jQuery.timers = []; 7785jQuery.fx.tick = function() { 7786 var timer, 7787 i = 0, 7788 timers = jQuery.timers; 7789 7790 fxNow = Date.now(); 7791 7792 for ( ; i < timers.length; i++ ) { 7793 timer = timers[ i ]; 7794 7795 // Run the timer and safely remove it when done (allowing for external removal) 7796 if ( !timer() && timers[ i ] === timer ) { 7797 timers.splice( i--, 1 ); 7798 } 7799 } 7800 7801 if ( !timers.length ) { 7802 jQuery.fx.stop(); 7803 } 7804 fxNow = undefined; 7805}; 7806 7807jQuery.fx.timer = function( timer ) { 7808 jQuery.timers.push( timer ); 7809 jQuery.fx.start(); 7810}; 7811 7812jQuery.fx.interval = 13; 7813jQuery.fx.start = function() { 7814 if ( inProgress ) { 7815 return; 7816 } 7817 7818 inProgress = true; 7819 schedule(); 7820}; 7821 7822jQuery.fx.stop = function() { 7823 inProgress = null; 7824}; 7825 7826jQuery.fx.speeds = { 7827 slow: 600, 7828 fast: 200, 7829 7830 // Default speed 7831 _default: 400 7832}; 7833 7834 7835// Based off of the plugin by Clint Helfers, with permission.
vendor: 5,177 bytes, lines 7836-8056
7836jQuery.fn.delay = function( time, type ) { 7837 time = jQuery.fx ? jQuery.fx.speeds[ time ] || time : time; 7838 type = type || "fx"; 7839 7840 return this.queue( type, function( next, hooks ) { 7841 var timeout = window.setTimeout( next, time ); 7842 hooks.stop = function() { 7843 window.clearTimeout( timeout ); 7844 }; 7845 } ); 7846}; 7847 7848 7849( function() { 7850 var input = document.createElement( "input" ), 7851 select = document.createElement( "select" ), 7852 opt = select.appendChild( document.createElement( "option" ) ); 7853 7854 input.type = "checkbox"; 7855 7856 // Support: Android <=4.3 only 7857 // Default value for a checkbox should be "on" 7858 support.checkOn = input.value !== ""; 7859 7860 // Support: IE <=11 only 7861 // Must access selectedIndex to make default options select 7862 support.optSelected = opt.selected; 7863 7864 // Support: IE <=11 only 7865 // An input loses its value after becoming a radio 7866 input = document.createElement( "input" ); 7867 input.value = "t"; 7868 input.type = "radio"; 7869 support.radioValue = input.value === "t"; 7870} )(); 7871 7872 7873var boolHook, 7874 attrHandle = jQuery.expr.attrHandle; 7875 7876jQuery.fn.extend( { 7877 attr: function( name, value ) { 7878 return access( this, jQuery.attr, name, value, arguments.length > 1 ); 7879 }, 7880 7881 removeAttr: function( name ) { 7882 return this.each( function() { 7883 jQuery.removeAttr( this, name ); 7884 } ); 7885 } 7886} ); 7887 7888jQuery.extend( { 7889 attr: function( elem, name, value ) { 7890 var ret, hooks, 7891 nType = elem.nodeType; 7892 7893 // Don't get/set attributes on text, comment and attribute nodes 7894 if ( nType === 3 || nType === 8 || nType === 2 ) { 7895 return; 7896 } 7897 7898 // Fallback to prop when attributes are not supported 7899 if ( typeof elem.getAttribute === "undefined" ) { 7900 return jQuery.prop( elem, name, value ); 7901 } 7902 7903 // Attribute hooks are determined by the lowercase version 7904 // Grab necessary hook if one is defined 7905 if ( nType !== 1 || !jQuery.isXMLDoc( elem ) ) { 7906 hooks = jQuery.attrHooks[ name.toLowerCase() ] || 7907 ( jQuery.expr.match.bool.test( name ) ? boolHook : undefined ); 7908 } 7909 7910 if ( value !== undefined ) { 7911 if ( value === null ) { 7912 jQuery.removeAttr( elem, name ); 7913 return; 7914 } 7915 7916 if ( hooks && "set" in hooks && 7917 ( ret = hooks.set( elem, value, name ) ) !== undefined ) { 7918 return ret; 7919 } 7920 7921 elem.setAttribute( name, value + "" ); 7922 return value; 7923 } 7924 7925 if ( hooks && "get" in hooks && ( ret = hooks.get( elem, name ) ) !== null ) { 7926 return ret; 7927 } 7928 7929 ret = jQuery.find.attr( elem, name ); 7930 7931 // Non-existent attributes return null, we normalize to undefined 7932 return ret == null ? undefined : ret; 7933 }, 7934 7935 attrHooks: { 7936 type: { 7937 set: function( elem, value ) { 7938 if ( !support.radioValue && value === "radio" && 7939 nodeName( elem, "input" ) ) { 7940 var val = elem.value; 7941 elem.setAttribute( "type", value ); 7942 if ( val ) { 7943 elem.value = val; 7944 } 7945 return value; 7946 } 7947 } 7948 } 7949 }, 7950 7951 removeAttr: function( elem, value ) { 7952 var name, 7953 i = 0, 7954 7955 // Attribute names can contain non-HTML whitespace characters 7956 // https://html.spec.whatwg.org/multipage/syntax.html#attributes-2 7957 attrNames = value && value.match( rnothtmlwhite ); 7958 7959 if ( attrNames && elem.nodeType === 1 ) { 7960 while ( ( name = attrNames[ i++ ] ) ) { 7961 elem.removeAttribute( name ); 7962 } 7963 } 7964 } 7965} ); 7966 7967// Hooks for boolean attributes 7968boolHook = { 7969 set: function( elem, value, name ) { 7970 if ( value === false ) { 7971 7972 // Remove boolean attributes when set to false 7973 jQuery.removeAttr( elem, name ); 7974 } else { 7975 elem.setAttribute( name, name ); 7976 } 7977 return name; 7978 } 7979}; 7980 7981jQuery.each( jQuery.expr.match.bool.source.match( /\w+/g ), function( _i, name ) { 7982 var getter = attrHandle[ name ] || jQuery.find.attr; 7983 7984 attrHandle[ name ] = function( elem, name, isXML ) { 7985 var ret, handle, 7986 lowercaseName = name.toLowerCase(); 7987 7988 if ( !isXML ) { 7989 7990 // Avoid an infinite loop by temporarily removing this function from the getter 7991 handle = attrHandle[ lowercaseName ]; 7992 attrHandle[ lowercaseName ] = ret; 7993 ret = getter( elem, name, isXML ) != null ? 7994 lowercaseName : 7995 null; 7996 attrHandle[ lowercaseName ] = handle; 7997 } 7998 return ret; 7999 }; 8000} ); 8001 8002 8003 8004 8005var rfocusable = /^(?:input|select|textarea|button)$/i, 8006 rclickable = /^(?:a|area)$/i; 8007 8008jQuery.fn.extend( { 8009 prop: function( name, value ) { 8010 return access( this, jQuery.prop, name, value, arguments.length > 1 ); 8011 }, 8012 8013 removeProp: function( name ) { 8014 return this.each( function() { 8015 delete this[ jQuery.propFix[ name ] || name ]; 8016 } ); 8017 } 8018} ); 8019 8020jQuery.extend( { 8021 prop: function( elem, name, value ) { 8022 var ret, hooks, 8023 nType = elem.nodeType; 8024 8025 // Don't get/set properties on text, comment and attribute nodes 8026 if ( nType === 3 || nType === 8 || nType === 2 ) { 8027 return; 8028 } 8029 8030 if ( nType !== 1 || !jQuery.isXMLDoc( elem ) ) { 8031 8032 // Fix name and attach hooks 8033 name = jQuery.propFix[ name ] || name; 8034 hooks = jQuery.propHooks[ name ]; 8035 } 8036 8037 if ( value !== undefined ) { 8038 if ( hooks && "set" in hooks && 8039 ( ret = hooks.set( elem, value, name ) ) !== undefined ) { 8040 return ret; 8041 } 8042 8043 return ( elem[ name ] = value ); 8044 } 8045 8046 if ( hooks && "get" in hooks && ( ret = hooks.get( elem, name ) ) !== null ) { 8047 return ret; 8048 } 8049 8050 return elem[ name ]; 8051 }, 8052 8053 propHooks: { 8054 tabIndex: { 8055 get: function( elem ) { 8056
vendor: 6,126 bytes, lines 8057-8316
8057 // Support: IE <=9 - 11 only 8058 // elem.tabIndex doesn't always return the 8059 // correct value when it hasn't been explicitly set 8060 // Use proper attribute retrieval (trac-12072) 8061 var tabindex = jQuery.find.attr( elem, "tabindex" ); 8062 8063 if ( tabindex ) { 8064 return parseInt( tabindex, 10 ); 8065 } 8066 8067 if ( 8068 rfocusable.test( elem.nodeName ) || 8069 rclickable.test( elem.nodeName ) && 8070 elem.href 8071 ) { 8072 return 0; 8073 } 8074 8075 return -1; 8076 } 8077 } 8078 }, 8079 8080 propFix: { 8081 "for": "htmlFor", 8082 "class": "className" 8083 } 8084} ); 8085 8086// Support: IE <=11 only 8087// Accessing the selectedIndex property 8088// forces the browser to respect setting selected 8089// on the option 8090// The getter ensures a default option is selected 8091// when in an optgroup 8092// eslint rule "no-unused-expressions" is disabled for this code 8093// since it considers such accessions noop 8094if ( !support.optSelected ) { 8095 jQuery.propHooks.selected = { 8096 get: function( elem ) { 8097 8098 /* eslint no-unused-expressions: "off" */ 8099 8100 var parent = elem.parentNode; 8101 if ( parent && parent.parentNode ) { 8102 parent.parentNode.selectedIndex; 8103 } 8104 return null; 8105 }, 8106 set: function( elem ) { 8107 8108 /* eslint no-unused-expressions: "off" */ 8109 8110 var parent = elem.parentNode; 8111 if ( parent ) { 8112 parent.selectedIndex; 8113 8114 if ( parent.parentNode ) { 8115 parent.parentNode.selectedIndex; 8116 } 8117 } 8118 } 8119 }; 8120} 8121 8122jQuery.each( [ 8123 "tabIndex", 8124 "readOnly", 8125 "maxLength", 8126 "cellSpacing", 8127 "cellPadding", 8128 "rowSpan", 8129 "colSpan", 8130 "useMap", 8131 "frameBorder", 8132 "contentEditable" 8133], function() { 8134 jQuery.propFix[ this.toLowerCase() ] = this; 8135} ); 8136 8137 8138 8139 8140 // Strip and collapse whitespace according to HTML spec 8141 // https://infra.spec.whatwg.org/#strip-and-collapse-ascii-whitespace 8142 function stripAndCollapse( value ) { 8143 var tokens = value.match( rnothtmlwhite ) || []; 8144 return tokens.join( " " ); 8145 } 8146 8147 8148function getClass( elem ) { 8149 return elem.getAttribute && elem.getAttribute( "class" ) || ""; 8150} 8151 8152function classesToArray( value ) { 8153 if ( Array.isArray( value ) ) { 8154 return value; 8155 } 8156 if ( typeof value === "string" ) { 8157 return value.match( rnothtmlwhite ) || []; 8158 } 8159 return []; 8160} 8161 8162jQuery.fn.extend( { 8163 addClass: function( value ) { 8164 var classNames, cur, curValue, className, i, finalValue; 8165 8166 if ( isFunction( value ) ) { 8167 return this.each( function( j ) { 8168 jQuery( this ).addClass( value.call( this, j, getClass( this ) ) ); 8169 } ); 8170 } 8171 8172 classNames = classesToArray( value ); 8173 8174 if ( classNames.length ) { 8175 return this.each( function() { 8176 curValue = getClass( this ); 8177 cur = this.nodeType === 1 && ( " " + stripAndCollapse( curValue ) + " " ); 8178 8179 if ( cur ) { 8180 for ( i = 0; i < classNames.length; i++ ) { 8181 className = classNames[ i ]; 8182 if ( cur.indexOf( " " + className + " " ) < 0 ) { 8183 cur += className + " "; 8184 } 8185 } 8186 8187 // Only assign if different to avoid unneeded rendering. 8188 finalValue = stripAndCollapse( cur ); 8189 if ( curValue !== finalValue ) { 8190 this.setAttribute( "class", finalValue ); 8191 } 8192 } 8193 } ); 8194 } 8195 8196 return this; 8197 }, 8198 8199 removeClass: function( value ) { 8200 var classNames, cur, curValue, className, i, finalValue; 8201 8202 if ( isFunction( value ) ) { 8203 return this.each( function( j ) { 8204 jQuery( this ).removeClass( value.call( this, j, getClass( this ) ) ); 8205 } ); 8206 } 8207 8208 if ( !arguments.length ) { 8209 return this.attr( "class", "" ); 8210 } 8211 8212 classNames = classesToArray( value ); 8213 8214 if ( classNames.length ) { 8215 return this.each( function() { 8216 curValue = getClass( this ); 8217 8218 // This expression is here for better compressibility (see addClass) 8219 cur = this.nodeType === 1 && ( " " + stripAndCollapse( curValue ) + " " ); 8220 8221 if ( cur ) { 8222 for ( i = 0; i < classNames.length; i++ ) { 8223 className = classNames[ i ]; 8224 8225 // Remove *all* instances 8226 while ( cur.indexOf( " " + className + " " ) > -1 ) { 8227 cur = cur.replace( " " + className + " ", " " ); 8228 } 8229 } 8230 8231 // Only assign if different to avoid unneeded rendering. 8232 finalValue = stripAndCollapse( cur ); 8233 if ( curValue !== finalValue ) { 8234 this.setAttribute( "class", finalValue ); 8235 } 8236 } 8237 } ); 8238 } 8239 8240 return this; 8241 }, 8242 8243 toggleClass: function( value, stateVal ) { 8244 var classNames, className, i, self, 8245 type = typeof value, 8246 isValidValue = type === "string" || Array.isArray( value ); 8247 8248 if ( isFunction( value ) ) { 8249 return this.each( function( i ) { 8250 jQuery( this ).toggleClass( 8251 value.call( this, i, getClass( this ), stateVal ), 8252 stateVal 8253 ); 8254 } ); 8255 } 8256 8257 if ( typeof stateVal === "boolean" && isValidValue ) { 8258 return stateVal ? this.addClass( value ) : this.removeClass( value ); 8259 } 8260 8261 classNames = classesToArray( value ); 8262 8263 return this.each( function() { 8264 if ( isValidValue ) { 8265 8266 // Toggle individual class names 8267 self = jQuery( this ); 8268 8269 for ( i = 0; i < classNames.length; i++ ) { 8270 className = classNames[ i ]; 8271 8272 // Check each className given, space separated list 8273 if ( self.hasClass( className ) ) { 8274 self.removeClass( className ); 8275 } else { 8276 self.addClass( className ); 8277 } 8278 } 8279 8280 // Toggle whole class name 8281 } else if ( value === undefined || type === "boolean" ) { 8282 className = getClass( this ); 8283 if ( className ) { 8284 8285 // Store className if set 8286 dataPriv.set( this, "__className__", className ); 8287 } 8288 8289 // If the element has a class name or if we're passed `false`, 8290 // then remove the whole classname (if there was one, the above saved it). 8291 // Otherwise bring back whatever was previously saved (if anything), 8292 // falling back to the empty string if nothing was stored. 8293 if ( this.setAttribute ) { 8294 this.setAttribute( "class", 8295 className || value === false ? 8296 "" : 8297 dataPriv.get( this, "__className__" ) || "" 8298 ); 8299 } 8300 } 8301 } ); 8302 }, 8303 8304 hasClass: function( selector ) { 8305 var className, elem, 8306 i = 0; 8307 8308 className = " " + selector + " "; 8309 while ( ( elem = this[ i++ ] ) ) { 8310 if ( elem.nodeType === 1 && 8311 ( " " + stripAndCollapse( getClass( elem ) ) + " " ).indexOf( className ) > -1 ) { 8312 return true; 8313 } 8314 } 8315 8316 return false;
vendor: 1,385 bytes, lines 8317-8386
8317 } 8318} ); 8319 8320 8321 8322 8323var rreturn = /\r/g; 8324 8325jQuery.fn.extend( { 8326 val: function( value ) { 8327 var hooks, ret, valueIsFunction, 8328 elem = this[ 0 ]; 8329 8330 if ( !arguments.length ) { 8331 if ( elem ) { 8332 hooks = jQuery.valHooks[ elem.type ] || 8333 jQuery.valHooks[ elem.nodeName.toLowerCase() ]; 8334 8335 if ( hooks && 8336 "get" in hooks && 8337 ( ret = hooks.get( elem, "value" ) ) !== undefined 8338 ) { 8339 return ret; 8340 } 8341 8342 ret = elem.value; 8343 8344 // Handle most common string cases 8345 if ( typeof ret === "string" ) { 8346 return ret.replace( rreturn, "" ); 8347 } 8348 8349 // Handle cases where value is null/undef or number 8350 return ret == null ? "" : ret; 8351 } 8352 8353 return; 8354 } 8355 8356 valueIsFunction = isFunction( value ); 8357 8358 return this.each( function( i ) { 8359 var val; 8360 8361 if ( this.nodeType !== 1 ) { 8362 return; 8363 } 8364 8365 if ( valueIsFunction ) { 8366 val = value.call( this, i, jQuery( this ).val() ); 8367 } else { 8368 val = value; 8369 } 8370 8371 // Treat null/undefined as ""; convert numbers to string 8372 if ( val == null ) { 8373 val = ""; 8374 8375 } else if ( typeof val === "number" ) { 8376 val += ""; 8377 8378 } else if ( Array.isArray( val ) ) { 8379 val = jQuery.map( val, function( value ) { 8380 return value == null ? "" : value + ""; 8381 } ); 8382 } 8383 8384 hooks = jQuery.valHooks[ this.type ] || jQuery.valHooks[ this.nodeName.toLowerCase() ]; 8385 8386 // If set returns undefined, fall back to normal setting
vendor: 4,458 bytes, lines 8387-8572
8387 if ( !hooks || !( "set" in hooks ) || hooks.set( this, val, "value" ) === undefined ) { 8388 this.value = val; 8389 } 8390 } ); 8391 } 8392} ); 8393 8394jQuery.extend( { 8395 valHooks: { 8396 option: { 8397 get: function( elem ) { 8398 8399 var val = jQuery.find.attr( elem, "value" ); 8400 return val != null ? 8401 val : 8402 8403 // Support: IE <=10 - 11 only 8404 // option.text throws exceptions (trac-14686, trac-14858) 8405 // Strip and collapse whitespace 8406 // https://html.spec.whatwg.org/#strip-and-collapse-whitespace 8407 stripAndCollapse( jQuery.text( elem ) ); 8408 } 8409 }, 8410 select: { 8411 get: function( elem ) { 8412 var value, option, i, 8413 options = elem.options, 8414 index = elem.selectedIndex, 8415 one = elem.type === "select-one", 8416 values = one ? null : [], 8417 max = one ? index + 1 : options.length; 8418 8419 if ( index < 0 ) { 8420 i = max; 8421 8422 } else { 8423 i = one ? index : 0; 8424 } 8425 8426 // Loop through all the selected options 8427 for ( ; i < max; i++ ) { 8428 option = options[ i ]; 8429 8430 // Support: IE <=9 only 8431 // IE8-9 doesn't update selected after form reset (trac-2551) 8432 if ( ( option.selected || i === index ) && 8433 8434 // Don't return options that are disabled or in a disabled optgroup 8435 !option.disabled && 8436 ( !option.parentNode.disabled || 8437 !nodeName( option.parentNode, "optgroup" ) ) ) { 8438 8439 // Get the specific value for the option 8440 value = jQuery( option ).val(); 8441 8442 // We don't need an array for one selects 8443 if ( one ) { 8444 return value; 8445 } 8446 8447 // Multi-Selects return an array 8448 values.push( value ); 8449 } 8450 } 8451 8452 return values; 8453 }, 8454 8455 set: function( elem, value ) { 8456 var optionSet, option, 8457 options = elem.options, 8458 values = jQuery.makeArray( value ), 8459 i = options.length; 8460 8461 while ( i-- ) { 8462 option = options[ i ]; 8463 8464 /* eslint-disable no-cond-assign */ 8465 8466 if ( option.selected = 8467 jQuery.inArray( jQuery.valHooks.option.get( option ), values ) > -1 8468 ) { 8469 optionSet = true; 8470 } 8471 8472 /* eslint-enable no-cond-assign */ 8473 } 8474 8475 // Force browsers to behave consistently when non-matching value is set 8476 if ( !optionSet ) { 8477 elem.selectedIndex = -1; 8478 } 8479 return values; 8480 } 8481 } 8482 } 8483} ); 8484 8485// Radios and checkboxes getter/setter 8486jQuery.each( [ "radio", "checkbox" ], function() { 8487 jQuery.valHooks[ this ] = { 8488 set: function( elem, value ) { 8489 if ( Array.isArray( value ) ) { 8490 return ( elem.checked = jQuery.inArray( jQuery( elem ).val(), value ) > -1 ); 8491 } 8492 } 8493 }; 8494 if ( !support.checkOn ) { 8495 jQuery.valHooks[ this ].get = function( elem ) { 8496 return elem.getAttribute( "value" ) === null ? "on" : elem.value; 8497 }; 8498 } 8499} ); 8500 8501 8502 8503 8504// Return jQuery for attributes-only inclusion 8505var location = window.location; 8506 8507var nonce = { guid: Date.now() }; 8508 8509var rquery = ( /\?/ ); 8510 8511 8512 8513// Cross-browser xml parsing 8514jQuery.parseXML = function( data ) { 8515 var xml, parserErrorElem; 8516 if ( !data || typeof data !== "string" ) { 8517 return null; 8518 } 8519 8520 // Support: IE 9 - 11 only 8521 // IE throws on parseFromString with invalid input. 8522 try { 8523 xml = ( new window.DOMParser() ).parseFromString( data, "text/xml" ); 8524 } catch ( e ) {} 8525 8526 parserErrorElem = xml && xml.getElementsByTagName( "parsererror" )[ 0 ]; 8527 if ( !xml || parserErrorElem ) { 8528 jQuery.error( "Invalid XML: " + ( 8529 parserErrorElem ? 8530 jQuery.map( parserErrorElem.childNodes, function( el ) { 8531 return el.textContent; 8532 } ).join( "\n" ) : 8533 data 8534 ) ); 8535 } 8536 return xml; 8537}; 8538 8539 8540var rfocusMorph = /^(?:focusinfocus|focusoutblur)$/, 8541 stopPropagationCallback = function( e ) { 8542 e.stopPropagation(); 8543 }; 8544 8545jQuery.extend( jQuery.event, { 8546 8547 trigger: function( event, data, elem, onlyHandlers ) { 8548 8549 var i, cur, tmp, bubbleType, ontype, handle, special, lastElement, 8550 eventPath = [ elem || document ], 8551 type = hasOwn.call( event, "type" ) ? event.type : event, 8552 namespaces = hasOwn.call( event, "namespace" ) ? event.namespace.split( "." ) : []; 8553 8554 cur = lastElement = tmp = elem = elem || document; 8555 8556 // Don't do events on text and comment nodes 8557 if ( elem.nodeType === 3 || elem.nodeType === 8 ) { 8558 return; 8559 } 8560 8561 // focus/blur morphs to focusin/out; ensure we're not firing them right now 8562 if ( rfocusMorph.test( type + jQuery.event.triggered ) ) { 8563 return; 8564 } 8565 8566 if ( type.indexOf( "." ) > -1 ) { 8567 8568 // Namespaced trigger; create a regexp to match event type in handle() 8569 namespaces = type.split( "." ); 8570 type = namespaces.shift(); 8571 namespaces.sort(); 8572 }
vendor: 6,524 bytes, lines 8573-8822
8573 ontype = type.indexOf( ":" ) < 0 && "on" + type; 8574 8575 // Caller can pass in a jQuery.Event object, Object, or just an event type string 8576 event = event[ jQuery.expando ] ? 8577 event : 8578 new jQuery.Event( type, typeof event === "object" && event ); 8579 8580 // Trigger bitmask: & 1 for native handlers; & 2 for jQuery (always true) 8581 event.isTrigger = onlyHandlers ? 2 : 3; 8582 event.namespace = namespaces.join( "." ); 8583 event.rnamespace = event.namespace ? 8584 new RegExp( "(^|\\.)" + namespaces.join( "\\.(?:.*\\.|)" ) + "(\\.|$)" ) : 8585 null; 8586 8587 // Clean up the event in case it is being reused 8588 event.result = undefined; 8589 if ( !event.target ) { 8590 event.target = elem; 8591 } 8592 8593 // Clone any incoming data and prepend the event, creating the handler arg list 8594 data = data == null ? 8595 [ event ] : 8596 jQuery.makeArray( data, [ event ] ); 8597 8598 // Allow special events to draw outside the lines 8599 special = jQuery.event.special[ type ] || {}; 8600 if ( !onlyHandlers && special.trigger && special.trigger.apply( elem, data ) === false ) { 8601 return; 8602 } 8603 8604 // Determine event propagation path in advance, per W3C events spec (trac-9951) 8605 // Bubble up to document, then to window; watch for a global ownerDocument var (trac-9724) 8606 if ( !onlyHandlers && !special.noBubble && !isWindow( elem ) ) { 8607 8608 bubbleType = special.delegateType || type; 8609 if ( !rfocusMorph.test( bubbleType + type ) ) { 8610 cur = cur.parentNode; 8611 } 8612 for ( ; cur; cur = cur.parentNode ) { 8613 eventPath.push( cur ); 8614 tmp = cur; 8615 } 8616 8617 // Only add window if we got to document (e.g., not plain obj or detached DOM) 8618 if ( tmp === ( elem.ownerDocument || document ) ) { 8619 eventPath.push( tmp.defaultView || tmp.parentWindow || window ); 8620 } 8621 } 8622 8623 // Fire handlers on the event path 8624 i = 0; 8625 while ( ( cur = eventPath[ i++ ] ) && !event.isPropagationStopped() ) { 8626 lastElement = cur; 8627 event.type = i > 1 ? 8628 bubbleType : 8629 special.bindType || type; 8630 8631 // jQuery handler 8632 handle = ( dataPriv.get( cur, "events" ) || Object.create( null ) )[ event.type ] && 8633 dataPriv.get( cur, "handle" ); 8634 if ( handle ) { 8635 handle.apply( cur, data ); 8636 } 8637 8638 // Native handler 8639 handle = ontype && cur[ ontype ]; 8640 if ( handle && handle.apply && acceptData( cur ) ) { 8641 event.result = handle.apply( cur, data ); 8642 if ( event.result === false ) { 8643 event.preventDefault(); 8644 } 8645 } 8646 } 8647 event.type = type; 8648 8649 // If nobody prevented the default action, do it now 8650 if ( !onlyHandlers && !event.isDefaultPrevented() ) { 8651 8652 if ( ( !special._default || 8653 special._default.apply( eventPath.pop(), data ) === false ) && 8654 acceptData( elem ) ) { 8655 8656 // Call a native DOM method on the target with the same name as the event. 8657 // Don't do default actions on window, that's where global variables be (trac-6170) 8658 if ( ontype && isFunction( elem[ type ] ) && !isWindow( elem ) ) { 8659 8660 // Don't re-trigger an onFOO event when we call its FOO() method 8661 tmp = elem[ ontype ]; 8662 8663 if ( tmp ) { 8664 elem[ ontype ] = null; 8665 } 8666 8667 // Prevent re-triggering of the same event, since we already bubbled it above 8668 jQuery.event.triggered = type; 8669 8670 if ( event.isPropagationStopped() ) { 8671 lastElement.addEventListener( type, stopPropagationCallback ); 8672 } 8673 8674 elem[ type ](); 8675 8676 if ( event.isPropagationStopped() ) { 8677 lastElement.removeEventListener( type, stopPropagationCallback ); 8678 } 8679 8680 jQuery.event.triggered = undefined; 8681 8682 if ( tmp ) { 8683 elem[ ontype ] = tmp; 8684 } 8685 } 8686 } 8687 } 8688 8689 return event.result; 8690 }, 8691 8692 // Piggyback on a donor event to simulate a different one 8693 // Used only for `focus(in | out)` events 8694 simulate: function( type, elem, event ) { 8695 var e = jQuery.extend( 8696 new jQuery.Event(), 8697 event, 8698 { 8699 type: type, 8700 isSimulated: true 8701 } 8702 ); 8703 8704 jQuery.event.trigger( e, null, elem ); 8705 } 8706 8707} ); 8708 8709jQuery.fn.extend( { 8710 8711 trigger: function( type, data ) { 8712 return this.each( function() { 8713 jQuery.event.trigger( type, data, this ); 8714 } ); 8715 }, 8716 triggerHandler: function( type, data ) { 8717 var elem = this[ 0 ]; 8718 if ( elem ) { 8719 return jQuery.event.trigger( type, data, elem, true ); 8720 } 8721 } 8722} ); 8723 8724 8725var 8726 rbracket = /\[\]$/, 8727 rCRLF = /\r?\n/g, 8728 rsubmitterTypes = /^(?:submit|button|image|reset|file)$/i, 8729 rsubmittable = /^(?:input|select|textarea|keygen)/i; 8730 8731function buildParams( prefix, obj, traditional, add ) { 8732 var name; 8733 8734 if ( Array.isArray( obj ) ) { 8735 8736 // Serialize array item. 8737 jQuery.each( obj, function( i, v ) { 8738 if ( traditional || rbracket.test( prefix ) ) { 8739 8740 // Treat each array item as a scalar. 8741 add( prefix, v ); 8742 8743 } else { 8744 8745 // Item is non-scalar (array or object), encode its numeric index. 8746 buildParams( 8747 prefix + "[" + ( typeof v === "object" && v != null ? i : "" ) + "]", 8748 v, 8749 traditional, 8750 add 8751 ); 8752 } 8753 } ); 8754 8755 } else if ( !traditional && toType( obj ) === "object" ) { 8756 8757 // Serialize object item. 8758 for ( name in obj ) { 8759 buildParams( prefix + "[" + name + "]", obj[ name ], traditional, add ); 8760 } 8761 8762 } else { 8763 8764 // Serialize scalar item. 8765 add( prefix, obj ); 8766 } 8767} 8768 8769// Serialize an array of form elements or a set of 8770// key/values into a query string 8771jQuery.param = function( a, traditional ) { 8772 var prefix, 8773 s = [], 8774 add = function( key, valueOrFunction ) { 8775 8776 // If value is a function, invoke it and use its return value 8777 var value = isFunction( valueOrFunction ) ? 8778 valueOrFunction() : 8779 valueOrFunction; 8780 8781 s[ s.length ] = encodeURIComponent( key ) + "=" + 8782 encodeURIComponent( value == null ? "" : value ); 8783 }; 8784 8785 if ( a == null ) { 8786 return ""; 8787 } 8788 8789 // If an array was passed in, assume that it is an array of form elements. 8790 if ( Array.isArray( a ) || ( a.jquery && !jQuery.isPlainObject( a ) ) ) { 8791 8792 // Serialize the form elements 8793 jQuery.each( a, function() { 8794 add( this.name, this.value ); 8795 } ); 8796 8797 } else { 8798 8799 // If traditional, encode the "old" way (the way 1.3.2 or older 8800 // did it), otherwise encode params recursively. 8801 for ( prefix in a ) { 8802 buildParams( prefix, a[ prefix ], traditional, add ); 8803 } 8804 } 8805 8806 // Return the resulting serialization 8807 return s.join( "&" ); 8808}; 8809 8810jQuery.fn.extend( { 8811 serialize: function() { 8812 return jQuery.param( this.serializeArray() ); 8813 }, 8814 serializeArray: function() { 8815 return this.map( function() { 8816 8817 // Can add propHook for "elements" to filter or add form elements 8818 var elements = jQuery.prop( this, "elements" ); 8819 return elements ? jQuery.makeArray( elements ) : this; 8820 } ).filter( function() { 8821 var type = this.type; 8822
vendor: 32,437 bytes, lines 8823-10076
8823 // Use .is( ":disabled" ) so that fieldset[disabled] works 8824 return this.name && !jQuery( this ).is( ":disabled" ) && 8825 rsubmittable.test( this.nodeName ) && !rsubmitterTypes.test( type ) && 8826 ( this.checked || !rcheckableType.test( type ) ); 8827 } ).map( function( _i, elem ) { 8828 var val = jQuery( this ).val(); 8829 8830 if ( val == null ) { 8831 return null; 8832 } 8833 8834 if ( Array.isArray( val ) ) { 8835 return jQuery.map( val, function( val ) { 8836 return { name: elem.name, value: val.replace( rCRLF, "\r\n" ) }; 8837 } ); 8838 } 8839 8840 return { name: elem.name, value: val.replace( rCRLF, "\r\n" ) }; 8841 } ).get(); 8842 } 8843} ); 8844 8845 8846var 8847 r20 = /%20/g, 8848 rhash = /#.*$/, 8849 rantiCache = /([?&])_=[^&]*/, 8850 rheaders = /^(.*?):[ \t]*([^\r\n]*)$/mg, 8851 8852 // trac-7653, trac-8125, trac-8152: local protocol detection 8853 rlocalProtocol = /^(?:about|app|app-storage|.+-extension|file|res|widget):$/, 8854 rnoContent = /^(?:GET|HEAD)$/, 8855 rprotocol = /^\/\//, 8856 8857 /* Prefilters 8858 * 1) They are useful to introduce custom dataTypes (see ajax/jsonp.js for an example) 8859 * 2) These are called: 8860 * - BEFORE asking for a transport 8861 * - AFTER param serialization (s.data is a string if s.processData is true) 8862 * 3) key is the dataType 8863 * 4) the catchall symbol "*" can be used 8864 * 5) execution will start with transport dataType and THEN continue down to "*" if needed 8865 */ 8866 prefilters = {}, 8867 8868 /* Transports bindings 8869 * 1) key is the dataType 8870 * 2) the catchall symbol "*" can be used 8871 * 3) selection will start with transport dataType and THEN go to "*" if needed 8872 */ 8873 transports = {}, 8874 8875 // Avoid comment-prolog char sequence (trac-10098); must appease lint and evade compression 8876 allTypes = "*/".concat( "*" ), 8877 8878 // Anchor tag for parsing the document origin 8879 originAnchor = document.createElement( "a" ); 8880 8881originAnchor.href = location.href; 8882 8883// Base "constructor" for jQuery.ajaxPrefilter and jQuery.ajaxTransport 8884function addToPrefiltersOrTransports( structure ) { 8885 8886 // dataTypeExpression is optional and defaults to "*" 8887 return function( dataTypeExpression, func ) { 8888 8889 if ( typeof dataTypeExpression !== "string" ) { 8890 func = dataTypeExpression; 8891 dataTypeExpression = "*"; 8892 } 8893 8894 var dataType, 8895 i = 0, 8896 dataTypes = dataTypeExpression.toLowerCase().match( rnothtmlwhite ) || []; 8897 8898 if ( isFunction( func ) ) { 8899 8900 // For each dataType in the dataTypeExpression 8901 while ( ( dataType = dataTypes[ i++ ] ) ) { 8902 8903 // Prepend if requested 8904 if ( dataType[ 0 ] === "+" ) { 8905 dataType = dataType.slice( 1 ) || "*"; 8906 ( structure[ dataType ] = structure[ dataType ] || [] ).unshift( func ); 8907 8908 // Otherwise append 8909 } else { 8910 ( structure[ dataType ] = structure[ dataType ] || [] ).push( func ); 8911 } 8912 } 8913 } 8914 }; 8915} 8916 8917// Base inspection function for prefilters and transports 8918function inspectPrefiltersOrTransports( structure, options, originalOptions, jqXHR ) { 8919 8920 var inspected = {}, 8921 seekingTransport = ( structure === transports ); 8922 8923 function inspect( dataType ) { 8924 var selected; 8925 inspected[ dataType ] = true; 8926 jQuery.each( structure[ dataType ] || [], function( _, prefilterOrFactory ) { 8927 var dataTypeOrTransport = prefilterOrFactory( options, originalOptions, jqXHR ); 8928 if ( typeof dataTypeOrTransport === "string" && 8929 !seekingTransport && !inspected[ dataTypeOrTransport ] ) { 8930 8931 options.dataTypes.unshift( dataTypeOrTransport ); 8932 inspect( dataTypeOrTransport ); 8933 return false; 8934 } else if ( seekingTransport ) { 8935 return !( selected = dataTypeOrTransport ); 8936 } 8937 } ); 8938 return selected; 8939 } 8940 8941 return inspect( options.dataTypes[ 0 ] ) || !inspected[ "*" ] && inspect( "*" ); 8942} 8943 8944// A special extend for ajax options 8945// that takes "flat" options (not to be deep extended) 8946// Fixes trac-9887 8947function ajaxExtend( target, src ) { 8948 var key, deep, 8949 flatOptions = jQuery.ajaxSettings.flatOptions || {}; 8950 8951 for ( key in src ) { 8952 if ( src[ key ] !== undefined ) { 8953 ( flatOptions[ key ] ? target : ( deep || ( deep = {} ) ) )[ key ] = src[ key ]; 8954 } 8955 } 8956 if ( deep ) { 8957 jQuery.extend( true, target, deep ); 8958 } 8959 8960 return target; 8961} 8962 8963/* Handles responses to an ajax request: 8964 * - finds the right dataType (mediates between content-type and expected dataType) 8965 * - returns the corresponding response 8966 */ 8967function ajaxHandleResponses( s, jqXHR, responses ) { 8968 8969 var ct, type, finalDataType, firstDataType, 8970 contents = s.contents, 8971 dataTypes = s.dataTypes; 8972 8973 // Remove auto dataType and get content-type in the process 8974 while ( dataTypes[ 0 ] === "*" ) { 8975 dataTypes.shift(); 8976 if ( ct === undefined ) { 8977 ct = s.mimeType || jqXHR.getResponseHeader( "Content-Type" ); 8978 } 8979 } 8980 8981 // Check if we're dealing with a known content-type 8982 if ( ct ) { 8983 for ( type in contents ) { 8984 if ( contents[ type ] && contents[ type ].test( ct ) ) { 8985 dataTypes.unshift( type ); 8986 break; 8987 } 8988 } 8989 } 8990 8991 // Check to see if we have a response for the expected dataType 8992 if ( dataTypes[ 0 ] in responses ) { 8993 finalDataType = dataTypes[ 0 ]; 8994 } else { 8995 8996 // Try convertible dataTypes 8997 for ( type in responses ) { 8998 if ( !dataTypes[ 0 ] || s.converters[ type + " " + dataTypes[ 0 ] ] ) { 8999 finalDataType = type; 9000 break; 9001 } 9002 if ( !firstDataType ) { 9003 firstDataType = type; 9004 } 9005 } 9006 9007 // Or just use first one 9008 finalDataType = finalDataType || firstDataType; 9009 } 9010 9011 // If we found a dataType 9012 // We add the dataType to the list if needed 9013 // and return the corresponding response 9014 if ( finalDataType ) { 9015 if ( finalDataType !== dataTypes[ 0 ] ) { 9016 dataTypes.unshift( finalDataType ); 9017 } 9018 return responses[ finalDataType ]; 9019 } 9020} 9021 9022/* Chain conversions given the request and the original response 9023 * Also sets the responseXXX fields on the jqXHR instance 9024 */ 9025function ajaxConvert( s, response, jqXHR, isSuccess ) { 9026 var conv2, current, conv, tmp, prev, 9027 converters = {}, 9028 9029 // Work with a copy of dataTypes in case we need to modify it for conversion 9030 dataTypes = s.dataTypes.slice(); 9031 9032 // Create converters map with lowercased keys 9033 if ( dataTypes[ 1 ] ) { 9034 for ( conv in s.converters ) { 9035 converters[ conv.toLowerCase() ] = s.converters[ conv ]; 9036 } 9037 } 9038 9039 current = dataTypes.shift(); 9040 9041 // Convert to each sequential dataType 9042 while ( current ) { 9043 9044 if ( s.responseFields[ current ] ) { 9045 jqXHR[ s.responseFields[ current ] ] = response; 9046 } 9047 9048 // Apply the dataFilter if provided 9049 if ( !prev && isSuccess && s.dataFilter ) { 9050 response = s.dataFilter( response, s.dataType ); 9051 } 9052 9053 prev = current; 9054 current = dataTypes.shift(); 9055 9056 if ( current ) { 9057 9058 // There's only work to do if current dataType is non-auto 9059 if ( current === "*" ) { 9060 9061 current = prev; 9062 9063 // Convert response if prev dataType is non-auto and differs from current 9064 } else if ( prev !== "*" && prev !== current ) { 9065 9066 // Seek a direct converter 9067 conv = converters[ prev + " " + current ] || converters[ "* " + current ]; 9068 9069 // If none found, seek a pair 9070 if ( !conv ) { 9071 for ( conv2 in converters ) { 9072 9073 // If conv2 outputs current 9074 tmp = conv2.split( " " ); 9075 if ( tmp[ 1 ] === current ) { 9076 9077 // If prev can be converted to accepted input 9078 conv = converters[ prev + " " + tmp[ 0 ] ] || 9079 converters[ "* " + tmp[ 0 ] ]; 9080 if ( conv ) { 9081 9082 // Condense equivalence converters 9083 if ( conv === true ) { 9084 conv = converters[ conv2 ]; 9085 9086 // Otherwise, insert the intermediate dataType 9087 } else if ( converters[ conv2 ] !== true ) { 9088 current = tmp[ 0 ]; 9089 dataTypes.unshift( tmp[ 1 ] ); 9090 } 9091 break; 9092 } 9093 } 9094 } 9095 } 9096 9097 // Apply converter (if not an equivalence) 9098 if ( conv !== true ) { 9099 9100 // Unless errors are allowed to bubble, catch and return them 9101 if ( conv && s.throws ) { 9102 response = conv( response ); 9103 } else { 9104 try { 9105 response = conv( response ); 9106 } catch ( e ) { 9107 return { 9108 state: "parsererror", 9109 error: conv ? e : "No conversion from " + prev + " to " + current 9110 }; 9111 } 9112 } 9113 } 9114 } 9115 } 9116 } 9117 9118 return { state: "success", data: response }; 9119} 9120 9121jQuery.extend( { 9122 9123 // Counter for holding the number of active queries 9124 active: 0, 9125 9126 // Last-Modified header cache for next request 9127 lastModified: {}, 9128 etag: {}, 9129 9130 ajaxSettings: { 9131 url: location.href, 9132 type: "GET", 9133 isLocal: rlocalProtocol.test( location.protocol ), 9134 global: true, 9135 processData: true, 9136 async: true, 9137 contentType: "application/x-www-form-urlencoded; charset=UTF-8", 9138 9139 /* 9140 timeout: 0, 9141 data: null, 9142 dataType: null, 9143 username: null, 9144 password: null, 9145 cache: null, 9146 throws: false, 9147 traditional: false, 9148 headers: {}, 9149 */ 9150 9151 accepts: { 9152 "*": allTypes, 9153 text: "text/plain", 9154 html: "text/html", 9155 xml: "application/xml, text/xml", 9156 json: "application/json, text/javascript" 9157 }, 9158 9159 contents: { 9160 xml: /\bxml\b/, 9161 html: /\bhtml/, 9162 json: /\bjson\b/ 9163 }, 9164 9165 responseFields: { 9166 xml: "responseXML", 9167 text: "responseText", 9168 json: "responseJSON" 9169 }, 9170 9171 // Data converters 9172 // Keys separate source (or catchall "*") and destination types with a single space 9173 converters: { 9174 9175 // Convert anything to text 9176 "* text": String, 9177 9178 // Text to html (true = no transformation) 9179 "text html": true, 9180 9181 // Evaluate text as a json expression 9182 "text json": JSON.parse, 9183 9184 // Parse text as xml 9185 "text xml": jQuery.parseXML 9186 }, 9187 9188 // For options that shouldn't be deep extended: 9189 // you can add your own custom options here if 9190 // and when you create one that shouldn't be 9191 // deep extended (see ajaxExtend) 9192 flatOptions: { 9193 url: true, 9194 context: true 9195 } 9196 }, 9197 9198 // Creates a full fledged settings object into target 9199 // with both ajaxSettings and settings fields. 9200 // If target is omitted, writes into ajaxSettings. 9201 ajaxSetup: function( target, settings ) { 9202 return settings ? 9203 9204 // Building a settings object 9205 ajaxExtend( ajaxExtend( target, jQuery.ajaxSettings ), settings ) : 9206 9207 // Extending ajaxSettings 9208 ajaxExtend( jQuery.ajaxSettings, target ); 9209 }, 9210 9211 ajaxPrefilter: addToPrefiltersOrTransports( prefilters ), 9212 ajaxTransport: addToPrefiltersOrTransports( transports ), 9213 9214 // Main method 9215 ajax: function( url, options ) { 9216 9217 // If url is an object, simulate pre-1.5 signature 9218 if ( typeof url === "object" ) { 9219 options = url; 9220 url = undefined; 9221 } 9222 9223 // Force options to be an object 9224 options = options || {}; 9225 9226 var transport, 9227 9228 // URL without anti-cache param 9229 cacheURL, 9230 9231 // Response headers 9232 responseHeadersString, 9233 responseHeaders, 9234 9235 // timeout handle 9236 timeoutTimer, 9237 9238 // Url cleanup var 9239 urlAnchor, 9240 9241 // Request state (becomes false upon send and true upon completion) 9242 completed, 9243 9244 // To know if global events are to be dispatched 9245 fireGlobals, 9246 9247 // Loop variable 9248 i, 9249 9250 // uncached part of the url 9251 uncached, 9252 9253 // Create the final options object 9254 s = jQuery.ajaxSetup( {}, options ), 9255 9256 // Callbacks context 9257 callbackContext = s.context || s, 9258 9259 // Context for global events is callbackContext if it is a DOM node or jQuery collection 9260 globalEventContext = s.context && 9261 ( callbackContext.nodeType || callbackContext.jquery ) ? 9262 jQuery( callbackContext ) : 9263 jQuery.event, 9264 9265 // Deferreds 9266 deferred = jQuery.Deferred(), 9267 completeDeferred = jQuery.Callbacks( "once memory" ), 9268 9269 // Status-dependent callbacks 9270 statusCode = s.statusCode || {}, 9271 9272 // Headers (they are sent all at once) 9273 requestHeaders = {}, 9274 requestHeadersNames = {}, 9275 9276 // Default abort message 9277 strAbort = "canceled", 9278 9279 // Fake xhr 9280 jqXHR = { 9281 readyState: 0, 9282 9283 // Builds headers hashtable if needed 9284 getResponseHeader: function( key ) { 9285 var match; 9286 if ( completed ) { 9287 if ( !responseHeaders ) { 9288 responseHeaders = {}; 9289 while ( ( match = rheaders.exec( responseHeadersString ) ) ) { 9290 responseHeaders[ match[ 1 ].toLowerCase() + " " ] = 9291 ( responseHeaders[ match[ 1 ].toLowerCase() + " " ] || [] ) 9292 .concat( match[ 2 ] ); 9293 } 9294 } 9295 match = responseHeaders[ key.toLowerCase() + " " ]; 9296 } 9297 return match == null ? null : match.join( ", " ); 9298 }, 9299 9300 // Raw string 9301 getAllResponseHeaders: function() { 9302 return completed ? responseHeadersString : null; 9303 }, 9304 9305 // Caches the header 9306 setRequestHeader: function( name, value ) { 9307 if ( completed == null ) { 9308 name = requestHeadersNames[ name.toLowerCase() ] = 9309 requestHeadersNames[ name.toLowerCase() ] || name; 9310 requestHeaders[ name ] = value; 9311 } 9312 return this; 9313 }, 9314 9315 // Overrides response content-type header 9316 overrideMimeType: function( type ) { 9317 if ( completed == null ) { 9318 s.mimeType = type; 9319 } 9320 return this; 9321 }, 9322 9323 // Status-dependent callbacks 9324 statusCode: function( map ) { 9325 var code; 9326 if ( map ) { 9327 if ( completed ) { 9328 9329 // Execute the appropriate callbacks 9330 jqXHR.always( map[ jqXHR.status ] ); 9331 } else { 9332 9333 // Lazy-add the new callbacks in a way that preserves old ones 9334 for ( code in map ) { 9335 statusCode[ code ] = [ statusCode[ code ], map[ code ] ]; 9336 } 9337 } 9338 } 9339 return this; 9340 }, 9341 9342 // Cancel the request 9343 abort: function( statusText ) { 9344 var finalText = statusText || strAbort; 9345 if ( transport ) { 9346 transport.abort( finalText ); 9347 } 9348 done( 0, finalText ); 9349 return this; 9350 } 9351 }; 9352 9353 // Attach deferreds 9354 deferred.promise( jqXHR ); 9355 9356 // Add protocol if not provided (prefilters might expect it) 9357 // Handle falsy url in the settings object (trac-10093: consistency with old signature) 9358 // We also use the url parameter if available 9359 s.url = ( ( url || s.url || location.href ) + "" ) 9360 .replace( rprotocol, location.protocol + "//" ); 9361 9362 // Alias method option to type as per ticket trac-12004 9363 s.type = options.method || options.type || s.method || s.type; 9364 9365 // Extract dataTypes list 9366 s.dataTypes = ( s.dataType || "*" ).toLowerCase().match( rnothtmlwhite ) || [ "" ]; 9367 9368 // A cross-domain request is in order when the origin doesn't match the current origin. 9369 if ( s.crossDomain == null ) { 9370 urlAnchor = document.createElement( "a" ); 9371 9372 // Support: IE <=8 - 11, Edge 12 - 15 9373 // IE throws exception on accessing the href property if url is malformed, 9374 // e.g. http://example.com:80x/ 9375 try { 9376 urlAnchor.href = s.url; 9377 9378 // Support: IE <=8 - 11 only 9379 // Anchor's host property isn't correctly set when s.url is relative 9380 urlAnchor.href = urlAnchor.href; 9381 s.crossDomain = originAnchor.protocol + "//" + originAnchor.host !== 9382 urlAnchor.protocol + "//" + urlAnchor.host; 9383 } catch ( e ) { 9384 9385 // If there is an error parsing the URL, assume it is crossDomain, 9386 // it can be rejected by the transport if it is invalid 9387 s.crossDomain = true; 9388 } 9389 } 9390 9391 // Convert data if not already a string 9392 if ( s.data && s.processData && typeof s.data !== "string" ) { 9393 s.data = jQuery.param( s.data, s.traditional ); 9394 } 9395 9396 // Apply prefilters 9397 inspectPrefiltersOrTransports( prefilters, s, options, jqXHR ); 9398 9399 // If request was aborted inside a prefilter, stop there 9400 if ( completed ) { 9401 return jqXHR; 9402 } 9403 9404 // We can fire global events as of now if asked to 9405 // Don't fire events if jQuery.event is undefined in an AMD-usage scenario (trac-15118) 9406 fireGlobals = jQuery.event && s.global; 9407 9408 // Watch for a new set of requests 9409 if ( fireGlobals && jQuery.active++ === 0 ) { 9410 jQuery.event.trigger( "ajaxStart" ); 9411 } 9412 9413 // Uppercase the type 9414 s.type = s.type.toUpperCase(); 9415 9416 // Determine if request has content 9417 s.hasContent = !rnoContent.test( s.type ); 9418 9419 // Save the URL in case we're toying with the If-Modified-Since 9420 // and/or If-None-Match header later on 9421 // Remove hash to simplify url manipulation 9422 cacheURL = s.url.replace( rhash, "" ); 9423 9424 // More options handling for requests with no content 9425 if ( !s.hasContent ) { 9426 9427 // Remember the hash so we can put it back 9428 uncached = s.url.slice( cacheURL.length ); 9429 9430 // If data is available and should be processed, append data to url 9431 if ( s.data && ( s.processData || typeof s.data === "string" ) ) { 9432 cacheURL += ( rquery.test( cacheURL ) ? "&" : "?" ) + s.data; 9433 9434 // trac-9682: remove data so that it's not used in an eventual retry 9435 delete s.data; 9436 } 9437 9438 // Add or update anti-cache param if needed 9439 if ( s.cache === false ) { 9440 cacheURL = cacheURL.replace( rantiCache, "$1" ); 9441 uncached = ( rquery.test( cacheURL ) ? "&" : "?" ) + "_=" + ( nonce.guid++ ) + 9442 uncached; 9443 } 9444 9445 // Put hash and anti-cache on the URL that will be requested (gh-1732) 9446 s.url = cacheURL + uncached; 9447 9448 // Change '%20' to '+' if this is encoded form body content (gh-2658) 9449 } else if ( s.data && s.processData && 9450 ( s.contentType || "" ).indexOf( "application/x-www-form-urlencoded" ) === 0 ) { 9451 s.data = s.data.replace( r20, "+" ); 9452 } 9453 9454 // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode. 9455 if ( s.ifModified ) { 9456 if ( jQuery.lastModified[ cacheURL ] ) { 9457 jqXHR.setRequestHeader( "If-Modified-Since", jQuery.lastModified[ cacheURL ] ); 9458 } 9459 if ( jQuery.etag[ cacheURL ] ) { 9460 jqXHR.setRequestHeader( "If-None-Match", jQuery.etag[ cacheURL ] ); 9461 } 9462 } 9463 9464 // Set the correct header, if data is being sent 9465 if ( s.data && s.hasContent && s.contentType !== false || options.contentType ) { 9466 jqXHR.setRequestHeader( "Content-Type", s.contentType ); 9467 } 9468 9469 // Set the Accepts header for the server, depending on the dataType 9470 jqXHR.setRequestHeader( 9471 "Accept", 9472 s.dataTypes[ 0 ] && s.accepts[ s.dataTypes[ 0 ] ] ? 9473 s.accepts[ s.dataTypes[ 0 ] ] + 9474 ( s.dataTypes[ 0 ] !== "*" ? ", " + allTypes + "; q=0.01" : "" ) : 9475 s.accepts[ "*" ] 9476 ); 9477 9478 // Check for headers option 9479 for ( i in s.headers ) { 9480 jqXHR.setRequestHeader( i, s.headers[ i ] ); 9481 } 9482 9483 // Allow custom headers/mimetypes and early abort 9484 if ( s.beforeSend && 9485 ( s.beforeSend.call( callbackContext, jqXHR, s ) === false || completed ) ) { 9486 9487 // Abort if not done already and return 9488 return jqXHR.abort(); 9489 } 9490 9491 // Aborting is no longer a cancellation 9492 strAbort = "abort"; 9493 9494 // Install callbacks on deferreds 9495 completeDeferred.add( s.complete ); 9496 jqXHR.done( s.success ); 9497 jqXHR.fail( s.error ); 9498 9499 // Get transport 9500 transport = inspectPrefiltersOrTransports( transports, s, options, jqXHR ); 9501 9502 // If no transport, we auto-abort 9503 if ( !transport ) { 9504 done( -1, "No Transport" ); 9505 } else { 9506 jqXHR.readyState = 1; 9507 9508 // Send global event 9509 if ( fireGlobals ) { 9510 globalEventContext.trigger( "ajaxSend", [ jqXHR, s ] ); 9511 } 9512 9513 // If request was aborted inside ajaxSend, stop there 9514 if ( completed ) { 9515 return jqXHR; 9516 } 9517 9518 // Timeout 9519 if ( s.async && s.timeout > 0 ) { 9520 timeoutTimer = window.setTimeout( function() { 9521 jqXHR.abort( "timeout" ); 9522 }, s.timeout ); 9523 } 9524 9525 try { 9526 completed = false; 9527 transport.send( requestHeaders, done ); 9528 } catch ( e ) { 9529 9530 // Rethrow post-completion exceptions 9531 if ( completed ) { 9532 throw e; 9533 } 9534 9535 // Propagate others as results 9536 done( -1, e ); 9537 } 9538 } 9539 9540 // Callback for when everything is done 9541 function done( status, nativeStatusText, responses, headers ) { 9542 var isSuccess, success, error, response, modified, 9543 statusText = nativeStatusText; 9544 9545 // Ignore repeat invocations 9546 if ( completed ) { 9547 return; 9548 } 9549 9550 completed = true; 9551 9552 // Clear timeout if it exists 9553 if ( timeoutTimer ) { 9554 window.clearTimeout( timeoutTimer ); 9555 } 9556 9557 // Dereference transport for early garbage collection 9558 // (no matter how long the jqXHR object will be used) 9559 transport = undefined; 9560 9561 // Cache response headers 9562 responseHeadersString = headers || ""; 9563 9564 // Set readyState 9565 jqXHR.readyState = status > 0 ? 4 : 0; 9566 9567 // Determine if successful 9568 isSuccess = status >= 200 && status < 300 || status === 304; 9569 9570 // Get response data 9571 if ( responses ) { 9572 response = ajaxHandleResponses( s, jqXHR, responses ); 9573 } 9574 9575 // Use a noop converter for missing script but not if jsonp 9576 if ( !isSuccess && 9577 jQuery.inArray( "script", s.dataTypes ) > -1 && 9578 jQuery.inArray( "json", s.dataTypes ) < 0 ) { 9579 s.converters[ "text script" ] = function() {}; 9580 } 9581 9582 // Convert no matter what (that way responseXXX fields are always set) 9583 response = ajaxConvert( s, response, jqXHR, isSuccess ); 9584 9585 // If successful, handle type chaining 9586 if ( isSuccess ) { 9587 9588 // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode. 9589 if ( s.ifModified ) { 9590 modified = jqXHR.getResponseHeader( "Last-Modified" ); 9591 if ( modified ) { 9592 jQuery.lastModified[ cacheURL ] = modified; 9593 } 9594 modified = jqXHR.getResponseHeader( "etag" ); 9595 if ( modified ) { 9596 jQuery.etag[ cacheURL ] = modified; 9597 } 9598 } 9599 9600 // if no content 9601 if ( status === 204 || s.type === "HEAD" ) { 9602 statusText = "nocontent"; 9603 9604 // if not modified 9605 } else if ( status === 304 ) { 9606 statusText = "notmodified"; 9607 9608 // If we have data, let's convert it 9609 } else { 9610 statusText = response.state; 9611 success = response.data; 9612 error = response.error; 9613 isSuccess = !error; 9614 } 9615 } else { 9616 9617 // Extract error from statusText and normalize for non-aborts 9618 error = statusText; 9619 if ( status || !statusText ) { 9620 statusText = "error"; 9621 if ( status < 0 ) { 9622 status = 0; 9623 } 9624 } 9625 } 9626 9627 // Set data for the fake xhr object 9628 jqXHR.status = status; 9629 jqXHR.statusText = ( nativeStatusText || statusText ) + ""; 9630 9631 // Success/Error 9632 if ( isSuccess ) { 9633 deferred.resolveWith( callbackContext, [ success, statusText, jqXHR ] ); 9634 } else { 9635 deferred.rejectWith( callbackContext, [ jqXHR, statusText, error ] ); 9636 } 9637 9638 // Status-dependent callbacks 9639 jqXHR.statusCode( statusCode ); 9640 statusCode = undefined; 9641 9642 if ( fireGlobals ) { 9643 globalEventContext.trigger( isSuccess ? "ajaxSuccess" : "ajaxError", 9644 [ jqXHR, s, isSuccess ? success : error ] ); 9645 } 9646 9647 // Complete 9648 completeDeferred.fireWith( callbackContext, [ jqXHR, statusText ] ); 9649 9650 if ( fireGlobals ) { 9651 globalEventContext.trigger( "ajaxComplete", [ jqXHR, s ] ); 9652 9653 // Handle the global AJAX counter 9654 if ( !( --jQuery.active ) ) { 9655 jQuery.event.trigger( "ajaxStop" ); 9656 } 9657 } 9658 } 9659 9660 return jqXHR; 9661 }, 9662 9663 getJSON: function( url, data, callback ) { 9664 return jQuery.get( url, data, callback, "json" ); 9665 }, 9666 9667 getScript: function( url, callback ) { 9668 return jQuery.get( url, undefined, callback, "script" ); 9669 } 9670} ); 9671 9672jQuery.each( [ "get", "post" ], function( _i, method ) { 9673 jQuery[ method ] = function( url, data, callback, type ) { 9674 9675 // Shift arguments if data argument was omitted 9676 if ( isFunction( data ) ) { 9677 type = type || callback; 9678 callback = data; 9679 data = undefined; 9680 } 9681 9682 // The url can be an options object (which then must have .url) 9683 return jQuery.ajax( jQuery.extend( { 9684 url: url, 9685 type: method, 9686 dataType: type, 9687 data: data, 9688 success: callback 9689 }, jQuery.isPlainObject( url ) && url ) ); 9690 }; 9691} ); 9692 9693jQuery.ajaxPrefilter( function( s ) { 9694 var i; 9695 for ( i in s.headers ) { 9696 if ( i.toLowerCase() === "content-type" ) { 9697 s.contentType = s.headers[ i ] || ""; 9698 } 9699 } 9700} ); 9701 9702 9703jQuery._evalUrl = function( url, options, doc ) { 9704 return jQuery.ajax( { 9705 url: url, 9706 9707 // Make this explicit, since user can override this through ajaxSetup (trac-11264) 9708 type: "GET", 9709 dataType: "script", 9710 cache: true, 9711 async: false, 9712 global: false, 9713 9714 // Only evaluate the response if it is successful (gh-4126) 9715 // dataFilter is not invoked for failure responses, so using it instead 9716 // of the default converter is kludgy but it works. 9717 converters: { 9718 "text script": function() {} 9719 }, 9720 dataFilter: function( response ) { 9721 jQuery.globalEval( response, options, doc ); 9722 } 9723 } ); 9724}; 9725 9726 9727jQuery.fn.extend( { 9728 wrapAll: function( html ) { 9729 var wrap; 9730 9731 if ( this[ 0 ] ) { 9732 if ( isFunction( html ) ) { 9733 html = html.call( this[ 0 ] ); 9734 } 9735 9736 // The elements to wrap the target around 9737 wrap = jQuery( html, this[ 0 ].ownerDocument ).eq( 0 ).clone( true ); 9738 9739 if ( this[ 0 ].parentNode ) { 9740 wrap.insertBefore( this[ 0 ] ); 9741 } 9742 9743 wrap.map( function() { 9744 var elem = this; 9745 9746 while ( elem.firstElementChild ) { 9747 elem = elem.firstElementChild; 9748 } 9749 9750 return elem; 9751 } ).append( this ); 9752 } 9753 9754 return this; 9755 }, 9756 9757 wrapInner: function( html ) { 9758 if ( isFunction( html ) ) { 9759 return this.each( function( i ) { 9760 jQuery( this ).wrapInner( html.call( this, i ) ); 9761 } ); 9762 } 9763 9764 return this.each( function() { 9765 var self = jQuery( this ), 9766 contents = self.contents(); 9767 9768 if ( contents.length ) { 9769 contents.wrapAll( html ); 9770 9771 } else { 9772 self.append( html ); 9773 } 9774 } ); 9775 }, 9776 9777 wrap: function( html ) { 9778 var htmlIsFunction = isFunction( html ); 9779 9780 return this.each( function( i ) { 9781 jQuery( this ).wrapAll( htmlIsFunction ? html.call( this, i ) : html ); 9782 } ); 9783 }, 9784 9785 unwrap: function( selector ) { 9786 this.parent( selector ).not( "body" ).each( function() { 9787 jQuery( this ).replaceWith( this.childNodes ); 9788 } ); 9789 return this; 9790 } 9791} ); 9792 9793 9794jQuery.expr.pseudos.hidden = function( elem ) { 9795 return !jQuery.expr.pseudos.visible( elem ); 9796}; 9797jQuery.expr.pseudos.visible = function( elem ) { 9798 return !!( elem.offsetWidth || elem.offsetHeight || elem.getClientRects().length ); 9799}; 9800 9801 9802 9803 9804jQuery.ajaxSettings.xhr = function() { 9805 try { 9806 return new window.XMLHttpRequest(); 9807 } catch ( e ) {} 9808}; 9809 9810var xhrSuccessStatus = { 9811 9812 // File protocol always yields status code 0, assume 200 9813 0: 200, 9814 9815 // Support: IE <=9 only 9816 // trac-1450: sometimes IE returns 1223 when it should be 204 9817 1223: 204 9818 }, 9819 xhrSupported = jQuery.ajaxSettings.xhr(); 9820 9821support.cors = !!xhrSupported && ( "withCredentials" in xhrSupported ); 9822support.ajax = xhrSupported = !!xhrSupported; 9823 9824jQuery.ajaxTransport( function( options ) { 9825 var callback, errorCallback; 9826 9827 // Cross domain only allowed if supported through XMLHttpRequest 9828 if ( support.cors || xhrSupported && !options.crossDomain ) { 9829 return { 9830 send: function( headers, complete ) { 9831 var i, 9832 xhr = options.xhr(); 9833 9834 xhr.open( 9835 options.type, 9836 options.url, 9837 options.async, 9838 options.username, 9839 options.password 9840 ); 9841 9842 // Apply custom fields if provided 9843 if ( options.xhrFields ) { 9844 for ( i in options.xhrFields ) { 9845 xhr[ i ] = options.xhrFields[ i ]; 9846 } 9847 } 9848 9849 // Override mime type if needed 9850 if ( options.mimeType && xhr.overrideMimeType ) { 9851 xhr.overrideMimeType( options.mimeType ); 9852 } 9853 9854 // X-Requested-With header 9855 // For cross-domain requests, seeing as conditions for a preflight are 9856 // akin to a jigsaw puzzle, we simply never set it to be sure. 9857 // (it can always be set on a per-request basis or even using ajaxSetup) 9858 // For same-domain requests, won't change header if already provided. 9859 if ( !options.crossDomain && !headers[ "X-Requested-With" ] ) { 9860 headers[ "X-Requested-With" ] = "XMLHttpRequest"; 9861 } 9862 9863 // Set headers 9864 for ( i in headers ) { 9865 xhr.setRequestHeader( i, headers[ i ] ); 9866 } 9867 9868 // Callback 9869 callback = function( type ) { 9870 return function() { 9871 if ( callback ) { 9872 callback = errorCallback = xhr.onload = 9873 xhr.onerror = xhr.onabort = xhr.ontimeout = 9874 xhr.onreadystatechange = null; 9875 9876 if ( type === "abort" ) { 9877 xhr.abort(); 9878 } else if ( type === "error" ) { 9879 9880 // Support: IE <=9 only 9881 // On a manual native abort, IE9 throws 9882 // errors on any property access that is not readyState 9883 if ( typeof xhr.status !== "number" ) { 9884 complete( 0, "error" ); 9885 } else { 9886 complete( 9887 9888 // File: protocol always yields status 0; see trac-8605, trac-14207 9889 xhr.status, 9890 xhr.statusText 9891 ); 9892 } 9893 } else { 9894 complete( 9895 xhrSuccessStatus[ xhr.status ] || xhr.status, 9896 xhr.statusText, 9897 9898 // Support: IE <=9 only 9899 // IE9 has no XHR2 but throws on binary (trac-11426) 9900 // For XHR2 non-text, let the caller handle it (gh-2498) 9901 ( xhr.responseType || "text" ) !== "text" || 9902 typeof xhr.responseText !== "string" ? 9903 { binary: xhr.response } : 9904 { text: xhr.responseText }, 9905 xhr.getAllResponseHeaders() 9906 ); 9907 } 9908 } 9909 }; 9910 }; 9911 9912 // Listen to events 9913 xhr.onload = callback(); 9914 errorCallback = xhr.onerror = xhr.ontimeout = callback( "error" ); 9915 9916 // Support: IE 9 only 9917 // Use onreadystatechange to replace onabort 9918 // to handle uncaught aborts 9919 if ( xhr.onabort !== undefined ) { 9920 xhr.onabort = errorCallback; 9921 } else { 9922 xhr.onreadystatechange = function() { 9923 9924 // Check readyState before timeout as it changes 9925 if ( xhr.readyState === 4 ) { 9926 9927 // Allow onerror to be called first, 9928 // but that will not handle a native abort 9929 // Also, save errorCallback to a variable 9930 // as xhr.onerror cannot be accessed 9931 window.setTimeout( function() { 9932 if ( callback ) { 9933 errorCallback(); 9934 } 9935 } ); 9936 } 9937 }; 9938 } 9939 9940 // Create the abort callback 9941 callback = callback( "abort" ); 9942 9943 try { 9944 9945 // Do send the request (this may raise an exception) 9946 xhr.send( options.hasContent && options.data || null ); 9947 } catch ( e ) { 9948 9949 // trac-14683: Only rethrow if this hasn't been notified as an error yet 9950 if ( callback ) { 9951 throw e; 9952 } 9953 } 9954 }, 9955 9956 abort: function() { 9957 if ( callback ) { 9958 callback(); 9959 } 9960 } 9961 }; 9962 } 9963} ); 9964 9965 9966 9967 9968// Prevent auto-execution of scripts when no explicit dataType was provided (See gh-2432) 9969jQuery.ajaxPrefilter( function( s ) { 9970 if ( s.crossDomain ) { 9971 s.contents.script = false; 9972 } 9973} ); 9974 9975// Install script dataType 9976jQuery.ajaxSetup( { 9977 accepts: { 9978 script: "text/javascript, application/javascript, " + 9979 "application/ecmascript, application/x-ecmascript" 9980 }, 9981 contents: { 9982 script: /\b(?:java|ecma)script\b/ 9983 }, 9984 converters: { 9985 "text script": function( text ) { 9986 jQuery.globalEval( text ); 9987 return text; 9988 } 9989 } 9990} ); 9991 9992// Handle cache's special case and crossDomain 9993jQuery.ajaxPrefilter( "script", function( s ) { 9994 if ( s.cache === undefined ) { 9995 s.cache = false; 9996 } 9997 if ( s.crossDomain ) { 9998 s.type = "GET"; 9999 } 10000} ); 10001 10002// Bind script tag hack transport 10003jQuery.ajaxTransport( "script", function( s ) { 10004 10005 // This transport only deals with cross domain or forced-by-attrs requests 10006 if ( s.crossDomain || s.scriptAttrs ) { 10007 var script, callback; 10008 return { 10009 send: function( _, complete ) { 10010 script = jQuery( "<script>" ) 10011 .attr( s.scriptAttrs || {} ) 10012 .prop( { charset: s.scriptCharset, src: s.url } ) 10013 .on( "load error", callback = function( evt ) { 10014 script.remove(); 10015 callback = null; 10016 if ( evt ) { 10017 complete( evt.type === "error" ? 404 : 200, evt.type ); 10018 } 10019 } ); 10020 10021 // Use native DOM manipulation to avoid our domManip AJAX trickery 10022 document.head.appendChild( script[ 0 ] ); 10023 }, 10024 abort: function() { 10025 if ( callback ) { 10026 callback(); 10027 } 10028 } 10029 }; 10030 } 10031} ); 10032 10033 10034 10035 10036var oldCallbacks = [], 10037 rjsonp = /(=)\?(?=&|$)|\?\?/; 10038 10039// Default jsonp settings 10040jQuery.ajaxSetup( { 10041 jsonp: "callback", 10042 jsonpCallback: function() { 10043 var callback = oldCallbacks.pop() || ( jQuery.expando + "_" + ( nonce.guid++ ) ); 10044 this[ callback ] = true; 10045 return callback; 10046 } 10047} ); 10048 10049// Detect, normalize options and install callbacks for jsonp requests 10050jQuery.ajaxPrefilter( "json jsonp", function( s, originalSettings, jqXHR ) { 10051 10052 var callbackName, overwritten, responseContainer, 10053 jsonProp = s.jsonp !== false && ( rjsonp.test( s.url ) ? 10054 "url" : 10055 typeof s.data === "string" && 10056 ( s.contentType || "" ) 10057 .indexOf( "application/x-www-form-urlencoded" ) === 0 && 10058 rjsonp.test( s.data ) && "data" 10059 ); 10060 10061 // Handle iff the expected data type is "jsonp" or we have a parameter to set 10062 if ( jsonProp || s.dataTypes[ 0 ] === "jsonp" ) { 10063 10064 // Get callback name, remembering preexisting value associated with it 10065 callbackName = s.jsonpCallback = isFunction( s.jsonpCallback ) ? 10066 s.jsonpCallback() : 10067 s.jsonpCallback; 10068 10069 // Insert callback into url or form data 10070 if ( jsonProp ) { 10071 s[ jsonProp ] = s[ jsonProp ].replace( rjsonp, "$1" + callbackName ); 10072 } else if ( s.jsonp !== false ) { 10073 s.url += ( rquery.test( s.url ) ? "&" : "?" ) + s.jsonp + "=" + callbackName; 10074 } 10075 10076 // Use data converter to retrieve json after script execution
vendor: 8,362 bytes, lines 10077-10388
10077 s.converters[ "script json" ] = function() { 10078 if ( !responseContainer ) { 10079 jQuery.error( callbackName + " was not called" ); 10080 } 10081 return responseContainer[ 0 ]; 10082 }; 10083 10084 // Force json dataType 10085 s.dataTypes[ 0 ] = "json"; 10086 10087 // Install callback 10088 overwritten = window[ callbackName ]; 10089 window[ callbackName ] = function() { 10090 responseContainer = arguments; 10091 }; 10092 10093 // Clean-up function (fires after converters) 10094 jqXHR.always( function() { 10095 10096 // If previous value didn't exist - remove it 10097 if ( overwritten === undefined ) { 10098 jQuery( window ).removeProp( callbackName ); 10099 10100 // Otherwise restore preexisting value 10101 } else { 10102 window[ callbackName ] = overwritten; 10103 } 10104 10105 // Save back as free 10106 if ( s[ callbackName ] ) { 10107 10108 // Make sure that re-using the options doesn't screw things around 10109 s.jsonpCallback = originalSettings.jsonpCallback; 10110 10111 // Save the callback name for future use 10112 oldCallbacks.push( callbackName ); 10113 } 10114 10115 // Call if it was a function and we have a response 10116 if ( responseContainer && isFunction( overwritten ) ) { 10117 overwritten( responseContainer[ 0 ] ); 10118 } 10119 10120 responseContainer = overwritten = undefined; 10121 } ); 10122 10123 // Delegate to script 10124 return "script"; 10125 } 10126} ); 10127 10128 10129 10130 10131// Support: Safari 8 only 10132// In Safari 8 documents created via document.implementation.createHTMLDocument 10133// collapse sibling forms: the second one becomes a child of the first one. 10134// Because of that, this security measure has to be disabled in Safari 8. 10135// https://bugs.webkit.org/show_bug.cgi?id=137337 10136support.createHTMLDocument = ( function() { 10137 var body = document.implementation.createHTMLDocument( "" ).body; 10138 body.innerHTML = "<form></form><form></form>"; 10139 return body.childNodes.length === 2; 10140} )(); 10141 10142 10143// Argument "data" should be string of html 10144// context (optional): If specified, the fragment will be created in this context, 10145// defaults to document 10146// keepScripts (optional): If true, will include scripts passed in the html string 10147jQuery.parseHTML = function( data, context, keepScripts ) { 10148 if ( typeof data !== "string" ) { 10149 return []; 10150 } 10151 if ( typeof context === "boolean" ) { 10152 keepScripts = context; 10153 context = false; 10154 } 10155 10156 var base, parsed, scripts; 10157 10158 if ( !context ) { 10159 10160 // Stop scripts or inline event handlers from being executed immediately 10161 // by using document.implementation 10162 if ( support.createHTMLDocument ) { 10163 context = document.implementation.createHTMLDocument( "" ); 10164 10165 // Set the base href for the created document 10166 // so any parsed elements with URLs 10167 // are based on the document's URL (gh-2965) 10168 base = context.createElement( "base" ); 10169 base.href = document.location.href; 10170 context.head.appendChild( base ); 10171 } else { 10172 context = document; 10173 } 10174 } 10175 10176 parsed = rsingleTag.exec( data ); 10177 scripts = !keepScripts && []; 10178 10179 // Single tag 10180 if ( parsed ) { 10181 return [ context.createElement( parsed[ 1 ] ) ]; 10182 } 10183 10184 parsed = buildFragment( [ data ], context, scripts ); 10185 10186 if ( scripts && scripts.length ) { 10187 jQuery( scripts ).remove(); 10188 } 10189 10190 return jQuery.merge( [], parsed.childNodes ); 10191}; 10192 10193 10194/** 10195 * Load a url into a page 10196 */ 10197jQuery.fn.load = function( url, params, callback ) { 10198 var selector, type, response, 10199 self = this, 10200 off = url.indexOf( " " ); 10201 10202 if ( off > -1 ) { 10203 selector = stripAndCollapse( url.slice( off ) ); 10204 url = url.slice( 0, off ); 10205 } 10206 10207 // If it's a function 10208 if ( isFunction( params ) ) { 10209 10210 // We assume that it's the callback 10211 callback = params; 10212 params = undefined; 10213 10214 // Otherwise, build a param string 10215 } else if ( params && typeof params === "object" ) { 10216 type = "POST"; 10217 } 10218 10219 // If we have elements to modify, make the request 10220 if ( self.length > 0 ) { 10221 jQuery.ajax( { 10222 url: url, 10223 10224 // If "type" variable is undefined, then "GET" method will be used. 10225 // Make value of this field explicit since 10226 // user can override it through ajaxSetup method 10227 type: type || "GET", 10228 dataType: "html", 10229 data: params 10230 } ).done( function( responseText ) { 10231 10232 // Save response for use in complete callback 10233 response = arguments; 10234 10235 self.html( selector ? 10236 10237 // If a selector was specified, locate the right elements in a dummy div 10238 // Exclude scripts to avoid IE 'Permission Denied' errors 10239 jQuery( "<div>" ).append( jQuery.parseHTML( responseText ) ).find( selector ) : 10240 10241 // Otherwise use the full result 10242 responseText ); 10243 10244 // If the request succeeds, this function gets "data", "status", "jqXHR" 10245 // but they are ignored because response was set above. 10246 // If it fails, this function gets "jqXHR", "status", "error" 10247 } ).always( callback && function( jqXHR, status ) { 10248 self.each( function() { 10249 callback.apply( this, response || [ jqXHR.responseText, status, jqXHR ] ); 10250 } ); 10251 } ); 10252 } 10253 10254 return this; 10255}; 10256 10257 10258 10259 10260jQuery.expr.pseudos.animated = function( elem ) { 10261 return jQuery.grep( jQuery.timers, function( fn ) { 10262 return elem === fn.elem; 10263 } ).length; 10264}; 10265 10266 10267 10268 10269jQuery.offset = { 10270 setOffset: function( elem, options, i ) { 10271 var curPosition, curLeft, curCSSTop, curTop, curOffset, curCSSLeft, calculatePosition, 10272 position = jQuery.css( elem, "position" ), 10273 curElem = jQuery( elem ), 10274 props = {}; 10275 10276 // Set position first, in-case top/left are set even on static elem 10277 if ( position === "static" ) { 10278 elem.style.position = "relative"; 10279 } 10280 10281 curOffset = curElem.offset(); 10282 curCSSTop = jQuery.css( elem, "top" ); 10283 curCSSLeft = jQuery.css( elem, "left" ); 10284 calculatePosition = ( position === "absolute" || position === "fixed" ) && 10285 ( curCSSTop + curCSSLeft ).indexOf( "auto" ) > -1; 10286 10287 // Need to be able to calculate position if either 10288 // top or left is auto and position is either absolute or fixed 10289 if ( calculatePosition ) { 10290 curPosition = curElem.position(); 10291 curTop = curPosition.top; 10292 curLeft = curPosition.left; 10293 10294 } else { 10295 curTop = parseFloat( curCSSTop ) || 0; 10296 curLeft = parseFloat( curCSSLeft ) || 0; 10297 } 10298 10299 if ( isFunction( options ) ) { 10300 10301 // Use jQuery.extend here to allow modification of coordinates argument (gh-1848) 10302 options = options.call( elem, i, jQuery.extend( {}, curOffset ) ); 10303 } 10304 10305 if ( options.top != null ) { 10306 props.top = ( options.top - curOffset.top ) + curTop; 10307 } 10308 if ( options.left != null ) { 10309 props.left = ( options.left - curOffset.left ) + curLeft; 10310 } 10311 10312 if ( "using" in options ) { 10313 options.using.call( elem, props ); 10314 10315 } else { 10316 curElem.css( props ); 10317 } 10318 } 10319}; 10320 10321jQuery.fn.extend( { 10322 10323 // offset() relates an element's border box to the document origin 10324 offset: function( options ) { 10325 10326 // Preserve chaining for setter 10327 if ( arguments.length ) { 10328 return options === undefined ? 10329 this : 10330 this.each( function( i ) { 10331 jQuery.offset.setOffset( this, options, i ); 10332 } ); 10333 } 10334 10335 var rect, win, 10336 elem = this[ 0 ]; 10337 10338 if ( !elem ) { 10339 return; 10340 } 10341 10342 // Return zeros for disconnected and hidden (display: none) elements (gh-2310) 10343 // Support: IE <=11 only 10344 // Running getBoundingClientRect on a 10345 // disconnected node in IE throws an error 10346 if ( !elem.getClientRects().length ) { 10347 return { top: 0, left: 0 }; 10348 } 10349 10350 // Get document-relative position by adding viewport scroll to viewport-relative gBCR 10351 rect = elem.getBoundingClientRect(); 10352 win = elem.ownerDocument.defaultView; 10353 return { 10354 top: rect.top + win.pageYOffset, 10355 left: rect.left + win.pageXOffset 10356 }; 10357 }, 10358 10359 // position() relates an element's margin box to its offset parent's padding box 10360 // This corresponds to the behavior of CSS absolute positioning 10361 position: function() { 10362 if ( !this[ 0 ] ) { 10363 return; 10364 } 10365 10366 var offsetParent, offset, doc, 10367 elem = this[ 0 ], 10368 parentOffset = { top: 0, left: 0 }; 10369 10370 // position:fixed elements are offset from the viewport, which itself always has zero offset 10371 if ( jQuery.css( elem, "position" ) === "fixed" ) { 10372 10373 // Assume position:fixed implies availability of getBoundingClientRect 10374 offset = elem.getBoundingClientRect(); 10375 10376 } else { 10377 offset = this.offset(); 10378 10379 // Account for the *real* offset parent, which can be the document or its root element 10380 // when a statically positioned element is identified 10381 doc = elem.ownerDocument; 10382 offsetParent = elem.offsetParent || doc.documentElement; 10383 while ( offsetParent && 10384 ( offsetParent === doc.body || offsetParent === doc.documentElement ) && 10385 jQuery.css( offsetParent, "position" ) === "static" ) { 10386 10387 offsetParent = offsetParent.parentNode; 10388 }
vendor: 9,677 bytes, lines 10389-10726
10389 if ( offsetParent && offsetParent !== elem && offsetParent.nodeType === 1 ) { 10390 10391 // Incorporate borders into its offset, since they are outside its content origin 10392 parentOffset = jQuery( offsetParent ).offset(); 10393 parentOffset.top += jQuery.css( offsetParent, "borderTopWidth", true ); 10394 parentOffset.left += jQuery.css( offsetParent, "borderLeftWidth", true ); 10395 } 10396 } 10397 10398 // Subtract parent offsets and element margins 10399 return { 10400 top: offset.top - parentOffset.top - jQuery.css( elem, "marginTop", true ), 10401 left: offset.left - parentOffset.left - jQuery.css( elem, "marginLeft", true ) 10402 }; 10403 }, 10404 10405 // This method will return documentElement in the following cases: 10406 // 1) For the element inside the iframe without offsetParent, this method will return 10407 // documentElement of the parent window 10408 // 2) For the hidden or detached element 10409 // 3) For body or html element, i.e. in case of the html node - it will return itself 10410 // 10411 // but those exceptions were never presented as a real life use-cases 10412 // and might be considered as more preferable results. 10413 // 10414 // This logic, however, is not guaranteed and can change at any point in the future 10415 offsetParent: function() { 10416 return this.map( function() { 10417 var offsetParent = this.offsetParent; 10418 10419 while ( offsetParent && jQuery.css( offsetParent, "position" ) === "static" ) { 10420 offsetParent = offsetParent.offsetParent; 10421 } 10422 10423 return offsetParent || documentElement; 10424 } ); 10425 } 10426} ); 10427 10428// Create scrollLeft and scrollTop methods 10429jQuery.each( { scrollLeft: "pageXOffset", scrollTop: "pageYOffset" }, function( method, prop ) { 10430 var top = "pageYOffset" === prop; 10431 10432 jQuery.fn[ method ] = function( val ) { 10433 return access( this, function( elem, method, val ) { 10434 10435 // Coalesce documents and windows 10436 var win; 10437 if ( isWindow( elem ) ) { 10438 win = elem; 10439 } else if ( elem.nodeType === 9 ) { 10440 win = elem.defaultView; 10441 } 10442 10443 if ( val === undefined ) { 10444 return win ? win[ prop ] : elem[ method ]; 10445 } 10446 10447 if ( win ) { 10448 win.scrollTo( 10449 !top ? val : win.pageXOffset, 10450 top ? val : win.pageYOffset 10451 ); 10452 10453 } else { 10454 elem[ method ] = val; 10455 } 10456 }, method, val, arguments.length ); 10457 }; 10458} ); 10459 10460// Support: Safari <=7 - 9.1, Chrome <=37 - 49 10461// Add the top/left cssHooks using jQuery.fn.position 10462// Webkit bug: https://bugs.webkit.org/show_bug.cgi?id=29084 10463// Blink bug: https://bugs.chromium.org/p/chromium/issues/detail?id=589347 10464// getComputedStyle returns percent when specified for top/left/bottom/right; 10465// rather than make the css module depend on the offset module, just check for it here 10466jQuery.each( [ "top", "left" ], function( _i, prop ) { 10467 jQuery.cssHooks[ prop ] = addGetHookIf( support.pixelPosition, 10468 function( elem, computed ) { 10469 if ( computed ) { 10470 computed = curCSS( elem, prop ); 10471 10472 // If curCSS returns percentage, fallback to offset 10473 return rnumnonpx.test( computed ) ? 10474 jQuery( elem ).position()[ prop ] + "px" : 10475 computed; 10476 } 10477 } 10478 ); 10479} ); 10480 10481 10482// Create innerHeight, innerWidth, height, width, outerHeight and outerWidth methods 10483jQuery.each( { Height: "height", Width: "width" }, function( name, type ) { 10484 jQuery.each( { 10485 padding: "inner" + name, 10486 content: type, 10487 "": "outer" + name 10488 }, function( defaultExtra, funcName ) { 10489 10490 // Margin is only for outerHeight, outerWidth 10491 jQuery.fn[ funcName ] = function( margin, value ) { 10492 var chainable = arguments.length && ( defaultExtra || typeof margin !== "boolean" ), 10493 extra = defaultExtra || ( margin === true || value === true ? "margin" : "border" ); 10494 10495 return access( this, function( elem, type, value ) { 10496 var doc; 10497 10498 if ( isWindow( elem ) ) { 10499 10500 // $( window ).outerWidth/Height return w/h including scrollbars (gh-1729) 10501 return funcName.indexOf( "outer" ) === 0 ? 10502 elem[ "inner" + name ] : 10503 elem.document.documentElement[ "client" + name ]; 10504 } 10505 10506 // Get document width or height 10507 if ( elem.nodeType === 9 ) { 10508 doc = elem.documentElement; 10509 10510 // Either scroll[Width/Height] or offset[Width/Height] or client[Width/Height], 10511 // whichever is greatest 10512 return Math.max( 10513 elem.body[ "scroll" + name ], doc[ "scroll" + name ], 10514 elem.body[ "offset" + name ], doc[ "offset" + name ], 10515 doc[ "client" + name ] 10516 ); 10517 } 10518 10519 return value === undefined ? 10520 10521 // Get width or height on the element, requesting but not forcing parseFloat 10522 jQuery.css( elem, type, extra ) : 10523 10524 // Set width or height on the element 10525 jQuery.style( elem, type, value, extra ); 10526 }, type, chainable ? margin : undefined, chainable ); 10527 }; 10528 } ); 10529} ); 10530 10531 10532jQuery.each( [ 10533 "ajaxStart", 10534 "ajaxStop", 10535 "ajaxComplete", 10536 "ajaxError", 10537 "ajaxSuccess", 10538 "ajaxSend" 10539], function( _i, type ) { 10540 jQuery.fn[ type ] = function( fn ) { 10541 return this.on( type, fn ); 10542 }; 10543} ); 10544 10545 10546 10547 10548jQuery.fn.extend( { 10549 10550 bind: function( types, data, fn ) { 10551 return this.on( types, null, data, fn ); 10552 }, 10553 unbind: function( types, fn ) { 10554 return this.off( types, null, fn ); 10555 }, 10556 10557 delegate: function( selector, types, data, fn ) { 10558 return this.on( types, selector, data, fn ); 10559 }, 10560 undelegate: function( selector, types, fn ) { 10561 10562 // ( namespace ) or ( selector, types [, fn] ) 10563 return arguments.length === 1 ? 10564 this.off( selector, "**" ) : 10565 this.off( types, selector || "**", fn ); 10566 }, 10567 10568 hover: function( fnOver, fnOut ) { 10569 return this 10570 .on( "mouseenter", fnOver ) 10571 .on( "mouseleave", fnOut || fnOver ); 10572 } 10573} ); 10574 10575jQuery.each( 10576 ( "blur focus focusin focusout resize scroll click dblclick " + 10577 "mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave " + 10578 "change select submit keydown keypress keyup contextmenu" ).split( " " ), 10579 function( _i, name ) { 10580 10581 // Handle event binding 10582 jQuery.fn[ name ] = function( data, fn ) { 10583 return arguments.length > 0 ? 10584 this.on( name, null, data, fn ) : 10585 this.trigger( name ); 10586 }; 10587 } 10588); 10589 10590 10591 10592 10593// Support: Android <=4.0 only 10594// Make sure we trim BOM and NBSP 10595// Require that the "whitespace run" starts from a non-whitespace 10596// to avoid O(N^2) behavior when the engine would try matching "\s+$" at each space position. 10597var rtrim = /^[\s\uFEFF\xA0]+|([^\s\uFEFF\xA0])[\s\uFEFF\xA0]+$/g; 10598 10599// Bind a function to a context, optionally partially applying any 10600// arguments. 10601// jQuery.proxy is deprecated to promote standards (specifically Function#bind) 10602// However, it is not slated for removal any time soon 10603jQuery.proxy = function( fn, context ) { 10604 var tmp, args, proxy; 10605 10606 if ( typeof context === "string" ) { 10607 tmp = fn[ context ]; 10608 context = fn; 10609 fn = tmp; 10610 } 10611 10612 // Quick check to determine if target is callable, in the spec 10613 // this throws a TypeError, but we will just return undefined. 10614 if ( !isFunction( fn ) ) { 10615 return undefined; 10616 } 10617 10618 // Simulated bind 10619 args = slice.call( arguments, 2 ); 10620 proxy = function() { 10621 return fn.apply( context || this, args.concat( slice.call( arguments ) ) ); 10622 }; 10623 10624 // Set the guid of unique handler to the same of original handler, so it can be removed 10625 proxy.guid = fn.guid = fn.guid || jQuery.guid++; 10626 10627 return proxy; 10628}; 10629 10630jQuery.holdReady = function( hold ) { 10631 if ( hold ) { 10632 jQuery.readyWait++; 10633 } else { 10634 jQuery.ready( true ); 10635 } 10636}; 10637jQuery.isArray = Array.isArray; 10638jQuery.parseJSON = JSON.parse; 10639jQuery.nodeName = nodeName; 10640jQuery.isFunction = isFunction; 10641jQuery.isWindow = isWindow; 10642jQuery.camelCase = camelCase; 10643jQuery.type = toType; 10644 10645jQuery.now = Date.now; 10646 10647jQuery.isNumeric = function( obj ) { 10648 10649 // As of jQuery 3.0, isNumeric is limited to 10650 // strings and numbers (primitives or objects) 10651 // that can be coerced to finite numbers (gh-2662) 10652 var type = jQuery.type( obj ); 10653 return ( type === "number" || type === "string" ) && 10654 10655 // parseFloat NaNs numeric-cast false positives ("") 10656 // ...but misinterprets leading-number strings, particularly hex literals ("0x...") 10657 // subtraction forces infinities to NaN 10658 !isNaN( obj - parseFloat( obj ) ); 10659}; 10660 10661jQuery.trim = function( text ) { 10662 return text == null ? 10663 "" : 10664 ( text + "" ).replace( rtrim, "$1" ); 10665}; 10666 10667 10668 10669// Register as a named AMD module, since jQuery can be concatenated with other 10670// files that may use define, but not via a proper concatenation script that 10671// understands anonymous AMD modules. A named AMD is safest and most robust 10672// way to register. Lowercase jquery is used because AMD module names are 10673// derived from file names, and jQuery is normally delivered in a lowercase 10674// file name. Do this after creating the global so that if an AMD module wants 10675// to call noConflict to hide this version of jQuery, it will work. 10676 10677// Note that for maximum portability, libraries that are not jQuery should 10678// declare themselves as anonymous modules, and avoid setting a global if an 10679// AMD loader is present. jQuery is a special case. For more information, see 10680// https://github.com/jrburke/requirejs/wiki/Updating-existing-libraries#wiki-anon 10681 10682if ( true ) { 10683 !(__WEBPACK_AMD_DEFINE_ARRAY__ = [], __WEBPACK_AMD_DEFINE_RESULT__ = (function() { 10684 return jQuery; 10685 }).apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__), 10686 __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); 10687} 10688 10689 10690 10691 10692var 10693 10694 // Map over jQuery in case of overwrite 10695 _jQuery = window.jQuery, 10696 10697 // Map over the $ in case of overwrite 10698 _$ = window.$; 10699 10700jQuery.noConflict = function( deep ) { 10701 if ( window.$ === jQuery ) { 10702 window.$ = _$; 10703 } 10704 10705 if ( deep && window.jQuery === jQuery ) { 10706 window.jQuery = _jQuery; 10707 } 10708 10709 return jQuery; 10710}; 10711 10712// Expose jQuery and $ identifiers, even in AMD 10713// (trac-7102#comment:10, https://github.com/jquery/jquery/pull/557) 10714// and CommonJS for browser emulators (trac-13566) 10715if ( typeof noGlobal === "undefined" ) { 10716 window.jQuery = window.$ = jQuery; 10717} 10718 10719 10720 10721 10722return jQuery; 10723} ); 10724 10725 10726/***/ }
vendor: 3,722 bytes, lines 10726-10823
10726) 10727 10728/******/ }); 10729/************************************************************************/ 10730/******/ // The module cache 10731/******/ var __webpack_module_cache__ = {}; 10732/******/ 10733/******/ // The require function 10734/******/ function __webpack_require__(moduleId) { 10735/******/ // Check if module is in cache 10736/******/ var cachedModule = __webpack_module_cache__[moduleId]; 10737/******/ if (cachedModule !== undefined) { 10738/******/ return cachedModule.exports; 10739/******/ } 10740/******/ // Create a new module (and put it into the cache) 10741/******/ var module = __webpack_module_cache__[moduleId] = { 10742/******/ // no module.id needed 10743/******/ // no module.loaded needed 10744/******/ exports: {} 10745/******/ }; 10746/******/ 10747/******/ // Execute the module function 10748/******/ __webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__); 10749/******/ 10750/******/ // Return the exports of the module 10751/******/ return module.exports; 10752/******/ } 10753/******/ 10754/************************************************************************/ 10755/******/ /* webpack/runtime/compat get default export */ 10756/******/ (() => { 10757/******/ // getDefaultExport function for compatibility with non-harmony modules 10758/******/ __webpack_require__.n = (module) => { 10759/******/ var getter = module && module.__esModule ? 10760/******/ () => (module['default']) : 10761/******/ () => (module); 10762/******/ __webpack_require__.d(getter, { a: getter }); 10763/******/ return getter; 10764/******/ }; 10765/******/ })(); 10766/******/ 10767/******/ /* webpack/runtime/define property getters */ 10768/******/ (() => { 10769/******/ // define getter functions for harmony exports 10770/******/ __webpack_require__.d = (exports, definition) => { 10771/******/ for(var key in definition) { 10772/******/ if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) { 10773/******/ Object.defineProperty(exports, key, { enumerable: true, get: definition[key] }); 10774/******/ } 10775/******/ } 10776/******/ }; 10777/******/ })(); 10778/******/ 10779/******/ /* webpack/runtime/hasOwnProperty shorthand */ 10780/******/ (() => { 10781/******/ __webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop)) 10782/******/ })(); 10783/******/ 10784/******/ /* webpack/runtime/make namespace object */ 10785/******/ (() => { 10786/******/ // define __esModule on exports 10787/******/ __webpack_require__.r = (exports) => { 10788/******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) { 10789/******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); 10790/******/ } 10791/******/ Object.defineProperty(exports, '__esModule', { value: true }); 10792/******/ }; 10793/******/ })(); 10794/******/ 10795/******/ /* webpack/runtime/publicPath */ 10796/******/ (() => { 10797/******/ __webpack_require__.p = "/haiku_app/build/"; 10798/******/ })(); 10799/******/ 10800/************************************************************************/ 10801var __webpack_exports__ = {}; 10802// This entry need to be wrapped in an IIFE because it need to be in strict mode. 10803(() => { 10804"use strict"; 10805 10806// NAMESPACE OBJECT: ./node_modules/@popperjs/core/lib/index.js 10807var lib_namespaceObject = {}; 10808__webpack_require__.r(lib_namespaceObject); 10809__webpack_require__.d(lib_namespaceObject, { 10810 afterMain: () => (afterMain), 10811 afterRead: () => (afterRead), 10812 afterWrite: () => (afterWrite), 10813 applyStyles: () => (modifiers_applyStyles), 10814 arrow: () => (modifiers_arrow), 10815 auto: () => (auto), 10816 basePlacements: () => (basePlacements), 10817 beforeMain: () => (beforeMain), 10818 beforeRead: () => (beforeRead), 10819 beforeWrite: () => (beforeWrite), 10820 bottom: () => (bottom), 10821 clippingParents: () => (clippingParents), 10822 computeStyles: () => (modifiers_computeStyles), 10823 createPopper: () => (popper_createPopper),
vendor: 4,183 bytes, lines 10824-10945
10824 createPopperBase: () => (createPopper), 10825 createPopperLite: () => (popper_lite_createPopper), 10826 detectOverflow: () => (detectOverflow), 10827 end: () => (end), 10828 eventListeners: () => (eventListeners), 10829 flip: () => (modifiers_flip), 10830 hide: () => (modifiers_hide), 10831 left: () => (left), 10832 main: () => (main), 10833 modifierPhases: () => (modifierPhases), 10834 offset: () => (modifiers_offset), 10835 placements: () => (enums_placements), 10836 popper: () => (popper), 10837 popperGenerator: () => (popperGenerator), 10838 popperOffsets: () => (modifiers_popperOffsets), 10839 preventOverflow: () => (modifiers_preventOverflow), 10840 read: () => (read), 10841 reference: () => (reference), 10842 right: () => (right), 10843 start: () => (start), 10844 top: () => (enums_top), 10845 variationPlacements: () => (variationPlacements), 10846 viewport: () => (viewport), 10847 write: () => (write) 10848}); 10849 10850// EXTERNAL MODULE: ./node_modules/jquery/dist/jquery.js 10851var jquery = __webpack_require__(755); 10852var jquery_default = /*#__PURE__*/__webpack_require__.n(jquery); 10853;// CONCATENATED MODULE: ./node_modules/@popperjs/core/lib/enums.js 10854var enums_top = 'top'; 10855var bottom = 'bottom'; 10856var right = 'right'; 10857var left = 'left'; 10858var auto = 'auto'; 10859var basePlacements = [enums_top, bottom, right, left]; 10860var start = 'start'; 10861var end = 'end'; 10862var clippingParents = 'clippingParents'; 10863var viewport = 'viewport'; 10864var popper = 'popper'; 10865var reference = 'reference'; 10866var variationPlacements = /*#__PURE__*/basePlacements.reduce(function (acc, placement) { 10867 return acc.concat([placement + "-" + start, placement + "-" + end]); 10868}, []); 10869var enums_placements = /*#__PURE__*/[].concat(basePlacements, [auto]).reduce(function (acc, placement) { 10870 return acc.concat([placement, placement + "-" + start, placement + "-" + end]); 10871}, []); // modifiers that need to read the DOM 10872 10873var beforeRead = 'beforeRead'; 10874var read = 'read'; 10875var afterRead = 'afterRead'; // pure-logic modifiers 10876 10877var beforeMain = 'beforeMain'; 10878var main = 'main'; 10879var afterMain = 'afterMain'; // modifier with the purpose to write to the DOM (or write into a framework state) 10880 10881var beforeWrite = 'beforeWrite'; 10882var write = 'write'; 10883var afterWrite = 'afterWrite'; 10884var modifierPhases = [beforeRead, read, afterRead, beforeMain, main, afterMain, beforeWrite, write, afterWrite]; 10885;// CONCATENATED MODULE: ./node_modules/@popperjs/core/lib/dom-utils/getNodeName.js 10886function getNodeName(element) { 10887 return element ? (element.nodeName || '').toLowerCase() : null; 10888} 10889;// CONCATENATED MODULE: ./node_modules/@popperjs/core/lib/dom-utils/getWindow.js 10890function getWindow(node) { 10891 if (node == null) { 10892 return window; 10893 } 10894 10895 if (node.toString() !== '[object Window]') { 10896 var ownerDocument = node.ownerDocument; 10897 return ownerDocument ? ownerDocument.defaultView || window : window; 10898 } 10899 10900 return node; 10901} 10902;// CONCATENATED MODULE: ./node_modules/@popperjs/core/lib/dom-utils/instanceOf.js 10903 10904 10905function isElement(node) { 10906 var OwnElement = getWindow(node).Element; 10907 return node instanceof OwnElement || node instanceof Element; 10908} 10909 10910function isHTMLElement(node) { 10911 var OwnElement = getWindow(node).HTMLElement; 10912 return node instanceof OwnElement || node instanceof HTMLElement; 10913} 10914 10915function isShadowRoot(node) { 10916 // IE 11 has no ShadowRoot 10917 if (typeof ShadowRoot === 'undefined') { 10918 return false; 10919 } 10920 10921 var OwnElement = getWindow(node).ShadowRoot; 10922 return node instanceof OwnElement || node instanceof ShadowRoot; 10923} 10924 10925 10926;// CONCATENATED MODULE: ./node_modules/@popperjs/core/lib/modifiers/applyStyles.js 10927 10928 // This modifier takes the styles prepared by the `computeStyles` modifier 10929// and applies them to the HTMLElements such as popper and arrow 10930 10931function applyStyles(_ref) { 10932 var state = _ref.state; 10933 Object.keys(state.elements).forEach(function (name) { 10934 var style = state.styles[name] || {}; 10935 var attributes = state.attributes[name] || {}; 10936 var element = state.elements[name]; // arrow is optional + virtual elements 10937 10938 if (!isHTMLElement(element) || !getNodeName(element)) { 10939 return; 10940 } // Flow doesn't support to extend this property, but it's the most 10941 // effective way to apply styles to an HTMLElement 10942 // $FlowFixMe[cannot-write] 10943 10944 10945 Object.assign(element.style, style);
vendor: 5,345 bytes, lines 10946-11127
10946 Object.keys(attributes).forEach(function (name) { 10947 var value = attributes[name]; 10948 10949 if (value === false) { 10950 element.removeAttribute(name); 10951 } else { 10952 element.setAttribute(name, value === true ? '' : value); 10953 } 10954 }); 10955 }); 10956} 10957 10958function effect(_ref2) { 10959 var state = _ref2.state; 10960 var initialStyles = { 10961 popper: { 10962 position: state.options.strategy, 10963 left: '0', 10964 top: '0', 10965 margin: '0' 10966 }, 10967 arrow: { 10968 position: 'absolute' 10969 }, 10970 reference: {} 10971 }; 10972 Object.assign(state.elements.popper.style, initialStyles.popper); 10973 state.styles = initialStyles; 10974 10975 if (state.elements.arrow) { 10976 Object.assign(state.elements.arrow.style, initialStyles.arrow); 10977 } 10978 10979 return function () { 10980 Object.keys(state.elements).forEach(function (name) { 10981 var element = state.elements[name]; 10982 var attributes = state.attributes[name] || {}; 10983 var styleProperties = Object.keys(state.styles.hasOwnProperty(name) ? state.styles[name] : initialStyles[name]); // Set all values to an empty string to unset them 10984 10985 var style = styleProperties.reduce(function (style, property) { 10986 style[property] = ''; 10987 return style; 10988 }, {}); // arrow is optional + virtual elements 10989 10990 if (!isHTMLElement(element) || !getNodeName(element)) { 10991 return; 10992 } 10993 10994 Object.assign(element.style, style); 10995 Object.keys(attributes).forEach(function (attribute) { 10996 element.removeAttribute(attribute); 10997 }); 10998 }); 10999 }; 11000} // eslint-disable-next-line import/no-unused-modules 11001 11002 11003/* harmony default export */ const modifiers_applyStyles = ({ 11004 name: 'applyStyles', 11005 enabled: true, 11006 phase: 'write', 11007 fn: applyStyles, 11008 effect: effect, 11009 requires: ['computeStyles'] 11010}); 11011;// CONCATENATED MODULE: ./node_modules/@popperjs/core/lib/utils/getBasePlacement.js 11012 11013function getBasePlacement(placement) { 11014 return placement.split('-')[0]; 11015} 11016;// CONCATENATED MODULE: ./node_modules/@popperjs/core/lib/utils/math.js 11017var math_max = Math.max; 11018var math_min = Math.min; 11019var round = Math.round; 11020;// CONCATENATED MODULE: ./node_modules/@popperjs/core/lib/utils/userAgent.js 11021function getUAString() { 11022 var uaData = navigator.userAgentData; 11023 11024 if (uaData != null && uaData.brands && Array.isArray(uaData.brands)) { 11025 return uaData.brands.map(function (item) { 11026 return item.brand + "/" + item.version; 11027 }).join(' '); 11028 } 11029 11030 return navigator.userAgent; 11031} 11032;// CONCATENATED MODULE: ./node_modules/@popperjs/core/lib/dom-utils/isLayoutViewport.js 11033 11034function isLayoutViewport() { 11035 return !/^((?!chrome|android).)*safari/i.test(getUAString()); 11036} 11037;// CONCATENATED MODULE: ./node_modules/@popperjs/core/lib/dom-utils/getBoundingClientRect.js 11038 11039 11040 11041 11042function getBoundingClientRect(element, includeScale, isFixedStrategy) { 11043 if (includeScale === void 0) { 11044 includeScale = false; 11045 } 11046 11047 if (isFixedStrategy === void 0) { 11048 isFixedStrategy = false; 11049 } 11050 11051 var clientRect = element.getBoundingClientRect(); 11052 var scaleX = 1; 11053 var scaleY = 1; 11054 11055 if (includeScale && isHTMLElement(element)) { 11056 scaleX = element.offsetWidth > 0 ? round(clientRect.width) / element.offsetWidth || 1 : 1; 11057 scaleY = element.offsetHeight > 0 ? round(clientRect.height) / element.offsetHeight || 1 : 1; 11058 } 11059 11060 var _ref = isElement(element) ? getWindow(element) : window, 11061 visualViewport = _ref.visualViewport; 11062 11063 var addVisualOffsets = !isLayoutViewport() && isFixedStrategy; 11064 var x = (clientRect.left + (addVisualOffsets && visualViewport ? visualViewport.offsetLeft : 0)) / scaleX; 11065 var y = (clientRect.top + (addVisualOffsets && visualViewport ? visualViewport.offsetTop : 0)) / scaleY; 11066 var width = clientRect.width / scaleX; 11067 var height = clientRect.height / scaleY; 11068 return { 11069 width: width, 11070 height: height, 11071 top: y, 11072 right: x + width, 11073 bottom: y + height, 11074 left: x, 11075 x: x, 11076 y: y 11077 }; 11078} 11079;// CONCATENATED MODULE: ./node_modules/@popperjs/core/lib/dom-utils/getLayoutRect.js 11080 // Returns the layout rect of an element relative to its offsetParent. Layout 11081// means it doesn't take into account transforms. 11082 11083function getLayoutRect(element) { 11084 var clientRect = getBoundingClientRect(element); // Use the clientRect sizes if it's not been transformed. 11085 // Fixes https://github.com/popperjs/popper-core/issues/1223 11086 11087 var width = element.offsetWidth; 11088 var height = element.offsetHeight; 11089 11090 if (Math.abs(clientRect.width - width) <= 1) { 11091 width = clientRect.width; 11092 } 11093 11094 if (Math.abs(clientRect.height - height) <= 1) { 11095 height = clientRect.height; 11096 } 11097 11098 return { 11099 x: element.offsetLeft, 11100 y: element.offsetTop, 11101 width: width, 11102 height: height 11103 }; 11104} 11105;// CONCATENATED MODULE: ./node_modules/@popperjs/core/lib/dom-utils/contains.js 11106 11107function contains(parent, child) { 11108 var rootNode = child.getRootNode && child.getRootNode(); // First, attempt with faster native method 11109 11110 if (parent.contains(child)) { 11111 return true; 11112 } // then fallback to custom implementation with Shadow DOM support 11113 else if (rootNode && isShadowRoot(rootNode)) { 11114 var next = child; 11115 11116 do { 11117 if (next && parent.isSameNode(next)) { 11118 return true; 11119 } // $FlowFixMe[prop-missing]: need a better way to handle this... 11120 11121 11122 next = next.parentNode || next.host; 11123 } while (next); 11124 } // Give up, the result is false 11125 11126 11127 return false;
vendor: 4,171 bytes, lines 11128-11242
11128} 11129;// CONCATENATED MODULE: ./node_modules/@popperjs/core/lib/dom-utils/getComputedStyle.js 11130 11131function getComputedStyle_getComputedStyle(element) { 11132 return getWindow(element).getComputedStyle(element); 11133} 11134;// CONCATENATED MODULE: ./node_modules/@popperjs/core/lib/dom-utils/isTableElement.js 11135 11136function isTableElement(element) { 11137 return ['table', 'td', 'th'].indexOf(getNodeName(element)) >= 0; 11138} 11139;// CONCATENATED MODULE: ./node_modules/@popperjs/core/lib/dom-utils/getDocumentElement.js 11140 11141function getDocumentElement(element) { 11142 // $FlowFixMe[incompatible-return]: assume body is always available 11143 return ((isElement(element) ? element.ownerDocument : // $FlowFixMe[prop-missing] 11144 element.document) || window.document).documentElement; 11145} 11146;// CONCATENATED MODULE: ./node_modules/@popperjs/core/lib/dom-utils/getParentNode.js 11147 11148 11149 11150function getParentNode(element) { 11151 if (getNodeName(element) === 'html') { 11152 return element; 11153 } 11154 11155 return (// this is a quicker (but less type safe) way to save quite some bytes from the bundle 11156 // $FlowFixMe[incompatible-return] 11157 // $FlowFixMe[prop-missing] 11158 element.assignedSlot || // step into the shadow DOM of the parent of a slotted node 11159 element.parentNode || ( // DOM Element detected 11160 isShadowRoot(element) ? element.host : null) || // ShadowRoot detected 11161 // $FlowFixMe[incompatible-call]: HTMLElement is a Node 11162 getDocumentElement(element) // fallback 11163 11164 ); 11165} 11166;// CONCATENATED MODULE: ./node_modules/@popperjs/core/lib/dom-utils/getOffsetParent.js 11167 11168 11169 11170 11171 11172 11173 11174 11175function getTrueOffsetParent(element) { 11176 if (!isHTMLElement(element) || // https://github.com/popperjs/popper-core/issues/837 11177 getComputedStyle_getComputedStyle(element).position === 'fixed') { 11178 return null; 11179 } 11180 11181 return element.offsetParent; 11182} // `.offsetParent` reports `null` for fixed elements, while absolute elements 11183// return the containing block 11184 11185 11186function getContainingBlock(element) { 11187 var isFirefox = /firefox/i.test(getUAString()); 11188 var isIE = /Trident/i.test(getUAString()); 11189 11190 if (isIE && isHTMLElement(element)) { 11191 // In IE 9, 10 and 11 fixed elements containing block is always established by the viewport 11192 var elementCss = getComputedStyle_getComputedStyle(element); 11193 11194 if (elementCss.position === 'fixed') { 11195 return null; 11196 } 11197 } 11198 11199 var currentNode = getParentNode(element); 11200 11201 if (isShadowRoot(currentNode)) { 11202 currentNode = currentNode.host; 11203 } 11204 11205 while (isHTMLElement(currentNode) && ['html', 'body'].indexOf(getNodeName(currentNode)) < 0) { 11206 var css = getComputedStyle_getComputedStyle(currentNode); // This is non-exhaustive but covers the most common CSS properties that 11207 // create a containing block. 11208 // https://developer.mozilla.org/en-US/docs/Web/CSS/Containing_block#identifying_the_containing_block 11209 11210 if (css.transform !== 'none' || css.perspective !== 'none' || css.contain === 'paint' || ['transform', 'perspective'].indexOf(css.willChange) !== -1 || isFirefox && css.willChange === 'filter' || isFirefox && css.filter && css.filter !== 'none') { 11211 return currentNode; 11212 } else { 11213 currentNode = currentNode.parentNode; 11214 } 11215 } 11216 11217 return null; 11218} // Gets the closest ancestor positioned element. Handles some edge cases, 11219// such as table ancestors and cross browser bugs. 11220 11221 11222function getOffsetParent(element) { 11223 var window = getWindow(element); 11224 var offsetParent = getTrueOffsetParent(element); 11225 11226 while (offsetParent && isTableElement(offsetParent) && getComputedStyle_getComputedStyle(offsetParent).position === 'static') { 11227 offsetParent = getTrueOffsetParent(offsetParent); 11228 } 11229 11230 if (offsetParent && (getNodeName(offsetParent) === 'html' || getNodeName(offsetParent) === 'body' && getComputedStyle_getComputedStyle(offsetParent).position === 'static')) { 11231 return window; 11232 } 11233 11234 return offsetParent || getContainingBlock(element) || window; 11235} 11236;// CONCATENATED MODULE: ./node_modules/@popperjs/core/lib/utils/getMainAxisFromPlacement.js 11237function getMainAxisFromPlacement(placement) { 11238 return ['top', 'bottom'].indexOf(placement) >= 0 ? 'x' : 'y'; 11239} 11240;// CONCATENATED MODULE: ./node_modules/@popperjs/core/lib/utils/within.js 11241 11242function within(min, value, max) {
vendor: 12,803 bytes, lines 11243-11647
11243 return math_max(min, math_min(value, max)); 11244} 11245function withinMaxClamp(min, value, max) { 11246 var v = within(min, value, max); 11247 return v > max ? max : v; 11248} 11249;// CONCATENATED MODULE: ./node_modules/@popperjs/core/lib/utils/getFreshSideObject.js 11250function getFreshSideObject() { 11251 return { 11252 top: 0, 11253 right: 0, 11254 bottom: 0, 11255 left: 0 11256 }; 11257} 11258;// CONCATENATED MODULE: ./node_modules/@popperjs/core/lib/utils/mergePaddingObject.js 11259 11260function mergePaddingObject(paddingObject) { 11261 return Object.assign({}, getFreshSideObject(), paddingObject); 11262} 11263;// CONCATENATED MODULE: ./node_modules/@popperjs/core/lib/utils/expandToHashMap.js 11264function expandToHashMap(value, keys) { 11265 return keys.reduce(function (hashMap, key) { 11266 hashMap[key] = value; 11267 return hashMap; 11268 }, {}); 11269} 11270;// CONCATENATED MODULE: ./node_modules/@popperjs/core/lib/modifiers/arrow.js 11271 11272 11273 11274 11275 11276 11277 11278 11279 // eslint-disable-next-line import/no-unused-modules 11280 11281var toPaddingObject = function toPaddingObject(padding, state) { 11282 padding = typeof padding === 'function' ? padding(Object.assign({}, state.rects, { 11283 placement: state.placement 11284 })) : padding; 11285 return mergePaddingObject(typeof padding !== 'number' ? padding : expandToHashMap(padding, basePlacements)); 11286}; 11287 11288function arrow(_ref) { 11289 var _state$modifiersData$; 11290 11291 var state = _ref.state, 11292 name = _ref.name, 11293 options = _ref.options; 11294 var arrowElement = state.elements.arrow; 11295 var popperOffsets = state.modifiersData.popperOffsets; 11296 var basePlacement = getBasePlacement(state.placement); 11297 var axis = getMainAxisFromPlacement(basePlacement); 11298 var isVertical = [left, right].indexOf(basePlacement) >= 0; 11299 var len = isVertical ? 'height' : 'width'; 11300 11301 if (!arrowElement || !popperOffsets) { 11302 return; 11303 } 11304 11305 var paddingObject = toPaddingObject(options.padding, state); 11306 var arrowRect = getLayoutRect(arrowElement); 11307 var minProp = axis === 'y' ? enums_top : left; 11308 var maxProp = axis === 'y' ? bottom : right; 11309 var endDiff = state.rects.reference[len] + state.rects.reference[axis] - popperOffsets[axis] - state.rects.popper[len]; 11310 var startDiff = popperOffsets[axis] - state.rects.reference[axis]; 11311 var arrowOffsetParent = getOffsetParent(arrowElement); 11312 var clientSize = arrowOffsetParent ? axis === 'y' ? arrowOffsetParent.clientHeight || 0 : arrowOffsetParent.clientWidth || 0 : 0; 11313 var centerToReference = endDiff / 2 - startDiff / 2; // Make sure the arrow doesn't overflow the popper if the center point is 11314 // outside of the popper bounds 11315 11316 var min = paddingObject[minProp]; 11317 var max = clientSize - arrowRect[len] - paddingObject[maxProp]; 11318 var center = clientSize / 2 - arrowRect[len] / 2 + centerToReference; 11319 var offset = within(min, center, max); // Prevents breaking syntax highlighting... 11320 11321 var axisProp = axis; 11322 state.modifiersData[name] = (_state$modifiersData$ = {}, _state$modifiersData$[axisProp] = offset, _state$modifiersData$.centerOffset = offset - center, _state$modifiersData$); 11323} 11324 11325function arrow_effect(_ref2) { 11326 var state = _ref2.state, 11327 options = _ref2.options; 11328 var _options$element = options.element, 11329 arrowElement = _options$element === void 0 ? '[data-popper-arrow]' : _options$element; 11330 11331 if (arrowElement == null) { 11332 return; 11333 } // CSS selector 11334 11335 11336 if (typeof arrowElement === 'string') { 11337 arrowElement = state.elements.popper.querySelector(arrowElement); 11338 11339 if (!arrowElement) { 11340 return; 11341 } 11342 } 11343 11344 if (!contains(state.elements.popper, arrowElement)) { 11345 return; 11346 } 11347 11348 state.elements.arrow = arrowElement; 11349} // eslint-disable-next-line import/no-unused-modules 11350 11351 11352/* harmony default export */ const modifiers_arrow = ({ 11353 name: 'arrow', 11354 enabled: true, 11355 phase: 'main', 11356 fn: arrow, 11357 effect: arrow_effect, 11358 requires: ['popperOffsets'], 11359 requiresIfExists: ['preventOverflow'] 11360}); 11361;// CONCATENATED MODULE: ./node_modules/@popperjs/core/lib/utils/getVariation.js 11362function getVariation(placement) { 11363 return placement.split('-')[1]; 11364} 11365;// CONCATENATED MODULE: ./node_modules/@popperjs/core/lib/modifiers/computeStyles.js 11366 11367 11368 11369 11370 11371 11372 11373 // eslint-disable-next-line import/no-unused-modules 11374 11375var unsetSides = { 11376 top: 'auto', 11377 right: 'auto', 11378 bottom: 'auto', 11379 left: 'auto' 11380}; // Round the offsets to the nearest suitable subpixel based on the DPR. 11381// Zooming can change the DPR, but it seems to report a value that will 11382// cleanly divide the values into the appropriate subpixels. 11383 11384function roundOffsetsByDPR(_ref, win) { 11385 var x = _ref.x, 11386 y = _ref.y; 11387 var dpr = win.devicePixelRatio || 1; 11388 return { 11389 x: round(x * dpr) / dpr || 0, 11390 y: round(y * dpr) / dpr || 0 11391 }; 11392} 11393 11394function mapToStyles(_ref2) { 11395 var _Object$assign2; 11396 11397 var popper = _ref2.popper, 11398 popperRect = _ref2.popperRect, 11399 placement = _ref2.placement, 11400 variation = _ref2.variation, 11401 offsets = _ref2.offsets, 11402 position = _ref2.position, 11403 gpuAcceleration = _ref2.gpuAcceleration, 11404 adaptive = _ref2.adaptive, 11405 roundOffsets = _ref2.roundOffsets, 11406 isFixed = _ref2.isFixed; 11407 var _offsets$x = offsets.x, 11408 x = _offsets$x === void 0 ? 0 : _offsets$x, 11409 _offsets$y = offsets.y, 11410 y = _offsets$y === void 0 ? 0 : _offsets$y; 11411 11412 var _ref3 = typeof roundOffsets === 'function' ? roundOffsets({ 11413 x: x, 11414 y: y 11415 }) : { 11416 x: x, 11417 y: y 11418 }; 11419 11420 x = _ref3.x; 11421 y = _ref3.y; 11422 var hasX = offsets.hasOwnProperty('x'); 11423 var hasY = offsets.hasOwnProperty('y'); 11424 var sideX = left; 11425 var sideY = enums_top; 11426 var win = window; 11427 11428 if (adaptive) { 11429 var offsetParent = getOffsetParent(popper); 11430 var heightProp = 'clientHeight'; 11431 var widthProp = 'clientWidth'; 11432 11433 if (offsetParent === getWindow(popper)) { 11434 offsetParent = getDocumentElement(popper); 11435 11436 if (getComputedStyle_getComputedStyle(offsetParent).position !== 'static' && position === 'absolute') { 11437 heightProp = 'scrollHeight'; 11438 widthProp = 'scrollWidth'; 11439 } 11440 } // $FlowFixMe[incompatible-cast]: force type refinement, we compare offsetParent with window above, but Flow doesn't detect it 11441 11442 11443 offsetParent = offsetParent; 11444 11445 if (placement === enums_top || (placement === left || placement === right) && variation === end) { 11446 sideY = bottom; 11447 var offsetY = isFixed && offsetParent === win && win.visualViewport ? win.visualViewport.height : // $FlowFixMe[prop-missing] 11448 offsetParent[heightProp]; 11449 y -= offsetY - popperRect.height; 11450 y *= gpuAcceleration ? 1 : -1; 11451 } 11452 11453 if (placement === left || (placement === enums_top || placement === bottom) && variation === end) { 11454 sideX = right; 11455 var offsetX = isFixed && offsetParent === win && win.visualViewport ? win.visualViewport.width : // $FlowFixMe[prop-missing] 11456 offsetParent[widthProp]; 11457 x -= offsetX - popperRect.width; 11458 x *= gpuAcceleration ? 1 : -1; 11459 } 11460 } 11461 11462 var commonStyles = Object.assign({ 11463 position: position 11464 }, adaptive && unsetSides); 11465 11466 var _ref4 = roundOffsets === true ? roundOffsetsByDPR({ 11467 x: x, 11468 y: y 11469 }, getWindow(popper)) : { 11470 x: x, 11471 y: y 11472 }; 11473 11474 x = _ref4.x; 11475 y = _ref4.y; 11476 11477 if (gpuAcceleration) { 11478 var _Object$assign; 11479 11480 return Object.assign({}, commonStyles, (_Object$assign = {}, _Object$assign[sideY] = hasY ? '0' : '', _Object$assign[sideX] = hasX ? '0' : '', _Object$assign.transform = (win.devicePixelRatio || 1) <= 1 ? "translate(" + x + "px, " + y + "px)" : "translate3d(" + x + "px, " + y + "px, 0)", _Object$assign)); 11481 } 11482 11483 return Object.assign({}, commonStyles, (_Object$assign2 = {}, _Object$assign2[sideY] = hasY ? y + "px" : '', _Object$assign2[sideX] = hasX ? x + "px" : '', _Object$assign2.transform = '', _Object$assign2)); 11484} 11485 11486function computeStyles(_ref5) { 11487 var state = _ref5.state, 11488 options = _ref5.options; 11489 var _options$gpuAccelerat = options.gpuAcceleration, 11490 gpuAcceleration = _options$gpuAccelerat === void 0 ? true : _options$gpuAccelerat, 11491 _options$adaptive = options.adaptive, 11492 adaptive = _options$adaptive === void 0 ? true : _options$adaptive, 11493 _options$roundOffsets = options.roundOffsets, 11494 roundOffsets = _options$roundOffsets === void 0 ? true : _options$roundOffsets; 11495 var commonStyles = { 11496 placement: getBasePlacement(state.placement), 11497 variation: getVariation(state.placement), 11498 popper: state.elements.popper, 11499 popperRect: state.rects.popper, 11500 gpuAcceleration: gpuAcceleration, 11501 isFixed: state.options.strategy === 'fixed' 11502 }; 11503 11504 if (state.modifiersData.popperOffsets != null) { 11505 state.styles.popper = Object.assign({}, state.styles.popper, mapToStyles(Object.assign({}, commonStyles, { 11506 offsets: state.modifiersData.popperOffsets, 11507 position: state.options.strategy, 11508 adaptive: adaptive, 11509 roundOffsets: roundOffsets 11510 }))); 11511 } 11512 11513 if (state.modifiersData.arrow != null) { 11514 state.styles.arrow = Object.assign({}, state.styles.arrow, mapToStyles(Object.assign({}, commonStyles, { 11515 offsets: state.modifiersData.arrow, 11516 position: 'absolute', 11517 adaptive: false, 11518 roundOffsets: roundOffsets 11519 }))); 11520 } 11521 11522 state.attributes.popper = Object.assign({}, state.attributes.popper, { 11523 'data-popper-placement': state.placement 11524 }); 11525} // eslint-disable-next-line import/no-unused-modules 11526 11527 11528/* harmony default export */ const modifiers_computeStyles = ({ 11529 name: 'computeStyles', 11530 enabled: true, 11531 phase: 'beforeWrite', 11532 fn: computeStyles, 11533 data: {} 11534}); 11535;// CONCATENATED MODULE: ./node_modules/@popperjs/core/lib/modifiers/eventListeners.js 11536 // eslint-disable-next-line import/no-unused-modules 11537 11538var passive = { 11539 passive: true 11540}; 11541 11542function eventListeners_effect(_ref) { 11543 var state = _ref.state, 11544 instance = _ref.instance, 11545 options = _ref.options; 11546 var _options$scroll = options.scroll, 11547 scroll = _options$scroll === void 0 ? true : _options$scroll, 11548 _options$resize = options.resize, 11549 resize = _options$resize === void 0 ? true : _options$resize; 11550 var window = getWindow(state.elements.popper); 11551 var scrollParents = [].concat(state.scrollParents.reference, state.scrollParents.popper); 11552 11553 if (scroll) { 11554 scrollParents.forEach(function (scrollParent) { 11555 scrollParent.addEventListener('scroll', instance.update, passive); 11556 }); 11557 } 11558 11559 if (resize) { 11560 window.addEventListener('resize', instance.update, passive); 11561 } 11562 11563 return function () { 11564 if (scroll) { 11565 scrollParents.forEach(function (scrollParent) { 11566 scrollParent.removeEventListener('scroll', instance.update, passive); 11567 }); 11568 } 11569 11570 if (resize) { 11571 window.removeEventListener('resize', instance.update, passive); 11572 } 11573 }; 11574} // eslint-disable-next-line import/no-unused-modules 11575 11576 11577/* harmony default export */ const eventListeners = ({ 11578 name: 'eventListeners', 11579 enabled: true, 11580 phase: 'write', 11581 fn: function fn() {}, 11582 effect: eventListeners_effect, 11583 data: {} 11584}); 11585;// CONCATENATED MODULE: ./node_modules/@popperjs/core/lib/utils/getOppositePlacement.js 11586var hash = { 11587 left: 'right', 11588 right: 'left', 11589 bottom: 'top', 11590 top: 'bottom' 11591}; 11592function getOppositePlacement(placement) { 11593 return placement.replace(/left|right|bottom|top/g, function (matched) { 11594 return hash[matched]; 11595 }); 11596} 11597;// CONCATENATED MODULE: ./node_modules/@popperjs/core/lib/utils/getOppositeVariationPlacement.js 11598var getOppositeVariationPlacement_hash = { 11599 start: 'end', 11600 end: 'start' 11601}; 11602function getOppositeVariationPlacement(placement) { 11603 return placement.replace(/start|end/g, function (matched) { 11604 return getOppositeVariationPlacement_hash[matched]; 11605 }); 11606} 11607;// CONCATENATED MODULE: ./node_modules/@popperjs/core/lib/dom-utils/getWindowScroll.js 11608 11609function getWindowScroll(node) { 11610 var win = getWindow(node); 11611 var scrollLeft = win.pageXOffset; 11612 var scrollTop = win.pageYOffset; 11613 return { 11614 scrollLeft: scrollLeft, 11615 scrollTop: scrollTop 11616 }; 11617} 11618;// CONCATENATED MODULE: ./node_modules/@popperjs/core/lib/dom-utils/getWindowScrollBarX.js 11619 11620 11621 11622function getWindowScrollBarX(element) { 11623 // If <html> has a CSS width greater than the viewport, then this will be 11624 // incorrect for RTL. 11625 // Popper 1 is broken in this case and never had a bug report so let's assume 11626 // it's not an issue. I don't think anyone ever specifies width on <html> 11627 // anyway. 11628 // Browsers where the left scrollbar doesn't cause an issue report `0` for 11629 // this (e.g. Edge 2019, IE11, Safari) 11630 return getBoundingClientRect(getDocumentElement(element)).left + getWindowScroll(element).scrollLeft; 11631} 11632;// CONCATENATED MODULE: ./node_modules/@popperjs/core/lib/dom-utils/getViewportRect.js 11633 11634 11635 11636 11637function getViewportRect(element, strategy) { 11638 var win = getWindow(element); 11639 var html = getDocumentElement(element); 11640 var visualViewport = win.visualViewport; 11641 var width = html.clientWidth; 11642 var height = html.clientHeight; 11643 var x = 0; 11644 var y = 0; 11645 11646 if (visualViewport) { 11647 width = visualViewport.width;
vendor: 4,874 bytes, lines 11648-11796
11648 height = visualViewport.height; 11649 var layoutViewport = isLayoutViewport(); 11650 11651 if (layoutViewport || !layoutViewport && strategy === 'fixed') { 11652 x = visualViewport.offsetLeft; 11653 y = visualViewport.offsetTop; 11654 } 11655 } 11656 11657 return { 11658 width: width, 11659 height: height, 11660 x: x + getWindowScrollBarX(element), 11661 y: y 11662 }; 11663} 11664;// CONCATENATED MODULE: ./node_modules/@popperjs/core/lib/dom-utils/getDocumentRect.js 11665 11666 11667 11668 11669 // Gets the entire size of the scrollable document area, even extending outside 11670// of the `<html>` and `<body>` rect bounds if horizontally scrollable 11671 11672function getDocumentRect(element) { 11673 var _element$ownerDocumen; 11674 11675 var html = getDocumentElement(element); 11676 var winScroll = getWindowScroll(element); 11677 var body = (_element$ownerDocumen = element.ownerDocument) == null ? void 0 : _element$ownerDocumen.body; 11678 var width = math_max(html.scrollWidth, html.clientWidth, body ? body.scrollWidth : 0, body ? body.clientWidth : 0); 11679 var height = math_max(html.scrollHeight, html.clientHeight, body ? body.scrollHeight : 0, body ? body.clientHeight : 0); 11680 var x = -winScroll.scrollLeft + getWindowScrollBarX(element); 11681 var y = -winScroll.scrollTop; 11682 11683 if (getComputedStyle_getComputedStyle(body || html).direction === 'rtl') { 11684 x += math_max(html.clientWidth, body ? body.clientWidth : 0) - width; 11685 } 11686 11687 return { 11688 width: width, 11689 height: height, 11690 x: x, 11691 y: y 11692 }; 11693} 11694;// CONCATENATED MODULE: ./node_modules/@popperjs/core/lib/dom-utils/isScrollParent.js 11695 11696function isScrollParent(element) { 11697 // Firefox wants us to check `-x` and `-y` variations as well 11698 var _getComputedStyle = getComputedStyle_getComputedStyle(element), 11699 overflow = _getComputedStyle.overflow, 11700 overflowX = _getComputedStyle.overflowX, 11701 overflowY = _getComputedStyle.overflowY; 11702 11703 return /auto|scroll|overlay|hidden/.test(overflow + overflowY + overflowX); 11704} 11705;// CONCATENATED MODULE: ./node_modules/@popperjs/core/lib/dom-utils/getScrollParent.js 11706 11707 11708 11709 11710function getScrollParent(node) { 11711 if (['html', 'body', '#document'].indexOf(getNodeName(node)) >= 0) { 11712 // $FlowFixMe[incompatible-return]: assume body is always available 11713 return node.ownerDocument.body; 11714 } 11715 11716 if (isHTMLElement(node) && isScrollParent(node)) { 11717 return node; 11718 } 11719 11720 return getScrollParent(getParentNode(node)); 11721} 11722;// CONCATENATED MODULE: ./node_modules/@popperjs/core/lib/dom-utils/listScrollParents.js 11723 11724 11725 11726 11727/* 11728given a DOM element, return the list of all scroll parents, up the list of ancesors 11729until we get to the top window object. This list is what we attach scroll listeners 11730to, because if any of these parent elements scroll, we'll need to re-calculate the 11731reference element's position. 11732*/ 11733 11734function listScrollParents(element, list) { 11735 var _element$ownerDocumen; 11736 11737 if (list === void 0) { 11738 list = []; 11739 } 11740 11741 var scrollParent = getScrollParent(element); 11742 var isBody = scrollParent === ((_element$ownerDocumen = element.ownerDocument) == null ? void 0 : _element$ownerDocumen.body); 11743 var win = getWindow(scrollParent); 11744 var target = isBody ? [win].concat(win.visualViewport || [], isScrollParent(scrollParent) ? scrollParent : []) : scrollParent; 11745 var updatedList = list.concat(target); 11746 return isBody ? updatedList : // $FlowFixMe[incompatible-call]: isBody tells us target will be an HTMLElement here 11747 updatedList.concat(listScrollParents(getParentNode(target))); 11748} 11749;// CONCATENATED MODULE: ./node_modules/@popperjs/core/lib/utils/rectToClientRect.js 11750function rectToClientRect(rect) { 11751 return Object.assign({}, rect, { 11752 left: rect.x, 11753 top: rect.y, 11754 right: rect.x + rect.width, 11755 bottom: rect.y + rect.height 11756 }); 11757} 11758;// CONCATENATED MODULE: ./node_modules/@popperjs/core/lib/dom-utils/getClippingRect.js 11759 11760 11761 11762 11763 11764 11765 11766 11767 11768 11769 11770 11771 11772 11773 11774function getInnerBoundingClientRect(element, strategy) { 11775 var rect = getBoundingClientRect(element, false, strategy === 'fixed'); 11776 rect.top = rect.top + element.clientTop; 11777 rect.left = rect.left + element.clientLeft; 11778 rect.bottom = rect.top + element.clientHeight; 11779 rect.right = rect.left + element.clientWidth; 11780 rect.width = element.clientWidth; 11781 rect.height = element.clientHeight; 11782 rect.x = rect.left; 11783 rect.y = rect.top; 11784 return rect; 11785} 11786 11787function getClientRectFromMixedType(element, clippingParent, strategy) { 11788 return clippingParent === viewport ? rectToClientRect(getViewportRect(element, strategy)) : isElement(clippingParent) ? getInnerBoundingClientRect(clippingParent, strategy) : rectToClientRect(getDocumentRect(getDocumentElement(element))); 11789} // A "clipping parent" is an overflowable container with the characteristic of 11790// clipping (or hiding) overflowing elements with a position different from 11791// `initial` 11792 11793 11794function getClippingParents(element) { 11795 var clippingParents = listScrollParents(getParentNode(element)); 11796 var canEscapeClipping = ['absolute', 'fixed'].indexOf(getComputedStyle_
vendor: 7,214 bytes, lines 11796-11993
11796getComputedStyle(element).position) >= 0; 11797 var clipperElement = canEscapeClipping && isHTMLElement(element) ? getOffsetParent(element) : element; 11798 11799 if (!isElement(clipperElement)) { 11800 return []; 11801 } // $FlowFixMe[incompatible-return]: https://github.com/facebook/flow/issues/1414 11802 11803 11804 return clippingParents.filter(function (clippingParent) { 11805 return isElement(clippingParent) && contains(clippingParent, clipperElement) && getNodeName(clippingParent) !== 'body'; 11806 }); 11807} // Gets the maximum area that the element is visible in due to any number of 11808// clipping parents 11809 11810 11811function getClippingRect(element, boundary, rootBoundary, strategy) { 11812 var mainClippingParents = boundary === 'clippingParents' ? getClippingParents(element) : [].concat(boundary); 11813 var clippingParents = [].concat(mainClippingParents, [rootBoundary]); 11814 var firstClippingParent = clippingParents[0]; 11815 var clippingRect = clippingParents.reduce(function (accRect, clippingParent) { 11816 var rect = getClientRectFromMixedType(element, clippingParent, strategy); 11817 accRect.top = math_max(rect.top, accRect.top); 11818 accRect.right = math_min(rect.right, accRect.right); 11819 accRect.bottom = math_min(rect.bottom, accRect.bottom); 11820 accRect.left = math_max(rect.left, accRect.left); 11821 return accRect; 11822 }, getClientRectFromMixedType(element, firstClippingParent, strategy)); 11823 clippingRect.width = clippingRect.right - clippingRect.left; 11824 clippingRect.height = clippingRect.bottom - clippingRect.top; 11825 clippingRect.x = clippingRect.left; 11826 clippingRect.y = clippingRect.top; 11827 return clippingRect; 11828} 11829;// CONCATENATED MODULE: ./node_modules/@popperjs/core/lib/utils/computeOffsets.js 11830 11831 11832 11833 11834function computeOffsets(_ref) { 11835 var reference = _ref.reference, 11836 element = _ref.element, 11837 placement = _ref.placement; 11838 var basePlacement = placement ? getBasePlacement(placement) : null; 11839 var variation = placement ? getVariation(placement) : null; 11840 var commonX = reference.x + reference.width / 2 - element.width / 2; 11841 var commonY = reference.y + reference.height / 2 - element.height / 2; 11842 var offsets; 11843 11844 switch (basePlacement) { 11845 case enums_top: 11846 offsets = { 11847 x: commonX, 11848 y: reference.y - element.height 11849 }; 11850 break; 11851 11852 case bottom: 11853 offsets = { 11854 x: commonX, 11855 y: reference.y + reference.height 11856 }; 11857 break; 11858 11859 case right: 11860 offsets = { 11861 x: reference.x + reference.width, 11862 y: commonY 11863 }; 11864 break; 11865 11866 case left: 11867 offsets = { 11868 x: reference.x - element.width, 11869 y: commonY 11870 }; 11871 break; 11872 11873 default: 11874 offsets = { 11875 x: reference.x, 11876 y: reference.y 11877 }; 11878 } 11879 11880 var mainAxis = basePlacement ? getMainAxisFromPlacement(basePlacement) : null; 11881 11882 if (mainAxis != null) { 11883 var len = mainAxis === 'y' ? 'height' : 'width'; 11884 11885 switch (variation) { 11886 case start: 11887 offsets[mainAxis] = offsets[mainAxis] - (reference[len] / 2 - element[len] / 2); 11888 break; 11889 11890 case end: 11891 offsets[mainAxis] = offsets[mainAxis] + (reference[len] / 2 - element[len] / 2); 11892 break; 11893 11894 default: 11895 } 11896 } 11897 11898 return offsets; 11899} 11900;// CONCATENATED MODULE: ./node_modules/@popperjs/core/lib/utils/detectOverflow.js 11901 11902 11903 11904 11905 11906 11907 11908 11909 // eslint-disable-next-line import/no-unused-modules 11910 11911function detectOverflow(state, options) { 11912 if (options === void 0) { 11913 options = {}; 11914 } 11915 11916 var _options = options, 11917 _options$placement = _options.placement, 11918 placement = _options$placement === void 0 ? state.placement : _options$placement, 11919 _options$strategy = _options.strategy, 11920 strategy = _options$strategy === void 0 ? state.strategy : _options$strategy, 11921 _options$boundary = _options.boundary, 11922 boundary = _options$boundary === void 0 ? clippingParents : _options$boundary, 11923 _options$rootBoundary = _options.rootBoundary, 11924 rootBoundary = _options$rootBoundary === void 0 ? viewport : _options$rootBoundary, 11925 _options$elementConte = _options.elementContext, 11926 elementContext = _options$elementConte === void 0 ? popper : _options$elementConte, 11927 _options$altBoundary = _options.altBoundary, 11928 altBoundary = _options$altBoundary === void 0 ? false : _options$altBoundary, 11929 _options$padding = _options.padding, 11930 padding = _options$padding === void 0 ? 0 : _options$padding; 11931 var paddingObject = mergePaddingObject(typeof padding !== 'number' ? padding : expandToHashMap(padding, basePlacements)); 11932 var altContext = elementContext === popper ? reference : popper; 11933 var popperRect = state.rects.popper; 11934 var element = state.elements[altBoundary ? altContext : elementContext]; 11935 var clippingClientRect = getClippingRect(isElement(element) ? element : element.contextElement || getDocumentElement(state.elements.popper), boundary, rootBoundary, strategy); 11936 var referenceClientRect = getBoundingClientRect(state.elements.reference); 11937 var popperOffsets = computeOffsets({ 11938 reference: referenceClientRect, 11939 element: popperRect, 11940 strategy: 'absolute', 11941 placement: placement 11942 }); 11943 var popperClientRect = rectToClientRect(Object.assign({}, popperRect, popperOffsets)); 11944 var elementClientRect = elementContext === popper ? popperClientRect : referenceClientRect; // positive = overflowing the clipping rect 11945 // 0 or negative = within the clipping rect 11946 11947 var overflowOffsets = { 11948 top: clippingClientRect.top - elementClientRect.top + paddingObject.top, 11949 bottom: elementClientRect.bottom - clippingClientRect.bottom + paddingObject.bottom, 11950 left: clippingClientRect.left - elementClientRect.left + paddingObject.left, 11951 right: elementClientRect.right - clippingClientRect.right + paddingObject.right 11952 }; 11953 var offsetData = state.modifiersData.offset; // Offsets can be applied only to the popper element 11954 11955 if (elementContext === popper && offsetData) { 11956 var offset = offsetData[placement]; 11957 Object.keys(overflowOffsets).forEach(function (key) { 11958 var multiply = [right, bottom].indexOf(key) >= 0 ? 1 : -1; 11959 var axis = [enums_top, bottom].indexOf(key) >= 0 ? 'y' : 'x'; 11960 overflowOffsets[key] += offset[axis] * multiply; 11961 }); 11962 } 11963 11964 return overflowOffsets; 11965} 11966;// CONCATENATED MODULE: ./node_modules/@popperjs/core/lib/utils/computeAutoPlacement.js 11967 11968 11969 11970 11971function computeAutoPlacement(state, options) { 11972 if (options === void 0) { 11973 options = {}; 11974 } 11975 11976 var _options = options, 11977 placement = _options.placement, 11978 boundary = _options.boundary, 11979 rootBoundary = _options.rootBoundary, 11980 padding = _options.padding, 11981 flipVariations = _options.flipVariations, 11982 _options$allowedAutoP = _options.allowedAutoPlacements, 11983 allowedAutoPlacements = _options$allowedAutoP === void 0 ? enums_placements : _options$allowedAutoP; 11984 var variation = getVariation(placement); 11985 var placements = variation ? flipVariations ? variationPlacements : variationPlacements.filter(function (placement) { 11986 return getVariation(placement) === variation; 11987 }) : basePlacements; 11988 var allowedPlacements = placements.filter(function (placement) { 11989 return allowedAutoPlacements.indexOf(placement) >= 0; 11990 }); 11991 11992 if (allowedPlacements.length === 0) { 11993 allowedPlacements = placements;
vendor: 3,050 bytes, lines 11994-12076
11994 } // $FlowFixMe[incompatible-type]: Flow seems to have problems with two array unions... 11995 11996 11997 var overflows = allowedPlacements.reduce(function (acc, placement) { 11998 acc[placement] = detectOverflow(state, { 11999 placement: placement, 12000 boundary: boundary, 12001 rootBoundary: rootBoundary, 12002 padding: padding 12003 })[getBasePlacement(placement)]; 12004 return acc; 12005 }, {}); 12006 return Object.keys(overflows).sort(function (a, b) { 12007 return overflows[a] - overflows[b]; 12008 }); 12009} 12010;// CONCATENATED MODULE: ./node_modules/@popperjs/core/lib/modifiers/flip.js 12011 12012 12013 12014 12015 12016 12017 // eslint-disable-next-line import/no-unused-modules 12018 12019function getExpandedFallbackPlacements(placement) { 12020 if (getBasePlacement(placement) === auto) { 12021 return []; 12022 } 12023 12024 var oppositePlacement = getOppositePlacement(placement); 12025 return [getOppositeVariationPlacement(placement), oppositePlacement, getOppositeVariationPlacement(oppositePlacement)]; 12026} 12027 12028function flip(_ref) { 12029 var state = _ref.state, 12030 options = _ref.options, 12031 name = _ref.name; 12032 12033 if (state.modifiersData[name]._skip) { 12034 return; 12035 } 12036 12037 var _options$mainAxis = options.mainAxis, 12038 checkMainAxis = _options$mainAxis === void 0 ? true : _options$mainAxis, 12039 _options$altAxis = options.altAxis, 12040 checkAltAxis = _options$altAxis === void 0 ? true : _options$altAxis, 12041 specifiedFallbackPlacements = options.fallbackPlacements, 12042 padding = options.padding, 12043 boundary = options.boundary, 12044 rootBoundary = options.rootBoundary, 12045 altBoundary = options.altBoundary, 12046 _options$flipVariatio = options.flipVariations, 12047 flipVariations = _options$flipVariatio === void 0 ? true : _options$flipVariatio, 12048 allowedAutoPlacements = options.allowedAutoPlacements; 12049 var preferredPlacement = state.options.placement; 12050 var basePlacement = getBasePlacement(preferredPlacement); 12051 var isBasePlacement = basePlacement === preferredPlacement; 12052 var fallbackPlacements = specifiedFallbackPlacements || (isBasePlacement || !flipVariations ? [getOppositePlacement(preferredPlacement)] : getExpandedFallbackPlacements(preferredPlacement)); 12053 var placements = [preferredPlacement].concat(fallbackPlacements).reduce(function (acc, placement) { 12054 return acc.concat(getBasePlacement(placement) === auto ? computeAutoPlacement(state, { 12055 placement: placement, 12056 boundary: boundary, 12057 rootBoundary: rootBoundary, 12058 padding: padding, 12059 flipVariations: flipVariations, 12060 allowedAutoPlacements: allowedAutoPlacements 12061 }) : placement); 12062 }, []); 12063 var referenceRect = state.rects.reference; 12064 var popperRect = state.rects.popper; 12065 var checksMap = new Map(); 12066 var makeFallbackChecks = true; 12067 var firstFittingPlacement = placements[0]; 12068 12069 for (var i = 0; i < placements.length; i++) { 12070 var placement = placements[i]; 12071 12072 var _basePlacement = getBasePlacement(placement); 12073 12074 var isStartVariation = getVariation(placement) === start; 12075 var isVertical = [enums_top, bottom].indexOf(_basePlacement) >= 0; 12076 var len = isVertical ? 'width' : 'height';
vendor: 9,315 bytes, lines 12077-12386
12077 var overflow = detectOverflow(state, { 12078 placement: placement, 12079 boundary: boundary, 12080 rootBoundary: rootBoundary, 12081 altBoundary: altBoundary, 12082 padding: padding 12083 }); 12084 var mainVariationSide = isVertical ? isStartVariation ? right : left : isStartVariation ? bottom : enums_top; 12085 12086 if (referenceRect[len] > popperRect[len]) { 12087 mainVariationSide = getOppositePlacement(mainVariationSide); 12088 } 12089 12090 var altVariationSide = getOppositePlacement(mainVariationSide); 12091 var checks = []; 12092 12093 if (checkMainAxis) { 12094 checks.push(overflow[_basePlacement] <= 0); 12095 } 12096 12097 if (checkAltAxis) { 12098 checks.push(overflow[mainVariationSide] <= 0, overflow[altVariationSide] <= 0); 12099 } 12100 12101 if (checks.every(function (check) { 12102 return check; 12103 })) { 12104 firstFittingPlacement = placement; 12105 makeFallbackChecks = false; 12106 break; 12107 } 12108 12109 checksMap.set(placement, checks); 12110 } 12111 12112 if (makeFallbackChecks) { 12113 // `2` may be desired in some cases â research later 12114 var numberOfChecks = flipVariations ? 3 : 1; 12115 12116 var _loop = function _loop(_i) { 12117 var fittingPlacement = placements.find(function (placement) { 12118 var checks = checksMap.get(placement); 12119 12120 if (checks) { 12121 return checks.slice(0, _i).every(function (check) { 12122 return check; 12123 }); 12124 } 12125 }); 12126 12127 if (fittingPlacement) { 12128 firstFittingPlacement = fittingPlacement; 12129 return "break"; 12130 } 12131 }; 12132 12133 for (var _i = numberOfChecks; _i > 0; _i--) { 12134 var _ret = _loop(_i); 12135 12136 if (_ret === "break") break; 12137 } 12138 } 12139 12140 if (state.placement !== firstFittingPlacement) { 12141 state.modifiersData[name]._skip = true; 12142 state.placement = firstFittingPlacement; 12143 state.reset = true; 12144 } 12145} // eslint-disable-next-line import/no-unused-modules 12146 12147 12148/* harmony default export */ const modifiers_flip = ({ 12149 name: 'flip', 12150 enabled: true, 12151 phase: 'main', 12152 fn: flip, 12153 requiresIfExists: ['offset'], 12154 data: { 12155 _skip: false 12156 } 12157}); 12158;// CONCATENATED MODULE: ./node_modules/@popperjs/core/lib/modifiers/hide.js 12159 12160 12161 12162function getSideOffsets(overflow, rect, preventedOffsets) { 12163 if (preventedOffsets === void 0) { 12164 preventedOffsets = { 12165 x: 0, 12166 y: 0 12167 }; 12168 } 12169 12170 return { 12171 top: overflow.top - rect.height - preventedOffsets.y, 12172 right: overflow.right - rect.width + preventedOffsets.x, 12173 bottom: overflow.bottom - rect.height + preventedOffsets.y, 12174 left: overflow.left - rect.width - preventedOffsets.x 12175 }; 12176} 12177 12178function isAnySideFullyClipped(overflow) { 12179 return [enums_top, right, bottom, left].some(function (side) { 12180 return overflow[side] >= 0; 12181 }); 12182} 12183 12184function hide(_ref) { 12185 var state = _ref.state, 12186 name = _ref.name; 12187 var referenceRect = state.rects.reference; 12188 var popperRect = state.rects.popper; 12189 var preventedOffsets = state.modifiersData.preventOverflow; 12190 var referenceOverflow = detectOverflow(state, { 12191 elementContext: 'reference' 12192 }); 12193 var popperAltOverflow = detectOverflow(state, { 12194 altBoundary: true 12195 }); 12196 var referenceClippingOffsets = getSideOffsets(referenceOverflow, referenceRect); 12197 var popperEscapeOffsets = getSideOffsets(popperAltOverflow, popperRect, preventedOffsets); 12198 var isReferenceHidden = isAnySideFullyClipped(referenceClippingOffsets); 12199 var hasPopperEscaped = isAnySideFullyClipped(popperEscapeOffsets); 12200 state.modifiersData[name] = { 12201 referenceClippingOffsets: referenceClippingOffsets, 12202 popperEscapeOffsets: popperEscapeOffsets, 12203 isReferenceHidden: isReferenceHidden, 12204 hasPopperEscaped: hasPopperEscaped 12205 }; 12206 state.attributes.popper = Object.assign({}, state.attributes.popper, { 12207 'data-popper-reference-hidden': isReferenceHidden, 12208 'data-popper-escaped': hasPopperEscaped 12209 }); 12210} // eslint-disable-next-line import/no-unused-modules 12211 12212 12213/* harmony default export */ const modifiers_hide = ({ 12214 name: 'hide', 12215 enabled: true, 12216 phase: 'main', 12217 requiresIfExists: ['preventOverflow'], 12218 fn: hide 12219}); 12220;// CONCATENATED MODULE: ./node_modules/@popperjs/core/lib/modifiers/offset.js 12221 12222 // eslint-disable-next-line import/no-unused-modules 12223 12224function distanceAndSkiddingToXY(placement, rects, offset) { 12225 var basePlacement = getBasePlacement(placement); 12226 var invertDistance = [left, enums_top].indexOf(basePlacement) >= 0 ? -1 : 1; 12227 12228 var _ref = typeof offset === 'function' ? offset(Object.assign({}, rects, { 12229 placement: placement 12230 })) : offset, 12231 skidding = _ref[0], 12232 distance = _ref[1]; 12233 12234 skidding = skidding || 0; 12235 distance = (distance || 0) * invertDistance; 12236 return [left, right].indexOf(basePlacement) >= 0 ? { 12237 x: distance, 12238 y: skidding 12239 } : { 12240 x: skidding, 12241 y: distance 12242 }; 12243} 12244 12245function offset(_ref2) { 12246 var state = _ref2.state, 12247 options = _ref2.options, 12248 name = _ref2.name; 12249 var _options$offset = options.offset, 12250 offset = _options$offset === void 0 ? [0, 0] : _options$offset; 12251 var data = enums_placements.reduce(function (acc, placement) { 12252 acc[placement] = distanceAndSkiddingToXY(placement, state.rects, offset); 12253 return acc; 12254 }, {}); 12255 var _data$state$placement = data[state.placement], 12256 x = _data$state$placement.x, 12257 y = _data$state$placement.y; 12258 12259 if (state.modifiersData.popperOffsets != null) { 12260 state.modifiersData.popperOffsets.x += x; 12261 state.modifiersData.popperOffsets.y += y; 12262 } 12263 12264 state.modifiersData[name] = data; 12265} // eslint-disable-next-line import/no-unused-modules 12266 12267 12268/* harmony default export */ const modifiers_offset = ({ 12269 name: 'offset', 12270 enabled: true, 12271 phase: 'main', 12272 requires: ['popperOffsets'], 12273 fn: offset 12274}); 12275;// CONCATENATED MODULE: ./node_modules/@popperjs/core/lib/modifiers/popperOffsets.js 12276 12277 12278function popperOffsets(_ref) { 12279 var state = _ref.state, 12280 name = _ref.name; 12281 // Offsets are the actual position the popper needs to have to be 12282 // properly positioned near its reference element 12283 // This is the most basic placement, and will be adjusted by 12284 // the modifiers in the next step 12285 state.modifiersData[name] = computeOffsets({ 12286 reference: state.rects.reference, 12287 element: state.rects.popper, 12288 strategy: 'absolute', 12289 placement: state.placement 12290 }); 12291} // eslint-disable-next-line import/no-unused-modules 12292 12293 12294/* harmony default export */ const modifiers_popperOffsets = ({ 12295 name: 'popperOffsets', 12296 enabled: true, 12297 phase: 'read', 12298 fn: popperOffsets, 12299 data: {} 12300}); 12301;// CONCATENATED MODULE: ./node_modules/@popperjs/core/lib/utils/getAltAxis.js 12302function getAltAxis(axis) { 12303 return axis === 'x' ? 'y' : 'x'; 12304} 12305;// CONCATENATED MODULE: ./node_modules/@popperjs/core/lib/modifiers/preventOverflow.js 12306 12307 12308 12309 12310 12311 12312 12313 12314 12315 12316 12317 12318function preventOverflow(_ref) { 12319 var state = _ref.state, 12320 options = _ref.options, 12321 name = _ref.name; 12322 var _options$mainAxis = options.mainAxis, 12323 checkMainAxis = _options$mainAxis === void 0 ? true : _options$mainAxis, 12324 _options$altAxis = options.altAxis, 12325 checkAltAxis = _options$altAxis === void 0 ? false : _options$altAxis, 12326 boundary = options.boundary, 12327 rootBoundary = options.rootBoundary, 12328 altBoundary = options.altBoundary, 12329 padding = options.padding, 12330 _options$tether = options.tether, 12331 tether = _options$tether === void 0 ? true : _options$tether, 12332 _options$tetherOffset = options.tetherOffset, 12333 tetherOffset = _options$tetherOffset === void 0 ? 0 : _options$tetherOffset; 12334 var overflow = detectOverflow(state, { 12335 boundary: boundary, 12336 rootBoundary: rootBoundary, 12337 padding: padding, 12338 altBoundary: altBoundary 12339 }); 12340 var basePlacement = getBasePlacement(state.placement); 12341 var variation = getVariation(state.placement); 12342 var isBasePlacement = !variation; 12343 var mainAxis = getMainAxisFromPlacement(basePlacement); 12344 var altAxis = getAltAxis(mainAxis); 12345 var popperOffsets = state.modifiersData.popperOffsets; 12346 var referenceRect = state.rects.reference; 12347 var popperRect = state.rects.popper; 12348 var tetherOffsetValue = typeof tetherOffset === 'function' ? tetherOffset(Object.assign({}, state.rects, { 12349 placement: state.placement 12350 })) : tetherOffset; 12351 var normalizedTetherOffsetValue = typeof tetherOffsetValue === 'number' ? { 12352 mainAxis: tetherOffsetValue, 12353 altAxis: tetherOffsetValue 12354 } : Object.assign({ 12355 mainAxis: 0, 12356 altAxis: 0 12357 }, tetherOffsetValue); 12358 var offsetModifierState = state.modifiersData.offset ? state.modifiersData.offset[state.placement] : null; 12359 var data = { 12360 x: 0, 12361 y: 0 12362 }; 12363 12364 if (!popperOffsets) { 12365 return; 12366 } 12367 12368 if (checkMainAxis) { 12369 var _offsetModifierState$; 12370 12371 var mainSide = mainAxis === 'y' ? enums_top : left; 12372 var altSide = mainAxis === 'y' ? bottom : right; 12373 var len = mainAxis === 'y' ? 'height' : 'width'; 12374 var offset = popperOffsets[mainAxis]; 12375 var min = offset + overflow[mainSide]; 12376 var max = offset - overflow[altSide]; 12377 var additive = tether ? -popperRect[len] / 2 : 0; 12378 var minLen = variation === start ? referenceRect[len] : popperRect[len]; 12379 var maxLen = variation === start ? -popperRect[len] : -referenceRect[len]; // We need to include the arrow in the calculation so the arrow doesn't go 12380 // outside the reference bounds 12381 12382 var arrowElement = state.elements.arrow; 12383 var arrowRect = tether && arrowElement ? getLayoutRect(arrowElement) : { 12384 width: 0, 12385 height: 0 12386 };
vendor: 7,915 bytes, lines 12387-12619
12387 var arrowPaddingObject = state.modifiersData['arrow#persistent'] ? state.modifiersData['arrow#persistent'].padding : getFreshSideObject(); 12388 var arrowPaddingMin = arrowPaddingObject[mainSide]; 12389 var arrowPaddingMax = arrowPaddingObject[altSide]; // If the reference length is smaller than the arrow length, we don't want 12390 // to include its full size in the calculation. If the reference is small 12391 // and near the edge of a boundary, the popper can overflow even if the 12392 // reference is not overflowing as well (e.g. virtual elements with no 12393 // width or height) 12394 12395 var arrowLen = within(0, referenceRect[len], arrowRect[len]); 12396 var minOffset = isBasePlacement ? referenceRect[len] / 2 - additive - arrowLen - arrowPaddingMin - normalizedTetherOffsetValue.mainAxis : minLen - arrowLen - arrowPaddingMin - normalizedTetherOffsetValue.mainAxis; 12397 var maxOffset = isBasePlacement ? -referenceRect[len] / 2 + additive + arrowLen + arrowPaddingMax + normalizedTetherOffsetValue.mainAxis : maxLen + arrowLen + arrowPaddingMax + normalizedTetherOffsetValue.mainAxis; 12398 var arrowOffsetParent = state.elements.arrow && getOffsetParent(state.elements.arrow); 12399 var clientOffset = arrowOffsetParent ? mainAxis === 'y' ? arrowOffsetParent.clientTop || 0 : arrowOffsetParent.clientLeft || 0 : 0; 12400 var offsetModifierValue = (_offsetModifierState$ = offsetModifierState == null ? void 0 : offsetModifierState[mainAxis]) != null ? _offsetModifierState$ : 0; 12401 var tetherMin = offset + minOffset - offsetModifierValue - clientOffset; 12402 var tetherMax = offset + maxOffset - offsetModifierValue; 12403 var preventedOffset = within(tether ? math_min(min, tetherMin) : min, offset, tether ? math_max(max, tetherMax) : max); 12404 popperOffsets[mainAxis] = preventedOffset; 12405 data[mainAxis] = preventedOffset - offset; 12406 } 12407 12408 if (checkAltAxis) { 12409 var _offsetModifierState$2; 12410 12411 var _mainSide = mainAxis === 'x' ? enums_top : left; 12412 12413 var _altSide = mainAxis === 'x' ? bottom : right; 12414 12415 var _offset = popperOffsets[altAxis]; 12416 12417 var _len = altAxis === 'y' ? 'height' : 'width'; 12418 12419 var _min = _offset + overflow[_mainSide]; 12420 12421 var _max = _offset - overflow[_altSide]; 12422 12423 var isOriginSide = [enums_top, left].indexOf(basePlacement) !== -1; 12424 12425 var _offsetModifierValue = (_offsetModifierState$2 = offsetModifierState == null ? void 0 : offsetModifierState[altAxis]) != null ? _offsetModifierState$2 : 0; 12426 12427 var _tetherMin = isOriginSide ? _min : _offset - referenceRect[_len] - popperRect[_len] - _offsetModifierValue + normalizedTetherOffsetValue.altAxis; 12428 12429 var _tetherMax = isOriginSide ? _offset + referenceRect[_len] + popperRect[_len] - _offsetModifierValue - normalizedTetherOffsetValue.altAxis : _max; 12430 12431 var _preventedOffset = tether && isOriginSide ? withinMaxClamp(_tetherMin, _offset, _tetherMax) : within(tether ? _tetherMin : _min, _offset, tether ? _tetherMax : _max); 12432 12433 popperOffsets[altAxis] = _preventedOffset; 12434 data[altAxis] = _preventedOffset - _offset; 12435 } 12436 12437 state.modifiersData[name] = data; 12438} // eslint-disable-next-line import/no-unused-modules 12439 12440 12441/* harmony default export */ const modifiers_preventOverflow = ({ 12442 name: 'preventOverflow', 12443 enabled: true, 12444 phase: 'main', 12445 fn: preventOverflow, 12446 requiresIfExists: ['offset'] 12447}); 12448;// CONCATENATED MODULE: ./node_modules/@popperjs/core/lib/modifiers/index.js 12449 12450 12451 12452 12453 12454 12455 12456 12457 12458;// CONCATENATED MODULE: ./node_modules/@popperjs/core/lib/dom-utils/getHTMLElementScroll.js 12459function getHTMLElementScroll(element) { 12460 return { 12461 scrollLeft: element.scrollLeft, 12462 scrollTop: element.scrollTop 12463 }; 12464} 12465;// CONCATENATED MODULE: ./node_modules/@popperjs/core/lib/dom-utils/getNodeScroll.js 12466 12467 12468 12469 12470function getNodeScroll(node) { 12471 if (node === getWindow(node) || !isHTMLElement(node)) { 12472 return getWindowScroll(node); 12473 } else { 12474 return getHTMLElementScroll(node); 12475 } 12476} 12477;// CONCATENATED MODULE: ./node_modules/@popperjs/core/lib/dom-utils/getCompositeRect.js 12478 12479 12480 12481 12482 12483 12484 12485 12486 12487function isElementScaled(element) { 12488 var rect = element.getBoundingClientRect(); 12489 var scaleX = round(rect.width) / element.offsetWidth || 1; 12490 var scaleY = round(rect.height) / element.offsetHeight || 1; 12491 return scaleX !== 1 || scaleY !== 1; 12492} // Returns the composite rect of an element relative to its offsetParent. 12493// Composite means it takes into account transforms as well as layout. 12494 12495 12496function getCompositeRect(elementOrVirtualElement, offsetParent, isFixed) { 12497 if (isFixed === void 0) { 12498 isFixed = false; 12499 } 12500 12501 var isOffsetParentAnElement = isHTMLElement(offsetParent); 12502 var offsetParentIsScaled = isHTMLElement(offsetParent) && isElementScaled(offsetParent); 12503 var documentElement = getDocumentElement(offsetParent); 12504 var rect = getBoundingClientRect(elementOrVirtualElement, offsetParentIsScaled, isFixed); 12505 var scroll = { 12506 scrollLeft: 0, 12507 scrollTop: 0 12508 }; 12509 var offsets = { 12510 x: 0, 12511 y: 0 12512 }; 12513 12514 if (isOffsetParentAnElement || !isOffsetParentAnElement && !isFixed) { 12515 if (getNodeName(offsetParent) !== 'body' || // https://github.com/popperjs/popper-core/issues/1078 12516 isScrollParent(documentElement)) { 12517 scroll = getNodeScroll(offsetParent); 12518 } 12519 12520 if (isHTMLElement(offsetParent)) { 12521 offsets = getBoundingClientRect(offsetParent, true); 12522 offsets.x += offsetParent.clientLeft; 12523 offsets.y += offsetParent.clientTop; 12524 } else if (documentElement) { 12525 offsets.x = getWindowScrollBarX(documentElement); 12526 } 12527 } 12528 12529 return { 12530 x: rect.left + scroll.scrollLeft - offsets.x, 12531 y: rect.top + scroll.scrollTop - offsets.y, 12532 width: rect.width, 12533 height: rect.height 12534 }; 12535} 12536;// CONCATENATED MODULE: ./node_modules/@popperjs/core/lib/utils/orderModifiers.js 12537 // source: https://stackoverflow.com/questions/49875255 12538 12539function order(modifiers) { 12540 var map = new Map(); 12541 var visited = new Set(); 12542 var result = []; 12543 modifiers.forEach(function (modifier) { 12544 map.set(modifier.name, modifier); 12545 }); // On visiting object, check for its dependencies and visit them recursively 12546 12547 function sort(modifier) { 12548 visited.add(modifier.name); 12549 var requires = [].concat(modifier.requires || [], modifier.requiresIfExists || []); 12550 requires.forEach(function (dep) { 12551 if (!visited.has(dep)) { 12552 var depModifier = map.get(dep); 12553 12554 if (depModifier) { 12555 sort(depModifier); 12556 } 12557 } 12558 }); 12559 result.push(modifier); 12560 } 12561 12562 modifiers.forEach(function (modifier) { 12563 if (!visited.has(modifier.name)) { 12564 // check for visited object 12565 sort(modifier); 12566 } 12567 }); 12568 return result; 12569} 12570 12571function orderModifiers(modifiers) { 12572 // order based on dependencies 12573 var orderedModifiers = order(modifiers); // order based on phase 12574 12575 return modifierPhases.reduce(function (acc, phase) { 12576 return acc.concat(orderedModifiers.filter(function (modifier) { 12577 return modifier.phase === phase; 12578 })); 12579 }, []); 12580} 12581;// CONCATENATED MODULE: ./node_modules/@popperjs/core/lib/utils/debounce.js 12582function debounce(fn) { 12583 var pending; 12584 return function () { 12585 if (!pending) { 12586 pending = new Promise(function (resolve) { 12587 Promise.resolve().then(function () { 12588 pending = undefined; 12589 resolve(fn()); 12590 }); 12591 }); 12592 } 12593 12594 return pending; 12595 }; 12596} 12597;// CONCATENATED MODULE: ./node_modules/@popperjs/core/lib/utils/mergeByName.js 12598function mergeByName(modifiers) { 12599 var merged = modifiers.reduce(function (merged, current) { 12600 var existing = merged[current.name]; 12601 merged[current.name] = existing ? Object.assign({}, existing, current, { 12602 options: Object.assign({}, existing.options, current.options), 12603 data: Object.assign({}, existing.data, current.data) 12604 }) : current; 12605 return merged; 12606 }, {}); // IE11 does not support Object.values 12607 12608 return Object.keys(merged).map(function (key) { 12609 return merged[key]; 12610 }); 12611} 12612;// CONCATENATED MODULE: ./node_modules/@popperjs/core/lib/createPopper.js 12613 12614 12615 12616 12617 12618 12619
vendor: 6,690 bytes, lines 12620-12808
12620 12621 12622var DEFAULT_OPTIONS = { 12623 placement: 'bottom', 12624 modifiers: [], 12625 strategy: 'absolute' 12626}; 12627 12628function areValidElements() { 12629 for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) { 12630 args[_key] = arguments[_key]; 12631 } 12632 12633 return !args.some(function (element) { 12634 return !(element && typeof element.getBoundingClientRect === 'function'); 12635 }); 12636} 12637 12638function popperGenerator(generatorOptions) { 12639 if (generatorOptions === void 0) { 12640 generatorOptions = {}; 12641 } 12642 12643 var _generatorOptions = generatorOptions, 12644 _generatorOptions$def = _generatorOptions.defaultModifiers, 12645 defaultModifiers = _generatorOptions$def === void 0 ? [] : _generatorOptions$def, 12646 _generatorOptions$def2 = _generatorOptions.defaultOptions, 12647 defaultOptions = _generatorOptions$def2 === void 0 ? DEFAULT_OPTIONS : _generatorOptions$def2; 12648 return function createPopper(reference, popper, options) { 12649 if (options === void 0) { 12650 options = defaultOptions; 12651 } 12652 12653 var state = { 12654 placement: 'bottom', 12655 orderedModifiers: [], 12656 options: Object.assign({}, DEFAULT_OPTIONS, defaultOptions), 12657 modifiersData: {}, 12658 elements: { 12659 reference: reference, 12660 popper: popper 12661 }, 12662 attributes: {}, 12663 styles: {} 12664 }; 12665 var effectCleanupFns = []; 12666 var isDestroyed = false; 12667 var instance = { 12668 state: state, 12669 setOptions: function setOptions(setOptionsAction) { 12670 var options = typeof setOptionsAction === 'function' ? setOptionsAction(state.options) : setOptionsAction; 12671 cleanupModifierEffects(); 12672 state.options = Object.assign({}, defaultOptions, state.options, options); 12673 state.scrollParents = { 12674 reference: isElement(reference) ? listScrollParents(reference) : reference.contextElement ? listScrollParents(reference.contextElement) : [], 12675 popper: listScrollParents(popper) 12676 }; // Orders the modifiers based on their dependencies and `phase` 12677 // properties 12678 12679 var orderedModifiers = orderModifiers(mergeByName([].concat(defaultModifiers, state.options.modifiers))); // Strip out disabled modifiers 12680 12681 state.orderedModifiers = orderedModifiers.filter(function (m) { 12682 return m.enabled; 12683 }); 12684 runModifierEffects(); 12685 return instance.update(); 12686 }, 12687 // Sync update â it will always be executed, even if not necessary. This 12688 // is useful for low frequency updates where sync behavior simplifies the 12689 // logic. 12690 // For high frequency updates (e.g. `resize` and `scroll` events), always 12691 // prefer the async Popper#update method 12692 forceUpdate: function forceUpdate() { 12693 if (isDestroyed) { 12694 return; 12695 } 12696 12697 var _state$elements = state.elements, 12698 reference = _state$elements.reference, 12699 popper = _state$elements.popper; // Don't proceed if `reference` or `popper` are not valid elements 12700 // anymore 12701 12702 if (!areValidElements(reference, popper)) { 12703 return; 12704 } // Store the reference and popper rects to be read by modifiers 12705 12706 12707 state.rects = { 12708 reference: getCompositeRect(reference, getOffsetParent(popper), state.options.strategy === 'fixed'), 12709 popper: getLayoutRect(popper) 12710 }; // Modifiers have the ability to reset the current update cycle. The 12711 // most common use case for this is the `flip` modifier changing the 12712 // placement, which then needs to re-run all the modifiers, because the 12713 // logic was previously ran for the previous placement and is therefore 12714 // stale/incorrect 12715 12716 state.reset = false; 12717 state.placement = state.options.placement; // On each update cycle, the `modifiersData` property for each modifier 12718 // is filled with the initial data specified by the modifier. This means 12719 // it doesn't persist and is fresh on each update. 12720 // To ensure persistent data, use `${name}#persistent` 12721 12722 state.orderedModifiers.forEach(function (modifier) { 12723 return state.modifiersData[modifier.name] = Object.assign({}, modifier.data); 12724 }); 12725 12726 for (var index = 0; index < state.orderedModifiers.length; index++) { 12727 if (state.reset === true) { 12728 state.reset = false; 12729 index = -1; 12730 continue; 12731 } 12732 12733 var _state$orderedModifie = state.orderedModifiers[index], 12734 fn = _state$orderedModifie.fn, 12735 _state$orderedModifie2 = _state$orderedModifie.options, 12736 _options = _state$orderedModifie2 === void 0 ? {} : _state$orderedModifie2, 12737 name = _state$orderedModifie.name; 12738 12739 if (typeof fn === 'function') { 12740 state = fn({ 12741 state: state, 12742 options: _options, 12743 name: name, 12744 instance: instance 12745 }) || state; 12746 } 12747 } 12748 }, 12749 // Async and optimistically optimized update â it will not be executed if 12750 // not necessary (debounced to run at most once-per-tick) 12751 update: debounce(function () { 12752 return new Promise(function (resolve) { 12753 instance.forceUpdate(); 12754 resolve(state); 12755 }); 12756 }), 12757 destroy: function destroy() { 12758 cleanupModifierEffects(); 12759 isDestroyed = true; 12760 } 12761 }; 12762 12763 if (!areValidElements(reference, popper)) { 12764 return instance; 12765 } 12766 12767 instance.setOptions(options).then(function (state) { 12768 if (!isDestroyed && options.onFirstUpdate) { 12769 options.onFirstUpdate(state); 12770 } 12771 }); // Modifiers have the ability to execute arbitrary code before the first 12772 // update cycle runs. They will be executed in the same order as the update 12773 // cycle. This is useful when a modifier adds some persistent data that 12774 // other modifiers need to use, but the modifier is run after the dependent 12775 // one. 12776 12777 function runModifierEffects() { 12778 state.orderedModifiers.forEach(function (_ref) { 12779 var name = _ref.name, 12780 _ref$options = _ref.options, 12781 options = _ref$options === void 0 ? {} : _ref$options, 12782 effect = _ref.effect; 12783 12784 if (typeof effect === 'function') { 12785 var cleanupFn = effect({ 12786 state: state, 12787 name: name, 12788 instance: instance, 12789 options: options 12790 }); 12791 12792 var noopFn = function noopFn() {}; 12793 12794 effectCleanupFns.push(cleanupFn || noopFn); 12795 } 12796 }); 12797 } 12798 12799 function cleanupModifierEffects() { 12800 effectCleanupFns.forEach(function (fn) { 12801 return fn(); 12802 }); 12803 effectCleanupFns = []; 12804 } 12805 12806 return instance; 12807 }; 12808}
vendor: 5,172 bytes, lines 12809-12980
12809var createPopper = /*#__PURE__*/popperGenerator(); // eslint-disable-next-line import/no-unused-modules 12810 12811 12812;// CONCATENATED MODULE: ./node_modules/@popperjs/core/lib/popper.js 12813 12814 12815 12816 12817 12818 12819 12820 12821 12822 12823var defaultModifiers = [eventListeners, modifiers_popperOffsets, modifiers_computeStyles, modifiers_applyStyles, modifiers_offset, modifiers_flip, modifiers_preventOverflow, modifiers_arrow, modifiers_hide]; 12824var popper_createPopper = /*#__PURE__*/popperGenerator({ 12825 defaultModifiers: defaultModifiers 12826}); // eslint-disable-next-line import/no-unused-modules 12827 12828 // eslint-disable-next-line import/no-unused-modules 12829 12830 // eslint-disable-next-line import/no-unused-modules 12831 12832 12833;// CONCATENATED MODULE: ./node_modules/@popperjs/core/lib/popper-lite.js 12834 12835 12836 12837 12838 12839var popper_lite_defaultModifiers = [eventListeners, modifiers_popperOffsets, modifiers_computeStyles, modifiers_applyStyles]; 12840var popper_lite_createPopper = /*#__PURE__*/popperGenerator({ 12841 defaultModifiers: popper_lite_defaultModifiers 12842}); // eslint-disable-next-line import/no-unused-modules 12843 12844 12845;// CONCATENATED MODULE: ./node_modules/@popperjs/core/lib/index.js 12846 12847 // eslint-disable-next-line import/no-unused-modules 12848 12849 // eslint-disable-next-line import/no-unused-modules 12850 12851 // eslint-disable-next-line import/no-unused-modules 12852 12853 12854;// CONCATENATED MODULE: ./node_modules/bootstrap/dist/js/bootstrap.esm.js 12855/*! 12856 * Bootstrap v5.3.2 (https://getbootstrap.com/) 12857 * Copyright 2011-2023 The Bootstrap Authors (https://github.com/twbs/bootstrap/graphs/contributors) 12858 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 12859 */ 12860 12861 12862/** 12863 * -------------------------------------------------------------------------- 12864 * Bootstrap dom/data.js 12865 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 12866 * -------------------------------------------------------------------------- 12867 */ 12868 12869/** 12870 * Constants 12871 */ 12872 12873const elementMap = new Map(); 12874const Data = { 12875 set(element, key, instance) { 12876 if (!elementMap.has(element)) { 12877 elementMap.set(element, new Map()); 12878 } 12879 const instanceMap = elementMap.get(element); 12880 12881 // make it clear we only want one instance per element 12882 // can be removed later when multiple key/instances are fine to be used 12883 if (!instanceMap.has(key) && instanceMap.size !== 0) { 12884 // eslint-disable-next-line no-console 12885 console.error(`Bootstrap doesn't allow more than one instance per element. Bound instance: ${Array.from(instanceMap.keys())[0]}.`); 12886 return; 12887 } 12888 instanceMap.set(key, instance); 12889 }, 12890 get(element, key) { 12891 if (elementMap.has(element)) { 12892 return elementMap.get(element).get(key) || null; 12893 } 12894 return null; 12895 }, 12896 remove(element, key) { 12897 if (!elementMap.has(element)) { 12898 return; 12899 } 12900 const instanceMap = elementMap.get(element); 12901 instanceMap.delete(key); 12902 12903 // free up element references if there are no instances left for an element 12904 if (instanceMap.size === 0) { 12905 elementMap.delete(element); 12906 } 12907 } 12908}; 12909 12910/** 12911 * -------------------------------------------------------------------------- 12912 * Bootstrap util/index.js 12913 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 12914 * -------------------------------------------------------------------------- 12915 */ 12916 12917const MAX_UID = 1000000; 12918const MILLISECONDS_MULTIPLIER = 1000; 12919const TRANSITION_END = 'transitionend'; 12920 12921/** 12922 * Properly escape IDs selectors to handle weird IDs 12923 * @param {string} selector 12924 * @returns {string} 12925 */ 12926const parseSelector = selector => { 12927 if (selector && window.CSS && window.CSS.escape) { 12928 // document.querySelector needs escaping to handle IDs (html5+) containing for instance / 12929 selector = selector.replace(/#([^\s"#']+)/g, (match, id) => `#${CSS.escape(id)}`); 12930 } 12931 return selector; 12932}; 12933 12934// Shout-out Angus Croll (https://goo.gl/pxwQGp) 12935const toType = object => { 12936 if (object === null || object === undefined) { 12937 return `${object}`; 12938 } 12939 return Object.prototype.toString.call(object).match(/\s([a-z]+)/i)[1].toLowerCase(); 12940}; 12941 12942/** 12943 * Public Util API 12944 */ 12945 12946const getUID = prefix => { 12947 do { 12948 prefix += Math.floor(Math.random() * MAX_UID); 12949 } while (document.getElementById(prefix)); 12950 return prefix; 12951}; 12952const getTransitionDurationFromElement = element => { 12953 if (!element) { 12954 return 0; 12955 } 12956 12957 // Get transition-duration of the element 12958 let { 12959 transitionDuration, 12960 transitionDelay 12961 } = window.getComputedStyle(element); 12962 const floatTransitionDuration = Number.parseFloat(transitionDuration); 12963 const floatTransitionDelay = Number.parseFloat(transitionDelay); 12964 12965 // Return 0 if element or transition duration is not found 12966 if (!floatTransitionDuration && !floatTransitionDelay) { 12967 return 0; 12968 } 12969 12970 // If multiple durations are defined, take the first 12971 transitionDuration = transitionDuration.split(',')[0]; 12972 transitionDelay = transitionDelay.split(',')[0]; 12973 return (Number.parseFloat(transitionDuration) + Number.parseFloat(transitionDelay)) * MILLISECONDS_MULTIPLIER; 12974}; 12975const triggerTransitionEnd = element => { 12976 element.dispatchEvent(new Event(TRANSITION_END)); 12977}; 12978const bootstrap_esm_isElement = object => { 12979 if (!object || typeof object !== 'object') { 12980 return false;
12981 } 12982 if (typeof object.jquery !== 'undefined') { 12983 object = object[0]; 12984 } 12985 return typeof object.nodeType !== 'undefined'; 12986}; 12987const getElement = object => { 12988 // it's a jQuery object or a node element 12989 if (bootstrap_esm_isElement(object)) { 12990 return object.jquery ? object[0] : object; 12991 } 12992 if (typeof object === 'string' && object.length > 0) { 12993 return document.querySelector(parseSelector(object)); 12994 } 12995 return null; 12996}; 12997const isVisible = element => { 12998 if (!bootstrap_esm_
vendor: 15,484 bytes, lines 12998-13469
12998isElement(element) || element.getClientRects().length === 0) { 12999 return false; 13000 } 13001 const elementIsVisible = getComputedStyle(element).getPropertyValue('visibility') === 'visible'; 13002 // Handle `details` element as its content may falsie appear visible when it is closed 13003 const closedDetails = element.closest('details:not([open])'); 13004 if (!closedDetails) { 13005 return elementIsVisible; 13006 } 13007 if (closedDetails !== element) { 13008 const summary = element.closest('summary'); 13009 if (summary && summary.parentNode !== closedDetails) { 13010 return false; 13011 } 13012 if (summary === null) { 13013 return false; 13014 } 13015 } 13016 return elementIsVisible; 13017}; 13018const isDisabled = element => { 13019 if (!element || element.nodeType !== Node.ELEMENT_NODE) { 13020 return true; 13021 } 13022 if (element.classList.contains('disabled')) { 13023 return true; 13024 } 13025 if (typeof element.disabled !== 'undefined') { 13026 return element.disabled; 13027 } 13028 return element.hasAttribute('disabled') && element.getAttribute('disabled') !== 'false'; 13029}; 13030const findShadowRoot = element => { 13031 if (!document.documentElement.attachShadow) { 13032 return null; 13033 } 13034 13035 // Can find the shadow root otherwise it'll return the document 13036 if (typeof element.getRootNode === 'function') { 13037 const root = element.getRootNode(); 13038 return root instanceof ShadowRoot ? root : null; 13039 } 13040 if (element instanceof ShadowRoot) { 13041 return element; 13042 } 13043 13044 // when we don't find a shadow root 13045 if (!element.parentNode) { 13046 return null; 13047 } 13048 return findShadowRoot(element.parentNode); 13049}; 13050const noop = () => {}; 13051 13052/** 13053 * Trick to restart an element's animation 13054 * 13055 * @param {HTMLElement} element 13056 * @return void 13057 * 13058 * @see https://www.charistheo.io/blog/2021/02/restart-a-css-animation-with-javascript/#restarting-a-css-animation 13059 */ 13060const reflow = element => { 13061 element.offsetHeight; // eslint-disable-line no-unused-expressions 13062}; 13063 13064const getjQuery = () => { 13065 if (window.jQuery && !document.body.hasAttribute('data-bs-no-jquery')) { 13066 return window.jQuery; 13067 } 13068 return null; 13069}; 13070const DOMContentLoadedCallbacks = []; 13071const onDOMContentLoaded = callback => { 13072 if (document.readyState === 'loading') { 13073 // add listener on the first call when the document is in loading state 13074 if (!DOMContentLoadedCallbacks.length) { 13075 document.addEventListener('DOMContentLoaded', () => { 13076 for (const callback of DOMContentLoadedCallbacks) { 13077 callback(); 13078 } 13079 }); 13080 } 13081 DOMContentLoadedCallbacks.push(callback); 13082 } else { 13083 callback(); 13084 } 13085}; 13086const isRTL = () => document.documentElement.dir === 'rtl'; 13087const defineJQueryPlugin = plugin => { 13088 onDOMContentLoaded(() => { 13089 const $ = getjQuery(); 13090 /* istanbul ignore if */ 13091 if ($) { 13092 const name = plugin.NAME; 13093 const JQUERY_NO_CONFLICT = $.fn[name]; 13094 $.fn[name] = plugin.jQueryInterface; 13095 $.fn[name].Constructor = plugin; 13096 $.fn[name].noConflict = () => { 13097 $.fn[name] = JQUERY_NO_CONFLICT; 13098 return plugin.jQueryInterface; 13099 }; 13100 } 13101 }); 13102}; 13103const execute = (possibleCallback, args = [], defaultValue = possibleCallback) => { 13104 return typeof possibleCallback === 'function' ? possibleCallback(...args) : defaultValue; 13105}; 13106const executeAfterTransition = (callback, transitionElement, waitForTransition = true) => { 13107 if (!waitForTransition) { 13108 execute(callback); 13109 return; 13110 } 13111 const durationPadding = 5; 13112 const emulatedDuration = getTransitionDurationFromElement(transitionElement) + durationPadding; 13113 let called = false; 13114 const handler = ({ 13115 target 13116 }) => { 13117 if (target !== transitionElement) { 13118 return; 13119 } 13120 called = true; 13121 transitionElement.removeEventListener(TRANSITION_END, handler); 13122 execute(callback); 13123 }; 13124 transitionElement.addEventListener(TRANSITION_END, handler); 13125 setTimeout(() => { 13126 if (!called) { 13127 triggerTransitionEnd(transitionElement); 13128 } 13129 }, emulatedDuration); 13130}; 13131 13132/** 13133 * Return the previous/next element of a list. 13134 * 13135 * @param {array} list The list of elements 13136 * @param activeElement The active element 13137 * @param shouldGetNext Choose to get next or previous element 13138 * @param isCycleAllowed 13139 * @return {Element|elem} The proper element 13140 */ 13141const getNextActiveElement = (list, activeElement, shouldGetNext, isCycleAllowed) => { 13142 const listLength = list.length; 13143 let index = list.indexOf(activeElement); 13144 13145 // if the element does not exist in the list return an element 13146 // depending on the direction and if cycle is allowed 13147 if (index === -1) { 13148 return !shouldGetNext && isCycleAllowed ? list[listLength - 1] : list[0]; 13149 } 13150 index += shouldGetNext ? 1 : -1; 13151 if (isCycleAllowed) { 13152 index = (index + listLength) % listLength; 13153 } 13154 return list[Math.max(0, Math.min(index, listLength - 1))]; 13155}; 13156 13157/** 13158 * -------------------------------------------------------------------------- 13159 * Bootstrap dom/event-handler.js 13160 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 13161 * -------------------------------------------------------------------------- 13162 */ 13163 13164 13165/** 13166 * Constants 13167 */ 13168 13169const namespaceRegex = /[^.]*(?=\..*)\.|.*/; 13170const stripNameRegex = /\..*/; 13171const stripUidRegex = /::\d+$/; 13172const eventRegistry = {}; // Events storage 13173let uidEvent = 1; 13174const customEvents = { 13175 mouseenter: 'mouseover', 13176 mouseleave: 'mouseout' 13177}; 13178const nativeEvents = new Set(['click', 'dblclick', 'mouseup', 'mousedown', 'contextmenu', 'mousewheel', 'DOMMouseScroll', 'mouseover', 'mouseout', 'mousemove', 'selectstart', 'selectend', 'keydown', 'keypress', 'keyup', 'orientationchange', 'touchstart', 'touchmove', 'touchend', 'touchcancel', 'pointerdown', 'pointermove', 'pointerup', 'pointerleave', 'pointercancel', 'gesturestart', 'gesturechange', 'gestureend', 'focus', 'blur', 'change', 'reset', 'select', 'submit', 'focusin', 'focusout', 'load', 'unload', 'beforeunload', 'resize', 'move', 'DOMContentLoaded', 'readystatechange', 'error', 'abort', 'scroll']); 13179 13180/** 13181 * Private methods 13182 */ 13183 13184function makeEventUid(element, uid) { 13185 return uid && `${uid}::${uidEvent++}` || element.uidEvent || uidEvent++; 13186} 13187function getElementEvents(element) { 13188 const uid = makeEventUid(element); 13189 element.uidEvent = uid; 13190 eventRegistry[uid] = eventRegistry[uid] || {}; 13191 return eventRegistry[uid]; 13192} 13193function bootstrapHandler(element, fn) { 13194 return function handler(event) { 13195 hydrateObj(event, { 13196 delegateTarget: element 13197 }); 13198 if (handler.oneOff) { 13199 EventHandler.off(element, event.type, fn); 13200 } 13201 return fn.apply(element, [event]); 13202 }; 13203} 13204function bootstrapDelegationHandler(element, selector, fn) { 13205 return function handler(event) { 13206 const domElements = element.querySelectorAll(selector); 13207 for (let { 13208 target 13209 } = event; target && target !== this; target = target.parentNode) { 13210 for (const domElement of domElements) { 13211 if (domElement !== target) { 13212 continue; 13213 } 13214 hydrateObj(event, { 13215 delegateTarget: target 13216 }); 13217 if (handler.oneOff) { 13218 EventHandler.off(element, event.type, selector, fn); 13219 } 13220 return fn.apply(target, [event]); 13221 } 13222 } 13223 }; 13224} 13225function findHandler(events, callable, delegationSelector = null) { 13226 return Object.values(events).find(event => event.callable === callable && event.delegationSelector === delegationSelector); 13227} 13228function normalizeParameters(originalTypeEvent, handler, delegationFunction) { 13229 const isDelegated = typeof handler === 'string'; 13230 // TODO: tooltip passes `false` instead of selector, so we need to check 13231 const callable = isDelegated ? delegationFunction : handler || delegationFunction; 13232 let typeEvent = getTypeEvent(originalTypeEvent); 13233 if (!nativeEvents.has(typeEvent)) { 13234 typeEvent = originalTypeEvent; 13235 } 13236 return [isDelegated, callable, typeEvent]; 13237} 13238function addHandler(element, originalTypeEvent, handler, delegationFunction, oneOff) { 13239 if (typeof originalTypeEvent !== 'string' || !element) { 13240 return; 13241 } 13242 let [isDelegated, callable, typeEvent] = normalizeParameters(originalTypeEvent, handler, delegationFunction); 13243 13244 // in case of mouseenter or mouseleave wrap the handler within a function that checks for its DOM position 13245 // this prevents the handler from being dispatched the same way as mouseover or mouseout does 13246 if (originalTypeEvent in customEvents) { 13247 const wrapFunction = fn => { 13248 return function (event) { 13249 if (!event.relatedTarget || event.relatedTarget !== event.delegateTarget && !event.delegateTarget.contains(event.relatedTarget)) { 13250 return fn.call(this, event); 13251 } 13252 }; 13253 }; 13254 callable = wrapFunction(callable); 13255 } 13256 const events = getElementEvents(element); 13257 const handlers = events[typeEvent] || (events[typeEvent] = {}); 13258 const previousFunction = findHandler(handlers, callable, isDelegated ? handler : null); 13259 if (previousFunction) { 13260 previousFunction.oneOff = previousFunction.oneOff && oneOff; 13261 return; 13262 } 13263 const uid = makeEventUid(callable, originalTypeEvent.replace(namespaceRegex, '')); 13264 const fn = isDelegated ? bootstrapDelegationHandler(element, handler, callable) : bootstrapHandler(element, callable); 13265 fn.delegationSelector = isDelegated ? handler : null; 13266 fn.callable = callable; 13267 fn.oneOff = oneOff; 13268 fn.uidEvent = uid; 13269 handlers[uid] = fn; 13270 element.addEventListener(typeEvent, fn, isDelegated); 13271} 13272function removeHandler(element, events, typeEvent, handler, delegationSelector) { 13273 const fn = findHandler(events[typeEvent], handler, delegationSelector); 13274 if (!fn) { 13275 return; 13276 } 13277 element.removeEventListener(typeEvent, fn, Boolean(delegationSelector)); 13278 delete events[typeEvent][fn.uidEvent]; 13279} 13280function removeNamespacedHandlers(element, events, typeEvent, namespace) { 13281 const storeElementEvent = events[typeEvent] || {}; 13282 for (const [handlerKey, event] of Object.entries(storeElementEvent)) { 13283 if (handlerKey.includes(namespace)) { 13284 removeHandler(element, events, typeEvent, event.callable, event.delegationSelector); 13285 } 13286 } 13287} 13288function getTypeEvent(event) { 13289 // allow to get the native events from namespaced events ('click.bs.button' --> 'click') 13290 event = event.replace(stripNameRegex, ''); 13291 return customEvents[event] || event; 13292} 13293const EventHandler = { 13294 on(element, event, handler, delegationFunction) { 13295 addHandler(element, event, handler, delegationFunction, false); 13296 }, 13297 one(element, event, handler, delegationFunction) { 13298 addHandler(element, event, handler, delegationFunction, true); 13299 }, 13300 off(element, originalTypeEvent, handler, delegationFunction) { 13301 if (typeof originalTypeEvent !== 'string' || !element) { 13302 return; 13303 } 13304 const [isDelegated, callable, typeEvent] = normalizeParameters(originalTypeEvent, handler, delegationFunction); 13305 const inNamespace = typeEvent !== originalTypeEvent; 13306 const events = getElementEvents(element); 13307 const storeElementEvent = events[typeEvent] || {}; 13308 const isNamespace = originalTypeEvent.startsWith('.'); 13309 if (typeof callable !== 'undefined') { 13310 // Simplest case: handler is passed, remove that listener ONLY. 13311 if (!Object.keys(storeElementEvent).length) { 13312 return; 13313 } 13314 removeHandler(element, events, typeEvent, callable, isDelegated ? handler : null); 13315 return; 13316 } 13317 if (isNamespace) { 13318 for (const elementEvent of Object.keys(events)) { 13319 removeNamespacedHandlers(element, events, elementEvent, originalTypeEvent.slice(1)); 13320 } 13321 } 13322 for (const [keyHandlers, event] of Object.entries(storeElementEvent)) { 13323 const handlerKey = keyHandlers.replace(stripUidRegex, ''); 13324 if (!inNamespace || originalTypeEvent.includes(handlerKey)) { 13325 removeHandler(element, events, typeEvent, event.callable, event.delegationSelector); 13326 } 13327 } 13328 }, 13329 trigger(element, event, args) { 13330 if (typeof event !== 'string' || !element) { 13331 return null; 13332 } 13333 const $ = getjQuery(); 13334 const typeEvent = getTypeEvent(event); 13335 const inNamespace = event !== typeEvent; 13336 let jQueryEvent = null; 13337 let bubbles = true; 13338 let nativeDispatch = true; 13339 let defaultPrevented = false; 13340 if (inNamespace && $) { 13341 jQueryEvent = $.Event(event, args); 13342 $(element).trigger(jQueryEvent); 13343 bubbles = !jQueryEvent.isPropagationStopped(); 13344 nativeDispatch = !jQueryEvent.isImmediatePropagationStopped(); 13345 defaultPrevented = jQueryEvent.isDefaultPrevented(); 13346 } 13347 const evt = hydrateObj(new Event(event, { 13348 bubbles, 13349 cancelable: true 13350 }), args); 13351 if (defaultPrevented) { 13352 evt.preventDefault(); 13353 } 13354 if (nativeDispatch) { 13355 element.dispatchEvent(evt); 13356 } 13357 if (evt.defaultPrevented && jQueryEvent) { 13358 jQueryEvent.preventDefault(); 13359 } 13360 return evt; 13361 } 13362}; 13363function hydrateObj(obj, meta = {}) { 13364 for (const [key, value] of Object.entries(meta)) { 13365 try { 13366 obj[key] = value; 13367 } catch (_unused) { 13368 Object.defineProperty(obj, key, { 13369 configurable: true, 13370 get() { 13371 return value; 13372 } 13373 }); 13374 } 13375 } 13376 return obj; 13377} 13378 13379/** 13380 * -------------------------------------------------------------------------- 13381 * Bootstrap dom/manipulator.js 13382 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 13383 * -------------------------------------------------------------------------- 13384 */ 13385 13386function normalizeData(value) { 13387 if (value === 'true') { 13388 return true; 13389 } 13390 if (value === 'false') { 13391 return false; 13392 } 13393 if (value === Number(value).toString()) { 13394 return Number(value); 13395 } 13396 if (value === '' || value === 'null') { 13397 return null; 13398 } 13399 if (typeof value !== 'string') { 13400 return value; 13401 } 13402 try { 13403 return JSON.parse(decodeURIComponent(value)); 13404 } catch (_unused) { 13405 return value; 13406 } 13407} 13408function normalizeDataKey(key) { 13409 return key.replace(/[A-Z]/g, chr => `-${chr.toLowerCase()}`); 13410} 13411const Manipulator = { 13412 setDataAttribute(element, key, value) { 13413 element.setAttribute(`data-bs-${normalizeDataKey(key)}`, value); 13414 }, 13415 removeDataAttribute(element, key) { 13416 element.removeAttribute(`data-bs-${normalizeDataKey(key)}`); 13417 }, 13418 getDataAttributes(element) { 13419 if (!element) { 13420 return {}; 13421 } 13422 const attributes = {}; 13423 const bsKeys = Object.keys(element.dataset).filter(key => key.startsWith('bs') && !key.startsWith('bsConfig')); 13424 for (const key of bsKeys) { 13425 let pureKey = key.replace(/^bs/, ''); 13426 pureKey = pureKey.charAt(0).toLowerCase() + pureKey.slice(1, pureKey.length); 13427 attributes[pureKey] = normalizeData(element.dataset[key]); 13428 } 13429 return attributes; 13430 }, 13431 getDataAttribute(element, key) { 13432 return normalizeData(element.getAttribute(`data-bs-${normalizeDataKey(key)}`)); 13433 } 13434}; 13435 13436/** 13437 * -------------------------------------------------------------------------- 13438 * Bootstrap util/config.js 13439 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 13440 * -------------------------------------------------------------------------- 13441 */ 13442 13443 13444/** 13445 * Class definition 13446 */ 13447 13448class Config { 13449 // Getters 13450 static get Default() { 13451 return {}; 13452 } 13453 static get DefaultType() { 13454 return {}; 13455 } 13456 static get NAME() { 13457 throw new Error('You have to implement the static method "NAME", for each component!'); 13458 } 13459 _getConfig(config) { 13460 config = this._mergeConfigObj(config); 13461 config = this._configAfterMerge(config); 13462 this._typeCheckConfig(config); 13463 return config; 13464 } 13465 _configAfterMerge(config) { 13466 return config; 13467 } 13468 _mergeConfigObj(config, element) { 13469 const jsonConfig =
vendor: 1,674 bytes, lines 13469-13522
13469bootstrap_esm_isElement(element) ? Manipulator.getDataAttribute(element, 'config') : {}; // try to parse 13470 13471 return { 13472 ...this.constructor.Default, 13473 ...(typeof jsonConfig === 'object' ? jsonConfig : {}), 13474 ...(bootstrap_esm_isElement(element) ? Manipulator.getDataAttributes(element) : {}), 13475 ...(typeof config === 'object' ? config : {}) 13476 }; 13477 } 13478 _typeCheckConfig(config, configTypes = this.constructor.DefaultType) { 13479 for (const [property, expectedTypes] of Object.entries(configTypes)) { 13480 const value = config[property]; 13481 const valueType = bootstrap_esm_isElement(value) ? 'element' : toType(value); 13482 if (!new RegExp(expectedTypes).test(valueType)) { 13483 throw new TypeError(`${this.constructor.NAME.toUpperCase()}: Option "${property}" provided type "${valueType}" but expected type "${expectedTypes}".`); 13484 } 13485 } 13486 } 13487} 13488 13489/** 13490 * -------------------------------------------------------------------------- 13491 * Bootstrap base-component.js 13492 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 13493 * -------------------------------------------------------------------------- 13494 */ 13495 13496 13497/** 13498 * Constants 13499 */ 13500 13501const VERSION = '5.3.2'; 13502 13503/** 13504 * Class definition 13505 */ 13506 13507class BaseComponent extends Config { 13508 constructor(element, config) { 13509 super(); 13510 element = getElement(element); 13511 if (!element) { 13512 return; 13513 } 13514 this._element = element; 13515 this._config = this._getConfig(config); 13516 Data.set(this._element, this.constructor.DATA_KEY, this); 13517 } 13518 13519 // Public 13520 dispose() { 13521 Data.remove(this._element, this.constructor.DATA_KEY); 13522 EventHandler.off(this._element, this.constructor.EVENT_KEY);
vendor: 2,135 bytes, lines 13523-13584
13523 for (const propertyName of Object.getOwnPropertyNames(this)) { 13524 this[propertyName] = null; 13525 } 13526 } 13527 _queueCallback(callback, element, isAnimated = true) { 13528 executeAfterTransition(callback, element, isAnimated); 13529 } 13530 _getConfig(config) { 13531 config = this._mergeConfigObj(config, this._element); 13532 config = this._configAfterMerge(config); 13533 this._typeCheckConfig(config); 13534 return config; 13535 } 13536 13537 // Static 13538 static getInstance(element) { 13539 return Data.get(getElement(element), this.DATA_KEY); 13540 } 13541 static getOrCreateInstance(element, config = {}) { 13542 return this.getInstance(element) || new this(element, typeof config === 'object' ? config : null); 13543 } 13544 static get VERSION() { 13545 return VERSION; 13546 } 13547 static get DATA_KEY() { 13548 return `bs.${this.NAME}`; 13549 } 13550 static get EVENT_KEY() { 13551 return `.${this.DATA_KEY}`; 13552 } 13553 static eventName(name) { 13554 return `${name}${this.EVENT_KEY}`; 13555 } 13556} 13557 13558/** 13559 * -------------------------------------------------------------------------- 13560 * Bootstrap dom/selector-engine.js 13561 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 13562 * -------------------------------------------------------------------------- 13563 */ 13564 13565const getSelector = element => { 13566 let selector = element.getAttribute('data-bs-target'); 13567 if (!selector || selector === '#') { 13568 let hrefAttribute = element.getAttribute('href'); 13569 13570 // The only valid content that could double as a selector are IDs or classes, 13571 // so everything starting with `#` or `.`. If a "real" URL is used as the selector, 13572 // `document.querySelector` will rightfully complain it is invalid. 13573 // See https://github.com/twbs/bootstrap/issues/32273 13574 if (!hrefAttribute || !hrefAttribute.includes('#') && !hrefAttribute.startsWith('.')) { 13575 return null; 13576 } 13577 13578 // Just in case some CMS puts out a full URL with the anchor appended 13579 if (hrefAttribute.includes('#') && !hrefAttribute.startsWith('#')) { 13580 hrefAttribute = `#${hrefAttribute.split('#')[1]}`; 13581 } 13582 selector = hrefAttribute && hrefAttribute !== '#' ? parseSelector(hrefAttribute.trim()) : null; 13583 } 13584 return selector
vendor: 25,815 bytes, lines 13584-14450
13584; 13585}; 13586const SelectorEngine = { 13587 find(selector, element = document.documentElement) { 13588 return [].concat(...Element.prototype.querySelectorAll.call(element, selector)); 13589 }, 13590 findOne(selector, element = document.documentElement) { 13591 return Element.prototype.querySelector.call(element, selector); 13592 }, 13593 children(element, selector) { 13594 return [].concat(...element.children).filter(child => child.matches(selector)); 13595 }, 13596 parents(element, selector) { 13597 const parents = []; 13598 let ancestor = element.parentNode.closest(selector); 13599 while (ancestor) { 13600 parents.push(ancestor); 13601 ancestor = ancestor.parentNode.closest(selector); 13602 } 13603 return parents; 13604 }, 13605 prev(element, selector) { 13606 let previous = element.previousElementSibling; 13607 while (previous) { 13608 if (previous.matches(selector)) { 13609 return [previous]; 13610 } 13611 previous = previous.previousElementSibling; 13612 } 13613 return []; 13614 }, 13615 // TODO: this is now unused; remove later along with prev() 13616 next(element, selector) { 13617 let next = element.nextElementSibling; 13618 while (next) { 13619 if (next.matches(selector)) { 13620 return [next]; 13621 } 13622 next = next.nextElementSibling; 13623 } 13624 return []; 13625 }, 13626 focusableChildren(element) { 13627 const focusables = ['a', 'button', 'input', 'textarea', 'select', 'details', '[tabindex]', '[contenteditable="true"]'].map(selector => `${selector}:not([tabindex^="-"])`).join(','); 13628 return this.find(focusables, element).filter(el => !isDisabled(el) && isVisible(el)); 13629 }, 13630 getSelectorFromElement(element) { 13631 const selector = getSelector(element); 13632 if (selector) { 13633 return SelectorEngine.findOne(selector) ? selector : null; 13634 } 13635 return null; 13636 }, 13637 getElementFromSelector(element) { 13638 const selector = getSelector(element); 13639 return selector ? SelectorEngine.findOne(selector) : null; 13640 }, 13641 getMultipleElementsFromSelector(element) { 13642 const selector = getSelector(element); 13643 return selector ? SelectorEngine.find(selector) : []; 13644 } 13645}; 13646 13647/** 13648 * -------------------------------------------------------------------------- 13649 * Bootstrap util/component-functions.js 13650 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 13651 * -------------------------------------------------------------------------- 13652 */ 13653 13654const enableDismissTrigger = (component, method = 'hide') => { 13655 const clickEvent = `click.dismiss${component.EVENT_KEY}`; 13656 const name = component.NAME; 13657 EventHandler.on(document, clickEvent, `[data-bs-dismiss="${name}"]`, function (event) { 13658 if (['A', 'AREA'].includes(this.tagName)) { 13659 event.preventDefault(); 13660 } 13661 if (isDisabled(this)) { 13662 return; 13663 } 13664 const target = SelectorEngine.getElementFromSelector(this) || this.closest(`.${name}`); 13665 const instance = component.getOrCreateInstance(target); 13666 13667 // Method argument is left, for Alert and only, as it doesn't implement the 'hide' method 13668 instance[method](); 13669 }); 13670}; 13671 13672/** 13673 * -------------------------------------------------------------------------- 13674 * Bootstrap alert.js 13675 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 13676 * -------------------------------------------------------------------------- 13677 */ 13678 13679 13680/** 13681 * Constants 13682 */ 13683 13684const NAME$f = 'alert'; 13685const DATA_KEY$a = 'bs.alert'; 13686const EVENT_KEY$b = `.${DATA_KEY$a}`; 13687const EVENT_CLOSE = `close${EVENT_KEY$b}`; 13688const EVENT_CLOSED = `closed${EVENT_KEY$b}`; 13689const CLASS_NAME_FADE$5 = 'fade'; 13690const CLASS_NAME_SHOW$8 = 'show'; 13691 13692/** 13693 * Class definition 13694 */ 13695 13696class Alert extends BaseComponent { 13697 // Getters 13698 static get NAME() { 13699 return NAME$f; 13700 } 13701 13702 // Public 13703 close() { 13704 const closeEvent = EventHandler.trigger(this._element, EVENT_CLOSE); 13705 if (closeEvent.defaultPrevented) { 13706 return; 13707 } 13708 this._element.classList.remove(CLASS_NAME_SHOW$8); 13709 const isAnimated = this._element.classList.contains(CLASS_NAME_FADE$5); 13710 this._queueCallback(() => this._destroyElement(), this._element, isAnimated); 13711 } 13712 13713 // Private 13714 _destroyElement() { 13715 this._element.remove(); 13716 EventHandler.trigger(this._element, EVENT_CLOSED); 13717 this.dispose(); 13718 } 13719 13720 // Static 13721 static jQueryInterface(config) { 13722 return this.each(function () { 13723 const data = Alert.getOrCreateInstance(this); 13724 if (typeof config !== 'string') { 13725 return; 13726 } 13727 if (data[config] === undefined || config.startsWith('_') || config === 'constructor') { 13728 throw new TypeError(`No method named "${config}"`); 13729 } 13730 data[config](this); 13731 }); 13732 } 13733} 13734 13735/** 13736 * Data API implementation 13737 */ 13738 13739enableDismissTrigger(Alert, 'close'); 13740 13741/** 13742 * jQuery 13743 */ 13744 13745defineJQueryPlugin(Alert); 13746 13747/** 13748 * -------------------------------------------------------------------------- 13749 * Bootstrap button.js 13750 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 13751 * -------------------------------------------------------------------------- 13752 */ 13753 13754 13755/** 13756 * Constants 13757 */ 13758 13759const NAME$e = 'button'; 13760const DATA_KEY$9 = 'bs.button'; 13761const EVENT_KEY$a = `.${DATA_KEY$9}`; 13762const DATA_API_KEY$6 = '.data-api'; 13763const CLASS_NAME_ACTIVE$3 = 'active'; 13764const SELECTOR_DATA_TOGGLE$5 = '[data-bs-toggle="button"]'; 13765const EVENT_CLICK_DATA_API$6 = `click${EVENT_KEY$a}${DATA_API_KEY$6}`; 13766 13767/** 13768 * Class definition 13769 */ 13770 13771class Button extends BaseComponent { 13772 // Getters 13773 static get NAME() { 13774 return NAME$e; 13775 } 13776 13777 // Public 13778 toggle() { 13779 // Toggle class and sync the `aria-pressed` attribute with the return value of the `.toggle()` method 13780 this._element.setAttribute('aria-pressed', this._element.classList.toggle(CLASS_NAME_ACTIVE$3)); 13781 } 13782 13783 // Static 13784 static jQueryInterface(config) { 13785 return this.each(function () { 13786 const data = Button.getOrCreateInstance(this); 13787 if (config === 'toggle') { 13788 data[config](); 13789 } 13790 }); 13791 } 13792} 13793 13794/** 13795 * Data API implementation 13796 */ 13797 13798EventHandler.on(document, EVENT_CLICK_DATA_API$6, SELECTOR_DATA_TOGGLE$5, event => { 13799 event.preventDefault(); 13800 const button = event.target.closest(SELECTOR_DATA_TOGGLE$5); 13801 const data = Button.getOrCreateInstance(button); 13802 data.toggle(); 13803}); 13804 13805/** 13806 * jQuery 13807 */ 13808 13809defineJQueryPlugin(Button); 13810 13811/** 13812 * -------------------------------------------------------------------------- 13813 * Bootstrap util/swipe.js 13814 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 13815 * -------------------------------------------------------------------------- 13816 */ 13817 13818 13819/** 13820 * Constants 13821 */ 13822 13823const NAME$d = 'swipe'; 13824const EVENT_KEY$9 = '.bs.swipe'; 13825const EVENT_TOUCHSTART = `touchstart${EVENT_KEY$9}`; 13826const EVENT_TOUCHMOVE = `touchmove${EVENT_KEY$9}`; 13827const EVENT_TOUCHEND = `touchend${EVENT_KEY$9}`; 13828const EVENT_POINTERDOWN = `pointerdown${EVENT_KEY$9}`; 13829const EVENT_POINTERUP = `pointerup${EVENT_KEY$9}`; 13830const POINTER_TYPE_TOUCH = 'touch'; 13831const POINTER_TYPE_PEN = 'pen'; 13832const CLASS_NAME_POINTER_EVENT = 'pointer-event'; 13833const SWIPE_THRESHOLD = 40; 13834const Default$c = { 13835 endCallback: null, 13836 leftCallback: null, 13837 rightCallback: null 13838}; 13839const DefaultType$c = { 13840 endCallback: '(function|null)', 13841 leftCallback: '(function|null)', 13842 rightCallback: '(function|null)' 13843}; 13844 13845/** 13846 * Class definition 13847 */ 13848 13849class Swipe extends Config { 13850 constructor(element, config) { 13851 super(); 13852 this._element = element; 13853 if (!element || !Swipe.isSupported()) { 13854 return; 13855 } 13856 this._config = this._getConfig(config); 13857 this._deltaX = 0; 13858 this._supportPointerEvents = Boolean(window.PointerEvent); 13859 this._initEvents(); 13860 } 13861 13862 // Getters 13863 static get Default() { 13864 return Default$c; 13865 } 13866 static get DefaultType() { 13867 return DefaultType$c; 13868 } 13869 static get NAME() { 13870 return NAME$d; 13871 } 13872 13873 // Public 13874 dispose() { 13875 EventHandler.off(this._element, EVENT_KEY$9); 13876 } 13877 13878 // Private 13879 _start(event) { 13880 if (!this._supportPointerEvents) { 13881 this._deltaX = event.touches[0].clientX; 13882 return; 13883 } 13884 if (this._eventIsPointerPenTouch(event)) { 13885 this._deltaX = event.clientX; 13886 } 13887 } 13888 _end(event) { 13889 if (this._eventIsPointerPenTouch(event)) { 13890 this._deltaX = event.clientX - this._deltaX; 13891 } 13892 this._handleSwipe(); 13893 execute(this._config.endCallback); 13894 } 13895 _move(event) { 13896 this._deltaX = event.touches && event.touches.length > 1 ? 0 : event.touches[0].clientX - this._deltaX; 13897 } 13898 _handleSwipe() { 13899 const absDeltaX = Math.abs(this._deltaX); 13900 if (absDeltaX <= SWIPE_THRESHOLD) { 13901 return; 13902 } 13903 const direction = absDeltaX / this._deltaX; 13904 this._deltaX = 0; 13905 if (!direction) { 13906 return; 13907 } 13908 execute(direction > 0 ? this._config.rightCallback : this._config.leftCallback); 13909 } 13910 _initEvents() { 13911 if (this._supportPointerEvents) { 13912 EventHandler.on(this._element, EVENT_POINTERDOWN, event => this._start(event)); 13913 EventHandler.on(this._element, EVENT_POINTERUP, event => this._end(event)); 13914 this._element.classList.add(CLASS_NAME_POINTER_EVENT); 13915 } else { 13916 EventHandler.on(this._element, EVENT_TOUCHSTART, event => this._start(event)); 13917 EventHandler.on(this._element, EVENT_TOUCHMOVE, event => this._move(event)); 13918 EventHandler.on(this._element, EVENT_TOUCHEND, event => this._end(event)); 13919 } 13920 } 13921 _eventIsPointerPenTouch(event) { 13922 return this._supportPointerEvents && (event.pointerType === POINTER_TYPE_PEN || event.pointerType === POINTER_TYPE_TOUCH); 13923 } 13924 13925 // Static 13926 static isSupported() { 13927 return 'ontouchstart' in document.documentElement || navigator.maxTouchPoints > 0; 13928 } 13929} 13930 13931/** 13932 * -------------------------------------------------------------------------- 13933 * Bootstrap carousel.js 13934 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 13935 * -------------------------------------------------------------------------- 13936 */ 13937 13938 13939/** 13940 * Constants 13941 */ 13942 13943const NAME$c = 'carousel'; 13944const DATA_KEY$8 = 'bs.carousel'; 13945const EVENT_KEY$8 = `.${DATA_KEY$8}`; 13946const DATA_API_KEY$5 = '.data-api'; 13947const ARROW_LEFT_KEY$1 = 'ArrowLeft'; 13948const ARROW_RIGHT_KEY$1 = 'ArrowRight'; 13949const TOUCHEVENT_COMPAT_WAIT = 500; // Time for mouse compat events to fire after touch 13950 13951const ORDER_NEXT = 'next'; 13952const ORDER_PREV = 'prev'; 13953const DIRECTION_LEFT = 'left'; 13954const DIRECTION_RIGHT = 'right'; 13955const EVENT_SLIDE = `slide${EVENT_KEY$8}`; 13956const EVENT_SLID = `slid${EVENT_KEY$8}`; 13957const EVENT_KEYDOWN$1 = `keydown${EVENT_KEY$8}`; 13958const EVENT_MOUSEENTER$1 = `mouseenter${EVENT_KEY$8}`; 13959const EVENT_MOUSELEAVE$1 = `mouseleave${EVENT_KEY$8}`; 13960const EVENT_DRAG_START = `dragstart${EVENT_KEY$8}`; 13961const EVENT_LOAD_DATA_API$3 = `load${EVENT_KEY$8}${DATA_API_KEY$5}`; 13962const EVENT_CLICK_DATA_API$5 = `click${EVENT_KEY$8}${DATA_API_KEY$5}`; 13963const CLASS_NAME_CAROUSEL = 'carousel'; 13964const CLASS_NAME_ACTIVE$2 = 'active'; 13965const CLASS_NAME_SLIDE = 'slide'; 13966const CLASS_NAME_END = 'carousel-item-end'; 13967const CLASS_NAME_START = 'carousel-item-start'; 13968const CLASS_NAME_NEXT = 'carousel-item-next'; 13969const CLASS_NAME_PREV = 'carousel-item-prev'; 13970const SELECTOR_ACTIVE = '.active'; 13971const SELECTOR_ITEM = '.carousel-item'; 13972const SELECTOR_ACTIVE_ITEM = SELECTOR_ACTIVE + SELECTOR_ITEM; 13973const SELECTOR_ITEM_IMG = '.carousel-item img'; 13974const SELECTOR_INDICATORS = '.carousel-indicators'; 13975const SELECTOR_DATA_SLIDE = '[data-bs-slide], [data-bs-slide-to]'; 13976const SELECTOR_DATA_RIDE = '[data-bs-ride="carousel"]'; 13977const KEY_TO_DIRECTION = { 13978 [ARROW_LEFT_KEY$1]: DIRECTION_RIGHT, 13979 [ARROW_RIGHT_KEY$1]: DIRECTION_LEFT 13980}; 13981const Default$b = { 13982 interval: 5000, 13983 keyboard: true, 13984 pause: 'hover', 13985 ride: false, 13986 touch: true, 13987 wrap: true 13988}; 13989const DefaultType$b = { 13990 interval: '(number|boolean)', 13991 // TODO:v6 remove boolean support 13992 keyboard: 'boolean', 13993 pause: '(string|boolean)', 13994 ride: '(boolean|string)', 13995 touch: 'boolean', 13996 wrap: 'boolean' 13997}; 13998 13999/** 14000 * Class definition 14001 */ 14002 14003class Carousel extends BaseComponent { 14004 constructor(element, config) { 14005 super(element, config); 14006 this._interval = null; 14007 this._activeElement = null; 14008 this._isSliding = false; 14009 this.touchTimeout = null; 14010 this._swipeHelper = null; 14011 this._indicatorsElement = SelectorEngine.findOne(SELECTOR_INDICATORS, this._element); 14012 this._addEventListeners(); 14013 if (this._config.ride === CLASS_NAME_CAROUSEL) { 14014 this.cycle(); 14015 } 14016 } 14017 14018 // Getters 14019 static get Default() { 14020 return Default$b; 14021 } 14022 static get DefaultType() { 14023 return DefaultType$b; 14024 } 14025 static get NAME() { 14026 return NAME$c; 14027 } 14028 14029 // Public 14030 next() { 14031 this._slide(ORDER_NEXT); 14032 } 14033 nextWhenVisible() { 14034 // FIXME TODO use `document.visibilityState` 14035 // Don't call next when the page isn't visible 14036 // or the carousel or its parent isn't visible 14037 if (!document.hidden && isVisible(this._element)) { 14038 this.next(); 14039 } 14040 } 14041 prev() { 14042 this._slide(ORDER_PREV); 14043 } 14044 pause() { 14045 if (this._isSliding) { 14046 triggerTransitionEnd(this._element); 14047 } 14048 this._clearInterval(); 14049 } 14050 cycle() { 14051 this._clearInterval(); 14052 this._updateInterval(); 14053 this._interval = setInterval(() => this.nextWhenVisible(), this._config.interval); 14054 } 14055 _maybeEnableCycle() { 14056 if (!this._config.ride) { 14057 return; 14058 } 14059 if (this._isSliding) { 14060 EventHandler.one(this._element, EVENT_SLID, () => this.cycle()); 14061 return; 14062 } 14063 this.cycle(); 14064 } 14065 to(index) { 14066 const items = this._getItems(); 14067 if (index > items.length - 1 || index < 0) { 14068 return; 14069 } 14070 if (this._isSliding) { 14071 EventHandler.one(this._element, EVENT_SLID, () => this.to(index)); 14072 return; 14073 } 14074 const activeIndex = this._getItemIndex(this._getActive()); 14075 if (activeIndex === index) { 14076 return; 14077 } 14078 const order = index > activeIndex ? ORDER_NEXT : ORDER_PREV; 14079 this._slide(order, items[index]); 14080 } 14081 dispose() { 14082 if (this._swipeHelper) { 14083 this._swipeHelper.dispose(); 14084 } 14085 super.dispose(); 14086 } 14087 14088 // Private 14089 _configAfterMerge(config) { 14090 config.defaultInterval = config.interval; 14091 return config; 14092 } 14093 _addEventListeners() { 14094 if (this._config.keyboard) { 14095 EventHandler.on(this._element, EVENT_KEYDOWN$1, event => this._keydown(event)); 14096 } 14097 if (this._config.pause === 'hover') { 14098 EventHandler.on(this._element, EVENT_MOUSEENTER$1, () => this.pause()); 14099 EventHandler.on(this._element, EVENT_MOUSELEAVE$1, () => this._maybeEnableCycle()); 14100 } 14101 if (this._config.touch && Swipe.isSupported()) { 14102 this._addTouchEventListeners(); 14103 } 14104 } 14105 _addTouchEventListeners() { 14106 for (const img of SelectorEngine.find(SELECTOR_ITEM_IMG, this._element)) { 14107 EventHandler.on(img, EVENT_DRAG_START, event => event.preventDefault()); 14108 } 14109 const endCallBack = () => { 14110 if (this._config.pause !== 'hover') { 14111 return; 14112 } 14113 14114 // If it's a touch-enabled device, mouseenter/leave are fired as 14115 // part of the mouse compatibility events on first tap - the carousel 14116 // would stop cycling until user tapped out of it; 14117 // here, we listen for touchend, explicitly pause the carousel 14118 // (as if it's the second time we tap on it, mouseenter compat event 14119 // is NOT fired) and after a timeout (to allow for mouse compatibility 14120 // events to fire) we explicitly restart cycling 14121 14122 this.pause(); 14123 if (this.touchTimeout) { 14124 clearTimeout(this.touchTimeout); 14125 } 14126 this.touchTimeout = setTimeout(() => this._maybeEnableCycle(), TOUCHEVENT_COMPAT_WAIT + this._config.interval); 14127 }; 14128 const swipeConfig = { 14129 leftCallback: () => this._slide(this._directionToOrder(DIRECTION_LEFT)), 14130 rightCallback: () => this._slide(this._directionToOrder(DIRECTION_RIGHT)), 14131 endCallback: endCallBack 14132 }; 14133 this._swipeHelper = new Swipe(this._element, swipeConfig); 14134 } 14135 _keydown(event) { 14136 if (/input|textarea/i.test(event.target.tagName)) { 14137 return; 14138 } 14139 const direction = KEY_TO_DIRECTION[event.key]; 14140 if (direction) { 14141 event.preventDefault(); 14142 this._slide(this._directionToOrder(direction)); 14143 } 14144 } 14145 _getItemIndex(element) { 14146 return this._getItems().indexOf(element); 14147 } 14148 _setActiveIndicatorElement(index) { 14149 if (!this._indicatorsElement) { 14150 return; 14151 } 14152 const activeIndicator = SelectorEngine.findOne(SELECTOR_ACTIVE, this._indicatorsElement); 14153 activeIndicator.classList.remove(CLASS_NAME_ACTIVE$2); 14154 activeIndicator.removeAttribute('aria-current'); 14155 const newActiveIndicator = SelectorEngine.findOne(`[data-bs-slide-to="${index}"]`, this._indicatorsElement); 14156 if (newActiveIndicator) { 14157 newActiveIndicator.classList.add(CLASS_NAME_ACTIVE$2); 14158 newActiveIndicator.setAttribute('aria-current', 'true'); 14159 } 14160 } 14161 _updateInterval() { 14162 const element = this._activeElement || this._getActive(); 14163 if (!element) { 14164 return; 14165 } 14166 const elementInterval = Number.parseInt(element.getAttribute('data-bs-interval'), 10); 14167 this._config.interval = elementInterval || this._config.defaultInterval; 14168 } 14169 _slide(order, element = null) { 14170 if (this._isSliding) { 14171 return; 14172 } 14173 const activeElement = this._getActive(); 14174 const isNext = order === ORDER_NEXT; 14175 const nextElement = element || getNextActiveElement(this._getItems(), activeElement, isNext, this._config.wrap); 14176 if (nextElement === activeElement) { 14177 return; 14178 } 14179 const nextElementIndex = this._getItemIndex(nextElement); 14180 const triggerEvent = eventName => { 14181 return EventHandler.trigger(this._element, eventName, { 14182 relatedTarget: nextElement, 14183 direction: this._orderToDirection(order), 14184 from: this._getItemIndex(activeElement), 14185 to: nextElementIndex 14186 }); 14187 }; 14188 const slideEvent = triggerEvent(EVENT_SLIDE); 14189 if (slideEvent.defaultPrevented) { 14190 return; 14191 } 14192 if (!activeElement || !nextElement) { 14193 // Some weirdness is happening, so we bail 14194 // TODO: change tests that use empty divs to avoid this check 14195 return; 14196 } 14197 const isCycling = Boolean(this._interval); 14198 this.pause(); 14199 this._isSliding = true; 14200 this._setActiveIndicatorElement(nextElementIndex); 14201 this._activeElement = nextElement; 14202 const directionalClassName = isNext ? CLASS_NAME_START : CLASS_NAME_END; 14203 const orderClassName = isNext ? CLASS_NAME_NEXT : CLASS_NAME_PREV; 14204 nextElement.classList.add(orderClassName); 14205 reflow(nextElement); 14206 activeElement.classList.add(directionalClassName); 14207 nextElement.classList.add(directionalClassName); 14208 const completeCallBack = () => { 14209 nextElement.classList.remove(directionalClassName, orderClassName); 14210 nextElement.classList.add(CLASS_NAME_ACTIVE$2); 14211 activeElement.classList.remove(CLASS_NAME_ACTIVE$2, orderClassName, directionalClassName); 14212 this._isSliding = false; 14213 triggerEvent(EVENT_SLID); 14214 }; 14215 this._queueCallback(completeCallBack, activeElement, this._isAnimated()); 14216 if (isCycling) { 14217 this.cycle(); 14218 } 14219 } 14220 _isAnimated() { 14221 return this._element.classList.contains(CLASS_NAME_SLIDE); 14222 } 14223 _getActive() { 14224 return SelectorEngine.findOne(SELECTOR_ACTIVE_ITEM, this._element); 14225 } 14226 _getItems() { 14227 return SelectorEngine.find(SELECTOR_ITEM, this._element); 14228 } 14229 _clearInterval() { 14230 if (this._interval) { 14231 clearInterval(this._interval); 14232 this._interval = null; 14233 } 14234 } 14235 _directionToOrder(direction) { 14236 if (isRTL()) { 14237 return direction === DIRECTION_LEFT ? ORDER_PREV : ORDER_NEXT; 14238 } 14239 return direction === DIRECTION_LEFT ? ORDER_NEXT : ORDER_PREV; 14240 } 14241 _orderToDirection(order) { 14242 if (isRTL()) { 14243 return order === ORDER_PREV ? DIRECTION_LEFT : DIRECTION_RIGHT; 14244 } 14245 return order === ORDER_PREV ? DIRECTION_RIGHT : DIRECTION_LEFT; 14246 } 14247 14248 // Static 14249 static jQueryInterface(config) { 14250 return this.each(function () { 14251 const data = Carousel.getOrCreateInstance(this, config); 14252 if (typeof config === 'number') { 14253 data.to(config); 14254 return; 14255 } 14256 if (typeof config === 'string') { 14257 if (data[config] === undefined || config.startsWith('_') || config === 'constructor') { 14258 throw new TypeError(`No method named "${config}"`); 14259 } 14260 data[config](); 14261 } 14262 }); 14263 } 14264} 14265 14266/** 14267 * Data API implementation 14268 */ 14269 14270EventHandler.on(document, EVENT_CLICK_DATA_API$5, SELECTOR_DATA_SLIDE, function (event) { 14271 const target = SelectorEngine.getElementFromSelector(this); 14272 if (!target || !target.classList.contains(CLASS_NAME_CAROUSEL)) { 14273 return; 14274 } 14275 event.preventDefault(); 14276 const carousel = Carousel.getOrCreateInstance(target); 14277 const slideIndex = this.getAttribute('data-bs-slide-to'); 14278 if (slideIndex) { 14279 carousel.to(slideIndex); 14280 carousel._maybeEnableCycle(); 14281 return; 14282 } 14283 if (Manipulator.getDataAttribute(this, 'slide') === 'next') { 14284 carousel.next(); 14285 carousel._maybeEnableCycle(); 14286 return; 14287 } 14288 carousel.prev(); 14289 carousel._maybeEnableCycle(); 14290}); 14291EventHandler.on(window, EVENT_LOAD_DATA_API$3, () => { 14292 const carousels = SelectorEngine.find(SELECTOR_DATA_RIDE); 14293 for (const carousel of carousels) { 14294 Carousel.getOrCreateInstance(carousel); 14295 } 14296}); 14297 14298/** 14299 * jQuery 14300 */ 14301 14302defineJQueryPlugin(Carousel); 14303 14304/** 14305 * -------------------------------------------------------------------------- 14306 * Bootstrap collapse.js 14307 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 14308 * -------------------------------------------------------------------------- 14309 */ 14310 14311 14312/** 14313 * Constants 14314 */ 14315 14316const NAME$b = 'collapse'; 14317const DATA_KEY$7 = 'bs.collapse'; 14318const EVENT_KEY$7 = `.${DATA_KEY$7}`; 14319const DATA_API_KEY$4 = '.data-api'; 14320const EVENT_SHOW$6 = `show${EVENT_KEY$7}`; 14321const EVENT_SHOWN$6 = `shown${EVENT_KEY$7}`; 14322const EVENT_HIDE$6 = `hide${EVENT_KEY$7}`; 14323const EVENT_HIDDEN$6 = `hidden${EVENT_KEY$7}`; 14324const EVENT_CLICK_DATA_API$4 = `click${EVENT_KEY$7}${DATA_API_KEY$4}`; 14325const CLASS_NAME_SHOW$7 = 'show'; 14326const CLASS_NAME_COLLAPSE = 'collapse'; 14327const CLASS_NAME_COLLAPSING = 'collapsing'; 14328const CLASS_NAME_COLLAPSED = 'collapsed'; 14329const CLASS_NAME_DEEPER_CHILDREN = `:scope .${CLASS_NAME_COLLAPSE} .${CLASS_NAME_COLLAPSE}`; 14330const CLASS_NAME_HORIZONTAL = 'collapse-horizontal'; 14331const WIDTH = 'width'; 14332const HEIGHT = 'height'; 14333const SELECTOR_ACTIVES = '.collapse.show, .collapse.collapsing'; 14334const SELECTOR_DATA_TOGGLE$4 = '[data-bs-toggle="collapse"]'; 14335const Default$a = { 14336 parent: null, 14337 toggle: true 14338}; 14339const DefaultType$a = { 14340 parent: '(null|element)', 14341 toggle: 'boolean' 14342}; 14343 14344/** 14345 * Class definition 14346 */ 14347 14348class Collapse extends BaseComponent { 14349 constructor(element, config) { 14350 super(element, config); 14351 this._isTransitioning = false; 14352 this._triggerArray = []; 14353 const toggleList = SelectorEngine.find(SELECTOR_DATA_TOGGLE$4); 14354 for (const elem of toggleList) { 14355 const selector = SelectorEngine.getSelectorFromElement(elem); 14356 const filterElement = SelectorEngine.find(selector).filter(foundElement => foundElement === this._element); 14357 if (selector !== null && filterElement.length) { 14358 this._triggerArray.push(elem); 14359 } 14360 } 14361 this._initializeChildren(); 14362 if (!this._config.parent) { 14363 this._addAriaAndCollapsedClass(this._triggerArray, this._isShown()); 14364 } 14365 if (this._config.toggle) { 14366 this.toggle(); 14367 } 14368 } 14369 14370 // Getters 14371 static get Default() { 14372 return Default$a; 14373 } 14374 static get DefaultType() { 14375 return DefaultType$a; 14376 } 14377 static get NAME() { 14378 return NAME$b; 14379 } 14380 14381 // Public 14382 toggle() { 14383 if (this._isShown()) { 14384 this.hide(); 14385 } else { 14386 this.show(); 14387 } 14388 } 14389 show() { 14390 if (this._isTransitioning || this._isShown()) { 14391 return; 14392 } 14393 let activeChildren = []; 14394 14395 // find active children 14396 if (this._config.parent) { 14397 activeChildren = this._getFirstLevelChildren(SELECTOR_ACTIVES).filter(element => element !== this._element).map(element => Collapse.getOrCreateInstance(element, { 14398 toggle: false 14399 })); 14400 } 14401 if (activeChildren.length && activeChildren[0]._isTransitioning) { 14402 return; 14403 } 14404 const startEvent = EventHandler.trigger(this._element, EVENT_SHOW$6); 14405 if (startEvent.defaultPrevented) { 14406 return; 14407 } 14408 for (const activeInstance of activeChildren) { 14409 activeInstance.hide(); 14410 } 14411 const dimension = this._getDimension(); 14412 this._element.classList.remove(CLASS_NAME_COLLAPSE); 14413 this._element.classList.add(CLASS_NAME_COLLAPSING); 14414 this._element.style[dimension] = 0; 14415 this._addAriaAndCollapsedClass(this._triggerArray, true); 14416 this._isTransitioning = true; 14417 const complete = () => { 14418 this._isTransitioning = false; 14419 this._element.classList.remove(CLASS_NAME_COLLAPSING); 14420 this._element.classList.add(CLASS_NAME_COLLAPSE, CLASS_NAME_SHOW$7); 14421 this._element.style[dimension] = ''; 14422 EventHandler.trigger(this._element, EVENT_SHOWN$6); 14423 }; 14424 const capitalizedDimension = dimension[0].toUpperCase() + dimension.slice(1); 14425 const scrollSize = `scroll${capitalizedDimension}`; 14426 this._queueCallback(complete, this._element, true); 14427 this._element.style[dimension] = `${this._element[scrollSize]}px`; 14428 } 14429 hide() { 14430 if (this._isTransitioning || !this._isShown()) { 14431 return; 14432 } 14433 const startEvent = EventHandler.trigger(this._element, EVENT_HIDE$6); 14434 if (startEvent.defaultPrevented) { 14435 return; 14436 } 14437 const dimension = this._getDimension(); 14438 this._element.style[dimension] = `${this._element.getBoundingClientRect()[dimension]}px`; 14439 reflow(this._element); 14440 this._element.classList.add(CLASS_NAME_COLLAPSING); 14441 this._element.classList.remove(CLASS_NAME_COLLAPSE, CLASS_NAME_SHOW$7); 14442 for (const trigger of this._triggerArray) { 14443 const element = SelectorEngine.getElementFromSelector(trigger); 14444 if (element && !this._isShown(element)) { 14445 this._addAriaAndCollapsedClass([trigger], false); 14446 } 14447 } 14448 this._isTransitioning = true; 14449 const complete = () => { 14450 this._isTransitioning = false;
vendor: 8,488 bytes, lines 14451-14708
14451 this._element.classList.remove(CLASS_NAME_COLLAPSING); 14452 this._element.classList.add(CLASS_NAME_COLLAPSE); 14453 EventHandler.trigger(this._element, EVENT_HIDDEN$6); 14454 }; 14455 this._element.style[dimension] = ''; 14456 this._queueCallback(complete, this._element, true); 14457 } 14458 _isShown(element = this._element) { 14459 return element.classList.contains(CLASS_NAME_SHOW$7); 14460 } 14461 14462 // Private 14463 _configAfterMerge(config) { 14464 config.toggle = Boolean(config.toggle); // Coerce string values 14465 config.parent = getElement(config.parent); 14466 return config; 14467 } 14468 _getDimension() { 14469 return this._element.classList.contains(CLASS_NAME_HORIZONTAL) ? WIDTH : HEIGHT; 14470 } 14471 _initializeChildren() { 14472 if (!this._config.parent) { 14473 return; 14474 } 14475 const children = this._getFirstLevelChildren(SELECTOR_DATA_TOGGLE$4); 14476 for (const element of children) { 14477 const selected = SelectorEngine.getElementFromSelector(element); 14478 if (selected) { 14479 this._addAriaAndCollapsedClass([element], this._isShown(selected)); 14480 } 14481 } 14482 } 14483 _getFirstLevelChildren(selector) { 14484 const children = SelectorEngine.find(CLASS_NAME_DEEPER_CHILDREN, this._config.parent); 14485 // remove children if greater depth 14486 return SelectorEngine.find(selector, this._config.parent).filter(element => !children.includes(element)); 14487 } 14488 _addAriaAndCollapsedClass(triggerArray, isOpen) { 14489 if (!triggerArray.length) { 14490 return; 14491 } 14492 for (const element of triggerArray) { 14493 element.classList.toggle(CLASS_NAME_COLLAPSED, !isOpen); 14494 element.setAttribute('aria-expanded', isOpen); 14495 } 14496 } 14497 14498 // Static 14499 static jQueryInterface(config) { 14500 const _config = {}; 14501 if (typeof config === 'string' && /show|hide/.test(config)) { 14502 _config.toggle = false; 14503 } 14504 return this.each(function () { 14505 const data = Collapse.getOrCreateInstance(this, _config); 14506 if (typeof config === 'string') { 14507 if (typeof data[config] === 'undefined') { 14508 throw new TypeError(`No method named "${config}"`); 14509 } 14510 data[config](); 14511 } 14512 }); 14513 } 14514} 14515 14516/** 14517 * Data API implementation 14518 */ 14519 14520EventHandler.on(document, EVENT_CLICK_DATA_API$4, SELECTOR_DATA_TOGGLE$4, function (event) { 14521 // preventDefault only for <a> elements (which change the URL) not inside the collapsible element 14522 if (event.target.tagName === 'A' || event.delegateTarget && event.delegateTarget.tagName === 'A') { 14523 event.preventDefault(); 14524 } 14525 for (const element of SelectorEngine.getMultipleElementsFromSelector(this)) { 14526 Collapse.getOrCreateInstance(element, { 14527 toggle: false 14528 }).toggle(); 14529 } 14530}); 14531 14532/** 14533 * jQuery 14534 */ 14535 14536defineJQueryPlugin(Collapse); 14537 14538/** 14539 * -------------------------------------------------------------------------- 14540 * Bootstrap dropdown.js 14541 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 14542 * -------------------------------------------------------------------------- 14543 */ 14544 14545 14546/** 14547 * Constants 14548 */ 14549 14550const NAME$a = 'dropdown'; 14551const DATA_KEY$6 = 'bs.dropdown'; 14552const EVENT_KEY$6 = `.${DATA_KEY$6}`; 14553const DATA_API_KEY$3 = '.data-api'; 14554const ESCAPE_KEY$2 = 'Escape'; 14555const TAB_KEY$1 = 'Tab'; 14556const ARROW_UP_KEY$1 = 'ArrowUp'; 14557const ARROW_DOWN_KEY$1 = 'ArrowDown'; 14558const RIGHT_MOUSE_BUTTON = 2; // MouseEvent.button value for the secondary button, usually the right button 14559 14560const EVENT_HIDE$5 = `hide${EVENT_KEY$6}`; 14561const EVENT_HIDDEN$5 = `hidden${EVENT_KEY$6}`; 14562const EVENT_SHOW$5 = `show${EVENT_KEY$6}`; 14563const EVENT_SHOWN$5 = `shown${EVENT_KEY$6}`; 14564const EVENT_CLICK_DATA_API$3 = `click${EVENT_KEY$6}${DATA_API_KEY$3}`; 14565const EVENT_KEYDOWN_DATA_API = `keydown${EVENT_KEY$6}${DATA_API_KEY$3}`; 14566const EVENT_KEYUP_DATA_API = `keyup${EVENT_KEY$6}${DATA_API_KEY$3}`; 14567const CLASS_NAME_SHOW$6 = 'show'; 14568const CLASS_NAME_DROPUP = 'dropup'; 14569const CLASS_NAME_DROPEND = 'dropend'; 14570const CLASS_NAME_DROPSTART = 'dropstart'; 14571const CLASS_NAME_DROPUP_CENTER = 'dropup-center'; 14572const CLASS_NAME_DROPDOWN_CENTER = 'dropdown-center'; 14573const SELECTOR_DATA_TOGGLE$3 = '[data-bs-toggle="dropdown"]:not(.disabled):not(:disabled)'; 14574const SELECTOR_DATA_TOGGLE_SHOWN = `${SELECTOR_DATA_TOGGLE$3}.${CLASS_NAME_SHOW$6}`; 14575const SELECTOR_MENU = '.dropdown-menu'; 14576const SELECTOR_NAVBAR = '.navbar'; 14577const SELECTOR_NAVBAR_NAV = '.navbar-nav'; 14578const SELECTOR_VISIBLE_ITEMS = '.dropdown-menu .dropdown-item:not(.disabled):not(:disabled)'; 14579const PLACEMENT_TOP = isRTL() ? 'top-end' : 'top-start'; 14580const PLACEMENT_TOPEND = isRTL() ? 'top-start' : 'top-end'; 14581const PLACEMENT_BOTTOM = isRTL() ? 'bottom-end' : 'bottom-start'; 14582const PLACEMENT_BOTTOMEND = isRTL() ? 'bottom-start' : 'bottom-end'; 14583const PLACEMENT_RIGHT = isRTL() ? 'left-start' : 'right-start'; 14584const PLACEMENT_LEFT = isRTL() ? 'right-start' : 'left-start'; 14585const PLACEMENT_TOPCENTER = 'top'; 14586const PLACEMENT_BOTTOMCENTER = 'bottom'; 14587const Default$9 = { 14588 autoClose: true, 14589 boundary: 'clippingParents', 14590 display: 'dynamic', 14591 offset: [0, 2], 14592 popperConfig: null, 14593 reference: 'toggle' 14594}; 14595const DefaultType$9 = { 14596 autoClose: '(boolean|string)', 14597 boundary: '(string|element)', 14598 display: 'string', 14599 offset: '(array|string|function)', 14600 popperConfig: '(null|object|function)', 14601 reference: '(string|element|object)' 14602}; 14603 14604/** 14605 * Class definition 14606 */ 14607 14608class Dropdown extends BaseComponent { 14609 constructor(element, config) { 14610 super(element, config); 14611 this._popper = null; 14612 this._parent = this._element.parentNode; // dropdown wrapper 14613 // TODO: v6 revert #37011 & change markup https://getbootstrap.com/docs/5.3/forms/input-group/ 14614 this._menu = SelectorEngine.next(this._element, SELECTOR_MENU)[0] || SelectorEngine.prev(this._element, SELECTOR_MENU)[0] || SelectorEngine.findOne(SELECTOR_MENU, this._parent); 14615 this._inNavbar = this._detectNavbar(); 14616 } 14617 14618 // Getters 14619 static get Default() { 14620 return Default$9; 14621 } 14622 static get DefaultType() { 14623 return DefaultType$9; 14624 } 14625 static get NAME() { 14626 return NAME$a; 14627 } 14628 14629 // Public 14630 toggle() { 14631 return this._isShown() ? this.hide() : this.show(); 14632 } 14633 show() { 14634 if (isDisabled(this._element) || this._isShown()) { 14635 return; 14636 } 14637 const relatedTarget = { 14638 relatedTarget: this._element 14639 }; 14640 const showEvent = EventHandler.trigger(this._element, EVENT_SHOW$5, relatedTarget); 14641 if (showEvent.defaultPrevented) { 14642 return; 14643 } 14644 this._createPopper(); 14645 14646 // If this is a touch-enabled device we add extra 14647 // empty mouseover listeners to the body's immediate children; 14648 // only needed because of broken event delegation on iOS 14649 // https://www.quirksmode.org/blog/archives/2014/02/mouse_event_bub.html 14650 if ('ontouchstart' in document.documentElement && !this._parent.closest(SELECTOR_NAVBAR_NAV)) { 14651 for (const element of [].concat(...document.body.children)) { 14652 EventHandler.on(element, 'mouseover', noop); 14653 } 14654 } 14655 this._element.focus(); 14656 this._element.setAttribute('aria-expanded', true); 14657 this._menu.classList.add(CLASS_NAME_SHOW$6); 14658 this._element.classList.add(CLASS_NAME_SHOW$6); 14659 EventHandler.trigger(this._element, EVENT_SHOWN$5, relatedTarget); 14660 } 14661 hide() { 14662 if (isDisabled(this._element) || !this._isShown()) { 14663 return; 14664 } 14665 const relatedTarget = { 14666 relatedTarget: this._element 14667 }; 14668 this._completeHide(relatedTarget); 14669 } 14670 dispose() { 14671 if (this._popper) { 14672 this._popper.destroy(); 14673 } 14674 super.dispose(); 14675 } 14676 update() { 14677 this._inNavbar = this._detectNavbar(); 14678 if (this._popper) { 14679 this._popper.update(); 14680 } 14681 } 14682 14683 // Private 14684 _completeHide(relatedTarget) { 14685 const hideEvent = EventHandler.trigger(this._element, EVENT_HIDE$5, relatedTarget); 14686 if (hideEvent.defaultPrevented) { 14687 return; 14688 } 14689 14690 // If this is a touch-enabled device we remove the extra 14691 // empty mouseover listeners we added for iOS support 14692 if ('ontouchstart' in document.documentElement) { 14693 for (const element of [].concat(...document.body.children)) { 14694 EventHandler.off(element, 'mouseover', noop); 14695 } 14696 } 14697 if (this._popper) { 14698 this._popper.destroy(); 14699 } 14700 this._menu.classList.remove(CLASS_NAME_SHOW$6); 14701 this._element.classList.remove(CLASS_NAME_SHOW$6); 14702 this._element.setAttribute('aria-expanded', 'false'); 14703 Manipulator.removeDataAttribute(this._menu, 'popper'); 14704 EventHandler.trigger(this._element, EVENT_HIDDEN$5, relatedTarget); 14705 } 14706 _getConfig(config) { 14707 config = super._getConfig(config); 14708 if (typeof config.reference === 'object' && !
vendor: 977 bytes, lines 14708-14727
14708bootstrap_esm_isElement(config.reference) && typeof config.reference.getBoundingClientRect !== 'function') { 14709 // Popper virtual elements require a getBoundingClientRect method 14710 throw new TypeError(`${NAME$a.toUpperCase()}: Option "reference" provided type "object" without a required "getBoundingClientRect" method.`); 14711 } 14712 return config; 14713 } 14714 _createPopper() { 14715 if (typeof lib_namespaceObject === 'undefined') { 14716 throw new TypeError('Bootstrap\'s dropdowns require Popper (https://popper.js.org)'); 14717 } 14718 let referenceElement = this._element; 14719 if (this._config.reference === 'parent') { 14720 referenceElement = this._parent; 14721 } else if (bootstrap_esm_isElement(this._config.reference)) { 14722 referenceElement = getElement(this._config.reference); 14723 } else if (typeof this._config.reference === 'object') { 14724 referenceElement = this._config.reference; 14725 } 14726 const popperConfig = this._getPopperConfig(); 14727 this._popper = popper_
vendor: 6,257 bytes, lines 14727-14908
14727createPopper(referenceElement, this._menu, popperConfig); 14728 } 14729 _isShown() { 14730 return this._menu.classList.contains(CLASS_NAME_SHOW$6); 14731 } 14732 _getPlacement() { 14733 const parentDropdown = this._parent; 14734 if (parentDropdown.classList.contains(CLASS_NAME_DROPEND)) { 14735 return PLACEMENT_RIGHT; 14736 } 14737 if (parentDropdown.classList.contains(CLASS_NAME_DROPSTART)) { 14738 return PLACEMENT_LEFT; 14739 } 14740 if (parentDropdown.classList.contains(CLASS_NAME_DROPUP_CENTER)) { 14741 return PLACEMENT_TOPCENTER; 14742 } 14743 if (parentDropdown.classList.contains(CLASS_NAME_DROPDOWN_CENTER)) { 14744 return PLACEMENT_BOTTOMCENTER; 14745 } 14746 14747 // We need to trim the value because custom properties can also include spaces 14748 const isEnd = getComputedStyle(this._menu).getPropertyValue('--bs-position').trim() === 'end'; 14749 if (parentDropdown.classList.contains(CLASS_NAME_DROPUP)) { 14750 return isEnd ? PLACEMENT_TOPEND : PLACEMENT_TOP; 14751 } 14752 return isEnd ? PLACEMENT_BOTTOMEND : PLACEMENT_BOTTOM; 14753 } 14754 _detectNavbar() { 14755 return this._element.closest(SELECTOR_NAVBAR) !== null; 14756 } 14757 _getOffset() { 14758 const { 14759 offset 14760 } = this._config; 14761 if (typeof offset === 'string') { 14762 return offset.split(',').map(value => Number.parseInt(value, 10)); 14763 } 14764 if (typeof offset === 'function') { 14765 return popperData => offset(popperData, this._element); 14766 } 14767 return offset; 14768 } 14769 _getPopperConfig() { 14770 const defaultBsPopperConfig = { 14771 placement: this._getPlacement(), 14772 modifiers: [{ 14773 name: 'preventOverflow', 14774 options: { 14775 boundary: this._config.boundary 14776 } 14777 }, { 14778 name: 'offset', 14779 options: { 14780 offset: this._getOffset() 14781 } 14782 }] 14783 }; 14784 14785 // Disable Popper if we have a static display or Dropdown is in Navbar 14786 if (this._inNavbar || this._config.display === 'static') { 14787 Manipulator.setDataAttribute(this._menu, 'popper', 'static'); // TODO: v6 remove 14788 defaultBsPopperConfig.modifiers = [{ 14789 name: 'applyStyles', 14790 enabled: false 14791 }]; 14792 } 14793 return { 14794 ...defaultBsPopperConfig, 14795 ...execute(this._config.popperConfig, [defaultBsPopperConfig]) 14796 }; 14797 } 14798 _selectMenuItem({ 14799 key, 14800 target 14801 }) { 14802 const items = SelectorEngine.find(SELECTOR_VISIBLE_ITEMS, this._menu).filter(element => isVisible(element)); 14803 if (!items.length) { 14804 return; 14805 } 14806 14807 // if target isn't included in items (e.g. when expanding the dropdown) 14808 // allow cycling to get the last item in case key equals ARROW_UP_KEY 14809 getNextActiveElement(items, target, key === ARROW_DOWN_KEY$1, !items.includes(target)).focus(); 14810 } 14811 14812 // Static 14813 static jQueryInterface(config) { 14814 return this.each(function () { 14815 const data = Dropdown.getOrCreateInstance(this, config); 14816 if (typeof config !== 'string') { 14817 return; 14818 } 14819 if (typeof data[config] === 'undefined') { 14820 throw new TypeError(`No method named "${config}"`); 14821 } 14822 data[config](); 14823 }); 14824 } 14825 static clearMenus(event) { 14826 if (event.button === RIGHT_MOUSE_BUTTON || event.type === 'keyup' && event.key !== TAB_KEY$1) { 14827 return; 14828 } 14829 const openToggles = SelectorEngine.find(SELECTOR_DATA_TOGGLE_SHOWN); 14830 for (const toggle of openToggles) { 14831 const context = Dropdown.getInstance(toggle); 14832 if (!context || context._config.autoClose === false) { 14833 continue; 14834 } 14835 const composedPath = event.composedPath(); 14836 const isMenuTarget = composedPath.includes(context._menu); 14837 if (composedPath.includes(context._element) || context._config.autoClose === 'inside' && !isMenuTarget || context._config.autoClose === 'outside' && isMenuTarget) { 14838 continue; 14839 } 14840 14841 // Tab navigation through the dropdown menu or events from contained inputs shouldn't close the menu 14842 if (context._menu.contains(event.target) && (event.type === 'keyup' && event.key === TAB_KEY$1 || /input|select|option|textarea|form/i.test(event.target.tagName))) { 14843 continue; 14844 } 14845 const relatedTarget = { 14846 relatedTarget: context._element 14847 }; 14848 if (event.type === 'click') { 14849 relatedTarget.clickEvent = event; 14850 } 14851 context._completeHide(relatedTarget); 14852 } 14853 } 14854 static dataApiKeydownHandler(event) { 14855 // If not an UP | DOWN | ESCAPE key => not a dropdown command 14856 // If input/textarea && if key is other than ESCAPE => not a dropdown command 14857 14858 const isInput = /input|textarea/i.test(event.target.tagName); 14859 const isEscapeEvent = event.key === ESCAPE_KEY$2; 14860 const isUpOrDownEvent = [ARROW_UP_KEY$1, ARROW_DOWN_KEY$1].includes(event.key); 14861 if (!isUpOrDownEvent && !isEscapeEvent) { 14862 return; 14863 } 14864 if (isInput && !isEscapeEvent) { 14865 return; 14866 } 14867 event.preventDefault(); 14868 14869 // TODO: v6 revert #37011 & change markup https://getbootstrap.com/docs/5.3/forms/input-group/ 14870 const getToggleButton = this.matches(SELECTOR_DATA_TOGGLE$3) ? this : SelectorEngine.prev(this, SELECTOR_DATA_TOGGLE$3)[0] || SelectorEngine.next(this, SELECTOR_DATA_TOGGLE$3)[0] || SelectorEngine.findOne(SELECTOR_DATA_TOGGLE$3, event.delegateTarget.parentNode); 14871 const instance = Dropdown.getOrCreateInstance(getToggleButton); 14872 if (isUpOrDownEvent) { 14873 event.stopPropagation(); 14874 instance.show(); 14875 instance._selectMenuItem(event); 14876 return; 14877 } 14878 if (instance._isShown()) { 14879 // else is escape and we check if it is shown 14880 event.stopPropagation(); 14881 instance.hide(); 14882 getToggleButton.focus(); 14883 } 14884 } 14885} 14886 14887/** 14888 * Data API implementation 14889 */ 14890 14891EventHandler.on(document, EVENT_KEYDOWN_DATA_API, SELECTOR_DATA_TOGGLE$3, Dropdown.dataApiKeydownHandler); 14892EventHandler.on(document, EVENT_KEYDOWN_DATA_API, SELECTOR_MENU, Dropdown.dataApiKeydownHandler); 14893EventHandler.on(document, EVENT_CLICK_DATA_API$3, Dropdown.clearMenus); 14894EventHandler.on(document, EVENT_KEYUP_DATA_API, Dropdown.clearMenus); 14895EventHandler.on(document, EVENT_CLICK_DATA_API$3, SELECTOR_DATA_TOGGLE$3, function (event) { 14896 event.preventDefault(); 14897 Dropdown.getOrCreateInstance(this).toggle(); 14898}); 14899 14900/** 14901 * jQuery 14902 */ 14903 14904defineJQueryPlugin(Dropdown); 14905 14906/** 14907 * -------------------------------------------------------------------------- 14908 * Bootstrap
vendor: 8,753 bytes, lines 14908-15218
14908util/backdrop.js 14909 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 14910 * -------------------------------------------------------------------------- 14911 */ 14912 14913 14914/** 14915 * Constants 14916 */ 14917 14918const NAME$9 = 'backdrop'; 14919const CLASS_NAME_FADE$4 = 'fade'; 14920const CLASS_NAME_SHOW$5 = 'show'; 14921const EVENT_MOUSEDOWN = `mousedown.bs.${NAME$9}`; 14922const Default$8 = { 14923 className: 'modal-backdrop', 14924 clickCallback: null, 14925 isAnimated: false, 14926 isVisible: true, 14927 // if false, we use the backdrop helper without adding any element to the dom 14928 rootElement: 'body' // give the choice to place backdrop under different elements 14929}; 14930 14931const DefaultType$8 = { 14932 className: 'string', 14933 clickCallback: '(function|null)', 14934 isAnimated: 'boolean', 14935 isVisible: 'boolean', 14936 rootElement: '(element|string)' 14937}; 14938 14939/** 14940 * Class definition 14941 */ 14942 14943class Backdrop extends Config { 14944 constructor(config) { 14945 super(); 14946 this._config = this._getConfig(config); 14947 this._isAppended = false; 14948 this._element = null; 14949 } 14950 14951 // Getters 14952 static get Default() { 14953 return Default$8; 14954 } 14955 static get DefaultType() { 14956 return DefaultType$8; 14957 } 14958 static get NAME() { 14959 return NAME$9; 14960 } 14961 14962 // Public 14963 show(callback) { 14964 if (!this._config.isVisible) { 14965 execute(callback); 14966 return; 14967 } 14968 this._append(); 14969 const element = this._getElement(); 14970 if (this._config.isAnimated) { 14971 reflow(element); 14972 } 14973 element.classList.add(CLASS_NAME_SHOW$5); 14974 this._emulateAnimation(() => { 14975 execute(callback); 14976 }); 14977 } 14978 hide(callback) { 14979 if (!this._config.isVisible) { 14980 execute(callback); 14981 return; 14982 } 14983 this._getElement().classList.remove(CLASS_NAME_SHOW$5); 14984 this._emulateAnimation(() => { 14985 this.dispose(); 14986 execute(callback); 14987 }); 14988 } 14989 dispose() { 14990 if (!this._isAppended) { 14991 return; 14992 } 14993 EventHandler.off(this._element, EVENT_MOUSEDOWN); 14994 this._element.remove(); 14995 this._isAppended = false; 14996 } 14997 14998 // Private 14999 _getElement() { 15000 if (!this._element) { 15001 const backdrop = document.createElement('div'); 15002 backdrop.className = this._config.className; 15003 if (this._config.isAnimated) { 15004 backdrop.classList.add(CLASS_NAME_FADE$4); 15005 } 15006 this._element = backdrop; 15007 } 15008 return this._element; 15009 } 15010 _configAfterMerge(config) { 15011 // use getElement() with the default "body" to get a fresh Element on each instantiation 15012 config.rootElement = getElement(config.rootElement); 15013 return config; 15014 } 15015 _append() { 15016 if (this._isAppended) { 15017 return; 15018 } 15019 const element = this._getElement(); 15020 this._config.rootElement.append(element); 15021 EventHandler.on(element, EVENT_MOUSEDOWN, () => { 15022 execute(this._config.clickCallback); 15023 }); 15024 this._isAppended = true; 15025 } 15026 _emulateAnimation(callback) { 15027 executeAfterTransition(callback, this._getElement(), this._config.isAnimated); 15028 } 15029} 15030 15031/** 15032 * -------------------------------------------------------------------------- 15033 * Bootstrap util/focustrap.js 15034 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 15035 * -------------------------------------------------------------------------- 15036 */ 15037 15038 15039/** 15040 * Constants 15041 */ 15042 15043const NAME$8 = 'focustrap'; 15044const DATA_KEY$5 = 'bs.focustrap'; 15045const EVENT_KEY$5 = `.${DATA_KEY$5}`; 15046const EVENT_FOCUSIN$2 = `focusin${EVENT_KEY$5}`; 15047const EVENT_KEYDOWN_TAB = `keydown.tab${EVENT_KEY$5}`; 15048const TAB_KEY = 'Tab'; 15049const TAB_NAV_FORWARD = 'forward'; 15050const TAB_NAV_BACKWARD = 'backward'; 15051const Default$7 = { 15052 autofocus: true, 15053 trapElement: null // The element to trap focus inside of 15054}; 15055 15056const DefaultType$7 = { 15057 autofocus: 'boolean', 15058 trapElement: 'element' 15059}; 15060 15061/** 15062 * Class definition 15063 */ 15064 15065class FocusTrap extends Config { 15066 constructor(config) { 15067 super(); 15068 this._config = this._getConfig(config); 15069 this._isActive = false; 15070 this._lastTabNavDirection = null; 15071 } 15072 15073 // Getters 15074 static get Default() { 15075 return Default$7; 15076 } 15077 static get DefaultType() { 15078 return DefaultType$7; 15079 } 15080 static get NAME() { 15081 return NAME$8; 15082 } 15083 15084 // Public 15085 activate() { 15086 if (this._isActive) { 15087 return; 15088 } 15089 if (this._config.autofocus) { 15090 this._config.trapElement.focus(); 15091 } 15092 EventHandler.off(document, EVENT_KEY$5); // guard against infinite focus loop 15093 EventHandler.on(document, EVENT_FOCUSIN$2, event => this._handleFocusin(event)); 15094 EventHandler.on(document, EVENT_KEYDOWN_TAB, event => this._handleKeydown(event)); 15095 this._isActive = true; 15096 } 15097 deactivate() { 15098 if (!this._isActive) { 15099 return; 15100 } 15101 this._isActive = false; 15102 EventHandler.off(document, EVENT_KEY$5); 15103 } 15104 15105 // Private 15106 _handleFocusin(event) { 15107 const { 15108 trapElement 15109 } = this._config; 15110 if (event.target === document || event.target === trapElement || trapElement.contains(event.target)) { 15111 return; 15112 } 15113 const elements = SelectorEngine.focusableChildren(trapElement); 15114 if (elements.length === 0) { 15115 trapElement.focus(); 15116 } else if (this._lastTabNavDirection === TAB_NAV_BACKWARD) { 15117 elements[elements.length - 1].focus(); 15118 } else { 15119 elements[0].focus(); 15120 } 15121 } 15122 _handleKeydown(event) { 15123 if (event.key !== TAB_KEY) { 15124 return; 15125 } 15126 this._lastTabNavDirection = event.shiftKey ? TAB_NAV_BACKWARD : TAB_NAV_FORWARD; 15127 } 15128} 15129 15130/** 15131 * -------------------------------------------------------------------------- 15132 * Bootstrap util/scrollBar.js 15133 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 15134 * -------------------------------------------------------------------------- 15135 */ 15136 15137 15138/** 15139 * Constants 15140 */ 15141 15142const SELECTOR_FIXED_CONTENT = '.fixed-top, .fixed-bottom, .is-fixed, .sticky-top'; 15143const SELECTOR_STICKY_CONTENT = '.sticky-top'; 15144const PROPERTY_PADDING = 'padding-right'; 15145const PROPERTY_MARGIN = 'margin-right'; 15146 15147/** 15148 * Class definition 15149 */ 15150 15151class ScrollBarHelper { 15152 constructor() { 15153 this._element = document.body; 15154 } 15155 15156 // Public 15157 getWidth() { 15158 // https://developer.mozilla.org/en-US/docs/Web/API/Window/innerWidth#usage_notes 15159 const documentWidth = document.documentElement.clientWidth; 15160 return Math.abs(window.innerWidth - documentWidth); 15161 } 15162 hide() { 15163 const width = this.getWidth(); 15164 this._disableOverFlow(); 15165 // give padding to element to balance the hidden scrollbar width 15166 this._setElementAttributes(this._element, PROPERTY_PADDING, calculatedValue => calculatedValue + width); 15167 // trick: We adjust positive paddingRight and negative marginRight to sticky-top elements to keep showing fullwidth 15168 this._setElementAttributes(SELECTOR_FIXED_CONTENT, PROPERTY_PADDING, calculatedValue => calculatedValue + width); 15169 this._setElementAttributes(SELECTOR_STICKY_CONTENT, PROPERTY_MARGIN, calculatedValue => calculatedValue - width); 15170 } 15171 reset() { 15172 this._resetElementAttributes(this._element, 'overflow'); 15173 this._resetElementAttributes(this._element, PROPERTY_PADDING); 15174 this._resetElementAttributes(SELECTOR_FIXED_CONTENT, PROPERTY_PADDING); 15175 this._resetElementAttributes(SELECTOR_STICKY_CONTENT, PROPERTY_MARGIN); 15176 } 15177 isOverflowing() { 15178 return this.getWidth() > 0; 15179 } 15180 15181 // Private 15182 _disableOverFlow() { 15183 this._saveInitialAttribute(this._element, 'overflow'); 15184 this._element.style.overflow = 'hidden'; 15185 } 15186 _setElementAttributes(selector, styleProperty, callback) { 15187 const scrollbarWidth = this.getWidth(); 15188 const manipulationCallBack = element => { 15189 if (element !== this._element && window.innerWidth > element.clientWidth + scrollbarWidth) { 15190 return; 15191 } 15192 this._saveInitialAttribute(element, styleProperty); 15193 const calculatedValue = window.getComputedStyle(element).getPropertyValue(styleProperty); 15194 element.style.setProperty(styleProperty, `${callback(Number.parseFloat(calculatedValue))}px`); 15195 }; 15196 this._applyManipulationCallback(selector, manipulationCallBack); 15197 } 15198 _saveInitialAttribute(element, styleProperty) { 15199 const actualValue = element.style.getPropertyValue(styleProperty); 15200 if (actualValue) { 15201 Manipulator.setDataAttribute(element, styleProperty, actualValue); 15202 } 15203 } 15204 _resetElementAttributes(selector, styleProperty) { 15205 const manipulationCallBack = element => { 15206 const value = Manipulator.getDataAttribute(element, styleProperty); 15207 // We only want to remove the property if the value is `null`; the value can also be zero 15208 if (value === null) { 15209 element.style.removeProperty(styleProperty); 15210 return; 15211 } 15212 Manipulator.removeDataAttribute(element, styleProperty); 15213 element.style.setProperty(styleProperty, value); 15214 }; 15215 this._applyManipulationCallback(selector, manipulationCallBack); 15216 } 15217 _applyManipulationCallback(selector, callBack) { 15218 if (bootstrap_esm_
vendor: 16,596 bytes, lines 15218-15782
15218isElement(selector)) { 15219 callBack(selector); 15220 return; 15221 } 15222 for (const sel of SelectorEngine.find(selector, this._element)) { 15223 callBack(sel); 15224 } 15225 } 15226} 15227 15228/** 15229 * -------------------------------------------------------------------------- 15230 * Bootstrap modal.js 15231 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 15232 * -------------------------------------------------------------------------- 15233 */ 15234 15235 15236/** 15237 * Constants 15238 */ 15239 15240const NAME$7 = 'modal'; 15241const DATA_KEY$4 = 'bs.modal'; 15242const EVENT_KEY$4 = `.${DATA_KEY$4}`; 15243const DATA_API_KEY$2 = '.data-api'; 15244const ESCAPE_KEY$1 = 'Escape'; 15245const EVENT_HIDE$4 = `hide${EVENT_KEY$4}`; 15246const EVENT_HIDE_PREVENTED$1 = `hidePrevented${EVENT_KEY$4}`; 15247const EVENT_HIDDEN$4 = `hidden${EVENT_KEY$4}`; 15248const EVENT_SHOW$4 = `show${EVENT_KEY$4}`; 15249const EVENT_SHOWN$4 = `shown${EVENT_KEY$4}`; 15250const EVENT_RESIZE$1 = `resize${EVENT_KEY$4}`; 15251const EVENT_CLICK_DISMISS = `click.dismiss${EVENT_KEY$4}`; 15252const EVENT_MOUSEDOWN_DISMISS = `mousedown.dismiss${EVENT_KEY$4}`; 15253const EVENT_KEYDOWN_DISMISS$1 = `keydown.dismiss${EVENT_KEY$4}`; 15254const EVENT_CLICK_DATA_API$2 = `click${EVENT_KEY$4}${DATA_API_KEY$2}`; 15255const CLASS_NAME_OPEN = 'modal-open'; 15256const CLASS_NAME_FADE$3 = 'fade'; 15257const CLASS_NAME_SHOW$4 = 'show'; 15258const CLASS_NAME_STATIC = 'modal-static'; 15259const OPEN_SELECTOR$1 = '.modal.show'; 15260const SELECTOR_DIALOG = '.modal-dialog'; 15261const SELECTOR_MODAL_BODY = '.modal-body'; 15262const SELECTOR_DATA_TOGGLE$2 = '[data-bs-toggle="modal"]'; 15263const Default$6 = { 15264 backdrop: true, 15265 focus: true, 15266 keyboard: true 15267}; 15268const DefaultType$6 = { 15269 backdrop: '(boolean|string)', 15270 focus: 'boolean', 15271 keyboard: 'boolean' 15272}; 15273 15274/** 15275 * Class definition 15276 */ 15277 15278class Modal extends BaseComponent { 15279 constructor(element, config) { 15280 super(element, config); 15281 this._dialog = SelectorEngine.findOne(SELECTOR_DIALOG, this._element); 15282 this._backdrop = this._initializeBackDrop(); 15283 this._focustrap = this._initializeFocusTrap(); 15284 this._isShown = false; 15285 this._isTransitioning = false; 15286 this._scrollBar = new ScrollBarHelper(); 15287 this._addEventListeners(); 15288 } 15289 15290 // Getters 15291 static get Default() { 15292 return Default$6; 15293 } 15294 static get DefaultType() { 15295 return DefaultType$6; 15296 } 15297 static get NAME() { 15298 return NAME$7; 15299 } 15300 15301 // Public 15302 toggle(relatedTarget) { 15303 return this._isShown ? this.hide() : this.show(relatedTarget); 15304 } 15305 show(relatedTarget) { 15306 if (this._isShown || this._isTransitioning) { 15307 return; 15308 } 15309 const showEvent = EventHandler.trigger(this._element, EVENT_SHOW$4, { 15310 relatedTarget 15311 }); 15312 if (showEvent.defaultPrevented) { 15313 return; 15314 } 15315 this._isShown = true; 15316 this._isTransitioning = true; 15317 this._scrollBar.hide(); 15318 document.body.classList.add(CLASS_NAME_OPEN); 15319 this._adjustDialog(); 15320 this._backdrop.show(() => this._showElement(relatedTarget)); 15321 } 15322 hide() { 15323 if (!this._isShown || this._isTransitioning) { 15324 return; 15325 } 15326 const hideEvent = EventHandler.trigger(this._element, EVENT_HIDE$4); 15327 if (hideEvent.defaultPrevented) { 15328 return; 15329 } 15330 this._isShown = false; 15331 this._isTransitioning = true; 15332 this._focustrap.deactivate(); 15333 this._element.classList.remove(CLASS_NAME_SHOW$4); 15334 this._queueCallback(() => this._hideModal(), this._element, this._isAnimated()); 15335 } 15336 dispose() { 15337 EventHandler.off(window, EVENT_KEY$4); 15338 EventHandler.off(this._dialog, EVENT_KEY$4); 15339 this._backdrop.dispose(); 15340 this._focustrap.deactivate(); 15341 super.dispose(); 15342 } 15343 handleUpdate() { 15344 this._adjustDialog(); 15345 } 15346 15347 // Private 15348 _initializeBackDrop() { 15349 return new Backdrop({ 15350 isVisible: Boolean(this._config.backdrop), 15351 // 'static' option will be translated to true, and booleans will keep their value, 15352 isAnimated: this._isAnimated() 15353 }); 15354 } 15355 _initializeFocusTrap() { 15356 return new FocusTrap({ 15357 trapElement: this._element 15358 }); 15359 } 15360 _showElement(relatedTarget) { 15361 // try to append dynamic modal 15362 if (!document.body.contains(this._element)) { 15363 document.body.append(this._element); 15364 } 15365 this._element.style.display = 'block'; 15366 this._element.removeAttribute('aria-hidden'); 15367 this._element.setAttribute('aria-modal', true); 15368 this._element.setAttribute('role', 'dialog'); 15369 this._element.scrollTop = 0; 15370 const modalBody = SelectorEngine.findOne(SELECTOR_MODAL_BODY, this._dialog); 15371 if (modalBody) { 15372 modalBody.scrollTop = 0; 15373 } 15374 reflow(this._element); 15375 this._element.classList.add(CLASS_NAME_SHOW$4); 15376 const transitionComplete = () => { 15377 if (this._config.focus) { 15378 this._focustrap.activate(); 15379 } 15380 this._isTransitioning = false; 15381 EventHandler.trigger(this._element, EVENT_SHOWN$4, { 15382 relatedTarget 15383 }); 15384 }; 15385 this._queueCallback(transitionComplete, this._dialog, this._isAnimated()); 15386 } 15387 _addEventListeners() { 15388 EventHandler.on(this._element, EVENT_KEYDOWN_DISMISS$1, event => { 15389 if (event.key !== ESCAPE_KEY$1) { 15390 return; 15391 } 15392 if (this._config.keyboard) { 15393 this.hide(); 15394 return; 15395 } 15396 this._triggerBackdropTransition(); 15397 }); 15398 EventHandler.on(window, EVENT_RESIZE$1, () => { 15399 if (this._isShown && !this._isTransitioning) { 15400 this._adjustDialog(); 15401 } 15402 }); 15403 EventHandler.on(this._element, EVENT_MOUSEDOWN_DISMISS, event => { 15404 // a bad trick to segregate clicks that may start inside dialog but end outside, and avoid listen to scrollbar clicks 15405 EventHandler.one(this._element, EVENT_CLICK_DISMISS, event2 => { 15406 if (this._element !== event.target || this._element !== event2.target) { 15407 return; 15408 } 15409 if (this._config.backdrop === 'static') { 15410 this._triggerBackdropTransition(); 15411 return; 15412 } 15413 if (this._config.backdrop) { 15414 this.hide(); 15415 } 15416 }); 15417 }); 15418 } 15419 _hideModal() { 15420 this._element.style.display = 'none'; 15421 this._element.setAttribute('aria-hidden', true); 15422 this._element.removeAttribute('aria-modal'); 15423 this._element.removeAttribute('role'); 15424 this._isTransitioning = false; 15425 this._backdrop.hide(() => { 15426 document.body.classList.remove(CLASS_NAME_OPEN); 15427 this._resetAdjustments(); 15428 this._scrollBar.reset(); 15429 EventHandler.trigger(this._element, EVENT_HIDDEN$4); 15430 }); 15431 } 15432 _isAnimated() { 15433 return this._element.classList.contains(CLASS_NAME_FADE$3); 15434 } 15435 _triggerBackdropTransition() { 15436 const hideEvent = EventHandler.trigger(this._element, EVENT_HIDE_PREVENTED$1); 15437 if (hideEvent.defaultPrevented) { 15438 return; 15439 } 15440 const isModalOverflowing = this._element.scrollHeight > document.documentElement.clientHeight; 15441 const initialOverflowY = this._element.style.overflowY; 15442 // return if the following background transition hasn't yet completed 15443 if (initialOverflowY === 'hidden' || this._element.classList.contains(CLASS_NAME_STATIC)) { 15444 return; 15445 } 15446 if (!isModalOverflowing) { 15447 this._element.style.overflowY = 'hidden'; 15448 } 15449 this._element.classList.add(CLASS_NAME_STATIC); 15450 this._queueCallback(() => { 15451 this._element.classList.remove(CLASS_NAME_STATIC); 15452 this._queueCallback(() => { 15453 this._element.style.overflowY = initialOverflowY; 15454 }, this._dialog); 15455 }, this._dialog); 15456 this._element.focus(); 15457 } 15458 15459 /** 15460 * The following methods are used to handle overflowing modals 15461 */ 15462 15463 _adjustDialog() { 15464 const isModalOverflowing = this._element.scrollHeight > document.documentElement.clientHeight; 15465 const scrollbarWidth = this._scrollBar.getWidth(); 15466 const isBodyOverflowing = scrollbarWidth > 0; 15467 if (isBodyOverflowing && !isModalOverflowing) { 15468 const property = isRTL() ? 'paddingLeft' : 'paddingRight'; 15469 this._element.style[property] = `${scrollbarWidth}px`; 15470 } 15471 if (!isBodyOverflowing && isModalOverflowing) { 15472 const property = isRTL() ? 'paddingRight' : 'paddingLeft'; 15473 this._element.style[property] = `${scrollbarWidth}px`; 15474 } 15475 } 15476 _resetAdjustments() { 15477 this._element.style.paddingLeft = ''; 15478 this._element.style.paddingRight = ''; 15479 } 15480 15481 // Static 15482 static jQueryInterface(config, relatedTarget) { 15483 return this.each(function () { 15484 const data = Modal.getOrCreateInstance(this, config); 15485 if (typeof config !== 'string') { 15486 return; 15487 } 15488 if (typeof data[config] === 'undefined') { 15489 throw new TypeError(`No method named "${config}"`); 15490 } 15491 data[config](relatedTarget); 15492 }); 15493 } 15494} 15495 15496/** 15497 * Data API implementation 15498 */ 15499 15500EventHandler.on(document, EVENT_CLICK_DATA_API$2, SELECTOR_DATA_TOGGLE$2, function (event) { 15501 const target = SelectorEngine.getElementFromSelector(this); 15502 if (['A', 'AREA'].includes(this.tagName)) { 15503 event.preventDefault(); 15504 } 15505 EventHandler.one(target, EVENT_SHOW$4, showEvent => { 15506 if (showEvent.defaultPrevented) { 15507 // only register focus restorer if modal will actually get shown 15508 return; 15509 } 15510 EventHandler.one(target, EVENT_HIDDEN$4, () => { 15511 if (isVisible(this)) { 15512 this.focus(); 15513 } 15514 }); 15515 }); 15516 15517 // avoid conflict when clicking modal toggler while another one is open 15518 const alreadyOpen = SelectorEngine.findOne(OPEN_SELECTOR$1); 15519 if (alreadyOpen) { 15520 Modal.getInstance(alreadyOpen).hide(); 15521 } 15522 const data = Modal.getOrCreateInstance(target); 15523 data.toggle(this); 15524}); 15525enableDismissTrigger(Modal); 15526 15527/** 15528 * jQuery 15529 */ 15530 15531defineJQueryPlugin(Modal); 15532 15533/** 15534 * -------------------------------------------------------------------------- 15535 * Bootstrap offcanvas.js 15536 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 15537 * -------------------------------------------------------------------------- 15538 */ 15539 15540 15541/** 15542 * Constants 15543 */ 15544 15545const NAME$6 = 'offcanvas'; 15546const DATA_KEY$3 = 'bs.offcanvas'; 15547const EVENT_KEY$3 = `.${DATA_KEY$3}`; 15548const DATA_API_KEY$1 = '.data-api'; 15549const EVENT_LOAD_DATA_API$2 = `load${EVENT_KEY$3}${DATA_API_KEY$1}`; 15550const ESCAPE_KEY = 'Escape'; 15551const CLASS_NAME_SHOW$3 = 'show'; 15552const CLASS_NAME_SHOWING$1 = 'showing'; 15553const CLASS_NAME_HIDING = 'hiding'; 15554const CLASS_NAME_BACKDROP = 'offcanvas-backdrop'; 15555const OPEN_SELECTOR = '.offcanvas.show'; 15556const EVENT_SHOW$3 = `show${EVENT_KEY$3}`; 15557const EVENT_SHOWN$3 = `shown${EVENT_KEY$3}`; 15558const EVENT_HIDE$3 = `hide${EVENT_KEY$3}`; 15559const EVENT_HIDE_PREVENTED = `hidePrevented${EVENT_KEY$3}`; 15560const EVENT_HIDDEN$3 = `hidden${EVENT_KEY$3}`; 15561const EVENT_RESIZE = `resize${EVENT_KEY$3}`; 15562const EVENT_CLICK_DATA_API$1 = `click${EVENT_KEY$3}${DATA_API_KEY$1}`; 15563const EVENT_KEYDOWN_DISMISS = `keydown.dismiss${EVENT_KEY$3}`; 15564const SELECTOR_DATA_TOGGLE$1 = '[data-bs-toggle="offcanvas"]'; 15565const Default$5 = { 15566 backdrop: true, 15567 keyboard: true, 15568 scroll: false 15569}; 15570const DefaultType$5 = { 15571 backdrop: '(boolean|string)', 15572 keyboard: 'boolean', 15573 scroll: 'boolean' 15574}; 15575 15576/** 15577 * Class definition 15578 */ 15579 15580class Offcanvas extends BaseComponent { 15581 constructor(element, config) { 15582 super(element, config); 15583 this._isShown = false; 15584 this._backdrop = this._initializeBackDrop(); 15585 this._focustrap = this._initializeFocusTrap(); 15586 this._addEventListeners(); 15587 } 15588 15589 // Getters 15590 static get Default() { 15591 return Default$5; 15592 } 15593 static get DefaultType() { 15594 return DefaultType$5; 15595 } 15596 static get NAME() { 15597 return NAME$6; 15598 } 15599 15600 // Public 15601 toggle(relatedTarget) { 15602 return this._isShown ? this.hide() : this.show(relatedTarget); 15603 } 15604 show(relatedTarget) { 15605 if (this._isShown) { 15606 return; 15607 } 15608 const showEvent = EventHandler.trigger(this._element, EVENT_SHOW$3, { 15609 relatedTarget 15610 }); 15611 if (showEvent.defaultPrevented) { 15612 return; 15613 } 15614 this._isShown = true; 15615 this._backdrop.show(); 15616 if (!this._config.scroll) { 15617 new ScrollBarHelper().hide(); 15618 } 15619 this._element.setAttribute('aria-modal', true); 15620 this._element.setAttribute('role', 'dialog'); 15621 this._element.classList.add(CLASS_NAME_SHOWING$1); 15622 const completeCallBack = () => { 15623 if (!this._config.scroll || this._config.backdrop) { 15624 this._focustrap.activate(); 15625 } 15626 this._element.classList.add(CLASS_NAME_SHOW$3); 15627 this._element.classList.remove(CLASS_NAME_SHOWING$1); 15628 EventHandler.trigger(this._element, EVENT_SHOWN$3, { 15629 relatedTarget 15630 }); 15631 }; 15632 this._queueCallback(completeCallBack, this._element, true); 15633 } 15634 hide() { 15635 if (!this._isShown) { 15636 return; 15637 } 15638 const hideEvent = EventHandler.trigger(this._element, EVENT_HIDE$3); 15639 if (hideEvent.defaultPrevented) { 15640 return; 15641 } 15642 this._focustrap.deactivate(); 15643 this._element.blur(); 15644 this._isShown = false; 15645 this._element.classList.add(CLASS_NAME_HIDING); 15646 this._backdrop.hide(); 15647 const completeCallback = () => { 15648 this._element.classList.remove(CLASS_NAME_SHOW$3, CLASS_NAME_HIDING); 15649 this._element.removeAttribute('aria-modal'); 15650 this._element.removeAttribute('role'); 15651 if (!this._config.scroll) { 15652 new ScrollBarHelper().reset(); 15653 } 15654 EventHandler.trigger(this._element, EVENT_HIDDEN$3); 15655 }; 15656 this._queueCallback(completeCallback, this._element, true); 15657 } 15658 dispose() { 15659 this._backdrop.dispose(); 15660 this._focustrap.deactivate(); 15661 super.dispose(); 15662 } 15663 15664 // Private 15665 _initializeBackDrop() { 15666 const clickCallback = () => { 15667 if (this._config.backdrop === 'static') { 15668 EventHandler.trigger(this._element, EVENT_HIDE_PREVENTED); 15669 return; 15670 } 15671 this.hide(); 15672 }; 15673 15674 // 'static' option will be translated to true, and booleans will keep their value 15675 const isVisible = Boolean(this._config.backdrop); 15676 return new Backdrop({ 15677 className: CLASS_NAME_BACKDROP, 15678 isVisible, 15679 isAnimated: true, 15680 rootElement: this._element.parentNode, 15681 clickCallback: isVisible ? clickCallback : null 15682 }); 15683 } 15684 _initializeFocusTrap() { 15685 return new FocusTrap({ 15686 trapElement: this._element 15687 }); 15688 } 15689 _addEventListeners() { 15690 EventHandler.on(this._element, EVENT_KEYDOWN_DISMISS, event => { 15691 if (event.key !== ESCAPE_KEY) { 15692 return; 15693 } 15694 if (this._config.keyboard) { 15695 this.hide(); 15696 return; 15697 } 15698 EventHandler.trigger(this._element, EVENT_HIDE_PREVENTED); 15699 }); 15700 } 15701 15702 // Static 15703 static jQueryInterface(config) { 15704 return this.each(function () { 15705 const data = Offcanvas.getOrCreateInstance(this, config); 15706 if (typeof config !== 'string') { 15707 return; 15708 } 15709 if (data[config] === undefined || config.startsWith('_') || config === 'constructor') { 15710 throw new TypeError(`No method named "${config}"`); 15711 } 15712 data[config](this); 15713 }); 15714 } 15715} 15716 15717/** 15718 * Data API implementation 15719 */ 15720 15721EventHandler.on(document, EVENT_CLICK_DATA_API$1, SELECTOR_DATA_TOGGLE$1, function (event) { 15722 const target = SelectorEngine.getElementFromSelector(this); 15723 if (['A', 'AREA'].includes(this.tagName)) { 15724 event.preventDefault(); 15725 } 15726 if (isDisabled(this)) { 15727 return; 15728 } 15729 EventHandler.one(target, EVENT_HIDDEN$3, () => { 15730 // focus on trigger when it is closed 15731 if (isVisible(this)) { 15732 this.focus(); 15733 } 15734 }); 15735 15736 // avoid conflict when clicking a toggler of an offcanvas, while another is open 15737 const alreadyOpen = SelectorEngine.findOne(OPEN_SELECTOR); 15738 if (alreadyOpen && alreadyOpen !== target) { 15739 Offcanvas.getInstance(alreadyOpen).hide(); 15740 } 15741 const data = Offcanvas.getOrCreateInstance(target); 15742 data.toggle(this); 15743}); 15744EventHandler.on(window, EVENT_LOAD_DATA_API$2, () => { 15745 for (const selector of SelectorEngine.find(OPEN_SELECTOR)) { 15746 Offcanvas.getOrCreateInstance(selector).show(); 15747 } 15748}); 15749EventHandler.on(window, EVENT_RESIZE, () => { 15750 for (const element of SelectorEngine.find('[aria-modal][class*=show][class*=offcanvas-]')) { 15751 if (getComputedStyle(element).position !== 'fixed') { 15752 Offcanvas.getOrCreateInstance(element).hide(); 15753 } 15754 } 15755}); 15756enableDismissTrigger(Offcanvas); 15757 15758/** 15759 * jQuery 15760 */ 15761 15762defineJQueryPlugin(Offcanvas); 15763 15764/** 15765 * -------------------------------------------------------------------------- 15766 * Bootstrap util/sanitizer.js 15767 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 15768 * -------------------------------------------------------------------------- 15769 */ 15770 15771// js-docs-start allow-list 15772const ARIA_ATTRIBUTE_PATTERN = /^aria-[\w-]*$/i; 15773const DefaultAllowlist = { 15774 // Global attributes allowed on any supplied element below. 15775 '*': ['class', 'dir', 'id', 'lang', 'role', ARIA_ATTRIBUTE_PATTERN], 15776 a: ['target', 'href', 'title', 'rel'], 15777 area: [], 15778 b: [], 15779 br: [], 15780 col: [], 15781 code: [], 15782 d
vendor: 5,421 bytes, lines 15782-15978
15782iv: [], 15783 em: [], 15784 hr: [], 15785 h1: [], 15786 h2: [], 15787 h3: [], 15788 h4: [], 15789 h5: [], 15790 h6: [], 15791 i: [], 15792 img: ['src', 'srcset', 'alt', 'title', 'width', 'height'], 15793 li: [], 15794 ol: [], 15795 p: [], 15796 pre: [], 15797 s: [], 15798 small: [], 15799 span: [], 15800 sub: [], 15801 sup: [], 15802 strong: [], 15803 u: [], 15804 ul: [] 15805}; 15806// js-docs-end allow-list 15807 15808const uriAttributes = new Set(['background', 'cite', 'href', 'itemtype', 'longdesc', 'poster', 'src', 'xlink:href']); 15809 15810/** 15811 * A pattern that recognizes URLs that are safe wrt. XSS in URL navigation 15812 * contexts. 15813 * 15814 * Shout-out to Angular https://github.com/angular/angular/blob/15.2.8/packages/core/src/sanitization/url_sanitizer.ts#L38 15815 */ 15816// eslint-disable-next-line unicorn/better-regex 15817const SAFE_URL_PATTERN = /^(?!javascript:)(?:[a-z0-9+.-]+:|[^&:/?#]*(?:[/?#]|$))/i; 15818const allowedAttribute = (attribute, allowedAttributeList) => { 15819 const attributeName = attribute.nodeName.toLowerCase(); 15820 if (allowedAttributeList.includes(attributeName)) { 15821 if (uriAttributes.has(attributeName)) { 15822 return Boolean(SAFE_URL_PATTERN.test(attribute.nodeValue)); 15823 } 15824 return true; 15825 } 15826 15827 // Check if a regular expression validates the attribute. 15828 return allowedAttributeList.filter(attributeRegex => attributeRegex instanceof RegExp).some(regex => regex.test(attributeName)); 15829}; 15830function sanitizeHtml(unsafeHtml, allowList, sanitizeFunction) { 15831 if (!unsafeHtml.length) { 15832 return unsafeHtml; 15833 } 15834 if (sanitizeFunction && typeof sanitizeFunction === 'function') { 15835 return sanitizeFunction(unsafeHtml); 15836 } 15837 const domParser = new window.DOMParser(); 15838 const createdDocument = domParser.parseFromString(unsafeHtml, 'text/html'); 15839 const elements = [].concat(...createdDocument.body.querySelectorAll('*')); 15840 for (const element of elements) { 15841 const elementName = element.nodeName.toLowerCase(); 15842 if (!Object.keys(allowList).includes(elementName)) { 15843 element.remove(); 15844 continue; 15845 } 15846 const attributeList = [].concat(...element.attributes); 15847 const allowedAttributes = [].concat(allowList['*'] || [], allowList[elementName] || []); 15848 for (const attribute of attributeList) { 15849 if (!allowedAttribute(attribute, allowedAttributes)) { 15850 element.removeAttribute(attribute.nodeName); 15851 } 15852 } 15853 } 15854 return createdDocument.body.innerHTML; 15855} 15856 15857/** 15858 * -------------------------------------------------------------------------- 15859 * Bootstrap util/template-factory.js 15860 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 15861 * -------------------------------------------------------------------------- 15862 */ 15863 15864 15865/** 15866 * Constants 15867 */ 15868 15869const NAME$5 = 'TemplateFactory'; 15870const Default$4 = { 15871 allowList: DefaultAllowlist, 15872 content: {}, 15873 // { selector : text , selector2 : text2 , } 15874 extraClass: '', 15875 html: false, 15876 sanitize: true, 15877 sanitizeFn: null, 15878 template: '<div></div>' 15879}; 15880const DefaultType$4 = { 15881 allowList: 'object', 15882 content: 'object', 15883 extraClass: '(string|function)', 15884 html: 'boolean', 15885 sanitize: 'boolean', 15886 sanitizeFn: '(null|function)', 15887 template: 'string' 15888}; 15889const DefaultContentType = { 15890 entry: '(string|element|function|null)', 15891 selector: '(string|element)' 15892}; 15893 15894/** 15895 * Class definition 15896 */ 15897 15898class TemplateFactory extends Config { 15899 constructor(config) { 15900 super(); 15901 this._config = this._getConfig(config); 15902 } 15903 15904 // Getters 15905 static get Default() { 15906 return Default$4; 15907 } 15908 static get DefaultType() { 15909 return DefaultType$4; 15910 } 15911 static get NAME() { 15912 return NAME$5; 15913 } 15914 15915 // Public 15916 getContent() { 15917 return Object.values(this._config.content).map(config => this._resolvePossibleFunction(config)).filter(Boolean); 15918 } 15919 hasContent() { 15920 return this.getContent().length > 0; 15921 } 15922 changeContent(content) { 15923 this._checkContent(content); 15924 this._config.content = { 15925 ...this._config.content, 15926 ...content 15927 }; 15928 return this; 15929 } 15930 toHtml() { 15931 const templateWrapper = document.createElement('div'); 15932 templateWrapper.innerHTML = this._maybeSanitize(this._config.template); 15933 for (const [selector, text] of Object.entries(this._config.content)) { 15934 this._setContent(templateWrapper, text, selector); 15935 } 15936 const template = templateWrapper.children[0]; 15937 const extraClass = this._resolvePossibleFunction(this._config.extraClass); 15938 if (extraClass) { 15939 template.classList.add(...extraClass.split(' ')); 15940 } 15941 return template; 15942 } 15943 15944 // Private 15945 _typeCheckConfig(config) { 15946 super._typeCheckConfig(config); 15947 this._checkContent(config.content); 15948 } 15949 _checkContent(arg) { 15950 for (const [selector, content] of Object.entries(arg)) { 15951 super._typeCheckConfig({ 15952 selector, 15953 entry: content 15954 }, DefaultContentType); 15955 } 15956 } 15957 _setContent(template, content, selector) { 15958 const templateElement = SelectorEngine.findOne(selector, template); 15959 if (!templateElement) { 15960 return; 15961 } 15962 content = this._resolvePossibleFunction(content); 15963 if (!content) { 15964 templateElement.remove(); 15965 return; 15966 } 15967 if (bootstrap_esm_isElement(content)) { 15968 this._putElementInTemplate(getElement(content), templateElement); 15969 return; 15970 } 15971 if (this._config.html) { 15972 templateElement.innerHTML = this._maybeSanitize(content); 15973 return; 15974 } 15975 templateElement.textContent = content; 15976 } 15977 _maybeSanitize(arg) { 15978 return this._config.sanitize ? sanitizeHtml(arg, this._config.allowList, this._config.sanitizeFn) : arg;
vendor: 3,710 bytes, lines 15979-16126
15979 } 15980 _resolvePossibleFunction(arg) { 15981 return execute(arg, [this]); 15982 } 15983 _putElementInTemplate(element, templateElement) { 15984 if (this._config.html) { 15985 templateElement.innerHTML = ''; 15986 templateElement.append(element); 15987 return; 15988 } 15989 templateElement.textContent = element.textContent; 15990 } 15991} 15992 15993/** 15994 * -------------------------------------------------------------------------- 15995 * Bootstrap tooltip.js 15996 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 15997 * -------------------------------------------------------------------------- 15998 */ 15999 16000 16001/** 16002 * Constants 16003 */ 16004 16005const NAME$4 = 'tooltip'; 16006const DISALLOWED_ATTRIBUTES = new Set(['sanitize', 'allowList', 'sanitizeFn']); 16007const CLASS_NAME_FADE$2 = 'fade'; 16008const CLASS_NAME_MODAL = 'modal'; 16009const CLASS_NAME_SHOW$2 = 'show'; 16010const SELECTOR_TOOLTIP_INNER = '.tooltip-inner'; 16011const SELECTOR_MODAL = `.${CLASS_NAME_MODAL}`; 16012const EVENT_MODAL_HIDE = 'hide.bs.modal'; 16013const TRIGGER_HOVER = 'hover'; 16014const TRIGGER_FOCUS = 'focus'; 16015const TRIGGER_CLICK = 'click'; 16016const TRIGGER_MANUAL = 'manual'; 16017const EVENT_HIDE$2 = 'hide'; 16018const EVENT_HIDDEN$2 = 'hidden'; 16019const EVENT_SHOW$2 = 'show'; 16020const EVENT_SHOWN$2 = 'shown'; 16021const EVENT_INSERTED = 'inserted'; 16022const EVENT_CLICK$1 = 'click'; 16023const EVENT_FOCUSIN$1 = 'focusin'; 16024const EVENT_FOCUSOUT$1 = 'focusout'; 16025const EVENT_MOUSEENTER = 'mouseenter'; 16026const EVENT_MOUSELEAVE = 'mouseleave'; 16027const AttachmentMap = { 16028 AUTO: 'auto', 16029 TOP: 'top', 16030 RIGHT: isRTL() ? 'left' : 'right', 16031 BOTTOM: 'bottom', 16032 LEFT: isRTL() ? 'right' : 'left' 16033}; 16034const Default$3 = { 16035 allowList: DefaultAllowlist, 16036 animation: true, 16037 boundary: 'clippingParents', 16038 container: false, 16039 customClass: '', 16040 delay: 0, 16041 fallbackPlacements: ['top', 'right', 'bottom', 'left'], 16042 html: false, 16043 offset: [0, 6], 16044 placement: 'top', 16045 popperConfig: null, 16046 sanitize: true, 16047 sanitizeFn: null, 16048 selector: false, 16049 template: '<div class="tooltip" role="tooltip">' + '<div class="tooltip-arrow"></div>' + '<div class="tooltip-inner"></div>' + '</div>', 16050 title: '', 16051 trigger: 'hover focus' 16052}; 16053const DefaultType$3 = { 16054 allowList: 'object', 16055 animation: 'boolean', 16056 boundary: '(string|element)', 16057 container: '(string|element|boolean)', 16058 customClass: '(string|function)', 16059 delay: '(number|object)', 16060 fallbackPlacements: 'array', 16061 html: 'boolean', 16062 offset: '(array|string|function)', 16063 placement: '(string|function)', 16064 popperConfig: '(null|object|function)', 16065 sanitize: 'boolean', 16066 sanitizeFn: '(null|function)', 16067 selector: '(string|boolean)', 16068 template: 'string', 16069 title: '(string|element|function)', 16070 trigger: 'string' 16071}; 16072 16073/** 16074 * Class definition 16075 */ 16076 16077class Tooltip extends BaseComponent { 16078 constructor(element, config) { 16079 if (typeof lib_namespaceObject === 'undefined') { 16080 throw new TypeError('Bootstrap\'s tooltips require Popper (https://popper.js.org)'); 16081 } 16082 super(element, config); 16083 16084 // Private 16085 this._isEnabled = true; 16086 this._timeout = 0; 16087 this._isHovered = null; 16088 this._activeTrigger = {}; 16089 this._popper = null; 16090 this._templateFactory = null; 16091 this._newContent = null; 16092 16093 // Protected 16094 this.tip = null; 16095 this._setListeners(); 16096 if (!this._config.selector) { 16097 this._fixTitle(); 16098 } 16099 } 16100 16101 // Getters 16102 static get Default() { 16103 return Default$3; 16104 } 16105 static get DefaultType() { 16106 return DefaultType$3; 16107 } 16108 static get NAME() { 16109 return NAME$4; 16110 } 16111 16112 // Public 16113 enable() { 16114 this._isEnabled = true; 16115 } 16116 disable() { 16117 this._isEnabled = false; 16118 } 16119 toggleEnabled() { 16120 this._isEnabled = !this._isEnabled; 16121 } 16122 toggle() { 16123 if (!this._isEnabled) { 16124 return; 16125 } 16126 this._activeTrigger.click = !this._activeTrigger.click;
vendor: 5,746 bytes, lines 16126-16299
16126 16127 if (this._isShown()) { 16128 this._leave(); 16129 return; 16130 } 16131 this._enter(); 16132 } 16133 dispose() { 16134 clearTimeout(this._timeout); 16135 EventHandler.off(this._element.closest(SELECTOR_MODAL), EVENT_MODAL_HIDE, this._hideModalHandler); 16136 if (this._element.getAttribute('data-bs-original-title')) { 16137 this._element.setAttribute('title', this._element.getAttribute('data-bs-original-title')); 16138 } 16139 this._disposePopper(); 16140 super.dispose(); 16141 } 16142 show() { 16143 if (this._element.style.display === 'none') { 16144 throw new Error('Please use show on visible elements'); 16145 } 16146 if (!(this._isWithContent() && this._isEnabled)) { 16147 return; 16148 } 16149 const showEvent = EventHandler.trigger(this._element, this.constructor.eventName(EVENT_SHOW$2)); 16150 const shadowRoot = findShadowRoot(this._element); 16151 const isInTheDom = (shadowRoot || this._element.ownerDocument.documentElement).contains(this._element); 16152 if (showEvent.defaultPrevented || !isInTheDom) { 16153 return; 16154 } 16155 16156 // TODO: v6 remove this or make it optional 16157 this._disposePopper(); 16158 const tip = this._getTipElement(); 16159 this._element.setAttribute('aria-describedby', tip.getAttribute('id')); 16160 const { 16161 container 16162 } = this._config; 16163 if (!this._element.ownerDocument.documentElement.contains(this.tip)) { 16164 container.append(tip); 16165 EventHandler.trigger(this._element, this.constructor.eventName(EVENT_INSERTED)); 16166 } 16167 this._popper = this._createPopper(tip); 16168 tip.classList.add(CLASS_NAME_SHOW$2); 16169 16170 // If this is a touch-enabled device we add extra 16171 // empty mouseover listeners to the body's immediate children; 16172 // only needed because of broken event delegation on iOS 16173 // https://www.quirksmode.org/blog/archives/2014/02/mouse_event_bub.html 16174 if ('ontouchstart' in document.documentElement) { 16175 for (const element of [].concat(...document.body.children)) { 16176 EventHandler.on(element, 'mouseover', noop); 16177 } 16178 } 16179 const complete = () => { 16180 EventHandler.trigger(this._element, this.constructor.eventName(EVENT_SHOWN$2)); 16181 if (this._isHovered === false) { 16182 this._leave(); 16183 } 16184 this._isHovered = false; 16185 }; 16186 this._queueCallback(complete, this.tip, this._isAnimated()); 16187 } 16188 hide() { 16189 if (!this._isShown()) { 16190 return; 16191 } 16192 const hideEvent = EventHandler.trigger(this._element, this.constructor.eventName(EVENT_HIDE$2)); 16193 if (hideEvent.defaultPrevented) { 16194 return; 16195 } 16196 const tip = this._getTipElement(); 16197 tip.classList.remove(CLASS_NAME_SHOW$2); 16198 16199 // If this is a touch-enabled device we remove the extra 16200 // empty mouseover listeners we added for iOS support 16201 if ('ontouchstart' in document.documentElement) { 16202 for (const element of [].concat(...document.body.children)) { 16203 EventHandler.off(element, 'mouseover', noop); 16204 } 16205 } 16206 this._activeTrigger[TRIGGER_CLICK] = false; 16207 this._activeTrigger[TRIGGER_FOCUS] = false; 16208 this._activeTrigger[TRIGGER_HOVER] = false; 16209 this._isHovered = null; // it is a trick to support manual triggering 16210 16211 const complete = () => { 16212 if (this._isWithActiveTrigger()) { 16213 return; 16214 } 16215 if (!this._isHovered) { 16216 this._disposePopper(); 16217 } 16218 this._element.removeAttribute('aria-describedby'); 16219 EventHandler.trigger(this._element, this.constructor.eventName(EVENT_HIDDEN$2)); 16220 }; 16221 this._queueCallback(complete, this.tip, this._isAnimated()); 16222 } 16223 update() { 16224 if (this._popper) { 16225 this._popper.update(); 16226 } 16227 } 16228 16229 // Protected 16230 _isWithContent() { 16231 return Boolean(this._getTitle()); 16232 } 16233 _getTipElement() { 16234 if (!this.tip) { 16235 this.tip = this._createTipElement(this._newContent || this._getContentForTemplate()); 16236 } 16237 return this.tip; 16238 } 16239 _createTipElement(content) { 16240 const tip = this._getTemplateFactory(content).toHtml(); 16241 16242 // TODO: remove this check in v6 16243 if (!tip) { 16244 return null; 16245 } 16246 tip.classList.remove(CLASS_NAME_FADE$2, CLASS_NAME_SHOW$2); 16247 // TODO: v6 the following can be achieved with CSS only 16248 tip.classList.add(`bs-${this.constructor.NAME}-auto`); 16249 const tipId = getUID(this.constructor.NAME).toString(); 16250 tip.setAttribute('id', tipId); 16251 if (this._isAnimated()) { 16252 tip.classList.add(CLASS_NAME_FADE$2); 16253 } 16254 return tip; 16255 } 16256 setContent(content) { 16257 this._newContent = content; 16258 if (this._isShown()) { 16259 this._disposePopper(); 16260 this.show(); 16261 } 16262 } 16263 _getTemplateFactory(content) { 16264 if (this._templateFactory) { 16265 this._templateFactory.changeContent(content); 16266 } else { 16267 this._templateFactory = new TemplateFactory({ 16268 ...this._config, 16269 // the `content` var has to be after `this._config` 16270 // to override config.content in case of popover 16271 content, 16272 extraClass: this._resolvePossibleFunction(this._config.customClass) 16273 }); 16274 } 16275 return this._templateFactory; 16276 } 16277 _getContentForTemplate() { 16278 return { 16279 [SELECTOR_TOOLTIP_INNER]: this._getTitle() 16280 }; 16281 } 16282 _getTitle() { 16283 return this._resolvePossibleFunction(this._config.title) || this._element.getAttribute('data-bs-original-title'); 16284 } 16285 16286 // Private 16287 _initializeOnDelegatedTarget(event) { 16288 return this.constructor.getOrCreateInstance(event.delegateTarget, this._getDelegateConfig()); 16289 } 16290 _isAnimated() { 16291 return this._config.animation || this.tip && this.tip.classList.contains(CLASS_NAME_FADE$2); 16292 } 16293 _isShown() { 16294 return this.tip && this.tip.classList.contains(CLASS_NAME_SHOW$2); 16295 } 16296 _createPopper(tip) { 16297 const placement = execute(this._config.placement, [this, tip, this._element]); 16298 const attachment = AttachmentMap[placement.toUpperCase()]; 16299 return
vendor: 1,938 bytes, lines 16299-16360
16299popper_createPopper(this._element, tip, this._getPopperConfig(attachment)); 16300 } 16301 _getOffset() { 16302 const { 16303 offset 16304 } = this._config; 16305 if (typeof offset === 'string') { 16306 return offset.split(',').map(value => Number.parseInt(value, 10)); 16307 } 16308 if (typeof offset === 'function') { 16309 return popperData => offset(popperData, this._element); 16310 } 16311 return offset; 16312 } 16313 _resolvePossibleFunction(arg) { 16314 return execute(arg, [this._element]); 16315 } 16316 _getPopperConfig(attachment) { 16317 const defaultBsPopperConfig = { 16318 placement: attachment, 16319 modifiers: [{ 16320 name: 'flip', 16321 options: { 16322 fallbackPlacements: this._config.fallbackPlacements 16323 } 16324 }, { 16325 name: 'offset', 16326 options: { 16327 offset: this._getOffset() 16328 } 16329 }, { 16330 name: 'preventOverflow', 16331 options: { 16332 boundary: this._config.boundary 16333 } 16334 }, { 16335 name: 'arrow', 16336 options: { 16337 element: `.${this.constructor.NAME}-arrow` 16338 } 16339 }, { 16340 name: 'preSetPlacement', 16341 enabled: true, 16342 phase: 'beforeMain', 16343 fn: data => { 16344 // Pre-set Popper's placement attribute in order to read the arrow sizes properly. 16345 // Otherwise, Popper mixes up the width and height dimensions since the initial arrow style is for top placement 16346 this._getTipElement().setAttribute('data-popper-placement', data.state.placement); 16347 } 16348 }] 16349 }; 16350 return { 16351 ...defaultBsPopperConfig, 16352 ...execute(this._config.popperConfig, [defaultBsPopperConfig]) 16353 }; 16354 } 16355 _setListeners() { 16356 const triggers = this._config.trigger.split(' '); 16357 for (const trigger of triggers) { 16358 if (trigger === 'click') { 16359 EventHandler.on(this._element, this.constructor.eventName(EVENT_CLICK$1), this._config.selector, event => { 16360 const context = this._initializeOnDelegatedTarget(event
vendor: 26,585 bytes, lines 16360-17225
16360); 16361 context.toggle(); 16362 }); 16363 } else if (trigger !== TRIGGER_MANUAL) { 16364 const eventIn = trigger === TRIGGER_HOVER ? this.constructor.eventName(EVENT_MOUSEENTER) : this.constructor.eventName(EVENT_FOCUSIN$1); 16365 const eventOut = trigger === TRIGGER_HOVER ? this.constructor.eventName(EVENT_MOUSELEAVE) : this.constructor.eventName(EVENT_FOCUSOUT$1); 16366 EventHandler.on(this._element, eventIn, this._config.selector, event => { 16367 const context = this._initializeOnDelegatedTarget(event); 16368 context._activeTrigger[event.type === 'focusin' ? TRIGGER_FOCUS : TRIGGER_HOVER] = true; 16369 context._enter(); 16370 }); 16371 EventHandler.on(this._element, eventOut, this._config.selector, event => { 16372 const context = this._initializeOnDelegatedTarget(event); 16373 context._activeTrigger[event.type === 'focusout' ? TRIGGER_FOCUS : TRIGGER_HOVER] = context._element.contains(event.relatedTarget); 16374 context._leave(); 16375 }); 16376 } 16377 } 16378 this._hideModalHandler = () => { 16379 if (this._element) { 16380 this.hide(); 16381 } 16382 }; 16383 EventHandler.on(this._element.closest(SELECTOR_MODAL), EVENT_MODAL_HIDE, this._hideModalHandler); 16384 } 16385 _fixTitle() { 16386 const title = this._element.getAttribute('title'); 16387 if (!title) { 16388 return; 16389 } 16390 if (!this._element.getAttribute('aria-label') && !this._element.textContent.trim()) { 16391 this._element.setAttribute('aria-label', title); 16392 } 16393 this._element.setAttribute('data-bs-original-title', title); // DO NOT USE IT. Is only for backwards compatibility 16394 this._element.removeAttribute('title'); 16395 } 16396 _enter() { 16397 if (this._isShown() || this._isHovered) { 16398 this._isHovered = true; 16399 return; 16400 } 16401 this._isHovered = true; 16402 this._setTimeout(() => { 16403 if (this._isHovered) { 16404 this.show(); 16405 } 16406 }, this._config.delay.show); 16407 } 16408 _leave() { 16409 if (this._isWithActiveTrigger()) { 16410 return; 16411 } 16412 this._isHovered = false; 16413 this._setTimeout(() => { 16414 if (!this._isHovered) { 16415 this.hide(); 16416 } 16417 }, this._config.delay.hide); 16418 } 16419 _setTimeout(handler, timeout) { 16420 clearTimeout(this._timeout); 16421 this._timeout = setTimeout(handler, timeout); 16422 } 16423 _isWithActiveTrigger() { 16424 return Object.values(this._activeTrigger).includes(true); 16425 } 16426 _getConfig(config) { 16427 const dataAttributes = Manipulator.getDataAttributes(this._element); 16428 for (const dataAttribute of Object.keys(dataAttributes)) { 16429 if (DISALLOWED_ATTRIBUTES.has(dataAttribute)) { 16430 delete dataAttributes[dataAttribute]; 16431 } 16432 } 16433 config = { 16434 ...dataAttributes, 16435 ...(typeof config === 'object' && config ? config : {}) 16436 }; 16437 config = this._mergeConfigObj(config); 16438 config = this._configAfterMerge(config); 16439 this._typeCheckConfig(config); 16440 return config; 16441 } 16442 _configAfterMerge(config) { 16443 config.container = config.container === false ? document.body : getElement(config.container); 16444 if (typeof config.delay === 'number') { 16445 config.delay = { 16446 show: config.delay, 16447 hide: config.delay 16448 }; 16449 } 16450 if (typeof config.title === 'number') { 16451 config.title = config.title.toString(); 16452 } 16453 if (typeof config.content === 'number') { 16454 config.content = config.content.toString(); 16455 } 16456 return config; 16457 } 16458 _getDelegateConfig() { 16459 const config = {}; 16460 for (const [key, value] of Object.entries(this._config)) { 16461 if (this.constructor.Default[key] !== value) { 16462 config[key] = value; 16463 } 16464 } 16465 config.selector = false; 16466 config.trigger = 'manual'; 16467 16468 // In the future can be replaced with: 16469 // const keysWithDifferentValues = Object.entries(this._config).filter(entry => this.constructor.Default[entry[0]] !== this._config[entry[0]]) 16470 // `Object.fromEntries(keysWithDifferentValues)` 16471 return config; 16472 } 16473 _disposePopper() { 16474 if (this._popper) { 16475 this._popper.destroy(); 16476 this._popper = null; 16477 } 16478 if (this.tip) { 16479 this.tip.remove(); 16480 this.tip = null; 16481 } 16482 } 16483 16484 // Static 16485 static jQueryInterface(config) { 16486 return this.each(function () { 16487 const data = Tooltip.getOrCreateInstance(this, config); 16488 if (typeof config !== 'string') { 16489 return; 16490 } 16491 if (typeof data[config] === 'undefined') { 16492 throw new TypeError(`No method named "${config}"`); 16493 } 16494 data[config](); 16495 }); 16496 } 16497} 16498 16499/** 16500 * jQuery 16501 */ 16502 16503defineJQueryPlugin(Tooltip); 16504 16505/** 16506 * -------------------------------------------------------------------------- 16507 * Bootstrap popover.js 16508 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 16509 * -------------------------------------------------------------------------- 16510 */ 16511 16512 16513/** 16514 * Constants 16515 */ 16516 16517const NAME$3 = 'popover'; 16518const SELECTOR_TITLE = '.popover-header'; 16519const SELECTOR_CONTENT = '.popover-body'; 16520const Default$2 = { 16521 ...Tooltip.Default, 16522 content: '', 16523 offset: [0, 8], 16524 placement: 'right', 16525 template: '<div class="popover" role="tooltip">' + '<div class="popover-arrow"></div>' + '<h3 class="popover-header"></h3>' + '<div class="popover-body"></div>' + '</div>', 16526 trigger: 'click' 16527}; 16528const DefaultType$2 = { 16529 ...Tooltip.DefaultType, 16530 content: '(null|string|element|function)' 16531}; 16532 16533/** 16534 * Class definition 16535 */ 16536 16537class Popover extends Tooltip { 16538 // Getters 16539 static get Default() { 16540 return Default$2; 16541 } 16542 static get DefaultType() { 16543 return DefaultType$2; 16544 } 16545 static get NAME() { 16546 return NAME$3; 16547 } 16548 16549 // Overrides 16550 _isWithContent() { 16551 return this._getTitle() || this._getContent(); 16552 } 16553 16554 // Private 16555 _getContentForTemplate() { 16556 return { 16557 [SELECTOR_TITLE]: this._getTitle(), 16558 [SELECTOR_CONTENT]: this._getContent() 16559 }; 16560 } 16561 _getContent() { 16562 return this._resolvePossibleFunction(this._config.content); 16563 } 16564 16565 // Static 16566 static jQueryInterface(config) { 16567 return this.each(function () { 16568 const data = Popover.getOrCreateInstance(this, config); 16569 if (typeof config !== 'string') { 16570 return; 16571 } 16572 if (typeof data[config] === 'undefined') { 16573 throw new TypeError(`No method named "${config}"`); 16574 } 16575 data[config](); 16576 }); 16577 } 16578} 16579 16580/** 16581 * jQuery 16582 */ 16583 16584defineJQueryPlugin(Popover); 16585 16586/** 16587 * -------------------------------------------------------------------------- 16588 * Bootstrap scrollspy.js 16589 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 16590 * -------------------------------------------------------------------------- 16591 */ 16592 16593 16594/** 16595 * Constants 16596 */ 16597 16598const NAME$2 = 'scrollspy'; 16599const DATA_KEY$2 = 'bs.scrollspy'; 16600const EVENT_KEY$2 = `.${DATA_KEY$2}`; 16601const DATA_API_KEY = '.data-api'; 16602const EVENT_ACTIVATE = `activate${EVENT_KEY$2}`; 16603const EVENT_CLICK = `click${EVENT_KEY$2}`; 16604const EVENT_LOAD_DATA_API$1 = `load${EVENT_KEY$2}${DATA_API_KEY}`; 16605const CLASS_NAME_DROPDOWN_ITEM = 'dropdown-item'; 16606const CLASS_NAME_ACTIVE$1 = 'active'; 16607const SELECTOR_DATA_SPY = '[data-bs-spy="scroll"]'; 16608const SELECTOR_TARGET_LINKS = '[href]'; 16609const SELECTOR_NAV_LIST_GROUP = '.nav, .list-group'; 16610const SELECTOR_NAV_LINKS = '.nav-link'; 16611const SELECTOR_NAV_ITEMS = '.nav-item'; 16612const SELECTOR_LIST_ITEMS = '.list-group-item'; 16613const SELECTOR_LINK_ITEMS = `${SELECTOR_NAV_LINKS}, ${SELECTOR_NAV_ITEMS} > ${SELECTOR_NAV_LINKS}, ${SELECTOR_LIST_ITEMS}`; 16614const SELECTOR_DROPDOWN = '.dropdown'; 16615const SELECTOR_DROPDOWN_TOGGLE$1 = '.dropdown-toggle'; 16616const Default$1 = { 16617 offset: null, 16618 // TODO: v6 @deprecated, keep it for backwards compatibility reasons 16619 rootMargin: '0px 0px -25%', 16620 smoothScroll: false, 16621 target: null, 16622 threshold: [0.1, 0.5, 1] 16623}; 16624const DefaultType$1 = { 16625 offset: '(number|null)', 16626 // TODO v6 @deprecated, keep it for backwards compatibility reasons 16627 rootMargin: 'string', 16628 smoothScroll: 'boolean', 16629 target: 'element', 16630 threshold: 'array' 16631}; 16632 16633/** 16634 * Class definition 16635 */ 16636 16637class ScrollSpy extends BaseComponent { 16638 constructor(element, config) { 16639 super(element, config); 16640 16641 // this._element is the observablesContainer and config.target the menu links wrapper 16642 this._targetLinks = new Map(); 16643 this._observableSections = new Map(); 16644 this._rootElement = getComputedStyle(this._element).overflowY === 'visible' ? null : this._element; 16645 this._activeTarget = null; 16646 this._observer = null; 16647 this._previousScrollData = { 16648 visibleEntryTop: 0, 16649 parentScrollTop: 0 16650 }; 16651 this.refresh(); // initialize 16652 } 16653 16654 // Getters 16655 static get Default() { 16656 return Default$1; 16657 } 16658 static get DefaultType() { 16659 return DefaultType$1; 16660 } 16661 static get NAME() { 16662 return NAME$2; 16663 } 16664 16665 // Public 16666 refresh() { 16667 this._initializeTargetsAndObservables(); 16668 this._maybeEnableSmoothScroll(); 16669 if (this._observer) { 16670 this._observer.disconnect(); 16671 } else { 16672 this._observer = this._getNewObserver(); 16673 } 16674 for (const section of this._observableSections.values()) { 16675 this._observer.observe(section); 16676 } 16677 } 16678 dispose() { 16679 this._observer.disconnect(); 16680 super.dispose(); 16681 } 16682 16683 // Private 16684 _configAfterMerge(config) { 16685 // TODO: on v6 target should be given explicitly & remove the {target: 'ss-target'} case 16686 config.target = getElement(config.target) || document.body; 16687 16688 // TODO: v6 Only for backwards compatibility reasons. Use rootMargin only 16689 config.rootMargin = config.offset ? `${config.offset}px 0px -30%` : config.rootMargin; 16690 if (typeof config.threshold === 'string') { 16691 config.threshold = config.threshold.split(',').map(value => Number.parseFloat(value)); 16692 } 16693 return config; 16694 } 16695 _maybeEnableSmoothScroll() { 16696 if (!this._config.smoothScroll) { 16697 return; 16698 } 16699 16700 // unregister any previous listeners 16701 EventHandler.off(this._config.target, EVENT_CLICK); 16702 EventHandler.on(this._config.target, EVENT_CLICK, SELECTOR_TARGET_LINKS, event => { 16703 const observableSection = this._observableSections.get(event.target.hash); 16704 if (observableSection) { 16705 event.preventDefault(); 16706 const root = this._rootElement || window; 16707 const height = observableSection.offsetTop - this._element.offsetTop; 16708 if (root.scrollTo) { 16709 root.scrollTo({ 16710 top: height, 16711 behavior: 'smooth' 16712 }); 16713 return; 16714 } 16715 16716 // Chrome 60 doesn't support `scrollTo` 16717 root.scrollTop = height; 16718 } 16719 }); 16720 } 16721 _getNewObserver() { 16722 const options = { 16723 root: this._rootElement, 16724 threshold: this._config.threshold, 16725 rootMargin: this._config.rootMargin 16726 }; 16727 return new IntersectionObserver(entries => this._observerCallback(entries), options); 16728 } 16729 16730 // The logic of selection 16731 _observerCallback(entries) { 16732 const targetElement = entry => this._targetLinks.get(`#${entry.target.id}`); 16733 const activate = entry => { 16734 this._previousScrollData.visibleEntryTop = entry.target.offsetTop; 16735 this._process(targetElement(entry)); 16736 }; 16737 const parentScrollTop = (this._rootElement || document.documentElement).scrollTop; 16738 const userScrollsDown = parentScrollTop >= this._previousScrollData.parentScrollTop; 16739 this._previousScrollData.parentScrollTop = parentScrollTop; 16740 for (const entry of entries) { 16741 if (!entry.isIntersecting) { 16742 this._activeTarget = null; 16743 this._clearActiveClass(targetElement(entry)); 16744 continue; 16745 } 16746 const entryIsLowerThanPrevious = entry.target.offsetTop >= this._previousScrollData.visibleEntryTop; 16747 // if we are scrolling down, pick the bigger offsetTop 16748 if (userScrollsDown && entryIsLowerThanPrevious) { 16749 activate(entry); 16750 // if parent isn't scrolled, let's keep the first visible item, breaking the iteration 16751 if (!parentScrollTop) { 16752 return; 16753 } 16754 continue; 16755 } 16756 16757 // if we are scrolling up, pick the smallest offsetTop 16758 if (!userScrollsDown && !entryIsLowerThanPrevious) { 16759 activate(entry); 16760 } 16761 } 16762 } 16763 _initializeTargetsAndObservables() { 16764 this._targetLinks = new Map(); 16765 this._observableSections = new Map(); 16766 const targetLinks = SelectorEngine.find(SELECTOR_TARGET_LINKS, this._config.target); 16767 for (const anchor of targetLinks) { 16768 // ensure that the anchor has an id and is not disabled 16769 if (!anchor.hash || isDisabled(anchor)) { 16770 continue; 16771 } 16772 const observableSection = SelectorEngine.findOne(decodeURI(anchor.hash), this._element); 16773 16774 // ensure that the observableSection exists & is visible 16775 if (isVisible(observableSection)) { 16776 this._targetLinks.set(decodeURI(anchor.hash), anchor); 16777 this._observableSections.set(anchor.hash, observableSection); 16778 } 16779 } 16780 } 16781 _process(target) { 16782 if (this._activeTarget === target) { 16783 return; 16784 } 16785 this._clearActiveClass(this._config.target); 16786 this._activeTarget = target; 16787 target.classList.add(CLASS_NAME_ACTIVE$1); 16788 this._activateParents(target); 16789 EventHandler.trigger(this._element, EVENT_ACTIVATE, { 16790 relatedTarget: target 16791 }); 16792 } 16793 _activateParents(target) { 16794 // Activate dropdown parents 16795 if (target.classList.contains(CLASS_NAME_DROPDOWN_ITEM)) { 16796 SelectorEngine.findOne(SELECTOR_DROPDOWN_TOGGLE$1, target.closest(SELECTOR_DROPDOWN)).classList.add(CLASS_NAME_ACTIVE$1); 16797 return; 16798 } 16799 for (const listGroup of SelectorEngine.parents(target, SELECTOR_NAV_LIST_GROUP)) { 16800 // Set triggered links parents as active 16801 // With both <ul> and <nav> markup a parent is the previous sibling of any nav ancestor 16802 for (const item of SelectorEngine.prev(listGroup, SELECTOR_LINK_ITEMS)) { 16803 item.classList.add(CLASS_NAME_ACTIVE$1); 16804 } 16805 } 16806 } 16807 _clearActiveClass(parent) { 16808 parent.classList.remove(CLASS_NAME_ACTIVE$1); 16809 const activeNodes = SelectorEngine.find(`${SELECTOR_TARGET_LINKS}.${CLASS_NAME_ACTIVE$1}`, parent); 16810 for (const node of activeNodes) { 16811 node.classList.remove(CLASS_NAME_ACTIVE$1); 16812 } 16813 } 16814 16815 // Static 16816 static jQueryInterface(config) { 16817 return this.each(function () { 16818 const data = ScrollSpy.getOrCreateInstance(this, config); 16819 if (typeof config !== 'string') { 16820 return; 16821 } 16822 if (data[config] === undefined || config.startsWith('_') || config === 'constructor') { 16823 throw new TypeError(`No method named "${config}"`); 16824 } 16825 data[config](); 16826 }); 16827 } 16828} 16829 16830/** 16831 * Data API implementation 16832 */ 16833 16834EventHandler.on(window, EVENT_LOAD_DATA_API$1, () => { 16835 for (const spy of SelectorEngine.find(SELECTOR_DATA_SPY)) { 16836 ScrollSpy.getOrCreateInstance(spy); 16837 } 16838}); 16839 16840/** 16841 * jQuery 16842 */ 16843 16844defineJQueryPlugin(ScrollSpy); 16845 16846/** 16847 * -------------------------------------------------------------------------- 16848 * Bootstrap tab.js 16849 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 16850 * -------------------------------------------------------------------------- 16851 */ 16852 16853 16854/** 16855 * Constants 16856 */ 16857 16858const NAME$1 = 'tab'; 16859const DATA_KEY$1 = 'bs.tab'; 16860const EVENT_KEY$1 = `.${DATA_KEY$1}`; 16861const EVENT_HIDE$1 = `hide${EVENT_KEY$1}`; 16862const EVENT_HIDDEN$1 = `hidden${EVENT_KEY$1}`; 16863const EVENT_SHOW$1 = `show${EVENT_KEY$1}`; 16864const EVENT_SHOWN$1 = `shown${EVENT_KEY$1}`; 16865const EVENT_CLICK_DATA_API = `click${EVENT_KEY$1}`; 16866const EVENT_KEYDOWN = `keydown${EVENT_KEY$1}`; 16867const EVENT_LOAD_DATA_API = `load${EVENT_KEY$1}`; 16868const ARROW_LEFT_KEY = 'ArrowLeft'; 16869const ARROW_RIGHT_KEY = 'ArrowRight'; 16870const ARROW_UP_KEY = 'ArrowUp'; 16871const ARROW_DOWN_KEY = 'ArrowDown'; 16872const HOME_KEY = 'Home'; 16873const END_KEY = 'End'; 16874const CLASS_NAME_ACTIVE = 'active'; 16875const CLASS_NAME_FADE$1 = 'fade'; 16876const CLASS_NAME_SHOW$1 = 'show'; 16877const CLASS_DROPDOWN = 'dropdown'; 16878const SELECTOR_DROPDOWN_TOGGLE = '.dropdown-toggle'; 16879const SELECTOR_DROPDOWN_MENU = '.dropdown-menu'; 16880const NOT_SELECTOR_DROPDOWN_TOGGLE = `:not(${SELECTOR_DROPDOWN_TOGGLE})`; 16881const SELECTOR_TAB_PANEL = '.list-group, .nav, [role="tablist"]'; 16882const SELECTOR_OUTER = '.nav-item, .list-group-item'; 16883const SELECTOR_INNER = `.nav-link${NOT_SELECTOR_DROPDOWN_TOGGLE}, .list-group-item${NOT_SELECTOR_DROPDOWN_TOGGLE}, [role="tab"]${NOT_SELECTOR_DROPDOWN_TOGGLE}`; 16884const SELECTOR_DATA_TOGGLE = '[data-bs-toggle="tab"], [data-bs-toggle="pill"], [data-bs-toggle="list"]'; // TODO: could only be `tab` in v6 16885const SELECTOR_INNER_ELEM = `${SELECTOR_INNER}, ${SELECTOR_DATA_TOGGLE}`; 16886const SELECTOR_DATA_TOGGLE_ACTIVE = `.${CLASS_NAME_ACTIVE}[data-bs-toggle="tab"], .${CLASS_NAME_ACTIVE}[data-bs-toggle="pill"], .${CLASS_NAME_ACTIVE}[data-bs-toggle="list"]`; 16887 16888/** 16889 * Class definition 16890 */ 16891 16892class Tab extends BaseComponent { 16893 constructor(element) { 16894 super(element); 16895 this._parent = this._element.closest(SELECTOR_TAB_PANEL); 16896 if (!this._parent) { 16897 return; 16898 // TODO: should throw exception in v6 16899 // throw new TypeError(`${element.outerHTML} has not a valid parent ${SELECTOR_INNER_ELEM}`) 16900 } 16901 16902 // Set up initial aria attributes 16903 this._setInitialAttributes(this._parent, this._getChildren()); 16904 EventHandler.on(this._element, EVENT_KEYDOWN, event => this._keydown(event)); 16905 } 16906 16907 // Getters 16908 static get NAME() { 16909 return NAME$1; 16910 } 16911 16912 // Public 16913 show() { 16914 // Shows this elem and deactivate the active sibling if exists 16915 const innerElem = this._element; 16916 if (this._elemIsActive(innerElem)) { 16917 return; 16918 } 16919 16920 // Search for active tab on same parent to deactivate it 16921 const active = this._getActiveElem(); 16922 const hideEvent = active ? EventHandler.trigger(active, EVENT_HIDE$1, { 16923 relatedTarget: innerElem 16924 }) : null; 16925 const showEvent = EventHandler.trigger(innerElem, EVENT_SHOW$1, { 16926 relatedTarget: active 16927 }); 16928 if (showEvent.defaultPrevented || hideEvent && hideEvent.defaultPrevented) { 16929 return; 16930 } 16931 this._deactivate(active, innerElem); 16932 this._activate(innerElem, active); 16933 } 16934 16935 // Private 16936 _activate(element, relatedElem) { 16937 if (!element) { 16938 return; 16939 } 16940 element.classList.add(CLASS_NAME_ACTIVE); 16941 this._activate(SelectorEngine.getElementFromSelector(element)); // Search and activate/show the proper section 16942 16943 const complete = () => { 16944 if (element.getAttribute('role') !== 'tab') { 16945 element.classList.add(CLASS_NAME_SHOW$1); 16946 return; 16947 } 16948 element.removeAttribute('tabindex'); 16949 element.setAttribute('aria-selected', true); 16950 this._toggleDropDown(element, true); 16951 EventHandler.trigger(element, EVENT_SHOWN$1, { 16952 relatedTarget: relatedElem 16953 }); 16954 }; 16955 this._queueCallback(complete, element, element.classList.contains(CLASS_NAME_FADE$1)); 16956 } 16957 _deactivate(element, relatedElem) { 16958 if (!element) { 16959 return; 16960 } 16961 element.classList.remove(CLASS_NAME_ACTIVE); 16962 element.blur(); 16963 this._deactivate(SelectorEngine.getElementFromSelector(element)); // Search and deactivate the shown section too 16964 16965 const complete = () => { 16966 if (element.getAttribute('role') !== 'tab') { 16967 element.classList.remove(CLASS_NAME_SHOW$1); 16968 return; 16969 } 16970 element.setAttribute('aria-selected', false); 16971 element.setAttribute('tabindex', '-1'); 16972 this._toggleDropDown(element, false); 16973 EventHandler.trigger(element, EVENT_HIDDEN$1, { 16974 relatedTarget: relatedElem 16975 }); 16976 }; 16977 this._queueCallback(complete, element, element.classList.contains(CLASS_NAME_FADE$1)); 16978 } 16979 _keydown(event) { 16980 if (![ARROW_LEFT_KEY, ARROW_RIGHT_KEY, ARROW_UP_KEY, ARROW_DOWN_KEY, HOME_KEY, END_KEY].includes(event.key)) { 16981 return; 16982 } 16983 event.stopPropagation(); // stopPropagation/preventDefault both added to support up/down keys without scrolling the page 16984 event.preventDefault(); 16985 const children = this._getChildren().filter(element => !isDisabled(element)); 16986 let nextActiveElement; 16987 if ([HOME_KEY, END_KEY].includes(event.key)) { 16988 nextActiveElement = children[event.key === HOME_KEY ? 0 : children.length - 1]; 16989 } else { 16990 const isNext = [ARROW_RIGHT_KEY, ARROW_DOWN_KEY].includes(event.key); 16991 nextActiveElement = getNextActiveElement(children, event.target, isNext, true); 16992 } 16993 if (nextActiveElement) { 16994 nextActiveElement.focus({ 16995 preventScroll: true 16996 }); 16997 Tab.getOrCreateInstance(nextActiveElement).show(); 16998 } 16999 } 17000 _getChildren() { 17001 // collection of inner elements 17002 return SelectorEngine.find(SELECTOR_INNER_ELEM, this._parent); 17003 } 17004 _getActiveElem() { 17005 return this._getChildren().find(child => this._elemIsActive(child)) || null; 17006 } 17007 _setInitialAttributes(parent, children) { 17008 this._setAttributeIfNotExists(parent, 'role', 'tablist'); 17009 for (const child of children) { 17010 this._setInitialAttributesOnChild(child); 17011 } 17012 } 17013 _setInitialAttributesOnChild(child) { 17014 child = this._getInnerElement(child); 17015 const isActive = this._elemIsActive(child); 17016 const outerElem = this._getOuterElement(child); 17017 child.setAttribute('aria-selected', isActive); 17018 if (outerElem !== child) { 17019 this._setAttributeIfNotExists(outerElem, 'role', 'presentation'); 17020 } 17021 if (!isActive) { 17022 child.setAttribute('tabindex', '-1'); 17023 } 17024 this._setAttributeIfNotExists(child, 'role', 'tab'); 17025 17026 // set attributes to the related panel too 17027 this._setInitialAttributesOnTargetPanel(child); 17028 } 17029 _setInitialAttributesOnTargetPanel(child) { 17030 const target = SelectorEngine.getElementFromSelector(child); 17031 if (!target) { 17032 return; 17033 } 17034 this._setAttributeIfNotExists(target, 'role', 'tabpanel'); 17035 if (child.id) { 17036 this._setAttributeIfNotExists(target, 'aria-labelledby', `${child.id}`); 17037 } 17038 } 17039 _toggleDropDown(element, open) { 17040 const outerElem = this._getOuterElement(element); 17041 if (!outerElem.classList.contains(CLASS_DROPDOWN)) { 17042 return; 17043 } 17044 const toggle = (selector, className) => { 17045 const element = SelectorEngine.findOne(selector, outerElem); 17046 if (element) { 17047 element.classList.toggle(className, open); 17048 } 17049 }; 17050 toggle(SELECTOR_DROPDOWN_TOGGLE, CLASS_NAME_ACTIVE); 17051 toggle(SELECTOR_DROPDOWN_MENU, CLASS_NAME_SHOW$1); 17052 outerElem.setAttribute('aria-expanded', open); 17053 } 17054 _setAttributeIfNotExists(element, attribute, value) { 17055 if (!element.hasAttribute(attribute)) { 17056 element.setAttribute(attribute, value); 17057 } 17058 } 17059 _elemIsActive(elem) { 17060 return elem.classList.contains(CLASS_NAME_ACTIVE); 17061 } 17062 17063 // Try to get the inner element (usually the .nav-link) 17064 _getInnerElement(elem) { 17065 return elem.matches(SELECTOR_INNER_ELEM) ? elem : SelectorEngine.findOne(SELECTOR_INNER_ELEM, elem); 17066 } 17067 17068 // Try to get the outer element (usually the .nav-item) 17069 _getOuterElement(elem) { 17070 return elem.closest(SELECTOR_OUTER) || elem; 17071 } 17072 17073 // Static 17074 static jQueryInterface(config) { 17075 return this.each(function () { 17076 const data = Tab.getOrCreateInstance(this); 17077 if (typeof config !== 'string') { 17078 return; 17079 } 17080 if (data[config] === undefined || config.startsWith('_') || config === 'constructor') { 17081 throw new TypeError(`No method named "${config}"`); 17082 } 17083 data[config](); 17084 }); 17085 } 17086} 17087 17088/** 17089 * Data API implementation 17090 */ 17091 17092EventHandler.on(document, EVENT_CLICK_DATA_API, SELECTOR_DATA_TOGGLE, function (event) { 17093 if (['A', 'AREA'].includes(this.tagName)) { 17094 event.preventDefault(); 17095 } 17096 if (isDisabled(this)) { 17097 return; 17098 } 17099 Tab.getOrCreateInstance(this).show(); 17100}); 17101 17102/** 17103 * Initialize on focus 17104 */ 17105EventHandler.on(window, EVENT_LOAD_DATA_API, () => { 17106 for (const element of SelectorEngine.find(SELECTOR_DATA_TOGGLE_ACTIVE)) { 17107 Tab.getOrCreateInstance(element); 17108 } 17109}); 17110/** 17111 * jQuery 17112 */ 17113 17114defineJQueryPlugin(Tab); 17115 17116/** 17117 * -------------------------------------------------------------------------- 17118 * Bootstrap toast.js 17119 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 17120 * -------------------------------------------------------------------------- 17121 */ 17122 17123 17124/** 17125 * Constants 17126 */ 17127 17128const NAME = 'toast'; 17129const DATA_KEY = 'bs.toast'; 17130const EVENT_KEY = `.${DATA_KEY}`; 17131const EVENT_MOUSEOVER = `mouseover${EVENT_KEY}`; 17132const EVENT_MOUSEOUT = `mouseout${EVENT_KEY}`; 17133const EVENT_FOCUSIN = `focusin${EVENT_KEY}`; 17134const EVENT_FOCUSOUT = `focusout${EVENT_KEY}`; 17135const EVENT_HIDE = `hide${EVENT_KEY}`; 17136const EVENT_HIDDEN = `hidden${EVENT_KEY}`; 17137const EVENT_SHOW = `show${EVENT_KEY}`; 17138const EVENT_SHOWN = `shown${EVENT_KEY}`; 17139const CLASS_NAME_FADE = 'fade'; 17140const CLASS_NAME_HIDE = 'hide'; // @deprecated - kept here only for backwards compatibility 17141const CLASS_NAME_SHOW = 'show'; 17142const CLASS_NAME_SHOWING = 'showing'; 17143const DefaultType = { 17144 animation: 'boolean', 17145 autohide: 'boolean', 17146 delay: 'number' 17147}; 17148const Default = { 17149 animation: true, 17150 autohide: true, 17151 delay: 5000 17152}; 17153 17154/** 17155 * Class definition 17156 */ 17157 17158class Toast extends BaseComponent { 17159 constructor(element, config) { 17160 super(element, config); 17161 this._timeout = null; 17162 this._hasMouseInteraction = false; 17163 this._hasKeyboardInteraction = false; 17164 this._setListeners(); 17165 } 17166 17167 // Getters 17168 static get Default() { 17169 return Default; 17170 } 17171 static get DefaultType() { 17172 return DefaultType; 17173 } 17174 static get NAME() { 17175 return NAME; 17176 } 17177 17178 // Public 17179 show() { 17180 const showEvent = EventHandler.trigger(this._element, EVENT_SHOW); 17181 if (showEvent.defaultPrevented) { 17182 return; 17183 } 17184 this._clearTimeout(); 17185 if (this._config.animation) { 17186 this._element.classList.add(CLASS_NAME_FADE); 17187 } 17188 const complete = () => { 17189 this._element.classList.remove(CLASS_NAME_SHOWING); 17190 EventHandler.trigger(this._element, EVENT_SHOWN); 17191 this._maybeScheduleHide(); 17192 }; 17193 this._element.classList.remove(CLASS_NAME_HIDE); // @deprecated 17194 reflow(this._element); 17195 this._element.classList.add(CLASS_NAME_SHOW, CLASS_NAME_SHOWING); 17196 this._queueCallback(complete, this._element, this._config.animation); 17197 } 17198 hide() { 17199 if (!this.isShown()) { 17200 return; 17201 } 17202 const hideEvent = EventHandler.trigger(this._element, EVENT_HIDE); 17203 if (hideEvent.defaultPrevented) { 17204 return; 17205 } 17206 const complete = () => { 17207 this._element.classList.add(CLASS_NAME_HIDE); // @deprecated 17208 this._element.classList.remove(CLASS_NAME_SHOWING, CLASS_NAME_SHOW); 17209 EventHandler.trigger(this._element, EVENT_HIDDEN); 17210 }; 17211 this._element.classList.add(CLASS_NAME_SHOWING); 17212 this._queueCallback(complete, this._element, this._config.animation); 17213 } 17214 dispose() { 17215 this._clearTimeout(); 17216 if (this.isShown()) { 17217 this._element.classList.remove(CLASS_NAME_SHOW); 17218 } 17219 super.dispose(); 17220 } 17221 isShown() { 17222 return this._element.classList.contains(CLASS_NAME_SHOW); 17223 } 17224 17225 // Private
vendor: 1,583 bytes, lines 17226-17279
17226 17227 _maybeScheduleHide() { 17228 if (!this._config.autohide) { 17229 return; 17230 } 17231 if (this._hasMouseInteraction || this._hasKeyboardInteraction) { 17232 return; 17233 } 17234 this._timeout = setTimeout(() => { 17235 this.hide(); 17236 }, this._config.delay); 17237 } 17238 _onInteraction(event, isInteracting) { 17239 switch (event.type) { 17240 case 'mouseover': 17241 case 'mouseout': 17242 { 17243 this._hasMouseInteraction = isInteracting; 17244 break; 17245 } 17246 case 'focusin': 17247 case 'focusout': 17248 { 17249 this._hasKeyboardInteraction = isInteracting; 17250 break; 17251 } 17252 } 17253 if (isInteracting) { 17254 this._clearTimeout(); 17255 return; 17256 } 17257 const nextElement = event.relatedTarget; 17258 if (this._element === nextElement || this._element.contains(nextElement)) { 17259 return; 17260 } 17261 this._maybeScheduleHide(); 17262 } 17263 _setListeners() { 17264 EventHandler.on(this._element, EVENT_MOUSEOVER, event => this._onInteraction(event, true)); 17265 EventHandler.on(this._element, EVENT_MOUSEOUT, event => this._onInteraction(event, false)); 17266 EventHandler.on(this._element, EVENT_FOCUSIN, event => this._onInteraction(event, true)); 17267 EventHandler.on(this._element, EVENT_FOCUSOUT, event => this._onInteraction(event, false)); 17268 } 17269 _clearTimeout() { 17270 clearTimeout(this._timeout); 17271 this._timeout = null; 17272 } 17273 17274 // Static 17275 static jQueryInterface(config) { 17276 return this.each(function () { 17277 const data = Toast.getOrCreateInstance(this, config); 17278 if (typeof config === 'string') { 17279 if (typeof data[config] === 'undefined') {
17280 throw new TypeError(`No method named "${config}"`); 17281 } 17282 data[config](this); 17283 } 17284 }); 17285 } 17286} 17287 17288/** 17289 * Data API implementation 17290 */ 17291 17292enableDismissTrigger(Toast); 17293 17294/** 17295 * jQuery 17296 */ 17297 17298defineJQueryPlugin(Toast); 17299 17300 17301//# sourceMappingURL=bootstrap.esm.js.map 17302 17303;// CONCATENATED MODULE: ./src/WinUtil.js 17304function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); } 17305function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } 17306function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); } 17307function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); } 17308function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); } 17309function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; } 17310var WinUtil = { 17311 getSizes: function getSizes() { 17312 var contentWidth = _toConsumableArray(document.body.children).reduce(function (a, el) { 17313 return Math.max(a, el.getBoundingClientRect().right); 17314 }, 0) - document.body.getBoundingClientRect().x; 17315 return { 17316 windowWidth: document.documentElement.clientWidth, 17317 windowHeight: document.documentElement.clientHeight, 17318 pageWidth: Math.min(document.body.scrollWidth, contentWidth), 17319 pageHeight: document.body.scrollHeight, 17320 screenWidth: parseInt(window.screen.width), 17321 screenHeight: parseInt(window.screen.height), 17322 pageX: document.body.getBoundingClientRect().x, 17323 pageY: document.body.getBoundingClientRect().y, 17324 screenX: -window.screenX, 17325 screenY: -window.screenY - (window.outerHeight - window.innerHeight) 17326 }; 17327 } 17328}; 17329 17330;// CONCATENATED MODULE: ./src/assets/logo-170x50-sg-ds.png 17331/* harmony default export */ const logo_170x50_sg_ds = (__webpack_require__.p + "5377da0821ac220681d50a837dcbe1b5.png"); 17332;// CONCATENATED MODULE: ./node_modules/raw-loader/dist/cjs.js!./src/static-content/header.html 17333/* harmony default export */ const header = ("<!-- Navigation -->\n<nav class=\"navbar navbar-default navbar-fixed-top topnav\" role=\"navigation\">\n\t<div class=\"container topnav\">\n\t\t<div class=\"navbar-header\">\n\t\t\t<div class=\"logo_sect\" data-toggle=\"tooltip\" data-placement=\"top\" title=\"Go to Statgenic Data Science\">\n\t\t\t\t<a target=\"_blank\" href=\"http://www.knutas.com/data_science\">\n\t\t\t\t\t<img src=\"\" alt=\"\" width=\"170\" height=\"50\" class=\"logo_def\">\n\t\t\t\t</a>\n\t\t\t</div>\n\t\t</div>\n <!-- /.navbar-collapse -->\n\t</div>\n<!-- /.container -->\n</nav>\n\n<!-- header -->"); 17334;// CONCATENATED MODULE: ./node_modules/raw-loader/dist/cjs.js!./src/static-content/content-main.html 17335/* harmony default export */ const content_main = ("\n<div id=\"haiku-app-content\">\n\n\t<div id=\"title\">\n\t\t<p>\n\t\t<h1><i>H/ai/ku Master</i></h1>\n\t\t<h5>俳å¥ã®é人 / <i>Haiku no tatsujin</i></h5>\n\t\t</p>\n\t</div>\n\n\n\t<div style=\"padding: 20px;\" data-toggle=\"tooltip\" data-placement=\"top\" title=\"Open haiku editor\">\n\t\t<i class=\"material-symbols-outlined\" onclick=\"javascript:app.openEditor();\" style=\"font-size:36px;cursor: pointer; opacity: 0.5;\">ink_pen</i>\n\t</div>\n\n\t\n\t<div id=\"haiku\">\n\t\t<h2><i>sudden rainstorm</i></h2>\n\t\t<h2><i>a moth flies towards</i></h2>\n\t\t<h2><i>she and her reflection</i></h2>\n\t</div>\n\n\t\n\t<div class=\"menu-item-haiku button\" id=\"menu-item-generate\" onclick=\"javascript:app.renderHaiku();\"> \n\t\t<div id=\"generate-status\" class=\"menu-item-haiku-label\">\n\t\t\tGenerate Haiku!\n\t\t</div>\n\t</div>\n\t\n\n\t<div class=\"menu-item-haiku\" id=\"menu-item-keywords-selected\">\n\t\t<div id=\"keywords-selected\">...</div>\n\t</div>\n\n\n\t<div class=\"menu-item-haiku button\" id=\"menu-item-keywords\"\n\t\t\t\t\tonclick=\"javascript:app.openKeywords();\"> \n\t\t<div id=\"keywords-status\" class=\"menu-item-haiku-label\">\n\t\t\tChange Keywords\n\t\t</div>\n\t</div>\n\t\t\n\n\t<div class=\"menu-item-haiku\" id=\"menu-item-settings\" data-toggle=\"tooltip\" data-placement=\"top\" title=\"Open settings\"\n\t onclick=\"javascript:app.openSettings();\">\n\t\t<div id=\"settings-status\" class=\"menu-item-haiku-label\">\n\t\t\tSettings\n\t\t</div>\n\t\t<i class=\"material-symbols-outlined\" style=\"font-size:36px\">settings</i>\n\t</div>\n\n\n\t<div id=\"help-haiku\">\n\t\t<p>\n\t\t\t \n\t\t</P>\n\n\t\t<p style=\"color:#bbb\">\n\t\t\t<h4>Help</h4>\n\t\t\tThe haiku is generated based on the selected keywords.<br/>\n\t\t\t3 keywords, one for each line, are mandatory.<br/>
17335\n\t\t\tFor strict 5-7-5 syllable haikus, go to settings and select 'Strict Mode'.<br/>\n\t\t\tTo write your own haikus click on the <span class=\"material-symbols-outlined\">ink_pen</span> to open the editor. <br/>The editor provides creative assistance and generative AI-features.\n\t\t</p>\n\n\t\t\n\t\t<p style=\"color:#bbb\">\n\t\t\t\n\t\t\t<h4>About</h4>\n\t\t\t\n\t\t\tHaiku (俳å¥) is a type of short form poetry that originated in Japan.<br/>\n\t\t\tTraditional Japanese haiku consist of three phrases<br/> \n\t\t\tcomposed of 17 phonetic units (called on in Japanese,<br/>\n\t\t\twhich are similar to syllables) in a 5, 7, 5 pattern;<br/> \n\t\t\tthat include a kireji, or \"cutting word\";<br/> \n\t\t\tand a kigo, or seasonal reference.<br/>\n\t\t\tSimilar poems that do not adhere to these rules<br/>\n\t\t\tare generally classified as senryÅ«.\n\t\t\t\n\t\t\t<br/><br/>\n\t\t\t<a target=\"_blank\" href=\"https://en.wikipedia.org/wiki/Haiku\">https://en.wikipedia.org/wiki/Haiku</a>\n\t\t</p>\n\t</div>\n\n\t<!-- footer -->\n\n\t<div class=\"container\">\n\t\t<div class=\"row\">\n\t\t\t<div class=\"col-lg-12\">\n\t\t\t\t<ul class=\"list-inline\">\n\t\t\t\t\t<li>\n\t\t\t\t\t\t<a href=\"#\">Top</a>\n\t\t\t\t\t</li>\n\t\t\t\t</ul>\n\t\t\t\t<p class=\"copyright text-muted small\">\n\t\t\t\t\t<a target=\"_blank\" href=\"http://www.knutas.com/data_science\">© 2023 Statgenic Data Science</a>\n\t\t\t\t</p>\n\n\t\t\t\t <p class=\"copyright text-muted small\">\n \t\tBuild version: <span id=\"build_version\"></span>\n \t\t</p>\n\t\t\t</div>\n\t\t</div>\n\t</div>\n\n</div>\n"); 17336;// CONCATENATED MODULE: ./node_modules/raw-loader/dist/cjs.js!./src/static-content/editor.html 17337/* harmony default export */ const editor = ("<div id=\"editor\">\n\n\t<div id=\"editor-close-icon\" class=\"close-icon\" onclick=\"javascript:app.closeEditor();\">\n\t\t<a>â Close </a>\n\t</div>\n\n\t<div id=\"editor-title\">\n\t\t<p>\n\t\t\t<h2><i>H/ai/ku Master Editor</i></h2>\n\t\t\t<h5>俳å¥ã®é人 / <i>Haiku no tatsujin</i></h5>\n\t\t</p>\n\t\t<div class=\"divider-haiku-top\"></div>\n\t</div>\n\n\t<div id=\"edit-haiku\">\n\t\t<h2 class=\"editor-row\" onclick=\"javascript:app.editor.selectEditorRowId(0);\"><i>white swan in green</i></h2>\n\t\t<h2 class=\"editor-row\" onclick=\"javascript:app.editor.selectEditorRowId(1);\"><i>a moth flies towards</i></h2>\n\t\t<h2 class=\"editor-row\" onclick=\"javascript:app.editor.selectEditorRowId(2);\"><i>she and her reflection</i></h2>\n\t\t\n\t</div>\n\n\t<div id=\"edit-haiku-auto\">\n\t\t<div class=\"divider-haiku-top\"></div>\n\n\t\t<h2 class=\"editor-row\">\n\t\t\t<i><span id=\"editor-auto-row\"></span></i>\n\t\t</h2>\n\n\t\t<div id=\"auto-row-toolbar\">\n\n\t\t\t<span id=\"auto-complete-diversity\">Diversity=1</span><br/>\n\n\t\t\t\n\t\t\t<span onclick=\"javascript:app.wordfreq.deleteSelectedWordFromAutoComplete();\" class=\"material-symbols-outlined auto-row-toolbar-item\" style=\"font-size: 36px;\"\n\t\t\tdata-toggle=\"tooltip\" data-placement=\"top\" title=\"Delete selected word\">delete</span>\n\t\t\t \n\t\t\t\t\n\n\t\t\t<span onclick=\"javascript:app.setDiversity();\" data-toggle=\"tooltip\" data-placement=\"top\" title=\"Tune diversity in output\" class=\"material-symbols-outlined auto-row-toolbar-item\" style=\"font-size: 36px;\">\n\t\t\t\tdiscover_tune\n\t\t\t</span> \n\n\t\t\t<span onclick=\"javascript:app.autoComplete();\" data-toggle=\"tooltip\" data-placement=\"top\" title=\"Auto-complete row\" class=\"material-symbols-outlined auto-row-toolbar-item\" style=\"font-size: 36px;\">\n\t\t\texperiment\n\t\t\t</span> \n\n\t\t\t<span onclick=\"javascript:app.autoSuggest();\" data-toggle=\"tooltip\" data-placement=\"top\" title=\"Auto-generate haiku\" class=\"material-symbols-outlined auto-row-toolbar-item\" style=\"font-size: 36px;\">\n\t\t\tcasino\n\t\t\t</span> \n\n\t\t\t<span onclick=\"javascript:app.editor.flipRows();\" data-toggle=\"tooltip\" data-placement=\"top\" title=\"Move selected row\" class=\"material-symbols-outlined auto-row-toolbar-item\" style=\"font-size: 36px;\">\n\t\t\ttext_select_move_up\n\t\t\t</span> \n\n\t\t\t<span onclick=\"javascript:app.editor.addRowFromAutoComplete();\" class=\"material-symbols-outlined auto-row-toolbar-item\" style=\"font-size: 36px;\"\n\t\t\tdata-toggle=\"tooltip\" data-placement=\"top\" title=\"Add sentence to Haiku\">playlist_add</span> \n\n\t\t\t<span onclick=\"javascript:app.editor.addToHistory();\" class=\"material-symbols-outlined auto-row-toolbar-item\" style=\"font-size: 36px;\"\n\t\t\tdata-toggle=\"tooltip\" data-placement=\"top\" title=\"Add to history\">bookmark</span><span id=\"history-count\">0</span>\n\n\t\t</div>\n\n\t\t<div class=\"divider-haiku-top\"></div>\n\n\t\t<span id=\"editor-help-icon\" class=\"help-icon\" onclick=\"javascript:app.openHelp();\">\n\t\t\t<a>ℹ Help </a>\n\t\t</span>\n\t\t<span id=\"editor-history-icon\" class=\"help-icon\" onclick=\"javascript:app.openHistory();\">\n\t\t\t<a>☆ History </a>\n\t\t</span>\n\n\t</div>\n</div>"); 17338;// CONCATENATED MODULE: ./node_modules/raw-loader/dist/cjs.js!./src/static-content/editor-help.html 17339/* harmony default export */ const editor_help = ("<div id=\"editor-help\">\n\n\t<div class=\"close-icon\" onclick=\"javascript:app.toggleDiv('editor-help');\">\n\t\t<a>â Close </a>\n\t</div>\n\t\n\t<p>\n\t\t<h1>Help</h1>\n\t</p>\n\n\t<p style=\"color:#bbb\">\n\t\tHit a key, A-Z, to start writing. Click on a row or hit [enter] to select row.\n\t</p>\n\n\t<p>\n\t\tDelete the last character with the <span class=\"material-symbols-outlined\">backspace</span>-key.\n\t</p>\n\n\t<p>\n\t\tClick <span class=\"material-symbols-outlined\">casino</span> to auto-generate a haiku.<br/>\n\t\tWords in the selected row will be used as a template.\n\t</p>\n\t<p>\n\t\tClick <span class=\"material-symbols-outlined\">playlist_add</span> to replace selected row with a generated haiku row<br/> (once for the first haiku-row, twice for the second etc.).\n\t</p>\n\n\t<p style=\"color:#bbb\">\n\t\tClick <span class=\"material-symbols-outlined\">experiment</span> to auto-complete the selected row.\n\t</p>\n\n\t<p style=\"color:#bbb\">\n\t\tClick <span class=\"material-symbols-outlined\">playlist_add</span> to replace selected row with generated <span style=\"color:#f00;\">row</span>.\n\t</p>\n\n\t<p style=\"color:#bbb\">\n\t\tClick on a generated <span style=\"color:#f00;\">word</span> to mark it, click on <span class=\"material-symbols-outlined\">delete</span> to delete it.\n\t</p>\n\n\t<p>\n\t\tClick <span class=\"material-symbols-outlined\">discover_tune</span> to tune diversity for auto-generate and auto-complete. 1 gives the most diverse results.\n\t</p>\n\n\t<div class=\"divider-haiku-top\"></div>\n\n\t<p>\n\t\t<i><sup>*</sup>This is a Beta-version!</i>\n\t</p>\n\t\n</div>\n"); 17340;// CONCATENATED MODULE: ./node_modules/raw-loader/dist/cjs.js!./src/static-content/settings.html 17341/* harmony default export */ const settings = ("<div id=\"settings\" class=\"align-left\"> \n\n\t<div class=\"close-icon\" onclick=\"javascript:window.app.toggleDiv('settings');\"><a>â Close </a></div>\n\t<h1>Settings</h1>\n\n\t<div class=\"menu-item-haiku\" id=\"settings-syll-count\"\n\t onclick=\"javascript:window.app.toggleSyllC
17341ount();\">\n\t\t<div id=\"settings-syll-count-status\" class=\"menu-item-haiku-label\">\n\t\t\tShow Syllable Count\n\t\t</div>\n\t\t<span id=\"checkbox-syll-count-on\" class=\"material-symbols-outlined\" style=\"font-size:36px\">check_box</span>\n\t\t<span id=\"checkbox-syll-count-off\" class=\"material-symbols-outlined\" style=\"font-size:36px\">check_box_outline_blank</span>\n\t</div>\n\n\t<div class=\"menu-item-haiku\" id=\"settings-syll-color\"\n\t onclick=\"javascript:window.app.toggleSyllColor();\">\n\t\t<div id=\"settings-syll-color-status\" class=\"menu-item-haiku-label\">\n\t\t\tShow Syllable Coloring\n\t\t</div>\n\t\t<span id=\"checkbox-syll-color-on\" class=\"material-symbols-outlined\" style=\"font-size:36px\">check_box</span>\n\t\t<span id=\"checkbox-syll-color-off\" class=\"material-symbols-outlined\" style=\"font-size:36px\">check_box_outline_blank</span>\n\t</div>\n\n\t<div class=\"menu-item-haiku\" id=\"settings-syll-strict\"\n\t onclick=\"javascript:window.app.toggleStrictMode();\">\n\t\t<div id=\"settings-syll-strict-status\" class=\"menu-item-haiku-label\">\n\t\t\tStrict Mode, 5-7-5 Syllables\n\t\t</div>\n\t\t<span id=\"checkbox-syll-strict-on\" class=\"material-symbols-outlined\" style=\"font-size:36px\">check_box</span>\n\t\t<span id=\"checkbox-syll-strict-off\" class=\"material-symbols-outlined\" style=\"font-size:36px\">check_box_outline_blank</span>\n\t</div>\n\n\t<div class=\"button-close\" onclick=\"javascript:window.app.toggleDiv('settings');\">Close</div>\n\n</div>"); 17342;// CONCATENATED MODULE: ./node_modules/raw-loader/dist/cjs.js!./src/static-content/keywords.html 17343/* harmony default export */ const keywords = ("<div id=\"keywords\"> \n\t<div class=\"close-icon\" onclick=\"javascript:window.app.toggleDiv('keywords');\"><a>â Close </a></div>\n\t\t<div id=\"keywords-content\"> \n\t\t\t<!-- generated -->\n\t\t</div>\n\t\t<div id=\"keywords-list\"> \n\t\t\t<!-- generated -->\n\t\t</div>\n\n\t\t<div class=\"button-close\" style=\"margin-bottom: 50px;\" onclick=\"javascript:window.app.randomKeywords();\">Random</div>\n\t\t<div class=\"button-close\" onclick=\"javascript:window.app.toggleDiv('keywords');\">Close</div>\n</div>"); 17344;// CONCATENATED MODULE: ./node_modules/raw-loader/dist/cjs.js!./src/static-content/history.html 17345/* harmony default export */ const static_content_history = ("<div id=\"history\">\n\n\t<div id=\"history-close-icon\" class=\"close-icon\" onclick=\"javascript:window.app.toggleDiv('history');\">\n\t\t<a>â Close </a>\n\t</div>\n\n\t<h1>History</h1>\n\n\t<div class=\"divider-haiku-top\"></div>\n\t\n\t<div id=\"history-content\">\n\t\t<!-- content -->\n\t\tLorem ipsum..\n\t</div>\n\n</div>\n"); 17346;// CONCATENATED MODULE: ./src/Page.js 17347function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); } 17348function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } 17349function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } } 17350function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; } 17351function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); } 17352function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); } 17353 17354 17355 17356 17357 17358 17359 17360 17361 17362 17363 17364 17365 17366var Page = /*#__PURE__*/function () { 17367 function Page() { 17368 _classCallCheck(this, Page); 17369 this.id = 0; 17370 this.root = "#root";
17371 } 17372 _createClass(Page, [{ 17373 key: "getID", 17374 value: function getID() { 17375 return "_elm_" + this.id++; 17376 } 17377 }, { 17378 key: "renderHeader", 17379 value: function renderHeader() { 17380 jquery_default()(this.root).append(header); 17381 jquery_default()(".logo_def").attr("src", logo_170x50_sg_ds); 17382 } 17383 }, { 17384 key: "renderContent", 17385 value: function renderContent(app) { 17386 jquery_default()(this.root).append(content_main); 17387 jquery_default()("#build_version").html(app.buildVersion); 17388 } 17389 }, { 17390 key: "renderEditor", 17391 value: function renderEditor() { 17392 jquery_default()(this.root).append(editor); 17393 } 17394 }, { 17395 key: "renderEditorHelp", 17396 value: function renderEditorHelp() { 17397 jquery_default()(this.root).append(editor_help); 17398 } 17399 }, { 17400 key: "renderSettings", 17401 value: function renderSettings() { 17402 jquery_default()(this.root).append(settings); 17403 } 17404 }, { 17405 key: "renderKeywords", 17406 value: function renderKeywords() { 17407 jquery_default()(this.root).append(keywords); 17408 } 17409 }, { 17410 key: "renderHistory", 17411 value: function renderHistory() { 17412 jquery_default()(this.root).append(static_content_history); 17413 } 17414 }, { 17415 key: "render", 17416 value: function render(app) { 17417 jquery_default()(this.root).empty(); 17418 this.renderHeader(); 17419 this.renderContent(app); 17420 this.renderKeywords(); 17421 this.renderEditor(); 17422 this.renderEditorHelp(); 17423 this.renderHistory(); 17424 this.renderSettings(); 17425 //app.isDev() ? $(this.root).append(debug) : null; 17426 return this; 17427 } 17428 }]); 17429 return Page; 17430}(); 17431 17432;// CONCATENATED MODULE: ./src/Tokenizer.js 17433function Tokenizer_toConsumableArray(arr) { return Tokenizer_arrayWithoutHoles(arr) || Tokenizer_iterableToArray(arr) || Tokenizer_unsupportedIterableToArray(arr) || Tokenizer_nonIterableSpread(); } 17434function Tokenizer_nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } 17435function Tokenizer_unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return Tokenizer_arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return Tokenizer_arrayLikeToArray(o, minLen); } 17436function Tokenizer_iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); } 17437function Tokenizer_arrayWithoutHoles(arr) { if (Array.isArray(arr)) return Tokenizer_arrayLikeToArray(arr); } 17438function Tokenizer_arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; } 17439var Tokenizer = { 17440 getVowels: function getVowels() { 17441 return "aeiouyåäö"; 17442 }, 17443 isVowel: function isVowel(letter) { 17444 return this.getVowels().indexOf(letter.toLowerCase()) > -1; 17445 }, 17446 getExpectedVow: function getExpectedVow(rowId) { 17447 var sylCount = window.app.strictPattern.split(","); 17448 return parseInt(sylCount[rowId - 1]); 17449 }, 17450 countUmlauts: function countUmlauts(sentence) { 17451 var _this = this; 17452 var vows = this.getVowels(); 17453 var count = 0; 17454 var letters = Tokenizer_toConsumableArray(sentence.slice(0, -1)); 17455 letters.forEach(function (item, i) { 17456 if (_this.isVowel(item)) { 17457 if (_this.isVowel(sentence[i + 1])) { 17458 count += 1; 17459 } 17460 ; 17461 } 17462 }); 17463 return count; 17464 }, 17465 isLastVowel: function isLastVowel(sentence) { 17466 return this.isVowel(sentence.slice(-1)); 17467 }, 17468 countVowels: function countVowels(sentence) { 17469 var vowels = this.getVowels(); 17470 var sentLower = sentence.toLowerCase(); 17471 var sentLettersLow = Tokenizer_toConsumableArray(sentLower); 17472 var vowelCount = 0; 17473 Tokenizer_toConsumableArray(vowels).forEach(function (vowel) { 17474 vowelCount += sentLettersLow.filter(function (item) { 17475 return item == vowel; 17476 }).length; 17477 }); 17478 return vowelCount; 17479 }, 17480 countSyll: function countSyll(sentence) { 17481 var vowelCount = this.countVowels(sentence); 17482 var umlautCount = this.countUmlauts(sentence); 17483 var syllCount = vowelCount - umlautCount; 17484 var lastCharCorr = this.isLastVowel(sentence.toLowerCase()) ? -1 : 0; 17485 syllCount += lastCharCorr; 17486 return syllCount; 17487 }, 17488 countSyllTokenized: function countSyllTokenized(tokenized) { 17489 return tokenized.filter(function (item) { 17490 return item != " ";
17491 }).length; 17492 }, 17493 getVowelPositions: function getVowelPositions(word) { 17494 var _this2 = this; 17495 var vowPos = []; 17496 Tokenizer_toConsumableArray(word).forEach(function (letter, i) { 17497 if (_this2.isVowel(letter)) { 17498 vowPos.push(i); 17499 } 17500 }); 17501 return vowPos; 17502 }, 17503 compressUmlauts: function compressUmlauts(pos) { 17504 var pos_temp = Tokenizer_toConsumableArray(pos); 17505 pos_temp.push(0); 17506 var pos_compressed = []; 17507 for (var i = 0; i < pos.length; i++) { 17508 if (pos_temp[i] - pos[i + 1] != -1) { 17509 pos_compressed.push(pos[i]); 17510 } 17511 } 17512 return pos_compressed; 17513 }, 17514 getSplitPositions: function getSplitPositions(vowPos) { 17515 var splitPos = []; 17516 for (var i = vowPos.length - 1; i > 0; i--) { 17517 if (vowPos[i] - vowPos[i - 1] == 1) { 17518 splitPos.push(vowPos[i - 1] - 1); 17519 } else { 17520 var pos = parseInt((vowPos[i] + vowPos[i - 1]) / 2); 17521 splitPos.push(pos); 17522 } 17523 } 17524 return splitPos; 17525 }, 17526 syllTokenizer: function syllTokenizer(sentence) { 17527 var _this3 = this; 17528 var tokens = []; 17529 var vowels = this.getVowels(); 17530 var words = sentence.toLowerCase().split(" "); 17531 words.forEach(function (word) { 17532 var syllCount = _this3.countSyll(word); 17533 if (syllCount > 1) { 17534 var vowPos = _this3.getVowelPositions(word); 17535 vowPos = _this3.compressUmlauts(vowPos); 17536 var splitPos = _this3.getSplitPositions(vowPos); 17537 splitPos.reverse(); 17538 splitPos.unshift(0); 17539 splitPos.push(word.length); 17540 for (var i = 0; i < splitPos.length - 1; i++) { 17541 var syll = word.slice(splitPos[i], splitPos[i + 1]); 17542 var prevTokenIndex = tokens.length - 1; 17543 if (syll.length == 1 && !_this3.isVowel(syll)) { 17544 tokens[prevTokenIndex] = tokens[prevTokenIndex] + syll; 17545 } else { 17546 tokens.push(syll); 17547 } 17548 } 17549 } else { 17550 tokens.push(word); 17551 } 17552 tokens.push(" "); 17553 }); 17554 return tokens.slice(0, -1).filter(function (item) { 17555 return item != ""; 17556 }); 17557 } 17558}; 17559 17560;// CONCATENATED MODULE: ./src/Editor.js 17561function Editor_toConsumableArray(arr) { return Editor_arrayWithoutHoles(arr) || Editor_iterableToArray(arr) || Editor_unsupportedIterableToArray(arr) || Editor_nonIterableSpread(); } 17562function Editor_nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } 17563function Editor_unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return Editor_arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return Editor_arrayLikeToArray(o, minLen); } 17564function Editor_iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); } 17565function Editor_arrayWithoutHoles(arr) { if (Array.isArray(arr)) return Editor_arrayLikeToArray(arr); } 17566function Editor_arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; } 17567 17568 17569var Editor = { 17570 editor: ["white swan in green", "a moth flies towards", "she and her reflection"], 17571 rowMaxRowLength: 50, 17572 rowId: 0, 17573 genHaikuRowId: null, 17574 // pointer to generated haiku row 17575 colPos: [0, 0, 0], 17576 targetDiv: "edit-haiku", 17577 history: new Map(), 17578 getKey: function getKey(rows) { 17579 return rows.join("_").split(" ").join("_").replace("'", "_"); 17580 }, 17581 addToHistory: function addToHistory() { 17582 var rows = this.editorGetRows(); 17583 console.log("rows---", rows); 17584 if (rows && rows.length == 3) { 17585 var key = this.getKey(rows); 17586 if (this.history.get(key) == null) { 17587 console.log("key", key); 17588 this.history.set(key, rows); 17589 var histCount = Editor_toConsumableArray(this.history.keys()).length; 17590 jquery_default()("#history-count").html(histCount); 17591 } else { 17592 alert("Already in history!"); 17593 } 17594 } 17595 }, 17596 copyToClipboard: function copyToClipboard(key) { 17597 var haiku = this.history.get(key); 17598 var text = haiku.join("\n"); 17599 var dummy = document.createElement("textarea"); 17600 document.body.appendChild(dummy); 17601 dummy.value = text; 17602 dummy.select(); 17603 document.execCommand("copy"); 17604 document.body.removeChild(dummy); 17605 alert("Copied to clipboard:" + "\n" + text); 17606 }, 17607 deleteFromHist: function deleteFromHist(key) { 17608 if (confirm("Sure you want to delete?")) { 17609 this.history["delete"](key); 17610 app.renderHistory(); 17611 } 17612 ; 17613 }, 17614 editFromHist: function editFromHist(key) { 17615 var haiku = this.history.get(key); 17616 this.editor = haiku.filter(function (item) { 17617 return item; 17618 }); 17619 this.renderEditor(); 17620 app.toggleDiv("history"); 17621 }, 17622 recitate: function recitate(key) { 17623 var haiku = this.history.get(key); 17624 haiku.forEach(function (sentence) { 17625 app.speak(sentence); 17626 }); 17627 }, 17628 getCursor: function getCursor(item, i) { 17629 if (i == this.rowId) { 17630 var colPos = this.editorGetColPos(i); 17631 var cursor = item.slice(colPos, colPos + 1); 17632 return item.slice(0, colPos) + "<span class='editor-cursor'>" + cursor + "</span>" + item.slice(colPos + 1); 17633 } 17634 return item; 17635 }, 17636 getTokenCountHtml: function getTokenCountHtml(sent) { 17637 return "<sup>" + Tokenizer.countSyllTokenized(Tokenizer.syllTokenizer(sent)) + "</sup>"; 17638 }, 17639 getColorCode: function getColorCode(i, j) { 17640 var color = app.colors[i][j]; 17641 return !color || color == undefined ? "#ddd" : color; 17642 }, 17643 addColorSpan: function addColorSpan(syll, i, j) { 17644 return "<span style='color: #" + app.editor.getColorCode(i, j) + "'>" + syll + "</span>"; 17645 }, 17646 addRandomColorSpan: function addRandomColorSpan(elem) { 17647 var i = parseInt(app.colors.length * Math.random()); 17648 var j = parseInt(app.colors[0].length * Math.random()); 17649 return this.addColorSpan(elem, i, j); 17650 }, 17651 renderEditor: function renderEditor() { 17652 var f = function f(i) { 17653 return 'style="cursor:pointer;color:#' + app.editor.getColorCode(app.editor.rowId == i ? 0 : 1, 0) + ';" onclick="javascript:app.editor.selectEditorRowId(' + i + ');"'; 17654 }; 17655 var html = this.editor.map(function (item, i) { 17656 return "<h2 class='editor-row'" + f(i) + "><i>" + app.editor.getCursor(item, i) + "</i>" + app.editor.getTokenCountHtml(item) + "</h2>"; 17657 }); 17658 jquery_default()("#" + app.editor.targetDiv).html(html.join("")); 17659 }, 17660 selectEditorRowId: function selectEditorRowId(rowId) { 17661 this.rowId = rowId; 17662 this.genHaikuRowId = null; 17663 this.renderEditor(); 17664 }, 17665 editorMoveCursor: function editorMoveCursor(step) { 17666 var colPos = this.editorGetColPos(); 17667 var maxRowLen = this.rowMaxRowLength; 17668 if (step > 0) { 17669 this.colPos[this.rowId] = colPos > maxRowLen ? maxRowLen : colPos + step; 17670 } else { 17671 this.colPos[this.rowId] = colPos > 0 ? colPos + step : 0; 17672 } 17673 }, 17674 editorSetColPos: function editorSetColPos(colPos) { 17675 return this.colPos[this.rowId] = colPos; 17676 }, 17677 editorGetColPos: function editorGetColPos() { 17678 return this.colPos[this.rowId]; 17679 }, 17680 editorGetRow: function editorGetRow() { 17681 return this.editor[this.rowId]; 17682 }, 17683 editorGetRowById: function editorGetRowById(rowId) { 17684 return this.editor[rowId]; 17685 }, 17686 editorGetRows: function editorGetRows() { 17687 return this.editor.filter(function (item) { 17688 return item; 17689 }); 17690 }, 17691 editorSetRow: function editorSetRow(row) { 17692 this.editor[this.rowId] = row; 17693 }, 17694 editorSetRowById: function editorSetRowById(row, rowId) { 17695 this.editor[rowId] = row; 17696 }, 17697 editorChangeRow: function editorChangeRow(up) { 17698 if (up) { 17699 this.rowId = this.rowId < 1 ? 2 : this.rowId - 1; 17700 } else { 17701 this.rowId = this.rowId > 1 ? 0 : this.rowId + 1; 17702 } 17703 this.genHaikuRowId = null; 17704 this.renderEditor(); 17705 },
17706 flipRows: function flipRows() { 17707 var rowFrom = this.editorGetRow(); 17708 var rowIdFrom = this.rowId; 17709 this.editorChangeRow(true); 17710 var rowTo = this.editorGetRow(); 17711 this.editorSetRow(rowFrom); 17712 this.editorSetRowById(rowTo, rowIdFrom); 17713 this.renderEditor(); 17714 }, 17715 editorInsert: function editorInsert(_char) { 17716 var row = this.editorGetRow(); 17717 var colPos = this.editorGetColPos(); 17718 if (colPos < this.rowMaxRowLength) { 17719 var rowNew = row.slice(0, colPos) + _char + row.slice(colPos, row.length); 17720 this.editorSetRow(rowNew); 17721 this.renderEditor(); 17722 this.editorMoveCursor(1); 17723 } 17724 }, 17725 editorReplace: function editorReplace(rowNew) { 17726 this.editorSetRow(rowNew); 17727 }, 17728 editorDelete: function editorDelete() { 17729 var row = this.editorGetRow(); 17730 var colPos = this.editorGetColPos(); 17731 var rowLen = row.length; 17732 var rowNew = row.slice(0, colPos) + row.slice(colPos + 1, row.length); 17733 this.editorSetRow(rowNew); 17734 this.editorMoveCursor(0); 17735 this.renderEditor(); 17736 }, 17737 getGenHaikuRowId: function getGenHaikuRowId() { 17738 if (this.genHaikuRowId != null) { 17739 this.genHaikuRowId = this.genHaikuRowId < 2 ? this.genHaikuRowId + 1 : 0; 17740 } else { 17741 this.genHaikuRowId = this.rowId; 17742 } 17743 return this.genHaikuRowId; 17744 }, 17745 addRowFromAutoComplete: function addRowFromAutoComplete() { 17746 app.logger("addRowFromAutoComplete()"); 17747 var sent = app.genItems.filter(function (item, i) { 17748 return i == app.genTypeId; 17749 }).map(function (item) { 17750 return item; 17751 }); 17752 var sentStr = sent.join(" "); 17753 if (sentStr && sentStr.trim().length > 1) { 17754 if (sentStr.indexOf(",") > -1) { 17755 var rows = sentStr.split(","); 17756 var rowId = this.getGenHaikuRowId(); 17757 sentStr = rows[rowId]; 17758 } 17759 ; 17760 var maxLen = this.rowMaxRowLength; 17761 if (sentStr.length <= maxLen) { 17762 this.editorReplace(sentStr); 17763 this.renderEditor(); 17764 } else { 17765 alert("Sentence to long! (max " + maxLen + "characters)"); 17766 } 17767 } else { 17768 alert("Sentence to short!"); 17769 } 17770 }, 17771 getLastSentenceFirst: function getLastSentenceFirst() { 17772 var rowId = this.rowId; 17773 var sentence = this.editor.filter(function (item, i) { 17774 return i != rowId; 17775 }); 17776 sentence.push(this.editor[rowId]); 17777 var sentenceStr = sentence.join("\n"); 17778 app.logger("using sentence=", sentenceStr); 17779 return sentenceStr; 17780 }, 17781 copyFromKeyWordMatchedHaiku: function copyFromKeyWordMatchedHaiku() { 17782 var _this = this; 17783 var haiku = app.getLatestHaiku(); 17784 haiku.forEach(function (row, i) { 17785 _this.editorSetRowById(row, i); 17786 }); 17787 } 17788}; 17789 17790;// CONCATENATED MODULE: ./src/WordFreq.js 17791function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = WordFreq_unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; } 17792function WordFreq_unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return WordFreq_arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return WordFreq_arrayLikeToArray(o, minLen); } 17793function WordFreq_arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; } 17794 17795var WordFreq = { 17796 autoCompleteCharPos: 0, 17797 autoCompleteDelay: 25, 17798 autoCompleteTimeout: null, 17799 targetDiv: "editor-auto-row", 17800 maxWords: 10, 17801 selectedWords: [], 17802 selectedWordsPos: [], 17803 wordfreqIsRunning: false, 17804 pronomina: ['you', 'he', 'she', 'it', 'we', 'they', 'me', 'him', 'her', 'us', 'them', 'you', 'he', 'she', 'it', 'we', 'they', 'what', 'who', 'me', 'him', 'her', 'it', 'us', 'you', 'them', 'whom', 'mine', 'yours', 'his', 'hers', 'ours', 'our', 'theirs', 'this', 'that', 'these', 'those', 'who', 'whom', 'which', 'what', 'whose', 'whoever', 'whatever', 'whichever', 'whomever', 'who', 'whom', 'whose', 'which', 'that', 'what', 'whatever', 'whoever', 'whomever', 'whichever', 'myself', 'yourself', 'himself', 'herself', 'itself', 'ourselves', 'themselves', 'each other', 'one another', 'anything', 'everybody', 'another', 'each', 'few', 'many', 'none', 'some', 'all', 'any', 'anybody', 'anyone', 'everyone', 'everything', 'no one', 'nobody', 'nothing', 'none', 'other', 'others', 'several', 'somebody', 'someone', 'something', 'most', 'enough', 'little', 'more', 'both', 'either', 'neither', 'one', 'much', 'such'], 17805 article: ["a", "an", "the"], 17806 preposition: ['aboard', 'about', 'above', 'across', 'after', 'against', 'along', 'amid', 'among', 'anti', 'around', 'as', 'at', 'before', 'behind', 'below', 'beneath', 'beside', 'besides', 'between', 'beyond', 'but', 'by', 'concerning', 'considering', 'despite', 'down', 'during', 'except', 'excepting', 'excluding', 'following', 'for', 'from', 'in', 'inside', 'into', 'like', 'minus', 'near', 'of', 'off', 'on', 'onto', 'opposite', 'outside', 'over', 'past', 'per', 'plus', 'regarding', 'round', 'save', 'since', 'than', 'through', 'to', 'toward', 'towards', 'under', 'underneath', 'unlike', 'until', 'up', 'upon', 'versus', 'via', 'with', 'within', 'without'], 17807 isArticle: function isArticle(word) { 17808 return this.article.indexOf(word) > -1; 17809 }, 17810 isPreposition: function isPreposition(word) { 17811 return this.preposition.indexOf(word) > -1; 17812 }, 17813 isPronomina: function isPronomina(word) { 17814 return this.pronomina.indexOf(word) > -1; 17815 }, 17816 isExcludedWordClass: function isExcludedWordClass(word) { 17817 return this.isArticle(word) || this.isPreposition(word) || this.isPronomina(word); 17818 }, 17819 washSentence: function washSentence(sentence) { 17820 var chars = ["'s", "'"];
17821 chars.forEach(function (item) { 17822 sentence = sentence.replace(item, ""); 17823 }); 17824 return sentence; 17825 }, 17826 getWords: function getWords(sentence) { 17827 var sentence = app.editor.editorGetRow(); 17828 var sentenceWash = this.washSentence(sentence); 17829 return sentenceWash.trim().split(" ").map(function (item) { 17830 return item.trim(); 17831 }).filter(function (item) { 17832 return item != ""; 17833 }); 17834 }, 17835 showErrorMsg: function showErrorMsg() { 17836 var maxWords = app.wordfreq.maxWords; 17837 var msg = "To many (or none) words in selected sentence (max " + maxWords + ")!"; 17838 alert(msg); 17839 }, 17840 sampleWordFreqs: function sampleWordFreqs(wordFreqs, diversity) { 17841 if (diversity && wordFreqs && wordFreqs.length > 5) { 17842 wordFreqs = wordFreqs.slice(0, parseInt(wordFreqs.length * diversity)); 17843 } 17844 var totalCount = wordFreqs.map(function (item) { 17845 return item[1]; 17846 }).reduce(function (a, b) { 17847 return a + b; 17848 }); 17849 var probs = wordFreqs.map(function (item, i) { 17850 return { 17851 prob: item[1] / totalCount, 17852 count: item[1], 17853 words: item[0] 17854 }; 17855 }); 17856 var accProb = 0; 17857 probs.forEach(function (item) { 17858 accProb += item.prob; 17859 item.prob = accProb; 17860 }); 17861 var rnd = Math.random(); 17862 var sample = probs.filter(function (item) { 17863 return item.prob <= rnd; 17864 }).slice(-1); 17865 return sample != null && sample.length > 0 ? sample[0] : { 17866 "words": [] 17867 }; 17868 }, 17869 sampleSentFreqsTop: function sampleSentFreqsTop(data, words, diversity) { 17870 var top = parseInt(4 + 16 * diversity); 17871 var hitCount = []; 17872 data.forEach(function (item, i) { 17873 var count = 0; 17874 var _iterator = _createForOfIteratorHelper(words), 17875 _step; 17876 try { 17877 for (_iterator.s(); !(_step = _iterator.n()).done;) { 17878 var word = _step.value; 17879 count = item.haiku.indexOf(word) > -1 ? count + 1 : count; 17880 } 17881 } catch (err) { 17882 _iterator.e(err); 17883 } finally { 17884 _iterator.f(); 17885 } 17886 item.count = count; 17887 }); 17888 data.sort(function (a, b) { 17889 return a.count < b.count ? 1 : -1; 17890 }); 17891 var top = data.slice(0, top); 17892 //console.log("data ==", top); 17893 return this.sampleSentFreqs(top); 17894 }, 17895 sampleSentFreqs: function sampleSentFreqs(data) { 17896 return data[parseInt(data.length * Math.random())].haiku; 17897 }, 17898 addStatusMsg: function addStatusMsg(msg) { 17899 msg = msg != null ? msg : "Wait..."; 17900 jquery_default()("#" + this.targetDiv).html(msg); 17901 }, 17902 sentfreq: function sentfreq() { 17903 this.addStatusMsg("Wait..."); 17904 if (app.isDev()) { 17905 // simulate delay in dev 17906 setTimeout(function () { 17907 app.wordfreq.sentfreqExec(); 17908 }, 1000); 17909 } else { 17910 app.wordfreq.sentfreqExec(); 17911 } 17912 }, 17913 sentfreqExec: function sentfreqExec() { 17914 var _this = this; 17915 var words = this.getWords(); 17916 var wordsFiltered = words.filter(function (item) { 17917 return !_this.isExcludedWordClass(item); 17918 }); 17919 var url = app.getSentFreqURL(wordsFiltered); 17920 jquery_default().get(url, function (data, status) { 17921 if (data.data && data.data.length > 0) { 17922 var outputSent = app.wordfreq.sampleSentFreqsTop(data.data, words, app.diversity); 17923 app.genItems[app.genTypeId] = outputSent; 17924 app.wordfreq.renderAutoCompleteItemsDelay(); 17925 } else { 17926 app.wordfreq.showErrorMsg(); 17927 } 17928 }); 17929 }, 17930 wordfreq: function wordfreq() { 17931 this.addStatusMsg("Wait..."); 17932 if (app.isDev()) { 17933 // simulate delay in dev 17934 setTimeout(function () { 17935 app.wordfreq.wordfreqExec(); 17936 }, 1000); 17937 } else { 17938 app.wordfreq.wordfreqExec(); 17939 } 17940 }, 17941 wordfreqExec: function wordfreqExec() { 17942 var words = this.getWords(); 17943 if (words.length <= 10) { 17944 var word1 = words.slice(-1); 17945 var word2 = ""; 17946 var url = app.getWordFreqURL(word1, word2); 17947 jquery_default().get(url, function (data, status) { 17948 if (data.data && data.data.length > 0) { 17949 app.wordfreq.wordfreqIsRunning = true; 17950 var wordFreqs = data.data.map(function (item) { 17951 return [[item.word2, item.word3], item.count]; 17952 }); 17953 var sample = app.wordfreq.sampleWordFreqs(wordFreqs, app.diversity); 17954 var outputWords = sample.words.filter(function (item) { 17955 return item != null && item.length > 0; 17956 }).join(" "); 17957 var currentRow = app.editor.editorGetRow(); 17958 app.genItems[app.genTypeId] = currentRow + " " + outputWords; 17959 app.wordfreq.renderAutoCompleteItemsDelay(); 17960 } else { 17961 app.wordfreq.showErrorMsg(); 17962 } 17963 }); 17964 } else { 17965 app.wordfreq.showErrorMsg(); 17966 } 17967 }, 17968 isWordSelected: function isWordSelected(word, i) { 17969 return this.selectedWords.indexOf(word) > -1 && this.selectedWordsPos.indexOf(i) > -1; 17970 }, 17971 selectWord: function selectWord(word, i) { 17972 if (!this.isWordSelected(word, i)) { 17973 this.selectedWords.push(word); 17974 this.selectedWordsPos.push(i); 17975 } else { 17976 this.selectedWords = this.selectedWords.filter(function (item) { 17977 return item != word; 17978 }); 17979 this.selectedWordsPos = this.selectedWordsPos.filter(function (item) { 17980 return item != i; 17981 }); 17982 } 17983 var sentence = app.wordfreq.getCurrentSentence(); 17984 var syllCountHtml = app.editor.getTokenCountHtml(sentence); 17985 jquery_default()("#" + this.targetDiv).html(this.addSelectWordHtml(sentence) + syllCountHtml); 17986 }, 17987 deleteSelectedWordFromAutoComplete: function deleteSelectedWordFromAutoComplete() { 17988 var sentence = app.wordfreq.getCurrentSentence(); 17989 var word = app.wordfreq.selectedWords; 17990 var wordPos = app.wordfreq.selectedWordsPos; 17991 var wordsUpdated = sentence.split(" ").filter(function (item, i) { 17992 return !app.wordfreq.isWordSelected(item, i); 17993 }); 17994 var sentUpdated = wordsUpdated.join(" "); 17995 app.wordfreq.setCurrentSentence(sentUpdated); 17996 var syllCountHtml = app.editor.getTokenCountHtml(sentUpdated); 17997 app.wordfreq.selectedWords = []; 17998 app.wordfreq.selectedWordsPos = []; 17999 jquery_default()("#" + this.targetDiv).html(this.addSelectWordHtml(sentUpdated) + syllCountHtml); 18000 }, 18001 getCurrentSentence: function getCurrentSentence() { 18002 return app.genItems.filter(function (item, i) { 18003 return i == app.genTypeId; 18004 }).map(function (item) { 18005 return item; 18006 })[0]; 18007 }, 18008 setCurrentSentence: function setCurrentSentence(sentence) { 18009 app.genItems[app.genTypeId] = sentence; 18010 }, 18011 addSelectWordHtml: function addSelectWordHtml(sentence) { 18012 var html = []; 18013 sentence.split(" ").forEach(function (item, i) { 18014 var word = item; 18015 var style = ""; 18016 if (app.wordfreq.isWordSelected(word, i)) { 18017 style = 'style="background-color: #777;"'; 18018 } 18019 ; 18020 html.push('<span ' + style + ' onclick="javascript:app.wordfreq.selectWord(\'' + word + '\',' + i + ');">' + word + "</span>"); 18021 }); 18022 return html.join(" "); 18023 }, 18024 renderAutoCompleteItemsDelay: function renderAutoCompleteItemsDelay() { 18025 if (app.genItems && app.genItems.length > 0) { 18026 var sentence = app.wordfreq.getCurrentSentence(); 18027 this.autoCompleteCharPos = this.autoCompleteCharPos + 1; 18028 var sentenceSlice = sentence.slice(0, this.autoCompleteCharPos); 18029 var syllCountHtml = app.editor.getTokenCountHtml(sentenceSlice); 18030 jquery_default()("#" + this.targetDiv).html(this.addSelectWordHtml(sentenceSlice) + syllCountHtml); 18031 if (this.autoCompleteCharPos < sentence.length) { 18032 var delayFuzzy = this.autoCompleteDelay + 2 * parseInt(Math.random() * this.autoCompleteDelay); 18033 this.autoCompleteTimeout = setTimeout(function () { 18034 app.wordfreq.renderAutoCompleteItemsDelay(); 18035 }, delayFuzzy); 18036 } else { 18037 clearTimeout(this.autoCompleteTimeout); 18038 this.autoCompleteCharPos = 0; 18039 app.wordfreq.wordfreqIsRunning = false;
18040 } 18041 } else { 18042 app.wordfreq.wordfreqIsRunning = false; 18043 } 18044 } 18045}; 18046 18047;// CONCATENATED MODULE: ./src/Keywords.js 18048var Keywords = { 18049 keywords: [{ 18050 "letter": "a", 18051 "words": ["autumn", "after", "another", "afternoon", "again", "about", "against", "away", "across", "above", "around", "august", "almost", "ancient", "apple", "along", "april", "alone", "among", "ants", "ashes", "asks", "abandoned", "asphalt", "argument"] 18052 }, { 18053 "letter": "b", 18054 "words": ["blue", "between", "before", "back", "blossoms", "black", "breeze", "butterfly", "beach", "behind", "breath", "book", "buddha", "bird", "bloom", "birds", "bright", "beneath", "birthday", "bowl", "break", "breaks", "bottle", "beer", "broken"] 18055 }, { 18056 "letter": "c", 18057 "words": ["cold", "clouds", "coffee", "cherry", "christmas", "cool", "crescent", "cloud", "call", "chill", "candle", "cricket", "cemetery", "clear", "cycle", "city", "colors", "cloudy", "cream", "child", "comes", "cars", "clock", "come", "chair"] 18058 }, { 18059 "letter": "d", 18060 "words": ["dawn", "dark", "dusk", "down", "deep", "dead", "dance", "door", "distant", "dreams", "darkness", "days", "dust", "dream", "death", "december", "drizzle", "desert", "dancing", "daffodils", "drops", "downpour", "dragonfly", "drips", "deepens"] 18061 }, { 18062 "letter": "e", 18063 "words": ["evening", "empty", "eyes", "embrace", "echoes", "each", "early", "endless", "earth", "even", "every", "equinox", "eternal", "edge", "essence", "echo", "enough", "easter", "east", "ends", "echoing", "eclipse", "ephemeral", "egret", "eating"] 18064 }, { 18065 "letter": "f", 18066 "words": ["from", "first", "full", "fall", "frost", "face", "field", "fresh", "flowers", "flight", "falling", "falls", "fireflies", "fallen", "fire", "forest", "friend", "fish", "fireworks", "friday", "finally", "flies", "fence", "flower", "fleeting"] 18067 }, { 18068 "letter": "g", 18069 "words": ["garden", "grass", "green", "gray", "glass", "grey", "graffiti", "gentle", "geese", "grave", "glow", "garbage", "goes", "girl", "golden", "gate", "glasses", "good", "gold", "ground", "gone", "grasp", "going", "grand", "gather"] 18070 }, { 18071 "letter": "h", 18072 "words": ["house", "home", "haiku", "heat", "high", "half", "hair", "harvest", "hand", "haze", "have", "hands", "heavy", "hour", "homeless", "harmony", "heart", "highway", "head", "hues", "hail", "horizon", "heron", "horse", "hidden"] 18073 }, { 18074 "letter": "i", 18075 "words": ["into", "it", "inside", "island", "iris", "infinity", "insect", "irises", "iron", "iraq", "insects", "icicle", "icicles", "incense", "instead", "itself", "insistent", "insomnia", "ides", "ive", "invisible", "irene", "illness", "inch", "ironed"] 18076 }, { 18077 "letter": "j", 18078 "words": ["just", "july", "jasmine", "journey", "june", "january", "japanese", "japan", "jazz", "joins", "jogger", "juice", "jeans", "junk", "jays", "jacket", "jumping", "jesus", "jellyfish", "jay", "join", "jewel", "juillet", "jizo", "jogging"] 18079 }, { 18080 "letter": "k", 18081 "words": ["kitchen", "kiss", "kids", "know", "kite", "keep", "kettle", "keeps", "kisses", "kept", "kissing", "knowing", "keys", "king", "knocks", "kissed", "kimono", "keyboard", "kingdom", "knot", "kitten", "kingfisher", "kona", "knee", "knickknacks"] 18082 }, { 18083 "letter": "l", 18084 "words": ["leaves", "light", "last", "long", "late", "life", "lights", "left", "lost", "line", "leaf", "little", "love", "like", "looks", "lake", "look", "looking", "lingers", "legs", "lilacs", "lightning", "longer", "lips", "lilies"] 18085 }, { 18086 "letter": "m", 18087 "words": ["moon", "morning", "mist", "more", "many", "mother", "moonlight", "midnight", "market", "maple", "march", "mirror", "memories", "moth", "mountain", "memorial", "memory", "moonless", "mind", "mountains", "missing", "music", "much", "mosquito", "machine"] 18088 }, { 18089 "letter": "n", 18090 "words": ["night", "nature", "neighbor", "november", "news", "nothing", "next", "noise", "name", "near", "north", "noon", "never", "nose", "nails", "neighbour", "nice", "nest", "neck", "neighbors", "nail", "nights", "nobody", "notes", "names"] 18091 }, { 18092 "letter": "o", 18093 "words": ["over", "only", "open", "october", "orange", "outside", "other", "overcast", "ocean", "office", "opens", "opening", "orion", "once", "onto", "obituary", "order", "opposite", "overgrown", "oven", "orchard", "older", "oranges", "orchid", "olive"] 18094 }, { 18095 "letter": "p", 18096 "words": ["petals", "path", "pond", "passes", "pink", "park", "phone", "pine", "pale", "passing", "past", "paper", "pass", "puddle", "promise", "page", "plastic", "pumpkin", "plane", "purple", "perfume", "pines", "prayer", "party", "palm"] 18097 }, { 18098 "letter": "q", 18099 "words": ["quiet", "quick", "quarrel", "quest", "quietly", "quarter", "quake", "quarters", "queens", "quickens", "question", "quitting", "quite", "queuejumper", "quinie", "queensborough", "quickly", "quit", "quarrels", "quilt", "quince", "quartered", "quietness", "quadro", "quilts"] 18100 }, { 18101 "letter": "r", 18102 "words": ["rain", "river", "road", "room", "rose", "rice", "rainy", "roses", "rises", "rising", "remember", "raindrops", "roof", "rush", "rise", "reflection", "robin", "reading", "right", "read", "rainbow", "rest", "return", "reach", "round"] 18103 }, { 18104 "letter": "s", 18105 "words": ["summer", "spring", "snow", "still", "smell", "silence", "scent", "sunset", "storm", "sound", "stars", "shadow", "street", "shadows", "silent", "stone", "sunday", "song", "sunrise", "small", "same", "slowly", "soft", "slow", "solstice"] 18106 }, { 18107 "letter": "t", 18108 "words": ["through", "this", "time", "tree", "train", "that", "twilight", "their", "traffic", "trees", "thunder", "than", "tide", "thoughts", "three", "temple", "table", "touch", "turns", "takes", "turn", "truck", "they", "tales", "trail"] 18109 }, { 18110 "letter": "u", 18111 "words": ["under", "umbrella", "unknown", "umbrellas", "used", "universe", "unfinished", "upon", "urban", "ultrasound", "unanswered", "unseen", "unity", "unfolds", "underfoot", "uniform", "unnamed", "unsaid", "upside", "unfold", "usual", "upstairs", "until", "unborn", "undone"] 18112 }, { 18113 "letter": "v", 18114 "words": ["valentine", "voice", "voices", "void", "view", "very", "visit", "veiled", "veil", "village", "vase", "vibrant", "valley", "vast", "ver
18114nal", "viewing", "violets", "visions", "veterans", "veteran", "voar", "veins", "venus", "villa", "vigil"] 18115 }, { 18116 "letter": "w", 18117 "words": ["winter", "with", "wind", "white", "window", "whispers", "water", "wall", "watch", "woman", "waiting", "without", "walk", "where", "warmth", "wild", "words", "warm", "what", "windows", "work", "world", "watching", "wine", "waves"] 18118 }, { 18119 "letter": "x", 18120 "words": ["xray", "xmas"] 18121 }, { 18122 "letter": "y", 18123 "words": ["year", "your", "yellow", "years", "yesterday", "yard", "york", "yoga", "yogi", "yellowed", "yield", "yogurt", "yule", "yells", "yore", "yields", "yesteryears", "yearning", "yuri", "yori", "yawn", "yearold", "youthie"] 18124 }, { 18125 "letter": "z", 18126 "words": ["zephyr", "zero", "zigzagging", "zidane", "zigzags", "zazen", "zucchini", "zigzag", "zealously", "zone", "zombie"] 18127 }], 18128 get: function get() { 18129 return this.keywords; 18130 } 18131}; 18132 18133;// CONCATENATED MODULE: ./src/app.js 18134function app_toConsumableArray(arr) { return app_arrayWithoutHoles(arr) || app_iterableToArray(arr) || app_unsupportedIterableToArray(arr) || app_nonIterableSpread(); } 18135function app_nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } 18136function app_unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return app_arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return app_arrayLikeToArray(o, minLen); } 18137function app_iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); } 18138function app_arrayWithoutHoles(arr) { if (Array.isArray(arr)) return app_arrayLikeToArray(arr); } 18139function app_arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; } 18140 18141 18142 18143 18144 18145 18146 18147 18148 18149 18150 18151window.app = { 18152 buildVersion: "0.6.0", 18153 page: null, 18154 editor: null, 18155 tokenizer: null, 18156 wordfreq: null, 18157 keywords: null, 18158 winutil: null, 18159 showSyllableCount: true, 18160 showSyllableColor: true, 18161 strictMode: false, 18162 letters: "abcdefghijklmnopqrstuvwxyz", 18163 haikuId: 0, 18164 selectedKeywords: ["cool", "mountain", "stars"], 18165 selectedLetter: "a", 18166 maxKeywords: 3, 18167 strictPattern: "5,7,5", 18168 isEditorOpen: false, 18169 diversity: 1.0, 18170 smallScreenWidthPix: 768, 18171 errorMsg: ["No Haiku was created", "Keywords to odd or to few", "Alter or add one"], 18172 haikus: [["with a cool breeze", "mountains veiled in mist", "against the stars"]], 18173 colors: [["f08700", "f49f0a", "efca08", "#0a6a6", "bbdef0", "545863", "00e8fc", "f96e46", "f9c846", "ffe3e3"], ["3772ff", "f038ff", "ef709d", "e2ef70", "70e4ef", "587291", "2f97c1", "1ccad8", "15e6cd", "0cf574"], ["f5ffc6", "b4e1ff", "ab87ff", "fface4", "c1ff9b", "bcc4db", "c0a9b0", "7880b5", "6987c9", "6bbaec"]], 18174 genItems: [null, "", null, null], 18175 genTypes: ["ml", "prob", "real"], 18176 genTypeId: 1, 18177 haikusDev: [["with a cool breeze", "mountains veiled in mist", "against the stars"], ["freedom's endless call", "creeping along the stone wall", "A snail crawls up the front wheel"], ["a field of dandelion fluffs", "in the harmattan", "night watch"], ["Sudden rainstorm", "a moth flies towards", "she and her reflection"], ["My coffee grows cold", "eternal reprieve", "my shadow"], ["The blank page", "suddenly the silence", "day after christmas"], ["Harvest days", "sunny afternoon", "seagulls cry to the vast blue"]], 18178 init: function init() { 18179 this.page = new Page().render(this); 18180 this.editor = Editor; 18181 this.tokenizer = Tokenizer; 18182 this.wordfreq = WordFreq; 18183 this.keywords = Keywords; 18184 this.winutil = WinUtil; 18185 this.hide("settings"); 18186 this.hide("keywords"); 18187 this.hide("editor"); 18188 this.hide("editor-help"); 18189 this.hide("history"); 18190 this.show("checkbox-syll-count-on"); 18191 this.hide("checkbox-syll-count-off"); 18192 this.show("checkbox-syll-color-on"); 18193 this.hide("checkbox-syll-color-off"); 18194 this.hide("checkbox-syll-strict-on"); 18195 this.show("checkbox-syll-strict-off"); 18196 this.hide("checkbox-gen-type-on"); 18197 this.show("checkbox-gen-type-off"); 18198 this.renderSelectedKeywords(); 18199 this.renderKeywordList(this.selectedLetter); 18200 this.renderInitialHaiku(); 18201 this.setDiversity(this.diversity); 18202 setTimeout(function () { 18203 window.app.renderRandomHaiku(); 18204 }, 1000); 18205 }, 18206 isDev: function isDev() { 18207 return window.location.host === 'localhost:8000'; 18208 }, 18209 logger: function logger() { 18210 if (this.isDev()) { 18211 var _console;
18212 (_console = console).log.apply(_console, arguments); 18213 } 18214 ; 18215 }, 18216 isSmallScreen: function isSmallScreen() { 18217 var width = this.winutil.getSizes().pageWidth; 18218 return width <= this.smallScreenWidthPix; 18219 }, 18220 getKeywords: function getKeywords(letter) { 18221 var words = window.app.keywords.get().filter(function (item) { 18222 return item.letter == letter; 18223 }); 18224 if (words.length > 0) { 18225 return words[0].words; 18226 } 18227 return "NA"; 18228 }, 18229 hide: function hide(div) { 18230 var elem = "#" + div; 18231 jquery_default()(elem).hide(); 18232 }, 18233 show: function show(div) { 18234 var elem = "#" + div; 18235 jquery_default()(elem).show(); 18236 }, 18237 isVisible: function isVisible(div) { 18238 return jquery_default()("#" + div).is(':visible'); 18239 }, 18240 toggleDiv: function toggleDiv(div) { 18241 if (!this.isVisible(div)) { 18242 this.show(div); 18243 } else { 18244 this.hide(div); 18245 } 18246 this.toggleScroll(div); 18247 }, 18248 toggleCheckBox: function toggleCheckBox(state, id) { 18249 if (state) { 18250 this.show("checkbox-" + id + "-on"); 18251 this.hide("checkbox-" + id + "-off"); 18252 } else { 18253 this.show("checkbox-" + id + "-off"); 18254 this.hide("checkbox-" + id + "-on"); 18255 } 18256 }, 18257 toggleStrictMode: function toggleStrictMode() { 18258 this.strictMode = this.strictMode ? false : true; 18259 this.toggleCheckBox(this.strictMode, "syll-strict"); 18260 }, 18261 toggleSyllCount: function toggleSyllCount() { 18262 this.showSyllableCount = this.showSyllableCount ? false : true; 18263 this.toggleCheckBox(this.showSyllableCount, "syll-count"); 18264 }, 18265 toggleSyllColor: function toggleSyllColor() { 18266 this.showSyllableColor = this.showSyllableColor ? false : true; 18267 this.toggleCheckBox(this.showSyllableColor, "syll-color"); 18268 }, 18269 addSyllableCount: function addSyllableCount(sent) { 18270 var syllCount = this.tokenizer.countSyllTokenized(this.tokenizer.syllTokenizer(sent)); 18271 return this.showSyllableCount ? "<sup>" + syllCount + "</sup>" : ""; 18272 }, 18273 addSyllColor: function addSyllColor(sent, i) { 18274 var _this = this; 18275 var sylls = this.tokenizer.syllTokenizer(sent); 18276 var j = 0; 18277 var syllsColored = []; 18278 sylls.forEach(function (syll, j) { 18279 if (syll != " ") { 18280 syllsColored.push(_this.editor.addColorSpan(syll.trim(), i, j)); 18281 } else { 18282 syllsColored.push(" "); 18283 } 18284 }); 18285 return this.showSyllableColor ? syllsColored.join("") : sent; 18286 }, 18287 formatHaiku: function formatHaiku(haiku) { 18288 var _this2 = this; 18289 return haiku.map(function (item, i) { 18290 return "<h2><i>" + _this2.addSyllColor(item, i) + _this2.addSyllableCount(item) + "</h2></i>"; 18291 }).join(""); 18292 }, 18293 openSettings: function openSettings() { 18294 this.scrollToPos(0); 18295 this.hide("keywords"); 18296 this.toggleDiv("settings"); 18297 }, 18298 openHistory: function openHistory() { 18299 this.scrollToPos(0); 18300 this.renderHistory(); 18301 this.toggleDiv("history"); 18302 }, 18303 renderHistory: function renderHistory() { 18304 var _this3 = this; 18305 var keys = app_toConsumableArray(this.editor.history.keys()); 18306 var html = []; 18307 if (keys && keys.length > 0) { 18308 keys.sort(function (a, b) { 18309 return a > b ? 1 : -1; 18310 }); 18311 keys.forEach(function (key, i) { 18312 console.log("key", key); 18313 var haiku = _this3.editor.history.get(key); 18314 html.push("<li>â</li>"); 18315 html.push("<li>" + haiku.join("<br/>") + "</li><br/>"); 18316 html.push('<span style="cursor: pointer;" onclick="javascript: app.editor.editFromHist(\'' + key + '\')" class="material-symbols-outlined">edit</span>'); 18317 html.push(' <span style="cursor: pointer;" onclick="javascript: app.editor.copyToClipboard(\'' + key + '\')" class="material-symbols-outlined">content_copy</span>'); 18318 //html.push(' <span style="cursor: pointer;" onclick="javascript: app.editor.recitate(\'' + key + '\')" class="material-symbols-outlined">record_voice_over</span>'); 18319 html.push(' <span style="cursor: pointer;" onclick="javascript: app.editor.deleteFromHist(\'' + key + '\')" class="material-symbols-outlined">delete</span>'); 18320 html.push('<div class="divider-haiku-top"></div>'); 18321 }); 18322 } else { 18323 html.push("<li>History is empty.</li>"); 18324 } 18325 ; 18326 jquery_default()("#history-content").html("<ul>" + html.join("") + "</ul>"); 18327 }, 18328 openHelp: function openHelp() { 18329 this.scrollToPos(0); 18330 this.toggleDiv("editor-help"); 18331 }, 18332 removeKeyword: function removeKeyword(keyword) { 18333 this.selectedKeywords = this.selectedKeywords.filter(function (item) { 18334 return item != keyword; 18335 }); 18336 this.renderSelectedKeywords(); 18337 this.renderKeywordList(this.selectedLetter); 18338 },
18339 renderSelectedKeywords: function renderSelectedKeywords() { 18340 var html = []; 18341 this.selectedKeywords.map(function (item) { 18342 var f = "javascript:window.app.removeKeyword('" + item + "')"; 18343 html.push('<span onclick="' + f + '" class="selected-keywords">' + item.trim() + "</span>"); 18344 }); 18345 jquery_default()("#keywords-selected").html(html.join("/ ")); 18346 }, 18347 setSelectedLetter: function setSelectedLetter(keyword) { 18348 this.selectedLetter = keyword.slice(0, 1).toLowerCase(); 18349 }, 18350 speak: function speak(words) { 18351 var voices = speechSynthesis.getVoices(); 18352 var utterance = new SpeechSynthesisUtterance(words); 18353 utterance.voice = voices[0]; 18354 speechSynthesis.speak(utterance); 18355 }, 18356 addKeyword: function addKeyword(keyword) { 18357 if (this.selectedKeywords.indexOf(keyword) < 0) { 18358 if (this.selectedKeywords.length < this.maxKeywords) { 18359 this.selectedKeywords.push(keyword); 18360 } else { 18361 this.selectedKeywords.shift(); 18362 this.selectedKeywords.push(keyword); 18363 } 18364 this.setSelectedLetter(keyword); 18365 this.renderSelectedKeywords(); 18366 this.renderLetterList(); 18367 this.renderKeywordList(this.selectedLetter); 18368 } 18369 }, 18370 renderKeywordList: function renderKeywordList(letter) { 18371 var keywords = window.app.getKeywords(letter); 18372 var html = []; 18373 keywords.forEach(function (item) { 18374 var f = "javascript:window.app.addKeyword('" + item + "')"; 18375 var keywordHtml = window.app.editor.addRandomColorSpan(item.trim()); 18376 var selectedClass = window.app.selectedKeywords.indexOf(item) > -1 ? "selected-keyword" : ""; 18377 html.push('<span style="float:left;" onclick="' + f + '" class="keywords-menu-item ' + selectedClass + '">' + keywordHtml + "</span>"); 18378 }); 18379 jquery_default()("#keywords-list").html(html.join("")); 18380 }, 18381 renderLetterList: function renderLetterList() { 18382 var html = []; 18383 html.push("<h3>Keywords</h3>"); 18384 var selectedKeywordsHtml = this.selectedKeywords.map(function (item) { 18385 return '<span style="text-transform: uppercase;"> ' + window.app.editor.addRandomColorSpan(item) + "</span>"; 18386 }); 18387 html.push("<h2>" + selectedKeywordsHtml + "</h2>"); 18388 this.letters.split("").forEach(function (item, i) { 18389 var f = "javascript:window.app.renderKeywordList('" + item + "')"; 18390 var style = 'style="float: left;"'; 18391 html.push('<span ' + style + ' onclick="' + f + '" class="keywords-menu-item">' + item.toUpperCase() + "</span>"); 18392 }); 18393 html.push('<span style="float: left;" class="keywords-menu-item">/</span>'); 18394 jquery_default()("#keywords-content").html(html.join("")); 18395 }, 18396 openKeywords: function openKeywords() { 18397 this.scrollToPos(0); 18398 this.hide("settings"); 18399 this.renderLetterList(); 18400 this.toggleDiv("keywords"); 18401 }, 18402 randomChoice: function randomChoice(values) { 18403 return values[parseInt(values.length * Math.random())]; 18404 }, 18405 randomKeywords: function randomKeywords() { 18406 var _this4 = this; 18407 [1, 2, 3].forEach(function (item) { 18408 var keywords = _this4.getKeywords(_this4.randomChoice(_this4.letters)); 18409 _this4.addKeyword(_this4.randomChoice(keywords)); 18410 }); 18411 }, 18412 isFileServing: function isFileServing() { 18413 return window.location.host === ""; 18414 }, 18415 getBaseURL: function getBaseURL() { 18416 var urlProd = "https://knutas.com/haiku_app/build/rest-api/"; 18417 var urlDev = "http://localhost:8000/rest-api/"; 18418 return window.app.isDev() ? urlDev : urlProd; 18419 }, 18420 getRandomChoice: function getRandomChoice(values) { 18421 return values[parseInt(values * Math.random())]; 18422 }, 18423 getSentFreqURL: function getSentFreqURL(words) { 18424 var urlProd = this.getBaseURL() + "get/sentfreq?words=" + words.join(","); 18425 var urlDev = this.getBaseURL() + "get/sentfreq/sentfreq.json"; 18426 return window.app.isDev() ? urlDev : urlProd; 18427 }, 18428 getWordFreqURL: function getWordFreqURL(word1, word2) { 18429 var urlProd = this.getBaseURL() + "get/wordfreq?word1=" + word1 + "&word2=" + word2; 18430 var urlDev = this.getBaseURL() + "get/wordfreq/wordfreq.json"; 18431 return window.app.isDev() ? urlDev : urlProd; 18432 }, 18433 getHaikuURL: function getHaikuURL() { 18434 var keywords = window.app.selectedKeywords.join(","); 18435 var strictMode = window.app.strictMode ? "&format=" + window.app.strictPattern + "&strict=0" : ""; 18436 var urlProd = this.getBaseURL() + "get/haiku?keywords=" + keywords + strictMode; 18437 var urlDev = this.getBaseURL() + "get/haiku/haiku.json"; 18438 return window.app.isDev() ? urlDev : urlProd; 18439 }, 18440 openEditor: function openEditor() { 18441 this.scrollToPos(0); 18442 this.editor.copyFromKeyWordMatchedHaiku(); 18443 this.editor.renderEditor(); 18444 this.toggleDiv('editor'); 18445 this.isEditorOpen = true; 18446 }, 18447 closeEditor: function closeEditor() { 18448 this.isEditorOpen = false;
18449 this.toggleDiv("editor"); 18450 }, 18451 toggleScroll: function toggleScroll(div) { 18452 if (div == 'editor' || div == 'settings') { 18453 if (jquery_default()("body.noscroll").length > 0) { 18454 jquery_default()("body").removeClass("noscroll"); 18455 } else { 18456 jquery_default()("body").addClass("noscroll"); 18457 } 18458 } 18459 }, 18460 scrollToPos: function scrollToPos() { 18461 var pos = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null; 18462 if (pos == null) { 18463 pos = parseInt(window.innerHeight / 3); // window.innerHeight; 18464 } 18465 18466 jquery_default()('html, body').animate({ 18467 scrollTop: pos 18468 }, 'slow'); 18469 }, 18470 isAlpha: function isAlpha(ch) { 18471 return /^[A-Za-z]{1,1}$/.test(ch); 18472 }, 18473 renderInitialHaiku: function renderInitialHaiku() { 18474 jquery_default()("#haiku").html(this.formatHaiku(this.haikus[this.haikuId])); 18475 }, 18476 getLatestHaiku: function getLatestHaiku() { 18477 //console.log("haikus==", this.haikus); 18478 return this.haikus[this.haikuId]; 18479 }, 18480 renderHaiku: function renderHaiku() { 18481 this.logger("window.location.host", window.location.host); 18482 this.logger("this.isDev()", this.isDev()); 18483 this.logger("this.isFileServing()", this.isFileServing()); 18484 if (this.isDev() || this.isFileServing()) { 18485 var id = parseInt(this.haikusDev.length * Math.random()); 18486 var haiku = this.haikusDev[id]; 18487 this.haikus = [haiku]; 18488 this.haikuId = 0; 18489 jquery_default()("#haiku").html(this.formatHaiku(haiku)); 18490 } else { 18491 var url = window.app.getHaikuURL(); 18492 jquery_default().get(url, function (data, status) { 18493 var haikus = []; 18494 var tempRows = []; 18495 if (data.data && data.data.length > 0) { 18496 data.data.forEach(function (item, i) { 18497 tempRows.push(item.sent); 18498 if (i > 1 && (i + 1) % 3 == 0) { 18499 haikus.push(tempRows); 18500 tempRows = []; 18501 } 18502 }); 18503 window.app.haikus = haikus; 18504 window.app.haikuId = parseInt(Math.random() * window.app.haikus.length); 18505 var haiku = window.app.getLatestHaiku(); 18506 if (window.app.haikus.length > 0 && window.app.selectedKeywords.length == 3) { 18507 jquery_default()("#haiku").html(window.app.formatHaiku(haiku)); 18508 } else { 18509 jquery_default()("#haiku").html(window.app.formatHaiku(window.app.errorMsg)); 18510 } 18511 } else { 18512 jquery_default()("#haiku").html(window.app.formatHaiku(window.app.errorMsg)); 18513 } 18514 }); 18515 } 18516 }, 18517 setDiversity: function setDiversity(value) { 18518 if (value) { 18519 this.diversity = value; 18520 } else { 18521 this.diversity = this.diversity <= 0.9 ? this.diversity + 0.1 : 0.1; 18522 } 18523 var captionDiversity = this.isSmallScreen() ? "D=" : "Diversity="; 18524 var captionMethod = ""; // this.genTypeId == 0 ? "(ML)" : "(PP)"; 18525 jquery_default()("#auto-complete-diversity").html(captionDiversity + Math.round(this.diversity * 10) / 10 + " " + captionMethod); 18526 }, 18527 autoSuggest: function autoSuggest() { 18528 this.wordfreq.sentfreq(); 18529 }, 18530 autoComplete: function autoComplete() { 18531 switch (this.genTypeId) { 18532 case 0: 18533 // NA 18534 break; 18535 case 1: 18536 this.wordfreq.wordfreq(); 18537 break; 18538 default: 18539 // code block 18540 } 18541 }, 18542 18543 renderRandomHaiku: function renderRandomHaiku() { 18544 this.randomKeywords(); 18545 this.renderHaiku(); 18546 } 18547}; 18548window.onload = function (e) { 18549 window.app.init(); 18550 if (window.app.isDev()) { 18551 jquery_default()(".debug").html(WinUtil.getSizes().windowWidth + "," + WinUtil.getSizes().windowHeight); 18552 } 18553}; 18554 18555// for debug 18556window.onresize = function (e) { 18557 if (window.app.isDev()) { 18558 jquery_default()(".debug").html(WinUtil.getSizes().windowWidth + "," + WinUtil.getSizes().windowHeight); 18559 } 18560}; 18561 18562// handle key press events 18563document.body.onkeyup = function (e) { 18564 if (window.app.isEditorOpen) { 18565 var _char = String.fromCharCode(e.keyCode).toLowerCase(); 18566 if (window.app.isAlpha(_char) || e.keyCode == 222) { 18567 var _char = e.keyCode == 222 ? "'" : _char; 18568 window.app.editor.editorInsert(_char); 18569 } else if (e.keyCode == 32) { 18570 window.app.editor.editorInsert(" "); 18571 window.app.logger("space"); 18572 } else if (e.keyCode == 13) { 18573 window.app.logger("return"); 18574 window.app.editor.editorChangeRow(); 18575 } else if (e.keyCode == 8) { 18576 window.app.logger("delete"); 18577 window.app.editor.editorDelete(); 18578 } else if (e.keyCode == 39) { 18579 window.app.logger("right arrow..."); 18580 window.app.editor.editorMoveCursor(1); 18581 window.app.editor.renderEditor(); 18582 } else if (e.keyCode == 37) { 18583 window.app.logger("left arrow..."); 18584 window.app.editor.editorMoveCursor(-1); 18585 window.app.editor.renderEditor(); 18586 } 18587 } 18588}; 18589 18590// disable scroll by "space" key 18591window.onkeydown = function (e) { 18592 return !(e.key == ' ' && e.target == document.body); 18593}; 18594})(); 18595 18596/******/ })() 18597;
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.