vendor: 78 bytes, lines 1-3
1/******/ (() => { // webpackBootstrap 2/******/ var __webpack_modules__ = ({ 3
vendor: 137,873 bytes, lines 4-4368
4/***/ "./node_modules/bootstrap/dist/js/bootstrap.js": 5/*!*****************************************************!*\ 6 !*** ./node_modules/bootstrap/dist/js/bootstrap.js ***! 7 \*****************************************************/ 8/***/ (function(__unused_webpack_module, exports, __webpack_require__) { 9 10/*! 11 * Bootstrap v4.6.2 (https://getbootstrap.com/) 12 * Copyright 2011-2022 The Bootstrap Authors (https://github.com/twbs/bootstrap/graphs/contributors) 13 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 14 */ 15(function (global, factory) { 16 true ? factory(exports, __webpack_require__(/*! jquery */ "./node_modules/jquery/dist/jquery.js"), __webpack_require__(/*! popper.js */ "./node_modules/popper.js/dist/esm/popper.js")) : 17 0; 18})(this, (function (exports, $, Popper) { 'use strict'; 19 20 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; } 21 22 var $__default = /*#__PURE__*/_interopDefaultLegacy($); 23 var Popper__default = /*#__PURE__*/_interopDefaultLegacy(Popper); 24 25 function _defineProperties(target, props) { 26 for (var i = 0; i < props.length; i++) { 27 var descriptor = props[i]; 28 descriptor.enumerable = descriptor.enumerable || false; 29 descriptor.configurable = true; 30 if ("value" in descriptor) descriptor.writable = true; 31 Object.defineProperty(target, descriptor.key, descriptor); 32 } 33 } 34 35 function _createClass(Constructor, protoProps, staticProps) { 36 if (protoProps) _defineProperties(Constructor.prototype, protoProps); 37 if (staticProps) _defineProperties(Constructor, staticProps); 38 Object.defineProperty(Constructor, "prototype", { 39 writable: false 40 }); 41 return Constructor; 42 } 43 44 function _extends() { 45 _extends = Object.assign ? Object.assign.bind() : function (target) { 46 for (var i = 1; i < arguments.length; i++) { 47 var source = arguments[i]; 48 49 for (var key in source) { 50 if (Object.prototype.hasOwnProperty.call(source, key)) { 51 target[key] = source[key]; 52 } 53 } 54 } 55 56 return target; 57 }; 58 return _extends.apply(this, arguments); 59 } 60 61 function _inheritsLoose(subClass, superClass) { 62 subClass.prototype = Object.create(superClass.prototype); 63 subClass.prototype.constructor = subClass; 64 65 _setPrototypeOf(subClass, superClass); 66 } 67 68 function _setPrototypeOf(o, p) { 69 _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { 70 o.__proto__ = p; 71 return o; 72 }; 73 return _setPrototypeOf(o, p); 74 } 75 76 /** 77 * -------------------------------------------------------------------------- 78 * Bootstrap (v4.6.2): util.js 79 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 80 * -------------------------------------------------------------------------- 81 */ 82 /** 83 * Private TransitionEnd Helpers 84 */ 85 86 var TRANSITION_END = 'transitionend'; 87 var MAX_UID = 1000000; 88 var MILLISECONDS_MULTIPLIER = 1000; // Shoutout AngusCroll (https://goo.gl/pxwQGp) 89 90 function toType(obj) { 91 if (obj === null || typeof obj === 'undefined') { 92 return "" + obj; 93 } 94 95 return {}.toString.call(obj).match(/\s([a-z]+)/i)[1].toLowerCase(); 96 } 97 98 function getSpecialTransitionEndEvent() { 99 return { 100 bindType: TRANSITION_END, 101 delegateType: TRANSITION_END, 102 handle: function handle(event) { 103 if ($__default["default"](event.target).is(this)) { 104 return event.handleObj.handler.apply(this, arguments); // eslint-disable-line prefer-rest-params 105 } 106 107 return undefined; 108 } 109 }; 110 } 111 112 function transitionEndEmulator(duration) { 113 var _this = this; 114 115 var called = false; 116 $__default["default"](this).one(Util.TRANSITION_END, function () { 117 called = true; 118 }); 119 setTimeout(function () { 120 if (!called) { 121 Util.triggerTransitionEnd(_this); 122 } 123 }, duration); 124 return this; 125 } 126 127 function setTransitionEndSupport() { 128 $__default["default"].fn.emulateTransitionEnd = transitionEndEmulator; 129 $__default["default"].event.special[Util.TRANSITION_END] = getSpecialTransitionEndEvent(); 130 } 131 /** 132 * Public Util API 133 */ 134 135 136 var Util = { 137 TRANSITION_END: 'bsTransitionEnd', 138 getUID: function getUID(prefix) { 139 do { 140 // eslint-disable-next-line no-bitwise 141 prefix += ~~(Math.random() * MAX_UID); // "~~" acts like a faster Math.floor() here 142 } while (document.getElementById(prefix)); 143 144 return prefix; 145 }, 146 getSelectorFromElement: function getSelectorFromElement(element) { 147 var selector = element.getAttribute('data-target'); 148 149 if (!selector || selector === '#') { 150 var hrefAttr = element.getAttribute('href'); 151 selector = hrefAttr && hrefAttr !== '#' ? hrefAttr.trim() : ''; 152 } 153 154 try { 155 return document.querySelector(selector) ? selector : null; 156 } catch (_) { 157 return null; 158 } 159 }, 160 getTransitionDurationFromElement: function getTransitionDurationFromElement(element) { 161 if (!element) { 162 return 0; 163 } // Get transition-duration of the element 164 165 166 var transitionDuration = $__default["default"](element).css('transition-duration'); 167 var transitionDelay = $__default["default"](element).css('transition-delay'); 168 var floatTransitionDuration = parseFloat(transitionDuration); 169 var floatTransitionDelay = parseFloat(transitionDelay); // Return 0 if element or transition duration is not found 170 171 if (!floatTransitionDuration && !floatTransitionDelay) { 172 return 0; 173 } // If multiple durations are defined, take the first 174 175 176 transitionDuration = transitionDuration.split(',')[0]; 177 transitionDelay = transitionDelay.split(',')[0]; 178 return (parseFloat(transitionDuration) + parseFloat(transitionDelay)) * MILLISECONDS_MULTIPLIER; 179 }, 180 reflow: function reflow(element) { 181 return element.offsetHeight; 182 }, 183 triggerTransitionEnd: function triggerTransitionEnd(element) { 184 $__default["default"](element).trigger(TRANSITION_END); 185 }, 186 supportsTransitionEnd: function supportsTransitionEnd() { 187 return Boolean(TRANSITION_END); 188 }, 189 isElement: function isElement(obj) { 190 return (obj[0] || obj).nodeType; 191 }, 192 typeCheckConfig: function typeCheckConfig(componentName, config, configTypes) { 193 for (var property in configTypes) { 194 if (Object.prototype.hasOwnProperty.call(configTypes, property)) { 195 var expectedTypes = configTypes[property]; 196 var value = config[property]; 197 var valueType = value && Util.isElement(value) ? 'element' : toType(value); 198 199 if (!new RegExp(expectedTypes).test(valueType)) { 200 throw new Error(componentName.toUpperCase() + ": " + ("Option \"" + property + "\" provided type \"" + valueType + "\" ") + ("but expected type \"" + expectedTypes + "\".")); 201 } 202 } 203 } 204 }, 205 findShadowRoot: function findShadowRoot(element) { 206 if (!document.documentElement.attachShadow) { 207 return null; 208 } // Can find the shadow root otherwise it'll return the document 209 210 211 if (typeof element.getRootNode === 'function') { 212 var root = element.getRootNode(); 213 return root instanceof ShadowRoot ? root : null; 214 } 215 216 if (element instanceof ShadowRoot) { 217 return element; 218 } // when we don't find a shadow root 219 220 221 if (!element.parentNode) { 222 return null; 223 } 224 225 return Util.findShadowRoot(element.parentNode); 226 }, 227 jQueryDetection: function jQueryDetection() { 228 if (typeof $__default["default"] === 'undefined') { 229 throw new TypeError('Bootstrap\'s JavaScript requires jQuery. jQuery must be included before Bootstrap\'s JavaScript.'); 230 } 231 232 var version = $__default["default"].fn.jquery.split(' ')[0].split('.'); 233 var minMajor = 1; 234 var ltMajor = 2; 235 var minMinor = 9; 236 var minPatch = 1; 237 var maxMajor = 4; 238 239 if (version[0] < ltMajor && version[1] < minMinor || version[0] === minMajor && version[1] === minMinor && version[2] < minPatch || version[0] >= maxMajor) { 240 throw new Error('Bootstrap\'s JavaScript requires at least jQuery v1.9.1 but less than v4.0.0'); 241 } 242 } 243 }; 244 Util.jQueryDetection(); 245 setTransitionEndSupport(); 246 247 /** 248 * Constants 249 */ 250 251 var NAME$a = 'alert'; 252 var VERSION$a = '4.6.2'; 253 var DATA_KEY$a = 'bs.alert'; 254 var EVENT_KEY$a = "." + DATA_KEY$a; 255 var DATA_API_KEY$7 = '.data-api'; 256 var JQUERY_NO_CONFLICT$a = $__default["default"].fn[NAME$a]; 257 var CLASS_NAME_ALERT = 'alert'; 258 var CLASS_NAME_FADE$5 = 'fade'; 259 var CLASS_NAME_SHOW$7 = 'show'; 260 var EVENT_CLOSE = "close" + EVENT_KEY$a; 261 var EVENT_CLOSED = "closed" + EVENT_KEY$a; 262 var EVENT_CLICK_DATA_API$6 = "click" + EVENT_KEY$a + DATA_API_KEY$7; 263 var SELECTOR_DISMISS = '[data-dismiss="alert"]'; 264 /** 265 * Class definition 266 */ 267 268 var Alert = /*#__PURE__*/function () { 269 function Alert(element) { 270 this._element = element; 271 } // Getters 272 273 274 var _proto = Alert.prototype; 275 276 // Public 277 _proto.close = function close(element) { 278 var rootElement = this._element; 279 280 if (element) { 281 rootElement = this._getRootElement(element); 282 } 283 284 var customEvent = this._triggerCloseEvent(rootElement); 285 286 if (customEvent.isDefaultPrevented()) { 287 return; 288 } 289 290 this._removeElement(rootElement); 291 }; 292 293 _proto.dispose = function dispose() { 294 $__default["default"].removeData(this._element, DATA_KEY$a); 295 this._element = null; 296 } // Private 297 ; 298 299 _proto._getRootElement = function _getRootElement(element) { 300 var selector = Util.getSelectorFromElement(element); 301 var parent = false; 302 303 if (selector) { 304 parent = document.querySelector(selector); 305 } 306 307 if (!parent) { 308 parent = $__default["default"](element).closest("." + CLASS_NAME_ALERT)[0]; 309 } 310 311 return parent; 312 }; 313 314 _proto._triggerCloseEvent = function _triggerCloseEvent(element) { 315 var closeEvent = $__default["default"].Event(EVENT_CLOSE); 316 $__default["default"](element).trigger(closeEvent); 317 return closeEvent; 318 }; 319 320 _proto._removeElement = function _removeElement(element) { 321 var _this = this; 322 323 $__default["default"](element).removeClass(CLASS_NAME_SHOW$7); 324 325 if (!$__default["default"](element).hasClass(CLASS_NAME_FADE$5)) { 326 this._destroyElement(element); 327 328 return; 329 } 330 331 var transitionDuration = Util.getTransitionDurationFromElement(element); 332 $__default["default"](element).one(Util.TRANSITION_END, function (event) { 333 return _this._destroyElement(element, event); 334 }).emulateTransitionEnd(transitionDuration); 335 }; 336 337 _proto._destroyElement = function _destroyElement(element) { 338 $__default["default"](element).detach().trigger(EVENT_CLOSED).remove(); 339 } // Static 340 ; 341 342 Alert._jQueryInterface = function _jQueryInterface(config) { 343 return this.each(function () { 344 var $element = $__default["default"](this); 345 var data = $element.data(DATA_KEY$a); 346 347 if (!data) { 348 data = new Alert(this); 349 $element.data(DATA_KEY$a, data); 350 } 351 352 if (config === 'close') { 353 data[config](this); 354 } 355 }); 356 }; 357 358 Alert._handleDismiss = function _handleDismiss(alertInstance) { 359 return function (event) { 360 if (event) { 361 event.preventDefault(); 362 } 363 364 alertInstance.close(this); 365 }; 366 }; 367 368 _createClass(Alert, null, [{ 369 key: "VERSION", 370 get: function get() { 371 return VERSION$a; 372 } 373 }]); 374 375 return Alert; 376 }(); 377 /** 378 * Data API implementation 379 */ 380 381 382 $__default["default"](document).on(EVENT_CLICK_DATA_API$6, SELECTOR_DISMISS, Alert._handleDismiss(new Alert())); 383 /** 384 * jQuery 385 */ 386 387 $__default["default"].fn[NAME$a] = Alert._jQueryInterface; 388 $__default["default"].fn[NAME$a].Constructor = Alert; 389 390 $__default["default"].fn[NAME$a].noConflict = function () { 391 $__default["default"].fn[NAME$a] = JQUERY_NO_CONFLICT$a; 392 return Alert._jQueryInterface; 393 }; 394 395 /** 396 * Constants 397 */ 398 399 var NAME$9 = 'button'; 400 var VERSION$9 = '4.6.2'; 401 var DATA_KEY$9 = 'bs.button'; 402 var EVENT_KEY$9 = "." + DATA_KEY$9; 403 var DATA_API_KEY$6 = '.data-api'; 404 var JQUERY_NO_CONFLICT$9 = $__default["default"].fn[NAME$9]; 405 var CLASS_NAME_ACTIVE$3 = 'active'; 406 var CLASS_NAME_BUTTON = 'btn'; 407 var CLASS_NAME_FOCUS = 'focus'; 408 var EVENT_CLICK_DATA_API$5 = "click" + EVENT_KEY$9 + DATA_API_KEY$6; 409 var EVENT_FOCUS_BLUR_DATA_API = "focus" + EVENT_KEY$9 + DATA_API_KEY$6 + " " + ("blur" + EVENT_KEY$9 + DATA_API_KEY$6); 410 var EVENT_LOAD_DATA_API$2 = "load" + EVENT_KEY$9 + DATA_API_KEY$6; 411 var SELECTOR_DATA_TOGGLE_CARROT = '[data-toggle^="button"]'; 412 var SELECTOR_DATA_TOGGLES = '[data-toggle="buttons"]'; 413 var SELECTOR_DATA_TOGGLE$4 = '[data-toggle="button"]'; 414 var SELECTOR_DATA_TOGGLES_BUTTONS = '[data-toggle="buttons"] .btn'; 415 var SELECTOR_INPUT = 'input:not([type="hidden"])'; 416 var SELECTOR_ACTIVE$2 = '.active'; 417 var SELECTOR_BUTTON = '.btn'; 418 /** 419 * Class definition 420 */ 421 422 var Button = /*#__PURE__*/function () { 423 function Button(element) { 424 this._element = element; 425 this.shouldAvoidTriggerChange = false; 426 } // Getters 427 428 429 var _proto = Button.prototype; 430 431 // Public 432 _proto.toggle = function toggle() { 433 var triggerChangeEvent = true; 434 var addAriaPressed = true; 435 var rootElement = $__default["default"](this._element).closest(SELECTOR_DATA_TOGGLES)[0]; 436 437 if (rootElement) { 438 var input = this._element.querySelector(SELECTOR_INPUT); 439 440 if (input) { 441 if (input.type === 'radio') { 442 if (input.checked && this._element.classList.contains(CLASS_NAME_ACTIVE$3)) { 443 triggerChangeEvent = false; 444 } else { 445 var activeElement = rootElement.querySelector(SELECTOR_ACTIVE$2); 446 447 if (activeElement) { 448 $__default["default"](activeElement).removeClass(CLASS_NAME_ACTIVE$3); 449 } 450 } 451 } 452 453 if (triggerChangeEvent) { 454 // if it's not a radio button or checkbox don't add a pointless/invalid checked property to the input 455 if (input.type === 'checkbox' || input.type === 'radio') { 456 input.checked = !this._element.classList.contains(CLASS_NAME_ACTIVE$3); 457 } 458 459 if (!this.shouldAvoidTriggerChange) { 460 $__default["default"](input).trigger('change'); 461 } 462 } 463 464 input.focus(); 465 addAriaPressed = false; 466 } 467 } 468 469 if (!(this._element.hasAttribute('disabled') || this._element.classList.contains('disabled'))) { 470 if (addAriaPressed) { 471 this._element.setAttribute('aria-pressed', !this._element.classList.contains(CLASS_NAME_ACTIVE$3)); 472 } 473 474 if (triggerChangeEvent) { 475 $__default["default"](this._element).toggleClass(CLASS_NAME_ACTIVE$3); 476 } 477 } 478 }; 479 480 _proto.dispose = function dispose() { 481 $__default["default"].removeData(this._element, DATA_KEY$9); 482 this._element = null; 483 } // Static 484 ; 485 486 Button._jQueryInterface = function _jQueryInterface(config, avoidTriggerChange) { 487 return this.each(function () { 488 var $element = $__default["default"](this); 489 var data = $element.data(DATA_KEY$9); 490 491 if (!data) { 492 data = new Button(this); 493 $element.data(DATA_KEY$9, data); 494 } 495 496 data.shouldAvoidTriggerChange = avoidTriggerChange; 497 498 if (config === 'toggle') { 499 data[config](); 500 } 501 }); 502 }; 503 504 _createClass(Button, null, [{ 505 key: "VERSION", 506 get: function get() { 507 return VERSION$9; 508 } 509 }]); 510 511 return Button; 512 }(); 513 /** 514 * Data API implementation 515 */ 516 517 518 $__default["default"](document).on(EVENT_CLICK_DATA_API$5, SELECTOR_DATA_TOGGLE_CARROT, function (event) { 519 var button = event.target; 520 var initialButton = button; 521 522 if (!$__default["default"](button).hasClass(CLASS_NAME_BUTTON)) { 523 button = $__default["default"](button).closest(SELECTOR_BUTTON)[0]; 524 } 525 526 if (!button || button.hasAttribute('disabled') || button.classList.contains('disabled')) { 527 event.preventDefault(); // work around Firefox bug #1540995 528 } else { 529 var inputBtn = button.querySelector(SELECTOR_INPUT); 530 531 if (inputBtn && (inputBtn.hasAttribute('disabled') || inputBtn.classList.contains('disabled'))) { 532 event.preventDefault(); // work around Firefox bug #1540995 533 534 return; 535 } 536 537 if (initialButton.tagName === 'INPUT' || button.tagName !== 'LABEL') { 538 Button._jQueryInterface.call($__default["default"](button), 'toggle', initialButton.tagName === 'INPUT'); 539 } 540 } 541 }).on(EVENT_FOCUS_BLUR_DATA_API, SELECTOR_DATA_TOGGLE_CARROT, function (event) { 542 var button = $__default["default"](event.target).closest(SELECTOR_BUTTON)[0]; 543 $__default["default"](button).toggleClass(CLASS_NAME_FOCUS, /^focus(in)?$/.test(event.type)); 544 }); 545 $__default["default"](window).on(EVENT_LOAD_DATA_API$2, function () { 546 // ensure correct active class is set to match the controls' actual values/states 547 // find all checkboxes/readio buttons inside data-toggle groups 548 var buttons = [].slice.call(document.querySelectorAll(SELECTOR_DATA_TOGGLES_BUTTONS)); 549 550 for (var i = 0, len = buttons.length; i < len; i++) { 551 var button = buttons[i]; 552 var input = button.querySelector(SELECTOR_INPUT); 553 554 if (input.checked || input.hasAttribute('checked')) { 555 button.classList.add(CLASS_NAME_ACTIVE$3); 556 } else { 557 button.classList.remove(CLASS_NAME_ACTIVE$3); 558 } 559 } // find all button toggles 560 561 562 buttons = [].slice.call(document.querySelectorAll(SELECTOR_DATA_TOGGLE$4)); 563 564 for (var _i = 0, _len = buttons.length; _i < _len; _i++) { 565 var _button = buttons[_i]; 566 567 if (_button.getAttribute('aria-pressed') === 'true') { 568 _button.classList.add(CLASS_NAME_ACTIVE$3); 569 } else { 570 _button.classList.remove(CLASS_NAME_ACTIVE$3); 571 } 572 } 573 }); 574 /** 575 * jQuery 576 */ 577 578 $__default["default"].fn[NAME$9] = Button._jQueryInterface; 579 $__default["default"].fn[NAME$9].Constructor = Button; 580 581 $__default["default"].fn[NAME$9].noConflict = function () { 582 $__default["default"].fn[NAME$9] = JQUERY_NO_CONFLICT$9; 583 return Button._jQueryInterface; 584 }; 585 586 /** 587 * Constants 588 */ 589 590 var NAME$8 = 'carousel'; 591 var VERSION$8 = '4.6.2'; 592 var DATA_KEY$8 = 'bs.carousel'; 593 var EVENT_KEY$8 = "." + DATA_KEY$8; 594 var DATA_API_KEY$5 = '.data-api'; 595 var JQUERY_NO_CONFLICT$8 = $__default["default"].fn[NAME$8]; 596 var ARROW_LEFT_KEYCODE = 37; // KeyboardEvent.which value for left arrow key 597 598 var ARROW_RIGHT_KEYCODE = 39; // KeyboardEvent.which value for right arrow key 599 600 var TOUCHEVENT_COMPAT_WAIT = 500; // Time for mouse compat events to fire after touch 601 602 var SWIPE_THRESHOLD = 40; 603 var CLASS_NAME_CAROUSEL = 'carousel'; 604 var CLASS_NAME_ACTIVE$2 = 'active'; 605 var CLASS_NAME_SLIDE = 'slide'; 606 var CLASS_NAME_RIGHT = 'carousel-item-right'; 607 var CLASS_NAME_LEFT = 'carousel-item-left'; 608 var CLASS_NAME_NEXT = 'carousel-item-next'; 609 var CLASS_NAME_PREV = 'carousel-item-prev'; 610 var CLASS_NAME_POINTER_EVENT = 'pointer-event'; 611 var DIRECTION_NEXT = 'next'; 612 var DIRECTION_PREV = 'prev'; 613 var DIRECTION_LEFT = 'left'; 614 var DIRECTION_RIGHT = 'right'; 615 var EVENT_SLIDE = "slide" + EVENT_KEY$8; 616 var EVENT_SLID = "slid" + EVENT_KEY$8; 617 var EVENT_KEYDOWN = "keydown" + EVENT_KEY$8; 618 var EVENT_MOUSEENTER = "mouseenter" + EVENT_KEY$8; 619 var EVENT_MOUSELEAVE = "mouseleave" + EVENT_KEY$8; 620 var EVENT_TOUCHSTART = "touchstart" + EVENT_KEY$8; 621 var EVENT_TOUCHMOVE = "touchmove" + EVENT_KEY$8; 622 var EVENT_TOUCHEND = "touchend" + EVENT_KEY$8; 623 var EVENT_POINTERDOWN = "pointerdown" + EVENT_KEY$8; 624 var EVENT_POINTERUP = "pointerup" + EVENT_KEY$8; 625 var EVENT_DRAG_START = "dragstart" + EVENT_KEY$8; 626 var EVENT_LOAD_DATA_API$1 = "load" + EVENT_KEY$8 + DATA_API_KEY$5; 627 var EVENT_CLICK_DATA_API$4 = "click" + EVENT_KEY$8 + DATA_API_KEY$5; 628 var SELECTOR_ACTIVE$1 = '.active'; 629 var SELECTOR_ACTIVE_ITEM = '.active.carousel-item'; 630 var SELECTOR_ITEM = '.carousel-item'; 631 var SELECTOR_ITEM_IMG = '.carousel-item img'; 632 var SELECTOR_NEXT_PREV = '.carousel-item-next, .carousel-item-prev'; 633 var SELECTOR_INDICATORS = '.carousel-indicators'; 634 var SELECTOR_DATA_SLIDE = '[data-slide], [data-slide-to]'; 635 var SELECTOR_DATA_RIDE = '[data-ride="carousel"]'; 636 var Default$7 = { 637 interval: 5000, 638 keyboard: true, 639 slide: false, 640 pause: 'hover', 641 wrap: true, 642 touch: true 643 }; 644 var DefaultType$7 = { 645 interval: '(number|boolean)', 646 keyboard: 'boolean', 647 slide: '(boolean|string)', 648 pause: '(string|boolean)', 649 wrap: 'boolean', 650 touch: 'boolean' 651 }; 652 var PointerType = { 653 TOUCH: 'touch', 654 PEN: 'pen' 655 }; 656 /** 657 * Class definition 658 */ 659 660 var Carousel = /*#__PURE__*/function () { 661 function Carousel(element, config) { 662 this._items = null; 663 this._interval = null; 664 this._activeElement = null; 665 this._isPaused = false; 666 this._isSliding = false; 667 this.touchTimeout = null; 668 this.touchStartX = 0; 669 this.touchDeltaX = 0; 670 this._config = this._getConfig(config); 671 this._element = element; 672 this._indicatorsElement = this._element.querySelector(SELECTOR_INDICATORS); 673 this._touchSupported = 'ontouchstart' in document.documentElement || navigator.maxTouchPoints > 0; 674 this._pointerEvent = Boolean(window.PointerEvent || window.MSPointerEvent); 675 676 this._addEventListeners(); 677 } // Getters 678 679 680 var _proto = Carousel.prototype; 681 682 // Public 683 _proto.next = function next() { 684 if (!this._isSliding) { 685 this._slide(DIRECTION_NEXT); 686 } 687 }; 688 689 _proto.nextWhenVisible = function nextWhenVisible() { 690 var $element = $__default["default"](this._element); // Don't call next when the page isn't visible 691 // or the carousel or its parent isn't visible 692 693 if (!document.hidden && $element.is(':visible') && $element.css('visibility') !== 'hidden') { 694 this.next(); 695 } 696 }; 697 698 _proto.prev = function prev() { 699 if (!this._isSliding) { 700 this._slide(DIRECTION_PREV); 701 } 702 }; 703 704 _proto.pause = function pause(event) { 705 if (!event) { 706 this._isPaused = true; 707 } 708 709 if (this._element.querySelector(SELECTOR_NEXT_PREV)) { 710 Util.triggerTransitionEnd(this._element); 711 this.cycle(true); 712 } 713 714 clearInterval(this._interval); 715 this._interval = null; 716 }; 717 718 _proto.cycle = function cycle(event) { 719 if (!event) { 720 this._isPaused = false; 721 } 722 723 if (this._interval) { 724 clearInterval(this._interval); 725 this._interval = null; 726 } 727 728 if (this._config.interval && !this._isPaused) { 729 this._updateInterval(); 730 731 this._interval = setInterval((document.visibilityState ? this.nextWhenVisible : this.next).bind(this), this._config.interval); 732 } 733 }; 734 735 _proto.to = function to(index) { 736 var _this = this; 737 738 this._activeElement = this._element.querySelector(SELECTOR_ACTIVE_ITEM); 739 740 var activeIndex = this._getItemIndex(this._activeElement); 741 742 if (index > this._items.length - 1 || index < 0) { 743 return; 744 } 745 746 if (this._isSliding) { 747 $__default["default"](this._element).one(EVENT_SLID, function () { 748 return _this.to(index); 749 }); 750 return; 751 } 752 753 if (activeIndex === index) { 754 this.pause(); 755 this.cycle(); 756 return; 757 } 758 759 var direction = index > activeIndex ? DIRECTION_NEXT : DIRECTION_PREV; 760 761 this._slide(direction, this._items[index]); 762 }; 763 764 _proto.dispose = function dispose() { 765 $__default["default"](this._element).off(EVENT_KEY$8); 766 $__default["default"].removeData(this._element, DATA_KEY$8); 767 this._items = null; 768 this._config = null; 769 this._element = null; 770 this._interval = null; 771 this._isPaused = null; 772 this._isSliding = null; 773 this._activeElement = null; 774 this._indicatorsElement = null; 775 } // Private 776 ; 777 778 _proto._getConfig = function _getConfig(config) { 779 config = _extends({}, Default$7, config); 780 Util.typeCheckConfig(NAME$8, config, DefaultType$7); 781 return config; 782 }; 783 784 _proto._handleSwipe = function _handleSwipe() { 785 var absDeltax = Math.abs(this.touchDeltaX); 786 787 if (absDeltax <= SWIPE_THRESHOLD) { 788 return; 789 } 790 791 var direction = absDeltax / this.touchDeltaX; 792 this.touchDeltaX = 0; // swipe left 793 794 if (direction > 0) { 795 this.prev(); 796 } // swipe right 797 798 799 if (direction < 0) { 800 this.next(); 801 } 802 }; 803 804 _proto._addEventListeners = function _addEventListeners() { 805 var _this2 = this; 806 807 if (this._config.keyboard) { 808 $__default["default"](this._element).on(EVENT_KEYDOWN, function (event) { 809 return _this2._keydown(event); 810 }); 811 } 812 813 if (this._config.pause === 'hover') { 814 $__default["default"](this._element).on(EVENT_MOUSEENTER, function (event) { 815 return _this2.pause(event); 816 }).on(EVENT_MOUSELEAVE, function (event) { 817 return _this2.cycle(event); 818 }); 819 } 820 821 if (this._config.touch) { 822 this._addTouchEventListeners(); 823 } 824 }; 825 826 _proto._addTouchEventListeners = function _addTouchEventListeners() { 827 var _this3 = this; 828 829 if (!this._touchSupported) { 830 return; 831 } 832 833 var start = function start(event) { 834 if (_this3._pointerEvent && PointerType[event.originalEvent.pointerType.toUpperCase()]) { 835 _this3.touchStartX = event.originalEvent.clientX; 836 } else if (!_this3._pointerEvent) { 837 _this3.touchStartX = event.originalEvent.touches[0].clientX; 838 } 839 }; 840 841 var move = function move(event) { 842 // ensure swiping with one touch and not pinching 843 _this3.touchDeltaX = event.originalEvent.touches && event.originalEvent.touches.length > 1 ? 0 : event.originalEvent.touches[0].clientX - _this3.touchStartX; 844 }; 845 846 var end = function end(event) { 847 if (_this3._pointerEvent && PointerType[event.originalEvent.pointerType.toUpperCase()]) { 848 _this3.touchDeltaX = event.originalEvent.clientX - _this3.touchStartX; 849 } 850 851 _this3._handleSwipe(); 852 853 if (_this3._config.pause === 'hover') { 854 // If it's a touch-enabled device, mouseenter/leave are fired as 855 // part of the mouse compatibility events on first tap - the carousel 856 // would stop cycling until user tapped out of it; 857 // here, we listen for touchend, explicitly pause the carousel 858 // (as if it's the second time we tap on it, mouseenter compat event 859 // is NOT fired) and after a timeout (to allow for mouse compatibility 860 // events to fire) we explicitly restart cycling 861 _this3.pause(); 862 863 if (_this3.touchTimeout) { 864 clearTimeout(_this3.touchTimeout); 865 } 866 867 _this3.touchTimeout = setTimeout(function (event) { 868 return _this3.cycle(event); 869 }, TOUCHEVENT_COMPAT_WAIT + _this3._config.interval); 870 } 871 }; 872 873 $__default["default"](this._element.querySelectorAll(SELECTOR_ITEM_IMG)).on(EVENT_DRAG_START, function (e) { 874 return e.preventDefault(); 875 }); 876 877 if (this._pointerEvent) { 878 $__default["default"](this._element).on(EVENT_POINTERDOWN, function (event) { 879 return start(event); 880 }); 881 $__default["default"](this._element).on(EVENT_POINTERUP, function (event) { 882 return end(event); 883 }); 884 885 this._element.classList.add(CLASS_NAME_POINTER_EVENT); 886 } else { 887 $__default["default"](this._element).on(EVENT_TOUCHSTART, function (event) { 888 return start(event); 889 }); 890 $__default["default"](this._element).on(EVENT_TOUCHMOVE, function (event) { 891 return move(event); 892 }); 893 $__default["default"](this._element).on(EVENT_TOUCHEND, function (event) { 894 return end(event); 895 }); 896 } 897 }; 898 899 _proto._keydown = function _keydown(event) { 900 if (/input|textarea/i.test(event.target.tagName)) { 901 return; 902 } 903 904 switch (event.which) { 905 case ARROW_LEFT_KEYCODE: 906 event.preventDefault(); 907 this.prev(); 908 break; 909 910 case ARROW_RIGHT_KEYCODE: 911 event.preventDefault(); 912 this.next(); 913 break; 914 } 915 }; 916 917 _proto._getItemIndex = function _getItemIndex(element) { 918 this._items = element && element.parentNode ? [].slice.call(element.parentNode.querySelectorAll(SELECTOR_ITEM)) : []; 919 return this._items.indexOf(element); 920 }; 921 922 _proto._getItemByDirection = function _getItemByDirection(direction, activeElement) { 923 var isNextDirection = direction === DIRECTION_NEXT; 924 var isPrevDirection = direction === DIRECTION_PREV; 925 926 var activeIndex = this._getItemIndex(activeElement); 927 928 var lastItemIndex = this._items.length - 1; 929 var isGoingToWrap = isPrevDirection && activeIndex === 0 || isNextDirection && activeIndex === lastItemIndex; 930 931 if (isGoingToWrap && !this._config.wrap) { 932 return activeElement; 933 } 934 935 var delta = direction === DIRECTION_PREV ? -1 : 1; 936 var itemIndex = (activeIndex + delta) % this._items.length; 937 return itemIndex === -1 ? this._items[this._items.length - 1] : this._items[itemIndex]; 938 }; 939 940 _proto._triggerSlideEvent = function _triggerSlideEvent(relatedTarget, eventDirectionName) { 941 var targetIndex = this._getItemIndex(relatedTarget); 942 943 var fromIndex = this._getItemIndex(this._element.querySelector(SELECTOR_ACTIVE_ITEM)); 944 945 var slideEvent = $__default["default"].Event(EVENT_SLIDE, { 946 relatedTarget: relatedTarget, 947 direction: eventDirectionName, 948 from: fromIndex, 949 to: targetIndex 950 }); 951 $__default["default"](this._element).trigger(slideEvent); 952 return slideEvent; 953 }; 954 955 _proto._setActiveIndicatorElement = function _setActiveIndicatorElement(element) { 956 if (this._indicatorsElement) { 957 var indicators = [].slice.call(this._indicatorsElement.querySelectorAll(SELECTOR_ACTIVE$1)); 958 $__default["default"](indicators).removeClass(CLASS_NAME_ACTIVE$2); 959 960 var nextIndicator = this._indicatorsElement.children[this._getItemIndex(element)]; 961 962 if (nextIndicator) { 963 $__default["default"](nextIndicator).addClass(CLASS_NAME_ACTIVE$2); 964 } 965 } 966 }; 967 968 _proto._updateInterval = function _updateInterval() { 969 var element = this._activeElement || this._element.querySelector(SELECTOR_ACTIVE_ITEM); 970 971 if (!element) { 972 return; 973 } 974 975 var elementInterval = parseInt(element.getAttribute('data-interval'), 10); 976 977 if (elementInterval) { 978 this._config.defaultInterval = this._config.defaultInterval || this._config.interval; 979 this._config.interval = elementInterval; 980 } else { 981 this._config.interval = this._config.defaultInterval || this._config.interval; 982 } 983 }; 984 985 _proto._slide = function _slide(direction, element) { 986 var _this4 = this; 987 988 var activeElement = this._element.querySelector(SELECTOR_ACTIVE_ITEM); 989 990 var activeElementIndex = this._getItemIndex(activeElement); 991 992 var nextElement = element || activeElement && this._getItemByDirection(direction, activeElement); 993 994 var nextElementIndex = this._getItemIndex(nextElement); 995 996 var isCycling = Boolean(this._interval); 997 var directionalClassName; 998 var orderClassName; 999 var eventDirectionName; 1000 1001 if (direction === DIRECTION_NEXT) { 1002 directionalClassName = CLASS_NAME_LEFT; 1003 orderClassName = CLASS_NAME_NEXT; 1004 eventDirectionName = DIRECTION_LEFT; 1005 } else { 1006 directionalClassName = CLASS_NAME_RIGHT; 1007 orderClassName = CLASS_NAME_PREV; 1008 eventDirectionName = DIRECTION_RIGHT; 1009 } 1010 1011 if (nextElement && $__default["default"](nextElement).hasClass(CLASS_NAME_ACTIVE$2)) { 1012 this._isSliding = false; 1013 return; 1014 } 1015 1016 var slideEvent = this._triggerSlideEvent(nextElement, eventDirectionName); 1017 1018 if (slideEvent.isDefaultPrevented()) { 1019 return; 1020 } 1021 1022 if (!activeElement || !nextElement) { 1023 // Some weirdness is happening, so we bail 1024 return; 1025 } 1026 1027 this._isSliding = true; 1028 1029 if (isCycling) { 1030 this.pause(); 1031 } 1032 1033 this._setActiveIndicatorElement(nextElement); 1034 1035 this._activeElement = nextElement; 1036 var slidEvent = $__default["default"].Event(EVENT_SLID, { 1037 relatedTarget: nextElement, 1038 direction: eventDirectionName, 1039 from: activeElementIndex, 1040 to: nextElementIndex 1041 }); 1042 1043 if ($__default["default"](this._element).hasClass(CLASS_NAME_SLIDE)) { 1044 $__default["default"](nextElement).addClass(orderClassName); 1045 Util.reflow(nextElement); 1046 $__default["default"](activeElement).addClass(directionalClassName); 1047 $__default["default"](nextElement).addClass(directionalClassName); 1048 var transitionDuration = Util.getTransitionDurationFromElement(activeElement); 1049 $__default["default"](activeElement).one(Util.TRANSITION_END, function () { 1050 $__default["default"](nextElement).removeClass(directionalClassName + " " + orderClassName).addClass(CLASS_NAME_ACTIVE$2); 1051 $__default["default"](activeElement).removeClass(CLASS_NAME_ACTIVE$2 + " " + orderClassName + " " + directionalClassName); 1052 _this4._isSliding = false; 1053 setTimeout(function () { 1054 return $__default["default"](_this4._element).trigger(slidEvent); 1055 }, 0); 1056 }).emulateTransitionEnd(transitionDuration); 1057 } else { 1058 $__default["default"](activeElement).removeClass(CLASS_NAME_ACTIVE$2); 1059 $__default["default"](nextElement).addClass(CLASS_NAME_ACTIVE$2); 1060 this._isSliding = false; 1061 $__default["default"](this._element).trigger(slidEvent); 1062 } 1063 1064 if (isCycling) { 1065 this.cycle(); 1066 } 1067 } // Static 1068 ; 1069 1070 Carousel._jQueryInterface = function _jQueryInterface(config) { 1071 return this.each(function () { 1072 var data = $__default["default"](this).data(DATA_KEY$8); 1073 1074 var _config = _extends({}, Default$7, $__default["default"](this).data()); 1075 1076 if (typeof config === 'object') { 1077 _config = _extends({}, _config, config); 1078 } 1079 1080 var action = typeof config === 'string' ? config : _config.slide; 1081 1082 if (!data) { 1083 data = new Carousel(this, _config); 1084 $__default["default"](this).data(DATA_KEY$8, data); 1085 } 1086 1087 if (typeof config === 'number') { 1088 data.to(config); 1089 } else if (typeof action === 'string') { 1090 if (typeof data[action] === 'undefined') { 1091 throw new TypeError("No method named \"" + action + "\""); 1092 } 1093 1094 data[action](); 1095 } else if (_config.interval && _config.ride) { 1096 data.pause(); 1097 data.cycle(); 1098 } 1099 }); 1100 }; 1101 1102 Carousel._dataApiClickHandler = function _dataApiClickHandler(event) { 1103 var selector = Util.getSelectorFromElement(this); 1104 1105 if (!selector) { 1106 return; 1107 } 1108 1109 var target = $__default["default"](selector)[0]; 1110 1111 if (!target || !$__default["default"](target).hasClass(CLASS_NAME_CAROUSEL)) { 1112 return; 1113 } 1114 1115 var config = _extends({}, $__default["default"](target).data(), $__default["default"](this).data()); 1116 1117 var slideIndex = this.getAttribute('data-slide-to'); 1118 1119 if (slideIndex) { 1120 config.interval = false; 1121 } 1122 1123 Carousel._jQueryInterface.call($__default["default"](target), config); 1124 1125 if (slideIndex) { 1126 $__default["default"](target).data(DATA_KEY$8).to(slideIndex); 1127 } 1128 1129 event.preventDefault(); 1130 }; 1131 1132 _createClass(Carousel, null, [{ 1133 key: "VERSION", 1134 get: function get() { 1135 return VERSION$8; 1136 } 1137 }, { 1138 key: "Default", 1139 get: function get() { 1140 return Default$7; 1141 } 1142 }]); 1143 1144 return Carousel; 1145 }(); 1146 /** 1147 * Data API implementation 1148 */ 1149 1150 1151 $__default["default"](document).on(EVENT_CLICK_DATA_API$4, SELECTOR_DATA_SLIDE, Carousel._dataApiClickHandler); 1152 $__default["default"](window).on(EVENT_LOAD_DATA_API$1, function () { 1153 var carousels = [].slice.call(document.querySelectorAll(SELECTOR_DATA_RIDE)); 1154 1155 for (var i = 0, len = carousels.length; i < len; i++) { 1156 var $carousel = $__default["default"](carousels[i]); 1157 1158 Carousel._jQueryInterface.call($carousel, $carousel.data()); 1159 } 1160 }); 1161 /** 1162 * jQuery 1163 */ 1164 1165 $__default["default"].fn[NAME$8] = Carousel._jQueryInterface; 1166 $__default["default"].fn[NAME$8].Constructor = Carousel; 1167 1168 $__default["default"].fn[NAME$8].noConflict = function () { 1169 $__default["default"].fn[NAME$8] = JQUERY_NO_CONFLICT$8; 1170 return Carousel._jQueryInterface; 1171 }; 1172 1173 /** 1174 * Constants 1175 */ 1176 1177 var NAME$7 = 'collapse'; 1178 var VERSION$7 = '4.6.2'; 1179 var DATA_KEY$7 = 'bs.collapse'; 1180 var EVENT_KEY$7 = "." + DATA_KEY$7; 1181 var DATA_API_KEY$4 = '.data-api'; 1182 var JQUERY_NO_CONFLICT$7 = $__default["default"].fn[NAME$7]; 1183 var CLASS_NAME_SHOW$6 = 'show'; 1184 var CLASS_NAME_COLLAPSE = 'collapse'; 1185 var CLASS_NAME_COLLAPSING = 'collapsing'; 1186 var CLASS_NAME_COLLAPSED = 'collapsed'; 1187 var DIMENSION_WIDTH = 'width'; 1188 var DIMENSION_HEIGHT = 'height'; 1189 var EVENT_SHOW$4 = "show" + EVENT_KEY$7; 1190 var EVENT_SHOWN$4 = "shown" + EVENT_KEY$7; 1191 var EVENT_HIDE$4 = "hide" + EVENT_KEY$7; 1192 var EVENT_HIDDEN$4 = "hidden" + EVENT_KEY$7; 1193 var EVENT_CLICK_DATA_API$3 = "click" + EVENT_KEY$7 + DATA_API_KEY$4; 1194 var SELECTOR_ACTIVES = '.show, .collapsing'; 1195 var SELECTOR_DATA_TOGGLE$3 = '[data-toggle="collapse"]'; 1196 var Default$6 = { 1197 toggle: true, 1198 parent: '' 1199 }; 1200 var DefaultType$6 = { 1201 toggle: 'boolean', 1202 parent: '(string|element)' 1203 }; 1204 /** 1205 * Class definition 1206 */ 1207 1208 var Collapse = /*#__PURE__*/function () { 1209 function Collapse(element, config) { 1210 this._isTransitioning = false; 1211 this._element = element; 1212 this._config = this._getConfig(config); 1213 this._triggerArray = [].slice.call(document.querySelectorAll("[data-toggle=\"collapse\"][href=\"#" + element.id + "\"]," + ("[data-toggle=\"collapse\"][data-target=\"#" + element.id + "\"]"))); 1214 var toggleList = [].slice.call(document.querySelectorAll(SELECTOR_DATA_TOGGLE$3)); 1215 1216 for (var i = 0, len = toggleList.length; i < len; i++) { 1217 var elem = toggleList[i]; 1218 var selector = Util.getSelectorFromElement(elem); 1219 var filterElement = [].slice.call(document.querySelectorAll(selector)).filter(function (foundElem) { 1220 return foundElem === element; 1221 }); 1222 1223 if (selector !== null && filterElement.length > 0) { 1224 this._selector = selector; 1225 1226 this._triggerArray.push(elem); 1227 } 1228 } 1229 1230 this._parent = this._config.parent ? this._getParent() : null; 1231 1232 if (!this._config.parent) { 1233 this._addAriaAndCollapsedClass(this._element, this._triggerArray); 1234 } 1235 1236 if (this._config.toggle) { 1237 this.toggle(); 1238 } 1239 } // Getters 1240 1241 1242 var _proto = Collapse.prototype; 1243 1244 // Public 1245 _proto.toggle = function toggle() { 1246 if ($__default["default"](this._element).hasClass(CLASS_NAME_SHOW$6)) { 1247 this.hide(); 1248 } else { 1249 this.show(); 1250 } 1251 }; 1252 1253 _proto.show = function show() { 1254 var _this = this; 1255 1256 if (this._isTransitioning || $__default["default"](this._element).hasClass(CLASS_NAME_SHOW$6)) { 1257 return; 1258 } 1259 1260 var actives; 1261 var activesData; 1262 1263 if (this._parent) { 1264 actives = [].slice.call(this._parent.querySelectorAll(SELECTOR_ACTIVES)).filter(function (elem) { 1265 if (typeof _this._config.parent === 'string') { 1266 return elem.getAttribute('data-parent') === _this._config.parent; 1267 } 1268 1269 return elem.classList.contains(CLASS_NAME_COLLAPSE); 1270 }); 1271 1272 if (actives.length === 0) { 1273 actives = null; 1274 } 1275 } 1276 1277 if (actives) { 1278 activesData = $__default["default"](actives).not(this._selector).data(DATA_KEY$7); 1279 1280 if (activesData && activesData._isTransitioning) { 1281 return; 1282 } 1283 } 1284 1285 var startEvent = $__default["default"].Event(EVENT_SHOW$4); 1286 $__default["default"](this._element).trigger(startEvent); 1287 1288 if (startEvent.isDefaultPrevented()) { 1289 return; 1290 } 1291 1292 if (actives) { 1293 Collapse._jQueryInterface.call($__default["default"](actives).not(this._selector), 'hide'); 1294 1295 if (!activesData) { 1296 $__default["default"](actives).data(DATA_KEY$7, null); 1297 } 1298 } 1299 1300 var dimension = this._getDimension(); 1301 1302 $__default["default"](this._element).removeClass(CLASS_NAME_COLLAPSE).addClass(CLASS_NAME_COLLAPSING); 1303 this._element.style[dimension] = 0; 1304 1305 if (this._triggerArray.length) { 1306 $__default["default"](this._triggerArray).removeClass(CLASS_NAME_COLLAPSED).attr('aria-expanded', true); 1307 } 1308 1309 this.setTransitioning(true); 1310 1311 var complete = function complete() { 1312 $__default["default"](_this._element).removeClass(CLASS_NAME_COLLAPSING).addClass(CLASS_NAME_COLLAPSE + " " + CLASS_NAME_SHOW$6); 1313 _this._element.style[dimension] = ''; 1314 1315 _this.setTransitioning(false); 1316 1317 $__default["default"](_this._element).trigger(EVENT_SHOWN$4); 1318 }; 1319 1320 var capitalizedDimension = dimension[0].toUpperCase() + dimension.slice(1); 1321 var scrollSize = "scroll" + capitalizedDimension; 1322 var transitionDuration = Util.getTransitionDurationFromElement(this._element); 1323 $__default["default"](this._element).one(Util.TRANSITION_END, complete).emulateTransitionEnd(transitionDuration); 1324 this._element.style[dimension] = this._element[scrollSize] + "px"; 1325 }; 1326 1327 _proto.hide = function hide() { 1328 var _this2 = this; 1329 1330 if (this._isTransitioning || !$__default["default"](this._element).hasClass(CLASS_NAME_SHOW$6)) { 1331 return; 1332 } 1333 1334 var startEvent = $__default["default"].Event(EVENT_HIDE$4); 1335 $__default["default"](this._element).trigger(startEvent); 1336 1337 if (startEvent.isDefaultPrevented()) { 1338 return; 1339 } 1340 1341 var dimension = this._getDimension(); 1342 1343 this._element.style[dimension] = this._element.getBoundingClientRect()[dimension] + "px"; 1344 Util.reflow(this._element); 1345 $__default["default"](this._element).addClass(CLASS_NAME_COLLAPSING).removeClass(CLASS_NAME_COLLAPSE + " " + CLASS_NAME_SHOW$6); 1346 var triggerArrayLength = this._triggerArray.length; 1347 1348 if (triggerArrayLength > 0) { 1349 for (var i = 0; i < triggerArrayLength; i++) { 1350 var trigger = this._triggerArray[i]; 1351 var selector = Util.getSelectorFromElement(trigger); 1352 1353 if (selector !== null) { 1354 var $elem = $__default["default"]([].slice.call(document.querySelectorAll(selector))); 1355 1356 if (!$elem.hasClass(CLASS_NAME_SHOW$6)) { 1357 $__default["default"](trigger).addClass(CLASS_NAME_COLLAPSED).attr('aria-expanded', false); 1358 } 1359 } 1360 } 1361 } 1362 1363 this.setTransitioning(true); 1364 1365 var complete = function complete() { 1366 _this2.setTransitioning(false); 1367 1368 $__default["default"](_this2._element).removeClass(CLASS_NAME_COLLAPSING).addClass(CLASS_NAME_COLLAPSE).trigger(EVENT_HIDDEN$4); 1369 }; 1370 1371 this._element.style[dimension] = ''; 1372 var transitionDuration = Util.getTransitionDurationFromElement(this._element); 1373 $__default["default"](this._element).one(Util.TRANSITION_END, complete).emulateTransitionEnd(transitionDuration); 1374 }; 1375 1376 _proto.setTransitioning = function setTransitioning(isTransitioning) { 1377 this._isTransitioning = isTransitioning; 1378 }; 1379 1380 _proto.dispose = function dispose() { 1381 $__default["default"].removeData(this._element, DATA_KEY$7); 1382 this._config = null; 1383 this._parent = null; 1384 this._element = null; 1385 this._triggerArray = null; 1386 this._isTransitioning = null; 1387 } // Private 1388 ; 1389 1390 _proto._getConfig = function _getConfig(config) { 1391 config = _extends({}, Default$6, config); 1392 config.toggle = Boolean(config.toggle); // Coerce string values 1393 1394 Util.typeCheckConfig(NAME$7, config, DefaultType$6); 1395 return config; 1396 }; 1397 1398 _proto._getDimension = function _getDimension() { 1399 var hasWidth = $__default["default"](this._element).hasClass(DIMENSION_WIDTH); 1400 return hasWidth ? DIMENSION_WIDTH : DIMENSION_HEIGHT; 1401 }; 1402 1403 _proto._getParent = function _getParent() { 1404 var _this3 = this; 1405 1406 var parent; 1407 1408 if (Util.isElement(this._config.parent)) { 1409 parent = this._config.parent; // It's a jQuery object 1410 1411 if (typeof this._config.parent.jquery !== 'undefined') { 1412 parent = this._config.parent[0]; 1413 } 1414 } else { 1415 parent = document.querySelector(this._config.parent); 1416 } 1417 1418 var selector = "[data-toggle=\"collapse\"][data-parent=\"" + this._config.parent + "\"]"; 1419 var children = [].slice.call(parent.querySelectorAll(selector)); 1420 $__default["default"](children).each(function (i, element) { 1421 _this3._addAriaAndCollapsedClass(Collapse._getTargetFromElement(element), [element]); 1422 }); 1423 return parent; 1424 }; 1425 1426 _proto._addAriaAndCollapsedClass = function _addAriaAndCollapsedClass(element, triggerArray) { 1427 var isOpen = $__default["default"](element).hasClass(CLASS_NAME_SHOW$6); 1428 1429 if (triggerArray.length) { 1430 $__default["default"](triggerArray).toggleClass(CLASS_NAME_COLLAPSED, !isOpen).attr('aria-expanded', isOpen); 1431 } 1432 } // Static 1433 ; 1434 1435 Collapse._getTargetFromElement = function _getTargetFromElement(element) { 1436 var selector = Util.getSelectorFromElement(element); 1437 return selector ? document.querySelector(selector) : null; 1438 }; 1439 1440 Collapse._jQueryInterface = function _jQueryInterface(config) { 1441 return this.each(function () { 1442 var $element = $__default["default"](this); 1443 var data = $element.data(DATA_KEY$7); 1444 1445 var _config = _extends({}, Default$6, $element.data(), typeof config === 'object' && config ? config : {}); 1446 1447 if (!data && _config.toggle && typeof config === 'string' && /show|hide/.test(config)) { 1448 _config.toggle = false; 1449 } 1450 1451 if (!data) { 1452 data = new Collapse(this, _config); 1453 $element.data(DATA_KEY$7, data); 1454 } 1455 1456 if (typeof config === 'string') { 1457 if (typeof data[config] === 'undefined') { 1458 throw new TypeError("No method named \"" + config + "\""); 1459 } 1460 1461 data[config](); 1462 } 1463 }); 1464 }; 1465 1466 _createClass(Collapse, null, [{ 1467 key: "VERSION", 1468 get: function get() { 1469 return VERSION$7; 1470 } 1471 }, { 1472 key: "Default", 1473 get: function get() { 1474 return Default$6; 1475 } 1476 }]); 1477 1478 return Collapse; 1479 }(); 1480 /** 1481 * Data API implementation 1482 */ 1483 1484 1485 $__default["default"](document).on(EVENT_CLICK_DATA_API$3, SELECTOR_DATA_TOGGLE$3, function (event) { 1486 // preventDefault only for <a> elements (which change the URL) not inside the collapsible element 1487 if (event.currentTarget.tagName === 'A') { 1488 event.preventDefault(); 1489 } 1490 1491 var $trigger = $__default["default"](this); 1492 var selector = Util.getSelectorFromElement(this); 1493 var selectors = [].slice.call(document.querySelectorAll(selector)); 1494 $__default["default"](selectors).each(function () { 1495 var $target = $__default["default"](this); 1496 var data = $target.data(DATA_KEY$7); 1497 var config = data ? 'toggle' : $trigger.data(); 1498 1499 Collapse._jQueryInterface.call($target, config); 1500 }); 1501 }); 1502 /** 1503 * jQuery 1504 */ 1505 1506 $__default["default"].fn[NAME$7] = Collapse._jQueryInterface; 1507 $__default["default"].fn[NAME$7].Constructor = Collapse; 1508 1509 $__default["default"].fn[NAME$7].noConflict = function () { 1510 $__default["default"].fn[NAME$7] = JQUERY_NO_CONFLICT$7; 1511 return Collapse._jQueryInterface; 1512 }; 1513 1514 /** 1515 * Constants 1516 */ 1517 1518 var NAME$6 = 'dropdown'; 1519 var VERSION$6 = '4.6.2'; 1520 var DATA_KEY$6 = 'bs.dropdown'; 1521 var EVENT_KEY$6 = "." + DATA_KEY$6; 1522 var DATA_API_KEY$3 = '.data-api'; 1523 var JQUERY_NO_CONFLICT$6 = $__default["default"].fn[NAME$6]; 1524 var ESCAPE_KEYCODE$1 = 27; // KeyboardEvent.which value for Escape (Esc) key 1525 1526 var SPACE_KEYCODE = 32; // KeyboardEvent.which value for space key 1527 1528 var TAB_KEYCODE = 9; // KeyboardEvent.which value for tab key 1529 1530 var ARROW_UP_KEYCODE = 38; // KeyboardEvent.which value for up arrow key 1531 1532 var ARROW_DOWN_KEYCODE = 40; // KeyboardEvent.which value for down arrow key 1533 1534 var RIGHT_MOUSE_BUTTON_WHICH = 3; // MouseEvent.which value for the right button (assuming a right-handed mouse) 1535 1536 var REGEXP_KEYDOWN = new RegExp(ARROW_UP_KEYCODE + "|" + ARROW_DOWN_KEYCODE + "|" + ESCAPE_KEYCODE$1); 1537 var CLASS_NAME_DISABLED$1 = 'disabled'; 1538 var CLASS_NAME_SHOW$5 = 'show'; 1539 var CLASS_NAME_DROPUP = 'dropup'; 1540 var CLASS_NAME_DROPRIGHT = 'dropright'; 1541 var CLASS_NAME_DROPLEFT = 'dropleft'; 1542 var CLASS_NAME_MENURIGHT = 'dropdown-menu-right'; 1543 var CLASS_NAME_POSITION_STATIC = 'position-static'; 1544 var EVENT_HIDE$3 = "hide" + EVENT_KEY$6; 1545 var EVENT_HIDDEN$3 = "hidden" + EVENT_KEY$6; 1546 var EVENT_SHOW$3 = "show" + EVENT_KEY$6; 1547 var EVENT_SHOWN$3 = "shown" + EVENT_KEY$6; 1548 var EVENT_CLICK = "click" + EVENT_KEY$6; 1549 var EVENT_CLICK_DATA_API$2 = "click" + EVENT_KEY$6 + DATA_API_KEY$3; 1550 var EVENT_KEYDOWN_DATA_API = "keydown" + EVENT_KEY$6 + DATA_API_KEY$3; 1551 var EVENT_KEYUP_DATA_API = "keyup" + EVENT_KEY$6 + DATA_API_KEY$3; 1552 var SELECTOR_DATA_TOGGLE$2 = '[data-toggle="dropdown"]'; 1553 var SELECTOR_FORM_CHILD = '.dropdown form'; 1554 var SELECTOR_MENU = '.dropdown-menu'; 1555 var SELECTOR_NAVBAR_NAV = '.navbar-nav'; 1556 var SELECTOR_VISIBLE_ITEMS = '.dropdown-menu .dropdown-item:not(.disabled):not(:disabled)'; 1557 var PLACEMENT_TOP = 'top-start'; 1558 var PLACEMENT_TOPEND = 'top-end'; 1559 var PLACEMENT_BOTTOM = 'bottom-start'; 1560 var PLACEMENT_BOTTOMEND = 'bottom-end'; 1561 var PLACEMENT_RIGHT = 'right-start'; 1562 var PLACEMENT_LEFT = 'left-start'; 1563 var Default$5 = { 1564 offset: 0, 1565 flip: true, 1566 boundary: 'scrollParent', 1567 reference: 'toggle', 1568 display: 'dynamic', 1569 popperConfig: null 1570 }; 1571 var DefaultType$5 = { 1572 offset: '(number|string|function)', 1573 flip: 'boolean', 1574 boundary: '(string|element)', 1575 reference: '(string|element)', 1576 display: 'string', 1577 popperConfig: '(null|object)' 1578 }; 1579 /** 1580 * Class definition 1581 */ 1582 1583 var Dropdown = /*#__PURE__*/function () { 1584 function Dropdown(element, config) { 1585 this._element = element; 1586 this._popper = null; 1587 this._config = this._getConfig(config); 1588 this._menu = this._getMenuElement(); 1589 this._inNavbar = this._detectNavbar(); 1590 1591 this._addEventListeners(); 1592 } // Getters 1593 1594 1595 var _proto = Dropdown.prototype; 1596 1597 // Public 1598 _proto.toggle = function toggle() { 1599 if (this._element.disabled || $__default["default"](this._element).hasClass(CLASS_NAME_DISABLED$1)) { 1600 return; 1601 } 1602 1603 var isActive = $__default["default"](this._menu).hasClass(CLASS_NAME_SHOW$5); 1604 1605 Dropdown._clearMenus(); 1606 1607 if (isActive) { 1608 return; 1609 } 1610 1611 this.show(true); 1612 }; 1613 1614 _proto.show = function show(usePopper) { 1615 if (usePopper === void 0) { 1616 usePopper = false; 1617 } 1618 1619 if (this._element.disabled || $__default["default"](this._element).hasClass(CLASS_NAME_DISABLED$1) || $__default["default"](this._menu).hasClass(CLASS_NAME_SHOW$5)) { 1620 return; 1621 } 1622 1623 var relatedTarget = { 1624 relatedTarget: this._element 1625 }; 1626 var showEvent = $__default["default"].Event(EVENT_SHOW$3, relatedTarget); 1627 1628 var parent = Dropdown._getParentFromElement(this._element); 1629 1630 $__default["default"](parent).trigger(showEvent); 1631 1632 if (showEvent.isDefaultPrevented()) { 1633 return; 1634 } // Totally disable Popper for Dropdowns in Navbar 1635 1636 1637 if (!this._inNavbar && usePopper) { 1638 // Check for Popper dependency 1639 if (typeof Popper__default["default"] === 'undefined') { 1640 throw new TypeError('Bootstrap\'s dropdowns require Popper (https://popper.js.org)'); 1641 } 1642 1643 var referenceElement = this._element; 1644 1645 if (this._config.reference === 'parent') { 1646 referenceElement = parent; 1647 } else if (Util.isElement(this._config.reference)) { 1648 referenceElement = this._config.reference; // Check if it's jQuery element 1649 1650 if (typeof this._config.reference.jquery !== 'undefined') { 1651 referenceElement = this._config.reference[0]; 1652 } 1653 } // If boundary is not `scrollParent`, then set position to `static` 1654 // to allow the menu to "escape" the scroll parent's boundaries 1655 // https://github.com/twbs/bootstrap/issues/24251 1656 1657 1658 if (this._config.boundary !== 'scrollParent') { 1659 $__default["default"](parent).addClass(CLASS_NAME_POSITION_STATIC); 1660 } 1661 1662 this._popper = new Popper__default["default"](referenceElement, this._menu, this._getPopperConfig()); 1663 } // If this is a touch-enabled device we add extra 1664 // empty mouseover listeners to the body's immediate children; 1665 // only needed because of broken event delegation on iOS 1666 // https://www.quirksmode.org/blog/archives/2014/02/mouse_event_bub.html 1667 1668 1669 if ('ontouchstart' in document.documentElement && $__default["default"](parent).closest(SELECTOR_NAVBAR_NAV).length === 0) { 1670 $__default["default"](document.body).children().on('mouseover', null, $__default["default"].noop); 1671 } 1672 1673 this._element.focus(); 1674 1675 this._element.setAttribute('aria-expanded', true); 1676 1677 $__default["default"](this._menu).toggleClass(CLASS_NAME_SHOW$5); 1678 $__default["default"](parent).toggleClass(CLASS_NAME_SHOW$5).trigger($__default["default"].Event(EVENT_SHOWN$3, relatedTarget)); 1679 }; 1680 1681 _proto.hide = function hide() { 1682 if (this._element.disabled || $__default["default"](this._element).hasClass(CLASS_NAME_DISABLED$1) || !$__default["default"](this._menu).hasClass(CLASS_NAME_SHOW$5)) { 1683 return; 1684 } 1685 1686 var relatedTarget = { 1687 relatedTarget: this._element 1688 }; 1689 var hideEvent = $__default["default"].Event(EVENT_HIDE$3, relatedTarget); 1690 1691 var parent = Dropdown._getParentFromElement(this._element); 1692 1693 $__default["default"](parent).trigger(hideEvent); 1694 1695 if (hideEvent.isDefaultPrevented()) { 1696 return; 1697 } 1698 1699 if (this._popper) { 1700 this._popper.destroy(); 1701 } 1702 1703 $__default["default"](this._menu).toggleClass(CLASS_NAME_SHOW$5); 1704 $__default["default"](parent).toggleClass(CLASS_NAME_SHOW$5).trigger($__default["default"].Event(EVENT_HIDDEN$3, relatedTarget)); 1705 }; 1706 1707 _proto.dispose = function dispose() { 1708 $__default["default"].removeData(this._element, DATA_KEY$6); 1709 $__default["default"](this._element).off(EVENT_KEY$6); 1710 this._element = null; 1711 this._menu = null; 1712 1713 if (this._popper !== null) { 1714 this._popper.destroy(); 1715 1716 this._popper = null; 1717 } 1718 }; 1719 1720 _proto.update = function update() { 1721 this._inNavbar = this._detectNavbar(); 1722 1723 if (this._popper !== null) { 1724 this._popper.scheduleUpdate(); 1725 } 1726 } // Private 1727 ; 1728 1729 _proto._addEventListeners = function _addEventListeners() { 1730 var _this = this; 1731 1732 $__default["default"](this._element).on(EVENT_CLICK, function (event) { 1733 event.preventDefault(); 1734 event.stopPropagation(); 1735 1736 _this.toggle(); 1737 }); 1738 }; 1739 1740 _proto._getConfig = function _getConfig(config) { 1741 config = _extends({}, this.constructor.Default, $__default["default"](this._element).data(), config); 1742 Util.typeCheckConfig(NAME$6, config, this.constructor.DefaultType); 1743 return config; 1744 }; 1745 1746 _proto._getMenuElement = function _getMenuElement() { 1747 if (!this._menu) { 1748 var parent = Dropdown._getParentFromElement(this._element); 1749 1750 if (parent) { 1751 this._menu = parent.querySelector(SELECTOR_MENU); 1752 } 1753 } 1754 1755 return this._menu; 1756 }; 1757 1758 _proto._getPlacement = function _getPlacement() { 1759 var $parentDropdown = $__default["default"](this._element.parentNode); 1760 var placement = PLACEMENT_BOTTOM; // Handle dropup 1761 1762 if ($parentDropdown.hasClass(CLASS_NAME_DROPUP)) { 1763 placement = $__default["default"](this._menu).hasClass(CLASS_NAME_MENURIGHT) ? PLACEMENT_TOPEND : PLACEMENT_TOP; 1764 } else if ($parentDropdown.hasClass(CLASS_NAME_DROPRIGHT)) { 1765 placement = PLACEMENT_RIGHT; 1766 } else if ($parentDropdown.hasClass(CLASS_NAME_DROPLEFT)) { 1767 placement = PLACEMENT_LEFT; 1768 } else if ($__default["default"](this._menu).hasClass(CLASS_NAME_MENURIGHT)) { 1769 placement = PLACEMENT_BOTTOMEND; 1770 } 1771 1772 return placement; 1773 }; 1774 1775 _proto._detectNavbar = function _detectNavbar() { 1776 return $__default["default"](this._element).closest('.navbar').length > 0; 1777 }; 1778 1779 _proto._getOffset = function _getOffset() { 1780 var _this2 = this; 1781 1782 var offset = {}; 1783 1784 if (typeof this._config.offset === 'function') { 1785 offset.fn = function (data) { 1786 data.offsets = _extends({}, data.offsets, _this2._config.offset(data.offsets, _this2._element)); 1787 return data; 1788 }; 1789 } else { 1790 offset.offset = this._config.offset; 1791 } 1792 1793 return offset; 1794 }; 1795 1796 _proto._getPopperConfig = function _getPopperConfig() { 1797 var popperConfig = { 1798 placement: this._getPlacement(), 1799 modifiers: { 1800 offset: this._getOffset(), 1801 flip: { 1802 enabled: this._config.flip 1803 }, 1804 preventOverflow: { 1805 boundariesElement: this._config.boundary 1806 } 1807 } 1808 }; // Disable Popper if we have a static display 1809 1810 if (this._config.display === 'static') { 1811 popperConfig.modifiers.applyStyle = { 1812 enabled: false 1813 }; 1814 } 1815 1816 return _extends({}, popperConfig, this._config.popperConfig); 1817 } // Static 1818 ; 1819 1820 Dropdown._jQueryInterface = function _jQueryInterface(config) { 1821 return this.each(function () { 1822 var data = $__default["default"](this).data(DATA_KEY$6); 1823 1824 var _config = typeof config === 'object' ? config : null; 1825 1826 if (!data) { 1827 data = new Dropdown(this, _config); 1828 $__default["default"](this).data(DATA_KEY$6, data); 1829 } 1830 1831 if (typeof config === 'string') { 1832 if (typeof data[config] === 'undefined') { 1833 throw new TypeError("No method named \"" + config + "\""); 1834 } 1835 1836 data[config](); 1837 } 1838 }); 1839 }; 1840 1841 Dropdown._clearMenus = function _clearMenus(event) { 1842 if (event && (event.which === RIGHT_MOUSE_BUTTON_WHICH || event.type === 'keyup' && event.which !== TAB_KEYCODE)) { 1843 return; 1844 } 1845 1846 var toggles = [].slice.call(document.querySelectorAll(SELECTOR_DATA_TOGGLE$2)); 1847 1848 for (var i = 0, len = toggles.length; i < len; i++) { 1849 var parent = Dropdown._getParentFromElement(toggles[i]); 1850 1851 var context = $__default["default"](toggles[i]).data(DATA_KEY$6); 1852 var relatedTarget = { 1853 relatedTarget: toggles[i] 1854 }; 1855 1856 if (event && event.type === 'click') { 1857 relatedTarget.clickEvent = event; 1858 } 1859 1860 if (!context) { 1861 continue; 1862 } 1863 1864 var dropdownMenu = context._menu; 1865 1866 if (!$__default["default"](parent).hasClass(CLASS_NAME_SHOW$5)) { 1867 continue; 1868 } 1869 1870 if (event && (event.type === 'click' && /input|textarea/i.test(event.target.tagName) || event.type === 'keyup' && event.which === TAB_KEYCODE) && $__default["default"].contains(parent, event.target)) { 1871 continue; 1872 } 1873 1874 var hideEvent = $__default["default"].Event(EVENT_HIDE$3, relatedTarget); 1875 $__default["default"](parent).trigger(hideEvent); 1876 1877 if (hideEvent.isDefaultPrevented()) { 1878 continue; 1879 } // If this is a touch-enabled device we remove the extra 1880 // empty mouseover listeners we added for iOS support 1881 1882 1883 if ('ontouchstart' in document.documentElement) { 1884 $__default["default"](document.body).children().off('mouseover', null, $__default["default"].noop); 1885 } 1886 1887 toggles[i].setAttribute('aria-expanded', 'false'); 1888 1889 if (context._popper) { 1890 context._popper.destroy(); 1891 } 1892 1893 $__default["default"](dropdownMenu).removeClass(CLASS_NAME_SHOW$5); 1894 $__default["default"](parent).removeClass(CLASS_NAME_SHOW$5).trigger($__default["default"].Event(EVENT_HIDDEN$3, relatedTarget)); 1895 } 1896 }; 1897 1898 Dropdown._getParentFromElement = function _getParentFromElement(element) { 1899 var parent; 1900 var selector = Util.getSelectorFromElement(element); 1901 1902 if (selector) { 1903 parent = document.querySelector(selector); 1904 } 1905 1906 return parent || element.parentNode; 1907 } // eslint-disable-next-line complexity 1908 ; 1909 1910 Dropdown._dataApiKeydownHandler = function _dataApiKeydownHandler(event) { 1911 // If not input/textarea: 1912 // - And not a key in REGEXP_KEYDOWN => not a dropdown command 1913 // If input/textarea: 1914 // - If space key => not a dropdown command 1915 // - If key is other than escape 1916 // - If key is not up or down => not a dropdown command 1917 // - If trigger inside the menu => not a dropdown command 1918 if (/input|textarea/i.test(event.target.tagName) ? event.which === SPACE_KEYCODE || event.which !== ESCAPE_KEYCODE$1 && (event.which !== ARROW_DOWN_KEYCODE && event.which !== ARROW_UP_KEYCODE || $__default["default"](event.target).closest(SELECTOR_MENU).length) : !REGEXP_KEYDOWN.test(event.which)) { 1919 return; 1920 } 1921 1922 if (this.disabled || $__default["default"](this).hasClass(CLASS_NAME_DISABLED$1)) { 1923 return; 1924 } 1925 1926 var parent = Dropdown._getParentFromElement(this); 1927 1928 var isActive = $__default["default"](parent).hasClass(CLASS_NAME_SHOW$5); 1929 1930 if (!isActive && event.which === ESCAPE_KEYCODE$1) { 1931 return; 1932 } 1933 1934 event.preventDefault(); 1935 event.stopPropagation(); 1936 1937 if (!isActive || event.which === ESCAPE_KEYCODE$1 || event.which === SPACE_KEYCODE) { 1938 if (event.which === ESCAPE_KEYCODE$1) { 1939 $__default["default"](parent.querySelector(SELECTOR_DATA_TOGGLE$2)).trigger('focus'); 1940 } 1941 1942 $__default["default"](this).trigger('click'); 1943 return; 1944 } 1945 1946 var items = [].slice.call(parent.querySelectorAll(SELECTOR_VISIBLE_ITEMS)).filter(function (item) { 1947 return $__default["default"](item).is(':visible'); 1948 }); 1949 1950 if (items.length === 0) { 1951 return; 1952 } 1953 1954 var index = items.indexOf(event.target); 1955 1956 if (event.which === ARROW_UP_KEYCODE && index > 0) { 1957 // Up 1958 index--; 1959 } 1960 1961 if (event.which === ARROW_DOWN_KEYCODE && index < items.length - 1) { 1962 // Down 1963 index++; 1964 } 1965 1966 if (index < 0) { 1967 index = 0; 1968 } 1969 1970 items[index].focus(); 1971 }; 1972 1973 _createClass(Dropdown, null, [{ 1974 key: "VERSION", 1975 get: function get() { 1976 return VERSION$6; 1977 } 1978 }, { 1979 key: "Default", 1980 get: function get() { 1981 return Default$5; 1982 } 1983 }, { 1984 key: "DefaultType", 1985 get: function get() { 1986 return DefaultType$5; 1987 } 1988 }]); 1989 1990 return Dropdown; 1991 }(); 1992 /** 1993 * Data API implementation 1994 */ 1995 1996 1997 $__default["default"](document).on(EVENT_KEYDOWN_DATA_API, SELECTOR_DATA_TOGGLE$2, Dropdown._dataApiKeydownHandler).on(EVENT_KEYDOWN_DATA_API, SELECTOR_MENU, Dropdown._dataApiKeydownHandler).on(EVENT_CLICK_DATA_API$2 + " " + EVENT_KEYUP_DATA_API, Dropdown._clearMenus).on(EVENT_CLICK_DATA_API$2, SELECTOR_DATA_TOGGLE$2, function (event) { 1998 event.preventDefault(); 1999 event.stopPropagation(); 2000 2001 Dropdown._jQueryInterface.call($__default["default"](this), 'toggle'); 2002 }).on(EVENT_CLICK_DATA_API$2, SELECTOR_FORM_CHILD, function (e) { 2003 e.stopPropagation(); 2004 }); 2005 /** 2006 * jQuery 2007 */ 2008 2009 $__default["default"].fn[NAME$6] = Dropdown._jQueryInterface; 2010 $__default["default"].fn[NAME$6].Constructor = Dropdown; 2011 2012 $__default["default"].fn[NAME$6].noConflict = function () { 2013 $__default["default"].fn[NAME$6] = JQUERY_NO_CONFLICT$6; 2014 return Dropdown._jQueryInterface; 2015 }; 2016 2017 /** 2018 * Constants 2019 */ 2020 2021 var NAME$5 = 'modal'; 2022 var VERSION$5 = '4.6.2'; 2023 var DATA_KEY$5 = 'bs.modal'; 2024 var EVENT_KEY$5 = "." + DATA_KEY$5; 2025 var DATA_API_KEY$2 = '.data-api'; 2026 var JQUERY_NO_CONFLICT$5 = $__default["default"].fn[NAME$5]; 2027 var ESCAPE_KEYCODE = 27; // KeyboardEvent.which value for Escape (Esc) key 2028 2029 var CLASS_NAME_SCROLLABLE = 'modal-dialog-scrollable'; 2030 var CLASS_NAME_SCROLLBAR_MEASURER = 'modal-scrollbar-measure'; 2031 var CLASS_NAME_BACKDROP = 'modal-backdrop'; 2032 var CLASS_NAME_OPEN = 'modal-open'; 2033 var CLASS_NAME_FADE$4 = 'fade'; 2034 var CLASS_NAME_SHOW$4 = 'show'; 2035 var CLASS_NAME_STATIC = 'modal-static'; 2036 var EVENT_HIDE$2 = "hide" + EVENT_KEY$5; 2037 var EVENT_HIDE_PREVENTED = "hidePrevented" + EVENT_KEY$5; 2038 var EVENT_HIDDEN$2 = "hidden" + EVENT_KEY$5; 2039 var EVENT_SHOW$2 = "show" + EVENT_KEY$5; 2040 var EVENT_SHOWN$2 = "shown" + EVENT_KEY$5; 2041 var EVENT_FOCUSIN = "focusin" + EVENT_KEY$5; 2042 var EVENT_RESIZE = "resize" + EVENT_KEY$5; 2043 var EVENT_CLICK_DISMISS$1 = "click.dismiss" + EVENT_KEY$5; 2044 var EVENT_KEYDOWN_DISMISS = "keydown.dismiss" + EVENT_KEY$5; 2045 var EVENT_MOUSEUP_DISMISS = "mouseup.dismiss" + EVENT_KEY$5; 2046 var EVENT_MOUSEDOWN_DISMISS = "mousedown.dismiss" + EVENT_KEY$5; 2047 var EVENT_CLICK_DATA_API$1 = "click" + EVENT_KEY$5 + DATA_API_KEY$2; 2048 var SELECTOR_DIALOG = '.modal-dialog'; 2049 var SELECTOR_MODAL_BODY = '.modal-body'; 2050 var SELECTOR_DATA_TOGGLE$1 = '[data-toggle="modal"]'; 2051 var SELECTOR_DATA_DISMISS$1 = '[data-dismiss="modal"]'; 2052 var SELECTOR_FIXED_CONTENT = '.fixed-top, .fixed-bottom, .is-fixed, .sticky-top'; 2053 var SELECTOR_STICKY_CONTENT = '.sticky-top'; 2054 var Default$4 = { 2055 backdrop: true, 2056 keyboard: true, 2057 focus: true, 2058 show: true 2059 }; 2060 var DefaultType$4 = { 2061 backdrop: '(boolean|string)', 2062 keyboard: 'boolean', 2063 focus: 'boolean', 2064 show: 'boolean' 2065 }; 2066 /** 2067 * Class definition 2068 */ 2069 2070 var Modal = /*#__PURE__*/function () { 2071 function Modal(element, config) { 2072 this._config = this._getConfig(config); 2073 this._element = element; 2074 this._dialog = element.querySelector(SELECTOR_DIALOG); 2075 this._backdrop = null; 2076 this._isShown = false; 2077 this._isBodyOverflowing = false; 2078 this._ignoreBackdropClick = false; 2079 this._isTransitioning = false; 2080 this._scrollbarWidth = 0; 2081 } // Getters 2082 2083 2084 var _proto = Modal.prototype; 2085 2086 // Public 2087 _proto.toggle = function toggle(relatedTarget) { 2088 return this._isShown ? this.hide() : this.show(relatedTarget); 2089 }; 2090 2091 _proto.show = function show(relatedTarget) { 2092 var _this = this; 2093 2094 if (this._isShown || this._isTransitioning) { 2095 return; 2096 } 2097 2098 var showEvent = $__default["default"].Event(EVENT_SHOW$2, { 2099 relatedTarget: relatedTarget 2100 }); 2101 $__default["default"](this._element).trigger(showEvent); 2102 2103 if (showEvent.isDefaultPrevented()) { 2104 return; 2105 } 2106 2107 this._isShown = true; 2108 2109 if ($__default["default"](this._element).hasClass(CLASS_NAME_FADE$4)) { 2110 this._isTransitioning = true; 2111 } 2112 2113 this._checkScrollbar(); 2114 2115 this._setScrollbar(); 2116 2117 this._adjustDialog(); 2118 2119 this._setEscapeEvent(); 2120 2121 this._setResizeEvent(); 2122 2123 $__default["default"](this._element).on(EVENT_CLICK_DISMISS$1, SELECTOR_DATA_DISMISS$1, function (event) { 2124 return _this.hide(event); 2125 }); 2126 $__default["default"](this._dialog).on(EVENT_MOUSEDOWN_DISMISS, function () { 2127 $__default["default"](_this._element).one(EVENT_MOUSEUP_DISMISS, function (event) { 2128 if ($__default["default"](event.target).is(_this._element)) { 2129 _this._ignoreBackdropClick = true; 2130 } 2131 }); 2132 }); 2133 2134 this._showBackdrop(function () { 2135 return _this._showElement(relatedTarget); 2136 }); 2137 }; 2138 2139 _proto.hide = function hide(event) { 2140 var _this2 = this; 2141 2142 if (event) { 2143 event.preventDefault(); 2144 } 2145 2146 if (!this._isShown || this._isTransitioning) { 2147 return; 2148 } 2149 2150 var hideEvent = $__default["default"].Event(EVENT_HIDE$2); 2151 $__default["default"](this._element).trigger(hideEvent); 2152 2153 if (!this._isShown || hideEvent.isDefaultPrevented()) { 2154 return; 2155 } 2156 2157 this._isShown = false; 2158 var transition = $__default["default"](this._element).hasClass(CLASS_NAME_FADE$4); 2159 2160 if (transition) { 2161 this._isTransitioning = true; 2162 } 2163 2164 this._setEscapeEvent(); 2165 2166 this._setResizeEvent(); 2167 2168 $__default["default"](document).off(EVENT_FOCUSIN); 2169 $__default["default"](this._element).removeClass(CLASS_NAME_SHOW$4); 2170 $__default["default"](this._element).off(EVENT_CLICK_DISMISS$1); 2171 $__default["default"](this._dialog).off(EVENT_MOUSEDOWN_DISMISS); 2172 2173 if (transition) { 2174 var transitionDuration = Util.getTransitionDurationFromElement(this._element); 2175 $__default["default"](this._element).one(Util.TRANSITION_END, function (event) { 2176 return _this2._hideModal(event); 2177 }).emulateTransitionEnd(transitionDuration); 2178 } else { 2179 this._hideModal(); 2180 } 2181 }; 2182 2183 _proto.dispose = function dispose() { 2184 [window, this._element, this._dialog].forEach(function (htmlElement) { 2185 return $__default["default"](htmlElement).off(EVENT_KEY$5); 2186 }); 2187 /** 2188 * `document` has 2 events `EVENT_FOCUSIN` and `EVENT_CLICK_DATA_API` 2189 * Do not move `document` in `htmlElements` array 2190 * It will remove `EVENT_CLICK_DATA_API` event that should remain 2191 */ 2192 2193 $__default["default"](document).off(EVENT_FOCUSIN); 2194 $__default["default"].removeData(this._element, DATA_KEY$5); 2195 this._config = null; 2196 this._element = null; 2197 this._dialog = null; 2198 this._backdrop = null; 2199 this._isShown = null; 2200 this._isBodyOverflowing = null; 2201 this._ignoreBackdropClick = null; 2202 this._isTransitioning = null; 2203 this._scrollbarWidth = null; 2204 }; 2205 2206 _proto.handleUpdate = function handleUpdate() { 2207 this._adjustDialog(); 2208 } // Private 2209 ; 2210 2211 _proto._getConfig = function _getConfig(config) { 2212 config = _extends({}, Default$4, config); 2213 Util.typeCheckConfig(NAME$5, config, DefaultType$4); 2214 return config; 2215 }; 2216 2217 _proto._triggerBackdropTransition = function _triggerBackdropTransition() { 2218 var _this3 = this; 2219 2220 var hideEventPrevented = $__default["default"].Event(EVENT_HIDE_PREVENTED); 2221 $__default["default"](this._element).trigger(hideEventPrevented); 2222 2223 if (hideEventPrevented.isDefaultPrevented()) { 2224 return; 2225 } 2226 2227 var isModalOverflowing = this._element.scrollHeight > document.documentElement.clientHeight; 2228 2229 if (!isModalOverflowing) { 2230 this._element.style.overflowY = 'hidden'; 2231 } 2232 2233 this._element.classList.add(CLASS_NAME_STATIC); 2234 2235 var modalTransitionDuration = Util.getTransitionDurationFromElement(this._dialog); 2236 $__default["default"](this._element).off(Util.TRANSITION_END); 2237 $__default["default"](this._element).one(Util.TRANSITION_END, function () { 2238 _this3._element.classList.remove(CLASS_NAME_STATIC); 2239 2240 if (!isModalOverflowing) { 2241 $__default["default"](_this3._element).one(Util.TRANSITION_END, function () { 2242 _this3._element.style.overflowY = ''; 2243 }).emulateTransitionEnd(_this3._element, modalTransitionDuration); 2244 } 2245 }).emulateTransitionEnd(modalTransitionDuration); 2246 2247 this._element.focus(); 2248 }; 2249 2250 _proto._showElement = function _showElement(relatedTarget) { 2251 var _this4 = this; 2252 2253 var transition = $__default["default"](this._element).hasClass(CLASS_NAME_FADE$4); 2254 var modalBody = this._dialog ? this._dialog.querySelector(SELECTOR_MODAL_BODY) : null; 2255 2256 if (!this._element.parentNode || this._element.parentNode.nodeType !== Node.ELEMENT_NODE) { 2257 // Don't move modal's DOM position 2258 document.body.appendChild(this._element); 2259 } 2260 2261 this._element.style.display = 'block'; 2262 2263 this._element.removeAttribute('aria-hidden'); 2264 2265 this._element.setAttribute('aria-modal', true); 2266 2267 this._element.setAttribute('role', 'dialog'); 2268 2269 if ($__default["default"](this._dialog).hasClass(CLASS_NAME_SCROLLABLE) && modalBody) { 2270 modalBody.scrollTop = 0; 2271 } else { 2272 this._element.scrollTop = 0; 2273 } 2274 2275 if (transition) { 2276 Util.reflow(this._element); 2277 } 2278 2279 $__default["default"](this._element).addClass(CLASS_NAME_SHOW$4); 2280 2281 if (this._config.focus) { 2282 this._enforceFocus(); 2283 } 2284 2285 var shownEvent = $__default["default"].Event(EVENT_SHOWN$2, { 2286 relatedTarget: relatedTarget 2287 }); 2288 2289 var transitionComplete = function transitionComplete() { 2290 if (_this4._config.focus) { 2291 _this4._element.focus(); 2292 } 2293 2294 _this4._isTransitioning = false; 2295 $__default["default"](_this4._element).trigger(shownEvent); 2296 }; 2297 2298 if (transition) { 2299 var transitionDuration = Util.getTransitionDurationFromElement(this._dialog); 2300 $__default["default"](this._dialog).one(Util.TRANSITION_END, transitionComplete).emulateTransitionEnd(transitionDuration); 2301 } else { 2302 transitionComplete(); 2303 } 2304 }; 2305 2306 _proto._enforceFocus = function _enforceFocus() { 2307 var _this5 = this; 2308 2309 $__default["default"](document).off(EVENT_FOCUSIN) // Guard against infinite focus loop 2310 .on(EVENT_FOCUSIN, function (event) { 2311 if (document !== event.target && _this5._element !== event.target && $__default["default"](_this5._element).has(event.target).length === 0) { 2312 _this5._element.focus(); 2313 } 2314 }); 2315 }; 2316 2317 _proto._setEscapeEvent = function _setEscapeEvent() { 2318 var _this6 = this; 2319 2320 if (this._isShown) { 2321 $__default["default"](this._element).on(EVENT_KEYDOWN_DISMISS, function (event) { 2322 if (_this6._config.keyboard && event.which === ESCAPE_KEYCODE) { 2323 event.preventDefault(); 2324 2325 _this6.hide(); 2326 } else if (!_this6._config.keyboard && event.which === ESCAPE_KEYCODE) { 2327 _this6._triggerBackdropTransition(); 2328 } 2329 }); 2330 } else if (!this._isShown) { 2331 $__default["default"](this._element).off(EVENT_KEYDOWN_DISMISS); 2332 } 2333 }; 2334 2335 _proto._setResizeEvent = function _setResizeEvent() { 2336 var _this7 = this; 2337 2338 if (this._isShown) { 2339 $__default["default"](window).on(EVENT_RESIZE, function (event) { 2340 return _this7.handleUpdate(event); 2341 }); 2342 } else { 2343 $__default["default"](window).off(EVENT_RESIZE); 2344 } 2345 }; 2346 2347 _proto._hideModal = function _hideModal() { 2348 var _this8 = this; 2349 2350 this._element.style.display = 'none'; 2351 2352 this._element.setAttribute('aria-hidden', true); 2353 2354 this._element.removeAttribute('aria-modal'); 2355 2356 this._element.removeAttribute('role'); 2357 2358 this._isTransitioning = false; 2359 2360 this._showBackdrop(function () { 2361 $__default["default"](document.body).removeClass(CLASS_NAME_OPEN); 2362 2363 _this8._resetAdjustments(); 2364 2365 _this8._resetScrollbar(); 2366 2367 $__default["default"](_this8._element).trigger(EVENT_HIDDEN$2); 2368 }); 2369 }; 2370 2371 _proto._removeBackdrop = function _removeBackdrop() { 2372 if (this._backdrop) { 2373 $__default["default"](this._backdrop).remove(); 2374 this._backdrop = null; 2375 } 2376 }; 2377 2378 _proto._showBackdrop = function _showBackdrop(callback) { 2379 var _this9 = this; 2380 2381 var animate = $__default["default"](this._element).hasClass(CLASS_NAME_FADE$4) ? CLASS_NAME_FADE$4 : ''; 2382 2383 if (this._isShown && this._config.backdrop) { 2384 this._backdrop = document.createElement('div'); 2385 this._backdrop.className = CLASS_NAME_BACKDROP; 2386 2387 if (animate) { 2388 this._backdrop.classList.add(animate); 2389 } 2390 2391 $__default["default"](this._backdrop).appendTo(document.body); 2392 $__default["default"](this._element).on(EVENT_CLICK_DISMISS$1, function (event) { 2393 if (_this9._ignoreBackdropClick) { 2394 _this9._ignoreBackdropClick = false; 2395 return; 2396 } 2397 2398 if (event.target !== event.currentTarget) { 2399 return; 2400 } 2401 2402 if (_this9._config.backdrop === 'static') { 2403 _this9._triggerBackdropTransition(); 2404 } else { 2405 _this9.hide(); 2406 } 2407 }); 2408 2409 if (animate) { 2410 Util.reflow(this._backdrop); 2411 } 2412 2413 $__default["default"](this._backdrop).addClass(CLASS_NAME_SHOW$4); 2414 2415 if (!callback) { 2416 return; 2417 } 2418 2419 if (!animate) { 2420 callback(); 2421 return; 2422 } 2423 2424 var backdropTransitionDuration = Util.getTransitionDurationFromElement(this._backdrop); 2425 $__default["default"](this._backdrop).one(Util.TRANSITION_END, callback).emulateTransitionEnd(backdropTransitionDuration); 2426 } else if (!this._isShown && this._backdrop) { 2427 $__default["default"](this._backdrop).removeClass(CLASS_NAME_SHOW$4); 2428 2429 var callbackRemove = function callbackRemove() { 2430 _this9._removeBackdrop(); 2431 2432 if (callback) { 2433 callback(); 2434 } 2435 }; 2436 2437 if ($__default["default"](this._element).hasClass(CLASS_NAME_FADE$4)) { 2438 var _backdropTransitionDuration = Util.getTransitionDurationFromElement(this._backdrop); 2439 2440 $__default["default"](this._backdrop).one(Util.TRANSITION_END, callbackRemove).emulateTransitionEnd(_backdropTransitionDuration); 2441 } else { 2442 callbackRemove(); 2443 } 2444 } else if (callback) { 2445 callback(); 2446 } 2447 } // ---------------------------------------------------------------------- 2448 // the following methods are used to handle overflowing modals 2449 // todo (fat): these should probably be refactored out of modal.js 2450 // ---------------------------------------------------------------------- 2451 ; 2452 2453 _proto._adjustDialog = function _adjustDialog() { 2454 var isModalOverflowing = this._element.scrollHeight > document.documentElement.clientHeight; 2455 2456 if (!this._isBodyOverflowing && isModalOverflowing) { 2457 this._element.style.paddingLeft = this._scrollbarWidth + "px"; 2458 } 2459 2460 if (this._isBodyOverflowing && !isModalOverflowing) { 2461 this._element.style.paddingRight = this._scrollbarWidth + "px"; 2462 } 2463 }; 2464 2465 _proto._resetAdjustments = function _resetAdjustments() { 2466 this._element.style.paddingLeft = ''; 2467 this._element.style.paddingRight = ''; 2468 }; 2469 2470 _proto._checkScrollbar = function _checkScrollbar() { 2471 var rect = document.body.getBoundingClientRect(); 2472 this._isBodyOverflowing = Math.round(rect.left + rect.right) < window.innerWidth; 2473 this._scrollbarWidth = this._getScrollbarWidth(); 2474 }; 2475 2476 _proto._setScrollbar = function _setScrollbar() { 2477 var _this10 = this; 2478 2479 if (this._isBodyOverflowing) { 2480 // Note: DOMNode.style.paddingRight returns the actual value or '' if not set 2481 // while $(DOMNode).css('padding-right') returns the calculated value or 0 if not set 2482 var fixedContent = [].slice.call(document.querySelectorAll(SELECTOR_FIXED_CONTENT)); 2483 var stickyContent = [].slice.call(document.querySelectorAll(SELECTOR_STICKY_CONTENT)); // Adjust fixed content padding 2484 2485 $__default["default"](fixedContent).each(function (index, element) { 2486 var actualPadding = element.style.paddingRight; 2487 var calculatedPadding = $__default["default"](element).css('padding-right'); 2488 $__default["default"](element).data('padding-right', actualPadding).css('padding-right', parseFloat(calculatedPadding) + _this10._scrollbarWidth + "px"); 2489 }); // Adjust sticky content margin 2490 2491 $__default["default"](stickyContent).each(function (index, element) { 2492 var actualMargin = element.style.marginRight; 2493 var calculatedMargin = $__default["default"](element).css('margin-right'); 2494 $__default["default"](element).data('margin-right', actualMargin).css('margin-right', parseFloat(calculatedMargin) - _this10._scrollbarWidth + "px"); 2495 }); // Adjust body padding 2496 2497 var actualPadding = document.body.style.paddingRight; 2498 var calculatedPadding = $__default["default"](document.body).css('padding-right'); 2499 $__default["default"](document.body).data('padding-right', actualPadding).css('padding-right', parseFloat(calculatedPadding) + this._scrollbarWidth + "px"); 2500 } 2501 2502 $__default["default"](document.body).addClass(CLASS_NAME_OPEN); 2503 }; 2504 2505 _proto._resetScrollbar = function _resetScrollbar() { 2506 // Restore fixed content padding 2507 var fixedContent = [].slice.call(document.querySelectorAll(SELECTOR_FIXED_CONTENT)); 2508 $__default["default"](fixedContent).each(function (index, element) { 2509 var padding = $__default["default"](element).data('padding-right'); 2510 $__default["default"](element).removeData('padding-right'); 2511 element.style.paddingRight = padding ? padding : ''; 2512 }); // Restore sticky content 2513 2514 var elements = [].slice.call(document.querySelectorAll("" + SELECTOR_STICKY_CONTENT)); 2515 $__default["default"](elements).each(function (index, element) { 2516 var margin = $__default["default"](element).data('margin-right'); 2517 2518 if (typeof margin !== 'undefined') { 2519 $__default["default"](element).css('margin-right', margin).removeData('margin-right'); 2520 } 2521 }); // Restore body padding 2522 2523 var padding = $__default["default"](document.body).data('padding-right'); 2524 $__default["default"](document.body).removeData('padding-right'); 2525 document.body.style.paddingRight = padding ? padding : ''; 2526 }; 2527 2528 _proto._getScrollbarWidth = function _getScrollbarWidth() { 2529 // thx d.walsh 2530 var scrollDiv = document.createElement('div'); 2531 scrollDiv.className = CLASS_NAME_SCROLLBAR_MEASURER; 2532 document.body.appendChild(scrollDiv); 2533 var scrollbarWidth = scrollDiv.getBoundingClientRect().width - scrollDiv.clientWidth; 2534 document.body.removeChild(scrollDiv); 2535 return scrollbarWidth; 2536 } // Static 2537 ; 2538 2539 Modal._jQueryInterface = function _jQueryInterface(config, relatedTarget) { 2540 return this.each(function () { 2541 var data = $__default["default"](this).data(DATA_KEY$5); 2542 2543 var _config = _extends({}, Default$4, $__default["default"](this).data(), typeof config === 'object' && config ? config : {}); 2544 2545 if (!data) { 2546 data = new Modal(this, _config); 2547 $__default["default"](this).data(DATA_KEY$5, data); 2548 } 2549 2550 if (typeof config === 'string') { 2551 if (typeof data[config] === 'undefined') { 2552 throw new TypeError("No method named \"" + config + "\""); 2553 } 2554 2555 data[config](relatedTarget); 2556 } else if (_config.show) { 2557 data.show(relatedTarget); 2558 } 2559 }); 2560 }; 2561 2562 _createClass(Modal, null, [{ 2563 key: "VERSION", 2564 get: function get() { 2565 return VERSION$5; 2566 } 2567 }, { 2568 key: "Default", 2569 get: function get() { 2570 return Default$4; 2571 } 2572 }]); 2573 2574 return Modal; 2575 }(); 2576 /** 2577 * Data API implementation 2578 */ 2579 2580 2581 $__default["default"](document).on(EVENT_CLICK_DATA_API$1, SELECTOR_DATA_TOGGLE$1, function (event) { 2582 var _this11 = this; 2583 2584 var target; 2585 var selector = Util.getSelectorFromElement(this); 2586 2587 if (selector) { 2588 target = document.querySelector(selector); 2589 } 2590 2591 var config = $__default["default"](target).data(DATA_KEY$5) ? 'toggle' : _extends({}, $__default["default"](target).data(), $__default["default"](this).data()); 2592 2593 if (this.tagName === 'A' || this.tagName === 'AREA') { 2594 event.preventDefault(); 2595 } 2596 2597 var $target = $__default["default"](target).one(EVENT_SHOW$2, function (showEvent) { 2598 if (showEvent.isDefaultPrevented()) { 2599 // Only register focus restorer if modal will actually get shown 2600 return; 2601 } 2602 2603 $target.one(EVENT_HIDDEN$2, function () { 2604 if ($__default["default"](_this11).is(':visible')) { 2605 _this11.focus(); 2606 } 2607 }); 2608 }); 2609 2610 Modal._jQueryInterface.call($__default["default"](target), config, this); 2611 }); 2612 /** 2613 * jQuery 2614 */ 2615 2616 $__default["default"].fn[NAME$5] = Modal._jQueryInterface; 2617 $__default["default"].fn[NAME$5].Constructor = Modal; 2618 2619 $__default["default"].fn[NAME$5].noConflict = function () { 2620 $__default["default"].fn[NAME$5] = JQUERY_NO_CONFLICT$5; 2621 return Modal._jQueryInterface; 2622 }; 2623 2624 /** 2625 * -------------------------------------------------------------------------- 2626 * Bootstrap (v4.6.2): tools/sanitizer.js 2627 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE) 2628 * -------------------------------------------------------------------------- 2629 */ 2630 var uriAttrs = ['background', 'cite', 'href', 'itemtype', 'longdesc', 'poster', 'src', 'xlink:href']; 2631 var ARIA_ATTRIBUTE_PATTERN = /^aria-[\w-]*$/i; 2632 var DefaultWhitelist = { 2633 // Global attributes allowed on any supplied element below. 2634 '*': ['class', 'dir', 'id', 'lang', 'role', ARIA_ATTRIBUTE_PATTERN], 2635 a: ['target', 'href', 'title', 'rel'], 2636 area: [], 2637 b: [], 2638 br: [], 2639 col: [], 2640 code: [], 2641 div: [], 2642 em: [], 2643 hr: [], 2644 h1: [], 2645 h2: [], 2646 h3: [], 2647 h4: [], 2648 h5: [], 2649 h6: [], 2650 i: [], 2651 img: ['src', 'srcset', 'alt', 'title', 'width', 'height'], 2652 li: [], 2653 ol: [], 2654 p: [], 2655 pre: [], 2656 s: [], 2657 small: [], 2658 span: [], 2659 sub: [], 2660 sup: [], 2661 strong: [], 2662 u: [], 2663 ul: [] 2664 }; 2665 /** 2666 * A pattern that recognizes a commonly useful subset of URLs that are safe. 2667 * 2668 * Shoutout to Angular https://github.com/angular/angular/blob/12.2.x/packages/core/src/sanitization/url_sanitizer.ts 2669 */ 2670 2671 var SAFE_URL_PATTERN = /^(?:(?:https?|mailto|ftp|tel|file|sms):|[^#&/:?]*(?:[#/?]|$))/i; 2672 /** 2673 * A pattern that matches safe data URLs. Only matches image, video and audio types. 2674 * 2675 * Shoutout to Angular https://github.com/angular/angular/blob/12.2.x/packages/core/src/sanitization/url_sanitizer.ts 2676 */ 2677 2678 var DATA_URL_PATTERN = /^data:(?:image\/(?:bmp|gif|jpeg|jpg|png|tiff|webp)|video\/(?:mpeg|mp4|ogg|webm)|audio\/(?:mp3|oga|ogg|opus));base64,[\d+/a-z]+=*$/i; 2679 2680 function allowedAttribute(attr, allowedAttributeList) { 2681 var attrName = attr.nodeName.toLowerCase(); 2682 2683 if (allowedAttributeList.indexOf(attrName) !== -1) { 2684 if (uriAttrs.indexOf(attrName) !== -1) { 2685 return Boolean(SAFE_URL_PATTERN.test(attr.nodeValue) || DATA_URL_PATTERN.test(attr.nodeValue)); 2686 } 2687 2688 return true; 2689 } 2690 2691 var regExp = allowedAttributeList.filter(function (attrRegex) { 2692 return attrRegex instanceof RegExp; 2693 }); // Check if a regular expression validates the attribute. 2694 2695 for (var i = 0, len = regExp.length; i < len; i++) { 2696 if (regExp[i].test(attrName)) { 2697 return true; 2698 } 2699 } 2700 2701 return false; 2702 } 2703 2704 function sanitizeHtml(unsafeHtml, whiteList, sanitizeFn) { 2705 if (unsafeHtml.length === 0) { 2706 return unsafeHtml; 2707 } 2708 2709 if (sanitizeFn && typeof sanitizeFn === 'function') { 2710 return sanitizeFn(unsafeHtml); 2711 } 2712 2713 var domParser = new window.DOMParser(); 2714 var createdDocument = domParser.parseFromString(unsafeHtml, 'text/html'); 2715 var whitelistKeys = Object.keys(whiteList); 2716 var elements = [].slice.call(createdDocument.body.querySelectorAll('*')); 2717 2718 var _loop = function _loop(i, len) { 2719 var el = elements[i]; 2720 var elName = el.nodeName.toLowerCase(); 2721 2722 if (whitelistKeys.indexOf(el.nodeName.toLowerCase()) === -1) { 2723 el.parentNode.removeChild(el); 2724 return "continue"; 2725 } 2726 2727 var attributeList = [].slice.call(el.attributes); // eslint-disable-next-line unicorn/prefer-spread 2728 2729 var whitelistedAttributes = [].concat(whiteList['*'] || [], whiteList[elName] || []); 2730 attributeList.forEach(function (attr) { 2731 if (!allowedAttribute(attr, whitelistedAttributes)) { 2732 el.removeAttribute(attr.nodeName); 2733 } 2734 }); 2735 }; 2736 2737 for (var i = 0, len = elements.length; i < len; i++) { 2738 var _ret = _loop(i); 2739 2740 if (_ret === "continue") continue; 2741 } 2742 2743 return createdDocument.body.innerHTML; 2744 } 2745 2746 /** 2747 * Constants 2748 */ 2749 2750 var NAME$4 = 'tooltip'; 2751 var VERSION$4 = '4.6.2'; 2752 var DATA_KEY$4 = 'bs.tooltip'; 2753 var EVENT_KEY$4 = "." + DATA_KEY$4; 2754 var JQUERY_NO_CONFLICT$4 = $__default["default"].fn[NAME$4]; 2755 var CLASS_PREFIX$1 = 'bs-tooltip'; 2756 var BSCLS_PREFIX_REGEX$1 = new RegExp("(^|\\s)" + CLASS_PREFIX$1 + "\\S+", 'g'); 2757 var DISALLOWED_ATTRIBUTES = ['sanitize', 'whiteList', 'sanitizeFn']; 2758 var CLASS_NAME_FADE$3 = 'fade'; 2759 var CLASS_NAME_SHOW$3 = 'show'; 2760 var HOVER_STATE_SHOW = 'show'; 2761 var HOVER_STATE_OUT = 'out'; 2762 var SELECTOR_TOOLTIP_INNER = '.tooltip-inner'; 2763 var SELECTOR_ARROW = '.arrow'; 2764 var TRIGGER_HOVER = 'hover'; 2765 var TRIGGER_FOCUS = 'focus'; 2766 var TRIGGER_CLICK = 'click'; 2767 var TRIGGER_MANUAL = 'manual'; 2768 var AttachmentMap = { 2769 AUTO: 'auto', 2770 TOP: 'top', 2771 RIGHT: 'right', 2772 BOTTOM: 'bottom', 2773 LEFT: 'left' 2774 }; 2775 var Default$3 = { 2776 animation: true, 2777 template: '<div class="tooltip" role="tooltip">' + '<div class="arrow"></div>' + '<div class="tooltip-inner"></div></div>', 2778 trigger: 'hover focus', 2779 title: '', 2780 delay: 0, 2781 html: false, 2782 selector: false, 2783 placement: 'top', 2784 offset: 0, 2785 container: false, 2786 fallbackPlacement: 'flip', 2787 boundary: 'scrollParent', 2788 customClass: '', 2789 sanitize: true, 2790 sanitizeFn: null, 2791 whiteList: DefaultWhitelist, 2792 popperConfig: null 2793 }; 2794 var DefaultType$3 = { 2795 animation: 'boolean', 2796 template: 'string', 2797 title: '(string|element|function)', 2798 trigger: 'string', 2799 delay: '(number|object)', 2800 html: 'boolean', 2801 selector: '(string|boolean)', 2802 placement: '(string|function)', 2803 offset: '(number|string|function)', 2804 container: '(string|element|boolean)', 2805 fallbackPlacement: '(string|array)', 2806 boundary: '(string|element)', 2807 customClass: '(string|function)', 2808 sanitize: 'boolean', 2809 sanitizeFn: '(null|function)', 2810 whiteList: 'object', 2811 popperConfig: '(null|object)' 2812 }; 2813 var Event$1 = { 2814 HIDE: "hide" + EVENT_KEY$4, 2815 HIDDEN: "hidden" + EVENT_KEY$4, 2816 SHOW: "show" + EVENT_KEY$4, 2817 SHOWN: "shown" + EVENT_KEY$4, 2818 INSERTED: "inserted" + EVENT_KEY$4, 2819 CLICK: "click" + EVENT_KEY$4, 2820 FOCUSIN: "focusin" + EVENT_KEY$4, 2821 FOCUSOUT: "focusout" + EVENT_KEY$4, 2822 MOUSEENTER: "mouseenter" + EVENT_KEY$4, 2823 MOUSELEAVE: "mouseleave" + EVENT_KEY$4 2824 }; 2825 /** 2826 * Class definition 2827 */ 2828 2829 var Tooltip = /*#__PURE__*/function () { 2830 function Tooltip(element, config) { 2831 if (typeof Popper__default["default"] === 'undefined') { 2832 throw new TypeError('Bootstrap\'s tooltips require Popper (https://popper.js.org)'); 2833 } // Private 2834 2835 2836 this._isEnabled = true; 2837 this._timeout = 0; 2838 this._hoverState = ''; 2839 this._activeTrigger = {}; 2840 this._popper = null; // Protected 2841 2842 this.element = element; 2843 this.config = this._getConfig(config); 2844 this.tip = null; 2845 2846 this._setListeners(); 2847 } // Getters 2848 2849 2850 var _proto = Tooltip.prototype; 2851 2852 // Public 2853 _proto.enable = function enable() { 2854 this._isEnabled = true; 2855 }; 2856 2857 _proto.disable = function disable() { 2858 this._isEnabled = false; 2859 }; 2860 2861 _proto.toggleEnabled = function toggleEnabled() { 2862 this._isEnabled = !this._isEnabled; 2863 }; 2864 2865 _proto.toggle = function toggle(event) { 2866 if (!this._isEnabled) { 2867 return; 2868 } 2869 2870 if (event) { 2871 var dataKey = this.constructor.DATA_KEY; 2872 var context = $__default["default"](event.currentTarget).data(dataKey); 2873 2874 if (!context) { 2875 context = new this.constructor(event.currentTarget, this._getDelegateConfig()); 2876 $__default["default"](event.currentTarget).data(dataKey, context); 2877 } 2878 2879 context._activeTrigger.click = !context._activeTrigger.click; 2880 2881 if (context._isWithActiveTrigger()) { 2882 context._enter(null, context); 2883 } else { 2884 context._leave(null, context); 2885 } 2886 } else { 2887 if ($__default["default"](this.getTipElement()).hasClass(CLASS_NAME_SHOW$3)) { 2888 this._leave(null, this); 2889 2890 return; 2891 } 2892 2893 this._enter(null, this); 2894 } 2895 }; 2896 2897 _proto.dispose = function dispose() { 2898 clearTimeout(this._timeout); 2899 $__default["default"].removeData(this.element, this.constructor.DATA_KEY); 2900 $__default["default"](this.element).off(this.constructor.EVENT_KEY); 2901 $__default["default"](this.element).closest('.modal').off('hide.bs.modal', this._hideModalHandler); 2902 2903 if (this.tip) { 2904 $__default["default"](this.tip).remove(); 2905 } 2906 2907 this._isEnabled = null; 2908 this._timeout = null; 2909 this._hoverState = null; 2910 this._activeTrigger = null; 2911 2912 if (this._popper) { 2913 this._popper.destroy(); 2914 } 2915 2916 this._popper = null; 2917 this.element = null; 2918 this.config = null; 2919 this.tip = null; 2920 }; 2921 2922 _proto.show = function show() { 2923 var _this = this; 2924 2925 if ($__default["default"](this.element).css('display') === 'none') { 2926 throw new Error('Please use show on visible elements'); 2927 } 2928 2929 var showEvent = $__default["default"].Event(this.constructor.Event.SHOW); 2930 2931 if (this.isWithContent() && this._isEnabled) { 2932 $__default["default"](this.element).trigger(showEvent); 2933 var shadowRoot = Util.findShadowRoot(this.element); 2934 var isInTheDom = $__default["default"].contains(shadowRoot !== null ? shadowRoot : this.element.ownerDocument.documentElement, this.element); 2935 2936 if (showEvent.isDefaultPrevented() || !isInTheDom) { 2937 return; 2938 } 2939 2940 var tip = this.getTipElement(); 2941 var tipId = Util.getUID(this.constructor.NAME); 2942 tip.setAttribute('id', tipId); 2943 this.element.setAttribute('aria-describedby', tipId); 2944 this.setContent(); 2945 2946 if (this.config.animation) { 2947 $__default["default"](tip).addClass(CLASS_NAME_FADE$3); 2948 } 2949 2950 var placement = typeof this.config.placement === 'function' ? this.config.placement.call(this, tip, this.element) : this.config.placement; 2951 2952 var attachment = this._getAttachment(placement); 2953 2954 this.addAttachmentClass(attachment); 2955 2956 var container = this._getContainer(); 2957 2958 $__default["default"](tip).data(this.constructor.DATA_KEY, this); 2959 2960 if (!$__default["default"].contains(this.element.ownerDocument.documentElement, this.tip)) { 2961 $__default["default"](tip).appendTo(container); 2962 } 2963 2964 $__default["default"](this.element).trigger(this.constructor.Event.INSERTED); 2965 this._popper = new Popper__default["default"](this.element, tip, this._getPopperConfig(attachment)); 2966 $__default["default"](tip).addClass(CLASS_NAME_SHOW$3); 2967 $__default["default"](tip).addClass(this.config.customClass); // If this is a touch-enabled device we add extra 2968 // empty mouseover listeners to the body's immediate children; 2969 // only needed because of broken event delegation on iOS 2970 // https://www.quirksmode.org/blog/archives/2014/02/mouse_event_bub.html 2971 2972 if ('ontouchstart' in document.documentElement) { 2973 $__default["default"](document.body).children().on('mouseover', null, $__default["default"].noop); 2974 } 2975 2976 var complete = function complete() { 2977 if (_this.config.animation) { 2978 _this._fixTransition(); 2979 } 2980 2981 var prevHoverState = _this._hoverState; 2982 _this._hoverState = null; 2983 $__default["default"](_this.element).trigger(_this.constructor.Event.SHOWN); 2984 2985 if (prevHoverState === HOVER_STATE_OUT) { 2986 _this._leave(null, _this); 2987 } 2988 }; 2989 2990 if ($__default["default"](this.tip).hasClass(CLASS_NAME_FADE$3)) { 2991 var transitionDuration = Util.getTransitionDurationFromElement(this.tip); 2992 $__default["default"](this.tip).one(Util.TRANSITION_END, complete).emulateTransitionEnd(transitionDuration); 2993 } else { 2994 complete(); 2995 } 2996 } 2997 }; 2998 2999 _proto.hide = function hide(callback) { 3000 var _this2 = this; 3001 3002 var tip = this.getTipElement(); 3003 var hideEvent = $__default["default"].Event(this.constructor.Event.HIDE); 3004 3005 var complete = function complete() { 3006 if (_this2._hoverState !== HOVER_STATE_SHOW && tip.parentNode) { 3007 tip.parentNode.removeChild(tip); 3008 } 3009 3010 _this2._cleanTipClass(); 3011 3012 _this2.element.removeAttribute('aria-describedby'); 3013 3014 $__default["default"](_this2.element).trigger(_this2.constructor.Event.HIDDEN); 3015 3016 if (_this2._popper !== null) { 3017 _this2._popper.destroy(); 3018 } 3019 3020 if (callback) { 3021 callback(); 3022 } 3023 }; 3024 3025 $__default["default"](this.element).trigger(hideEvent); 3026 3027 if (hideEvent.isDefaultPrevented()) { 3028 return; 3029 } 3030 3031 $__default["default"](tip).removeClass(CLASS_NAME_SHOW$3); // If this is a touch-enabled device we remove the extra 3032 // empty mouseover listeners we added for iOS support 3033 3034 if ('ontouchstart' in document.documentElement) { 3035 $__default["default"](document.body).children().off('mouseover', null, $__default["default"].noop); 3036 } 3037 3038 this._activeTrigger[TRIGGER_CLICK] = false; 3039 this._activeTrigger[TRIGGER_FOCUS] = false; 3040 this._activeTrigger[TRIGGER_HOVER] = false; 3041 3042 if ($__default["default"](this.tip).hasClass(CLASS_NAME_FADE$3)) { 3043 var transitionDuration = Util.getTransitionDurationFromElement(tip); 3044 $__default["default"](tip).one(Util.TRANSITION_END, complete).emulateTransitionEnd(transitionDuration); 3045 } else { 3046 complete(); 3047 } 3048 3049 this._hoverState = ''; 3050 }; 3051 3052 _proto.update = function update() { 3053 if (this._popper !== null) { 3054 this._popper.scheduleUpdate(); 3055 } 3056 } // Protected 3057 ; 3058 3059 _proto.isWithContent = function isWithContent() { 3060 return Boolean(this.getTitle()); 3061 }; 3062 3063 _proto.addAttachmentClass = function addAttachmentClass(attachment) { 3064 $__default["default"](this.getTipElement()).addClass(CLASS_PREFIX$1 + "-" + attachment); 3065 }; 3066 3067 _proto.getTipElement = function getTipElement() { 3068 this.tip = this.tip || $__default["default"](this.config.template)[0]; 3069 return this.tip; 3070 }; 3071 3072 _proto.setContent = function setContent() { 3073 var tip = this.getTipElement(); 3074 this.setElementContent($__default["default"](tip.querySelectorAll(SELECTOR_TOOLTIP_INNER)), this.getTitle()); 3075 $__default["default"](tip).removeClass(CLASS_NAME_FADE$3 + " " + CLASS_NAME_SHOW$3); 3076 }; 3077 3078 _proto.setElementContent = function setElementContent($element, content) { 3079 if (typeof content === 'object' && (content.nodeType || content.jquery)) { 3080 // Content is a DOM node or a jQuery 3081 if (this.config.html) { 3082 if (!$__default["default"](content).parent().is($element)) { 3083 $element.empty().append(content); 3084 } 3085 } else { 3086 $element.text($__default["default"](content).text()); 3087 } 3088 3089 return; 3090 } 3091 3092 if (this.config.html) { 3093 if (this.config.sanitize) { 3094 content = sanitizeHtml(content, this.config.whiteList, this.config.sanitizeFn); 3095 } 3096 3097 $element.html(content); 3098 } else { 3099 $element.text(content); 3100 } 3101 }; 3102 3103 _proto.getTitle = function getTitle() { 3104 var title = this.element.getAttribute('data-original-title'); 3105 3106 if (!title) { 3107 title = typeof this.config.title === 'function' ? this.config.title.call(this.element) : this.config.title; 3108 } 3109 3110 return title; 3111 } // Private 3112 ; 3113 3114 _proto._getPopperConfig = function _getPopperConfig(attachment) { 3115 var _this3 = this; 3116 3117 var defaultBsConfig = { 3118 placement: attachment, 3119 modifiers: { 3120 offset: this._getOffset(), 3121 flip: { 3122 behavior: this.config.fallbackPlacement 3123 }, 3124 arrow: { 3125 element: SELECTOR_ARROW 3126 }, 3127 preventOverflow: { 3128 boundariesElement: this.config.boundary 3129 } 3130 }, 3131 onCreate: function onCreate(data) { 3132 if (data.originalPlacement !== data.placement) { 3133 _this3._handlePopperPlacementChange(data); 3134 } 3135 }, 3136 onUpdate: function onUpdate(data) { 3137 return _this3._handlePopperPlacementChange(data); 3138 } 3139 }; 3140 return _extends({}, defaultBsConfig, this.config.popperConfig); 3141 }; 3142 3143 _proto._getOffset = function _getOffset() { 3144 var _this4 = this; 3145 3146 var offset = {}; 3147 3148 if (typeof this.config.offset === 'function') { 3149 offset.fn = function (data) { 3150 data.offsets = _extends({}, data.offsets, _this4.config.offset(data.offsets, _this4.element)); 3151 return data; 3152 }; 3153 } else { 3154 offset.offset = this.config.offset; 3155 } 3156 3157 return offset; 3158 }; 3159 3160 _proto._getContainer = function _getContainer() { 3161 if (this.config.container === false) { 3162 return document.body; 3163 } 3164 3165 if (Util.isElement(this.config.container)) { 3166 return $__default["default"](this.config.container); 3167 } 3168 3169 return $__default["default"](document).find(this.config.container); 3170 }; 3171 3172 _proto._getAttachment = function _getAttachment(placement) { 3173 return AttachmentMap[placement.toUpperCase()]; 3174 }; 3175 3176 _proto._setListeners = function _setListeners() { 3177 var _this5 = this; 3178 3179 var triggers = this.config.trigger.split(' '); 3180 triggers.forEach(function (trigger) { 3181 if (trigger === 'click') { 3182 $__default["default"](_this5.element).on(_this5.constructor.Event.CLICK, _this5.config.selector, function (event) { 3183 return _this5.toggle(event); 3184 }); 3185 } else if (trigger !== TRIGGER_MANUAL) { 3186 var eventIn = trigger === TRIGGER_HOVER ? _this5.constructor.Event.MOUSEENTER : _this5.constructor.Event.FOCUSIN; 3187 var eventOut = trigger === TRIGGER_HOVER ? _this5.constructor.Event.MOUSELEAVE : _this5.constructor.Event.FOCUSOUT; 3188 $__default["default"](_this5.element).on(eventIn, _this5.config.selector, function (event) { 3189 return _this5._enter(event); 3190 }).on(eventOut, _this5.config.selector, function (event) { 3191 return _this5._leave(event); 3192 }); 3193 } 3194 }); 3195 3196 this._hideModalHandler = function () { 3197 if (_this5.element) { 3198 _this5.hide(); 3199 } 3200 }; 3201 3202 $__default["default"](this.element).closest('.modal').on('hide.bs.modal', this._hideModalHandler); 3203 3204 if (this.config.selector) { 3205 this.config = _extends({}, this.config, { 3206 trigger: 'manual', 3207 selector: '' 3208 }); 3209 } else { 3210 this._fixTitle(); 3211 } 3212 }; 3213 3214 _proto._fixTitle = function _fixTitle() { 3215 var titleType = typeof this.element.getAttribute('data-original-title'); 3216 3217 if (this.element.getAttribute('title') || titleType !== 'string') { 3218 this.element.setAttribute('data-original-title', this.element.getAttribute('title') || ''); 3219 this.element.setAttribute('title', ''); 3220 } 3221 }; 3222 3223 _proto._enter = function _enter(event, context) { 3224 var dataKey = this.constructor.DATA_KEY; 3225 context = context || $__default["default"](event.currentTarget).data(dataKey); 3226 3227 if (!context) { 3228 context = new this.constructor(event.currentTarget, this._getDelegateConfig()); 3229 $__default["default"](event.currentTarget).data(dataKey, context); 3230 } 3231 3232 if (event) { 3233 context._activeTrigger[event.type === 'focusin' ? TRIGGER_FOCUS : TRIGGER_HOVER] = true; 3234 } 3235 3236 if ($__default["default"](context.getTipElement()).hasClass(CLASS_NAME_SHOW$3) || context._hoverState === HOVER_STATE_SHOW) { 3237 context._hoverState = HOVER_STATE_SHOW; 3238 return; 3239 } 3240 3241 clearTimeout(context._timeout); 3242 context._hoverState = HOVER_STATE_SHOW; 3243 3244 if (!context.config.delay || !context.config.delay.show) { 3245 context.show(); 3246 return; 3247 } 3248 3249 context._timeout = setTimeout(function () { 3250 if (context._hoverState === HOVER_STATE_SHOW) { 3251 context.show(); 3252 } 3253 }, context.config.delay.show); 3254 }; 3255 3256 _proto._leave = function _leave(event, context) { 3257 var dataKey = this.constructor.DATA_KEY; 3258 context = context || $__default["default"](event.currentTarget).data(dataKey); 3259 3260 if (!context) { 3261 context = new this.constructor(event.currentTarget, this._getDelegateConfig()); 3262 $__default["default"](event.currentTarget).data(dataKey, context); 3263 } 3264 3265 if (event) { 3266 context._activeTrigger[event.type === 'focusout' ? TRIGGER_FOCUS : TRIGGER_HOVER] = false; 3267 } 3268 3269 if (context._isWithActiveTrigger()) { 3270 return; 3271 } 3272 3273 clearTimeout(context._timeout); 3274 context._hoverState = HOVER_STATE_OUT; 3275 3276 if (!context.config.delay || !context.config.delay.hide) { 3277 context.hide(); 3278 return; 3279 } 3280 3281 context._timeout = setTimeout(function () { 3282 if (context._hoverState === HOVER_STATE_OUT) { 3283 context.hide(); 3284 } 3285 }, context.config.delay.hide); 3286 }; 3287 3288 _proto._isWithActiveTrigger = function _isWithActiveTrigger() { 3289 for (var trigger in this._activeTrigger) { 3290 if (this._activeTrigger[trigger]) { 3291 return true; 3292 } 3293 } 3294 3295 return false; 3296 }; 3297 3298 _proto._getConfig = function _getConfig(config) { 3299 var dataAttributes = $__default["default"](this.element).data(); 3300 Object.keys(dataAttributes).forEach(function (dataAttr) { 3301 if (DISALLOWED_ATTRIBUTES.indexOf(dataAttr) !== -1) { 3302 delete dataAttributes[dataAttr]; 3303 } 3304 }); 3305 config = _extends({}, this.constructor.Default, dataAttributes, typeof config === 'object' && config ? config : {}); 3306 3307 if (typeof config.delay === 'number') { 3308 config.delay = { 3309 show: config.delay, 3310 hide: config.delay 3311 }; 3312 } 3313 3314 if (typeof config.title === 'number') { 3315 config.title = config.title.toString(); 3316 } 3317 3318 if (typeof config.content === 'number') { 3319 config.content = config.content.toString(); 3320 } 3321 3322 Util.typeCheckConfig(NAME$4, config, this.constructor.DefaultType); 3323 3324 if (config.sanitize) { 3325 config.template = sanitizeHtml(config.template, config.whiteList, config.sanitizeFn); 3326 } 3327 3328 return config; 3329 }; 3330 3331 _proto._getDelegateConfig = function _getDelegateConfig() { 3332 var config = {}; 3333 3334 if (this.config) { 3335 for (var key in this.config) { 3336 if (this.constructor.Default[key] !== this.config[key]) { 3337 config[key] = this.config[key]; 3338 } 3339 } 3340 } 3341 3342 return config; 3343 }; 3344 3345 _proto._cleanTipClass = function _cleanTipClass() { 3346 var $tip = $__default["default"](this.getTipElement()); 3347 var tabClass = $tip.attr('class').match(BSCLS_PREFIX_REGEX$1); 3348 3349 if (tabClass !== null && tabClass.length) { 3350 $tip.removeClass(tabClass.join('')); 3351 } 3352 }; 3353 3354 _proto._handlePopperPlacementChange = function _handlePopperPlacementChange(popperData) { 3355 this.tip = popperData.instance.popper; 3356 3357 this._cleanTipClass(); 3358 3359 this.addAttachmentClass(this._getAttachment(popperData.placement)); 3360 }; 3361 3362 _proto._fixTransition = function _fixTransition() { 3363 var tip = this.getTipElement(); 3364 var initConfigAnimation = this.config.animation; 3365 3366 if (tip.getAttribute('x-placement') !== null) { 3367 return; 3368 } 3369 3370 $__default["default"](tip).removeClass(CLASS_NAME_FADE$3); 3371 this.config.animation = false; 3372 this.hide(); 3373 this.show(); 3374 this.config.animation = initConfigAnimation; 3375 } // Static 3376 ; 3377 3378 Tooltip._jQueryInterface = function _jQueryInterface(config) { 3379 return this.each(function () { 3380 var $element = $__default["default"](this); 3381 var data = $element.data(DATA_KEY$4); 3382 3383 var _config = typeof config === 'object' && config; 3384 3385 if (!data && /dispose|hide/.test(config)) { 3386 return; 3387 } 3388 3389 if (!data) { 3390 data = new Tooltip(this, _config); 3391 $element.data(DATA_KEY$4, data); 3392 } 3393 3394 if (typeof config === 'string') { 3395 if (typeof data[config] === 'undefined') { 3396 throw new TypeError("No method named \"" + config + "\""); 3397 } 3398 3399 data[config](); 3400 } 3401 }); 3402 }; 3403 3404 _createClass(Tooltip, null, [{ 3405 key: "VERSION", 3406 get: function get() { 3407 return VERSION$4; 3408 } 3409 }, { 3410 key: "Default", 3411 get: function get() { 3412 return Default$3; 3413 } 3414 }, { 3415 key: "NAME", 3416 get: function get() { 3417 return NAME$4; 3418 } 3419 }, { 3420 key: "DATA_KEY", 3421 get: function get() { 3422 return DATA_KEY$4; 3423 } 3424 }, { 3425 key: "Event", 3426 get: function get() { 3427 return Event$1; 3428 } 3429 }, { 3430 key: "EVENT_KEY", 3431 get: function get() { 3432 return EVENT_KEY$4; 3433 } 3434 }, { 3435 key: "DefaultType", 3436 get: function get() { 3437 return DefaultType$3; 3438 } 3439 }]); 3440 3441 return Tooltip; 3442 }(); 3443 /** 3444 * jQuery 3445 */ 3446 3447 3448 $__default["default"].fn[NAME$4] = Tooltip._jQueryInterface; 3449 $__default["default"].fn[NAME$4].Constructor = Tooltip; 3450 3451 $__default["default"].fn[NAME$4].noConflict = function () { 3452 $__default["default"].fn[NAME$4] = JQUERY_NO_CONFLICT$4; 3453 return Tooltip._jQueryInterface; 3454 }; 3455 3456 /** 3457 * Constants 3458 */ 3459 3460 var NAME$3 = 'popover'; 3461 var VERSION$3 = '4.6.2'; 3462 var DATA_KEY$3 = 'bs.popover'; 3463 var EVENT_KEY$3 = "." + DATA_KEY$3; 3464 var JQUERY_NO_CONFLICT$3 = $__default["default"].fn[NAME$3]; 3465 var CLASS_PREFIX = 'bs-popover'; 3466 var BSCLS_PREFIX_REGEX = new RegExp("(^|\\s)" + CLASS_PREFIX + "\\S+", 'g'); 3467 var CLASS_NAME_FADE$2 = 'fade'; 3468 var CLASS_NAME_SHOW$2 = 'show'; 3469 var SELECTOR_TITLE = '.popover-header'; 3470 var SELECTOR_CONTENT = '.popover-body'; 3471 3472 var Default$2 = _extends({}, Tooltip.Default, { 3473 placement: 'right', 3474 trigger: 'click', 3475 content: '', 3476 template: '<div class="popover" role="tooltip">' + '<div class="arrow"></div>' + '<h3 class="popover-header"></h3>' + '<div class="popover-body"></div></div>' 3477 }); 3478 3479 var DefaultType$2 = _extends({}, Tooltip.DefaultType, { 3480 content: '(string|element|function)' 3481 }); 3482 3483 var Event = { 3484 HIDE: "hide" + EVENT_KEY$3, 3485 HIDDEN: "hidden" + EVENT_KEY$3, 3486 SHOW: "show" + EVENT_KEY$3, 3487 SHOWN: "shown" + EVENT_KEY$3, 3488 INSERTED: "inserted" + EVENT_KEY$3, 3489 CLICK: "click" + EVENT_KEY$3, 3490 FOCUSIN: "focusin" + EVENT_KEY$3, 3491 FOCUSOUT: "focusout" + EVENT_KEY$3, 3492 MOUSEENTER: "mouseenter" + EVENT_KEY$3, 3493 MOUSELEAVE: "mouseleave" + EVENT_KEY$3 3494 }; 3495 /** 3496 * Class definition 3497 */ 3498 3499 var Popover = /*#__PURE__*/function (_Tooltip) { 3500 _inheritsLoose(Popover, _Tooltip); 3501 3502 function Popover() { 3503 return _Tooltip.apply(this, arguments) || this; 3504 } 3505 3506 var _proto = Popover.prototype; 3507 3508 // Overrides 3509 _proto.isWithContent = function isWithContent() { 3510 return this.getTitle() || this._getContent(); 3511 }; 3512 3513 _proto.addAttachmentClass = function addAttachmentClass(attachment) { 3514 $__default["default"](this.getTipElement()).addClass(CLASS_PREFIX + "-" + attachment); 3515 }; 3516 3517 _proto.getTipElement = function getTipElement() { 3518 this.tip = this.tip || $__default["default"](this.config.template)[0]; 3519 return this.tip; 3520 }; 3521 3522 _proto.setContent = function setContent() { 3523 var $tip = $__default["default"](this.getTipElement()); // We use append for html objects to maintain js events 3524 3525 this.setElementContent($tip.find(SELECTOR_TITLE), this.getTitle()); 3526 3527 var content = this._getContent(); 3528 3529 if (typeof content === 'function') { 3530 content = content.call(this.element); 3531 } 3532 3533 this.setElementContent($tip.find(SELECTOR_CONTENT), content); 3534 $tip.removeClass(CLASS_NAME_FADE$2 + " " + CLASS_NAME_SHOW$2); 3535 } // Private 3536 ; 3537 3538 _proto._getContent = function _getContent() { 3539 return this.element.getAttribute('data-content') || this.config.content; 3540 }; 3541 3542 _proto._cleanTipClass = function _cleanTipClass() { 3543 var $tip = $__default["default"](this.getTipElement()); 3544 var tabClass = $tip.attr('class').match(BSCLS_PREFIX_REGEX); 3545 3546 if (tabClass !== null && tabClass.length > 0) { 3547 $tip.removeClass(tabClass.join('')); 3548 } 3549 } // Static 3550 ; 3551 3552 Popover._jQueryInterface = function _jQueryInterface(config) { 3553 return this.each(function () { 3554 var data = $__default["default"](this).data(DATA_KEY$3); 3555 3556 var _config = typeof config === 'object' ? config : null; 3557 3558 if (!data && /dispose|hide/.test(config)) { 3559 return; 3560 } 3561 3562 if (!data) { 3563 data = new Popover(this, _config); 3564 $__default["default"](this).data(DATA_KEY$3, data); 3565 } 3566 3567 if (typeof config === 'string') { 3568 if (typeof data[config] === 'undefined') { 3569 throw new TypeError("No method named \"" + config + "\""); 3570 } 3571 3572 data[config](); 3573 } 3574 }); 3575 }; 3576 3577 _createClass(Popover, null, [{ 3578 key: "VERSION", 3579 get: // Getters 3580 function get() { 3581 return VERSION$3; 3582 } 3583 }, { 3584 key: "Default", 3585 get: function get() { 3586 return Default$2; 3587 } 3588 }, { 3589 key: "NAME", 3590 get: function get() { 3591 return NAME$3; 3592 } 3593 }, { 3594 key: "DATA_KEY", 3595 get: function get() { 3596 return DATA_KEY$3; 3597 } 3598 }, { 3599 key: "Event", 3600 get: function get() { 3601 return Event; 3602 } 3603 }, { 3604 key: "EVENT_KEY", 3605 get: function get() { 3606 return EVENT_KEY$3; 3607 } 3608 }, { 3609 key: "DefaultType", 3610 get: function get() { 3611 return DefaultType$2; 3612 } 3613 }]); 3614 3615 return Popover; 3616 }(Tooltip); 3617 /** 3618 * jQuery 3619 */ 3620 3621 3622 $__default["default"].fn[NAME$3] = Popover._jQueryInterface; 3623 $__default["default"].fn[NAME$3].Constructor = Popover; 3624 3625 $__default["default"].fn[NAME$3].noConflict = function () { 3626 $__default["default"].fn[NAME$3] = JQUERY_NO_CONFLICT$3; 3627 return Popover._jQueryInterface; 3628 }; 3629 3630 /** 3631 * Constants 3632 */ 3633 3634 var NAME$2 = 'scrollspy'; 3635 var VERSION$2 = '4.6.2'; 3636 var DATA_KEY$2 = 'bs.scrollspy'; 3637 var EVENT_KEY$2 = "." + DATA_KEY$2; 3638 var DATA_API_KEY$1 = '.data-api'; 3639 var JQUERY_NO_CONFLICT$2 = $__default["default"].fn[NAME$2]; 3640 var CLASS_NAME_DROPDOWN_ITEM = 'dropdown-item'; 3641 var CLASS_NAME_ACTIVE$1 = 'active'; 3642 var EVENT_ACTIVATE = "activate" + EVENT_KEY$2; 3643 var EVENT_SCROLL = "scroll" + EVENT_KEY$2; 3644 var EVENT_LOAD_DATA_API = "load" + EVENT_KEY$2 + DATA_API_KEY$1; 3645 var METHOD_OFFSET = 'offset'; 3646 var METHOD_POSITION = 'position'; 3647 var SELECTOR_DATA_SPY = '[data-spy="scroll"]'; 3648 var SELECTOR_NAV_LIST_GROUP$1 = '.nav, .list-group'; 3649 var SELECTOR_NAV_LINKS = '.nav-link'; 3650 var SELECTOR_NAV_ITEMS = '.nav-item'; 3651 var SELECTOR_LIST_ITEMS = '.list-group-item'; 3652 var SELECTOR_DROPDOWN$1 = '.dropdown'; 3653 var SELECTOR_DROPDOWN_ITEMS = '.dropdown-item'; 3654 var SELECTOR_DROPDOWN_TOGGLE$1 = '.dropdown-toggle'; 3655 var Default$1 = { 3656 offset: 10, 3657 method: 'auto', 3658 target: '' 3659 }; 3660 var DefaultType$1 = { 3661 offset: 'number', 3662 method: 'string', 3663 target: '(string|element)' 3664 }; 3665 /** 3666 * Class definition 3667 */ 3668 3669 var ScrollSpy = /*#__PURE__*/function () { 3670 function ScrollSpy(element, config) { 3671 var _this = this; 3672 3673 this._element = element; 3674 this._scrollElement = element.tagName === 'BODY' ? window : element; 3675 this._config = this._getConfig(config); 3676 this._selector = this._config.target + " " + SELECTOR_NAV_LINKS + "," + (this._config.target + " " + SELECTOR_LIST_ITEMS + ",") + (this._config.target + " " + SELECTOR_DROPDOWN_ITEMS); 3677 this._offsets = []; 3678 this._targets = []; 3679 this._activeTarget = null; 3680 this._scrollHeight = 0; 3681 $__default["default"](this._scrollElement).on(EVENT_SCROLL, function (event) { 3682 return _this._process(event); 3683 }); 3684 this.refresh(); 3685 3686 this._process(); 3687 } // Getters 3688 3689 3690 var _proto = ScrollSpy.prototype; 3691 3692 // Public 3693 _proto.refresh = function refresh() { 3694 var _this2 = this; 3695 3696 var autoMethod = this._scrollElement === this._scrollElement.window ? METHOD_OFFSET : METHOD_POSITION; 3697 var offsetMethod = this._config.method === 'auto' ? autoMethod : this._config.method; 3698 var offsetBase = offsetMethod === METHOD_POSITION ? this._getScrollTop() : 0; 3699 this._offsets = []; 3700 this._targets = []; 3701 this._scrollHeight = this._getScrollHeight(); 3702 var targets = [].slice.call(document.querySelectorAll(this._selector)); 3703 targets.map(function (element) { 3704 var target; 3705 var targetSelector = Util.getSelectorFromElement(element); 3706 3707 if (targetSelector) { 3708 target = document.querySelector(targetSelector); 3709 } 3710 3711 if (target) { 3712 var targetBCR = target.getBoundingClientRect(); 3713 3714 if (targetBCR.width || targetBCR.height) { 3715 // TODO (fat): remove sketch reliance on jQuery position/offset 3716 return [$__default["default"](target)[offsetMethod]().top + offsetBase, targetSelector]; 3717 } 3718 } 3719 3720 return null; 3721 }).filter(Boolean).sort(function (a, b) { 3722 return a[0] - b[0]; 3723 }).forEach(function (item) { 3724 _this2._offsets.push(item[0]); 3725 3726 _this2._targets.push(item[1]); 3727 }); 3728 }; 3729 3730 _proto.dispose = function dispose() { 3731 $__default["default"].removeData(this._element, DATA_KEY$2); 3732 $__default["default"](this._scrollElement).off(EVENT_KEY$2); 3733 this._element = null; 3734 this._scrollElement = null; 3735 this._config = null; 3736 this._selector = null; 3737 this._offsets = null; 3738 this._targets = null; 3739 this._activeTarget = null; 3740 this._scrollHeight = null; 3741 } // Private 3742 ; 3743 3744 _proto._getConfig = function _getConfig(config) { 3745 config = _extends({}, Default$1, typeof config === 'object' && config ? config : {}); 3746 3747 if (typeof config.target !== 'string' && Util.isElement(config.target)) { 3748 var id = $__default["default"](config.target).attr('id'); 3749 3750 if (!id) { 3751 id = Util.getUID(NAME$2); 3752 $__default["default"](config.target).attr('id', id); 3753 } 3754 3755 config.target = "#" + id; 3756 } 3757 3758 Util.typeCheckConfig(NAME$2, config, DefaultType$1); 3759 return config; 3760 }; 3761 3762 _proto._getScrollTop = function _getScrollTop() { 3763 return this._scrollElement === window ? this._scrollElement.pageYOffset : this._scrollElement.scrollTop; 3764 }; 3765 3766 _proto._getScrollHeight = function _getScrollHeight() { 3767 return this._scrollElement.scrollHeight || Math.max(document.body.scrollHeight, document.documentElement.scrollHeight); 3768 }; 3769 3770 _proto._getOffsetHeight = function _getOffsetHeight() { 3771 return this._scrollElement === window ? window.innerHeight : this._scrollElement.getBoundingClientRect().height; 3772 }; 3773 3774 _proto._process = function _process() { 3775 var scrollTop = this._getScrollTop() + this._config.offset; 3776 3777 var scrollHeight = this._getScrollHeight(); 3778 3779 var maxScroll = this._config.offset + scrollHeight - this._getOffsetHeight(); 3780 3781 if (this._scrollHeight !== scrollHeight) { 3782 this.refresh(); 3783 } 3784 3785 if (scrollTop >= maxScroll) { 3786 var target = this._targets[this._targets.length - 1]; 3787 3788 if (this._activeTarget !== target) { 3789 this._activate(target); 3790 } 3791 3792 return; 3793 } 3794 3795 if (this._activeTarget && scrollTop < this._offsets[0] && this._offsets[0] > 0) { 3796 this._activeTarget = null; 3797 3798 this._clear(); 3799 3800 return; 3801 } 3802 3803 for (var i = this._offsets.length; i--;) { 3804 var isActiveTarget = this._activeTarget !== this._targets[i] && scrollTop >= this._offsets[i] && (typeof this._offsets[i + 1] === 'undefined' || scrollTop < this._offsets[i + 1]); 3805 3806 if (isActiveTarget) { 3807 this._activate(this._targets[i]); 3808 } 3809 } 3810 }; 3811 3812 _proto._activate = function _activate(target) { 3813 this._activeTarget = target; 3814 3815 this._clear(); 3816 3817 var queries = this._selector.split(',').map(function (selector) { 3818 return selector + "[data-target=\"" + target + "\"]," + selector + "[href=\"" + target + "\"]"; 3819 }); 3820 3821 var $link = $__default["default"]([].slice.call(document.querySelectorAll(queries.join(',')))); 3822 3823 if ($link.hasClass(CLASS_NAME_DROPDOWN_ITEM)) { 3824 $link.closest(SELECTOR_DROPDOWN$1).find(SELECTOR_DROPDOWN_TOGGLE$1).addClass(CLASS_NAME_ACTIVE$1); 3825 $link.addClass(CLASS_NAME_ACTIVE$1); 3826 } else { 3827 // Set triggered link as active 3828 $link.addClass(CLASS_NAME_ACTIVE$1); // Set triggered links parents as active 3829 // With both <ul> and <nav> markup a parent is the previous sibling of any nav ancestor 3830 3831 $link.parents(SELECTOR_NAV_LIST_GROUP$1).prev(SELECTOR_NAV_LINKS + ", " + SELECTOR_LIST_ITEMS).addClass(CLASS_NAME_ACTIVE$1); // Handle special case when .nav-link is inside .nav-item 3832 3833 $link.parents(SELECTOR_NAV_LIST_GROUP$1).prev(SELECTOR_NAV_ITEMS).children(SELECTOR_NAV_LINKS).addClass(CLASS_NAME_ACTIVE$1); 3834 } 3835 3836 $__default["default"](this._scrollElement).trigger(EVENT_ACTIVATE, { 3837 relatedTarget: target 3838 }); 3839 }; 3840 3841 _proto._clear = function _clear() { 3842 [].slice.call(document.querySelectorAll(this._selector)).filter(function (node) { 3843 return node.classList.contains(CLASS_NAME_ACTIVE$1); 3844 }).forEach(function (node) { 3845 return node.classList.remove(CLASS_NAME_ACTIVE$1); 3846 }); 3847 } // Static 3848 ; 3849 3850 ScrollSpy._jQueryInterface = function _jQueryInterface(config) { 3851 return this.each(function () { 3852 var data = $__default["default"](this).data(DATA_KEY$2); 3853 3854 var _config = typeof config === 'object' && config; 3855 3856 if (!data) { 3857 data = new ScrollSpy(this, _config); 3858 $__default["default"](this).data(DATA_KEY$2, data); 3859 } 3860 3861 if (typeof config === 'string') { 3862 if (typeof data[config] === 'undefined') { 3863 throw new TypeError("No method named \"" + config + "\""); 3864 } 3865 3866 data[config](); 3867 } 3868 }); 3869 }; 3870 3871 _createClass(ScrollSpy, null, [{ 3872 key: "VERSION", 3873 get: function get() { 3874 return VERSION$2; 3875 } 3876 }, { 3877 key: "Default", 3878 get: function get() { 3879 return Default$1; 3880 } 3881 }]); 3882 3883 return ScrollSpy; 3884 }(); 3885 /** 3886 * Data API implementation 3887 */ 3888 3889 3890 $__default["default"](window).on(EVENT_LOAD_DATA_API, function () { 3891 var scrollSpys = [].slice.call(document.querySelectorAll(SELECTOR_DATA_SPY)); 3892 var scrollSpysLength = scrollSpys.length; 3893 3894 for (var i = scrollSpysLength; i--;) { 3895 var $spy = $__default["default"](scrollSpys[i]); 3896 3897 ScrollSpy._jQueryInterface.call($spy, $spy.data()); 3898 } 3899 }); 3900 /** 3901 * jQuery 3902 */ 3903 3904 $__default["default"].fn[NAME$2] = ScrollSpy._jQueryInterface; 3905 $__default["default"].fn[NAME$2].Constructor = ScrollSpy; 3906 3907 $__default["default"].fn[NAME$2].noConflict = function () { 3908 $__default["default"].fn[NAME$2] = JQUERY_NO_CONFLICT$2; 3909 return ScrollSpy._jQueryInterface; 3910 }; 3911 3912 /** 3913 * Constants 3914 */ 3915 3916 var NAME$1 = 'tab'; 3917 var VERSION$1 = '4.6.2'; 3918 var DATA_KEY$1 = 'bs.tab'; 3919 var EVENT_KEY$1 = "." + DATA_KEY$1; 3920 var DATA_API_KEY = '.data-api'; 3921 var JQUERY_NO_CONFLICT$1 = $__default["default"].fn[NAME$1]; 3922 var CLASS_NAME_DROPDOWN_MENU = 'dropdown-menu'; 3923 var CLASS_NAME_ACTIVE = 'active'; 3924 var CLASS_NAME_DISABLED = 'disabled'; 3925 var CLASS_NAME_FADE$1 = 'fade'; 3926 var CLASS_NAME_SHOW$1 = 'show'; 3927 var EVENT_HIDE$1 = "hide" + EVENT_KEY$1; 3928 var EVENT_HIDDEN$1 = "hidden" + EVENT_KEY$1; 3929 var EVENT_SHOW$1 = "show" + EVENT_KEY$1; 3930 var EVENT_SHOWN$1 = "shown" + EVENT_KEY$1; 3931 var EVENT_CLICK_DATA_API = "click" + EVENT_KEY$1 + DATA_API_KEY; 3932 var SELECTOR_DROPDOWN = '.dropdown'; 3933 var SELECTOR_NAV_LIST_GROUP = '.nav, .list-group'; 3934 var SELECTOR_ACTIVE = '.active'; 3935 var SELECTOR_ACTIVE_UL = '> li > .active'; 3936 var SELECTOR_DATA_TOGGLE = '[data-toggle="tab"], [data-toggle="pill"], [data-toggle="list"]'; 3937 var SELECTOR_DROPDOWN_TOGGLE = '.dropdown-toggle'; 3938 var SELECTOR_DROPDOWN_ACTIVE_CHILD = '> .dropdown-menu .active'; 3939 /** 3940 * Class definition 3941 */ 3942 3943 var Tab = /*#__PURE__*/function () { 3944 function Tab(element) { 3945 this._element = element; 3946 } // Getters 3947 3948 3949 var _proto = Tab.prototype; 3950 3951 // Public 3952 _proto.show = function show() { 3953 var _this = this; 3954 3955 if (this._element.parentNode && this._element.parentNode.nodeType === Node.ELEMENT_NODE && $__default["default"](this._element).hasClass(CLASS_NAME_ACTIVE) || $__default["default"](this._element).hasClass(CLASS_NAME_DISABLED) || this._element.hasAttribute('disabled')) { 3956 return; 3957 } 3958 3959 var target; 3960 var previous; 3961 var listElement = $__default["default"](this._element).closest(SELECTOR_NAV_LIST_GROUP)[0]; 3962 var selector = Util.getSelectorFromElement(this._element); 3963 3964 if (listElement) { 3965 var itemSelector = listElement.nodeName === 'UL' || listElement.nodeName === 'OL' ? SELECTOR_ACTIVE_UL : SELECTOR_ACTIVE; 3966 previous = $__default["default"].makeArray($__default["default"](listElement).find(itemSelector)); 3967 previous = previous[previous.length - 1]; 3968 } 3969 3970 var hideEvent = $__default["default"].Event(EVENT_HIDE$1, { 3971 relatedTarget: this._element 3972 }); 3973 var showEvent = $__default["default"].Event(EVENT_SHOW$1, { 3974 relatedTarget: previous 3975 }); 3976 3977 if (previous) { 3978 $__default["default"](previous).trigger(hideEvent); 3979 } 3980 3981 $__default["default"](this._element).trigger(showEvent); 3982 3983 if (showEvent.isDefaultPrevented() || hideEvent.isDefaultPrevented()) { 3984 return; 3985 } 3986 3987 if (selector) { 3988 target = document.querySelector(selector); 3989 } 3990 3991 this._activate(this._element, listElement); 3992 3993 var complete = function complete() { 3994 var hiddenEvent = $__default["default"].Event(EVENT_HIDDEN$1, { 3995 relatedTarget: _this._element 3996 }); 3997 var shownEvent = $__default["default"].Event(EVENT_SHOWN$1, { 3998 relatedTarget: previous 3999 }); 4000 $__default["default"](previous).trigger(hiddenEvent); 4001 $__default["default"](_this._element).trigger(shownEvent); 4002 }; 4003 4004 if (target) { 4005 this._activate(target, target.parentNode, complete); 4006 } else { 4007 complete(); 4008 } 4009 }; 4010 4011 _proto.dispose = function dispose() { 4012 $__default["default"].removeData(this._element, DATA_KEY$1); 4013 this._element = null; 4014 } // Private 4015 ; 4016 4017 _proto._activate = function _activate(element, container, callback) { 4018 var _this2 = this; 4019 4020 var activeElements = container && (container.nodeName === 'UL' || container.nodeName === 'OL') ? $__default["default"](container).find(SELECTOR_ACTIVE_UL) : $__default["default"](container).children(SELECTOR_ACTIVE); 4021 var active = activeElements[0]; 4022 var isTransitioning = callback && active && $__default["default"](active).hasClass(CLASS_NAME_FADE$1); 4023 4024 var complete = function complete() { 4025 return _this2._transitionComplete(element, active, callback); 4026 }; 4027 4028 if (active && isTransitioning) { 4029 var transitionDuration = Util.getTransitionDurationFromElement(active); 4030 $__default["default"](active).removeClass(CLASS_NAME_SHOW$1).one(Util.TRANSITION_END, complete).emulateTransitionEnd(transitionDuration); 4031 } else { 4032 complete(); 4033 } 4034 }; 4035 4036 _proto._transitionComplete = function _transitionComplete(element, active, callback) { 4037 if (active) { 4038 $__default["default"](active).removeClass(CLASS_NAME_ACTIVE); 4039 var dropdownChild = $__default["default"](active.parentNode).find(SELECTOR_DROPDOWN_ACTIVE_CHILD)[0]; 4040 4041 if (dropdownChild) { 4042 $__default["default"](dropdownChild).removeClass(CLASS_NAME_ACTIVE); 4043 } 4044 4045 if (active.getAttribute('role') === 'tab') { 4046 active.setAttribute('aria-selected', false); 4047 } 4048 } 4049 4050 $__default["default"](element).addClass(CLASS_NAME_ACTIVE); 4051 4052 if (element.getAttribute('role') === 'tab') { 4053 element.setAttribute('aria-selected', true); 4054 } 4055 4056 Util.reflow(element); 4057 4058 if (element.classList.contains(CLASS_NAME_FADE$1)) { 4059 element.classList.add(CLASS_NAME_SHOW$1); 4060 } 4061 4062 var parent = element.parentNode; 4063 4064 if (parent && parent.nodeName === 'LI') { 4065 parent = parent.parentNode; 4066 } 4067 4068 if (parent && $__default["default"](parent).hasClass(CLASS_NAME_DROPDOWN_MENU)) { 4069 var dropdownElement = $__default["default"](element).closest(SELECTOR_DROPDOWN)[0]; 4070 4071 if (dropdownElement) { 4072 var dropdownToggleList = [].slice.call(dropdownElement.querySelectorAll(SELECTOR_DROPDOWN_TOGGLE)); 4073 $__default["default"](dropdownToggleList).addClass(CLASS_NAME_ACTIVE); 4074 } 4075 4076 element.setAttribute('aria-expanded', true); 4077 } 4078 4079 if (callback) { 4080 callback(); 4081 } 4082 } // Static 4083 ; 4084 4085 Tab._jQueryInterface = function _jQueryInterface(config) { 4086 return this.each(function () { 4087 var $this = $__default["default"](this); 4088 var data = $this.data(DATA_KEY$1); 4089 4090 if (!data) { 4091 data = new Tab(this); 4092 $this.data(DATA_KEY$1, data); 4093 } 4094 4095 if (typeof config === 'string') { 4096 if (typeof data[config] === 'undefined') { 4097 throw new TypeError("No method named \"" + config + "\""); 4098 } 4099 4100 data[config](); 4101 } 4102 }); 4103 }; 4104 4105 _createClass(Tab, null, [{ 4106 key: "VERSION", 4107 get: function get() { 4108 return VERSION$1; 4109 } 4110 }]); 4111 4112 return Tab; 4113 }(); 4114 /** 4115 * Data API implementation 4116 */ 4117 4118 4119 $__default["default"](document).on(EVENT_CLICK_DATA_API, SELECTOR_DATA_TOGGLE, function (event) { 4120 event.preventDefault(); 4121 4122 Tab._jQueryInterface.call($__default["default"](this), 'show'); 4123 }); 4124 /** 4125 * jQuery 4126 */ 4127 4128 $__default["default"].fn[NAME$1] = Tab._jQueryInterface; 4129 $__default["default"].fn[NAME$1].Constructor = Tab; 4130 4131 $__default["default"].fn[NAME$1].noConflict = function () { 4132 $__default["default"].fn[NAME$1] = JQUERY_NO_CONFLICT$1; 4133 return Tab._jQueryInterface; 4134 }; 4135 4136 /** 4137 * Constants 4138 */ 4139 4140 var NAME = 'toast'; 4141 var VERSION = '4.6.2'; 4142 var DATA_KEY = 'bs.toast'; 4143 var EVENT_KEY = "." + DATA_KEY; 4144 var JQUERY_NO_CONFLICT = $__default["default"].fn[NAME]; 4145 var CLASS_NAME_FADE = 'fade'; 4146 var CLASS_NAME_HIDE = 'hide'; 4147 var CLASS_NAME_SHOW = 'show'; 4148 var CLASS_NAME_SHOWING = 'showing'; 4149 var EVENT_CLICK_DISMISS = "click.dismiss" + EVENT_KEY; 4150 var EVENT_HIDE = "hide" + EVENT_KEY; 4151 var EVENT_HIDDEN = "hidden" + EVENT_KEY; 4152 var EVENT_SHOW = "show" + EVENT_KEY; 4153 var EVENT_SHOWN = "shown" + EVENT_KEY; 4154 var SELECTOR_DATA_DISMISS = '[data-dismiss="toast"]'; 4155 var Default = { 4156 animation: true, 4157 autohide: true, 4158 delay: 500 4159 }; 4160 var DefaultType = { 4161 animation: 'boolean', 4162 autohide: 'boolean', 4163 delay: 'number' 4164 }; 4165 /** 4166 * Class definition 4167 */ 4168 4169 var Toast = /*#__PURE__*/function () { 4170 function Toast(element, config) { 4171 this._element = element; 4172 this._config = this._getConfig(config); 4173 this._timeout = null; 4174 4175 this._setListeners(); 4176 } // Getters 4177 4178 4179 var _proto = Toast.prototype; 4180 4181 // Public 4182 _proto.show = function show() { 4183 var _this = this; 4184 4185 var showEvent = $__default["default"].Event(EVENT_SHOW); 4186 $__default["default"](this._element).trigger(showEvent); 4187 4188 if (showEvent.isDefaultPrevented()) { 4189 return; 4190 } 4191 4192 this._clearTimeout(); 4193 4194 if (this._config.animation) { 4195 this._element.classList.add(CLASS_NAME_FADE); 4196 } 4197 4198 var complete = function complete() { 4199 _this._element.classList.remove(CLASS_NAME_SHOWING); 4200 4201 _this._element.classList.add(CLASS_NAME_SHOW); 4202 4203 $__default["default"](_this._element).trigger(EVENT_SHOWN); 4204 4205 if (_this._config.autohide) { 4206 _this._timeout = setTimeout(function () { 4207 _this.hide(); 4208 }, _this._config.delay); 4209 } 4210 }; 4211 4212 this._element.classList.remove(CLASS_NAME_HIDE); 4213 4214 Util.reflow(this._element); 4215 4216 this._element.classList.add(CLASS_NAME_SHOWING); 4217 4218 if (this._config.animation) { 4219 var transitionDuration = Util.getTransitionDurationFromElement(this._element); 4220 $__default["default"](this._element).one(Util.TRANSITION_END, complete).emulateTransitionEnd(transitionDuration); 4221 } else { 4222 complete(); 4223 } 4224 }; 4225 4226 _proto.hide = function hide() { 4227 if (!this._element.classList.contains(CLASS_NAME_SHOW)) { 4228 return; 4229 } 4230 4231 var hideEvent = $__default["default"].Event(EVENT_HIDE); 4232 $__default["default"](this._element).trigger(hideEvent); 4233 4234 if (hideEvent.isDefaultPrevented()) { 4235 return; 4236 } 4237 4238 this._close(); 4239 }; 4240 4241 _proto.dispose = function dispose() { 4242 this._clearTimeout(); 4243 4244 if (this._element.classList.contains(CLASS_NAME_SHOW)) { 4245 this._element.classList.remove(CLASS_NAME_SHOW); 4246 } 4247 4248 $__default["default"](this._element).off(EVENT_CLICK_DISMISS); 4249 $__default["default"].removeData(this._element, DATA_KEY); 4250 this._element = null; 4251 this._config = null; 4252 } // Private 4253 ; 4254 4255 _proto._getConfig = function _getConfig(config) { 4256 config = _extends({}, Default, $__default["default"](this._element).data(), typeof config === 'object' && config ? config : {}); 4257 Util.typeCheckConfig(NAME, config, this.constructor.DefaultType); 4258 return config; 4259 }; 4260 4261 _proto._setListeners = function _setListeners() { 4262 var _this2 = this; 4263 4264 $__default["default"](this._element).on(EVENT_CLICK_DISMISS, SELECTOR_DATA_DISMISS, function () { 4265 return _this2.hide(); 4266 }); 4267 }; 4268 4269 _proto._close = function _close() { 4270 var _this3 = this; 4271 4272 var complete = function complete() { 4273 _this3._element.classList.add(CLASS_NAME_HIDE); 4274 4275 $__default["default"](_this3._element).trigger(EVENT_HIDDEN); 4276 }; 4277 4278 this._element.classList.remove(CLASS_NAME_SHOW); 4279 4280 if (this._config.animation) { 4281 var transitionDuration = Util.getTransitionDurationFromElement(this._element); 4282 $__default["default"](this._element).one(Util.TRANSITION_END, complete).emulateTransitionEnd(transitionDuration); 4283 } else { 4284 complete(); 4285 } 4286 }; 4287 4288 _proto._clearTimeout = function _clearTimeout() { 4289 clearTimeout(this._timeout); 4290 this._timeout = null; 4291 } // Static 4292 ; 4293 4294 Toast._jQueryInterface = function _jQueryInterface(config) { 4295 return this.each(function () { 4296 var $element = $__default["default"](this); 4297 var data = $element.data(DATA_KEY); 4298 4299 var _config = typeof config === 'object' && config; 4300 4301 if (!data) { 4302 data = new Toast(this, _config); 4303 $element.data(DATA_KEY, data); 4304 } 4305 4306 if (typeof config === 'string') { 4307 if (typeof data[config] === 'undefined') { 4308 throw new TypeError("No method named \"" + config + "\""); 4309 } 4310 4311 data[config](this); 4312 } 4313 }); 4314 }; 4315 4316 _createClass(Toast, null, [{ 4317 key: "VERSION", 4318 get: function get() { 4319 return VERSION; 4320 } 4321 }, { 4322 key: "DefaultType", 4323 get: function get() { 4324 return DefaultType; 4325 } 4326 }, { 4327 key: "Default", 4328 get: function get() { 4329 return Default; 4330 } 4331 }]); 4332 4333 return Toast; 4334 }(); 4335 /** 4336 * jQuery 4337 */ 4338 4339 4340 $__default["default"].fn[NAME] = Toast._jQueryInterface; 4341 $__default["default"].fn[NAME].Constructor = Toast; 4342 4343 $__default["default"].fn[NAME].noConflict = function () { 4344 $__default["default"].fn[NAME] = JQUERY_NO_CONFLICT; 4345 return Toast._jQueryInterface; 4346 }; 4347 4348 exports.Alert = Alert; 4349 exports.Button = Button; 4350 exports.Carousel = Carousel; 4351 exports.Collapse = Collapse; 4352 exports.Dropdown = Dropdown; 4353 exports.Modal = Modal; 4354 exports.Popover = Popover; 4355 exports.Scrollspy = ScrollSpy; 4356 exports.Tab = Tab; 4357 exports.Toast = Toast; 4358 exports.Tooltip = Tooltip; 4359 exports.Util = Util; 4360 4361 Object.defineProperty(exports, '__esModule', { value: true }); 4362 4363})); 4364//# sourceMappingURL=bootstrap.js.d41d8cd98f00.map 4365 4366 4367/***/ }), 4368
vendor: 365 bytes, lines 4369-4384
4369/***/ "./node_modules/can-use-dom/index.js": 4370/*!*******************************************!*\ 4371 !*** ./node_modules/can-use-dom/index.js ***! 4372 \*******************************************/ 4373/***/ ((module) => { 4374 4375var canUseDOM = !!( 4376 typeof window !== 'undefined' && 4377 window.document && 4378 window.document.createElement 4379); 4380 4381module.exports = canUseDOM; 4382 4383/***/ }), 4384
vendor: 285,755 bytes, lines 4385-15111
4385/***/ "./node_modules/jquery/dist/jquery.js": 4386/*!********************************************!*\ 4387 !*** ./node_modules/jquery/dist/jquery.js ***! 4388 \********************************************/ 4389/***/ (function(module, exports) { 4390 4391var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/*! 4392 * jQuery JavaScript Library v3.7.1 4393 * https://jquery.com/ 4394 * 4395 * Copyright OpenJS Foundation and other contributors 4396 * Released under the MIT license 4397 * https://jquery.org/license 4398 * 4399 * Date: 2023-08-28T13:37Z 4400 */ 4401( function( global, factory ) { 4402 4403 "use strict"; 4404 4405 if ( true && typeof module.exports === "object" ) { 4406 4407 // For CommonJS and CommonJS-like environments where a proper `window` 4408 // is present, execute the factory and get jQuery. 4409 // For environments that do not have a `window` with a `document` 4410 // (such as Node.js), expose a factory as module.exports. 4411 // This accentuates the need for the creation of a real `window`. 4412 // e.g. var jQuery = require("jquery")(window); 4413 // See ticket trac-14549 for more info. 4414 module.exports = global.document ? 4415 factory( global, true ) : 4416 function( w ) { 4417 if ( !w.document ) { 4418 throw new Error( "jQuery requires a window with a document" ); 4419 } 4420 return factory( w ); 4421 }; 4422 } else { 4423 factory( global ); 4424 } 4425 4426// Pass this if window is not defined yet 4427} )( typeof window !== "undefined" ? window : this, function( window, noGlobal ) { 4428 4429// Edge <= 12 - 13+, Firefox <=18 - 45+, IE 10 - 11, Safari 5.1 - 9+, iOS 6 - 9.1 4430// throw exceptions when non-strict code (e.g., ASP.NET 4.5) accesses strict mode 4431// arguments.callee.caller (trac-13335). But as of jQuery 3.0 (2016), strict mode should be common 4432// enough that all such attempts are guarded in a try block. 4433"use strict"; 4434 4435var arr = []; 4436 4437var getProto = Object.getPrototypeOf; 4438 4439var slice = arr.slice; 4440 4441var flat = arr.flat ? function( array ) { 4442 return arr.flat.call( array ); 4443} : function( array ) { 4444 return arr.concat.apply( [], array ); 4445}; 4446 4447 4448var push = arr.push; 4449 4450var indexOf = arr.indexOf; 4451 4452var class2type = {}; 4453 4454var toString = class2type.toString; 4455 4456var hasOwn = class2type.hasOwnProperty; 4457 4458var fnToString = hasOwn.toString; 4459 4460var ObjectFunctionString = fnToString.call( Object ); 4461 4462var support = {}; 4463 4464var isFunction = function isFunction( obj ) { 4465 4466 // Support: Chrome <=57, Firefox <=52 4467 // In some browsers, typeof returns "function" for HTML <object> elements 4468 // (i.e., `typeof document.createElement( "object" ) === "function"`). 4469 // We don't want to classify *any* DOM node as a function. 4470 // Support: QtWeb <=3.8.5, WebKit <=534.34, wkhtmltopdf tool <=0.12.5 4471 // Plus for old WebKit, typeof returns "function" for HTML collections 4472 // (e.g., `typeof document.getElementsByTagName("div") === "function"`). (gh-4756) 4473 return typeof obj === "function" && typeof obj.nodeType !== "number" && 4474 typeof obj.item !== "function"; 4475 }; 4476 4477 4478var isWindow = function isWindow( obj ) { 4479 return obj != null && obj === obj.window; 4480 }; 4481 4482 4483var document = window.document; 4484 4485 4486 4487 var preservedScriptAttributes = { 4488 type: true, 4489 src: true, 4490 nonce: true, 4491 noModule: true 4492 }; 4493 4494 function DOMEval( code, node, doc ) { 4495 doc = doc || document; 4496 4497 var i, val, 4498 script = doc.createElement( "script" ); 4499 4500 script.text = code; 4501 if ( node ) { 4502 for ( i in preservedScriptAttributes ) { 4503 4504 // Support: Firefox 64+, Edge 18+ 4505 // Some browsers don't support the "nonce" property on scripts. 4506 // On the other hand, just using `getAttribute` is not enough as 4507 // the `nonce` attribute is reset to an empty string whenever it 4508 // becomes browsing-context connected. 4509 // See https://github.com/whatwg/html/issues/2369 4510 // See https://html.spec.whatwg.org/#nonce-attributes 4511 // The `node.getAttribute` check was added for the sake of 4512 // `jQuery.globalEval` so that it can fake a nonce-containing node 4513 // via an object. 4514 val = node[ i ] || node.getAttribute && node.getAttribute( i ); 4515 if ( val ) { 4516 script.setAttribute( i, val ); 4517 } 4518 } 4519 } 4520 doc.head.appendChild( script ).parentNode.removeChild( script ); 4521 } 4522 4523 4524function toType( obj ) { 4525 if ( obj == null ) { 4526 return obj + ""; 4527 } 4528 4529 // Support: Android <=2.3 only (functionish RegExp) 4530 return typeof obj === "object" || typeof obj === "function" ? 4531 class2type[ toString.call( obj ) ] || "object" : 4532 typeof obj; 4533} 4534/* global Symbol */ 4535// Defining this global in .eslintrc.json would create a danger of using the global 4536// unguarded in another place, it seems safer to define global only for this module 4537 4538 4539 4540var version = "3.7.1", 4541 4542 rhtmlSuffix = /HTML$/i, 4543 4544 // Define a local copy of jQuery 4545 jQuery = function( selector, context ) { 4546 4547 // The jQuery object is actually just the init constructor 'enhanced' 4548 // Need init if jQuery is called (just allow error to be thrown if not included) 4549 return new jQuery.fn.init( selector, context ); 4550 }; 4551 4552jQuery.fn = jQuery.prototype = { 4553 4554 // The current version of jQuery being used 4555 jquery: version, 4556 4557 constructor: jQuery, 4558 4559 // The default length of a jQuery object is 0 4560 length: 0, 4561 4562 toArray: function() { 4563 return slice.call( this ); 4564 }, 4565 4566 // Get the Nth element in the matched element set OR 4567 // Get the whole matched element set as a clean array 4568 get: function( num ) { 4569 4570 // Return all the elements in a clean array 4571 if ( num == null ) { 4572 return slice.call( this ); 4573 } 4574 4575 // Return just the one element from the set 4576 return num < 0 ? this[ num + this.length ] : this[ num ]; 4577 }, 4578 4579 // Take an array of elements and push it onto the stack 4580 // (returning the new matched element set) 4581 pushStack: function( elems ) { 4582 4583 // Build a new jQuery matched element set 4584 var ret = jQuery.merge( this.constructor(), elems ); 4585 4586 // Add the old object onto the stack (as a reference) 4587 ret.prevObject = this; 4588 4589 // Return the newly-formed element set 4590 return ret; 4591 }, 4592 4593 // Execute a callback for every element in the matched set. 4594 each: function( callback ) { 4595 return jQuery.each( this, callback ); 4596 }, 4597 4598 map: function( callback ) { 4599 return this.pushStack( jQuery.map( this, function( elem, i ) { 4600 return callback.call( elem, i, elem ); 4601 } ) ); 4602 }, 4603 4604 slice: function() { 4605 return this.pushStack( slice.apply( this, arguments ) ); 4606 }, 4607 4608 first: function() { 4609 return this.eq( 0 ); 4610 }, 4611 4612 last: function() { 4613 return this.eq( -1 ); 4614 }, 4615 4616 even: function() { 4617 return this.pushStack( jQuery.grep( this, function( _elem, i ) { 4618 return ( i + 1 ) % 2; 4619 } ) ); 4620 }, 4621 4622 odd: function() { 4623 return this.pushStack( jQuery.grep( this, function( _elem, i ) { 4624 return i % 2; 4625 } ) ); 4626 }, 4627 4628 eq: function( i ) { 4629 var len = this.length, 4630 j = +i + ( i < 0 ? len : 0 ); 4631 return this.pushStack( j >= 0 && j < len ? [ this[ j ] ] : [] ); 4632 }, 4633 4634 end: function() { 4635 return this.prevObject || this.constructor(); 4636 }, 4637 4638 // For internal use only. 4639 // Behaves like an Array's method, not like a jQuery method. 4640 push: push, 4641 sort: arr.sort, 4642 splice: arr.splice 4643}; 4644 4645jQuery.extend = jQuery.fn.extend = function() { 4646 var options, name, src, copy, copyIsArray, clone, 4647 target = arguments[ 0 ] || {}, 4648 i = 1, 4649 length = arguments.length, 4650 deep = false; 4651 4652 // Handle a deep copy situation 4653 if ( typeof target === "boolean" ) { 4654 deep = target; 4655 4656 // Skip the boolean and the target 4657 target = arguments[ i ] || {}; 4658 i++; 4659 } 4660 4661 // Handle case when target is a string or something (possible in deep copy) 4662 if ( typeof target !== "object" && !isFunction( target ) ) { 4663 target = {}; 4664 } 4665 4666 // Extend jQuery itself if only one argument is passed 4667 if ( i === length ) { 4668 target = this; 4669 i--; 4670 } 4671 4672 for ( ; i < length; i++ ) { 4673 4674 // Only deal with non-null/undefined values 4675 if ( ( options = arguments[ i ] ) != null ) { 4676 4677 // Extend the base object 4678 for ( name in options ) { 4679 copy = options[ name ]; 4680 4681 // Prevent Object.prototype pollution 4682 // Prevent never-ending loop 4683 if ( name === "__proto__" || target === copy ) { 4684 continue; 4685 } 4686 4687 // Recurse if we're merging plain objects or arrays 4688 if ( deep && copy && ( jQuery.isPlainObject( copy ) || 4689 ( copyIsArray = Array.isArray( copy ) ) ) ) { 4690 src = target[ name ]; 4691 4692 // Ensure proper type for the source value 4693 if ( copyIsArray && !Array.isArray( src ) ) { 4694 clone = []; 4695 } else if ( !copyIsArray && !jQuery.isPlainObject( src ) ) { 4696 clone = {}; 4697 } else { 4698 clone = src; 4699 } 4700 copyIsArray = false; 4701 4702 // Never move original objects, clone them 4703 target[ name ] = jQuery.extend( deep, clone, copy ); 4704 4705 // Don't bring in undefined values 4706 } else if ( copy !== undefined ) { 4707 target[ name ] = copy; 4708 } 4709 } 4710 } 4711 } 4712 4713 // Return the modified object 4714 return target; 4715}; 4716 4717jQuery.extend( { 4718 4719 // Unique for each copy of jQuery on the page 4720 expando: "jQuery" + ( version + Math.random() ).replace( /\D/g, "" ), 4721 4722 // Assume jQuery is ready without the ready module 4723 isReady: true, 4724 4725 error: function( msg ) { 4726 throw new Error( msg ); 4727 }, 4728 4729 noop: function() {}, 4730 4731 isPlainObject: function( obj ) { 4732 var proto, Ctor; 4733 4734 // Detect obvious negatives 4735 // Use toString instead of jQuery.type to catch host objects 4736 if ( !obj || toString.call( obj ) !== "[object Object]" ) { 4737 return false; 4738 } 4739 4740 proto = getProto( obj ); 4741 4742 // Objects with no prototype (e.g., `Object.create( null )`) are plain 4743 if ( !proto ) { 4744 return true; 4745 } 4746 4747 // Objects with prototype are plain iff they were constructed by a global Object function 4748 Ctor = hasOwn.call( proto, "constructor" ) && proto.constructor; 4749 return typeof Ctor === "function" && fnToString.call( Ctor ) === ObjectFunctionString; 4750 }, 4751 4752 isEmptyObject: function( obj ) { 4753 var name; 4754 4755 for ( name in obj ) { 4756 return false; 4757 } 4758 return true; 4759 }, 4760 4761 // Evaluates a script in a provided context; falls back to the global one 4762 // if not specified. 4763 globalEval: function( code, options, doc ) { 4764 DOMEval( code, { nonce: options && options.nonce }, doc ); 4765 }, 4766 4767 each: function( obj, callback ) { 4768 var length, i = 0; 4769 4770 if ( isArrayLike( obj ) ) { 4771 length = obj.length; 4772 for ( ; i < length; i++ ) { 4773 if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) { 4774 break; 4775 } 4776 } 4777 } else { 4778 for ( i in obj ) { 4779 if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) { 4780 break; 4781 } 4782 } 4783 } 4784 4785 return obj; 4786 }, 4787 4788 4789 // Retrieve the text value of an array of DOM nodes 4790 text: function( elem ) { 4791 var node, 4792 ret = "", 4793 i = 0, 4794 nodeType = elem.nodeType; 4795 4796 if ( !nodeType ) { 4797 4798 // If no nodeType, this is expected to be an array 4799 while ( ( node = elem[ i++ ] ) ) { 4800 4801 // Do not traverse comment nodes 4802 ret += jQuery.text( node ); 4803 } 4804 } 4805 if ( nodeType === 1 || nodeType === 11 ) { 4806 return elem.textContent; 4807 } 4808 if ( nodeType === 9 ) { 4809 return elem.documentElement.textContent; 4810 } 4811 if ( nodeType === 3 || nodeType === 4 ) { 4812 return elem.nodeValue; 4813 } 4814 4815 // Do not include comment or processing instruction nodes 4816 4817 return ret; 4818 }, 4819 4820 // results is for internal usage only 4821 makeArray: function( arr, results ) { 4822 var ret = results || []; 4823 4824 if ( arr != null ) { 4825 if ( isArrayLike( Object( arr ) ) ) { 4826 jQuery.merge( ret, 4827 typeof arr === "string" ? 4828 [ arr ] : arr 4829 ); 4830 } else { 4831 push.call( ret, arr ); 4832 } 4833 } 4834 4835 return ret; 4836 }, 4837 4838 inArray: function( elem, arr, i ) { 4839 return arr == null ? -1 : indexOf.call( arr, elem, i ); 4840 }, 4841 4842 isXMLDoc: function( elem ) { 4843 var namespace = elem && elem.namespaceURI, 4844 docElem = elem && ( elem.ownerDocument || elem ).documentElement; 4845 4846 // Assume HTML when documentElement doesn't yet exist, such as inside 4847 // document fragments. 4848 return !rhtmlSuffix.test( namespace || docElem && docElem.nodeName || "HTML" ); 4849 }, 4850 4851 // Support: Android <=4.0 only, PhantomJS 1 only 4852 // push.apply(_, arraylike) throws on ancient WebKit 4853 merge: function( first, second ) { 4854 var len = +second.length, 4855 j = 0, 4856 i = first.length; 4857 4858 for ( ; j < len; j++ ) { 4859 first[ i++ ] = second[ j ]; 4860 } 4861 4862 first.length = i; 4863 4864 return first; 4865 }, 4866 4867 grep: function( elems, callback, invert ) { 4868 var callbackInverse, 4869 matches = [], 4870 i = 0, 4871 length = elems.length, 4872 callbackExpect = !invert; 4873 4874 // Go through the array, only saving the items 4875 // that pass the validator function 4876 for ( ; i < length; i++ ) { 4877 callbackInverse = !callback( elems[ i ], i ); 4878 if ( callbackInverse !== callbackExpect ) { 4879 matches.push( elems[ i ] ); 4880 } 4881 } 4882 4883 return matches; 4884 }, 4885 4886 // arg is for internal usage only 4887 map: function( elems, callback, arg ) { 4888 var length, value, 4889 i = 0, 4890 ret = []; 4891 4892 // Go through the array, translating each of the items to their new values 4893 if ( isArrayLike( elems ) ) { 4894 length = elems.length; 4895 for ( ; i < length; i++ ) { 4896 value = callback( elems[ i ], i, arg ); 4897 4898 if ( value != null ) { 4899 ret.push( value ); 4900 } 4901 } 4902 4903 // Go through every key on the object, 4904 } else { 4905 for ( i in elems ) { 4906 value = callback( elems[ i ], i, arg ); 4907 4908 if ( value != null ) { 4909 ret.push( value ); 4910 } 4911 } 4912 } 4913 4914 // Flatten any nested arrays 4915 return flat( ret ); 4916 }, 4917 4918 // A global GUID counter for objects 4919 guid: 1, 4920 4921 // jQuery.support is not used in Core but other projects attach their 4922 // properties to it so it needs to exist. 4923 support: support 4924} ); 4925 4926if ( typeof Symbol === "function" ) { 4927 jQuery.fn[ Symbol.iterator ] = arr[ Symbol.iterator ]; 4928} 4929 4930// Populate the class2type map 4931jQuery.each( "Boolean Number String Function Array Date RegExp Object Error Symbol".split( " " ), 4932 function( _i, name ) { 4933 class2type[ "[object " + name + "]" ] = name.toLowerCase(); 4934 } ); 4935 4936function isArrayLike( obj ) { 4937 4938 // Support: real iOS 8.2 only (not reproducible in simulator) 4939 // `in` check used to prevent JIT error (gh-2145) 4940 // hasOwn isn't used here due to false negatives 4941 // regarding Nodelist length in IE 4942 var length = !!obj && "length" in obj && obj.length, 4943 type = toType( obj ); 4944 4945 if ( isFunction( obj ) || isWindow( obj ) ) { 4946 return false; 4947 } 4948 4949 return type === "array" || length === 0 || 4950 typeof length === "number" && length > 0 && ( length - 1 ) in obj; 4951} 4952 4953 4954function nodeName( elem, name ) { 4955 4956 return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase(); 4957 4958} 4959var pop = arr.pop; 4960 4961 4962var sort = arr.sort; 4963 4964 4965var splice = arr.splice; 4966 4967 4968var whitespace = "[\\x20\\t\\r\\n\\f]"; 4969 4970 4971var rtrimCSS = new RegExp( 4972 "^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" + whitespace + "+$", 4973 "g" 4974); 4975 4976 4977 4978 4979// Note: an element does not contain itself 4980jQuery.contains = function( a, b ) { 4981 var bup = b && b.parentNode; 4982 4983 return a === bup || !!( bup && bup.nodeType === 1 && ( 4984 4985 // Support: IE 9 - 11+ 4986 // IE doesn't have `contains` on SVG. 4987 a.contains ? 4988 a.contains( bup ) : 4989 a.compareDocumentPosition && a.compareDocumentPosition( bup ) & 16 4990 ) ); 4991}; 4992 4993 4994 4995 4996// CSS string/identifier serialization 4997// https://drafts.csswg.org/cssom/#common-serializing-idioms 4998var rcssescape = /([\0-\x1f\x7f]|^-?\d)|^-$|[^\x80-\uFFFF\w-]/g; 4999 5000function fcssescape( ch, asCodePoint ) { 5001 if ( asCodePoint ) { 5002 5003 // U+0000 NULL becomes U+FFFD REPLACEMENT CHARACTER 5004 if ( ch === "\0" ) { 5005 return "\uFFFD"; 5006 } 5007 5008 // Control characters and (dependent upon position) numbers get escaped as code points 5009 return ch.slice( 0, -1 ) + "\\" + ch.charCodeAt( ch.length - 1 ).toString( 16 ) + " "; 5010 } 5011 5012 // Other potentially-special ASCII characters get backslash-escaped 5013 return "\\" + ch; 5014} 5015 5016jQuery.escapeSelector = function( sel ) { 5017 return ( sel + "" ).replace( rcssescape, fcssescape ); 5018}; 5019 5020 5021 5022 5023var preferredDoc = document, 5024 pushNative = push; 5025 5026( function() { 5027 5028var i, 5029 Expr, 5030 outermostContext, 5031 sortInput, 5032 hasDuplicate, 5033 push = pushNative, 5034 5035 // Local document vars 5036 document, 5037 documentElement, 5038 documentIsHTML, 5039 rbuggyQSA, 5040 matches, 5041 5042 // Instance-specific data 5043 expando = jQuery.expando, 5044 dirruns = 0, 5045 done = 0, 5046 classCache = createCache(), 5047 tokenCache = createCache(), 5048 compilerCache = createCache(), 5049 nonnativeSelectorCache = createCache(), 5050 sortOrder = function( a, b ) { 5051 if ( a === b ) { 5052 hasDuplicate = true; 5053 } 5054 return 0; 5055 }, 5056 5057 booleans = "checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|" + 5058 "loop|multiple|open|readonly|required|scoped", 5059 5060 // Regular expressions 5061 5062 // https://www.w3.org/TR/css-syntax-3/#ident-token-diagram 5063 identifier = "(?:\\\\[\\da-fA-F]{1,6}" + whitespace + 5064 "?|\\\\[^\\r\\n\\f]|[\\w-]|[^\0-\\x7f])+", 5065 5066 // Attribute selectors: https://www.w3.org/TR/selectors/#attribute-selectors 5067 attributes = "\\[" + whitespace + "*(" + identifier + ")(?:" + whitespace + 5068 5069 // Operator (capture 2) 5070 "*([*^$|!~]?=)" + whitespace + 5071 5072 // "Attribute values must be CSS identifiers [capture 5] or strings [capture 3 or capture 4]" 5073 "*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|(" + identifier + "))|)" + 5074 whitespace + "*\\]", 5075 5076 pseudos = ":(" + identifier + ")(?:\\((" + 5077 5078 // To reduce the number of selectors needing tokenize in the preFilter, prefer arguments: 5079 // 1. quoted (capture 3; capture 4 or capture 5) 5080 "('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|" + 5081 5082 // 2. simple (capture 6) 5083 "((?:\\\\.|[^\\\\()[\\]]|" + attributes + ")*)|" + 5084 5085 // 3. anything else (capture 2) 5086 ".*" + 5087 ")\\)|)", 5088 5089 // Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter 5090 rwhitespace = new RegExp( whitespace + "+", "g" ), 5091 5092 rcomma = new RegExp( "^" + whitespace + "*," + whitespace + "*" ), 5093 rleadingCombinator = new RegExp( "^" + whitespace + "*([>+~]|" + whitespace + ")" + 5094 whitespace + "*" ), 5095 rdescend = new RegExp( whitespace + "|>" ), 5096 5097 rpseudo = new RegExp( pseudos ), 5098 ridentifier = new RegExp( "^" + identifier + "$" ), 5099 5100 matchExpr = { 5101 ID: new RegExp( "^#(" + identifier + ")" ), 5102 CLASS: new RegExp( "^\\.(" + identifier + ")" ), 5103 TAG: new RegExp( "^(" + identifier + "|[*])" ), 5104 ATTR: new RegExp( "^" + attributes ), 5105 PSEUDO: new RegExp( "^" + pseudos ), 5106 CHILD: new RegExp( 5107 "^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(" + 5108 whitespace + "*(even|odd|(([+-]|)(\\d*)n|)" + whitespace + "*(?:([+-]|)" + 5109 whitespace + "*(\\d+)|))" + whitespace + "*\\)|)", "i" ), 5110 bool: new RegExp( "^(?:" + booleans + ")$", "i" ), 5111 5112 // For use in libraries implementing .is() 5113 // We use this for POS matching in `select` 5114 needsContext: new RegExp( "^" + whitespace + 5115 "*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(" + whitespace + 5116 "*((?:-\\d)?\\d*)" + whitespace + "*\\)|)(?=[^-]|$)", "i" ) 5117 }, 5118 5119 rinputs = /^(?:input|select|textarea|button)$/i, 5120 rheader = /^h\d$/i, 5121 5122 // Easily-parseable/retrievable ID or TAG or CLASS selectors 5123 rquickExpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/, 5124 5125 rsibling = /[+~]/, 5126 5127 // CSS escapes 5128 // https://www.w3.org/TR/CSS21/syndata.html#escaped-characters 5129 runescape = new RegExp( "\\\\[\\da-fA-F]{1,6}" + whitespace + 5130 "?|\\\\([^\\r\\n\\f])", "g" ), 5131 funescape = function( escape, nonHex ) { 5132 var high = "0x" + escape.slice( 1 ) - 0x10000; 5133 5134 if ( nonHex ) { 5135 5136 // Strip the backslash prefix from a non-hex escape sequence 5137 return nonHex; 5138 } 5139 5140 // Replace a hexadecimal escape sequence with the encoded Unicode code point 5141 // Support: IE <=11+ 5142 // For values outside the Basic Multilingual Plane (BMP), manually construct a 5143 // surrogate pair 5144 return high < 0 ? 5145 String.fromCharCode( high + 0x10000 ) : 5146 String.fromCharCode( high >> 10 | 0xD800, high & 0x3FF | 0xDC00 ); 5147 }, 5148 5149 // Used for iframes; see `setDocument`. 5150 // Support: IE 9 - 11+, Edge 12 - 18+ 5151 // Removing the function wrapper causes a "Permission Denied" 5152 // error in IE/Edge. 5153 unloadHandler = function() { 5154 setDocument(); 5155 }, 5156 5157 inDisabledFieldset = addCombinator( 5158 function( elem ) { 5159 return elem.disabled === true && nodeName( elem, "fieldset" ); 5160 }, 5161 { dir: "parentNode", next: "legend" } 5162 ); 5163 5164// Support: IE <=9 only 5165// Accessing document.activeElement can throw unexpectedly 5166// https://bugs.jquery.com/ticket/13393 5167function safeActiveElement() { 5168 try { 5169 return document.activeElement; 5170 } catch ( err ) { } 5171} 5172 5173// Optimize for push.apply( _, NodeList ) 5174try { 5175 push.apply( 5176 ( arr = slice.call( preferredDoc.childNodes ) ), 5177 preferredDoc.childNodes 5178 ); 5179 5180 // Support: Android <=4.0 5181 // Detect silently failing push.apply 5182 // eslint-disable-next-line no-unused-expressions 5183 arr[ preferredDoc.childNodes.length ].nodeType; 5184} catch ( e ) { 5185 push = { 5186 apply: function( target, els ) { 5187 pushNative.apply( target, slice.call( els ) ); 5188 }, 5189 call: function( target ) { 5190 pushNative.apply( target, slice.call( arguments, 1 ) ); 5191 } 5192 }; 5193} 5194 5195function find( selector, context, results, seed ) { 5196 var m, i, elem, nid, match, groups, newSelector, 5197 newContext = context && context.ownerDocument, 5198 5199 // nodeType defaults to 9, since context defaults to document 5200 nodeType = context ? context.nodeType : 9; 5201 5202 results = results || []; 5203 5204 // Return early from calls with invalid selector or context 5205 if ( typeof selector !== "string" || !selector || 5206 nodeType !== 1 && nodeType !== 9 && nodeType !== 11 ) { 5207 5208 return results; 5209 } 5210 5211 // Try to shortcut find operations (as opposed to filters) in HTML documents 5212 if ( !seed ) { 5213 setDocument( context ); 5214 context = context || document; 5215 5216 if ( documentIsHTML ) { 5217 5218 // If the selector is sufficiently simple, try using a "get*By*" DOM method 5219 // (excepting DocumentFragment context, where the methods don't exist) 5220 if ( nodeType !== 11 && ( match = rquickExpr.exec( selector ) ) ) { 5221 5222 // ID selector 5223 if ( ( m = match[ 1 ] ) ) { 5224 5225 // Document context 5226 if ( nodeType === 9 ) { 5227 if ( ( elem = context.getElementById( m ) ) ) { 5228 5229 // Support: IE 9 only 5230 // getElementById can match elements by name instead of ID 5231 if ( elem.id === m ) { 5232 push.call( results, elem ); 5233 return results; 5234 } 5235 } else { 5236 return results; 5237 } 5238 5239 // Element context 5240 } else { 5241 5242 // Support: IE 9 only 5243 // getElementById can match elements by name instead of ID 5244 if ( newContext && ( elem = newContext.getElementById( m ) ) && 5245 find.contains( context, elem ) && 5246 elem.id === m ) { 5247 5248 push.call( results, elem ); 5249 return results; 5250 } 5251 } 5252 5253 // Type selector 5254 } else if ( match[ 2 ] ) { 5255 push.apply( results, context.getElementsByTagName( selector ) ); 5256 return results; 5257 5258 // Class selector 5259 } else if ( ( m = match[ 3 ] ) && context.getElementsByClassName ) { 5260 push.apply( results, context.getElementsByClassName( m ) ); 5261 return results; 5262 } 5263 } 5264 5265 // Take advantage of querySelectorAll 5266 if ( !nonnativeSelectorCache[ selector + " " ] && 5267 ( !rbuggyQSA || !rbuggyQSA.test( selector ) ) ) { 5268 5269 newSelector = selector; 5270 newContext = context; 5271 5272 // qSA considers elements outside a scoping root when evaluating child or 5273 // descendant combinators, which is not what we want. 5274 // In such cases, we work around the behavior by prefixing every selector in the 5275 // list with an ID selector referencing the scope context. 5276 // The technique has to be used as well when a leading combinator is used 5277 // as such selectors are not recognized by querySelectorAll. 5278 // Thanks to Andrew Dupont for this technique. 5279 if ( nodeType === 1 && 5280 ( rdescend.test( selector ) || rleadingCombinator.test( selector ) ) ) { 5281 5282 // Expand context for sibling selectors 5283 newContext = rsibling.test( selector ) && testContext( context.parentNode ) || 5284 context; 5285 5286 // We can use :scope instead of the ID hack if the browser 5287 // supports it & if we're not changing the context. 5288 // Support: IE 11+, Edge 17 - 18+ 5289 // IE/Edge sometimes throw a "Permission denied" error when 5290 // strict-comparing two documents; shallow comparisons work. 5291 // eslint-disable-next-line eqeqeq 5292 if ( newContext != context || !support.scope ) { 5293 5294 // Capture the context ID, setting it first if necessary 5295 if ( ( nid = context.getAttribute( "id" ) ) ) { 5296 nid = jQuery.escapeSelector( nid ); 5297 } else { 5298 context.setAttribute( "id", ( nid = expando ) ); 5299 } 5300 } 5301 5302 // Prefix every selector in the list 5303 groups = tokenize( selector ); 5304 i = groups.length; 5305 while ( i-- ) { 5306 groups[ i ] = ( nid ? "#" + nid : ":scope" ) + " " + 5307 toSelector( groups[ i ] ); 5308 } 5309 newSelector = groups.join( "," ); 5310 } 5311 5312 try { 5313 push.apply( results, 5314 newContext.querySelectorAll( newSelector ) 5315 ); 5316 return results; 5317 } catch ( qsaError ) { 5318 nonnativeSelectorCache( selector, true ); 5319 } finally { 5320 if ( nid === expando ) { 5321 context.removeAttribute( "id" ); 5322 } 5323 } 5324 } 5325 } 5326 } 5327 5328 // All others 5329 return select( selector.replace( rtrimCSS, "$1" ), context, results, seed ); 5330} 5331 5332/** 5333 * Create key-value caches of limited size 5334 * @returns {function(string, object)} Returns the Object data after storing it on itself with 5335 * property name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength) 5336 * deleting the oldest entry 5337 */ 5338function createCache() { 5339 var keys = []; 5340 5341 function cache( key, value ) { 5342 5343 // Use (key + " ") to avoid collision with native prototype properties 5344 // (see https://github.com/jquery/sizzle/issues/157) 5345 if ( keys.push( key + " " ) > Expr.cacheLength ) { 5346 5347 // Only keep the most recent entries 5348 delete cache[ keys.shift() ]; 5349 } 5350 return ( cache[ key + " " ] = value ); 5351 } 5352 return cache; 5353} 5354 5355/** 5356 * Mark a function for special use by jQuery selector module 5357 * @param {Function} fn The function to mark 5358 */ 5359function markFunction( fn ) { 5360 fn[ expando ] = true; 5361 return fn; 5362} 5363 5364/** 5365 * Support testing using an element 5366 * @param {Function} fn Passed the created element and returns a boolean result 5367 */ 5368function assert( fn ) { 5369 var el = document.createElement( "fieldset" ); 5370 5371 try { 5372 return !!fn( el ); 5373 } catch ( e ) { 5374 return false; 5375 } finally { 5376 5377 // Remove from its parent by default 5378 if ( el.parentNode ) { 5379 el.parentNode.removeChild( el ); 5380 } 5381 5382 // release memory in IE 5383 el = null; 5384 } 5385} 5386 5387/** 5388 * Returns a function to use in pseudos for input types 5389 * @param {String} type 5390 */ 5391function createInputPseudo( type ) { 5392 return function( elem ) { 5393 return nodeName( elem, "input" ) && elem.type === type; 5394 }; 5395} 5396 5397/** 5398 * Returns a function to use in pseudos for buttons 5399 * @param {String} type 5400 */ 5401function createButtonPseudo( type ) { 5402 return function( elem ) { 5403 return ( nodeName( elem, "input" ) || nodeName( elem, "button" ) ) && 5404 elem.type === type; 5405 }; 5406} 5407 5408/** 5409 * Returns a function to use in pseudos for :enabled/:disabled 5410 * @param {Boolean} disabled true for :disabled; false for :enabled 5411 */ 5412function createDisabledPseudo( disabled ) { 5413 5414 // Known :disabled false positives: fieldset[disabled] > legend:nth-of-type(n+2) :can-disable 5415 return function( elem ) { 5416 5417 // Only certain elements can match :enabled or :disabled 5418 // https://html.spec.whatwg.org/multipage/scripting.html#selector-enabled 5419 // https://html.spec.whatwg.org/multipage/scripting.html#selector-disabled 5420 if ( "form" in elem ) { 5421 5422 // Check for inherited disabledness on relevant non-disabled elements: 5423 // * listed form-associated elements in a disabled fieldset 5424 // https://html.spec.whatwg.org/multipage/forms.html#category-listed 5425 // https://html.spec.whatwg.org/multipage/forms.html#concept-fe-disabled 5426 // * option elements in a disabled optgroup 5427 // https://html.spec.whatwg.org/multipage/forms.html#concept-option-disabled 5428 // All such elements have a "form" property. 5429 if ( elem.parentNode && elem.disabled === false ) { 5430 5431 // Option elements defer to a parent optgroup if present 5432 if ( "label" in elem ) { 5433 if ( "label" in elem.parentNode ) { 5434 return elem.parentNode.disabled === disabled; 5435 } else { 5436 return elem.disabled === disabled; 5437 } 5438 } 5439 5440 // Support: IE 6 - 11+ 5441 // Use the isDisabled shortcut property to check for disabled fieldset ancestors 5442 return elem.isDisabled === disabled || 5443 5444 // Where there is no isDisabled, check manually 5445 elem.isDisabled !== !disabled && 5446 inDisabledFieldset( elem ) === disabled; 5447 } 5448 5449 return elem.disabled === disabled; 5450 5451 // Try to winnow out elements that can't be disabled before trusting the disabled property. 5452 // Some victims get caught in our net (label, legend, menu, track), but it shouldn't 5453 // even exist on them, let alone have a boolean value. 5454 } else if ( "label" in elem ) { 5455 return elem.disabled === disabled; 5456 } 5457 5458 // Remaining elements are neither :enabled nor :disabled 5459 return false; 5460 }; 5461} 5462 5463/** 5464 * Returns a function to use in pseudos for positionals 5465 * @param {Function} fn 5466 */ 5467function createPositionalPseudo( fn ) { 5468 return markFunction( function( argument ) { 5469 argument = +argument; 5470 return markFunction( function( seed, matches ) { 5471 var j, 5472 matchIndexes = fn( [], seed.length, argument ), 5473 i = matchIndexes.length; 5474 5475 // Match elements found at the specified indexes 5476 while ( i-- ) { 5477 if ( seed[ ( j = matchIndexes[ i ] ) ] ) { 5478 seed[ j ] = !( matches[ j ] = seed[ j ] ); 5479 } 5480 } 5481 } ); 5482 } ); 5483} 5484 5485/** 5486 * Checks a node for validity as a jQuery selector context 5487 * @param {Element|Object=} context 5488 * @returns {Element|Object|Boolean} The input node if acceptable, otherwise a falsy value 5489 */ 5490function testContext( context ) { 5491 return context && typeof context.getElementsByTagName !== "undefined" && context; 5492} 5493 5494/** 5495 * Sets document-related variables once based on the current document 5496 * @param {Element|Object} [node] An element or document object to use to set the document 5497 * @returns {Object} Returns the current document 5498 */ 5499function setDocument( node ) { 5500 var subWindow, 5501 doc = node ? node.ownerDocument || node : preferredDoc; 5502 5503 // Return early if doc is invalid or already selected 5504 // Support: IE 11+, Edge 17 - 18+ 5505 // IE/Edge sometimes throw a "Permission denied" error when strict-comparing 5506 // two documents; shallow comparisons work. 5507 // eslint-disable-next-line eqeqeq 5508 if ( doc == document || doc.nodeType !== 9 || !doc.documentElement ) { 5509 return document; 5510 } 5511 5512 // Update global variables 5513 document = doc; 5514 documentElement = document.documentElement; 5515 documentIsHTML = !jQuery.isXMLDoc( document ); 5516 5517 // Support: iOS 7 only, IE 9 - 11+ 5518 // Older browsers didn't support unprefixed `matches`. 5519 matches = documentElement.matches || 5520 documentElement.webkitMatchesSelector || 5521 documentElement.msMatchesSelector; 5522 5523 // Support: IE 9 - 11+, Edge 12 - 18+ 5524 // Accessing iframe documents after unload throws "permission denied" errors 5525 // (see trac-13936). 5526 // Limit the fix to IE & Edge Legacy; despite Edge 15+ implementing `matches`, 5527 // all IE 9+ and Edge Legacy versions implement `msMatchesSelector` as well. 5528 if ( documentElement.msMatchesSelector && 5529 5530 // Support: IE 11+, Edge 17 - 18+ 5531 // IE/Edge sometimes throw a "Permission denied" error when strict-comparing 5532 // two documents; shallow comparisons work. 5533 // eslint-disable-next-line eqeqeq 5534 preferredDoc != document && 5535 ( subWindow = document.defaultView ) && subWindow.top !== subWindow ) { 5536 5537 // Support: IE 9 - 11+, Edge 12 - 18+ 5538 subWindow.addEventListener( "unload", unloadHandler ); 5539 } 5540 5541 // Support: IE <10 5542 // Check if getElementById returns elements by name 5543 // The broken getElementById methods don't pick up programmatically-set names, 5544 // so use a roundabout getElementsByName test 5545 support.getById = assert( function( el ) { 5546 documentElement.appendChild( el ).id = jQuery.expando; 5547 return !document.getElementsByName || 5548 !document.getElementsByName( jQuery.expando ).length; 5549 } ); 5550 5551 // Support: IE 9 only 5552 // Check to see if it's possible to do matchesSelector 5553 // on a disconnected node. 5554 support.disconnectedMatch = assert( function( el ) { 5555 return matches.call( el, "*" ); 5556 } ); 5557 5558 // Support: IE 9 - 11+, Edge 12 - 18+ 5559 // IE/Edge don't support the :scope pseudo-class. 5560 support.scope = assert( function() { 5561 return document.querySelectorAll( ":scope" ); 5562 } ); 5563 5564 // Support: Chrome 105 - 111 only, Safari 15.4 - 16.3 only 5565 // Make sure the `:has()` argument is parsed unforgivingly. 5566 // We include `*` in the test to detect buggy implementations that are 5567 // _selectively_ forgiving (specifically when the list includes at least 5568 // one valid selector). 5569 // Note that we treat complete lack of support for `:has()` as if it were 5570 // spec-compliant support, which is fine because use of `:has()` in such 5571 // environments will fail in the qSA path and fall back to jQuery traversal 5572 // anyway. 5573 support.cssHas = assert( function() { 5574 try { 5575 document.querySelector( ":has(*,:jqfake)" ); 5576 return false; 5577 } catch ( e ) { 5578 return true; 5579 } 5580 } ); 5581 5582 // ID filter and find 5583 if ( support.getById ) { 5584 Expr.filter.ID = function( id ) { 5585 var attrId = id.replace( runescape, funescape ); 5586 return function( elem ) { 5587 return elem.getAttribute( "id" ) === attrId; 5588 }; 5589 }; 5590 Expr.find.ID = function( id, context ) { 5591 if ( typeof context.getElementById !== "undefined" && documentIsHTML ) { 5592 var elem = context.getElementById( id ); 5593 return elem ? [ elem ] : []; 5594 } 5595 }; 5596 } else { 5597 Expr.filter.ID = function( id ) { 5598 var attrId = id.replace( runescape, funescape ); 5599 return function( elem ) { 5600 var node = typeof elem.getAttributeNode !== "undefined" && 5601 elem.getAttributeNode( "id" ); 5602 return node && node.value === attrId; 5603 }; 5604 }; 5605 5606 // Support: IE 6 - 7 only 5607 // getElementById is not reliable as a find shortcut 5608 Expr.find.ID = function( id, context ) { 5609 if ( typeof context.getElementById !== "undefined" && documentIsHTML ) { 5610 var node, i, elems, 5611 elem = context.getElementById( id ); 5612 5613 if ( elem ) { 5614 5615 // Verify the id attribute 5616 node = elem.getAttributeNode( "id" ); 5617 if ( node && node.value === id ) { 5618 return [ elem ]; 5619 } 5620 5621 // Fall back on getElementsByName 5622 elems = context.getElementsByName( id ); 5623 i = 0; 5624 while ( ( elem = elems[ i++ ] ) ) { 5625 node = elem.getAttributeNode( "id" ); 5626 if ( node && node.value === id ) { 5627 return [ elem ]; 5628 } 5629 } 5630 } 5631 5632 return []; 5633 } 5634 }; 5635 } 5636 5637 // Tag 5638 Expr.find.TAG = function( tag, context ) { 5639 if ( typeof context.getElementsByTagName !== "undefined" ) { 5640 return context.getElementsByTagName( tag ); 5641 5642 // DocumentFragment nodes don't have gEBTN 5643 } else { 5644 return context.querySelectorAll( tag ); 5645 } 5646 }; 5647 5648 // Class 5649 Expr.find.CLASS = function( className, context ) { 5650 if ( typeof context.getElementsByClassName !== "undefined" && documentIsHTML ) { 5651 return context.getElementsByClassName( className ); 5652 } 5653 }; 5654 5655 /* QSA/matchesSelector 5656 ---------------------------------------------------------------------- */ 5657 5658 // QSA and matchesSelector support 5659 5660 rbuggyQSA = []; 5661 5662 // Build QSA regex 5663 // Regex strategy adopted from Diego Perini 5664 assert( function( el ) { 5665 5666 var input; 5667 5668 documentElement.appendChild( el ).innerHTML = 5669 "<a id='" + expando + "' href='' disabled='disabled'></a>" + 5670 "<select id='" + expando + "-\r\\' disabled='disabled'>" + 5671 "<option selected=''></option></select>"; 5672 5673 // Support: iOS <=7 - 8 only 5674 // Boolean attributes and "value" are not treated correctly in some XML documents 5675 if ( !el.querySelectorAll( "[selected]" ).length ) { 5676 rbuggyQSA.push( "\\[" + whitespace + "*(?:value|" + booleans + ")" ); 5677 } 5678 5679 // Support: iOS <=7 - 8 only 5680 if ( !el.querySelectorAll( "[id~=" + expando + "-]" ).length ) { 5681 rbuggyQSA.push( "~=" ); 5682 } 5683 5684 // Support: iOS 8 only 5685 // https://bugs.webkit.org/show_bug.cgi?id=136851 5686 // In-page `selector#id sibling-combinator selector` fails 5687 if ( !el.querySelectorAll( "a#" + expando + "+*" ).length ) { 5688 rbuggyQSA.push( ".#.+[+~]" ); 5689 } 5690 5691 // Support: Chrome <=105+, Firefox <=104+, Safari <=15.4+ 5692 // In some of the document kinds, these selectors wouldn't work natively. 5693 // This is probably OK but for backwards compatibility we want to maintain 5694 // handling them through jQuery traversal in jQuery 3.x. 5695 if ( !el.querySelectorAll( ":checked" ).length ) { 5696 rbuggyQSA.push( ":checked" ); 5697 } 5698 5699 // Support: Windows 8 Native Apps 5700 // The type and name attributes are restricted during .innerHTML assignment 5701 input = document.createElement( "input" ); 5702 input.setAttribute( "type", "hidden" ); 5703 el.appendChild( input ).setAttribute( "name", "D" ); 5704 5705 // Support: IE 9 - 11+ 5706 // IE's :disabled selector does not pick up the children of disabled fieldsets 5707 // Support: Chrome <=105+, Firefox <=104+, Safari <=15.4+ 5708 // In some of the document kinds, these selectors wouldn't work natively. 5709 // This is probably OK but for backwards compatibility we want to maintain 5710 // handling them through jQuery traversal in jQuery 3.x. 5711 documentElement.appendChild( el ).disabled = true; 5712 if ( el.querySelectorAll( ":disabled" ).length !== 2 ) { 5713 rbuggyQSA.push( ":enabled", ":disabled" ); 5714 } 5715 5716 // Support: IE 11+, Edge 15 - 18+ 5717 // IE 11/Edge don't find elements on a `[name='']` query in some cases. 5718 // Adding a temporary attribute to the document before the selection works 5719 // around the issue. 5720 // Interestingly, IE 10 & older don't seem to have the issue. 5721 input = document.createElement( "input" ); 5722 input.setAttribute( "name", "" ); 5723 el.appendChild( input ); 5724 if ( !el.querySelectorAll( "[name='']" ).length ) { 5725 rbuggyQSA.push( "\\[" + whitespace + "*name" + whitespace + "*=" + 5726 whitespace + "*(?:''|\"\")" ); 5727 } 5728 } ); 5729 5730 if ( !support.cssHas ) { 5731 5732 // Support: Chrome 105 - 110+, Safari 15.4 - 16.3+ 5733 // Our regular `try-catch` mechanism fails to detect natively-unsupported 5734 // pseudo-classes inside `:has()` (such as `:has(:contains("Foo"))`) 5735 // in browsers that parse the `:has()` argument as a forgiving selector list. 5736 // https://drafts.csswg.org/selectors/#relational now requires the argument 5737 // to be parsed unforgivingly, but browsers have not yet fully adjusted. 5738 rbuggyQSA.push( ":has" ); 5739 } 5740 5741 rbuggyQSA = rbuggyQSA.length && new RegExp( rbuggyQSA.join( "|" ) ); 5742 5743 /* Sorting 5744 ---------------------------------------------------------------------- */ 5745 5746 // Document order sorting 5747 sortOrder = function( a, b ) { 5748 5749 // Flag for duplicate removal 5750 if ( a === b ) { 5751 hasDuplicate = true; 5752 return 0; 5753 } 5754 5755 // Sort on method existence if only one input has compareDocumentPosition 5756 var compare = !a.compareDocumentPosition - !b.compareDocumentPosition; 5757 if ( compare ) { 5758 return compare; 5759 } 5760 5761 // Calculate position if both inputs belong to the same document 5762 // Support: IE 11+, Edge 17 - 18+ 5763 // IE/Edge sometimes throw a "Permission denied" error when strict-comparing 5764 // two documents; shallow comparisons work. 5765 // eslint-disable-next-line eqeqeq 5766 compare = ( a.ownerDocument || a ) == ( b.ownerDocument || b ) ? 5767 a.compareDocumentPosition( b ) : 5768 5769 // Otherwise we know they are disconnected 5770 1; 5771 5772 // Disconnected nodes 5773 if ( compare & 1 || 5774 ( !support.sortDetached && b.compareDocumentPosition( a ) === compare ) ) { 5775 5776 // Choose the first element that is related to our preferred document 5777 // Support: IE 11+, Edge 17 - 18+ 5778 // IE/Edge sometimes throw a "Permission denied" error when strict-comparing 5779 // two documents; shallow comparisons work. 5780 // eslint-disable-next-line eqeqeq 5781 if ( a === document || a.ownerDocument == preferredDoc && 5782 find.contains( preferredDoc, a ) ) { 5783 return -1; 5784 } 5785 5786 // Support: IE 11+, Edge 17 - 18+ 5787 // IE/Edge sometimes throw a "Permission denied" error when strict-comparing 5788 // two documents; shallow comparisons work. 5789 // eslint-disable-next-line eqeqeq 5790 if ( b === document || b.ownerDocument == preferredDoc && 5791 find.contains( preferredDoc, b ) ) { 5792 return 1; 5793 } 5794 5795 // Maintain original order 5796 return sortInput ? 5797 ( indexOf.call( sortInput, a ) - indexOf.call( sortInput, b ) ) : 5798 0; 5799 } 5800 5801 return compare & 4 ? -1 : 1; 5802 }; 5803 5804 return document; 5805} 5806 5807find.matches = function( expr, elements ) { 5808 return find( expr, null, null, elements ); 5809}; 5810 5811find.matchesSelector = function( elem, expr ) { 5812 setDocument( elem ); 5813 5814 if ( documentIsHTML && 5815 !nonnativeSelectorCache[ expr + " " ] && 5816 ( !rbuggyQSA || !rbuggyQSA.test( expr ) ) ) { 5817 5818 try { 5819 var ret = matches.call( elem, expr ); 5820 5821 // IE 9's matchesSelector returns false on disconnected nodes 5822 if ( ret || support.disconnectedMatch || 5823 5824 // As well, disconnected nodes are said to be in a document 5825 // fragment in IE 9 5826 elem.document && elem.document.nodeType !== 11 ) { 5827 return ret; 5828 } 5829 } catch ( e ) { 5830 nonnativeSelectorCache( expr, true ); 5831 } 5832 } 5833 5834 return find( expr, document, null, [ elem ] ).length > 0; 5835}; 5836 5837find.contains = function( context, elem ) { 5838 5839 // Set document vars if needed 5840 // Support: IE 11+, Edge 17 - 18+ 5841 // IE/Edge sometimes throw a "Permission denied" error when strict-comparing 5842 // two documents; shallow comparisons work. 5843 // eslint-disable-next-line eqeqeq 5844 if ( ( context.ownerDocument || context ) != document ) { 5845 setDocument( context ); 5846 } 5847 return jQuery.contains( context, elem ); 5848}; 5849 5850 5851find.attr = function( elem, name ) { 5852 5853 // Set document vars if needed 5854 // Support: IE 11+, Edge 17 - 18+ 5855 // IE/Edge sometimes throw a "Permission denied" error when strict-comparing 5856 // two documents; shallow comparisons work. 5857 // eslint-disable-next-line eqeqeq 5858 if ( ( elem.ownerDocument || elem ) != document ) { 5859 setDocument( elem ); 5860 } 5861 5862 var fn = Expr.attrHandle[ name.toLowerCase() ], 5863 5864 // Don't get fooled by Object.prototype properties (see trac-13807) 5865 val = fn && hasOwn.call( Expr.attrHandle, name.toLowerCase() ) ? 5866 fn( elem, name, !documentIsHTML ) : 5867 undefined; 5868 5869 if ( val !== undefined ) { 5870 return val; 5871 } 5872 5873 return elem.getAttribute( name ); 5874}; 5875 5876find.error = function( msg ) { 5877 throw new Error( "Syntax error, unrecognized expression: " + msg ); 5878}; 5879 5880/** 5881 * Document sorting and removing duplicates 5882 * @param {ArrayLike} results 5883 */ 5884jQuery.uniqueSort = function( results ) { 5885 var elem, 5886 duplicates = [], 5887 j = 0, 5888 i = 0; 5889 5890 // Unless we *know* we can detect duplicates, assume their presence 5891 // 5892 // Support: Android <=4.0+ 5893 // Testing for detecting duplicates is unpredictable so instead assume we can't 5894 // depend on duplicate detection in all browsers without a stable sort. 5895 hasDuplicate = !support.sortStable; 5896 sortInput = !support.sortStable && slice.call( results, 0 ); 5897 sort.call( results, sortOrder ); 5898 5899 if ( hasDuplicate ) { 5900 while ( ( elem = results[ i++ ] ) ) { 5901 if ( elem === results[ i ] ) { 5902 j = duplicates.push( i ); 5903 } 5904 } 5905 while ( j-- ) { 5906 splice.call( results, duplicates[ j ], 1 ); 5907 } 5908 } 5909 5910 // Clear input after sorting to release objects 5911 // See https://github.com/jquery/sizzle/pull/225 5912 sortInput = null; 5913 5914 return results; 5915}; 5916 5917jQuery.fn.uniqueSort = function() { 5918 return this.pushStack( jQuery.uniqueSort( slice.apply( this ) ) ); 5919}; 5920 5921Expr = jQuery.expr = { 5922 5923 // Can be adjusted by the user 5924 cacheLength: 50, 5925 5926 createPseudo: markFunction, 5927 5928 match: matchExpr, 5929 5930 attrHandle: {}, 5931 5932 find: {}, 5933 5934 relative: { 5935 ">": { dir: "parentNode", first: true }, 5936 " ": { dir: "parentNode" }, 5937 "+": { dir: "previousSibling", first: true }, 5938 "~": { dir: "previousSibling" } 5939 }, 5940 5941 preFilter: { 5942 ATTR: function( match ) { 5943 match[ 1 ] = match[ 1 ].replace( runescape, funescape ); 5944 5945 // Move the given value to match[3] whether quoted or unquoted 5946 match[ 3 ] = ( match[ 3 ] || match[ 4 ] || match[ 5 ] || "" ) 5947 .replace( runescape, funescape ); 5948 5949 if ( match[ 2 ] === "~=" ) { 5950 match[ 3 ] = " " + match[ 3 ] + " "; 5951 } 5952 5953 return match.slice( 0, 4 ); 5954 }, 5955 5956 CHILD: function( match ) { 5957 5958 /* matches from matchExpr["CHILD"] 5959 1 type (only|nth|...) 5960 2 what (child|of-type) 5961 3 argument (even|odd|\d*|\d*n([+-]\d+)?|...) 5962 4 xn-component of xn+y argument ([+-]?\d*n|) 5963 5 sign of xn-component 5964 6 x of xn-component 5965 7 sign of y-component 5966 8 y of y-component 5967 */ 5968 match[ 1 ] = match[ 1 ].toLowerCase(); 5969 5970 if ( match[ 1 ].slice( 0, 3 ) === "nth" ) { 5971 5972 // nth-* requires argument 5973 if ( !match[ 3 ] ) { 5974 find.error( match[ 0 ] ); 5975 } 5976 5977 // numeric x and y parameters for Expr.filter.CHILD 5978 // remember that false/true cast respectively to 0/1 5979 match[ 4 ] = +( match[ 4 ] ? 5980 match[ 5 ] + ( match[ 6 ] || 1 ) : 5981 2 * ( match[ 3 ] === "even" || match[ 3 ] === "odd" ) 5982 ); 5983 match[ 5 ] = +( ( match[ 7 ] + match[ 8 ] ) || match[ 3 ] === "odd" ); 5984 5985 // other types prohibit arguments 5986 } else if ( match[ 3 ] ) { 5987 find.error( match[ 0 ] ); 5988 } 5989 5990 return match; 5991 }, 5992 5993 PSEUDO: function( match ) { 5994 var excess, 5995 unquoted = !match[ 6 ] && match[ 2 ]; 5996 5997 if ( matchExpr.CHILD.test( match[ 0 ] ) ) { 5998 return null; 5999 } 6000 6001 // Accept quoted arguments as-is 6002 if ( match[ 3 ] ) { 6003 match[ 2 ] = match[ 4 ] || match[ 5 ] || ""; 6004 6005 // Strip excess characters from unquoted arguments 6006 } else if ( unquoted && rpseudo.test( unquoted ) && 6007 6008 // Get excess from tokenize (recursively) 6009 ( excess = tokenize( unquoted, true ) ) && 6010 6011 // advance to the next closing parenthesis 6012 ( excess = unquoted.indexOf( ")", unquoted.length - excess ) - unquoted.length ) ) { 6013 6014 // excess is a negative index 6015 match[ 0 ] = match[ 0 ].slice( 0, excess ); 6016 match[ 2 ] = unquoted.slice( 0, excess ); 6017 } 6018 6019 // Return only captures needed by the pseudo filter method (type and argument) 6020 return match.slice( 0, 3 ); 6021 } 6022 }, 6023 6024 filter: { 6025 6026 TAG: function( nodeNameSelector ) { 6027 var expectedNodeName = nodeNameSelector.replace( runescape, funescape ).toLowerCase(); 6028 return nodeNameSelector === "*" ? 6029 function() { 6030 return true; 6031 } : 6032 function( elem ) { 6033 return nodeName( elem, expectedNodeName ); 6034 }; 6035 }, 6036 6037 CLASS: function( className ) { 6038 var pattern = classCache[ className + " " ]; 6039 6040 return pattern || 6041 ( pattern = new RegExp( "(^|" + whitespace + ")" + className + 6042 "(" + whitespace + "|$)" ) ) && 6043 classCache( className, function( elem ) { 6044 return pattern.test( 6045 typeof elem.className === "string" && elem.className || 6046 typeof elem.getAttribute !== "undefined" && 6047 elem.getAttribute( "class" ) || 6048 "" 6049 ); 6050 } ); 6051 }, 6052 6053 ATTR: function( name, operator, check ) { 6054 return function( elem ) { 6055 var result = find.attr( elem, name ); 6056 6057 if ( result == null ) { 6058 return operator === "!="; 6059 } 6060 if ( !operator ) { 6061 return true; 6062 } 6063 6064 result += ""; 6065 6066 if ( operator === "=" ) { 6067 return result === check; 6068 } 6069 if ( operator === "!=" ) { 6070 return result !== check; 6071 } 6072 if ( operator === "^=" ) { 6073 return check && result.indexOf( check ) === 0; 6074 } 6075 if ( operator === "*=" ) { 6076 return check && result.indexOf( check ) > -1; 6077 } 6078 if ( operator === "$=" ) { 6079 return check && result.slice( -check.length ) === check; 6080 } 6081 if ( operator === "~=" ) { 6082 return ( " " + result.replace( rwhitespace, " " ) + " " ) 6083 .indexOf( check ) > -1; 6084 } 6085 if ( operator === "|=" ) { 6086 return result === check || result.slice( 0, check.length + 1 ) === check + "-"; 6087 } 6088 6089 return false; 6090 }; 6091 }, 6092 6093 CHILD: function( type, what, _argument, first, last ) { 6094 var simple = type.slice( 0, 3 ) !== "nth", 6095 forward = type.slice( -4 ) !== "last", 6096 ofType = what === "of-type"; 6097 6098 return first === 1 && last === 0 ? 6099 6100 // Shortcut for :nth-*(n) 6101 function( elem ) { 6102 return !!elem.parentNode; 6103 } : 6104 6105 function( elem, _context, xml ) { 6106 var cache, outerCache, node, nodeIndex, start, 6107 dir = simple !== forward ? "nextSibling" : "previousSibling", 6108 parent = elem.parentNode, 6109 name = ofType && elem.nodeName.toLowerCase(), 6110 useCache = !xml && !ofType, 6111 diff = false; 6112 6113 if ( parent ) { 6114 6115 // :(first|last|only)-(child|of-type) 6116 if ( simple ) { 6117 while ( dir ) { 6118 node = elem; 6119 while ( ( node = node[ dir ] ) ) { 6120 if ( ofType ? 6121 nodeName( node, name ) : 6122 node.nodeType === 1 ) { 6123 6124 return false; 6125 } 6126 } 6127 6128 // Reverse direction for :only-* (if we haven't yet done so) 6129 start = dir = type === "only" && !start && "nextSibling"; 6130 } 6131 return true; 6132 } 6133 6134 start = [ forward ? parent.firstChild : parent.lastChild ]; 6135 6136 // non-xml :nth-child(...) stores cache data on `parent` 6137 if ( forward && useCache ) { 6138 6139 // Seek `elem` from a previously-cached index 6140 outerCache = parent[ expando ] || ( parent[ expando ] = {} ); 6141 cache = outerCache[ type ] || []; 6142 nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ]; 6143 diff = nodeIndex && cache[ 2 ]; 6144 node = nodeIndex && parent.childNodes[ nodeIndex ]; 6145 6146 while ( ( node = ++nodeIndex && node && node[ dir ] || 6147 6148 // Fallback to seeking `elem` from the start 6149 ( diff = nodeIndex = 0 ) || start.pop() ) ) { 6150 6151 // When found, cache indexes on `parent` and break 6152 if ( node.nodeType === 1 && ++diff && node === elem ) { 6153 outerCache[ type ] = [ dirruns, nodeIndex, diff ]; 6154 break; 6155 } 6156 } 6157 6158 } else { 6159 6160 // Use previously-cached element index if available 6161 if ( useCache ) { 6162 outerCache = elem[ expando ] || ( elem[ expando ] = {} ); 6163 cache = outerCache[ type ] || []; 6164 nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ]; 6165 diff = nodeIndex; 6166 } 6167 6168 // xml :nth-child(...) 6169 // or :nth-last-child(...) or :nth(-last)?-of-type(...) 6170 if ( diff === false ) { 6171 6172 // Use the same loop as above to seek `elem` from the start 6173 while ( ( node = ++nodeIndex && node && node[ dir ] || 6174 ( diff = nodeIndex = 0 ) || start.pop() ) ) { 6175 6176 if ( ( ofType ? 6177 nodeName( node, name ) : 6178 node.nodeType === 1 ) && 6179 ++diff ) { 6180 6181 // Cache the index of each encountered element 6182 if ( useCache ) { 6183 outerCache = node[ expando ] || 6184 ( node[ expando ] = {} ); 6185 outerCache[ type ] = [ dirruns, diff ]; 6186 } 6187 6188 if ( node === elem ) { 6189 break; 6190 } 6191 } 6192 } 6193 } 6194 } 6195 6196 // Incorporate the offset, then check against cycle size 6197 diff -= last; 6198 return diff === first || ( diff % first === 0 && diff / first >= 0 ); 6199 } 6200 }; 6201 }, 6202 6203 PSEUDO: function( pseudo, argument ) { 6204 6205 // pseudo-class names are case-insensitive 6206 // https://www.w3.org/TR/selectors/#pseudo-classes 6207 // Prioritize by case sensitivity in case custom pseudos are added with uppercase letters 6208 // Remember that setFilters inherits from pseudos 6209 var args, 6210 fn = Expr.pseudos[ pseudo ] || Expr.setFilters[ pseudo.toLowerCase() ] || 6211 find.error( "unsupported pseudo: " + pseudo ); 6212 6213 // The user may use createPseudo to indicate that 6214 // arguments are needed to create the filter function 6215 // just as jQuery does 6216 if ( fn[ expando ] ) { 6217 return fn( argument ); 6218 } 6219 6220 // But maintain support for old signatures 6221 if ( fn.length > 1 ) { 6222 args = [ pseudo, pseudo, "", argument ]; 6223 return Expr.setFilters.hasOwnProperty( pseudo.toLowerCase() ) ? 6224 markFunction( function( seed, matches ) { 6225 var idx, 6226 matched = fn( seed, argument ), 6227 i = matched.length; 6228 while ( i-- ) { 6229 idx = indexOf.call( seed, matched[ i ] ); 6230 seed[ idx ] = !( matches[ idx ] = matched[ i ] ); 6231 } 6232 } ) : 6233 function( elem ) { 6234 return fn( elem, 0, args ); 6235 }; 6236 } 6237 6238 return fn; 6239 } 6240 }, 6241 6242 pseudos: { 6243 6244 // Potentially complex pseudos 6245 not: markFunction( function( selector ) { 6246 6247 // Trim the selector passed to compile 6248 // to avoid treating leading and trailing 6249 // spaces as combinators 6250 var input = [], 6251 results = [], 6252 matcher = compile( selector.replace( rtrimCSS, "$1" ) ); 6253 6254 return matcher[ expando ] ? 6255 markFunction( function( seed, matches, _context, xml ) { 6256 var elem, 6257 unmatched = matcher( seed, null, xml, [] ), 6258 i = seed.length; 6259 6260 // Match elements unmatched by `matcher` 6261 while ( i-- ) { 6262 if ( ( elem = unmatched[ i ] ) ) { 6263 seed[ i ] = !( matches[ i ] = elem ); 6264 } 6265 } 6266 } ) : 6267 function( elem, _context, xml ) { 6268 input[ 0 ] = elem; 6269 matcher( input, null, xml, results ); 6270 6271 // Don't keep the element 6272 // (see https://github.com/jquery/sizzle/issues/299) 6273 input[ 0 ] = null; 6274 return !results.pop(); 6275 }; 6276 } ), 6277 6278 has: markFunction( function( selector ) { 6279 return function( elem ) { 6280 return find( selector, elem ).length > 0; 6281 }; 6282 } ), 6283 6284 contains: markFunction( function( text ) { 6285 text = text.replace( runescape, funescape ); 6286 return function( elem ) { 6287 return ( elem.textContent || jQuery.text( elem ) ).indexOf( text ) > -1; 6288 }; 6289 } ), 6290 6291 // "Whether an element is represented by a :lang() selector 6292 // is based solely on the element's language value 6293 // being equal to the identifier C, 6294 // or beginning with the identifier C immediately followed by "-". 6295 // The matching of C against the element's language value is performed case-insensitively. 6296 // The identifier C does not have to be a valid language name." 6297 // https://www.w3.org/TR/selectors/#lang-pseudo 6298 lang: markFunction( function( lang ) { 6299 6300 // lang value must be a valid identifier 6301 if ( !ridentifier.test( lang || "" ) ) { 6302 find.error( "unsupported lang: " + lang ); 6303 } 6304 lang = lang.replace( runescape, funescape ).toLowerCase(); 6305 return function( elem ) { 6306 var elemLang; 6307 do { 6308 if ( ( elemLang = documentIsHTML ? 6309 elem.lang : 6310 elem.getAttribute( "xml:lang" ) || elem.getAttribute( "lang" ) ) ) { 6311 6312 elemLang = elemLang.toLowerCase(); 6313 return elemLang === lang || elemLang.indexOf( lang + "-" ) === 0; 6314 } 6315 } while ( ( elem = elem.parentNode ) && elem.nodeType === 1 ); 6316 return false; 6317 }; 6318 } ), 6319 6320 // Miscellaneous 6321 target: function( elem ) { 6322 var hash = window.location && window.location.hash; 6323 return hash && hash.slice( 1 ) === elem.id; 6324 }, 6325 6326 root: function( elem ) { 6327 return elem === documentElement; 6328 }, 6329 6330 focus: function( elem ) { 6331 return elem === safeActiveElement() && 6332 document.hasFocus() && 6333 !!( elem.type || elem.href || ~elem.tabIndex ); 6334 }, 6335 6336 // Boolean properties 6337 enabled: createDisabledPseudo( false ), 6338 disabled: createDisabledPseudo( true ), 6339 6340 checked: function( elem ) { 6341 6342 // In CSS3, :checked should return both checked and selected elements 6343 // https://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked 6344 return ( nodeName( elem, "input" ) && !!elem.checked ) || 6345 ( nodeName( elem, "option" ) && !!elem.selected ); 6346 }, 6347 6348 selected: function( elem ) { 6349 6350 // Support: IE <=11+ 6351 // Accessing the selectedIndex property 6352 // forces the browser to treat the default option as 6353 // selected when in an optgroup. 6354 if ( elem.parentNode ) { 6355 // eslint-disable-next-line no-unused-expressions 6356 elem.parentNode.selectedIndex; 6357 } 6358 6359 return elem.selected === true; 6360 }, 6361 6362 // Contents 6363 empty: function( elem ) { 6364 6365 // https://www.w3.org/TR/selectors/#empty-pseudo 6366 // :empty is negated by element (1) or content nodes (text: 3; cdata: 4; entity ref: 5), 6367 // but not by others (comment: 8; processing instruction: 7; etc.) 6368 // nodeType < 6 works because attributes (2) do not appear as children 6369 for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) { 6370 if ( elem.nodeType < 6 ) { 6371 return false; 6372 } 6373 } 6374 return true; 6375 }, 6376 6377 parent: function( elem ) { 6378 return !Expr.pseudos.empty( elem ); 6379 }, 6380 6381 // Element/input types 6382 header: function( elem ) { 6383 return rheader.test( elem.nodeName ); 6384 }, 6385 6386 input: function( elem ) { 6387 return rinputs.test( elem.nodeName ); 6388 }, 6389 6390 button: function( elem ) { 6391 return nodeName( elem, "input" ) && elem.type === "button" || 6392 nodeName( elem, "button" ); 6393 }, 6394 6395 text: function( elem ) { 6396 var attr; 6397 return nodeName( elem, "input" ) && elem.type === "text" && 6398 6399 // Support: IE <10 only 6400 // New HTML5 attribute values (e.g., "search") appear 6401 // with elem.type === "text" 6402 ( ( attr = elem.getAttribute( "type" ) ) == null || 6403 attr.toLowerCase() === "text" ); 6404 }, 6405 6406 // Position-in-collection 6407 first: createPositionalPseudo( function() { 6408 return [ 0 ]; 6409 } ), 6410 6411 last: createPositionalPseudo( function( _matchIndexes, length ) { 6412 return [ length - 1 ]; 6413 } ), 6414 6415 eq: createPositionalPseudo( function( _matchIndexes, length, argument ) { 6416 return [ argument < 0 ? argument + length : argument ]; 6417 } ), 6418 6419 even: createPositionalPseudo( function( matchIndexes, length ) { 6420 var i = 0; 6421 for ( ; i < length; i += 2 ) { 6422 matchIndexes.push( i ); 6423 } 6424 return matchIndexes; 6425 } ), 6426 6427 odd: createPositionalPseudo( function( matchIndexes, length ) { 6428 var i = 1; 6429 for ( ; i < length; i += 2 ) { 6430 matchIndexes.push( i ); 6431 } 6432 return matchIndexes; 6433 } ), 6434 6435 lt: createPositionalPseudo( function( matchIndexes, length, argument ) { 6436 var i; 6437 6438 if ( argument < 0 ) { 6439 i = argument + length; 6440 } else if ( argument > length ) { 6441 i = length; 6442 } else { 6443 i = argument; 6444 } 6445 6446 for ( ; --i >= 0; ) { 6447 matchIndexes.push( i ); 6448 } 6449 return matchIndexes; 6450 } ), 6451 6452 gt: createPositionalPseudo( function( matchIndexes, length, argument ) { 6453 var i = argument < 0 ? argument + length : argument; 6454 for ( ; ++i < length; ) { 6455 matchIndexes.push( i ); 6456 } 6457 return matchIndexes; 6458 } ) 6459 } 6460}; 6461 6462Expr.pseudos.nth = Expr.pseudos.eq; 6463 6464// Add button/input type pseudos 6465for ( i in { radio: true, checkbox: true, file: true, password: true, image: true } ) { 6466 Expr.pseudos[ i ] = createInputPseudo( i ); 6467} 6468for ( i in { submit: true, reset: true } ) { 6469 Expr.pseudos[ i ] = createButtonPseudo( i ); 6470} 6471 6472// Easy API for creating new setFilters 6473function setFilters() {} 6474setFilters.prototype = Expr.filters = Expr.pseudos; 6475Expr.setFilters = new setFilters(); 6476 6477function tokenize( selector, parseOnly ) { 6478 var matched, match, tokens, type, 6479 soFar, groups, preFilters, 6480 cached = tokenCache[ selector + " " ]; 6481 6482 if ( cached ) { 6483 return parseOnly ? 0 : cached.slice( 0 ); 6484 } 6485 6486 soFar = selector; 6487 groups = []; 6488 preFilters = Expr.preFilter; 6489 6490 while ( soFar ) { 6491 6492 // Comma and first run 6493 if ( !matched || ( match = rcomma.exec( soFar ) ) ) { 6494 if ( match ) { 6495 6496 // Don't consume trailing commas as valid 6497 soFar = soFar.slice( match[ 0 ].length ) || soFar; 6498 } 6499 groups.push( ( tokens = [] ) ); 6500 } 6501 6502 matched = false; 6503 6504 // Combinators 6505 if ( ( match = rleadingCombinator.exec( soFar ) ) ) { 6506 matched = match.shift(); 6507 tokens.push( { 6508 value: matched, 6509 6510 // Cast descendant combinators to space 6511 type: match[ 0 ].replace( rtrimCSS, " " ) 6512 } ); 6513 soFar = soFar.slice( matched.length ); 6514 } 6515 6516 // Filters 6517 for ( type in Expr.filter ) { 6518 if ( ( match = matchExpr[ type ].exec( soFar ) ) && ( !preFilters[ type ] || 6519 ( match = preFilters[ type ]( match ) ) ) ) { 6520 matched = match.shift(); 6521 tokens.push( { 6522 value: matched, 6523 type: type, 6524 matches: match 6525 } ); 6526 soFar = soFar.slice( matched.length ); 6527 } 6528 } 6529 6530 if ( !matched ) { 6531 break; 6532 } 6533 } 6534 6535 // Return the length of the invalid excess 6536 // if we're just parsing 6537 // Otherwise, throw an error or return tokens 6538 if ( parseOnly ) { 6539 return soFar.length; 6540 } 6541 6542 return soFar ? 6543 find.error( selector ) : 6544 6545 // Cache the tokens 6546 tokenCache( selector, groups ).slice( 0 ); 6547} 6548 6549function toSelector( tokens ) { 6550 var i = 0, 6551 len = tokens.length, 6552 selector = ""; 6553 for ( ; i < len; i++ ) { 6554 selector += tokens[ i ].value; 6555 } 6556 return selector; 6557} 6558 6559function addCombinator( matcher, combinator, base ) { 6560 var dir = combinator.dir, 6561 skip = combinator.next, 6562 key = skip || dir, 6563 checkNonElements = base && key === "parentNode", 6564 doneName = done++; 6565 6566 return combinator.first ? 6567 6568 // Check against closest ancestor/preceding element 6569 function( elem, context, xml ) { 6570 while ( ( elem = elem[ dir ] ) ) { 6571 if ( elem.nodeType === 1 || checkNonElements ) { 6572 return matcher( elem, context, xml ); 6573 } 6574 } 6575 return false; 6576 } : 6577 6578 // Check against all ancestor/preceding elements 6579 function( elem, context, xml ) { 6580 var oldCache, outerCache, 6581 newCache = [ dirruns, doneName ]; 6582 6583 // We can't set arbitrary data on XML nodes, so they don't benefit from combinator caching 6584 if ( xml ) { 6585 while ( ( elem = elem[ dir ] ) ) { 6586 if ( elem.nodeType === 1 || checkNonElements ) { 6587 if ( matcher( elem, context, xml ) ) { 6588 return true; 6589 } 6590 } 6591 } 6592 } else { 6593 while ( ( elem = elem[ dir ] ) ) { 6594 if ( elem.nodeType === 1 || checkNonElements ) { 6595 outerCache = elem[ expando ] || ( elem[ expando ] = {} ); 6596 6597 if ( skip && nodeName( elem, skip ) ) { 6598 elem = elem[ dir ] || elem; 6599 } else if ( ( oldCache = outerCache[ key ] ) && 6600 oldCache[ 0 ] === dirruns && oldCache[ 1 ] === doneName ) { 6601 6602 // Assign to newCache so results back-propagate to previous elements 6603 return ( newCache[ 2 ] = oldCache[ 2 ] ); 6604 } else { 6605 6606 // Reuse newcache so results back-propagate to previous elements 6607 outerCache[ key ] = newCache; 6608 6609 // A match means we're done; a fail means we have to keep checking 6610 if ( ( newCache[ 2 ] = matcher( elem, context, xml ) ) ) { 6611 return true; 6612 } 6613 } 6614 } 6615 } 6616 } 6617 return false; 6618 }; 6619} 6620 6621function elementMatcher( matchers ) { 6622 return matchers.length > 1 ? 6623 function( elem, context, xml ) { 6624 var i = matchers.length; 6625 while ( i-- ) { 6626 if ( !matchers[ i ]( elem, context, xml ) ) { 6627 return false; 6628 } 6629 } 6630 return true; 6631 } : 6632 matchers[ 0 ]; 6633} 6634 6635function multipleContexts( selector, contexts, results ) { 6636 var i = 0, 6637 len = contexts.length; 6638 for ( ; i < len; i++ ) { 6639 find( selector, contexts[ i ], results ); 6640 } 6641 return results; 6642} 6643 6644function condense( unmatched, map, filter, context, xml ) { 6645 var elem, 6646 newUnmatched = [], 6647 i = 0, 6648 len = unmatched.length, 6649 mapped = map != null; 6650 6651 for ( ; i < len; i++ ) { 6652 if ( ( elem = unmatched[ i ] ) ) { 6653 if ( !filter || filter( elem, context, xml ) ) { 6654 newUnmatched.push( elem ); 6655 if ( mapped ) { 6656 map.push( i ); 6657 } 6658 } 6659 } 6660 } 6661 6662 return newUnmatched; 6663} 6664 6665function setMatcher( preFilter, selector, matcher, postFilter, postFinder, postSelector ) { 6666 if ( postFilter && !postFilter[ expando ] ) { 6667 postFilter = setMatcher( postFilter ); 6668 } 6669 if ( postFinder && !postFinder[ expando ] ) { 6670 postFinder = setMatcher( postFinder, postSelector ); 6671 } 6672 return markFunction( function( seed, results, context, xml ) { 6673 var temp, i, elem, matcherOut, 6674 preMap = [], 6675 postMap = [], 6676 preexisting = results.length, 6677 6678 // Get initial elements from seed or context 6679 elems = seed || 6680 multipleContexts( selector || "*", 6681 context.nodeType ? [ context ] : context, [] ), 6682 6683 // Prefilter to get matcher input, preserving a map for seed-results synchronization 6684 matcherIn = preFilter && ( seed || !selector ) ? 6685 condense( elems, preMap, preFilter, context, xml ) : 6686 elems; 6687 6688 if ( matcher ) { 6689 6690 // If we have a postFinder, or filtered seed, or non-seed postFilter 6691 // or preexisting results, 6692 matcherOut = postFinder || ( seed ? preFilter : preexisting || postFilter ) ? 6693 6694 // ...intermediate processing is necessary 6695 [] : 6696 6697 // ...otherwise use results directly 6698 results; 6699 6700 // Find primary matches 6701 matcher( matcherIn, matcherOut, context, xml ); 6702 } else { 6703 matcherOut = matcherIn; 6704 } 6705 6706 // Apply postFilter 6707 if ( postFilter ) { 6708 temp = condense( matcherOut, postMap ); 6709 postFilter( temp, [], context, xml ); 6710 6711 // Un-match failing elements by moving them back to matcherIn 6712 i = temp.length; 6713 while ( i-- ) { 6714 if ( ( elem = temp[ i ] ) ) { 6715 matcherOut[ postMap[ i ] ] = !( matcherIn[ postMap[ i ] ] = elem ); 6716 } 6717 } 6718 } 6719 6720 if ( seed ) { 6721 if ( postFinder || preFilter ) { 6722 if ( postFinder ) { 6723 6724 // Get the final matcherOut by condensing this intermediate into postFinder contexts 6725 temp = []; 6726 i = matcherOut.length; 6727 while ( i-- ) { 6728 if ( ( elem = matcherOut[ i ] ) ) { 6729 6730 // Restore matcherIn since elem is not yet a final match 6731 temp.push( ( matcherIn[ i ] = elem ) ); 6732 } 6733 } 6734 postFinder( null, ( matcherOut = [] ), temp, xml ); 6735 } 6736 6737 // Move matched elements from seed to results to keep them synchronized 6738 i = matcherOut.length; 6739 while ( i-- ) { 6740 if ( ( elem = matcherOut[ i ] ) && 6741 ( temp = postFinder ? indexOf.call( seed, elem ) : preMap[ i ] ) > -1 ) { 6742 6743 seed[ temp ] = !( results[ temp ] = elem ); 6744 } 6745 } 6746 } 6747 6748 // Add elements to results, through postFinder if defined 6749 } else { 6750 matcherOut = condense( 6751 matcherOut === results ? 6752 matcherOut.splice( preexisting, matcherOut.length ) : 6753 matcherOut 6754 ); 6755 if ( postFinder ) { 6756 postFinder( null, results, matcherOut, xml ); 6757 } else { 6758 push.apply( results, matcherOut ); 6759 } 6760 } 6761 } ); 6762} 6763 6764function matcherFromTokens( tokens ) { 6765 var checkContext, matcher, j, 6766 len = tokens.length, 6767 leadingRelative = Expr.relative[ tokens[ 0 ].type ], 6768 implicitRelative = leadingRelative || Expr.relative[ " " ], 6769 i = leadingRelative ? 1 : 0, 6770 6771 // The foundational matcher ensures that elements are reachable from top-level context(s) 6772 matchContext = addCombinator( function( elem ) { 6773 return elem === checkContext; 6774 }, implicitRelative, true ), 6775 matchAnyContext = addCombinator( function( elem ) { 6776 return indexOf.call( checkContext, elem ) > -1; 6777 }, implicitRelative, true ), 6778 matchers = [ function( elem, context, xml ) { 6779 6780 // Support: IE 11+, Edge 17 - 18+ 6781 // IE/Edge sometimes throw a "Permission denied" error when strict-comparing 6782 // two documents; shallow comparisons work. 6783 // eslint-disable-next-line eqeqeq 6784 var ret = ( !leadingRelative && ( xml || context != outermostContext ) ) || ( 6785 ( checkContext = context ).nodeType ? 6786 matchContext( elem, context, xml ) : 6787 matchAnyContext( elem, context, xml ) ); 6788 6789 // Avoid hanging onto element 6790 // (see https://github.com/jquery/sizzle/issues/299) 6791 checkContext = null; 6792 return ret; 6793 } ]; 6794 6795 for ( ; i < len; i++ ) { 6796 if ( ( matcher = Expr.relative[ tokens[ i ].type ] ) ) { 6797 matchers = [ addCombinator( elementMatcher( matchers ), matcher ) ]; 6798 } else { 6799 matcher = Expr.filter[ tokens[ i ].type ].apply( null, tokens[ i ].matches ); 6800 6801 // Return special upon seeing a positional matcher 6802 if ( matcher[ expando ] ) { 6803 6804 // Find the next relative operator (if any) for proper handling 6805 j = ++i; 6806 for ( ; j < len; j++ ) { 6807 if ( Expr.relative[ tokens[ j ].type ] ) { 6808 break; 6809 } 6810 } 6811 return setMatcher( 6812 i > 1 && elementMatcher( matchers ), 6813 i > 1 && toSelector( 6814 6815 // If the preceding token was a descendant combinator, insert an implicit any-element `*` 6816 tokens.slice( 0, i - 1 ) 6817 .concat( { value: tokens[ i - 2 ].type === " " ? "*" : "" } ) 6818 ).replace( rtrimCSS, "$1" ), 6819 matcher, 6820 i < j && matcherFromTokens( tokens.slice( i, j ) ), 6821 j < len && matcherFromTokens( ( tokens = tokens.slice( j ) ) ), 6822 j < len && toSelector( tokens ) 6823 ); 6824 } 6825 matchers.push( matcher ); 6826 } 6827 } 6828 6829 return elementMatcher( matchers ); 6830} 6831 6832function matcherFromGroupMatchers( elementMatchers, setMatchers ) { 6833 var bySet = setMatchers.length > 0, 6834 byElement = elementMatchers.length > 0, 6835 superMatcher = function( seed, context, xml, results, outermost ) { 6836 var elem, j, matcher, 6837 matchedCount = 0, 6838 i = "0", 6839 unmatched = seed && [], 6840 setMatched = [], 6841 contextBackup = outermostContext, 6842 6843 // We must always have either seed elements or outermost context 6844 elems = seed || byElement && Expr.find.TAG( "*", outermost ), 6845 6846 // Use integer dirruns iff this is the outermost matcher 6847 dirrunsUnique = ( dirruns += contextBackup == null ? 1 : Math.random() || 0.1 ), 6848 len = elems.length; 6849 6850 if ( outermost ) { 6851 6852 // Support: IE 11+, Edge 17 - 18+ 6853 // IE/Edge sometimes throw a "Permission denied" error when strict-comparing 6854 // two documents; shallow comparisons work. 6855 // eslint-disable-next-line eqeqeq 6856 outermostContext = context == document || context || outermost; 6857 } 6858 6859 // Add elements passing elementMatchers directly to results 6860 // Support: iOS <=7 - 9 only 6861 // Tolerate NodeList properties (IE: "length"; Safari: <number>) matching 6862 // elements by id. (see trac-14142) 6863 for ( ; i !== len && ( elem = elems[ i ] ) != null; i++ ) { 6864 if ( byElement && elem ) { 6865 j = 0; 6866 6867 // Support: IE 11+, Edge 17 - 18+ 6868 // IE/Edge sometimes throw a "Permission denied" error when strict-comparing 6869 // two documents; shallow comparisons work. 6870 // eslint-disable-next-line eqeqeq 6871 if ( !context && elem.ownerDocument != document ) { 6872 setDocument( elem ); 6873 xml = !documentIsHTML; 6874 } 6875 while ( ( matcher = elementMatchers[ j++ ] ) ) { 6876 if ( matcher( elem, context || document, xml ) ) { 6877 push.call( results, elem ); 6878 break; 6879 } 6880 } 6881 if ( outermost ) { 6882 dirruns = dirrunsUnique; 6883 } 6884 } 6885 6886 // Track unmatched elements for set filters 6887 if ( bySet ) { 6888 6889 // They will have gone through all possible matchers 6890 if ( ( elem = !matcher && elem ) ) { 6891 matchedCount--; 6892 } 6893 6894 // Lengthen the array for every element, matched or not 6895 if ( seed ) { 6896 unmatched.push( elem ); 6897 } 6898 } 6899 } 6900 6901 // `i` is now the count of elements visited above, and adding it to `matchedCount` 6902 // makes the latter nonnegative. 6903 matchedCount += i; 6904 6905 // Apply set filters to unmatched elements 6906 // NOTE: This can be skipped if there are no unmatched elements (i.e., `matchedCount` 6907 // equals `i`), unless we didn't visit _any_ elements in the above loop because we have 6908 // no element matchers and no seed. 6909 // Incrementing an initially-string "0" `i` allows `i` to remain a string only in that 6910 // case, which will result in a "00" `matchedCount` that differs from `i` but is also 6911 // numerically zero. 6912 if ( bySet && i !== matchedCount ) { 6913 j = 0; 6914 while ( ( matcher = setMatchers[ j++ ] ) ) { 6915 matcher( unmatched, setMatched, context, xml ); 6916 } 6917 6918 if ( seed ) { 6919 6920 // Reintegrate element matches to eliminate the need for sorting 6921 if ( matchedCount > 0 ) { 6922 while ( i-- ) { 6923 if ( !( unmatched[ i ] || setMatched[ i ] ) ) { 6924 setMatched[ i ] = pop.call( results ); 6925 } 6926 } 6927 } 6928 6929 // Discard index placeholder values to get only actual matches 6930 setMatched = condense( setMatched ); 6931 } 6932 6933 // Add matches to results 6934 push.apply( results, setMatched ); 6935 6936 // Seedless set matches succeeding multiple successful matchers stipulate sorting 6937 if ( outermost && !seed && setMatched.length > 0 && 6938 ( matchedCount + setMatchers.length ) > 1 ) { 6939 6940 jQuery.uniqueSort( results ); 6941 } 6942 } 6943 6944 // Override manipulation of globals by nested matchers 6945 if ( outermost ) { 6946 dirruns = dirrunsUnique; 6947 outermostContext = contextBackup; 6948 } 6949 6950 return unmatched; 6951 }; 6952 6953 return bySet ? 6954 markFunction( superMatcher ) : 6955 superMatcher; 6956} 6957 6958function compile( selector, match /* Internal Use Only */ ) { 6959 var i, 6960 setMatchers = [], 6961 elementMatchers = [], 6962 cached = compilerCache[ selector + " " ]; 6963 6964 if ( !cached ) { 6965 6966 // Generate a function of recursive functions that can be used to check each element 6967 if ( !match ) { 6968 match = tokenize( selector ); 6969 } 6970 i = match.length; 6971 while ( i-- ) { 6972 cached = matcherFromTokens( match[ i ] ); 6973 if ( cached[ expando ] ) { 6974 setMatchers.push( cached ); 6975 } else { 6976 elementMatchers.push( cached ); 6977 } 6978 } 6979 6980 // Cache the compiled function 6981 cached = compilerCache( selector, 6982 matcherFromGroupMatchers( elementMatchers, setMatchers ) ); 6983 6984 // Save selector and tokenization 6985 cached.selector = selector; 6986 } 6987 return cached; 6988} 6989 6990/** 6991 * A low-level selection function that works with jQuery's compiled 6992 * selector functions 6993 * @param {String|Function} selector A selector or a pre-compiled 6994 * selector function built with jQuery selector compile 6995 * @param {Element} context 6996 * @param {Array} [results] 6997 * @param {Array} [seed] A set of elements to match against 6998 */ 6999function select( selector, context, results, seed ) { 7000 var i, tokens, token, type, find, 7001 compiled = typeof selector === "function" && selector, 7002 match = !seed && tokenize( ( selector = compiled.selector || selector ) ); 7003 7004 results = results || []; 7005 7006 // Try to minimize operations if there is only one selector in the list and no seed 7007 // (the latter of which guarantees us context) 7008 if ( match.length === 1 ) { 7009 7010 // Reduce context if the leading compound selector is an ID 7011 tokens = match[ 0 ] = match[ 0 ].slice( 0 ); 7012 if ( tokens.length > 2 && ( token = tokens[ 0 ] ).type === "ID" && 7013 context.nodeType === 9 && documentIsHTML && Expr.relative[ tokens[ 1 ].type ] ) { 7014 7015 context = ( Expr.find.ID( 7016 token.matches[ 0 ].replace( runescape, funescape ), 7017 context 7018 ) || [] )[ 0 ]; 7019 if ( !context ) { 7020 return results; 7021 7022 // Precompiled matchers will still verify ancestry, so step up a level 7023 } else if ( compiled ) { 7024 context = context.parentNode; 7025 } 7026 7027 selector = selector.slice( tokens.shift().value.length ); 7028 } 7029 7030 // Fetch a seed set for right-to-left matching 7031 i = matchExpr.needsContext.test( selector ) ? 0 : tokens.length; 7032 while ( i-- ) { 7033 token = tokens[ i ]; 7034 7035 // Abort if we hit a combinator 7036 if ( Expr.relative[ ( type = token.type ) ] ) { 7037 break; 7038 } 7039 if ( ( find = Expr.find[ type ] ) ) { 7040 7041 // Search, expanding context for leading sibling combinators 7042 if ( ( seed = find( 7043 token.matches[ 0 ].replace( runescape, funescape ), 7044 rsibling.test( tokens[ 0 ].type ) && 7045 testContext( context.parentNode ) || context 7046 ) ) ) { 7047 7048 // If seed is empty or no tokens remain, we can return early 7049 tokens.splice( i, 1 ); 7050 selector = seed.length && toSelector( tokens ); 7051 if ( !selector ) { 7052 push.apply( results, seed ); 7053 return results; 7054 } 7055 7056 break; 7057 } 7058 } 7059 } 7060 } 7061 7062 // Compile and execute a filtering function if one is not provided 7063 // Provide `match` to avoid retokenization if we modified the selector above 7064 ( compiled || compile( selector, match ) )( 7065 seed, 7066 context, 7067 !documentIsHTML, 7068 results, 7069 !context || rsibling.test( selector ) && testContext( context.parentNode ) || context 7070 ); 7071 return results; 7072} 7073 7074// One-time assignments 7075 7076// Support: Android <=4.0 - 4.1+ 7077// Sort stability 7078support.sortStable = expando.split( "" ).sort( sortOrder ).join( "" ) === expando; 7079 7080// Initialize against the default document 7081setDocument(); 7082 7083// Support: Android <=4.0 - 4.1+ 7084// Detached nodes confoundingly follow *each other* 7085support.sortDetached = assert( function( el ) { 7086 7087 // Should return 1, but returns 4 (following) 7088 return el.compareDocumentPosition( document.createElement( "fieldset" ) ) & 1; 7089} ); 7090 7091jQuery.find = find; 7092 7093// Deprecated 7094jQuery.expr[ ":" ] = jQuery.expr.pseudos; 7095jQuery.unique = jQuery.uniqueSort; 7096 7097// These have always been private, but they used to be documented as part of 7098// Sizzle so let's maintain them for now for backwards compatibility purposes. 7099find.compile = compile; 7100find.select = select; 7101find.setDocument = setDocument; 7102find.tokenize = tokenize; 7103 7104find.escape = jQuery.escapeSelector; 7105find.getText = jQuery.text; 7106find.isXML = jQuery.isXMLDoc; 7107find.selectors = jQuery.expr; 7108find.support = jQuery.support; 7109find.uniqueSort = jQuery.uniqueSort; 7110 7111 /* eslint-enable */ 7112 7113} )(); 7114 7115 7116var dir = function( elem, dir, until ) { 7117 var matched = [], 7118 truncate = until !== undefined; 7119 7120 while ( ( elem = elem[ dir ] ) && elem.nodeType !== 9 ) { 7121 if ( elem.nodeType === 1 ) { 7122 if ( truncate && jQuery( elem ).is( until ) ) { 7123 break; 7124 } 7125 matched.push( elem ); 7126 } 7127 } 7128 return matched; 7129}; 7130 7131 7132var siblings = function( n, elem ) { 7133 var matched = []; 7134 7135 for ( ; n; n = n.nextSibling ) { 7136 if ( n.nodeType === 1 && n !== elem ) { 7137 matched.push( n ); 7138 } 7139 } 7140 7141 return matched; 7142}; 7143 7144 7145var rneedsContext = jQuery.expr.match.needsContext; 7146 7147var rsingleTag = ( /^<([a-z][^\/\0>:\x20\t\r\n\f]*)[\x20\t\r\n\f]*\/?>(?:<\/\1>|)$/i ); 7148 7149 7150 7151// Implement the identical functionality for filter and not 7152function winnow( elements, qualifier, not ) { 7153 if ( isFunction( qualifier ) ) { 7154 return jQuery.grep( elements, function( elem, i ) { 7155 return !!qualifier.call( elem, i, elem ) !== not; 7156 } ); 7157 } 7158 7159 // Single element 7160 if ( qualifier.nodeType ) { 7161 return jQuery.grep( elements, function( elem ) { 7162 return ( elem === qualifier ) !== not; 7163 } ); 7164 } 7165 7166 // Arraylike of elements (jQuery, arguments, Array) 7167 if ( typeof qualifier !== "string" ) { 7168 return jQuery.grep( elements, function( elem ) { 7169 return ( indexOf.call( qualifier, elem ) > -1 ) !== not; 7170 } ); 7171 } 7172 7173 // Filtered directly for both simple and complex selectors 7174 return jQuery.filter( qualifier, elements, not ); 7175} 7176 7177jQuery.filter = function( expr, elems, not ) { 7178 var elem = elems[ 0 ]; 7179 7180 if ( not ) { 7181 expr = ":not(" + expr + ")"; 7182 } 7183 7184 if ( elems.length === 1 && elem.nodeType === 1 ) { 7185 return jQuery.find.matchesSelector( elem, expr ) ? [ elem ] : []; 7186 } 7187 7188 return jQuery.find.matches( expr, jQuery.grep( elems, function( elem ) { 7189 return elem.nodeType === 1; 7190 } ) ); 7191}; 7192 7193jQuery.fn.extend( { 7194 find: function( selector ) { 7195 var i, ret, 7196 len = this.length, 7197 self = this; 7198 7199 if ( typeof selector !== "string" ) { 7200 return this.pushStack( jQuery( selector ).filter( function() { 7201 for ( i = 0; i < len; i++ ) { 7202 if ( jQuery.contains( self[ i ], this ) ) { 7203 return true; 7204 } 7205 } 7206 } ) ); 7207 } 7208 7209 ret = this.pushStack( [] ); 7210 7211 for ( i = 0; i < len; i++ ) { 7212 jQuery.find( selector, self[ i ], ret ); 7213 } 7214 7215 return len > 1 ? jQuery.uniqueSort( ret ) : ret; 7216 }, 7217 filter: function( selector ) { 7218 return this.pushStack( winnow( this, selector || [], false ) ); 7219 }, 7220 not: function( selector ) { 7221 return this.pushStack( winnow( this, selector || [], true ) ); 7222 }, 7223 is: function( selector ) { 7224 return !!winnow( 7225 this, 7226 7227 // If this is a positional/relative selector, check membership in the returned set 7228 // so $("p:first").is("p:last") won't return true for a doc with two "p". 7229 typeof selector === "string" && rneedsContext.test( selector ) ? 7230 jQuery( selector ) : 7231 selector || [], 7232 false 7233 ).length; 7234 } 7235} ); 7236 7237 7238// Initialize a jQuery object 7239 7240 7241// A central reference to the root jQuery(document) 7242var rootjQuery, 7243 7244 // A simple way to check for HTML strings 7245 // Prioritize #id over <tag> to avoid XSS via location.hash (trac-9521) 7246 // Strict HTML recognition (trac-11290: must start with <) 7247 // Shortcut simple #id case for speed 7248 rquickExpr = /^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]+))$/, 7249 7250 init = jQuery.fn.init = function( selector, context, root ) { 7251 var match, elem; 7252 7253 // HANDLE: $(""), $(null), $(undefined), $(false) 7254 if ( !selector ) { 7255 return this; 7256 } 7257 7258 // Method init() accepts an alternate rootjQuery 7259 // so migrate can support jQuery.sub (gh-2101) 7260 root = root || rootjQuery; 7261 7262 // Handle HTML strings 7263 if ( typeof selector === "string" ) { 7264 if ( selector[ 0 ] === "<" && 7265 selector[ selector.length - 1 ] === ">" && 7266 selector.length >= 3 ) { 7267 7268 // Assume that strings that start and end with <> are HTML and skip the regex check 7269 match = [ null, selector, null ]; 7270 7271 } else { 7272 match = rquickExpr.exec( selector ); 7273 } 7274 7275 // Match html or make sure no context is specified for #id 7276 if ( match && ( match[ 1 ] || !context ) ) { 7277 7278 // HANDLE: $(html) -> $(array) 7279 if ( match[ 1 ] ) { 7280 context = context instanceof jQuery ? context[ 0 ] : context; 7281 7282 // Option to run scripts is true for back-compat 7283 // Intentionally let the error be thrown if parseHTML is not present 7284 jQuery.merge( this, jQuery.parseHTML( 7285 match[ 1 ], 7286 context && context.nodeType ? context.ownerDocument || context : document, 7287 true 7288 ) ); 7289 7290 // HANDLE: $(html, props) 7291 if ( rsingleTag.test( match[ 1 ] ) && jQuery.isPlainObject( context ) ) { 7292 for ( match in context ) { 7293 7294 // Properties of context are called as methods if possible 7295 if ( isFunction( this[ match ] ) ) { 7296 this[ match ]( context[ match ] ); 7297 7298 // ...and otherwise set as attributes 7299 } else { 7300 this.attr( match, context[ match ] ); 7301 } 7302 } 7303 } 7304 7305 return this; 7306 7307 // HANDLE: $(#id) 7308 } else { 7309 elem = document.getElementById( match[ 2 ] ); 7310 7311 if ( elem ) { 7312 7313 // Inject the element directly into the jQuery object 7314 this[ 0 ] = elem; 7315 this.length = 1; 7316 } 7317 return this; 7318 } 7319 7320 // HANDLE: $(expr, $(...)) 7321 } else if ( !context || context.jquery ) { 7322 return ( context || root ).find( selector ); 7323 7324 // HANDLE: $(expr, context) 7325 // (which is just equivalent to: $(context).find(expr) 7326 } else { 7327 return this.constructor( context ).find( selector ); 7328 } 7329 7330 // HANDLE: $(DOMElement) 7331 } else if ( selector.nodeType ) { 7332 this[ 0 ] = selector; 7333 this.length = 1; 7334 return this; 7335 7336 // HANDLE: $(function) 7337 // Shortcut for document ready 7338 } else if ( isFunction( selector ) ) { 7339 return root.ready !== undefined ? 7340 root.ready( selector ) : 7341 7342 // Execute immediately if ready is not present 7343 selector( jQuery ); 7344 } 7345 7346 return jQuery.makeArray( selector, this ); 7347 }; 7348 7349// Give the init function the jQuery prototype for later instantiation 7350init.prototype = jQuery.fn; 7351 7352// Initialize central reference 7353rootjQuery = jQuery( document ); 7354 7355 7356var rparentsprev = /^(?:parents|prev(?:Until|All))/, 7357 7358 // Methods guaranteed to produce a unique set when starting from a unique set 7359 guaranteedUnique = { 7360 children: true, 7361 contents: true, 7362 next: true, 7363 prev: true 7364 }; 7365 7366jQuery.fn.extend( { 7367 has: function( target ) { 7368 var targets = jQuery( target, this ), 7369 l = targets.length; 7370 7371 return this.filter( function() { 7372 var i = 0; 7373 for ( ; i < l; i++ ) { 7374 if ( jQuery.contains( this, targets[ i ] ) ) { 7375 return true; 7376 } 7377 } 7378 } ); 7379 }, 7380 7381 closest: function( selectors, context ) { 7382 var cur, 7383 i = 0, 7384 l = this.length, 7385 matched = [], 7386 targets = typeof selectors !== "string" && jQuery( selectors ); 7387 7388 // Positional selectors never match, since there's no _selection_ context 7389 if ( !rneedsContext.test( selectors ) ) { 7390 for ( ; i < l; i++ ) { 7391 for ( cur = this[ i ]; cur && cur !== context; cur = cur.parentNode ) { 7392 7393 // Always skip document fragments 7394 if ( cur.nodeType < 11 && ( targets ? 7395 targets.index( cur ) > -1 : 7396 7397 // Don't pass non-elements to jQuery#find 7398 cur.nodeType === 1 && 7399 jQuery.find.matchesSelector( cur, selectors ) ) ) { 7400 7401 matched.push( cur ); 7402 break; 7403 } 7404 } 7405 } 7406 } 7407 7408 return this.pushStack( matched.length > 1 ? jQuery.uniqueSort( matched ) : matched ); 7409 }, 7410 7411 // Determine the position of an element within the set 7412 index: function( elem ) { 7413 7414 // No argument, return index in parent 7415 if ( !elem ) { 7416 return ( this[ 0 ] && this[ 0 ].parentNode ) ? this.first().prevAll().length : -1; 7417 } 7418 7419 // Index in selector 7420 if ( typeof elem === "string" ) { 7421 return indexOf.call( jQuery( elem ), this[ 0 ] ); 7422 } 7423 7424 // Locate the position of the desired element 7425 return indexOf.call( this, 7426 7427 // If it receives a jQuery object, the first element is used 7428 elem.jquery ? elem[ 0 ] : elem 7429 ); 7430 }, 7431 7432 add: function( selector, context ) { 7433 return this.pushStack( 7434 jQuery.uniqueSort( 7435 jQuery.merge( this.get(), jQuery( selector, context ) ) 7436 ) 7437 ); 7438 }, 7439 7440 addBack: function( selector ) { 7441 return this.add( selector == null ? 7442 this.prevObject : this.prevObject.filter( selector ) 7443 ); 7444 } 7445} ); 7446 7447function sibling( cur, dir ) { 7448 while ( ( cur = cur[ dir ] ) && cur.nodeType !== 1 ) {} 7449 return cur; 7450} 7451 7452jQuery.each( { 7453 parent: function( elem ) { 7454 var parent = elem.parentNode; 7455 return parent && parent.nodeType !== 11 ? parent : null; 7456 }, 7457 parents: function( elem ) { 7458 return dir( elem, "parentNode" ); 7459 }, 7460 parentsUntil: function( elem, _i, until ) { 7461 return dir( elem, "parentNode", until ); 7462 }, 7463 next: function( elem ) { 7464 return sibling( elem, "nextSibling" ); 7465 }, 7466 prev: function( elem ) { 7467 return sibling( elem, "previousSibling" ); 7468 }, 7469 nextAll: function( elem ) { 7470 return dir( elem, "nextSibling" ); 7471 }, 7472 prevAll: function( elem ) { 7473 return dir( elem, "previousSibling" ); 7474 }, 7475 nextUntil: function( elem, _i, until ) { 7476 return dir( elem, "nextSibling", until ); 7477 }, 7478 prevUntil: function( elem, _i, until ) { 7479 return dir( elem, "previousSibling", until ); 7480 }, 7481 siblings: function( elem ) { 7482 return siblings( ( elem.parentNode || {} ).firstChild, elem ); 7483 }, 7484 children: function( elem ) { 7485 return siblings( elem.firstChild ); 7486 }, 7487 contents: function( elem ) { 7488 if ( elem.contentDocument != null && 7489 7490 // Support: IE 11+ 7491 // <object> elements with no `data` attribute has an object 7492 // `contentDocument` with a `null` prototype. 7493 getProto( elem.contentDocument ) ) { 7494 7495 return elem.contentDocument; 7496 } 7497 7498 // Support: IE 9 - 11 only, iOS 7 only, Android Browser <=4.3 only 7499 // Treat the template element as a regular one in browsers that 7500 // don't support it. 7501 if ( nodeName( elem, "template" ) ) { 7502 elem = elem.content || elem; 7503 } 7504 7505 return jQuery.merge( [], elem.childNodes ); 7506 } 7507}, function( name, fn ) { 7508 jQuery.fn[ name ] = function( until, selector ) { 7509 var matched = jQuery.map( this, fn, until ); 7510 7511 if ( name.slice( -5 ) !== "Until" ) { 7512 selector = until; 7513 } 7514 7515 if ( selector && typeof selector === "string" ) { 7516 matched = jQuery.filter( selector, matched ); 7517 } 7518 7519 if ( this.length > 1 ) { 7520 7521 // Remove duplicates 7522 if ( !guaranteedUnique[ name ] ) { 7523 jQuery.uniqueSort( matched ); 7524 } 7525 7526 // Reverse order for parents* and prev-derivatives 7527 if ( rparentsprev.test( name ) ) { 7528 matched.reverse(); 7529 } 7530 } 7531 7532 return this.pushStack( matched ); 7533 }; 7534} ); 7535var rnothtmlwhite = ( /[^\x20\t\r\n\f]+/g ); 7536 7537 7538 7539// Convert String-formatted options into Object-formatted ones 7540function createOptions( options ) { 7541 var object = {}; 7542 jQuery.each( options.match( rnothtmlwhite ) || [], function( _, flag ) { 7543 object[ flag ] = true; 7544 } ); 7545 return object; 7546} 7547 7548/* 7549 * Create a callback list using the following parameters: 7550 * 7551 * options: an optional list of space-separated options that will change how 7552 * the callback list behaves or a more traditional option object 7553 * 7554 * By default a callback list will act like an event callback list and can be 7555 * "fired" multiple times. 7556 * 7557 * Possible options: 7558 * 7559 * once: will ensure the callback list can only be fired once (like a Deferred) 7560 * 7561 * memory: will keep track of previous values and will call any callback added 7562 * after the list has been fired right away with the latest "memorized" 7563 * values (like a Deferred) 7564 * 7565 * unique: will ensure a callback can only be added once (no duplicate in the list) 7566 * 7567 * stopOnFalse: interrupt callings when a callback returns false 7568 * 7569 */ 7570jQuery.Callbacks = function( options ) { 7571 7572 // Convert options from String-formatted to Object-formatted if needed 7573 // (we check in cache first) 7574 options = typeof options === "string" ? 7575 createOptions( options ) : 7576 jQuery.extend( {}, options ); 7577 7578 var // Flag to know if list is currently firing 7579 firing, 7580 7581 // Last fire value for non-forgettable lists 7582 memory, 7583 7584 // Flag to know if list was already fired 7585 fired, 7586 7587 // Flag to prevent firing 7588 locked, 7589 7590 // Actual callback list 7591 list = [], 7592 7593 // Queue of execution data for repeatable lists 7594 queue = [], 7595 7596 // Index of currently firing callback (modified by add/remove as needed) 7597 firingIndex = -1, 7598 7599 // Fire callbacks 7600 fire = function() { 7601 7602 // Enforce single-firing 7603 locked = locked || options.once; 7604 7605 // Execute callbacks for all pending executions, 7606 // respecting firingIndex overrides and runtime changes 7607 fired = firing = true; 7608 for ( ; queue.length; firingIndex = -1 ) { 7609 memory = queue.shift(); 7610 while ( ++firingIndex < list.length ) { 7611 7612 // Run callback and check for early termination 7613 if ( list[ firingIndex ].apply( memory[ 0 ], memory[ 1 ] ) === false && 7614 options.stopOnFalse ) { 7615 7616 // Jump to end and forget the data so .add doesn't re-fire 7617 firingIndex = list.length; 7618 memory = false; 7619 } 7620 } 7621 } 7622 7623 // Forget the data if we're done with it 7624 if ( !options.memory ) { 7625 memory = false; 7626 } 7627 7628 firing = false; 7629 7630 // Clean up if we're done firing for good 7631 if ( locked ) { 7632 7633 // Keep an empty list if we have data for future add calls 7634 if ( memory ) { 7635 list = []; 7636 7637 // Otherwise, this object is spent 7638 } else { 7639 list = ""; 7640 } 7641 } 7642 }, 7643 7644 // Actual Callbacks object 7645 self = { 7646 7647 // Add a callback or a collection of callbacks to the list 7648 add: function() { 7649 if ( list ) { 7650 7651 // If we have memory from a past run, we should fire after adding 7652 if ( memory && !firing ) { 7653 firingIndex = list.length - 1; 7654 queue.push( memory ); 7655 } 7656 7657 ( function add( args ) { 7658 jQuery.each( args, function( _, arg ) { 7659 if ( isFunction( arg ) ) { 7660 if ( !options.unique || !self.has( arg ) ) { 7661 list.push( arg ); 7662 } 7663 } else if ( arg && arg.length && toType( arg ) !== "string" ) { 7664 7665 // Inspect recursively 7666 add( arg ); 7667 } 7668 } ); 7669 } )( arguments ); 7670 7671 if ( memory && !firing ) { 7672 fire(); 7673 } 7674 } 7675 return this; 7676 }, 7677 7678 // Remove a callback from the list 7679 remove: function() { 7680 jQuery.each( arguments, function( _, arg ) { 7681 var index; 7682 while ( ( index = jQuery.inArray( arg, list, index ) ) > -1 ) { 7683 list.splice( index, 1 ); 7684 7685 // Handle firing indexes 7686 if ( index <= firingIndex ) { 7687 firingIndex--; 7688 } 7689 } 7690 } ); 7691 return this; 7692 }, 7693 7694 // Check if a given callback is in the list. 7695 // If no argument is given, return whether or not list has callbacks attached. 7696 has: function( fn ) { 7697 return fn ? 7698 jQuery.inArray( fn, list ) > -1 : 7699 list.length > 0; 7700 }, 7701 7702 // Remove all callbacks from the list 7703 empty: function() { 7704 if ( list ) { 7705 list = []; 7706 } 7707 return this; 7708 }, 7709 7710 // Disable .fire and .add 7711 // Abort any current/pending executions 7712 // Clear all callbacks and values 7713 disable: function() { 7714 locked = queue = []; 7715 list = memory = ""; 7716 return this; 7717 }, 7718 disabled: function() { 7719 return !list; 7720 }, 7721 7722 // Disable .fire 7723 // Also disable .add unless we have memory (since it would have no effect) 7724 // Abort any pending executions 7725 lock: function() { 7726 locked = queue = []; 7727 if ( !memory && !firing ) { 7728 list = memory = ""; 7729 } 7730 return this; 7731 }, 7732 locked: function() { 7733 return !!locked; 7734 }, 7735 7736 // Call all callbacks with the given context and arguments 7737 fireWith: function( context, args ) { 7738 if ( !locked ) { 7739 args = args || []; 7740 args = [ context, args.slice ? args.slice() : args ]; 7741 queue.push( args ); 7742 if ( !firing ) { 7743 fire(); 7744 } 7745 } 7746 return this; 7747 }, 7748 7749 // Call all the callbacks with the given arguments 7750 fire: function() { 7751 self.fireWith( this, arguments ); 7752 return this; 7753 }, 7754 7755 // To know if the callbacks have already been called at least once 7756 fired: function() { 7757 return !!fired; 7758 } 7759 }; 7760 7761 return self; 7762}; 7763 7764 7765function Identity( v ) { 7766 return v; 7767} 7768function Thrower( ex ) { 7769 throw ex; 7770} 7771 7772function adoptValue( value, resolve, reject, noValue ) { 7773 var method; 7774 7775 try { 7776 7777 // Check for promise aspect first to privilege synchronous behavior 7778 if ( value && isFunction( ( method = value.promise ) ) ) { 7779 method.call( value ).done( resolve ).fail( reject ); 7780 7781 // Other thenables 7782 } else if ( value && isFunction( ( method = value.then ) ) ) { 7783 method.call( value, resolve, reject ); 7784 7785 // Other non-thenables 7786 } else { 7787 7788 // Control `resolve` arguments by letting Array#slice cast boolean `noValue` to integer: 7789 // * false: [ value ].slice( 0 ) => resolve( value ) 7790 // * true: [ value ].slice( 1 ) => resolve() 7791 resolve.apply( undefined, [ value ].slice( noValue ) ); 7792 } 7793 7794 // For Promises/A+, convert exceptions into rejections 7795 // Since jQuery.when doesn't unwrap thenables, we can skip the extra checks appearing in 7796 // Deferred#then to conditionally suppress rejection. 7797 } catch ( value ) { 7798 7799 // Support: Android 4.0 only 7800 // Strict mode functions invoked without .call/.apply get global-object context 7801 reject.apply( undefined, [ value ] ); 7802 } 7803} 7804 7805jQuery.extend( { 7806 7807 Deferred: function( func ) { 7808 var tuples = [ 7809 7810 // action, add listener, callbacks, 7811 // ... .then handlers, argument index, [final state] 7812 [ "notify", "progress", jQuery.Callbacks( "memory" ), 7813 jQuery.Callbacks( "memory" ), 2 ], 7814 [ "resolve", "done", jQuery.Callbacks( "once memory" ), 7815 jQuery.Callbacks( "once memory" ), 0, "resolved" ], 7816 [ "reject", "fail", jQuery.Callbacks( "once memory" ), 7817 jQuery.Callbacks( "once memory" ), 1, "rejected" ] 7818 ], 7819 state = "pending", 7820 promise = { 7821 state: function() { 7822 return state; 7823 }, 7824 always: function() { 7825 deferred.done( arguments ).fail( arguments ); 7826 return this; 7827 }, 7828 "catch": function( fn ) { 7829 return promise.then( null, fn ); 7830 }, 7831 7832 // Keep pipe for back-compat 7833 pipe: function( /* fnDone, fnFail, fnProgress */ ) { 7834 var fns = arguments; 7835 7836 return jQuery.Deferred( function( newDefer ) { 7837 jQuery.each( tuples, function( _i, tuple ) { 7838 7839 // Map tuples (progress, done, fail) to arguments (done, fail, progress) 7840 var fn = isFunction( fns[ tuple[ 4 ] ] ) && fns[ tuple[ 4 ] ]; 7841 7842 // deferred.progress(function() { bind to newDefer or newDefer.notify }) 7843 // deferred.done(function() { bind to newDefer or newDefer.resolve }) 7844 // deferred.fail(function() { bind to newDefer or newDefer.reject }) 7845 deferred[ tuple[ 1 ] ]( function() { 7846 var returned = fn && fn.apply( this, arguments ); 7847 if ( returned && isFunction( returned.promise ) ) { 7848 returned.promise() 7849 .progress( newDefer.notify ) 7850 .done( newDefer.resolve ) 7851 .fail( newDefer.reject ); 7852 } else { 7853 newDefer[ tuple[ 0 ] + "With" ]( 7854 this, 7855 fn ? [ returned ] : arguments 7856 ); 7857 } 7858 } ); 7859 } ); 7860 fns = null; 7861 } ).promise(); 7862 }, 7863 then: function( onFulfilled, onRejected, onProgress ) { 7864 var maxDepth = 0; 7865 function resolve( depth, deferred, handler, special ) { 7866 return function() { 7867 var that = this, 7868 args = arguments, 7869 mightThrow = function() { 7870 var returned, then; 7871 7872 // Support: Promises/A+ section 2.3.3.3.3 7873 // https://promisesaplus.com/#point-59 7874 // Ignore double-resolution attempts 7875 if ( depth < maxDepth ) { 7876 return; 7877 } 7878 7879 returned = handler.apply( that, args ); 7880 7881 // Support: Promises/A+ section 2.3.1 7882 // https://promisesaplus.com/#point-48 7883 if ( returned === deferred.promise() ) { 7884 throw new TypeError( "Thenable self-resolution" ); 7885 } 7886 7887 // Support: Promises/A+ sections 2.3.3.1, 3.5 7888 // https://promisesaplus.com/#point-54 7889 // https://promisesaplus.com/#point-75 7890 // Retrieve `then` only once 7891 then = returned && 7892 7893 // Support: Promises/A+ section 2.3.4 7894 // https://promisesaplus.com/#point-64 7895 // Only check objects and functions for thenability 7896 ( typeof returned === "object" || 7897 typeof returned === "function" ) && 7898 returned.then; 7899 7900 // Handle a returned thenable 7901 if ( isFunction( then ) ) { 7902 7903 // Special processors (notify) just wait for resolution 7904 if ( special ) { 7905 then.call( 7906 returned, 7907 resolve( maxDepth, deferred, Identity, special ), 7908 resolve( maxDepth, deferred, Thrower, special ) 7909 ); 7910 7911 // Normal processors (resolve) also hook into progress 7912 } else { 7913 7914 // ...and disregard older resolution values 7915 maxDepth++; 7916 7917 then.call( 7918 returned, 7919 resolve( maxDepth, deferred, Identity, special ), 7920 resolve( maxDepth, deferred, Thrower, special ), 7921 resolve( maxDepth, deferred, Identity, 7922 deferred.notifyWith ) 7923 ); 7924 } 7925 7926 // Handle all other returned values 7927 } else { 7928 7929 // Only substitute handlers pass on context 7930 // and multiple values (non-spec behavior) 7931 if ( handler !== Identity ) { 7932 that = undefined; 7933 args = [ returned ]; 7934 } 7935 7936 // Process the value(s) 7937 // Default process is resolve 7938 ( special || deferred.resolveWith )( that, args ); 7939 } 7940 }, 7941 7942 // Only normal processors (resolve) catch and reject exceptions 7943 process = special ? 7944 mightThrow : 7945 function() { 7946 try { 7947 mightThrow(); 7948 } catch ( e ) { 7949 7950 if ( jQuery.Deferred.exceptionHook ) { 7951 jQuery.Deferred.exceptionHook( e, 7952 process.error ); 7953 } 7954 7955 // Support: Promises/A+ section 2.3.3.3.4.1 7956 // https://promisesaplus.com/#point-61 7957 // Ignore post-resolution exceptions 7958 if ( depth + 1 >= maxDepth ) { 7959 7960 // Only substitute handlers pass on context 7961 // and multiple values (non-spec behavior) 7962 if ( handler !== Thrower ) { 7963 that = undefined; 7964 args = [ e ]; 7965 } 7966 7967 deferred.rejectWith( that, args ); 7968 } 7969 } 7970 }; 7971 7972 // Support: Promises/A+ section 2.3.3.3.1 7973 // https://promisesaplus.com/#point-57 7974 // Re-resolve promises immediately to dodge false rejection from 7975 // subsequent errors 7976 if ( depth ) { 7977 process(); 7978 } else { 7979 7980 // Call an optional hook to record the error, in case of exception 7981 // since it's otherwise lost when execution goes async 7982 if ( jQuery.Deferred.getErrorHook ) { 7983 process.error = jQuery.Deferred.getErrorHook(); 7984 7985 // The deprecated alias of the above. While the name suggests 7986 // returning the stack, not an error instance, jQuery just passes 7987 // it directly to `console.warn` so both will work; an instance 7988 // just better cooperates with source maps. 7989 } else if ( jQuery.Deferred.getStackHook ) { 7990 process.error = jQuery.Deferred.getStackHook(); 7991 } 7992 window.setTimeout( process ); 7993 } 7994 }; 7995 } 7996 7997 return jQuery.Deferred( function( newDefer ) { 7998 7999 // progress_handlers.add( ... ) 8000 tuples[ 0 ][ 3 ].add( 8001 resolve( 8002 0, 8003 newDefer, 8004 isFunction( onProgress ) ? 8005 onProgress : 8006 Identity, 8007 newDefer.notifyWith 8008 ) 8009 ); 8010 8011 // fulfilled_handlers.add( ... ) 8012 tuples[ 1 ][ 3 ].add( 8013 resolve( 8014 0, 8015 newDefer, 8016 isFunction( onFulfilled ) ? 8017 onFulfilled : 8018 Identity 8019 ) 8020 ); 8021 8022 // rejected_handlers.add( ... ) 8023 tuples[ 2 ][ 3 ].add( 8024 resolve( 8025 0, 8026 newDefer, 8027 isFunction( onRejected ) ? 8028 onRejected : 8029 Thrower 8030 ) 8031 ); 8032 } ).promise(); 8033 }, 8034 8035 // Get a promise for this deferred 8036 // If obj is provided, the promise aspect is added to the object 8037 promise: function( obj ) { 8038 return obj != null ? jQuery.extend( obj, promise ) : promise; 8039 } 8040 }, 8041 deferred = {}; 8042 8043 // Add list-specific methods 8044 jQuery.each( tuples, function( i, tuple ) { 8045 var list = tuple[ 2 ], 8046 stateString = tuple[ 5 ]; 8047 8048 // promise.progress = list.add 8049 // promise.done = list.add 8050 // promise.fail = list.add 8051 promise[ tuple[ 1 ] ] = list.add; 8052 8053 // Handle state 8054 if ( stateString ) { 8055 list.add( 8056 function() { 8057 8058 // state = "resolved" (i.e., fulfilled) 8059 // state = "rejected" 8060 state = stateString; 8061 }, 8062 8063 // rejected_callbacks.disable 8064 // fulfilled_callbacks.disable 8065 tuples[ 3 - i ][ 2 ].disable, 8066 8067 // rejected_handlers.disable 8068 // fulfilled_handlers.disable 8069 tuples[ 3 - i ][ 3 ].disable, 8070 8071 // progress_callbacks.lock 8072 tuples[ 0 ][ 2 ].lock, 8073 8074 // progress_handlers.lock 8075 tuples[ 0 ][ 3 ].lock 8076 ); 8077 } 8078 8079 // progress_handlers.fire 8080 // fulfilled_handlers.fire 8081 // rejected_handlers.fire 8082 list.add( tuple[ 3 ].fire ); 8083 8084 // deferred.notify = function() { deferred.notifyWith(...) } 8085 // deferred.resolve = function() { deferred.resolveWith(...) } 8086 // deferred.reject = function() { deferred.rejectWith(...) } 8087 deferred[ tuple[ 0 ] ] = function() { 8088 deferred[ tuple[ 0 ] + "With" ]( this === deferred ? undefined : this, arguments ); 8089 return this; 8090 }; 8091 8092 // deferred.notifyWith = list.fireWith 8093 // deferred.resolveWith = list.fireWith 8094 // deferred.rejectWith = list.fireWith 8095 deferred[ tuple[ 0 ] + "With" ] = list.fireWith; 8096 } ); 8097 8098 // Make the deferred a promise 8099 promise.promise( deferred ); 8100 8101 // Call given func if any 8102 if ( func ) { 8103 func.call( deferred, deferred ); 8104 } 8105 8106 // All done! 8107 return deferred; 8108 }, 8109 8110 // Deferred helper 8111 when: function( singleValue ) { 8112 var 8113 8114 // count of uncompleted subordinates 8115 remaining = arguments.length, 8116 8117 // count of unprocessed arguments 8118 i = remaining, 8119 8120 // subordinate fulfillment data 8121 resolveContexts = Array( i ), 8122 resolveValues = slice.call( arguments ), 8123 8124 // the primary Deferred 8125 primary = jQuery.Deferred(), 8126 8127 // subordinate callback factory 8128 updateFunc = function( i ) { 8129 return function( value ) { 8130 resolveContexts[ i ] = this; 8131 resolveValues[ i ] = arguments.length > 1 ? slice.call( arguments ) : value; 8132 if ( !( --remaining ) ) { 8133 primary.resolveWith( resolveContexts, resolveValues ); 8134 } 8135 }; 8136 }; 8137 8138 // Single- and empty arguments are adopted like Promise.resolve 8139 if ( remaining <= 1 ) { 8140 adoptValue( singleValue, primary.done( updateFunc( i ) ).resolve, primary.reject, 8141 !remaining ); 8142 8143 // Use .then() to unwrap secondary thenables (cf. gh-3000) 8144 if ( primary.state() === "pending" || 8145 isFunction( resolveValues[ i ] && resolveValues[ i ].then ) ) { 8146 8147 return primary.then(); 8148 } 8149 } 8150 8151 // Multiple arguments are aggregated like Promise.all array elements 8152 while ( i-- ) { 8153 adoptValue( resolveValues[ i ], updateFunc( i ), primary.reject ); 8154 } 8155 8156 return primary.promise(); 8157 } 8158} ); 8159 8160 8161// These usually indicate a programmer mistake during development, 8162// warn about them ASAP rather than swallowing them by default. 8163var rerrorNames = /^(Eval|Internal|Range|Reference|Syntax|Type|URI)Error$/; 8164 8165// If `jQuery.Deferred.getErrorHook` is defined, `asyncError` is an error 8166// captured before the async barrier to get the original error cause 8167// which may otherwise be hidden. 8168jQuery.Deferred.exceptionHook = function( error, asyncError ) { 8169 8170 // Support: IE 8 - 9 only 8171 // Console exists when dev tools are open, which can happen at any time 8172 if ( window.console && window.console.warn && error && rerrorNames.test( error.name ) ) { 8173 window.console.warn( "jQuery.Deferred exception: " + error.message, 8174 error.stack, asyncError ); 8175 } 8176}; 8177 8178 8179 8180 8181jQuery.readyException = function( error ) { 8182 window.setTimeout( function() { 8183 throw error; 8184 } ); 8185}; 8186 8187 8188 8189 8190// The deferred used on DOM ready 8191var readyList = jQuery.Deferred(); 8192 8193jQuery.fn.ready = function( fn ) { 8194 8195 readyList 8196 .then( fn ) 8197 8198 // Wrap jQuery.readyException in a function so that the lookup 8199 // happens at the time of error handling instead of callback 8200 // registration. 8201 .catch( function( error ) { 8202 jQuery.readyException( error ); 8203 } ); 8204 8205 return this; 8206}; 8207 8208jQuery.extend( { 8209 8210 // Is the DOM ready to be used? Set to true once it occurs. 8211 isReady: false, 8212 8213 // A counter to track how many items to wait for before 8214 // the ready event fires. See trac-6781 8215 readyWait: 1, 8216 8217 // Handle when the DOM is ready 8218 ready: function( wait ) { 8219 8220 // Abort if there are pending holds or we're already ready 8221 if ( wait === true ? --jQuery.readyWait : jQuery.isReady ) { 8222 return; 8223 } 8224 8225 // Remember that the DOM is ready 8226 jQuery.isReady = true; 8227 8228 // If a normal DOM Ready event fired, decrement, and wait if need be 8229 if ( wait !== true && --jQuery.readyWait > 0 ) { 8230 return; 8231 } 8232 8233 // If there are functions bound, to execute 8234 readyList.resolveWith( document, [ jQuery ] ); 8235 } 8236} ); 8237 8238jQuery.ready.then = readyList.then; 8239 8240// The ready event handler and self cleanup method 8241function completed() { 8242 document.removeEventListener( "DOMContentLoaded", completed ); 8243 window.removeEventListener( "load", completed ); 8244 jQuery.ready(); 8245} 8246 8247// Catch cases where $(document).ready() is called 8248// after the browser event has already occurred. 8249// Support: IE <=9 - 10 only 8250// Older IE sometimes signals "interactive" too soon 8251if ( document.readyState === "complete" || 8252 ( document.readyState !== "loading" && !document.documentElement.doScroll ) ) { 8253 8254 // Handle it asynchronously to allow scripts the opportunity to delay ready 8255 window.setTimeout( jQuery.ready ); 8256 8257} else { 8258 8259 // Use the handy event callback 8260 document.addEventListener( "DOMContentLoaded", completed ); 8261 8262 // A fallback to window.onload, that will always work 8263 window.addEventListener( "load", completed ); 8264} 8265 8266 8267 8268 8269// Multifunctional method to get and set values of a collection 8270// The value/s can optionally be executed if it's a function 8271var access = function( elems, fn, key, value, chainable, emptyGet, raw ) { 8272 var i = 0, 8273 len = elems.length, 8274 bulk = key == null; 8275 8276 // Sets many values 8277 if ( toType( key ) === "object" ) { 8278 chainable = true; 8279 for ( i in key ) { 8280 access( elems, fn, i, key[ i ], true, emptyGet, raw ); 8281 } 8282 8283 // Sets one value 8284 } else if ( value !== undefined ) { 8285 chainable = true; 8286 8287 if ( !isFunction( value ) ) { 8288 raw = true; 8289 } 8290 8291 if ( bulk ) { 8292 8293 // Bulk operations run against the entire set 8294 if ( raw ) { 8295 fn.call( elems, value ); 8296 fn = null; 8297 8298 // ...except when executing function values 8299 } else { 8300 bulk = fn; 8301 fn = function( elem, _key, value ) { 8302 return bulk.call( jQuery( elem ), value ); 8303 }; 8304 } 8305 } 8306 8307 if ( fn ) { 8308 for ( ; i < len; i++ ) { 8309 fn( 8310 elems[ i ], key, raw ? 8311 value : 8312 value.call( elems[ i ], i, fn( elems[ i ], key ) ) 8313 ); 8314 } 8315 } 8316 } 8317 8318 if ( chainable ) { 8319 return elems; 8320 } 8321 8322 // Gets 8323 if ( bulk ) { 8324 return fn.call( elems ); 8325 } 8326 8327 return len ? fn( elems[ 0 ], key ) : emptyGet; 8328}; 8329 8330 8331// Matches dashed string for camelizing 8332var rmsPrefix = /^-ms-/, 8333 rdashAlpha = /-([a-z])/g; 8334 8335// Used by camelCase as callback to replace() 8336function fcamelCase( _all, letter ) { 8337 return letter.toUpperCase(); 8338} 8339 8340// Convert dashed to camelCase; used by the css and data modules 8341// Support: IE <=9 - 11, Edge 12 - 15 8342// Microsoft forgot to hump their vendor prefix (trac-9572) 8343function camelCase( string ) { 8344 return string.replace( rmsPrefix, "ms-" ).replace( rdashAlpha, fcamelCase ); 8345} 8346var acceptData = function( owner ) { 8347 8348 // Accepts only: 8349 // - Node 8350 // - Node.ELEMENT_NODE 8351 // - Node.DOCUMENT_NODE 8352 // - Object 8353 // - Any 8354 return owner.nodeType === 1 || owner.nodeType === 9 || !( +owner.nodeType ); 8355}; 8356 8357 8358 8359 8360function Data() { 8361 this.expando = jQuery.expando + Data.uid++; 8362} 8363 8364Data.uid = 1; 8365 8366Data.prototype = { 8367 8368 cache: function( owner ) { 8369 8370 // Check if the owner object already has a cache 8371 var value = owner[ this.expando ]; 8372 8373 // If not, create one 8374 if ( !value ) { 8375 value = {}; 8376 8377 // We can accept data for non-element nodes in modern browsers, 8378 // but we should not, see trac-8335. 8379 // Always return an empty object. 8380 if ( acceptData( owner ) ) { 8381 8382 // If it is a node unlikely to be stringify-ed or looped over 8383 // use plain assignment 8384 if ( owner.nodeType ) { 8385 owner[ this.expando ] = value; 8386 8387 // Otherwise secure it in a non-enumerable property 8388 // configurable must be true to allow the property to be 8389 // deleted when data is removed 8390 } else { 8391 Object.defineProperty( owner, this.expando, { 8392 value: value, 8393 configurable: true 8394 } ); 8395 } 8396 } 8397 } 8398 8399 return value; 8400 }, 8401 set: function( owner, data, value ) { 8402 var prop, 8403 cache = this.cache( owner ); 8404 8405 // Handle: [ owner, key, value ] args 8406 // Always use camelCase key (gh-2257) 8407 if ( typeof data === "string" ) { 8408 cache[ camelCase( data ) ] = value; 8409 8410 // Handle: [ owner, { properties } ] args 8411 } else { 8412 8413 // Copy the properties one-by-one to the cache object 8414 for ( prop in data ) { 8415 cache[ camelCase( prop ) ] = data[ prop ]; 8416 } 8417 } 8418 return cache; 8419 }, 8420 get: function( owner, key ) { 8421 return key === undefined ? 8422 this.cache( owner ) : 8423 8424 // Always use camelCase key (gh-2257) 8425 owner[ this.expando ] && owner[ this.expando ][ camelCase( key ) ]; 8426 }, 8427 access: function( owner, key, value ) { 8428 8429 // In cases where either: 8430 // 8431 // 1. No key was specified 8432 // 2. A string key was specified, but no value provided 8433 // 8434 // Take the "read" path and allow the get method to determine 8435 // which value to return, respectively either: 8436 // 8437 // 1. The entire cache object 8438 // 2. The data stored at the key 8439 // 8440 if ( key === undefined || 8441 ( ( key && typeof key === "string" ) && value === undefined ) ) { 8442 8443 return this.get( owner, key ); 8444 } 8445 8446 // When the key is not a string, or both a key and value 8447 // are specified, set or extend (existing objects) with either: 8448 // 8449 // 1. An object of properties 8450 // 2. A key and value 8451 // 8452 this.set( owner, key, value ); 8453 8454 // Since the "set" path can have two possible entry points 8455 // return the expected data based on which path was taken[*] 8456 return value !== undefined ? value : key; 8457 }, 8458 remove: function( owner, key ) { 8459 var i, 8460 cache = owner[ this.expando ]; 8461 8462 if ( cache === undefined ) { 8463 return; 8464 } 8465 8466 if ( key !== undefined ) { 8467 8468 // Support array or space separated string of keys 8469 if ( Array.isArray( key ) ) { 8470 8471 // If key is an array of keys... 8472 // We always set camelCase keys, so remove that. 8473 key = key.map( camelCase ); 8474 } else { 8475 key = camelCase( key ); 8476 8477 // If a key with the spaces exists, use it. 8478 // Otherwise, create an array by matching non-whitespace 8479 key = key in cache ? 8480 [ key ] : 8481 ( key.match( rnothtmlwhite ) || [] ); 8482 } 8483 8484 i = key.length; 8485 8486 while ( i-- ) { 8487 delete cache[ key[ i ] ]; 8488 } 8489 } 8490 8491 // Remove the expando if there's no more data 8492 if ( key === undefined || jQuery.isEmptyObject( cache ) ) { 8493 8494 // Support: Chrome <=35 - 45 8495 // Webkit & Blink performance suffers when deleting properties 8496 // from DOM nodes, so set to undefined instead 8497 // https://bugs.chromium.org/p/chromium/issues/detail?id=378607 (bug restricted) 8498 if ( owner.nodeType ) { 8499 owner[ this.expando ] = undefined; 8500 } else { 8501 delete owner[ this.expando ]; 8502 } 8503 } 8504 }, 8505 hasData: function( owner ) { 8506 var cache = owner[ this.expando ]; 8507 return cache !== undefined && !jQuery.isEmptyObject( cache ); 8508 } 8509}; 8510var dataPriv = new Data(); 8511 8512var dataUser = new Data(); 8513 8514 8515 8516// Implementation Summary 8517// 8518// 1. Enforce API surface and semantic compatibility with 1.9.x branch 8519// 2. Improve the module's maintainability by reducing the storage 8520// paths to a single mechanism. 8521// 3. Use the same single mechanism to support "private" and "user" data. 8522// 4. _Never_ expose "private" data to user code (TODO: Drop _data, _removeData) 8523// 5. Avoid exposing implementation details on user objects (eg. expando properties) 8524// 6. Provide a clear path for implementation upgrade to WeakMap in 2014 8525 8526var rbrace = /^(?:\{[\w\W]*\}|\[[\w\W]*\])$/, 8527 rmultiDash = /[A-Z]/g; 8528 8529function getData( data ) { 8530 if ( data === "true" ) { 8531 return true; 8532 } 8533 8534 if ( data === "false" ) { 8535 return false; 8536 } 8537 8538 if ( data === "null" ) { 8539 return null; 8540 } 8541 8542 // Only convert to a number if it doesn't change the string 8543 if ( data === +data + "" ) { 8544 return +data; 8545 } 8546 8547 if ( rbrace.test( data ) ) { 8548 return JSON.parse( data ); 8549 } 8550 8551 return data; 8552} 8553 8554function dataAttr( elem, key, data ) { 8555 var name; 8556 8557 // If nothing was found internally, try to fetch any 8558 // data from the HTML5 data-* attribute 8559 if ( data === undefined && elem.nodeType === 1 ) { 8560 name = "data-" + key.replace( rmultiDash, "-$&" ).toLowerCase(); 8561 data = elem.getAttribute( name ); 8562 8563 if ( typeof data === "string" ) { 8564 try { 8565 data = getData( data ); 8566 } catch ( e ) {} 8567 8568 // Make sure we set the data so it isn't changed later 8569 dataUser.set( elem, key, data ); 8570 } else { 8571 data = undefined; 8572 } 8573 } 8574 return data; 8575} 8576 8577jQuery.extend( { 8578 hasData: function( elem ) { 8579 return dataUser.hasData( elem ) || dataPriv.hasData( elem ); 8580 }, 8581 8582 data: function( elem, name, data ) { 8583 return dataUser.access( elem, name, data ); 8584 }, 8585 8586 removeData: function( elem, name ) { 8587 dataUser.remove( elem, name ); 8588 }, 8589 8590 // TODO: Now that all calls to _data and _removeData have been replaced 8591 // with direct calls to dataPriv methods, these can be deprecated. 8592 _data: function( elem, name, data ) { 8593 return dataPriv.access( elem, name, data ); 8594 }, 8595 8596 _removeData: function( elem, name ) { 8597 dataPriv.remove( elem, name ); 8598 } 8599} ); 8600 8601jQuery.fn.extend( { 8602 data: function( key, value ) { 8603 var i, name, data, 8604 elem = this[ 0 ], 8605 attrs = elem && elem.attributes; 8606 8607 // Gets all values 8608 if ( key === undefined ) { 8609 if ( this.length ) { 8610 data = dataUser.get( elem ); 8611 8612 if ( elem.nodeType === 1 && !dataPriv.get( elem, "hasDataAttrs" ) ) { 8613 i = attrs.length; 8614 while ( i-- ) { 8615 8616 // Support: IE 11 only 8617 // The attrs elements can be null (trac-14894) 8618 if ( attrs[ i ] ) { 8619 name = attrs[ i ].name; 8620 if ( name.indexOf( "data-" ) === 0 ) { 8621 name = camelCase( name.slice( 5 ) ); 8622 dataAttr( elem, name, data[ name ] ); 8623 } 8624 } 8625 } 8626 dataPriv.set( elem, "hasDataAttrs", true ); 8627 } 8628 } 8629 8630 return data; 8631 } 8632 8633 // Sets multiple values 8634 if ( typeof key === "object" ) { 8635 return this.each( function() { 8636 dataUser.set( this, key ); 8637 } ); 8638 } 8639 8640 return access( this, function( value ) { 8641 var data; 8642 8643 // The calling jQuery object (element matches) is not empty 8644 // (and therefore has an element appears at this[ 0 ]) and the 8645 // `value` parameter was not undefined. An empty jQuery object 8646 // will result in `undefined` for elem = this[ 0 ] which will 8647 // throw an exception if an attempt to read a data cache is made. 8648 if ( elem && value === undefined ) { 8649 8650 // Attempt to get data from the cache 8651 // The key will always be camelCased in Data 8652 data = dataUser.get( elem, key ); 8653 if ( data !== undefined ) { 8654 return data; 8655 } 8656 8657 // Attempt to "discover" the data in 8658 // HTML5 custom data-* attrs 8659 data = dataAttr( elem, key ); 8660 if ( data !== undefined ) { 8661 return data; 8662 } 8663 8664 // We tried really hard, but the data doesn't exist. 8665 return; 8666 } 8667 8668 // Set the data... 8669 this.each( function() { 8670 8671 // We always store the camelCased key 8672 dataUser.set( this, key, value ); 8673 } ); 8674 }, null, value, arguments.length > 1, null, true ); 8675 }, 8676 8677 removeData: function( key ) { 8678 return this.each( function() { 8679 dataUser.remove( this, key ); 8680 } ); 8681 } 8682} ); 8683 8684 8685jQuery.extend( { 8686 queue: function( elem, type, data ) { 8687 var queue; 8688 8689 if ( elem ) { 8690 type = ( type || "fx" ) + "queue"; 8691 queue = dataPriv.get( elem, type ); 8692 8693 // Speed up dequeue by getting out quickly if this is just a lookup 8694 if ( data ) { 8695 if ( !queue || Array.isArray( data ) ) { 8696 queue = dataPriv.access( elem, type, jQuery.makeArray( data ) ); 8697 } else { 8698 queue.push( data ); 8699 } 8700 } 8701 return queue || []; 8702 } 8703 }, 8704 8705 dequeue: function( elem, type ) { 8706 type = type || "fx"; 8707 8708 var queue = jQuery.queue( elem, type ), 8709 startLength = queue.length, 8710 fn = queue.shift(), 8711 hooks = jQuery._queueHooks( elem, type ), 8712 next = function() { 8713 jQuery.dequeue( elem, type ); 8714 }; 8715 8716 // If the fx queue is dequeued, always remove the progress sentinel 8717 if ( fn === "inprogress" ) { 8718 fn = queue.shift(); 8719 startLength--; 8720 } 8721 8722 if ( fn ) { 8723 8724 // Add a progress sentinel to prevent the fx queue from being 8725 // automatically dequeued 8726 if ( type === "fx" ) { 8727 queue.unshift( "inprogress" ); 8728 } 8729 8730 // Clear up the last queue stop function 8731 delete hooks.stop; 8732 fn.call( elem, next, hooks ); 8733 } 8734 8735 if ( !startLength && hooks ) { 8736 hooks.empty.fire(); 8737 } 8738 }, 8739 8740 // Not public - generate a queueHooks object, or return the current one 8741 _queueHooks: function( elem, type ) { 8742 var key = type + "queueHooks"; 8743 return dataPriv.get( elem, key ) || dataPriv.access( elem, key, { 8744 empty: jQuery.Callbacks( "once memory" ).add( function() { 8745 dataPriv.remove( elem, [ type + "queue", key ] ); 8746 } ) 8747 } ); 8748 } 8749} ); 8750 8751jQuery.fn.extend( { 8752 queue: function( type, data ) { 8753 var setter = 2; 8754 8755 if ( typeof type !== "string" ) { 8756 data = type; 8757 type = "fx"; 8758 setter--; 8759 } 8760 8761 if ( arguments.length < setter ) { 8762 return jQuery.queue( this[ 0 ], type ); 8763 } 8764 8765 return data === undefined ? 8766 this : 8767 this.each( function() { 8768 var queue = jQuery.queue( this, type, data ); 8769 8770 // Ensure a hooks for this queue 8771 jQuery._queueHooks( this, type ); 8772 8773 if ( type === "fx" && queue[ 0 ] !== "inprogress" ) { 8774 jQuery.dequeue( this, type ); 8775 } 8776 } ); 8777 }, 8778 dequeue: function( type ) { 8779 return this.each( function() { 8780 jQuery.dequeue( this, type ); 8781 } ); 8782 }, 8783 clearQueue: function( type ) { 8784 return this.queue( type || "fx", [] ); 8785 }, 8786 8787 // Get a promise resolved when queues of a certain type 8788 // are emptied (fx is the type by default) 8789 promise: function( type, obj ) { 8790 var tmp, 8791 count = 1, 8792 defer = jQuery.Deferred(), 8793 elements = this, 8794 i = this.length, 8795 resolve = function() { 8796 if ( !( --count ) ) { 8797 defer.resolveWith( elements, [ elements ] ); 8798 } 8799 }; 8800 8801 if ( typeof type !== "string" ) { 8802 obj = type; 8803 type = undefined; 8804 } 8805 type = type || "fx"; 8806 8807 while ( i-- ) { 8808 tmp = dataPriv.get( elements[ i ], type + "queueHooks" ); 8809 if ( tmp && tmp.empty ) { 8810 count++; 8811 tmp.empty.add( resolve ); 8812 } 8813 } 8814 resolve(); 8815 return defer.promise( obj ); 8816 } 8817} ); 8818var pnum = ( /[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/ ).source; 8819 8820var rcssNum = new RegExp( "^(?:([+-])=|)(" + pnum + ")([a-z%]*)$", "i" ); 8821 8822 8823var cssExpand = [ "Top", "Right", "Bottom", "Left" ]; 8824 8825var documentElement = document.documentElement; 8826 8827 8828 8829 var isAttached = function( elem ) { 8830 return jQuery.contains( elem.ownerDocument, elem ); 8831 }, 8832 composed = { composed: true }; 8833 8834 // Support: IE 9 - 11+, Edge 12 - 18+, iOS 10.0 - 10.2 only 8835 // Check attachment across shadow DOM boundaries when possible (gh-3504) 8836 // Support: iOS 10.0-10.2 only 8837 // Early iOS 10 versions support `attachShadow` but not `getRootNode`, 8838 // leading to errors. We need to check for `getRootNode`. 8839 if ( documentElement.getRootNode ) { 8840 isAttached = function( elem ) { 8841 return jQuery.contains( elem.ownerDocument, elem ) || 8842 elem.getRootNode( composed ) === elem.ownerDocument; 8843 }; 8844 } 8845var isHiddenWithinTree = function( elem, el ) { 8846 8847 // isHiddenWithinTree might be called from jQuery#filter function; 8848 // in that case, element will be second argument 8849 elem = el || elem; 8850 8851 // Inline style trumps all 8852 return elem.style.display === "none" || 8853 elem.style.display === "" && 8854 8855 // Otherwise, check computed style 8856 // Support: Firefox <=43 - 45 8857 // Disconnected elements can have computed display: none, so first confirm that elem is 8858 // in the document. 8859 isAttached( elem ) && 8860 8861 jQuery.css( elem, "display" ) === "none"; 8862 }; 8863 8864 8865 8866function adjustCSS( elem, prop, valueParts, tween ) { 8867 var adjusted, scale, 8868 maxIterations = 20, 8869 currentValue = tween ? 8870 function() { 8871 return tween.cur(); 8872 } : 8873 function() { 8874 return jQuery.css( elem, prop, "" ); 8875 }, 8876 initial = currentValue(), 8877 unit = valueParts && valueParts[ 3 ] || ( jQuery.cssNumber[ prop ] ? "" : "px" ), 8878 8879 // Starting value computation is required for potential unit mismatches 8880 initialInUnit = elem.nodeType && 8881 ( jQuery.cssNumber[ prop ] || unit !== "px" && +initial ) && 8882 rcssNum.exec( jQuery.css( elem, prop ) ); 8883 8884 if ( initialInUnit && initialInUnit[ 3 ] !== unit ) { 8885 8886 // Support: Firefox <=54 8887 // Halve the iteration target value to prevent interference from CSS upper bounds (gh-2144) 8888 initial = initial / 2; 8889 8890 // Trust units reported by jQuery.css 8891 unit = unit || initialInUnit[ 3 ]; 8892 8893 // Iteratively approximate from a nonzero starting point 8894 initialInUnit = +initial || 1; 8895 8896 while ( maxIterations-- ) { 8897 8898 // Evaluate and update our best guess (doubling guesses that zero out). 8899 // Finish if the scale equals or crosses 1 (making the old*new product non-positive). 8900 jQuery.style( elem, prop, initialInUnit + unit ); 8901 if ( ( 1 - scale ) * ( 1 - ( scale = currentValue() / initial || 0.5 ) ) <= 0 ) { 8902 maxIterations = 0; 8903 } 8904 initialInUnit = initialInUnit / scale; 8905 8906 } 8907 8908 initialInUnit = initialInUnit * 2; 8909 jQuery.style( elem, prop, initialInUnit + unit ); 8910 8911 // Make sure we update the tween properties later on 8912 valueParts = valueParts || []; 8913 } 8914 8915 if ( valueParts ) { 8916 initialInUnit = +initialInUnit || +initial || 0; 8917 8918 // Apply relative offset (+=/-=) if specified 8919 adjusted = valueParts[ 1 ] ? 8920 initialInUnit + ( valueParts[ 1 ] + 1 ) * valueParts[ 2 ] : 8921 +valueParts[ 2 ]; 8922 if ( tween ) { 8923 tween.unit = unit; 8924 tween.start = initialInUnit; 8925 tween.end = adjusted; 8926 } 8927 } 8928 return adjusted; 8929} 8930 8931 8932var defaultDisplayMap = {}; 8933 8934function getDefaultDisplay( elem ) { 8935 var temp, 8936 doc = elem.ownerDocument, 8937 nodeName = elem.nodeName, 8938 display = defaultDisplayMap[ nodeName ]; 8939 8940 if ( display ) { 8941 return display; 8942 } 8943 8944 temp = doc.body.appendChild( doc.createElement( nodeName ) ); 8945 display = jQuery.css( temp, "display" ); 8946 8947 temp.parentNode.removeChild( temp ); 8948 8949 if ( display === "none" ) { 8950 display = "block"; 8951 } 8952 defaultDisplayMap[ nodeName ] = display; 8953 8954 return display; 8955} 8956 8957function showHide( elements, show ) { 8958 var display, elem, 8959 values = [], 8960 index = 0, 8961 length = elements.length; 8962 8963 // Determine new display value for elements that need to change 8964 for ( ; index < length; index++ ) { 8965 elem = elements[ index ]; 8966 if ( !elem.style ) { 8967 continue; 8968 } 8969 8970 display = elem.style.display; 8971 if ( show ) { 8972 8973 // Since we force visibility upon cascade-hidden elements, an immediate (and slow) 8974 // check is required in this first loop unless we have a nonempty display value (either 8975 // inline or about-to-be-restored) 8976 if ( display === "none" ) { 8977 values[ index ] = dataPriv.get( elem, "display" ) || null; 8978 if ( !values[ index ] ) { 8979 elem.style.display = ""; 8980 } 8981 } 8982 if ( elem.style.display === "" && isHiddenWithinTree( elem ) ) { 8983 values[ index ] = getDefaultDisplay( elem ); 8984 } 8985 } else { 8986 if ( display !== "none" ) { 8987 values[ index ] = "none"; 8988 8989 // Remember what we're overwriting 8990 dataPriv.set( elem, "display", display ); 8991 } 8992 } 8993 } 8994 8995 // Set the display of the elements in a second loop to avoid constant reflow 8996 for ( index = 0; index < length; index++ ) { 8997 if ( values[ index ] != null ) { 8998 elements[ index ].style.display = values[ index ]; 8999 } 9000 } 9001 9002 return elements; 9003} 9004 9005jQuery.fn.extend( { 9006 show: function() { 9007 return showHide( this, true ); 9008 }, 9009 hide: function() { 9010 return showHide( this ); 9011 }, 9012 toggle: function( state ) { 9013 if ( typeof state === "boolean" ) { 9014 return state ? this.show() : this.hide(); 9015 } 9016 9017 return this.each( function() { 9018 if ( isHiddenWithinTree( this ) ) { 9019 jQuery( this ).show(); 9020 } else { 9021 jQuery( this ).hide(); 9022 } 9023 } ); 9024 } 9025} ); 9026var rcheckableType = ( /^(?:checkbox|radio)$/i ); 9027 9028var rtagName = ( /<([a-z][^\/\0>\x20\t\r\n\f]*)/i ); 9029 9030var rscriptType = ( /^$|^module$|\/(?:java|ecma)script/i ); 9031 9032 9033 9034( function() { 9035 var fragment = document.createDocumentFragment(), 9036 div = fragment.appendChild( document.createElement( "div" ) ), 9037 input = document.createElement( "input" ); 9038 9039 // Support: Android 4.0 - 4.3 only 9040 // Check state lost if the name is set (trac-11217) 9041 // Support: Windows Web Apps (WWA) 9042 // `name` and `type` must use .setAttribute for WWA (trac-14901) 9043 input.setAttribute( "type", "radio" ); 9044 input.setAttribute( "checked", "checked" ); 9045 input.setAttribute( "name", "t" ); 9046 9047 div.appendChild( input ); 9048 9049 // Support: Android <=4.1 only 9050 // Older WebKit doesn't clone checked state correctly in fragments 9051 support.checkClone = div.cloneNode( true ).cloneNode( true ).lastChild.checked; 9052 9053 // Support: IE <=11 only 9054 // Make sure textarea (and checkbox) defaultValue is properly cloned 9055 div.innerHTML = "<textarea>x</textarea>"; 9056 support.noCloneChecked = !!div.cloneNode( true ).lastChild.defaultValue; 9057 9058 // Support: IE <=9 only 9059 // IE <=9 replaces <option> tags with their contents when inserted outside of 9060 // the select element. 9061 div.innerHTML = "<option></option>"; 9062 support.option = !!div.lastChild; 9063} )(); 9064 9065 9066// We have to close these tags to support XHTML (trac-13200) 9067var wrapMap = { 9068 9069 // XHTML parsers do not magically insert elements in the 9070 // same way that tag soup parsers do. So we cannot shorten 9071 // this by omitting <tbody> or other required elements. 9072 thead: [ 1, "<table>", "</table>" ], 9073 col: [ 2, "<table><colgroup>", "</colgroup></table>" ], 9074 tr: [ 2, "<table><tbody>", "</tbody></table>" ], 9075 td: [ 3, "<table><tbody><tr>", "</tr></tbody></table>" ], 9076 9077 _default: [ 0, "", "" ] 9078}; 9079 9080wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead; 9081wrapMap.th = wrapMap.td; 9082 9083// Support: IE <=9 only 9084if ( !support.option ) { 9085 wrapMap.optgroup = wrapMap.option = [ 1, "<select multiple='multiple'>", "</select>" ]; 9086} 9087 9088 9089function getAll( context, tag ) { 9090 9091 // Support: IE <=9 - 11 only 9092 // Use typeof to avoid zero-argument method invocation on host objects (trac-15151) 9093 var ret; 9094 9095 if ( typeof context.getElementsByTagName !== "undefined" ) { 9096 ret = context.getElementsByTagName( tag || "*" ); 9097 9098 } else if ( typeof context.querySelectorAll !== "undefined" ) { 9099 ret = context.querySelectorAll( tag || "*" ); 9100 9101 } else { 9102 ret = []; 9103 } 9104 9105 if ( tag === undefined || tag && nodeName( context, tag ) ) { 9106 return jQuery.merge( [ context ], ret ); 9107 } 9108 9109 return ret; 9110} 9111 9112 9113// Mark scripts as having already been evaluated 9114function setGlobalEval( elems, refElements ) { 9115 var i = 0, 9116 l = elems.length; 9117 9118 for ( ; i < l; i++ ) { 9119 dataPriv.set( 9120 elems[ i ], 9121 "globalEval", 9122 !refElements || dataPriv.get( refElements[ i ], "globalEval" ) 9123 ); 9124 } 9125} 9126 9127 9128var rhtml = /<|&#?\w+;/; 9129 9130function buildFragment( elems, context, scripts, selection, ignored ) { 9131 var elem, tmp, tag, wrap, attached, j, 9132 fragment = context.createDocumentFragment(), 9133 nodes = [], 9134 i = 0, 9135 l = elems.length; 9136 9137 for ( ; i < l; i++ ) { 9138 elem = elems[ i ]; 9139 9140 if ( elem || elem === 0 ) { 9141 9142 // Add nodes directly 9143 if ( toType( elem ) === "object" ) { 9144 9145 // Support: Android <=4.0 only, PhantomJS 1 only 9146 // push.apply(_, arraylike) throws on ancient WebKit 9147 jQuery.merge( nodes, elem.nodeType ? [ elem ] : elem ); 9148 9149 // Convert non-html into a text node 9150 } else if ( !rhtml.test( elem ) ) { 9151 nodes.push( context.createTextNode( elem ) ); 9152 9153 // Convert html into DOM nodes 9154 } else { 9155 tmp = tmp || fragment.appendChild( context.createElement( "div" ) ); 9156 9157 // Deserialize a standard representation 9158 tag = ( rtagName.exec( elem ) || [ "", "" ] )[ 1 ].toLowerCase(); 9159 wrap = wrapMap[ tag ] || wrapMap._default; 9160 tmp.innerHTML = wrap[ 1 ] + jQuery.htmlPrefilter( elem ) + wrap[ 2 ]; 9161 9162 // Descend through wrappers to the right content 9163 j = wrap[ 0 ]; 9164 while ( j-- ) { 9165 tmp = tmp.lastChild; 9166 } 9167 9168 // Support: Android <=4.0 only, PhantomJS 1 only 9169 // push.apply(_, arraylike) throws on ancient WebKit 9170 jQuery.merge( nodes, tmp.childNodes ); 9171 9172 // Remember the top-level container 9173 tmp = fragment.firstChild; 9174 9175 // Ensure the created nodes are orphaned (trac-12392) 9176 tmp.textContent = ""; 9177 } 9178 } 9179 } 9180 9181 // Remove wrapper from fragment 9182 fragment.textContent = ""; 9183 9184 i = 0; 9185 while ( ( elem = nodes[ i++ ] ) ) { 9186 9187 // Skip elements already in the context collection (trac-4087) 9188 if ( selection && jQuery.inArray( elem, selection ) > -1 ) { 9189 if ( ignored ) { 9190 ignored.push( elem ); 9191 } 9192 continue; 9193 } 9194 9195 attached = isAttached( elem ); 9196 9197 // Append to fragment 9198 tmp = getAll( fragment.appendChild( elem ), "script" ); 9199 9200 // Preserve script evaluation history 9201 if ( attached ) { 9202 setGlobalEval( tmp ); 9203 } 9204 9205 // Capture executables 9206 if ( scripts ) { 9207 j = 0; 9208 while ( ( elem = tmp[ j++ ] ) ) { 9209 if ( rscriptType.test( elem.type || "" ) ) { 9210 scripts.push( elem ); 9211 } 9212 } 9213 } 9214 } 9215 9216 return fragment; 9217} 9218 9219 9220var rtypenamespace = /^([^.]*)(?:\.(.+)|)/; 9221 9222function returnTrue() { 9223 return true; 9224} 9225 9226function returnFalse() { 9227 return false; 9228} 9229 9230function on( elem, types, selector, data, fn, one ) { 9231 var origFn, type; 9232 9233 // Types can be a map of types/handlers 9234 if ( typeof types === "object" ) { 9235 9236 // ( types-Object, selector, data ) 9237 if ( typeof selector !== "string" ) { 9238 9239 // ( types-Object, data ) 9240 data = data || selector; 9241 selector = undefined; 9242 } 9243 for ( type in types ) { 9244 on( elem, type, selector, data, types[ type ], one ); 9245 } 9246 return elem; 9247 } 9248 9249 if ( data == null && fn == null ) { 9250 9251 // ( types, fn ) 9252 fn = selector; 9253 data = selector = undefined; 9254 } else if ( fn == null ) { 9255 if ( typeof selector === "string" ) { 9256 9257 // ( types, selector, fn ) 9258 fn = data; 9259 data = undefined; 9260 } else { 9261 9262 // ( types, data, fn ) 9263 fn = data; 9264 data = selector; 9265 selector = undefined; 9266 } 9267 } 9268 if ( fn === false ) { 9269 fn = returnFalse; 9270 } else if ( !fn ) { 9271 return elem; 9272 } 9273 9274 if ( one === 1 ) { 9275 origFn = fn; 9276 fn = function( event ) { 9277 9278 // Can use an empty set, since event contains the info 9279 jQuery().off( event ); 9280 return origFn.apply( this, arguments ); 9281 }; 9282 9283 // Use same guid so caller can remove using origFn 9284 fn.guid = origFn.guid || ( origFn.guid = jQuery.guid++ ); 9285 } 9286 return elem.each( function() { 9287 jQuery.event.add( this, types, fn, data, selector ); 9288 } ); 9289} 9290 9291/* 9292 * Helper functions for managing events -- not part of the public interface. 9293 * Props to Dean Edwards' addEvent library for many of the ideas. 9294 */ 9295jQuery.event = { 9296 9297 global: {}, 9298 9299 add: function( elem, types, handler, data, selector ) { 9300 9301 var handleObjIn, eventHandle, tmp, 9302 events, t, handleObj, 9303 special, handlers, type, namespaces, origType, 9304 elemData = dataPriv.get( elem ); 9305 9306 // Only attach events to objects that accept data 9307 if ( !acceptData( elem ) ) { 9308 return; 9309 } 9310 9311 // Caller can pass in an object of custom data in lieu of the handler 9312 if ( handler.handler ) { 9313 handleObjIn = handler; 9314 handler = handleObjIn.handler; 9315 selector = handleObjIn.selector; 9316 } 9317 9318 // Ensure that invalid selectors throw exceptions at attach time 9319 // Evaluate against documentElement in case elem is a non-element node (e.g., document) 9320 if ( selector ) { 9321 jQuery.find.matchesSelector( documentElement, selector ); 9322 } 9323 9324 // Make sure that the handler has a unique ID, used to find/remove it later 9325 if ( !handler.guid ) { 9326 handler.guid = jQuery.guid++; 9327 } 9328 9329 // Init the element's event structure and main handler, if this is the first 9330 if ( !( events = elemData.events ) ) { 9331 events = elemData.events = Object.create( null ); 9332 } 9333 if ( !( eventHandle = elemData.handle ) ) { 9334 eventHandle = elemData.handle = function( e ) { 9335 9336 // Discard the second event of a jQuery.event.trigger() and 9337 // when an event is called after a page has unloaded 9338 return typeof jQuery !== "undefined" && jQuery.event.triggered !== e.type ? 9339 jQuery.event.dispatch.apply( elem, arguments ) : undefined; 9340 }; 9341 } 9342 9343 // Handle multiple events separated by a space 9344 types = ( types || "" ).match( rnothtmlwhite ) || [ "" ]; 9345 t = types.length; 9346 while ( t-- ) { 9347 tmp = rtypenamespace.exec( types[ t ] ) || []; 9348 type = origType = tmp[ 1 ]; 9349 namespaces = ( tmp[ 2 ] || "" ).split( "." ).sort(); 9350 9351 // There *must* be a type, no attaching namespace-only handlers 9352 if ( !type ) { 9353 continue; 9354 } 9355 9356 // If event changes its type, use the special event handlers for the changed type 9357 special = jQuery.event.special[ type ] || {}; 9358 9359 // If selector defined, determine special event api type, otherwise given type 9360 type = ( selector ? special.delegateType : special.bindType ) || type; 9361 9362 // Update special based on newly reset type 9363 special = jQuery.event.special[ type ] || {}; 9364 9365 // handleObj is passed to all event handlers 9366 handleObj = jQuery.extend( { 9367 type: type, 9368 origType: origType, 9369 data: data, 9370 handler: handler, 9371 guid: handler.guid, 9372 selector: selector, 9373 needsContext: selector && jQuery.expr.match.needsContext.test( selector ), 9374 namespace: namespaces.join( "." ) 9375 }, handleObjIn ); 9376 9377 // Init the event handler queue if we're the first 9378 if ( !( handlers = events[ type ] ) ) { 9379 handlers = events[ type ] = []; 9380 handlers.delegateCount = 0; 9381 9382 // Only use addEventListener if the special events handler returns false 9383 if ( !special.setup || 9384 special.setup.call( elem, data, namespaces, eventHandle ) === false ) { 9385 9386 if ( elem.addEventListener ) { 9387 elem.addEventListener( type, eventHandle ); 9388 } 9389 } 9390 } 9391 9392 if ( special.add ) { 9393 special.add.call( elem, handleObj ); 9394 9395 if ( !handleObj.handler.guid ) { 9396 handleObj.handler.guid = handler.guid; 9397 } 9398 } 9399 9400 // Add to the element's handler list, delegates in front 9401 if ( selector ) { 9402 handlers.splice( handlers.delegateCount++, 0, handleObj ); 9403 } else { 9404 handlers.push( handleObj ); 9405 } 9406 9407 // Keep track of which events have ever been used, for event optimization 9408 jQuery.event.global[ type ] = true; 9409 } 9410 9411 }, 9412 9413 // Detach an event or set of events from an element 9414 remove: function( elem, types, handler, selector, mappedTypes ) { 9415 9416 var j, origCount, tmp, 9417 events, t, handleObj, 9418 special, handlers, type, namespaces, origType, 9419 elemData = dataPriv.hasData( elem ) && dataPriv.get( elem ); 9420 9421 if ( !elemData || !( events = elemData.events ) ) { 9422 return; 9423 } 9424 9425 // Once for each type.namespace in types; type may be omitted 9426 types = ( types || "" ).match( rnothtmlwhite ) || [ "" ]; 9427 t = types.length; 9428 while ( t-- ) { 9429 tmp = rtypenamespace.exec( types[ t ] ) || []; 9430 type = origType = tmp[ 1 ]; 9431 namespaces = ( tmp[ 2 ] || "" ).split( "." ).sort(); 9432 9433 // Unbind all events (on this namespace, if provided) for the element 9434 if ( !type ) { 9435 for ( type in events ) { 9436 jQuery.event.remove( elem, type + types[ t ], handler, selector, true ); 9437 } 9438 continue; 9439 } 9440 9441 special = jQuery.event.special[ type ] || {}; 9442 type = ( selector ? special.delegateType : special.bindType ) || type; 9443 handlers = events[ type ] || []; 9444 tmp = tmp[ 2 ] && 9445 new RegExp( "(^|\\.)" + namespaces.join( "\\.(?:.*\\.|)" ) + "(\\.|$)" ); 9446 9447 // Remove matching events 9448 origCount = j = handlers.length; 9449 while ( j-- ) { 9450 handleObj = handlers[ j ]; 9451 9452 if ( ( mappedTypes || origType === handleObj.origType ) && 9453 ( !handler || handler.guid === handleObj.guid ) && 9454 ( !tmp || tmp.test( handleObj.namespace ) ) && 9455 ( !selector || selector === handleObj.selector || 9456 selector === "**" && handleObj.selector ) ) { 9457 handlers.splice( j, 1 ); 9458 9459 if ( handleObj.selector ) { 9460 handlers.delegateCount--; 9461 } 9462 if ( special.remove ) { 9463 special.remove.call( elem, handleObj ); 9464 } 9465 } 9466 } 9467 9468 // Remove generic event handler if we removed something and no more handlers exist 9469 // (avoids potential for endless recursion during removal of special event handlers) 9470 if ( origCount && !handlers.length ) { 9471 if ( !special.teardown || 9472 special.teardown.call( elem, namespaces, elemData.handle ) === false ) { 9473 9474 jQuery.removeEvent( elem, type, elemData.handle ); 9475 } 9476 9477 delete events[ type ]; 9478 } 9479 } 9480 9481 // Remove data and the expando if it's no longer used 9482 if ( jQuery.isEmptyObject( events ) ) { 9483 dataPriv.remove( elem, "handle events" ); 9484 } 9485 }, 9486 9487 dispatch: function( nativeEvent ) { 9488 9489 var i, j, ret, matched, handleObj, handlerQueue, 9490 args = new Array( arguments.length ), 9491 9492 // Make a writable jQuery.Event from the native event object 9493 event = jQuery.event.fix( nativeEvent ), 9494 9495 handlers = ( 9496 dataPriv.get( this, "events" ) || Object.create( null ) 9497 )[ event.type ] || [], 9498 special = jQuery.event.special[ event.type ] || {}; 9499 9500 // Use the fix-ed jQuery.Event rather than the (read-only) native event 9501 args[ 0 ] = event; 9502 9503 for ( i = 1; i < arguments.length; i++ ) { 9504 args[ i ] = arguments[ i ]; 9505 } 9506 9507 event.delegateTarget = this; 9508 9509 // Call the preDispatch hook for the mapped type, and let it bail if desired 9510 if ( special.preDispatch && special.preDispatch.call( this, event ) === false ) { 9511 return; 9512 } 9513 9514 // Determine handlers 9515 handlerQueue = jQuery.event.handlers.call( this, event, handlers ); 9516 9517 // Run delegates first; they may want to stop propagation beneath us 9518 i = 0; 9519 while ( ( matched = handlerQueue[ i++ ] ) && !event.isPropagationStopped() ) { 9520 event.currentTarget = matched.elem; 9521 9522 j = 0; 9523 while ( ( handleObj = matched.handlers[ j++ ] ) && 9524 !event.isImmediatePropagationStopped() ) { 9525 9526 // If the event is namespaced, then each handler is only invoked if it is 9527 // specially universal or its namespaces are a superset of the event's. 9528 if ( !event.rnamespace || handleObj.namespace === false || 9529 event.rnamespace.test( handleObj.namespace ) ) { 9530 9531 event.handleObj = handleObj; 9532 event.data = handleObj.data; 9533 9534 ret = ( ( jQuery.event.special[ handleObj.origType ] || {} ).handle || 9535 handleObj.handler ).apply( matched.elem, args ); 9536 9537 if ( ret !== undefined ) { 9538 if ( ( event.result = ret ) === false ) { 9539 event.preventDefault(); 9540 event.stopPropagation(); 9541 } 9542 } 9543 } 9544 } 9545 } 9546 9547 // Call the postDispatch hook for the mapped type 9548 if ( special.postDispatch ) { 9549 special.postDispatch.call( this, event ); 9550 } 9551 9552 return event.result; 9553 }, 9554 9555 handlers: function( event, handlers ) { 9556 var i, handleObj, sel, matchedHandlers, matchedSelectors, 9557 handlerQueue = [], 9558 delegateCount = handlers.delegateCount, 9559 cur = event.target; 9560 9561 // Find delegate handlers 9562 if ( delegateCount && 9563 9564 // Support: IE <=9 9565 // Black-hole SVG <use> instance trees (trac-13180) 9566 cur.nodeType && 9567 9568 // Support: Firefox <=42 9569 // Suppress spec-violating clicks indicating a non-primary pointer button (trac-3861) 9570 // https://www.w3.org/TR/DOM-Level-3-Events/#event-type-click 9571 // Support: IE 11 only 9572 // ...but not arrow key "clicks" of radio inputs, which can have `button` -1 (gh-2343) 9573 !( event.type === "click" && event.button >= 1 ) ) { 9574 9575 for ( ; cur !== this; cur = cur.parentNode || this ) { 9576 9577 // Don't check non-elements (trac-13208) 9578 // Don't process clicks on disabled elements (trac-6911, trac-8165, trac-11382, trac-11764) 9579 if ( cur.nodeType === 1 && !( event.type === "click" && cur.disabled === true ) ) { 9580 matchedHandlers = []; 9581 matchedSelectors = {}; 9582 for ( i = 0; i < delegateCount; i++ ) { 9583 handleObj = handlers[ i ]; 9584 9585 // Don't conflict with Object.prototype properties (trac-13203) 9586 sel = handleObj.selector + " "; 9587 9588 if ( matchedSelectors[ sel ] === undefined ) { 9589 matchedSelectors[ sel ] = handleObj.needsContext ? 9590 jQuery( sel, this ).index( cur ) > -1 : 9591 jQuery.find( sel, this, null, [ cur ] ).length; 9592 } 9593 if ( matchedSelectors[ sel ] ) { 9594 matchedHandlers.push( handleObj ); 9595 } 9596 } 9597 if ( matchedHandlers.length ) { 9598 handlerQueue.push( { elem: cur, handlers: matchedHandlers } ); 9599 } 9600 } 9601 } 9602 } 9603 9604 // Add the remaining (directly-bound) handlers 9605 cur = this; 9606 if ( delegateCount < handlers.length ) { 9607 handlerQueue.push( { elem: cur, handlers: handlers.slice( delegateCount ) } ); 9608 } 9609 9610 return handlerQueue; 9611 }, 9612 9613 addProp: function( name, hook ) { 9614 Object.defineProperty( jQuery.Event.prototype, name, { 9615 enumerable: true, 9616 configurable: true, 9617 9618 get: isFunction( hook ) ? 9619 function() { 9620 if ( this.originalEvent ) { 9621 return hook( this.originalEvent ); 9622 } 9623 } : 9624 function() { 9625 if ( this.originalEvent ) { 9626 return this.originalEvent[ name ]; 9627 } 9628 }, 9629 9630 set: function( value ) { 9631 Object.defineProperty( this, name, { 9632 enumerable: true, 9633 configurable: true, 9634 writable: true, 9635 value: value 9636 } ); 9637 } 9638 } ); 9639 }, 9640 9641 fix: function( originalEvent ) { 9642 return originalEvent[ jQuery.expando ] ? 9643 originalEvent : 9644 new jQuery.Event( originalEvent ); 9645 }, 9646 9647 special: { 9648 load: { 9649 9650 // Prevent triggered image.load events from bubbling to window.load 9651 noBubble: true 9652 }, 9653 click: { 9654 9655 // Utilize native event to ensure correct state for checkable inputs 9656 setup: function( data ) { 9657 9658 // For mutual compressibility with _default, replace `this` access with a local var. 9659 // `|| data` is dead code meant only to preserve the variable through minification. 9660 var el = this || data; 9661 9662 // Claim the first handler 9663 if ( rcheckableType.test( el.type ) && 9664 el.click && nodeName( el, "input" ) ) { 9665 9666 // dataPriv.set( el, "click", ... ) 9667 leverageNative( el, "click", true ); 9668 } 9669 9670 // Return false to allow normal processing in the caller 9671 return false; 9672 }, 9673 trigger: function( data ) { 9674 9675 // For mutual compressibility with _default, replace `this` access with a local var. 9676 // `|| data` is dead code meant only to preserve the variable through minification. 9677 var el = this || data; 9678 9679 // Force setup before triggering a click 9680 if ( rcheckableType.test( el.type ) && 9681 el.click && nodeName( el, "input" ) ) { 9682 9683 leverageNative( el, "click" ); 9684 } 9685 9686 // Return non-false to allow normal event-path propagation 9687 return true; 9688 }, 9689 9690 // For cross-browser consistency, suppress native .click() on links 9691 // Also prevent it if we're currently inside a leveraged native-event stack 9692 _default: function( event ) { 9693 var target = event.target; 9694 return rcheckableType.test( target.type ) && 9695 target.click && nodeName( target, "input" ) && 9696 dataPriv.get( target, "click" ) || 9697 nodeName( target, "a" ); 9698 } 9699 }, 9700 9701 beforeunload: { 9702 postDispatch: function( event ) { 9703 9704 // Support: Firefox 20+ 9705 // Firefox doesn't alert if the returnValue field is not set. 9706 if ( event.result !== undefined && event.originalEvent ) { 9707 event.originalEvent.returnValue = event.result; 9708 } 9709 } 9710 } 9711 } 9712}; 9713 9714// Ensure the presence of an event listener that handles manually-triggered 9715// synthetic events by interrupting progress until reinvoked in response to 9716// *native* events that it fires directly, ensuring that state changes have 9717// already occurred before other listeners are invoked. 9718function leverageNative( el, type, isSetup ) { 9719 9720 // Missing `isSetup` indicates a trigger call, which must force setup through jQuery.event.add 9721 if ( !isSetup ) { 9722 if ( dataPriv.get( el, type ) === undefined ) { 9723 jQuery.event.add( el, type, returnTrue ); 9724 } 9725 return; 9726 } 9727 9728 // Register the controller as a special universal handler for all event namespaces 9729 dataPriv.set( el, type, false ); 9730 jQuery.event.add( el, type, { 9731 namespace: false, 9732 handler: function( event ) { 9733 var result, 9734 saved = dataPriv.get( this, type ); 9735 9736 if ( ( event.isTrigger & 1 ) && this[ type ] ) { 9737 9738 // Interrupt processing of the outer synthetic .trigger()ed event 9739 if ( !saved ) { 9740 9741 // Store arguments for use when handling the inner native event 9742 // There will always be at least one argument (an event object), so this array 9743 // will not be confused with a leftover capture object. 9744 saved = slice.call( arguments ); 9745 dataPriv.set( this, type, saved ); 9746 9747 // Trigger the native event and capture its result 9748 this[ type ](); 9749 result = dataPriv.get( this, type ); 9750 dataPriv.set( this, type, false ); 9751 9752 if ( saved !== result ) { 9753 9754 // Cancel the outer synthetic event 9755 event.stopImmediatePropagation(); 9756 event.preventDefault(); 9757 9758 return result; 9759 } 9760 9761 // If this is an inner synthetic event for an event with a bubbling surrogate 9762 // (focus or blur), assume that the surrogate already propagated from triggering 9763 // the native event and prevent that from happening again here. 9764 // This technically gets the ordering wrong w.r.t. to `.trigger()` (in which the 9765 // bubbling surrogate propagates *after* the non-bubbling base), but that seems 9766 // less bad than duplication. 9767 } else if ( ( jQuery.event.special[ type ] || {} ).delegateType ) { 9768 event.stopPropagation(); 9769 } 9770 9771 // If this is a native event triggered above, everything is now in order 9772 // Fire an inner synthetic event with the original arguments 9773 } else if ( saved ) { 9774 9775 // ...and capture the result 9776 dataPriv.set( this, type, jQuery.event.trigger( 9777 saved[ 0 ], 9778 saved.slice( 1 ), 9779 this 9780 ) ); 9781 9782 // Abort handling of the native event by all jQuery handlers while allowing 9783 // native handlers on the same element to run. On target, this is achieved 9784 // by stopping immediate propagation just on the jQuery event. However, 9785 // the native event is re-wrapped by a jQuery one on each level of the 9786 // propagation so the only way to stop it for jQuery is to stop it for 9787 // everyone via native `stopPropagation()`. This is not a problem for 9788 // focus/blur which don't bubble, but it does also stop click on checkboxes 9789 // and radios. We accept this limitation. 9790 event.stopPropagation(); 9791 event.isImmediatePropagationStopped = returnTrue; 9792 } 9793 } 9794 } ); 9795} 9796 9797jQuery.removeEvent = function( elem, type, handle ) { 9798 9799 // This "if" is needed for plain objects 9800 if ( elem.removeEventListener ) { 9801 elem.removeEventListener( type, handle ); 9802 } 9803}; 9804 9805jQuery.Event = function( src, props ) { 9806 9807 // Allow instantiation without the 'new' keyword 9808 if ( !( this instanceof jQuery.Event ) ) { 9809 return new jQuery.Event( src, props ); 9810 } 9811 9812 // Event object 9813 if ( src && src.type ) { 9814 this.originalEvent = src; 9815 this.type = src.type; 9816 9817 // Events bubbling up the document may have been marked as prevented 9818 // by a handler lower down the tree; reflect the correct value. 9819 this.isDefaultPrevented = src.defaultPrevented || 9820 src.defaultPrevented === undefined && 9821 9822 // Support: Android <=2.3 only 9823 src.returnValue === false ? 9824 returnTrue : 9825 returnFalse; 9826 9827 // Create target properties 9828 // Support: Safari <=6 - 7 only 9829 // Target should not be a text node (trac-504, trac-13143) 9830 this.target = ( src.target && src.target.nodeType === 3 ) ? 9831 src.target.parentNode : 9832 src.target; 9833 9834 this.currentTarget = src.currentTarget; 9835 this.relatedTarget = src.relatedTarget; 9836 9837 // Event type 9838 } else { 9839 this.type = src; 9840 } 9841 9842 // Put explicitly provided properties onto the event object 9843 if ( props ) { 9844 jQuery.extend( this, props ); 9845 } 9846 9847 // Create a timestamp if incoming event doesn't have one 9848 this.timeStamp = src && src.timeStamp || Date.now(); 9849 9850 // Mark it as fixed 9851 this[ jQuery.expando ] = true; 9852}; 9853 9854// jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding 9855// https://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html 9856jQuery.Event.prototype = { 9857 constructor: jQuery.Event, 9858 isDefaultPrevented: returnFalse, 9859 isPropagationStopped: returnFalse, 9860 isImmediatePropagationStopped: returnFalse, 9861 isSimulated: false, 9862 9863 preventDefault: function() { 9864 var e = this.originalEvent; 9865 9866 this.isDefaultPrevented = returnTrue; 9867 9868 if ( e && !this.isSimulated ) { 9869 e.preventDefault(); 9870 } 9871 }, 9872 stopPropagation: function() { 9873 var e = this.originalEvent; 9874 9875 this.isPropagationStopped = returnTrue; 9876 9877 if ( e && !this.isSimulated ) { 9878 e.stopPropagation(); 9879 } 9880 }, 9881 stopImmediatePropagation: function() { 9882 var e = this.originalEvent; 9883 9884 this.isImmediatePropagationStopped = returnTrue; 9885 9886 if ( e && !this.isSimulated ) { 9887 e.stopImmediatePropagation(); 9888 } 9889 9890 this.stopPropagation(); 9891 } 9892}; 9893 9894// Includes all common event props including KeyEvent and MouseEvent specific props 9895jQuery.each( { 9896 altKey: true, 9897 bubbles: true, 9898 cancelable: true, 9899 changedTouches: true, 9900 ctrlKey: true, 9901 detail: true, 9902 eventPhase: true, 9903 metaKey: true, 9904 pageX: true, 9905 pageY: true, 9906 shiftKey: true, 9907 view: true, 9908 "char": true, 9909 code: true, 9910 charCode: true, 9911 key: true, 9912 keyCode: true, 9913 button: true, 9914 buttons: true, 9915 clientX: true, 9916 clientY: true, 9917 offsetX: true, 9918 offsetY: true, 9919 pointerId: true, 9920 pointerType: true, 9921 screenX: true, 9922 screenY: true, 9923 targetTouches: true, 9924 toElement: true, 9925 touches: true, 9926 which: true 9927}, jQuery.event.addProp ); 9928 9929jQuery.each( { focus: "focusin", blur: "focusout" }, function( type, delegateType ) { 9930 9931 function focusMappedHandler( nativeEvent ) { 9932 if ( document.documentMode ) { 9933 9934 // Support: IE 11+ 9935 // Attach a single focusin/focusout handler on the document while someone wants 9936 // focus/blur. This is because the former are synchronous in IE while the latter 9937 // are async. In other browsers, all those handlers are invoked synchronously. 9938 9939 // `handle` from private data would already wrap the event, but we need 9940 // to change the `type` here. 9941 var handle = dataPriv.get( this, "handle" ), 9942 event = jQuery.event.fix( nativeEvent ); 9943 event.type = nativeEvent.type === "focusin" ? "focus" : "blur"; 9944 event.isSimulated = true; 9945 9946 // First, handle focusin/focusout 9947 handle( nativeEvent ); 9948 9949 // ...then, handle focus/blur 9950 // 9951 // focus/blur don't bubble while focusin/focusout do; simulate the former by only 9952 // invoking the handler at the lower level. 9953 if ( event.target === event.currentTarget ) { 9954 9955 // The setup part calls `leverageNative`, which, in turn, calls 9956 // `jQuery.event.add`, so event handle will already have been set 9957 // by this point. 9958 handle( event ); 9959 } 9960 } else { 9961 9962 // For non-IE browsers, attach a single capturing handler on the document 9963 // while someone wants focusin/focusout. 9964 jQuery.event.simulate( delegateType, nativeEvent.target, 9965 jQuery.event.fix( nativeEvent ) ); 9966 } 9967 } 9968 9969 jQuery.event.special[ type ] = { 9970 9971 // Utilize native event if possible so blur/focus sequence is correct 9972 setup: function() { 9973 9974 var attaches; 9975 9976 // Claim the first handler 9977 // dataPriv.set( this, "focus", ... ) 9978 // dataPriv.set( this, "blur", ... ) 9979 leverageNative( this, type, true ); 9980 9981 if ( document.documentMode ) { 9982 9983 // Support: IE 9 - 11+ 9984 // We use the same native handler for focusin & focus (and focusout & blur) 9985 // so we need to coordinate setup & teardown parts between those events. 9986 // Use `delegateType` as the key as `type` is already used by `leverageNative`. 9987 attaches = dataPriv.get( this, delegateType ); 9988 if ( !attaches ) { 9989 this.addEventListener( delegateType, focusMappedHandler ); 9990 } 9991 dataPriv.set( this, delegateType, ( attaches || 0 ) + 1 ); 9992 } else { 9993 9994 // Return false to allow normal processing in the caller 9995 return false; 9996 } 9997 }, 9998 trigger: function() { 9999 10000 // Force setup before trigger 10001 leverageNative( this, type ); 10002 10003 // Return non-false to allow normal event-path propagation 10004 return true; 10005 }, 10006 10007 teardown: function() { 10008 var attaches; 10009 10010 if ( document.documentMode ) { 10011 attaches = dataPriv.get( this, delegateType ) - 1; 10012 if ( !attaches ) { 10013 this.removeEventListener( delegateType, focusMappedHandler ); 10014 dataPriv.remove( this, delegateType ); 10015 } else { 10016 dataPriv.set( this, delegateType, attaches ); 10017 } 10018 } else { 10019 10020 // Return false to indicate standard teardown should be applied 10021 return false; 10022 } 10023 }, 10024 10025 // Suppress native focus or blur if we're currently inside 10026 // a leveraged native-event stack 10027 _default: function( event ) { 10028 return dataPriv.get( event.target, type ); 10029 }, 10030 10031 delegateType: delegateType 10032 }; 10033 10034 // Support: Firefox <=44 10035 // Firefox doesn't have focus(in | out) events 10036 // Related ticket - https://bugzilla.mozilla.org/show_bug.cgi?id=687787 10037 // 10038 // Support: Chrome <=48 - 49, Safari <=9.0 - 9.1 10039 // focus(in | out) events fire after focus & blur events, 10040 // which is spec violation - http://www.w3.org/TR/DOM-Level-3-Events/#events-focusevent-event-order 10041 // Related ticket - https://bugs.chromium.org/p/chromium/issues/detail?id=449857 10042 // 10043 // Support: IE 9 - 11+ 10044 // To preserve relative focusin/focus & focusout/blur event order guaranteed on the 3.x branch, 10045 // attach a single handler for both events in IE. 10046 jQuery.event.special[ delegateType ] = { 10047 setup: function() { 10048 10049 // Handle: regular nodes (via `this.ownerDocument`), window 10050 // (via `this.document`) & document (via `this`). 10051 var doc = this.ownerDocument || this.document || this, 10052 dataHolder = document.documentMode ? this : doc, 10053 attaches = dataPriv.get( dataHolder, delegateType ); 10054 10055 // Support: IE 9 - 11+ 10056 // We use the same native handler for focusin & focus (and focusout & blur) 10057 // so we need to coordinate setup & teardown parts between those events. 10058 // Use `delegateType` as the key as `type` is already used by `leverageNative`. 10059 if ( !attaches ) { 10060 if ( document.documentMode ) { 10061 this.addEventListener( delegateType, focusMappedHandler ); 10062 } else { 10063 doc.addEventListener( type, focusMappedHandler, true ); 10064 } 10065 } 10066 dataPriv.set( dataHolder, delegateType, ( attaches || 0 ) + 1 ); 10067 }, 10068 teardown: function() { 10069 var doc = this.ownerDocument || this.document || this, 10070 dataHolder = document.documentMode ? this : doc, 10071 attaches = dataPriv.get( dataHolder, delegateType ) - 1; 10072 10073 if ( !attaches ) { 10074 if ( document.documentMode ) { 10075 this.removeEventListener( delegateType, focusMappedHandler ); 10076 } else { 10077 doc.removeEventListener( type, focusMappedHandler, true ); 10078 } 10079 dataPriv.remove( dataHolder, delegateType ); 10080 } else { 10081 dataPriv.set( dataHolder, delegateType, attaches ); 10082 } 10083 } 10084 }; 10085} ); 10086 10087// Create mouseenter/leave events using mouseover/out and event-time checks 10088// so that event delegation works in jQuery. 10089// Do the same for pointerenter/pointerleave and pointerover/pointerout 10090// 10091// Support: Safari 7 only 10092// Safari sends mouseenter too often; see: 10093// https://bugs.chromium.org/p/chromium/issues/detail?id=470258 10094// for the description of the bug (it existed in older Chrome versions as well). 10095jQuery.each( { 10096 mouseenter: "mouseover", 10097 mouseleave: "mouseout", 10098 pointerenter: "pointerover", 10099 pointerleave: "pointerout" 10100}, function( orig, fix ) { 10101 jQuery.event.special[ orig ] = { 10102 delegateType: fix, 10103 bindType: fix, 10104 10105 handle: function( event ) { 10106 var ret, 10107 target = this, 10108 related = event.relatedTarget, 10109 handleObj = event.handleObj; 10110 10111 // For mouseenter/leave call the handler if related is outside the target. 10112 // NB: No relatedTarget if the mouse left/entered the browser window 10113 if ( !related || ( related !== target && !jQuery.contains( target, related ) ) ) { 10114 event.type = handleObj.origType; 10115 ret = handleObj.handler.apply( this, arguments ); 10116 event.type = fix; 10117 } 10118 return ret; 10119 } 10120 }; 10121} ); 10122 10123jQuery.fn.extend( { 10124 10125 on: function( types, selector, data, fn ) { 10126 return on( this, types, selector, data, fn ); 10127 }, 10128 one: function( types, selector, data, fn ) { 10129 return on( this, types, selector, data, fn, 1 ); 10130 }, 10131 off: function( types, selector, fn ) { 10132 var handleObj, type; 10133 if ( types && types.preventDefault && types.handleObj ) { 10134 10135 // ( event ) dispatched jQuery.Event 10136 handleObj = types.handleObj; 10137 jQuery( types.delegateTarget ).off( 10138 handleObj.namespace ? 10139 handleObj.origType + "." + handleObj.namespace : 10140 handleObj.origType, 10141 handleObj.selector, 10142 handleObj.handler 10143 ); 10144 return this; 10145 } 10146 if ( typeof types === "object" ) { 10147 10148 // ( types-object [, selector] ) 10149 for ( type in types ) { 10150 this.off( type, selector, types[ type ] ); 10151 } 10152 return this; 10153 } 10154 if ( selector === false || typeof selector === "function" ) { 10155 10156 // ( types [, fn] ) 10157 fn = selector; 10158 selector = undefined; 10159 } 10160 if ( fn === false ) { 10161 fn = returnFalse; 10162 } 10163 return this.each( function() { 10164 jQuery.event.remove( this, types, fn, selector ); 10165 } ); 10166 } 10167} ); 10168 10169 10170var 10171 10172 // Support: IE <=10 - 11, Edge 12 - 13 only 10173 // In IE/Edge using regex groups here causes severe slowdowns. 10174 // See https://connect.microsoft.com/IE/feedback/details/1736512/ 10175 rnoInnerhtml = /<script|<style|<link/i, 10176 10177 // checked="checked" or checked 10178 rchecked = /checked\s*(?:[^=]|=\s*.checked.)/i, 10179 10180 rcleanScript = /^\s*<!\[CDATA\[|\]\]>\s*$/g; 10181 10182// Prefer a tbody over its parent table for containing new rows 10183function manipulationTarget( elem, content ) { 10184 if ( nodeName( elem, "table" ) && 10185 nodeName( content.nodeType !== 11 ? content : content.firstChild, "tr" ) ) { 10186 10187 return jQuery( elem ).children( "tbody" )[ 0 ] || elem; 10188 } 10189 10190 return elem; 10191} 10192 10193// Replace/restore the type attribute of script elements for safe DOM manipulation 10194function disableScript( elem ) { 10195 elem.type = ( elem.getAttribute( "type" ) !== null ) + "/" + elem.type; 10196 return elem; 10197} 10198function restoreScript( elem ) { 10199 if ( ( elem.type || "" ).slice( 0, 5 ) === "true/" ) { 10200 elem.type = elem.type.slice( 5 ); 10201 } else { 10202 elem.removeAttribute( "type" ); 10203 } 10204 10205 return elem; 10206} 10207 10208function cloneCopyEvent( src, dest ) { 10209 var i, l, type, pdataOld, udataOld, udataCur, events; 10210 10211 if ( dest.nodeType !== 1 ) { 10212 return; 10213 } 10214 10215 // 1. Copy private data: events, handlers, etc. 10216 if ( dataPriv.hasData( src ) ) { 10217 pdataOld = dataPriv.get( src ); 10218 events = pdataOld.events; 10219 10220 if ( events ) { 10221 dataPriv.remove( dest, "handle events" ); 10222 10223 for ( type in events ) { 10224 for ( i = 0, l = events[ type ].length; i < l; i++ ) { 10225 jQuery.event.add( dest, type, events[ type ][ i ] ); 10226 } 10227 } 10228 } 10229 } 10230 10231 // 2. Copy user data 10232 if ( dataUser.hasData( src ) ) { 10233 udataOld = dataUser.access( src ); 10234 udataCur = jQuery.extend( {}, udataOld ); 10235 10236 dataUser.set( dest, udataCur ); 10237 } 10238} 10239 10240// Fix IE bugs, see support tests 10241function fixInput( src, dest ) { 10242 var nodeName = dest.nodeName.toLowerCase(); 10243 10244 // Fails to persist the checked state of a cloned checkbox or radio button. 10245 if ( nodeName === "input" && rcheckableType.test( src.type ) ) { 10246 dest.checked = src.checked; 10247 10248 // Fails to return the selected option to the default selected state when cloning options 10249 } else if ( nodeName === "input" || nodeName === "textarea" ) { 10250 dest.defaultValue = src.defaultValue; 10251 } 10252} 10253 10254function domManip( collection, args, callback, ignored ) { 10255 10256 // Flatten any nested arrays 10257 args = flat( args ); 10258 10259 var fragment, first, scripts, hasScripts, node, doc, 10260 i = 0, 10261 l = collection.length, 10262 iNoClone = l - 1, 10263 value = args[ 0 ], 10264 valueIsFunction = isFunction( value ); 10265 10266 // We can't cloneNode fragments that contain checked, in WebKit 10267 if ( valueIsFunction || 10268 ( l > 1 && typeof value === "string" && 10269 !support.checkClone && rchecked.test( value ) ) ) { 10270 return collection.each( function( index ) { 10271 var self = collection.eq( index ); 10272 if ( valueIsFunction ) { 10273 args[ 0 ] = value.call( this, index, self.html() ); 10274 } 10275 domManip( self, args, callback, ignored ); 10276 } ); 10277 } 10278 10279 if ( l ) { 10280 fragment = buildFragment( args, collection[ 0 ].ownerDocument, false, collection, ignored ); 10281 first = fragment.firstChild; 10282 10283 if ( fragment.childNodes.length === 1 ) { 10284 fragment = first; 10285 } 10286 10287 // Require either new content or an interest in ignored elements to invoke the callback 10288 if ( first || ignored ) { 10289 scripts = jQuery.map( getAll( fragment, "script" ), disableScript ); 10290 hasScripts = scripts.length; 10291 10292 // Use the original fragment for the last item 10293 // instead of the first because it can end up 10294 // being emptied incorrectly in certain situations (trac-8070). 10295 for ( ; i < l; i++ ) { 10296 node = fragment; 10297 10298 if ( i !== iNoClone ) { 10299 node = jQuery.clone( node, true, true ); 10300 10301 // Keep references to cloned scripts for later restoration 10302 if ( hasScripts ) { 10303 10304 // Support: Android <=4.0 only, PhantomJS 1 only 10305 // push.apply(_, arraylike) throws on ancient WebKit 10306 jQuery.merge( scripts, getAll( node, "script" ) ); 10307 } 10308 } 10309 10310 callback.call( collection[ i ], node, i ); 10311 } 10312 10313 if ( hasScripts ) { 10314 doc = scripts[ scripts.length - 1 ].ownerDocument; 10315 10316 // Re-enable scripts 10317 jQuery.map( scripts, restoreScript ); 10318 10319 // Evaluate executable scripts on first document insertion 10320 for ( i = 0; i < hasScripts; i++ ) { 10321 node = scripts[ i ]; 10322 if ( rscriptType.test( node.type || "" ) && 10323 !dataPriv.access( node, "globalEval" ) && 10324 jQuery.contains( doc, node ) ) { 10325 10326 if ( node.src && ( node.type || "" ).toLowerCase() !== "module" ) { 10327 10328 // Optional AJAX dependency, but won't run scripts if not present 10329 if ( jQuery._evalUrl && !node.noModule ) { 10330 jQuery._evalUrl( node.src, { 10331 nonce: node.nonce || node.getAttribute( "nonce" ) 10332 }, doc ); 10333 } 10334 } else { 10335 10336 // Unwrap a CDATA section containing script contents. This shouldn't be 10337 // needed as in XML documents they're already not visible when 10338 // inspecting element contents and in HTML documents they have no 10339 // meaning but we're preserving that logic for backwards compatibility. 10340 // This will be removed completely in 4.0. See gh-4904. 10341 DOMEval( node.textContent.replace( rcleanScript, "" ), node, doc ); 10342 } 10343 } 10344 } 10345 } 10346 } 10347 } 10348 10349 return collection; 10350} 10351 10352function remove( elem, selector, keepData ) { 10353 var node, 10354 nodes = selector ? jQuery.filter( selector, elem ) : elem, 10355 i = 0; 10356 10357 for ( ; ( node = nodes[ i ] ) != null; i++ ) { 10358 if ( !keepData && node.nodeType === 1 ) { 10359 jQuery.cleanData( getAll( node ) ); 10360 } 10361 10362 if ( node.parentNode ) { 10363 if ( keepData && isAttached( node ) ) { 10364 setGlobalEval( getAll( node, "script" ) ); 10365 } 10366 node.parentNode.removeChild( node ); 10367 } 10368 } 10369 10370 return elem; 10371} 10372 10373jQuery.extend( { 10374 htmlPrefilter: function( html ) { 10375 return html; 10376 }, 10377 10378 clone: function( elem, dataAndEvents, deepDataAndEvents ) { 10379 var i, l, srcElements, destElements, 10380 clone = elem.cloneNode( true ), 10381 inPage = isAttached( elem ); 10382 10383 // Fix IE cloning issues 10384 if ( !support.noCloneChecked && ( elem.nodeType === 1 || elem.nodeType === 11 ) && 10385 !jQuery.isXMLDoc( elem ) ) { 10386 10387 // We eschew jQuery#find here for performance reasons: 10388 // https://jsperf.com/getall-vs-sizzle/2 10389 destElements = getAll( clone ); 10390 srcElements = getAll( elem ); 10391 10392 for ( i = 0, l = srcElements.length; i < l; i++ ) { 10393 fixInput( srcElements[ i ], destElements[ i ] ); 10394 } 10395 } 10396 10397 // Copy the events from the original to the clone 10398 if ( dataAndEvents ) { 10399 if ( deepDataAndEvents ) { 10400 srcElements = srcElements || getAll( elem ); 10401 destElements = destElements || getAll( clone ); 10402 10403 for ( i = 0, l = srcElements.length; i < l; i++ ) { 10404 cloneCopyEvent( srcElements[ i ], destElements[ i ] ); 10405 } 10406 } else { 10407 cloneCopyEvent( elem, clone ); 10408 } 10409 } 10410 10411 // Preserve script evaluation history 10412 destElements = getAll( clone, "script" ); 10413 if ( destElements.length > 0 ) { 10414 setGlobalEval( destElements, !inPage && getAll( elem, "script" ) ); 10415 } 10416 10417 // Return the cloned set 10418 return clone; 10419 }, 10420 10421 cleanData: function( elems ) { 10422 var data, elem, type, 10423 special = jQuery.event.special, 10424 i = 0; 10425 10426 for ( ; ( elem = elems[ i ] ) !== undefined; i++ ) { 10427 if ( acceptData( elem ) ) { 10428 if ( ( data = elem[ dataPriv.expando ] ) ) { 10429 if ( data.events ) { 10430 for ( type in data.events ) { 10431 if ( special[ type ] ) { 10432 jQuery.event.remove( elem, type ); 10433 10434 // This is a shortcut to avoid jQuery.event.remove's overhead 10435 } else { 10436 jQuery.removeEvent( elem, type, data.handle ); 10437 } 10438 } 10439 } 10440 10441 // Support: Chrome <=35 - 45+ 10442 // Assign undefined instead of using delete, see Data#remove 10443 elem[ dataPriv.expando ] = undefined; 10444 } 10445 if ( elem[ dataUser.expando ] ) { 10446 10447 // Support: Chrome <=35 - 45+ 10448 // Assign undefined instead of using delete, see Data#remove 10449 elem[ dataUser.expando ] = undefined; 10450 } 10451 } 10452 } 10453 } 10454} ); 10455 10456jQuery.fn.extend( { 10457 detach: function( selector ) { 10458 return remove( this, selector, true ); 10459 }, 10460 10461 remove: function( selector ) { 10462 return remove( this, selector ); 10463 }, 10464 10465 text: function( value ) { 10466 return access( this, function( value ) { 10467 return value === undefined ? 10468 jQuery.text( this ) : 10469 this.empty().each( function() { 10470 if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) { 10471 this.textContent = value; 10472 } 10473 } ); 10474 }, null, value, arguments.length ); 10475 }, 10476 10477 append: function() { 10478 return domManip( this, arguments, function( elem ) { 10479 if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) { 10480 var target = manipulationTarget( this, elem ); 10481 target.appendChild( elem ); 10482 } 10483 } ); 10484 }, 10485 10486 prepend: function() { 10487 return domManip( this, arguments, function( elem ) { 10488 if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) { 10489 var target = manipulationTarget( this, elem ); 10490 target.insertBefore( elem, target.firstChild ); 10491 } 10492 } ); 10493 }, 10494 10495 before: function() { 10496 return domManip( this, arguments, function( elem ) { 10497 if ( this.parentNode ) { 10498 this.parentNode.insertBefore( elem, this ); 10499 } 10500 } ); 10501 }, 10502 10503 after: function() { 10504 return domManip( this, arguments, function( elem ) { 10505 if ( this.parentNode ) { 10506 this.parentNode.insertBefore( elem, this.nextSibling ); 10507 } 10508 } ); 10509 }, 10510 10511 empty: function() { 10512 var elem, 10513 i = 0; 10514 10515 for ( ; ( elem = this[ i ] ) != null; i++ ) { 10516 if ( elem.nodeType === 1 ) { 10517 10518 // Prevent memory leaks 10519 jQuery.cleanData( getAll( elem, false ) ); 10520 10521 // Remove any remaining nodes 10522 elem.textContent = ""; 10523 } 10524 } 10525 10526 return this; 10527 }, 10528 10529 clone: function( dataAndEvents, deepDataAndEvents ) { 10530 dataAndEvents = dataAndEvents == null ? false : dataAndEvents; 10531 deepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents; 10532 10533 return this.map( function() { 10534 return jQuery.clone( this, dataAndEvents, deepDataAndEvents ); 10535 } ); 10536 }, 10537 10538 html: function( value ) { 10539 return access( this, function( value ) { 10540 var elem = this[ 0 ] || {}, 10541 i = 0, 10542 l = this.length; 10543 10544 if ( value === undefined && elem.nodeType === 1 ) { 10545 return elem.innerHTML; 10546 } 10547 10548 // See if we can take a shortcut and just use innerHTML 10549 if ( typeof value === "string" && !rnoInnerhtml.test( value ) && 10550 !wrapMap[ ( rtagName.exec( value ) || [ "", "" ] )[ 1 ].toLowerCase() ] ) { 10551 10552 value = jQuery.htmlPrefilter( value ); 10553 10554 try { 10555 for ( ; i < l; i++ ) { 10556 elem = this[ i ] || {}; 10557 10558 // Remove element nodes and prevent memory leaks 10559 if ( elem.nodeType === 1 ) { 10560 jQuery.cleanData( getAll( elem, false ) ); 10561 elem.innerHTML = value; 10562 } 10563 } 10564 10565 elem = 0; 10566 10567 // If using innerHTML throws an exception, use the fallback method 10568 } catch ( e ) {} 10569 } 10570 10571 if ( elem ) { 10572 this.empty().append( value ); 10573 } 10574 }, null, value, arguments.length ); 10575 }, 10576 10577 replaceWith: function() { 10578 var ignored = []; 10579 10580 // Make the changes, replacing each non-ignored context element with the new content 10581 return domManip( this, arguments, function( elem ) { 10582 var parent = this.parentNode; 10583 10584 if ( jQuery.inArray( this, ignored ) < 0 ) { 10585 jQuery.cleanData( getAll( this ) ); 10586 if ( parent ) { 10587 parent.replaceChild( elem, this ); 10588 } 10589 } 10590 10591 // Force callback invocation 10592 }, ignored ); 10593 } 10594} ); 10595 10596jQuery.each( { 10597 appendTo: "append", 10598 prependTo: "prepend", 10599 insertBefore: "before", 10600 insertAfter: "after", 10601 replaceAll: "replaceWith" 10602}, function( name, original ) { 10603 jQuery.fn[ name ] = function( selector ) { 10604 var elems, 10605 ret = [], 10606 insert = jQuery( selector ), 10607 last = insert.length - 1, 10608 i = 0; 10609 10610 for ( ; i <= last; i++ ) { 10611 elems = i === last ? this : this.clone( true ); 10612 jQuery( insert[ i ] )[ original ]( elems ); 10613 10614 // Support: Android <=4.0 only, PhantomJS 1 only 10615 // .get() because push.apply(_, arraylike) throws on ancient WebKit 10616 push.apply( ret, elems.get() ); 10617 } 10618 10619 return this.pushStack( ret ); 10620 }; 10621} ); 10622var rnumnonpx = new RegExp( "^(" + pnum + ")(?!px)[a-z%]+$", "i" ); 10623 10624var rcustomProp = /^--/; 10625 10626 10627var getStyles = function( elem ) { 10628 10629 // Support: IE <=11 only, Firefox <=30 (trac-15098, trac-14150) 10630 // IE throws on elements created in popups 10631 // FF meanwhile throws on frame elements through "defaultView.getComputedStyle" 10632 var view = elem.ownerDocument.defaultView; 10633 10634 if ( !view || !view.opener ) { 10635 view = window; 10636 } 10637 10638 return view.getComputedStyle( elem ); 10639 }; 10640 10641var swap = function( elem, options, callback ) { 10642 var ret, name, 10643 old = {}; 10644 10645 // Remember the old values, and insert the new ones 10646 for ( name in options ) { 10647 old[ name ] = elem.style[ name ]; 10648 elem.style[ name ] = options[ name ]; 10649 } 10650 10651 ret = callback.call( elem ); 10652 10653 // Revert the old values 10654 for ( name in options ) { 10655 elem.style[ name ] = old[ name ]; 10656 } 10657 10658 return ret; 10659}; 10660 10661 10662var rboxStyle = new RegExp( cssExpand.join( "|" ), "i" ); 10663 10664 10665 10666( function() { 10667 10668 // Executing both pixelPosition & boxSizingReliable tests require only one layout 10669 // so they're executed at the same time to save the second computation. 10670 function computeStyleTests() { 10671 10672 // This is a singleton, we need to execute it only once 10673 if ( !div ) { 10674 return; 10675 } 10676 10677 container.style.cssText = "position:absolute;left:-11111px;width:60px;" + 10678 "margin-top:1px;padding:0;border:0"; 10679 div.style.cssText = 10680 "position:relative;display:block;box-sizing:border-box;overflow:scroll;" + 10681 "margin:auto;border:1px;padding:1px;" + 10682 "width:60%;top:1%"; 10683 documentElement.appendChild( container ).appendChild( div ); 10684 10685 var divStyle = window.getComputedStyle( div ); 10686 pixelPositionVal = divStyle.top !== "1%"; 10687 10688 // Support: Android 4.0 - 4.3 only, Firefox <=3 - 44 10689 reliableMarginLeftVal = roundPixelMeasures( divStyle.marginLeft ) === 12; 10690 10691 // Support: Android 4.0 - 4.3 only, Safari <=9.1 - 10.1, iOS <=7.0 - 9.3 10692 // Some styles come back with percentage values, even though they shouldn't 10693 div.style.right = "60%"; 10694 pixelBoxStylesVal = roundPixelMeasures( divStyle.right ) === 36; 10695 10696 // Support: IE 9 - 11 only 10697 // Detect misreporting of content dimensions for box-sizing:border-box elements 10698 boxSizingReliableVal = roundPixelMeasures( divStyle.width ) === 36; 10699 10700 // Support: IE 9 only 10701 // Detect overflow:scroll screwiness (gh-3699) 10702 // Support: Chrome <=64 10703 // Don't get tricked when zoom affects offsetWidth (gh-4029) 10704 div.style.position = "absolute"; 10705 scrollboxSizeVal = roundPixelMeasures( div.offsetWidth / 3 ) === 12; 10706 10707 documentElement.removeChild( container ); 10708 10709 // Nullify the div so it wouldn't be stored in the memory and 10710 // it will also be a sign that checks already performed 10711 div = null; 10712 } 10713 10714 function roundPixelMeasures( measure ) { 10715 return Math.round( parseFloat( measure ) ); 10716 } 10717 10718 var pixelPositionVal, boxSizingReliableVal, scrollboxSizeVal, pixelBoxStylesVal, 10719 reliableTrDimensionsVal, reliableMarginLeftVal, 10720 container = document.createElement( "div" ), 10721 div = document.createElement( "div" ); 10722 10723 // Finish early in limited (non-browser) environments 10724 if ( !div.style ) { 10725 return; 10726 } 10727 10728 // Support: IE <=9 - 11 only 10729 // Style of cloned element affects source element cloned (trac-8908) 10730 div.style.backgroundClip = "content-box"; 10731 div.cloneNode( true ).style.backgroundClip = ""; 10732 support.clearCloneStyle = div.style.backgroundClip === "content-box"; 10733 10734 jQuery.extend( support, { 10735 boxSizingReliable: function() { 10736 computeStyleTests(); 10737 return boxSizingReliableVal; 10738 }, 10739 pixelBoxStyles: function() { 10740 computeStyleTests(); 10741 return pixelBoxStylesVal; 10742 }, 10743 pixelPosition: function() { 10744 computeStyleTests(); 10745 return pixelPositionVal; 10746 }, 10747 reliableMarginLeft: function() { 10748 computeStyleTests(); 10749 return reliableMarginLeftVal; 10750 }, 10751 scrollboxSize: function() { 10752 computeStyleTests(); 10753 return scrollboxSizeVal; 10754 }, 10755 10756 // Support: IE 9 - 11+, Edge 15 - 18+ 10757 // IE/Edge misreport `getComputedStyle` of table rows with width/height 10758 // set in CSS while `offset*` properties report correct values. 10759 // Behavior in IE 9 is more subtle than in newer versions & it passes 10760 // some versions of this test; make sure not to make it pass there! 10761 // 10762 // Support: Firefox 70+ 10763 // Only Firefox includes border widths 10764 // in computed dimensions. (gh-4529) 10765 reliableTrDimensions: function() { 10766 var table, tr, trChild, trStyle; 10767 if ( reliableTrDimensionsVal == null ) { 10768 table = document.createElement( "table" ); 10769 tr = document.createElement( "tr" ); 10770 trChild = document.createElement( "div" ); 10771 10772 table.style.cssText = "position:absolute;left:-11111px;border-collapse:separate"; 10773 tr.style.cssText = "box-sizing:content-box;border:1px solid"; 10774 10775 // Support: Chrome 86+ 10776 // Height set through cssText does not get applied. 10777 // Computed height then comes back as 0. 10778 tr.style.height = "1px"; 10779 trChild.style.height = "9px"; 10780 10781 // Support: Android 8 Chrome 86+ 10782 // In our bodyBackground.html iframe, 10783 // display for all div elements is set to "inline", 10784 // which causes a problem only in Android 8 Chrome 86. 10785 // Ensuring the div is `display: block` 10786 // gets around this issue. 10787 trChild.style.display = "block"; 10788 10789 documentElement 10790 .appendChild( table ) 10791 .appendChild( tr ) 10792 .appendChild( trChild ); 10793 10794 trStyle = window.getComputedStyle( tr ); 10795 reliableTrDimensionsVal = ( parseInt( trStyle.height, 10 ) + 10796 parseInt( trStyle.borderTopWidth, 10 ) + 10797 parseInt( trStyle.borderBottomWidth, 10 ) ) === tr.offsetHeight; 10798 10799 documentElement.removeChild( table ); 10800 } 10801 return reliableTrDimensionsVal; 10802 } 10803 } ); 10804} )(); 10805 10806 10807function curCSS( elem, name, computed ) { 10808 var width, minWidth, maxWidth, ret, 10809 isCustomProp = rcustomProp.test( name ), 10810 10811 // Support: Firefox 51+ 10812 // Retrieving style before computed somehow 10813 // fixes an issue with getting wrong values 10814 // on detached elements 10815 style = elem.style; 10816 10817 computed = computed || getStyles( elem ); 10818 10819 // getPropertyValue is needed for: 10820 // .css('filter') (IE 9 only, trac-12537) 10821 // .css('--customProperty) (gh-3144) 10822 if ( computed ) { 10823 10824 // Support: IE <=9 - 11+ 10825 // IE only supports `"float"` in `getPropertyValue`; in computed styles 10826 // it's only available as `"cssFloat"`. We no longer modify properties 10827 // sent to `.css()` apart from camelCasing, so we need to check both. 10828 // Normally, this would create difference in behavior: if 10829 // `getPropertyValue` returns an empty string, the value returned 10830 // by `.css()` would be `undefined`. This is usually the case for 10831 // disconnected elements. However, in IE even disconnected elements 10832 // with no styles return `"none"` for `getPropertyValue( "float" )` 10833 ret = computed.getPropertyValue( name ) || computed[ name ]; 10834 10835 if ( isCustomProp && ret ) { 10836 10837 // Support: Firefox 105+, Chrome <=105+ 10838 // Spec requires trimming whitespace for custom properties (gh-4926). 10839 // Firefox only trims leading whitespace. Chrome just collapses 10840 // both leading & trailing whitespace to a single space. 10841 // 10842 // Fall back to `undefined` if empty string returned. 10843 // This collapses a missing definition with property defined 10844 // and set to an empty string but there's no standard API 10845 // allowing us to differentiate them without a performance penalty 10846 // and returning `undefined` aligns with older jQuery. 10847 // 10848 // rtrimCSS treats U+000D CARRIAGE RETURN and U+000C FORM FEED 10849 // as whitespace while CSS does not, but this is not a problem 10850 // because CSS preprocessing replaces them with U+000A LINE FEED 10851 // (which *is* CSS whitespace) 10852 // https://www.w3.org/TR/css-syntax-3/#input-preprocessing 10853 ret = ret.replace( rtrimCSS, "$1" ) || undefined; 10854 } 10855 10856 if ( ret === "" && !isAttached( elem ) ) { 10857 ret = jQuery.style( elem, name ); 10858 } 10859 10860 // A tribute to the "awesome hack by Dean Edwards" 10861 // Android Browser returns percentage for some values, 10862 // but width seems to be reliably pixels. 10863 // This is against the CSSOM draft spec: 10864 // https://drafts.csswg.org/cssom/#resolved-values 10865 if ( !support.pixelBoxStyles() && rnumnonpx.test( ret ) && rboxStyle.test( name ) ) { 10866 10867 // Remember the original values 10868 width = style.width; 10869 minWidth = style.minWidth; 10870 maxWidth = style.maxWidth; 10871 10872 // Put in the new values to get a computed value out 10873 style.minWidth = style.maxWidth = style.width = ret; 10874 ret = computed.width; 10875 10876 // Revert the changed values 10877 style.width = width; 10878 style.minWidth = minWidth; 10879 style.maxWidth = maxWidth; 10880 } 10881 } 10882 10883 return ret !== undefined ? 10884 10885 // Support: IE <=9 - 11 only 10886 // IE returns zIndex value as an integer. 10887 ret + "" : 10888 ret; 10889} 10890 10891 10892function addGetHookIf( conditionFn, hookFn ) { 10893 10894 // Define the hook, we'll check on the first run if it's really needed. 10895 return { 10896 get: function() { 10897 if ( conditionFn() ) { 10898 10899 // Hook not needed (or it's not possible to use it due 10900 // to missing dependency), remove it. 10901 delete this.get; 10902 return; 10903 } 10904 10905 // Hook needed; redefine it so that the support test is not executed again. 10906 return ( this.get = hookFn ).apply( this, arguments ); 10907 } 10908 }; 10909} 10910 10911 10912var cssPrefixes = [ "Webkit", "Moz", "ms" ], 10913 emptyStyle = document.createElement( "div" ).style, 10914 vendorProps = {}; 10915 10916// Return a vendor-prefixed property or undefined 10917function vendorPropName( name ) { 10918 10919 // Check for vendor prefixed names 10920 var capName = name[ 0 ].toUpperCase() + name.slice( 1 ), 10921 i = cssPrefixes.length; 10922 10923 while ( i-- ) { 10924 name = cssPrefixes[ i ] + capName; 10925 if ( name in emptyStyle ) { 10926 return name; 10927 } 10928 } 10929} 10930 10931// Return a potentially-mapped jQuery.cssProps or vendor prefixed property 10932function finalPropName( name ) { 10933 var final = jQuery.cssProps[ name ] || vendorProps[ name ]; 10934 10935 if ( final ) { 10936 return final; 10937 } 10938 if ( name in emptyStyle ) { 10939 return name; 10940 } 10941 return vendorProps[ name ] = vendorPropName( name ) || name; 10942} 10943 10944 10945var 10946 10947 // Swappable if display is none or starts with table 10948 // except "table", "table-cell", or "table-caption" 10949 // See here for display values: https://developer.mozilla.org/en-US/docs/CSS/display 10950 rdisplayswap = /^(none|table(?!-c[ea]).+)/, 10951 cssShow = { position: "absolute", visibility: "hidden", display: "block" }, 10952 cssNormalTransform = { 10953 letterSpacing: "0", 10954 fontWeight: "400" 10955 }; 10956 10957function setPositiveNumber( _elem, value, subtract ) { 10958 10959 // Any relative (+/-) values have already been 10960 // normalized at this point 10961 var matches = rcssNum.exec( value ); 10962 return matches ? 10963 10964 // Guard against undefined "subtract", e.g., when used as in cssHooks 10965 Math.max( 0, matches[ 2 ] - ( subtract || 0 ) ) + ( matches[ 3 ] || "px" ) : 10966 value; 10967} 10968 10969function boxModelAdjustment( elem, dimension, box, isBorderBox, styles, computedVal ) { 10970 var i = dimension === "width" ? 1 : 0, 10971 extra = 0, 10972 delta = 0, 10973 marginDelta = 0; 10974 10975 // Adjustment may not be necessary 10976 if ( box === ( isBorderBox ? "border" : "content" ) ) { 10977 return 0; 10978 } 10979 10980 for ( ; i < 4; i += 2 ) { 10981 10982 // Both box models exclude margin 10983 // Count margin delta separately to only add it after scroll gutter adjustment. 10984 // This is needed to make negative margins work with `outerHeight( true )` (gh-3982). 10985 if ( box === "margin" ) { 10986 marginDelta += jQuery.css( elem, box + cssExpand[ i ], true, styles ); 10987 } 10988 10989 // If we get here with a content-box, we're seeking "padding" or "border" or "margin" 10990 if ( !isBorderBox ) { 10991 10992 // Add padding 10993 delta += jQuery.css( elem, "padding" + cssExpand[ i ], true, styles ); 10994 10995 // For "border" or "margin", add border 10996 if ( box !== "padding" ) { 10997 delta += jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles ); 10998 10999 // But still keep track of it otherwise 11000 } else { 11001 extra += jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles ); 11002 } 11003 11004 // If we get here with a border-box (content + padding + border), we're seeking "content" or 11005 // "padding" or "margin" 11006 } else { 11007 11008 // For "content", subtract padding 11009 if ( box === "content" ) { 11010 delta -= jQuery.css( elem, "padding" + cssExpand[ i ], true, styles ); 11011 } 11012 11013 // For "content" or "padding", subtract border 11014 if ( box !== "margin" ) { 11015 delta -= jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles ); 11016 } 11017 } 11018 } 11019 11020 // Account for positive content-box scroll gutter when requested by providing computedVal 11021 if ( !isBorderBox && computedVal >= 0 ) { 11022 11023 // offsetWidth/offsetHeight is a rounded sum of content, padding, scroll gutter, and border 11024 // Assuming integer scroll gutter, subtract the rest and round down 11025 delta += Math.max( 0, Math.ceil( 11026 elem[ "offset" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 ) ] - 11027 computedVal - 11028 delta - 11029 extra - 11030 0.5 11031 11032 // If offsetWidth/offsetHeight is unknown, then we can't determine content-box scroll gutter 11033 // Use an explicit zero to avoid NaN (gh-3964) 11034 ) ) || 0; 11035 } 11036 11037 return delta + marginDelta; 11038} 11039 11040function getWidthOrHeight( elem, dimension, extra ) { 11041 11042 // Start with computed style 11043 var styles = getStyles( elem ), 11044 11045 // To avoid forcing a reflow, only fetch boxSizing if we need it (gh-4322). 11046 // Fake content-box until we know it's needed to know the true value. 11047 boxSizingNeeded = !support.boxSizingReliable() || extra, 11048 isBorderBox = boxSizingNeeded && 11049 jQuery.css( elem, "boxSizing", false, styles ) === "border-box", 11050 valueIsBorderBox = isBorderBox, 11051 11052 val = curCSS( elem, dimension, styles ), 11053 offsetProp = "offset" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 ); 11054 11055 // Support: Firefox <=54 11056 // Return a confounding non-pixel value or feign ignorance, as appropriate. 11057 if ( rnumnonpx.test( val ) ) { 11058 if ( !extra ) { 11059 return val; 11060 } 11061 val = "auto"; 11062 } 11063 11064 11065 // Support: IE 9 - 11 only 11066 // Use offsetWidth/offsetHeight for when box sizing is unreliable. 11067 // In those cases, the computed value can be trusted to be border-box. 11068 if ( ( !support.boxSizingReliable() && isBorderBox || 11069 11070 // Support: IE 10 - 11+, Edge 15 - 18+ 11071 // IE/Edge misreport `getComputedStyle` of table rows with width/height 11072 // set in CSS while `offset*` properties report correct values. 11073 // Interestingly, in some cases IE 9 doesn't suffer from this issue. 11074 !support.reliableTrDimensions() && nodeName( elem, "tr" ) || 11075 11076 // Fall back to offsetWidth/offsetHeight when value is "auto" 11077 // This happens for inline elements with no explicit setting (gh-3571) 11078 val === "auto" || 11079 11080 // Support: Android <=4.1 - 4.3 only 11081 // Also use offsetWidth/offsetHeight for misreported inline dimensions (gh-3602) 11082 !parseFloat( val ) && jQuery.css( elem, "display", false, styles ) === "inline" ) && 11083 11084 // Make sure the element is visible & connected 11085 elem.getClientRects().length ) { 11086 11087 isBorderBox = jQuery.css( elem, "boxSizing", false, styles ) === "border-box"; 11088 11089 // Where available, offsetWidth/offsetHeight approximate border box dimensions. 11090 // Where not available (e.g., SVG), assume unreliable box-sizing and interpret the 11091 // retrieved value as a content box dimension. 11092 valueIsBorderBox = offsetProp in elem; 11093 if ( valueIsBorderBox ) { 11094 val = elem[ offsetProp ]; 11095 } 11096 } 11097 11098 // Normalize "" and auto 11099 val = parseFloat( val ) || 0; 11100 11101 // Adjust for the element's box model 11102 return ( val + 11103 boxModelAdjustment( 11104 elem, 11105 dimension, 11106 extra || ( isBorderBox ? "border" : "content" ), 11107 valueIsBorderBox, 11108 styles, 11109 11110 // Provide the current computed size to request scroll gutter calculation (gh-3589) 11111 val 11112 ) 11113 ) + "px"; 11114} 11115 11116jQuery.extend( { 11117 11118 // Add in style property hooks for overriding the default 11119 // behavior of getting and setting a style property 11120 cssHooks: { 11121 opacity: { 11122 get: function( elem, computed ) { 11123 if ( computed ) { 11124 11125 // We should always get a number back from opacity 11126 var ret = curCSS( elem, "opacity" ); 11127 return ret === "" ? "1" : ret; 11128 } 11129 } 11130 } 11131 }, 11132 11133 // Don't automatically add "px" to these possibly-unitless properties 11134 cssNumber: { 11135 animationIterationCount: true, 11136 aspectRatio: true, 11137 borderImageSlice: true, 11138 columnCount: true, 11139 flexGrow: true, 11140 flexShrink: true, 11141 fontWeight: true, 11142 gridArea: true, 11143 gridColumn: true, 11144 gridColumnEnd: true, 11145 gridColumnStart: true, 11146 gridRow: true, 11147 gridRowEnd: true, 11148 gridRowStart: true, 11149 lineHeight: true, 11150 opacity: true, 11151 order: true, 11152 orphans: true, 11153 scale: true, 11154 widows: true, 11155 zIndex: true, 11156 zoom: true, 11157 11158 // SVG-related 11159 fillOpacity: true, 11160 floodOpacity: true, 11161 stopOpacity: true, 11162 strokeMiterlimit: true, 11163 strokeOpacity: true 11164 }, 11165 11166 // Add in properties whose names you wish to fix before 11167 // setting or getting the value 11168 cssProps: {}, 11169 11170 // Get and set the style property on a DOM Node 11171 style: function( elem, name, value, extra ) { 11172 11173 // Don't set styles on text and comment nodes 11174 if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style ) { 11175 return; 11176 } 11177 11178 // Make sure that we're working with the right name 11179 var ret, type, hooks, 11180 origName = camelCase( name ), 11181 isCustomProp = rcustomProp.test( name ), 11182 style = elem.style; 11183 11184 // Make sure that we're working with the right name. We don't 11185 // want to query the value if it is a CSS custom property 11186 // since they are user-defined. 11187 if ( !isCustomProp ) { 11188 name = finalPropName( origName ); 11189 } 11190 11191 // Gets hook for the prefixed version, then unprefixed version 11192 hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ]; 11193 11194 // Check if we're setting a value 11195 if ( value !== undefined ) { 11196 type = typeof value; 11197 11198 // Convert "+=" or "-=" to relative numbers (trac-7345) 11199 if ( type === "string" && ( ret = rcssNum.exec( value ) ) && ret[ 1 ] ) { 11200 value = adjustCSS( elem, name, ret ); 11201 11202 // Fixes bug trac-9237 11203 type = "number"; 11204 } 11205 11206 // Make sure that null and NaN values aren't set (trac-7116) 11207 if ( value == null || value !== value ) { 11208 return; 11209 } 11210 11211 // If a number was passed in, add the unit (except for certain CSS properties) 11212 // The isCustomProp check can be removed in jQuery 4.0 when we only auto-append 11213 // "px" to a few hardcoded values. 11214 if ( type === "number" && !isCustomProp ) { 11215 value += ret && ret[ 3 ] || ( jQuery.cssNumber[ origName ] ? "" : "px" ); 11216 } 11217 11218 // background-* props affect original clone's values 11219 if ( !support.clearCloneStyle && value === "" && name.indexOf( "background" ) === 0 ) { 11220 style[ name ] = "inherit"; 11221 } 11222 11223 // If a hook was provided, use that value, otherwise just set the specified value 11224 if ( !hooks || !( "set" in hooks ) || 11225 ( value = hooks.set( elem, value, extra ) ) !== undefined ) { 11226 11227 if ( isCustomProp ) { 11228 style.setProperty( name, value ); 11229 } else { 11230 style[ name ] = value; 11231 } 11232 } 11233 11234 } else { 11235 11236 // If a hook was provided get the non-computed value from there 11237 if ( hooks && "get" in hooks && 11238 ( ret = hooks.get( elem, false, extra ) ) !== undefined ) { 11239 11240 return ret; 11241 } 11242 11243 // Otherwise just get the value from the style object 11244 return style[ name ]; 11245 } 11246 }, 11247 11248 css: function( elem, name, extra, styles ) { 11249 var val, num, hooks, 11250 origName = camelCase( name ), 11251 isCustomProp = rcustomProp.test( name ); 11252 11253 // Make sure that we're working with the right name. We don't 11254 // want to modify the value if it is a CSS custom property 11255 // since they are user-defined. 11256 if ( !isCustomProp ) { 11257 name = finalPropName( origName ); 11258 } 11259 11260 // Try prefixed name followed by the unprefixed name 11261 hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ]; 11262 11263 // If a hook was provided get the computed value from there 11264 if ( hooks && "get" in hooks ) { 11265 val = hooks.get( elem, true, extra ); 11266 } 11267 11268 // Otherwise, if a way to get the computed value exists, use that 11269 if ( val === undefined ) { 11270 val = curCSS( elem, name, styles ); 11271 } 11272 11273 // Convert "normal" to computed value 11274 if ( val === "normal" && name in cssNormalTransform ) { 11275 val = cssNormalTransform[ name ]; 11276 } 11277 11278 // Make numeric if forced or a qualifier was provided and val looks numeric 11279 if ( extra === "" || extra ) { 11280 num = parseFloat( val ); 11281 return extra === true || isFinite( num ) ? num || 0 : val; 11282 } 11283 11284 return val; 11285 } 11286} ); 11287 11288jQuery.each( [ "height", "width" ], function( _i, dimension ) { 11289 jQuery.cssHooks[ dimension ] = { 11290 get: function( elem, computed, extra ) { 11291 if ( computed ) { 11292 11293 // Certain elements can have dimension info if we invisibly show them 11294 // but it must have a current display style that would benefit 11295 return rdisplayswap.test( jQuery.css( elem, "display" ) ) && 11296 11297 // Support: Safari 8+ 11298 // Table columns in Safari have non-zero offsetWidth & zero 11299 // getBoundingClientRect().width unless display is changed. 11300 // Support: IE <=11 only 11301 // Running getBoundingClientRect on a disconnected node 11302 // in IE throws an error. 11303 ( !elem.getClientRects().length || !elem.getBoundingClientRect().width ) ? 11304 swap( elem, cssShow, function() { 11305 return getWidthOrHeight( elem, dimension, extra ); 11306 } ) : 11307 getWidthOrHeight( elem, dimension, extra ); 11308 } 11309 }, 11310 11311 set: function( elem, value, extra ) { 11312 var matches, 11313 styles = getStyles( elem ), 11314 11315 // Only read styles.position if the test has a chance to fail 11316 // to avoid forcing a reflow. 11317 scrollboxSizeBuggy = !support.scrollboxSize() && 11318 styles.position === "absolute", 11319 11320 // To avoid forcing a reflow, only fetch boxSizing if we need it (gh-3991) 11321 boxSizingNeeded = scrollboxSizeBuggy || extra, 11322 isBorderBox = boxSizingNeeded && 11323 jQuery.css( elem, "boxSizing", false, styles ) === "border-box", 11324 subtract = extra ? 11325 boxModelAdjustment( 11326 elem, 11327 dimension, 11328 extra, 11329 isBorderBox, 11330 styles 11331 ) : 11332 0; 11333 11334 // Account for unreliable border-box dimensions by comparing offset* to computed and 11335 // faking a content-box to get border and padding (gh-3699) 11336 if ( isBorderBox && scrollboxSizeBuggy ) { 11337 subtract -= Math.ceil( 11338 elem[ "offset" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 ) ] - 11339 parseFloat( styles[ dimension ] ) - 11340 boxModelAdjustment( elem, dimension, "border", false, styles ) - 11341 0.5 11342 ); 11343 } 11344 11345 // Convert to pixels if value adjustment is needed 11346 if ( subtract && ( matches = rcssNum.exec( value ) ) && 11347 ( matches[ 3 ] || "px" ) !== "px" ) { 11348 11349 elem.style[ dimension ] = value; 11350 value = jQuery.css( elem, dimension ); 11351 } 11352 11353 return setPositiveNumber( elem, value, subtract ); 11354 } 11355 }; 11356} ); 11357 11358jQuery.cssHooks.marginLeft = addGetHookIf( support.reliableMarginLeft, 11359 function( elem, computed ) { 11360 if ( computed ) { 11361 return ( parseFloat( curCSS( elem, "marginLeft" ) ) || 11362 elem.getBoundingClientRect().left - 11363 swap( elem, { marginLeft: 0 }, function() { 11364 return elem.getBoundingClientRect().left; 11365 } ) 11366 ) + "px"; 11367 } 11368 } 11369); 11370 11371// These hooks are used by animate to expand properties 11372jQuery.each( { 11373 margin: "", 11374 padding: "", 11375 border: "Width" 11376}, function( prefix, suffix ) { 11377 jQuery.cssHooks[ prefix + suffix ] = { 11378 expand: function( value ) { 11379 var i = 0, 11380 expanded = {}, 11381 11382 // Assumes a single number if not a string 11383 parts = typeof value === "string" ? value.split( " " ) : [ value ]; 11384 11385 for ( ; i < 4; i++ ) { 11386 expanded[ prefix + cssExpand[ i ] + suffix ] = 11387 parts[ i ] || parts[ i - 2 ] || parts[ 0 ]; 11388 } 11389 11390 return expanded; 11391 } 11392 }; 11393 11394 if ( prefix !== "margin" ) { 11395 jQuery.cssHooks[ prefix + suffix ].set = setPositiveNumber; 11396 } 11397} ); 11398 11399jQuery.fn.extend( { 11400 css: function( name, value ) { 11401 return access( this, function( elem, name, value ) { 11402 var styles, len, 11403 map = {}, 11404 i = 0; 11405 11406 if ( Array.isArray( name ) ) { 11407 styles = getStyles( elem ); 11408 len = name.length; 11409 11410 for ( ; i < len; i++ ) { 11411 map[ name[ i ] ] = jQuery.css( elem, name[ i ], false, styles ); 11412 } 11413 11414 return map; 11415 } 11416 11417 return value !== undefined ? 11418 jQuery.style( elem, name, value ) : 11419 jQuery.css( elem, name ); 11420 }, name, value, arguments.length > 1 ); 11421 } 11422} ); 11423 11424 11425function Tween( elem, options, prop, end, easing ) { 11426 return new Tween.prototype.init( elem, options, prop, end, easing ); 11427} 11428jQuery.Tween = Tween; 11429 11430Tween.prototype = { 11431 constructor: Tween, 11432 init: function( elem, options, prop, end, easing, unit ) { 11433 this.elem = elem; 11434 this.prop = prop; 11435 this.easing = easing || jQuery.easing._default; 11436 this.options = options; 11437 this.start = this.now = this.cur(); 11438 this.end = end; 11439 this.unit = unit || ( jQuery.cssNumber[ prop ] ? "" : "px" ); 11440 }, 11441 cur: function() { 11442 var hooks = Tween.propHooks[ this.prop ]; 11443 11444 return hooks && hooks.get ? 11445 hooks.get( this ) : 11446 Tween.propHooks._default.get( this ); 11447 }, 11448 run: function( percent ) { 11449 var eased, 11450 hooks = Tween.propHooks[ this.prop ]; 11451 11452 if ( this.options.duration ) { 11453 this.pos = eased = jQuery.easing[ this.easing ]( 11454 percent, this.options.duration * percent, 0, 1, this.options.duration 11455 ); 11456 } else { 11457 this.pos = eased = percent; 11458 } 11459 this.now = ( this.end - this.start ) * eased + this.start; 11460 11461 if ( this.options.step ) { 11462 this.options.step.call( this.elem, this.now, this ); 11463 } 11464 11465 if ( hooks && hooks.set ) { 11466 hooks.set( this ); 11467 } else { 11468 Tween.propHooks._default.set( this ); 11469 } 11470 return this; 11471 } 11472}; 11473 11474Tween.prototype.init.prototype = Tween.prototype; 11475 11476Tween.propHooks = { 11477 _default: { 11478 get: function( tween ) { 11479 var result; 11480 11481 // Use a property on the element directly when it is not a DOM element, 11482 // or when there is no matching style property that exists. 11483 if ( tween.elem.nodeType !== 1 || 11484 tween.elem[ tween.prop ] != null && tween.elem.style[ tween.prop ] == null ) { 11485 return tween.elem[ tween.prop ]; 11486 } 11487 11488 // Passing an empty string as a 3rd parameter to .css will automatically 11489 // attempt a parseFloat and fallback to a string if the parse fails. 11490 // Simple values such as "10px" are parsed to Float; 11491 // complex values such as "rotate(1rad)" are returned as-is. 11492 result = jQuery.css( tween.elem, tween.prop, "" ); 11493 11494 // Empty strings, null, undefined and "auto" are converted to 0. 11495 return !result || result === "auto" ? 0 : result; 11496 }, 11497 set: function( tween ) { 11498 11499 // Use step hook for back compat. 11500 // Use cssHook if its there. 11501 // Use .style if available and use plain properties where available. 11502 if ( jQuery.fx.step[ tween.prop ] ) { 11503 jQuery.fx.step[ tween.prop ]( tween ); 11504 } else if ( tween.elem.nodeType === 1 && ( 11505 jQuery.cssHooks[ tween.prop ] || 11506 tween.elem.style[ finalPropName( tween.prop ) ] != null ) ) { 11507 jQuery.style( tween.elem, tween.prop, tween.now + tween.unit ); 11508 } else { 11509 tween.elem[ tween.prop ] = tween.now; 11510 } 11511 } 11512 } 11513}; 11514 11515// Support: IE <=9 only 11516// Panic based approach to setting things on disconnected nodes 11517Tween.propHooks.scrollTop = Tween.propHooks.scrollLeft = { 11518 set: function( tween ) { 11519 if ( tween.elem.nodeType && tween.elem.parentNode ) { 11520 tween.elem[ tween.prop ] = tween.now; 11521 } 11522 } 11523}; 11524 11525jQuery.easing = { 11526 linear: function( p ) { 11527 return p; 11528 }, 11529 swing: function( p ) { 11530 return 0.5 - Math.cos( p * Math.PI ) / 2; 11531 }, 11532 _default: "swing" 11533}; 11534 11535jQuery.fx = Tween.prototype.init; 11536 11537// Back compat <1.8 extension point 11538jQuery.fx.step = {}; 11539 11540 11541 11542 11543var 11544 fxNow, inProgress, 11545 rfxtypes = /^(?:toggle|show|hide)$/, 11546 rrun = /queueHooks$/; 11547 11548function schedule() { 11549 if ( inProgress ) { 11550 if ( document.hidden === false && window.requestAnimationFrame ) { 11551 window.requestAnimationFrame( schedule ); 11552 } else { 11553 window.setTimeout( schedule, jQuery.fx.interval ); 11554 } 11555 11556 jQuery.fx.tick(); 11557 } 11558} 11559 11560// Animations created synchronously will run synchronously 11561function createFxNow() { 11562 window.setTimeout( function() { 11563 fxNow = undefined; 11564 } ); 11565 return ( fxNow = Date.now() ); 11566} 11567 11568// Generate parameters to create a standard animation 11569function genFx( type, includeWidth ) { 11570 var which, 11571 i = 0, 11572 attrs = { height: type }; 11573 11574 // If we include width, step value is 1 to do all cssExpand values, 11575 // otherwise step value is 2 to skip over Left and Right 11576 includeWidth = includeWidth ? 1 : 0; 11577 for ( ; i < 4; i += 2 - includeWidth ) { 11578 which = cssExpand[ i ]; 11579 attrs[ "margin" + which ] = attrs[ "padding" + which ] = type; 11580 } 11581 11582 if ( includeWidth ) { 11583 attrs.opacity = attrs.width = type; 11584 } 11585 11586 return attrs; 11587} 11588 11589function createTween( value, prop, animation ) { 11590 var tween, 11591 collection = ( Animation.tweeners[ prop ] || [] ).concat( Animation.tweeners[ "*" ] ), 11592 index = 0, 11593 length = collection.length; 11594 for ( ; index < length; index++ ) { 11595 if ( ( tween = collection[ index ].call( animation, prop, value ) ) ) { 11596 11597 // We're done with this property 11598 return tween; 11599 } 11600 } 11601} 11602 11603function defaultPrefilter( elem, props, opts ) { 11604 var prop, value, toggle, hooks, oldfire, propTween, restoreDisplay, display, 11605 isBox = "width" in props || "height" in props, 11606 anim = this, 11607 orig = {}, 11608 style = elem.style, 11609 hidden = elem.nodeType && isHiddenWithinTree( elem ), 11610 dataShow = dataPriv.get( elem, "fxshow" ); 11611 11612 // Queue-skipping animations hijack the fx hooks 11613 if ( !opts.queue ) { 11614 hooks = jQuery._queueHooks( elem, "fx" ); 11615 if ( hooks.unqueued == null ) { 11616 hooks.unqueued = 0; 11617 oldfire = hooks.empty.fire; 11618 hooks.empty.fire = function() { 11619 if ( !hooks.unqueued ) { 11620 oldfire(); 11621 } 11622 }; 11623 } 11624 hooks.unqueued++; 11625 11626 anim.always( function() { 11627 11628 // Ensure the complete handler is called before this completes 11629 anim.always( function() { 11630 hooks.unqueued--; 11631 if ( !jQuery.queue( elem, "fx" ).length ) { 11632 hooks.empty.fire(); 11633 } 11634 } ); 11635 } ); 11636 } 11637 11638 // Detect show/hide animations 11639 for ( prop in props ) { 11640 value = props[ prop ]; 11641 if ( rfxtypes.test( value ) ) { 11642 delete props[ prop ]; 11643 toggle = toggle || value === "toggle"; 11644 if ( value === ( hidden ? "hide" : "show" ) ) { 11645 11646 // Pretend to be hidden if this is a "show" and 11647 // there is still data from a stopped show/hide 11648 if ( value === "show" && dataShow && dataShow[ prop ] !== undefined ) { 11649 hidden = true; 11650 11651 // Ignore all other no-op show/hide data 11652 } else { 11653 continue; 11654 } 11655 } 11656 orig[ prop ] = dataShow && dataShow[ prop ] || jQuery.style( elem, prop ); 11657 } 11658 } 11659 11660 // Bail out if this is a no-op like .hide().hide() 11661 propTween = !jQuery.isEmptyObject( props ); 11662 if ( !propTween && jQuery.isEmptyObject( orig ) ) { 11663 return; 11664 } 11665 11666 // Restrict "overflow" and "display" styles during box animations 11667 if ( isBox && elem.nodeType === 1 ) { 11668 11669 // Support: IE <=9 - 11, Edge 12 - 15 11670 // Record all 3 overflow attributes because IE does not infer the shorthand 11671 // from identically-valued overflowX and overflowY and Edge just mirrors 11672 // the overflowX value there. 11673 opts.overflow = [ style.overflow, style.overflowX, style.overflowY ]; 11674 11675 // Identify a display type, preferring old show/hide data over the CSS cascade 11676 restoreDisplay = dataShow && dataShow.display; 11677 if ( restoreDisplay == null ) { 11678 restoreDisplay = dataPriv.get( elem, "display" ); 11679 } 11680 display = jQuery.css( elem, "display" ); 11681 if ( display === "none" ) { 11682 if ( restoreDisplay ) { 11683 display = restoreDisplay; 11684 } else { 11685 11686 // Get nonempty value(s) by temporarily forcing visibility 11687 showHide( [ elem ], true ); 11688 restoreDisplay = elem.style.display || restoreDisplay; 11689 display = jQuery.css( elem, "display" ); 11690 showHide( [ elem ] ); 11691 } 11692 } 11693 11694 // Animate inline elements as inline-block 11695 if ( display === "inline" || display === "inline-block" && restoreDisplay != null ) { 11696 if ( jQuery.css( elem, "float" ) === "none" ) { 11697 11698 // Restore the original display value at the end of pure show/hide animations 11699 if ( !propTween ) { 11700 anim.done( function() { 11701 style.display = restoreDisplay; 11702 } ); 11703 if ( restoreDisplay == null ) { 11704 display = style.display; 11705 restoreDisplay = display === "none" ? "" : display; 11706 } 11707 } 11708 style.display = "inline-block"; 11709 } 11710 } 11711 } 11712 11713 if ( opts.overflow ) { 11714 style.overflow = "hidden"; 11715 anim.always( function() { 11716 style.overflow = opts.overflow[ 0 ]; 11717 style.overflowX = opts.overflow[ 1 ]; 11718 style.overflowY = opts.overflow[ 2 ]; 11719 } ); 11720 } 11721 11722 // Implement show/hide animations 11723 propTween = false; 11724 for ( prop in orig ) { 11725 11726 // General show/hide setup for this element animation 11727 if ( !propTween ) { 11728 if ( dataShow ) { 11729 if ( "hidden" in dataShow ) { 11730 hidden = dataShow.hidden; 11731 } 11732 } else { 11733 dataShow = dataPriv.access( elem, "fxshow", { display: restoreDisplay } ); 11734 } 11735 11736 // Store hidden/visible for toggle so `.stop().toggle()` "reverses" 11737 if ( toggle ) { 11738 dataShow.hidden = !hidden; 11739 } 11740 11741 // Show elements before animating them 11742 if ( hidden ) { 11743 showHide( [ elem ], true ); 11744 } 11745 11746 /* eslint-disable no-loop-func */ 11747 11748 anim.done( function() { 11749 11750 /* eslint-enable no-loop-func */ 11751 11752 // The final step of a "hide" animation is actually hiding the element 11753 if ( !hidden ) { 11754 showHide( [ elem ] ); 11755 } 11756 dataPriv.remove( elem, "fxshow" ); 11757 for ( prop in orig ) { 11758 jQuery.style( elem, prop, orig[ prop ] ); 11759 } 11760 } ); 11761 } 11762 11763 // Per-property setup 11764 propTween = createTween( hidden ? dataShow[ prop ] : 0, prop, anim ); 11765 if ( !( prop in dataShow ) ) { 11766 dataShow[ prop ] = propTween.start; 11767 if ( hidden ) { 11768 propTween.end = propTween.start; 11769 propTween.start = 0; 11770 } 11771 } 11772 } 11773} 11774 11775function propFilter( props, specialEasing ) { 11776 var index, name, easing, value, hooks; 11777 11778 // camelCase, specialEasing and expand cssHook pass 11779 for ( index in props ) { 11780 name = camelCase( index ); 11781 easing = specialEasing[ name ]; 11782 value = props[ index ]; 11783 if ( Array.isArray( value ) ) { 11784 easing = value[ 1 ]; 11785 value = props[ index ] = value[ 0 ]; 11786 } 11787 11788 if ( index !== name ) { 11789 props[ name ] = value; 11790 delete props[ index ]; 11791 } 11792 11793 hooks = jQuery.cssHooks[ name ]; 11794 if ( hooks && "expand" in hooks ) { 11795 value = hooks.expand( value ); 11796 delete props[ name ]; 11797 11798 // Not quite $.extend, this won't overwrite existing keys. 11799 // Reusing 'index' because we have the correct "name" 11800 for ( index in value ) { 11801 if ( !( index in props ) ) { 11802 props[ index ] = value[ index ]; 11803 specialEasing[ index ] = easing; 11804 } 11805 } 11806 } else { 11807 specialEasing[ name ] = easing; 11808 } 11809 } 11810} 11811 11812function Animation( elem, properties, options ) { 11813 var result, 11814 stopped, 11815 index = 0, 11816 length = Animation.prefilters.length, 11817 deferred = jQuery.Deferred().always( function() { 11818 11819 // Don't match elem in the :animated selector 11820 delete tick.elem; 11821 } ), 11822 tick = function() { 11823 if ( stopped ) { 11824 return false; 11825 } 11826 var currentTime = fxNow || createFxNow(), 11827 remaining = Math.max( 0, animation.startTime + animation.duration - currentTime ), 11828 11829 // Support: Android 2.3 only 11830 // Archaic crash bug won't allow us to use `1 - ( 0.5 || 0 )` (trac-12497) 11831 temp = remaining / animation.duration || 0, 11832 percent = 1 - temp, 11833 index = 0, 11834 length = animation.tweens.length; 11835 11836 for ( ; index < length; index++ ) { 11837 animation.tweens[ index ].run( percent ); 11838 } 11839 11840 deferred.notifyWith( elem, [ animation, percent, remaining ] ); 11841 11842 // If there's more to do, yield 11843 if ( percent < 1 && length ) { 11844 return remaining; 11845 } 11846 11847 // If this was an empty animation, synthesize a final progress notification 11848 if ( !length ) { 11849 deferred.notifyWith( elem, [ animation, 1, 0 ] ); 11850 } 11851 11852 // Resolve the animation and report its conclusion 11853 deferred.resolveWith( elem, [ animation ] ); 11854 return false; 11855 }, 11856 animation = deferred.promise( { 11857 elem: elem, 11858 props: jQuery.extend( {}, properties ), 11859 opts: jQuery.extend( true, { 11860 specialEasing: {}, 11861 easing: jQuery.easing._default 11862 }, options ), 11863 originalProperties: properties, 11864 originalOptions: options, 11865 startTime: fxNow || createFxNow(), 11866 duration: options.duration, 11867 tweens: [], 11868 createTween: function( prop, end ) { 11869 var tween = jQuery.Tween( elem, animation.opts, prop, end, 11870 animation.opts.specialEasing[ prop ] || animation.opts.easing ); 11871 animation.tweens.push( tween ); 11872 return tween; 11873 }, 11874 stop: function( gotoEnd ) { 11875 var index = 0, 11876 11877 // If we are going to the end, we want to run all the tweens 11878 // otherwise we skip this part 11879 length = gotoEnd ? animation.tweens.length : 0; 11880 if ( stopped ) { 11881 return this; 11882 } 11883 stopped = true; 11884 for ( ; index < length; index++ ) { 11885 animation.tweens[ index ].run( 1 ); 11886 } 11887 11888 // Resolve when we played the last frame; otherwise, reject 11889 if ( gotoEnd ) { 11890 deferred.notifyWith( elem, [ animation, 1, 0 ] ); 11891 deferred.resolveWith( elem, [ animation, gotoEnd ] ); 11892 } else { 11893 deferred.rejectWith( elem, [ animation, gotoEnd ] ); 11894 } 11895 return this; 11896 } 11897 } ), 11898 props = animation.props; 11899 11900 propFilter( props, animation.opts.specialEasing ); 11901 11902 for ( ; index < length; index++ ) { 11903 result = Animation.prefilters[ index ].call( animation, elem, props, animation.opts ); 11904 if ( result ) { 11905 if ( isFunction( result.stop ) ) { 11906 jQuery._queueHooks( animation.elem, animation.opts.queue ).stop = 11907 result.stop.bind( result ); 11908 } 11909 return result; 11910 } 11911 } 11912 11913 jQuery.map( props, createTween, animation ); 11914 11915 if ( isFunction( animation.opts.start ) ) { 11916 animation.opts.start.call( elem, animation ); 11917 } 11918 11919 // Attach callbacks from options 11920 animation 11921 .progress( animation.opts.progress ) 11922 .done( animation.opts.done, animation.opts.complete ) 11923 .fail( animation.opts.fail ) 11924 .always( animation.opts.always ); 11925 11926 jQuery.fx.timer( 11927 jQuery.extend( tick, { 11928 elem: elem, 11929 anim: animation, 11930 queue: animation.opts.queue 11931 } ) 11932 ); 11933 11934 return animation; 11935} 11936 11937jQuery.Animation = jQuery.extend( Animation, { 11938 11939 tweeners: { 11940 "*": [ function( prop, value ) { 11941 var tween = this.createTween( prop, value ); 11942 adjustCSS( tween.elem, prop, rcssNum.exec( value ), tween ); 11943 return tween; 11944 } ] 11945 }, 11946 11947 tweener: function( props, callback ) { 11948 if ( isFunction( props ) ) { 11949 callback = props; 11950 props = [ "*" ]; 11951 } else { 11952 props = props.match( rnothtmlwhite ); 11953 } 11954 11955 var prop, 11956 index = 0, 11957 length = props.length; 11958 11959 for ( ; index < length; index++ ) { 11960 prop = props[ index ]; 11961 Animation.tweeners[ prop ] = Animation.tweeners[ prop ] || []; 11962 Animation.tweeners[ prop ].unshift( callback ); 11963 } 11964 }, 11965 11966 prefilters: [ defaultPrefilter ], 11967 11968 prefilter: function( callback, prepend ) { 11969 if ( prepend ) { 11970 Animation.prefilters.unshift( callback ); 11971 } else { 11972 Animation.prefilters.push( callback ); 11973 } 11974 } 11975} ); 11976 11977jQuery.speed = function( speed, easing, fn ) { 11978 var opt = speed && typeof speed === "object" ? jQuery.extend( {}, speed ) : { 11979 complete: fn || !fn && easing || 11980 isFunction( speed ) && speed, 11981 duration: speed, 11982 easing: fn && easing || easing && !isFunction( easing ) && easing 11983 }; 11984 11985 // Go to the end state if fx are off 11986 if ( jQuery.fx.off ) { 11987 opt.duration = 0; 11988 11989 } else { 11990 if ( typeof opt.duration !== "number" ) { 11991 if ( opt.duration in jQuery.fx.speeds ) { 11992 opt.duration = jQuery.fx.speeds[ opt.duration ]; 11993 11994 } else { 11995 opt.duration = jQuery.fx.speeds._default; 11996 } 11997 } 11998 } 11999 12000 // Normalize opt.queue - true/undefined/null -> "fx" 12001 if ( opt.queue == null || opt.queue === true ) { 12002 opt.queue = "fx"; 12003 } 12004 12005 // Queueing 12006 opt.old = opt.complete; 12007 12008 opt.complete = function() { 12009 if ( isFunction( opt.old ) ) { 12010 opt.old.call( this ); 12011 } 12012 12013 if ( opt.queue ) { 12014 jQuery.dequeue( this, opt.queue ); 12015 } 12016 }; 12017 12018 return opt; 12019}; 12020 12021jQuery.fn.extend( { 12022 fadeTo: function( speed, to, easing, callback ) { 12023 12024 // Show any hidden elements after setting opacity to 0 12025 return this.filter( isHiddenWithinTree ).css( "opacity", 0 ).show() 12026 12027 // Animate to the value specified 12028 .end().animate( { opacity: to }, speed, easing, callback ); 12029 }, 12030 animate: function( prop, speed, easing, callback ) { 12031 var empty = jQuery.isEmptyObject( prop ), 12032 optall = jQuery.speed( speed, easing, callback ), 12033 doAnimation = function() { 12034 12035 // Operate on a copy of prop so per-property easing won't be lost 12036 var anim = Animation( this, jQuery.extend( {}, prop ), optall ); 12037 12038 // Empty animations, or finishing resolves immediately 12039 if ( empty || dataPriv.get( this, "finish" ) ) { 12040 anim.stop( true ); 12041 } 12042 }; 12043 12044 doAnimation.finish = doAnimation; 12045 12046 return empty || optall.queue === false ? 12047 this.each( doAnimation ) : 12048 this.queue( optall.queue, doAnimation ); 12049 }, 12050 stop: function( type, clearQueue, gotoEnd ) { 12051 var stopQueue = function( hooks ) { 12052 var stop = hooks.stop; 12053 delete hooks.stop; 12054 stop( gotoEnd ); 12055 }; 12056 12057 if ( typeof type !== "string" ) { 12058 gotoEnd = clearQueue; 12059 clearQueue = type; 12060 type = undefined; 12061 } 12062 if ( clearQueue ) { 12063 this.queue( type || "fx", [] ); 12064 } 12065 12066 return this.each( function() { 12067 var dequeue = true, 12068 index = type != null && type + "queueHooks", 12069 timers = jQuery.timers, 12070 data = dataPriv.get( this ); 12071 12072 if ( index ) { 12073 if ( data[ index ] && data[ index ].stop ) { 12074 stopQueue( data[ index ] ); 12075 } 12076 } else { 12077 for ( index in data ) { 12078 if ( data[ index ] && data[ index ].stop && rrun.test( index ) ) { 12079 stopQueue( data[ index ] ); 12080 } 12081 } 12082 } 12083 12084 for ( index = timers.length; index--; ) { 12085 if ( timers[ index ].elem === this && 12086 ( type == null || timers[ index ].queue === type ) ) { 12087 12088 timers[ index ].anim.stop( gotoEnd ); 12089 dequeue = false; 12090 timers.splice( index, 1 ); 12091 } 12092 } 12093 12094 // Start the next in the queue if the last step wasn't forced. 12095 // Timers currently will call their complete callbacks, which 12096 // will dequeue but only if they were gotoEnd. 12097 if ( dequeue || !gotoEnd ) { 12098 jQuery.dequeue( this, type ); 12099 } 12100 } ); 12101 }, 12102 finish: function( type ) { 12103 if ( type !== false ) { 12104 type = type || "fx"; 12105 } 12106 return this.each( function() { 12107 var index, 12108 data = dataPriv.get( this ), 12109 queue = data[ type + "queue" ], 12110 hooks = data[ type + "queueHooks" ], 12111 timers = jQuery.timers, 12112 length = queue ? queue.length : 0; 12113 12114 // Enable finishing flag on private data 12115 data.finish = true; 12116 12117 // Empty the queue first 12118 jQuery.queue( this, type, [] ); 12119 12120 if ( hooks && hooks.stop ) { 12121 hooks.stop.call( this, true ); 12122 } 12123 12124 // Look for any active animations, and finish them 12125 for ( index = timers.length; index--; ) { 12126 if ( timers[ index ].elem === this && timers[ index ].queue === type ) { 12127 timers[ index ].anim.stop( true ); 12128 timers.splice( index, 1 ); 12129 } 12130 } 12131 12132 // Look for any animations in the old queue and finish them 12133 for ( index = 0; index < length; index++ ) { 12134 if ( queue[ index ] && queue[ index ].finish ) { 12135 queue[ index ].finish.call( this ); 12136 } 12137 } 12138 12139 // Turn off finishing flag 12140 delete data.finish; 12141 } ); 12142 } 12143} ); 12144 12145jQuery.each( [ "toggle", "show", "hide" ], function( _i, name ) { 12146 var cssFn = jQuery.fn[ name ]; 12147 jQuery.fn[ name ] = function( speed, easing, callback ) { 12148 return speed == null || typeof speed === "boolean" ? 12149 cssFn.apply( this, arguments ) : 12150 this.animate( genFx( name, true ), speed, easing, callback ); 12151 }; 12152} ); 12153 12154// Generate shortcuts for custom animations 12155jQuery.each( { 12156 slideDown: genFx( "show" ), 12157 slideUp: genFx( "hide" ), 12158 slideToggle: genFx( "toggle" ), 12159 fadeIn: { opacity: "show" }, 12160 fadeOut: { opacity: "hide" }, 12161 fadeToggle: { opacity: "toggle" } 12162}, function( name, props ) { 12163 jQuery.fn[ name ] = function( speed, easing, callback ) { 12164 return this.animate( props, speed, easing, callback ); 12165 }; 12166} ); 12167 12168jQuery.timers = []; 12169jQuery.fx.tick = function() { 12170 var timer, 12171 i = 0, 12172 timers = jQuery.timers; 12173 12174 fxNow = Date.now(); 12175 12176 for ( ; i < timers.length; i++ ) { 12177 timer = timers[ i ]; 12178 12179 // Run the timer and safely remove it when done (allowing for external removal) 12180 if ( !timer() && timers[ i ] === timer ) { 12181 timers.splice( i--, 1 ); 12182 } 12183 } 12184 12185 if ( !timers.length ) { 12186 jQuery.fx.stop(); 12187 } 12188 fxNow = undefined; 12189}; 12190 12191jQuery.fx.timer = function( timer ) { 12192 jQuery.timers.push( timer ); 12193 jQuery.fx.start(); 12194}; 12195 12196jQuery.fx.interval = 13; 12197jQuery.fx.start = function() { 12198 if ( inProgress ) { 12199 return; 12200 } 12201 12202 inProgress = true; 12203 schedule(); 12204}; 12205 12206jQuery.fx.stop = function() { 12207 inProgress = null; 12208}; 12209 12210jQuery.fx.speeds = { 12211 slow: 600, 12212 fast: 200, 12213 12214 // Default speed 12215 _default: 400 12216}; 12217 12218 12219// Based off of the plugin by Clint Helfers, with permission. 12220jQuery.fn.delay = function( time, type ) { 12221 time = jQuery.fx ? jQuery.fx.speeds[ time ] || time : time; 12222 type = type || "fx"; 12223 12224 return this.queue( type, function( next, hooks ) { 12225 var timeout = window.setTimeout( next, time ); 12226 hooks.stop = function() { 12227 window.clearTimeout( timeout ); 12228 }; 12229 } ); 12230}; 12231 12232 12233( function() { 12234 var input = document.createElement( "input" ), 12235 select = document.createElement( "select" ), 12236 opt = select.appendChild( document.createElement( "option" ) ); 12237 12238 input.type = "checkbox"; 12239 12240 // Support: Android <=4.3 only 12241 // Default value for a checkbox should be "on" 12242 support.checkOn = input.value !== ""; 12243 12244 // Support: IE <=11 only 12245 // Must access selectedIndex to make default options select 12246 support.optSelected = opt.selected; 12247 12248 // Support: IE <=11 only 12249 // An input loses its value after becoming a radio 12250 input = document.createElement( "input" ); 12251 input.value = "t"; 12252 input.type = "radio"; 12253 support.radioValue = input.value === "t"; 12254} )(); 12255 12256 12257var boolHook, 12258 attrHandle = jQuery.expr.attrHandle; 12259 12260jQuery.fn.extend( { 12261 attr: function( name, value ) { 12262 return access( this, jQuery.attr, name, value, arguments.length > 1 ); 12263 }, 12264 12265 removeAttr: function( name ) { 12266 return this.each( function() { 12267 jQuery.removeAttr( this, name ); 12268 } ); 12269 } 12270} ); 12271 12272jQuery.extend( { 12273 attr: function( elem, name, value ) { 12274 var ret, hooks, 12275 nType = elem.nodeType; 12276 12277 // Don't get/set attributes on text, comment and attribute nodes 12278 if ( nType === 3 || nType === 8 || nType === 2 ) { 12279 return; 12280 } 12281 12282 // Fallback to prop when attributes are not supported 12283 if ( typeof elem.getAttribute === "undefined" ) { 12284 return jQuery.prop( elem, name, value ); 12285 } 12286 12287 // Attribute hooks are determined by the lowercase version 12288 // Grab necessary hook if one is defined 12289 if ( nType !== 1 || !jQuery.isXMLDoc( elem ) ) { 12290 hooks = jQuery.attrHooks[ name.toLowerCase() ] || 12291 ( jQuery.expr.match.bool.test( name ) ? boolHook : undefined ); 12292 } 12293 12294 if ( value !== undefined ) { 12295 if ( value === null ) { 12296 jQuery.removeAttr( elem, name ); 12297 return; 12298 } 12299 12300 if ( hooks && "set" in hooks && 12301 ( ret = hooks.set( elem, value, name ) ) !== undefined ) { 12302 return ret; 12303 } 12304 12305 elem.setAttribute( name, value + "" ); 12306 return value; 12307 } 12308 12309 if ( hooks && "get" in hooks && ( ret = hooks.get( elem, name ) ) !== null ) { 12310 return ret; 12311 } 12312 12313 ret = jQuery.find.attr( elem, name ); 12314 12315 // Non-existent attributes return null, we normalize to undefined 12316 return ret == null ? undefined : ret; 12317 }, 12318 12319 attrHooks: { 12320 type: { 12321 set: function( elem, value ) { 12322 if ( !support.radioValue && value === "radio" && 12323 nodeName( elem, "input" ) ) { 12324 var val = elem.value; 12325 elem.setAttribute( "type", value ); 12326 if ( val ) { 12327 elem.value = val; 12328 } 12329 return value; 12330 } 12331 } 12332 } 12333 }, 12334 12335 removeAttr: function( elem, value ) { 12336 var name, 12337 i = 0, 12338 12339 // Attribute names can contain non-HTML whitespace characters 12340 // https://html.spec.whatwg.org/multipage/syntax.html#attributes-2 12341 attrNames = value && value.match( rnothtmlwhite ); 12342 12343 if ( attrNames && elem.nodeType === 1 ) { 12344 while ( ( name = attrNames[ i++ ] ) ) { 12345 elem.removeAttribute( name ); 12346 } 12347 } 12348 } 12349} ); 12350 12351// Hooks for boolean attributes 12352boolHook = { 12353 set: function( elem, value, name ) { 12354 if ( value === false ) { 12355 12356 // Remove boolean attributes when set to false 12357 jQuery.removeAttr( elem, name ); 12358 } else { 12359 elem.setAttribute( name, name ); 12360 } 12361 return name; 12362 } 12363}; 12364 12365jQuery.each( jQuery.expr.match.bool.source.match( /\w+/g ), function( _i, name ) { 12366 var getter = attrHandle[ name ] || jQuery.find.attr; 12367 12368 attrHandle[ name ] = function( elem, name, isXML ) { 12369 var ret, handle, 12370 lowercaseName = name.toLowerCase(); 12371 12372 if ( !isXML ) { 12373 12374 // Avoid an infinite loop by temporarily removing this function from the getter 12375 handle = attrHandle[ lowercaseName ]; 12376 attrHandle[ lowercaseName ] = ret; 12377 ret = getter( elem, name, isXML ) != null ? 12378 lowercaseName : 12379 null; 12380 attrHandle[ lowercaseName ] = handle; 12381 } 12382 return ret; 12383 }; 12384} ); 12385 12386 12387 12388 12389var rfocusable = /^(?:input|select|textarea|button)$/i, 12390 rclickable = /^(?:a|area)$/i; 12391 12392jQuery.fn.extend( { 12393 prop: function( name, value ) { 12394 return access( this, jQuery.prop, name, value, arguments.length > 1 ); 12395 }, 12396 12397 removeProp: function( name ) { 12398 return this.each( function() { 12399 delete this[ jQuery.propFix[ name ] || name ]; 12400 } ); 12401 } 12402} ); 12403 12404jQuery.extend( { 12405 prop: function( elem, name, value ) { 12406 var ret, hooks, 12407 nType = elem.nodeType; 12408 12409 // Don't get/set properties on text, comment and attribute nodes 12410 if ( nType === 3 || nType === 8 || nType === 2 ) { 12411 return; 12412 } 12413 12414 if ( nType !== 1 || !jQuery.isXMLDoc( elem ) ) { 12415 12416 // Fix name and attach hooks 12417 name = jQuery.propFix[ name ] || name; 12418 hooks = jQuery.propHooks[ name ]; 12419 } 12420 12421 if ( value !== undefined ) { 12422 if ( hooks && "set" in hooks && 12423 ( ret = hooks.set( elem, value, name ) ) !== undefined ) { 12424 return ret; 12425 } 12426 12427 return ( elem[ name ] = value ); 12428 } 12429 12430 if ( hooks && "get" in hooks && ( ret = hooks.get( elem, name ) ) !== null ) { 12431 return ret; 12432 } 12433 12434 return elem[ name ]; 12435 }, 12436 12437 propHooks: { 12438 tabIndex: { 12439 get: function( elem ) { 12440 12441 // Support: IE <=9 - 11 only 12442 // elem.tabIndex doesn't always return the 12443 // correct value when it hasn't been explicitly set 12444 // Use proper attribute retrieval (trac-12072) 12445 var tabindex = jQuery.find.attr( elem, "tabindex" ); 12446 12447 if ( tabindex ) { 12448 return parseInt( tabindex, 10 ); 12449 } 12450 12451 if ( 12452 rfocusable.test( elem.nodeName ) || 12453 rclickable.test( elem.nodeName ) && 12454 elem.href 12455 ) { 12456 return 0; 12457 } 12458 12459 return -1; 12460 } 12461 } 12462 }, 12463 12464 propFix: { 12465 "for": "htmlFor", 12466 "class": "className" 12467 } 12468} ); 12469 12470// Support: IE <=11 only 12471// Accessing the selectedIndex property 12472// forces the browser to respect setting selected 12473// on the option 12474// The getter ensures a default option is selected 12475// when in an optgroup 12476// eslint rule "no-unused-expressions" is disabled for this code 12477// since it considers such accessions noop 12478if ( !support.optSelected ) { 12479 jQuery.propHooks.selected = { 12480 get: function( elem ) { 12481 12482 /* eslint no-unused-expressions: "off" */ 12483 12484 var parent = elem.parentNode; 12485 if ( parent && parent.parentNode ) { 12486 parent.parentNode.selectedIndex; 12487 } 12488 return null; 12489 }, 12490 set: function( elem ) { 12491 12492 /* eslint no-unused-expressions: "off" */ 12493 12494 var parent = elem.parentNode; 12495 if ( parent ) { 12496 parent.selectedIndex; 12497 12498 if ( parent.parentNode ) { 12499 parent.parentNode.selectedIndex; 12500 } 12501 } 12502 } 12503 }; 12504} 12505 12506jQuery.each( [ 12507 "tabIndex", 12508 "readOnly", 12509 "maxLength", 12510 "cellSpacing", 12511 "cellPadding", 12512 "rowSpan", 12513 "colSpan", 12514 "useMap", 12515 "frameBorder", 12516 "contentEditable" 12517], function() { 12518 jQuery.propFix[ this.toLowerCase() ] = this; 12519} ); 12520 12521 12522 12523 12524 // Strip and collapse whitespace according to HTML spec 12525 // https://infra.spec.whatwg.org/#strip-and-collapse-ascii-whitespace 12526 function stripAndCollapse( value ) { 12527 var tokens = value.match( rnothtmlwhite ) || []; 12528 return tokens.join( " " ); 12529 } 12530 12531 12532function getClass( elem ) { 12533 return elem.getAttribute && elem.getAttribute( "class" ) || ""; 12534} 12535 12536function classesToArray( value ) { 12537 if ( Array.isArray( value ) ) { 12538 return value; 12539 } 12540 if ( typeof value === "string" ) { 12541 return value.match( rnothtmlwhite ) || []; 12542 } 12543 return []; 12544} 12545 12546jQuery.fn.extend( { 12547 addClass: function( value ) { 12548 var classNames, cur, curValue, className, i, finalValue; 12549 12550 if ( isFunction( value ) ) { 12551 return this.each( function( j ) { 12552 jQuery( this ).addClass( value.call( this, j, getClass( this ) ) ); 12553 } ); 12554 } 12555 12556 classNames = classesToArray( value ); 12557 12558 if ( classNames.length ) { 12559 return this.each( function() { 12560 curValue = getClass( this ); 12561 cur = this.nodeType === 1 && ( " " + stripAndCollapse( curValue ) + " " ); 12562 12563 if ( cur ) { 12564 for ( i = 0; i < classNames.length; i++ ) { 12565 className = classNames[ i ]; 12566 if ( cur.indexOf( " " + className + " " ) < 0 ) { 12567 cur += className + " "; 12568 } 12569 } 12570 12571 // Only assign if different to avoid unneeded rendering. 12572 finalValue = stripAndCollapse( cur ); 12573 if ( curValue !== finalValue ) { 12574 this.setAttribute( "class", finalValue ); 12575 } 12576 } 12577 } ); 12578 } 12579 12580 return this; 12581 }, 12582 12583 removeClass: function( value ) { 12584 var classNames, cur, curValue, className, i, finalValue; 12585 12586 if ( isFunction( value ) ) { 12587 return this.each( function( j ) { 12588 jQuery( this ).removeClass( value.call( this, j, getClass( this ) ) ); 12589 } ); 12590 } 12591 12592 if ( !arguments.length ) { 12593 return this.attr( "class", "" ); 12594 } 12595 12596 classNames = classesToArray( value ); 12597 12598 if ( classNames.length ) { 12599 return this.each( function() { 12600 curValue = getClass( this ); 12601 12602 // This expression is here for better compressibility (see addClass) 12603 cur = this.nodeType === 1 && ( " " + stripAndCollapse( curValue ) + " " ); 12604 12605 if ( cur ) { 12606 for ( i = 0; i < classNames.length; i++ ) { 12607 className = classNames[ i ]; 12608 12609 // Remove *all* instances 12610 while ( cur.indexOf( " " + className + " " ) > -1 ) { 12611 cur = cur.replace( " " + className + " ", " " ); 12612 } 12613 } 12614 12615 // Only assign if different to avoid unneeded rendering. 12616 finalValue = stripAndCollapse( cur ); 12617 if ( curValue !== finalValue ) { 12618 this.setAttribute( "class", finalValue ); 12619 } 12620 } 12621 } ); 12622 } 12623 12624 return this; 12625 }, 12626 12627 toggleClass: function( value, stateVal ) { 12628 var classNames, className, i, self, 12629 type = typeof value, 12630 isValidValue = type === "string" || Array.isArray( value ); 12631 12632 if ( isFunction( value ) ) { 12633 return this.each( function( i ) { 12634 jQuery( this ).toggleClass( 12635 value.call( this, i, getClass( this ), stateVal ), 12636 stateVal 12637 ); 12638 } ); 12639 } 12640 12641 if ( typeof stateVal === "boolean" && isValidValue ) { 12642 return stateVal ? this.addClass( value ) : this.removeClass( value ); 12643 } 12644 12645 classNames = classesToArray( value ); 12646 12647 return this.each( function() { 12648 if ( isValidValue ) { 12649 12650 // Toggle individual class names 12651 self = jQuery( this ); 12652 12653 for ( i = 0; i < classNames.length; i++ ) { 12654 className = classNames[ i ]; 12655 12656 // Check each className given, space separated list 12657 if ( self.hasClass( className ) ) { 12658 self.removeClass( className ); 12659 } else { 12660 self.addClass( className ); 12661 } 12662 } 12663 12664 // Toggle whole class name 12665 } else if ( value === undefined || type === "boolean" ) { 12666 className = getClass( this ); 12667 if ( className ) { 12668 12669 // Store className if set 12670 dataPriv.set( this, "__className__", className ); 12671 } 12672 12673 // If the element has a class name or if we're passed `false`, 12674 // then remove the whole classname (if there was one, the above saved it). 12675 // Otherwise bring back whatever was previously saved (if anything), 12676 // falling back to the empty string if nothing was stored. 12677 if ( this.setAttribute ) { 12678 this.setAttribute( "class", 12679 className || value === false ? 12680 "" : 12681 dataPriv.get( this, "__className__" ) || "" 12682 ); 12683 } 12684 } 12685 } ); 12686 }, 12687 12688 hasClass: function( selector ) { 12689 var className, elem, 12690 i = 0; 12691 12692 className = " " + selector + " "; 12693 while ( ( elem = this[ i++ ] ) ) { 12694 if ( elem.nodeType === 1 && 12695 ( " " + stripAndCollapse( getClass( elem ) ) + " " ).indexOf( className ) > -1 ) { 12696 return true; 12697 } 12698 } 12699 12700 return false; 12701 } 12702} ); 12703 12704 12705 12706 12707var rreturn = /\r/g; 12708 12709jQuery.fn.extend( { 12710 val: function( value ) { 12711 var hooks, ret, valueIsFunction, 12712 elem = this[ 0 ]; 12713 12714 if ( !arguments.length ) { 12715 if ( elem ) { 12716 hooks = jQuery.valHooks[ elem.type ] || 12717 jQuery.valHooks[ elem.nodeName.toLowerCase() ]; 12718 12719 if ( hooks && 12720 "get" in hooks && 12721 ( ret = hooks.get( elem, "value" ) ) !== undefined 12722 ) { 12723 return ret; 12724 } 12725 12726 ret = elem.value; 12727 12728 // Handle most common string cases 12729 if ( typeof ret === "string" ) { 12730 return ret.replace( rreturn, "" ); 12731 } 12732 12733 // Handle cases where value is null/undef or number 12734 return ret == null ? "" : ret; 12735 } 12736 12737 return; 12738 } 12739 12740 valueIsFunction = isFunction( value ); 12741 12742 return this.each( function( i ) { 12743 var val; 12744 12745 if ( this.nodeType !== 1 ) { 12746 return; 12747 } 12748 12749 if ( valueIsFunction ) { 12750 val = value.call( this, i, jQuery( this ).val() ); 12751 } else { 12752 val = value; 12753 } 12754 12755 // Treat null/undefined as ""; convert numbers to string 12756 if ( val == null ) { 12757 val = ""; 12758 12759 } else if ( typeof val === "number" ) { 12760 val += ""; 12761 12762 } else if ( Array.isArray( val ) ) { 12763 val = jQuery.map( val, function( value ) { 12764 return value == null ? "" : value + ""; 12765 } ); 12766 } 12767 12768 hooks = jQuery.valHooks[ this.type ] || jQuery.valHooks[ this.nodeName.toLowerCase() ]; 12769 12770 // If set returns undefined, fall back to normal setting 12771 if ( !hooks || !( "set" in hooks ) || hooks.set( this, val, "value" ) === undefined ) { 12772 this.value = val; 12773 } 12774 } ); 12775 } 12776} ); 12777 12778jQuery.extend( { 12779 valHooks: { 12780 option: { 12781 get: function( elem ) { 12782 12783 var val = jQuery.find.attr( elem, "value" ); 12784 return val != null ? 12785 val : 12786 12787 // Support: IE <=10 - 11 only 12788 // option.text throws exceptions (trac-14686, trac-14858) 12789 // Strip and collapse whitespace 12790 // https://html.spec.whatwg.org/#strip-and-collapse-whitespace 12791 stripAndCollapse( jQuery.text( elem ) ); 12792 } 12793 }, 12794 select: { 12795 get: function( elem ) { 12796 var value, option, i, 12797 options = elem.options, 12798 index = elem.selectedIndex, 12799 one = elem.type === "select-one", 12800 values = one ? null : [], 12801 max = one ? index + 1 : options.length; 12802 12803 if ( index < 0 ) { 12804 i = max; 12805 12806 } else { 12807 i = one ? index : 0; 12808 } 12809 12810 // Loop through all the selected options 12811 for ( ; i < max; i++ ) { 12812 option = options[ i ]; 12813 12814 // Support: IE <=9 only 12815 // IE8-9 doesn't update selected after form reset (trac-2551) 12816 if ( ( option.selected || i === index ) && 12817 12818 // Don't return options that are disabled or in a disabled optgroup 12819 !option.disabled && 12820 ( !option.parentNode.disabled || 12821 !nodeName( option.parentNode, "optgroup" ) ) ) { 12822 12823 // Get the specific value for the option 12824 value = jQuery( option ).val(); 12825 12826 // We don't need an array for one selects 12827 if ( one ) { 12828 return value; 12829 } 12830 12831 // Multi-Selects return an array 12832 values.push( value ); 12833 } 12834 } 12835 12836 return values; 12837 }, 12838 12839 set: function( elem, value ) { 12840 var optionSet, option, 12841 options = elem.options, 12842 values = jQuery.makeArray( value ), 12843 i = options.length; 12844 12845 while ( i-- ) { 12846 option = options[ i ]; 12847 12848 /* eslint-disable no-cond-assign */ 12849 12850 if ( option.selected = 12851 jQuery.inArray( jQuery.valHooks.option.get( option ), values ) > -1 12852 ) { 12853 optionSet = true; 12854 } 12855 12856 /* eslint-enable no-cond-assign */ 12857 } 12858 12859 // Force browsers to behave consistently when non-matching value is set 12860 if ( !optionSet ) { 12861 elem.selectedIndex = -1; 12862 } 12863 return values; 12864 } 12865 } 12866 } 12867} ); 12868 12869// Radios and checkboxes getter/setter 12870jQuery.each( [ "radio", "checkbox" ], function() { 12871 jQuery.valHooks[ this ] = { 12872 set: function( elem, value ) { 12873 if ( Array.isArray( value ) ) { 12874 return ( elem.checked = jQuery.inArray( jQuery( elem ).val(), value ) > -1 ); 12875 } 12876 } 12877 }; 12878 if ( !support.checkOn ) { 12879 jQuery.valHooks[ this ].get = function( elem ) { 12880 return elem.getAttribute( "value" ) === null ? "on" : elem.value; 12881 }; 12882 } 12883} ); 12884 12885 12886 12887 12888// Return jQuery for attributes-only inclusion 12889var location = window.location; 12890 12891var nonce = { guid: Date.now() }; 12892 12893var rquery = ( /\?/ ); 12894 12895 12896 12897// Cross-browser xml parsing 12898jQuery.parseXML = function( data ) { 12899 var xml, parserErrorElem; 12900 if ( !data || typeof data !== "string" ) { 12901 return null; 12902 } 12903 12904 // Support: IE 9 - 11 only 12905 // IE throws on parseFromString with invalid input. 12906 try { 12907 xml = ( new window.DOMParser() ).parseFromString( data, "text/xml" ); 12908 } catch ( e ) {} 12909 12910 parserErrorElem = xml && xml.getElementsByTagName( "parsererror" )[ 0 ]; 12911 if ( !xml || parserErrorElem ) { 12912 jQuery.error( "Invalid XML: " + ( 12913 parserErrorElem ? 12914 jQuery.map( parserErrorElem.childNodes, function( el ) { 12915 return el.textContent; 12916 } ).join( "\n" ) : 12917 data 12918 ) ); 12919 } 12920 return xml; 12921}; 12922 12923 12924var rfocusMorph = /^(?:focusinfocus|focusoutblur)$/, 12925 stopPropagationCallback = function( e ) { 12926 e.stopPropagation(); 12927 }; 12928 12929jQuery.extend( jQuery.event, { 12930 12931 trigger: function( event, data, elem, onlyHandlers ) { 12932 12933 var i, cur, tmp, bubbleType, ontype, handle, special, lastElement, 12934 eventPath = [ elem || document ], 12935 type = hasOwn.call( event, "type" ) ? event.type : event, 12936 namespaces = hasOwn.call( event, "namespace" ) ? event.namespace.split( "." ) : []; 12937 12938 cur = lastElement = tmp = elem = elem || document; 12939 12940 // Don't do events on text and comment nodes 12941 if ( elem.nodeType === 3 || elem.nodeType === 8 ) { 12942 return; 12943 } 12944 12945 // focus/blur morphs to focusin/out; ensure we're not firing them right now 12946 if ( rfocusMorph.test( type + jQuery.event.triggered ) ) { 12947 return; 12948 } 12949 12950 if ( type.indexOf( "." ) > -1 ) { 12951 12952 // Namespaced trigger; create a regexp to match event type in handle() 12953 namespaces = type.split( "." ); 12954 type = namespaces.shift(); 12955 namespaces.sort(); 12956 } 12957 ontype = type.indexOf( ":" ) < 0 && "on" + type; 12958 12959 // Caller can pass in a jQuery.Event object, Object, or just an event type string 12960 event = event[ jQuery.expando ] ? 12961 event : 12962 new jQuery.Event( type, typeof event === "object" && event ); 12963 12964 // Trigger bitmask: & 1 for native handlers; & 2 for jQuery (always true) 12965 event.isTrigger = onlyHandlers ? 2 : 3; 12966 event.namespace = namespaces.join( "." ); 12967 event.rnamespace = event.namespace ? 12968 new RegExp( "(^|\\.)" + namespaces.join( "\\.(?:.*\\.|)" ) + "(\\.|$)" ) : 12969 null; 12970 12971 // Clean up the event in case it is being reused 12972 event.result = undefined; 12973 if ( !event.target ) { 12974 event.target = elem; 12975 } 12976 12977 // Clone any incoming data and prepend the event, creating the handler arg list 12978 data = data == null ? 12979 [ event ] : 12980 jQuery.makeArray( data, [ event ] ); 12981 12982 // Allow special events to draw outside the lines 12983 special = jQuery.event.special[ type ] || {}; 12984 if ( !onlyHandlers && special.trigger && special.trigger.apply( elem, data ) === false ) { 12985 return; 12986 } 12987 12988 // Determine event propagation path in advance, per W3C events spec (trac-9951) 12989 // Bubble up to document, then to window; watch for a global ownerDocument var (trac-9724) 12990 if ( !onlyHandlers && !special.noBubble && !isWindow( elem ) ) { 12991 12992 bubbleType = special.delegateType || type; 12993 if ( !rfocusMorph.test( bubbleType + type ) ) { 12994 cur = cur.parentNode; 12995 } 12996 for ( ; cur; cur = cur.parentNode ) { 12997 eventPath.push( cur ); 12998 tmp = cur; 12999 } 13000 13001 // Only add window if we got to document (e.g., not plain obj or detached DOM) 13002 if ( tmp === ( elem.ownerDocument || document ) ) { 13003 eventPath.push( tmp.defaultView || tmp.parentWindow || window ); 13004 } 13005 } 13006 13007 // Fire handlers on the event path 13008 i = 0; 13009 while ( ( cur = eventPath[ i++ ] ) && !event.isPropagationStopped() ) { 13010 lastElement = cur; 13011 event.type = i > 1 ? 13012 bubbleType : 13013 special.bindType || type; 13014 13015 // jQuery handler 13016 handle = ( dataPriv.get( cur, "events" ) || Object.create( null ) )[ event.type ] && 13017 dataPriv.get( cur, "handle" ); 13018 if ( handle ) { 13019 handle.apply( cur, data ); 13020 } 13021 13022 // Native handler 13023 handle = ontype && cur[ ontype ]; 13024 if ( handle && handle.apply && acceptData( cur ) ) { 13025 event.result = handle.apply( cur, data ); 13026 if ( event.result === false ) { 13027 event.preventDefault(); 13028 } 13029 } 13030 } 13031 event.type = type; 13032 13033 // If nobody prevented the default action, do it now 13034 if ( !onlyHandlers && !event.isDefaultPrevented() ) { 13035 13036 if ( ( !special._default || 13037 special._default.apply( eventPath.pop(), data ) === false ) && 13038 acceptData( elem ) ) { 13039 13040 // Call a native DOM method on the target with the same name as the event. 13041 // Don't do default actions on window, that's where global variables be (trac-6170) 13042 if ( ontype && isFunction( elem[ type ] ) && !isWindow( elem ) ) { 13043 13044 // Don't re-trigger an onFOO event when we call its FOO() method 13045 tmp = elem[ ontype ]; 13046 13047 if ( tmp ) { 13048 elem[ ontype ] = null; 13049 } 13050 13051 // Prevent re-triggering of the same event, since we already bubbled it above 13052 jQuery.event.triggered = type; 13053 13054 if ( event.isPropagationStopped() ) { 13055 lastElement.addEventListener( type, stopPropagationCallback ); 13056 } 13057 13058 elem[ type ](); 13059 13060 if ( event.isPropagationStopped() ) { 13061 lastElement.removeEventListener( type, stopPropagationCallback ); 13062 } 13063 13064 jQuery.event.triggered = undefined; 13065 13066 if ( tmp ) { 13067 elem[ ontype ] = tmp; 13068 } 13069 } 13070 } 13071 } 13072 13073 return event.result; 13074 }, 13075 13076 // Piggyback on a donor event to simulate a different one 13077 // Used only for `focus(in | out)` events 13078 simulate: function( type, elem, event ) { 13079 var e = jQuery.extend( 13080 new jQuery.Event(), 13081 event, 13082 { 13083 type: type, 13084 isSimulated: true 13085 } 13086 ); 13087 13088 jQuery.event.trigger( e, null, elem ); 13089 } 13090 13091} ); 13092 13093jQuery.fn.extend( { 13094 13095 trigger: function( type, data ) { 13096 return this.each( function() { 13097 jQuery.event.trigger( type, data, this ); 13098 } ); 13099 }, 13100 triggerHandler: function( type, data ) { 13101 var elem = this[ 0 ]; 13102 if ( elem ) { 13103 return jQuery.event.trigger( type, data, elem, true ); 13104 } 13105 } 13106} ); 13107 13108 13109var 13110 rbracket = /\[\]$/, 13111 rCRLF = /\r?\n/g, 13112 rsubmitterTypes = /^(?:submit|button|image|reset|file)$/i, 13113 rsubmittable = /^(?:input|select|textarea|keygen)/i; 13114 13115function buildParams( prefix, obj, traditional, add ) { 13116 var name; 13117 13118 if ( Array.isArray( obj ) ) { 13119 13120 // Serialize array item. 13121 jQuery.each( obj, function( i, v ) { 13122 if ( traditional || rbracket.test( prefix ) ) { 13123 13124 // Treat each array item as a scalar. 13125 add( prefix, v ); 13126 13127 } else { 13128 13129 // Item is non-scalar (array or object), encode its numeric index. 13130 buildParams( 13131 prefix + "[" + ( typeof v === "object" && v != null ? i : "" ) + "]", 13132 v, 13133 traditional, 13134 add 13135 ); 13136 } 13137 } ); 13138 13139 } else if ( !traditional && toType( obj ) === "object" ) { 13140 13141 // Serialize object item. 13142 for ( name in obj ) { 13143 buildParams( prefix + "[" + name + "]", obj[ name ], traditional, add ); 13144 } 13145 13146 } else { 13147 13148 // Serialize scalar item. 13149 add( prefix, obj ); 13150 } 13151} 13152 13153// Serialize an array of form elements or a set of 13154// key/values into a query string 13155jQuery.param = function( a, traditional ) { 13156 var prefix, 13157 s = [], 13158 add = function( key, valueOrFunction ) { 13159 13160 // If value is a function, invoke it and use its return value 13161 var value = isFunction( valueOrFunction ) ? 13162 valueOrFunction() : 13163 valueOrFunction; 13164 13165 s[ s.length ] = encodeURIComponent( key ) + "=" + 13166 encodeURIComponent( value == null ? "" : value ); 13167 }; 13168 13169 if ( a == null ) { 13170 return ""; 13171 } 13172 13173 // If an array was passed in, assume that it is an array of form elements. 13174 if ( Array.isArray( a ) || ( a.jquery && !jQuery.isPlainObject( a ) ) ) { 13175 13176 // Serialize the form elements 13177 jQuery.each( a, function() { 13178 add( this.name, this.value ); 13179 } ); 13180 13181 } else { 13182 13183 // If traditional, encode the "old" way (the way 1.3.2 or older 13184 // did it), otherwise encode params recursively. 13185 for ( prefix in a ) { 13186 buildParams( prefix, a[ prefix ], traditional, add ); 13187 } 13188 } 13189 13190 // Return the resulting serialization 13191 return s.join( "&" ); 13192}; 13193 13194jQuery.fn.extend( { 13195 serialize: function() { 13196 return jQuery.param( this.serializeArray() ); 13197 }, 13198 serializeArray: function() { 13199 return this.map( function() { 13200 13201 // Can add propHook for "elements" to filter or add form elements 13202 var elements = jQuery.prop( this, "elements" ); 13203 return elements ? jQuery.makeArray( elements ) : this; 13204 } ).filter( function() { 13205 var type = this.type; 13206 13207 // Use .is( ":disabled" ) so that fieldset[disabled] works 13208 return this.name && !jQuery( this ).is( ":disabled" ) && 13209 rsubmittable.test( this.nodeName ) && !rsubmitterTypes.test( type ) && 13210 ( this.checked || !rcheckableType.test( type ) ); 13211 } ).map( function( _i, elem ) { 13212 var val = jQuery( this ).val(); 13213 13214 if ( val == null ) { 13215 return null; 13216 } 13217 13218 if ( Array.isArray( val ) ) { 13219 return jQuery.map( val, function( val ) { 13220 return { name: elem.name, value: val.replace( rCRLF, "\r\n" ) }; 13221 } ); 13222 } 13223 13224 return { name: elem.name, value: val.replace( rCRLF, "\r\n" ) }; 13225 } ).get(); 13226 } 13227} ); 13228 13229 13230var 13231 r20 = /%20/g, 13232 rhash = /#.*$/, 13233 rantiCache = /([?&])_=[^&]*/, 13234 rheaders = /^(.*?):[ \t]*([^\r\n]*)$/mg, 13235 13236 // trac-7653, trac-8125, trac-8152: local protocol detection 13237 rlocalProtocol = /^(?:about|app|app-storage|.+-extension|file|res|widget):$/, 13238 rnoContent = /^(?:GET|HEAD)$/, 13239 rprotocol = /^\/\//, 13240 13241 /* Prefilters 13242 * 1) They are useful to introduce custom dataTypes (see ajax/jsonp.js for an example) 13243 * 2) These are called: 13244 * - BEFORE asking for a transport 13245 * - AFTER param serialization (s.data is a string if s.processData is true) 13246 * 3) key is the dataType 13247 * 4) the catchall symbol "*" can be used 13248 * 5) execution will start with transport dataType and THEN continue down to "*" if needed 13249 */ 13250 prefilters = {}, 13251 13252 /* Transports bindings 13253 * 1) key is the dataType 13254 * 2) the catchall symbol "*" can be used 13255 * 3) selection will start with transport dataType and THEN go to "*" if needed 13256 */ 13257 transports = {}, 13258 13259 // Avoid comment-prolog char sequence (trac-10098); must appease lint and evade compression 13260 allTypes = "*/".concat( "*" ), 13261 13262 // Anchor tag for parsing the document origin 13263 originAnchor = document.createElement( "a" ); 13264 13265originAnchor.href = location.href; 13266 13267// Base "constructor" for jQuery.ajaxPrefilter and jQuery.ajaxTransport 13268function addToPrefiltersOrTransports( structure ) { 13269 13270 // dataTypeExpression is optional and defaults to "*" 13271 return function( dataTypeExpression, func ) { 13272 13273 if ( typeof dataTypeExpression !== "string" ) { 13274 func = dataTypeExpression; 13275 dataTypeExpression = "*"; 13276 } 13277 13278 var dataType, 13279 i = 0, 13280 dataTypes = dataTypeExpression.toLowerCase().match( rnothtmlwhite ) || []; 13281 13282 if ( isFunction( func ) ) { 13283 13284 // For each dataType in the dataTypeExpression 13285 while ( ( dataType = dataTypes[ i++ ] ) ) { 13286 13287 // Prepend if requested 13288 if ( dataType[ 0 ] === "+" ) { 13289 dataType = dataType.slice( 1 ) || "*"; 13290 ( structure[ dataType ] = structure[ dataType ] || [] ).unshift( func ); 13291 13292 // Otherwise append 13293 } else { 13294 ( structure[ dataType ] = structure[ dataType ] || [] ).push( func ); 13295 } 13296 } 13297 } 13298 }; 13299} 13300 13301// Base inspection function for prefilters and transports 13302function inspectPrefiltersOrTransports( structure, options, originalOptions, jqXHR ) { 13303 13304 var inspected = {}, 13305 seekingTransport = ( structure === transports ); 13306 13307 function inspect( dataType ) { 13308 var selected; 13309 inspected[ dataType ] = true; 13310 jQuery.each( structure[ dataType ] || [], function( _, prefilterOrFactory ) { 13311 var dataTypeOrTransport = prefilterOrFactory( options, originalOptions, jqXHR ); 13312 if ( typeof dataTypeOrTransport === "string" && 13313 !seekingTransport && !inspected[ dataTypeOrTransport ] ) { 13314 13315 options.dataTypes.unshift( dataTypeOrTransport ); 13316 inspect( dataTypeOrTransport ); 13317 return false; 13318 } else if ( seekingTransport ) { 13319 return !( selected = dataTypeOrTransport ); 13320 } 13321 } ); 13322 return selected; 13323 } 13324 13325 return inspect( options.dataTypes[ 0 ] ) || !inspected[ "*" ] && inspect( "*" ); 13326} 13327 13328// A special extend for ajax options 13329// that takes "flat" options (not to be deep extended) 13330// Fixes trac-9887 13331function ajaxExtend( target, src ) { 13332 var key, deep, 13333 flatOptions = jQuery.ajaxSettings.flatOptions || {}; 13334 13335 for ( key in src ) { 13336 if ( src[ key ] !== undefined ) { 13337 ( flatOptions[ key ] ? target : ( deep || ( deep = {} ) ) )[ key ] = src[ key ]; 13338 } 13339 } 13340 if ( deep ) { 13341 jQuery.extend( true, target, deep ); 13342 } 13343 13344 return target; 13345} 13346 13347/* Handles responses to an ajax request: 13348 * - finds the right dataType (mediates between content-type and expected dataType) 13349 * - returns the corresponding response 13350 */ 13351function ajaxHandleResponses( s, jqXHR, responses ) { 13352 13353 var ct, type, finalDataType, firstDataType, 13354 contents = s.contents, 13355 dataTypes = s.dataTypes; 13356 13357 // Remove auto dataType and get content-type in the process 13358 while ( dataTypes[ 0 ] === "*" ) { 13359 dataTypes.shift(); 13360 if ( ct === undefined ) { 13361 ct = s.mimeType || jqXHR.getResponseHeader( "Content-Type" ); 13362 } 13363 } 13364 13365 // Check if we're dealing with a known content-type 13366 if ( ct ) { 13367 for ( type in contents ) { 13368 if ( contents[ type ] && contents[ type ].test( ct ) ) { 13369 dataTypes.unshift( type ); 13370 break; 13371 } 13372 } 13373 } 13374 13375 // Check to see if we have a response for the expected dataType 13376 if ( dataTypes[ 0 ] in responses ) { 13377 finalDataType = dataTypes[ 0 ]; 13378 } else { 13379 13380 // Try convertible dataTypes 13381 for ( type in responses ) { 13382 if ( !dataTypes[ 0 ] || s.converters[ type + " " + dataTypes[ 0 ] ] ) { 13383 finalDataType = type; 13384 break; 13385 } 13386 if ( !firstDataType ) { 13387 firstDataType = type; 13388 } 13389 } 13390 13391 // Or just use first one 13392 finalDataType = finalDataType || firstDataType; 13393 } 13394 13395 // If we found a dataType 13396 // We add the dataType to the list if needed 13397 // and return the corresponding response 13398 if ( finalDataType ) { 13399 if ( finalDataType !== dataTypes[ 0 ] ) { 13400 dataTypes.unshift( finalDataType ); 13401 } 13402 return responses[ finalDataType ]; 13403 } 13404} 13405 13406/* Chain conversions given the request and the original response 13407 * Also sets the responseXXX fields on the jqXHR instance 13408 */ 13409function ajaxConvert( s, response, jqXHR, isSuccess ) { 13410 var conv2, current, conv, tmp, prev, 13411 converters = {}, 13412 13413 // Work with a copy of dataTypes in case we need to modify it for conversion 13414 dataTypes = s.dataTypes.slice(); 13415 13416 // Create converters map with lowercased keys 13417 if ( dataTypes[ 1 ] ) { 13418 for ( conv in s.converters ) { 13419 converters[ conv.toLowerCase() ] = s.converters[ conv ]; 13420 } 13421 } 13422 13423 current = dataTypes.shift(); 13424 13425 // Convert to each sequential dataType 13426 while ( current ) { 13427 13428 if ( s.responseFields[ current ] ) { 13429 jqXHR[ s.responseFields[ current ] ] = response; 13430 } 13431 13432 // Apply the dataFilter if provided 13433 if ( !prev && isSuccess && s.dataFilter ) { 13434 response = s.dataFilter( response, s.dataType ); 13435 } 13436 13437 prev = current; 13438 current = dataTypes.shift(); 13439 13440 if ( current ) { 13441 13442 // There's only work to do if current dataType is non-auto 13443 if ( current === "*" ) { 13444 13445 current = prev; 13446 13447 // Convert response if prev dataType is non-auto and differs from current 13448 } else if ( prev !== "*" && prev !== current ) { 13449 13450 // Seek a direct converter 13451 conv = converters[ prev + " " + current ] || converters[ "* " + current ]; 13452 13453 // If none found, seek a pair 13454 if ( !conv ) { 13455 for ( conv2 in converters ) { 13456 13457 // If conv2 outputs current 13458 tmp = conv2.split( " " ); 13459 if ( tmp[ 1 ] === current ) { 13460 13461 // If prev can be converted to accepted input 13462 conv = converters[ prev + " " + tmp[ 0 ] ] || 13463 converters[ "* " + tmp[ 0 ] ]; 13464 if ( conv ) { 13465 13466 // Condense equivalence converters 13467 if ( conv === true ) { 13468 conv = converters[ conv2 ]; 13469 13470 // Otherwise, insert the intermediate dataType 13471 } else if ( converters[ conv2 ] !== true ) { 13472 current = tmp[ 0 ]; 13473 dataTypes.unshift( tmp[ 1 ] ); 13474 } 13475 break; 13476 } 13477 } 13478 } 13479 } 13480 13481 // Apply converter (if not an equivalence) 13482 if ( conv !== true ) { 13483 13484 // Unless errors are allowed to bubble, catch and return them 13485 if ( conv && s.throws ) { 13486 response = conv( response ); 13487 } else { 13488 try { 13489 response = conv( response ); 13490 } catch ( e ) { 13491 return { 13492 state: "parsererror", 13493 error: conv ? e : "No conversion from " + prev + " to " + current 13494 }; 13495 } 13496 } 13497 } 13498 } 13499 } 13500 } 13501 13502 return { state: "success", data: response }; 13503} 13504 13505jQuery.extend( { 13506 13507 // Counter for holding the number of active queries 13508 active: 0, 13509 13510 // Last-Modified header cache for next request 13511 lastModified: {}, 13512 etag: {}, 13513 13514 ajaxSettings: { 13515 url: location.href, 13516 type: "GET", 13517 isLocal: rlocalProtocol.test( location.protocol ), 13518 global: true, 13519 processData: true, 13520 async: true, 13521 contentType: "application/x-www-form-urlencoded; charset=UTF-8", 13522 13523 /* 13524 timeout: 0, 13525 data: null, 13526 dataType: null, 13527 username: null, 13528 password: null, 13529 cache: null, 13530 throws: false, 13531 traditional: false, 13532 headers: {}, 13533 */ 13534 13535 accepts: { 13536 "*": allTypes, 13537 text: "text/plain", 13538 html: "text/html", 13539 xml: "application/xml, text/xml", 13540 json: "application/json, text/javascript" 13541 }, 13542 13543 contents: { 13544 xml: /\bxml\b/, 13545 html: /\bhtml/, 13546 json: /\bjson\b/ 13547 }, 13548 13549 responseFields: { 13550 xml: "responseXML", 13551 text: "responseText", 13552 json: "responseJSON" 13553 }, 13554 13555 // Data converters 13556 // Keys separate source (or catchall "*") and destination types with a single space 13557 converters: { 13558 13559 // Convert anything to text 13560 "* text": String, 13561 13562 // Text to html (true = no transformation) 13563 "text html": true, 13564 13565 // Evaluate text as a json expression 13566 "text json": JSON.parse, 13567 13568 // Parse text as xml 13569 "text xml": jQuery.parseXML 13570 }, 13571 13572 // For options that shouldn't be deep extended: 13573 // you can add your own custom options here if 13574 // and when you create one that shouldn't be 13575 // deep extended (see ajaxExtend) 13576 flatOptions: { 13577 url: true, 13578 context: true 13579 } 13580 }, 13581 13582 // Creates a full fledged settings object into target 13583 // with both ajaxSettings and settings fields. 13584 // If target is omitted, writes into ajaxSettings. 13585 ajaxSetup: function( target, settings ) { 13586 return settings ? 13587 13588 // Building a settings object 13589 ajaxExtend( ajaxExtend( target, jQuery.ajaxSettings ), settings ) : 13590 13591 // Extending ajaxSettings 13592 ajaxExtend( jQuery.ajaxSettings, target ); 13593 }, 13594 13595 ajaxPrefilter: addToPrefiltersOrTransports( prefilters ), 13596 ajaxTransport: addToPrefiltersOrTransports( transports ), 13597 13598 // Main method 13599 ajax: function( url, options ) { 13600 13601 // If url is an object, simulate pre-1.5 signature 13602 if ( typeof url === "object" ) { 13603 options = url; 13604 url = undefined; 13605 } 13606 13607 // Force options to be an object 13608 options = options || {}; 13609 13610 var transport, 13611 13612 // URL without anti-cache param 13613 cacheURL, 13614 13615 // Response headers 13616 responseHeadersString, 13617 responseHeaders, 13618 13619 // timeout handle 13620 timeoutTimer, 13621 13622 // Url cleanup var 13623 urlAnchor, 13624 13625 // Request state (becomes false upon send and true upon completion) 13626 completed, 13627 13628 // To know if global events are to be dispatched 13629 fireGlobals, 13630 13631 // Loop variable 13632 i, 13633 13634 // uncached part of the url 13635 uncached, 13636 13637 // Create the final options object 13638 s = jQuery.ajaxSetup( {}, options ), 13639 13640 // Callbacks context 13641 callbackContext = s.context || s, 13642 13643 // Context for global events is callbackContext if it is a DOM node or jQuery collection 13644 globalEventContext = s.context && 13645 ( callbackContext.nodeType || callbackContext.jquery ) ? 13646 jQuery( callbackContext ) : 13647 jQuery.event, 13648 13649 // Deferreds 13650 deferred = jQuery.Deferred(), 13651 completeDeferred = jQuery.Callbacks( "once memory" ), 13652 13653 // Status-dependent callbacks 13654 statusCode = s.statusCode || {}, 13655 13656 // Headers (they are sent all at once) 13657 requestHeaders = {}, 13658 requestHeadersNames = {}, 13659 13660 // Default abort message 13661 strAbort = "canceled", 13662 13663 // Fake xhr 13664 jqXHR = { 13665 readyState: 0, 13666 13667 // Builds headers hashtable if needed 13668 getResponseHeader: function( key ) { 13669 var match; 13670 if ( completed ) { 13671 if ( !responseHeaders ) { 13672 responseHeaders = {}; 13673 while ( ( match = rheaders.exec( responseHeadersString ) ) ) { 13674 responseHeaders[ match[ 1 ].toLowerCase() + " " ] = 13675 ( responseHeaders[ match[ 1 ].toLowerCase() + " " ] || [] ) 13676 .concat( match[ 2 ] ); 13677 } 13678 } 13679 match = responseHeaders[ key.toLowerCase() + " " ]; 13680 } 13681 return match == null ? null : match.join( ", " ); 13682 }, 13683 13684 // Raw string 13685 getAllResponseHeaders: function() { 13686 return completed ? responseHeadersString : null; 13687 }, 13688 13689 // Caches the header 13690 setRequestHeader: function( name, value ) { 13691 if ( completed == null ) { 13692 name = requestHeadersNames[ name.toLowerCase() ] = 13693 requestHeadersNames[ name.toLowerCase() ] || name; 13694 requestHeaders[ name ] = value; 13695 } 13696 return this; 13697 }, 13698 13699 // Overrides response content-type header 13700 overrideMimeType: function( type ) { 13701 if ( completed == null ) { 13702 s.mimeType = type; 13703 } 13704 return this; 13705 }, 13706 13707 // Status-dependent callbacks 13708 statusCode: function( map ) { 13709 var code; 13710 if ( map ) { 13711 if ( completed ) { 13712 13713 // Execute the appropriate callbacks 13714 jqXHR.always( map[ jqXHR.status ] ); 13715 } else { 13716 13717 // Lazy-add the new callbacks in a way that preserves old ones 13718 for ( code in map ) { 13719 statusCode[ code ] = [ statusCode[ code ], map[ code ] ]; 13720 } 13721 } 13722 } 13723 return this; 13724 }, 13725 13726 // Cancel the request 13727 abort: function( statusText ) { 13728 var finalText = statusText || strAbort; 13729 if ( transport ) { 13730 transport.abort( finalText ); 13731 } 13732 done( 0, finalText ); 13733 return this; 13734 } 13735 }; 13736 13737 // Attach deferreds 13738 deferred.promise( jqXHR ); 13739 13740 // Add protocol if not provided (prefilters might expect it) 13741 // Handle falsy url in the settings object (trac-10093: consistency with old signature) 13742 // We also use the url parameter if available 13743 s.url = ( ( url || s.url || location.href ) + "" ) 13744 .replace( rprotocol, location.protocol + "//" ); 13745 13746 // Alias method option to type as per ticket trac-12004 13747 s.type = options.method || options.type || s.method || s.type; 13748 13749 // Extract dataTypes list 13750 s.dataTypes = ( s.dataType || "*" ).toLowerCase().match( rnothtmlwhite ) || [ "" ]; 13751 13752 // A cross-domain request is in order when the origin doesn't match the current origin. 13753 if ( s.crossDomain == null ) { 13754 urlAnchor = document.createElement( "a" ); 13755 13756 // Support: IE <=8 - 11, Edge 12 - 15 13757 // IE throws exception on accessing the href property if url is malformed, 13758 // e.g. http://example.com:80x/ 13759 try { 13760 urlAnchor.href = s.url; 13761 13762 // Support: IE <=8 - 11 only 13763 // Anchor's host property isn't correctly set when s.url is relative 13764 urlAnchor.href = urlAnchor.href; 13765 s.crossDomain = originAnchor.protocol + "//" + originAnchor.host !== 13766 urlAnchor.protocol + "//" + urlAnchor.host; 13767 } catch ( e ) { 13768 13769 // If there is an error parsing the URL, assume it is crossDomain, 13770 // it can be rejected by the transport if it is invalid 13771 s.crossDomain = true; 13772 } 13773 } 13774 13775 // Convert data if not already a string 13776 if ( s.data && s.processData && typeof s.data !== "string" ) { 13777 s.data = jQuery.param( s.data, s.traditional ); 13778 } 13779 13780 // Apply prefilters 13781 inspectPrefiltersOrTransports( prefilters, s, options, jqXHR ); 13782 13783 // If request was aborted inside a prefilter, stop there 13784 if ( completed ) { 13785 return jqXHR; 13786 } 13787 13788 // We can fire global events as of now if asked to 13789 // Don't fire events if jQuery.event is undefined in an AMD-usage scenario (trac-15118) 13790 fireGlobals = jQuery.event && s.global; 13791 13792 // Watch for a new set of requests 13793 if ( fireGlobals && jQuery.active++ === 0 ) { 13794 jQuery.event.trigger( "ajaxStart" ); 13795 } 13796 13797 // Uppercase the type 13798 s.type = s.type.toUpperCase(); 13799 13800 // Determine if request has content 13801 s.hasContent = !rnoContent.test( s.type ); 13802 13803 // Save the URL in case we're toying with the If-Modified-Since 13804 // and/or If-None-Match header later on 13805 // Remove hash to simplify url manipulation 13806 cacheURL = s.url.replace( rhash, "" ); 13807 13808 // More options handling for requests with no content 13809 if ( !s.hasContent ) { 13810 13811 // Remember the hash so we can put it back 13812 uncached = s.url.slice( cacheURL.length ); 13813 13814 // If data is available and should be processed, append data to url 13815 if ( s.data && ( s.processData || typeof s.data === "string" ) ) { 13816 cacheURL += ( rquery.test( cacheURL ) ? "&" : "?" ) + s.data; 13817 13818 // trac-9682: remove data so that it's not used in an eventual retry 13819 delete s.data; 13820 } 13821 13822 // Add or update anti-cache param if needed 13823 if ( s.cache === false ) { 13824 cacheURL = cacheURL.replace( rantiCache, "$1" ); 13825 uncached = ( rquery.test( cacheURL ) ? "&" : "?" ) + "_=" + ( nonce.guid++ ) + 13826 uncached; 13827 } 13828 13829 // Put hash and anti-cache on the URL that will be requested (gh-1732) 13830 s.url = cacheURL + uncached; 13831 13832 // Change '%20' to '+' if this is encoded form body content (gh-2658) 13833 } else if ( s.data && s.processData && 13834 ( s.contentType || "" ).indexOf( "application/x-www-form-urlencoded" ) === 0 ) { 13835 s.data = s.data.replace( r20, "+" ); 13836 } 13837 13838 // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode. 13839 if ( s.ifModified ) { 13840 if ( jQuery.lastModified[ cacheURL ] ) { 13841 jqXHR.setRequestHeader( "If-Modified-Since", jQuery.lastModified[ cacheURL ] ); 13842 } 13843 if ( jQuery.etag[ cacheURL ] ) { 13844 jqXHR.setRequestHeader( "If-None-Match", jQuery.etag[ cacheURL ] ); 13845 } 13846 } 13847 13848 // Set the correct header, if data is being sent 13849 if ( s.data && s.hasContent && s.contentType !== false || options.contentType ) { 13850 jqXHR.setRequestHeader( "Content-Type", s.contentType ); 13851 } 13852 13853 // Set the Accepts header for the server, depending on the dataType 13854 jqXHR.setRequestHeader( 13855 "Accept", 13856 s.dataTypes[ 0 ] && s.accepts[ s.dataTypes[ 0 ] ] ? 13857 s.accepts[ s.dataTypes[ 0 ] ] + 13858 ( s.dataTypes[ 0 ] !== "*" ? ", " + allTypes + "; q=0.01" : "" ) : 13859 s.accepts[ "*" ] 13860 ); 13861 13862 // Check for headers option 13863 for ( i in s.headers ) { 13864 jqXHR.setRequestHeader( i, s.headers[ i ] ); 13865 } 13866 13867 // Allow custom headers/mimetypes and early abort 13868 if ( s.beforeSend && 13869 ( s.beforeSend.call( callbackContext, jqXHR, s ) === false || completed ) ) { 13870 13871 // Abort if not done already and return 13872 return jqXHR.abort(); 13873 } 13874 13875 // Aborting is no longer a cancellation 13876 strAbort = "abort"; 13877 13878 // Install callbacks on deferreds 13879 completeDeferred.add( s.complete ); 13880 jqXHR.done( s.success ); 13881 jqXHR.fail( s.error ); 13882 13883 // Get transport 13884 transport = inspectPrefiltersOrTransports( transports, s, options, jqXHR ); 13885 13886 // If no transport, we auto-abort 13887 if ( !transport ) { 13888 done( -1, "No Transport" ); 13889 } else { 13890 jqXHR.readyState = 1; 13891 13892 // Send global event 13893 if ( fireGlobals ) { 13894 globalEventContext.trigger( "ajaxSend", [ jqXHR, s ] ); 13895 } 13896 13897 // If request was aborted inside ajaxSend, stop there 13898 if ( completed ) { 13899 return jqXHR; 13900 } 13901 13902 // Timeout 13903 if ( s.async && s.timeout > 0 ) { 13904 timeoutTimer = window.setTimeout( function() { 13905 jqXHR.abort( "timeout" ); 13906 }, s.timeout ); 13907 } 13908 13909 try { 13910 completed = false; 13911 transport.send( requestHeaders, done ); 13912 } catch ( e ) { 13913 13914 // Rethrow post-completion exceptions 13915 if ( completed ) { 13916 throw e; 13917 } 13918 13919 // Propagate others as results 13920 done( -1, e ); 13921 } 13922 } 13923 13924 // Callback for when everything is done 13925 function done( status, nativeStatusText, responses, headers ) { 13926 var isSuccess, success, error, response, modified, 13927 statusText = nativeStatusText; 13928 13929 // Ignore repeat invocations 13930 if ( completed ) { 13931 return; 13932 } 13933 13934 completed = true; 13935 13936 // Clear timeout if it exists 13937 if ( timeoutTimer ) { 13938 window.clearTimeout( timeoutTimer ); 13939 } 13940 13941 // Dereference transport for early garbage collection 13942 // (no matter how long the jqXHR object will be used) 13943 transport = undefined; 13944 13945 // Cache response headers 13946 responseHeadersString = headers || ""; 13947 13948 // Set readyState 13949 jqXHR.readyState = status > 0 ? 4 : 0; 13950 13951 // Determine if successful 13952 isSuccess = status >= 200 && status < 300 || status === 304; 13953 13954 // Get response data 13955 if ( responses ) { 13956 response = ajaxHandleResponses( s, jqXHR, responses ); 13957 } 13958 13959 // Use a noop converter for missing script but not if jsonp 13960 if ( !isSuccess && 13961 jQuery.inArray( "script", s.dataTypes ) > -1 && 13962 jQuery.inArray( "json", s.dataTypes ) < 0 ) { 13963 s.converters[ "text script" ] = function() {}; 13964 } 13965 13966 // Convert no matter what (that way responseXXX fields are always set) 13967 response = ajaxConvert( s, response, jqXHR, isSuccess ); 13968 13969 // If successful, handle type chaining 13970 if ( isSuccess ) { 13971 13972 // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode. 13973 if ( s.ifModified ) { 13974 modified = jqXHR.getResponseHeader( "Last-Modified" ); 13975 if ( modified ) { 13976 jQuery.lastModified[ cacheURL ] = modified; 13977 } 13978 modified = jqXHR.getResponseHeader( "etag" ); 13979 if ( modified ) { 13980 jQuery.etag[ cacheURL ] = modified; 13981 } 13982 } 13983 13984 // if no content 13985 if ( status === 204 || s.type === "HEAD" ) { 13986 statusText = "nocontent"; 13987 13988 // if not modified 13989 } else if ( status === 304 ) { 13990 statusText = "notmodified"; 13991 13992 // If we have data, let's convert it 13993 } else { 13994 statusText = response.state; 13995 success = response.data; 13996 error = response.error; 13997 isSuccess = !error; 13998 } 13999 } else { 14000 14001 // Extract error from statusText and normalize for non-aborts 14002 error = statusText; 14003 if ( status || !statusText ) { 14004 statusText = "error"; 14005 if ( status < 0 ) { 14006 status = 0; 14007 } 14008 } 14009 } 14010 14011 // Set data for the fake xhr object 14012 jqXHR.status = status; 14013 jqXHR.statusText = ( nativeStatusText || statusText ) + ""; 14014 14015 // Success/Error 14016 if ( isSuccess ) { 14017 deferred.resolveWith( callbackContext, [ success, statusText, jqXHR ] ); 14018 } else { 14019 deferred.rejectWith( callbackContext, [ jqXHR, statusText, error ] ); 14020 } 14021 14022 // Status-dependent callbacks 14023 jqXHR.statusCode( statusCode ); 14024 statusCode = undefined; 14025 14026 if ( fireGlobals ) { 14027 globalEventContext.trigger( isSuccess ? "ajaxSuccess" : "ajaxError", 14028 [ jqXHR, s, isSuccess ? success : error ] ); 14029 } 14030 14031 // Complete 14032 completeDeferred.fireWith( callbackContext, [ jqXHR, statusText ] ); 14033 14034 if ( fireGlobals ) { 14035 globalEventContext.trigger( "ajaxComplete", [ jqXHR, s ] ); 14036 14037 // Handle the global AJAX counter 14038 if ( !( --jQuery.active ) ) { 14039 jQuery.event.trigger( "ajaxStop" ); 14040 } 14041 } 14042 } 14043 14044 return jqXHR; 14045 }, 14046 14047 getJSON: function( url, data, callback ) { 14048 return jQuery.get( url, data, callback, "json" ); 14049 }, 14050 14051 getScript: function( url, callback ) { 14052 return jQuery.get( url, undefined, callback, "script" ); 14053 } 14054} ); 14055 14056jQuery.each( [ "get", "post" ], function( _i, method ) { 14057 jQuery[ method ] = function( url, data, callback, type ) { 14058 14059 // Shift arguments if data argument was omitted 14060 if ( isFunction( data ) ) { 14061 type = type || callback; 14062 callback = data; 14063 data = undefined; 14064 } 14065 14066 // The url can be an options object (which then must have .url) 14067 return jQuery.ajax( jQuery.extend( { 14068 url: url, 14069 type: method, 14070 dataType: type, 14071 data: data, 14072 success: callback 14073 }, jQuery.isPlainObject( url ) && url ) ); 14074 }; 14075} ); 14076 14077jQuery.ajaxPrefilter( function( s ) { 14078 var i; 14079 for ( i in s.headers ) { 14080 if ( i.toLowerCase() === "content-type" ) { 14081 s.contentType = s.headers[ i ] || ""; 14082 } 14083 } 14084} ); 14085 14086 14087jQuery._evalUrl = function( url, options, doc ) { 14088 return jQuery.ajax( { 14089 url: url, 14090 14091 // Make this explicit, since user can override this through ajaxSetup (trac-11264) 14092 type: "GET", 14093 dataType: "script", 14094 cache: true, 14095 async: false, 14096 global: false, 14097 14098 // Only evaluate the response if it is successful (gh-4126) 14099 // dataFilter is not invoked for failure responses, so using it instead 14100 // of the default converter is kludgy but it works. 14101 converters: { 14102 "text script": function() {} 14103 }, 14104 dataFilter: function( response ) { 14105 jQuery.globalEval( response, options, doc ); 14106 } 14107 } ); 14108}; 14109 14110 14111jQuery.fn.extend( { 14112 wrapAll: function( html ) { 14113 var wrap; 14114 14115 if ( this[ 0 ] ) { 14116 if ( isFunction( html ) ) { 14117 html = html.call( this[ 0 ] ); 14118 } 14119 14120 // The elements to wrap the target around 14121 wrap = jQuery( html, this[ 0 ].ownerDocument ).eq( 0 ).clone( true ); 14122 14123 if ( this[ 0 ].parentNode ) { 14124 wrap.insertBefore( this[ 0 ] ); 14125 } 14126 14127 wrap.map( function() { 14128 var elem = this; 14129 14130 while ( elem.firstElementChild ) { 14131 elem = elem.firstElementChild; 14132 } 14133 14134 return elem; 14135 } ).append( this ); 14136 } 14137 14138 return this; 14139 }, 14140 14141 wrapInner: function( html ) { 14142 if ( isFunction( html ) ) { 14143 return this.each( function( i ) { 14144 jQuery( this ).wrapInner( html.call( this, i ) ); 14145 } ); 14146 } 14147 14148 return this.each( function() { 14149 var self = jQuery( this ), 14150 contents = self.contents(); 14151 14152 if ( contents.length ) { 14153 contents.wrapAll( html ); 14154 14155 } else { 14156 self.append( html ); 14157 } 14158 } ); 14159 }, 14160 14161 wrap: function( html ) { 14162 var htmlIsFunction = isFunction( html ); 14163 14164 return this.each( function( i ) { 14165 jQuery( this ).wrapAll( htmlIsFunction ? html.call( this, i ) : html ); 14166 } ); 14167 }, 14168 14169 unwrap: function( selector ) { 14170 this.parent( selector ).not( "body" ).each( function() { 14171 jQuery( this ).replaceWith( this.childNodes ); 14172 } ); 14173 return this; 14174 } 14175} ); 14176 14177 14178jQuery.expr.pseudos.hidden = function( elem ) { 14179 return !jQuery.expr.pseudos.visible( elem ); 14180}; 14181jQuery.expr.pseudos.visible = function( elem ) { 14182 return !!( elem.offsetWidth || elem.offsetHeight || elem.getClientRects().length ); 14183}; 14184 14185 14186 14187 14188jQuery.ajaxSettings.xhr = function() { 14189 try { 14190 return new window.XMLHttpRequest(); 14191 } catch ( e ) {} 14192}; 14193 14194var xhrSuccessStatus = { 14195 14196 // File protocol always yields status code 0, assume 200 14197 0: 200, 14198 14199 // Support: IE <=9 only 14200 // trac-1450: sometimes IE returns 1223 when it should be 204 14201 1223: 204 14202 }, 14203 xhrSupported = jQuery.ajaxSettings.xhr(); 14204 14205support.cors = !!xhrSupported && ( "withCredentials" in xhrSupported ); 14206support.ajax = xhrSupported = !!xhrSupported; 14207 14208jQuery.ajaxTransport( function( options ) { 14209 var callback, errorCallback; 14210 14211 // Cross domain only allowed if supported through XMLHttpRequest 14212 if ( support.cors || xhrSupported && !options.crossDomain ) { 14213 return { 14214 send: function( headers, complete ) { 14215 var i, 14216 xhr = options.xhr(); 14217 14218 xhr.open( 14219 options.type, 14220 options.url, 14221 options.async, 14222 options.username, 14223 options.password 14224 ); 14225 14226 // Apply custom fields if provided 14227 if ( options.xhrFields ) { 14228 for ( i in options.xhrFields ) { 14229 xhr[ i ] = options.xhrFields[ i ]; 14230 } 14231 } 14232 14233 // Override mime type if needed 14234 if ( options.mimeType && xhr.overrideMimeType ) { 14235 xhr.overrideMimeType( options.mimeType ); 14236 } 14237 14238 // X-Requested-With header 14239 // For cross-domain requests, seeing as conditions for a preflight are 14240 // akin to a jigsaw puzzle, we simply never set it to be sure. 14241 // (it can always be set on a per-request basis or even using ajaxSetup) 14242 // For same-domain requests, won't change header if already provided. 14243 if ( !options.crossDomain && !headers[ "X-Requested-With" ] ) { 14244 headers[ "X-Requested-With" ] = "XMLHttpRequest"; 14245 } 14246 14247 // Set headers 14248 for ( i in headers ) { 14249 xhr.setRequestHeader( i, headers[ i ] ); 14250 } 14251 14252 // Callback 14253 callback = function( type ) { 14254 return function() { 14255 if ( callback ) { 14256 callback = errorCallback = xhr.onload = 14257 xhr.onerror = xhr.onabort = xhr.ontimeout = 14258 xhr.onreadystatechange = null; 14259 14260 if ( type === "abort" ) { 14261 xhr.abort(); 14262 } else if ( type === "error" ) { 14263 14264 // Support: IE <=9 only 14265 // On a manual native abort, IE9 throws 14266 // errors on any property access that is not readyState 14267 if ( typeof xhr.status !== "number" ) { 14268 complete( 0, "error" ); 14269 } else { 14270 complete( 14271 14272 // File: protocol always yields status 0; see trac-8605, trac-14207 14273 xhr.status, 14274 xhr.statusText 14275 ); 14276 } 14277 } else { 14278 complete( 14279 xhrSuccessStatus[ xhr.status ] || xhr.status, 14280 xhr.statusText, 14281 14282 // Support: IE <=9 only 14283 // IE9 has no XHR2 but throws on binary (trac-11426) 14284 // For XHR2 non-text, let the caller handle it (gh-2498) 14285 ( xhr.responseType || "text" ) !== "text" || 14286 typeof xhr.responseText !== "string" ? 14287 { binary: xhr.response } : 14288 { text: xhr.responseText }, 14289 xhr.getAllResponseHeaders() 14290 ); 14291 } 14292 } 14293 }; 14294 }; 14295 14296 // Listen to events 14297 xhr.onload = callback(); 14298 errorCallback = xhr.onerror = xhr.ontimeout = callback( "error" ); 14299 14300 // Support: IE 9 only 14301 // Use onreadystatechange to replace onabort 14302 // to handle uncaught aborts 14303 if ( xhr.onabort !== undefined ) { 14304 xhr.onabort = errorCallback; 14305 } else { 14306 xhr.onreadystatechange = function() { 14307 14308 // Check readyState before timeout as it changes 14309 if ( xhr.readyState === 4 ) { 14310 14311 // Allow onerror to be called first, 14312 // but that will not handle a native abort 14313 // Also, save errorCallback to a variable 14314 // as xhr.onerror cannot be accessed 14315 window.setTimeout( function() { 14316 if ( callback ) { 14317 errorCallback(); 14318 } 14319 } ); 14320 } 14321 }; 14322 } 14323 14324 // Create the abort callback 14325 callback = callback( "abort" ); 14326 14327 try { 14328 14329 // Do send the request (this may raise an exception) 14330 xhr.send( options.hasContent && options.data || null ); 14331 } catch ( e ) { 14332 14333 // trac-14683: Only rethrow if this hasn't been notified as an error yet 14334 if ( callback ) { 14335 throw e; 14336 } 14337 } 14338 }, 14339 14340 abort: function() { 14341 if ( callback ) { 14342 callback(); 14343 } 14344 } 14345 }; 14346 } 14347} ); 14348 14349 14350 14351 14352// Prevent auto-execution of scripts when no explicit dataType was provided (See gh-2432) 14353jQuery.ajaxPrefilter( function( s ) { 14354 if ( s.crossDomain ) { 14355 s.contents.script = false; 14356 } 14357} ); 14358 14359// Install script dataType 14360jQuery.ajaxSetup( { 14361 accepts: { 14362 script: "text/javascript, application/javascript, " + 14363 "application/ecmascript, application/x-ecmascript" 14364 }, 14365 contents: { 14366 script: /\b(?:java|ecma)script\b/ 14367 }, 14368 converters: { 14369 "text script": function( text ) { 14370 jQuery.globalEval( text ); 14371 return text; 14372 } 14373 } 14374} ); 14375 14376// Handle cache's special case and crossDomain 14377jQuery.ajaxPrefilter( "script", function( s ) { 14378 if ( s.cache === undefined ) { 14379 s.cache = false; 14380 } 14381 if ( s.crossDomain ) { 14382 s.type = "GET"; 14383 } 14384} ); 14385 14386// Bind script tag hack transport 14387jQuery.ajaxTransport( "script", function( s ) { 14388 14389 // This transport only deals with cross domain or forced-by-attrs requests 14390 if ( s.crossDomain || s.scriptAttrs ) { 14391 var script, callback; 14392 return { 14393 send: function( _, complete ) { 14394 script = jQuery( "<script>" ) 14395 .attr( s.scriptAttrs || {} ) 14396 .prop( { charset: s.scriptCharset, src: s.url } ) 14397 .on( "load error", callback = function( evt ) { 14398 script.remove(); 14399 callback = null; 14400 if ( evt ) { 14401 complete( evt.type === "error" ? 404 : 200, evt.type ); 14402 } 14403 } ); 14404 14405 // Use native DOM manipulation to avoid our domManip AJAX trickery 14406 document.head.appendChild( script[ 0 ] ); 14407 }, 14408 abort: function() { 14409 if ( callback ) { 14410 callback(); 14411 } 14412 } 14413 }; 14414 } 14415} ); 14416 14417 14418 14419 14420var oldCallbacks = [], 14421 rjsonp = /(=)\?(?=&|$)|\?\?/; 14422 14423// Default jsonp settings 14424jQuery.ajaxSetup( { 14425 jsonp: "callback", 14426 jsonpCallback: function() { 14427 var callback = oldCallbacks.pop() || ( jQuery.expando + "_" + ( nonce.guid++ ) ); 14428 this[ callback ] = true; 14429 return callback; 14430 } 14431} ); 14432 14433// Detect, normalize options and install callbacks for jsonp requests 14434jQuery.ajaxPrefilter( "json jsonp", function( s, originalSettings, jqXHR ) { 14435 14436 var callbackName, overwritten, responseContainer, 14437 jsonProp = s.jsonp !== false && ( rjsonp.test( s.url ) ? 14438 "url" : 14439 typeof s.data === "string" && 14440 ( s.contentType || "" ) 14441 .indexOf( "application/x-www-form-urlencoded" ) === 0 && 14442 rjsonp.test( s.data ) && "data" 14443 ); 14444 14445 // Handle iff the expected data type is "jsonp" or we have a parameter to set 14446 if ( jsonProp || s.dataTypes[ 0 ] === "jsonp" ) { 14447 14448 // Get callback name, remembering preexisting value associated with it 14449 callbackName = s.jsonpCallback = isFunction( s.jsonpCallback ) ? 14450 s.jsonpCallback() : 14451 s.jsonpCallback; 14452 14453 // Insert callback into url or form data 14454 if ( jsonProp ) { 14455 s[ jsonProp ] = s[ jsonProp ].replace( rjsonp, "$1" + callbackName ); 14456 } else if ( s.jsonp !== false ) { 14457 s.url += ( rquery.test( s.url ) ? "&" : "?" ) + s.jsonp + "=" + callbackName; 14458 } 14459 14460 // Use data converter to retrieve json after script execution 14461 s.converters[ "script json" ] = function() { 14462 if ( !responseContainer ) { 14463 jQuery.error( callbackName + " was not called" ); 14464 } 14465 return responseContainer[ 0 ]; 14466 }; 14467 14468 // Force json dataType 14469 s.dataTypes[ 0 ] = "json"; 14470 14471 // Install callback 14472 overwritten = window[ callbackName ]; 14473 window[ callbackName ] = function() { 14474 responseContainer = arguments; 14475 }; 14476 14477 // Clean-up function (fires after converters) 14478 jqXHR.always( function() { 14479 14480 // If previous value didn't exist - remove it 14481 if ( overwritten === undefined ) { 14482 jQuery( window ).removeProp( callbackName ); 14483 14484 // Otherwise restore preexisting value 14485 } else { 14486 window[ callbackName ] = overwritten; 14487 } 14488 14489 // Save back as free 14490 if ( s[ callbackName ] ) { 14491 14492 // Make sure that re-using the options doesn't screw things around 14493 s.jsonpCallback = originalSettings.jsonpCallback; 14494 14495 // Save the callback name for future use 14496 oldCallbacks.push( callbackName ); 14497 } 14498 14499 // Call if it was a function and we have a response 14500 if ( responseContainer && isFunction( overwritten ) ) { 14501 overwritten( responseContainer[ 0 ] ); 14502 } 14503 14504 responseContainer = overwritten = undefined; 14505 } ); 14506 14507 // Delegate to script 14508 return "script"; 14509 } 14510} ); 14511 14512 14513 14514 14515// Support: Safari 8 only 14516// In Safari 8 documents created via document.implementation.createHTMLDocument 14517// collapse sibling forms: the second one becomes a child of the first one. 14518// Because of that, this security measure has to be disabled in Safari 8. 14519// https://bugs.webkit.org/show_bug.cgi?id=137337 14520support.createHTMLDocument = ( function() { 14521 var body = document.implementation.createHTMLDocument( "" ).body; 14522 body.innerHTML = "<form></form><form></form>"; 14523 return body.childNodes.length === 2; 14524} )(); 14525 14526 14527// Argument "data" should be string of html 14528// context (optional): If specified, the fragment will be created in this context, 14529// defaults to document 14530// keepScripts (optional): If true, will include scripts passed in the html string 14531jQuery.parseHTML = function( data, context, keepScripts ) { 14532 if ( typeof data !== "string" ) { 14533 return []; 14534 } 14535 if ( typeof context === "boolean" ) { 14536 keepScripts = context; 14537 context = false; 14538 } 14539 14540 var base, parsed, scripts; 14541 14542 if ( !context ) { 14543 14544 // Stop scripts or inline event handlers from being executed immediately 14545 // by using document.implementation 14546 if ( support.createHTMLDocument ) { 14547 context = document.implementation.createHTMLDocument( "" ); 14548 14549 // Set the base href for the created document 14550 // so any parsed elements with URLs 14551 // are based on the document's URL (gh-2965) 14552 base = context.createElement( "base" ); 14553 base.href = document.location.href; 14554 context.head.appendChild( base ); 14555 } else { 14556 context = document; 14557 } 14558 } 14559 14560 parsed = rsingleTag.exec( data ); 14561 scripts = !keepScripts && []; 14562 14563 // Single tag 14564 if ( parsed ) { 14565 return [ context.createElement( parsed[ 1 ] ) ]; 14566 } 14567 14568 parsed = buildFragment( [ data ], context, scripts ); 14569 14570 if ( scripts && scripts.length ) { 14571 jQuery( scripts ).remove(); 14572 } 14573 14574 return jQuery.merge( [], parsed.childNodes ); 14575}; 14576 14577 14578/** 14579 * Load a url into a page 14580 */ 14581jQuery.fn.load = function( url, params, callback ) { 14582 var selector, type, response, 14583 self = this, 14584 off = url.indexOf( " " ); 14585 14586 if ( off > -1 ) { 14587 selector = stripAndCollapse( url.slice( off ) ); 14588 url = url.slice( 0, off ); 14589 } 14590 14591 // If it's a function 14592 if ( isFunction( params ) ) { 14593 14594 // We assume that it's the callback 14595 callback = params; 14596 params = undefined; 14597 14598 // Otherwise, build a param string 14599 } else if ( params && typeof params === "object" ) { 14600 type = "POST"; 14601 } 14602 14603 // If we have elements to modify, make the request 14604 if ( self.length > 0 ) { 14605 jQuery.ajax( { 14606 url: url, 14607 14608 // If "type" variable is undefined, then "GET" method will be used. 14609 // Make value of this field explicit since 14610 // user can override it through ajaxSetup method 14611 type: type || "GET", 14612 dataType: "html", 14613 data: params 14614 } ).done( function( responseText ) { 14615 14616 // Save response for use in complete callback 14617 response = arguments; 14618 14619 self.html( selector ? 14620 14621 // If a selector was specified, locate the right elements in a dummy div 14622 // Exclude scripts to avoid IE 'Permission Denied' errors 14623 jQuery( "<div>" ).append( jQuery.parseHTML( responseText ) ).find( selector ) : 14624 14625 // Otherwise use the full result 14626 responseText ); 14627 14628 // If the request succeeds, this function gets "data", "status", "jqXHR" 14629 // but they are ignored because response was set above. 14630 // If it fails, this function gets "jqXHR", "status", "error" 14631 } ).always( callback && function( jqXHR, status ) { 14632 self.each( function() { 14633 callback.apply( this, response || [ jqXHR.responseText, status, jqXHR ] ); 14634 } ); 14635 } ); 14636 } 14637 14638 return this; 14639}; 14640 14641 14642 14643 14644jQuery.expr.pseudos.animated = function( elem ) { 14645 return jQuery.grep( jQuery.timers, function( fn ) { 14646 return elem === fn.elem; 14647 } ).length; 14648}; 14649 14650 14651 14652 14653jQuery.offset = { 14654 setOffset: function( elem, options, i ) { 14655 var curPosition, curLeft, curCSSTop, curTop, curOffset, curCSSLeft, calculatePosition, 14656 position = jQuery.css( elem, "position" ), 14657 curElem = jQuery( elem ), 14658 props = {}; 14659 14660 // Set position first, in-case top/left are set even on static elem 14661 if ( position === "static" ) { 14662 elem.style.position = "relative"; 14663 } 14664 14665 curOffset = curElem.offset(); 14666 curCSSTop = jQuery.css( elem, "top" ); 14667 curCSSLeft = jQuery.css( elem, "left" ); 14668 calculatePosition = ( position === "absolute" || position === "fixed" ) && 14669 ( curCSSTop + curCSSLeft ).indexOf( "auto" ) > -1; 14670 14671 // Need to be able to calculate position if either 14672 // top or left is auto and position is either absolute or fixed 14673 if ( calculatePosition ) { 14674 curPosition = curElem.position(); 14675 curTop = curPosition.top; 14676 curLeft = curPosition.left; 14677 14678 } else { 14679 curTop = parseFloat( curCSSTop ) || 0; 14680 curLeft = parseFloat( curCSSLeft ) || 0; 14681 } 14682 14683 if ( isFunction( options ) ) { 14684 14685 // Use jQuery.extend here to allow modification of coordinates argument (gh-1848) 14686 options = options.call( elem, i, jQuery.extend( {}, curOffset ) ); 14687 } 14688 14689 if ( options.top != null ) { 14690 props.top = ( options.top - curOffset.top ) + curTop; 14691 } 14692 if ( options.left != null ) { 14693 props.left = ( options.left - curOffset.left ) + curLeft; 14694 } 14695 14696 if ( "using" in options ) { 14697 options.using.call( elem, props ); 14698 14699 } else { 14700 curElem.css( props ); 14701 } 14702 } 14703}; 14704 14705jQuery.fn.extend( { 14706 14707 // offset() relates an element's border box to the document origin 14708 offset: function( options ) { 14709 14710 // Preserve chaining for setter 14711 if ( arguments.length ) { 14712 return options === undefined ? 14713 this : 14714 this.each( function( i ) { 14715 jQuery.offset.setOffset( this, options, i ); 14716 } ); 14717 } 14718 14719 var rect, win, 14720 elem = this[ 0 ]; 14721 14722 if ( !elem ) { 14723 return; 14724 } 14725 14726 // Return zeros for disconnected and hidden (display: none) elements (gh-2310) 14727 // Support: IE <=11 only 14728 // Running getBoundingClientRect on a 14729 // disconnected node in IE throws an error 14730 if ( !elem.getClientRects().length ) { 14731 return { top: 0, left: 0 }; 14732 } 14733 14734 // Get document-relative position by adding viewport scroll to viewport-relative gBCR 14735 rect = elem.getBoundingClientRect(); 14736 win = elem.ownerDocument.defaultView; 14737 return { 14738 top: rect.top + win.pageYOffset, 14739 left: rect.left + win.pageXOffset 14740 }; 14741 }, 14742 14743 // position() relates an element's margin box to its offset parent's padding box 14744 // This corresponds to the behavior of CSS absolute positioning 14745 position: function() { 14746 if ( !this[ 0 ] ) { 14747 return; 14748 } 14749 14750 var offsetParent, offset, doc, 14751 elem = this[ 0 ], 14752 parentOffset = { top: 0, left: 0 }; 14753 14754 // position:fixed elements are offset from the viewport, which itself always has zero offset 14755 if ( jQuery.css( elem, "position" ) === "fixed" ) { 14756 14757 // Assume position:fixed implies availability of getBoundingClientRect 14758 offset = elem.getBoundingClientRect(); 14759 14760 } else { 14761 offset = this.offset(); 14762 14763 // Account for the *real* offset parent, which can be the document or its root element 14764 // when a statically positioned element is identified 14765 doc = elem.ownerDocument; 14766 offsetParent = elem.offsetParent || doc.documentElement; 14767 while ( offsetParent && 14768 ( offsetParent === doc.body || offsetParent === doc.documentElement ) && 14769 jQuery.css( offsetParent, "position" ) === "static" ) { 14770 14771 offsetParent = offsetParent.parentNode; 14772 } 14773 if ( offsetParent && offsetParent !== elem && offsetParent.nodeType === 1 ) { 14774 14775 // Incorporate borders into its offset, since they are outside its content origin 14776 parentOffset = jQuery( offsetParent ).offset(); 14777 parentOffset.top += jQuery.css( offsetParent, "borderTopWidth", true ); 14778 parentOffset.left += jQuery.css( offsetParent, "borderLeftWidth", true ); 14779 } 14780 } 14781 14782 // Subtract parent offsets and element margins 14783 return { 14784 top: offset.top - parentOffset.top - jQuery.css( elem, "marginTop", true ), 14785 left: offset.left - parentOffset.left - jQuery.css( elem, "marginLeft", true ) 14786 }; 14787 }, 14788 14789 // This method will return documentElement in the following cases: 14790 // 1) For the element inside the iframe without offsetParent, this method will return 14791 // documentElement of the parent window 14792 // 2) For the hidden or detached element 14793 // 3) For body or html element, i.e. in case of the html node - it will return itself 14794 // 14795 // but those exceptions were never presented as a real life use-cases 14796 // and might be considered as more preferable results. 14797 // 14798 // This logic, however, is not guaranteed and can change at any point in the future 14799 offsetParent: function() { 14800 return this.map( function() { 14801 var offsetParent = this.offsetParent; 14802 14803 while ( offsetParent && jQuery.css( offsetParent, "position" ) === "static" ) { 14804 offsetParent = offsetParent.offsetParent; 14805 } 14806 14807 return offsetParent || documentElement; 14808 } ); 14809 } 14810} ); 14811 14812// Create scrollLeft and scrollTop methods 14813jQuery.each( { scrollLeft: "pageXOffset", scrollTop: "pageYOffset" }, function( method, prop ) { 14814 var top = "pageYOffset" === prop; 14815 14816 jQuery.fn[ method ] = function( val ) { 14817 return access( this, function( elem, method, val ) { 14818 14819 // Coalesce documents and windows 14820 var win; 14821 if ( isWindow( elem ) ) { 14822 win = elem; 14823 } else if ( elem.nodeType === 9 ) { 14824 win = elem.defaultView; 14825 } 14826 14827 if ( val === undefined ) { 14828 return win ? win[ prop ] : elem[ method ]; 14829 } 14830 14831 if ( win ) { 14832 win.scrollTo( 14833 !top ? val : win.pageXOffset, 14834 top ? val : win.pageYOffset 14835 ); 14836 14837 } else { 14838 elem[ method ] = val; 14839 } 14840 }, method, val, arguments.length ); 14841 }; 14842} ); 14843 14844// Support: Safari <=7 - 9.1, Chrome <=37 - 49 14845// Add the top/left cssHooks using jQuery.fn.position 14846// Webkit bug: https://bugs.webkit.org/show_bug.cgi?id=29084 14847// Blink bug: https://bugs.chromium.org/p/chromium/issues/detail?id=589347 14848// getComputedStyle returns percent when specified for top/left/bottom/right; 14849// rather than make the css module depend on the offset module, just check for it here 14850jQuery.each( [ "top", "left" ], function( _i, prop ) { 14851 jQuery.cssHooks[ prop ] = addGetHookIf( support.pixelPosition, 14852 function( elem, computed ) { 14853 if ( computed ) { 14854 computed = curCSS( elem, prop ); 14855 14856 // If curCSS returns percentage, fallback to offset 14857 return rnumnonpx.test( computed ) ? 14858 jQuery( elem ).position()[ prop ] + "px" : 14859 computed; 14860 } 14861 } 14862 ); 14863} ); 14864 14865 14866// Create innerHeight, innerWidth, height, width, outerHeight and outerWidth methods 14867jQuery.each( { Height: "height", Width: "width" }, function( name, type ) { 14868 jQuery.each( { 14869 padding: "inner" + name, 14870 content: type, 14871 "": "outer" + name 14872 }, function( defaultExtra, funcName ) { 14873 14874 // Margin is only for outerHeight, outerWidth 14875 jQuery.fn[ funcName ] = function( margin, value ) { 14876 var chainable = arguments.length && ( defaultExtra || typeof margin !== "boolean" ), 14877 extra = defaultExtra || ( margin === true || value === true ? "margin" : "border" ); 14878 14879 return access( this, function( elem, type, value ) { 14880 var doc; 14881 14882 if ( isWindow( elem ) ) { 14883 14884 // $( window ).outerWidth/Height return w/h including scrollbars (gh-1729) 14885 return funcName.indexOf( "outer" ) === 0 ? 14886 elem[ "inner" + name ] : 14887 elem.document.documentElement[ "client" + name ]; 14888 } 14889 14890 // Get document width or height 14891 if ( elem.nodeType === 9 ) { 14892 doc = elem.documentElement; 14893 14894 // Either scroll[Width/Height] or offset[Width/Height] or client[Width/Height], 14895 // whichever is greatest 14896 return Math.max( 14897 elem.body[ "scroll" + name ], doc[ "scroll" + name ], 14898 elem.body[ "offset" + name ], doc[ "offset" + name ], 14899 doc[ "client" + name ] 14900 ); 14901 } 14902 14903 return value === undefined ? 14904 14905 // Get width or height on the element, requesting but not forcing parseFloat 14906 jQuery.css( elem, type, extra ) : 14907 14908 // Set width or height on the element 14909 jQuery.style( elem, type, value, extra ); 14910 }, type, chainable ? margin : undefined, chainable ); 14911 }; 14912 } ); 14913} ); 14914 14915 14916jQuery.each( [ 14917 "ajaxStart", 14918 "ajaxStop", 14919 "ajaxComplete", 14920 "ajaxError", 14921 "ajaxSuccess", 14922 "ajaxSend" 14923], function( _i, type ) { 14924 jQuery.fn[ type ] = function( fn ) { 14925 return this.on( type, fn ); 14926 }; 14927} ); 14928 14929 14930 14931 14932jQuery.fn.extend( { 14933 14934 bind: function( types, data, fn ) { 14935 return this.on( types, null, data, fn ); 14936 }, 14937 unbind: function( types, fn ) { 14938 return this.off( types, null, fn ); 14939 }, 14940 14941 delegate: function( selector, types, data, fn ) { 14942 return this.on( types, selector, data, fn ); 14943 }, 14944 undelegate: function( selector, types, fn ) { 14945 14946 // ( namespace ) or ( selector, types [, fn] ) 14947 return arguments.length === 1 ? 14948 this.off( selector, "**" ) : 14949 this.off( types, selector || "**", fn ); 14950 }, 14951 14952 hover: function( fnOver, fnOut ) { 14953 return this 14954 .on( "mouseenter", fnOver ) 14955 .on( "mouseleave", fnOut || fnOver ); 14956 } 14957} ); 14958 14959jQuery.each( 14960 ( "blur focus focusin focusout resize scroll click dblclick " + 14961 "mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave " + 14962 "change select submit keydown keypress keyup contextmenu" ).split( " " ), 14963 function( _i, name ) { 14964 14965 // Handle event binding 14966 jQuery.fn[ name ] = function( data, fn ) { 14967 return arguments.length > 0 ? 14968 this.on( name, null, data, fn ) : 14969 this.trigger( name ); 14970 }; 14971 } 14972); 14973 14974 14975 14976 14977// Support: Android <=4.0 only 14978// Make sure we trim BOM and NBSP 14979// Require that the "whitespace run" starts from a non-whitespace 14980// to avoid O(N^2) behavior when the engine would try matching "\s+$" at each space position. 14981var rtrim = /^[\s\uFEFF\xA0]+|([^\s\uFEFF\xA0])[\s\uFEFF\xA0]+$/g; 14982 14983// Bind a function to a context, optionally partially applying any 14984// arguments. 14985// jQuery.proxy is deprecated to promote standards (specifically Function#bind) 14986// However, it is not slated for removal any time soon 14987jQuery.proxy = function( fn, context ) { 14988 var tmp, args, proxy; 14989 14990 if ( typeof context === "string" ) { 14991 tmp = fn[ context ]; 14992 context = fn; 14993 fn = tmp; 14994 } 14995 14996 // Quick check to determine if target is callable, in the spec 14997 // this throws a TypeError, but we will just return undefined. 14998 if ( !isFunction( fn ) ) { 14999 return undefined; 15000 } 15001 15002 // Simulated bind 15003 args = slice.call( arguments, 2 ); 15004 proxy = function() { 15005 return fn.apply( context || this, args.concat( slice.call( arguments ) ) ); 15006 }; 15007 15008 // Set the guid of unique handler to the same of original handler, so it can be removed 15009 proxy.guid = fn.guid = fn.guid || jQuery.guid++; 15010 15011 return proxy; 15012}; 15013 15014jQuery.holdReady = function( hold ) { 15015 if ( hold ) { 15016 jQuery.readyWait++; 15017 } else { 15018 jQuery.ready( true ); 15019 } 15020}; 15021jQuery.isArray = Array.isArray; 15022jQuery.parseJSON = JSON.parse; 15023jQuery.nodeName = nodeName; 15024jQuery.isFunction = isFunction; 15025jQuery.isWindow = isWindow; 15026jQuery.camelCase = camelCase; 15027jQuery.type = toType; 15028 15029jQuery.now = Date.now; 15030 15031jQuery.isNumeric = function( obj ) { 15032 15033 // As of jQuery 3.0, isNumeric is limited to 15034 // strings and numbers (primitives or objects) 15035 // that can be coerced to finite numbers (gh-2662) 15036 var type = jQuery.type( obj ); 15037 return ( type === "number" || type === "string" ) && 15038 15039 // parseFloat NaNs numeric-cast false positives ("") 15040 // ...but misinterprets leading-number strings, particularly hex literals ("0x...") 15041 // subtraction forces infinities to NaN 15042 !isNaN( obj - parseFloat( obj ) ); 15043}; 15044 15045jQuery.trim = function( text ) { 15046 return text == null ? 15047 "" : 15048 ( text + "" ).replace( rtrim, "$1" ); 15049}; 15050 15051 15052 15053// Register as a named AMD module, since jQuery can be concatenated with other 15054// files that may use define, but not via a proper concatenation script that 15055// understands anonymous AMD modules. A named AMD is safest and most robust 15056// way to register. Lowercase jquery is used because AMD module names are 15057// derived from file names, and jQuery is normally delivered in a lowercase 15058// file name. Do this after creating the global so that if an AMD module wants 15059// to call noConflict to hide this version of jQuery, it will work. 15060 15061// Note that for maximum portability, libraries that are not jQuery should 15062// declare themselves as anonymous modules, and avoid setting a global if an 15063// AMD loader is present. jQuery is a special case. For more information, see 15064// https://github.com/jrburke/requirejs/wiki/Updating-existing-libraries#wiki-anon 15065 15066if ( true ) { 15067 !(__WEBPACK_AMD_DEFINE_ARRAY__ = [], __WEBPACK_AMD_DEFINE_RESULT__ = (function() { 15068 return jQuery; 15069 }).apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__), 15070 __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__)); 15071} 15072 15073 15074 15075 15076var 15077 15078 // Map over jQuery in case of overwrite 15079 _jQuery = window.jQuery, 15080 15081 // Map over the $ in case of overwrite 15082 _$ = window.$; 15083 15084jQuery.noConflict = function( deep ) { 15085 if ( window.$ === jQuery ) { 15086 window.$ = _$; 15087 } 15088 15089 if ( deep && window.jQuery === jQuery ) { 15090 window.jQuery = _jQuery; 15091 } 15092 15093 return jQuery; 15094}; 15095 15096// Expose jQuery and $ identifiers, even in AMD 15097// (trac-7102#comment:10, https://github.com/jquery/jquery/pull/557) 15098// and CommonJS for browser emulators (trac-13566) 15099if ( typeof noGlobal === "undefined" ) { 15100 window.jQuery = window.$ = jQuery; 15101} 15102 15103 15104 15105 15106return jQuery; 15107} ); 15108 15109 15110/***/ }), 15111
15112/***/ "./apps/birta_cms/static/sass/main.scss": 15113/*!**********************************************!*\ 15114 !*** ./apps/birta_cms/static/sass/main.scss ***! 15115 \**********************************************/ 15116/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { 15117 15118"use strict"; 15119__webpack_require__.r(__webpack_exports__); 15120// extracted by mini-css-extract-plugin 15121 15122 15123/***/ }), 15124
vendor: 89,096 bytes, lines 15125-17755
15125/***/ "./node_modules/popper.js/dist/esm/popper.js": 15126/*!***************************************************!*\ 15127 !*** ./node_modules/popper.js/dist/esm/popper.js ***! 15128 \***************************************************/ 15129/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { 15130 15131"use strict"; 15132__webpack_require__.r(__webpack_exports__); 15133/* harmony export */ __webpack_require__.d(__webpack_exports__, { 15134/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) 15135/* harmony export */ }); 15136/**! 15137 * @fileOverview Kickass library to create and place poppers near their reference elements. 15138 * @version 1.16.1 15139 * @license 15140 * Copyright (c) 2016 Federico Zivolo and contributors 15141 * 15142 * Permission is hereby granted, free of charge, to any person obtaining a copy 15143 * of this software and associated documentation files (the "Software"), to deal 15144 * in the Software without restriction, including without limitation the rights 15145 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 15146 * copies of the Software, and to permit persons to whom the Software is 15147 * furnished to do so, subject to the following conditions: 15148 * 15149 * The above copyright notice and this permission notice shall be included in all 15150 * copies or substantial portions of the Software. 15151 * 15152 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 15153 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 15154 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 15155 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 15156 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 15157 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 15158 * SOFTWARE. 15159 */ 15160var isBrowser = typeof window !== 'undefined' && typeof document !== 'undefined' && typeof navigator !== 'undefined'; 15161 15162var timeoutDuration = function () { 15163 var longerTimeoutBrowsers = ['Edge', 'Trident', 'Firefox']; 15164 for (var i = 0; i < longerTimeoutBrowsers.length; i += 1) { 15165 if (isBrowser && navigator.userAgent.indexOf(longerTimeoutBrowsers[i]) >= 0) { 15166 return 1; 15167 } 15168 } 15169 return 0; 15170}(); 15171 15172function microtaskDebounce(fn) { 15173 var called = false; 15174 return function () { 15175 if (called) { 15176 return; 15177 } 15178 called = true; 15179 window.Promise.resolve().then(function () { 15180 called = false; 15181 fn(); 15182 }); 15183 }; 15184} 15185 15186function taskDebounce(fn) { 15187 var scheduled = false; 15188 return function () { 15189 if (!scheduled) { 15190 scheduled = true; 15191 setTimeout(function () { 15192 scheduled = false; 15193 fn(); 15194 }, timeoutDuration); 15195 } 15196 }; 15197} 15198 15199var supportsMicroTasks = isBrowser && window.Promise; 15200 15201/** 15202* Create a debounced version of a method, that's asynchronously deferred 15203* but called in the minimum time possible. 15204* 15205* @method 15206* @memberof Popper.Utils 15207* @argument {Function} fn 15208* @returns {Function} 15209*/ 15210var debounce = supportsMicroTasks ? microtaskDebounce : taskDebounce; 15211 15212/** 15213 * Check if the given variable is a function 15214 * @method 15215 * @memberof Popper.Utils 15216 * @argument {Any} functionToCheck - variable to check 15217 * @returns {Boolean} answer to: is a function? 15218 */ 15219function isFunction(functionToCheck) { 15220 var getType = {}; 15221 return functionToCheck && getType.toString.call(functionToCheck) === '[object Function]'; 15222} 15223 15224/** 15225 * Get CSS computed property of the given element 15226 * @method 15227 * @memberof Popper.Utils 15228 * @argument {Eement} element 15229 * @argument {String} property 15230 */ 15231function getStyleComputedProperty(element, property) { 15232 if (element.nodeType !== 1) { 15233 return []; 15234 } 15235 // NOTE: 1 DOM access here 15236 var window = element.ownerDocument.defaultView; 15237 var css = window.getComputedStyle(element, null); 15238 return property ? css[property] : css; 15239} 15240 15241/** 15242 * Returns the parentNode or the host of the element 15243 * @method 15244 * @memberof Popper.Utils 15245 * @argument {Element} element 15246 * @returns {Element} parent 15247 */ 15248function getParentNode(element) { 15249 if (element.nodeName === 'HTML') { 15250 return element; 15251 } 15252 return element.parentNode || element.host; 15253} 15254 15255/** 15256 * Returns the scrolling parent of the given element 15257 * @method 15258 * @memberof Popper.Utils 15259 * @argument {Element} element 15260 * @returns {Element} scroll parent 15261 */ 15262function getScrollParent(element) { 15263 // Return body, `getScroll` will take care to get the correct `scrollTop` from it 15264 if (!element) { 15265 return document.body; 15266 } 15267 15268 switch (element.nodeName) { 15269 case 'HTML': 15270 case 'BODY': 15271 return element.ownerDocument.body; 15272 case '#document': 15273 return element.body; 15274 } 15275 15276 // Firefox want us to check `-x` and `-y` variations as well 15277 15278 var _getStyleComputedProp = getStyleComputedProperty(element), 15279 overflow = _getStyleComputedProp.overflow, 15280 overflowX = _getStyleComputedProp.overflowX, 15281 overflowY = _getStyleComputedProp.overflowY; 15282 15283 if (/(auto|scroll|overlay)/.test(overflow + overflowY + overflowX)) { 15284 return element; 15285 } 15286 15287 return getScrollParent(getParentNode(element)); 15288} 15289 15290/** 15291 * Returns the reference node of the reference object, or the reference object itself. 15292 * @method 15293 * @memberof Popper.Utils 15294 * @param {Element|Object} reference - the reference element (the popper will be relative to this) 15295 * @returns {Element} parent 15296 */ 15297function getReferenceNode(reference) { 15298 return reference && reference.referenceNode ? reference.referenceNode : reference; 15299} 15300 15301var isIE11 = isBrowser && !!(window.MSInputMethodContext && document.documentMode); 15302var isIE10 = isBrowser && /MSIE 10/.test(navigator.userAgent); 15303 15304/** 15305 * Determines if the browser is Internet Explorer 15306 * @method 15307 * @memberof Popper.Utils 15308 * @param {Number} version to check 15309 * @returns {Boolean} isIE 15310 */ 15311function isIE(version) { 15312 if (version === 11) { 15313 return isIE11; 15314 } 15315 if (version === 10) { 15316 return isIE10; 15317 } 15318 return isIE11 || isIE10; 15319} 15320 15321/** 15322 * Returns the offset parent of the given element 15323 * @method 15324 * @memberof Popper.Utils 15325 * @argument {Element} element 15326 * @returns {Element} offset parent 15327 */ 15328function getOffsetParent(element) { 15329 if (!element) { 15330 return document.documentElement; 15331 } 15332 15333 var noOffsetParent = isIE(10) ? document.body : null; 15334 15335 // NOTE: 1 DOM access here 15336 var offsetParent = element.offsetParent || null; 15337 // Skip hidden elements which don't have an offsetParent 15338 while (offsetParent === noOffsetParent && element.nextElementSibling) { 15339 offsetParent = (element = element.nextElementSibling).offsetParent; 15340 } 15341 15342 var nodeName = offsetParent && offsetParent.nodeName; 15343 15344 if (!nodeName || nodeName === 'BODY' || nodeName === 'HTML') { 15345 return element ? element.ownerDocument.documentElement : document.documentElement; 15346 } 15347 15348 // .offsetParent will return the closest TH, TD or TABLE in case 15349 // no offsetParent is present, I hate this job... 15350 if (['TH', 'TD', 'TABLE'].indexOf(offsetParent.nodeName) !== -1 && getStyleComputedProperty(offsetParent, 'position') === 'static') { 15351 return getOffsetParent(offsetParent); 15352 } 15353 15354 return offsetParent; 15355} 15356 15357function isOffsetContainer(element) { 15358 var nodeName = element.nodeName; 15359 15360 if (nodeName === 'BODY') { 15361 return false; 15362 } 15363 return nodeName === 'HTML' || getOffsetParent(element.firstElementChild) === element; 15364} 15365 15366/** 15367 * Finds the root node (document, shadowDOM root) of the given element 15368 * @method 15369 * @memberof Popper.Utils 15370 * @argument {Element} node 15371 * @returns {Element} root node 15372 */ 15373function getRoot(node) { 15374 if (node.parentNode !== null) { 15375 return getRoot(node.parentNode); 15376 } 15377 15378 return node; 15379} 15380 15381/** 15382 * Finds the offset parent common to the two provided nodes 15383 * @method 15384 * @memberof Popper.Utils 15385 * @argument {Element} element1 15386 * @argument {Element} element2 15387 * @returns {Element} common offset parent 15388 */ 15389function findCommonOffsetParent(element1, element2) { 15390 // This check is needed to avoid errors in case one of the elements isn't defined for any reason 15391 if (!element1 || !element1.nodeType || !element2 || !element2.nodeType) { 15392 return document.documentElement; 15393 } 15394 15395 // Here we make sure to give as "start" the element that comes first in the DOM 15396 var order = element1.compareDocumentPosition(element2) & Node.DOCUMENT_POSITION_FOLLOWING; 15397 var start = order ? element1 : element2; 15398 var end = order ? element2 : element1; 15399 15400 // Get common ancestor container 15401 var range = document.createRange(); 15402 range.setStart(start, 0); 15403 range.setEnd(end, 0); 15404 var commonAncestorContainer = range.commonAncestorContainer; 15405 15406 // Both nodes are inside #document 15407 15408 if (element1 !== commonAncestorContainer && element2 !== commonAncestorContainer || start.contains(end)) { 15409 if (isOffsetContainer(commonAncestorContainer)) { 15410 return commonAncestorContainer; 15411 } 15412 15413 return getOffsetParent(commonAncestorContainer); 15414 } 15415 15416 // one of the nodes is inside shadowDOM, find which one 15417 var element1root = getRoot(element1); 15418 if (element1root.host) { 15419 return findCommonOffsetParent(element1root.host, element2); 15420 } else { 15421 return findCommonOffsetParent(element1, getRoot(element2).host); 15422 } 15423} 15424 15425/** 15426 * Gets the scroll value of the given element in the given side (top and left) 15427 * @method 15428 * @memberof Popper.Utils 15429 * @argument {Element} element 15430 * @argument {String} side `top` or `left` 15431 * @returns {number} amount of scrolled pixels 15432 */ 15433function getScroll(element) { 15434 var side = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'top'; 15435 15436 var upperSide = side === 'top' ? 'scrollTop' : 'scrollLeft'; 15437 var nodeName = element.nodeName; 15438 15439 if (nodeName === 'BODY' || nodeName === 'HTML') { 15440 var html = element.ownerDocument.documentElement; 15441 var scrollingElement = element.ownerDocument.scrollingElement || html; 15442 return scrollingElement[upperSide]; 15443 } 15444 15445 return element[upperSide]; 15446} 15447 15448/* 15449 * Sum or subtract the element scroll values (left and top) from a given rect object 15450 * @method 15451 * @memberof Popper.Utils 15452 * @param {Object} rect - Rect object you want to change 15453 * @param {HTMLElement} element - The element from the function reads the scroll values 15454 * @param {Boolean} subtract - set to true if you want to subtract the scroll values 15455 * @return {Object} rect - The modifier rect object 15456 */ 15457function includeScroll(rect, element) { 15458 var subtract = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false; 15459 15460 var scrollTop = getScroll(element, 'top'); 15461 var scrollLeft = getScroll(element, 'left'); 15462 var modifier = subtract ? -1 : 1; 15463 rect.top += scrollTop * modifier; 15464 rect.bottom += scrollTop * modifier; 15465 rect.left += scrollLeft * modifier; 15466 rect.right += scrollLeft * modifier; 15467 return rect; 15468} 15469 15470/* 15471 * Helper to detect borders of a given element 15472 * @method 15473 * @memberof Popper.Utils 15474 * @param {CSSStyleDeclaration} styles 15475 * Result of `getStyleComputedProperty` on the given element 15476 * @param {String} axis - `x` or `y` 15477 * @return {number} borders - The borders size of the given axis 15478 */ 15479 15480function getBordersSize(styles, axis) { 15481 var sideA = axis === 'x' ? 'Left' : 'Top'; 15482 var sideB = sideA === 'Left' ? 'Right' : 'Bottom'; 15483 15484 return parseFloat(styles['border' + sideA + 'Width']) + parseFloat(styles['border' + sideB + 'Width']); 15485} 15486 15487function getSize(axis, body, html, computedStyle) { 15488 return Math.max(body['offset' + axis], body['scroll' + axis], html['client' + axis], html['offset' + axis], html['scroll' + axis], isIE(10) ? parseInt(html['offset' + axis]) + parseInt(computedStyle['margin' + (axis === 'Height' ? 'Top' : 'Left')]) + parseInt(computedStyle['margin' + (axis === 'Height' ? 'Bottom' : 'Right')]) : 0); 15489} 15490 15491function getWindowSizes(document) { 15492 var body = document.body; 15493 var html = document.documentElement; 15494 var computedStyle = isIE(10) && getComputedStyle(html); 15495 15496 return { 15497 height: getSize('Height', body, html, computedStyle), 15498 width: getSize('Width', body, html, computedStyle) 15499 }; 15500} 15501 15502var classCallCheck = function (instance, Constructor) { 15503 if (!(instance instanceof Constructor)) { 15504 throw new TypeError("Cannot call a class as a function"); 15505 } 15506}; 15507 15508var createClass = function () { 15509 function defineProperties(target, props) { 15510 for (var i = 0; i < props.length; i++) { 15511 var descriptor = props[i]; 15512 descriptor.enumerable = descriptor.enumerable || false; 15513 descriptor.configurable = true; 15514 if ("value" in descriptor) descriptor.writable = true; 15515 Object.defineProperty(target, descriptor.key, descriptor); 15516 } 15517 } 15518 15519 return function (Constructor, protoProps, staticProps) { 15520 if (protoProps) defineProperties(Constructor.prototype, protoProps); 15521 if (staticProps) defineProperties(Constructor, staticProps); 15522 return Constructor; 15523 }; 15524}(); 15525 15526 15527 15528 15529 15530var defineProperty = function (obj, key, value) { 15531 if (key in obj) { 15532 Object.defineProperty(obj, key, { 15533 value: value, 15534 enumerable: true, 15535 configurable: true, 15536 writable: true 15537 }); 15538 } else { 15539 obj[key] = value; 15540 } 15541 15542 return obj; 15543}; 15544 15545var _extends = Object.assign || function (target) { 15546 for (var i = 1; i < arguments.length; i++) { 15547 var source = arguments[i]; 15548 15549 for (var key in source) { 15550 if (Object.prototype.hasOwnProperty.call(source, key)) { 15551 target[key] = source[key]; 15552 } 15553 } 15554 } 15555 15556 return target; 15557}; 15558 15559/** 15560 * Given element offsets, generate an output similar to getBoundingClientRect 15561 * @method 15562 * @memberof Popper.Utils 15563 * @argument {Object} offsets 15564 * @returns {Object} ClientRect like output 15565 */ 15566function getClientRect(offsets) { 15567 return _extends({}, offsets, { 15568 right: offsets.left + offsets.width, 15569 bottom: offsets.top + offsets.height 15570 }); 15571} 15572 15573/** 15574 * Get bounding client rect of given element 15575 * @method 15576 * @memberof Popper.Utils 15577 * @param {HTMLElement} element 15578 * @return {Object} client rect 15579 */ 15580function getBoundingClientRect(element) { 15581 var rect = {}; 15582 15583 // IE10 10 FIX: Please, don't ask, the element isn't 15584 // considered in DOM in some circumstances... 15585 // This isn't reproducible in IE10 compatibility mode of IE11 15586 try { 15587 if (isIE(10)) { 15588 rect = element.getBoundingClientRect(); 15589 var scrollTop = getScroll(element, 'top'); 15590 var scrollLeft = getScroll(element, 'left'); 15591 rect.top += scrollTop; 15592 rect.left += scrollLeft; 15593 rect.bottom += scrollTop; 15594 rect.right += scrollLeft; 15595 } else { 15596 rect = element.getBoundingClientRect(); 15597 } 15598 } catch (e) {} 15599 15600 var result = { 15601 left: rect.left, 15602 top: rect.top, 15603 width: rect.right - rect.left, 15604 height: rect.bottom - rect.top 15605 }; 15606 15607 // subtract scrollbar size from sizes 15608 var sizes = element.nodeName === 'HTML' ? getWindowSizes(element.ownerDocument) : {}; 15609 var width = sizes.width || element.clientWidth || result.width; 15610 var height = sizes.height || element.clientHeight || result.height; 15611 15612 var horizScrollbar = element.offsetWidth - width; 15613 var vertScrollbar = element.offsetHeight - height; 15614 15615 // if an hypothetical scrollbar is detected, we must be sure it's not a `border` 15616 // we make this check conditional for performance reasons 15617 if (horizScrollbar || vertScrollbar) { 15618 var styles = getStyleComputedProperty(element); 15619 horizScrollbar -= getBordersSize(styles, 'x'); 15620 vertScrollbar -= getBordersSize(styles, 'y'); 15621 15622 result.width -= horizScrollbar; 15623 result.height -= vertScrollbar; 15624 } 15625 15626 return getClientRect(result); 15627} 15628 15629function getOffsetRectRelativeToArbitraryNode(children, parent) { 15630 var fixedPosition = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false; 15631 15632 var isIE10 = isIE(10); 15633 var isHTML = parent.nodeName === 'HTML'; 15634 var childrenRect = getBoundingClientRect(children); 15635 var parentRect = getBoundingClientRect(parent); 15636 var scrollParent = getScrollParent(children); 15637 15638 var styles = getStyleComputedProperty(parent); 15639 var borderTopWidth = parseFloat(styles.borderTopWidth); 15640 var borderLeftWidth = parseFloat(styles.borderLeftWidth); 15641 15642 // In cases where the parent is fixed, we must ignore negative scroll in offset calc 15643 if (fixedPosition && isHTML) { 15644 parentRect.top = Math.max(parentRect.top, 0); 15645 parentRect.left = Math.max(parentRect.left, 0); 15646 } 15647 var offsets = getClientRect({ 15648 top: childrenRect.top - parentRect.top - borderTopWidth, 15649 left: childrenRect.left - parentRect.left - borderLeftWidth, 15650 width: childrenRect.width, 15651 height: childrenRect.height 15652 }); 15653 offsets.marginTop = 0; 15654 offsets.marginLeft = 0; 15655 15656 // Subtract margins of documentElement in case it's being used as parent 15657 // we do this only on HTML because it's the only element that behaves 15658 // differently when margins are applied to it. The margins are included in 15659 // the box of the documentElement, in the other cases not. 15660 if (!isIE10 && isHTML) { 15661 var marginTop = parseFloat(styles.marginTop); 15662 var marginLeft = parseFloat(styles.marginLeft); 15663 15664 offsets.top -= borderTopWidth - marginTop; 15665 offsets.bottom -= borderTopWidth - marginTop; 15666 offsets.left -= borderLeftWidth - marginLeft; 15667 offsets.right -= borderLeftWidth - marginLeft; 15668 15669 // Attach marginTop and marginLeft because in some circumstances we may need them 15670 offsets.marginTop = marginTop; 15671 offsets.marginLeft = marginLeft; 15672 } 15673 15674 if (isIE10 && !fixedPosition ? parent.contains(scrollParent) : parent === scrollParent && scrollParent.nodeName !== 'BODY') { 15675 offsets = includeScroll(offsets, parent); 15676 } 15677 15678 return offsets; 15679} 15680 15681function getViewportOffsetRectRelativeToArtbitraryNode(element) { 15682 var excludeScroll = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false; 15683 15684 var html = element.ownerDocument.documentElement; 15685 var relativeOffset = getOffsetRectRelativeToArbitraryNode(element, html); 15686 var width = Math.max(html.clientWidth, window.innerWidth || 0); 15687 var height = Math.max(html.clientHeight, window.innerHeight || 0); 15688 15689 var scrollTop = !excludeScroll ? getScroll(html) : 0; 15690 var scrollLeft = !excludeScroll ? getScroll(html, 'left') : 0; 15691 15692 var offset = { 15693 top: scrollTop - relativeOffset.top + relativeOffset.marginTop, 15694 left: scrollLeft - relativeOffset.left + relativeOffset.marginLeft, 15695 width: width, 15696 height: height 15697 }; 15698 15699 return getClientRect(offset); 15700} 15701 15702/** 15703 * Check if the given element is fixed or is inside a fixed parent 15704 * @method 15705 * @memberof Popper.Utils 15706 * @argument {Element} element 15707 * @argument {Element} customContainer 15708 * @returns {Boolean} answer to "isFixed?" 15709 */ 15710function isFixed(element) { 15711 var nodeName = element.nodeName; 15712 if (nodeName === 'BODY' || nodeName === 'HTML') { 15713 return false; 15714 } 15715 if (getStyleComputedProperty(element, 'position') === 'fixed') { 15716 return true; 15717 } 15718 var parentNode = getParentNode(element); 15719 if (!parentNode) { 15720 return false; 15721 } 15722 return isFixed(parentNode); 15723} 15724 15725/** 15726 * Finds the first parent of an element that has a transformed property defined 15727 * @method 15728 * @memberof Popper.Utils 15729 * @argument {Element} element 15730 * @returns {Element} first transformed parent or documentElement 15731 */ 15732 15733function getFixedPositionOffsetParent(element) { 15734 // This check is needed to avoid errors in case one of the elements isn't defined for any reason 15735 if (!element || !element.parentElement || isIE()) { 15736 return document.documentElement; 15737 } 15738 var el = element.parentElement; 15739 while (el && getStyleComputedProperty(el, 'transform') === 'none') { 15740 el = el.parentElement; 15741 } 15742 return el || document.documentElement; 15743} 15744 15745/** 15746 * Computed the boundaries limits and return them 15747 * @method 15748 * @memberof Popper.Utils 15749 * @param {HTMLElement} popper 15750 * @param {HTMLElement} reference 15751 * @param {number} padding 15752 * @param {HTMLElement} boundariesElement - Element used to define the boundaries 15753 * @param {Boolean} fixedPosition - Is in fixed position mode 15754 * @returns {Object} Coordinates of the boundaries 15755 */ 15756function getBoundaries(popper, reference, padding, boundariesElement) { 15757 var fixedPosition = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false; 15758 15759 // NOTE: 1 DOM access here 15760 15761 var boundaries = { top: 0, left: 0 }; 15762 var offsetParent = fixedPosition ? getFixedPositionOffsetParent(popper) : findCommonOffsetParent(popper, getReferenceNode(reference)); 15763 15764 // Handle viewport case 15765 if (boundariesElement === 'viewport') { 15766 boundaries = getViewportOffsetRectRelativeToArtbitraryNode(offsetParent, fixedPosition); 15767 } else { 15768 // Handle other cases based on DOM element used as boundaries 15769 var boundariesNode = void 0; 15770 if (boundariesElement === 'scrollParent') { 15771 boundariesNode = getScrollParent(getParentNode(reference)); 15772 if (boundariesNode.nodeName === 'BODY') { 15773 boundariesNode = popper.ownerDocument.documentElement; 15774 } 15775 } else if (boundariesElement === 'window') { 15776 boundariesNode = popper.ownerDocument.documentElement; 15777 } else { 15778 boundariesNode = boundariesElement; 15779 } 15780 15781 var offsets = getOffsetRectRelativeToArbitraryNode(boundariesNode, offsetParent, fixedPosition); 15782 15783 // In case of HTML, we need a different computation 15784 if (boundariesNode.nodeName === 'HTML' && !isFixed(offsetParent)) { 15785 var _getWindowSizes = getWindowSizes(popper.ownerDocument), 15786 height = _getWindowSizes.height, 15787 width = _getWindowSizes.width; 15788 15789 boundaries.top += offsets.top - offsets.marginTop; 15790 boundaries.bottom = height + offsets.top; 15791 boundaries.left += offsets.left - offsets.marginLeft; 15792 boundaries.right = width + offsets.left; 15793 } else { 15794 // for all the other DOM elements, this one is good 15795 boundaries = offsets; 15796 } 15797 } 15798 15799 // Add paddings 15800 padding = padding || 0; 15801 var isPaddingNumber = typeof padding === 'number'; 15802 boundaries.left += isPaddingNumber ? padding : padding.left || 0; 15803 boundaries.top += isPaddingNumber ? padding : padding.top || 0; 15804 boundaries.right -= isPaddingNumber ? padding : padding.right || 0; 15805 boundaries.bottom -= isPaddingNumber ? padding : padding.bottom || 0; 15806 15807 return boundaries; 15808} 15809 15810function getArea(_ref) { 15811 var width = _ref.width, 15812 height = _ref.height; 15813 15814 return width * height; 15815} 15816 15817/** 15818 * Utility used to transform the `auto` placement to the placement with more 15819 * available space. 15820 * @method 15821 * @memberof Popper.Utils 15822 * @argument {Object} data - The data object generated by update method 15823 * @argument {Object} options - Modifiers configuration and options 15824 * @returns {Object} The data object, properly modified 15825 */ 15826function computeAutoPlacement(placement, refRect, popper, reference, boundariesElement) { 15827 var padding = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : 0; 15828 15829 if (placement.indexOf('auto') === -1) { 15830 return placement; 15831 } 15832 15833 var boundaries = getBoundaries(popper, reference, padding, boundariesElement); 15834 15835 var rects = { 15836 top: { 15837 width: boundaries.width, 15838 height: refRect.top - boundaries.top 15839 }, 15840 right: { 15841 width: boundaries.right - refRect.right, 15842 height: boundaries.height 15843 }, 15844 bottom: { 15845 width: boundaries.width, 15846 height: boundaries.bottom - refRect.bottom 15847 }, 15848 left: { 15849 width: refRect.left - boundaries.left, 15850 height: boundaries.height 15851 } 15852 }; 15853 15854 var sortedAreas = Object.keys(rects).map(function (key) { 15855 return _extends({ 15856 key: key 15857 }, rects[key], { 15858 area: getArea(rects[key]) 15859 }); 15860 }).sort(function (a, b) { 15861 return b.area - a.area; 15862 }); 15863 15864 var filteredAreas = sortedAreas.filter(function (_ref2) { 15865 var width = _ref2.width, 15866 height = _ref2.height; 15867 return width >= popper.clientWidth && height >= popper.clientHeight; 15868 }); 15869 15870 var computedPlacement = filteredAreas.length > 0 ? filteredAreas[0].key : sortedAreas[0].key; 15871 15872 var variation = placement.split('-')[1]; 15873 15874 return computedPlacement + (variation ? '-' + variation : ''); 15875} 15876 15877/** 15878 * Get offsets to the reference element 15879 * @method 15880 * @memberof Popper.Utils 15881 * @param {Object} state 15882 * @param {Element} popper - the popper element 15883 * @param {Element} reference - the reference element (the popper will be relative to this) 15884 * @param {Element} fixedPosition - is in fixed position mode 15885 * @returns {Object} An object containing the offsets which will be applied to the popper 15886 */ 15887function getReferenceOffsets(state, popper, reference) { 15888 var fixedPosition = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null; 15889 15890 var commonOffsetParent = fixedPosition ? getFixedPositionOffsetParent(popper) : findCommonOffsetParent(popper, getReferenceNode(reference)); 15891 return getOffsetRectRelativeToArbitraryNode(reference, commonOffsetParent, fixedPosition); 15892} 15893 15894/** 15895 * Get the outer sizes of the given element (offset size + margins) 15896 * @method 15897 * @memberof Popper.Utils 15898 * @argument {Element} element 15899 * @returns {Object} object containing width and height properties 15900 */ 15901function getOuterSizes(element) { 15902 var window = element.ownerDocument.defaultView; 15903 var styles = window.getComputedStyle(element); 15904 var x = parseFloat(styles.marginTop || 0) + parseFloat(styles.marginBottom || 0); 15905 var y = parseFloat(styles.marginLeft || 0) + parseFloat(styles.marginRight || 0); 15906 var result = { 15907 width: element.offsetWidth + y, 15908 height: element.offsetHeight + x 15909 }; 15910 return result; 15911} 15912 15913/** 15914 * Get the opposite placement of the given one 15915 * @method 15916 * @memberof Popper.Utils 15917 * @argument {String} placement 15918 * @returns {String} flipped placement 15919 */ 15920function getOppositePlacement(placement) { 15921 var hash = { left: 'right', right: 'left', bottom: 'top', top: 'bottom' }; 15922 return placement.replace(/left|right|bottom|top/g, function (matched) { 15923 return hash[matched]; 15924 }); 15925} 15926 15927/** 15928 * Get offsets to the popper 15929 * @method 15930 * @memberof Popper.Utils 15931 * @param {Object} position - CSS position the Popper will get applied 15932 * @param {HTMLElement} popper - the popper element 15933 * @param {Object} referenceOffsets - the reference offsets (the popper will be relative to this) 15934 * @param {String} placement - one of the valid placement options 15935 * @returns {Object} popperOffsets - An object containing the offsets which will be applied to the popper 15936 */ 15937function getPopperOffsets(popper, referenceOffsets, placement) { 15938 placement = placement.split('-')[0]; 15939 15940 // Get popper node sizes 15941 var popperRect = getOuterSizes(popper); 15942 15943 // Add position, width and height to our offsets object 15944 var popperOffsets = { 15945 width: popperRect.width, 15946 height: popperRect.height 15947 }; 15948 15949 // depending by the popper placement we have to compute its offsets slightly differently 15950 var isHoriz = ['right', 'left'].indexOf(placement) !== -1; 15951 var mainSide = isHoriz ? 'top' : 'left'; 15952 var secondarySide = isHoriz ? 'left' : 'top'; 15953 var measurement = isHoriz ? 'height' : 'width'; 15954 var secondaryMeasurement = !isHoriz ? 'height' : 'width'; 15955 15956 popperOffsets[mainSide] = referenceOffsets[mainSide] + referenceOffsets[measurement] / 2 - popperRect[measurement] / 2; 15957 if (placement === secondarySide) { 15958 popperOffsets[secondarySide] = referenceOffsets[secondarySide] - popperRect[secondaryMeasurement]; 15959 } else { 15960 popperOffsets[secondarySide] = referenceOffsets[getOppositePlacement(secondarySide)]; 15961 } 15962 15963 return popperOffsets; 15964} 15965 15966/** 15967 * Mimics the `find` method of Array 15968 * @method 15969 * @memberof Popper.Utils 15970 * @argument {Array} arr 15971 * @argument prop 15972 * @argument value 15973 * @returns index or -1 15974 */ 15975function find(arr, check) { 15976 // use native find if supported 15977 if (Array.prototype.find) { 15978 return arr.find(check); 15979 } 15980 15981 // use `filter` to obtain the same behavior of `find` 15982 return arr.filter(check)[0]; 15983} 15984 15985/** 15986 * Return the index of the matching object 15987 * @method 15988 * @memberof Popper.Utils 15989 * @argument {Array} arr 15990 * @argument prop 15991 * @argument value 15992 * @returns index or -1 15993 */ 15994function findIndex(arr, prop, value) { 15995 // use native findIndex if supported 15996 if (Array.prototype.findIndex) { 15997 return arr.findIndex(function (cur) { 15998 return cur[prop] === value; 15999 }); 16000 } 16001 16002 // use `find` + `indexOf` if `findIndex` isn't supported 16003 var match = find(arr, function (obj) { 16004 return obj[prop] === value; 16005 }); 16006 return arr.indexOf(match); 16007} 16008 16009/** 16010 * Loop trough the list of modifiers and run them in order, 16011 * each of them will then edit the data object. 16012 * @method 16013 * @memberof Popper.Utils 16014 * @param {dataObject} data 16015 * @param {Array} modifiers 16016 * @param {String} ends - Optional modifier name used as stopper 16017 * @returns {dataObject} 16018 */ 16019function runModifiers(modifiers, data, ends) { 16020 var modifiersToRun = ends === undefined ? modifiers : modifiers.slice(0, findIndex(modifiers, 'name', ends)); 16021 16022 modifiersToRun.forEach(function (modifier) { 16023 if (modifier['function']) { 16024 // eslint-disable-line dot-notation 16025 console.warn('`modifier.function` is deprecated, use `modifier.fn`!'); 16026 } 16027 var fn = modifier['function'] || modifier.fn; // eslint-disable-line dot-notation 16028 if (modifier.enabled && isFunction(fn)) { 16029 // Add properties to offsets to make them a complete clientRect object 16030 // we do this before each modifier to make sure the previous one doesn't 16031 // mess with these values 16032 data.offsets.popper = getClientRect(data.offsets.popper); 16033 data.offsets.reference = getClientRect(data.offsets.reference); 16034 16035 data = fn(data, modifier); 16036 } 16037 }); 16038 16039 return data; 16040} 16041 16042/** 16043 * Updates the position of the popper, computing the new offsets and applying 16044 * the new style.<br /> 16045 * Prefer `scheduleUpdate` over `update` because of performance reasons. 16046 * @method 16047 * @memberof Popper 16048 */ 16049function update() { 16050 // if popper is destroyed, don't perform any further update 16051 if (this.state.isDestroyed) { 16052 return; 16053 } 16054 16055 var data = { 16056 instance: this, 16057 styles: {}, 16058 arrowStyles: {}, 16059 attributes: {}, 16060 flipped: false, 16061 offsets: {} 16062 }; 16063 16064 // compute reference element offsets 16065 data.offsets.reference = getReferenceOffsets(this.state, this.popper, this.reference, this.options.positionFixed); 16066 16067 // compute auto placement, store placement inside the data object, 16068 // modifiers will be able to edit `placement` if needed 16069 // and refer to originalPlacement to know the original value 16070 data.placement = computeAutoPlacement(this.options.placement, data.offsets.reference, this.popper, this.reference, this.options.modifiers.flip.boundariesElement, this.options.modifiers.flip.padding); 16071 16072 // store the computed placement inside `originalPlacement` 16073 data.originalPlacement = data.placement; 16074 16075 data.positionFixed = this.options.positionFixed; 16076 16077 // compute the popper offsets 16078 data.offsets.popper = getPopperOffsets(this.popper, data.offsets.reference, data.placement); 16079 16080 data.offsets.popper.position = this.options.positionFixed ? 'fixed' : 'absolute'; 16081 16082 // run the modifiers 16083 data = runModifiers(this.modifiers, data); 16084 16085 // the first `update` will call `onCreate` callback 16086 // the other ones will call `onUpdate` callback 16087 if (!this.state.isCreated) { 16088 this.state.isCreated = true; 16089 this.options.onCreate(data); 16090 } else { 16091 this.options.onUpdate(data); 16092 } 16093} 16094 16095/** 16096 * Helper used to know if the given modifier is enabled. 16097 * @method 16098 * @memberof Popper.Utils 16099 * @returns {Boolean} 16100 */ 16101function isModifierEnabled(modifiers, modifierName) { 16102 return modifiers.some(function (_ref) { 16103 var name = _ref.name, 16104 enabled = _ref.enabled; 16105 return enabled && name === modifierName; 16106 }); 16107} 16108 16109/** 16110 * Get the prefixed supported property name 16111 * @method 16112 * @memberof Popper.Utils 16113 * @argument {String} property (camelCase) 16114 * @returns {String} prefixed property (camelCase or PascalCase, depending on the vendor prefix) 16115 */ 16116function getSupportedPropertyName(property) { 16117 var prefixes = [false, 'ms', 'Webkit', 'Moz', 'O']; 16118 var upperProp = property.charAt(0).toUpperCase() + property.slice(1); 16119 16120 for (var i = 0; i < prefixes.length; i++) { 16121 var prefix = prefixes[i]; 16122 var toCheck = prefix ? '' + prefix + upperProp : property; 16123 if (typeof document.body.style[toCheck] !== 'undefined') { 16124 return toCheck; 16125 } 16126 } 16127 return null; 16128} 16129 16130/** 16131 * Destroys the popper. 16132 * @method 16133 * @memberof Popper 16134 */ 16135function destroy() { 16136 this.state.isDestroyed = true; 16137 16138 // touch DOM only if `applyStyle` modifier is enabled 16139 if (isModifierEnabled(this.modifiers, 'applyStyle')) { 16140 this.popper.removeAttribute('x-placement'); 16141 this.popper.style.position = ''; 16142 this.popper.style.top = ''; 16143 this.popper.style.left = ''; 16144 this.popper.style.right = ''; 16145 this.popper.style.bottom = ''; 16146 this.popper.style.willChange = ''; 16147 this.popper.style[getSupportedPropertyName('transform')] = ''; 16148 } 16149 16150 this.disableEventListeners(); 16151 16152 // remove the popper if user explicitly asked for the deletion on destroy 16153 // do not use `remove` because IE11 doesn't support it 16154 if (this.options.removeOnDestroy) { 16155 this.popper.parentNode.removeChild(this.popper); 16156 } 16157 return this; 16158} 16159 16160/** 16161 * Get the window associated with the element 16162 * @argument {Element} element 16163 * @returns {Window} 16164 */ 16165function getWindow(element) { 16166 var ownerDocument = element.ownerDocument; 16167 return ownerDocument ? ownerDocument.defaultView : window; 16168} 16169 16170function attachToScrollParents(scrollParent, event, callback, scrollParents) { 16171 var isBody = scrollParent.nodeName === 'BODY'; 16172 var target = isBody ? scrollParent.ownerDocument.defaultView : scrollParent; 16173 target.addEventListener(event, callback, { passive: true }); 16174 16175 if (!isBody) { 16176 attachToScrollParents(getScrollParent(target.parentNode), event, callback, scrollParents); 16177 } 16178 scrollParents.push(target); 16179} 16180 16181/** 16182 * Setup needed event listeners used to update the popper position 16183 * @method 16184 * @memberof Popper.Utils 16185 * @private 16186 */ 16187function setupEventListeners(reference, options, state, updateBound) { 16188 // Resize event listener on window 16189 state.updateBound = updateBound; 16190 getWindow(reference).addEventListener('resize', state.updateBound, { passive: true }); 16191 16192 // Scroll event listener on scroll parents 16193 var scrollElement = getScrollParent(reference); 16194 attachToScrollParents(scrollElement, 'scroll', state.updateBound, state.scrollParents); 16195 state.scrollElement = scrollElement; 16196 state.eventsEnabled = true; 16197 16198 return state; 16199} 16200 16201/** 16202 * It will add resize/scroll events and start recalculating 16203 * position of the popper element when they are triggered. 16204 * @method 16205 * @memberof Popper 16206 */ 16207function enableEventListeners() { 16208 if (!this.state.eventsEnabled) { 16209 this.state = setupEventListeners(this.reference, this.options, this.state, this.scheduleUpdate); 16210 } 16211} 16212 16213/** 16214 * Remove event listeners used to update the popper position 16215 * @method 16216 * @memberof Popper.Utils 16217 * @private 16218 */ 16219function removeEventListeners(reference, state) { 16220 // Remove resize event listener on window 16221 getWindow(reference).removeEventListener('resize', state.updateBound); 16222 16223 // Remove scroll event listener on scroll parents 16224 state.scrollParents.forEach(function (target) { 16225 target.removeEventListener('scroll', state.updateBound); 16226 }); 16227 16228 // Reset state 16229 state.updateBound = null; 16230 state.scrollParents = []; 16231 state.scrollElement = null; 16232 state.eventsEnabled = false; 16233 return state; 16234} 16235 16236/** 16237 * It will remove resize/scroll events and won't recalculate popper position 16238 * when they are triggered. It also won't trigger `onUpdate` callback anymore, 16239 * unless you call `update` method manually. 16240 * @method 16241 * @memberof Popper 16242 */ 16243function disableEventListeners() { 16244 if (this.state.eventsEnabled) { 16245 cancelAnimationFrame(this.scheduleUpdate); 16246 this.state = removeEventListeners(this.reference, this.state); 16247 } 16248} 16249 16250/** 16251 * Tells if a given input is a number 16252 * @method 16253 * @memberof Popper.Utils 16254 * @param {*} input to check 16255 * @return {Boolean} 16256 */ 16257function isNumeric(n) { 16258 return n !== '' && !isNaN(parseFloat(n)) && isFinite(n); 16259} 16260 16261/** 16262 * Set the style to the given popper 16263 * @method 16264 * @memberof Popper.Utils 16265 * @argument {Element} element - Element to apply the style to 16266 * @argument {Object} styles 16267 * Object with a list of properties and values which will be applied to the element 16268 */ 16269function setStyles(element, styles) { 16270 Object.keys(styles).forEach(function (prop) { 16271 var unit = ''; 16272 // add unit if the value is numeric and is one of the following 16273 if (['width', 'height', 'top', 'right', 'bottom', 'left'].indexOf(prop) !== -1 && isNumeric(styles[prop])) { 16274 unit = 'px'; 16275 } 16276 element.style[prop] = styles[prop] + unit; 16277 }); 16278} 16279 16280/** 16281 * Set the attributes to the given popper 16282 * @method 16283 * @memberof Popper.Utils 16284 * @argument {Element} element - Element to apply the attributes to 16285 * @argument {Object} styles 16286 * Object with a list of properties and values which will be applied to the element 16287 */ 16288function setAttributes(element, attributes) { 16289 Object.keys(attributes).forEach(function (prop) { 16290 var value = attributes[prop]; 16291 if (value !== false) { 16292 element.setAttribute(prop, attributes[prop]); 16293 } else { 16294 element.removeAttribute(prop); 16295 } 16296 }); 16297} 16298 16299/** 16300 * @function 16301 * @memberof Modifiers 16302 * @argument {Object} data - The data object generated by `update` method 16303 * @argument {Object} data.styles - List of style properties - values to apply to popper element 16304 * @argument {Object} data.attributes - List of attribute properties - values to apply to popper element 16305 * @argument {Object} options - Modifiers configuration and options 16306 * @returns {Object} The same data object 16307 */ 16308function applyStyle(data) { 16309 // any property present in `data.styles` will be applied to the popper, 16310 // in this way we can make the 3rd party modifiers add custom styles to it 16311 // Be aware, modifiers could override the properties defined in the previous 16312 // lines of this modifier! 16313 setStyles(data.instance.popper, data.styles); 16314 16315 // any property present in `data.attributes` will be applied to the popper, 16316 // they will be set as HTML attributes of the element 16317 setAttributes(data.instance.popper, data.attributes); 16318 16319 // if arrowElement is defined and arrowStyles has some properties 16320 if (data.arrowElement && Object.keys(data.arrowStyles).length) { 16321 setStyles(data.arrowElement, data.arrowStyles); 16322 } 16323 16324 return data; 16325} 16326 16327/** 16328 * Set the x-placement attribute before everything else because it could be used 16329 * to add margins to the popper margins needs to be calculated to get the 16330 * correct popper offsets. 16331 * @method 16332 * @memberof Popper.modifiers 16333 * @param {HTMLElement} reference - The reference element used to position the popper 16334 * @param {HTMLElement} popper - The HTML element used as popper 16335 * @param {Object} options - Popper.js options 16336 */ 16337function applyStyleOnLoad(reference, popper, options, modifierOptions, state) { 16338 // compute reference element offsets 16339 var referenceOffsets = getReferenceOffsets(state, popper, reference, options.positionFixed); 16340 16341 // compute auto placement, store placement inside the data object, 16342 // modifiers will be able to edit `placement` if needed 16343 // and refer to originalPlacement to know the original value 16344 var placement = computeAutoPlacement(options.placement, referenceOffsets, popper, reference, options.modifiers.flip.boundariesElement, options.modifiers.flip.padding); 16345 16346 popper.setAttribute('x-placement', placement); 16347 16348 // Apply `position` to popper before anything else because 16349 // without the position applied we can't guarantee correct computations 16350 setStyles(popper, { position: options.positionFixed ? 'fixed' : 'absolute' }); 16351 16352 return options; 16353} 16354 16355/** 16356 * @function 16357 * @memberof Popper.Utils 16358 * @argument {Object} data - The data object generated by `update` method 16359 * @argument {Boolean} shouldRound - If the offsets should be rounded at all 16360 * @returns {Object} The popper's position offsets rounded 16361 * 16362 * The tale of pixel-perfect positioning. It's still not 100% perfect, but as 16363 * good as it can be within reason. 16364 * Discussion here: https://github.com/FezVrasta/popper.js/pull/715 16365 * 16366 * Low DPI screens cause a popper to be blurry if not using full pixels (Safari 16367 * as well on High DPI screens). 16368 * 16369 * Firefox prefers no rounding for positioning and does not have blurriness on 16370 * high DPI screens. 16371 * 16372 * Only horizontal placement and left/right values need to be considered. 16373 */ 16374function getRoundedOffsets(data, shouldRound) { 16375 var _data$offsets = data.offsets, 16376 popper = _data$offsets.popper, 16377 reference = _data$offsets.reference; 16378 var round = Math.round, 16379 floor = Math.floor; 16380 16381 var noRound = function noRound(v) { 16382 return v; 16383 }; 16384 16385 var referenceWidth = round(reference.width); 16386 var popperWidth = round(popper.width); 16387 16388 var isVertical = ['left', 'right'].indexOf(data.placement) !== -1; 16389 var isVariation = data.placement.indexOf('-') !== -1; 16390 var sameWidthParity = referenceWidth % 2 === popperWidth % 2; 16391 var bothOddWidth = referenceWidth % 2 === 1 && popperWidth % 2 === 1; 16392 16393 var horizontalToInteger = !shouldRound ? noRound : isVertical || isVariation || sameWidthParity ? round : floor; 16394 var verticalToInteger = !shouldRound ? noRound : round; 16395 16396 return { 16397 left: horizontalToInteger(bothOddWidth && !isVariation && shouldRound ? popper.left - 1 : popper.left), 16398 top: verticalToInteger(popper.top), 16399 bottom: verticalToInteger(popper.bottom), 16400 right: horizontalToInteger(popper.right) 16401 }; 16402} 16403 16404var isFirefox = isBrowser && /Firefox/i.test(navigator.userAgent); 16405 16406/** 16407 * @function 16408 * @memberof Modifiers 16409 * @argument {Object} data - The data object generated by `update` method 16410 * @argument {Object} options - Modifiers configuration and options 16411 * @returns {Object} The data object, properly modified 16412 */ 16413function computeStyle(data, options) { 16414 var x = options.x, 16415 y = options.y; 16416 var popper = data.offsets.popper; 16417 16418 // Remove this legacy support in Popper.js v2 16419 16420 var legacyGpuAccelerationOption = find(data.instance.modifiers, function (modifier) { 16421 return modifier.name === 'applyStyle'; 16422 }).gpuAcceleration; 16423 if (legacyGpuAccelerationOption !== undefined) { 16424 console.warn('WARNING: `gpuAcceleration` option moved to `computeStyle` modifier and will not be supported in future versions of Popper.js!'); 16425 } 16426 var gpuAcceleration = legacyGpuAccelerationOption !== undefined ? legacyGpuAccelerationOption : options.gpuAcceleration; 16427 16428 var offsetParent = getOffsetParent(data.instance.popper); 16429 var offsetParentRect = getBoundingClientRect(offsetParent); 16430 16431 // Styles 16432 var styles = { 16433 position: popper.position 16434 }; 16435 16436 var offsets = getRoundedOffsets(data, window.devicePixelRatio < 2 || !isFirefox); 16437 16438 var sideA = x === 'bottom' ? 'top' : 'bottom'; 16439 var sideB = y === 'right' ? 'left' : 'right'; 16440 16441 // if gpuAcceleration is set to `true` and transform is supported, 16442 // we use `translate3d` to apply the position to the popper we 16443 // automatically use the supported prefixed version if needed 16444 var prefixedProperty = getSupportedPropertyName('transform'); 16445 16446 // now, let's make a step back and look at this code closely (wtf?) 16447 // If the content of the popper grows once it's been positioned, it 16448 // may happen that the popper gets misplaced because of the new content 16449 // overflowing its reference element 16450 // To avoid this problem, we provide two options (x and y), which allow 16451 // the consumer to define the offset origin. 16452 // If we position a popper on top of a reference element, we can set 16453 // `x` to `top` to make the popper grow towards its top instead of 16454 // its bottom. 16455 var left = void 0, 16456 top = void 0; 16457 if (sideA === 'bottom') { 16458 // when offsetParent is <html> the positioning is relative to the bottom of the screen (excluding the scrollbar) 16459 // and not the bottom of the html element 16460 if (offsetParent.nodeName === 'HTML') { 16461 top = -offsetParent.clientHeight + offsets.bottom; 16462 } else { 16463 top = -offsetParentRect.height + offsets.bottom; 16464 } 16465 } else { 16466 top = offsets.top; 16467 } 16468 if (sideB === 'right') { 16469 if (offsetParent.nodeName === 'HTML') { 16470 left = -offsetParent.clientWidth + offsets.right; 16471 } else { 16472 left = -offsetParentRect.width + offsets.right; 16473 } 16474 } else { 16475 left = offsets.left; 16476 } 16477 if (gpuAcceleration && prefixedProperty) { 16478 styles[prefixedProperty] = 'translate3d(' + left + 'px, ' + top + 'px, 0)'; 16479 styles[sideA] = 0; 16480 styles[sideB] = 0; 16481 styles.willChange = 'transform'; 16482 } else { 16483 // othwerise, we use the standard `top`, `left`, `bottom` and `right` properties 16484 var invertTop = sideA === 'bottom' ? -1 : 1; 16485 var invertLeft = sideB === 'right' ? -1 : 1; 16486 styles[sideA] = top * invertTop; 16487 styles[sideB] = left * invertLeft; 16488 styles.willChange = sideA + ', ' + sideB; 16489 } 16490 16491 // Attributes 16492 var attributes = { 16493 'x-placement': data.placement 16494 }; 16495 16496 // Update `data` attributes, styles and arrowStyles 16497 data.attributes = _extends({}, attributes, data.attributes); 16498 data.styles = _extends({}, styles, data.styles); 16499 data.arrowStyles = _extends({}, data.offsets.arrow, data.arrowStyles); 16500 16501 return data; 16502} 16503 16504/** 16505 * Helper used to know if the given modifier depends from another one.<br /> 16506 * It checks if the needed modifier is listed and enabled. 16507 * @method 16508 * @memberof Popper.Utils 16509 * @param {Array} modifiers - list of modifiers 16510 * @param {String} requestingName - name of requesting modifier 16511 * @param {String} requestedName - name of requested modifier 16512 * @returns {Boolean} 16513 */ 16514function isModifierRequired(modifiers, requestingName, requestedName) { 16515 var requesting = find(modifiers, function (_ref) { 16516 var name = _ref.name; 16517 return name === requestingName; 16518 }); 16519 16520 var isRequired = !!requesting && modifiers.some(function (modifier) { 16521 return modifier.name === requestedName && modifier.enabled && modifier.order < requesting.order; 16522 }); 16523 16524 if (!isRequired) { 16525 var _requesting = '`' + requestingName + '`'; 16526 var requested = '`' + requestedName + '`'; 16527 console.warn(requested + ' modifier is required by ' + _requesting + ' modifier in order to work, be sure to include it before ' + _requesting + '!'); 16528 } 16529 return isRequired; 16530} 16531 16532/** 16533 * @function 16534 * @memberof Modifiers 16535 * @argument {Object} data - The data object generated by update method 16536 * @argument {Object} options - Modifiers configuration and options 16537 * @returns {Object} The data object, properly modified 16538 */ 16539function arrow(data, options) { 16540 var _data$offsets$arrow; 16541 16542 // arrow depends on keepTogether in order to work 16543 if (!isModifierRequired(data.instance.modifiers, 'arrow', 'keepTogether')) { 16544 return data; 16545 } 16546 16547 var arrowElement = options.element; 16548 16549 // if arrowElement is a string, suppose it's a CSS selector 16550 if (typeof arrowElement === 'string') { 16551 arrowElement = data.instance.popper.querySelector(arrowElement); 16552 16553 // if arrowElement is not found, don't run the modifier 16554 if (!arrowElement) { 16555 return data; 16556 } 16557 } else { 16558 // if the arrowElement isn't a query selector we must check that the 16559 // provided DOM node is child of its popper node 16560 if (!data.instance.popper.contains(arrowElement)) { 16561 console.warn('WARNING: `arrow.element` must be child of its popper element!'); 16562 return data; 16563 } 16564 } 16565 16566 var placement = data.placement.split('-')[0]; 16567 var _data$offsets = data.offsets, 16568 popper = _data$offsets.popper, 16569 reference = _data$offsets.reference; 16570 16571 var isVertical = ['left', 'right'].indexOf(placement) !== -1; 16572 16573 var len = isVertical ? 'height' : 'width'; 16574 var sideCapitalized = isVertical ? 'Top' : 'Left'; 16575 var side = sideCapitalized.toLowerCase(); 16576 var altSide = isVertical ? 'left' : 'top'; 16577 var opSide = isVertical ? 'bottom' : 'right'; 16578 var arrowElementSize = getOuterSizes(arrowElement)[len]; 16579 16580 // 16581 // extends keepTogether behavior making sure the popper and its 16582 // reference have enough pixels in conjunction 16583 // 16584 16585 // top/left side 16586 if (reference[opSide] - arrowElementSize < popper[side]) { 16587 data.offsets.popper[side] -= popper[side] - (reference[opSide] - arrowElementSize); 16588 } 16589 // bottom/right side 16590 if (reference[side] + arrowElementSize > popper[opSide]) { 16591 data.offsets.popper[side] += reference[side] + arrowElementSize - popper[opSide]; 16592 } 16593 data.offsets.popper = getClientRect(data.offsets.popper); 16594 16595 // compute center of the popper 16596 var center = reference[side] + reference[len] / 2 - arrowElementSize / 2; 16597 16598 // Compute the sideValue using the updated popper offsets 16599 // take popper margin in account because we don't have this info available 16600 var css = getStyleComputedProperty(data.instance.popper); 16601 var popperMarginSide = parseFloat(css['margin' + sideCapitalized]); 16602 var popperBorderSide = parseFloat(css['border' + sideCapitalized + 'Width']); 16603 var sideValue = center - data.offsets.popper[side] - popperMarginSide - popperBorderSide; 16604 16605 // prevent arrowElement from being placed not contiguously to its popper 16606 sideValue = Math.max(Math.min(popper[len] - arrowElementSize, sideValue), 0); 16607 16608 data.arrowElement = arrowElement; 16609 data.offsets.arrow = (_data$offsets$arrow = {}, defineProperty(_data$offsets$arrow, side, Math.round(sideValue)), defineProperty(_data$offsets$arrow, altSide, ''), _data$offsets$arrow); 16610 16611 return data; 16612} 16613 16614/** 16615 * Get the opposite placement variation of the given one 16616 * @method 16617 * @memberof Popper.Utils 16618 * @argument {String} placement variation 16619 * @returns {String} flipped placement variation 16620 */ 16621function getOppositeVariation(variation) { 16622 if (variation === 'end') { 16623 return 'start'; 16624 } else if (variation === 'start') { 16625 return 'end'; 16626 } 16627 return variation; 16628} 16629 16630/** 16631 * List of accepted placements to use as values of the `placement` option.<br /> 16632 * Valid placements are: 16633 * - `auto` 16634 * - `top` 16635 * - `right` 16636 * - `bottom` 16637 * - `left` 16638 * 16639 * Each placement can have a variation from this list: 16640 * - `-start` 16641 * - `-end` 16642 * 16643 * Variations are interpreted easily if you think of them as the left to right 16644 * written languages. Horizontally (`top` and `bottom`), `start` is left and `end` 16645 * is right.<br /> 16646 * Vertically (`left` and `right`), `start` is top and `end` is bottom. 16647 * 16648 * Some valid examples are: 16649 * - `top-end` (on top of reference, right aligned) 16650 * - `right-start` (on right of reference, top aligned) 16651 * - `bottom` (on bottom, centered) 16652 * - `auto-end` (on the side with more space available, alignment depends by placement) 16653 * 16654 * @static 16655 * @type {Array} 16656 * @enum {String} 16657 * @readonly 16658 * @method placements 16659 * @memberof Popper 16660 */ 16661var placements = ['auto-start', 'auto', 'auto-end', 'top-start', 'top', 'top-end', 'right-start', 'right', 'right-end', 'bottom-end', 'bottom', 'bottom-start', 'left-end', 'left', 'left-start']; 16662 16663// Get rid of `auto` `auto-start` and `auto-end` 16664var validPlacements = placements.slice(3); 16665 16666/** 16667 * Given an initial placement, returns all the subsequent placements 16668 * clockwise (or counter-clockwise). 16669 * 16670 * @method 16671 * @memberof Popper.Utils 16672 * @argument {String} placement - A valid placement (it accepts variations) 16673 * @argument {Boolean} counter - Set to true to walk the placements counterclockwise 16674 * @returns {Array} placements including their variations 16675 */ 16676function clockwise(placement) { 16677 var counter = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false; 16678 16679 var index = validPlacements.indexOf(placement); 16680 var arr = validPlacements.slice(index + 1).concat(validPlacements.slice(0, index)); 16681 return counter ? arr.reverse() : arr; 16682} 16683 16684var BEHAVIORS = { 16685 FLIP: 'flip', 16686 CLOCKWISE: 'clockwise', 16687 COUNTERCLOCKWISE: 'counterclockwise' 16688}; 16689 16690/** 16691 * @function 16692 * @memberof Modifiers 16693 * @argument {Object} data - The data object generated by update method 16694 * @argument {Object} options - Modifiers configuration and options 16695 * @returns {Object} The data object, properly modified 16696 */ 16697function flip(data, options) { 16698 // if `inner` modifier is enabled, we can't use the `flip` modifier 16699 if (isModifierEnabled(data.instance.modifiers, 'inner')) { 16700 return data; 16701 } 16702 16703 if (data.flipped && data.placement === data.originalPlacement) { 16704 // seems like flip is trying to loop, probably there's not enough space on any of the flippable sides 16705 return data; 16706 } 16707 16708 var boundaries = getBoundaries(data.instance.popper, data.instance.reference, options.padding, options.boundariesElement, data.positionFixed); 16709 16710 var placement = data.placement.split('-')[0]; 16711 var placementOpposite = getOppositePlacement(placement); 16712 var variation = data.placement.split('-')[1] || ''; 16713 16714 var flipOrder = []; 16715 16716 switch (options.behavior) { 16717 case BEHAVIORS.FLIP: 16718 flipOrder = [placement, placementOpposite]; 16719 break; 16720 case BEHAVIORS.CLOCKWISE: 16721 flipOrder = clockwise(placement); 16722 break; 16723 case BEHAVIORS.COUNTERCLOCKWISE: 16724 flipOrder = clockwise(placement, true); 16725 break; 16726 default: 16727 flipOrder = options.behavior; 16728 } 16729 16730 flipOrder.forEach(function (step, index) { 16731 if (placement !== step || flipOrder.length === index + 1) { 16732 return data; 16733 } 16734 16735 placement = data.placement.split('-')[0]; 16736 placementOpposite = getOppositePlacement(placement); 16737 16738 var popperOffsets = data.offsets.popper; 16739 var refOffsets = data.offsets.reference; 16740 16741 // using floor because the reference offsets may contain decimals we are not going to consider here 16742 var floor = Math.floor; 16743 var overlapsRef = placement === 'left' && floor(popperOffsets.right) > floor(refOffsets.left) || placement === 'right' && floor(popperOffsets.left) < floor(refOffsets.right) || placement === 'top' && floor(popperOffsets.bottom) > floor(refOffsets.top) || placement === 'bottom' && floor(popperOffsets.top) < floor(refOffsets.bottom); 16744 16745 var overflowsLeft = floor(popperOffsets.left) < floor(boundaries.left); 16746 var overflowsRight = floor(popperOffsets.right) > floor(boundaries.right); 16747 var overflowsTop = floor(popperOffsets.top) < floor(boundaries.top); 16748 var overflowsBottom = floor(popperOffsets.bottom) > floor(boundaries.bottom); 16749 16750 var overflowsBoundaries = placement === 'left' && overflowsLeft || placement === 'right' && overflowsRight || placement === 'top' && overflowsTop || placement === 'bottom' && overflowsBottom; 16751 16752 // flip the variation if required 16753 var isVertical = ['top', 'bottom'].indexOf(placement) !== -1; 16754 16755 // flips variation if reference element overflows boundaries 16756 var flippedVariationByRef = !!options.flipVariations && (isVertical && variation === 'start' && overflowsLeft || isVertical && variation === 'end' && overflowsRight || !isVertical && variation === 'start' && overflowsTop || !isVertical && variation === 'end' && overflowsBottom); 16757 16758 // flips variation if popper content overflows boundaries 16759 var flippedVariationByContent = !!options.flipVariationsByContent && (isVertical && variation === 'start' && overflowsRight || isVertical && variation === 'end' && overflowsLeft || !isVertical && variation === 'start' && overflowsBottom || !isVertical && variation === 'end' && overflowsTop); 16760 16761 var flippedVariation = flippedVariationByRef || flippedVariationByContent; 16762 16763 if (overlapsRef || overflowsBoundaries || flippedVariation) { 16764 // this boolean to detect any flip loop 16765 data.flipped = true; 16766 16767 if (overlapsRef || overflowsBoundaries) { 16768 placement = flipOrder[index + 1]; 16769 } 16770 16771 if (flippedVariation) { 16772 variation = getOppositeVariation(variation); 16773 } 16774 16775 data.placement = placement + (variation ? '-' + variation : ''); 16776 16777 // this object contains `position`, we want to preserve it along with 16778 // any additional property we may add in the future 16779 data.offsets.popper = _extends({}, data.offsets.popper, getPopperOffsets(data.instance.popper, data.offsets.reference, data.placement)); 16780 16781 data = runModifiers(data.instance.modifiers, data, 'flip'); 16782 } 16783 }); 16784 return data; 16785} 16786 16787/** 16788 * @function 16789 * @memberof Modifiers 16790 * @argument {Object} data - The data object generated by update method 16791 * @argument {Object} options - Modifiers configuration and options 16792 * @returns {Object} The data object, properly modified 16793 */ 16794function keepTogether(data) { 16795 var _data$offsets = data.offsets, 16796 popper = _data$offsets.popper, 16797 reference = _data$offsets.reference; 16798 16799 var placement = data.placement.split('-')[0]; 16800 var floor = Math.floor; 16801 var isVertical = ['top', 'bottom'].indexOf(placement) !== -1; 16802 var side = isVertical ? 'right' : 'bottom'; 16803 var opSide = isVertical ? 'left' : 'top'; 16804 var measurement = isVertical ? 'width' : 'height'; 16805 16806 if (popper[side] < floor(reference[opSide])) { 16807 data.offsets.popper[opSide] = floor(reference[opSide]) - popper[measurement]; 16808 } 16809 if (popper[opSide] > floor(reference[side])) { 16810 data.offsets.popper[opSide] = floor(reference[side]); 16811 } 16812 16813 return data; 16814} 16815 16816/** 16817 * Converts a string containing value + unit into a px value number 16818 * @function 16819 * @memberof {modifiers~offset} 16820 * @private 16821 * @argument {String} str - Value + unit string 16822 * @argument {String} measurement - `height` or `width` 16823 * @argument {Object} popperOffsets 16824 * @argument {Object} referenceOffsets 16825 * @returns {Number|String} 16826 * Value in pixels, or original string if no values were extracted 16827 */ 16828function toValue(str, measurement, popperOffsets, referenceOffsets) { 16829 // separate value from unit 16830 var split = str.match(/((?:\-|\+)?\d*\.?\d*)(.*)/); 16831 var value = +split[1]; 16832 var unit = split[2]; 16833 16834 // If it's not a number it's an operator, I guess 16835 if (!value) { 16836 return str; 16837 } 16838 16839 if (unit.indexOf('%') === 0) { 16840 var element = void 0; 16841 switch (unit) { 16842 case '%p': 16843 element = popperOffsets; 16844 break; 16845 case '%': 16846 case '%r': 16847 default: 16848 element = referenceOffsets; 16849 } 16850 16851 var rect = getClientRect(element); 16852 return rect[measurement] / 100 * value; 16853 } else if (unit === 'vh' || unit === 'vw') { 16854 // if is a vh or vw, we calculate the size based on the viewport 16855 var size = void 0; 16856 if (unit === 'vh') { 16857 size = Math.max(document.documentElement.clientHeight, window.innerHeight || 0); 16858 } else { 16859 size = Math.max(document.documentElement.clientWidth, window.innerWidth || 0); 16860 } 16861 return size / 100 * value; 16862 } else { 16863 // if is an explicit pixel unit, we get rid of the unit and keep the value 16864 // if is an implicit unit, it's px, and we return just the value 16865 return value; 16866 } 16867} 16868 16869/** 16870 * Parse an `offset` string to extrapolate `x` and `y` numeric offsets. 16871 * @function 16872 * @memberof {modifiers~offset} 16873 * @private 16874 * @argument {String} offset 16875 * @argument {Object} popperOffsets 16876 * @argument {Object} referenceOffsets 16877 * @argument {String} basePlacement 16878 * @returns {Array} a two cells array with x and y offsets in numbers 16879 */ 16880function parseOffset(offset, popperOffsets, referenceOffsets, basePlacement) { 16881 var offsets = [0, 0]; 16882 16883 // Use height if placement is left or right and index is 0 otherwise use width 16884 // in this way the first offset will use an axis and the second one 16885 // will use the other one 16886 var useHeight = ['right', 'left'].indexOf(basePlacement) !== -1; 16887 16888 // Split the offset string to obtain a list of values and operands 16889 // The regex addresses values with the plus or minus sign in front (+10, -20, etc) 16890 var fragments = offset.split(/(\+|\-)/).map(function (frag) { 16891 return frag.trim(); 16892 }); 16893 16894 // Detect if the offset string contains a pair of values or a single one 16895 // they could be separated by comma or space 16896 var divider = fragments.indexOf(find(fragments, function (frag) { 16897 return frag.search(/,|\s/) !== -1; 16898 })); 16899 16900 if (fragments[divider] && fragments[divider].indexOf(',') === -1) { 16901 console.warn('Offsets separated by white space(s) are deprecated, use a comma (,) instead.'); 16902 } 16903 16904 // If divider is found, we divide the list of values and operands to divide 16905 // them by ofset X and Y. 16906 var splitRegex = /\s*,\s*|\s+/; 16907 var ops = divider !== -1 ? [fragments.slice(0, divider).concat([fragments[divider].split(splitRegex)[0]]), [fragments[divider].split(splitRegex)[1]].concat(fragments.slice(divider + 1))] : [fragments]; 16908 16909 // Convert the values with units to absolute pixels to allow our computations 16910 ops = ops.map(function (op, index) { 16911 // Most of the units rely on the orientation of the popper 16912 var measurement = (index === 1 ? !useHeight : useHeight) ? 'height' : 'width'; 16913 var mergeWithPrevious = false; 16914 return op 16915 // This aggregates any `+` or `-` sign that aren't considered operators 16916 // e.g.: 10 + +5 => [10, +, +5] 16917 .reduce(function (a, b) { 16918 if (a[a.length - 1] === '' && ['+', '-'].indexOf(b) !== -1) { 16919 a[a.length - 1] = b; 16920 mergeWithPrevious = true; 16921 return a; 16922 } else if (mergeWithPrevious) { 16923 a[a.length - 1] += b; 16924 mergeWithPrevious = false; 16925 return a; 16926 } else { 16927 return a.concat(b); 16928 } 16929 }, []) 16930 // Here we convert the string values into number values (in px) 16931 .map(function (str) { 16932 return toValue(str, measurement, popperOffsets, referenceOffsets); 16933 }); 16934 }); 16935 16936 // Loop trough the offsets arrays and execute the operations 16937 ops.forEach(function (op, index) { 16938 op.forEach(function (frag, index2) { 16939 if (isNumeric(frag)) { 16940 offsets[index] += frag * (op[index2 - 1] === '-' ? -1 : 1); 16941 } 16942 }); 16943 }); 16944 return offsets; 16945} 16946 16947/** 16948 * @function 16949 * @memberof Modifiers 16950 * @argument {Object} data - The data object generated by update method 16951 * @argument {Object} options - Modifiers configuration and options 16952 * @argument {Number|String} options.offset=0 16953 * The offset value as described in the modifier description 16954 * @returns {Object} The data object, properly modified 16955 */ 16956function offset(data, _ref) { 16957 var offset = _ref.offset; 16958 var placement = data.placement, 16959 _data$offsets = data.offsets, 16960 popper = _data$offsets.popper, 16961 reference = _data$offsets.reference; 16962 16963 var basePlacement = placement.split('-')[0]; 16964 16965 var offsets = void 0; 16966 if (isNumeric(+offset)) { 16967 offsets = [+offset, 0]; 16968 } else { 16969 offsets = parseOffset(offset, popper, reference, basePlacement); 16970 } 16971 16972 if (basePlacement === 'left') { 16973 popper.top += offsets[0]; 16974 popper.left -= offsets[1]; 16975 } else if (basePlacement === 'right') { 16976 popper.top += offsets[0]; 16977 popper.left += offsets[1]; 16978 } else if (basePlacement === 'top') { 16979 popper.left += offsets[0]; 16980 popper.top -= offsets[1]; 16981 } else if (basePlacement === 'bottom') { 16982 popper.left += offsets[0]; 16983 popper.top += offsets[1]; 16984 } 16985 16986 data.popper = popper; 16987 return data; 16988} 16989 16990/** 16991 * @function 16992 * @memberof Modifiers 16993 * @argument {Object} data - The data object generated by `update` method 16994 * @argument {Object} options - Modifiers configuration and options 16995 * @returns {Object} The data object, properly modified 16996 */ 16997function preventOverflow(data, options) { 16998 var boundariesElement = options.boundariesElement || getOffsetParent(data.instance.popper); 16999 17000 // If offsetParent is the reference element, we really want to 17001 // go one step up and use the next offsetParent as reference to 17002 // avoid to make this modifier completely useless and look like broken 17003 if (data.instance.reference === boundariesElement) { 17004 boundariesElement = getOffsetParent(boundariesElement); 17005 } 17006 17007 // NOTE: DOM access here 17008 // resets the popper's position so that the document size can be calculated excluding 17009 // the size of the popper element itself 17010 var transformProp = getSupportedPropertyName('transform'); 17011 var popperStyles = data.instance.popper.style; // assignment to help minification 17012 var top = popperStyles.top, 17013 left = popperStyles.left, 17014 transform = popperStyles[transformProp]; 17015 17016 popperStyles.top = ''; 17017 popperStyles.left = ''; 17018 popperStyles[transformProp] = ''; 17019 17020 var boundaries = getBoundaries(data.instance.popper, data.instance.reference, options.padding, boundariesElement, data.positionFixed); 17021 17022 // NOTE: DOM access here 17023 // restores the original style properties after the offsets have been computed 17024 popperStyles.top = top; 17025 popperStyles.left = left; 17026 popperStyles[transformProp] = transform; 17027 17028 options.boundaries = boundaries; 17029 17030 var order = options.priority; 17031 var popper = data.offsets.popper; 17032 17033 var check = { 17034 primary: function primary(placement) { 17035 var value = popper[placement]; 17036 if (popper[placement] < boundaries[placement] && !options.escapeWithReference) { 17037 value = Math.max(popper[placement], boundaries[placement]); 17038 } 17039 return defineProperty({}, placement, value); 17040 }, 17041 secondary: function secondary(placement) { 17042 var mainSide = placement === 'right' ? 'left' : 'top'; 17043 var value = popper[mainSide]; 17044 if (popper[placement] > boundaries[placement] && !options.escapeWithReference) { 17045 value = Math.min(popper[mainSide], boundaries[placement] - (placement === 'right' ? popper.width : popper.height)); 17046 } 17047 return defineProperty({}, mainSide, value); 17048 } 17049 }; 17050 17051 order.forEach(function (placement) { 17052 var side = ['left', 'top'].indexOf(placement) !== -1 ? 'primary' : 'secondary'; 17053 popper = _extends({}, popper, check[side](placement)); 17054 }); 17055 17056 data.offsets.popper = popper; 17057 17058 return data; 17059} 17060 17061/** 17062 * @function 17063 * @memberof Modifiers 17064 * @argument {Object} data - The data object generated by `update` method 17065 * @argument {Object} options - Modifiers configuration and options 17066 * @returns {Object} The data object, properly modified 17067 */ 17068function shift(data) { 17069 var placement = data.placement; 17070 var basePlacement = placement.split('-')[0]; 17071 var shiftvariation = placement.split('-')[1]; 17072 17073 // if shift shiftvariation is specified, run the modifier 17074 if (shiftvariation) { 17075 var _data$offsets = data.offsets, 17076 reference = _data$offsets.reference, 17077 popper = _data$offsets.popper; 17078 17079 var isVertical = ['bottom', 'top'].indexOf(basePlacement) !== -1; 17080 var side = isVertical ? 'left' : 'top'; 17081 var measurement = isVertical ? 'width' : 'height'; 17082 17083 var shiftOffsets = { 17084 start: defineProperty({}, side, reference[side]), 17085 end: defineProperty({}, side, reference[side] + reference[measurement] - popper[measurement]) 17086 }; 17087 17088 data.offsets.popper = _extends({}, popper, shiftOffsets[shiftvariation]); 17089 } 17090 17091 return data; 17092} 17093 17094/** 17095 * @function 17096 * @memberof Modifiers 17097 * @argument {Object} data - The data object generated by update method 17098 * @argument {Object} options - Modifiers configuration and options 17099 * @returns {Object} The data object, properly modified 17100 */ 17101function hide(data) { 17102 if (!isModifierRequired(data.instance.modifiers, 'hide', 'preventOverflow')) { 17103 return data; 17104 } 17105 17106 var refRect = data.offsets.reference; 17107 var bound = find(data.instance.modifiers, function (modifier) { 17108 return modifier.name === 'preventOverflow'; 17109 }).boundaries; 17110 17111 if (refRect.bottom < bound.top || refRect.left > bound.right || refRect.top > bound.bottom || refRect.right < bound.left) { 17112 // Avoid unnecessary DOM access if visibility hasn't changed 17113 if (data.hide === true) { 17114 return data; 17115 } 17116 17117 data.hide = true; 17118 data.attributes['x-out-of-boundaries'] = ''; 17119 } else { 17120 // Avoid unnecessary DOM access if visibility hasn't changed 17121 if (data.hide === false) { 17122 return data; 17123 } 17124 17125 data.hide = false; 17126 data.attributes['x-out-of-boundaries'] = false; 17127 } 17128 17129 return data; 17130} 17131 17132/** 17133 * @function 17134 * @memberof Modifiers 17135 * @argument {Object} data - The data object generated by `update` method 17136 * @argument {Object} options - Modifiers configuration and options 17137 * @returns {Object} The data object, properly modified 17138 */ 17139function inner(data) { 17140 var placement = data.placement; 17141 var basePlacement = placement.split('-')[0]; 17142 var _data$offsets = data.offsets, 17143 popper = _data$offsets.popper, 17144 reference = _data$offsets.reference; 17145 17146 var isHoriz = ['left', 'right'].indexOf(basePlacement) !== -1; 17147 17148 var subtractLength = ['top', 'left'].indexOf(basePlacement) === -1; 17149 17150 popper[isHoriz ? 'left' : 'top'] = reference[basePlacement] - (subtractLength ? popper[isHoriz ? 'width' : 'height'] : 0); 17151 17152 data.placement = getOppositePlacement(placement); 17153 data.offsets.popper = getClientRect(popper); 17154 17155 return data; 17156} 17157 17158/** 17159 * Modifier function, each modifier can have a function of this type assigned 17160 * to its `fn` property.<br /> 17161 * These functions will be called on each update, this means that you must 17162 * make sure they are performant enough to avoid performance bottlenecks. 17163 * 17164 * @function ModifierFn 17165 * @argument {dataObject} data - The data object generated by `update` method 17166 * @argument {Object} options - Modifiers configuration and options 17167 * @returns {dataObject} The data object, properly modified 17168 */ 17169 17170/** 17171 * Modifiers are plugins used to alter the behavior of your poppers.<br /> 17172 * Popper.js uses a set of 9 modifiers to provide all the basic functionalities 17173 * needed by the library. 17174 * 17175 * Usually you don't want to override the `order`, `fn` and `onLoad` props. 17176 * All the other properties are configurations that could be tweaked. 17177 * @namespace modifiers 17178 */ 17179var modifiers = { 17180 /** 17181 * Modifier used to shift the popper on the start or end of its reference 17182 * element.<br /> 17183 * It will read the variation of the `placement` property.<br /> 17184 * It can be one either `-end` or `-start`. 17185 * @memberof modifiers 17186 * @inner 17187 */ 17188 shift: { 17189 /** @prop {number} order=100 - Index used to define the order of execution */ 17190 order: 100, 17191 /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */ 17192 enabled: true, 17193 /** @prop {ModifierFn} */ 17194 fn: shift 17195 }, 17196 17197 /** 17198 * The `offset` modifier can shift your popper on both its axis. 17199 * 17200 * It accepts the following units: 17201 * - `px` or unit-less, interpreted as pixels 17202 * - `%` or `%r`, percentage relative to the length of the reference element 17203 * - `%p`, percentage relative to the length of the popper element 17204 * - `vw`, CSS viewport width unit 17205 * - `vh`, CSS viewport height unit 17206 * 17207 * For length is intended the main axis relative to the placement of the popper.<br /> 17208 * This means that if the placement is `top` or `bottom`, the length will be the 17209 * `width`. In case of `left` or `right`, it will be the `height`. 17210 * 17211 * You can provide a single value (as `Number` or `String`), or a pair of values 17212 * as `String` divided by a comma or one (or more) white spaces.<br /> 17213 * The latter is a deprecated method because it leads to confusion and will be 17214 * removed in v2.<br /> 17215 * Additionally, it accepts additions and subtractions between different units. 17216 * Note that multiplications and divisions aren't supported. 17217 * 17218 * Valid examples are: 17219 * ``` 17220 * 10 17221 * '10%' 17222 * '10, 10' 17223 * '10%, 10' 17224 * '10 + 10%' 17225 * '10 - 5vh + 3%' 17226 * '-10px + 5vh, 5px - 6%' 17227 * ``` 17228 * > **NB**: If you desire to apply offsets to your poppers in a way that may make them overlap 17229 * > with their reference element, unfortunately, you will have to disable the `flip` modifier. 17230 * > You can read more on this at this [issue](https://github.com/FezVrasta/popper.js/issues/373). 17231 * 17232 * @memberof modifiers 17233 * @inner 17234 */ 17235 offset: { 17236 /** @prop {number} order=200 - Index used to define the order of execution */ 17237 order: 200, 17238 /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */ 17239 enabled: true, 17240 /** @prop {ModifierFn} */ 17241 fn: offset, 17242 /** @prop {Number|String} offset=0 17243 * The offset value as described in the modifier description 17244 */ 17245 offset: 0 17246 }, 17247 17248 /** 17249 * Modifier used to prevent the popper from being positioned outside the boundary. 17250 * 17251 * A scenario exists where the reference itself is not within the boundaries.<br /> 17252 * We can say it has "escaped the boundaries" — or just "escaped".<br /> 17253 * In this case we need to decide whether the popper should either: 17254 * 17255 * - detach from the reference and remain "trapped" in the boundaries, or 17256 * - if it should ignore the boundary and "escape with its reference" 17257 * 17258 * When `escapeWithReference` is set to`true` and reference is completely 17259 * outside its boundaries, the popper will overflow (or completely leave) 17260 * the boundaries in order to remain attached to the edge of the reference. 17261 * 17262 * @memberof modifiers 17263 * @inner 17264 */ 17265 preventOverflow: { 17266 /** @prop {number} order=300 - Index used to define the order of execution */ 17267 order: 300, 17268 /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */ 17269 enabled: true, 17270 /** @prop {ModifierFn} */ 17271 fn: preventOverflow, 17272 /** 17273 * @prop {Array} [priority=['left','right','top','bottom']] 17274 * Popper will try to prevent overflow following these priorities by default, 17275 * then, it could overflow on the left and on top of the `boundariesElement` 17276 */ 17277 priority: ['left', 'right', 'top', 'bottom'], 17278 /** 17279 * @prop {number} padding=5 17280 * Amount of pixel used to define a minimum distance between the boundaries 17281 * and the popper. This makes sure the popper always has a little padding 17282 * between the edges of its container 17283 */ 17284 padding: 5, 17285 /** 17286 * @prop {String|HTMLElement} boundariesElement='scrollParent' 17287 * Boundaries used by the modifier. Can be `scrollParent`, `window`, 17288 * `viewport` or any DOM element. 17289 */ 17290 boundariesElement: 'scrollParent' 17291 }, 17292 17293 /** 17294 * Modifier used to make sure the reference and its popper stay near each other 17295 * without leaving any gap between the two. Especially useful when the arrow is 17296 * enabled and you want to ensure that it points to its reference element. 17297 * It cares only about the first axis. You can still have poppers with margin 17298 * between the popper and its reference element. 17299 * @memberof modifiers 17300 * @inner 17301 */ 17302 keepTogether: { 17303 /** @prop {number} order=400 - Index used to define the order of execution */ 17304 order: 400, 17305 /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */ 17306 enabled: true, 17307 /** @prop {ModifierFn} */ 17308 fn: keepTogether 17309 }, 17310 17311 /** 17312 * This modifier is used to move the `arrowElement` of the popper to make 17313 * sure it is positioned between the reference element and its popper element. 17314 * It will read the outer size of the `arrowElement` node to detect how many 17315 * pixels of conjunction are needed. 17316 * 17317 * It has no effect if no `arrowElement` is provided. 17318 * @memberof modifiers 17319 * @inner 17320 */ 17321 arrow: { 17322 /** @prop {number} order=500 - Index used to define the order of execution */ 17323 order: 500, 17324 /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */ 17325 enabled: true, 17326 /** @prop {ModifierFn} */ 17327 fn: arrow, 17328 /** @prop {String|HTMLElement} element='[x-arrow]' - Selector or node used as arrow */ 17329 element: '[x-arrow]' 17330 }, 17331 17332 /** 17333 * Modifier used to flip the popper's placement when it starts to overlap its 17334 * reference element. 17335 * 17336 * Requires the `preventOverflow` modifier before it in order to work. 17337 * 17338 * **NOTE:** this modifier will interrupt the current update cycle and will 17339 * restart it if it detects the need to flip the placement. 17340 * @memberof modifiers 17341 * @inner 17342 */ 17343 flip: { 17344 /** @prop {number} order=600 - Index used to define the order of execution */ 17345 order: 600, 17346 /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */ 17347 enabled: true, 17348 /** @prop {ModifierFn} */ 17349 fn: flip, 17350 /** 17351 * @prop {String|Array} behavior='flip' 17352 * The behavior used to change the popper's placement. It can be one of 17353 * `flip`, `clockwise`, `counterclockwise` or an array with a list of valid 17354 * placements (with optional variations) 17355 */ 17356 behavior: 'flip', 17357 /** 17358 * @prop {number} padding=5 17359 * The popper will flip if it hits the edges of the `boundariesElement` 17360 */ 17361 padding: 5, 17362 /** 17363 * @prop {String|HTMLElement} boundariesElement='viewport' 17364 * The element which will define the boundaries of the popper position. 17365 * The popper will never be placed outside of the defined boundaries 17366 * (except if `keepTogether` is enabled) 17367 */ 17368 boundariesElement: 'viewport', 17369 /** 17370 * @prop {Boolean} flipVariations=false 17371 * The popper will switch placement variation between `-start` and `-end` when 17372 * the reference element overlaps its boundaries. 17373 * 17374 * The original placement should have a set variation. 17375 */ 17376 flipVariations: false, 17377 /** 17378 * @prop {Boolean} flipVariationsByContent=false 17379 * The popper will switch placement variation between `-start` and `-end` when 17380 * the popper element overlaps its reference boundaries. 17381 * 17382 * The original placement should have a set variation. 17383 */ 17384 flipVariationsByContent: false 17385 }, 17386 17387 /** 17388 * Modifier used to make the popper flow toward the inner of the reference element. 17389 * By default, when this modifier is disabled, the popper will be placed outside 17390 * the reference element. 17391 * @memberof modifiers 17392 * @inner 17393 */ 17394 inner: { 17395 /** @prop {number} order=700 - Index used to define the order of execution */ 17396 order: 700, 17397 /** @prop {Boolean} enabled=false - Whether the modifier is enabled or not */ 17398 enabled: false, 17399 /** @prop {ModifierFn} */ 17400 fn: inner 17401 }, 17402 17403 /** 17404 * Modifier used to hide the popper when its reference element is outside of the 17405 * popper boundaries. It will set a `x-out-of-boundaries` attribute which can 17406 * be used to hide with a CSS selector the popper when its reference is 17407 * out of boundaries. 17408 * 17409 * Requires the `preventOverflow` modifier before it in order to work. 17410 * @memberof modifiers 17411 * @inner 17412 */ 17413 hide: { 17414 /** @prop {number} order=800 - Index used to define the order of execution */ 17415 order: 800, 17416 /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */ 17417 enabled: true, 17418 /** @prop {ModifierFn} */ 17419 fn: hide 17420 }, 17421 17422 /** 17423 * Computes the style that will be applied to the popper element to gets 17424 * properly positioned. 17425 * 17426 * Note that this modifier will not touch the DOM, it just prepares the styles 17427 * so that `applyStyle` modifier can apply it. This separation is useful 17428 * in case you need to replace `applyStyle` with a custom implementation. 17429 * 17430 * This modifier has `850` as `order` value to maintain backward compatibility 17431 * with previous versions of Popper.js. Expect the modifiers ordering method 17432 * to change in future major versions of the library. 17433 * 17434 * @memberof modifiers 17435 * @inner 17436 */ 17437 computeStyle: { 17438 /** @prop {number} order=850 - Index used to define the order of execution */ 17439 order: 850, 17440 /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */ 17441 enabled: true, 17442 /** @prop {ModifierFn} */ 17443 fn: computeStyle, 17444 /** 17445 * @prop {Boolean} gpuAcceleration=true 17446 * If true, it uses the CSS 3D transformation to position the popper. 17447 * Otherwise, it will use the `top` and `left` properties 17448 */ 17449 gpuAcceleration: true, 17450 /** 17451 * @prop {string} [x='bottom'] 17452 * Where to anchor the X axis (`bottom` or `top`). AKA X offset origin. 17453 * Change this if your popper should grow in a direction different from `bottom` 17454 */ 17455 x: 'bottom', 17456 /** 17457 * @prop {string} [x='left'] 17458 * Where to anchor the Y axis (`left` or `right`). AKA Y offset origin. 17459 * Change this if your popper should grow in a direction different from `right` 17460 */ 17461 y: 'right' 17462 }, 17463 17464 /** 17465 * Applies the computed styles to the popper element. 17466 * 17467 * All the DOM manipulations are limited to this modifier. This is useful in case 17468 * you want to integrate Popper.js inside a framework or view library and you 17469 * want to delegate all the DOM manipulations to it. 17470 * 17471 * Note that if you disable this modifier, you must make sure the popper element 17472 * has its position set to `absolute` before Popper.js can do its work! 17473 * 17474 * Just disable this modifier and define your own to achieve the desired effect. 17475 * 17476 * @memberof modifiers 17477 * @inner 17478 */ 17479 applyStyle: { 17480 /** @prop {number} order=900 - Index used to define the order of execution */ 17481 order: 900, 17482 /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */ 17483 enabled: true, 17484 /** @prop {ModifierFn} */ 17485 fn: applyStyle, 17486 /** @prop {Function} */ 17487 onLoad: applyStyleOnLoad, 17488 /** 17489 * @deprecated since version 1.10.0, the property moved to `computeStyle` modifier 17490 * @prop {Boolean} gpuAcceleration=true 17491 * If true, it uses the CSS 3D transformation to position the popper. 17492 * Otherwise, it will use the `top` and `left` properties 17493 */ 17494 gpuAcceleration: undefined 17495 } 17496}; 17497 17498/** 17499 * The `dataObject` is an object containing all the information used by Popper.js. 17500 * This object is passed to modifiers and to the `onCreate` and `onUpdate` callbacks. 17501 * @name dataObject 17502 * @property {Object} data.instance The Popper.js instance 17503 * @property {String} data.placement Placement applied to popper 17504 * @property {String} data.originalPlacement Placement originally defined on init 17505 * @property {Boolean} data.flipped True if popper has been flipped by flip modifier 17506 * @property {Boolean} data.hide True if the reference element is out of boundaries, useful to know when to hide the popper 17507 * @property {HTMLElement} data.arrowElement Node used as arrow by arrow modifier 17508 * @property {Object} data.styles Any CSS property defined here will be applied to the popper. It expects the JavaScript nomenclature (eg. `marginBottom`) 17509 * @property {Object} data.arrowStyles Any CSS property defined here will be applied to the popper arrow. It expects the JavaScript nomenclature (eg. `marginBottom`) 17510 * @property {Object} data.boundaries Offsets of the popper boundaries 17511 * @property {Object} data.offsets The measurements of popper, reference and arrow elements 17512 * @property {Object} data.offsets.popper `top`, `left`, `width`, `height` values 17513 * @property {Object} data.offsets.reference `top`, `left`, `width`, `height` values 17514 * @property {Object} data.offsets.arrow] `top` and `left` offsets, only one of them will be different from 0 17515 */ 17516 17517/** 17518 * Default options provided to Popper.js constructor.<br /> 17519 * These can be overridden using the `options` argument of Popper.js.<br /> 17520 * To override an option, simply pass an object with the same 17521 * structure of the `options` object, as the 3rd argument. For example: 17522 * ``` 17523 * new Popper(ref, pop, { 17524 * modifiers: { 17525 * preventOverflow: { enabled: false } 17526 * } 17527 * }) 17528 * ``` 17529 * @type {Object} 17530 * @static 17531 * @memberof Popper 17532 */ 17533var Defaults = { 17534 /** 17535 * Popper's placement. 17536 * @prop {Popper.placements} placement='bottom' 17537 */ 17538 placement: 'bottom', 17539 17540 /** 17541 * Set this to true if you want popper to position it self in 'fixed' mode 17542 * @prop {Boolean} positionFixed=false 17543 */ 17544 positionFixed: false, 17545 17546 /** 17547 * Whether events (resize, scroll) are initially enabled. 17548 * @prop {Boolean} eventsEnabled=true 17549 */ 17550 eventsEnabled: true, 17551 17552 /** 17553 * Set to true if you want to automatically remove the popper when 17554 * you call the `destroy` method. 17555 * @prop {Boolean} removeOnDestroy=false 17556 */ 17557 removeOnDestroy: false, 17558 17559 /** 17560 * Callback called when the popper is created.<br /> 17561 * By default, it is set to no-op.<br /> 17562 * Access Popper.js instance with `data.instance`. 17563 * @prop {onCreate} 17564 */ 17565 onCreate: function onCreate() {}, 17566 17567 /** 17568 * Callback called when the popper is updated. This callback is not called 17569 * on the initialization/creation of the popper, but only on subsequent 17570 * updates.<br /> 17571 * By default, it is set to no-op.<br /> 17572 * Access Popper.js instance with `data.instance`. 17573 * @prop {onUpdate} 17574 */ 17575 onUpdate: function onUpdate() {}, 17576 17577 /** 17578 * List of modifiers used to modify the offsets before they are applied to the popper. 17579 * They provide most of the functionalities of Popper.js. 17580 * @prop {modifiers} 17581 */ 17582 modifiers: modifiers 17583}; 17584 17585/** 17586 * @callback onCreate 17587 * @param {dataObject} data 17588 */ 17589 17590/** 17591 * @callback onUpdate 17592 * @param {dataObject} data 17593 */ 17594 17595// Utils 17596// Methods 17597var Popper = function () { 17598 /** 17599 * Creates a new Popper.js instance. 17600 * @class Popper 17601 * @param {Element|referenceObject} reference - The reference element used to position the popper 17602 * @param {Element} popper - The HTML / XML element used as the popper 17603 * @param {Object} options - Your custom options to override the ones defined in [Defaults](#defaults) 17604 * @return {Object} instance - The generated Popper.js instance 17605 */ 17606 function Popper(reference, popper) { 17607 var _this = this; 17608 17609 var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {}; 17610 classCallCheck(this, Popper); 17611 17612 this.scheduleUpdate = function () { 17613 return requestAnimationFrame(_this.update); 17614 }; 17615 17616 // make update() debounced, so that it only runs at most once-per-tick 17617 this.update = debounce(this.update.bind(this)); 17618 17619 // with {} we create a new object with the options inside it 17620 this.options = _extends({}, Popper.Defaults, options); 17621 17622 // init state 17623 this.state = { 17624 isDestroyed: false, 17625 isCreated: false, 17626 scrollParents: [] 17627 }; 17628 17629 // get reference and popper elements (allow jQuery wrappers) 17630 this.reference = reference && reference.jquery ? reference[0] : reference; 17631 this.popper = popper && popper.jquery ? popper[0] : popper; 17632 17633 // Deep merge modifiers options 17634 this.options.modifiers = {}; 17635 Object.keys(_extends({}, Popper.Defaults.modifiers, options.modifiers)).forEach(function (name) { 17636 _this.options.modifiers[name] = _extends({}, Popper.Defaults.modifiers[name] || {}, options.modifiers ? options.modifiers[name] : {}); 17637 }); 17638 17639 // Refactoring modifiers' list (Object => Array) 17640 this.modifiers = Object.keys(this.options.modifiers).map(function (name) { 17641 return _extends({ 17642 name: name 17643 }, _this.options.modifiers[name]); 17644 }) 17645 // sort the modifiers by order 17646 .sort(function (a, b) { 17647 return a.order - b.order; 17648 }); 17649 17650 // modifiers have the ability to execute arbitrary code when Popper.js get inited 17651 // such code is executed in the same order of its modifier 17652 // they could add new properties to their options configuration 17653 // BE AWARE: don't add options to `options.modifiers.name` but to `modifierOptions`! 17654 this.modifiers.forEach(function (modifierOptions) { 17655 if (modifierOptions.enabled && isFunction(modifierOptions.onLoad)) { 17656 modifierOptions.onLoad(_this.reference, _this.popper, _this.options, modifierOptions, _this.state); 17657 } 17658 }); 17659 17660 // fire the first update to position the popper in the right place 17661 this.update(); 17662 17663 var eventsEnabled = this.options.eventsEnabled; 17664 if (eventsEnabled) { 17665 // setup event listeners, they will take care of update the position in specific situations 17666 this.enableEventListeners(); 17667 } 17668 17669 this.state.eventsEnabled = eventsEnabled; 17670 } 17671 17672 // We can't use class properties because they don't get listed in the 17673 // class prototype and break stuff like Sinon stubs 17674 17675 17676 createClass(Popper, [{ 17677 key: 'update', 17678 value: function update$$1() { 17679 return update.call(this); 17680 } 17681 }, { 17682 key: 'destroy', 17683 value: function destroy$$1() { 17684 return destroy.call(this); 17685 } 17686 }, { 17687 key: 'enableEventListeners', 17688 value: function enableEventListeners$$1() { 17689 return enableEventListeners.call(this); 17690 } 17691 }, { 17692 key: 'disableEventListeners', 17693 value: function disableEventListeners$$1() { 17694 return disableEventListeners.call(this); 17695 } 17696 17697 /** 17698 * Schedules an update. It will run on the next UI update available. 17699 * @method scheduleUpdate 17700 * @memberof Popper 17701 */ 17702 17703 17704 /** 17705 * Collection of utilities useful when writing custom modifiers. 17706 * Starting from version 1.7, this method is available only if you 17707 * include `popper-utils.js` before `popper.js`. 17708 * 17709 * **DEPRECATION**: This way to access PopperUtils is deprecated 17710 * and will be removed in v2! Use the PopperUtils module directly instead. 17711 * Due to the high instability of the methods contained in Utils, we can't 17712 * guarantee them to follow semver. Use them at your own risk! 17713 * @static 17714 * @private 17715 * @type {Object} 17716 * @deprecated since version 1.8 17717 * @member Utils 17718 * @memberof Popper 17719 */ 17720 17721 }]); 17722 return Popper; 17723}(); 17724 17725/** 17726 * The `referenceObject` is an object that provides an interface compatible with Popper.js 17727 * and lets you use it as replacement of a real DOM node.<br /> 17728 * You can use this method to position a popper relatively to a set of coordinates 17729 * in case you don't have a DOM node to use as reference. 17730 * 17731 * ``` 17732 * new Popper(referenceObject, popperNode); 17733 * ``` 17734 * 17735 * NB: This feature isn't supported in Internet Explorer 10. 17736 * @name referenceObject 17737 * @property {Function} data.getBoundingClientRect 17738 * A function that returns a set of coordinates compatible with the native `getBoundingClientRect` method. 17739 * @property {number} data.clientWidth 17740 * An ES6 getter that will return the width of the virtual reference element. 17741 * @property {number} data.clientHeight 17742 * An ES6 getter that will return the height of the virtual reference element. 17743 */ 17744 17745 17746Popper.Utils = (typeof window !== 'undefined' ? window : __webpack_require__.g).PopperUtils; 17747Popper.placements = placements; 17748Popper.Defaults = Defaults; 17749 17750/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (Popper); 17751//# sourceMappingURL=popper.js.d41d8cd98f00.map 17752 17753 17754/***/ }), 17755
vendor: 837 bytes, lines 17756-17777
17756/***/ "./node_modules/lodash-es/_Symbol.js": 17757/*!*******************************************!*\ 17758 !*** ./node_modules/lodash-es/_Symbol.js ***! 17759 \*******************************************/ 17760/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => { 17761 17762"use strict"; 17763__webpack_require__.r(__webpack_exports__); 17764/* harmony export */ __webpack_require__.d(__webpack_exports__, { 17765/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) 17766/* harmony export */ }); 17767/* harmony import */ var _root_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./_root.js */ "./node_modules/lodash-es/_root.js"); 17768 17769 17770/** Built-in value references. */ 17771var Symbol = _root_js__WEBPACK_IMPORTED_MODULE_0__["default"].Symbol; 17772 17773/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (Symbol); 17774 17775 17776/***/ }), 17777
vendor: 1,906 bytes, lines 17778-17823
17778/***/ "./node_modules/lodash-es/_baseGetTag.js": 17779/*!***********************************************!*\ 17780 !*** ./node_modules/lodash-es/_baseGetTag.js ***! 17781 \***********************************************/ 17782/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => { 17783 17784"use strict"; 17785__webpack_require__.r(__webpack_exports__); 17786/* harmony export */ __webpack_require__.d(__webpack_exports__, { 17787/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) 17788/* harmony export */ }); 17789/* harmony import */ var _Symbol_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./_Symbol.js */ "./node_modules/lodash-es/_Symbol.js"); 17790/* harmony import */ var _getRawTag_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./_getRawTag.js */ "./node_modules/lodash-es/_getRawTag.js"); 17791/* harmony import */ var _objectToString_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./_objectToString.js */ "./node_modules/lodash-es/_objectToString.js"); 17792 17793 17794 17795 17796/** `Object#toString` result references. */ 17797var nullTag = '[object Null]', 17798 undefinedTag = '[object Undefined]'; 17799 17800/** Built-in value references. */ 17801var symToStringTag = _Symbol_js__WEBPACK_IMPORTED_MODULE_0__["default"] ? _Symbol_js__WEBPACK_IMPORTED_MODULE_0__["default"].toStringTag : undefined; 17802 17803/** 17804 * The base implementation of `getTag` without fallbacks for buggy environments. 17805 * 17806 * @private 17807 * @param {*} value The value to query. 17808 * @returns {string} Returns the `toStringTag`. 17809 */ 17810function baseGetTag(value) { 17811 if (value == null) { 17812 return value === undefined ? undefinedTag : nullTag; 17813 } 17814 return (symToStringTag && symToStringTag in Object(value)) 17815 ? (0,_getRawTag_js__WEBPACK_IMPORTED_MODULE_1__["default"])(value) 17816 : (0,_objectToString_js__WEBPACK_IMPORTED_MODULE_2__["default"])(value); 17817} 17818 17819/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (baseGetTag); 17820 17821 17822/***/ }), 17823
vendor: 1,186 bytes, lines 17824-17858
17824/***/ "./node_modules/lodash-es/_baseTrim.js": 17825/*!*********************************************!*\ 17826 !*** ./node_modules/lodash-es/_baseTrim.js ***! 17827 \*********************************************/ 17828/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => { 17829 17830"use strict"; 17831__webpack_require__.r(__webpack_exports__); 17832/* harmony export */ __webpack_require__.d(__webpack_exports__, { 17833/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) 17834/* harmony export */ }); 17835/* harmony import */ var _trimmedEndIndex_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./_trimmedEndIndex.js */ "./node_modules/lodash-es/_trimmedEndIndex.js"); 17836 17837 17838/** Used to match leading whitespace. */ 17839var reTrimStart = /^\s+/; 17840 17841/** 17842 * The base implementation of `_.trim`. 17843 * 17844 * @private 17845 * @param {string} string The string to trim. 17846 * @returns {string} Returns the trimmed string. 17847 */ 17848function baseTrim(string) { 17849 return string 17850 ? string.slice(0, (0,_trimmedEndIndex_js__WEBPACK_IMPORTED_MODULE_0__["default"])(string) + 1).replace(reTrimStart, '') 17851 : string; 17852} 17853 17854/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (baseTrim); 17855 17856 17857/***/ }), 17858
vendor: 753 bytes, lines 17859-17877
17859/***/ "./node_modules/lodash-es/_freeGlobal.js": 17860/*!***********************************************!*\ 17861 !*** ./node_modules/lodash-es/_freeGlobal.js ***! 17862 \***********************************************/ 17863/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => { 17864 17865"use strict"; 17866__webpack_require__.r(__webpack_exports__); 17867/* harmony export */ __webpack_require__.d(__webpack_exports__, { 17868/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) 17869/* harmony export */ }); 17870/** Detect free variable `global` from Node.js. */ 17871var freeGlobal = typeof global == 'object' && global && global.Object === Object && global; 17872 17873/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (freeGlobal); 17874 17875 17876/***/ }), 17877
vendor: 1,916 bytes, lines 17878-17939
17878/***/ "./node_modules/lodash-es/_getRawTag.js": 17879/*!**********************************************!*\ 17880 !*** ./node_modules/lodash-es/_getRawTag.js ***! 17881 \**********************************************/ 17882/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => { 17883 17884"use strict"; 17885__webpack_require__.r(__webpack_exports__); 17886/* harmony export */ __webpack_require__.d(__webpack_exports__, { 17887/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) 17888/* harmony export */ }); 17889/* harmony import */ var _Symbol_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./_Symbol.js */ "./node_modules/lodash-es/_Symbol.js"); 17890 17891 17892/** Used for built-in method references. */ 17893var objectProto = Object.prototype; 17894 17895/** Used to check objects for own properties. */ 17896var hasOwnProperty = objectProto.hasOwnProperty; 17897 17898/** 17899 * Used to resolve the 17900 * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring) 17901 * of values. 17902 */ 17903var nativeObjectToString = objectProto.toString; 17904 17905/** Built-in value references. */ 17906var symToStringTag = _Symbol_js__WEBPACK_IMPORTED_MODULE_0__["default"] ? _Symbol_js__WEBPACK_IMPORTED_MODULE_0__["default"].toStringTag : undefined; 17907 17908/** 17909 * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values. 17910 * 17911 * @private 17912 * @param {*} value The value to query. 17913 * @returns {string} Returns the raw `toStringTag`. 17914 */ 17915function getRawTag(value) { 17916 var isOwn = hasOwnProperty.call(value, symToStringTag), 17917 tag = value[symToStringTag]; 17918 17919 try { 17920 value[symToStringTag] = undefined; 17921 var unmasked = true; 17922 } catch (e) {} 17923 17924 var result = nativeObjectToString.call(value); 17925 if (unmasked) { 17926 if (isOwn) { 17927 value[symToStringTag] = tag; 17928 } else { 17929 delete value[symToStringTag]; 17930 } 17931 } 17932 return result; 17933} 17934 17935/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (getRawTag); 17936 17937 17938/***/ }), 17939
vendor: 1,161 bytes, lines 17940-17976
17940/***/ "./node_modules/lodash-es/_objectToString.js": 17941/*!***************************************************!*\ 17942 !*** ./node_modules/lodash-es/_objectToString.js ***! 17943 \***************************************************/ 17944/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => { 17945 17946"use strict"; 17947__webpack_require__.r(__webpack_exports__); 17948/* harmony export */ __webpack_require__.d(__webpack_exports__, { 17949/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) 17950/* harmony export */ }); 17951/** Used for built-in method references. */ 17952var objectProto = Object.prototype; 17953 17954/** 17955 * Used to resolve the 17956 * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring) 17957 * of values. 17958 */ 17959var nativeObjectToString = objectProto.toString; 17960 17961/** 17962 * Converts `value` to a string using `Object.prototype.toString`. 17963 * 17964 * @private 17965 * @param {*} value The value to convert. 17966 * @returns {string} Returns the converted string. 17967 */ 17968function objectToString(value) { 17969 return nativeObjectToString.call(value); 17970} 17971 17972/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (objectToString); 17973 17974 17975/***/ }), 17976
vendor: 1,017 bytes, lines 17977-18001
17977/***/ "./node_modules/lodash-es/_root.js": 17978/*!*****************************************!*\ 17979 !*** ./node_modules/lodash-es/_root.js ***! 17980 \*****************************************/ 17981/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => { 17982 17983"use strict"; 17984__webpack_require__.r(__webpack_exports__); 17985/* harmony export */ __webpack_require__.d(__webpack_exports__, { 17986/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) 17987/* harmony export */ }); 17988/* harmony import */ var _freeGlobal_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./_freeGlobal.js */ "./node_modules/lodash-es/_freeGlobal.js"); 17989 17990 17991/** Detect free variable `self`. */ 17992var freeSelf = typeof self == 'object' && self && self.Object === Object && self; 17993 17994/** Used as a reference to the global object. */ 17995var root = _freeGlobal_js__WEBPACK_IMPORTED_MODULE_0__["default"] || freeSelf || Function('return this')(); 17996 17997/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (root); 17998 17999 18000/***/ }), 18001
vendor: 1,115 bytes, lines 18002-18035
18002/***/ "./node_modules/lodash-es/_trimmedEndIndex.js": 18003/*!****************************************************!*\ 18004 !*** ./node_modules/lodash-es/_trimmedEndIndex.js ***! 18005 \****************************************************/ 18006/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => { 18007 18008"use strict"; 18009__webpack_require__.r(__webpack_exports__); 18010/* harmony export */ __webpack_require__.d(__webpack_exports__, { 18011/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) 18012/* harmony export */ }); 18013/** Used to match a single whitespace character. */ 18014var reWhitespace = /\s/; 18015 18016/** 18017 * Used by `_.trim` and `_.trimEnd` to get the index of the last non-whitespace 18018 * character of `string`. 18019 * 18020 * @private 18021 * @param {string} string The string to inspect. 18022 * @returns {number} Returns the index of the last non-whitespace character. 18023 */ 18024function trimmedEndIndex(string) { 18025 var index = string.length; 18026 18027 while (index-- && reWhitespace.test(string.charAt(index))) {} 18028 return index; 18029} 18030 18031/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (trimmedEndIndex); 18032 18033 18034/***/ }), 18035
vendor: 7,293 bytes, lines 18036-18244
18036/***/ "./node_modules/lodash-es/debounce.js": 18037/*!********************************************!*\ 18038 !*** ./node_modules/lodash-es/debounce.js ***! 18039 \********************************************/ 18040/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => { 18041 18042"use strict"; 18043__webpack_require__.r(__webpack_exports__); 18044/* harmony export */ __webpack_require__.d(__webpack_exports__, { 18045/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) 18046/* harmony export */ }); 18047/* harmony import */ var _isObject_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./isObject.js */ "./node_modules/lodash-es/isObject.js"); 18048/* harmony import */ var _now_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./now.js */ "./node_modules/lodash-es/now.js"); 18049/* harmony import */ var _toNumber_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./toNumber.js */ "./node_modules/lodash-es/toNumber.js"); 18050 18051 18052 18053 18054/** Error message constants. */ 18055var FUNC_ERROR_TEXT = 'Expected a function'; 18056 18057/* Built-in method references for those with the same name as other `lodash` methods. */ 18058var nativeMax = Math.max, 18059 nativeMin = Math.min; 18060 18061/** 18062 * Creates a debounced function that delays invoking `func` until after `wait` 18063 * milliseconds have elapsed since the last time the debounced function was 18064 * invoked. The debounced function comes with a `cancel` method to cancel 18065 * delayed `func` invocations and a `flush` method to immediately invoke them. 18066 * Provide `options` to indicate whether `func` should be invoked on the 18067 * leading and/or trailing edge of the `wait` timeout. The `func` is invoked 18068 * with the last arguments provided to the debounced function. Subsequent 18069 * calls to the debounced function return the result of the last `func` 18070 * invocation. 18071 * 18072 * **Note:** If `leading` and `trailing` options are `true`, `func` is 18073 * invoked on the trailing edge of the timeout only if the debounced function 18074 * is invoked more than once during the `wait` timeout. 18075 * 18076 * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred 18077 * until to the next tick, similar to `setTimeout` with a timeout of `0`. 18078 * 18079 * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/) 18080 * for details over the differences between `_.debounce` and `_.throttle`. 18081 * 18082 * @static 18083 * @memberOf _ 18084 * @since 0.1.0 18085 * @category Function 18086 * @param {Function} func The function to debounce. 18087 * @param {number} [wait=0] The number of milliseconds to delay. 18088 * @param {Object} [options={}] The options object. 18089 * @param {boolean} [options.leading=false] 18090 * Specify invoking on the leading edge of the timeout. 18091 * @param {number} [options.maxWait] 18092 * The maximum time `func` is allowed to be delayed before it's invoked. 18093 * @param {boolean} [options.trailing=true] 18094 * Specify invoking on the trailing edge of the timeout. 18095 * @returns {Function} Returns the new debounced function. 18096 * @example 18097 * 18098 * // Avoid costly calculations while the window size is in flux. 18099 * jQuery(window).on('resize', _.debounce(calculateLayout, 150)); 18100 * 18101 * // Invoke `sendMail` when clicked, debouncing subsequent calls. 18102 * jQuery(element).on('click', _.debounce(sendMail, 300, { 18103 * 'leading': true, 18104 * 'trailing': false 18105 * })); 18106 * 18107 * // Ensure `batchLog` is invoked once after 1 second of debounced calls. 18108 * var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 }); 18109 * var source = new EventSource('/stream'); 18110 * jQuery(source).on('message', debounced); 18111 * 18112 * // Cancel the trailing debounced invocation. 18113 * jQuery(window).on('popstate', debounced.cancel); 18114 */ 18115function debounce(func, wait, options) { 18116 var lastArgs, 18117 lastThis, 18118 maxWait, 18119 result, 18120 timerId, 18121 lastCallTime, 18122 lastInvokeTime = 0, 18123 leading = false, 18124 maxing = false, 18125 trailing = true; 18126 18127 if (typeof func != 'function') { 18128 throw new TypeError(FUNC_ERROR_TEXT); 18129 } 18130 wait = (0,_toNumber_js__WEBPACK_IMPORTED_MODULE_0__["default"])(wait) || 0; 18131 if ((0,_isObject_js__WEBPACK_IMPORTED_MODULE_1__["default"])(options)) { 18132 leading = !!options.leading; 18133 maxing = 'maxWait' in options; 18134 maxWait = maxing ? nativeMax((0,_toNumber_js__WEBPACK_IMPORTED_MODULE_0__["default"])(options.maxWait) || 0, wait) : maxWait; 18135 trailing = 'trailing' in options ? !!options.trailing : trailing; 18136 } 18137 18138 function invokeFunc(time) { 18139 var args = lastArgs, 18140 thisArg = lastThis; 18141 18142 lastArgs = lastThis = undefined; 18143 lastInvokeTime = time; 18144 result = func.apply(thisArg, args); 18145 return result; 18146 } 18147 18148 function leadingEdge(time) { 18149 // Reset any `maxWait` timer. 18150 lastInvokeTime = time; 18151 // Start the timer for the trailing edge. 18152 timerId = setTimeout(timerExpired, wait); 18153 // Invoke the leading edge. 18154 return leading ? invokeFunc(time) : result; 18155 } 18156 18157 function remainingWait(time) { 18158 var timeSinceLastCall = time - lastCallTime, 18159 timeSinceLastInvoke = time - lastInvokeTime, 18160 timeWaiting = wait - timeSinceLastCall; 18161 18162 return maxing 18163 ? nativeMin(timeWaiting, maxWait - timeSinceLastInvoke) 18164 : timeWaiting; 18165 } 18166 18167 function shouldInvoke(time) { 18168 var timeSinceLastCall = time - lastCallTime, 18169 timeSinceLastInvoke = time - lastInvokeTime; 18170 18171 // Either this is the first call, activity has stopped and we're at the 18172 // trailing edge, the system time has gone backwards and we're treating 18173 // it as the trailing edge, or we've hit the `maxWait` limit. 18174 return (lastCallTime === undefined || (timeSinceLastCall >= wait) || 18175 (timeSinceLastCall < 0) || (maxing && timeSinceLastInvoke >= maxWait)); 18176 } 18177 18178 function timerExpired() { 18179 var time = (0,_now_js__WEBPACK_IMPORTED_MODULE_2__["default"])(); 18180 if (shouldInvoke(time)) { 18181 return trailingEdge(time); 18182 } 18183 // Restart the timer. 18184 timerId = setTimeout(timerExpired, remainingWait(time)); 18185 } 18186 18187 function trailingEdge(time) { 18188 timerId = undefined; 18189 18190 // Only invoke if we have `lastArgs` which means `func` has been 18191 // debounced at least once. 18192 if (trailing && lastArgs) { 18193 return invokeFunc(time); 18194 } 18195 lastArgs = lastThis = undefined; 18196 return result; 18197 } 18198 18199 function cancel() { 18200 if (timerId !== undefined) { 18201 clearTimeout(timerId); 18202 } 18203 lastInvokeTime = 0; 18204 lastArgs = lastCallTime = lastThis = timerId = undefined; 18205 } 18206 18207 function flush() { 18208 return timerId === undefined ? result : trailingEdge((0,_now_js__WEBPACK_IMPORTED_MODULE_2__["default"])()); 18209 } 18210 18211 function debounced() { 18212 var time = (0,_now_js__WEBPACK_IMPORTED_MODULE_2__["default"])(), 18213 isInvoking = shouldInvoke(time); 18214 18215 lastArgs = arguments; 18216 lastThis = this; 18217 lastCallTime = time; 18218 18219 if (isInvoking) { 18220 if (timerId === undefined) { 18221 return leadingEdge(lastCallTime); 18222 } 18223 if (maxing) { 18224 // Handle invocations in a tight loop. 18225 clearTimeout(timerId); 18226 timerId = setTimeout(timerExpired, wait); 18227 return invokeFunc(lastCallTime); 18228 } 18229 } 18230 if (timerId === undefined) { 18231 timerId = setTimeout(timerExpired, wait); 18232 } 18233 return result; 18234 } 18235 debounced.cancel = cancel; 18236 debounced.flush = flush; 18237 return debounced; 18238} 18239 18240/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (debounce); 18241 18242 18243/***/ }), 18244
vendor: 1,301 bytes, lines 18245-18290
18245/***/ "./node_modules/lodash-es/isObject.js": 18246/*!********************************************!*\ 18247 !*** ./node_modules/lodash-es/isObject.js ***! 18248 \********************************************/ 18249/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => { 18250 18251"use strict"; 18252__webpack_require__.r(__webpack_exports__); 18253/* harmony export */ __webpack_require__.d(__webpack_exports__, { 18254/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) 18255/* harmony export */ }); 18256/** 18257 * Checks if `value` is the 18258 * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types) 18259 * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`) 18260 * 18261 * @static 18262 * @memberOf _ 18263 * @since 0.1.0 18264 * @category Lang 18265 * @param {*} value The value to check. 18266 * @returns {boolean} Returns `true` if `value` is an object, else `false`. 18267 * @example 18268 * 18269 * _.isObject({}); 18270 * // => true 18271 * 18272 * _.isObject([1, 2, 3]); 18273 * // => true 18274 * 18275 * _.isObject(_.noop); 18276 * // => true 18277 * 18278 * _.isObject(null); 18279 * // => false 18280 */ 18281function isObject(value) { 18282 var type = typeof value; 18283 return value != null && (type == 'object' || type == 'function'); 18284} 18285 18286/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (isObject); 18287 18288 18289/***/ }), 18290
vendor: 1,198 bytes, lines 18291-18334
18291/***/ "./node_modules/lodash-es/isObjectLike.js": 18292/*!************************************************!*\ 18293 !*** ./node_modules/lodash-es/isObjectLike.js ***! 18294 \************************************************/ 18295/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => { 18296 18297"use strict"; 18298__webpack_require__.r(__webpack_exports__); 18299/* harmony export */ __webpack_require__.d(__webpack_exports__, { 18300/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) 18301/* harmony export */ }); 18302/** 18303 * Checks if `value` is object-like. A value is object-like if it's not `null` 18304 * and has a `typeof` result of "object". 18305 * 18306 * @static 18307 * @memberOf _ 18308 * @since 4.0.0 18309 * @category Lang 18310 * @param {*} value The value to check. 18311 * @returns {boolean} Returns `true` if `value` is object-like, else `false`. 18312 * @example 18313 * 18314 * _.isObjectLike({}); 18315 * // => true 18316 * 18317 * _.isObjectLike([1, 2, 3]); 18318 * // => true 18319 * 18320 * _.isObjectLike(_.noop); 18321 * // => false 18322 * 18323 * _.isObjectLike(null); 18324 * // => false 18325 */ 18326function isObjectLike(value) { 18327 return value != null && typeof value == 'object'; 18328} 18329 18330/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (isObjectLike); 18331 18332 18333/***/ }), 18334
vendor: 1,581 bytes, lines 18335-18380
18335/***/ "./node_modules/lodash-es/isSymbol.js": 18336/*!********************************************!*\ 18337 !*** ./node_modules/lodash-es/isSymbol.js ***! 18338 \********************************************/ 18339/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => { 18340 18341"use strict"; 18342__webpack_require__.r(__webpack_exports__); 18343/* harmony export */ __webpack_require__.d(__webpack_exports__, { 18344/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) 18345/* harmony export */ }); 18346/* harmony import */ var _baseGetTag_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./_baseGetTag.js */ "./node_modules/lodash-es/_baseGetTag.js"); 18347/* harmony import */ var _isObjectLike_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./isObjectLike.js */ "./node_modules/lodash-es/isObjectLike.js"); 18348 18349 18350 18351/** `Object#toString` result references. */ 18352var symbolTag = '[object Symbol]'; 18353 18354/** 18355 * Checks if `value` is classified as a `Symbol` primitive or object. 18356 * 18357 * @static 18358 * @memberOf _ 18359 * @since 4.0.0 18360 * @category Lang 18361 * @param {*} value The value to check. 18362 * @returns {boolean} Returns `true` if `value` is a symbol, else `false`. 18363 * @example 18364 * 18365 * _.isSymbol(Symbol.iterator); 18366 * // => true 18367 * 18368 * _.isSymbol('abc'); 18369 * // => false 18370 */ 18371function isSymbol(value) { 18372 return typeof value == 'symbol' || 18373 ((0,_isObjectLike_js__WEBPACK_IMPORTED_MODULE_0__["default"])(value) && (0,_baseGetTag_js__WEBPACK_IMPORTED_MODULE_1__["default"])(value) == symbolTag); 18374} 18375 18376/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (isSymbol); 18377 18378 18379/***/ }), 18380
vendor: 1,223 bytes, lines 18381-18419
18381/***/ "./node_modules/lodash-es/now.js": 18382/*!***************************************!*\ 18383 !*** ./node_modules/lodash-es/now.js ***! 18384 \***************************************/ 18385/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => { 18386 18387"use strict"; 18388__webpack_require__.r(__webpack_exports__); 18389/* harmony export */ __webpack_require__.d(__webpack_exports__, { 18390/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) 18391/* harmony export */ }); 18392/* harmony import */ var _root_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./_root.js */ "./node_modules/lodash-es/_root.js"); 18393 18394 18395/** 18396 * Gets the timestamp of the number of milliseconds that have elapsed since 18397 * the Unix epoch (1 January 1970 00:00:00 UTC). 18398 * 18399 * @static 18400 * @memberOf _ 18401 * @since 2.4.0 18402 * @category Date 18403 * @returns {number} Returns the timestamp. 18404 * @example 18405 * 18406 * _.defer(function(stamp) { 18407 * console.log(_.now() - stamp); 18408 * }, _.now()); 18409 * // => Logs the number of milliseconds it took for the deferred invocation. 18410 */ 18411var now = function() { 18412 return _root_js__WEBPACK_IMPORTED_MODULE_0__["default"].Date.now(); 18413}; 18414 18415/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (now); 18416 18417 18418/***/ }), 18419
vendor: 3,601 bytes, lines 18420-18505
18420/***/ "./node_modules/lodash-es/throttle.js": 18421/*!********************************************!*\ 18422 !*** ./node_modules/lodash-es/throttle.js ***! 18423 \********************************************/ 18424/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => { 18425 18426"use strict"; 18427__webpack_require__.r(__webpack_exports__); 18428/* harmony export */ __webpack_require__.d(__webpack_exports__, { 18429/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) 18430/* harmony export */ }); 18431/* harmony import */ var _debounce_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./debounce.js */ "./node_modules/lodash-es/debounce.js"); 18432/* harmony import */ var _isObject_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./isObject.js */ "./node_modules/lodash-es/isObject.js"); 18433 18434 18435 18436/** Error message constants. */ 18437var FUNC_ERROR_TEXT = 'Expected a function'; 18438 18439/** 18440 * Creates a throttled function that only invokes `func` at most once per 18441 * every `wait` milliseconds. The throttled function comes with a `cancel` 18442 * method to cancel delayed `func` invocations and a `flush` method to 18443 * immediately invoke them. Provide `options` to indicate whether `func` 18444 * should be invoked on the leading and/or trailing edge of the `wait` 18445 * timeout. The `func` is invoked with the last arguments provided to the 18446 * throttled function. Subsequent calls to the throttled function return the 18447 * result of the last `func` invocation. 18448 * 18449 * **Note:** If `leading` and `trailing` options are `true`, `func` is 18450 * invoked on the trailing edge of the timeout only if the throttled function 18451 * is invoked more than once during the `wait` timeout. 18452 * 18453 * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred 18454 * until to the next tick, similar to `setTimeout` with a timeout of `0`. 18455 * 18456 * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/) 18457 * for details over the differences between `_.throttle` and `_.debounce`. 18458 * 18459 * @static 18460 * @memberOf _ 18461 * @since 0.1.0 18462 * @category Function 18463 * @param {Function} func The function to throttle. 18464 * @param {number} [wait=0] The number of milliseconds to throttle invocations to. 18465 * @param {Object} [options={}] The options object. 18466 * @param {boolean} [options.leading=true] 18467 * Specify invoking on the leading edge of the timeout. 18468 * @param {boolean} [options.trailing=true] 18469 * Specify invoking on the trailing edge of the timeout. 18470 * @returns {Function} Returns the new throttled function. 18471 * @example 18472 * 18473 * // Avoid excessively updating the position while scrolling. 18474 * jQuery(window).on('scroll', _.throttle(updatePosition, 100)); 18475 * 18476 * // Invoke `renewToken` when the click event is fired, but not more than once every 5 minutes. 18477 * var throttled = _.throttle(renewToken, 300000, { 'trailing': false }); 18478 * jQuery(element).on('click', throttled); 18479 * 18480 * // Cancel the trailing throttled invocation. 18481 * jQuery(window).on('popstate', throttled.cancel); 18482 */ 18483function throttle(func, wait, options) { 18484 var leading = true, 18485 trailing = true; 18486 18487 if (typeof func != 'function') { 18488 throw new TypeError(FUNC_ERROR_TEXT); 18489 } 18490 if ((0,_isObject_js__WEBPACK_IMPORTED_MODULE_0__["default"])(options)) { 18491 leading = 'leading' in options ? !!options.leading : leading; 18492 trailing = 'trailing' in options ? !!options.trailing : trailing; 18493 } 18494 return (0,_debounce_js__WEBPACK_IMPORTED_MODULE_1__["default"])(func, wait, { 18495 'leading': leading, 18496 'maxWait': wait, 18497 'trailing': trailing 18498 }); 18499} 18500 18501/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (throttle); 18502 18503 18504/***/ }), 18505
vendor: 2,622 bytes, lines 18506-18587
18506/***/ "./node_modules/lodash-es/toNumber.js": 18507/*!********************************************!*\ 18508 !*** ./node_modules/lodash-es/toNumber.js ***! 18509 \********************************************/ 18510/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => { 18511 18512"use strict"; 18513__webpack_require__.r(__webpack_exports__); 18514/* harmony export */ __webpack_require__.d(__webpack_exports__, { 18515/* harmony export */ "default": () => (__WEBPACK_DEFAULT_EXPORT__) 18516/* harmony export */ }); 18517/* harmony import */ var _baseTrim_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./_baseTrim.js */ "./node_modules/lodash-es/_baseTrim.js"); 18518/* harmony import */ var _isObject_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./isObject.js */ "./node_modules/lodash-es/isObject.js"); 18519/* harmony import */ var _isSymbol_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./isSymbol.js */ "./node_modules/lodash-es/isSymbol.js"); 18520 18521 18522 18523 18524/** Used as references for various `Number` constants. */ 18525var NAN = 0 / 0; 18526 18527/** Used to detect bad signed hexadecimal string values. */ 18528var reIsBadHex = /^[-+]0x[0-9a-f]+$/i; 18529 18530/** Used to detect binary string values. */ 18531var reIsBinary = /^0b[01]+$/i; 18532 18533/** Used to detect octal string values. */ 18534var reIsOctal = /^0o[0-7]+$/i; 18535 18536/** Built-in method references without a dependency on `root`. */ 18537var freeParseInt = parseInt; 18538 18539/** 18540 * Converts `value` to a number. 18541 * 18542 * @static 18543 * @memberOf _ 18544 * @since 4.0.0 18545 * @category Lang 18546 * @param {*} value The value to process. 18547 * @returns {number} Returns the number. 18548 * @example 18549 * 18550 * _.toNumber(3.2); 18551 * // => 3.2 18552 * 18553 * _.toNumber(Number.MIN_VALUE); 18554 * // => 5e-324 18555 * 18556 * _.toNumber(Infinity); 18557 * // => Infinity 18558 * 18559 * _.toNumber('3.2'); 18560 * // => 3.2 18561 */ 18562function toNumber(value) { 18563 if (typeof value == 'number') { 18564 return value; 18565 } 18566 if ((0,_isSymbol_js__WEBPACK_IMPORTED_MODULE_0__["default"])(value)) { 18567 return NAN; 18568 } 18569 if ((0,_isObject_js__WEBPACK_IMPORTED_MODULE_1__["default"])(value)) { 18570 var other = typeof value.valueOf == 'function' ? value.valueOf() : value; 18571 value = (0,_isObject_js__WEBPACK_IMPORTED_MODULE_1__["default"])(other) ? (other + '') : other; 18572 } 18573 if (typeof value != 'string') { 18574 return value === 0 ? value : +value; 18575 } 18576 value = (0,_baseTrim_js__WEBPACK_IMPORTED_MODULE_2__["default"])(value); 18577 var isBinary = reIsBinary.test(value); 18578 return (isBinary || reIsOctal.test(value)) 18579 ? freeParseInt(value.slice(2), isBinary ? 2 : 8) 18580 : (reIsBadHex.test(value) ? NAN : +value); 18581} 18582 18583/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (toNumber); 18584 18585 18586/***/ }), 18587
vendor: 42,008 bytes, lines 18588-19523
18588/***/ "./node_modules/simplebar-core/dist/index.mjs": 18589/*!****************************************************!*\ 18590 !*** ./node_modules/simplebar-core/dist/index.mjs ***! 18591 \****************************************************/ 18592/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => { 18593 18594"use strict"; 18595__webpack_require__.r(__webpack_exports__); 18596/* harmony export */ __webpack_require__.d(__webpack_exports__, { 18597/* harmony export */ "default": () => (/* binding */ SimpleBarCore) 18598/* harmony export */ }); 18599/* harmony import */ var lodash_es__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! lodash-es */ "./node_modules/lodash-es/throttle.js"); 18600/* harmony import */ var lodash_es__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! lodash-es */ "./node_modules/lodash-es/debounce.js"); 18601/* harmony import */ var can_use_dom__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! can-use-dom */ "./node_modules/can-use-dom/index.js"); 18602/** 18603 * simplebar-core - v1.2.4 18604 * Scrollbars, simpler. 18605 * https://grsmto.github.io/simplebar/ 18606 * 18607 * Made by Adrien Denat from a fork by Jonathan Nicol 18608 * Under MIT License 18609 */ 18610 18611 18612 18613 18614/****************************************************************************** 18615Copyright (c) Microsoft Corporation. 18616 18617Permission to use, copy, modify, and/or distribute this software for any 18618purpose with or without fee is hereby granted. 18619 18620THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH 18621REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY 18622AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, 18623INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM 18624LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR 18625OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR 18626PERFORMANCE OF THIS SOFTWARE. 18627***************************************************************************** */ 18628 18629var __assign = function() { 18630 __assign = Object.assign || function __assign(t) { 18631 for (var s, i = 1, n = arguments.length; i < n; i++) { 18632 s = arguments[i]; 18633 for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p]; 18634 } 18635 return t; 18636 }; 18637 return __assign.apply(this, arguments); 18638}; 18639 18640var cachedScrollbarWidth = null; 18641var cachedDevicePixelRatio = null; 18642if (can_use_dom__WEBPACK_IMPORTED_MODULE_0__) { 18643 window.addEventListener('resize', function () { 18644 if (cachedDevicePixelRatio !== window.devicePixelRatio) { 18645 cachedDevicePixelRatio = window.devicePixelRatio; 18646 cachedScrollbarWidth = null; 18647 } 18648 }); 18649} 18650function scrollbarWidth() { 18651 if (cachedScrollbarWidth === null) { 18652 if (typeof document === 'undefined') { 18653 cachedScrollbarWidth = 0; 18654 return cachedScrollbarWidth; 18655 } 18656 var body = document.body; 18657 var box = document.createElement('div'); 18658 box.classList.add('simplebar-hide-scrollbar'); 18659 body.appendChild(box); 18660 var width = box.getBoundingClientRect().right; 18661 body.removeChild(box); 18662 cachedScrollbarWidth = width; 18663 } 18664 return cachedScrollbarWidth; 18665} 18666 18667function getElementWindow$1(element) { 18668 if (!element || 18669 !element.ownerDocument || 18670 !element.ownerDocument.defaultView) { 18671 return window; 18672 } 18673 return element.ownerDocument.defaultView; 18674} 18675function getElementDocument$1(element) { 18676 if (!element || !element.ownerDocument) { 18677 return document; 18678 } 18679 return element.ownerDocument; 18680} 18681// Helper function to retrieve options from element attributes 18682var getOptions$1 = function (obj) { 18683 var initialObj = {}; 18684 var options = Array.prototype.reduce.call(obj, function (acc, attribute) { 18685 var option = attribute.name.match(/data-simplebar-(.+)/); 18686 if (option) { 18687 var key = option[1].replace(/\W+(.)/g, function (_, chr) { return chr.toUpperCase(); }); 18688 switch (attribute.value) { 18689 case 'true': 18690 acc[key] = true; 18691 break; 18692 case 'false': 18693 acc[key] = false; 18694 break; 18695 case undefined: 18696 acc[key] = true; 18697 break; 18698 default: 18699 acc[key] = attribute.value; 18700 } 18701 } 18702 return acc; 18703 }, initialObj); 18704 return options; 18705}; 18706function addClasses$1(el, classes) { 18707 var _a; 18708 if (!el) 18709 return; 18710 (_a = el.classList).add.apply(_a, classes.split(' ')); 18711} 18712function removeClasses$1(el, classes) { 18713 if (!el) 18714 return; 18715 classes.split(' ').forEach(function (className) { 18716 el.classList.remove(className); 18717 }); 18718} 18719function classNamesToQuery$1(classNames) { 18720 return ".".concat(classNames.split(' ').join('.')); 18721} 18722 18723var helpers = /*#__PURE__*/Object.freeze({ 18724 __proto__: null, 18725 getElementWindow: getElementWindow$1, 18726 getElementDocument: getElementDocument$1, 18727 getOptions: getOptions$1, 18728 addClasses: addClasses$1, 18729 removeClasses: removeClasses$1, 18730 classNamesToQuery: classNamesToQuery$1 18731}); 18732 18733var getElementWindow = getElementWindow$1, getElementDocument = getElementDocument$1, getOptions = getOptions$1, addClasses = addClasses$1, removeClasses = removeClasses$1, classNamesToQuery = classNamesToQuery$1; 18734var SimpleBarCore = /** @class */ (function () { 18735 function SimpleBarCore(element, options) { 18736 if (options === void 0) { options = {}; } 18737 var _this = this; 18738 this.removePreventClickId = null; 18739 this.minScrollbarWidth = 20; 18740 this.stopScrollDelay = 175; 18741 this.isScrolling = false; 18742 this.isMouseEntering = false; 18743 this.scrollXTicking = false; 18744 this.scrollYTicking = false; 18745 this.wrapperEl = null; 18746 this.contentWrapperEl = null; 18747 this.contentEl = null; 18748 this.offsetEl = null; 18749 this.maskEl = null; 18750 this.placeholderEl = null; 18751 this.heightAutoObserverWrapperEl = null; 18752 this.heightAutoObserverEl = null; 18753 this.rtlHelpers = null; 18754 this.scrollbarWidth = 0; 18755 this.resizeObserver = null; 18756 this.mutationObserver = null; 18757 this.elStyles = null; 18758 this.isRtl = null; 18759 this.mouseX = 0; 18760 this.mouseY = 0; 18761 this.onMouseMove = function () { }; 18762 this.onWindowResize = function () { }; 18763 this.onStopScrolling = function () { }; 18764 this.onMouseEntered = function () { }; 18765 /** 18766 * On scroll event handling 18767 */ 18768 this.onScroll = function () { 18769 var elWindow = getElementWindow(_this.el); 18770 if (!_this.scrollXTicking) { 18771 elWindow.requestAnimationFrame(_this.scrollX); 18772 _this.scrollXTicking = true; 18773 } 18774 if (!_this.scrollYTicking) { 18775 elWindow.requestAnimationFrame(_this.scrollY); 18776 _this.scrollYTicking = true; 18777 } 18778 if (!_this.isScrolling) { 18779 _this.isScrolling = true; 18780 addClasses(_this.el, _this.classNames.scrolling); 18781 } 18782 _this.showScrollbar('x'); 18783 _this.showScrollbar('y'); 18784 _this.onStopScrolling(); 18785 }; 18786 this.scrollX = function () { 18787 if (_this.axis.x.isOverflowing) { 18788 _this.positionScrollbar('x'); 18789 } 18790 _this.scrollXTicking = false; 18791 }; 18792 this.scrollY = function () { 18793 if (_this.axis.y.isOverflowing) { 18794 _this.positionScrollbar('y'); 18795 } 18796 _this.scrollYTicking = false; 18797 }; 18798 this._onStopScrolling = function () { 18799 removeClasses(_this.el, _this.classNames.scrolling); 18800 if (_this.options.autoHide) { 18801 _this.hideScrollbar('x'); 18802 _this.hideScrollbar('y'); 18803 } 18804 _this.isScrolling = false; 18805 }; 18806 this.onMouseEnter = function () { 18807 if (!_this.isMouseEntering) { 18808 addClasses(_this.el, _this.classNames.mouseEntered); 18809 _this.showScrollbar('x'); 18810 _this.showScrollbar('y'); 18811 _this.isMouseEntering = true; 18812 } 18813 _this.onMouseEntered(); 18814 }; 18815 this._onMouseEntered = function () { 18816 removeClasses(_this.el, _this.classNames.mouseEntered); 18817 if (_this.options.autoHide) { 18818 _this.hideScrollbar('x'); 18819 _this.hideScrollbar('y'); 18820 } 18821 _this.isMouseEntering = false; 18822 }; 18823 this._onMouseMove = function (e) { 18824 _this.mouseX = e.clientX; 18825 _this.mouseY = e.clientY; 18826 if (_this.axis.x.isOverflowing || _this.axis.x.forceVisible) { 18827 _this.onMouseMoveForAxis('x'); 18828 } 18829 if (_this.axis.y.isOverflowing || _this.axis.y.forceVisible) { 18830 _this.onMouseMoveForAxis('y'); 18831 } 18832 }; 18833 this.onMouseLeave = function () { 18834 _this.onMouseMove.cancel(); 18835 if (_this.axis.x.isOverflowing || _this.axis.x.forceVisible) { 18836 _this.onMouseLeaveForAxis('x'); 18837 } 18838 if (_this.axis.y.isOverflowing || _this.axis.y.forceVisible) { 18839 _this.onMouseLeaveForAxis('y'); 18840 } 18841 _this.mouseX = -1; 18842 _this.mouseY = -1; 18843 }; 18844 this._onWindowResize = function () { 18845 // Recalculate scrollbarWidth in case it's a zoom 18846 _this.scrollbarWidth = _this.getScrollbarWidth(); 18847 _this.hideNativeScrollbar(); 18848 }; 18849 this.onPointerEvent = function (e) { 18850 if (!_this.axis.x.track.el || 18851 !_this.axis.y.track.el || 18852 !_this.axis.x.scrollbar.el || 18853 !_this.axis.y.scrollbar.el) 18854 return; 18855 var isWithinTrackXBounds, isWithinTrackYBounds; 18856 _this.axis.x.track.rect = _this.axis.x.track.el.getBoundingClientRect(); 18857 _this.axis.y.track.rect = _this.axis.y.track.el.getBoundingClientRect(); 18858 if (_this.axis.x.isOverflowing || _this.axis.x.forceVisible) { 18859 isWithinTrackXBounds = _this.isWithinBounds(_this.axis.x.track.rect); 18860 } 18861 if (_this.axis.y.isOverflowing || _this.axis.y.forceVisible) { 18862 isWithinTrackYBounds = _this.isWithinBounds(_this.axis.y.track.rect); 18863 } 18864 // If any pointer event is called on the scrollbar 18865 if (isWithinTrackXBounds || isWithinTrackYBounds) { 18866 // Prevent event leaking 18867 e.stopPropagation(); 18868 if (e.type === 'pointerdown' && e.pointerType !== 'touch') { 18869 if (isWithinTrackXBounds) { 18870 _this.axis.x.scrollbar.rect = 18871 _this.axis.x.scrollbar.el.getBoundingClientRect(); 18872 if (_this.isWithinBounds(_this.axis.x.scrollbar.rect)) { 18873 _this.onDragStart(e, 'x'); 18874 } 18875 else { 18876 _this.onTrackClick(e, 'x'); 18877 } 18878 } 18879 if (isWithinTrackYBounds) { 18880 _this.axis.y.scrollbar.rect = 18881 _this.axis.y.scrollbar.el.getBoundingClientRect(); 18882 if (_this.isWithinBounds(_this.axis.y.scrollbar.rect)) { 18883 _this.onDragStart(e, 'y'); 18884 } 18885 else { 18886 _this.onTrackClick(e, 'y'); 18887 } 18888 } 18889 } 18890 } 18891 }; 18892 /** 18893 * Drag scrollbar handle 18894 */ 18895 this.drag = function (e) { 18896 var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l; 18897 if (!_this.draggedAxis || !_this.contentWrapperEl) 18898 return; 18899 var eventOffset; 18900 var track = _this.axis[_this.draggedAxis].track; 18901 var trackSize = (_b = (_a = track.rect) === null || _a === void 0 ? void 0 : _a[_this.axis[_this.draggedAxis].sizeAttr]) !== null && _b !== void 0 ? _b : 0; 18902 var scrollbar = _this.axis[_this.draggedAxis].scrollbar; 18903 var contentSize = (_d = (_c = _this.contentWrapperEl) === null || _c === void 0 ? void 0 : _c[_this.axis[_this.draggedAxis].scrollSizeAttr]) !== null && _d !== void 0 ? _d : 0; 18904 var hostSize = parseInt((_f = (_e = _this.elStyles) === null || _e === void 0 ? void 0 : _e[_this.axis[_this.draggedAxis].sizeAttr]) !== null && _f !== void 0 ? _f : '0px', 10); 18905 e.preventDefault(); 18906 e.stopPropagation(); 18907 if (_this.draggedAxis === 'y') { 18908 eventOffset = e.pageY; 18909 } 18910 else { 18911 eventOffset = e.pageX; 18912 } 18913 // Calculate how far the user's mouse is from the top/left of the scrollbar (minus the dragOffset). 18914 var dragPos = eventOffset - 18915 ((_h = (_g = track.rect) === null || _g === void 0 ? void 0 : _g[_this.axis[_this.draggedAxis].offsetAttr]) !== null && _h !== void 0 ? _h : 0) - 18916 _this.axis[_this.draggedAxis].dragOffset; 18917 dragPos = _this.draggedAxis === 'x' && _this.isRtl 18918 ? ((_k = (_j = track.rect) === null || _j === void 0 ? void 0 : _j[_this.axis[_this.draggedAxis].sizeAttr]) !== null && _k !== void 0 ? _k : 0) - 18919 scrollbar.size - 18920 dragPos 18921 : dragPos; 18922 // Convert the mouse position into a percentage of the scrollbar height/width. 18923 var dragPerc = dragPos / (trackSize - scrollbar.size); 18924 // Scroll the content by the same percentage. 18925 var scrollPos = dragPerc * (contentSize - hostSize); 18926 // Fix browsers inconsistency on RTL 18927 if (_this.draggedAxis === 'x' && _this.isRtl) { 18928 scrollPos = ((_l = SimpleBarCore.getRtlHelpers()) === null || _l === void 0 ? void 0 : _l.isScrollingToNegative) 18929 ? -scrollPos 18930 : scrollPos; 18931 } 18932 _this.contentWrapperEl[_this.axis[_this.draggedAxis].scrollOffsetAttr] = 18933 scrollPos; 18934 }; 18935 /** 18936 * End scroll handle drag 18937 */ 18938 this.onEndDrag = function (e) { 18939 var elDocument = getElementDocument(_this.el); 18940 var elWindow = getElementWindow(_this.el); 18941 e.preventDefault(); 18942 e.stopPropagation(); 18943 removeClasses(_this.el, _this.classNames.dragging); 18944 elDocument.removeEventListener('mousemove', _this.drag, true); 18945 elDocument.removeEventListener('mouseup', _this.onEndDrag, true); 18946 _this.removePreventClickId = elWindow.setTimeout(function () { 18947 // Remove these asynchronously so we still suppress click events 18948 // generated simultaneously with mouseup. 18949 elDocument.removeEventListener('click', _this.preventClick, true); 18950 elDocument.removeEventListener('dblclick', _this.preventClick, true); 18951 _this.removePreventClickId = null; 18952 }); 18953 }; 18954 /** 18955 * Handler to ignore click events during drag 18956 */ 18957 this.preventClick = function (e) { 18958 e.preventDefault(); 18959 e.stopPropagation(); 18960 }; 18961 this.el = element; 18962 this.options = __assign(__assign({}, SimpleBarCore.defaultOptions), options); 18963 this.classNames = __assign(__assign({}, SimpleBarCore.defaultOptions.classNames), options.classNames); 18964 this.axis = { 18965 x: { 18966 scrollOffsetAttr: 'scrollLeft', 18967 sizeAttr: 'width', 18968 scrollSizeAttr: 'scrollWidth', 18969 offsetSizeAttr: 'offsetWidth', 18970 offsetAttr: 'left', 18971 overflowAttr: 'overflowX', 18972 dragOffset: 0, 18973 isOverflowing: true, 18974 forceVisible: false, 18975 track: { size: null, el: null, rect: null, isVisible: false }, 18976 scrollbar: { size: null, el: null, rect: null, isVisible: false } 18977 }, 18978 y: { 18979 scrollOffsetAttr: 'scrollTop', 18980 sizeAttr: 'height', 18981 scrollSizeAttr: 'scrollHeight', 18982 offsetSizeAttr: 'offsetHeight', 18983 offsetAttr: 'top', 18984 overflowAttr: 'overflowY', 18985 dragOffset: 0, 18986 isOverflowing: true, 18987 forceVisible: false, 18988 track: { size: null, el: null, rect: null, isVisible: false }, 18989 scrollbar: { size: null, el: null, rect: null, isVisible: false } 18990 } 18991 }; 18992 if (typeof this.el !== 'object' || !this.el.nodeName) { 18993 throw new Error("Argument passed to SimpleBar must be an HTML element instead of ".concat(this.el)); 18994 } 18995 this.onMouseMove = (0,lodash_es__WEBPACK_IMPORTED_MODULE_1__["default"])(this._onMouseMove, 64); 18996 this.onWindowResize = (0,lodash_es__WEBPACK_IMPORTED_MODULE_2__["default"])(this._onWindowResize, 64, { leading: true }); 18997 this.onStopScrolling = (0,lodash_es__WEBPACK_IMPORTED_MODULE_2__["default"])(this._onStopScrolling, this.stopScrollDelay); 18998 this.onMouseEntered = (0,lodash_es__WEBPACK_IMPORTED_MODULE_2__["default"])(this._onMouseEntered, this.stopScrollDelay); 18999 this.init(); 19000 } 19001 /** 19002 * Helper to fix browsers inconsistency on RTL: 19003 * - Firefox inverts the scrollbar initial position 19004 * - IE11 inverts both scrollbar position and scrolling offset 19005 * Directly inspired by @KingSora's OverlayScrollbars https://github.com/KingSora/OverlayScrollbars/blob/master/js/OverlayScrollbars.js#L1634 19006 */ 19007 SimpleBarCore.getRtlHelpers = function () { 19008 if (SimpleBarCore.rtlHelpers) { 19009 return SimpleBarCore.rtlHelpers; 19010 } 19011 var dummyDiv = document.createElement('div'); 19012 dummyDiv.innerHTML = 19013 '<div class="simplebar-dummy-scrollbar-size"><div></div></div>'; 19014 var scrollbarDummyEl = dummyDiv.firstElementChild; 19015 var dummyChild = scrollbarDummyEl === null || scrollbarDummyEl === void 0 ? void 0 : scrollbarDummyEl.firstElementChild; 19016 if (!dummyChild) 19017 return null; 19018 document.body.appendChild(scrollbarDummyEl); 19019 scrollbarDummyEl.scrollLeft = 0; 19020 var dummyContainerOffset = SimpleBarCore.getOffset(scrollbarDummyEl); 19021 var dummyChildOffset = SimpleBarCore.getOffset(dummyChild); 19022 scrollbarDummyEl.scrollLeft = -999; 19023 var dummyChildOffsetAfterScroll = SimpleBarCore.getOffset(dummyChild); 19024 document.body.removeChild(scrollbarDummyEl); 19025 SimpleBarCore.rtlHelpers = { 19026 // determines if the scrolling is responding with negative values 19027 isScrollOriginAtZero: dummyContainerOffset.left !== dummyChildOffset.left, 19028 // determines if the origin scrollbar position is inverted or not (positioned on left or right) 19029 isScrollingToNegative: dummyChildOffset.left !== dummyChildOffsetAfterScroll.left 19030 }; 19031 return SimpleBarCore.rtlHelpers; 19032 }; 19033 SimpleBarCore.prototype.getScrollbarWidth = function () { 19034 // Try/catch for FF 56 throwing on undefined computedStyles 19035 try { 19036 // Detect browsers supporting CSS scrollbar styling and do not calculate 19037 if ((this.contentWrapperEl && 19038 getComputedStyle(this.contentWrapperEl, '::-webkit-scrollbar') 19039 .display === 'none') || 19040 'scrollbarWidth' in document.documentElement.style || 19041 '-ms-overflow-style' in document.documentElement.style) { 19042 return 0; 19043 } 19044 else { 19045 return scrollbarWidth(); 19046 } 19047 } 19048 catch (e) { 19049 return scrollbarWidth(); 19050 } 19051 }; 19052 SimpleBarCore.getOffset = function (el) { 19053 var rect = el.getBoundingClientRect(); 19054 var elDocument = getElementDocument(el); 19055 var elWindow = getElementWindow(el); 19056 return { 19057 top: rect.top + 19058 (elWindow.pageYOffset || elDocument.documentElement.scrollTop), 19059 left: rect.left + 19060 (elWindow.pageXOffset || elDocument.documentElement.scrollLeft) 19061 }; 19062 }; 19063 SimpleBarCore.prototype.init = function () { 19064 // We stop here on server-side 19065 if (can_use_dom__WEBPACK_IMPORTED_MODULE_0__) { 19066 this.initDOM(); 19067 this.rtlHelpers = SimpleBarCore.getRtlHelpers(); 19068 this.scrollbarWidth = this.getScrollbarWidth(); 19069 this.recalculate(); 19070 this.initListeners(); 19071 } 19072 }; 19073 SimpleBarCore.prototype.initDOM = function () { 19074 var _a, _b; 19075 // assume that element has his DOM already initiated 19076 this.wrapperEl = this.el.querySelector(classNamesToQuery(this.classNames.wrapper)); 19077 this.contentWrapperEl = 19078 this.options.scrollableNode || 19079 this.el.querySelector(classNamesToQuery(this.classNames.contentWrapper)); 19080 this.contentEl = 19081 this.options.contentNode || 19082 this.el.querySelector(classNamesToQuery(this.classNames.contentEl)); 19083 this.offsetEl = this.el.querySelector(classNamesToQuery(this.classNames.offset)); 19084 this.maskEl = this.el.querySelector(classNamesToQuery(this.classNames.mask)); 19085 this.placeholderEl = this.findChild(this.wrapperEl, classNamesToQuery(this.classNames.placeholder)); 19086 this.heightAutoObserverWrapperEl = this.el.querySelector(classNamesToQuery(this.classNames.heightAutoObserverWrapperEl)); 19087 this.heightAutoObserverEl = this.el.querySelector(classNamesToQuery(this.classNames.heightAutoObserverEl)); 19088 this.axis.x.track.el = this.findChild(this.el, "".concat(classNamesToQuery(this.classNames.track)).concat(classNamesToQuery(this.classNames.horizontal))); 19089 this.axis.y.track.el = this.findChild(this.el, "".concat(classNamesToQuery(this.classNames.track)).concat(classNamesToQuery(this.classNames.vertical))); 19090 this.axis.x.scrollbar.el = 19091 ((_a = this.axis.x.track.el) === null || _a === void 0 ? void 0 : _a.querySelector(classNamesToQuery(this.classNames.scrollbar))) || null; 19092 this.axis.y.scrollbar.el = 19093 ((_b = this.axis.y.track.el) === null || _b === void 0 ? void 0 : _b.querySelector(classNamesToQuery(this.classNames.scrollbar))) || null; 19094 if (!this.options.autoHide) { 19095 addClasses(this.axis.x.scrollbar.el, this.classNames.visible); 19096 addClasses(this.axis.y.scrollbar.el, this.classNames.visible); 19097 } 19098 }; 19099 SimpleBarCore.prototype.initListeners = function () { 19100 var _this = this; 19101 var _a; 19102 var elWindow = getElementWindow(this.el); 19103 // Event listeners 19104 this.el.addEventListener('mouseenter', this.onMouseEnter); 19105 this.el.addEventListener('pointerdown', this.onPointerEvent, true); 19106 this.el.addEventListener('mousemove', this.onMouseMove); 19107 this.el.addEventListener('mouseleave', this.onMouseLeave); 19108 (_a = this.contentWrapperEl) === null || _a === void 0 ? void 0 : _a.addEventListener('scroll', this.onScroll); 19109 // Browser zoom triggers a window resize 19110 elWindow.addEventListener('resize', this.onWindowResize); 19111 if (!this.contentEl) 19112 return; 19113 if (window.ResizeObserver) { 19114 // Hack for https://github.com/WICG/ResizeObserver/issues/38 19115 var resizeObserverStarted_1 = false; 19116 var resizeObserver = elWindow.ResizeObserver || ResizeObserver; 19117 this.resizeObserver = new resizeObserver(function () { 19118 if (!resizeObserverStarted_1) 19119 return; 19120 elWindow.requestAnimationFrame(function () { 19121 _this.recalculate(); 19122 }); 19123 }); 19124 this.resizeObserver.observe(this.el); 19125 this.resizeObserver.observe(this.contentEl); 19126 elWindow.requestAnimationFrame(function () { 19127 resizeObserverStarted_1 = true; 19128 }); 19129 } 19130 // This is required to detect horizontal scroll. Vertical scroll only needs the resizeObserver. 19131 this.mutationObserver = new elWindow.MutationObserver(function () { 19132 elWindow.requestAnimationFrame(function () { 19133 _this.recalculate(); 19134 }); 19135 }); 19136 this.mutationObserver.observe(this.contentEl, { 19137 childList: true, 19138 subtree: true, 19139 characterData: true 19140 }); 19141 }; 19142 SimpleBarCore.prototype.recalculate = function () { 19143 if (!this.heightAutoObserverEl || 19144 !this.contentEl || 19145 !this.contentWrapperEl || 19146 !this.wrapperEl || 19147 !this.placeholderEl) 19148 return; 19149 var elWindow = getElementWindow(this.el); 19150 this.elStyles = elWindow.getComputedStyle(this.el); 19151 this.isRtl = this.elStyles.direction === 'rtl'; 19152 var contentElOffsetWidth = this.contentEl.offsetWidth; 19153 var isHeightAuto = this.heightAutoObserverEl.offsetHeight <= 1; 19154 var isWidthAuto = this.heightAutoObserverEl.offsetWidth <= 1 || contentElOffsetWidth > 0; 19155 var contentWrapperElOffsetWidth = this.contentWrapperEl.offsetWidth; 19156 var elOverflowX = this.elStyles.overflowX; 19157 var elOverflowY = this.elStyles.overflowY; 19158 this.contentEl.style.padding = "".concat(this.elStyles.paddingTop, " ").concat(this.elStyles.paddingRight, " ").concat(this.elStyles.paddingBottom, " ").concat(this.elStyles.paddingLeft); 19159 this.wrapperEl.style.margin = "-".concat(this.elStyles.paddingTop, " -").concat(this.elStyles.paddingRight, " -").concat(this.elStyles.paddingBottom, " -").concat(this.elStyles.paddingLeft); 19160 var contentElScrollHeight = this.contentEl.scrollHeight; 19161 var contentElScrollWidth = this.contentEl.scrollWidth; 19162 this.contentWrapperEl.style.height = isHeightAuto ? 'auto' : '100%'; 19163 // Determine placeholder size 19164 this.placeholderEl.style.width = isWidthAuto 19165 ? "".concat(contentElOffsetWidth || contentElScrollWidth, "px") 19166 : 'auto'; 19167 this.placeholderEl.style.height = "".concat(contentElScrollHeight, "px"); 19168 var contentWrapperElOffsetHeight = this.contentWrapperEl.offsetHeight; 19169 this.axis.x.isOverflowing = 19170 contentElOffsetWidth !== 0 && contentElScrollWidth > contentElOffsetWidth; 19171 this.axis.y.isOverflowing = 19172 contentElScrollHeight > contentWrapperElOffsetHeight; 19173 // Set isOverflowing to false if user explicitely set hidden overflow 19174 this.axis.x.isOverflowing = 19175 elOverflowX === 'hidden' ? false : this.axis.x.isOverflowing; 19176 this.axis.y.isOverflowing = 19177 elOverflowY === 'hidden' ? false : this.axis.y.isOverflowing; 19178 this.axis.x.forceVisible = 19179 this.options.forceVisible === 'x' || this.options.forceVisible === true; 19180 this.axis.y.forceVisible = 19181 this.options.forceVisible === 'y' || this.options.forceVisible === true; 19182 this.hideNativeScrollbar(); 19183 // Set isOverflowing to false if scrollbar is not necessary (content is shorter than offset) 19184 var offsetForXScrollbar = this.axis.x.isOverflowing 19185 ? this.scrollbarWidth 19186 : 0; 19187 var offsetForYScrollbar = this.axis.y.isOverflowing 19188 ? this.scrollbarWidth 19189 : 0; 19190 this.axis.x.isOverflowing = 19191 this.axis.x.isOverflowing && 19192 contentElScrollWidth > contentWrapperElOffsetWidth - offsetForYScrollbar; 19193 this.axis.y.isOverflowing = 19194 this.axis.y.isOverflowing && 19195 contentElScrollHeight > 19196 contentWrapperElOffsetHeight - offsetForXScrollbar; 19197 this.axis.x.scrollbar.size = this.getScrollbarSize('x'); 19198 this.axis.y.scrollbar.size = this.getScrollbarSize('y'); 19199 if (this.axis.x.scrollbar.el) 19200 this.axis.x.scrollbar.el.style.width = "".concat(this.axis.x.scrollbar.size, "px"); 19201 if (this.axis.y.scrollbar.el) 19202 this.axis.y.scrollbar.el.style.height = "".concat(this.axis.y.scrollbar.size, "px"); 19203 this.positionScrollbar('x'); 19204 this.positionScrollbar('y'); 19205 this.toggleTrackVisibility('x'); 19206 this.toggleTrackVisibility('y'); 19207 }; 19208 /** 19209 * Calculate scrollbar size 19210 */ 19211 SimpleBarCore.prototype.getScrollbarSize = function (axis) { 19212 var _a, _b; 19213 if (axis === void 0) { axis = 'y'; } 19214 if (!this.axis[axis].isOverflowing || !this.contentEl) { 19215 return 0; 19216 } 19217 var contentSize = this.contentEl[this.axis[axis].scrollSizeAttr]; 19218 var trackSize = (_b = (_a = this.axis[axis].track.el) === null || _a === void 0 ? void 0 : _a[this.axis[axis].offsetSizeAttr]) !== null && _b !== void 0 ? _b : 0; 19219 var scrollbarRatio = trackSize / contentSize; 19220 var scrollbarSize; 19221 // Calculate new height/position of drag handle. 19222 scrollbarSize = Math.max(~~(scrollbarRatio * trackSize), this.options.scrollbarMinSize); 19223 if (this.options.scrollbarMaxSize) { 19224 scrollbarSize = Math.min(scrollbarSize, this.options.scrollbarMaxSize); 19225 } 19226 return scrollbarSize; 19227 }; 19228 SimpleBarCore.prototype.positionScrollbar = function (axis) { 19229 var _a, _b, _c; 19230 if (axis === void 0) { axis = 'y'; } 19231 var scrollbar = this.axis[axis].scrollbar; 19232 if (!this.axis[axis].isOverflowing || 19233 !this.contentWrapperEl || 19234 !scrollbar.el || 19235 !this.elStyles) { 19236 return; 19237 } 19238 var contentSize = this.contentWrapperEl[this.axis[axis].scrollSizeAttr]; 19239 var trackSize = ((_a = this.axis[axis].track.el) === null || _a === void 0 ? void 0 : _a[this.axis[axis].offsetSizeAttr]) || 0; 19240 var hostSize = parseInt(this.elStyles[this.axis[axis].sizeAttr], 10); 19241 var scrollOffset = this.contentWrapperEl[this.axis[axis].scrollOffsetAttr]; 19242 scrollOffset = 19243 axis === 'x' && 19244 this.isRtl && 19245 ((_b = SimpleBarCore.getRtlHelpers()) === null || _b === void 0 ? void 0 : _b.isScrollOriginAtZero) 19246 ? -scrollOffset 19247 : scrollOffset; 19248 if (axis === 'x' && this.isRtl) { 19249 scrollOffset = ((_c = SimpleBarCore.getRtlHelpers()) === null || _c === void 0 ? void 0 : _c.isScrollingToNegative) 19250 ? scrollOffset 19251 : -scrollOffset; 19252 } 19253 var scrollPourcent = scrollOffset / (contentSize - hostSize); 19254 var handleOffset = ~~((trackSize - scrollbar.size) * scrollPourcent); 19255 handleOffset = 19256 axis === 'x' && this.isRtl 19257 ? -handleOffset + (trackSize - scrollbar.size) 19258 : handleOffset; 19259 scrollbar.el.style.transform = 19260 axis === 'x' 19261 ? "translate3d(".concat(handleOffset, "px, 0, 0)") 19262 : "translate3d(0, ".concat(handleOffset, "px, 0)"); 19263 }; 19264 SimpleBarCore.prototype.toggleTrackVisibility = function (axis) { 19265 if (axis === void 0) { axis = 'y'; } 19266 var track = this.axis[axis].track.el; 19267 var scrollbar = this.axis[axis].scrollbar.el; 19268 if (!track || !scrollbar || !this.contentWrapperEl) 19269 return; 19270 if (this.axis[axis].isOverflowing || this.axis[axis].forceVisible) { 19271 track.style.visibility = 'visible'; 19272 this.contentWrapperEl.style[this.axis[axis].overflowAttr] = 'scroll'; 19273 this.el.classList.add("".concat(this.classNames.scrollable, "-").concat(axis)); 19274 } 19275 else { 19276 track.style.visibility = 'hidden'; 19277 this.contentWrapperEl.style[this.axis[axis].overflowAttr] = 'hidden'; 19278 this.el.classList.remove("".concat(this.classNames.scrollable, "-").concat(axis)); 19279 } 19280 // Even if forceVisible is enabled, scrollbar itself should be hidden 19281 if (this.axis[axis].isOverflowing) { 19282 scrollbar.style.display = 'block'; 19283 } 19284 else { 19285 scrollbar.style.display = 'none'; 19286 } 19287 }; 19288 SimpleBarCore.prototype.showScrollbar = function (axis) { 19289 if (axis === void 0) { axis = 'y'; } 19290 if (this.axis[axis].isOverflowing && !this.axis[axis].scrollbar.isVisible) { 19291 addClasses(this.axis[axis].scrollbar.el, this.classNames.visible); 19292 this.axis[axis].scrollbar.isVisible = true; 19293 } 19294 }; 19295 SimpleBarCore.prototype.hideScrollbar = function (axis) { 19296 if (axis === void 0) { axis = 'y'; } 19297 if (this.axis[axis].isOverflowing && this.axis[axis].scrollbar.isVisible) { 19298 removeClasses(this.axis[axis].scrollbar.el, this.classNames.visible); 19299 this.axis[axis].scrollbar.isVisible = false; 19300 } 19301 }; 19302 SimpleBarCore.prototype.hideNativeScrollbar = function () { 19303 if (!this.offsetEl) 19304 return; 19305 this.offsetEl.style[this.isRtl ? 'left' : 'right'] = 19306 this.axis.y.isOverflowing || this.axis.y.forceVisible 19307 ? "-".concat(this.scrollbarWidth, "px") 19308 : '0px'; 19309 this.offsetEl.style.bottom = 19310 this.axis.x.isOverflowing || this.axis.x.forceVisible 19311 ? "-".concat(this.scrollbarWidth, "px") 19312 : '0px'; 19313 }; 19314 SimpleBarCore.prototype.onMouseMoveForAxis = function (axis) { 19315 if (axis === void 0) { axis = 'y'; } 19316 var currentAxis = this.axis[axis]; 19317 if (!currentAxis.track.el || !currentAxis.scrollbar.el) 19318 return; 19319 currentAxis.track.rect = currentAxis.track.el.getBoundingClientRect(); 19320 currentAxis.scrollbar.rect = 19321 currentAxis.scrollbar.el.getBoundingClientRect(); 19322 if (this.isWithinBounds(currentAxis.track.rect)) { 19323 this.showScrollbar(axis); 19324 addClasses(currentAxis.track.el, this.classNames.hover); 19325 if (this.isWithinBounds(currentAxis.scrollbar.rect)) { 19326 addClasses(currentAxis.scrollbar.el, this.classNames.hover); 19327 } 19328 else { 19329 removeClasses(currentAxis.scrollbar.el, this.classNames.hover); 19330 } 19331 } 19332 else { 19333 removeClasses(currentAxis.track.el, this.classNames.hover); 19334 if (this.options.autoHide) { 19335 this.hideScrollbar(axis); 19336 } 19337 } 19338 }; 19339 SimpleBarCore.prototype.onMouseLeaveForAxis = function (axis) { 19340 if (axis === void 0) { axis = 'y'; } 19341 removeClasses(this.axis[axis].track.el, this.classNames.hover); 19342 removeClasses(this.axis[axis].scrollbar.el, this.classNames.hover); 19343 if (this.options.autoHide) { 19344 this.hideScrollbar(axis); 19345 } 19346 }; 19347 /** 19348 * on scrollbar handle drag movement starts 19349 */ 19350 SimpleBarCore.prototype.onDragStart = function (e, axis) { 19351 var _a; 19352 if (axis === void 0) { axis = 'y'; } 19353 var elDocument = getElementDocument(this.el); 19354 var elWindow = getElementWindow(this.el); 19355 var scrollbar = this.axis[axis].scrollbar; 19356 // Measure how far the user's mouse is from the top of the scrollbar drag handle. 19357 var eventOffset = axis === 'y' ? e.pageY : e.pageX; 19358 this.axis[axis].dragOffset = 19359 eventOffset - (((_a = scrollbar.rect) === null || _a === void 0 ? void 0 : _a[this.axis[axis].offsetAttr]) || 0); 19360 this.draggedAxis = axis; 19361 addClasses(this.el, this.classNames.dragging); 19362 elDocument.addEventListener('mousemove', this.drag, true); 19363 elDocument.addEventListener('mouseup', this.onEndDrag, true); 19364 if (this.removePreventClickId === null) { 19365 elDocument.addEventListener('click', this.preventClick, true); 19366 elDocument.addEventListener('dblclick', this.preventClick, true); 19367 } 19368 else { 19369 elWindow.clearTimeout(this.removePreventClickId); 19370 this.removePreventClickId = null; 19371 } 19372 }; 19373 SimpleBarCore.prototype.onTrackClick = function (e, axis) { 19374 var _this = this; 19375 var _a, _b, _c, _d; 19376 if (axis === void 0) { axis = 'y'; } 19377 var currentAxis = this.axis[axis]; 19378 if (!this.options.clickOnTrack || 19379 !currentAxis.scrollbar.el || 19380 !this.contentWrapperEl) 19381 return; 19382 // Preventing the event's default to trigger click underneath 19383 e.preventDefault(); 19384 var elWindow = getElementWindow(this.el); 19385 this.axis[axis].scrollbar.rect = 19386 currentAxis.scrollbar.el.getBoundingClientRect(); 19387 var scrollbar = this.axis[axis].scrollbar; 19388 var scrollbarOffset = (_b = (_a = scrollbar.rect) === null || _a === void 0 ? void 0 : _a[this.axis[axis].offsetAttr]) !== null && _b !== void 0 ? _b : 0; 19389 var hostSize = parseInt((_d = (_c = this.elStyles) === null || _c === void 0 ? void 0 : _c[this.axis[axis].sizeAttr]) !== null && _d !== void 0 ? _d : '0px', 10); 19390 var scrolled = this.contentWrapperEl[this.axis[axis].scrollOffsetAttr]; 19391 var t = axis === 'y' 19392 ? this.mouseY - scrollbarOffset 19393 : this.mouseX - scrollbarOffset; 19394 var dir = t < 0 ? -1 : 1; 19395 var scrollSize = dir === -1 ? scrolled - hostSize : scrolled + hostSize; 19396 var speed = 40; 19397 var scrollTo = function () { 19398 if (!_this.contentWrapperEl) 19399 return; 19400 if (dir === -1) { 19401 if (scrolled > scrollSize) { 19402 scrolled -= speed; 19403 _this.contentWrapperEl[_this.axis[axis].scrollOffsetAttr] = scrolled; 19404 elWindow.requestAnimationFrame(scrollTo); 19405 } 19406 } 19407 else { 19408 if (scrolled < scrollSize) { 19409 scrolled += speed; 19410 _this.contentWrapperEl[_this.axis[axis].scrollOffsetAttr] = scrolled; 19411 elWindow.requestAnimationFrame(scrollTo); 19412 } 19413 } 19414 }; 19415 scrollTo(); 19416 }; 19417 /** 19418 * Getter for content element 19419 */ 19420 SimpleBarCore.prototype.getContentElement = function () { 19421 return this.contentEl; 19422 }; 19423 /** 19424 * Getter for original scrolling element 19425 */ 19426 SimpleBarCore.prototype.getScrollElement = function () { 19427 return this.contentWrapperEl; 19428 }; 19429 SimpleBarCore.prototype.removeListeners = function () { 19430 var elWindow = getElementWindow(this.el); 19431 // Event listeners 19432 this.el.removeEventListener('mouseenter', this.onMouseEnter); 19433 this.el.removeEventListener('pointerdown', this.onPointerEvent, true); 19434 this.el.removeEventListener('mousemove', this.onMouseMove); 19435 this.el.removeEventListener('mouseleave', this.onMouseLeave); 19436 if (this.contentWrapperEl) { 19437 this.contentWrapperEl.removeEventListener('scroll', this.onScroll); 19438 } 19439 elWindow.removeEventListener('resize', this.onWindowResize); 19440 if (this.mutationObserver) { 19441 this.mutationObserver.disconnect(); 19442 } 19443 if (this.resizeObserver) { 19444 this.resizeObserver.disconnect(); 19445 } 19446 // Cancel all debounced functions 19447 this.onMouseMove.cancel(); 19448 this.onWindowResize.cancel(); 19449 this.onStopScrolling.cancel(); 19450 this.onMouseEntered.cancel(); 19451 }; 19452 /** 19453 * Remove all listeners from DOM nodes 19454 */ 19455 SimpleBarCore.prototype.unMount = function () { 19456 this.removeListeners(); 19457 }; 19458 /** 19459 * Check if mouse is within bounds 19460 */ 19461 SimpleBarCore.prototype.isWithinBounds = function (bbox) { 19462 return (this.mouseX >= bbox.left && 19463 this.mouseX <= bbox.left + bbox.width && 19464 this.mouseY >= bbox.top && 19465 this.mouseY <= bbox.top + bbox.height); 19466 }; 19467 /** 19468 * Find element children matches query 19469 */ 19470 SimpleBarCore.prototype.findChild = function (el, query) { 19471 var matches = el.matches || 19472 el.webkitMatchesSelector || 19473 el.mozMatchesSelector || 19474 el.msMatchesSelector; 19475 return Array.prototype.filter.call(el.children, function (child) { 19476 return matches.call(child, query); 19477 })[0]; 19478 }; 19479 SimpleBarCore.rtlHelpers = null; 19480 SimpleBarCore.defaultOptions = { 19481 forceVisible: false, 19482 clickOnTrack: true, 19483 scrollbarMinSize: 25, 19484 scrollbarMaxSize: 0, 19485 ariaLabel: 'scrollable content', 19486 classNames: { 19487 contentEl: 'simplebar-content', 19488 contentWrapper: 'simplebar-content-wrapper', 19489 offset: 'simplebar-offset', 19490 mask: 'simplebar-mask', 19491 wrapper: 'simplebar-wrapper', 19492 placeholder: 'simplebar-placeholder', 19493 scrollbar: 'simplebar-scrollbar', 19494 track: 'simplebar-track', 19495 heightAutoObserverWrapperEl: 'simplebar-height-auto-observer-wrapper', 19496 heightAutoObserverEl: 'simplebar-height-auto-observer', 19497 visible: 'simplebar-visible', 19498 horizontal: 'simplebar-horizontal', 19499 vertical: 'simplebar-vertical', 19500 hover: 'simplebar-hover', 19501 dragging: 'simplebar-dragging', 19502 scrolling: 'simplebar-scrolling', 19503 scrollable: 'simplebar-scrollable', 19504 mouseEntered: 'simplebar-mouse-entered' 19505 }, 19506 scrollableNode: null, 19507 contentNode: null, 19508 autoHide: true 19509 }; 19510 /** 19511 * Static functions 19512 */ 19513 SimpleBarCore.getOptions = getOptions; 19514 SimpleBarCore.helpers = helpers; 19515 return SimpleBarCore; 19516}()); 19517 19518 19519//# sourceMappingURL=index.mjs.d41d8cd98f00.map 19520 19521 19522/***/ }), 19523
vendor: 10,685 bytes, lines 19524-19739
19524/***/ "./node_modules/simplebar/dist/index.mjs": 19525/*!***********************************************!*\ 19526 !*** ./node_modules/simplebar/dist/index.mjs ***! 19527 \***********************************************/ 19528/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => { 19529 19530"use strict"; 19531__webpack_require__.r(__webpack_exports__); 19532/* harmony export */ __webpack_require__.d(__webpack_exports__, { 19533/* harmony export */ "default": () => (/* binding */ SimpleBar) 19534/* harmony export */ }); 19535/* harmony import */ var can_use_dom__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! can-use-dom */ "./node_modules/can-use-dom/index.js"); 19536/* harmony import */ var simplebar_core__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! simplebar-core */ "./node_modules/simplebar-core/dist/index.mjs"); 19537/** 19538 * simplebar - v6.2.5 19539 * Scrollbars, simpler. 19540 * https://grsmto.github.io/simplebar/ 19541 * 19542 * Made by Adrien Denat from a fork by Jonathan Nicol 19543 * Under MIT License 19544 */ 19545 19546 19547 19548 19549/****************************************************************************** 19550Copyright (c) Microsoft Corporation. 19551 19552Permission to use, copy, modify, and/or distribute this software for any 19553purpose with or without fee is hereby granted. 19554 19555THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH 19556REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY 19557AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, 19558INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM 19559LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR 19560OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR 19561PERFORMANCE OF THIS SOFTWARE. 19562***************************************************************************** */ 19563/* global Reflect, Promise */ 19564 19565var extendStatics = function(d, b) { 19566 extendStatics = Object.setPrototypeOf || 19567 ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || 19568 function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; }; 19569 return extendStatics(d, b); 19570}; 19571 19572function __extends(d, b) { 19573 if (typeof b !== "function" && b !== null) 19574 throw new TypeError("Class extends value " + String(b) + " is not a constructor or null"); 19575 extendStatics(d, b); 19576 function __() { this.constructor = d; } 19577 d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); 19578} 19579 19580var _a = simplebar_core__WEBPACK_IMPORTED_MODULE_1__["default"].helpers, getOptions = _a.getOptions, addClasses = _a.addClasses; 19581var SimpleBar = /** @class */ (function (_super) { 19582 __extends(SimpleBar, _super); 19583 function SimpleBar() { 19584 var args = []; 19585 for (var _i = 0; _i < arguments.length; _i++) { 19586 args[_i] = arguments[_i]; 19587 } 19588 var _this = _super.apply(this, args) || this; 19589 // // Save a reference to the instance, so we know this DOM node has already been instancied 19590 SimpleBar.instances.set(args[0], _this); 19591 return _this; 19592 } 19593 SimpleBar.initDOMLoadedElements = function () { 19594 document.removeEventListener('DOMContentLoaded', this.initDOMLoadedElements); 19595 window.removeEventListener('load', this.initDOMLoadedElements); 19596 Array.prototype.forEach.call(document.querySelectorAll('[data-simplebar]'), function (el) { 19597 if (el.getAttribute('data-simplebar') !== 'init' && 19598 !SimpleBar.instances.has(el)) 19599 new SimpleBar(el, getOptions(el.attributes)); 19600 }); 19601 }; 19602 SimpleBar.removeObserver = function () { 19603 var _a; 19604 (_a = SimpleBar.globalObserver) === null || _a === void 0 ? void 0 : _a.disconnect(); 19605 }; 19606 SimpleBar.prototype.initDOM = function () { 19607 var _this = this; 19608 var _a, _b, _c; 19609 // make sure this element doesn't have the elements yet 19610 if (!Array.prototype.filter.call(this.el.children, function (child) { 19611 return child.classList.contains(_this.classNames.wrapper); 19612 }).length) { 19613 // Prepare DOM 19614 this.wrapperEl = document.createElement('div'); 19615 this.contentWrapperEl = document.createElement('div'); 19616 this.offsetEl = document.createElement('div'); 19617 this.maskEl = document.createElement('div'); 19618 this.contentEl = document.createElement('div'); 19619 this.placeholderEl = document.createElement('div'); 19620 this.heightAutoObserverWrapperEl = document.createElement('div'); 19621 this.heightAutoObserverEl = document.createElement('div'); 19622 addClasses(this.wrapperEl, this.classNames.wrapper); 19623 addClasses(this.contentWrapperEl, this.classNames.contentWrapper); 19624 addClasses(this.offsetEl, this.classNames.offset); 19625 addClasses(this.maskEl, this.classNames.mask); 19626 addClasses(this.contentEl, this.classNames.contentEl); 19627 addClasses(this.placeholderEl, this.classNames.placeholder); 19628 addClasses(this.heightAutoObserverWrapperEl, this.classNames.heightAutoObserverWrapperEl); 19629 addClasses(this.heightAutoObserverEl, this.classNames.heightAutoObserverEl); 19630 while (this.el.firstChild) { 19631 this.contentEl.appendChild(this.el.firstChild); 19632 } 19633 this.contentWrapperEl.appendChild(this.contentEl); 19634 this.offsetEl.appendChild(this.contentWrapperEl); 19635 this.maskEl.appendChild(this.offsetEl); 19636 this.heightAutoObserverWrapperEl.appendChild(this.heightAutoObserverEl); 19637 this.wrapperEl.appendChild(this.heightAutoObserverWrapperEl); 19638 this.wrapperEl.appendChild(this.maskEl); 19639 this.wrapperEl.appendChild(this.placeholderEl); 19640 this.el.appendChild(this.wrapperEl); 19641 (_a = this.contentWrapperEl) === null || _a === void 0 ? void 0 : _a.setAttribute('tabindex', '0'); 19642 (_b = this.contentWrapperEl) === null || _b === void 0 ? void 0 : _b.setAttribute('role', 'region'); 19643 (_c = this.contentWrapperEl) === null || _c === void 0 ? void 0 : _c.setAttribute('aria-label', this.options.ariaLabel); 19644 } 19645 if (!this.axis.x.track.el || !this.axis.y.track.el) { 19646 var track = document.createElement('div'); 19647 var scrollbar = document.createElement('div'); 19648 addClasses(track, this.classNames.track); 19649 addClasses(scrollbar, this.classNames.scrollbar); 19650 track.appendChild(scrollbar); 19651 this.axis.x.track.el = track.cloneNode(true); 19652 addClasses(this.axis.x.track.el, this.classNames.horizontal); 19653 this.axis.y.track.el = track.cloneNode(true); 19654 addClasses(this.axis.y.track.el, this.classNames.vertical); 19655 this.el.appendChild(this.axis.x.track.el); 19656 this.el.appendChild(this.axis.y.track.el); 19657 } 19658 simplebar_core__WEBPACK_IMPORTED_MODULE_1__["default"].prototype.initDOM.call(this); 19659 this.el.setAttribute('data-simplebar', 'init'); 19660 }; 19661 SimpleBar.prototype.unMount = function () { 19662 simplebar_core__WEBPACK_IMPORTED_MODULE_1__["default"].prototype.unMount.call(this); 19663 SimpleBar.instances["delete"](this.el); 19664 }; 19665 SimpleBar.initHtmlApi = function () { 19666 this.initDOMLoadedElements = this.initDOMLoadedElements.bind(this); 19667 // MutationObserver is IE11+ 19668 if (typeof MutationObserver !== 'undefined') { 19669 // Mutation observer to observe dynamically added elements 19670 this.globalObserver = new MutationObserver(SimpleBar.handleMutations); 19671 this.globalObserver.observe(document, { childList: true, subtree: true }); 19672 } 19673 // Taken from jQuery `ready` function 19674 // Instantiate elements already present on the page 19675 if (document.readyState === 'complete' || // @ts-ignore: IE specific 19676 (document.readyState !== 'loading' && !document.documentElement.doScroll)) { 19677 // Handle it asynchronously to allow scripts the opportunity to delay init 19678 window.setTimeout(this.initDOMLoadedElements); 19679 } 19680 else { 19681 document.addEventListener('DOMContentLoaded', this.initDOMLoadedElements); 19682 window.addEventListener('load', this.initDOMLoadedElements); 19683 } 19684 }; 19685 SimpleBar.handleMutations = function (mutations) { 19686 mutations.forEach(function (mutation) { 19687 mutation.addedNodes.forEach(function (addedNode) { 19688 if (addedNode.nodeType === 1) { 19689 if (addedNode.hasAttribute('data-simplebar')) { 19690 !SimpleBar.instances.has(addedNode) && 19691 document.documentElement.contains(addedNode) && 19692 new SimpleBar(addedNode, getOptions(addedNode.attributes)); 19693 } 19694 else { 19695 addedNode 19696 .querySelectorAll('[data-simplebar]') 19697 .forEach(function (el) { 19698 if (el.getAttribute('data-simplebar') !== 'init' && 19699 !SimpleBar.instances.has(el) && 19700 document.documentElement.contains(el)) 19701 new SimpleBar(el, getOptions(el.attributes)); 19702 }); 19703 } 19704 } 19705 }); 19706 mutation.removedNodes.forEach(function (removedNode) { 19707 if (removedNode.nodeType === 1) { 19708 if (removedNode.getAttribute('data-simplebar') === 'init') { 19709 SimpleBar.instances.has(removedNode) && 19710 !document.documentElement.contains(removedNode) && 19711 SimpleBar.instances.get(removedNode).unMount(); 19712 } 19713 else { 19714 Array.prototype.forEach.call(removedNode.querySelectorAll('[data-simplebar="init"]'), function (el) { 19715 SimpleBar.instances.has(el) && 19716 !document.documentElement.contains(el) && 19717 SimpleBar.instances.get(el).unMount(); 19718 }); 19719 } 19720 } 19721 }); 19722 }); 19723 }; 19724 SimpleBar.instances = new WeakMap(); 19725 return SimpleBar; 19726}(simplebar_core__WEBPACK_IMPORTED_MODULE_1__["default"])); 19727/** 19728 * HTML API 19729 * Called only in a browser env. 19730 */ 19731if (can_use_dom__WEBPACK_IMPORTED_MODULE_0__) { 19732 SimpleBar.initHtmlApi(); 19733} 19734 19735 19736//# sourceMappingURL=index.mjs.d41d8cd98f00.map 19737 19738 19739/***/ })
vendor: 4,538 bytes, lines 19739-19844
19739 19740 19741/******/ }); 19742/************************************************************************/ 19743/******/ // The module cache 19744/******/ var __webpack_module_cache__ = {}; 19745/******/ 19746/******/ // The require function 19747/******/ function __webpack_require__(moduleId) { 19748/******/ // Check if module is in cache 19749/******/ var cachedModule = __webpack_module_cache__[moduleId]; 19750/******/ if (cachedModule !== undefined) { 19751/******/ return cachedModule.exports; 19752/******/ } 19753/******/ // Create a new module (and put it into the cache) 19754/******/ var module = __webpack_module_cache__[moduleId] = { 19755/******/ // no module.id needed 19756/******/ // no module.loaded needed 19757/******/ exports: {} 19758/******/ }; 19759/******/ 19760/******/ // Execute the module function 19761/******/ __webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__); 19762/******/ 19763/******/ // Return the exports of the module 19764/******/ return module.exports; 19765/******/ } 19766/******/ 19767/************************************************************************/ 19768/******/ /* webpack/runtime/compat get default export */ 19769/******/ (() => { 19770/******/ // getDefaultExport function for compatibility with non-harmony modules 19771/******/ __webpack_require__.n = (module) => { 19772/******/ var getter = module && module.__esModule ? 19773/******/ () => (module['default']) : 19774/******/ () => (module); 19775/******/ __webpack_require__.d(getter, { a: getter }); 19776/******/ return getter; 19777/******/ }; 19778/******/ })(); 19779/******/ 19780/******/ /* webpack/runtime/define property getters */ 19781/******/ (() => { 19782/******/ // define getter functions for harmony exports 19783/******/ __webpack_require__.d = (exports, definition) => { 19784/******/ for(var key in definition) { 19785/******/ if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) { 19786/******/ Object.defineProperty(exports, key, { enumerable: true, get: definition[key] }); 19787/******/ } 19788/******/ } 19789/******/ }; 19790/******/ })(); 19791/******/ 19792/******/ /* webpack/runtime/global */ 19793/******/ (() => { 19794/******/ __webpack_require__.g = (function() { 19795/******/ if (typeof globalThis === 'object') return globalThis; 19796/******/ try { 19797/******/ return this || new Function('return this')(); 19798/******/ } catch (e) { 19799/******/ if (typeof window === 'object') return window; 19800/******/ } 19801/******/ })(); 19802/******/ })(); 19803/******/ 19804/******/ /* webpack/runtime/hasOwnProperty shorthand */ 19805/******/ (() => { 19806/******/ __webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop)) 19807/******/ })(); 19808/******/ 19809/******/ /* webpack/runtime/make namespace object */ 19810/******/ (() => { 19811/******/ // define __esModule on exports 19812/******/ __webpack_require__.r = (exports) => { 19813/******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) { 19814/******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); 19815/******/ } 19816/******/ Object.defineProperty(exports, '__esModule', { value: true }); 19817/******/ }; 19818/******/ })(); 19819/******/ 19820/************************************************************************/ 19821var __webpack_exports__ = {}; 19822// This entry need to be wrapped in an IIFE because it need to be in strict mode. 19823(() => { 19824"use strict"; 19825/*!***********************************************!*\ 19826 !*** ./apps/birta_cms/static/js/app/index.js ***! 19827 \***********************************************/ 19828__webpack_require__.r(__webpack_exports__); 19829/* harmony import */ var jquery__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! jquery */ "./node_modules/jquery/dist/jquery.js"); 19830/* harmony import */ var jquery__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(jquery__WEBPACK_IMPORTED_MODULE_0__); 19831/* harmony import */ var simplebar__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! simplebar */ "./node_modules/simplebar/dist/index.mjs"); 19832/* harmony import */ var _sass_main_scss__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ../../sass/main.scss */ "./apps/birta_cms/static/sass/main.scss"); 19833/* provided dependency */ var __webpack_provided_window_dot_jQuery = __webpack_require__(/*! jquery */ "./node_modules/jquery/dist/jquery.js"); 19834 19835window.$ = (jquery__WEBPACK_IMPORTED_MODULE_0___default()); 19836__webpack_provided_window_dot_jQuery = (jquery__WEBPACK_IMPORTED_MODULE_0___default()); 19837var bootstrap = __webpack_require__(/*! bootstrap */ "./node_modules/bootstrap/dist/js/bootstrap.js"); 19838 19839 19840})(); 19841 19842/******/ })() 19843; 19844//# sourceMappingURL=bundle.js.f7cd47c91e44.map
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.