1(function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c="function"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error("Cannot find module '"+i+"'");throw a.code="MODULE_NOT_FOUND",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u="function"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()({1:[function(require,module,exports){ 2function _arrayLikeToArray(r, a) { 3 (null == a || a > r.length) && (a = r.length); 4 for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; 5 return n; 6} 7module.exports = _arrayLikeToArray, module.exports.__esModule = true, module.exports["default"] = module.exports; 8},{}],2:[function(require,module,exports){ 9function _arrayWithHoles(r) { 10 if (Array.isArray(r)) return r; 11} 12module.exports = _arrayWithHoles, module.exports.__esModule = true, module.exports["default"] = module.exports; 13},{}],3:[function(require,module,exports){ 14function _interopRequireDefault(e) { 15 return e && e.__esModule ? e : { 16 "default": e 17 }; 18} 19module.exports = _interopRequireDefault, module.exports.__esModule = true, module.exports["default"] = module.exports; 20},{}],4:[function(require,module,exports){ 21function _iterableToArrayLimit(r, l) { 22 var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; 23 if (null != t) { 24 var e, 25 n, 26 i, 27 u, 28 a = [], 29 f = !0, 30 o = !1; 31 try { 32 if (i = (t = t.call(r)).next, 0 === l) { 33 if (Object(t) !== t) return; 34 f = !1; 35 } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); 36 } catch (r) { 37 o = !0, n = r; 38 } finally { 39 try { 40 if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return; 41 } finally { 42 if (o) throw n; 43 } 44 } 45 return a; 46 } 47} 48module.exports = _iterableToArrayLimit, module.exports.__esModule = true, module.exports["default"] = module.exports; 49},{}],5:[function(require,module,exports){ 50function _nonIterableRest() { 51 throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); 52} 53module.exports = _nonIterableRest, module.exports.__esModule = true, module.exports["default"] = module.exports; 54},{}],6:[function(require,module,exports){ 55var arrayWithHoles = require("./arrayWithHoles.js"); 56var iterableToArrayLimit = require("./iterableToArrayLimit.js"); 57var unsupportedIterableToArray = require("./unsupportedIterableToArray.js"); 58var nonIterableRest = require("./nonIterableRest.js"); 59function _slicedToArray(r, e) { 60 return arrayWithHoles(r) || iterableToArrayLimit(r, e) || unsupportedIterableToArray(r, e) || nonIterableRest(); 61} 62module.exports = _slicedToArray, module.exports.__esModule = true, module.exports["default"] = module.exports; 63},{"./arrayWithHoles.js":2,"./iterableToArrayLimit.js":4,"./nonIterableRest.js":5,"./unsupportedIterableToArray.js":8}],7:[function(require,module,exports){ 64function _typeof(o) { 65 "@babel/helpers - typeof"; 66 67 return module.exports = _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { 68 return typeof o; 69 } : function (o) { 70 return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; 71 }, module.exports.__esModule = true, module.exports["default"] = module.exports, _typeof(o); 72} 73module.exports = _typeof, module.exports.__esModule = true, module.exports["default"] = module.exports; 74},{}],8:[function(require,module,exports){ 75var arrayLikeToArray = require("./arrayLikeToArray.js"); 76function _unsupportedIterableToArray(r, a) { 77 if (r) { 78 if ("string" == typeof r) return arrayLikeToArray(r, a); 79 var t = {}.toString.call(r).slice(8, -1); 80 return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? arrayLikeToArray(r, a) : void 0; 81 } 82} 83module.exports = _unsupportedIterableToArray, module.exports.__esModule = true, module.exports["default"] = module.exports; 84},{"./arrayLikeToArray.js":1}],9:[function(require,module,exports){ 85/*! 86 * Bootstrap v4.4.1 (https://getbootstrap.com/) 87 * Copyright 2011-2019 The Bootstrap Authors (https://github.com/twbs/bootstrap/graphs/contributors) 88 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE) 89 */ 90(function (global, factory) { 91 typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('jquery'), require('popper.js')) : 92 typeof define === 'function' && define.amd ? define(['exports', 'jquery', 'popper.js'], factory) : 93 (global = global || self, factory(global.bootstrap = {}, global.jQuery, global.Popper)); 94}(this, (function (exports, $, Popper) { 'use strict'; 95 96 $ = $ && $.hasOwnProperty('default') ? $['default'] : $; 97 Popper = Popper && Popper.hasOwnProperty('default') ? Popper['default'] : Popper; 98 99 function _defineProperties(target, props) { 100 for (var i = 0; i < props.length; i++) { 101 var descriptor = props[i]; 102 descriptor.enumerable = descriptor.enumerable || false; 103 descriptor.configurable = true; 104 if ("value" in descriptor) descriptor.writable = true; 105 Object.defineProperty(target, descriptor.key, descriptor); 106 } 107 } 108 109 function _createClass(Constructor, protoProps, staticProps) { 110 if (protoProps) _defineProperties(Constructor.prototype, protoProps); 111 if (staticProps) _defineProperties(Constructor, staticProps); 112 return Constructor; 113 } 114 115 function _defineProperty(obj, key, value) { 116 if (key in obj) { 117 Object.defineProperty(obj, key, { 118 value: value, 119 enumerable: true, 120 configurable: true, 121 writable: true 122 }); 123 } else { 124 obj[key] = value; 125 } 126 127 return obj; 128 } 129 130 function ownKeys(object, enumerableOnly) { 131 var keys = Object.keys(object); 132 133 if (Object.getOwnPropertySymbols) { 134 var symbols = Object.getOwnPropertySymbols(object); 135 if (enumerableOnly) symbols = symbols.filter(function (sym) { 136 return Object.getOwnPropertyDescriptor(object, sym).enumerable; 137 }); 138 keys.push.apply(keys, symbols); 139 } 140 141 return keys; 142 } 143
144 function _objectSpread2(target) { 145 for (var i = 1; i < arguments.length; i++) { 146 var source = arguments[i] != null ? arguments[i] : {}; 147 148 if (i % 2) { 149 ownKeys(Object(source), true).forEach(function (key) { 150 _defineProperty(target, key, source[key]); 151 }); 152 } else if (Object.getOwnPropertyDescriptors) { 153 Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); 154 } else { 155 ownKeys(Object(source)).forEach(function (key) { 156 Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); 157 }); 158 } 159 } 160 161 return target; 162 } 163 164 function _inheritsLoose(subClass, superClass) { 165 subClass.prototype = Object.create(superClass.prototype); 166 subClass.prototype.constructor = subClass; 167 subClass.__proto__ = superClass; 168 } 169 170 /** 171 * -------------------------------------------------------------------------- 172 * Bootstrap (v4.4.1): util.js 173 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE) 174 * -------------------------------------------------------------------------- 175 */ 176 /** 177 * ------------------------------------------------------------------------ 178 * Private TransitionEnd Helpers 179 * ------------------------------------------------------------------------ 180 */ 181 182 var TRANSITION_END = 'transitionend'; 183 var MAX_UID = 1000000; 184 var MILLISECONDS_MULTIPLIER = 1000; // Shoutout AngusCroll (https://goo.gl/pxwQGp) 185 186 function toType(obj) { 187 return {}.toString.call(obj).match(/\s([a-z]+)/i)[1].toLowerCase(); 188 } 189 190 function getSpecialTransitionEndEvent() { 191 return { 192 bindType: TRANSITION_END, 193 delegateType: TRANSITION_END, 194 handle: function handle(event) { 195 if ($(event.target).is(this)) { 196 return event.handleObj.handler.apply(this, arguments); // eslint-disable-line prefer-rest-params 197 } 198 199 return undefined; // eslint-disable-line no-undefined 200 } 201 }; 202 } 203 204 function transitionEndEmulator(duration) { 205 var _this = this; 206 207 var called = false; 208 $(this).one(Util.TRANSITION_END, function () { 209 called = true; 210 }); 211 setTimeout(function () { 212 if (!called) { 213 Util.triggerTransitionEnd(_this); 214 } 215 }, duration); 216 return this; 217 } 218 219 function setTransitionEndSupport() { 220 $.fn.emulateTransitionEnd = transitionEndEmulator; 221 $.event.special[Util.TRANSITION_END] = getSpecialTransitionEndEvent(); 222 } 223 /** 224 * -------------------------------------------------------------------------- 225 * Public Util Api 226 * -------------------------------------------------------------------------- 227 */ 228 229 230 var Util = { 231 TRANSITION_END: 'bsTransitionEnd', 232 getUID: function getUID(prefix) { 233 do { 234 // eslint-disable-next-line no-bitwise 235 prefix += ~~(Math.random() * MAX_UID); // "~~" acts like a faster Math.floor() here 236 } while (document.getElementById(prefix)); 237 238 return prefix; 239 }, 240 getSelectorFromElement: function getSelectorFromElement(element) { 241 var selector = element.getAttribute('data-target'); 242 243 if (!selector || selector === '#') { 244 var hrefAttr = element.getAttribute('href'); 245 selector = hrefAttr && hrefAttr !== '#' ? hrefAttr.trim() : ''; 246 } 247 248 try { 249 return document.querySelector(selector) ? selector : null; 250 } catch (err) { 251 return null; 252 } 253 }, 254 getTransitionDurationFromElement: function getTransitionDurationFromElement(element) { 255 if (!element) { 256 return 0; 257 } // Get transition-duration of the element 258 259 260 var transitionDuration = $(element).css('transition-duration'); 261 var transitionDelay = $(element).css('transition-delay'); 262 var floatTransitionDuration = parseFloat(transitionDuration); 263 var floatTransitionDelay = parseFloat(transitionDelay); // Return 0 if element or transition duration is not found 264 265 if (!floatTransitionDuration && !floatTransitionDelay) { 266 return 0; 267 } // If multiple durations are defined, take the first 268 269 270 transitionDuration = transitionDuration.split(',')[0]; 271 transitionDelay = transitionDelay.split(',')[0]; 272 return (parseFloat(transitionDuration) + parseFloat(transitionDelay)) * MILLISECONDS_MULTIPLIER; 273 }, 274 reflow: function reflow(element) { 275 return element.offsetHeight; 276 }, 277 triggerTransitionEnd: function triggerTransitionEnd(element) { 278 $(element).trigger(TRANSITION_END); 279 }, 280 // TODO: Remove in v5 281 supportsTransitionEnd: function supportsTransitionEnd() { 282 return Boolean(TRANSITION_END); 283 }, 284 isElement: function isElement(obj) { 285 return (obj[0] || obj).nodeType; 286 }, 287 typeCheckConfig: function typeCheckConfig(componentName, config, configTypes) { 288 for (var property in configTypes) { 289 if (Object.prototype.hasOwnProperty.call(configTypes, property)) { 290 var expectedTypes = configTypes[property]; 291 var value = config[property]; 292 var valueType = value && Util.isElement(value) ? 'element' : toType(value); 293 294 if (!new RegExp(expectedTypes).test(valueType)) { 295 throw new Error(componentName.toUpperCase() + ": " + ("Option \"" + property + "\" provided type \"" + valueType + "\" ") + ("but expected type \"" + expectedTypes + "\".")); 296 } 297 } 298 } 299 }, 300 findShadowRoot: function findShadowRoot(element) { 301 if (!document.documentElement.attachShadow) { 302 return null; 303 } // Can find the shadow root otherwise it'll return the document 304 305 306 if (typeof element.getRootNode === 'function') { 307 var root = element.getRootNode(); 308 return root instanceof ShadowRoot ? root : null; 309 } 310 311 if (element instanceof ShadowRoot) { 312 return element; 313 } // when we don't find a shadow root 314 315 316 if (!element.parentNode) { 317 return null; 318 } 319 320 return Util.findShadowRoot(element.parentNode); 321 }, 322 jQueryDetection: function jQueryDetection() { 323 if (typeof $ === 'undefined') { 324 throw new TypeError('Bootstrap\'s JavaScript requires jQuery. jQuery must be included before Bootstrap\'s JavaScript.'); 325 } 326 327 var version = $.fn.jquery.split(' ')[0].split('.'); 328 var minMajor = 1; 329 var ltMajor = 2; 330 var minMinor = 9; 331 var minPatch = 1; 332 var maxMajor = 4; 333 334 if (version[0] < ltMajor && version[1] < minMinor || version[0] === minMajor && version[1] === minMinor && version[2] < minPatch || version[0] >
334= maxMajor) { 335 throw new Error('Bootstrap\'s JavaScript requires at least jQuery v1.9.1 but less than v4.0.0'); 336 } 337 } 338 }; 339 Util.jQueryDetection(); 340 setTransitionEndSupport(); 341 342 /** 343 * ------------------------------------------------------------------------ 344 * Constants 345 * ------------------------------------------------------------------------ 346 */ 347 348 var NAME = 'alert'; 349 var VERSION = '4.4.1'; 350 var DATA_KEY = 'bs.alert'; 351 var EVENT_KEY = "." + DATA_KEY; 352 var DATA_API_KEY = '.data-api'; 353 var JQUERY_NO_CONFLICT = $.fn[NAME]; 354 var Selector = { 355 DISMISS: '[data-dismiss="alert"]' 356 }; 357 var Event = { 358 CLOSE: "close" + EVENT_KEY, 359 CLOSED: "closed" + EVENT_KEY, 360 CLICK_DATA_API: "click" + EVENT_KEY + DATA_API_KEY 361 }; 362 var ClassName = { 363 ALERT: 'alert', 364 FADE: 'fade', 365 SHOW: 'show' 366 }; 367 /** 368 * ------------------------------------------------------------------------ 369 * Class Definition 370 * ------------------------------------------------------------------------ 371 */ 372 373 var Alert = 374 /*#__PURE__*/ 375 function () { 376 function Alert(element) { 377 this._element = element; 378 } // Getters 379 380 381 var _proto = Alert.prototype; 382 383 // Public 384 _proto.close = function close(element) { 385 var rootElement = this._element; 386 387 if (element) { 388 rootElement = this._getRootElement(element); 389 } 390 391 var customEvent = this._triggerCloseEvent(rootElement); 392 393 if (customEvent.isDefaultPrevented()) { 394 return; 395 } 396 397 this._removeElement(rootElement); 398 }; 399 400 _proto.dispose = function dispose() { 401 $.removeData(this._element, DATA_KEY); 402 this._element = null; 403 } // Private 404 ; 405 406 _proto._getRootElement = function _getRootElement(element) { 407 var selector = Util.getSelectorFromElement(element); 408 var parent = false; 409 410 if (selector) { 411 parent = document.querySelector(selector); 412 } 413 414 if (!parent) { 415 parent = $(element).closest("." + ClassName.ALERT)[0]; 416 } 417 418 return parent; 419 }; 420 421 _proto._triggerCloseEvent = function _triggerCloseEvent(element) { 422 var closeEvent = $.Event(Event.CLOSE); 423 $(element).trigger(closeEvent); 424 return closeEvent; 425 }; 426 427 _proto._removeElement = function _removeElement(element) { 428 var _this = this; 429 430 $(element).removeClass(ClassName.SHOW); 431 432 if (!$(element).hasClass(ClassName.FADE)) { 433 this._destroyElement(element); 434 435 return; 436 } 437 438 var transitionDuration = Util.getTransitionDurationFromElement(element); 439 $(element).one(Util.TRANSITION_END, function (event) { 440 return _this._destroyElement(element, event); 441 }).emulateTransitionEnd(transitionDuration); 442 }; 443 444 _proto._destroyElement = function _destroyElement(element) { 445 $(element).detach().trigger(Event.CLOSED).remove(); 446 } // Static 447 ; 448 449 Alert._jQueryInterface = function _jQueryInterface(config) { 450 return this.each(function () { 451 var $element = $(this); 452 var data = $element.data(DATA_KEY); 453 454 if (!data) { 455 data = new Alert(this); 456 $element.data(DATA_KEY, data); 457 } 458 459 if (config === 'close') { 460 data[config](this); 461 } 462 }); 463 }; 464 465 Alert._handleDismiss = function _handleDismiss(alertInstance) { 466 return function (event) { 467 if (event) { 468 event.preventDefault(); 469 } 470 471 alertInstance.close(this); 472 }; 473 }; 474 475 _createClass(Alert, null, [{ 476 key: "VERSION", 477 get: function get() { 478 return VERSION; 479 } 480 }]); 481 482 return Alert; 483 }(); 484 /** 485 * ------------------------------------------------------------------------ 486 * Data Api implementation 487 * ------------------------------------------------------------------------ 488 */ 489 490 491 $(document).on(Event.CLICK_DATA_API, Selector.DISMISS, Alert._handleDismiss(new Alert())); 492 /** 493 * ------------------------------------------------------------------------ 494 * jQuery 495 * ------------------------------------------------------------------------ 496 */ 497 498 $.fn[NAME] = Alert._jQueryInterface; 499 $.fn[NAME].Constructor = Alert; 500 501 $.fn[NAME].noConflict = function () { 502 $.fn[NAME] = JQUERY_NO_CONFLICT; 503 return Alert._jQueryInterface; 504 }; 505 506 /** 507 * ------------------------------------------------------------------------ 508 * Constants 509 * ------------------------------------------------------------------------ 510 */ 511 512 var NAME$1 = 'button'; 513 var VERSION$1 = '4.4.1'; 514 var DATA_KEY$1 = 'bs.button'; 515 var EVENT_KEY$1 = "." + DATA_KEY$1; 516 var DATA_API_KEY$1 = '.data-api'; 517 var JQUERY_NO_CONFLICT$1 = $.fn[NAME$1]; 518 var ClassName$1 = { 519 ACTIVE: 'active', 520 BUTTON: 'btn', 521 FOCUS: 'focus' 522 }; 523 var Selector$1 = { 524 DATA_TOGGLE_CARROT: '[data-toggle^="button"]', 525 DATA_TOGGLES: '[data-toggle="buttons"]', 526 DATA_TOGGLE: '[data-toggle="button"]', 527 DATA_TOGGLES_BUTTONS: '[data-toggle="buttons"] .btn', 528 INPUT: 'input:not([type="hidden"])', 529 ACTIVE: '.active', 530 BUTTON: '.btn' 531 }; 532 var Event$1 = { 533 CLICK_DATA_API: "click" + EVENT_KEY$1 + DATA_API_KEY$1, 534 FOCUS_BLUR_DATA_API: "focus" + EVENT_KEY$1 + DATA_API_KEY$1 + " " + ("blur" + EVENT_KEY$1 + DATA_API_KEY$1), 535 LOAD_DATA_API: "load" + EVENT_KEY$1 + DATA_API_KEY$1 536 }; 537 /** 538 * ------------------------------------------------------------------------ 539 * Class Definition 540 * ------------------------------------------------------------------------ 541 */ 542 543 var Button = 544 /*#__PURE__*/ 545 function () { 546 function Button(element) { 547 this._element = element; 548 } // Getters 549 550 551 var _proto = Button.prototype; 552 553 // Public
554 _proto.toggle = function toggle() { 555 var triggerChangeEvent = true; 556 var addAriaPressed = true; 557 var rootElement = $(this._element).closest(Selector$1.DATA_TOGGLES)[0]; 558 559 if (rootElement) { 560 var input = this._element.querySelector(Selector$1.INPUT); 561 562 if (input) { 563 if (input.type === 'radio') { 564 if (input.checked && this._element.classList.contains(ClassName$1.ACTIVE)) { 565 triggerChangeEvent = false; 566 } else { 567 var activeElement = rootElement.querySelector(Selector$1.ACTIVE); 568 569 if (activeElement) { 570 $(activeElement).removeClass(ClassName$1.ACTIVE); 571 } 572 } 573 } else if (input.type === 'checkbox') { 574 if (this._element.tagName === 'LABEL' && input.checked === this._element.classList.contains(ClassName$1.ACTIVE)) { 575 triggerChangeEvent = false; 576 } 577 } else { 578 // if it's not a radio button or checkbox don't add a pointless/invalid checked property to the input 579 triggerChangeEvent = false; 580 } 581 582 if (triggerChangeEvent) { 583 input.checked = !this._element.classList.contains(ClassName$1.ACTIVE); 584 $(input).trigger('change'); 585 } 586 587 input.focus(); 588 addAriaPressed = false; 589 } 590 } 591 592 if (!(this._element.hasAttribute('disabled') || this._element.classList.contains('disabled'))) { 593 if (addAriaPressed) { 594 this._element.setAttribute('aria-pressed', !this._element.classList.contains(ClassName$1.ACTIVE)); 595 } 596 597 if (triggerChangeEvent) { 598 $(this._element).toggleClass(ClassName$1.ACTIVE); 599 } 600 } 601 }; 602 603 _proto.dispose = function dispose() { 604 $.removeData(this._element, DATA_KEY$1); 605 this._element = null; 606 } // Static 607 ; 608 609 Button._jQueryInterface = function _jQueryInterface(config) { 610 return this.each(function () { 611 var data = $(this).data(DATA_KEY$1); 612 613 if (!data) { 614 data = new Button(this); 615 $(this).data(DATA_KEY$1, data); 616 } 617 618 if (config === 'toggle') { 619 data[config](); 620 } 621 }); 622 }; 623 624 _createClass(Button, null, [{ 625 key: "VERSION", 626 get: function get() { 627 return VERSION$1; 628 } 629 }]); 630 631 return Button; 632 }(); 633 /** 634 * ------------------------------------------------------------------------ 635 * Data Api implementation 636 * ------------------------------------------------------------------------ 637 */ 638 639 640 $(document).on(Event$1.CLICK_DATA_API, Selector$1.DATA_TOGGLE_CARROT, function (event) { 641 var button = event.target; 642 643 if (!$(button).hasClass(ClassName$1.BUTTON)) { 644 button = $(button).closest(Selector$1.BUTTON)[0]; 645 } 646 647 if (!button || button.hasAttribute('disabled') || button.classList.contains('disabled')) { 648 event.preventDefault(); // work around Firefox bug #1540995 649 } else { 650 var inputBtn = button.querySelector(Selector$1.INPUT); 651 652 if (inputBtn && (inputBtn.hasAttribute('disabled') || inputBtn.classList.contains('disabled'))) { 653 event.preventDefault(); // work around Firefox bug #1540995 654 655 return; 656 } 657 658 Button._jQueryInterface.call($(button), 'toggle'); 659 } 660 }).on(Event$1.FOCUS_BLUR_DATA_API, Selector$1.DATA_TOGGLE_CARROT, function (event) { 661 var button = $(event.target).closest(Selector$1.BUTTON)[0]; 662 $(button).toggleClass(ClassName$1.FOCUS, /^focus(in)?$/.test(event.type)); 663 }); 664 $(window).on(Event$1.LOAD_DATA_API, function () { 665 // ensure correct active class is set to match the controls' actual values/states 666 // find all checkboxes/readio buttons inside data-toggle groups 667 var buttons = [].slice.call(document.querySelectorAll(Selector$1.DATA_TOGGLES_BUTTONS)); 668 669 for (var i = 0, len = buttons.length; i < len; i++) { 670 var button = buttons[i]; 671 var input = button.querySelector(Selector$1.INPUT); 672 673 if (input.checked || input.hasAttribute('checked')) { 674 button.classList.add(ClassName$1.ACTIVE); 675 } else { 676 button.classList.remove(ClassName$1.ACTIVE); 677 } 678 } // find all button toggles 679 680 681 buttons = [].slice.call(document.querySelectorAll(Selector$1.DATA_TOGGLE)); 682 683 for (var _i = 0, _len = buttons.length; _i < _len; _i++) { 684 var _button = buttons[_i]; 685 686 if (_button.getAttribute('aria-pressed') === 'true') { 687 _button.classList.add(ClassName$1.ACTIVE); 688 } else { 689 _button.classList.remove(ClassName$1.ACTIVE); 690 } 691 } 692 }); 693 /** 694 * ------------------------------------------------------------------------ 695 * jQuery 696 * ------------------------------------------------------------------------ 697 */ 698 699 $.fn[NAME$1] = Button._jQueryInterface; 700 $.fn[NAME$1].Constructor = Button; 701 702 $.fn[NAME$1].noConflict = function () { 703 $.fn[NAME$1] = JQUERY_NO_CONFLICT$1; 704 return Button._jQueryInterface; 705 }; 706 707 /** 708 * ------------------------------------------------------------------------ 709 * Constants 710 * ------------------------------------------------------------------------ 711 */ 712 713 var NAME$2 = 'carousel'; 714 var VERSION$2 = '4.4.1'; 715 var DATA_KEY$2 = 'bs.carousel'; 716 var EVENT_KEY$2 = "." + DATA_KEY$2; 717 var DATA_API_KEY$2 = '.data-api'; 718 var JQUERY_NO_CONFLICT$2 = $.fn[NAME$2]; 719 var ARROW_LEFT_KEYCODE = 37; // KeyboardEvent.which value for left arrow key 720 721 var ARROW_RIGHT_KEYCODE = 39; // KeyboardEvent.which value for right arrow key 722 723 var TOUCHEVENT_COMPAT_WAIT = 500; // Time for mouse compat events to fire after touch 724 725 var SWIPE_THRESHOLD = 40; 726 var Default = { 727 interval: 5000, 728 keyboard: true, 729 slide: false, 730 pause: 'hover', 731 wrap: true, 732 touch: true 733 }; 734 var DefaultType = { 735 interval: '(number|boolean)', 736 keyboard: 'boolean', 737 slide: '(boolean|string)', 738 pause: '(string|boolean)', 739 wrap: 'boolean', 740 touch: 'boolean' 741 }; 742 var Direction = { 743 NEXT: 'next', 744 PREV: 'prev', 745 LEFT: 'left', 746 RIGHT: 'right' 747 }; 748 var Event$2 = { 749 SLIDE: "slide" + EVENT_KEY$2, 750 SLID: "slid" + EVENT_KEY$2, 751 KEYDOWN: "keydown" + EVENT_KEY$2, 752 MOUSEENTER: "mouseenter" + EVENT_KEY$2, 753 MOUSELEAVE: "mouseleave" + EVENT_KEY$2, 754 TOUCHSTART: "touchstart" + EVENT_KEY$2, 755 TOUCHMOVE: "touchmove" + EVENT_KEY$2, 756 TOUCHEND: "touchend" + EVENT_KEY$2, 757 POINTERDOWN: "pointerdown" + EVENT_KEY$2, 758 POINTERUP: "pointerup" + EVENT_KEY$2, 759 DRAG_START: "dragstart" + EVENT_KEY$2, 760 LOAD_DATA_API: "load" + EVENT_KEY$2 + DATA_API_KEY$2, 761 CLICK_DATA_API: "click" + EVENT_KEY$2 + DATA_API_KEY$2 762 }; 763 var ClassName$2 = { 764 CAROUSEL: 'carousel', 765 ACTIVE: 'active', 766 SLIDE: 'slide', 767 RIGHT: 'carousel-item-right', 768 LEFT: 'carousel-item-left', 769 NEXT: 'carousel-item-next', 770 PREV: 'carousel-item-prev', 771 ITEM: 'carousel-item', 772 POINTER_EVENT: 'pointer-event' 773 }; 774 var Selector$2 = { 775 ACTIVE: '.active', 776 ACTIVE_ITEM: '.active.carousel-item', 777 ITEM: '.carousel-item', 778 ITEM_IMG: '.carousel-item img', 779 NEXT_PREV: '.carousel-item-next, .carousel-item-prev', 780 INDICATORS: '.carousel-indicators',
781 DATA_SLIDE: '[data-slide], [data-slide-to]', 782 DATA_RIDE: '[data-ride="carousel"]' 783 }; 784 var PointerType = { 785 TOUCH: 'touch', 786 PEN: 'pen' 787 }; 788 /** 789 * ------------------------------------------------------------------------ 790 * Class Definition 791 * ------------------------------------------------------------------------ 792 */ 793 794 var Carousel = 795 /*#__PURE__*/ 796 function () { 797 function Carousel(element, config) { 798 this._items = null; 799 this._interval = null; 800 this._activeElement = null; 801 this._isPaused = false; 802 this._isSliding = false; 803 this.touchTimeout = null; 804 this.touchStartX = 0; 805 this.touchDeltaX = 0; 806 this._config = this._getConfig(config); 807 this._element = element; 808 this._indicatorsElement = this._element.querySelector(Selector$2.INDICATORS); 809 this._touchSupported = 'ontouchstart' in document.documentElement || navigator.maxTouchPoints > 0; 810 this._pointerEvent = Boolean(window.PointerEvent || window.MSPointerEvent); 811 812 this._addEventListeners(); 813 } // Getters 814 815 816 var _proto = Carousel.prototype; 817 818 // Public 819 _proto.next = function next() { 820 if (!this._isSliding) { 821 this._slide(Direction.NEXT); 822 } 823 }; 824 825 _proto.nextWhenVisible = function nextWhenVisible() { 826 // Don't call next when the page isn't visible 827 // or the carousel or its parent isn't visible 828 if (!document.hidden && $(this._element).is(':visible') && $(this._element).css('visibility') !== 'hidden') { 829 this.next(); 830 } 831 }; 832 833 _proto.prev = function prev() { 834 if (!this._isSliding) { 835 this._slide(Direction.PREV); 836 } 837 }; 838 839 _proto.pause = function pause(event) { 840 if (!event) { 841 this._isPaused = true; 842 } 843 844 if (this._element.querySelector(Selector$2.NEXT_PREV)) { 845 Util.triggerTransitionEnd(this._element); 846 this.cycle(true); 847 } 848 849 clearInterval(this._interval); 850 this._interval = null; 851 }; 852 853 _proto.cycle = function cycle(event) { 854 if (!event) { 855 this._isPaused = false; 856 } 857 858 if (this._interval) { 859 clearInterval(this._interval); 860 this._interval = null; 861 } 862 863 if (this._config.interval && !this._isPaused) { 864 this._interval = setInterval((document.visibilityState ? this.nextWhenVisible : this.next).bind(this), this._config.interval); 865 } 866 }; 867 868 _proto.to = function to(index) { 869 var _this = this; 870 871 this._activeElement = this._element.querySelector(Selector$2.ACTIVE_ITEM); 872 873 var activeIndex = this._getItemIndex(this._activeElement); 874 875 if (index > this._items.length - 1 || index < 0) { 876 return; 877 } 878 879 if (this._isSliding) { 880 $(this._element).one(Event$2.SLID, function () { 881 return _this.to(index); 882 }); 883 return; 884 } 885 886 if (activeIndex === index) { 887 this.pause(); 888 this.cycle(); 889 return; 890 } 891 892 var direction = index > activeIndex ? Direction.NEXT : Direction.PREV; 893 894 this._slide(direction, this._items[index]); 895 }; 896 897 _proto.dispose = function dispose() { 898 $(this._element).off(EVENT_KEY$2); 899 $.removeData(this._element, DATA_KEY$2); 900 this._items = null; 901 this._config = null; 902 this._element = null; 903 this._interval = null; 904 this._isPaused = null; 905 this._isSliding = null; 906 this._activeElement = null; 907 this._indicatorsElement = null; 908 } // Private 909 ; 910 911 _proto._getConfig = function _getConfig(config) { 912 config = _objectSpread2({}, Default, {}, config); 913 Util.typeCheckConfig(NAME$2, config, DefaultType); 914 return config; 915 }; 916 917 _proto._handleSwipe = function _handleSwipe() { 918 var absDeltax = Math.abs(this.touchDeltaX); 919 920 if (absDeltax <= SWIPE_THRESHOLD) { 921 return; 922 } 923 924 var direction = absDeltax / this.touchDeltaX; 925 this.touchDeltaX = 0; // swipe left 926 927 if (direction > 0) { 928 this.prev(); 929 } // swipe right 930 931 932 if (direction < 0) { 933 this.next(); 934 } 935 }; 936 937 _proto._addEventListeners = function _addEventListeners() { 938 var _this2 = this; 939 940 if (this._config.keyboard) { 941 $(this._element).on(Event$2.KEYDOWN, function (event) { 942 return _this2._keydown(event); 943 }); 944 } 945 946 if (this._config.pause === 'hover') { 947 $(this._element).on(Event$2.MOUSEENTER, function (event) { 948 return _this2.pause(event); 949 }).on(Event$2.MOUSELEAVE, function (event) { 950 return _this2.cycle(event); 951 }); 952 } 953 954 if (this._config.touch) { 955 this._addTouchEventListeners(); 956 } 957 }; 958 959 _proto._addTouchEventListeners = function _addTouchEventListeners() { 960 var _this3 = this; 961 962 if (!this._touchSupported) { 963 return; 964 } 965 966 var start = function start(event) { 967 if (_this3._pointerEvent && PointerType[event.originalEvent.pointerType.toUpperCase()]) { 968 _this3.touchStartX = event.originalEvent.clientX; 969 } else if (!_this3._pointerEvent) { 970 _this3.touchStartX = event.originalEvent.touches[0].clientX; 971 } 972 }; 973 974 var move = function move(event) { 975 // ensure swiping with one touch and not pinching 976 if (event.originalEvent.touches && event.originalEvent.touches.length > 1) { 977 _this3.touchDeltaX = 0; 978 } else { 979 _this3.touchDeltaX = event.originalEvent.touches[0].clientX - _this3.touchStartX; 980 } 981 }; 982 983 var end = function end(event) { 984 if (_this3._pointerEvent && PointerType[event.originalEvent.pointerType.toUpperCase()]) { 985 _this3.touchDeltaX = event.originalEvent.clientX - _this3.touchStartX; 986 } 987 988 _this3._handleSwipe(); 989 990 if (_this3._config.pause === 'hover') {
991 // If it's a touch-enabled device, mouseenter/leave are fired as 992 // part of the mouse compatibility events on first tap - the carousel 993 // would stop cycling until user tapped out of it; 994 // here, we listen for touchend, explicitly pause the carousel 995 // (as if it's the second time we tap on it, mouseenter compat event 996 // is NOT fired) and after a timeout (to allow for mouse compatibility 997 // events to fire) we explicitly restart cycling 998 _this3.pause(); 999 1000 if (_this3.touchTimeout) { 1001 clearTimeout(_this3.touchTimeout); 1002 } 1003 1004 _this3.touchTimeout = setTimeout(function (event) { 1005 return _this3.cycle(event); 1006 }, TOUCHEVENT_COMPAT_WAIT + _this3._config.interval); 1007 } 1008 }; 1009 1010 $(this._element.querySelectorAll(Selector$2.ITEM_IMG)).on(Event$2.DRAG_START, function (e) { 1011 return e.preventDefault(); 1012 }); 1013 1014 if (this._pointerEvent) { 1015 $(this._element).on(Event$2.POINTERDOWN, function (event) { 1016 return start(event); 1017 }); 1018 $(this._element).on(Event$2.POINTERUP, function (event) { 1019 return end(event); 1020 }); 1021 1022 this._element.classList.add(ClassName$2.POINTER_EVENT); 1023 } else { 1024 $(this._element).on(Event$2.TOUCHSTART, function (event) { 1025 return start(event); 1026 }); 1027 $(this._element).on(Event$2.TOUCHMOVE, function (event) { 1028 return move(event); 1029 }); 1030 $(this._element).on(Event$2.TOUCHEND, function (event) { 1031 return end(event); 1032 }); 1033 } 1034 }; 1035 1036 _proto._keydown = function _keydown(event) { 1037 if (/input|textarea/i.test(event.target.tagName)) { 1038 return; 1039 } 1040 1041 switch (event.which) { 1042 case ARROW_LEFT_KEYCODE: 1043 event.preventDefault(); 1044 this.prev(); 1045 break; 1046 1047 case ARROW_RIGHT_KEYCODE: 1048 event.preventDefault(); 1049 this.next(); 1050 break; 1051 } 1052 }; 1053 1054 _proto._getItemIndex = function _getItemIndex(element) { 1055 this._items = element && element.parentNode ? [].slice.call(element.parentNode.querySelectorAll(Selector$2.ITEM)) : []; 1056 return this._items.indexOf(element); 1057 }; 1058 1059 _proto._getItemByDirection = function _getItemByDirection(direction, activeElement) { 1060 var isNextDirection = direction === Direction.NEXT; 1061 var isPrevDirection = direction === Direction.PREV; 1062 1063 var activeIndex = this._getItemIndex(activeElement); 1064 1065 var lastItemIndex = this._items.length - 1; 1066 var isGoingToWrap = isPrevDirection && activeIndex === 0 || isNextDirection && activeIndex === lastItemIndex; 1067 1068 if (isGoingToWrap && !this._config.wrap) { 1069 return activeElement; 1070 } 1071 1072 var delta = direction === Direction.PREV ? -1 : 1; 1073 var itemIndex = (activeIndex + delta) % this._items.length; 1074 return itemIndex === -1 ? this._items[this._items.length - 1] : this._items[itemIndex]; 1075 }; 1076 1077 _proto._triggerSlideEvent = function _triggerSlideEvent(relatedTarget, eventDirectionName) { 1078 var targetIndex = this._getItemIndex(relatedTarget); 1079 1080 var fromIndex = this._getItemIndex(this._element.querySelector(Selector$2.ACTIVE_ITEM)); 1081 1082 var slideEvent = $.Event(Event$2.SLIDE, { 1083 relatedTarget: relatedTarget, 1084 direction: eventDirectionName, 1085 from: fromIndex, 1086 to: targetIndex 1087 }); 1088 $(this._element).trigger(slideEvent); 1089 return slideEvent; 1090 }; 1091 1092 _proto._setActiveIndicatorElement = function _setActiveIndicatorElement(element) { 1093 if (this._indicatorsElement) { 1094 var indicators = [].slice.call(this._indicatorsElement.querySelectorAll(Selector$2.ACTIVE)); 1095 $(indicators).removeClass(ClassName$2.ACTIVE); 1096 1097 var nextIndicator = this._indicatorsElement.children[this._getItemIndex(element)]; 1098 1099 if (nextIndicator) { 1100 $(nextIndicator).addClass(ClassName$2.ACTIVE); 1101 } 1102 } 1103 }; 1104 1105 _proto._slide = function _slide(direction, element) { 1106 var _this4 = this; 1107 1108 var activeElement = this._element.querySelector(Selector$2.ACTIVE_ITEM); 1109 1110 var activeElementIndex = this._getItemIndex(activeElement); 1111 1112 var nextElement = element || activeElement && this._getItemByDirection(direction, activeElement); 1113 1114 var nextElementIndex = this._getItemIndex(nextElement); 1115 1116 var isCycling = Boolean(this._interval); 1117 var directionalClassName; 1118 var orderClassName; 1119 var eventDirectionName; 1120 1121 if (direction === Direction.NEXT) { 1122 directionalClassName = ClassName$2.LEFT; 1123 orderClassName = ClassName$2.NEXT; 1124 eventDirectionName = Direction.LEFT; 1125 } else { 1126 directionalClassName = ClassName$2.RIGHT; 1127 orderClassName = ClassName$2.PREV; 1128 eventDirectionName = Direction.RIGHT; 1129 } 1130 1131 if (nextElement && $(nextElement).hasClass(ClassName$2.ACTIVE)) { 1132 this._isSliding = false;
1133 return; 1134 } 1135 1136 var slideEvent = this._triggerSlideEvent(nextElement, eventDirectionName); 1137 1138 if (slideEvent.isDefaultPrevented()) { 1139 return; 1140 } 1141 1142 if (!activeElement || !nextElement) { 1143 // Some weirdness is happening, so we bail 1144 return; 1145 } 1146 1147 this._isSliding = true; 1148 1149 if (isCycling) { 1150 this.pause(); 1151 } 1152 1153 this._setActiveIndicatorElement(nextElement); 1154 1155 var slidEvent = $.Event(Event$2.SLID, { 1156 relatedTarget: nextElement, 1157 direction: eventDirectionName, 1158 from: activeElementIndex, 1159 to: nextElementIndex 1160 }); 1161 1162 if ($(this._element).hasClass(ClassName$2.SLIDE)) { 1163 $(nextElement).addClass(orderClassName); 1164 Util.reflow(nextElement); 1165 $(activeElement).addClass(directionalClassName); 1166 $(nextElement).addClass(directionalClassName); 1167 var nextElementInterval = parseInt(nextElement.getAttribute('data-interval'), 10); 1168 1169 if (nextElementInterval) { 1170 this._config.defaultInterval = this._config.defaultInterval || this._config.interval; 1171 this._config.interval = nextElementInterval; 1172 } else { 1173 this._config.interval = this._config.defaultInterval || this._config.interval; 1174 } 1175 1176 var transitionDuration = Util.getTransitionDurationFromElement(activeElement); 1177 $(activeElement).one(Util.TRANSITION_END, function () { 1178 $(nextElement).removeClass(directionalClassName + " " + orderClassName).addClass(ClassName$2.ACTIVE); 1179 $(activeElement).removeClass(ClassName$2.ACTIVE + " " + orderClassName + " " + directionalClassName); 1180 _this4._isSliding = false; 1181 setTimeout(function () { 1182 return $(_this4._element).trigger(slidEvent); 1183 }, 0); 1184 }).emulateTransitionEnd(transitionDuration); 1185 } else { 1186 $(activeElement).removeClass(ClassName$2.ACTIVE); 1187 $(nextElement).addClass(ClassName$2.ACTIVE); 1188 this._isSliding = false; 1189 $(this._element).trigger(slidEvent); 1190 } 1191 1192 if (isCycling) { 1193 this.cycle(); 1194 } 1195 } // Static 1196 ; 1197 1198 Carousel._jQueryInterface = function _jQueryInterface(config) { 1199 return this.each(function () { 1200 var data = $(this).data(DATA_KEY$2); 1201 1202 var _config = _objectSpread2({}, Default, {}, $(this).data()); 1203 1204 if (typeof config === 'object') { 1205 _config = _objectSpread2({}, _config, {}, config); 1206 } 1207 1208 var action = typeof config === 'string' ? config : _config.slide; 1209 1210 if (!data) { 1211 data = new Carousel(this, _config); 1212 $(this).data(DATA_KEY$2, data); 1213 } 1214 1215 if (typeof config === 'number') { 1216 data.to(config); 1217 } else if (typeof action === 'string') { 1218 if (typeof data[action] === 'undefined') { 1219 throw new TypeError("No method named \"" + action + "\""); 1220 } 1221 1222 data[action](); 1223 } else if (_config.interval && _config.ride) { 1224 data.pause(); 1225 data.cycle(); 1226 } 1227 }); 1228 }; 1229 1230 Carousel._dataApiClickHandler = function _dataApiClickHandler(event) { 1231 var selector = Util.getSelectorFromElement(this); 1232 1233 if (!selector) { 1234 return; 1235 } 1236 1237 var target = $(selector)[0]; 1238 1239 if (!target || !$(target).hasClass(ClassName$2.CAROUSEL)) { 1240 return; 1241 } 1242 1243 var config = _objectSpread2({}, $(target).data(), {}, $(this).data()); 1244 1245 var slideIndex = this.getAttribute('data-slide-to'); 1246 1247 if (slideIndex) { 1248 config.interval = false; 1249 } 1250 1251 Carousel._jQueryInterface.call($(target), config); 1252 1253 if (slideIndex) { 1254 $(target).data(DATA_KEY$2).to(slideIndex); 1255 } 1256 1257 event.preventDefault(); 1258 }; 1259 1260 _createClass(Carousel, null, [{ 1261 key: "VERSION", 1262 get: function get() { 1263 return VERSION$2; 1264 } 1265 }, { 1266 key: "Default", 1267 get: function get() { 1268 return Default; 1269 } 1270 }]); 1271 1272 return Carousel; 1273 }(); 1274 /** 1275 * ------------------------------------------------------------------------ 1276 * Data Api implementation 1277 * ------------------------------------------------------------------------ 1278 */ 1279 1280 1281 $(document).on(Event$2.CLICK_DATA_API, Selector$2.DATA_SLIDE, Carousel._dataApiClickHandler); 1282 $(window).on(Event$2.LOAD_DATA_API, function () { 1283 var carousels = [].slice.call(document.querySelectorAll(Selector$2.DATA_RIDE)); 1284 1285 for (var i = 0, len = carousels.length; i < len; i++) {
1286 var $carousel = $(carousels[i]); 1287 1288 Carousel._jQueryInterface.call($carousel, $carousel.data()); 1289 } 1290 }); 1291 /** 1292 * ------------------------------------------------------------------------ 1293 * jQuery 1294 * ------------------------------------------------------------------------ 1295 */ 1296 1297 $.fn[NAME$2] = Carousel._jQueryInterface; 1298 $.fn[NAME$2].Constructor = Carousel; 1299 1300 $.fn[NAME$2].noConflict = function () { 1301 $.fn[NAME$2] = JQUERY_NO_CONFLICT$2; 1302 return Carousel._jQueryInterface; 1303 }; 1304 1305 /** 1306 * ------------------------------------------------------------------------ 1307 * Constants 1308 * ------------------------------------------------------------------------ 1309 */ 1310 1311 var NAME$3 = 'collapse'; 1312 var VERSION$3 = '4.4.1'; 1313 var DATA_KEY$3 = 'bs.collapse'; 1314 var EVENT_KEY$3 = "." + DATA_KEY$3; 1315 var DATA_API_KEY$3 = '.data-api'; 1316 var JQUERY_NO_CONFLICT$3 = $.fn[NAME$3]; 1317 var Default$1 = { 1318 toggle: true, 1319 parent: '' 1320 }; 1321 var DefaultType$1 = { 1322 toggle: 'boolean', 1323 parent: '(string|element)' 1324 }; 1325 var Event$3 = { 1326 SHOW: "show" + EVENT_KEY$3, 1327 SHOWN: "shown" + EVENT_KEY$3, 1328 HIDE: "hide" + EVENT_KEY$3, 1329 HIDDEN: "hidden" + EVENT_KEY$3, 1330 CLICK_DATA_API: "click" + EVENT_KEY$3 + DATA_API_KEY$3 1331 }; 1332 var ClassName$3 = { 1333 SHOW: 'show', 1334 COLLAPSE: 'collapse', 1335 COLLAPSING: 'collapsing', 1336 COLLAPSED: 'collapsed' 1337 }; 1338 var Dimension = { 1339 WIDTH: 'width', 1340 HEIGHT: 'height' 1341 }; 1342 var Selector$3 = { 1343 ACTIVES: '.show, .collapsing', 1344 DATA_TOGGLE: '[data-toggle="collapse"]' 1345 }; 1346 /** 1347 * ------------------------------------------------------------------------ 1348 * Class Definition 1349 * ------------------------------------------------------------------------ 1350 */ 1351 1352 var Collapse = 1353 /*#__PURE__*/ 1354 function () { 1355 function Collapse(element, config) { 1356 this._isTransitioning = false; 1357 this._element = element; 1358 this._config = this._getConfig(config); 1359 this._triggerArray = [].slice.call(document.querySelectorAll("[data-toggle=\"collapse\"][href=\"#" + element.id + "\"]," + ("[data-toggle=\"collapse\"][data-target=\"#" + element.id + "\"]"))); 1360 var toggleList = [].slice.call(document.querySelectorAll(Selector$3.DATA_TOGGLE)); 1361 1362 for (var i = 0, len = toggleList.length; i < len; i++) { 1363 var elem = toggleList[i]; 1364 var selector = Util.getSelectorFromElement(elem); 1365 var filterElement = [].slice.call(document.querySelectorAll(selector)).filter(function (foundElem) { 1366 return foundElem === element; 1367 }); 1368 1369 if (selector !== null && filterElement.length > 0) { 1370 this._selector = selector; 1371 1372 this._triggerArray.push(elem); 1373 } 1374 } 1375 1376 this._parent = this._config.parent ? this._getParent() : null; 1377 1378 if (!this._config.parent) { 1379 this._addAriaAndCollapsedClass(this._element, this._triggerArray); 1380 } 1381 1382 if (this._config.toggle) { 1383 this.toggle(); 1384 } 1385 } // Getters 1386 1387 1388 var _proto = Collapse.prototype; 1389 1390 // Public 1391 _proto.toggle = function toggle() { 1392 if ($(this._element).hasClass(ClassName$3.SHOW)) { 1393 this.hide(); 1394 } else { 1395 this.show(); 1396 } 1397 }; 1398 1399 _proto.show = function show() { 1400 var _this = this; 1401 1402 if (this._isTransitioning || $(this._element).hasClass(ClassName$3.SHOW)) { 1403 return; 1404 } 1405 1406 var actives; 1407 var activesData; 1408 1409 if (this._parent) { 1410 actives = [].slice.call(this._parent.querySelectorAll(Selector$3.ACTIVES)).filter(function (elem) { 1411 if (typeof _this._config.parent === 'string') { 1412 return elem.getAttribute('data-parent') === _this._config.parent; 1413 } 1414 1415 return elem.classList.contains(ClassName$3.COLLAPSE); 1416 }); 1417 1418 if (actives.length === 0) { 1419 actives = null; 1420 } 1421 } 1422 1423 if (actives) { 1424 activesData = $(actives).not(this._selector).data(DATA_KEY$3); 1425 1426 if (activesData && activesData._isTransitioning) { 1427 return; 1428 } 1429 } 1430 1431 var startEvent = $.Event(Event$3.SHOW); 1432 $(this._element).trigger(startEvent); 1433 1434 if (startEvent.isDefaultPrevented()) { 1435 return; 1436 } 1437 1438 if (actives) { 1439 Collapse._jQueryInterface.call($(actives).not(this._selector), 'hide'); 1440 1441 if (!activesData) { 1442 $(actives).data(DATA_KEY$3, null); 1443 } 1444 } 1445 1446 var dimension = this._getDimension(); 1447 1448 $(this._element).removeClass(ClassName$3.COLLAPSE).addClass(ClassName$3.COLLAPSING); 1449 this._element.style[dimension] = 0; 1450 1451 if (this._triggerArray.length) { 1452 $(this._triggerArray).removeClass(ClassName$3.COLLAPSED).attr('aria-expanded', true); 1453 } 1454 1455 this.setTransitioning(true); 1456 1457 var complete = function complete() { 1458 $(_this._element).removeClass(ClassName$3.COLLAPSING).addClass(ClassName$3.COLLAPSE).addClass(ClassName$3.SHOW); 1459 _this._element.style[dimension] = ''; 1460 1461 _this.setTransitioning(false); 1462 1463 $(_this._element).trigger(Event$3.SHOWN); 1464 }; 1465 1466 var capitalizedDimension = dimension[0].toUpperCase() + dimension.slice(1); 1467 var scrollSize = "scroll" + capitalizedDimension; 1468 var transitionDuration = Util.getTransitionDurationFromElement(this._element); 1469 $(this._element).one(Util.TRANSITION_END, complete).emulateTransitionEnd(transitionDuration); 1470 this._element.style[dimension] = this._element[scrollSize] + "px"; 1471 }; 1472 1473 _proto.hide = function hide() { 1474 var _this2 = this; 1475 1476 if (this._isTransitioning || !$(this._element).hasClass(ClassName$3.SHOW)) { 1477 return; 1478 } 1479 1480 var startEvent = $.Event(Event$3.HIDE); 1481 $(this._element).trigger(startEvent); 1482 1483 if (startEvent.isDefaultPrevented()) { 1484 return; 1485 } 1486 1487 var dimension = this._getDimension(); 1488 1489 this._element.style[dimension] = this._element.getBoundingClientRect()[dimension] + "px"; 1490 Util.reflow(this._element); 1491 $(this._element).addClass(ClassName$3.COLLAPSING).removeClass(ClassName$3.COLLAPSE).removeClass(ClassName$3.SHOW); 1492 var triggerArrayLength = this._triggerArray.length; 1493 1494 if (triggerArrayLength > 0) { 1495 for (var i = 0; i < triggerArrayLength; i++) { 1496 var trigger = this._triggerArray[i]; 1497 var selector = Util.getSelectorFromElement(trigger); 1498 1499 if (selector !== null) { 1500 var $elem = $([].slice.call(document.querySelectorAll(selector))); 1501 1502 if (!$elem.hasClass(ClassName$3.SHOW)) { 1503 $(trigger).addClass(ClassName$3.COLLAPSED).attr('aria-expanded', false); 1504 } 1505 } 1506 } 1507 } 1508 1509 this.setTransitioning(true); 1510 1511 var complete = function complete() { 1512 _this2.setTransitioning(false); 1513 1514 $(_this2._element).removeClass(ClassName$3.COLLAPSING).addClass(ClassName$3.COLLAPSE).trigger(Event$3.HIDDEN); 1515 }; 1516 1517 this._element.style[dimension] = ''; 1518 var transitionDuration = Util.getTransitionDurationFromElement(this._element); 1519 $(this._element).one(Util.TRANSITION_END, complete).emulateTransitionEnd(transitionDuration); 1520 }; 1521 1522 _proto.setTransitioning = function setTransitioning(isTransitioning) { 1523 this._isTransitioning = isTransitioning; 1524 }; 1525 1526 _proto.dispose = function dispose() { 1527 $.removeData(this._element, DATA_KEY$3); 1528 this._config = null; 1529 this._parent = null; 1530 this._element = null; 1531 this._triggerArray = null; 1532 this._isTransitioning = null; 1533 } // Private 1534 ; 1535 1536 _proto._getConfig = function _getConfig(config) {
1537 config = _objectSpread2({}, Default$1, {}, config); 1538 config.toggle = Boolean(config.toggle); // Coerce string values 1539 1540 Util.typeCheckConfig(NAME$3, config, DefaultType$1); 1541 return config; 1542 }; 1543 1544 _proto._getDimension = function _getDimension() { 1545 var hasWidth = $(this._element).hasClass(Dimension.WIDTH); 1546 return hasWidth ? Dimension.WIDTH : Dimension.HEIGHT; 1547 }; 1548 1549 _proto._getParent = function _getParent() { 1550 var _this3 = this; 1551 1552 var parent; 1553 1554 if (Util.isElement(this._config.parent)) { 1555 parent = this._config.parent; // It's a jQuery object 1556 1557 if (typeof this._config.parent.jquery !== 'undefined') { 1558 parent = this._config.parent[0]; 1559 } 1560 } else { 1561 parent = document.querySelector(this._config.parent); 1562 } 1563 1564 var selector = "[data-toggle=\"collapse\"][data-parent=\"" + this._config.parent + "\"]"; 1565 var children = [].slice.call(parent.querySelectorAll(selector)); 1566 $(children).each(function (i, element) { 1567 _this3._addAriaAndCollapsedClass(Collapse._getTargetFromElement(element), [element]); 1568 }); 1569 return parent; 1570 }; 1571 1572 _proto._addAriaAndCollapsedClass = function _addAriaAndCollapsedClass(element, triggerArray) { 1573 var isOpen = $(element).hasClass(ClassName$3.SHOW); 1574 1575 if (triggerArray.length) { 1576 $(triggerArray).toggleClass(ClassName$3.COLLAPSED, !isOpen).attr('aria-expanded', isOpen); 1577 } 1578 } // Static 1579 ; 1580 1581 Collapse._getTargetFromElement = function _getTargetFromElement(element) { 1582 var selector = Util.getSelectorFromElement(element); 1583 return selector ? document.querySelector(selector) : null; 1584 }; 1585 1586 Collapse._jQueryInterface = function _jQueryInterface(config) { 1587 return this.each(function () { 1588 var $this = $(this); 1589 var data = $this.data(DATA_KEY$3); 1590 1591 var _config = _objectSpread2({}, Default$1, {}, $this.data(), {}, typeof config === 'object' && config ? config : {}); 1592 1593 if (!data && _config.toggle && /show|hide/.test(config)) { 1594 _config.toggle = false; 1595 } 1596 1597 if (!data) { 1598 data = new Collapse(this, _config); 1599 $this.data(DATA_KEY$3, data); 1600 } 1601 1602 if (typeof config === 'string') { 1603 if (typeof data[config] === 'undefined') { 1604 throw new TypeError("No method named \"" + config + "\""); 1605 } 1606 1607 data[config](); 1608 } 1609 }); 1610 }; 1611 1612 _createClass(Collapse, null, [{ 1613 key: "VERSION", 1614 get: function get() { 1615 return VERSION$3; 1616 } 1617 }, { 1618 key: "Default", 1619 get: function get() { 1620 return Default$1; 1621 } 1622 }]); 1623 1624 return Collapse; 1625 }(); 1626 /** 1627 * ------------------------------------------------------------------------ 1628 * Data Api implementation 1629 * ------------------------------------------------------------------------ 1630 */ 1631 1632 1633 $(document).on(Event$3.CLICK_DATA_API, Selector$3.DATA_TOGGLE, function (event) { 1634 // preventDefault only for <a> elements (which change the URL) not inside the collapsible element 1635 if (event.currentTarget.tagName === 'A') { 1636 event.preventDefault(); 1637 } 1638 1639 var $trigger = $(this); 1640 var selector = Util.getSelectorFromElement(this); 1641 var selectors = [].slice.call(document.querySelectorAll(selector)); 1642 $(selectors).each(function () { 1643 var $target = $(this); 1644 var data = $target.data(DATA_KEY$3); 1645 var config = data ? 'toggle' : $trigger.data(); 1646 1647 Collapse._jQueryInterface.call($target, config); 1648 }); 1649 }); 1650 /** 1651 * ------------------------------------------------------------------------ 1652 * jQuery 1653 * ------------------------------------------------------------------------ 1654 */ 1655 1656 $.fn[NAME$3] = Collapse._jQueryInterface; 1657 $.fn[NAME$3].Constructor = Collapse; 1658 1659 $.fn[NAME$3].noConflict = function () { 1660 $.fn[NAME$3] = JQUERY_NO_CONFLICT$3; 1661 return Collapse._jQueryInterface; 1662 }; 1663 1664 /** 1665 * ------------------------------------------------------------------------ 1666 * Constants 1667 * ------------------------------------------------------------------------ 1668 */ 1669 1670 var NAME$4 = 'dropdown'; 1671 var VERSION$4 = '4.4.1'; 1672 var DATA_KEY$4 = 'bs.dropdown'; 1673 var EVENT_KEY$4 = "." + DATA_KEY$4; 1674 var DATA_API_KEY$4 = '.data-api'; 1675 var JQUERY_NO_CONFLICT$4 = $.fn[NAME$4]; 1676 var ESCAPE_KEYCODE = 27; // KeyboardEvent.which value for Escape (Esc) key 1677 1678 var SPACE_KEYCODE = 32; // KeyboardEvent.which value for space key 1679 1680 var TAB_KEYCODE = 9; // KeyboardEvent.which value for tab key 1681 1682 var ARROW_UP_KEYCODE = 38; // KeyboardEvent.which value for up arrow key 1683 1684 var ARROW_DOWN_KEYCODE = 40; // KeyboardEvent.which value for down arrow key 1685 1686 var RIGHT_MOUSE_BUTTON_WHICH = 3; // MouseEvent.which value for the right button (assuming a right-handed mouse) 1687 1688 var REGEXP_KEYDOWN = new RegExp(ARROW_UP_KEYCODE + "|" + ARROW_DOWN_KEYCODE + "|" + ESCAPE_KEYCODE); 1689 var Event$4 = { 1690 HIDE: "hide" + EVENT_KEY$4, 1691 HIDDEN: "hidden" + EVENT_KEY$4, 1692 SHOW: "show" + EVENT_KEY$4, 1693 SHOWN: "shown" + EVENT_KEY$4, 1694 CLICK: "click" + EVENT_KEY$4, 1695 CLICK_DATA_API: "click" + EVENT_KEY$4 + DATA_API_KEY$4, 1696 KEYDOWN_DATA_API: "keydown" + EVENT_KEY$4 + DATA_API_KEY$4, 1697 KEYUP_DATA_API: "keyup" + EVENT_KEY$4 + DATA_API_KEY$4 1698 }; 1699 var ClassName$4 = { 1700 DISABLED: 'disabled', 1701 SHOW: 'show', 1702 DROPUP: 'dropup', 1703 DROPRIGHT: 'dropright', 1704 DROPLEFT: 'dropleft', 1705 MENURIGHT: 'dropdown-menu-right', 1706 MENULEFT: 'dropdown-menu-left', 1707 POSITION_STATIC: 'position-static' 1708 }; 1709 var Selector$4 = { 1710 DATA_TOGGLE: '[data-toggle="dropdown"]', 1711 FORM_CHILD: '.dropdown form', 1712 MENU: '.dropdown-menu', 1713 NAVBAR_NAV: '.navbar-nav', 1714 VISIBLE_ITEMS: '.dropdown-menu .dropdown-item:not(.disabled):not(:disabled)' 1715 }; 1716 var AttachmentMap = { 1717 TOP: 'top-start', 1718 TOPEND: 'top-end', 1719 BOTTOM: 'bottom-start', 1720 BOTTOMEND: 'bottom-end', 1721 RIGHT: 'right-start', 1722 RIGHTEND: 'right-end', 1723 LEFT: 'left-start', 1724 LEFTEND: 'left-end' 1725 }; 1726 var Default$2 = { 1727 offset: 0, 1728 flip: true, 1729 boundary: 'scrollParent', 1730 reference: 'toggle', 1731 display: 'dynamic', 1732 popperConfig: null 1733 }; 1734 var DefaultType$2 = { 1735 offset: '(number|string|function)', 1736 flip: 'boolean', 1737 boundary: '(string|element)', 1738 reference: '(string|element)', 1739 display: 'string', 1740 popperConfig: '(null|object)' 1741 }; 1742 /** 1743 * ------------------------------------------------------------------------ 1744 * Class Definition 1745 * ------------------------------------------------------------------------ 1746 */ 1747 1748 var Dropdown = 1749 /*#__PURE__*/ 1750 function () { 1751 function Dropdown(element, config) { 1752 this._element = element; 1753 this._popper = null; 1754 this._config = this._getConfig(config); 1755 this._menu = this._getMenuElement(); 1756 this._inNavbar = this._detectNavbar(); 1757 1758 this._addEventListeners(); 1759 } // Getters 1760 1761 1762 var _proto = Dropdown.prototype; 1763 1764 // Public
1765 _proto.toggle = function toggle() { 1766 if (this._element.disabled || $(this._element).hasClass(ClassName$4.DISABLED)) { 1767 return; 1768 } 1769 1770 var isActive = $(this._menu).hasClass(ClassName$4.SHOW); 1771 1772 Dropdown._clearMenus(); 1773 1774 if (isActive) { 1775 return; 1776 } 1777 1778 this.show(true); 1779 }; 1780 1781 _proto.show = function show(usePopper) { 1782 if (usePopper === void 0) { 1783 usePopper = false; 1784 } 1785 1786 if (this._element.disabled || $(this._element).hasClass(ClassName$4.DISABLED) || $(this._menu).hasClass(ClassName$4.SHOW)) { 1787 return; 1788 } 1789 1790 var relatedTarget = { 1791 relatedTarget: this._element 1792 }; 1793 var showEvent = $.Event(Event$4.SHOW, relatedTarget); 1794 1795 var parent = Dropdown._getParentFromElement(this._element); 1796 1797 $(parent).trigger(showEvent); 1798 1799 if (showEvent.isDefaultPrevented()) { 1800 return; 1801 } // Disable totally Popper.js for Dropdown in Navbar 1802 1803 1804 if (!this._inNavbar && usePopper) { 1805 /** 1806 * Check for Popper dependency 1807 * Popper - https://popper.js.org 1808 */ 1809 if (typeof Popper === 'undefined') { 1810 throw new TypeError('Bootstrap\'s dropdowns require Popper.js (https://popper.js.org/)'); 1811 } 1812 1813 var referenceElement = this._element; 1814 1815 if (this._config.reference === 'parent') { 1816 referenceElement = parent; 1817 } else if (Util.isElement(this._config.reference)) { 1818 referenceElement = this._config.reference; // Check if it's jQuery element 1819 1820 if (typeof this._config.reference.jquery !== 'undefined') { 1821 referenceElement = this._config.reference[0]; 1822 } 1823 } // If boundary is not `scrollParent`, then set position to `static` 1824 // to allow the menu to "escape" the scroll parent's boundaries 1825 // https://github.com/twbs/bootstrap/issues/24251 1826 1827 1828 if (this._config.boundary !== 'scrollParent') { 1829 $(parent).addClass(ClassName$4.POSITION_STATIC); 1830 } 1831 1832 this._popper = new Popper(referenceElement, this._menu, this._getPopperConfig()); 1833 } // If this is a touch-enabled device we add extra 1834 // empty mouseover listeners to the body's immediate children; 1835 // only needed because of broken event delegation on iOS 1836 // https://www.quirksmode.org/blog/archives/2014/02/mouse_event_bub.html 1837 1838 1839 if ('ontouchstart' in document.documentElement && $(parent).closest(Selector$4.NAVBAR_NAV).length === 0) { 1840 $(document.body).children().on('mouseover', null, $.noop); 1841 } 1842 1843 this._element.focus(); 1844 1845 this._element.setAttribute('aria-expanded', true); 1846 1847 $(this._menu).toggleClass(ClassName$4.SHOW); 1848 $(parent).toggleClass(ClassName$4.SHOW).trigger($.Event(Event$4.SHOWN, relatedTarget)); 1849 }; 1850 1851 _proto.hide = function hide() { 1852 if (this._element.disabled || $(this._element).hasClass(ClassName$4.DISABLED) || !$(this._menu).hasClass(ClassName$4.SHOW)) { 1853 return; 1854 } 1855 1856 var relatedTarget = { 1857 relatedTarget: this._element 1858 }; 1859 var hideEvent = $.Event(Event$4.HIDE, relatedTarget); 1860 1861 var parent = Dropdown._getParentFromElement(this._element); 1862 1863 $(parent).trigger(hideEvent); 1864 1865 if (hideEvent.isDefaultPrevented()) { 1866 return; 1867 } 1868 1869 if (this._popper) { 1870 this._popper.destroy(); 1871 } 1872 1873 $(this._menu).toggleClass(ClassName$4.SHOW); 1874 $(parent).toggleClass(ClassName$4.SHOW).trigger($.Event(Event$4.HIDDEN, relatedTarget)); 1875 }; 1876 1877 _proto.dispose = function dispose() { 1878 $.removeData(this._element, DATA_KEY$4); 1879 $(this._element).off(EVENT_KEY$4); 1880 this._element = null; 1881 this._menu = null; 1882 1883 if (this._popper !== null) { 1884 this._popper.destroy(); 1885 1886 this._popper = null; 1887 } 1888 }; 1889 1890 _proto.update = function update() { 1891 this._inNavbar = this._detectNavbar(); 1892 1893 if (this._popper !== null) { 1894 this._popper.scheduleUpdate(); 1895 } 1896 } // Private 1897 ; 1898 1899 _proto._addEventListeners = function _addEventListeners() { 1900 var _this = this; 1901 1902 $(this._element).on(Event$4.CLICK, function (event) { 1903 event.preventDefault(); 1904 event.stopPropagation(); 1905 1906 _this.toggle(); 1907 }); 1908 }; 1909 1910 _proto._getConfig = function _getConfig(config) {
1911 config = _objectSpread2({}, this.constructor.Default, {}, $(this._element).data(), {}, config); 1912 Util.typeCheckConfig(NAME$4, config, this.constructor.DefaultType); 1913 return config; 1914 }; 1915 1916 _proto._getMenuElement = function _getMenuElement() { 1917 if (!this._menu) { 1918 var parent = Dropdown._getParentFromElement(this._element); 1919 1920 if (parent) { 1921 this._menu = parent.querySelector(Selector$4.MENU); 1922 } 1923 } 1924 1925 return this._menu; 1926 }; 1927 1928 _proto._getPlacement = function _getPlacement() { 1929 var $parentDropdown = $(this._element.parentNode); 1930 var placement = AttachmentMap.BOTTOM; // Handle dropup 1931 1932 if ($parentDropdown.hasClass(ClassName$4.DROPUP)) { 1933 placement = AttachmentMap.TOP; 1934 1935 if ($(this._menu).hasClass(ClassName$4.MENURIGHT)) { 1936 placement = AttachmentMap.TOPEND; 1937 } 1938 } else if ($parentDropdown.hasClass(ClassName$4.DROPRIGHT)) { 1939 placement = AttachmentMap.RIGHT; 1940 } else if ($parentDropdown.hasClass(ClassName$4.DROPLEFT)) { 1941 placement = AttachmentMap.LEFT; 1942 } else if ($(this._menu).hasClass(ClassName$4.MENURIGHT)) { 1943 placement = AttachmentMap.BOTTOMEND; 1944 } 1945 1946 return placement; 1947 }; 1948 1949 _proto._detectNavbar = function _detectNavbar() { 1950 return $(this._element).closest('.navbar').length > 0; 1951 }; 1952 1953 _proto._getOffset = function _getOffset() { 1954 var _this2 = this; 1955 1956 var offset = {}; 1957 1958 if (typeof this._config.offset === 'function') { 1959 offset.fn = function (data) { 1960 data.offsets = _objectSpread2({}, data.offsets, {}, _this2._config.offset(data.offsets, _this2._element) || {}); 1961 return data; 1962 }; 1963 } else { 1964 offset.offset = this._config.offset; 1965 } 1966 1967 return offset; 1968 }; 1969 1970 _proto._getPopperConfig = function _getPopperConfig() { 1971 var popperConfig = { 1972 placement: this._getPlacement(), 1973 modifiers: { 1974 offset: this._getOffset(), 1975 flip: { 1976 enabled: this._config.flip 1977 }, 1978 preventOverflow: { 1979 boundariesElement: this._config.boundary 1980 } 1981 } 1982 }; // Disable Popper.js if we have a static display 1983 1984 if (this._config.display === 'static') { 1985 popperConfig.modifiers.applyStyle = { 1986 enabled: false 1987 }; 1988 } 1989 1990 return _objectSpread2({}, popperConfig, {}, this._config.popperConfig); 1991 } // Static 1992 ; 1993 1994 Dropdown._jQueryInterface = function _jQueryInterface(config) { 1995 return this.each(function () { 1996 var data = $(this).data(DATA_KEY$4); 1997 1998 var _config = typeof config === 'object' ? config : null; 1999 2000 if (!data) { 2001 data = new Dropdown(this, _config); 2002 $(this).data(DATA_KEY$4, data); 2003 } 2004 2005 if (typeof config === 'string') { 2006 if (typeof data[config] === 'undefined') { 2007 throw new TypeError("No method named \"" + config + "\""); 2008 } 2009 2010 data[config](); 2011 } 2012 }); 2013 }; 2014 2015 Dropdown._clearMenus = function _clearMenus(event) { 2016 if (event && (event.which === RIGHT_MOUSE_BUTTON_WHICH || event.type === 'keyup' && event.which !== TAB_KEYCODE)) { 2017 return; 2018 } 2019 2020 var toggles = [].slice.call(document.querySelectorAll(Selector$4.DATA_TOGGLE)); 2021 2022 for (var i = 0, len = toggles.length; i < len; i++) { 2023 var parent = Dropdown._getParentFromElement(toggles[i]); 2024 2025 var context = $(toggles[i]).data(DATA_KEY$4); 2026 var relatedTarget = { 2027 relatedTarget: toggles[i] 2028 }; 2029 2030 if (event && event.type === 'click') { 2031 relatedTarget.clickEvent = event; 2032 } 2033 2034 if (!context) { 2035 continue; 2036 } 2037 2038 var dropdownMenu = context._menu; 2039 2040 if (!$(parent).hasClass(ClassName$4.SHOW)) { 2041 continue; 2042 } 2043 2044 if (event && (event.type === 'click' && /input|textarea/i.test(event.target.tagName) || event.type === 'keyup' && event.which === TAB_KEYCODE) && $.contains(parent, event.target)) { 2045 continue; 2046 } 2047 2048 var hideEvent = $.Event(Event$4.HIDE, relatedTarget); 2049 $(parent).trigger(hideEvent); 2050 2051 if (hideEvent.isDefaultPrevented()) { 2052 continue; 2053 } // If this is a touch-enabled device we remove the extra 2054 // empty mouseover listeners we added for iOS support 2055 2056 2057 if ('ontouchstart' in document.documentElement) { 2058 $(document.body).children().off('mouseover', null, $.noop); 2059 } 2060 2061 toggles[i].setAttribute('aria-expanded', 'false'); 2062 2063 if (context._popper) { 2064 context._popper.destroy(); 2065 } 2066 2067 $(dropdownMenu).removeClass(ClassName$4.SHOW); 2068 $(parent).removeClass(ClassName$4.SHOW).trigger($.Event(Event$4.HIDDEN, relatedTarget)); 2069 } 2070 }; 2071 2072 Dropdown._getParentFromElement = function _getParentFromElement(element) { 2073 var parent; 2074 var selector = Util.getSelectorFromElement(element); 2075 2076 if (selector) { 2077 parent = document.querySelector(selector); 2078 } 2079 2080 return parent || element.parentNode; 2081 } // eslint-disable-next-line complexity 2082 ; 2083 2084 Dropdown._dataApiKeydownHandler = function _dataApiKeydownHandler(event) { 2085 // If not input/textarea: 2086 // - And not a key in REGEXP_KEYDOWN => not a dropdown command 2087 // If input/textarea: 2088 // - If space key => not a dropdown command 2089 // - If key is other than escape 2090 // - If key is not up or down => not a dropdown command 2091 // - If trigger inside the menu =>
2091 not a dropdown command 2092 if (/input|textarea/i.test(event.target.tagName) ? event.which === SPACE_KEYCODE || event.which !== ESCAPE_KEYCODE && (event.which !== ARROW_DOWN_KEYCODE && event.which !== ARROW_UP_KEYCODE || $(event.target).closest(Selector$4.MENU).length) : !REGEXP_KEYDOWN.test(event.which)) { 2093 return; 2094 } 2095 2096 event.preventDefault(); 2097 event.stopPropagation(); 2098 2099 if (this.disabled || $(this).hasClass(ClassName$4.DISABLED)) { 2100 return; 2101 } 2102 2103 var parent = Dropdown._getParentFromElement(this); 2104 2105 var isActive = $(parent).hasClass(ClassName$4.SHOW); 2106 2107 if (!isActive && event.which === ESCAPE_KEYCODE) { 2108 return; 2109 } 2110 2111 if (!isActive || isActive && (event.which === ESCAPE_KEYCODE || event.which === SPACE_KEYCODE)) { 2112 if (event.which === ESCAPE_KEYCODE) { 2113 var toggle = parent.querySelector(Selector$4.DATA_TOGGLE); 2114 $(toggle).trigger('focus'); 2115 } 2116 2117 $(this).trigger('click'); 2118 return; 2119 } 2120 2121 var items = [].slice.call(parent.querySelectorAll(Selector$4.VISIBLE_ITEMS)).filter(function (item) { 2122 return $(item).is(':visible'); 2123 }); 2124 2125 if (items.length === 0) { 2126 return; 2127 } 2128 2129 var index = items.indexOf(event.target); 2130 2131 if (event.which === ARROW_UP_KEYCODE && index > 0) { 2132 // Up 2133 index--; 2134 } 2135 2136 if (event.which === ARROW_DOWN_KEYCODE && index < items.length - 1) { 2137 // Down 2138 index++; 2139 } 2140 2141 if (index < 0) { 2142 index = 0; 2143 } 2144 2145 items[index].focus(); 2146 }; 2147 2148 _createClass(Dropdown, null, [{ 2149 key: "VERSION", 2150 get: function get() { 2151 return VERSION$4; 2152 } 2153 }, { 2154 key: "Default", 2155 get: function get() { 2156 return Default$2; 2157 } 2158 }, { 2159 key: "DefaultType", 2160 get: function get() { 2161 return DefaultType$2; 2162 } 2163 }]); 2164 2165 return Dropdown; 2166 }(); 2167 /** 2168 * ------------------------------------------------------------------------ 2169 * Data Api implementation 2170 * ------------------------------------------------------------------------ 2171 */ 2172 2173 2174 $(document).on(Event$4.KEYDOWN_DATA_API, Selector$4.DATA_TOGGLE, Dropdown._dataApiKeydownHandler).on(Event$4.KEYDOWN_DATA_API, Selector$4.MENU, Dropdown._dataApiKeydownHandler).on(Event$4.CLICK_DATA_API + " " + Event$4.KEYUP_DATA_API, Dropdown._clearMenus).on(Event$4.CLICK_DATA_API, Selector$4.DATA_TOGGLE, function (event) { 2175 event.preventDefault(); 2176 event.stopPropagation(); 2177 2178 Dropdown._jQueryInterface.call($(this), 'toggle'); 2179 }).on(Event$4.CLICK_DATA_API, Selector$4.FORM_CHILD, function (e) { 2180 e.stopPropagation(); 2181 }); 2182 /** 2183 * ------------------------------------------------------------------------ 2184 * jQuery 2185 * ------------------------------------------------------------------------ 2186 */ 2187 2188 $.fn[NAME$4] = Dropdown._jQueryInterface; 2189 $.fn[NAME$4].Constructor = Dropdown; 2190 2191 $.fn[NAME$4].noConflict = function () { 2192 $.fn[NAME$4] = JQUERY_NO_CONFLICT$4; 2193 return Dropdown._jQueryInterface; 2194 }; 2195 2196 /** 2197 * ------------------------------------------------------------------------ 2198 * Constants 2199 * ------------------------------------------------------------------------ 2200 */ 2201 2202 var NAME$5 = 'modal'; 2203 var VERSION$5 = '4.4.1'; 2204 var DATA_KEY$5 = 'bs.modal'; 2205 var EVENT_KEY$5 = "." + DATA_KEY$5; 2206 var DATA_API_KEY$5 = '.data-api'; 2207 var JQUERY_NO_CONFLICT$5 = $.fn[NAME$5]; 2208 var ESCAPE_KEYCODE$1 = 27; // KeyboardEvent.which value for Escape (Esc) key 2209 2210 var Default$3 = { 2211 backdrop: true, 2212 keyboard: true, 2213 focus: true, 2214 show: true 2215 }; 2216 var DefaultType$3 = { 2217 backdrop: '(boolean|string)', 2218 keyboard: 'boolean', 2219 focus: 'boolean', 2220 show: 'boolean' 2221 }; 2222 var Event$5 = { 2223 HIDE: "hide" + EVENT_KEY$5, 2224 HIDE_PREVENTED: "hidePrevented" + EVENT_KEY$5, 2225 HIDDEN: "hidden" + EVENT_KEY$5, 2226 SHOW: "show" + EVENT_KEY$5, 2227 SHOWN: "shown" + EVENT_KEY$5, 2228 FOCUSIN: "focusin" + EVENT_KEY$5, 2229 RESIZE: "resize" + EVENT_KEY$5, 2230 CLICK_DISMISS: "click.dismiss" + EVENT_KEY$5, 2231 KEYDOWN_DISMISS: "keydown.dismiss" + EVENT_KEY$5, 2232 MOUSEUP_DISMISS: "mouseup.dismiss" + EVENT_KEY$5, 2233 MOUSEDOWN_DISMISS: "mousedown.dismiss" + EVENT_KEY$5, 2234 CLICK_DATA_API: "click" + EVENT_KEY$5 + DATA_API_KEY$5 2235 }; 2236 var ClassName$5 = {
2237 SCROLLABLE: 'modal-dialog-scrollable', 2238 SCROLLBAR_MEASURER: 'modal-scrollbar-measure', 2239 BACKDROP: 'modal-backdrop', 2240 OPEN: 'modal-open', 2241 FADE: 'fade', 2242 SHOW: 'show', 2243 STATIC: 'modal-static' 2244 }; 2245 var Selector$5 = { 2246 DIALOG: '.modal-dialog', 2247 MODAL_BODY: '.modal-body', 2248 DATA_TOGGLE: '[data-toggle="modal"]', 2249 DATA_DISMISS: '[data-dismiss="modal"]', 2250 FIXED_CONTENT: '.fixed-top, .fixed-bottom, .is-fixed, .sticky-top', 2251 STICKY_CONTENT: '.sticky-top' 2252 }; 2253 /** 2254 * ------------------------------------------------------------------------ 2255 * Class Definition 2256 * ------------------------------------------------------------------------ 2257 */ 2258 2259 var Modal = 2260 /*#__PURE__*/ 2261 function () { 2262 function Modal(element, config) { 2263 this._config = this._getConfig(config); 2264 this._element = element; 2265 this._dialog = element.querySelector(Selector$5.DIALOG); 2266 this._backdrop = null; 2267 this._isShown = false; 2268 this._isBodyOverflowing = false; 2269 this._ignoreBackdropClick = false; 2270 this._isTransitioning = false; 2271 this._scrollbarWidth = 0; 2272 } // Getters 2273 2274 2275 var _proto = Modal.prototype; 2276 2277 // Public 2278 _proto.toggle = function toggle(relatedTarget) { 2279 return this._isShown ? this.hide() : this.show(relatedTarget); 2280 }; 2281 2282 _proto.show = function show(relatedTarget) { 2283 var _this = this; 2284 2285 if (this._isShown || this._isTransitioning) { 2286 return; 2287 } 2288 2289 if ($(this._element).hasClass(ClassName$5.FADE)) { 2290 this._isTransitioning = true; 2291 } 2292 2293 var showEvent = $.Event(Event$5.SHOW, { 2294 relatedTarget: relatedTarget 2295 }); 2296 $(this._element).trigger(showEvent); 2297 2298 if (this._isShown || showEvent.isDefaultPrevented()) { 2299 return; 2300 } 2301 2302 this._isShown = true; 2303 2304 this._checkScrollbar(); 2305 2306 this._setScrollbar(); 2307 2308 this._adjustDialog(); 2309 2310 this._setEscapeEvent(); 2311 2312 this._setResizeEvent(); 2313 2314 $(this._element).on(Event$5.CLICK_DISMISS, Selector$5.DATA_DISMISS, function (event) { 2315 return _this.hide(event); 2316 }); 2317 $(this._dialog).on(Event$5.MOUSEDOWN_DISMISS, function () { 2318 $(_this._element).one(Event$5.MOUSEUP_DISMISS, function (event) { 2319 if ($(event.target).is(_this._element)) { 2320 _this._ignoreBackdropClick = true; 2321 } 2322 }); 2323 }); 2324 2325 this._showBackdrop(function () { 2326 return _this._showElement(relatedTarget); 2327 }); 2328 }; 2329 2330 _proto.hide = function hide(event) { 2331 var _this2 = this; 2332 2333 if (event) { 2334 event.preventDefault(); 2335 } 2336 2337 if (!this._isShown || this._isTransitioning) { 2338 return; 2339 } 2340 2341 var hideEvent = $.Event(Event$5.HIDE); 2342 $(this._element).trigger(hideEvent); 2343 2344 if (!this._isShown || hideEvent.isDefaultPrevented()) { 2345 return; 2346 } 2347 2348 this._isShown = false; 2349 var transition = $(this._element).hasClass(ClassName$5.FADE); 2350 2351 if (transition) { 2352 this._isTransitioning = true; 2353 } 2354 2355 this._setEscapeEvent(); 2356 2357 this._setResizeEvent(); 2358 2359 $(document).off(Event$5.FOCUSIN); 2360 $(this._element).removeClass(ClassName$5.SHOW); 2361 $(this._element).off(Event$5.CLICK_DISMISS); 2362 $(this._dialog).off(Event$5.MOUSEDOWN_DISMISS); 2363 2364 if (transition) { 2365 var transitionDuration = Util.getTransitionDurationFromElement(this._element); 2366 $(this._element).one(Util.TRANSITION_END, function (event) { 2367 return _this2._hideModal(event); 2368 }).emulateTransitionEnd(transitionDuration); 2369 } else { 2370 this._hideModal(); 2371 } 2372 }; 2373 2374 _proto.dispose = function dispose() { 2375 [window, this._element, this._dialog].forEach(function (htmlElement) { 2376 return $(htmlElement).off(EVENT_KEY$5); 2377 }); 2378 /** 2379 * `document` has 2 events `Event.FOCUSIN` and `Event.CLICK_DATA_API` 2380 * Do not move `document` in `htmlElements` array 2381 * It will remove `Event.CLICK_DATA_API` event that should remain 2382 */ 2383 2384 $(document).off(Event$5.FOCUSIN); 2385 $.removeData(this._element, DATA_KEY$5); 2386 this._config = null; 2387 this._element = null; 2388 this._dialog = null; 2389 this._backdrop = null; 2390 this._isShown = null; 2391 this._isBodyOverflowing = null; 2392 this._ignoreBackdropClick = null; 2393 this._isTransitioning = null; 2394 this._scrollbarWidth = null; 2395 }; 2396 2397 _proto.handleUpdate = function handleUpdate() { 2398 this._adjustDialog(); 2399 } // Private 2400 ; 2401 2402 _proto._getConfig = function _getConfig(config) {
2403 config = _objectSpread2({}, Default$3, {}, config); 2404 Util.typeCheckConfig(NAME$5, config, DefaultType$3); 2405 return config; 2406 }; 2407 2408 _proto._triggerBackdropTransition = function _triggerBackdropTransition() { 2409 var _this3 = this; 2410 2411 if (this._config.backdrop === 'static') { 2412 var hideEventPrevented = $.Event(Event$5.HIDE_PREVENTED); 2413 $(this._element).trigger(hideEventPrevented); 2414 2415 if (hideEventPrevented.defaultPrevented) { 2416 return; 2417 } 2418 2419 this._element.classList.add(ClassName$5.STATIC); 2420 2421 var modalTransitionDuration = Util.getTransitionDurationFromElement(this._element); 2422 $(this._element).one(Util.TRANSITION_END, function () { 2423 _this3._element.classList.remove(ClassName$5.STATIC); 2424 }).emulateTransitionEnd(modalTransitionDuration); 2425 2426 this._element.focus(); 2427 } else { 2428 this.hide(); 2429 } 2430 }; 2431 2432 _proto._showElement = function _showElement(relatedTarget) { 2433 var _this4 = this; 2434 2435 var transition = $(this._element).hasClass(ClassName$5.FADE); 2436 var modalBody = this._dialog ? this._dialog.querySelector(Selector$5.MODAL_BODY) : null; 2437 2438 if (!this._element.parentNode || this._element.parentNode.nodeType !== Node.ELEMENT_NODE) { 2439 // Don't move modal's DOM position 2440 document.body.appendChild(this._element); 2441 } 2442 2443 this._element.style.display = 'block'; 2444 2445 this._element.removeAttribute('aria-hidden'); 2446 2447 this._element.setAttribute('aria-modal', true); 2448 2449 if ($(this._dialog).hasClass(ClassName$5.SCROLLABLE) && modalBody) { 2450 modalBody.scrollTop = 0; 2451 } else { 2452 this._element.scrollTop = 0; 2453 } 2454 2455 if (transition) { 2456 Util.reflow(this._element); 2457 } 2458 2459 $(this._element).addClass(ClassName$5.SHOW); 2460 2461 if (this._config.focus) { 2462 this._enforceFocus(); 2463 } 2464 2465 var shownEvent = $.Event(Event$5.SHOWN, { 2466 relatedTarget: relatedTarget 2467 }); 2468 2469 var transitionComplete = function transitionComplete() { 2470 if (_this4._config.focus) { 2471 _this4._element.focus(); 2472 } 2473 2474 _this4._isTransitioning = false; 2475 $(_this4._element).trigger(shownEvent); 2476 }; 2477 2478 if (transition) { 2479 var transitionDuration = Util.getTransitionDurationFromElement(this._dialog); 2480 $(this._dialog).one(Util.TRANSITION_END, transitionComplete).emulateTransitionEnd(transitionDuration); 2481 } else { 2482 transitionComplete(); 2483 } 2484 }; 2485 2486 _proto._enforceFocus = function _enforceFocus() { 2487 var _this5 = this; 2488 2489 $(document).off(Event$5.FOCUSIN) // Guard against infinite focus loop 2490 .on(Event$5.FOCUSIN, function (event) { 2491 if (document !== event.target && _this5._element !== event.target && $(_this5._element).has(event.target).length === 0) { 2492 _this5._element.focus(); 2493 } 2494 }); 2495 }; 2496 2497 _proto._setEscapeEvent = function _setEscapeEvent() { 2498 var _this6 = this; 2499 2500 if (this._isShown && this._config.keyboard) { 2501 $(this._element).on(Event$5.KEYDOWN_DISMISS, function (event) { 2502 if (event.which === ESCAPE_KEYCODE$1) { 2503 _this6._triggerBackdropTransition(); 2504 } 2505 }); 2506 } else if (!this._isShown) { 2507 $(this._element).off(Event$5.KEYDOWN_DISMISS); 2508 } 2509 }; 2510 2511 _proto._setResizeEvent = function _setResizeEvent() { 2512 var _this7 = this; 2513 2514 if (this._isShown) { 2515 $(window).on(Event$5.RESIZE, function (event) { 2516 return _this7.handleUpdate(event); 2517 }); 2518 } else { 2519 $(window).off(Event$5.RESIZE); 2520 } 2521 }; 2522 2523 _proto._hideModal = function _hideModal() { 2524 var _this8 = this; 2525 2526 this._element.style.display = 'none'; 2527 2528 this._element.setAttribute('aria-hidden', true); 2529 2530 this._element.removeAttribute('aria-modal'); 2531 2532 this._isTransitioning = false; 2533 2534 this._showBackdrop(function () { 2535 $(document.body).removeClass(ClassName$5.OPEN); 2536 2537 _this8._resetAdjustments(); 2538 2539 _this8._resetScrollbar(); 2540 2541 $(_this8._element).trigger(Event$5.HIDDEN); 2542 }); 2543 }; 2544 2545 _proto._removeBackdrop = function _removeBackdrop() { 2546 if (this._backdrop) { 2547 $(this._backdrop).remove(); 2548 this._backdrop = null; 2549 } 2550 }; 2551 2552 _proto._showBackdrop = function _showBackdrop(callback) { 2553 var _this9 = this; 2554 2555 var animate = $(this._element).hasClass(ClassName$5.FADE) ? ClassName$5.FADE : ''; 2556 2557 if (this._isShown && this._config.backdrop) { 2558 this._backdrop = document.createElement('div'); 2559 this._backdrop.className = ClassName$5.BACKDROP; 2560 2561 if (animate) { 2562 this._backdrop.classList.add(animate); 2563 } 2564 2565 $(this._backdrop).appendTo(document.body); 2566 $(this._element).on(Event$5.CLICK_DISMISS, function (event) { 2567 if (_this9._ignoreBackdropClick) { 2568 _this9._ignoreBackdropClick = false;
2569 return; 2570 } 2571 2572 if (event.target !== event.currentTarget) { 2573 return; 2574 } 2575 2576 _this9._triggerBackdropTransition(); 2577 }); 2578 2579 if (animate) { 2580 Util.reflow(this._backdrop); 2581 } 2582 2583 $(this._backdrop).addClass(ClassName$5.SHOW); 2584 2585 if (!callback) { 2586 return; 2587 } 2588 2589 if (!animate) { 2590 callback(); 2591 return; 2592 } 2593 2594 var backdropTransitionDuration = Util.getTransitionDurationFromElement(this._backdrop); 2595 $(this._backdrop).one(Util.TRANSITION_END, callback).emulateTransitionEnd(backdropTransitionDuration); 2596 } else if (!this._isShown && this._backdrop) { 2597 $(this._backdrop).removeClass(ClassName$5.SHOW); 2598 2599 var callbackRemove = function callbackRemove() { 2600 _this9._removeBackdrop(); 2601 2602 if (callback) { 2603 callback(); 2604 } 2605 }; 2606 2607 if ($(this._element).hasClass(ClassName$5.FADE)) { 2608 var _backdropTransitionDuration = Util.getTransitionDurationFromElement(this._backdrop); 2609 2610 $(this._backdrop).one(Util.TRANSITION_END, callbackRemove).emulateTransitionEnd(_backdropTransitionDuration); 2611 } else { 2612 callbackRemove(); 2613 } 2614 } else if (callback) { 2615 callback(); 2616 } 2617 } // ---------------------------------------------------------------------- 2618 // the following methods are used to handle overflowing modals 2619 // todo (fat): these should probably be refactored out of modal.js 2620 // ---------------------------------------------------------------------- 2621 ; 2622 2623 _proto._adjustDialog = function _adjustDialog() { 2624 var isModalOverflowing = this._element.scrollHeight > document.documentElement.clientHeight; 2625 2626 if (!this._isBodyOverflowing && isModalOverflowing) { 2627 this._element.style.paddingLeft = this._scrollbarWidth + "px"; 2628 } 2629 2630 if (this._isBodyOverflowing && !isModalOverflowing) { 2631 this._element.style.paddingRight = this._scrollbarWidth + "px"; 2632 } 2633 }; 2634 2635 _proto._resetAdjustments = function _resetAdjustments() { 2636 this._element.style.paddingLeft = ''; 2637 this._element.style.paddingRight = ''; 2638 }; 2639 2640 _proto._checkScrollbar = function _checkScrollbar() { 2641 var rect = document.body.getBoundingClientRect(); 2642 this._isBodyOverflowing = rect.left + rect.right < window.innerWidth; 2643 this._scrollbarWidth = this._getScrollbarWidth(); 2644 }; 2645 2646 _proto._setScrollbar = function _setScrollbar() { 2647 var _this10 = this; 2648 2649 if (this._isBodyOverflowing) { 2650 // Note: DOMNode.style.paddingRight returns the actual value or '' if not set 2651 // while $(DOMNode).css('padding-right') returns the calculated value or 0 if not set 2652 var fixedContent = [].slice.call(document.querySelectorAll(Selector$5.FIXED_CONTENT)); 2653 var stickyContent = [].slice.call(document.querySelectorAll(Selector$5.STICKY_CONTENT)); // Adjust fixed content padding 2654 2655 $(fixedContent).each(function (index, element) { 2656 var actualPadding = element.style.paddingRight; 2657 var calculatedPadding = $(element).css('padding-right'); 2658 $(element).data('padding-right', actualPadding).css('padding-right', parseFloat(calculatedPadding) + _this10._scrollbarWidth + "px"); 2659 }); // Adjust sticky content margin 2660 2661 $(stickyContent).each(function (index, element) { 2662 var actualMargin = element.style.marginRight; 2663 var calculatedMargin = $(element).css('margin-right'); 2664 $(element).data('margin-right', actualMargin).css('margin-right', parseFloat(calculatedMargin) - _this10._scrollbarWidth + "px"); 2665 }); // Adjust body padding 2666 2667 var actualPadding = document.body.style.paddingRight; 2668 var calculatedPadding = $(document.body).css('padding-right'); 2669 $(document.body).data('padding-right', actualPadding).css('padding-right', parseFloat(calculatedPadding) + this._scrollbarWidth + "px"); 2670 } 2671 2672 $(document.body).addClass(ClassName$5.OPEN); 2673 }; 2674 2675 _proto._resetScrollbar = function _resetScrollbar() { 2676 // Restore fixed content padding 2677 var fixedContent = [].slice.call(document.querySelectorAll(Selector$5.FIXED_CONTENT)); 2678 $(fixedContent).each(function (index, element) { 2679 var padding = $(element).data('padding-right'); 2680 $(element).removeData('padding-right'); 2681 element.style.paddingRight = padding ? padding : ''; 2682 }); // Restore sticky content 2683 2684 var elements = [].slice.call(document.querySelectorAll("" + Selector$5.STICKY_CONTENT)); 2685 $(elements).each(function (index, element) { 2686 var margin = $(element).data('margin-right'); 2687 2688 if (typeof margin !== 'undefined') { 2689 $(element).css('margin-right', margin).removeData('margin-right'); 2690 } 2691 }); // Restore body padding 2692 2693 var padding = $(document.body).data('padding-right'); 2694 $(document.body).removeData('padding-right'); 2695 document.body.style.paddingRight = padding ? padding : ''; 2696 }; 2697 2698 _proto._getScrollbarWidth = function _getScrollbarWidth() { 2699 // thx d.walsh 2700 var scrollDiv = document.createElement('div'); 2701 scrollDiv.className = ClassName$5.SCROLLBAR_MEASURER; 2702 document.body.appendChild(scrollDiv); 2703 var scrollbarWidth = scrollDiv.getBoundingClientRect().width - scrollDiv.clientWidth; 2704 document.body.removeChild(scrollDiv); 2705 return scrollbarWidth; 2706 } // Static 2707 ; 2708 2709 Modal._jQueryInterface = function _jQueryInterface(config, relatedTarget) { 2710 return this.each(function () { 2711 var data = $(this).data(DATA_KEY$5); 2712
2713 var _config = _objectSpread2({}, Default$3, {}, $(this).data(), {}, typeof config === 'object' && config ? config : {}); 2714 2715 if (!data) { 2716 data = new Modal(this, _config); 2717 $(this).data(DATA_KEY$5, data); 2718 } 2719 2720 if (typeof config === 'string') { 2721 if (typeof data[config] === 'undefined') { 2722 throw new TypeError("No method named \"" + config + "\""); 2723 } 2724 2725 data[config](relatedTarget); 2726 } else if (_config.show) { 2727 data.show(relatedTarget); 2728 } 2729 }); 2730 }; 2731 2732 _createClass(Modal, null, [{ 2733 key: "VERSION", 2734 get: function get() { 2735 return VERSION$5; 2736 } 2737 }, { 2738 key: "Default", 2739 get: function get() { 2740 return Default$3; 2741 } 2742 }]); 2743 2744 return Modal; 2745 }(); 2746 /** 2747 * ------------------------------------------------------------------------ 2748 * Data Api implementation 2749 * ------------------------------------------------------------------------ 2750 */ 2751 2752 2753 $(document).on(Event$5.CLICK_DATA_API, Selector$5.DATA_TOGGLE, function (event) { 2754 var _this11 = this; 2755 2756 var target; 2757 var selector = Util.getSelectorFromElement(this); 2758 2759 if (selector) { 2760 target = document.querySelector(selector); 2761 } 2762 2763 var config = $(target).data(DATA_KEY$5) ? 'toggle' : _objectSpread2({}, $(target).data(), {}, $(this).data()); 2764 2765 if (this.tagName === 'A' || this.tagName === 'AREA') { 2766 event.preventDefault(); 2767 } 2768 2769 var $target = $(target).one(Event$5.SHOW, function (showEvent) { 2770 if (showEvent.isDefaultPrevented()) { 2771 // Only register focus restorer if modal will actually get shown 2772 return; 2773 } 2774 2775 $target.one(Event$5.HIDDEN, function () { 2776 if ($(_this11).is(':visible')) { 2777 _this11.focus(); 2778 } 2779 }); 2780 }); 2781 2782 Modal._jQueryInterface.call($(target), config, this); 2783 }); 2784 /** 2785 * ------------------------------------------------------------------------ 2786 * jQuery 2787 * ------------------------------------------------------------------------ 2788 */ 2789 2790 $.fn[NAME$5] = Modal._jQueryInterface; 2791 $.fn[NAME$5].Constructor = Modal; 2792 2793 $.fn[NAME$5].noConflict = function () { 2794 $.fn[NAME$5] = JQUERY_NO_CONFLICT$5; 2795 return Modal._jQueryInterface; 2796 }; 2797 2798 /** 2799 * -------------------------------------------------------------------------- 2800 * Bootstrap (v4.4.1): tools/sanitizer.js 2801 * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE) 2802 * -------------------------------------------------------------------------- 2803 */ 2804 var uriAttrs = ['background', 'cite', 'href', 'itemtype', 'longdesc', 'poster', 'src', 'xlink:href']; 2805 var ARIA_ATTRIBUTE_PATTERN = /^aria-[\w-]*$/i; 2806 var DefaultWhitelist = { 2807 // Global attributes allowed on any supplied element below. 2808 '*': ['class', 'dir', 'id', 'lang', 'role', ARIA_ATTRIBUTE_PATTERN], 2809 a: ['target', 'href', 'title', 'rel'], 2810 area: [], 2811 b: [], 2812 br: [], 2813 col: [], 2814 code: [], 2815 div: [], 2816 em: [], 2817 hr: [], 2818 h1: [], 2819 h2: [], 2820 h3: [], 2821 h4: [], 2822 h5: [], 2823 h6: [], 2824 i: [], 2825 img: ['src', 'alt', 'title', 'width', 'height'], 2826 li: [], 2827 ol: [], 2828 p: [], 2829 pre: [], 2830 s: [], 2831 small: [], 2832 span: [], 2833 sub: [], 2834 sup: [], 2835 strong: [], 2836 u: [], 2837 ul: [] 2838 }; 2839 /** 2840 * A pattern that recognizes a commonly useful subset of URLs that are safe. 2841 * 2842 * Shoutout to Angular 7 https://github.com/angular/angular/blob/7.2.4/packages/core/src/sanitization/url_sanitizer.ts 2843 */ 2844 2845 var SAFE_URL_PATTERN = /^(?:(?:https?|mailto|ftp|tel|file):|[^&:/?#]*(?:[/?#]|$))/gi; 2846 /** 2847 * A pattern that matches safe data URLs. Only matches image, video and audio types. 2848 * 2849 * Shoutout to Angular 7 https://github.com/angular/angular/blob/7.2.4/packages/core/src/sanitization/url_sanitizer.ts 2850 */ 2851 2852 var DATA_URL_PATTERN = /^data:(?:image\/(?:bmp|gif|jpeg|jpg|png|tiff|webp)|video\/(?:mpeg|mp4|ogg|webm)|audio\/(?:mp3|oga|ogg|opus));base64,[a-z0-9+/]+=*$/i; 2853 2854 function allowedAttribute(attr, allowedAttributeList) { 2855 var attrName = attr.nodeName.toLowerCase(); 2856 2857 if (allowedAttributeList.indexOf(attrName) !== -1) { 2858 if (uriAttrs.indexOf(attrName) !== -1) { 2859 return Boolean(attr.nodeValue.match(SAFE_URL_PATTERN) || attr.nodeValue.match(DATA_URL_PATTERN)); 2860 } 2861 2862 return true; 2863 } 2864 2865 var regExp = allowedAttributeList.filter(function (attrRegex) {
vendor: 4,872 bytes, lines 2866-3044
2866 return attrRegex instanceof RegExp; 2867 }); // Check if a regular expression validates the attribute. 2868 2869 for (var i = 0, l = regExp.length; i < l; i++) { 2870 if (attrName.match(regExp[i])) { 2871 return true; 2872 } 2873 } 2874 2875 return false; 2876 } 2877 2878 function sanitizeHtml(unsafeHtml, whiteList, sanitizeFn) { 2879 if (unsafeHtml.length === 0) { 2880 return unsafeHtml; 2881 } 2882 2883 if (sanitizeFn && typeof sanitizeFn === 'function') { 2884 return sanitizeFn(unsafeHtml); 2885 } 2886 2887 var domParser = new window.DOMParser(); 2888 var createdDocument = domParser.parseFromString(unsafeHtml, 'text/html'); 2889 var whitelistKeys = Object.keys(whiteList); 2890 var elements = [].slice.call(createdDocument.body.querySelectorAll('*')); 2891 2892 var _loop = function _loop(i, len) { 2893 var el = elements[i]; 2894 var elName = el.nodeName.toLowerCase(); 2895 2896 if (whitelistKeys.indexOf(el.nodeName.toLowerCase()) === -1) { 2897 el.parentNode.removeChild(el); 2898 return "continue"; 2899 } 2900 2901 var attributeList = [].slice.call(el.attributes); 2902 var whitelistedAttributes = [].concat(whiteList['*'] || [], whiteList[elName] || []); 2903 attributeList.forEach(function (attr) { 2904 if (!allowedAttribute(attr, whitelistedAttributes)) { 2905 el.removeAttribute(attr.nodeName); 2906 } 2907 }); 2908 }; 2909 2910 for (var i = 0, len = elements.length; i < len; i++) { 2911 var _ret = _loop(i); 2912 2913 if (_ret === "continue") continue; 2914 } 2915 2916 return createdDocument.body.innerHTML; 2917 } 2918 2919 /** 2920 * ------------------------------------------------------------------------ 2921 * Constants 2922 * ------------------------------------------------------------------------ 2923 */ 2924 2925 var NAME$6 = 'tooltip'; 2926 var VERSION$6 = '4.4.1'; 2927 var DATA_KEY$6 = 'bs.tooltip'; 2928 var EVENT_KEY$6 = "." + DATA_KEY$6; 2929 var JQUERY_NO_CONFLICT$6 = $.fn[NAME$6]; 2930 var CLASS_PREFIX = 'bs-tooltip'; 2931 var BSCLS_PREFIX_REGEX = new RegExp("(^|\\s)" + CLASS_PREFIX + "\\S+", 'g'); 2932 var DISALLOWED_ATTRIBUTES = ['sanitize', 'whiteList', 'sanitizeFn']; 2933 var DefaultType$4 = { 2934 animation: 'boolean', 2935 template: 'string', 2936 title: '(string|element|function)', 2937 trigger: 'string', 2938 delay: '(number|object)', 2939 html: 'boolean', 2940 selector: '(string|boolean)', 2941 placement: '(string|function)', 2942 offset: '(number|string|function)', 2943 container: '(string|element|boolean)', 2944 fallbackPlacement: '(string|array)', 2945 boundary: '(string|element)', 2946 sanitize: 'boolean', 2947 sanitizeFn: '(null|function)', 2948 whiteList: 'object', 2949 popperConfig: '(null|object)' 2950 }; 2951 var AttachmentMap$1 = { 2952 AUTO: 'auto', 2953 TOP: 'top', 2954 RIGHT: 'right', 2955 BOTTOM: 'bottom', 2956 LEFT: 'left' 2957 }; 2958 var Default$4 = { 2959 animation: true, 2960 template: '<div class="tooltip" role="tooltip">' + '<div class="arrow"></div>' + '<div class="tooltip-inner"></div></div>', 2961 trigger: 'hover focus', 2962 title: '', 2963 delay: 0, 2964 html: false, 2965 selector: false, 2966 placement: 'top', 2967 offset: 0, 2968 container: false, 2969 fallbackPlacement: 'flip', 2970 boundary: 'scrollParent', 2971 sanitize: true, 2972 sanitizeFn: null, 2973 whiteList: DefaultWhitelist, 2974 popperConfig: null 2975 }; 2976 var HoverState = { 2977 SHOW: 'show', 2978 OUT: 'out' 2979 }; 2980 var Event$6 = { 2981 HIDE: "hide" + EVENT_KEY$6, 2982 HIDDEN: "hidden" + EVENT_KEY$6, 2983 SHOW: "show" + EVENT_KEY$6, 2984 SHOWN: "shown" + EVENT_KEY$6, 2985 INSERTED: "inserted" + EVENT_KEY$6, 2986 CLICK: "click" + EVENT_KEY$6, 2987 FOCUSIN: "focusin" + EVENT_KEY$6, 2988 FOCUSOUT: "focusout" + EVENT_KEY$6, 2989 MOUSEENTER: "mouseenter" + EVENT_KEY$6, 2990 MOUSELEAVE: "mouseleave" + EVENT_KEY$6 2991 }; 2992 var ClassName$6 = { 2993 FADE: 'fade', 2994 SHOW: 'show' 2995 }; 2996 var Selector$6 = { 2997 TOOLTIP: '.tooltip', 2998 TOOLTIP_INNER: '.tooltip-inner', 2999 ARROW: '.arrow' 3000 }; 3001 var Trigger = { 3002 HOVER: 'hover', 3003 FOCUS: 'focus', 3004 CLICK: 'click', 3005 MANUAL: 'manual' 3006 }; 3007 /** 3008 * ------------------------------------------------------------------------ 3009 * Class Definition 3010 * ------------------------------------------------------------------------ 3011 */ 3012 3013 var Tooltip = 3014 /*#__PURE__*/ 3015 function () { 3016 function Tooltip(element, config) { 3017 if (typeof Popper === 'undefined') { 3018 throw new TypeError('Bootstrap\'s tooltips require Popper.js (https://popper.js.org/)'); 3019 } // private 3020 3021 3022 this._isEnabled = true; 3023 this._timeout = 0; 3024 this._hoverState = ''; 3025 this._activeTrigger = {}; 3026 this._popper = null; // Protected 3027 3028 this.element = element; 3029 this.config = this._getConfig(config); 3030 this.tip = null; 3031 3032 this._setListeners(); 3033 } // Getters 3034 3035 3036 var _proto = Tooltip.prototype; 3037 3038 // Public 3039 _proto.enable = function enable() { 3040 this._isEnabled = true; 3041 }; 3042 3043 _proto.disable = function disable() { 3044 this._isEnabled = false;
3045 }; 3046 3047 _proto.toggleEnabled = function toggleEnabled() { 3048 this._isEnabled = !this._isEnabled; 3049 }; 3050 3051 _proto.toggle = function toggle(event) { 3052 if (!this._isEnabled) { 3053 return; 3054 } 3055 3056 if (event) { 3057 var dataKey = this.constructor.DATA_KEY; 3058 var context = $(event.currentTarget).data(dataKey); 3059 3060 if (!context) { 3061 context = new this.constructor(event.currentTarget, this._getDelegateConfig()); 3062 $(event.currentTarget).data(dataKey, context); 3063 } 3064 3065 context._activeTrigger.click = !context._activeTrigger.click; 3066 3067 if (context._isWithActiveTrigger()) { 3068 context._enter(null, context); 3069 } else { 3070 context._leave(null, context); 3071 } 3072 } else { 3073 if ($(this.getTipElement()).hasClass(ClassName$6.SHOW)) { 3074 this._leave(null, this); 3075 3076 return; 3077 } 3078 3079 this._enter(null, this); 3080 } 3081 }; 3082 3083 _proto.dispose = function dispose() { 3084 clearTimeout(this._timeout); 3085 $.removeData(this.element, this.constructor.DATA_KEY); 3086 $(this.element).off(this.constructor.EVENT_KEY); 3087 $(this.element).closest('.modal').off('hide.bs.modal', this._hideModalHandler); 3088 3089 if (this.tip) { 3090 $(this.tip).remove(); 3091 } 3092 3093 this._isEnabled = null; 3094 this._timeout = null; 3095 this._hoverState = null; 3096 this._activeTrigger = null; 3097 3098 if (this._popper) { 3099 this._popper.destroy(); 3100 } 3101 3102 this._popper = null; 3103 this.element = null; 3104 this.config = null; 3105 this.tip = null; 3106 }; 3107 3108 _proto.show = function show() { 3109 var _this = this; 3110 3111 if ($(this.element).css('display') === 'none') { 3112 throw new Error('Please use show on visible elements'); 3113 } 3114 3115 var showEvent = $.Event(this.constructor.Event.SHOW); 3116 3117 if (this.isWithContent() && this._isEnabled) { 3118 $(this.element).trigger(showEvent); 3119 var shadowRoot = Util.findShadowRoot(this.element); 3120 var isInTheDom = $.contains(shadowRoot !== null ? shadowRoot : this.element.ownerDocument.documentElement, this.element); 3121 3122 if (showEvent.isDefaultPrevented() || !isInTheDom) { 3123 return; 3124 } 3125 3126 var tip = this.getTipElement(); 3127 var tipId = Util.getUID(this.constructor.NAME);
3128 tip.setAttribute('id', tipId); 3129 this.element.setAttribute('aria-describedby', tipId); 3130 this.setContent(); 3131 3132 if (this.config.animation) { 3133 $(tip).addClass(ClassName$6.FADE); 3134 } 3135 3136 var placement = typeof this.config.placement === 'function' ? this.config.placement.call(this, tip, this.element) : this.config.placement; 3137 3138 var attachment = this._getAttachment(placement); 3139 3140 this.addAttachmentClass(attachment); 3141 3142 var container = this._getContainer(); 3143 3144 $(tip).data(this.constructor.DATA_KEY, this); 3145 3146 if (!$.contains(this.element.ownerDocument.documentElement, this.tip)) { 3147 $(tip).appendTo(container); 3148 } 3149 3150 $(this.element).trigger(this.constructor.Event.INSERTED); 3151 this._popper = new Popper(this.element, tip, this._getPopperConfig(attachment)); 3152 $(tip).addClass(ClassName$6.SHOW); // If this is a touch-enabled device we add extra 3153 // empty mouseover listeners to the body's immediate children; 3154 // only needed because of broken event delegation on iOS 3155 // https://www.quirksmode.org/blog/archives/2014/02/mouse_event_bub.html 3156 3157 if ('ontouchstart' in document.documentElement) { 3158 $(document.body).children().on('mouseover', null, $.noop); 3159 } 3160 3161 var complete = function complete() { 3162 if (_this.config.animation) { 3163 _this._fixTransition(); 3164 } 3165 3166 var prevHoverState = _this._hoverState; 3167 _this._hoverState = null; 3168 $(_this.element).trigger(_this.constructor.Event.SHOWN); 3169 3170 if (prevHoverState === HoverState.OUT) { 3171 _this._leave(null, _this); 3172 } 3173 }; 3174 3175 if ($(this.tip).hasClass(ClassName$6.FADE)) { 3176 var transitionDuration = Util.getTransitionDurationFromElement(this.tip); 3177 $(this.tip).one(Util.TRANSITION_END, complete).emulateTransitionEnd(transitionDuration); 3178 } else { 3179 complete(); 3180 } 3181 } 3182 }; 3183 3184 _proto.hide = function hide(callback) { 3185 var _this2 = this; 3186 3187 var tip = this.getTipElement(); 3188 var hideEvent = $.Event(this.constructor.Event.HIDE); 3189 3190 var complete = function complete() { 3191 if (_this2._hoverState !== HoverState.SHOW && tip.parentNode) { 3192 tip.parentNode.removeChild(tip); 3193 } 3194 3195 _this2._cleanTipClass(); 3196 3197 _this2.element.removeAttribute('aria-describedby'); 3198 3199 $(_this2.element).trigger(_this2.constructor.Event.HIDDEN); 3200 3201 if (_this2._popper !== null) { 3202 _this2._popper.destroy(); 3203 } 3204 3205 if (callback) { 3206 callback(); 3207 } 3208 }; 3209 3210 $(this.element).trigger(hideEvent); 3211 3212 if (hideEvent.isDefaultPrevented()) { 3213 return; 3214 } 3215 3216 $(tip).removeClass(ClassName$6.SHOW); // If this is a touch-enabled device we remove the extra 3217 // empty mouseover listeners we added for iOS support 3218 3219 if ('ontouchstart' in document.documentElement) { 3220 $(document.body).children().off('mouseover', null, $.noop); 3221 } 3222 3223 this._activeTrigger[Trigger.CLICK] = false; 3224 this._activeTrigger[Trigger.FOCUS] = false; 3225 this._activeTrigger[Trigger.HOVER] = false; 3226 3227 if ($(this.tip).hasClass(ClassName$6.FADE)) { 3228 var transitionDuration = Util.getTransitionDurationFromElement(tip); 3229 $(tip).one(Util.TRANSITION_END, complete).emulateTransitionEnd(transitionDuration); 3230 } else { 3231 complete(); 3232 } 3233 3234 this._hoverState = ''; 3235 }; 3236 3237 _proto.update = function update() { 3238 if (this._popper !== null) { 3239 this._popper.scheduleUpdate(); 3240 } 3241 } // Protected 3242 ; 3243 3244 _proto.isWithContent = function isWithContent() { 3245 return Boolean(this.getTitle()); 3246 }; 3247 3248 _proto.addAttachmentClass = function addAttachmentClass(attachment) { 3249 $(this.getTipElement()).addClass(CLASS_PREFIX + "-" + attachment); 3250 }; 3251 3252 _proto.getTipElement = function getTipElement() { 3253 this.tip = this.tip || $(this.config.template)[0]; 3254 return this.tip; 3255 }; 3256 3257 _proto.setContent = function setContent() { 3258 var tip = this.getTipElement(); 3259 this.setElementContent($(tip.querySelectorAll(Selector$6.TOOLTIP_INNER)), this.getTitle()); 3260 $(tip).removeClass(ClassName$6.FADE + " " + ClassName$6.SHOW); 3261 }; 3262 3263 _proto.setElementContent = function setElementContent($element, content) { 3264 if (typeof content === 'object' && (content.nodeType || content.jquery)) { 3265 // Content is a DOM node or a jQuery 3266 if (this.config.html) { 3267 if (!$(content).parent().is($element)) { 3268 $element.empty().append(content); 3269 } 3270 } else { 3271 $element.text($(content).text()); 3272 } 3273 3274 return; 3275 } 3276 3277 if (this.config.html) { 3278 if (this.config.sanitize) { 3279 content = sanitizeHtml(content, this.config.whiteList, this.config.sanitizeFn); 3280 } 3281 3282 $element.html(content); 3283 } else { 3284 $element.text(content); 3285 } 3286 }; 3287 3288 _proto.getTitle = function getTitle() { 3289 var title = this.element.getAttribute('data-original-title'); 3290 3291 if (!title) { 3292 title = typeof this.config.title === 'function' ? this.config.title.call(this.element) : this.config.title; 3293 } 3294 3295 return title; 3296 } // Private 3297 ; 3298 3299 _proto._getPopperConfig = function _getPopperConfig(attachment) { 3300 var _this3 = this; 3301 3302 var defaultBsConfig = { 3303 placement: attachment, 3304 modifiers: { 3305 offset: this._getOffset(), 3306 flip: { 3307 behavior: this.config.fallbackPlacement 3308 }, 3309 arrow: { 3310 element: Selector$6.ARROW 3311 }, 3312 preventOverflow: {
3313 boundariesElement: this.config.boundary 3314 } 3315 }, 3316 onCreate: function onCreate(data) { 3317 if (data.originalPlacement !== data.placement) { 3318 _this3._handlePopperPlacementChange(data); 3319 } 3320 }, 3321 onUpdate: function onUpdate(data) { 3322 return _this3._handlePopperPlacementChange(data); 3323 } 3324 }; 3325 return _objectSpread2({}, defaultBsConfig, {}, this.config.popperConfig); 3326 }; 3327 3328 _proto._getOffset = function _getOffset() { 3329 var _this4 = this; 3330 3331 var offset = {}; 3332 3333 if (typeof this.config.offset === 'function') { 3334 offset.fn = function (data) { 3335 data.offsets = _objectSpread2({}, data.offsets, {}, _this4.config.offset(data.offsets, _this4.element) || {}); 3336 return data; 3337 }; 3338 } else { 3339 offset.offset = this.config.offset; 3340 } 3341 3342 return offset; 3343 }; 3344 3345 _proto._getContainer = function _getContainer() { 3346 if (this.config.container === false) { 3347 return document.body; 3348 } 3349 3350 if (Util.isElement(this.config.container)) { 3351 return $(this.config.container); 3352 } 3353 3354 return $(document).find(this.config.container); 3355 }; 3356 3357 _proto._getAttachment = function _getAttachment(placement) { 3358 return AttachmentMap$1[placement.toUpperCase()]; 3359 }; 3360 3361 _proto._setListeners = function _setListeners() { 3362 var _this5 = this; 3363 3364 var triggers = this.config.trigger.split(' '); 3365 triggers.forEach(function (trigger) { 3366 if (trigger === 'click') { 3367 $(_this5.element).on(_this5.constructor.Event.CLICK, _this5.config.selector, function (event) { 3368 return _this5.toggle(event); 3369 }); 3370 } else if (trigger !== Trigger.MANUAL) { 3371 var eventIn = trigger === Trigger.HOVER ? _this5.constructor.Event.MOUSEENTER : _this5.constructor.Event.FOCUSIN; 3372 var eventOut = trigger === Trigger.HOVER ? _this5.constructor.Event.MOUSELEAVE : _this5.constructor.Event.FOCUSOUT; 3373 $(_this5.element).on(eventIn, _this5.config.selector, function (event) { 3374 return _this5._enter(event); 3375 }).on(eventOut, _this5.config.selector, function (event) { 3376 return _this5._leave(event); 3377 }); 3378 } 3379 }); 3380 3381 this._hideModalHandler = function () { 3382 if (_this5.element) { 3383 _this5.hide(); 3384 } 3385 }; 3386 3387 $(this.element).closest('.modal').on('hide.bs.modal', this._hideModalHandler); 3388 3389 if (this.config.selector) { 3390 this.config = _objectSpread2({}, this.config, { 3391 trigger: 'manual', 3392 selector: '' 3393 }); 3394 } else { 3395 this._fixTitle(); 3396 } 3397 }; 3398 3399 _proto._fixTitle = function _fixTitle() { 3400 var titleType = typeof this.element.getAttribute('data-original-title'); 3401 3402 if (this.element.getAttribute('title') || titleType !== 'string') { 3403 this.element.setAttribute('data-original-title', this.element.getAttribute('title') || ''); 3404 this.element.setAttribute('title', ''); 3405 } 3406 }; 3407 3408 _proto._enter = function _enter(event, context) { 3409 var dataKey = this.constructor.DATA_KEY; 3410 context = context || $(event.currentTarget).data(dataKey); 3411 3412 if (!context) { 3413 context = new this.constructor(event.currentTarget, this._getDelegateConfig()); 3414 $(event.currentTarget).data(dataKey, context); 3415 } 3416 3417 if (event) { 3418 context._activeTrigger[event.type === 'focusin' ? Trigger.FOCUS : Trigger.HOVER] = true; 3419 } 3420 3421 if ($(context.getTipElement()).hasClass(ClassName$6.SHOW) || context._hoverState === HoverState.SHOW) { 3422 context._hoverState = HoverState.SHOW; 3423 return; 3424 } 3425 3426 clearTimeout(context._timeout); 3427 context._hoverState = HoverState.SHOW; 3428 3429 if (!context.config.delay || !context.config.delay.show) { 3430 context.show(); 3431 return; 3432 } 3433 3434 context._timeout = setTimeout(function () { 3435 if (context._hoverState === HoverState.SHOW) { 3436 context.show(); 3437 } 3438 }, context.config.delay.show); 3439 }; 3440 3441 _proto._leave = function _leave(event, context) { 3442 var dataKey = this.constructor.DATA_KEY; 3443 context = context || $(event.currentTarget).data(dataKey); 3444 3445 if (!context) { 3446 context = new this.constructor(event.currentTarget, this._getDelegateConfig()); 3447 $(event.currentTarget).data(dataKey, context); 3448 } 3449 3450 if (event) { 3451 context._activeTrigger[event.type === 'focusout' ? Trigger.FOCUS : Trigger.HOVER] = false;
vendor: 4,175 bytes, lines 3452-3614
3452 } 3453 3454 if (context._isWithActiveTrigger()) { 3455 return; 3456 } 3457 3458 clearTimeout(context._timeout); 3459 context._hoverState = HoverState.OUT; 3460 3461 if (!context.config.delay || !context.config.delay.hide) { 3462 context.hide(); 3463 return; 3464 } 3465 3466 context._timeout = setTimeout(function () { 3467 if (context._hoverState === HoverState.OUT) { 3468 context.hide(); 3469 } 3470 }, context.config.delay.hide); 3471 }; 3472 3473 _proto._isWithActiveTrigger = function _isWithActiveTrigger() { 3474 for (var trigger in this._activeTrigger) { 3475 if (this._activeTrigger[trigger]) { 3476 return true; 3477 } 3478 } 3479 3480 return false; 3481 }; 3482 3483 _proto._getConfig = function _getConfig(config) { 3484 var dataAttributes = $(this.element).data(); 3485 Object.keys(dataAttributes).forEach(function (dataAttr) { 3486 if (DISALLOWED_ATTRIBUTES.indexOf(dataAttr) !== -1) { 3487 delete dataAttributes[dataAttr]; 3488 } 3489 }); 3490 config = _objectSpread2({}, this.constructor.Default, {}, dataAttributes, {}, typeof config === 'object' && config ? config : {}); 3491 3492 if (typeof config.delay === 'number') { 3493 config.delay = { 3494 show: config.delay, 3495 hide: config.delay 3496 }; 3497 } 3498 3499 if (typeof config.title === 'number') { 3500 config.title = config.title.toString(); 3501 } 3502 3503 if (typeof config.content === 'number') { 3504 config.content = config.content.toString(); 3505 } 3506 3507 Util.typeCheckConfig(NAME$6, config, this.constructor.DefaultType); 3508 3509 if (config.sanitize) { 3510 config.template = sanitizeHtml(config.template, config.whiteList, config.sanitizeFn); 3511 } 3512 3513 return config; 3514 }; 3515 3516 _proto._getDelegateConfig = function _getDelegateConfig() { 3517 var config = {}; 3518 3519 if (this.config) { 3520 for (var key in this.config) { 3521 if (this.constructor.Default[key] !== this.config[key]) { 3522 config[key] = this.config[key]; 3523 } 3524 } 3525 } 3526 3527 return config; 3528 }; 3529 3530 _proto._cleanTipClass = function _cleanTipClass() { 3531 var $tip = $(this.getTipElement()); 3532 var tabClass = $tip.attr('class').match(BSCLS_PREFIX_REGEX); 3533 3534 if (tabClass !== null && tabClass.length) { 3535 $tip.removeClass(tabClass.join('')); 3536 } 3537 }; 3538 3539 _proto._handlePopperPlacementChange = function _handlePopperPlacementChange(popperData) { 3540 var popperInstance = popperData.instance; 3541 this.tip = popperInstance.popper; 3542 3543 this._cleanTipClass(); 3544 3545 this.addAttachmentClass(this._getAttachment(popperData.placement)); 3546 }; 3547 3548 _proto._fixTransition = function _fixTransition() { 3549 var tip = this.getTipElement(); 3550 var initConfigAnimation = this.config.animation; 3551 3552 if (tip.getAttribute('x-placement') !== null) { 3553 return; 3554 } 3555 3556 $(tip).removeClass(ClassName$6.FADE); 3557 this.config.animation = false; 3558 this.hide(); 3559 this.show(); 3560 this.config.animation = initConfigAnimation; 3561 } // Static 3562 ; 3563 3564 Tooltip._jQueryInterface = function _jQueryInterface(config) { 3565 return this.each(function () { 3566 var data = $(this).data(DATA_KEY$6); 3567 3568 var _config = typeof config === 'object' && config; 3569 3570 if (!data && /dispose|hide/.test(config)) { 3571 return; 3572 } 3573 3574 if (!data) { 3575 data = new Tooltip(this, _config); 3576 $(this).data(DATA_KEY$6, data); 3577 } 3578 3579 if (typeof config === 'string') { 3580 if (typeof data[config] === 'undefined') { 3581 throw new TypeError("No method named \"" + config + "\""); 3582 } 3583 3584 data[config](); 3585 } 3586 }); 3587 }; 3588 3589 _createClass(Tooltip, null, [{ 3590 key: "VERSION", 3591 get: function get() { 3592 return VERSION$6; 3593 } 3594 }, { 3595 key: "Default", 3596 get: function get() { 3597 return Default$4; 3598 } 3599 }, { 3600 key: "NAME", 3601 get: function get() { 3602 return NAME$6; 3603 } 3604 }, { 3605 key: "DATA_KEY", 3606 get: function get() { 3607 return DATA_KEY$6; 3608 } 3609 }, { 3610 key: "Event", 3611 get: function get() { 3612 return Event$6; 3613 } 3614 }, {
3615 key: "EVENT_KEY", 3616 get: function get() { 3617 return EVENT_KEY$6; 3618 } 3619 }, { 3620 key: "DefaultType", 3621 get: function get() { 3622 return DefaultType$4; 3623 } 3624 }]); 3625 3626 return Tooltip; 3627 }(); 3628 /** 3629 * ------------------------------------------------------------------------ 3630 * jQuery 3631 * ------------------------------------------------------------------------ 3632 */ 3633 3634 3635 $.fn[NAME$6] = Tooltip._jQueryInterface; 3636 $.fn[NAME$6].Constructor = Tooltip; 3637 3638 $.fn[NAME$6].noConflict = function () { 3639 $.fn[NAME$6] = JQUERY_NO_CONFLICT$6; 3640 return Tooltip._jQueryInterface; 3641 }; 3642 3643 /** 3644 * ------------------------------------------------------------------------ 3645 * Constants 3646 * ------------------------------------------------------------------------ 3647 */ 3648 3649 var NAME$7 = 'popover'; 3650 var VERSION$7 = '4.4.1'; 3651 var DATA_KEY$7 = 'bs.popover'; 3652 var EVENT_KEY$7 = "." + DATA_KEY$7; 3653 var JQUERY_NO_CONFLICT$7 = $.fn[NAME$7]; 3654 var CLASS_PREFIX$1 = 'bs-popover'; 3655 var BSCLS_PREFIX_REGEX$1 = new RegExp("(^|\\s)" + CLASS_PREFIX$1 + "\\S+", 'g'); 3656 3657 var Default$5 = _objectSpread2({}, Tooltip.Default, { 3658 placement: 'right', 3659 trigger: 'click', 3660 content: '', 3661 template: '<div class="popover" role="tooltip">' + '<div class="arrow"></div>' + '<h3 class="popover-header"></h3>' + '<div class="popover-body"></div></div>' 3662 }); 3663 3664 var DefaultType$5 = _objectSpread2({}, Tooltip.DefaultType, { 3665 content: '(string|element|function)' 3666 }); 3667 3668 var ClassName$7 = { 3669 FADE: 'fade', 3670 SHOW: 'show' 3671 }; 3672 var Selector$7 = { 3673 TITLE: '.popover-header', 3674 CONTENT: '.popover-body' 3675 }; 3676 var Event$7 = { 3677 HIDE: "hide" + EVENT_KEY$7, 3678 HIDDEN: "hidden" + EVENT_KEY$7, 3679 SHOW: "show" + EVENT_KEY$7, 3680 SHOWN: "shown" + EVENT_KEY$7, 3681 INSERTED: "inserted" + EVENT_KEY$7, 3682 CLICK: "click" + EVENT_KEY$7, 3683 FOCUSIN: "focusin" + EVENT_KEY$7, 3684 FOCUSOUT: "focusout" + EVENT_KEY$7, 3685 MOUSEENTER: "mouseenter" + EVENT_KEY$7, 3686 MOUSELEAVE: "mouseleave" + EVENT_KEY$7 3687 }; 3688 /** 3689 * ------------------------------------------------------------------------ 3690 * Class Definition 3691 * ------------------------------------------------------------------------ 3692 */ 3693 3694 var Popover = 3695 /*#__PURE__*/ 3696 function (_Tooltip) { 3697 _inheritsLoose(Popover, _Tooltip); 3698 3699 function Popover() { 3700 return _Tooltip.apply(this, arguments) || this; 3701 } 3702 3703 var _proto = Popover.prototype; 3704 3705 // Overrides 3706 _proto.isWithContent = function isWithContent() { 3707 return this.getTitle() || this._getContent(); 3708 }; 3709 3710 _proto.addAttachmentClass = function addAttachmentClass(attachment) { 3711 $(this.getTipElement()).addClass(CLASS_PREFIX$1 + "-" + attachment); 3712 }; 3713 3714 _proto.getTipElement = function getTipElement() { 3715 this.tip = this.tip || $(this.config.template)[0]; 3716 return this.tip; 3717 }; 3718 3719 _proto.setContent = function setContent() { 3720 var $tip = $(this.getTipElement()); // We use append for html objects to maintain js events 3721 3722 this.setElementContent($tip.find(Selector$7.TITLE), this.getTitle()); 3723 3724 var content = this._getContent(); 3725 3726 if (typeof content === 'function') { 3727 content = content.call(this.element); 3728 } 3729 3730 this.setElementContent($tip.find(Selector$7.CONTENT), content); 3731 $tip.removeClass(ClassName$7.FADE + " " + ClassName$7.SHOW); 3732 } // Private 3733 ; 3734 3735 _proto._getContent = function _getContent() { 3736 return this.element.getAttribute('data-content') || this.config.content; 3737 }; 3738 3739 _proto._cleanTipClass = function _cleanTipClass() { 3740 var $tip = $(this.getTipElement()); 3741 var tabClass = $tip.attr('class').match(BSCLS_PREFIX_REGEX$1); 3742 3743 if (tabClass !== null && tabClass.length > 0) { 3744 $tip.removeClass(tabClass.join('')); 3745 } 3746 } // Static 3747 ; 3748 3749 Popover._jQueryInterface = function _jQueryInterface(config) { 3750 return this.each(function () { 3751 var data = $(this).data(DATA_KEY$7); 3752 3753 var _config = typeof config === 'object' ? config : null; 3754 3755 if (!data && /dispose|hide/.test(config)) { 3756 return; 3757 } 3758 3759 if (!data) { 3760 data = new Popover(this, _config); 3761 $(this).data(DATA_KEY$7, data); 3762 } 3763 3764 if (typeof config === 'string') { 3765 if (typeof data[config] === 'undefined') {
3766 throw new TypeError("No method named \"" + config + "\""); 3767 } 3768 3769 data[config](); 3770 } 3771 }); 3772 }; 3773 3774 _createClass(Popover, null, [{ 3775 key: "VERSION", 3776 // Getters 3777 get: function get() { 3778 return VERSION$7; 3779 } 3780 }, { 3781 key: "Default", 3782 get: function get() { 3783 return Default$5; 3784 } 3785 }, { 3786 key: "NAME", 3787 get: function get() { 3788 return NAME$7; 3789 } 3790 }, { 3791 key: "DATA_KEY", 3792 get: function get() { 3793 return DATA_KEY$7; 3794 } 3795 }, { 3796 key: "Event", 3797 get: function get() { 3798 return Event$7; 3799 } 3800 }, { 3801 key: "EVENT_KEY", 3802 get: function get() { 3803 return EVENT_KEY$7; 3804 } 3805 }, { 3806 key: "DefaultType", 3807 get: function get() { 3808 return DefaultType$5; 3809 } 3810 }]); 3811 3812 return Popover; 3813 }(Tooltip); 3814 /** 3815 * ------------------------------------------------------------------------ 3816 * jQuery 3817 * ------------------------------------------------------------------------ 3818 */ 3819 3820 3821 $.fn[NAME$7] = Popover._jQueryInterface; 3822 $.fn[NAME$7].Constructor = Popover; 3823 3824 $.fn[NAME$7].noConflict = function () { 3825 $.fn[NAME$7] = JQUERY_NO_CONFLICT$7; 3826 return Popover._jQueryInterface; 3827 }; 3828 3829 /** 3830 * ------------------------------------------------------------------------ 3831 * Constants 3832 * ------------------------------------------------------------------------ 3833 */ 3834 3835 var NAME$8 = 'scrollspy'; 3836 var VERSION$8 = '4.4.1'; 3837 var DATA_KEY$8 = 'bs.scrollspy'; 3838 var EVENT_KEY$8 = "." + DATA_KEY$8; 3839 var DATA_API_KEY$6 = '.data-api'; 3840 var JQUERY_NO_CONFLICT$8 = $.fn[NAME$8]; 3841 var Default$6 = { 3842 offset: 10, 3843 method: 'auto', 3844 target: '' 3845 }; 3846 var DefaultType$6 = { 3847 offset: 'number', 3848 method: 'string', 3849 target: '(string|element)' 3850 }; 3851 var Event$8 = { 3852 ACTIVATE: "activate" + EVENT_KEY$8, 3853 SCROLL: "scroll" + EVENT_KEY$8, 3854 LOAD_DATA_API: "load" + EVENT_KEY$8 + DATA_API_KEY$6 3855 }; 3856 var ClassName$8 = { 3857 DROPDOWN_ITEM: 'dropdown-item', 3858 DROPDOWN_MENU: 'dropdown-menu', 3859 ACTIVE: 'active' 3860 }; 3861 var Selector$8 = { 3862 DATA_SPY: '[data-spy="scroll"]', 3863 ACTIVE: '.active', 3864 NAV_LIST_GROUP: '.nav, .list-group', 3865 NAV_LINKS: '.nav-link', 3866 NAV_ITEMS: '.nav-item', 3867 LIST_ITEMS: '.list-group-item', 3868 DROPDOWN: '.dropdown', 3869 DROPDOWN_ITEMS: '.dropdown-item', 3870 DROPDOWN_TOGGLE: '.dropdown-toggle' 3871 }; 3872 var OffsetMethod = { 3873 OFFSET: 'offset', 3874 POSITION: 'position' 3875 }; 3876 /** 3877 * ------------------------------------------------------------------------ 3878 * Class Definition 3879 * ------------------------------------------------------------------------ 3880 */ 3881 3882 var ScrollSpy = 3883 /*#__PURE__*/ 3884 function () { 3885 function ScrollSpy(element, config) { 3886 var _this = this; 3887 3888 this._element = element; 3889 this._scrollElement = element.tagName === 'BODY' ? window : element; 3890 this._config = this._getConfig(config); 3891 this._selector = this._config.target + " " + Selector$8.NAV_LINKS + "," + (this._config.target + " " + Selector$8.LIST_ITEMS + ",") + (this._config.target + " " + Selector$8.DROPDOWN_ITEMS); 3892 this._offsets = []; 3893 this._targets = []; 3894 this._activeTarget = null; 3895 this._scrollHeight = 0; 3896 $(this._scrollElement).on(Event$8.SCROLL, function (event) { 3897 return _this._process(event); 3898 }); 3899 this.refresh(); 3900 3901 this._process(); 3902 } // Getters 3903 3904 3905 var _proto = ScrollSpy.prototype; 3906 3907 // Public 3908 _proto.refresh = function refresh() { 3909 var _this2 = this; 3910 3911 var autoMethod = this._scrollElement === this._scrollElement.window ? OffsetMethod.OFFSET : OffsetMethod.POSITION; 3912 var offsetMethod = this._config.method === 'auto' ? autoMethod : this._config.method; 3913 var offsetBase = offsetMethod === OffsetMethod.POSITION ? this._getScrollTop() : 0; 3914 this._offsets = []; 3915 this._targets = []; 3916 this._scrollHeight = this._getScrollHeight(); 3917 var targets = [].slice.call(document.querySelectorAll(this._selector)); 3918 targets.map(function (element) { 3919 var target; 3920 var targetSelector = Util.getSelectorFromElement(element); 3921
vendor: 4,138 bytes, lines 3922-4050
3922 if (targetSelector) { 3923 target = document.querySelector(targetSelector); 3924 } 3925 3926 if (target) { 3927 var targetBCR = target.getBoundingClientRect(); 3928 3929 if (targetBCR.width || targetBCR.height) { 3930 // TODO (fat): remove sketch reliance on jQuery position/offset 3931 return [$(target)[offsetMethod]().top + offsetBase, targetSelector]; 3932 } 3933 } 3934 3935 return null; 3936 }).filter(function (item) { 3937 return item; 3938 }).sort(function (a, b) { 3939 return a[0] - b[0]; 3940 }).forEach(function (item) { 3941 _this2._offsets.push(item[0]); 3942 3943 _this2._targets.push(item[1]); 3944 }); 3945 }; 3946 3947 _proto.dispose = function dispose() { 3948 $.removeData(this._element, DATA_KEY$8); 3949 $(this._scrollElement).off(EVENT_KEY$8); 3950 this._element = null; 3951 this._scrollElement = null; 3952 this._config = null; 3953 this._selector = null; 3954 this._offsets = null; 3955 this._targets = null; 3956 this._activeTarget = null; 3957 this._scrollHeight = null; 3958 } // Private 3959 ; 3960 3961 _proto._getConfig = function _getConfig(config) { 3962 config = _objectSpread2({}, Default$6, {}, typeof config === 'object' && config ? config : {}); 3963 3964 if (typeof config.target !== 'string') { 3965 var id = $(config.target).attr('id'); 3966 3967 if (!id) { 3968 id = Util.getUID(NAME$8); 3969 $(config.target).attr('id', id); 3970 } 3971 3972 config.target = "#" + id; 3973 } 3974 3975 Util.typeCheckConfig(NAME$8, config, DefaultType$6); 3976 return config; 3977 }; 3978 3979 _proto._getScrollTop = function _getScrollTop() { 3980 return this._scrollElement === window ? this._scrollElement.pageYOffset : this._scrollElement.scrollTop; 3981 }; 3982 3983 _proto._getScrollHeight = function _getScrollHeight() { 3984 return this._scrollElement.scrollHeight || Math.max(document.body.scrollHeight, document.documentElement.scrollHeight); 3985 }; 3986 3987 _proto._getOffsetHeight = function _getOffsetHeight() { 3988 return this._scrollElement === window ? window.innerHeight : this._scrollElement.getBoundingClientRect().height; 3989 }; 3990 3991 _proto._process = function _process() { 3992 var scrollTop = this._getScrollTop() + this._config.offset; 3993 3994 var scrollHeight = this._getScrollHeight(); 3995 3996 var maxScroll = this._config.offset + scrollHeight - this._getOffsetHeight(); 3997 3998 if (this._scrollHeight !== scrollHeight) { 3999 this.refresh(); 4000 } 4001 4002 if (scrollTop >= maxScroll) { 4003 var target = this._targets[this._targets.length - 1]; 4004 4005 if (this._activeTarget !== target) { 4006 this._activate(target); 4007 } 4008 4009 return; 4010 } 4011 4012 if (this._activeTarget && scrollTop < this._offsets[0] && this._offsets[0] > 0) { 4013 this._activeTarget = null; 4014 4015 this._clear(); 4016 4017 return; 4018 } 4019 4020 var offsetLength = this._offsets.length; 4021 4022 for (var i = offsetLength; i--;) { 4023 var isActiveTarget = this._activeTarget !== this._targets[i] && scrollTop >= this._offsets[i] && (typeof this._offsets[i + 1] === 'undefined' || scrollTop < this._offsets[i + 1]); 4024 4025 if (isActiveTarget) { 4026 this._activate(this._targets[i]); 4027 } 4028 } 4029 }; 4030 4031 _proto._activate = function _activate(target) { 4032 this._activeTarget = target; 4033 4034 this._clear(); 4035 4036 var queries = this._selector.split(',').map(function (selector) { 4037 return selector + "[data-target=\"" + target + "\"]," + selector + "[href=\"" + target + "\"]"; 4038 }); 4039 4040 var $link = $([].slice.call(document.querySelectorAll(queries.join(',')))); 4041 4042 if ($link.hasClass(ClassName$8.DROPDOWN_ITEM)) { 4043 $link.closest(Selector$8.DROPDOWN).find(Selector$8.DROPDOWN_TOGGLE).addClass(ClassName$8.ACTIVE); 4044 $link.addClass(ClassName$8.ACTIVE); 4045 } else { 4046 // Set triggered link as active 4047 $link.addClass(ClassName$8.ACTIVE); // Set triggered links parents as active 4048 // With both <ul> and <nav> markup a parent is the previous sibling of any nav ancestor 4049 4050 $link.parents(Selector$8.NAV_LIST_GROUP).prev(Selector$8.NAV_LINKS + ", " + Selector$8.
4050LIST_ITEMS).addClass(ClassName$8.ACTIVE); // Handle special case when .nav-link is inside .nav-item 4051 4052 $link.parents(Selector$8.NAV_LIST_GROUP).prev(Selector$8.NAV_ITEMS).children(Selector$8.NAV_LINKS).addClass(ClassName$8.ACTIVE); 4053 } 4054 4055 $(this._scrollElement).trigger(Event$8.ACTIVATE, { 4056 relatedTarget: target 4057 }); 4058 }; 4059 4060 _proto._clear = function _clear() { 4061 [].slice.call(document.querySelectorAll(this._selector)).filter(function (node) { 4062 return node.classList.contains(ClassName$8.ACTIVE); 4063 }).forEach(function (node) { 4064 return node.classList.remove(ClassName$8.ACTIVE); 4065 }); 4066 } // Static 4067 ; 4068 4069 ScrollSpy._jQueryInterface = function _jQueryInterface(config) { 4070 return this.each(function () { 4071 var data = $(this).data(DATA_KEY$8); 4072 4073 var _config = typeof config === 'object' && config; 4074 4075 if (!data) { 4076 data = new ScrollSpy(this, _config); 4077 $(this).data(DATA_KEY$8, data); 4078 } 4079 4080 if (typeof config === 'string') { 4081 if (typeof data[config] === 'undefined') { 4082 throw new TypeError("No method named \"" + config + "\""); 4083 } 4084 4085 data[config](); 4086 } 4087 }); 4088 }; 4089 4090 _createClass(ScrollSpy, null, [{ 4091 key: "VERSION", 4092 get: function get() { 4093 return VERSION$8; 4094 } 4095 }, { 4096 key: "Default", 4097 get: function get() { 4098 return Default$6; 4099 } 4100 }]); 4101 4102 return ScrollSpy; 4103 }(); 4104 /** 4105 * ------------------------------------------------------------------------ 4106 * Data Api implementation 4107 * ------------------------------------------------------------------------ 4108 */ 4109 4110 4111 $(window).on(Event$8.LOAD_DATA_API, function () { 4112 var scrollSpys = [].slice.call(document.querySelectorAll(Selector$8.DATA_SPY)); 4113 var scrollSpysLength = scrollSpys.length; 4114 4115 for (var i = scrollSpysLength; i--;) { 4116 var $spy = $(scrollSpys[i]); 4117 4118 ScrollSpy._jQueryInterface.call($spy, $spy.data()); 4119 } 4120 }); 4121 /** 4122 * ------------------------------------------------------------------------ 4123 * jQuery 4124 * ------------------------------------------------------------------------ 4125 */ 4126 4127 $.fn[NAME$8] = ScrollSpy._jQueryInterface; 4128 $.fn[NAME$8].Constructor = ScrollSpy; 4129 4130 $.fn[NAME$8].noConflict = function () { 4131 $.fn[NAME$8] = JQUERY_NO_CONFLICT$8; 4132 return ScrollSpy._jQueryInterface; 4133 }; 4134 4135 /** 4136 * ------------------------------------------------------------------------ 4137 * Constants 4138 * ------------------------------------------------------------------------ 4139 */ 4140 4141 var NAME$9 = 'tab'; 4142 var VERSION$9 = '4.4.1'; 4143 var DATA_KEY$9 = 'bs.tab'; 4144 var EVENT_KEY$9 = "." + DATA_KEY$9; 4145 var DATA_API_KEY$7 = '.data-api'; 4146 var JQUERY_NO_CONFLICT$9 = $.fn[NAME$9]; 4147 var Event$9 = { 4148 HIDE: "hide" + EVENT_KEY$9, 4149 HIDDEN: "hidden" + EVENT_KEY$9, 4150 SHOW: "show" + EVENT_KEY$9, 4151 SHOWN: "shown" + EVENT_KEY$9, 4152 CLICK_DATA_API: "click" + EVENT_KEY$9 + DATA_API_KEY$7 4153 }; 4154 var ClassName$9 = { 4155 DROPDOWN_MENU: 'dropdown-menu', 4156 ACTIVE: 'active', 4157 DISABLED: 'disabled', 4158 FADE: 'fade', 4159 SHOW: 'show' 4160 }; 4161 var Selector$9 = { 4162 DROPDOWN: '.dropdown', 4163 NAV_LIST_GROUP: '.nav, .list-group', 4164 ACTIVE: '.active', 4165 ACTIVE_UL: '> li > .active', 4166 DATA_TOGGLE: '[data-toggle="tab"], [data-toggle="pill"], [data-toggle="list"]', 4167 DROPDOWN_TOGGLE: '.dropdown-toggle', 4168 DROPDOWN_ACTIVE_CHILD: '> .dropdown-menu .active' 4169 }; 4170 /** 4171 * ------------------------------------------------------------------------ 4172 * Class Definition 4173 * ------------------------------------------------------------------------ 4174 */ 4175 4176 var Tab = 4177 /*#__PURE__*/ 4178 function () { 4179 function Tab(element) { 4180 this._element = element; 4181 } // Getters 4182 4183 4184 var _proto = Tab.prototype; 4185 4186 // Public 4187 _proto.show = function show() { 4188 var _this = this; 4189 4190 if (this._element.parentNode && this._element.parentNode.nodeType === Node.ELEMENT_NODE && $(this._element).hasClass(ClassName$9.ACTIVE) || $(this._element).hasClass(ClassName$9.DISABLED)) { 4191 return; 4192 } 4193 4194 var target; 4195 var previous; 4196 var listElement = $(this._element).closest(Selector$9.NAV_LIST_GROUP)[0]; 4197 var selector = Util.getSelectorFromElement(this._element); 4198 4199 if (listElement) { 4200 var itemSelector = listElement.nodeName === 'UL' || listElement.nodeName === 'OL' ? Selector$9.ACTIVE_UL : Selector$9.ACTIVE; 4201 previous = $.makeArray($(listElement).find(itemSelector)); 4202 previous = previous[previous.length - 1]; 4203 } 4204 4205 var hideEvent = $.Event(Event$9.HIDE, { 4206 relatedTarget: this._element 4207 }); 4208 var showEvent = $.Event(Event$9.SHOW, { 4209 relatedTarget: previous 4210 }); 4211 4212 if (previous) { 4213 $(previous).trigger(hideEvent); 4214 } 4215 4216 $(this._element).trigger(showEvent); 4217 4218 if (showEvent.isDefaultPrevented() || hideEvent.isDefaultPrevented()) { 4219 return; 4220 } 4221 4222 if (selector) { 4223 target = document.querySelector(selector); 4224 } 4225 4226 this._activate(this._element, listElement); 4227 4228 var complete = function complete() { 4229 var hiddenEvent = $.Event(Event$9.HIDDEN, { 4230 relatedTarget: _this._element 4231 }); 4232 var shownEvent = $.Event(Event$9.SHOWN, { 4233 relatedTarget: previous 4234 }); 4235 $(previous).trigger(hiddenEvent); 4236 $(_this._element).trigger(shownEvent); 4237 }; 4238 4239 if (target) { 4240 this._activate(target, target.parentNode, complete); 4241 } else { 4242 complete(); 4243 } 4244 }; 4245 4246 _proto.dispose = function dispose() { 4247 $.removeData(this._element, DATA_KEY$9); 4248 this._element = null; 4249 } // Private 4250 ; 4251 4252 _proto._activate = function _activate(element, container, callback) { 4253 var _this2 = this; 4254 4255 var activeElements = container && (container.nodeName === 'UL' || container.nodeName === 'OL') ? $(container).find(Selector$9.ACTIVE_UL) : $(container).children(Selector$9.ACTIVE); 4256 var active = activeElements[0]; 4257 var isTransitioning = callback && active && $(active).hasClass(ClassName$9.FADE); 4258 4259 var complete = function complete() { 4260 return _this2._transitionComplete(element, active, callback); 4261 }; 4262 4263 if (active && isTransitioning) { 4264 var transitionDuration = Util.getTransitionDurationFromElement(active); 4265 $(active).removeClass(ClassName$9.SHOW).one(Util.TRANSITION_END, complete).emulateTransitionEnd(transitionDuration); 4266 } else { 4267 complete(); 4268 } 4269 }; 4270 4271 _proto._transitionComplete = function _transitionComplete(element, active, callback) { 4272 if (active) { 4273 $(active).removeClass(ClassName$9.ACTIVE);
4274 var dropdownChild = $(active.parentNode).find(Selector$9.DROPDOWN_ACTIVE_CHILD)[0]; 4275 4276 if (dropdownChild) { 4277 $(dropdownChild).removeClass(ClassName$9.ACTIVE); 4278 } 4279 4280 if (active.getAttribute('role') === 'tab') { 4281 active.setAttribute('aria-selected', false); 4282 } 4283 } 4284 4285 $(element).addClass(ClassName$9.ACTIVE); 4286 4287 if (element.getAttribute('role') === 'tab') { 4288 element.setAttribute('aria-selected', true); 4289 } 4290 4291 Util.reflow(element); 4292 4293 if (element.classList.contains(ClassName$9.FADE)) { 4294 element.classList.add(ClassName$9.SHOW); 4295 } 4296 4297 if (element.parentNode && $(element.parentNode).hasClass(ClassName$9.DROPDOWN_MENU)) { 4298 var dropdownElement = $(element).closest(Selector$9.DROPDOWN)[0]; 4299 4300 if (dropdownElement) { 4301 var dropdownToggleList = [].slice.call(dropdownElement.querySelectorAll(Selector$9.DROPDOWN_TOGGLE)); 4302 $(dropdownToggleList).addClass(ClassName$9.ACTIVE); 4303 } 4304 4305 element.setAttribute('aria-expanded', true); 4306 } 4307 4308 if (callback) { 4309 callback(); 4310 } 4311 } // Static 4312 ; 4313 4314 Tab._jQueryInterface = function _jQueryInterface(config) { 4315 return this.each(function () { 4316 var $this = $(this); 4317 var data = $this.data(DATA_KEY$9); 4318 4319 if (!data) { 4320 data = new Tab(this); 4321 $this.data(DATA_KEY$9, data); 4322 } 4323 4324 if (typeof config === 'string') { 4325 if (typeof data[config] === 'undefined') { 4326 throw new TypeError("No method named \"" + config + "\""); 4327 } 4328 4329 data[config](); 4330 } 4331 }); 4332 }; 4333 4334 _createClass(Tab, null, [{ 4335 key: "VERSION", 4336 get: function get() { 4337 return VERSION$9; 4338 } 4339 }]); 4340 4341 return Tab; 4342 }(); 4343 /** 4344 * ------------------------------------------------------------------------ 4345 * Data Api implementation 4346 * ------------------------------------------------------------------------ 4347 */ 4348 4349 4350 $(document).on(Event$9.CLICK_DATA_API, Selector$9.DATA_TOGGLE, function (event) { 4351 event.preventDefault(); 4352 4353 Tab._jQueryInterface.call($(this), 'show'); 4354 }); 4355 /** 4356 * ------------------------------------------------------------------------ 4357 * jQuery 4358 * ------------------------------------------------------------------------ 4359 */ 4360 4361 $.fn[NAME$9] = Tab._jQueryInterface; 4362 $.fn[NAME$9].Constructor = Tab; 4363 4364 $.fn[NAME$9].noConflict = function () { 4365 $.fn[NAME$9] = JQUERY_NO_CONFLICT$9; 4366 return Tab._jQueryInterface; 4367 }; 4368 4369 /** 4370 * ------------------------------------------------------------------------ 4371 * Constants 4372 * ------------------------------------------------------------------------ 4373 */ 4374 4375 var NAME$a = 'toast'; 4376 var VERSION$a = '4.4.1'; 4377 var DATA_KEY$a = 'bs.toast'; 4378 var EVENT_KEY$a = "." + DATA_KEY$a; 4379 var JQUERY_NO_CONFLICT$a = $.fn[NAME$a]; 4380 var Event$a = { 4381 CLICK_DISMISS: "click.dismiss" + EVENT_KEY$a, 4382 HIDE: "hide" + EVENT_KEY$a, 4383 HIDDEN: "hidden" + EVENT_KEY$a, 4384 SHOW: "show" + EVENT_KEY$a, 4385 SHOWN: "shown" + EVENT_KEY$a 4386 }; 4387 var ClassName$a = { 4388 FADE: 'fade', 4389 HIDE: 'hide', 4390 SHOW: 'show', 4391 SHOWING: 'showing' 4392 }; 4393 var DefaultType$7 = { 4394 animation: 'boolean', 4395 autohide: 'boolean', 4396 delay: 'number' 4397 }; 4398 var Default$7 = { 4399 animation: true, 4400 autohide: true, 4401 delay: 500 4402 }; 4403 var Selector$a = { 4404 DATA_DISMISS: '[data-dismiss="toast"]' 4405 }; 4406 /** 4407 * ------------------------------------------------------------------------ 4408 * Class Definition 4409 * ------------------------------------------------------------------------ 4410 */ 4411 4412 var Toast = 4413 /*#__PURE__*/ 4414 function () { 4415 function Toast(element, config) { 4416 this._element = element; 4417 this._config = this._getConfig(config); 4418 this._timeout = null; 4419 4420 this._setListeners(); 4421 } // Getters 4422 4423 4424 var _proto = Toast.prototype; 4425 4426 // Public 4427 _proto.show = function show() { 4428 var _this = this; 4429 4430 var showEvent = $.Event(Event$a.SHOW); 4431 $(this._element).trigger(showEvent); 4432 4433 if (showEvent.isDefaultPrevented()) { 4434 return; 4435 } 4436 4437 if (this._config.animation) { 4438 this._element.classList.add(ClassName$a.FADE); 4439 } 4440 4441 var complete = function complete() { 4442 _this._element.classList.remove(ClassName$a.SHOWING); 4443 4444 _this._element.classList.add(ClassName$a.SHOW); 4445 4446 $(_this._element).trigger(Event$a.SHOWN); 4447 4448 if (_this._config.autohide) { 4449 _this._timeout = setTimeout(function () { 4450 _this.hide(); 4451 }, _this._config.delay); 4452 } 4453 }; 4454 4455 this._element.classList.remove(ClassName$a.HIDE); 4456 4457 Util.reflow(this._element); 4458 4459 this._element.classList.add(ClassName$a.SHOWING); 4460 4461 if (this._config.animation) { 4462 var transitionDuration = Util.getTransitionDurationFromElement(this._element); 4463 $(this._element).one(Util.TRANSITION_END, complete).emulateTransitionEnd(transitionDuration); 4464 } else { 4465 complete(); 4466 } 4467 }; 4468 4469 _proto.hide = function hide() { 4470 if (!this._element.classList.contains(ClassName$a.SHOW)) { 4471 return; 4472 } 4473 4474 var hideEvent = $.Event(Event$a.HIDE); 4475 $(this._element).trigger(hideEvent); 4476 4477 if (hideEvent.isDefaultPrevented()) { 4478 return; 4479 } 4480 4481 this._close(); 4482 }; 4483 4484 _proto.dispose = function dispose() { 4485 clearTimeout(this._timeout); 4486 this._timeout = null; 4487 4488 if (this._element.classList.contains(ClassName$a.SHOW)) { 4489 this._element.classList.remove(ClassName$a.SHOW); 4490 } 4491 4492 $(this._element).off(Event$a.CLICK_DISMISS); 4493 $.removeData(this._element, DATA_KEY$a); 4494 this._element = null; 4495 this._config = null; 4496 } // Private 4497 ; 4498 4499 _proto._getConfig = function _getConfig(config) {
4500 config = _objectSpread2({}, Default$7, {}, $(this._element).data(), {}, typeof config === 'object' && config ? config : {}); 4501 Util.typeCheckConfig(NAME$a, config, this.constructor.DefaultType); 4502 return config; 4503 }; 4504 4505 _proto._setListeners = function _setListeners() { 4506 var _this2 = this; 4507 4508 $(this._element).on(Event$a.CLICK_DISMISS, Selector$a.DATA_DISMISS, function () { 4509 return _this2.hide(); 4510 }); 4511 }; 4512 4513 _proto._close = function _close() { 4514 var _this3 = this; 4515 4516 var complete = function complete() { 4517 _this3._element.classList.add(ClassName$a.HIDE); 4518 4519 $(_this3._element).trigger(Event$a.HIDDEN); 4520 }; 4521 4522 this._element.classList.remove(ClassName$a.SHOW); 4523 4524 if (this._config.animation) { 4525 var transitionDuration = Util.getTransitionDurationFromElement(this._element); 4526 $(this._element).one(Util.TRANSITION_END, complete).emulateTransitionEnd(transitionDuration); 4527 } else { 4528 complete(); 4529 } 4530 } // Static 4531 ; 4532 4533 Toast._jQueryInterface = function _jQueryInterface(config) { 4534 return this.each(function () { 4535 var $element = $(this); 4536 var data = $element.data(DATA_KEY$a); 4537 4538 var _config = typeof config === 'object' && config; 4539 4540 if (!data) { 4541 data = new Toast(this, _config); 4542 $element.data(DATA_KEY$a, data); 4543 } 4544 4545 if (typeof config === 'string') { 4546 if (typeof data[config] === 'undefined') { 4547 throw new TypeError("No method named \"" + config + "\""); 4548 } 4549 4550 data[config](this); 4551 } 4552 }); 4553 }; 4554 4555 _createClass(Toast, null, [{ 4556 key: "VERSION", 4557 get: function get() { 4558 return VERSION$a; 4559 } 4560 }, { 4561 key: "DefaultType", 4562 get: function get() { 4563 return DefaultType$7; 4564 } 4565 }, { 4566 key: "Default", 4567 get: function get() { 4568 return Default$7; 4569 } 4570 }]); 4571 4572 return Toast; 4573 }(); 4574 /** 4575 * ------------------------------------------------------------------------ 4576 * jQuery 4577 * ------------------------------------------------------------------------ 4578 */ 4579 4580 4581 $.fn[NAME$a] = Toast._jQueryInterface; 4582 $.fn[NAME$a].Constructor = Toast; 4583 4584 $.fn[NAME$a].noConflict = function () { 4585 $.fn[NAME$a] = JQUERY_NO_CONFLICT$a; 4586 return Toast._jQueryInterface; 4587 }; 4588 4589 exports.Alert = Alert; 4590 exports.Button = Button; 4591 exports.Carousel = Carousel; 4592 exports.Collapse = Collapse; 4593 exports.Dropdown = Dropdown; 4594 exports.Modal = Modal; 4595 exports.Popover = Popover; 4596 exports.Scrollspy = ScrollSpy; 4597 exports.Tab = Tab; 4598 exports.Toast = Toast; 4599 exports.Tooltip = Tooltip; 4600 exports.Util = Util; 4601 4602 Object.defineProperty(exports, '__esModule', { value: true }); 4603 4604}))); 4605 4606 4607},{"jquery":12,"popper.js":14}],10:[function(require,module,exports){ 4608/*! 4609 * jQuery Migrate - v3.1.0 - 2019-06-08 4610 * Copyright OpenJS Foundation and other contributors 4611 */ 4612;( function( factory ) { 4613 if ( typeof define === "function" && define.amd ) { 4614 4615 // AMD. Register as an anonymous module. 4616 define( [ "jquery" ], function ( jQuery ) { 4617 return factory( jQuery, window ); 4618 } ); 4619 } else if ( typeof module === "object" && module.exports ) { 4620 4621 // Node/CommonJS 4622 // eslint-disable-next-line no-undef 4623 module.exports = factory( require( "jquery" ), window ); 4624 } else { 4625 4626 // Browser globals 4627 factory( jQuery, window ); 4628 } 4629} )( function( jQuery, window ) { 4630"use strict"; 4631 4632 4633jQuery.migrateVersion = "3.1.0"; 4634 4635/* exported jQueryVersionSince, compareVersions */ 4636 4637// Returns 0 if v1 == v2, -1 if v1 < v2, 1 if v1 > v2 4638function compareVersions( v1, v2 ) { 4639 var rVersionParts = /^(\d+)\.(\d+)\.(\d+)/, 4640 v1p = rVersionParts.exec( v1 ) || [ ], 4641 v2p = rVersionParts.exec( v2 ) || [ ]; 4642 4643 for ( var i = 1; i <= 3; i++ ) { 4644 if ( +v1p[ i ] > +v2p[ i ] ) { 4645 return 1; 4646 } 4647 if ( +v1p[ i ] < +v2p[ i ] ) { 4648 return -1; 4649 } 4650 } 4651 return 0; 4652} 4653 4654function jQueryVersionSince( version ) { 4655 return compareVersions( jQuery.fn.jquery, version ) >= 0; 4656} 4657 4658/* exported migrateWarn, migrateWarnFunc, migrateWarnProp */ 4659 4660( function() { 4661 4662 // Support: IE9 only 4663 // IE9 only creates console object when dev tools are first opened 4664 // IE9 console is a host object, callable but doesn't have .apply() 4665 if ( !window.console || !window.console.log ) { 4666 return; 4667 } 4668 4669 // Need jQuery 3.0.0+ and no older Migrate loaded 4670 if ( !jQuery || !jQueryVersionSince( "3.0.0" ) ) { 4671 window.console.log( "JQMIGRATE: jQuery 3.0.0+ REQUIRED" ); 4672 } 4673 if ( jQuery.migrateWarnings ) { 4674 window.console.log( "JQMIGRATE: Migrate plugin loaded multiple times" ); 4675 } 4676 4677 // Show a message on the console so devs know we're active 4678 window.console.log( "JQMIGRATE: Migrate is installed" + 4679 ( jQuery.migrateMute ? "" : " with logging active" ) + 4680 ", version " + jQuery.migrateVersion ); 4681 4682} )(); 4683 4684var warnedAbout = {}; 4685 4686// List of warnings already given; public read only 4687jQuery.migrateWarnings = []; 4688 4689// Set to false to disable traces that appear with warnings 4690if ( jQuery.migrateTrace === undefined ) { 4691 jQuery.migrateTrace = true; 4692} 4693 4694// Forget any warnings we've already given; public 4695jQuery.migrateReset = function() { 4696 warnedAbout = {}; 4697 jQuery.migrateWarnings.length = 0; 4698}; 4699 4700function migrateWarn( msg ) { 4701 var console = window.console; 4702 if ( !warnedAbout[ msg ] ) { 4703 warnedAbout[ msg ] = true; 4704 jQuery.migrateWarnings.push( msg ); 4705 if ( console && console.warn && !jQuery.migrateMute ) { 4706 console.warn( "JQMIGRATE: " + msg ); 4707 if ( jQuery.migrateTrace && console.trace ) { 4708 console.trace(); 4709 } 4710 } 4711 } 4712} 4713 4714function migrateWarnProp( obj, prop, value, msg ) { 4715 Object.defineProperty( obj, prop, { 4716 configurable: true, 4717 enumerable: true, 4718 get: function() { 4719 migrateWarn( msg ); 4720 return value; 4721 }, 4722 set: function( newValue ) { 4723 migrateWarn( msg ); 4724 value = newValue; 4725 } 4726 } ); 4727} 4728 4729function migrateWarnFunc( obj, prop, newFunc, msg ) { 4730 obj[ prop ] = function() { 4731 migrateWarn( msg ); 4732 return newFunc.apply( this, arguments ); 4733 }; 4734} 4735 4736if ( window.document.compatMode === "BackCompat" ) { 4737 4738 // JQuery has never supported or tested Quirks Mode 4739 migrateWarn( "jQuery is not compatible with Quirks Mode" ); 4740} 4741 4742 4743var oldInit = jQuery.fn.init, 4744 oldIsNumeric = jQuery.isNumeric, 4745 oldFind = jQuery.find, 4746 rattrHashTest = /\[(\s*[-\w]+\s*)([~|^$*]?=)\s*([-\w#]*?#[-\w#]*)\s*\]/, 4747 rattrHashGlob = /\[(\s*[-\w]+\s*)([~|^$*]?=)\s*([-\w#]*?#[-\w#]*)\s*\]/g; 4748 4749jQuery.fn.init = function( arg1 ) { 4750 var args = Array.prototype.slice.call( arguments ); 4751 4752 if ( typeof arg1 === "string" && arg1 === "#" ) { 4753 4754 // JQuery( "#" ) is a bogus ID selector, but it returned an empty set before jQuery 3.0 4755 migrateWarn( "jQuery( '#' ) is not a valid selector" ); 4756 args[ 0 ] = []; 4757 } 4758 4759 return oldInit.apply( this, args ); 4760}; 4761jQuery.fn.init.prototype = jQuery.fn; 4762 4763jQuery.find = function( selector ) { 4764 var args = Array.prototype.slice.call( arguments ); 4765 4766 // Support: PhantomJS 1.x 4767 // String#match fails to match when used with a //g RegExp, only on some strings 4768 if ( typeof selector === "string" && rattrHashTest.test( selector ) ) { 4769 4770 // The nonstandard and undocumented unquoted-hash was removed in jQuery 1.12.0 4771 // First see if qS thinks it's a valid selector, if so avoid a false positive 4772 try { 4773 window.document.querySelector( selector ); 4774 } catch ( err1 ) { 4775 4776 // Didn't *look* valid to qSA, warn and try quoting what we think is the value 4777 selector = selector.replace( rattrHashGlob, function( _, attr, op, value ) { 4778 return "[" + attr + op + "\"" + value + "\"]"; 4779 } ); 4780
4781 // If the regexp *may* have created an invalid selector, don't update it 4782 // Note that there may be false alarms if selector uses jQuery extensions 4783 try { 4784 window.document.querySelector( selector ); 4785 migrateWarn( "Attribute selector with '#' must be quoted: " + args[ 0 ] ); 4786 args[ 0 ] = selector; 4787 } catch ( err2 ) { 4788 migrateWarn( "Attribute selector with '#' was not fixed: " + args[ 0 ] ); 4789 } 4790 } 4791 } 4792 4793 return oldFind.apply( this, args ); 4794}; 4795 4796// Copy properties attached to original jQuery.find method (e.g. .attr, .isXML) 4797var findProp; 4798for ( findProp in oldFind ) { 4799 if ( Object.prototype.hasOwnProperty.call( oldFind, findProp ) ) { 4800 jQuery.find[ findProp ] = oldFind[ findProp ]; 4801 } 4802} 4803 4804// The number of elements contained in the matched element set 4805jQuery.fn.size = function() { 4806 migrateWarn( "jQuery.fn.size() is deprecated and removed; use the .length property" ); 4807 return this.length; 4808}; 4809 4810jQuery.parseJSON = function() { 4811 migrateWarn( "jQuery.parseJSON is deprecated; use JSON.parse" ); 4812 return JSON.parse.apply( null, arguments ); 4813}; 4814 4815jQuery.isNumeric = function( val ) { 4816 4817 // The jQuery 2.2.3 implementation of isNumeric 4818 function isNumeric2( obj ) { 4819 var realStringObj = obj && obj.toString(); 4820 return !jQuery.isArray( obj ) && ( realStringObj - parseFloat( realStringObj ) + 1 ) >= 0; 4821 } 4822 4823 var newValue = oldIsNumeric( val ), 4824 oldValue = isNumeric2( val ); 4825 4826 if ( newValue !== oldValue ) { 4827 migrateWarn( "jQuery.isNumeric() should not be called on constructed objects" ); 4828 } 4829 4830 return oldValue; 4831}; 4832 4833if ( jQueryVersionSince( "3.3.0" ) ) { 4834 migrateWarnFunc( jQuery, "isWindow", 4835 function( obj ) { 4836 return obj != null && obj === obj.window; 4837 }, 4838 "jQuery.isWindow() is deprecated" 4839 ); 4840} 4841 4842migrateWarnFunc( jQuery, "holdReady", jQuery.holdReady, 4843 "jQuery.holdReady is deprecated" ); 4844 4845migrateWarnFunc( jQuery, "unique", jQuery.uniqueSort, 4846 "jQuery.unique is deprecated; use jQuery.uniqueSort" ); 4847 4848// Now jQuery.expr.pseudos is the standard incantation 4849migrateWarnProp( jQuery.expr, "filters", jQuery.expr.pseudos, 4850 "jQuery.expr.filters is deprecated; use jQuery.expr.pseudos" ); 4851migrateWarnProp( jQuery.expr, ":", jQuery.expr.pseudos, 4852 "jQuery.expr[':'] is deprecated; use jQuery.expr.pseudos" ); 4853 4854// Prior to jQuery 3.2 there were internal refs so we don't warn there 4855if ( jQueryVersionSince( "3.2.0" ) ) { 4856 migrateWarnFunc( jQuery, "nodeName", jQuery.nodeName, 4857 "jQuery.nodeName is deprecated" ); 4858} 4859 4860 4861var oldAjax = jQuery.ajax; 4862 4863jQuery.ajax = function( ) { 4864 var jQXHR = oldAjax.apply( this, arguments ); 4865 4866 // Be sure we got a jQXHR (e.g., not sync) 4867 if ( jQXHR.promise ) { 4868 migrateWarnFunc( jQXHR, "success", jQXHR.done, 4869 "jQXHR.success is deprecated and removed" ); 4870 migrateWarnFunc( jQXHR, "error", jQXHR.fail, 4871 "jQXHR.error is deprecated and removed" ); 4872 migrateWarnFunc( jQXHR, "complete", jQXHR.always, 4873 "jQXHR.complete is deprecated and removed" ); 4874 } 4875 4876 return jQXHR; 4877}; 4878 4879 4880var oldRemoveAttr = jQuery.fn.removeAttr, 4881 oldToggleClass = jQuery.fn.toggleClass, 4882 rmatchNonSpace = /\S+/g; 4883 4884jQuery.fn.removeAttr = function( name ) { 4885 var self = this; 4886 4887 jQuery.each( name.match( rmatchNonSpace ), function( _i, attr ) { 4888 if ( jQuery.expr.match.bool.test( attr ) ) { 4889 migrateWarn( "jQuery.fn.removeAttr no longer sets boolean properties: " + attr ); 4890 self.prop( attr, false ); 4891 } 4892 } ); 4893 4894 return oldRemoveAttr.apply( this, arguments ); 4895}; 4896 4897jQuery.fn.toggleClass = function( state ) { 4898 4899 // Only deprecating no-args or single boolean arg 4900 if ( state !== undefined && typeof state !== "boolean" ) { 4901 return oldToggleClass.apply( this, arguments ); 4902 } 4903 4904 migrateWarn( "jQuery.fn.toggleClass( boolean ) is deprecated" ); 4905 4906 // Toggle entire class name of each element 4907 return this.each( function() { 4908 var className = this.getAttribute && this.getAttribute( "class" ) || ""; 4909 4910 if ( className ) { 4911 jQuery.data( this, "__className__", className ); 4912 } 4913 4914 // If the element has a class name or if we're passed `false`, 4915 // then remove the whole classname (if there was one, the above saved it). 4916 // Otherwise bring back whatever was previously saved (if anything), 4917 // falling back to the empty string if nothing was stored. 4918 if ( this.setAttribute ) { 4919 this.setAttribute( "class", 4920 className || state === false ? 4921 "" : 4922 jQuery.data( this, "__className__" ) || "" 4923 ); 4924 } 4925 } ); 4926}; 4927 4928 4929var internalSwapCall = false;
4930 4931// If this version of jQuery has .swap(), don't false-alarm on internal uses 4932if ( jQuery.swap ) { 4933 jQuery.each( [ "height", "width", "reliableMarginRight" ], function( _, name ) { 4934 var oldHook = jQuery.cssHooks[ name ] && jQuery.cssHooks[ name ].get; 4935 4936 if ( oldHook ) { 4937 jQuery.cssHooks[ name ].get = function() { 4938 var ret; 4939 4940 internalSwapCall = true; 4941 ret = oldHook.apply( this, arguments ); 4942 internalSwapCall = false; 4943 return ret; 4944 }; 4945 } 4946 } ); 4947} 4948 4949jQuery.swap = function( elem, options, callback, args ) { 4950 var ret, name, 4951 old = {}; 4952 4953 if ( !internalSwapCall ) { 4954 migrateWarn( "jQuery.swap() is undocumented and deprecated" ); 4955 } 4956 4957 // Remember the old values, and insert the new ones 4958 for ( name in options ) { 4959 old[ name ] = elem.style[ name ]; 4960 elem.style[ name ] = options[ name ]; 4961 } 4962 4963 ret = callback.apply( elem, args || [] ); 4964 4965 // Revert the old values 4966 for ( name in options ) { 4967 elem.style[ name ] = old[ name ]; 4968 } 4969 4970 return ret; 4971}; 4972 4973var oldData = jQuery.data; 4974 4975jQuery.data = function( elem, name, value ) { 4976 var curData; 4977 4978 // Name can be an object, and each entry in the object is meant to be set as data 4979 if ( name && typeof name === "object" && arguments.length === 2 ) { 4980 curData = jQuery.hasData( elem ) && oldData.call( this, elem ); 4981 var sameKeys = {}; 4982 for ( var key in name ) { 4983 if ( key !== jQuery.camelCase( key ) ) { 4984 migrateWarn( "jQuery.data() always sets/gets camelCased names: " + key ); 4985 curData[ key ] = name[ key ]; 4986 } else { 4987 sameKeys[ key ] = name[ key ]; 4988 } 4989 } 4990 4991 oldData.call( this, elem, sameKeys ); 4992 4993 return name; 4994 } 4995 4996 // If the name is transformed, look for the un-transformed name in the data object 4997 if ( name && typeof name === "string" && name !== jQuery.camelCase( name ) ) { 4998 curData = jQuery.hasData( elem ) && oldData.call( this, elem ); 4999 if ( curData && name in curData ) { 5000 migrateWarn( "jQuery.data() always sets/gets camelCased names: " + name ); 5001 if ( arguments.length > 2 ) { 5002 curData[ name ] = value; 5003 } 5004 return curData[ name ]; 5005 } 5006 } 5007 5008 return oldData.apply( this, arguments ); 5009}; 5010 5011var oldTweenRun = jQuery.Tween.prototype.run; 5012var linearEasing = function( pct ) { 5013 return pct; 5014 }; 5015 5016jQuery.Tween.prototype.run = function( ) { 5017 if ( jQuery.easing[ this.easing ].length > 1 ) { 5018 migrateWarn( 5019 "'jQuery.easing." + this.easing.toString() + "' should use only one argument" 5020 ); 5021 5022 jQuery.easing[ this.easing ] = linearEasing; 5023 } 5024 5025 oldTweenRun.apply( this, arguments ); 5026}; 5027 5028var intervalValue = jQuery.fx.interval || 13, 5029 intervalMsg = "jQuery.fx.interval is deprecated"; 5030 5031// Support: IE9, Android <=4.4 5032// Avoid false positives on browsers that lack rAF 5033// Don't warn if document is hidden, jQuery uses setTimeout (#292) 5034if ( window.requestAnimationFrame ) { 5035 Object.defineProperty( jQuery.fx, "interval", { 5036 configurable: true, 5037 enumerable: true, 5038 get: function() { 5039 if ( !window.document.hidden ) { 5040 migrateWarn( intervalMsg ); 5041 } 5042 return intervalValue; 5043 }, 5044 set: function( newValue ) { 5045 migrateWarn( intervalMsg ); 5046 intervalValue = newValue; 5047 } 5048 } ); 5049} 5050 5051var oldLoad = jQuery.fn.load, 5052 oldEventAdd = jQuery.event.add, 5053 originalFix = jQuery.event.fix; 5054 5055jQuery.event.props = []; 5056jQuery.event.fixHooks = {}; 5057 5058migrateWarnProp( jQuery.event.props, "concat", jQuery.event.props.concat, 5059 "jQuery.event.props.concat() is deprecated and removed" ); 5060 5061jQuery.event.fix = function( originalEvent ) { 5062 var event, 5063 type = originalEvent.type, 5064 fixHook = this.fixHooks[ type ], 5065 props = jQuery.event.props; 5066 5067 if ( props.length ) { 5068 migrateWarn( "jQuery.event.props are deprecated and removed: " + props.join() ); 5069 while ( props.length ) { 5070 jQuery.event.addProp( props.pop() ); 5071 } 5072 } 5073 5074 if ( fixHook && !fixHook._migrated_ ) { 5075 fixHook._migrated_ = true; 5076 migrateWarn( "jQuery.event.fixHooks are deprecated and removed: " + type ); 5077 if ( ( props = fixHook.props ) && props.length ) { 5078 while ( props.length ) { 5079 jQuery.event.addProp( props.pop() ); 5080 } 5081 } 5082 } 5083 5084 event = originalFix.call( this, originalEvent ); 5085 5086 return fixHook && fixHook.filter ? fixHook.filter( event, originalEvent ) : event; 5087}; 5088 5089jQuery.event.add = function( elem, types ) { 5090 5091 // This misses the multiple-types case but that seems awfully rare 5092 if ( elem === window && types === "load" && window.document.readyState === "complete" ) { 5093 migrateWarn( "jQuery(window).on('load'...) called after load event occurred" ); 5094 } 5095 return oldEventAdd.apply( this, arguments ); 5096}; 5097 5098jQuery.each( [ "load", "unload", "error" ], function( _, name ) { 5099 5100 jQuery.fn[ name ] = function() { 5101 var args = Array.prototype.slice.call( arguments, 0 ); 5102 5103 // If this is an ajax load() the first arg should be the string URL; 5104 // technically this could also be the "Anything" arg of the event .load() 5105 // which just goes to show why this dumb signature has been deprecated! 5106 // jQuery custom builds that exclude the Ajax module justifiably die here. 5107 if ( name === "load" && typeof args[ 0 ] === "string" ) { 5108 return oldLoad.apply( this, args ); 5109 } 5110 5111 migrateWarn( "jQuery.fn." + name + "() is deprecated" ); 5112 5113 args.splice( 0, 0, name ); 5114 if ( arguments.length ) { 5115 return this.on.apply( this, args ); 5116 } 5117 5118 // Use .triggerHandler here because: 5119 // - load and unload events don't need to bubble, only applied to window or image 5120 // - error event should not bubble to window, although it does pre-1.7 5121 // See http://bugs.jquery.com/ticket/11820 5122 this.triggerHandler.apply( this, args ); 5123 return this; 5124 }; 5125 5126} ); 5127 5128jQuery.each( ( "blur focus focusin focusout resize scroll click dblclick " + 5129 "mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave " + 5130 "change select submit keydown keypress keyup contextmenu" ).split( " " ), 5131 function( _i, name ) { 5132 5133 // Handle event binding 5134 jQuery.fn[ name ] = function( data, fn ) { 5135 migrateWarn( "jQuery.fn." + name + "() event shorthand is deprecated" ); 5136 return arguments.length > 0 ? 5137 this.on( name, null, data, fn ) : 5138 this.trigger( name ); 5139 }; 5140} ); 5141 5142// Trigger "ready" event only once, on document ready 5143jQuery( function() { 5144 jQuery( window.document ).triggerHandler( "ready" ); 5145} ); 5146 5147jQuery.event.special.ready = { 5148 setup: function() { 5149 if ( this === window.document ) { 5150 migrateWarn( "'ready' event is deprecated" ); 5151 } 5152 } 5153}; 5154 5155jQuery.fn.extend( { 5156 5157 bind: function( types, data, fn ) { 5158 migrateWarn( "jQuery.fn.bind() is deprecated" ); 5159 return this.on( types, null, data, fn ); 5160 }, 5161 unbind: function( types, fn ) { 5162 migrateWarn( "jQuery.fn.unbind() is deprecated" ); 5163 return this.off( types, null, fn ); 5164 }, 5165 delegate: function( selector, types, data, fn ) { 5166 migrateWarn( "jQuery.fn.delegate() is deprecated" ); 5167 return this.on( types, selector, data, fn ); 5168 }, 5169 undelegate: function( selector, types, fn ) { 5170 migrateWarn( "jQuery.fn.undelegate() is deprecated" ); 5171 return arguments.length === 1 ? 5172 this.off( selector, "**" ) : 5173 this.off( types, selector || "**", fn ); 5174 }, 5175 hover: function( fnOver, fnOut ) { 5176 migrateWarn( "jQuery.fn.hover() is deprecated" ); 5177 return this.on( "mouseenter", fnOver ).on( "mouseleave", fnOut || fnOver ); 5178 } 5179} ); 5180 5181 5182var oldOffset = jQuery.fn.offset; 5183 5184jQuery.fn.offset = function() { 5185 var docElem, 5186 elem = this[ 0 ], 5187 origin = { top: 0, left: 0 }; 5188 5189 if ( !elem || !elem.nodeType ) { 5190 migrateWarn( "jQuery.fn.offset() requires a valid DOM element" ); 5191 return origin; 5192 } 5193 5194 docElem = ( elem.ownerDocument || window.document ).documentElement; 5195 if ( !jQuery.contains( docElem, elem ) ) { 5196 migrateWarn( "jQuery.fn.offset() requires an element connected to a document" ); 5197 return origin; 5198 } 5199 5200 return oldOffset.apply( this, arguments ); 5201}; 5202 5203 5204var oldParam = jQuery.param; 5205 5206jQuery.param = function( data, traditional ) { 5207 var ajaxTraditional = jQuery.ajaxSettings && jQuery.ajaxSettings.traditional; 5208 5209 if ( traditional === undefined && ajaxTraditional ) { 5210 5211 migrateWarn( "jQuery.param() no longer uses jQuery.ajaxSettings.traditional" ); 5212 traditional = ajaxTraditional; 5213 } 5214 5215 return oldParam.call( this, data, traditional ); 5216}; 5217 5218var oldSelf = jQuery.fn.andSelf || jQuery.fn.addBack; 5219 5220jQuery.fn.andSelf = function() { 5221 migrateWarn( "jQuery.fn.andSelf() is deprecated and removed, use jQuery.fn.addBack()" ); 5222 return oldSelf.apply( this, arguments ); 5223}; 5224 5225 5226var oldDeferred = jQuery.Deferred, 5227 tuples = [ 5228 5229 // Action, add listener, callbacks, .then handlers, final state 5230 [ "resolve", "done", jQuery.Callbacks( "once memory" ), 5231 jQuery.Callbacks( "once memory" ), "resolved" ], 5232 [ "reject", "fail", jQuery.Callbacks( "once memory" ), 5233 jQuery.Callbacks( "once memory" ), "rejected" ], 5234 [ "notify", "progress", jQuery.Callbacks( "memory" ), 5235 jQuery.Callbacks( "memory" ) ] 5236 ]; 5237 5238jQuery.Deferred = function( func ) { 5239 var deferred = oldDeferred(), 5240 promise = deferred.promise(); 5241 5242 deferred.pipe = promise.pipe = function( /* fnDone, fnFail, fnProgress */ ) { 5243 var fns = arguments; 5244 5245 migrateWarn( "deferred.pipe() is deprecated" ); 5246 5247 return jQuery.Deferred( function( newDefer ) { 5248 jQuery.each( tuples, function( i, tuple ) { 5249 var fn = jQuery.isFunction( fns[ i ] ) && fns[ i ]; 5250 5251 // Deferred.done(function() { bind to newDefer or newDefer.resolve }) 5252 // deferred.fail(function() { bind to newDefer or newDefer.reject }) 5253 // deferred.progress(function() { bind to newDefer or newDefer.notify }) 5254 deferred[ tuple[ 1 ] ]( function() { 5255 var returned = fn && fn.apply( this, arguments ); 5256 if ( returned && jQuery.isFunction( returned.promise ) ) { 5257 returned.promise() 5258 .done( newDefer.resolve ) 5259 .fail( newDefer.reject ) 5260 .progress( newDefer.notify ); 5261 } else { 5262 newDefer[ tuple[ 0 ] + "With" ]( 5263 this === promise ? newDefer.promise() : this, 5264 fn ? [ returned ] : arguments 5265 ); 5266 } 5267 } ); 5268 } ); 5269 fns = null; 5270 } ).promise(); 5271 5272 }; 5273 5274 if ( func ) { 5275 func.call( deferred, deferred ); 5276 } 5277 5278 return deferred; 5279}; 5280 5281// Preserve handler of uncaught exceptions in promise chains 5282jQuery.Deferred.exceptionHook = oldDeferred.exceptionHook; 5283 5284return jQuery; 5285} ); 5286 5287},{"jquery":12}],11:[function(require,module,exports){ 5288(function (global){(function (){ 5289/*! 5290 * jQuery Mobile Events 5291 * By: Sam Delgado (https://rizerapp.com), Ben Major (http://www.ben-major.co.uk), and hachigoro (https://github.com/hachigoro) 5292 * 5293 * Copyright 2011-2015, Ben Major - Copyright 2016, Sam Delgado 5294 * Licensed under the MIT License: 5295 * 5296 * Permission is hereby granted, free of charge, to any person obtaining a copy 5297 * of this software and associated documentation files (the "Software"), to deal 5298 * in the Software without restriction, including without limitation the rights 5299 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 5300 * copies of the Software, and to permit persons to whom the Software is 5301 * furnished to do so, subject to the following conditions: 5302 * 5303 * The above copyright notice and this permission notice shall be included in 5304 * all copies or substantial portions of the Software. 5305 * 5306 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 5307 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 5308 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 5309 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 5310 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 5311 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 5312 * THE SOFTWARE. 5313 * 5314 */ 5315 5316module.exports = function loadTouchEvents(jQuery) { 5317 5318 var $ = global.$ || window.$ || jQuery || require('jquery'); 5319 5320 $.attrFn = $.attrFn || {}; 5321 5322 // navigator.userAgent.toLowerCase() isn't reliable for Chrome installs 5323 // on mobile devices. As such, we will create a boolean isChromeDesktop 5324 // The reason that we need to do this is because Chrome annoyingly 5325 // purports support for touch events even if the underlying hardware 5326 // does not! 5327 var agent = navigator.userAgent.toLowerCase(), 5328 isChromeDesktop = (agent.indexOf('chrome') > -1 && ((agent.indexOf('windows') > -1) || (agent.indexOf('macintosh') > -1) || (agent.indexOf('linux') > -1)) && agent.indexOf('mobile') < 0 && agent.indexOf('android') < 0), 5329 5330 settings = { 5331 tap_pixel_range: 5, 5332 swipe_h_threshold: 50, 5333 swipe_v_threshold: 50, 5334 taphold_threshold: 750, 5335 doubletap_int: 500, 5336 5337 touch_capable: ('ontouchstart' in window && !isChromeDesktop), 5338 orientation_support: ('orientation' in window && 'onorientationchange' in window), 5339 5340 startevent: (('ontouchstart' in window && !isChromeDesktop) ? 'touchstart' : 'mousedown'), 5341 endevent: (('ontouchstart' in window && !isChromeDesktop) ? 'touchend' : 'mouseup'), 5342 moveevent: (('ontouchstart' in window && !isChromeDesktop) ? 'touchmove' : 'mousemove'), 5343 tapevent: ('ontouchstart' in window && !isChromeDesktop) ? 'tap' : 'click', 5344 scrollevent: ('ontouchstart' in window && !isChromeDesktop) ? 'touchmove' : 'scroll', 5345 5346 hold_timer: null, 5347 tap_timer: null 5348 }; 5349 5350 // Convenience functions: 5351 $.isTouchCapable = function() { return settings.touch_capable; }; 5352 $.getStartEvent = function() { return settings.startevent; }; 5353 $.getEndEvent = function() { return settings.endevent; }; 5354 $.getMoveEvent = function() { return settings.moveevent; }; 5355 $.getTapEvent = function() { return settings.tapevent; }; 5356 $.getScrollEvent = function() { return settings.scrollevent; }; 5357 5358 // Add Event shortcuts: 5359 $.each(['tapstart', 'tapend', 'tapmove', 'tap', 'tap2', 'tap3', 'tap4', 'singletap', 'doubletap', 'taphold', 'swipe', 'swipeup', 'swiperight', 'swipedown', 'swipeleft', 'swipeend', 'scrollstart', 'scrollend', 'orientationchange'], function (i, name) { 5360 $.fn[name] = function (fn) { 5361 return fn ? this.on(name, fn) : this.trigger(name); 5362 }; 5363 5364 $.attrFn[name] = true; 5365 }); 5366 5367 // tapstart Event: 5368 $.event.special.tapstart = { 5369 setup: function () { 5370 5371 var thisObject = this, 5372 $this = $(thisObject); 5373 5374 $this.on(settings.startevent, function tapStartFunc(e) { 5375 5376 $this.data('callee', tapStartFunc); 5377 if (e.which && e.which !== 1) { 5378 return false; 5379 } 5380 5381 var origEvent = e.originalEvent, 5382 touchData = { 5383 'position': { 5384 'x': ((settings.touch_capable) ? origEvent.touches[0].screenX : e.screenX), 5385 'y': (settings.touch_capable) ? origEvent.touches[0].screenY : e.screenY 5386 }, 5387 'offset': { 5388 'x': (settings.touch_capable) ? Math.round(origEvent.changedTouches[0].pageX - ($this.offset() ? $this.offset().left : 0)) : Math.round(e.pageX - ($this.offset() ? $this.offset().left : 0)), 5389 'y': (settings.touch_capable) ? Math.round(origEvent.changedTouches[0].pageY - ($this.offset() ? $this.offset().top : 0)) : Math.round(e.pageY - ($this.offset() ? $this.offset().top : 0)) 5390 }, 5391 'time': Date.now(), 5392 'target': e.target 5393 }; 5394 5395 triggerCustomEvent(thisObject, 'tapstart', e, touchData); 5396 return true; 5397 }); 5398 }, 5399 5400 remove: function () { 5401 $(this).off(settings.startevent, $(this).data.callee); 5402 } 5403 }; 5404 5405 // tapmove Event: 5406 $.event.special.tapmove = { 5407 setup: function() { 5408 var thisObject = this, 5409 $this = $(thisObject); 5410 5411 $this.on(settings.moveevent, function tapMoveFunc(e) { 5412 $this.data('callee', tapMoveFunc); 5413 5414 var origEvent = e.originalEvent, 5415 touchData = { 5416 'position': { 5417 'x': ((settings.touch_capable) ? origEvent.touches[0].screenX : e.screenX), 5418 'y': (settings.touch_capable) ? origEvent.touches[0].screenY : e.screenY 5419 }, 5420 'offset': { 5421 'x': (settings.touch_capable) ? Math.round(origEvent.changedTouches[0].pageX - ($this.offset() ? $this.offset().l
5421eft : 0)) : Math.round(e.pageX - ($this.offset() ? $this.offset().left : 0)), 5422 'y': (settings.touch_capable) ? Math.round(origEvent.changedTouches[0].pageY - ($this.offset() ? $this.offset().top : 0)) : Math.round(e.pageY - ($this.offset() ? $this.offset().top : 0)) 5423 }, 5424 'time': Date.now(), 5425 'target': e.target 5426 }; 5427 5428 triggerCustomEvent(thisObject, 'tapmove', e, touchData); 5429 return true; 5430 }); 5431 }, 5432 remove: function() { 5433 $(this).off(settings.moveevent, $(this).data.callee); 5434 } 5435 }; 5436 5437 // tapend Event: 5438 $.event.special.tapend = { 5439 setup: function () { 5440 var thisObject = this, 5441 $this = $(thisObject); 5442 5443 $this.on(settings.endevent, function tapEndFunc(e) { 5444 // Touch event data: 5445 $this.data('callee', tapEndFunc); 5446 5447 var origEvent = e.originalEvent; 5448 var touchData = { 5449 'position': { 5450 'x': (settings.touch_capable) ? origEvent.changedTouches[0].screenX : e.screenX, 5451 'y': (settings.touch_capable) ? origEvent.changedTouches[0].screenY : e.screenY 5452 }, 5453 'offset': { 5454 'x': (settings.touch_capable) ? Math.round(origEvent.changedTouches[0].pageX - ($this.offset() ? $this.offset().left : 0)) : Math.round(e.pageX - ($this.offset() ? $this.offset().left : 0)), 5455 'y': (settings.touch_capable) ? Math.round(origEvent.changedTouches[0].pageY - ($this.offset() ? $this.offset().top : 0)) : Math.round(e.pageY - ($this.offset() ? $this.offset().top : 0)) 5456 }, 5457 'time': Date.now(), 5458 'target': e.target 5459 }; 5460 triggerCustomEvent(thisObject, 'tapend', e, touchData); 5461 return true; 5462 }); 5463 }, 5464 remove: function () { 5465 $(this).off(settings.endevent, $(this).data.callee); 5466 } 5467 }; 5468 5469 // taphold Event: 5470 $.event.special.taphold = { 5471 setup: function () { 5472 var thisObject = this, 5473 $this = $(thisObject), 5474 origTarget, 5475 start_pos = { 5476 x: 0, 5477 y: 0 5478 }, 5479 end_x = 0, 5480 end_y = 0; 5481 5482 $this.on(settings.startevent, function tapHoldFunc1(e) { 5483 if (e.which && e.which !== 1) { 5484 return false; 5485 } else { 5486 $this.data('tapheld', false); 5487 origTarget = e.target; 5488 5489 var origEvent = e.originalEvent; 5490 var start_time = Date.now(), 5491 startPosition = { 5492 'x': (settings.touch_capable) ? origEvent.touches[0].screenX : e.screenX, 5493 'y': (settings.touch_capable) ? origEvent.touches[0].screenY : e.screenY 5494 }, 5495 startOffset = { 5496 'x': (settings.touch_capable) ? origEvent.touches[0].pageX - origEvent.touches[0].target.offsetLeft : e.offsetX, 5497 'y': (settings.touch_capable) ? origEvent.touches[0].pageY - origEvent.touches[0].target.offsetTop : e.offsetY 5498 }; 5499 5500 start_pos.x = (e.originalEvent.targetTouches) ? e.originalEvent.targetTouches[0].pageX : e.pageX; 5501 start_pos.y = (e.originalEvent.targetTouches) ? e.originalEvent.targetTouches[0].pageY : e.pageY; 5502 5503 end_x = start_pos.x; 5504 end_y = start_pos.y; 5505 5506 settings.hold_timer = window.setTimeout(function () { 5507 5508 var diff_x = (start_pos.x - end_x), 5509 diff_y = (start_pos.y - end_y); 5510 5511 if (e.target == origTarget && ((start_pos.x == end_x && start_pos.y == end_y) || (diff_x >= -(settings.tap_pixel_range) && diff_x <= settings.tap_pixel_range && diff_y >= -(settings.tap_pixel_range) && diff_y <= settings.tap_pixel_range))) { 5512 $this.data('tapheld', true); 5513 5514 var end_time = Date.now(), 5515 endPosition = { 5516 'x': (settings.touch_capable) ? origEvent.touches[0].screenX : e.screenX, 5517 'y': (settings.touch_capable) ? origEvent.touches[0].screenY : e.screenY 5518 }, 5519 endOffset = { 5520 'x': (settings.touch_capable) ? Math.round(origEvent.changedTouches[0].pageX - ($this.offset() ? $this.offset().left : 0)) : Math.round(e.pageX - ($this.offset() ? $this.offset().left : 0)), 5521 'y': (settings.touch_capable) ? Math.round(origEvent.changedTouches[0].pageY - ($this.offset() ? $this.offset().top : 0)) : Math.round(e.pageY - ($this.offset() ? $this.offset().top : 0)) 5522 }; 5523 var duration = end_time - start_time; 5524 5525 // Build the touch data: 5526 var touchData = { 5527 'startTime': start_time, 5528 'endTime': end_time, 5529 'startPosition': startPosition, 5530 'startOffset': startOffset, 5531 'endPosition': endPosition, 5532 'endOffset': endOffset, 5533 'duration': duration, 5534 'target': e.target 5535 }; 5536 $this.data('callee1', tapHoldFunc1); 5537 triggerCustomEvent(thisObject, 'taphold', e, touchData); 5538 } 5539 }, settings.taphold_threshold); 5540 5541 return true; 5542 } 5543 }).on(settings.endevent, function tapHoldFunc2() { 5544 $this.data('callee2', tapHoldFunc2); 5545 $this.data('tapheld', false); 5546 window.clearTimeout(settings.hold_timer); 5547 }) 5548 .on(settings.moveevent, function tapHoldFunc3(e) { 5549 $this.data('callee3', tapHoldFunc3); 5550 5551 end_x = (e.originalEvent.targetTouches) ? e.originalEvent.targetTouches[0].pageX : e.pageX; 5552 end_y = (e.originalEvent.targetTouches) ? e.originalEvent.targetTouches[0].pageY : e.pageY; 5553 }); 5554 }, 5555 5556 remove: function () { 5557 $(this).off(settings.startevent, $(this).data.callee1).off(settings.endevent, $(this).data.callee2).off(settings.moveevent, $(this).data.callee3); 5558 } 5559 }; 5560 5561 // doubletap Event: 5562 $.event.special.doubletap = { 5563 setup: function () { 5564 var thisObject = this, 5565 $this = $(thisObject), 5566 origTarget, 5567 action, 5568 firstTap = null, 5569 origEvent, 5570 cooloff, 5571 cooling = false; 5572 5573 $this.on(settings.startevent, function doubleTapFunc1(e) { 5574 if (e.which && e.which !== 1) { 5575 return false; 5576 } 5577 $this.data('doubletapped', false); 5578 origTarget = e.target; 5579 $this.data('callee1', doubleTapFunc1); 5580 5581 origEvent = e.originalEvent; 5582 if (!firstTap) { 5583 firstTap = { 5584 'position': { 5585 'x': (settings.touch_capable) ? origEvent.touches[0].screenX : e.screenX, 5586 'y': (settings.touch_capable) ? origEvent.touches[0].screenY : e.screenY 5587 }, 5588 'offset': { 5589 'x': (settings.touch_capable) ? Math.round(origEvent.changedTouches[0].pageX - ($this.offset() ? $this.offset().left : 0)) : Math.round(e.pageX - ($this.offset() ? $this.offset().left : 0)), 5590 'y': (settings.touch_capable) ? Math.round(origEvent.changedTouches[0].pageY - ($this.offset() ? $this.offset().top : 0)) : Math.round(e.pageY - ($this.offset() ? $this.offset().top : 0)) 5591 }, 5592 'time': Date.now(), 5593 'target': e.target 5594 }; 5595 } 5596 5597 return true; 5598 }).on(settings.endevent, function doubleTapFunc2(e) { 5599 5600 var now = Date.now(); 5601 var lastTouch = $this.data('lastTouch') || now + 1; 5602 var delta = now - lastTouch; 5603 window.clearTimeout(action); 5604 $this.data('callee2', doubleTapFunc2); 5605 5606 if (delta < settings.doubletap_int && (e.target == origTarget) && delta > 100) { 5607 $this.data('doubletapped', true); 5608 window.clearTimeout(settings.tap_timer); 5609 5610 // Now get the current event: 5611 var lastTap = { 5612 'position': { 5613 'x': (settings.touch_capable) ? e.originalEvent.changedTouches[0].screenX : e.screenX, 5614 'y': (settings.touch_capable) ? e.originalEvent.changedTouches[0].screenY : e.screenY 5615 }, 5616 'offset': { 5617 'x': (settings.touch_capable) ? Math.round(origEvent.changedTouches[0].pageX - ($this.offset() ? $this.offset().left : 0)) : Math.round(e.pageX - ($this.offset() ? $this.offset().left : 0)), 5618 'y': (settings.touch_capable) ? Math.round(origEvent.changedTouches[0].pageY - ($this.offset() ? $this.offset().top : 0)) : Math.round(e.pageY - ($this.offset() ? $this.offset().top : 0)) 5619 }, 5620 'time': Date.now(), 5621 'target': e.target 5622 }; 5623 5624 var touchData = { 5625 'firstTap': firstTap, 5626 'secondTap': lastTap, 5627 'interval': lastTap.time - firstTap.time 5628 }; 5629 5630 if (!cooling) { 5631 triggerCustomEvent(thisObject, 'doubletap', e, touchData); 5632 firstTap = null; 5633 } 5634 5635 cooling = true; 5636 5637 cooloff = window.setTimeout(function () { 5638 cooling = false; 5639 }, settings.doubletap_int); 5640 5641 } else { 5642 $this.data('lastTouch', now); 5643 action = window.setTimeout(function () { 5644 firstTap = null; 5645 window.clearTimeout(action); 5646 }, settings.doubletap_int, [e]); 5647 } 5648 $this.data('lastTouch', now); 5649 }); 5650 }, 5651 remove: function () { 5652 $(this).off(settings.startevent, $(this).data.callee1).off(settings.endevent, $(this).data.callee2); 5653 } 5654 }; 5655 5656 // singletap Event: 5657 // This is used in conjuction with doubletap when both events are needed on the same element 5658 $.event.special.singletap = { 5659 setup: function () { 5660 var thisObject = this, 5661 $this = $(thisObject), 5662 origTarget = null, 5663 startTime = null, 5664 start_pos = { 5665 x: 0, 5666 y: 0 5667 }; 5668 5669 $this.on(settings.startevent, function singleTapFunc1(e) { 5670 if (e.which && e.which !== 1) { 5671 return false; 5672 } else { 5673 startTime = Date.now(); 5674 origTarget = e.target; 5675 $this.data('callee1', singleTapFunc1); 5676 5677 // Get the start x and y position: 5678 start_pos.x = (e.originalEvent.targetTouches) ? e.originalEvent.targetTouches[0].pageX : e.pageX; 5679 start_pos.y = (e.originalEvent.targetTouches) ? e.originalEvent.targetTouches[0].pageY : e.pageY; 5680 5681 return true; 5682 } 5683 }).on(settings.endevent, function singleTapFunc2(e) { 5684 $this.data('callee2', singleTapFunc2); 5685 if (e.target == origTarget) { 5686 5687 // Get the end point: 5688 var end_pos_x = (e.originalEvent.changedTouches) ? e.originalEvent.changedTouches[0].pageX : e.pageX, 5689 end_pos_y = (e.originalEvent.changedTouches) ? e.originalEvent.changedTouches[0].pageY : e.pageY; 5690 5691 // We need to check if it was a taphold: 5692 5693 settings.tap_timer = window.setTimeout(function () { 5694 5695 var diff_x = (start_pos.x - end_pos_x), diff_y = (start_pos.y - end_pos_y); 5696 5697 if(!$this.data('doubletapped') && !$this.data('tapheld') && (((start_pos.x == end_pos_x) && (start_pos.y == end_pos_y)) || (diff_x >= -(settings.tap_pixel_range) && diff_x <= settings.tap_pixel_range && diff_y >= -(settings.tap_pixel_range) && diff_y <= settings.tap_pixel_range))) { 5698 5699 var origEvent = e.originalEvent; 5700 var touchData = { 5701 'position': { 5702 'x': (settings.touch_capable) ? origEvent.changedTouches[0].screenX : e.screenX, 5703 'y': (settings.touch_capable) ? origEvent.changedTouches[0].screenY : e.screenY 5704 }, 5705 'offset': { 5706 'x': (settings.touch_capable) ? Math.round(origEvent.changedTouches[0].pageX - ($this.offset() ? $this.offset().left : 0)) : Math.round(e.pageX - ($this.offset() ? $this.offset().left : 0)), 5707 'y': (settings.touch_capable) ? Math.round(origEvent.changedTouches[0].pageY - ($this.offset() ? $this.offset().top : 0)) : Math.round(e.pageY - ($this.offset() ? $this.offset().top : 0)) 5708 }, 5709 'time': Date.now(), 5710 'target': e.target 5711 }; 5712 5713 // Was it a taphold? 5714 if((touchData.time - startTime) < settings.taphold_threshold) 5715 { 5716 triggerCustomEvent(thisObject, 'singletap', e, touchData); 5717 } 5718 } 5719 }, settings.doubletap_int); 5720 } 5721 }); 5722 }, 5723 5724 remove: function () { 5725 $(this).off(settings.startevent, $(this).data.callee1).off(settings.endevent, $(this).data.callee2); 5726 } 5727 }; 5728 5729 // tap Event: 5730 $.event.special.tap = { 5731 setup: function () { 5732 var thisObject = this, 5733 $this = $(thisObject), 5734 started = false, 5735 origTarget = null, 5736 start_time, 5737 start_pos = { 5738 x: 0, 5739 y: 0 5740 }, 5741 touches; 5742 5743 $this.on(settings.startevent, function tapFunc1(e) { 5744 $this.data('callee1', tapFunc1); 5745 5746 if( e.which && e.which !== 1 ) 5747 { 5748 return false; 5749 } 5750 else 5751 { 5752 started = true; 5753 start_pos.x = (e.originalEvent.targetTouches) ? e.originalEvent.targetTouches[0].pageX : e.pageX; 5754 start_pos.y = (e.originalEvent.targetTouches) ? e.originalEvent.targetTouches[0].pageY : e.pageY; 5755 start_time = Date.now(); 5756 origTarget = e.target; 5757 5758 touches = (e.originalEvent.targetTouches) ? e.originalEvent.targetTouches : [ e ]; 5759 return true; 5760 } 5761 }).on(settings.endevent, function tapFunc2(e) { 5762 $this.data('callee2', tapFunc2); 5763 5764 // Only trigger if they've started, and the target matches: 5765 var end_x = (e.originalEvent.targetTouches) ? e.originalEvent.changedTouches[0].pageX : e.pageX, 5766 end_y = (e.originalEvent.targetTouches) ? e.originalEvent.changedTouches[0].pageY : e.pageY, 5767 diff_x = (start_pos.x - end_x), 5768 diff_y = (start_pos.y - end_y), 5769 eventName; 5770 5771 if (origTa
5771rget == e.target && started && ((Date.now() - start_time) < settings.taphold_threshold) && ((start_pos.x == end_x && start_pos.y == end_y) || (diff_x >= -(settings.tap_pixel_range) && diff_x <= settings.tap_pixel_range && diff_y >= -(settings.tap_pixel_range) && diff_y <= settings.tap_pixel_range))) { 5772 var origEvent = e.originalEvent; 5773 var touchData = [ ]; 5774 5775 for( var i = 0; i < touches.length; i++) 5776 { 5777 var touch = { 5778 'position': { 5779 'x': (settings.touch_capable) ? origEvent.changedTouches[i].screenX : e.screenX, 5780 'y': (settings.touch_capable) ? origEvent.changedTouches[i].screenY : e.screenY 5781 }, 5782 'offset': { 5783 'x': (settings.touch_capable) ? Math.round(origEvent.changedTouches[i].pageX - ($this.offset() ? $this.offset().left : 0)) : Math.round(e.pageX - ($this.offset() ? $this.offset().left : 0)), 5784 'y': (settings.touch_capable) ? Math.round(origEvent.changedTouches[i].pageY - ($this.offset() ? $this.offset().top : 0)) : Math.round(e.pageY - ($this.offset() ? $this.offset().top : 0)) 5785 }, 5786 'time': Date.now(), 5787 'target': e.target 5788 }; 5789 5790 touchData.push( touch ); 5791 } 5792 5793 triggerCustomEvent(thisObject, 'tap', e, touchData); 5794 } 5795 }); 5796 }, 5797 5798 remove: function () { 5799 $(this).off(settings.startevent, $(this).data.callee1).off(settings.endevent, $(this).data.callee2); 5800 } 5801 }; 5802 5803 // swipe Event (also handles swipeup, swiperight, swipedown and swipeleft): 5804 $.event.special.swipe = { 5805 setup: function () { 5806 var thisObject = this, 5807 $this = $(thisObject), 5808 started = false, 5809 hasSwiped = false, 5810 originalCoord = { 5811 x: 0, 5812 y: 0 5813 }, 5814 finalCoord = { 5815 x: 0, 5816 y: 0 5817 }, 5818 startEvnt; 5819 5820 // Screen touched, store the original coordinate 5821 5822 function touchStart(e) { 5823 $this = $(e.currentTarget); 5824 $this.data('callee1', touchStart); 5825 originalCoord.x = (e.originalEvent.targetTouches) ? e.originalEvent.targetTouches[0].pageX : e.pageX; 5826 originalCoord.y = (e.originalEvent.targetTouches) ? e.originalEvent.targetTouches[0].pageY : e.pageY; 5827 finalCoord.x = originalCoord.x; 5828 finalCoord.y = originalCoord.y; 5829 started = true; 5830 var origEvent = e.originalEvent; 5831 // Read event data into our startEvt: 5832 startEvnt = { 5833 'position': { 5834 'x': (settings.touch_capable) ? origEvent.touches[0].screenX : e.screenX, 5835 'y': (settings.touch_capable) ? origEvent.touches[0].screenY : e.screenY 5836 }, 5837 'offset': { 5838 'x': (settings.touch_capable) ? Math.round(origEvent.changedTouches[0].pageX - ($this.offset() ? $this.offset().left : 0)) : Math.round(e.pageX - ($this.offset() ? $this.offset().left : 0)), 5839 'y': (settings.touch_capable) ? Math.round(origEvent.changedTouches[0].pageY - ($this.offset() ? $this.offset().top : 0)) : Math.round(e.pageY - ($this.offset() ? $this.offset().top : 0)) 5840 }, 5841 'time': Date.now(), 5842 'target': e.target 5843 }; 5844 } 5845 5846 // Store coordinates as finger is swiping 5847 5848 function touchMove(e) { 5849 $this = $(e.currentTarget); 5850 $this.data('callee2', touchMove); 5851 finalCoord.x = (e.originalEvent.targetTouches) ? e.originalEvent.targetTouches[0].pageX : e.pageX; 5852 finalCoord.y = (e.originalEvent.targetTouches) ? e.originalEvent.targetTouches[0].pageY : e.pageY; 5853 5854 var swipedir; 5855 5856 // We need to check if the element to which the event was bound contains a data-xthreshold | data-vthreshold: 5857 var ele_x_threshold = ($this.parent().data('xthreshold')) ? $this.parent().data('xthreshold') : $this.data('xthreshold'), 5858 ele_y_threshold = ($this.parent().data('ythreshold')) ? $this.parent().data('ythreshold') : $this.data('ythreshold'), 5859 h_threshold = (typeof ele_x_threshold !== 'undefined' && ele_x_threshold !== false && parseInt(ele_x_threshold)) ? parseInt(ele_x_threshold) : settings.swipe_h_threshold, 5860 v_threshold = (typeof ele_y_threshold !== 'undefined' && ele_y_threshold !== false && parseInt(ele_y_threshold)) ? parseInt(ele_y_threshold) : settings.swipe_v_threshold; 5861 5862 if (originalCoord.y > finalCoord.y && (originalCoord.y - finalCoord.y > v_threshold)) { 5863 swipedir = 'swipeup'; 5864 } 5865 if (originalCoord.x < finalCoord.x && (finalCoord.x - originalCoord.x > h_threshold)) { 5866 swipedir = 'swiperight'; 5867 }
5868 if (originalCoord.y < finalCoord.y && (finalCoord.y - originalCoord.y > v_threshold)) { 5869 swipedir = 'swipedown'; 5870 } 5871 if (originalCoord.x > finalCoord.x && (originalCoord.x - finalCoord.x > h_threshold)) { 5872 swipedir = 'swipeleft'; 5873 } 5874 if (swipedir != undefined && started) { 5875 originalCoord.x = 0; 5876 originalCoord.y = 0; 5877 finalCoord.x = 0; 5878 finalCoord.y = 0; 5879 started = false; 5880 5881 // Read event data into our endEvnt: 5882 var origEvent = e.originalEvent; 5883 var endEvnt = { 5884 'position': { 5885 'x': (settings.touch_capable) ? origEvent.touches[0].screenX : e.screenX, 5886 'y': (settings.touch_capable) ? origEvent.touches[0].screenY : e.screenY 5887 }, 5888 'offset': { 5889 'x': (settings.touch_capable) ? Math.round(origEvent.changedTouches[0].pageX - ($this.offset() ? $this.offset().left : 0)) : Math.round(e.pageX - ($this.offset() ? $this.offset().left : 0)), 5890 'y': (settings.touch_capable) ? Math.round(origEvent.changedTouches[0].pageY - ($this.offset() ? $this.offset().top : 0)) : Math.round(e.pageY - ($this.offset() ? $this.offset().top : 0)) 5891 }, 5892 'time': Date.now(), 5893 'target': e.target 5894 }; 5895 5896 // Calculate the swipe amount (normalized): 5897 var xAmount = Math.abs(startEvnt.position.x - endEvnt.position.x), 5898 yAmount = Math.abs(startEvnt.position.y - endEvnt.position.y); 5899 5900 var touchData = { 5901 'startEvnt': startEvnt, 5902 'endEvnt': endEvnt, 5903 'direction': swipedir.replace('swipe', ''), 5904 'xAmount': xAmount, 5905 'yAmount': yAmount, 5906 'duration': endEvnt.time - startEvnt.time 5907 }; 5908 hasSwiped = true; 5909 $this.trigger('swipe', touchData).trigger(swipedir, touchData); 5910 } 5911 } 5912 5913 function touchEnd(e) { 5914 $this = $(e.currentTarget); 5915 var swipedir = ""; 5916 $this.data('callee3', touchEnd); 5917 if (hasSwiped) { 5918 // We need to check if the element to which the event was bound contains a data-xthreshold | data-vthreshold: 5919 var ele_x_threshold = $this.data('xthreshold'), 5920 ele_y_threshold = $this.data('ythreshold'), 5921 h_threshold = (typeof ele_x_threshold !== 'undefined' && ele_x_threshold !== false && parseInt(ele_x_threshold)) ? parseInt(ele_x_threshold) : settings.swipe_h_threshold, 5922 v_threshold = (typeof ele_y_threshold !== 'undefined' && ele_y_threshold !== false && parseInt(ele_y_threshold)) ? parseInt(ele_y_threshold) : settings.swipe_v_threshold; 5923 5924 var origEvent = e.originalEvent; 5925 var endEvnt = { 5926 'position': { 5927 'x': (settings.touch_capable) ? origEvent.changedTouches[0].screenX : e.screenX, 5928 'y': (settings.touch_capable) ? origEvent.changedTouches[0].screenY : e.screenY 5929 }, 5930 'offset': { 5931 'x': (settings.touch_capable) ? Math.round(origEvent.changedTouches[0].pageX - ($this.offset() ? $this.offset().left : 0)) : Math.round(e.pageX - ($this.offset() ? $this.offset().left : 0)), 5932 'y': (settings.touch_capable) ? Math.round(origEvent.changedTouches[0].pageY - ($this.offset() ? $this.offset().top : 0)) : Math.round(e.pageY - ($this.offset() ? $this.offset().top : 0)) 5933 }, 5934 'time': Date.now(), 5935 'target': e.target 5936 }; 5937 5938 // Read event data into our endEvnt: 5939 if (startEvnt.position.y > endEvnt.position.y && (startEvnt.position.y - endEvnt.position.y > v_threshold)) { 5940 swipedir = 'swipeup'; 5941 } 5942 if (startEvnt.position.x < endEvnt.position.x && (endEvnt.position.x - startEvnt.position.x > h_threshold)) { 5943 swipedir = 'swiperight'; 5944 } 5945 if (startEvnt.position.y < endEvnt.position.y && (endEvnt.position.y - startEvnt.position.y > v_threshold)) { 5946 swipedir = 'swipedown'; 5947 } 5948 if (startEvnt.position.x > endEvnt.position.x && (startEvnt.position.x - endEvnt.position.x > h_threshold)) { 5949 swipedir = 'swipeleft'; 5950 } 5951 5952 // Calculate the swipe amount (normalized): 5953 var xAmount = Math.abs(startEvnt.position.x - endEvnt.position.x), 5954 yAmount = Math.abs(startEvnt.position.y - endEvnt.position.y); 5955 5956 var touchData = { 5957 'startEvnt': startEvnt, 5958 'endEvnt': endEvnt, 5959 'direction': swipedir.replace('swipe', ''), 5960 'xAmount': xAmount, 5961 'yAmount': yAmount, 5962 'duration': endEvnt.time - startEvnt.time 5963 }; 5964 $this.trigger('swipeend', touchData); 5965 } 5966 5967 started = false; 5968 hasSwiped = false; 5969 } 5970 5971 $this.on(settings.startevent, touchStart); 5972 $this.on(settings.moveevent, touchMove); 5973 $this.on(settings.endevent, touchEnd); 5974 }, 5975 5976 remove: function () { 5977 $(this).off(settings.startevent, $(this).data.callee1).off(settings.moveevent, $(this).data.callee2).off(settings.endevent, $(this).data.callee3); 5978 } 5979 }; 5980 5981 // scrollstart Event (also handles scrollend): 5982 $.event.special.scrollstart = { 5983 setup: function () { 5984 var thisObject = this, 5985 $this = $(thisObject), 5986 scrolling, 5987 timer; 5988 5989 function trigger(event, state) { 5990 scrolling = state; 5991 triggerCustomEvent(thisObject, scrolling ? 'scrollstart' : 'scrollend', event); 5992 } 5993 5994 // iPhone triggers scroll after a small delay; use touchmove instead 5995 $this.on(settings.scrollevent, function scrollFunc(event) { 5996 $this.data('callee', scrollFunc); 5997 5998 if (!scrolling) { 5999 trigger(event, true); 6000 } 6001 6002 clearTimeout(timer); 6003 timer = setTimeout(function () { 6004 trigger(event, false); 6005 }, 50); 6006 }); 6007 }, 6008 6009 remove: function () { 6010 $(this).off(settings.scrollevent, $(this).data.callee); 6011 } 6012 }; 6013 6014 // This is the orientation change (largely borrowed from jQuery Mobile): 6015 var win = $(window), 6016 special_event, 6017 get_orientation, 6018 last_orientation, 6019 initial_orientation_is_landscape, 6020 initial_orientation_is_default, 6021 portrait_map = { 6022 '0': true, 6023 '180': true 6024 }; 6025 6026 if (settings.orientation_support) { 6027 var ww = window.innerWidth || win.width(), 6028 wh = window.innerHeight || win.height(), 6029 landscape_threshold = 50; 6030 6031 initial_orientation_is_landscape = ww > wh && (ww - wh) > landscape_threshold; 6032 initial_orientation_is_default = portrait_map[window.orientation]; 6033 6034 if ((initial_orientation_is_landscape && initial_orientation_is_default) || (!initial_orientation_is_landscape && !initial_orientation_is_default)) { 6035 portrait_map = {
6036 '-90': true, 6037 '90': true 6038 }; 6039 } 6040 } 6041 6042 $.event.special.orientationchange = special_event = { 6043 setup: function () { 6044 // If the event is supported natively, return false so that jQuery 6045 // will on to the event using DOM methods. 6046 if (settings.orientation_support) { 6047 return false; 6048 } 6049 6050 // Get the current orientation to avoid initial double-triggering. 6051 last_orientation = get_orientation(); 6052 6053 win.on('throttledresize', handler); 6054 return true; 6055 }, 6056 teardown: function () { 6057 if (settings.orientation_support) { 6058 return false; 6059 } 6060 6061 win.off('throttledresize', handler); 6062 return true; 6063 }, 6064 add: function (handleObj) { 6065 // Save a reference to the bound event handler. 6066 var old_handler = handleObj.handler; 6067 6068 handleObj.handler = function (event) { 6069 event.orientation = get_orientation(); 6070 return old_handler.apply(this, arguments); 6071 }; 6072 } 6073 }; 6074 6075 // If the event is not supported natively, this handler will be bound to 6076 // the window resize event to simulate the orientationchange event. 6077 6078 function handler() { 6079 // Get the current orientation. 6080 var orientation = get_orientation(); 6081 6082 if (orientation !== last_orientation) { 6083 // The orientation has changed, so trigger the orientationchange event. 6084 last_orientation = orientation; 6085 win.trigger("orientationchange"); 6086 } 6087 } 6088 6089 $.event.special.orientationchange.orientation = get_orientation = function () { 6090 var isPortrait = true, 6091 elem = document.documentElement; 6092 6093 if (settings.orientation_support) { 6094 isPortrait = portrait_map[window.orientation]; 6095 } else { 6096 isPortrait = elem && elem.clientWidth / elem.clientHeight < 1.1; 6097 } 6098 6099 return isPortrait ? 'portrait' : 'landscape'; 6100 }; 6101 6102 // throttle Handler: 6103 $.event.special.throttledresize = { 6104 setup: function () { 6105 $(this).on('resize', throttle_handler); 6106 }, 6107 teardown: function () { 6108 $(this).off('resize', throttle_handler); 6109 } 6110 }; 6111 6112 var throttle = 250, 6113 throttle_handler = function () { 6114 curr = Date.now(); 6115 diff = curr - lastCall; 6116 6117 if (diff >= throttle) { 6118 lastCall = curr; 6119 $(this).trigger('throttledresize'); 6120 6121 } else { 6122 if (heldCall) { 6123 window.clearTimeout(heldCall); 6124 } 6125 6126 // Promise a held call will still execute 6127 heldCall = window.setTimeout(handler, throttle - diff); 6128 } 6129 }, 6130 lastCall = 0, 6131 heldCall, 6132 curr, 6133 diff; 6134 6135 // Trigger a custom event: 6136 6137 function triggerCustomEvent(obj, eventType, event, touchData) { 6138 var originalType = event.type; 6139 event.type = eventType; 6140 6141 $.event.dispatch.call(obj, event, touchData); 6142 event.type = originalType; 6143 } 6144 6145 // Correctly on anything we've overloaded: 6146 $.each({ 6147 scrollend: 'scrollstart', 6148 swipeup: 'swipe', 6149 swiperight: 'swipe', 6150 swipedown: 'swipe', 6151 swipeleft: 'swipe', 6152 swipeend: 'swipe', 6153 tap2: 'tap' 6154 }, function (e, srcE) { 6155 $.event.special[e] = { 6156 setup: function () { 6157 $(this).on(srcE, $.noop); 6158 } 6159 }; 6160 }); 6161 6162 return; 6163 6164}; 6165 6166}).call(this)}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) 6167},{"jquery":12}],12:[function(require,module,exports){ 6168/*! 6169 * jQuery JavaScript Library v3.7.1 6170 * https://jquery.com/ 6171 * 6172 * Copyright OpenJS Foundation and other contributors 6173 * Released under the MIT license 6174 * https://jquery.org/license 6175 * 6176 * Date: 2023-08-28T13:37Z 6177 */ 6178( function( global, factory ) { 6179 6180 "use strict"; 6181 6182 if ( typeof module === "object"
vendor: 12,125 bytes, lines 6182-6675
6182 && typeof module.exports === "object" ) { 6183 6184 // For CommonJS and CommonJS-like environments where a proper `window` 6185 // is present, execute the factory and get jQuery. 6186 // For environments that do not have a `window` with a `document` 6187 // (such as Node.js), expose a factory as module.exports. 6188 // This accentuates the need for the creation of a real `window`. 6189 // e.g. var jQuery = require("jquery")(window); 6190 // See ticket trac-14549 for more info. 6191 module.exports = global.document ? 6192 factory( global, true ) : 6193 function( w ) { 6194 if ( !w.document ) { 6195 throw new Error( "jQuery requires a window with a document" ); 6196 } 6197 return factory( w ); 6198 }; 6199 } else { 6200 factory( global ); 6201 } 6202 6203// Pass this if window is not defined yet 6204} )( typeof window !== "undefined" ? window : this, function( window, noGlobal ) { 6205 6206// Edge <= 12 - 13+, Firefox <=18 - 45+, IE 10 - 11, Safari 5.1 - 9+, iOS 6 - 9.1 6207// throw exceptions when non-strict code (e.g., ASP.NET 4.5) accesses strict mode 6208// arguments.callee.caller (trac-13335). But as of jQuery 3.0 (2016), strict mode should be common 6209// enough that all such attempts are guarded in a try block. 6210"use strict"; 6211 6212var arr = []; 6213 6214var getProto = Object.getPrototypeOf; 6215 6216var slice = arr.slice; 6217 6218var flat = arr.flat ? function( array ) { 6219 return arr.flat.call( array ); 6220} : function( array ) { 6221 return arr.concat.apply( [], array ); 6222}; 6223 6224 6225var push = arr.push; 6226 6227var indexOf = arr.indexOf; 6228 6229var class2type = {}; 6230 6231var toString = class2type.toString; 6232 6233var hasOwn = class2type.hasOwnProperty; 6234 6235var fnToString = hasOwn.toString; 6236 6237var ObjectFunctionString = fnToString.call( Object ); 6238 6239var support = {}; 6240 6241var isFunction = function isFunction( obj ) { 6242 6243 // Support: Chrome <=57, Firefox <=52 6244 // In some browsers, typeof returns "function" for HTML <object> elements 6245 // (i.e., `typeof document.createElement( "object" ) === "function"`). 6246 // We don't want to classify *any* DOM node as a function. 6247 // Support: QtWeb <=3.8.5, WebKit <=534.34, wkhtmltopdf tool <=0.12.5 6248 // Plus for old WebKit, typeof returns "function" for HTML collections 6249 // (e.g., `typeof document.getElementsByTagName("div") === "function"`). (gh-4756) 6250 return typeof obj === "function" && typeof obj.nodeType !== "number" && 6251 typeof obj.item !== "function"; 6252 }; 6253 6254 6255var isWindow = function isWindow( obj ) { 6256 return obj != null && obj === obj.window; 6257 }; 6258 6259 6260var document = window.document; 6261 6262 6263 6264 var preservedScriptAttributes = { 6265 type: true, 6266 src: true, 6267 nonce: true, 6268 noModule: true 6269 }; 6270 6271 function DOMEval( code, node, doc ) { 6272 doc = doc || document; 6273 6274 var i, val, 6275 script = doc.createElement( "script" ); 6276 6277 script.text = code; 6278 if ( node ) { 6279 for ( i in preservedScriptAttributes ) { 6280 6281 // Support: Firefox 64+, Edge 18+ 6282 // Some browsers don't support the "nonce" property on scripts. 6283 // On the other hand, just using `getAttribute` is not enough as 6284 // the `nonce` attribute is reset to an empty string whenever it 6285 // becomes browsing-context connected. 6286 // See https://github.com/whatwg/html/issues/2369 6287 // See https://html.spec.whatwg.org/#nonce-attributes 6288 // The `node.getAttribute` check was added for the sake of 6289 // `jQuery.globalEval` so that it can fake a nonce-containing node 6290 // via an object. 6291 val = node[ i ] || node.getAttribute && node.getAttribute( i ); 6292 if ( val ) { 6293 script.setAttribute( i, val ); 6294 } 6295 } 6296 } 6297 doc.head.appendChild( script ).parentNode.removeChild( script ); 6298 } 6299 6300 6301function toType( obj ) { 6302 if ( obj == null ) { 6303 return obj + ""; 6304 } 6305 6306 // Support: Android <=2.3 only (functionish RegExp) 6307 return typeof obj === "object" || typeof obj === "function" ? 6308 class2type[ toString.call( obj ) ] || "object" : 6309 typeof obj; 6310} 6311/* global Symbol */ 6312// Defining this global in .eslintrc.json would create a danger of using the global 6313// unguarded in another place, it seems safer to define global only for this module 6314 6315 6316 6317var version = "3.7.1", 6318 6319 rhtmlSuffix = /HTML$/i, 6320 6321 // Define a local copy of jQuery 6322 jQuery = function( selector, context ) { 6323 6324 // The jQuery object is actually just the init constructor 'enhanced' 6325 // Need init if jQuery is called (just allow error to be thrown if not included) 6326 return new jQuery.fn.init( selector, context ); 6327 }; 6328 6329jQuery.fn = jQuery.prototype = { 6330 6331 // The current version of jQuery being used 6332 jquery: version, 6333 6334 constructor: jQuery, 6335 6336 // The default length of a jQuery object is 0 6337 length: 0, 6338 6339 toArray: function() { 6340 return slice.call( this ); 6341 }, 6342 6343 // Get the Nth element in the matched element set OR 6344 // Get the whole matched element set as a clean array 6345 get: function( num ) { 6346 6347 // Return all the elements in a clean array 6348 if ( num == null ) { 6349 return slice.call( this ); 6350 } 6351 6352 // Return just the one element from the set 6353 return num < 0 ? this[ num + this.length ] : this[ num ]; 6354 }, 6355 6356 // Take an array of elements and push it onto the stack 6357 // (returning the new matched element set) 6358 pushStack: function( elems ) { 6359 6360 // Build a new jQuery matched element set 6361 var ret = jQuery.merge( this.constructor(), elems ); 6362 6363 // Add the old object onto the stack (as a reference) 6364 ret.prevObject = this; 6365 6366 // Return the newly-formed element set 6367 return ret; 6368 }, 6369 6370 // Execute a callback for every element in the matched set. 6371 each: function( callback ) { 6372 return jQuery.each( this, callback ); 6373 }, 6374 6375 map: function( callback ) { 6376 return this.pushStack( jQuery.map( this, function( elem, i ) { 6377 return callback.call( elem, i, elem ); 6378 } ) ); 6379 }, 6380 6381 slice: function() { 6382 return this.pushStack( slice.apply( this, arguments ) ); 6383 }, 6384 6385 first: function() { 6386 return this.eq( 0 ); 6387 }, 6388 6389 last: function() { 6390 return this.eq( -1 ); 6391 }, 6392 6393 even: function() { 6394 return this.pushStack( jQuery.grep( this, function( _elem, i ) { 6395 return ( i + 1 ) % 2; 6396 } ) ); 6397 }, 6398 6399 odd: function() { 6400 return this.pushStack( jQuery.grep( this, function( _elem, i ) { 6401 return i % 2; 6402 } ) ); 6403 }, 6404 6405 eq: function( i ) { 6406 var len = this.length, 6407 j = +i + ( i < 0 ? len : 0 ); 6408 return this.pushStack( j >= 0 && j < len ? [ this[ j ] ] : [] ); 6409 }, 6410 6411 end: function() { 6412 return this.prevObject || this.constructor(); 6413 }, 6414 6415 // For internal use only. 6416 // Behaves like an Array's method, not like a jQuery method. 6417 push: push, 6418 sort: arr.sort, 6419 splice: arr.splice 6420}; 6421 6422jQuery.extend = jQuery.fn.extend = function() { 6423 var options, name, src, copy, copyIsArray, clone, 6424 target = arguments[ 0 ] || {}, 6425 i = 1, 6426 length = arguments.length, 6427 deep = false; 6428 6429 // Handle a deep copy situation 6430 if ( typeof target === "boolean" ) { 6431 deep = target; 6432 6433 // Skip the boolean and the target 6434 target = arguments[ i ] || {}; 6435 i++; 6436 } 6437 6438 // Handle case when target is a string or something (possible in deep copy) 6439 if ( typeof target !== "object" && !isFunction( target ) ) { 6440 target = {}; 6441 } 6442 6443 // Extend jQuery itself if only one argument is passed 6444 if ( i === length ) { 6445 target = this; 6446 i--; 6447 } 6448 6449 for ( ; i < length; i++ ) { 6450 6451 // Only deal with non-null/undefined values 6452 if ( ( options = arguments[ i ] ) != null ) { 6453 6454 // Extend the base object 6455 for ( name in options ) { 6456 copy = options[ name ]; 6457 6458 // Prevent Object.prototype pollution 6459 // Prevent never-ending loop 6460 if ( name === "__proto__" || target === copy ) { 6461 continue; 6462 } 6463 6464 // Recurse if we're merging plain objects or arrays 6465 if ( deep && copy && ( jQuery.isPlainObject( copy ) || 6466 ( copyIsArray = Array.isArray( copy ) ) ) ) { 6467 src = target[ name ]; 6468 6469 // Ensure proper type for the source value 6470 if ( copyIsArray && !Array.isArray( src ) ) { 6471 clone = []; 6472 } else if ( !copyIsArray && !jQuery.isPlainObject( src ) ) { 6473 clone = {}; 6474 } else { 6475 clone = src; 6476 } 6477 copyIsArray = false; 6478 6479 // Never move original objects, clone them 6480 target[ name ] = jQuery.extend( deep, clone, copy ); 6481 6482 // Don't bring in undefined values 6483 } else if ( copy !== undefined ) { 6484 target[ name ] = copy; 6485 } 6486 } 6487 } 6488 } 6489 6490 // Return the modified object 6491 return target; 6492}; 6493 6494jQuery.extend( { 6495 6496 // Unique for each copy of jQuery on the page 6497 expando: "jQuery" + ( version + Math.random() ).replace( /\D/g, "" ), 6498 6499 // Assume jQuery is ready without the ready module 6500 isReady: true, 6501 6502 error: function( msg ) { 6503 throw new Error( msg ); 6504 }, 6505 6506 noop: function() {}, 6507 6508 isPlainObject: function( obj ) { 6509 var proto, Ctor; 6510 6511 // Detect obvious negatives 6512 // Use toString instead of jQuery.type to catch host objects 6513 if ( !obj || toString.call( obj ) !== "[object Object]" ) { 6514 return false; 6515 } 6516 6517 proto = getProto( obj ); 6518 6519 // Objects with no prototype (e.g., `Object.create( null )`) are plain 6520 if ( !proto ) { 6521 return true; 6522 } 6523 6524 // Objects with prototype are plain iff they were constructed by a global Object function 6525 Ctor = hasOwn.call( proto, "constructor" ) && proto.constructor; 6526 return typeof Ctor === "function" && fnToString.call( Ctor ) === ObjectFunctionString; 6527 }, 6528 6529 isEmptyObject: function( obj ) { 6530 var name; 6531 6532 for ( name in obj ) { 6533 return false; 6534 } 6535 return true; 6536 }, 6537 6538 // Evaluates a script in a provided context; falls back to the global one 6539 // if not specified. 6540 globalEval: function( code, options, doc ) { 6541 DOMEval( code, { nonce: options && options.nonce }, doc ); 6542 }, 6543 6544 each: function( obj, callback ) { 6545 var length, i = 0; 6546 6547 if ( isArrayLike( obj ) ) { 6548 length = obj.length; 6549 for ( ; i < length; i++ ) { 6550 if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) { 6551 break; 6552 } 6553 } 6554 } else { 6555 for ( i in obj ) { 6556 if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) { 6557 break; 6558 } 6559 } 6560 } 6561 6562 return obj; 6563 }, 6564 6565 6566 // Retrieve the text value of an array of DOM nodes 6567 text: function( elem ) { 6568 var node, 6569 ret = "", 6570 i = 0, 6571 nodeType = elem.nodeType; 6572 6573 if ( !nodeType ) { 6574 6575 // If no nodeType, this is expected to be an array 6576 while ( ( node = elem[ i++ ] ) ) { 6577 6578 // Do not traverse comment nodes 6579 ret += jQuery.text( node ); 6580 } 6581 } 6582 if ( nodeType === 1 || nodeType === 11 ) { 6583 return elem.textContent; 6584 } 6585 if ( nodeType === 9 ) { 6586 return elem.documentElement.textContent; 6587 } 6588 if ( nodeType === 3 || nodeType === 4 ) { 6589 return elem.nodeValue; 6590 } 6591 6592 // Do not include comment or processing instruction nodes 6593 6594 return ret; 6595 }, 6596 6597 // results is for internal usage only 6598 makeArray: function( arr, results ) { 6599 var ret = results || []; 6600 6601 if ( arr != null ) { 6602 if ( isArrayLike( Object( arr ) ) ) { 6603 jQuery.merge( ret, 6604 typeof arr === "string" ? 6605 [ arr ] : arr 6606 ); 6607 } else { 6608 push.call( ret, arr ); 6609 } 6610 } 6611 6612 return ret; 6613 }, 6614 6615 inArray: function( elem, arr, i ) { 6616 return arr == null ? -1 : indexOf.call( arr, elem, i ); 6617 }, 6618 6619 isXMLDoc: function( elem ) { 6620 var namespace = elem && elem.namespaceURI, 6621 docElem = elem && ( elem.ownerDocument || elem ).documentElement; 6622 6623 // Assume HTML when documentElement doesn't yet exist, such as inside 6624 // document fragments. 6625 return !rhtmlSuffix.test( namespace || docElem && docElem.nodeName || "HTML" ); 6626 }, 6627 6628 // Support: Android <=4.0 only, PhantomJS 1 only 6629 // push.apply(_, arraylike) throws on ancient WebKit 6630 merge: function( first, second ) { 6631 var len = +second.length, 6632 j = 0, 6633 i = first.length; 6634 6635 for ( ; j < len; j++ ) { 6636 first[ i++ ] = second[ j ]; 6637 } 6638 6639 first.length = i; 6640 6641 return first; 6642 }, 6643 6644 grep: function( elems, callback, invert ) { 6645 var callbackInverse, 6646 matches = [], 6647 i = 0, 6648 length = elems.length, 6649 callbackExpect = !invert; 6650 6651 // Go through the array, only saving the items 6652 // that pass the validator function 6653 for ( ; i < length; i++ ) { 6654 callbackInverse = !callback( elems[ i ], i ); 6655 if ( callbackInverse !== callbackExpect ) { 6656 matches.push( elems[ i ] ); 6657 } 6658 } 6659 6660 return matches; 6661 }, 6662 6663 // arg is for internal usage only 6664 map: function( elems, callback, arg ) { 6665 var length, value, 6666 i = 0, 6667 ret = []; 6668 6669 // Go through the array, translating each of the items to their new values 6670 if ( isArrayLike( elems ) ) { 6671 length = elems.length; 6672 for ( ; i < length; i++ ) { 6673 value = callback( elems[ i ], i, arg ); 6674 6675 if ( value != null ) {
vendor: 17,514 bytes, lines 6676-7297
6676 ret.push( value ); 6677 } 6678 } 6679 6680 // Go through every key on the object, 6681 } else { 6682 for ( i in elems ) { 6683 value = callback( elems[ i ], i, arg ); 6684 6685 if ( value != null ) { 6686 ret.push( value ); 6687 } 6688 } 6689 } 6690 6691 // Flatten any nested arrays 6692 return flat( ret ); 6693 }, 6694 6695 // A global GUID counter for objects 6696 guid: 1, 6697 6698 // jQuery.support is not used in Core but other projects attach their 6699 // properties to it so it needs to exist. 6700 support: support 6701} ); 6702 6703if ( typeof Symbol === "function" ) { 6704 jQuery.fn[ Symbol.iterator ] = arr[ Symbol.iterator ]; 6705} 6706 6707// Populate the class2type map 6708jQuery.each( "Boolean Number String Function Array Date RegExp Object Error Symbol".split( " " ), 6709 function( _i, name ) { 6710 class2type[ "[object " + name + "]" ] = name.toLowerCase(); 6711 } ); 6712 6713function isArrayLike( obj ) { 6714 6715 // Support: real iOS 8.2 only (not reproducible in simulator) 6716 // `in` check used to prevent JIT error (gh-2145) 6717 // hasOwn isn't used here due to false negatives 6718 // regarding Nodelist length in IE 6719 var length = !!obj && "length" in obj && obj.length, 6720 type = toType( obj ); 6721 6722 if ( isFunction( obj ) || isWindow( obj ) ) { 6723 return false; 6724 } 6725 6726 return type === "array" || length === 0 || 6727 typeof length === "number" && length > 0 && ( length - 1 ) in obj; 6728} 6729 6730 6731function nodeName( elem, name ) { 6732 6733 return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase(); 6734 6735} 6736var pop = arr.pop; 6737 6738 6739var sort = arr.sort; 6740 6741 6742var splice = arr.splice; 6743 6744 6745var whitespace = "[\\x20\\t\\r\\n\\f]"; 6746 6747 6748var rtrimCSS = new RegExp( 6749 "^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" + whitespace + "+$", 6750 "g" 6751); 6752 6753 6754 6755 6756// Note: an element does not contain itself 6757jQuery.contains = function( a, b ) { 6758 var bup = b && b.parentNode; 6759 6760 return a === bup || !!( bup && bup.nodeType === 1 && ( 6761 6762 // Support: IE 9 - 11+ 6763 // IE doesn't have `contains` on SVG. 6764 a.contains ? 6765 a.contains( bup ) : 6766 a.compareDocumentPosition && a.compareDocumentPosition( bup ) & 16 6767 ) ); 6768}; 6769 6770 6771 6772 6773// CSS string/identifier serialization 6774// https://drafts.csswg.org/cssom/#common-serializing-idioms 6775var rcssescape = /([\0-\x1f\x7f]|^-?\d)|^-$|[^\x80-\uFFFF\w-]/g; 6776 6777function fcssescape( ch, asCodePoint ) { 6778 if ( asCodePoint ) { 6779 6780 // U+0000 NULL becomes U+FFFD REPLACEMENT CHARACTER 6781 if ( ch === "\0" ) { 6782 return "\uFFFD"; 6783 } 6784 6785 // Control characters and (dependent upon position) numbers get escaped as code points 6786 return ch.slice( 0, -1 ) + "\\" + ch.charCodeAt( ch.length - 1 ).toString( 16 ) + " "; 6787 } 6788 6789 // Other potentially-special ASCII characters get backslash-escaped 6790 return "\\" + ch; 6791} 6792 6793jQuery.escapeSelector = function( sel ) { 6794 return ( sel + "" ).replace( rcssescape, fcssescape ); 6795}; 6796 6797 6798 6799 6800var preferredDoc = document, 6801 pushNative = push; 6802 6803( function() { 6804 6805var i, 6806 Expr, 6807 outermostContext, 6808 sortInput, 6809 hasDuplicate, 6810 push = pushNative, 6811 6812 // Local document vars 6813 document, 6814 documentElement, 6815 documentIsHTML, 6816 rbuggyQSA, 6817 matches, 6818 6819 // Instance-specific data 6820 expando = jQuery.expando, 6821 dirruns = 0, 6822 done = 0, 6823 classCache = createCache(), 6824 tokenCache = createCache(), 6825 compilerCache = createCache(), 6826 nonnativeSelectorCache = createCache(), 6827 sortOrder = function( a, b ) { 6828 if ( a === b ) { 6829 hasDuplicate = true; 6830 } 6831 return 0; 6832 }, 6833 6834 booleans = "checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|" + 6835 "loop|multiple|open|readonly|required|scoped", 6836 6837 // Regular expressions 6838 6839 // https://www.w3.org/TR/css-syntax-3/#ident-token-diagram 6840 identifier = "(?:\\\\[\\da-fA-F]{1,6}" + whitespace + 6841 "?|\\\\[^\\r\\n\\f]|[\\w-]|[^\0-\\x7f])+", 6842 6843 // Attribute selectors: https://www.w3.org/TR/selectors/#attribute-selectors 6844 attributes = "\\[" + whitespace + "*(" + identifier + ")(?:" + whitespace + 6845 6846 // Operator (capture 2) 6847 "*([*^$|!~]?=)" + whitespace + 6848 6849 // "Attribute values must be CSS identifiers [capture 5] or strings [capture 3 or capture 4]" 6850 "*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|(" + identifier + "))|)" + 6851 whitespace + "*\\]", 6852 6853 pseudos = ":(" + identifier + ")(?:\\((" + 6854 6855 // To reduce the number of selectors needing tokenize in the preFilter, prefer arguments: 6856 // 1. quoted (capture 3; capture 4 or capture 5) 6857 "('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|" + 6858 6859 // 2. simple (capture 6) 6860 "((?:\\\\.|[^\\\\()[\\]]|" + attributes + ")*)|" + 6861 6862 // 3. anything else (capture 2) 6863 ".*" + 6864 ")\\)|)", 6865 6866 // Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter 6867 rwhitespace = new RegExp( whitespace + "+", "g" ), 6868 6869 rcomma = new RegExp( "^" + whitespace + "*," + whitespace + "*" ), 6870 rleadingCombinator = new RegExp( "^" + whitespace + "*([>+~]|" + whitespace + ")" + 6871 whitespace + "*" ), 6872 rdescend = new RegExp( whitespace + "|>" ), 6873 6874 rpseudo = new RegExp( pseudos ), 6875 ridentifier = new RegExp( "^" + identifier + "$" ), 6876 6877 matchExpr = { 6878 ID: new RegExp( "^#(" + identifier + ")" ), 6879 CLASS: new RegExp( "^\\.(" + identifier + ")" ), 6880 TAG: new RegExp( "^(" + identifier + "|[*])" ), 6881 ATTR: new RegExp( "^" + attributes ), 6882 PSEUDO: new RegExp( "^" + pseudos ), 6883 CHILD: new RegExp( 6884 "^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(" + 6885 whitespace + "*(even|odd|(([+-]|)(\\d*)n|)" + whitespace + "*(?:([+-]|)" + 6886 whitespace + "*(\\d+)|))" + whitespace + "*\\)|)", "i" ), 6887 bool: new RegExp( "^(?:" + booleans + ")$", "i" ), 6888 6889 // For use in libraries implementing .is() 6890 // We use this for POS matching in `select` 6891 needsContext: new RegExp( "^" + whitespace + 6892 "*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(" + whitespace + 6893 "*((?:-\\d)?\\d*)" + whitespace + "*\\)|)(?=[^-]|$)", "i" ) 6894 }, 6895 6896 rinputs = /^(?:input|select|textarea|button)$/i, 6897 rheader = /^h\d$/i, 6898 6899 // Easily-parseable/retrievable ID or TAG or CLASS selectors 6900 rquickExpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/, 6901 6902 rsibling = /[+~]/, 6903 6904 // CSS escapes 6905 // https://www.w3.org/TR/CSS21/syndata.html#escaped-characters 6906 runescape = new RegExp( "\\\\[\\da-fA-F]{1,6}" + whitespace + 6907 "?|\\\\([^\\r\\n\\f])", "g" ), 6908 funescape = function( escape, nonHex ) { 6909 var high = "0x" + escape.slice( 1 ) - 0x10000; 6910 6911 if ( nonHex ) { 6912 6913 // Strip the backslash prefix from a non-hex escape sequence 6914 return nonHex; 6915 } 6916 6917 // Replace a hexadecimal escape sequence with the encoded Unicode code point 6918 // Support: IE <=11+ 6919 // For values outside the Basic Multilingual Plane (BMP), manually construct a 6920 // surrogate pair 6921 return high < 0 ? 6922 String.fromCharCode( high + 0x10000 ) : 6923 String.fromCharCode( high >> 10 | 0xD800, high & 0x3FF | 0xDC00 ); 6924 }, 6925 6926 // Used for iframes; see `setDocument`. 6927 // Support: IE 9 - 11+, Edge 12 - 18+ 6928 // Removing the function wrapper causes a "Permission Denied" 6929 // error in IE/Edge. 6930 unloadHandler = function() { 6931 setDocument(); 6932 }, 6933 6934 inDisabledFieldset = addCombinator( 6935 function( elem ) { 6936 return elem.disabled === true && nodeName( elem, "fieldset" ); 6937 }, 6938 { dir: "parentNode", next: "legend" } 6939 ); 6940 6941// Support: IE <=9 only 6942// Accessing document.activeElement can throw unexpectedly 6943// https://bugs.jquery.com/ticket/13393 6944function safeActiveElement() { 6945 try { 6946 return document.activeElement; 6947 } catch ( err ) { } 6948} 6949 6950// Optimize for push.apply( _, NodeList ) 6951try { 6952 push.apply( 6953 ( arr = slice.call( preferredDoc.childNodes ) ), 6954 preferredDoc.childNodes 6955 ); 6956 6957 // Support: Android <=4.0 6958 // Detect silently failing push.apply 6959 // eslint-disable-next-line no-unused-expressions 6960 arr[ preferredDoc.childNodes.length ].nodeType; 6961} catch ( e ) { 6962 push = { 6963 apply: function( target, els ) { 6964 pushNative.apply( target, slice.call( els ) ); 6965 }, 6966 call: function( target ) { 6967 pushNative.apply( target, slice.call( arguments, 1 ) ); 6968 } 6969 }; 6970} 6971 6972function find( selector, context, results, seed ) { 6973 var m, i, elem, nid, match, groups, newSelector, 6974 newContext = context && context.ownerDocument, 6975 6976 // nodeType defaults to 9, since context defaults to document 6977 nodeType = context ? context.nodeType : 9; 6978 6979 results = results || []; 6980 6981 // Return early from calls with invalid selector or context 6982 if ( typeof selector !== "string" || !selector || 6983 nodeType !== 1 && nodeType !== 9 && nodeType !== 11 ) { 6984 6985 return results; 6986 } 6987 6988 // Try to shortcut find operations (as opposed to filters) in HTML documents 6989 if ( !seed ) { 6990 setDocument( context ); 6991 context = context || document; 6992 6993 if ( documentIsHTML ) { 6994 6995 // If the selector is sufficiently simple, try using a "get*By*" DOM method 6996 // (excepting DocumentFragment context, where the methods don't exist) 6997 if ( nodeType !== 11 && ( match = rquickExpr.exec( selector ) ) ) { 6998 6999 // ID selector 7000 if ( ( m = match[ 1 ] ) ) { 7001 7002 // Document context 7003 if ( nodeType === 9 ) { 7004 if ( ( elem = context.getElementById( m ) ) ) { 7005 7006 // Support: IE 9 only 7007 // getElementById can match elements by name instead of ID 7008 if ( elem.id === m ) { 7009 push.call( results, elem ); 7010 return results; 7011 } 7012 } else { 7013 return results; 7014 } 7015 7016 // Element context 7017 } else { 7018 7019 // Support: IE 9 only 7020 // getElementById can match elements by name instead of ID 7021 if ( newContext && ( elem = newContext.getElementById( m ) ) && 7022 find.contains( context, elem ) && 7023 elem.id === m ) { 7024 7025 push.call( results, elem ); 7026 return results; 7027 } 7028 } 7029 7030 // Type selector 7031 } else if ( match[ 2 ] ) { 7032 push.apply( results, context.getElementsByTagName( selector ) ); 7033 return results; 7034 7035 // Class selector 7036 } else if ( ( m = match[ 3 ] ) && context.getElementsByClassName ) { 7037 push.apply( results, context.getElementsByClassName( m ) ); 7038 return results; 7039 } 7040 } 7041 7042 // Take advantage of querySelectorAll 7043 if ( !nonnativeSelectorCache[ selector + " " ] && 7044 ( !rbuggyQSA || !rbuggyQSA.test( selector ) ) ) { 7045 7046 newSelector = selector; 7047 newContext = context; 7048 7049 // qSA considers elements outside a scoping root when evaluating child or 7050 // descendant combinators, which is not what we want. 7051 // In such cases, we work around the behavior by prefixing every selector in the 7052 // list with an ID selector referencing the scope context. 7053 // The technique has to be used as well when a leading combinator is used 7054 // as such selectors are not recognized by querySelectorAll. 7055 // Thanks to Andrew Dupont for this technique. 7056 if ( nodeType === 1 && 7057 ( rdescend.test( selector ) || rleadingCombinator.test( selector ) ) ) { 7058 7059 // Expand context for sibling selectors 7060 newContext = rsibling.test( selector ) && testContext( context.parentNode ) || 7061 context; 7062 7063 // We can use :scope instead of the ID hack if the browser 7064 // supports it & if we're not changing the context. 7065 // Support: IE 11+, Edge 17 - 18+ 7066 // IE/Edge sometimes throw a "Permission denied" error when 7067 // strict-comparing two documents; shallow comparisons work. 7068 // eslint-disable-next-line eqeqeq 7069 if ( newContext != context || !support.scope ) { 7070 7071 // Capture the context ID, setting it first if necessary 7072 if ( ( nid = context.getAttribute( "id" ) ) ) { 7073 nid = jQuery.escapeSelector( nid ); 7074 } else { 7075 context.setAttribute( "id", ( nid = expando ) ); 7076 } 7077 } 7078 7079 // Prefix every selector in the list 7080 groups = tokenize( selector ); 7081 i = groups.length; 7082 while ( i-- ) { 7083 groups[ i ] = ( nid ? "#" + nid : ":scope" ) + " " + 7084 toSelector( groups[ i ] ); 7085 } 7086 newSelector = groups.join( "," ); 7087 } 7088 7089 try { 7090 push.apply( results, 7091 newContext.querySelectorAll( newSelector ) 7092 ); 7093 return results; 7094 } catch ( qsaError ) { 7095 nonnativeSelectorCache( selector, true ); 7096 } finally { 7097 if ( nid === expando ) { 7098 context.removeAttribute( "id" ); 7099 } 7100 } 7101 } 7102 } 7103 } 7104 7105 // All others 7106 return select( selector.replace( rtrimCSS, "$1" ), context, results, seed ); 7107} 7108 7109/** 7110 * Create key-value caches of limited size 7111 * @returns {function(string, object)} Returns the Object data after storing it on itself with 7112 * property name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength) 7113 * deleting the oldest entry 7114 */ 7115function createCache() { 7116 var keys = []; 7117 7118 function cache( key, value ) { 7119 7120 // Use (key + " ") to avoid collision with native prototype properties 7121 // (see https://github.com/jquery/sizzle/issues/157) 7122 if ( keys.push( key + " " ) > Expr.cacheLength ) { 7123 7124 // Only keep the most recent entries 7125 delete cache[ keys.shift() ]; 7126 } 7127 return ( cache[ key + " " ] = value ); 7128 } 7129 return cache; 7130} 7131 7132/** 7133 * Mark a function for special use by jQuery selector module 7134 * @param {Function} fn The function to mark 7135 */ 7136function markFunction( fn ) { 7137 fn[ expando ] = true; 7138 return fn; 7139} 7140 7141/** 7142 * Support testing using an element 7143 * @param {Function} fn Passed the created element and returns a boolean result 7144 */ 7145function assert( fn ) { 7146 var el = document.createElement( "fieldset" ); 7147 7148 try { 7149 return !!fn( el ); 7150 } catch ( e ) { 7151 return false; 7152 } finally { 7153 7154 // Remove from its parent by default 7155 if ( el.parentNode ) { 7156 el.parentNode.removeChild( el ); 7157 } 7158 7159 // release memory in IE 7160 el = null; 7161 } 7162} 7163 7164/** 7165 * Returns a function to use in pseudos for input types 7166 * @param {String} type 7167 */ 7168function createInputPseudo( type ) { 7169 return function( elem ) { 7170 return nodeName( elem, "input" ) && elem.type === type; 7171 }; 7172} 7173 7174/** 7175 * Returns a function to use in pseudos for buttons 7176 * @param {String} type 7177 */ 7178function createButtonPseudo( type ) { 7179 return function( elem ) { 7180 return ( nodeName( elem, "input" ) || nodeName( elem, "button" ) ) && 7181 elem.type === type; 7182 }; 7183} 7184 7185/** 7186 * Returns a function to use in pseudos for :enabled/:disabled 7187 * @param {Boolean} disabled true for :disabled; false for :enabled 7188 */ 7189function createDisabledPseudo( disabled ) { 7190 7191 // Known :disabled false positives: fieldset[disabled] > legend:nth-of-type(n+2) :can-disable 7192 return function( elem ) { 7193 7194 // Only certain elements can match :enabled or :disabled 7195 // https://html.spec.whatwg.org/multipage/scripting.html#selector-enabled 7196 // https://html.spec.whatwg.org/multipage/scripting.html#selector-disabled 7197 if ( "form" in elem ) { 7198 7199 // Check for inherited disabledness on relevant non-disabled elements: 7200 // * listed form-associated elements in a disabled fieldset 7201 // https://html.spec.whatwg.org/multipage/forms.html#category-listed 7202 // https://html.spec.whatwg.org/multipage/forms.html#concept-fe-disabled 7203 // * option elements in a disabled optgroup 7204 // https://html.spec.whatwg.org/multipage/forms.html#concept-option-disabled 7205 // All such elements have a "form" property. 7206 if ( elem.parentNode && elem.disabled === false ) { 7207 7208 // Option elements defer to a parent optgroup if present 7209 if ( "label" in elem ) { 7210 if ( "label" in elem.parentNode ) { 7211 return elem.parentNode.disabled === disabled; 7212 } else { 7213 return elem.disabled === disabled; 7214 } 7215 } 7216 7217 // Support: IE 6 - 11+ 7218 // Use the isDisabled shortcut property to check for disabled fieldset ancestors 7219 return elem.isDisabled === disabled || 7220 7221 // Where there is no isDisabled, check manually 7222 elem.isDisabled !== !disabled && 7223 inDisabledFieldset( elem ) === disabled; 7224 } 7225 7226 return elem.disabled === disabled; 7227 7228 // Try to winnow out elements that can't be disabled before trusting the disabled property. 7229 // Some victims get caught in our net (label, legend, menu, track), but it shouldn't 7230 // even exist on them, let alone have a boolean value. 7231 } else if ( "label" in elem ) { 7232 return elem.disabled === disabled; 7233 } 7234 7235 // Remaining elements are neither :enabled nor :disabled 7236 return false; 7237 }; 7238} 7239 7240/** 7241 * Returns a function to use in pseudos for positionals 7242 * @param {Function} fn 7243 */ 7244function createPositionalPseudo( fn ) { 7245 return markFunction( function( argument ) { 7246 argument = +argument; 7247 return markFunction( function( seed, matches ) { 7248 var j, 7249 matchIndexes = fn( [], seed.length, argument ), 7250 i = matchIndexes.length; 7251 7252 // Match elements found at the specified indexes 7253 while ( i-- ) { 7254 if ( seed[ ( j = matchIndexes[ i ] ) ] ) { 7255 seed[ j ] = !( matches[ j ] = seed[ j ] ); 7256 } 7257 } 7258 } ); 7259 } ); 7260} 7261 7262/** 7263 * Checks a node for validity as a jQuery selector context 7264 * @param {Element|Object=} context 7265 * @returns {Element|Object|Boolean} The input node if acceptable, otherwise a falsy value 7266 */ 7267function testContext( context ) { 7268 return context && typeof context.getElementsByTagName !== "undefined" && context; 7269} 7270 7271/** 7272 * Sets document-related variables once based on the current document 7273 * @param {Element|Object} [node] An element or document object to use to set the document 7274 * @returns {Object} Returns the current document 7275 */ 7276function setDocument( node ) { 7277 var subWindow, 7278 doc = node ? node.ownerDocument || node : preferredDoc; 7279 7280 // Return early if doc is invalid or already selected 7281 // Support: IE 11+, Edge 17 - 18+ 7282 // IE/Edge sometimes throw a "Permission denied" error when strict-comparing 7283 // two documents; shallow comparisons work. 7284 // eslint-disable-next-line eqeqeq 7285 if ( doc == document || doc.nodeType !== 9 || !doc.documentElement ) { 7286 return document; 7287 } 7288 7289 // Update global variables 7290 document = doc; 7291 documentElement = document.documentElement; 7292 documentIsHTML = !jQuery.isXMLDoc( document ); 7293 7294 // Support: iOS 7 only, IE 9 - 11+ 7295 // Older browsers didn't support unprefixed `matches`. 7296 matches = documentElement.matches || 7297 documentElement.webkitMatchesSelector ||
vendor: 4,667 bytes, lines 7298-7449
7298 documentElement.msMatchesSelector; 7299 7300 // Support: IE 9 - 11+, Edge 12 - 18+ 7301 // Accessing iframe documents after unload throws "permission denied" errors 7302 // (see trac-13936). 7303 // Limit the fix to IE & Edge Legacy; despite Edge 15+ implementing `matches`, 7304 // all IE 9+ and Edge Legacy versions implement `msMatchesSelector` as well. 7305 if ( documentElement.msMatchesSelector && 7306 7307 // Support: IE 11+, Edge 17 - 18+ 7308 // IE/Edge sometimes throw a "Permission denied" error when strict-comparing 7309 // two documents; shallow comparisons work. 7310 // eslint-disable-next-line eqeqeq 7311 preferredDoc != document && 7312 ( subWindow = document.defaultView ) && subWindow.top !== subWindow ) { 7313 7314 // Support: IE 9 - 11+, Edge 12 - 18+ 7315 subWindow.addEventListener( "unload", unloadHandler ); 7316 } 7317 7318 // Support: IE <10 7319 // Check if getElementById returns elements by name 7320 // The broken getElementById methods don't pick up programmatically-set names, 7321 // so use a roundabout getElementsByName test 7322 support.getById = assert( function( el ) { 7323 documentElement.appendChild( el ).id = jQuery.expando; 7324 return !document.getElementsByName || 7325 !document.getElementsByName( jQuery.expando ).length; 7326 } ); 7327 7328 // Support: IE 9 only 7329 // Check to see if it's possible to do matchesSelector 7330 // on a disconnected node. 7331 support.disconnectedMatch = assert( function( el ) { 7332 return matches.call( el, "*" ); 7333 } ); 7334 7335 // Support: IE 9 - 11+, Edge 12 - 18+ 7336 // IE/Edge don't support the :scope pseudo-class. 7337 support.scope = assert( function() { 7338 return document.querySelectorAll( ":scope" ); 7339 } ); 7340 7341 // Support: Chrome 105 - 111 only, Safari 15.4 - 16.3 only 7342 // Make sure the `:has()` argument is parsed unforgivingly. 7343 // We include `*` in the test to detect buggy implementations that are 7344 // _selectively_ forgiving (specifically when the list includes at least 7345 // one valid selector). 7346 // Note that we treat complete lack of support for `:has()` as if it were 7347 // spec-compliant support, which is fine because use of `:has()` in such 7348 // environments will fail in the qSA path and fall back to jQuery traversal 7349 // anyway. 7350 support.cssHas = assert( function() { 7351 try { 7352 document.querySelector( ":has(*,:jqfake)" ); 7353 return false; 7354 } catch ( e ) { 7355 return true; 7356 } 7357 } ); 7358 7359 // ID filter and find 7360 if ( support.getById ) { 7361 Expr.filter.ID = function( id ) { 7362 var attrId = id.replace( runescape, funescape ); 7363 return function( elem ) { 7364 return elem.getAttribute( "id" ) === attrId; 7365 }; 7366 }; 7367 Expr.find.ID = function( id, context ) { 7368 if ( typeof context.getElementById !== "undefined" && documentIsHTML ) { 7369 var elem = context.getElementById( id ); 7370 return elem ? [ elem ] : []; 7371 } 7372 }; 7373 } else { 7374 Expr.filter.ID = function( id ) { 7375 var attrId = id.replace( runescape, funescape ); 7376 return function( elem ) { 7377 var node = typeof elem.getAttributeNode !== "undefined" && 7378 elem.getAttributeNode( "id" ); 7379 return node && node.value === attrId; 7380 }; 7381 }; 7382 7383 // Support: IE 6 - 7 only 7384 // getElementById is not reliable as a find shortcut 7385 Expr.find.ID = function( id, context ) { 7386 if ( typeof context.getElementById !== "undefined" && documentIsHTML ) { 7387 var node, i, elems, 7388 elem = context.getElementById( id ); 7389 7390 if ( elem ) { 7391 7392 // Verify the id attribute 7393 node = elem.getAttributeNode( "id" ); 7394 if ( node && node.value === id ) { 7395 return [ elem ]; 7396 } 7397 7398 // Fall back on getElementsByName 7399 elems = context.getElementsByName( id ); 7400 i = 0; 7401 while ( ( elem = elems[ i++ ] ) ) { 7402 node = elem.getAttributeNode( "id" ); 7403 if ( node && node.value === id ) { 7404 return [ elem ]; 7405 } 7406 } 7407 } 7408 7409 return []; 7410 } 7411 }; 7412 } 7413 7414 // Tag 7415 Expr.find.TAG = function( tag, context ) { 7416 if ( typeof context.getElementsByTagName !== "undefined" ) { 7417 return context.getElementsByTagName( tag ); 7418 7419 // DocumentFragment nodes don't have gEBTN 7420 } else { 7421 return context.querySelectorAll( tag ); 7422 } 7423 }; 7424 7425 // Class 7426 Expr.find.CLASS = function( className, context ) { 7427 if ( typeof context.getElementsByClassName !== "undefined" && documentIsHTML ) { 7428 return context.getElementsByClassName( className ); 7429 } 7430 }; 7431 7432 /* QSA/matchesSelector 7433 ---------------------------------------------------------------------- */ 7434 7435 // QSA and matchesSelector support 7436 7437 rbuggyQSA = []; 7438 7439 // Build QSA regex 7440 // Regex strategy adopted from Diego Perini 7441 assert( function( el ) { 7442 7443 var input; 7444 7445 documentElement.appendChild( el ).innerHTML = 7446 "<a id='" + expando + "' href='' disabled='disabled'></a>" + 7447 "<select id='" + expando + "-\r\\' disabled='disabled'>" + 7448 "<option selected=''></option></select>"; 7449
vendor: 38,614 bytes, lines 7450-8821
7450 // Support: iOS <=7 - 8 only 7451 // Boolean attributes and "value" are not treated correctly in some XML documents 7452 if ( !el.querySelectorAll( "[selected]" ).length ) { 7453 rbuggyQSA.push( "\\[" + whitespace + "*(?:value|" + booleans + ")" ); 7454 } 7455 7456 // Support: iOS <=7 - 8 only 7457 if ( !el.querySelectorAll( "[id~=" + expando + "-]" ).length ) { 7458 rbuggyQSA.push( "~=" ); 7459 } 7460 7461 // Support: iOS 8 only 7462 // https://bugs.webkit.org/show_bug.cgi?id=136851 7463 // In-page `selector#id sibling-combinator selector` fails 7464 if ( !el.querySelectorAll( "a#" + expando + "+*" ).length ) { 7465 rbuggyQSA.push( ".#.+[+~]" ); 7466 } 7467 7468 // Support: Chrome <=105+, Firefox <=104+, Safari <=15.4+ 7469 // In some of the document kinds, these selectors wouldn't work natively. 7470 // This is probably OK but for backwards compatibility we want to maintain 7471 // handling them through jQuery traversal in jQuery 3.x. 7472 if ( !el.querySelectorAll( ":checked" ).length ) { 7473 rbuggyQSA.push( ":checked" ); 7474 } 7475 7476 // Support: Windows 8 Native Apps 7477 // The type and name attributes are restricted during .innerHTML assignment 7478 input = document.createElement( "input" ); 7479 input.setAttribute( "type", "hidden" ); 7480 el.appendChild( input ).setAttribute( "name", "D" ); 7481 7482 // Support: IE 9 - 11+ 7483 // IE's :disabled selector does not pick up the children of disabled fieldsets 7484 // Support: Chrome <=105+, Firefox <=104+, Safari <=15.4+ 7485 // In some of the document kinds, these selectors wouldn't work natively. 7486 // This is probably OK but for backwards compatibility we want to maintain 7487 // handling them through jQuery traversal in jQuery 3.x. 7488 documentElement.appendChild( el ).disabled = true; 7489 if ( el.querySelectorAll( ":disabled" ).length !== 2 ) { 7490 rbuggyQSA.push( ":enabled", ":disabled" ); 7491 } 7492 7493 // Support: IE 11+, Edge 15 - 18+ 7494 // IE 11/Edge don't find elements on a `[name='']` query in some cases. 7495 // Adding a temporary attribute to the document before the selection works 7496 // around the issue. 7497 // Interestingly, IE 10 & older don't seem to have the issue. 7498 input = document.createElement( "input" ); 7499 input.setAttribute( "name", "" ); 7500 el.appendChild( input ); 7501 if ( !el.querySelectorAll( "[name='']" ).length ) { 7502 rbuggyQSA.push( "\\[" + whitespace + "*name" + whitespace + "*=" + 7503 whitespace + "*(?:''|\"\")" ); 7504 } 7505 } ); 7506 7507 if ( !support.cssHas ) { 7508 7509 // Support: Chrome 105 - 110+, Safari 15.4 - 16.3+ 7510 // Our regular `try-catch` mechanism fails to detect natively-unsupported 7511 // pseudo-classes inside `:has()` (such as `:has(:contains("Foo"))`) 7512 // in browsers that parse the `:has()` argument as a forgiving selector list. 7513 // https://drafts.csswg.org/selectors/#relational now requires the argument 7514 // to be parsed unforgivingly, but browsers have not yet fully adjusted. 7515 rbuggyQSA.push( ":has" ); 7516 } 7517 7518 rbuggyQSA = rbuggyQSA.length && new RegExp( rbuggyQSA.join( "|" ) ); 7519 7520 /* Sorting 7521 ---------------------------------------------------------------------- */ 7522 7523 // Document order sorting 7524 sortOrder = function( a, b ) { 7525 7526 // Flag for duplicate removal 7527 if ( a === b ) { 7528 hasDuplicate = true; 7529 return 0; 7530 } 7531 7532 // Sort on method existence if only one input has compareDocumentPosition 7533 var compare = !a.compareDocumentPosition - !b.compareDocumentPosition; 7534 if ( compare ) { 7535 return compare; 7536 } 7537 7538 // Calculate position if both inputs belong to the same document 7539 // Support: IE 11+, Edge 17 - 18+ 7540 // IE/Edge sometimes throw a "Permission denied" error when strict-comparing 7541 // two documents; shallow comparisons work. 7542 // eslint-disable-next-line eqeqeq 7543 compare = ( a.ownerDocument || a ) == ( b.ownerDocument || b ) ? 7544 a.compareDocumentPosition( b ) : 7545 7546 // Otherwise we know they are disconnected 7547 1; 7548 7549 // Disconnected nodes 7550 if ( compare & 1 || 7551 ( !support.sortDetached && b.compareDocumentPosition( a ) === compare ) ) { 7552 7553 // Choose the first element that is related to our preferred document 7554 // Support: IE 11+, Edge 17 - 18+ 7555 // IE/Edge sometimes throw a "Permission denied" error when strict-comparing 7556 // two documents; shallow comparisons work. 7557 // eslint-disable-next-line eqeqeq 7558 if ( a === document || a.ownerDocument == preferredDoc && 7559 find.contains( preferredDoc, a ) ) { 7560 return -1; 7561 } 7562 7563 // Support: IE 11+, Edge 17 - 18+ 7564 // IE/Edge sometimes throw a "Permission denied" error when strict-comparing 7565 // two documents; shallow comparisons work. 7566 // eslint-disable-next-line eqeqeq 7567 if ( b === document || b.ownerDocument == preferredDoc && 7568 find.contains( preferredDoc, b ) ) { 7569 return 1; 7570 } 7571 7572 // Maintain original order 7573 return sortInput ? 7574 ( indexOf.call( sortInput, a ) - indexOf.call( sortInput, b ) ) : 7575 0; 7576 } 7577 7578 return compare & 4 ? -1 : 1; 7579 }; 7580 7581 return document; 7582} 7583 7584find.matches = function( expr, elements ) { 7585 return find( expr, null, null, elements ); 7586}; 7587 7588find.matchesSelector = function( elem, expr ) { 7589 setDocument( elem ); 7590 7591 if ( documentIsHTML && 7592 !nonnativeSelectorCache[ expr + " " ] && 7593 ( !rbuggyQSA || !rbuggyQSA.test( expr ) ) ) { 7594 7595 try { 7596 var ret = matches.call( elem, expr ); 7597 7598 // IE 9's matchesSelector returns false on disconnected nodes 7599 if ( ret || support.disconnectedMatch || 7600 7601 // As well, disconnected nodes are said to be in a document 7602 // fragment in IE 9 7603 elem.document && elem.document.nodeType !== 11 ) { 7604 return ret; 7605 } 7606 } catch ( e ) { 7607 nonnativeSelectorCache( expr, true ); 7608 } 7609 } 7610 7611 return find( expr, document, null, [ elem ] ).length > 0; 7612}; 7613 7614find.contains = function( context, elem ) { 7615 7616 // Set document vars if needed 7617 // Support: IE 11+, Edge 17 - 18+ 7618 // IE/Edge sometimes throw a "Permission denied" error when strict-comparing 7619 // two documents; shallow comparisons work. 7620 // eslint-disable-next-line eqeqeq 7621 if ( ( context.ownerDocument || context ) != document ) { 7622 setDocument( context ); 7623 } 7624 return jQuery.contains( context, elem ); 7625}; 7626 7627 7628find.attr = function( elem, name ) { 7629 7630 // Set document vars if needed 7631 // Support: IE 11+, Edge 17 - 18+ 7632 // IE/Edge sometimes throw a "Permission denied" error when strict-comparing 7633 // two documents; shallow comparisons work. 7634 // eslint-disable-next-line eqeqeq 7635 if ( ( elem.ownerDocument || elem ) != document ) { 7636 setDocument( elem ); 7637 } 7638 7639 var fn = Expr.attrHandle[ name.toLowerCase() ], 7640 7641 // Don't get fooled by Object.prototype properties (see trac-13807) 7642 val = fn && hasOwn.call( Expr.attrHandle, name.toLowerCase() ) ? 7643 fn( elem, name, !documentIsHTML ) : 7644 undefined; 7645 7646 if ( val !== undefined ) { 7647 return val; 7648 } 7649 7650 return elem.getAttribute( name ); 7651}; 7652 7653find.error = function( msg ) { 7654 throw new Error( "Syntax error, unrecognized expression: " + msg ); 7655}; 7656 7657/** 7658 * Document sorting and removing duplicates 7659 * @param {ArrayLike} results 7660 */ 7661jQuery.uniqueSort = function( results ) { 7662 var elem, 7663 duplicates = [], 7664 j = 0, 7665 i = 0; 7666 7667 // Unless we *know* we can detect duplicates, assume their presence 7668 // 7669 // Support: Android <=4.0+ 7670 // Testing for detecting duplicates is unpredictable so instead assume we can't 7671 // depend on duplicate detection in all browsers without a stable sort. 7672 hasDuplicate = !support.sortStable; 7673 sortInput = !support.sortStable && slice.call( results, 0 ); 7674 sort.call( results, sortOrder ); 7675 7676 if ( hasDuplicate ) { 7677 while ( ( elem = results[ i++ ] ) ) { 7678 if ( elem === results[ i ] ) { 7679 j = duplicates.push( i ); 7680 } 7681 } 7682 while ( j-- ) { 7683 splice.call( results, duplicates[ j ], 1 ); 7684 } 7685 } 7686 7687 // Clear input after sorting to release objects 7688 // See https://github.com/jquery/sizzle/pull/225 7689 sortInput = null; 7690 7691 return results; 7692}; 7693 7694jQuery.fn.uniqueSort = function() { 7695 return this.pushStack( jQuery.uniqueSort( slice.apply( this ) ) ); 7696}; 7697 7698Expr = jQuery.expr = { 7699 7700 // Can be adjusted by the user 7701 cacheLength: 50, 7702 7703 createPseudo: markFunction, 7704 7705 match: matchExpr, 7706 7707 attrHandle: {}, 7708 7709 find: {}, 7710 7711 relative: { 7712 ">": { dir: "parentNode", first: true }, 7713 " ": { dir: "parentNode" }, 7714 "+": { dir: "previousSibling", first: true }, 7715 "~": { dir: "previousSibling" } 7716 }, 7717 7718 preFilter: { 7719 ATTR: function( match ) { 7720 match[ 1 ] = match[ 1 ].replace( runescape, funescape ); 7721 7722 // Move the given value to match[3] whether quoted or unquoted 7723 match[ 3 ] = ( match[ 3 ] || match[ 4 ] || match[ 5 ] || "" ) 7724 .replace( runescape, funescape ); 7725 7726 if ( match[ 2 ] === "~=" ) { 7727 match[ 3 ] = " " + match[ 3 ] + " "; 7728 } 7729 7730 return match.slice( 0, 4 ); 7731 }, 7732 7733 CHILD: function( match ) { 7734 7735 /* matches from matchExpr["CHILD"] 7736 1 type (only|nth|...) 7737 2 what (child|of-type) 7738 3 argument (even|odd|\d*|\d*n([+-]\d+)?|...) 7739 4 xn-component of xn+y argument ([+-]?\d*n|) 7740 5 sign of xn-component 7741 6 x of xn-component 7742 7 sign of y-component 7743 8 y of y-component 7744 */ 7745 match[ 1 ] = match[ 1 ].toLowerCase(); 7746 7747 if ( match[ 1 ].slice( 0, 3 ) === "nth" ) { 7748 7749 // nth-* requires argument 7750 if ( !match[ 3 ] ) { 7751 find.error( match[ 0 ] ); 7752 } 7753 7754 // numeric x and y parameters for Expr.filter.CHILD 7755 // remember that false/true cast respectively to 0/1 7756 match[ 4 ] = +( match[ 4 ] ? 7757 match[ 5 ] + ( match[ 6 ] || 1 ) : 7758 2 * ( match[ 3 ] === "even" || match[ 3 ] === "odd" ) 7759 ); 7760 match[ 5 ] = +( ( match[ 7 ] + match[ 8 ] ) || match[ 3 ] === "odd" ); 7761 7762 // other types prohibit arguments 7763 } else if ( match[ 3 ] ) { 7764 find.error( match[ 0 ] ); 7765 } 7766 7767 return match; 7768 }, 7769 7770 PSEUDO: function( match ) { 7771 var excess, 7772 unquoted = !match[ 6 ] && match[ 2 ]; 7773 7774 if ( matchExpr.CHILD.test( match[ 0 ] ) ) { 7775 return null; 7776 } 7777 7778 // Accept quoted arguments as-is 7779 if ( match[ 3 ] ) { 7780 match[ 2 ] = match[ 4 ] || match[ 5 ] || ""; 7781 7782 // Strip excess characters from unquoted arguments 7783 } else if ( unquoted && rpseudo.test( unquoted ) && 7784 7785 // Get excess from tokenize (recursively) 7786 ( excess = tokenize( unquoted, true ) ) && 7787 7788 // advance to the next closing parenthesis 7789 ( excess = unquoted.indexOf( ")", unquoted.length - excess ) - unquoted.length ) ) { 7790 7791 // excess is a negative index 7792 match[ 0 ] = match[ 0 ].slice( 0, excess ); 7793 match[ 2 ] = unquoted.slice( 0, excess ); 7794 } 7795 7796 // Return only captures needed by the pseudo filter method (type and argument) 7797 return match.slice( 0, 3 ); 7798 } 7799 }, 7800 7801 filter: { 7802 7803 TAG: function( nodeNameSelector ) { 7804 var expectedNodeName = nodeNameSelector.replace( runescape, funescape ).toLowerCase(); 7805 return nodeNameSelector === "*" ? 7806 function() { 7807 return true; 7808 } : 7809 function( elem ) { 7810 return nodeName( elem, expectedNodeName ); 7811 }; 7812 }, 7813 7814 CLASS: function( className ) { 7815 var pattern = classCache[ className + " " ]; 7816 7817 return pattern || 7818 ( pattern = new RegExp( "(^|" + whitespace + ")" + className + 7819 "(" + whitespace + "|$)" ) ) && 7820 classCache( className, function( elem ) { 7821 return pattern.test( 7822 typeof elem.className === "string" && elem.className || 7823 typeof elem.getAttribute !== "undefined" && 7824 elem.getAttribute( "class" ) || 7825 "" 7826 ); 7827 } ); 7828 }, 7829 7830 ATTR: function( name, operator, check ) { 7831 return function( elem ) { 7832 var result = find.attr( elem, name ); 7833 7834 if ( result == null ) { 7835 return operator === "!="; 7836 } 7837 if ( !operator ) { 7838 return true; 7839 } 7840 7841 result += ""; 7842 7843 if ( operator === "=" ) { 7844 return result === check; 7845 } 7846 if ( operator === "!=" ) { 7847 return result !== check; 7848 } 7849 if ( operator === "^=" ) { 7850 return check && result.indexOf( check ) === 0; 7851 } 7852 if ( operator === "*=" ) { 7853 return check && result.indexOf( check ) > -1; 7854 } 7855 if ( operator === "$=" ) { 7856 return check && result.slice( -check.length ) === check; 7857 } 7858 if ( operator === "~=" ) { 7859 return ( " " + result.replace( rwhitespace, " " ) + " " ) 7860 .indexOf( check ) > -1; 7861 } 7862 if ( operator === "|=" ) { 7863 return result === check || result.slice( 0, check.length + 1 ) === check + "-"; 7864 } 7865 7866 return false; 7867 }; 7868 }, 7869 7870 CHILD: function( type, what, _argument, first, last ) { 7871 var simple = type.slice( 0, 3 ) !== "nth", 7872 forward = type.slice( -4 ) !== "last", 7873 ofType = what === "of-type"; 7874 7875 return first === 1 && last === 0 ? 7876 7877 // Shortcut for :nth-*(n) 7878 function( elem ) { 7879 return !!elem.parentNode; 7880 } : 7881 7882 function( elem, _context, xml ) { 7883 var cache, outerCache, node, nodeIndex, start, 7884 dir = simple !== forward ? "nextSibling" : "previousSibling", 7885 parent = elem.parentNode, 7886 name = ofType && elem.nodeName.toLowerCase(), 7887 useCache = !xml && !ofType, 7888 diff = false; 7889 7890 if ( parent ) { 7891 7892 // :(first|last|only)-(child|of-type) 7893 if ( simple ) { 7894 while ( dir ) { 7895 node = elem; 7896 while ( ( node = node[ dir ] ) ) { 7897 if ( ofType ? 7898 nodeName( node, name ) : 7899 node.nodeType === 1 ) { 7900 7901 return false; 7902 } 7903 } 7904 7905 // Reverse direction for :only-* (if we haven't yet done so) 7906 start = dir = type === "only" && !start && "nextSibling"; 7907 } 7908 return true; 7909 } 7910 7911 start = [ forward ? parent.firstChild : parent.lastChild ]; 7912 7913 // non-xml :nth-child(...) stores cache data on `parent` 7914 if ( forward && useCache ) { 7915 7916 // Seek `elem` from a previously-cached index 7917 outerCache = parent[ expando ] || ( parent[ expando ] = {} ); 7918 cache = outerCache[ type ] || []; 7919 nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ]; 7920 diff = nodeIndex && cache[ 2 ]; 7921 node = nodeIndex && parent.childNodes[ nodeIndex ]; 7922 7923 while ( ( node = ++nodeIndex && node && node[ dir ] || 7924 7925 // Fallback to seeking `elem` from the start 7926 ( diff = nodeIndex = 0 ) || start.pop() ) ) { 7927 7928 // When found, cache indexes on `parent` and break 7929 if ( node.nodeType === 1 && ++diff && node === elem ) { 7930 outerCache[ type ] = [ dirruns, nodeIndex, diff ]; 7931 break; 7932 } 7933 } 7934 7935 } else { 7936 7937 // Use previously-cached element index if available 7938 if ( useCache ) { 7939 outerCache = elem[ expando ] || ( elem[ expando ] = {} ); 7940 cache = outerCache[ type ] || []; 7941 nodeIndex = cache[ 0 ] === dirruns && cache[ 1 ]; 7942 diff = nodeIndex; 7943 } 7944 7945 // xml :nth-child(...) 7946 // or :nth-last-child(...) or :nth(-last)?-of-type(...) 7947 if ( diff === false ) { 7948 7949 // Use the same loop as above to seek `elem` from the start 7950 while ( ( node = ++nodeIndex && node && node[ dir ] || 7951 ( diff = nodeIndex = 0 ) || start.pop() ) ) { 7952 7953 if ( ( ofType ? 7954 nodeName( node, name ) : 7955 node.nodeType === 1 ) && 7956 ++diff ) { 7957 7958 // Cache the index of each encountered element 7959 if ( useCache ) { 7960 outerCache = node[ expando ] || 7961 ( node[ expando ] = {} ); 7962 outerCache[ type ] = [ dirruns, diff ]; 7963 } 7964 7965 if ( node === elem ) { 7966 break; 7967 } 7968 } 7969 } 7970 } 7971 } 7972 7973 // Incorporate the offset, then check against cycle size 7974 diff -= last; 7975 return diff === first || ( diff % first === 0 && diff / first >= 0 ); 7976 } 7977 }; 7978 }, 7979 7980 PSEUDO: function( pseudo, argument ) { 7981 7982 // pseudo-class names are case-insensitive 7983 // https://www.w3.org/TR/selectors/#pseudo-classes 7984 // Prioritize by case sensitivity in case custom pseudos are added with uppercase letters 7985 // Remember that setFilters inherits from pseudos 7986 var args, 7987 fn = Expr.pseudos[ pseudo ] || Expr.setFilters[ pseudo.toLowerCase() ] || 7988 find.error( "unsupported pseudo: " + pseudo ); 7989 7990 // The user may use createPseudo to indicate that 7991 // arguments are needed to create the filter function 7992 // just as jQuery does 7993 if ( fn[ expando ] ) { 7994 return fn( argument ); 7995 } 7996 7997 // But maintain support for old signatures 7998 if ( fn.length > 1 ) { 7999 args = [ pseudo, pseudo, "", argument ]; 8000 return Expr.setFilters.hasOwnProperty( pseudo.toLowerCase() ) ? 8001 markFunction( function( seed, matches ) { 8002 var idx, 8003 matched = fn( seed, argument ), 8004 i = matched.length; 8005 while ( i-- ) { 8006 idx = indexOf.call( seed, matched[ i ] ); 8007 seed[ idx ] = !( matches[ idx ] = matched[ i ] ); 8008 } 8009 } ) : 8010 function( elem ) { 8011 return fn( elem, 0, args ); 8012 }; 8013 } 8014 8015 return fn; 8016 } 8017 }, 8018 8019 pseudos: { 8020 8021 // Potentially complex pseudos 8022 not: markFunction( function( selector ) { 8023 8024 // Trim the selector passed to compile 8025 // to avoid treating leading and trailing 8026 // spaces as combinators 8027 var input = [], 8028 results = [], 8029 matcher = compile( selector.replace( rtrimCSS, "$1" ) ); 8030 8031 return matcher[ expando ] ? 8032 markFunction( function( seed, matches, _context, xml ) { 8033 var elem, 8034 unmatched = matcher( seed, null, xml, [] ), 8035 i = seed.length; 8036 8037 // Match elements unmatched by `matcher` 8038 while ( i-- ) { 8039 if ( ( elem = unmatched[ i ] ) ) { 8040 seed[ i ] = !( matches[ i ] = elem ); 8041 } 8042 } 8043 } ) : 8044 function( elem, _context, xml ) { 8045 input[ 0 ] = elem; 8046 matcher( input, null, xml, results ); 8047 8048 // Don't keep the element 8049 // (see https://github.com/jquery/sizzle/issues/299) 8050 input[ 0 ] = null; 8051 return !results.pop(); 8052 }; 8053 } ), 8054 8055 has: markFunction( function( selector ) { 8056 return function( elem ) { 8057 return find( selector, elem ).length > 0; 8058 }; 8059 } ), 8060 8061 contains: markFunction( function( text ) { 8062 text = text.replace( runescape, funescape ); 8063 return function( elem ) { 8064 return ( elem.textContent || jQuery.text( elem ) ).indexOf( text ) > -1; 8065 }; 8066 } ), 8067 8068 // "Whether an element is represented by a :lang() selector 8069 // is based solely on the element's language value 8070 // being equal to the identifier C, 8071 // or beginning with the identifier C immediately followed by "-". 8072 // The matching of C against the element's language value is performed case-insensitively. 8073 // The identifier C does not have to be a valid language name." 8074 // https://www.w3.org/TR/selectors/#lang-pseudo 8075 lang: markFunction( function( lang ) { 8076 8077 // lang value must be a valid identifier 8078 if ( !ridentifier.test( lang || "" ) ) { 8079 find.error( "unsupported lang: " + lang ); 8080 } 8081 lang = lang.replace( runescape, funescape ).toLowerCase(); 8082 return function( elem ) { 8083 var elemLang; 8084 do { 8085 if ( ( elemLang = documentIsHTML ? 8086 elem.lang : 8087 elem.getAttribute( "xml:lang" ) || elem.getAttribute( "lang" ) ) ) { 8088 8089 elemLang = elemLang.toLowerCase(); 8090 return elemLang === lang || elemLang.indexOf( lang + "-" ) === 0; 8091 } 8092 } while ( ( elem = elem.parentNode ) && elem.nodeType === 1 ); 8093 return false; 8094 }; 8095 } ), 8096 8097 // Miscellaneous 8098 target: function( elem ) { 8099 var hash = window.location && window.location.hash; 8100 return hash && hash.slice( 1 ) === elem.id; 8101 }, 8102 8103 root: function( elem ) { 8104 return elem === documentElement; 8105 }, 8106 8107 focus: function( elem ) { 8108 return elem === safeActiveElement() && 8109 document.hasFocus() && 8110 !!( elem.type || elem.href || ~elem.tabIndex ); 8111 }, 8112 8113 // Boolean properties 8114 enabled: createDisabledPseudo( false ), 8115 disabled: createDisabledPseudo( true ), 8116 8117 checked: function( elem ) { 8118 8119 // In CSS3, :checked should return both checked and selected elements 8120 // https://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked 8121 return ( nodeName( elem, "input" ) && !!elem.checked ) || 8122 ( nodeName( elem, "option" ) && !!elem.selected ); 8123 }, 8124 8125 selected: function( elem ) { 8126 8127 // Support: IE <=11+ 8128 // Accessing the selectedIndex property 8129 // forces the browser to treat the default option as 8130 // selected when in an optgroup. 8131 if ( elem.parentNode ) { 8132 // eslint-disable-next-line no-unused-expressions 8133 elem.parentNode.selectedIndex; 8134 } 8135 8136 return elem.selected === true; 8137 }, 8138 8139 // Contents 8140 empty: function( elem ) { 8141 8142 // https://www.w3.org/TR/selectors/#empty-pseudo 8143 // :empty is negated by element (1) or content nodes (text: 3; cdata: 4; entity ref: 5), 8144 // but not by others (comment: 8; processing instruction: 7; etc.) 8145 // nodeType < 6 works because attributes (2) do not appear as children 8146 for ( elem = elem.firstChild; elem; elem = elem.nextSibling ) { 8147 if ( elem.nodeType < 6 ) { 8148 return false; 8149 } 8150 } 8151 return true; 8152 }, 8153 8154 parent: function( elem ) { 8155 return !Expr.pseudos.empty( elem ); 8156 }, 8157 8158 // Element/input types 8159 header: function( elem ) { 8160 return rheader.test( elem.nodeName ); 8161 }, 8162 8163 input: function( elem ) { 8164 return rinputs.test( elem.nodeName ); 8165 }, 8166 8167 button: function( elem ) { 8168 return nodeName( elem, "input" ) && elem.type === "button" || 8169 nodeName( elem, "button" ); 8170 }, 8171 8172 text: function( elem ) { 8173 var attr; 8174 return nodeName( elem, "input" ) && elem.type === "text" && 8175 8176 // Support: IE <10 only 8177 // New HTML5 attribute values (e.g., "search") appear 8178 // with elem.type === "text" 8179 ( ( attr = elem.getAttribute( "type" ) ) == null || 8180 attr.toLowerCase() === "text" ); 8181 }, 8182 8183 // Position-in-collection 8184 first: createPositionalPseudo( function() { 8185 return [ 0 ]; 8186 } ), 8187 8188 last: createPositionalPseudo( function( _matchIndexes, length ) { 8189 return [ length - 1 ]; 8190 } ), 8191 8192 eq: createPositionalPseudo( function( _matchIndexes, length, argument ) { 8193 return [ argument < 0 ? argument + length : argument ]; 8194 } ), 8195 8196 even: createPositionalPseudo( function( matchIndexes, length ) { 8197 var i = 0; 8198 for ( ; i < length; i += 2 ) { 8199 matchIndexes.push( i ); 8200 } 8201 return matchIndexes; 8202 } ), 8203 8204 odd: createPositionalPseudo( function( matchIndexes, length ) { 8205 var i = 1; 8206 for ( ; i < length; i += 2 ) { 8207 matchIndexes.push( i ); 8208 } 8209 return matchIndexes; 8210 } ), 8211 8212 lt: createPositionalPseudo( function( matchIndexes, length, argument ) { 8213 var i; 8214 8215 if ( argument < 0 ) { 8216 i = argument + length; 8217 } else if ( argument > length ) { 8218 i = length; 8219 } else { 8220 i = argument; 8221 } 8222 8223 for ( ; --i >= 0; ) { 8224 matchIndexes.push( i ); 8225 } 8226 return matchIndexes; 8227 } ), 8228 8229 gt: createPositionalPseudo( function( matchIndexes, length, argument ) { 8230 var i = argument < 0 ? argument + length : argument; 8231 for ( ; ++i < length; ) { 8232 matchIndexes.push( i ); 8233 } 8234 return matchIndexes; 8235 } ) 8236 } 8237}; 8238 8239Expr.pseudos.nth = Expr.pseudos.eq; 8240 8241// Add button/input type pseudos 8242for ( i in { radio: true, checkbox: true, file: true, password: true, image: true } ) { 8243 Expr.pseudos[ i ] = createInputPseudo( i ); 8244} 8245for ( i in { submit: true, reset: true } ) { 8246 Expr.pseudos[ i ] = createButtonPseudo( i ); 8247} 8248 8249// Easy API for creating new setFilters 8250function setFilters() {} 8251setFilters.prototype = Expr.filters = Expr.pseudos; 8252Expr.setFilters = new setFilters(); 8253 8254function tokenize( selector, parseOnly ) { 8255 var matched, match, tokens, type, 8256 soFar, groups, preFilters, 8257 cached = tokenCache[ selector + " " ]; 8258 8259 if ( cached ) { 8260 return parseOnly ? 0 : cached.slice( 0 ); 8261 } 8262 8263 soFar = selector; 8264 groups = []; 8265 preFilters = Expr.preFilter; 8266 8267 while ( soFar ) { 8268 8269 // Comma and first run 8270 if ( !matched || ( match = rcomma.exec( soFar ) ) ) { 8271 if ( match ) { 8272 8273 // Don't consume trailing commas as valid 8274 soFar = soFar.slice( match[ 0 ].length ) || soFar; 8275 } 8276 groups.push( ( tokens = [] ) ); 8277 } 8278 8279 matched = false; 8280 8281 // Combinators 8282 if ( ( match = rleadingCombinator.exec( soFar ) ) ) { 8283 matched = match.shift(); 8284 tokens.push( { 8285 value: matched, 8286 8287 // Cast descendant combinators to space 8288 type: match[ 0 ].replace( rtrimCSS, " " ) 8289 } ); 8290 soFar = soFar.slice( matched.length ); 8291 } 8292 8293 // Filters 8294 for ( type in Expr.filter ) { 8295 if ( ( match = matchExpr[ type ].exec( soFar ) ) && ( !preFilters[ type ] || 8296 ( match = preFilters[ type ]( match ) ) ) ) { 8297 matched = match.shift(); 8298 tokens.push( { 8299 value: matched, 8300 type: type, 8301 matches: match 8302 } ); 8303 soFar = soFar.slice( matched.length ); 8304 } 8305 } 8306 8307 if ( !matched ) { 8308 break; 8309 } 8310 } 8311 8312 // Return the length of the invalid excess 8313 // if we're just parsing 8314 // Otherwise, throw an error or return tokens 8315 if ( parseOnly ) { 8316 return soFar.length; 8317 } 8318 8319 return soFar ? 8320 find.error( selector ) : 8321 8322 // Cache the tokens 8323 tokenCache( selector, groups ).slice( 0 ); 8324} 8325 8326function toSelector( tokens ) { 8327 var i = 0, 8328 len = tokens.length, 8329 selector = ""; 8330 for ( ; i < len; i++ ) { 8331 selector += tokens[ i ].value; 8332 } 8333 return selector; 8334} 8335 8336function addCombinator( matcher, combinator, base ) { 8337 var dir = combinator.dir, 8338 skip = combinator.next, 8339 key = skip || dir, 8340 checkNonElements = base && key === "parentNode", 8341 doneName = done++; 8342 8343 return combinator.first ? 8344 8345 // Check against closest ancestor/preceding element 8346 function( elem, context, xml ) { 8347 while ( ( elem = elem[ dir ] ) ) { 8348 if ( elem.nodeType === 1 || checkNonElements ) { 8349 return matcher( elem, context, xml ); 8350 } 8351 } 8352 return false; 8353 } : 8354 8355 // Check against all ancestor/preceding elements 8356 function( elem, context, xml ) { 8357 var oldCache, outerCache, 8358 newCache = [ dirruns, doneName ]; 8359 8360 // We can't set arbitrary data on XML nodes, so they don't benefit from combinator caching 8361 if ( xml ) { 8362 while ( ( elem = elem[ dir ] ) ) { 8363 if ( elem.nodeType === 1 || checkNonElements ) { 8364 if ( matcher( elem, context, xml ) ) { 8365 return true; 8366 } 8367 } 8368 } 8369 } else { 8370 while ( ( elem = elem[ dir ] ) ) { 8371 if ( elem.nodeType === 1 || checkNonElements ) { 8372 outerCache = elem[ expando ] || ( elem[ expando ] = {} ); 8373 8374 if ( skip && nodeName( elem, skip ) ) { 8375 elem = elem[ dir ] || elem; 8376 } else if ( ( oldCache = outerCache[ key ] ) && 8377 oldCache[ 0 ] === dirruns && oldCache[ 1 ] === doneName ) { 8378 8379 // Assign to newCache so results back-propagate to previous elements 8380 return ( newCache[ 2 ] = oldCache[ 2 ] ); 8381 } else { 8382 8383 // Reuse newcache so results back-propagate to previous elements 8384 outerCache[ key ] = newCache; 8385 8386 // A match means we're done; a fail means we have to keep checking 8387 if ( ( newCache[ 2 ] = matcher( elem, context, xml ) ) ) { 8388 return true; 8389 } 8390 } 8391 } 8392 } 8393 } 8394 return false; 8395 }; 8396} 8397 8398function elementMatcher( matchers ) { 8399 return matchers.length > 1 ? 8400 function( elem, context, xml ) { 8401 var i = matchers.length; 8402 while ( i-- ) { 8403 if ( !matchers[ i ]( elem, context, xml ) ) { 8404 return false; 8405 } 8406 } 8407 return true; 8408 } : 8409 matchers[ 0 ]; 8410} 8411 8412function multipleContexts( selector, contexts, results ) { 8413 var i = 0, 8414 len = contexts.length; 8415 for ( ; i < len; i++ ) { 8416 find( selector, contexts[ i ], results ); 8417 } 8418 return results; 8419} 8420 8421function condense( unmatched, map, filter, context, xml ) { 8422 var elem, 8423 newUnmatched = [], 8424 i = 0, 8425 len = unmatched.length, 8426 mapped = map != null; 8427 8428 for ( ; i < len; i++ ) { 8429 if ( ( elem = unmatched[ i ] ) ) { 8430 if ( !filter || filter( elem, context, xml ) ) { 8431 newUnmatched.push( elem ); 8432 if ( mapped ) { 8433 map.push( i ); 8434 } 8435 } 8436 } 8437 } 8438 8439 return newUnmatched; 8440} 8441 8442function setMatcher( preFilter, selector, matcher, postFilter, postFinder, postSelector ) { 8443 if ( postFilter && !postFilter[ expando ] ) { 8444 postFilter = setMatcher( postFilter ); 8445 } 8446 if ( postFinder && !postFinder[ expando ] ) { 8447 postFinder = setMatcher( postFinder, postSelector ); 8448 } 8449 return markFunction( function( seed, results, context, xml ) { 8450 var temp, i, elem, matcherOut, 8451 preMap = [], 8452 postMap = [], 8453 preexisting = results.length, 8454 8455 // Get initial elements from seed or context 8456 elems = seed || 8457 multipleContexts( selector || "*", 8458 context.nodeType ? [ context ] : context, [] ), 8459 8460 // Prefilter to get matcher input, preserving a map for seed-results synchronization 8461 matcherIn = preFilter && ( seed || !selector ) ? 8462 condense( elems, preMap, preFilter, context, xml ) : 8463 elems; 8464 8465 if ( matcher ) { 8466 8467 // If we have a postFinder, or filtered seed, or non-seed postFilter 8468 // or preexisting results, 8469 matcherOut = postFinder || ( seed ? preFilter : preexisting || postFilter ) ? 8470 8471 // ...intermediate processing is necessary 8472 [] : 8473 8474 // ...otherwise use results directly 8475 results; 8476 8477 // Find primary matches 8478 matcher( matcherIn, matcherOut, context, xml ); 8479 } else { 8480 matcherOut = matcherIn; 8481 } 8482 8483 // Apply postFilter 8484 if ( postFilter ) { 8485 temp = condense( matcherOut, postMap ); 8486 postFilter( temp, [], context, xml ); 8487 8488 // Un-match failing elements by moving them back to matcherIn 8489 i = temp.length; 8490 while ( i-- ) { 8491 if ( ( elem = temp[ i ] ) ) { 8492 matcherOut[ postMap[ i ] ] = !( matcherIn[ postMap[ i ] ] = elem ); 8493 } 8494 } 8495 } 8496 8497 if ( seed ) { 8498 if ( postFinder || preFilter ) { 8499 if ( postFinder ) { 8500 8501 // Get the final matcherOut by condensing this intermediate into postFinder contexts 8502 temp = []; 8503 i = matcherOut.length; 8504 while ( i-- ) { 8505 if ( ( elem = matcherOut[ i ] ) ) { 8506 8507 // Restore matcherIn since elem is not yet a final match 8508 temp.push( ( matcherIn[ i ] = elem ) ); 8509 } 8510 } 8511 postFinder( null, ( matcherOut = [] ), temp, xml ); 8512 } 8513 8514 // Move matched elements from seed to results to keep them synchronized 8515 i = matcherOut.length; 8516 while ( i-- ) { 8517 if ( ( elem = matcherOut[ i ] ) && 8518 ( temp = postFinder ? indexOf.call( seed, elem ) : preMap[ i ] ) > -1 ) { 8519 8520 seed[ temp ] = !( results[ temp ] = elem ); 8521 } 8522 } 8523 } 8524 8525 // Add elements to results, through postFinder if defined 8526 } else { 8527 matcherOut = condense( 8528 matcherOut === results ? 8529 matcherOut.splice( preexisting, matcherOut.length ) : 8530 matcherOut 8531 ); 8532 if ( postFinder ) { 8533 postFinder( null, results, matcherOut, xml ); 8534 } else { 8535 push.apply( results, matcherOut ); 8536 } 8537 } 8538 } ); 8539} 8540 8541function matcherFromTokens( tokens ) { 8542 var checkContext, matcher, j, 8543 len = tokens.length, 8544 leadingRelative = Expr.relative[ tokens[ 0 ].type ], 8545 implicitRelative = leadingRelative || Expr.relative[ " " ], 8546 i = leadingRelative ? 1 : 0, 8547 8548 // The foundational matcher ensures that elements are reachable from top-level context(s) 8549 matchContext = addCombinator( function( elem ) { 8550 return elem === checkContext; 8551 }, implicitRelative, true ), 8552 matchAnyContext = addCombinator( function( elem ) { 8553 return indexOf.call( checkContext, elem ) > -1; 8554 }, implicitRelative, true ), 8555 matchers = [ function( elem, context, xml ) { 8556 8557 // Support: IE 11+, Edge 17 - 18+ 8558 // IE/Edge sometimes throw a "Permission denied" error when strict-comparing 8559 // two documents; shallow comparisons work. 8560 // eslint-disable-next-line eqeqeq 8561 var ret = ( !leadingRelative && ( xml || context != outermostContext ) ) || ( 8562 ( checkContext = context ).nodeType ? 8563 matchContext( elem, context, xml ) : 8564 matchAnyContext( elem, context, xml ) ); 8565 8566 // Avoid hanging onto element 8567 // (see https://github.com/jquery/sizzle/issues/299) 8568 checkContext = null; 8569 return ret; 8570 } ]; 8571 8572 for ( ; i < len; i++ ) { 8573 if ( ( matcher = Expr.relative[ tokens[ i ].type ] ) ) { 8574 matchers = [ addCombinator( elementMatcher( matchers ), matcher ) ]; 8575 } else { 8576 matcher = Expr.filter[ tokens[ i ].type ].apply( null, tokens[ i ].matches ); 8577 8578 // Return special upon seeing a positional matcher 8579 if ( matcher[ expando ] ) { 8580 8581 // Find the next relative operator (if any) for proper handling 8582 j = ++i; 8583 for ( ; j < len; j++ ) { 8584 if ( Expr.relative[ tokens[ j ].type ] ) { 8585 break; 8586 } 8587 } 8588 return setMatcher( 8589 i > 1 && elementMatcher( matchers ), 8590 i > 1 && toSelector( 8591 8592 // If the preceding token was a descendant combinator, insert an implicit any-element `*` 8593 tokens.slice( 0, i - 1 ) 8594 .concat( { value: tokens[ i - 2 ].type === " " ? "*" : "" } ) 8595 ).replace( rtrimCSS, "$1" ), 8596 matcher, 8597 i < j && matcherFromTokens( tokens.slice( i, j ) ), 8598 j < len && matcherFromTokens( ( tokens = tokens.slice( j ) ) ), 8599 j < len && toSelector( tokens ) 8600 ); 8601 } 8602 matchers.push( matcher ); 8603 } 8604 } 8605 8606 return elementMatcher( matchers ); 8607} 8608 8609function matcherFromGroupMatchers( elementMatchers, setMatchers ) { 8610 var bySet = setMatchers.length > 0, 8611 byElement = elementMatchers.length > 0, 8612 superMatcher = function( seed, context, xml, results, outermost ) { 8613 var elem, j, matcher, 8614 matchedCount = 0, 8615 i = "0", 8616 unmatched = seed && [], 8617 setMatched = [], 8618 contextBackup = outermostContext, 8619 8620 // We must always have either seed elements or outermost context 8621 elems = seed || byElement && Expr.find.TAG( "*", outermost ), 8622 8623 // Use integer dirruns iff this is the outermost matcher 8624 dirrunsUnique = ( dirruns += contextBackup == null ? 1 : Math.random() || 0.1 ), 8625 len = elems.length; 8626 8627 if ( outermost ) { 8628 8629 // Support: IE 11+, Edge 17 - 18+ 8630 // IE/Edge sometimes throw a "Permission denied" error when strict-comparing 8631 // two documents; shallow comparisons work. 8632 // eslint-disable-next-line eqeqeq 8633 outermostContext = context == document || context || outermost; 8634 } 8635 8636 // Add elements passing elementMatchers directly to results 8637 // Support: iOS <=7 - 9 only 8638 // Tolerate NodeList properties (IE: "length"; Safari: <number>) matching 8639 // elements by id. (see trac-14142) 8640 for ( ; i !== len && ( elem = elems[ i ] ) != null; i++ ) { 8641 if ( byElement && elem ) { 8642 j = 0; 8643 8644 // Support: IE 11+, Edge 17 - 18+ 8645 // IE/Edge sometimes throw a "Permission denied" error when strict-comparing 8646 // two documents; shallow comparisons work. 8647 // eslint-disable-next-line eqeqeq 8648 if ( !context && elem.ownerDocument != document ) { 8649 setDocument( elem ); 8650 xml = !documentIsHTML; 8651 } 8652 while ( ( matcher = elementMatchers[ j++ ] ) ) { 8653 if ( matcher( elem, context || document, xml ) ) { 8654 push.call( results, elem ); 8655 break; 8656 } 8657 } 8658 if ( outermost ) { 8659 dirruns = dirrunsUnique; 8660 } 8661 } 8662 8663 // Track unmatched elements for set filters 8664 if ( bySet ) { 8665 8666 // They will have gone through all possible matchers 8667 if ( ( elem = !matcher && elem ) ) { 8668 matchedCount--; 8669 } 8670 8671 // Lengthen the array for every element, matched or not 8672 if ( seed ) { 8673 unmatched.push( elem ); 8674 } 8675 } 8676 } 8677 8678 // `i` is now the count of elements visited above, and adding it to `matchedCount` 8679 // makes the latter nonnegative. 8680 matchedCount += i; 8681 8682 // Apply set filters to unmatched elements 8683 // NOTE: This can be skipped if there are no unmatched elements (i.e., `matchedCount` 8684 // equals `i`), unless we didn't visit _any_ elements in the above loop because we have 8685 // no element matchers and no seed. 8686 // Incrementing an initially-string "0" `i` allows `i` to remain a string only in that 8687 // case, which will result in a "00" `matchedCount` that differs from `i` but is also 8688 // numerically zero. 8689 if ( bySet && i !== matchedCount ) { 8690 j = 0; 8691 while ( ( matcher = setMatchers[ j++ ] ) ) { 8692 matcher( unmatched, setMatched, context, xml ); 8693 } 8694 8695 if ( seed ) { 8696 8697 // Reintegrate element matches to eliminate the need for sorting 8698 if ( matchedCount > 0 ) { 8699 while ( i-- ) { 8700 if ( !( unmatched[ i ] || setMatched[ i ] ) ) { 8701 setMatched[ i ] = pop.call( results ); 8702 } 8703 } 8704 } 8705 8706 // Discard index placeholder values to get only actual matches 8707 setMatched = condense( setMatched ); 8708 } 8709 8710 // Add matches to results 8711 push.apply( results, setMatched ); 8712 8713 // Seedless set matches succeeding multiple successful matchers stipulate sorting 8714 if ( outermost && !seed && setMatched.length > 0 && 8715 ( matchedCount + setMatchers.length ) > 1 ) { 8716 8717 jQuery.uniqueSort( results ); 8718 } 8719 } 8720 8721 // Override manipulation of globals by nested matchers 8722 if ( outermost ) { 8723 dirruns = dirrunsUnique; 8724 outermostContext = contextBackup; 8725 } 8726 8727 return unmatched; 8728 }; 8729 8730 return bySet ? 8731 markFunction( superMatcher ) : 8732 superMatcher; 8733} 8734 8735function compile( selector, match /* Internal Use Only */ ) { 8736 var i, 8737 setMatchers = [], 8738 elementMatchers = [], 8739 cached = compilerCache[ selector + " " ]; 8740 8741 if ( !cached ) { 8742 8743 // Generate a function of recursive functions that can be used to check each element 8744 if ( !match ) { 8745 match = tokenize( selector ); 8746 } 8747 i = match.length; 8748 while ( i-- ) { 8749 cached = matcherFromTokens( match[ i ] ); 8750 if ( cached[ expando ] ) { 8751 setMatchers.push( cached ); 8752 } else { 8753 elementMatchers.push( cached ); 8754 } 8755 } 8756 8757 // Cache the compiled function 8758 cached = compilerCache( selector, 8759 matcherFromGroupMatchers( elementMatchers, setMatchers ) ); 8760 8761 // Save selector and tokenization 8762 cached.selector = selector; 8763 } 8764 return cached; 8765} 8766 8767/** 8768 * A low-level selection function that works with jQuery's compiled 8769 * selector functions 8770 * @param {String|Function} selector A selector or a pre-compiled 8771 * selector function built with jQuery selector compile 8772 * @param {Element} context 8773 * @param {Array} [results] 8774 * @param {Array} [seed] A set of elements to match against 8775 */ 8776function select( selector, context, results, seed ) { 8777 var i, tokens, token, type, find, 8778 compiled = typeof selector === "function" && selector, 8779 match = !seed && tokenize( ( selector = compiled.selector || selector ) ); 8780 8781 results = results || []; 8782 8783 // Try to minimize operations if there is only one selector in the list and no seed 8784 // (the latter of which guarantees us context) 8785 if ( match.length === 1 ) { 8786 8787 // Reduce context if the leading compound selector is an ID 8788 tokens = match[ 0 ] = match[ 0 ].slice( 0 ); 8789 if ( tokens.length > 2 && ( token = tokens[ 0 ] ).type === "ID" && 8790 context.nodeType === 9 && documentIsHTML && Expr.relative[ tokens[ 1 ].type ] ) { 8791 8792 context = ( Expr.find.ID( 8793 token.matches[ 0 ].replace( runescape, funescape ), 8794 context 8795 ) || [] )[ 0 ]; 8796 if ( !context ) { 8797 return results; 8798 8799 // Precompiled matchers will still verify ancestry, so step up a level 8800 } else if ( compiled ) { 8801 context = context.parentNode; 8802 } 8803 8804 selector = selector.slice( tokens.shift().value.length ); 8805 } 8806 8807 // Fetch a seed set for right-to-left matching 8808 i = matchExpr.needsContext.test( selector ) ? 0 : tokens.length; 8809 while ( i-- ) { 8810 token = tokens[ i ]; 8811 8812 // Abort if we hit a combinator 8813 if ( Expr.relative[ ( type = token.type ) ] ) { 8814 break; 8815 } 8816 if ( ( find = Expr.find[ type ] ) ) { 8817 8818 // Search, expanding context for leading sibling combinators 8819 if ( ( seed = find( 8820 token.matches[ 0 ].replace( runescape, funescape ), 8821 rsibling.test( tokens[ 0 ].type ) &&
vendor: 4,497 bytes, lines 8822-9006
8822 testContext( context.parentNode ) || context 8823 ) ) ) { 8824 8825 // If seed is empty or no tokens remain, we can return early 8826 tokens.splice( i, 1 ); 8827 selector = seed.length && toSelector( tokens ); 8828 if ( !selector ) { 8829 push.apply( results, seed ); 8830 return results; 8831 } 8832 8833 break; 8834 } 8835 } 8836 } 8837 } 8838 8839 // Compile and execute a filtering function if one is not provided 8840 // Provide `match` to avoid retokenization if we modified the selector above 8841 ( compiled || compile( selector, match ) )( 8842 seed, 8843 context, 8844 !documentIsHTML, 8845 results, 8846 !context || rsibling.test( selector ) && testContext( context.parentNode ) || context 8847 ); 8848 return results; 8849} 8850 8851// One-time assignments 8852 8853// Support: Android <=4.0 - 4.1+ 8854// Sort stability 8855support.sortStable = expando.split( "" ).sort( sortOrder ).join( "" ) === expando; 8856 8857// Initialize against the default document 8858setDocument(); 8859 8860// Support: Android <=4.0 - 4.1+ 8861// Detached nodes confoundingly follow *each other* 8862support.sortDetached = assert( function( el ) { 8863 8864 // Should return 1, but returns 4 (following) 8865 return el.compareDocumentPosition( document.createElement( "fieldset" ) ) & 1; 8866} ); 8867 8868jQuery.find = find; 8869 8870// Deprecated 8871jQuery.expr[ ":" ] = jQuery.expr.pseudos; 8872jQuery.unique = jQuery.uniqueSort; 8873 8874// These have always been private, but they used to be documented as part of 8875// Sizzle so let's maintain them for now for backwards compatibility purposes. 8876find.compile = compile; 8877find.select = select; 8878find.setDocument = setDocument; 8879find.tokenize = tokenize; 8880 8881find.escape = jQuery.escapeSelector; 8882find.getText = jQuery.text; 8883find.isXML = jQuery.isXMLDoc; 8884find.selectors = jQuery.expr; 8885find.support = jQuery.support; 8886find.uniqueSort = jQuery.uniqueSort; 8887 8888 /* eslint-enable */ 8889 8890} )(); 8891 8892 8893var dir = function( elem, dir, until ) { 8894 var matched = [], 8895 truncate = until !== undefined; 8896 8897 while ( ( elem = elem[ dir ] ) && elem.nodeType !== 9 ) { 8898 if ( elem.nodeType === 1 ) { 8899 if ( truncate && jQuery( elem ).is( until ) ) { 8900 break; 8901 } 8902 matched.push( elem ); 8903 } 8904 } 8905 return matched; 8906}; 8907 8908 8909var siblings = function( n, elem ) { 8910 var matched = []; 8911 8912 for ( ; n; n = n.nextSibling ) { 8913 if ( n.nodeType === 1 && n !== elem ) { 8914 matched.push( n ); 8915 } 8916 } 8917 8918 return matched; 8919}; 8920 8921 8922var rneedsContext = jQuery.expr.match.needsContext; 8923 8924var rsingleTag = ( /^<([a-z][^\/\0>:\x20\t\r\n\f]*)[\x20\t\r\n\f]*\/?>(?:<\/\1>|)$/i ); 8925 8926 8927 8928// Implement the identical functionality for filter and not 8929function winnow( elements, qualifier, not ) { 8930 if ( isFunction( qualifier ) ) { 8931 return jQuery.grep( elements, function( elem, i ) { 8932 return !!qualifier.call( elem, i, elem ) !== not; 8933 } ); 8934 } 8935 8936 // Single element 8937 if ( qualifier.nodeType ) { 8938 return jQuery.grep( elements, function( elem ) { 8939 return ( elem === qualifier ) !== not; 8940 } ); 8941 } 8942 8943 // Arraylike of elements (jQuery, arguments, Array) 8944 if ( typeof qualifier !== "string" ) { 8945 return jQuery.grep( elements, function( elem ) { 8946 return ( indexOf.call( qualifier, elem ) > -1 ) !== not; 8947 } ); 8948 } 8949 8950 // Filtered directly for both simple and complex selectors 8951 return jQuery.filter( qualifier, elements, not ); 8952} 8953 8954jQuery.filter = function( expr, elems, not ) { 8955 var elem = elems[ 0 ]; 8956 8957 if ( not ) { 8958 expr = ":not(" + expr + ")"; 8959 } 8960 8961 if ( elems.length === 1 && elem.nodeType === 1 ) { 8962 return jQuery.find.matchesSelector( elem, expr ) ? [ elem ] : []; 8963 } 8964 8965 return jQuery.find.matches( expr, jQuery.grep( elems, function( elem ) { 8966 return elem.nodeType === 1; 8967 } ) ); 8968}; 8969 8970jQuery.fn.extend( { 8971 find: function( selector ) { 8972 var i, ret, 8973 len = this.length, 8974 self = this; 8975 8976 if ( typeof selector !== "string" ) { 8977 return this.pushStack( jQuery( selector ).filter( function() { 8978 for ( i = 0; i < len; i++ ) { 8979 if ( jQuery.contains( self[ i ], this ) ) { 8980 return true; 8981 } 8982 } 8983 } ) ); 8984 } 8985 8986 ret = this.pushStack( [] ); 8987 8988 for ( i = 0; i < len; i++ ) { 8989 jQuery.find( selector, self[ i ], ret ); 8990 } 8991 8992 return len > 1 ? jQuery.uniqueSort( ret ) : ret; 8993 }, 8994 filter: function( selector ) { 8995 return this.pushStack( winnow( this, selector || [], false ) ); 8996 }, 8997 not: function( selector ) { 8998 return this.pushStack( winnow( this, selector || [], true ) ); 8999 }, 9000 is: function( selector ) { 9001 return !!winnow( 9002 this, 9003 9004 // If this is a positional/relative selector, check membership in the returned set 9005 // so $("p:first").is("p:last") won't return true for a doc with two "p". 9006 typeof selector === "string" && rneedsContext.test( selector ) ?
vendor: 9,941 bytes, lines 9007-9395
9007 jQuery( selector ) : 9008 selector || [], 9009 false 9010 ).length; 9011 } 9012} ); 9013 9014 9015// Initialize a jQuery object 9016 9017 9018// A central reference to the root jQuery(document) 9019var rootjQuery, 9020 9021 // A simple way to check for HTML strings 9022 // Prioritize #id over <tag> to avoid XSS via location.hash (trac-9521) 9023 // Strict HTML recognition (trac-11290: must start with <) 9024 // Shortcut simple #id case for speed 9025 rquickExpr = /^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]+))$/, 9026 9027 init = jQuery.fn.init = function( selector, context, root ) { 9028 var match, elem; 9029 9030 // HANDLE: $(""), $(null), $(undefined), $(false) 9031 if ( !selector ) { 9032 return this; 9033 } 9034 9035 // Method init() accepts an alternate rootjQuery 9036 // so migrate can support jQuery.sub (gh-2101) 9037 root = root || rootjQuery; 9038 9039 // Handle HTML strings 9040 if ( typeof selector === "string" ) { 9041 if ( selector[ 0 ] === "<" && 9042 selector[ selector.length - 1 ] === ">" && 9043 selector.length >= 3 ) { 9044 9045 // Assume that strings that start and end with <> are HTML and skip the regex check 9046 match = [ null, selector, null ]; 9047 9048 } else { 9049 match = rquickExpr.exec( selector ); 9050 } 9051 9052 // Match html or make sure no context is specified for #id 9053 if ( match && ( match[ 1 ] || !context ) ) { 9054 9055 // HANDLE: $(html) -> $(array) 9056 if ( match[ 1 ] ) { 9057 context = context instanceof jQuery ? context[ 0 ] : context; 9058 9059 // Option to run scripts is true for back-compat 9060 // Intentionally let the error be thrown if parseHTML is not present 9061 jQuery.merge( this, jQuery.parseHTML( 9062 match[ 1 ], 9063 context && context.nodeType ? context.ownerDocument || context : document, 9064 true 9065 ) ); 9066 9067 // HANDLE: $(html, props) 9068 if ( rsingleTag.test( match[ 1 ] ) && jQuery.isPlainObject( context ) ) { 9069 for ( match in context ) { 9070 9071 // Properties of context are called as methods if possible 9072 if ( isFunction( this[ match ] ) ) { 9073 this[ match ]( context[ match ] ); 9074 9075 // ...and otherwise set as attributes 9076 } else { 9077 this.attr( match, context[ match ] ); 9078 } 9079 } 9080 } 9081 9082 return this; 9083 9084 // HANDLE: $(#id) 9085 } else { 9086 elem = document.getElementById( match[ 2 ] ); 9087 9088 if ( elem ) { 9089 9090 // Inject the element directly into the jQuery object 9091 this[ 0 ] = elem; 9092 this.length = 1; 9093 } 9094 return this; 9095 } 9096 9097 // HANDLE: $(expr, $(...)) 9098 } else if ( !context || context.jquery ) { 9099 return ( context || root ).find( selector ); 9100 9101 // HANDLE: $(expr, context) 9102 // (which is just equivalent to: $(context).find(expr) 9103 } else { 9104 return this.constructor( context ).find( selector ); 9105 } 9106 9107 // HANDLE: $(DOMElement) 9108 } else if ( selector.nodeType ) { 9109 this[ 0 ] = selector; 9110 this.length = 1; 9111 return this; 9112 9113 // HANDLE: $(function) 9114 // Shortcut for document ready 9115 } else if ( isFunction( selector ) ) { 9116 return root.ready !== undefined ? 9117 root.ready( selector ) : 9118 9119 // Execute immediately if ready is not present 9120 selector( jQuery ); 9121 } 9122 9123 return jQuery.makeArray( selector, this ); 9124 }; 9125 9126// Give the init function the jQuery prototype for later instantiation 9127init.prototype = jQuery.fn; 9128 9129// Initialize central reference 9130rootjQuery = jQuery( document ); 9131 9132 9133var rparentsprev = /^(?:parents|prev(?:Until|All))/, 9134 9135 // Methods guaranteed to produce a unique set when starting from a unique set 9136 guaranteedUnique = { 9137 children: true, 9138 contents: true, 9139 next: true, 9140 prev: true 9141 }; 9142 9143jQuery.fn.extend( { 9144 has: function( target ) { 9145 var targets = jQuery( target, this ), 9146 l = targets.length; 9147 9148 return this.filter( function() { 9149 var i = 0; 9150 for ( ; i < l; i++ ) { 9151 if ( jQuery.contains( this, targets[ i ] ) ) { 9152 return true; 9153 } 9154 } 9155 } ); 9156 }, 9157 9158 closest: function( selectors, context ) { 9159 var cur, 9160 i = 0, 9161 l = this.length, 9162 matched = [], 9163 targets = typeof selectors !== "string" && jQuery( selectors ); 9164 9165 // Positional selectors never match, since there's no _selection_ context 9166 if ( !rneedsContext.test( selectors ) ) { 9167 for ( ; i < l; i++ ) { 9168 for ( cur = this[ i ]; cur && cur !== context; cur = cur.parentNode ) { 9169 9170 // Always skip document fragments 9171 if ( cur.nodeType < 11 && ( targets ? 9172 targets.index( cur ) > -1 : 9173 9174 // Don't pass non-elements to jQuery#find 9175 cur.nodeType === 1 && 9176 jQuery.find.matchesSelector( cur, selectors ) ) ) { 9177 9178 matched.push( cur ); 9179 break; 9180 } 9181 } 9182 } 9183 } 9184 9185 return this.pushStack( matched.length > 1 ? jQuery.uniqueSort( matched ) : matched ); 9186 }, 9187 9188 // Determine the position of an element within the set 9189 index: function( elem ) { 9190 9191 // No argument, return index in parent 9192 if ( !elem ) { 9193 return ( this[ 0 ] && this[ 0 ].parentNode ) ? this.first().prevAll().length : -1; 9194 } 9195 9196 // Index in selector 9197 if ( typeof elem === "string" ) { 9198 return indexOf.call( jQuery( elem ), this[ 0 ] ); 9199 } 9200 9201 // Locate the position of the desired element 9202 return indexOf.call( this, 9203 9204 // If it receives a jQuery object, the first element is used 9205 elem.jquery ? elem[ 0 ] : elem 9206 ); 9207 }, 9208 9209 add: function( selector, context ) { 9210 return this.pushStack( 9211 jQuery.uniqueSort( 9212 jQuery.merge( this.get(), jQuery( selector, context ) ) 9213 ) 9214 ); 9215 }, 9216 9217 addBack: function( selector ) { 9218 return this.add( selector == null ? 9219 this.prevObject : this.prevObject.filter( selector ) 9220 ); 9221 } 9222} ); 9223 9224function sibling( cur, dir ) { 9225 while ( ( cur = cur[ dir ] ) && cur.nodeType !== 1 ) {} 9226 return cur; 9227} 9228 9229jQuery.each( { 9230 parent: function( elem ) { 9231 var parent = elem.parentNode; 9232 return parent && parent.nodeType !== 11 ? parent : null; 9233 }, 9234 parents: function( elem ) { 9235 return dir( elem, "parentNode" ); 9236 }, 9237 parentsUntil: function( elem, _i, until ) { 9238 return dir( elem, "parentNode", until ); 9239 }, 9240 next: function( elem ) { 9241 return sibling( elem, "nextSibling" ); 9242 }, 9243 prev: function( elem ) { 9244 return sibling( elem, "previousSibling" ); 9245 }, 9246 nextAll: function( elem ) { 9247 return dir( elem, "nextSibling" ); 9248 }, 9249 prevAll: function( elem ) { 9250 return dir( elem, "previousSibling" ); 9251 }, 9252 nextUntil: function( elem, _i, until ) { 9253 return dir( elem, "nextSibling", until ); 9254 }, 9255 prevUntil: function( elem, _i, until ) { 9256 return dir( elem, "previousSibling", until ); 9257 }, 9258 siblings: function( elem ) { 9259 return siblings( ( elem.parentNode || {} ).firstChild, elem ); 9260 }, 9261 children: function( elem ) { 9262 return siblings( elem.firstChild ); 9263 }, 9264 contents: function( elem ) { 9265 if ( elem.contentDocument != null && 9266 9267 // Support: IE 11+ 9268 // <object> elements with no `data` attribute has an object 9269 // `contentDocument` with a `null` prototype. 9270 getProto( elem.contentDocument ) ) { 9271 9272 return elem.contentDocument; 9273 } 9274 9275 // Support: IE 9 - 11 only, iOS 7 only, Android Browser <=4.3 only 9276 // Treat the template element as a regular one in browsers that 9277 // don't support it. 9278 if ( nodeName( elem, "template" ) ) { 9279 elem = elem.content || elem; 9280 } 9281 9282 return jQuery.merge( [], elem.childNodes ); 9283 } 9284}, function( name, fn ) { 9285 jQuery.fn[ name ] = function( until, selector ) { 9286 var matched = jQuery.map( this, fn, until ); 9287 9288 if ( name.slice( -5 ) !== "Until" ) { 9289 selector = until; 9290 } 9291 9292 if ( selector && typeof selector === "string" ) { 9293 matched = jQuery.filter( selector, matched ); 9294 } 9295 9296 if ( this.length > 1 ) { 9297 9298 // Remove duplicates 9299 if ( !guaranteedUnique[ name ] ) { 9300 jQuery.uniqueSort( matched ); 9301 } 9302 9303 // Reverse order for parents* and prev-derivatives 9304 if ( rparentsprev.test( name ) ) { 9305 matched.reverse(); 9306 } 9307 } 9308 9309 return this.pushStack( matched ); 9310 }; 9311} ); 9312var rnothtmlwhite = ( /[^\x20\t\r\n\f]+/g ); 9313 9314 9315 9316// Convert String-formatted options into Object-formatted ones 9317function createOptions( options ) { 9318 var object = {}; 9319 jQuery.each( options.match( rnothtmlwhite ) || [], function( _, flag ) { 9320 object[ flag ] = true; 9321 } ); 9322 return object; 9323} 9324 9325/* 9326 * Create a callback list using the following parameters: 9327 * 9328 * options: an optional list of space-separated options that will change how 9329 * the callback list behaves or a more traditional option object 9330 * 9331 * By default a callback list will act like an event callback list and can be 9332 * "fired" multiple times. 9333 * 9334 * Possible options: 9335 * 9336 * once: will ensure the callback list can only be fired once (like a Deferred) 9337 * 9338 * memory: will keep track of previous values and will call any callback added 9339 * after the list has been fired right away with the latest "memorized" 9340 * values (like a Deferred) 9341 * 9342 * unique: will ensure a callback can only be added once (no duplicate in the list) 9343 * 9344 * stopOnFalse: interrupt callings when a callback returns false 9345 * 9346 */ 9347jQuery.Callbacks = function( options ) { 9348 9349 // Convert options from String-formatted to Object-formatted if needed 9350 // (we check in cache first) 9351 options = typeof options === "string" ? 9352 createOptions( options ) : 9353 jQuery.extend( {}, options ); 9354 9355 var // Flag to know if list is currently firing 9356 firing, 9357 9358 // Last fire value for non-forgettable lists 9359 memory, 9360 9361 // Flag to know if list was already fired 9362 fired, 9363 9364 // Flag to prevent firing 9365 locked, 9366 9367 // Actual callback list 9368 list = [], 9369 9370 // Queue of execution data for repeatable lists 9371 queue = [], 9372 9373 // Index of currently firing callback (modified by add/remove as needed) 9374 firingIndex = -1, 9375 9376 // Fire callbacks 9377 fire = function() { 9378 9379 // Enforce single-firing 9380 locked = locked || options.once; 9381 9382 // Execute callbacks for all pending executions, 9383 // respecting firingIndex overrides and runtime changes 9384 fired = firing = true; 9385 for ( ; queue.length; firingIndex = -1 ) { 9386 memory = queue.shift(); 9387 while ( ++firingIndex < list.length ) { 9388 9389 // Run callback and check for early termination 9390 if ( list[ firingIndex ].apply( memory[ 0 ], memory[ 1 ] ) === false && 9391 options.stopOnFalse ) { 9392 9393 // Jump to end and forget the data so .add doesn't re-fire 9394 firingIndex = list.length; 9395 memory = false;
vendor: 4,918 bytes, lines 9396-9605
9396 } 9397 } 9398 } 9399 9400 // Forget the data if we're done with it 9401 if ( !options.memory ) { 9402 memory = false; 9403 } 9404 9405 firing = false; 9406 9407 // Clean up if we're done firing for good 9408 if ( locked ) { 9409 9410 // Keep an empty list if we have data for future add calls 9411 if ( memory ) { 9412 list = []; 9413 9414 // Otherwise, this object is spent 9415 } else { 9416 list = ""; 9417 } 9418 } 9419 }, 9420 9421 // Actual Callbacks object 9422 self = { 9423 9424 // Add a callback or a collection of callbacks to the list 9425 add: function() { 9426 if ( list ) { 9427 9428 // If we have memory from a past run, we should fire after adding 9429 if ( memory && !firing ) { 9430 firingIndex = list.length - 1; 9431 queue.push( memory ); 9432 } 9433 9434 ( function add( args ) { 9435 jQuery.each( args, function( _, arg ) { 9436 if ( isFunction( arg ) ) { 9437 if ( !options.unique || !self.has( arg ) ) { 9438 list.push( arg ); 9439 } 9440 } else if ( arg && arg.length && toType( arg ) !== "string" ) { 9441 9442 // Inspect recursively 9443 add( arg ); 9444 } 9445 } ); 9446 } )( arguments ); 9447 9448 if ( memory && !firing ) { 9449 fire(); 9450 } 9451 } 9452 return this; 9453 }, 9454 9455 // Remove a callback from the list 9456 remove: function() { 9457 jQuery.each( arguments, function( _, arg ) { 9458 var index; 9459 while ( ( index = jQuery.inArray( arg, list, index ) ) > -1 ) { 9460 list.splice( index, 1 ); 9461 9462 // Handle firing indexes 9463 if ( index <= firingIndex ) { 9464 firingIndex--; 9465 } 9466 } 9467 } ); 9468 return this; 9469 }, 9470 9471 // Check if a given callback is in the list. 9472 // If no argument is given, return whether or not list has callbacks attached. 9473 has: function( fn ) { 9474 return fn ? 9475 jQuery.inArray( fn, list ) > -1 : 9476 list.length > 0; 9477 }, 9478 9479 // Remove all callbacks from the list 9480 empty: function() { 9481 if ( list ) { 9482 list = []; 9483 } 9484 return this; 9485 }, 9486 9487 // Disable .fire and .add 9488 // Abort any current/pending executions 9489 // Clear all callbacks and values 9490 disable: function() { 9491 locked = queue = []; 9492 list = memory = ""; 9493 return this; 9494 }, 9495 disabled: function() { 9496 return !list; 9497 }, 9498 9499 // Disable .fire 9500 // Also disable .add unless we have memory (since it would have no effect) 9501 // Abort any pending executions 9502 lock: function() { 9503 locked = queue = []; 9504 if ( !memory && !firing ) { 9505 list = memory = ""; 9506 } 9507 return this; 9508 }, 9509 locked: function() { 9510 return !!locked; 9511 }, 9512 9513 // Call all callbacks with the given context and arguments 9514 fireWith: function( context, args ) { 9515 if ( !locked ) { 9516 args = args || []; 9517 args = [ context, args.slice ? args.slice() : args ]; 9518 queue.push( args ); 9519 if ( !firing ) { 9520 fire(); 9521 } 9522 } 9523 return this; 9524 }, 9525 9526 // Call all the callbacks with the given arguments 9527 fire: function() { 9528 self.fireWith( this, arguments ); 9529 return this; 9530 }, 9531 9532 // To know if the callbacks have already been called at least once 9533 fired: function() { 9534 return !!fired; 9535 } 9536 }; 9537 9538 return self; 9539}; 9540 9541 9542function Identity( v ) { 9543 return v; 9544} 9545function Thrower( ex ) { 9546 throw ex; 9547} 9548 9549function adoptValue( value, resolve, reject, noValue ) { 9550 var method; 9551 9552 try { 9553 9554 // Check for promise aspect first to privilege synchronous behavior 9555 if ( value && isFunction( ( method = value.promise ) ) ) { 9556 method.call( value ).done( resolve ).fail( reject ); 9557 9558 // Other thenables 9559 } else if ( value && isFunction( ( method = value.then ) ) ) { 9560 method.call( value, resolve, reject ); 9561 9562 // Other non-thenables 9563 } else { 9564 9565 // Control `resolve` arguments by letting Array#slice cast boolean `noValue` to integer: 9566 // * false: [ value ].slice( 0 ) => resolve( value ) 9567 // * true: [ value ].slice( 1 ) => resolve() 9568 resolve.apply( undefined, [ value ].slice( noValue ) ); 9569 } 9570 9571 // For Promises/A+, convert exceptions into rejections 9572 // Since jQuery.when doesn't unwrap thenables, we can skip the extra checks appearing in 9573 // Deferred#then to conditionally suppress rejection. 9574 } catch ( value ) { 9575 9576 // Support: Android 4.0 only 9577 // Strict mode functions invoked without .call/.apply get global-object context 9578 reject.apply( undefined, [ value ] ); 9579 } 9580} 9581 9582jQuery.extend( { 9583 9584 Deferred: function( func ) { 9585 var tuples = [ 9586 9587 // action, add listener, callbacks, 9588 // ... .then handlers, argument index, [final state] 9589 [ "notify", "progress", jQuery.Callbacks( "memory" ), 9590 jQuery.Callbacks( "memory" ), 2 ], 9591 [ "resolve", "done", jQuery.Callbacks( "once memory" ), 9592 jQuery.Callbacks( "once memory" ), 0, "resolved" ], 9593 [ "reject", "fail", jQuery.Callbacks( "once memory" ), 9594 jQuery.Callbacks( "once memory" ), 1, "rejected" ] 9595 ], 9596 state = "pending", 9597 promise = { 9598 state: function() { 9599 return state; 9600 }, 9601 always: function() { 9602 deferred.done( arguments ).fail( arguments ); 9603 return this; 9604 }, 9605 "catch": function( fn ) {
vendor: 28,472 bytes, lines 9606-10717
9606 return promise.then( null, fn ); 9607 }, 9608 9609 // Keep pipe for back-compat 9610 pipe: function( /* fnDone, fnFail, fnProgress */ ) { 9611 var fns = arguments; 9612 9613 return jQuery.Deferred( function( newDefer ) { 9614 jQuery.each( tuples, function( _i, tuple ) { 9615 9616 // Map tuples (progress, done, fail) to arguments (done, fail, progress) 9617 var fn = isFunction( fns[ tuple[ 4 ] ] ) && fns[ tuple[ 4 ] ]; 9618 9619 // deferred.progress(function() { bind to newDefer or newDefer.notify }) 9620 // deferred.done(function() { bind to newDefer or newDefer.resolve }) 9621 // deferred.fail(function() { bind to newDefer or newDefer.reject }) 9622 deferred[ tuple[ 1 ] ]( function() { 9623 var returned = fn && fn.apply( this, arguments ); 9624 if ( returned && isFunction( returned.promise ) ) { 9625 returned.promise() 9626 .progress( newDefer.notify ) 9627 .done( newDefer.resolve ) 9628 .fail( newDefer.reject ); 9629 } else { 9630 newDefer[ tuple[ 0 ] + "With" ]( 9631 this, 9632 fn ? [ returned ] : arguments 9633 ); 9634 } 9635 } ); 9636 } ); 9637 fns = null; 9638 } ).promise(); 9639 }, 9640 then: function( onFulfilled, onRejected, onProgress ) { 9641 var maxDepth = 0; 9642 function resolve( depth, deferred, handler, special ) { 9643 return function() { 9644 var that = this, 9645 args = arguments, 9646 mightThrow = function() { 9647 var returned, then; 9648 9649 // Support: Promises/A+ section 2.3.3.3.3 9650 // https://promisesaplus.com/#point-59 9651 // Ignore double-resolution attempts 9652 if ( depth < maxDepth ) { 9653 return; 9654 } 9655 9656 returned = handler.apply( that, args ); 9657 9658 // Support: Promises/A+ section 2.3.1 9659 // https://promisesaplus.com/#point-48 9660 if ( returned === deferred.promise() ) { 9661 throw new TypeError( "Thenable self-resolution" ); 9662 } 9663 9664 // Support: Promises/A+ sections 2.3.3.1, 3.5 9665 // https://promisesaplus.com/#point-54 9666 // https://promisesaplus.com/#point-75 9667 // Retrieve `then` only once 9668 then = returned && 9669 9670 // Support: Promises/A+ section 2.3.4 9671 // https://promisesaplus.com/#point-64 9672 // Only check objects and functions for thenability 9673 ( typeof returned === "object" || 9674 typeof returned === "function" ) && 9675 returned.then; 9676 9677 // Handle a returned thenable 9678 if ( isFunction( then ) ) { 9679 9680 // Special processors (notify) just wait for resolution 9681 if ( special ) { 9682 then.call( 9683 returned, 9684 resolve( maxDepth, deferred, Identity, special ), 9685 resolve( maxDepth, deferred, Thrower, special ) 9686 ); 9687 9688 // Normal processors (resolve) also hook into progress 9689 } else { 9690 9691 // ...and disregard older resolution values 9692 maxDepth++; 9693 9694 then.call( 9695 returned, 9696 resolve( maxDepth, deferred, Identity, special ), 9697 resolve( maxDepth, deferred, Thrower, special ), 9698 resolve( maxDepth, deferred, Identity, 9699 deferred.notifyWith ) 9700 ); 9701 } 9702 9703 // Handle all other returned values 9704 } else { 9705 9706 // Only substitute handlers pass on context 9707 // and multiple values (non-spec behavior) 9708 if ( handler !== Identity ) { 9709 that = undefined; 9710 args = [ returned ]; 9711 } 9712 9713 // Process the value(s) 9714 // Default process is resolve 9715 ( special || deferred.resolveWith )( that, args ); 9716 } 9717 }, 9718 9719 // Only normal processors (resolve) catch and reject exceptions 9720 process = special ? 9721 mightThrow : 9722 function() { 9723 try { 9724 mightThrow(); 9725 } catch ( e ) { 9726 9727 if ( jQuery.Deferred.exceptionHook ) { 9728 jQuery.Deferred.exceptionHook( e, 9729 process.error ); 9730 } 9731 9732 // Support: Promises/A+ section 2.3.3.3.4.1 9733 // https://promisesaplus.com/#point-61 9734 // Ignore post-resolution exceptions 9735 if ( depth + 1 >= maxDepth ) { 9736 9737 // Only substitute handlers pass on context 9738 // and multiple values (non-spec behavior) 9739 if ( handler !== Thrower ) { 9740 that = undefined; 9741 args = [ e ]; 9742 } 9743 9744 deferred.rejectWith( that, args ); 9745 } 9746 } 9747 }; 9748 9749 // Support: Promises/A+ section 2.3.3.3.1 9750 // https://promisesaplus.com/#point-57 9751 // Re-resolve promises immediately to dodge false rejection from 9752 // subsequent errors 9753 if ( depth ) { 9754 process(); 9755 } else { 9756 9757 // Call an optional hook to record the error, in case of exception 9758 // since it's otherwise lost when execution goes async 9759 if ( jQuery.Deferred.getErrorHook ) { 9760 process.error = jQuery.Deferred.getErrorHook(); 9761 9762 // The deprecated alias of the above. While the name suggests 9763 // returning the stack, not an error instance, jQuery just passes 9764 // it directly to `console.warn` so both will work; an instance 9765 // just better cooperates with source maps. 9766 } else if ( jQuery.Deferred.getStackHook ) { 9767 process.error = jQuery.Deferred.getStackHook(); 9768 } 9769 window.setTimeout( process ); 9770 } 9771 }; 9772 } 9773 9774 return jQuery.Deferred( function( newDefer ) { 9775 9776 // progress_handlers.add( ... ) 9777 tuples[ 0 ][ 3 ].add( 9778 resolve( 9779 0, 9780 newDefer, 9781 isFunction( onProgress ) ? 9782 onProgress : 9783 Identity, 9784 newDefer.notifyWith 9785 ) 9786 ); 9787 9788 // fulfilled_handlers.add( ... ) 9789 tuples[ 1 ][ 3 ].add( 9790 resolve( 9791 0, 9792 newDefer, 9793 isFunction( onFulfilled ) ? 9794 onFulfilled : 9795 Identity 9796 ) 9797 ); 9798 9799 // rejected_handlers.add( ... ) 9800 tuples[ 2 ][ 3 ].add( 9801 resolve( 9802 0, 9803 newDefer, 9804 isFunction( onRejected ) ? 9805 onRejected : 9806 Thrower 9807 ) 9808 ); 9809 } ).promise(); 9810 }, 9811 9812 // Get a promise for this deferred 9813 // If obj is provided, the promise aspect is added to the object 9814 promise: function( obj ) { 9815 return obj != null ? jQuery.extend( obj, promise ) : promise; 9816 } 9817 }, 9818 deferred = {}; 9819 9820 // Add list-specific methods 9821 jQuery.each( tuples, function( i, tuple ) { 9822 var list = tuple[ 2 ], 9823 stateString = tuple[ 5 ]; 9824 9825 // promise.progress = list.add 9826 // promise.done = list.add 9827 // promise.fail = list.add 9828 promise[ tuple[ 1 ] ] = list.add; 9829 9830 // Handle state 9831 if ( stateString ) { 9832 list.add( 9833 function() { 9834 9835 // state = "resolved" (i.e., fulfilled) 9836 // state = "rejected" 9837 state = stateString; 9838 }, 9839 9840 // rejected_callbacks.disable 9841 // fulfilled_callbacks.disable 9842 tuples[ 3 - i ][ 2 ].disable, 9843 9844 // rejected_handlers.disable 9845 // fulfilled_handlers.disable 9846 tuples[ 3 - i ][ 3 ].disable, 9847 9848 // progress_callbacks.lock 9849 tuples[ 0 ][ 2 ].lock, 9850 9851 // progress_handlers.lock 9852 tuples[ 0 ][ 3 ].lock 9853 ); 9854 } 9855 9856 // progress_handlers.fire 9857 // fulfilled_handlers.fire 9858 // rejected_handlers.fire 9859 list.add( tuple[ 3 ].fire ); 9860 9861 // deferred.notify = function() { deferred.notifyWith(...) } 9862 // deferred.resolve = function() { deferred.resolveWith(...) } 9863 // deferred.reject = function() { deferred.rejectWith(...) } 9864 deferred[ tuple[ 0 ] ] = function() { 9865 deferred[ tuple[ 0 ] + "With" ]( this === deferred ? undefined : this, arguments ); 9866 return this; 9867 }; 9868 9869 // deferred.notifyWith = list.fireWith 9870 // deferred.resolveWith = list.fireWith 9871 // deferred.rejectWith = list.fireWith 9872 deferred[ tuple[ 0 ] + "With" ] = list.fireWith; 9873 } ); 9874 9875 // Make the deferred a promise 9876 promise.promise( deferred ); 9877 9878 // Call given func if any 9879 if ( func ) { 9880 func.call( deferred, deferred ); 9881 } 9882 9883 // All done! 9884 return deferred; 9885 }, 9886 9887 // Deferred helper 9888 when: function( singleValue ) { 9889 var 9890 9891 // count of uncompleted subordinates 9892 remaining = arguments.length, 9893 9894 // count of unprocessed arguments 9895 i = remaining, 9896 9897 // subordinate fulfillment data 9898 resolveContexts = Array( i ), 9899 resolveValues = slice.call( arguments ), 9900 9901 // the primary Deferred 9902 primary = jQuery.Deferred(), 9903 9904 // subordinate callback factory 9905 updateFunc = function( i ) { 9906 return function( value ) { 9907 resolveContexts[ i ] = this; 9908 resolveValues[ i ] = arguments.length > 1 ? slice.call( arguments ) : value; 9909 if ( !( --remaining ) ) { 9910 primary.resolveWith( resolveContexts, resolveValues ); 9911 } 9912 }; 9913 }; 9914 9915 // Single- and empty arguments are adopted like Promise.resolve 9916 if ( remaining <= 1 ) { 9917 adoptValue( singleValue, primary.done( updateFunc( i ) ).resolve, primary.reject, 9918 !remaining ); 9919 9920 // Use .then() to unwrap secondary thenables (cf. gh-3000) 9921 if ( primary.state() === "pending" || 9922 isFunction( resolveValues[ i ] && resolveValues[ i ].then ) ) { 9923 9924 return primary.then(); 9925 } 9926 } 9927 9928 // Multiple arguments are aggregated like Promise.all array elements 9929 while ( i-- ) { 9930 adoptValue( resolveValues[ i ], updateFunc( i ), primary.reject ); 9931 } 9932 9933 return primary.promise(); 9934 } 9935} ); 9936 9937 9938// These usually indicate a programmer mistake during development, 9939// warn about them ASAP rather than swallowing them by default. 9940var rerrorNames = /^(Eval|Internal|Range|Reference|Syntax|Type|URI)Error$/; 9941 9942// If `jQuery.Deferred.getErrorHook` is defined, `asyncError` is an error 9943// captured before the async barrier to get the original error cause 9944// which may otherwise be hidden. 9945jQuery.Deferred.exceptionHook = function( error, asyncError ) { 9946 9947 // Support: IE 8 - 9 only 9948 // Console exists when dev tools are open, which can happen at any time 9949 if ( window.console && window.console.warn && error && rerrorNames.test( error.name ) ) { 9950 window.console.warn( "jQuery.Deferred exception: " + error.message, 9951 error.stack, asyncError ); 9952 } 9953}; 9954 9955 9956 9957 9958jQuery.readyException = function( error ) { 9959 window.setTimeout( function() { 9960 throw error; 9961 } ); 9962}; 9963 9964 9965 9966 9967// The deferred used on DOM ready 9968var readyList = jQuery.Deferred(); 9969 9970jQuery.fn.ready = function( fn ) { 9971 9972 readyList 9973 .then( fn ) 9974 9975 // Wrap jQuery.readyException in a function so that the lookup 9976 // happens at the time of error handling instead of callback 9977 // registration. 9978 .catch( function( error ) { 9979 jQuery.readyException( error ); 9980 } ); 9981 9982 return this; 9983}; 9984 9985jQuery.extend( { 9986 9987 // Is the DOM ready to be used? Set to true once it occurs. 9988 isReady: false, 9989 9990 // A counter to track how many items to wait for before 9991 // the ready event fires. See trac-6781 9992 readyWait: 1, 9993 9994 // Handle when the DOM is ready 9995 ready: function( wait ) { 9996 9997 // Abort if there are pending holds or we're already ready 9998 if ( wait === true ? --jQuery.readyWait : jQuery.isReady ) { 9999 return; 10000 } 10001 10002 // Remember that the DOM is ready 10003 jQuery.isReady = true; 10004 10005 // If a normal DOM Ready event fired, decrement, and wait if need be 10006 if ( wait !== true && --jQuery.readyWait > 0 ) { 10007 return; 10008 } 10009 10010 // If there are functions bound, to execute 10011 readyList.resolveWith( document, [ jQuery ] ); 10012 } 10013} ); 10014 10015jQuery.ready.then = readyList.then; 10016 10017// The ready event handler and self cleanup method 10018function completed() { 10019 document.removeEventListener( "DOMContentLoaded", completed ); 10020 window.removeEventListener( "load", completed ); 10021 jQuery.ready(); 10022} 10023 10024// Catch cases where $(document).ready() is called 10025// after the browser event has already occurred. 10026// Support: IE <=9 - 10 only 10027// Older IE sometimes signals "interactive" too soon 10028if ( document.readyState === "complete" || 10029 ( document.readyState !== "loading" && !document.documentElement.doScroll ) ) { 10030 10031 // Handle it asynchronously to allow scripts the opportunity to delay ready 10032 window.setTimeout( jQuery.ready ); 10033 10034} else { 10035 10036 // Use the handy event callback 10037 document.addEventListener( "DOMContentLoaded", completed ); 10038 10039 // A fallback to window.onload, that will always work 10040 window.addEventListener( "load", completed ); 10041} 10042 10043 10044 10045 10046// Multifunctional method to get and set values of a collection 10047// The value/s can optionally be executed if it's a function 10048var access = function( elems, fn, key, value, chainable, emptyGet, raw ) { 10049 var i = 0, 10050 len = elems.length, 10051 bulk = key == null; 10052 10053 // Sets many values 10054 if ( toType( key ) === "object" ) { 10055 chainable = true; 10056 for ( i in key ) { 10057 access( elems, fn, i, key[ i ], true, emptyGet, raw ); 10058 } 10059 10060 // Sets one value 10061 } else if ( value !== undefined ) { 10062 chainable = true; 10063 10064 if ( !isFunction( value ) ) { 10065 raw = true; 10066 } 10067 10068 if ( bulk ) { 10069 10070 // Bulk operations run against the entire set 10071 if ( raw ) { 10072 fn.call( elems, value ); 10073 fn = null; 10074 10075 // ...except when executing function values 10076 } else { 10077 bulk = fn; 10078 fn = function( elem, _key, value ) { 10079 return bulk.call( jQuery( elem ), value ); 10080 }; 10081 } 10082 } 10083 10084 if ( fn ) { 10085 for ( ; i < len; i++ ) { 10086 fn( 10087 elems[ i ], key, raw ? 10088 value : 10089 value.call( elems[ i ], i, fn( elems[ i ], key ) ) 10090 ); 10091 } 10092 } 10093 } 10094 10095 if ( chainable ) { 10096 return elems; 10097 } 10098 10099 // Gets 10100 if ( bulk ) { 10101 return fn.call( elems ); 10102 } 10103 10104 return len ? fn( elems[ 0 ], key ) : emptyGet; 10105}; 10106 10107 10108// Matches dashed string for camelizing 10109var rmsPrefix = /^-ms-/, 10110 rdashAlpha = /-([a-z])/g; 10111 10112// Used by camelCase as callback to replace() 10113function fcamelCase( _all, letter ) { 10114 return letter.toUpperCase(); 10115} 10116 10117// Convert dashed to camelCase; used by the css and data modules 10118// Support: IE <=9 - 11, Edge 12 - 15 10119// Microsoft forgot to hump their vendor prefix (trac-9572) 10120function camelCase( string ) { 10121 return string.replace( rmsPrefix, "ms-" ).replace( rdashAlpha, fcamelCase ); 10122} 10123var acceptData = function( owner ) { 10124 10125 // Accepts only: 10126 // - Node 10127 // - Node.ELEMENT_NODE 10128 // - Node.DOCUMENT_NODE 10129 // - Object 10130 // - Any 10131 return owner.nodeType === 1 || owner.nodeType === 9 || !( +owner.nodeType ); 10132}; 10133 10134 10135 10136 10137function Data() { 10138 this.expando = jQuery.expando + Data.uid++; 10139} 10140 10141Data.uid = 1; 10142 10143Data.prototype = { 10144 10145 cache: function( owner ) { 10146 10147 // Check if the owner object already has a cache 10148 var value = owner[ this.expando ]; 10149 10150 // If not, create one 10151 if ( !value ) { 10152 value = {}; 10153 10154 // We can accept data for non-element nodes in modern browsers, 10155 // but we should not, see trac-8335. 10156 // Always return an empty object. 10157 if ( acceptData( owner ) ) { 10158 10159 // If it is a node unlikely to be stringify-ed or looped over 10160 // use plain assignment 10161 if ( owner.nodeType ) { 10162 owner[ this.expando ] = value; 10163 10164 // Otherwise secure it in a non-enumerable property 10165 // configurable must be true to allow the property to be 10166 // deleted when data is removed 10167 } else { 10168 Object.defineProperty( owner, this.expando, { 10169 value: value, 10170 configurable: true 10171 } ); 10172 } 10173 } 10174 } 10175 10176 return value; 10177 }, 10178 set: function( owner, data, value ) { 10179 var prop, 10180 cache = this.cache( owner ); 10181 10182 // Handle: [ owner, key, value ] args 10183 // Always use camelCase key (gh-2257) 10184 if ( typeof data === "string" ) { 10185 cache[ camelCase( data ) ] = value; 10186 10187 // Handle: [ owner, { properties } ] args 10188 } else { 10189 10190 // Copy the properties one-by-one to the cache object 10191 for ( prop in data ) { 10192 cache[ camelCase( prop ) ] = data[ prop ]; 10193 } 10194 } 10195 return cache; 10196 }, 10197 get: function( owner, key ) { 10198 return key === undefined ? 10199 this.cache( owner ) : 10200 10201 // Always use camelCase key (gh-2257) 10202 owner[ this.expando ] && owner[ this.expando ][ camelCase( key ) ]; 10203 }, 10204 access: function( owner, key, value ) { 10205 10206 // In cases where either: 10207 // 10208 // 1. No key was specified 10209 // 2. A string key was specified, but no value provided 10210 // 10211 // Take the "read" path and allow the get method to determine 10212 // which value to return, respectively either: 10213 // 10214 // 1. The entire cache object 10215 // 2. The data stored at the key 10216 // 10217 if ( key === undefined || 10218 ( ( key && typeof key === "string" ) && value === undefined ) ) { 10219 10220 return this.get( owner, key ); 10221 } 10222 10223 // When the key is not a string, or both a key and value 10224 // are specified, set or extend (existing objects) with either: 10225 // 10226 // 1. An object of properties 10227 // 2. A key and value 10228 // 10229 this.set( owner, key, value ); 10230 10231 // Since the "set" path can have two possible entry points 10232 // return the expected data based on which path was taken[*] 10233 return value !== undefined ? value : key; 10234 }, 10235 remove: function( owner, key ) { 10236 var i, 10237 cache = owner[ this.expando ]; 10238 10239 if ( cache === undefined ) { 10240 return; 10241 } 10242 10243 if ( key !== undefined ) { 10244 10245 // Support array or space separated string of keys 10246 if ( Array.isArray( key ) ) { 10247 10248 // If key is an array of keys... 10249 // We always set camelCase keys, so remove that. 10250 key = key.map( camelCase ); 10251 } else { 10252 key = camelCase( key ); 10253 10254 // If a key with the spaces exists, use it. 10255 // Otherwise, create an array by matching non-whitespace 10256 key = key in cache ? 10257 [ key ] : 10258 ( key.match( rnothtmlwhite ) || [] ); 10259 } 10260 10261 i = key.length; 10262 10263 while ( i-- ) { 10264 delete cache[ key[ i ] ]; 10265 } 10266 } 10267 10268 // Remove the expando if there's no more data 10269 if ( key === undefined || jQuery.isEmptyObject( cache ) ) { 10270 10271 // Support: Chrome <=35 - 45 10272 // Webkit & Blink performance suffers when deleting properties 10273 // from DOM nodes, so set to undefined instead 10274 // https://bugs.chromium.org/p/chromium/issues/detail?id=378607 (bug restricted) 10275 if ( owner.nodeType ) { 10276 owner[ this.expando ] = undefined; 10277 } else { 10278 delete owner[ this.expando ]; 10279 } 10280 } 10281 }, 10282 hasData: function( owner ) { 10283 var cache = owner[ this.expando ]; 10284 return cache !== undefined && !jQuery.isEmptyObject( cache ); 10285 } 10286}; 10287var dataPriv = new Data(); 10288 10289var dataUser = new Data(); 10290 10291 10292 10293// Implementation Summary 10294// 10295// 1. Enforce API surface and semantic compatibility with 1.9.x branch 10296// 2. Improve the module's maintainability by reducing the storage 10297// paths to a single mechanism. 10298// 3. Use the same single mechanism to support "private" and "user" data. 10299// 4. _Never_ expose "private" data to user code (TODO: Drop _data, _removeData) 10300// 5. Avoid exposing implementation details on user objects (eg. expando properties) 10301// 6. Provide a clear path for implementation upgrade to WeakMap in 2014 10302 10303var rbrace = /^(?:\{[\w\W]*\}|\[[\w\W]*\])$/, 10304 rmultiDash = /[A-Z]/g; 10305 10306function getData( data ) { 10307 if ( data === "true" ) { 10308 return true; 10309 } 10310 10311 if ( data === "false" ) { 10312 return false; 10313 } 10314 10315 if ( data === "null" ) { 10316 return null; 10317 } 10318 10319 // Only convert to a number if it doesn't change the string 10320 if ( data === +data + "" ) { 10321 return +data; 10322 } 10323 10324 if ( rbrace.test( data ) ) { 10325 return JSON.parse( data ); 10326 } 10327 10328 return data; 10329} 10330 10331function dataAttr( elem, key, data ) { 10332 var name; 10333 10334 // If nothing was found internally, try to fetch any 10335 // data from the HTML5 data-* attribute 10336 if ( data === undefined && elem.nodeType === 1 ) { 10337 name = "data-" + key.replace( rmultiDash, "-$&" ).toLowerCase(); 10338 data = elem.getAttribute( name ); 10339 10340 if ( typeof data === "string" ) { 10341 try { 10342 data = getData( data ); 10343 } catch ( e ) {} 10344 10345 // Make sure we set the data so it isn't changed later 10346 dataUser.set( elem, key, data ); 10347 } else { 10348 data = undefined; 10349 } 10350 } 10351 return data; 10352} 10353 10354jQuery.extend( { 10355 hasData: function( elem ) { 10356 return dataUser.hasData( elem ) || dataPriv.hasData( elem ); 10357 }, 10358 10359 data: function( elem, name, data ) { 10360 return dataUser.access( elem, name, data ); 10361 }, 10362 10363 removeData: function( elem, name ) { 10364 dataUser.remove( elem, name ); 10365 }, 10366 10367 // TODO: Now that all calls to _data and _removeData have been replaced 10368 // with direct calls to dataPriv methods, these can be deprecated. 10369 _data: function( elem, name, data ) { 10370 return dataPriv.access( elem, name, data ); 10371 }, 10372 10373 _removeData: function( elem, name ) { 10374 dataPriv.remove( elem, name ); 10375 } 10376} ); 10377 10378jQuery.fn.extend( { 10379 data: function( key, value ) { 10380 var i, name, data, 10381 elem = this[ 0 ], 10382 attrs = elem && elem.attributes; 10383 10384 // Gets all values 10385 if ( key === undefined ) { 10386 if ( this.length ) { 10387 data = dataUser.get( elem ); 10388 10389 if ( elem.nodeType === 1 && !dataPriv.get( elem, "hasDataAttrs" ) ) { 10390 i = attrs.length; 10391 while ( i-- ) { 10392 10393 // Support: IE 11 only 10394 // The attrs elements can be null (trac-14894) 10395 if ( attrs[ i ] ) { 10396 name = attrs[ i ].name; 10397 if ( name.indexOf( "data-" ) === 0 ) { 10398 name = camelCase( name.slice( 5 ) ); 10399 dataAttr( elem, name, data[ name ] ); 10400 } 10401 } 10402 } 10403 dataPriv.set( elem, "hasDataAttrs", true ); 10404 } 10405 } 10406 10407 return data; 10408 } 10409 10410 // Sets multiple values 10411 if ( typeof key === "object" ) { 10412 return this.each( function() { 10413 dataUser.set( this, key ); 10414 } ); 10415 } 10416 10417 return access( this, function( value ) { 10418 var data; 10419 10420 // The calling jQuery object (element matches) is not empty 10421 // (and therefore has an element appears at this[ 0 ]) and the 10422 // `value` parameter was not undefined. An empty jQuery object 10423 // will result in `undefined` for elem = this[ 0 ] which will 10424 // throw an exception if an attempt to read a data cache is made. 10425 if ( elem && value === undefined ) { 10426 10427 // Attempt to get data from the cache 10428 // The key will always be camelCased in Data 10429 data = dataUser.get( elem, key ); 10430 if ( data !== undefined ) { 10431 return data; 10432 } 10433 10434 // Attempt to "discover" the data in 10435 // HTML5 custom data-* attrs 10436 data = dataAttr( elem, key ); 10437 if ( data !== undefined ) { 10438 return data; 10439 } 10440 10441 // We tried really hard, but the data doesn't exist. 10442 return; 10443 } 10444 10445 // Set the data... 10446 this.each( function() { 10447 10448 // We always store the camelCased key 10449 dataUser.set( this, key, value ); 10450 } ); 10451 }, null, value, arguments.length > 1, null, true ); 10452 }, 10453 10454 removeData: function( key ) { 10455 return this.each( function() { 10456 dataUser.remove( this, key ); 10457 } ); 10458 } 10459} ); 10460 10461 10462jQuery.extend( { 10463 queue: function( elem, type, data ) { 10464 var queue; 10465 10466 if ( elem ) { 10467 type = ( type || "fx" ) + "queue"; 10468 queue = dataPriv.get( elem, type ); 10469 10470 // Speed up dequeue by getting out quickly if this is just a lookup 10471 if ( data ) { 10472 if ( !queue || Array.isArray( data ) ) { 10473 queue = dataPriv.access( elem, type, jQuery.makeArray( data ) ); 10474 } else { 10475 queue.push( data ); 10476 } 10477 } 10478 return queue || []; 10479 } 10480 }, 10481 10482 dequeue: function( elem, type ) { 10483 type = type || "fx"; 10484 10485 var queue = jQuery.queue( elem, type ), 10486 startLength = queue.length, 10487 fn = queue.shift(), 10488 hooks = jQuery._queueHooks( elem, type ), 10489 next = function() { 10490 jQuery.dequeue( elem, type ); 10491 }; 10492 10493 // If the fx queue is dequeued, always remove the progress sentinel 10494 if ( fn === "inprogress" ) { 10495 fn = queue.shift(); 10496 startLength--; 10497 } 10498 10499 if ( fn ) { 10500 10501 // Add a progress sentinel to prevent the fx queue from being 10502 // automatically dequeued 10503 if ( type === "fx" ) { 10504 queue.unshift( "inprogress" ); 10505 } 10506 10507 // Clear up the last queue stop function 10508 delete hooks.stop; 10509 fn.call( elem, next, hooks ); 10510 } 10511 10512 if ( !startLength && hooks ) { 10513 hooks.empty.fire(); 10514 } 10515 }, 10516 10517 // Not public - generate a queueHooks object, or return the current one 10518 _queueHooks: function( elem, type ) { 10519 var key = type + "queueHooks"; 10520 return dataPriv.get( elem, key ) || dataPriv.access( elem, key, { 10521 empty: jQuery.Callbacks( "once memory" ).add( function() { 10522 dataPriv.remove( elem, [ type + "queue", key ] ); 10523 } ) 10524 } ); 10525 } 10526} ); 10527 10528jQuery.fn.extend( { 10529 queue: function( type, data ) { 10530 var setter = 2; 10531 10532 if ( typeof type !== "string" ) { 10533 data = type; 10534 type = "fx"; 10535 setter--; 10536 } 10537 10538 if ( arguments.length < setter ) { 10539 return jQuery.queue( this[ 0 ], type ); 10540 } 10541 10542 return data === undefined ? 10543 this : 10544 this.each( function() { 10545 var queue = jQuery.queue( this, type, data ); 10546 10547 // Ensure a hooks for this queue 10548 jQuery._queueHooks( this, type ); 10549 10550 if ( type === "fx" && queue[ 0 ] !== "inprogress" ) { 10551 jQuery.dequeue( this, type ); 10552 } 10553 } ); 10554 }, 10555 dequeue: function( type ) { 10556 return this.each( function() { 10557 jQuery.dequeue( this, type ); 10558 } ); 10559 }, 10560 clearQueue: function( type ) { 10561 return this.queue( type || "fx", [] ); 10562 }, 10563 10564 // Get a promise resolved when queues of a certain type 10565 // are emptied (fx is the type by default) 10566 promise: function( type, obj ) { 10567 var tmp, 10568 count = 1, 10569 defer = jQuery.Deferred(), 10570 elements = this, 10571 i = this.length, 10572 resolve = function() { 10573 if ( !( --count ) ) { 10574 defer.resolveWith( elements, [ elements ] ); 10575 } 10576 }; 10577 10578 if ( typeof type !== "string" ) { 10579 obj = type; 10580 type = undefined; 10581 } 10582 type = type || "fx"; 10583 10584 while ( i-- ) { 10585 tmp = dataPriv.get( elements[ i ], type + "queueHooks" ); 10586 if ( tmp && tmp.empty ) { 10587 count++; 10588 tmp.empty.add( resolve ); 10589 } 10590 } 10591 resolve(); 10592 return defer.promise( obj ); 10593 } 10594} ); 10595var pnum = ( /[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/ ).source; 10596 10597var rcssNum = new RegExp( "^(?:([+-])=|)(" + pnum + ")([a-z%]*)$", "i" ); 10598 10599 10600var cssExpand = [ "Top", "Right", "Bottom", "Left" ]; 10601 10602var documentElement = document.documentElement; 10603 10604 10605 10606 var isAttached = function( elem ) { 10607 return jQuery.contains( elem.ownerDocument, elem ); 10608 }, 10609 composed = { composed: true }; 10610 10611 // Support: IE 9 - 11+, Edge 12 - 18+, iOS 10.0 - 10.2 only 10612 // Check attachment across shadow DOM boundaries when possible (gh-3504) 10613 // Support: iOS 10.0-10.2 only 10614 // Early iOS 10 versions support `attachShadow` but not `getRootNode`, 10615 // leading to errors. We need to check for `getRootNode`. 10616 if ( documentElement.getRootNode ) { 10617 isAttached = function( elem ) { 10618 return jQuery.contains( elem.ownerDocument, elem ) || 10619 elem.getRootNode( composed ) === elem.ownerDocument; 10620 }; 10621 } 10622var isHiddenWithinTree = function( elem, el ) { 10623 10624 // isHiddenWithinTree might be called from jQuery#filter function; 10625 // in that case, element will be second argument 10626 elem = el || elem; 10627 10628 // Inline style trumps all 10629 return elem.style.display === "none" || 10630 elem.style.display === "" && 10631 10632 // Otherwise, check computed style 10633 // Support: Firefox <=43 - 45 10634 // Disconnected elements can have computed display: none, so first confirm that elem is 10635 // in the document. 10636 isAttached( elem ) && 10637 10638 jQuery.css( elem, "display" ) === "none"; 10639 }; 10640 10641 10642 10643function adjustCSS( elem, prop, valueParts, tween ) { 10644 var adjusted, scale, 10645 maxIterations = 20, 10646 currentValue = tween ? 10647 function() { 10648 return tween.cur(); 10649 } : 10650 function() { 10651 return jQuery.css( elem, prop, "" ); 10652 }, 10653 initial = currentValue(), 10654 unit = valueParts && valueParts[ 3 ] || ( jQuery.cssNumber[ prop ] ? "" : "px" ), 10655 10656 // Starting value computation is required for potential unit mismatches 10657 initialInUnit = elem.nodeType && 10658 ( jQuery.cssNumber[ prop ] || unit !== "px" && +initial ) && 10659 rcssNum.exec( jQuery.css( elem, prop ) ); 10660 10661 if ( initialInUnit && initialInUnit[ 3 ] !== unit ) { 10662 10663 // Support: Firefox <=54 10664 // Halve the iteration target value to prevent interference from CSS upper bounds (gh-2144) 10665 initial = initial / 2; 10666 10667 // Trust units reported by jQuery.css 10668 unit = unit || initialInUnit[ 3 ]; 10669 10670 // Iteratively approximate from a nonzero starting point 10671 initialInUnit = +initial || 1; 10672 10673 while ( maxIterations-- ) { 10674 10675 // Evaluate and update our best guess (doubling guesses that zero out). 10676 // Finish if the scale equals or crosses 1 (making the old*new product non-positive). 10677 jQuery.style( elem, prop, initialInUnit + unit ); 10678 if ( ( 1 - scale ) * ( 1 - ( scale = currentValue() / initial || 0.5 ) ) <= 0 ) { 10679 maxIterations = 0; 10680 } 10681 initialInUnit = initialInUnit / scale; 10682 10683 } 10684 10685 initialInUnit = initialInUnit * 2; 10686 jQuery.style( elem, prop, initialInUnit + unit ); 10687 10688 // Make sure we update the tween properties later on 10689 valueParts = valueParts || []; 10690 } 10691 10692 if ( valueParts ) { 10693 initialInUnit = +initialInUnit || +initial || 0; 10694 10695 // Apply relative offset (+=/-=) if specified 10696 adjusted = valueParts[ 1 ] ? 10697 initialInUnit + ( valueParts[ 1 ] + 1 ) * valueParts[ 2 ] : 10698 +valueParts[ 2 ]; 10699 if ( tween ) { 10700 tween.unit = unit; 10701 tween.start = initialInUnit; 10702 tween.end = adjusted; 10703 } 10704 } 10705 return adjusted; 10706} 10707 10708 10709var defaultDisplayMap = {}; 10710 10711function getDefaultDisplay( elem ) { 10712 var temp, 10713 doc = elem.ownerDocument, 10714 nodeName = elem.nodeName, 10715 display = defaultDisplayMap[ nodeName ]; 10716 10717 if ( display ) {
vendor: 2,317 bytes, lines 10718-10816
10718 return display; 10719 } 10720 10721 temp = doc.body.appendChild( doc.createElement( nodeName ) ); 10722 display = jQuery.css( temp, "display" ); 10723 10724 temp.parentNode.removeChild( temp ); 10725 10726 if ( display === "none" ) { 10727 display = "block"; 10728 } 10729 defaultDisplayMap[ nodeName ] = display; 10730 10731 return display; 10732} 10733 10734function showHide( elements, show ) { 10735 var display, elem, 10736 values = [], 10737 index = 0, 10738 length = elements.length; 10739 10740 // Determine new display value for elements that need to change 10741 for ( ; index < length; index++ ) { 10742 elem = elements[ index ]; 10743 if ( !elem.style ) { 10744 continue; 10745 } 10746 10747 display = elem.style.display; 10748 if ( show ) { 10749 10750 // Since we force visibility upon cascade-hidden elements, an immediate (and slow) 10751 // check is required in this first loop unless we have a nonempty display value (either 10752 // inline or about-to-be-restored) 10753 if ( display === "none" ) { 10754 values[ index ] = dataPriv.get( elem, "display" ) || null; 10755 if ( !values[ index ] ) { 10756 elem.style.display = ""; 10757 } 10758 } 10759 if ( elem.style.display === "" && isHiddenWithinTree( elem ) ) { 10760 values[ index ] = getDefaultDisplay( elem ); 10761 } 10762 } else { 10763 if ( display !== "none" ) { 10764 values[ index ] = "none"; 10765 10766 // Remember what we're overwriting 10767 dataPriv.set( elem, "display", display ); 10768 } 10769 } 10770 } 10771 10772 // Set the display of the elements in a second loop to avoid constant reflow 10773 for ( index = 0; index < length; index++ ) { 10774 if ( values[ index ] != null ) { 10775 elements[ index ].style.display = values[ index ]; 10776 } 10777 } 10778 10779 return elements; 10780} 10781 10782jQuery.fn.extend( { 10783 show: function() { 10784 return showHide( this, true ); 10785 }, 10786 hide: function() { 10787 return showHide( this ); 10788 }, 10789 toggle: function( state ) { 10790 if ( typeof state === "boolean" ) { 10791 return state ? this.show() : this.hide(); 10792 } 10793 10794 return this.each( function() { 10795 if ( isHiddenWithinTree( this ) ) { 10796 jQuery( this ).show(); 10797 } else { 10798 jQuery( this ).hide(); 10799 } 10800 } ); 10801 } 10802} ); 10803var rcheckableType = ( /^(?:checkbox|radio)$/i ); 10804 10805var rtagName = ( /<([a-z][^\/\0>\x20\t\r\n\f]*)/i ); 10806 10807var rscriptType = ( /^$|^module$|\/(?:java|ecma)script/i ); 10808 10809 10810 10811( function() { 10812 var fragment = document.createDocumentFragment(), 10813 div = fragment.appendChild( document.createElement( "div" ) ), 10814 input = document.createElement( "input" ); 10815 10816 // Support: Android 4.0 - 4.3 only
vendor: 10,092 bytes, lines 10817-11201
10817 // Check state lost if the name is set (trac-11217) 10818 // Support: Windows Web Apps (WWA) 10819 // `name` and `type` must use .setAttribute for WWA (trac-14901) 10820 input.setAttribute( "type", "radio" ); 10821 input.setAttribute( "checked", "checked" ); 10822 input.setAttribute( "name", "t" ); 10823 10824 div.appendChild( input ); 10825 10826 // Support: Android <=4.1 only 10827 // Older WebKit doesn't clone checked state correctly in fragments 10828 support.checkClone = div.cloneNode( true ).cloneNode( true ).lastChild.checked; 10829 10830 // Support: IE <=11 only 10831 // Make sure textarea (and checkbox) defaultValue is properly cloned 10832 div.innerHTML = "<textarea>x</textarea>"; 10833 support.noCloneChecked = !!div.cloneNode( true ).lastChild.defaultValue; 10834 10835 // Support: IE <=9 only 10836 // IE <=9 replaces <option> tags with their contents when inserted outside of 10837 // the select element. 10838 div.innerHTML = "<option></option>"; 10839 support.option = !!div.lastChild; 10840} )(); 10841 10842 10843// We have to close these tags to support XHTML (trac-13200) 10844var wrapMap = { 10845 10846 // XHTML parsers do not magically insert elements in the 10847 // same way that tag soup parsers do. So we cannot shorten 10848 // this by omitting <tbody> or other required elements. 10849 thead: [ 1, "<table>", "</table>" ], 10850 col: [ 2, "<table><colgroup>", "</colgroup></table>" ], 10851 tr: [ 2, "<table><tbody>", "</tbody></table>" ], 10852 td: [ 3, "<table><tbody><tr>", "</tr></tbody></table>" ], 10853 10854 _default: [ 0, "", "" ] 10855}; 10856 10857wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead; 10858wrapMap.th = wrapMap.td; 10859 10860// Support: IE <=9 only 10861if ( !support.option ) { 10862 wrapMap.optgroup = wrapMap.option = [ 1, "<select multiple='multiple'>", "</select>" ]; 10863} 10864 10865 10866function getAll( context, tag ) { 10867 10868 // Support: IE <=9 - 11 only 10869 // Use typeof to avoid zero-argument method invocation on host objects (trac-15151) 10870 var ret; 10871 10872 if ( typeof context.getElementsByTagName !== "undefined" ) { 10873 ret = context.getElementsByTagName( tag || "*" ); 10874 10875 } else if ( typeof context.querySelectorAll !== "undefined" ) { 10876 ret = context.querySelectorAll( tag || "*" ); 10877 10878 } else { 10879 ret = []; 10880 } 10881 10882 if ( tag === undefined || tag && nodeName( context, tag ) ) { 10883 return jQuery.merge( [ context ], ret ); 10884 } 10885 10886 return ret; 10887} 10888 10889 10890// Mark scripts as having already been evaluated 10891function setGlobalEval( elems, refElements ) { 10892 var i = 0, 10893 l = elems.length; 10894 10895 for ( ; i < l; i++ ) { 10896 dataPriv.set( 10897 elems[ i ], 10898 "globalEval", 10899 !refElements || dataPriv.get( refElements[ i ], "globalEval" ) 10900 ); 10901 } 10902} 10903 10904 10905var rhtml = /<|&#?\w+;/; 10906 10907function buildFragment( elems, context, scripts, selection, ignored ) { 10908 var elem, tmp, tag, wrap, attached, j, 10909 fragment = context.createDocumentFragment(), 10910 nodes = [], 10911 i = 0, 10912 l = elems.length; 10913 10914 for ( ; i < l; i++ ) { 10915 elem = elems[ i ]; 10916 10917 if ( elem || elem === 0 ) { 10918 10919 // Add nodes directly 10920 if ( toType( elem ) === "object" ) { 10921 10922 // Support: Android <=4.0 only, PhantomJS 1 only 10923 // push.apply(_, arraylike) throws on ancient WebKit 10924 jQuery.merge( nodes, elem.nodeType ? [ elem ] : elem ); 10925 10926 // Convert non-html into a text node 10927 } else if ( !rhtml.test( elem ) ) { 10928 nodes.push( context.createTextNode( elem ) ); 10929 10930 // Convert html into DOM nodes 10931 } else { 10932 tmp = tmp || fragment.appendChild( context.createElement( "div" ) ); 10933 10934 // Deserialize a standard representation 10935 tag = ( rtagName.exec( elem ) || [ "", "" ] )[ 1 ].toLowerCase(); 10936 wrap = wrapMap[ tag ] || wrapMap._default; 10937 tmp.innerHTML = wrap[ 1 ] + jQuery.htmlPrefilter( elem ) + wrap[ 2 ]; 10938 10939 // Descend through wrappers to the right content 10940 j = wrap[ 0 ]; 10941 while ( j-- ) { 10942 tmp = tmp.lastChild; 10943 } 10944 10945 // Support: Android <=4.0 only, PhantomJS 1 only 10946 // push.apply(_, arraylike) throws on ancient WebKit 10947 jQuery.merge( nodes, tmp.childNodes ); 10948 10949 // Remember the top-level container 10950 tmp = fragment.firstChild; 10951 10952 // Ensure the created nodes are orphaned (trac-12392) 10953 tmp.textContent = ""; 10954 } 10955 } 10956 } 10957 10958 // Remove wrapper from fragment 10959 fragment.textContent = ""; 10960 10961 i = 0; 10962 while ( ( elem = nodes[ i++ ] ) ) { 10963 10964 // Skip elements already in the context collection (trac-4087) 10965 if ( selection && jQuery.inArray( elem, selection ) > -1 ) { 10966 if ( ignored ) { 10967 ignored.push( elem ); 10968 } 10969 continue; 10970 } 10971 10972 attached = isAttached( elem ); 10973 10974 // Append to fragment 10975 tmp = getAll( fragment.appendChild( elem ), "script" ); 10976 10977 // Preserve script evaluation history 10978 if ( attached ) { 10979 setGlobalEval( tmp ); 10980 } 10981 10982 // Capture executables 10983 if ( scripts ) { 10984 j = 0; 10985 while ( ( elem = tmp[ j++ ] ) ) { 10986 if ( rscriptType.test( elem.type || "" ) ) { 10987 scripts.push( elem ); 10988 } 10989 } 10990 } 10991 } 10992 10993 return fragment; 10994} 10995 10996 10997var rtypenamespace = /^([^.]*)(?:\.(.+)|)/; 10998 10999function returnTrue() { 11000 return true; 11001} 11002 11003function returnFalse() { 11004 return false; 11005} 11006 11007function on( elem, types, selector, data, fn, one ) { 11008 var origFn, type; 11009 11010 // Types can be a map of types/handlers 11011 if ( typeof types === "object" ) { 11012 11013 // ( types-Object, selector, data ) 11014 if ( typeof selector !== "string" ) { 11015 11016 // ( types-Object, data ) 11017 data = data || selector; 11018 selector = undefined; 11019 } 11020 for ( type in types ) { 11021 on( elem, type, selector, data, types[ type ], one ); 11022 } 11023 return elem; 11024 } 11025 11026 if ( data == null && fn == null ) { 11027 11028 // ( types, fn ) 11029 fn = selector; 11030 data = selector = undefined; 11031 } else if ( fn == null ) { 11032 if ( typeof selector === "string" ) { 11033 11034 // ( types, selector, fn ) 11035 fn = data; 11036 data = undefined; 11037 } else { 11038 11039 // ( types, data, fn ) 11040 fn = data; 11041 data = selector; 11042 selector = undefined; 11043 } 11044 } 11045 if ( fn === false ) { 11046 fn = returnFalse; 11047 } else if ( !fn ) { 11048 return elem; 11049 } 11050 11051 if ( one === 1 ) { 11052 origFn = fn; 11053 fn = function( event ) { 11054 11055 // Can use an empty set, since event contains the info 11056 jQuery().off( event ); 11057 return origFn.apply( this, arguments ); 11058 }; 11059 11060 // Use same guid so caller can remove using origFn 11061 fn.guid = origFn.guid || ( origFn.guid = jQuery.guid++ ); 11062 } 11063 return elem.each( function() { 11064 jQuery.event.add( this, types, fn, data, selector ); 11065 } ); 11066} 11067 11068/* 11069 * Helper functions for managing events -- not part of the public interface. 11070 * Props to Dean Edwards' addEvent library for many of the ideas. 11071 */ 11072jQuery.event = { 11073 11074 global: {}, 11075 11076 add: function( elem, types, handler, data, selector ) { 11077 11078 var handleObjIn, eventHandle, tmp, 11079 events, t, handleObj, 11080 special, handlers, type, namespaces, origType, 11081 elemData = dataPriv.get( elem ); 11082 11083 // Only attach events to objects that accept data 11084 if ( !acceptData( elem ) ) { 11085 return; 11086 } 11087 11088 // Caller can pass in an object of custom data in lieu of the handler 11089 if ( handler.handler ) { 11090 handleObjIn = handler; 11091 handler = handleObjIn.handler; 11092 selector = handleObjIn.selector; 11093 } 11094 11095 // Ensure that invalid selectors throw exceptions at attach time 11096 // Evaluate against documentElement in case elem is a non-element node (e.g., document) 11097 if ( selector ) { 11098 jQuery.find.matchesSelector( documentElement, selector ); 11099 } 11100 11101 // Make sure that the handler has a unique ID, used to find/remove it later 11102 if ( !handler.guid ) { 11103 handler.guid = jQuery.guid++; 11104 } 11105 11106 // Init the element's event structure and main handler, if this is the first 11107 if ( !( events = elemData.events ) ) { 11108 events = elemData.events = Object.create( null ); 11109 } 11110 if ( !( eventHandle = elemData.handle ) ) { 11111 eventHandle = elemData.handle = function( e ) { 11112 11113 // Discard the second event of a jQuery.event.trigger() and 11114 // when an event is called after a page has unloaded 11115 return typeof jQuery !== "undefined" && jQuery.event.triggered !== e.type ? 11116 jQuery.event.dispatch.apply( elem, arguments ) : undefined; 11117 }; 11118 } 11119 11120 // Handle multiple events separated by a space 11121 types = ( types || "" ).match( rnothtmlwhite ) || [ "" ]; 11122 t = types.length; 11123 while ( t-- ) { 11124 tmp = rtypenamespace.exec( types[ t ] ) || []; 11125 type = origType = tmp[ 1 ]; 11126 namespaces = ( tmp[ 2 ] || "" ).split( "." ).sort(); 11127 11128 // There *must* be a type, no attaching namespace-only handlers 11129 if ( !type ) { 11130 continue; 11131 } 11132 11133 // If event changes its type, use the special event handlers for the changed type 11134 special = jQuery.event.special[ type ] || {}; 11135 11136 // If selector defined, determine special event api type, otherwise given type 11137 type = ( selector ? special.delegateType : special.bindType ) || type; 11138 11139 // Update special based on newly reset type 11140 special = jQuery.event.special[ type ] || {}; 11141 11142 // handleObj is passed to all event handlers 11143 handleObj = jQuery.extend( { 11144 type: type, 11145 origType: origType, 11146 data: data, 11147 handler: handler, 11148 guid: handler.guid, 11149 selector: selector, 11150 needsContext: selector && jQuery.expr.match.needsContext.test( selector ), 11151 namespace: namespaces.join( "." ) 11152 }, handleObjIn ); 11153 11154 // Init the event handler queue if we're the first 11155 if ( !( handlers = events[ type ] ) ) { 11156 handlers = events[ type ] = []; 11157 handlers.delegateCount = 0; 11158 11159 // Only use addEventListener if the special events handler returns false 11160 if ( !special.setup || 11161 special.setup.call( elem, data, namespaces, eventHandle ) === false ) { 11162 11163 if ( elem.addEventListener ) { 11164 elem.addEventListener( type, eventHandle ); 11165 } 11166 } 11167 } 11168 11169 if ( special.add ) { 11170 special.add.call( elem, handleObj ); 11171 11172 if ( !handleObj.handler.guid ) { 11173 handleObj.handler.guid = handler.guid; 11174 } 11175 } 11176 11177 // Add to the element's handler list, delegates in front 11178 if ( selector ) { 11179 handlers.splice( handlers.delegateCount++, 0, handleObj ); 11180 } else { 11181 handlers.push( handleObj ); 11182 } 11183 11184 // Keep track of which events have ever been used, for event optimization 11185 jQuery.event.global[ type ] = true; 11186 } 11187 11188 }, 11189 11190 // Detach an event or set of events from an element 11191 remove: function( elem, types, handler, selector, mappedTypes ) { 11192 11193 var j, origCount, tmp, 11194 events, t, handleObj, 11195 special, handlers, type, namespaces, origType, 11196 elemData = dataPriv.hasData( elem ) && dataPriv.get( elem ); 11197 11198 if ( !elemData || !( events = elemData.events ) ) { 11199 return; 11200 } 11201
vendor: 4,197 bytes, lines 11202-11340
11202 // Once for each type.namespace in types; type may be omitted 11203 types = ( types || "" ).match( rnothtmlwhite ) || [ "" ]; 11204 t = types.length; 11205 while ( t-- ) { 11206 tmp = rtypenamespace.exec( types[ t ] ) || []; 11207 type = origType = tmp[ 1 ]; 11208 namespaces = ( tmp[ 2 ] || "" ).split( "." ).sort(); 11209 11210 // Unbind all events (on this namespace, if provided) for the element 11211 if ( !type ) { 11212 for ( type in events ) { 11213 jQuery.event.remove( elem, type + types[ t ], handler, selector, true ); 11214 } 11215 continue; 11216 } 11217 11218 special = jQuery.event.special[ type ] || {}; 11219 type = ( selector ? special.delegateType : special.bindType ) || type; 11220 handlers = events[ type ] || []; 11221 tmp = tmp[ 2 ] && 11222 new RegExp( "(^|\\.)" + namespaces.join( "\\.(?:.*\\.|)" ) + "(\\.|$)" ); 11223 11224 // Remove matching events 11225 origCount = j = handlers.length; 11226 while ( j-- ) { 11227 handleObj = handlers[ j ]; 11228 11229 if ( ( mappedTypes || origType === handleObj.origType ) && 11230 ( !handler || handler.guid === handleObj.guid ) && 11231 ( !tmp || tmp.test( handleObj.namespace ) ) && 11232 ( !selector || selector === handleObj.selector || 11233 selector === "**" && handleObj.selector ) ) { 11234 handlers.splice( j, 1 ); 11235 11236 if ( handleObj.selector ) { 11237 handlers.delegateCount--; 11238 } 11239 if ( special.remove ) { 11240 special.remove.call( elem, handleObj ); 11241 } 11242 } 11243 } 11244 11245 // Remove generic event handler if we removed something and no more handlers exist 11246 // (avoids potential for endless recursion during removal of special event handlers) 11247 if ( origCount && !handlers.length ) { 11248 if ( !special.teardown || 11249 special.teardown.call( elem, namespaces, elemData.handle ) === false ) { 11250 11251 jQuery.removeEvent( elem, type, elemData.handle ); 11252 } 11253 11254 delete events[ type ]; 11255 } 11256 } 11257 11258 // Remove data and the expando if it's no longer used 11259 if ( jQuery.isEmptyObject( events ) ) { 11260 dataPriv.remove( elem, "handle events" ); 11261 } 11262 }, 11263 11264 dispatch: function( nativeEvent ) { 11265 11266 var i, j, ret, matched, handleObj, handlerQueue, 11267 args = new Array( arguments.length ), 11268 11269 // Make a writable jQuery.Event from the native event object 11270 event = jQuery.event.fix( nativeEvent ), 11271 11272 handlers = ( 11273 dataPriv.get( this, "events" ) || Object.create( null ) 11274 )[ event.type ] || [], 11275 special = jQuery.event.special[ event.type ] || {}; 11276 11277 // Use the fix-ed jQuery.Event rather than the (read-only) native event 11278 args[ 0 ] = event; 11279 11280 for ( i = 1; i < arguments.length; i++ ) { 11281 args[ i ] = arguments[ i ]; 11282 } 11283 11284 event.delegateTarget = this; 11285 11286 // Call the preDispatch hook for the mapped type, and let it bail if desired 11287 if ( special.preDispatch && special.preDispatch.call( this, event ) === false ) { 11288 return; 11289 } 11290 11291 // Determine handlers 11292 handlerQueue = jQuery.event.handlers.call( this, event, handlers ); 11293 11294 // Run delegates first; they may want to stop propagation beneath us 11295 i = 0; 11296 while ( ( matched = handlerQueue[ i++ ] ) && !event.isPropagationStopped() ) { 11297 event.currentTarget = matched.elem; 11298 11299 j = 0; 11300 while ( ( handleObj = matched.handlers[ j++ ] ) && 11301 !event.isImmediatePropagationStopped() ) { 11302 11303 // If the event is namespaced, then each handler is only invoked if it is 11304 // specially universal or its namespaces are a superset of the event's. 11305 if ( !event.rnamespace || handleObj.namespace === false || 11306 event.rnamespace.test( handleObj.namespace ) ) { 11307 11308 event.handleObj = handleObj; 11309 event.data = handleObj.data; 11310 11311 ret = ( ( jQuery.event.special[ handleObj.origType ] || {} ).handle || 11312 handleObj.handler ).apply( matched.elem, args ); 11313 11314 if ( ret !== undefined ) { 11315 if ( ( event.result = ret ) === false ) { 11316 event.preventDefault(); 11317 event.stopPropagation(); 11318 } 11319 } 11320 } 11321 } 11322 } 11323 11324 // Call the postDispatch hook for the mapped type 11325 if ( special.postDispatch ) { 11326 special.postDispatch.call( this, event ); 11327 } 11328 11329 return event.result; 11330 }, 11331 11332 handlers: function( event, handlers ) { 11333 var i, handleObj, sel, matchedHandlers, matchedSelectors, 11334 handlerQueue = [], 11335 delegateCount = handlers.delegateCount, 11336 cur = event.target; 11337 11338 // Find delegate handlers 11339 if ( delegateCount && 11340
vendor: 19,034 bytes, lines 11341-11987
11341 // Support: IE <=9 11342 // Black-hole SVG <use> instance trees (trac-13180) 11343 cur.nodeType && 11344 11345 // Support: Firefox <=42 11346 // Suppress spec-violating clicks indicating a non-primary pointer button (trac-3861) 11347 // https://www.w3.org/TR/DOM-Level-3-Events/#event-type-click 11348 // Support: IE 11 only 11349 // ...but not arrow key "clicks" of radio inputs, which can have `button` -1 (gh-2343) 11350 !( event.type === "click" && event.button >= 1 ) ) { 11351 11352 for ( ; cur !== this; cur = cur.parentNode || this ) { 11353 11354 // Don't check non-elements (trac-13208) 11355 // Don't process clicks on disabled elements (trac-6911, trac-8165, trac-11382, trac-11764) 11356 if ( cur.nodeType === 1 && !( event.type === "click" && cur.disabled === true ) ) { 11357 matchedHandlers = []; 11358 matchedSelectors = {}; 11359 for ( i = 0; i < delegateCount; i++ ) { 11360 handleObj = handlers[ i ]; 11361 11362 // Don't conflict with Object.prototype properties (trac-13203) 11363 sel = handleObj.selector + " "; 11364 11365 if ( matchedSelectors[ sel ] === undefined ) { 11366 matchedSelectors[ sel ] = handleObj.needsContext ? 11367 jQuery( sel, this ).index( cur ) > -1 : 11368 jQuery.find( sel, this, null, [ cur ] ).length; 11369 } 11370 if ( matchedSelectors[ sel ] ) { 11371 matchedHandlers.push( handleObj ); 11372 } 11373 } 11374 if ( matchedHandlers.length ) { 11375 handlerQueue.push( { elem: cur, handlers: matchedHandlers } ); 11376 } 11377 } 11378 } 11379 } 11380 11381 // Add the remaining (directly-bound) handlers 11382 cur = this; 11383 if ( delegateCount < handlers.length ) { 11384 handlerQueue.push( { elem: cur, handlers: handlers.slice( delegateCount ) } ); 11385 } 11386 11387 return handlerQueue; 11388 }, 11389 11390 addProp: function( name, hook ) { 11391 Object.defineProperty( jQuery.Event.prototype, name, { 11392 enumerable: true, 11393 configurable: true, 11394 11395 get: isFunction( hook ) ? 11396 function() { 11397 if ( this.originalEvent ) { 11398 return hook( this.originalEvent ); 11399 } 11400 } : 11401 function() { 11402 if ( this.originalEvent ) { 11403 return this.originalEvent[ name ]; 11404 } 11405 }, 11406 11407 set: function( value ) { 11408 Object.defineProperty( this, name, { 11409 enumerable: true, 11410 configurable: true, 11411 writable: true, 11412 value: value 11413 } ); 11414 } 11415 } ); 11416 }, 11417 11418 fix: function( originalEvent ) { 11419 return originalEvent[ jQuery.expando ] ? 11420 originalEvent : 11421 new jQuery.Event( originalEvent ); 11422 }, 11423 11424 special: { 11425 load: { 11426 11427 // Prevent triggered image.load events from bubbling to window.load 11428 noBubble: true 11429 }, 11430 click: { 11431 11432 // Utilize native event to ensure correct state for checkable inputs 11433 setup: function( data ) { 11434 11435 // For mutual compressibility with _default, replace `this` access with a local var. 11436 // `|| data` is dead code meant only to preserve the variable through minification. 11437 var el = this || data; 11438 11439 // Claim the first handler 11440 if ( rcheckableType.test( el.type ) && 11441 el.click && nodeName( el, "input" ) ) { 11442 11443 // dataPriv.set( el, "click", ... ) 11444 leverageNative( el, "click", true ); 11445 } 11446 11447 // Return false to allow normal processing in the caller 11448 return false; 11449 }, 11450 trigger: function( data ) { 11451 11452 // For mutual compressibility with _default, replace `this` access with a local var. 11453 // `|| data` is dead code meant only to preserve the variable through minification. 11454 var el = this || data; 11455 11456 // Force setup before triggering a click 11457 if ( rcheckableType.test( el.type ) && 11458 el.click && nodeName( el, "input" ) ) { 11459 11460 leverageNative( el, "click" ); 11461 } 11462 11463 // Return non-false to allow normal event-path propagation 11464 return true; 11465 }, 11466 11467 // For cross-browser consistency, suppress native .click() on links 11468 // Also prevent it if we're currently inside a leveraged native-event stack 11469 _default: function( event ) { 11470 var target = event.target; 11471 return rcheckableType.test( target.type ) && 11472 target.click && nodeName( target, "input" ) && 11473 dataPriv.get( target, "click" ) || 11474 nodeName( target, "a" ); 11475 } 11476 }, 11477 11478 beforeunload: { 11479 postDispatch: function( event ) { 11480 11481 // Support: Firefox 20+ 11482 // Firefox doesn't alert if the returnValue field is not set. 11483 if ( event.result !== undefined && event.originalEvent ) { 11484 event.originalEvent.returnValue = event.result; 11485 } 11486 } 11487 } 11488 } 11489}; 11490 11491// Ensure the presence of an event listener that handles manually-triggered 11492// synthetic events by interrupting progress until reinvoked in response to 11493// *native* events that it fires directly, ensuring that state changes have 11494// already occurred before other listeners are invoked. 11495function leverageNative( el, type, isSetup ) { 11496 11497 // Missing `isSetup` indicates a trigger call, which must force setup through jQuery.event.add 11498 if ( !isSetup ) { 11499 if ( dataPriv.get( el, type ) === undefined ) { 11500 jQuery.event.add( el, type, returnTrue ); 11501 } 11502 return; 11503 } 11504 11505 // Register the controller as a special universal handler for all event namespaces 11506 dataPriv.set( el, type, false ); 11507 jQuery.event.add( el, type, { 11508 namespace: false, 11509 handler: function( event ) { 11510 var result, 11511 saved = dataPriv.get( this, type ); 11512 11513 if ( ( event.isTrigger & 1 ) && this[ type ] ) { 11514 11515 // Interrupt processing of the outer synthetic .trigger()ed event 11516 if ( !saved ) { 11517 11518 // Store arguments for use when handling the inner native event 11519 // There will always be at least one argument (an event object), so this array 11520 // will not be confused with a leftover capture object. 11521 saved = slice.call( arguments ); 11522 dataPriv.set( this, type, saved ); 11523 11524 // Trigger the native event and capture its result 11525 this[ type ](); 11526 result = dataPriv.get( this, type ); 11527 dataPriv.set( this, type, false ); 11528 11529 if ( saved !== result ) { 11530 11531 // Cancel the outer synthetic event 11532 event.stopImmediatePropagation(); 11533 event.preventDefault(); 11534 11535 return result; 11536 } 11537 11538 // If this is an inner synthetic event for an event with a bubbling surrogate 11539 // (focus or blur), assume that the surrogate already propagated from triggering 11540 // the native event and prevent that from happening again here. 11541 // This technically gets the ordering wrong w.r.t. to `.trigger()` (in which the 11542 // bubbling surrogate propagates *after* the non-bubbling base), but that seems 11543 // less bad than duplication. 11544 } else if ( ( jQuery.event.special[ type ] || {} ).delegateType ) { 11545 event.stopPropagation(); 11546 } 11547 11548 // If this is a native event triggered above, everything is now in order 11549 // Fire an inner synthetic event with the original arguments 11550 } else if ( saved ) { 11551 11552 // ...and capture the result 11553 dataPriv.set( this, type, jQuery.event.trigger( 11554 saved[ 0 ], 11555 saved.slice( 1 ), 11556 this 11557 ) ); 11558 11559 // Abort handling of the native event by all jQuery handlers while allowing 11560 // native handlers on the same element to run. On target, this is achieved 11561 // by stopping immediate propagation just on the jQuery event. However, 11562 // the native event is re-wrapped by a jQuery one on each level of the 11563 // propagation so the only way to stop it for jQuery is to stop it for 11564 // everyone via native `stopPropagation()`. This is not a problem for 11565 // focus/blur which don't bubble, but it does also stop click on checkboxes 11566 // and radios. We accept this limitation. 11567 event.stopPropagation(); 11568 event.isImmediatePropagationStopped = returnTrue; 11569 } 11570 } 11571 } ); 11572} 11573 11574jQuery.removeEvent = function( elem, type, handle ) { 11575 11576 // This "if" is needed for plain objects 11577 if ( elem.removeEventListener ) { 11578 elem.removeEventListener( type, handle ); 11579 } 11580}; 11581 11582jQuery.Event = function( src, props ) { 11583 11584 // Allow instantiation without the 'new' keyword 11585 if ( !( this instanceof jQuery.Event ) ) { 11586 return new jQuery.Event( src, props ); 11587 } 11588 11589 // Event object 11590 if ( src && src.type ) { 11591 this.originalEvent = src; 11592 this.type = src.type; 11593 11594 // Events bubbling up the document may have been marked as prevented 11595 // by a handler lower down the tree; reflect the correct value. 11596 this.isDefaultPrevented = src.defaultPrevented || 11597 src.defaultPrevented === undefined && 11598 11599 // Support: Android <=2.3 only 11600 src.returnValue === false ? 11601 returnTrue : 11602 returnFalse; 11603 11604 // Create target properties 11605 // Support: Safari <=6 - 7 only 11606 // Target should not be a text node (trac-504, trac-13143) 11607 this.target = ( src.target && src.target.nodeType === 3 ) ? 11608 src.target.parentNode : 11609 src.target; 11610 11611 this.currentTarget = src.currentTarget; 11612 this.relatedTarget = src.relatedTarget; 11613 11614 // Event type 11615 } else { 11616 this.type = src; 11617 } 11618 11619 // Put explicitly provided properties onto the event object 11620 if ( props ) { 11621 jQuery.extend( this, props ); 11622 } 11623 11624 // Create a timestamp if incoming event doesn't have one 11625 this.timeStamp = src && src.timeStamp || Date.now(); 11626 11627 // Mark it as fixed 11628 this[ jQuery.expando ] = true; 11629}; 11630 11631// jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding 11632// https://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html 11633jQuery.Event.prototype = { 11634 constructor: jQuery.Event, 11635 isDefaultPrevented: returnFalse, 11636 isPropagationStopped: returnFalse, 11637 isImmediatePropagationStopped: returnFalse, 11638 isSimulated: false, 11639 11640 preventDefault: function() { 11641 var e = this.originalEvent; 11642 11643 this.isDefaultPrevented = returnTrue; 11644 11645 if ( e && !this.isSimulated ) { 11646 e.preventDefault(); 11647 } 11648 }, 11649 stopPropagation: function() { 11650 var e = this.originalEvent; 11651 11652 this.isPropagationStopped = returnTrue; 11653 11654 if ( e && !this.isSimulated ) { 11655 e.stopPropagation(); 11656 } 11657 }, 11658 stopImmediatePropagation: function() { 11659 var e = this.originalEvent; 11660 11661 this.isImmediatePropagationStopped = returnTrue; 11662 11663 if ( e && !this.isSimulated ) { 11664 e.stopImmediatePropagation(); 11665 } 11666 11667 this.stopPropagation(); 11668 } 11669}; 11670 11671// Includes all common event props including KeyEvent and MouseEvent specific props 11672jQuery.each( { 11673 altKey: true, 11674 bubbles: true, 11675 cancelable: true, 11676 changedTouches: true, 11677 ctrlKey: true, 11678 detail: true, 11679 eventPhase: true, 11680 metaKey: true, 11681 pageX: true, 11682 pageY: true, 11683 shiftKey: true, 11684 view: true, 11685 "char": true, 11686 code: true, 11687 charCode: true, 11688 key: true, 11689 keyCode: true, 11690 button: true, 11691 buttons: true, 11692 clientX: true, 11693 clientY: true, 11694 offsetX: true, 11695 offsetY: true, 11696 pointerId: true, 11697 pointerType: true, 11698 screenX: true, 11699 screenY: true, 11700 targetTouches: true, 11701 toElement: true, 11702 touches: true, 11703 which: true 11704}, jQuery.event.addProp ); 11705 11706jQuery.each( { focus: "focusin", blur: "focusout" }, function( type, delegateType ) { 11707 11708 function focusMappedHandler( nativeEvent ) { 11709 if ( document.documentMode ) { 11710 11711 // Support: IE 11+ 11712 // Attach a single focusin/focusout handler on the document while someone wants 11713 // focus/blur. This is because the former are synchronous in IE while the latter 11714 // are async. In other browsers, all those handlers are invoked synchronously. 11715 11716 // `handle` from private data would already wrap the event, but we need 11717 // to change the `type` here. 11718 var handle = dataPriv.get( this, "handle" ), 11719 event = jQuery.event.fix( nativeEvent ); 11720 event.type = nativeEvent.type === "focusin" ? "focus" : "blur"; 11721 event.isSimulated = true; 11722 11723 // First, handle focusin/focusout 11724 handle( nativeEvent ); 11725 11726 // ...then, handle focus/blur 11727 // 11728 // focus/blur don't bubble while focusin/focusout do; simulate the former by only 11729 // invoking the handler at the lower level. 11730 if ( event.target === event.currentTarget ) { 11731 11732 // The setup part calls `leverageNative`, which, in turn, calls 11733 // `jQuery.event.add`, so event handle will already have been set 11734 // by this point. 11735 handle( event ); 11736 } 11737 } else { 11738 11739 // For non-IE browsers, attach a single capturing handler on the document 11740 // while someone wants focusin/focusout. 11741 jQuery.event.simulate( delegateType, nativeEvent.target, 11742 jQuery.event.fix( nativeEvent ) ); 11743 } 11744 } 11745 11746 jQuery.event.special[ type ] = { 11747 11748 // Utilize native event if possible so blur/focus sequence is correct 11749 setup: function() { 11750 11751 var attaches; 11752 11753 // Claim the first handler 11754 // dataPriv.set( this, "focus", ... ) 11755 // dataPriv.set( this, "blur", ... ) 11756 leverageNative( this, type, true ); 11757 11758 if ( document.documentMode ) { 11759 11760 // Support: IE 9 - 11+ 11761 // We use the same native handler for focusin & focus (and focusout & blur) 11762 // so we need to coordinate setup & teardown parts between those events. 11763 // Use `delegateType` as the key as `type` is already used by `leverageNative`. 11764 attaches = dataPriv.get( this, delegateType ); 11765 if ( !attaches ) { 11766 this.addEventListener( delegateType, focusMappedHandler ); 11767 } 11768 dataPriv.set( this, delegateType, ( attaches || 0 ) + 1 ); 11769 } else { 11770 11771 // Return false to allow normal processing in the caller 11772 return false; 11773 } 11774 }, 11775 trigger: function() { 11776 11777 // Force setup before trigger 11778 leverageNative( this, type ); 11779 11780 // Return non-false to allow normal event-path propagation 11781 return true; 11782 }, 11783 11784 teardown: function() { 11785 var attaches; 11786 11787 if ( document.documentMode ) { 11788 attaches = dataPriv.get( this, delegateType ) - 1; 11789 if ( !attaches ) { 11790 this.removeEventListener( delegateType, focusMappedHandler ); 11791 dataPriv.remove( this, delegateType ); 11792 } else { 11793 dataPriv.set( this, delegateType, attaches ); 11794 } 11795 } else { 11796 11797 // Return false to indicate standard teardown should be applied 11798 return false; 11799 } 11800 }, 11801 11802 // Suppress native focus or blur if we're currently inside 11803 // a leveraged native-event stack 11804 _default: function( event ) { 11805 return dataPriv.get( event.target, type ); 11806 }, 11807 11808 delegateType: delegateType 11809 }; 11810 11811 // Support: Firefox <=44 11812 // Firefox doesn't have focus(in | out) events 11813 // Related ticket - https://bugzilla.mozilla.org/show_bug.cgi?id=687787 11814 // 11815 // Support: Chrome <=48 - 49, Safari <=9.0 - 9.1 11816 // focus(in | out) events fire after focus & blur events, 11817 // which is spec violation - http://www.w3.org/TR/DOM-Level-3-Events/#events-focusevent-event-order 11818 // Related ticket - https://bugs.chromium.org/p/chromium/issues/detail?id=449857 11819 // 11820 // Support: IE 9 - 11+ 11821 // To preserve relative focusin/focus & focusout/blur event order guaranteed on the 3.x branch, 11822 // attach a single handler for both events in IE. 11823 jQuery.event.special[ delegateType ] = { 11824 setup: function() { 11825 11826 // Handle: regular nodes (via `this.ownerDocument`), window 11827 // (via `this.document`) & document (via `this`). 11828 var doc = this.ownerDocument || this.document || this, 11829 dataHolder = document.documentMode ? this : doc, 11830 attaches = dataPriv.get( dataHolder, delegateType ); 11831 11832 // Support: IE 9 - 11+ 11833 // We use the same native handler for focusin & focus (and focusout & blur) 11834 // so we need to coordinate setup & teardown parts between those events. 11835 // Use `delegateType` as the key as `type` is already used by `leverageNative`. 11836 if ( !attaches ) { 11837 if ( document.documentMode ) { 11838 this.addEventListener( delegateType, focusMappedHandler ); 11839 } else { 11840 doc.addEventListener( type, focusMappedHandler, true ); 11841 } 11842 } 11843 dataPriv.set( dataHolder, delegateType, ( attaches || 0 ) + 1 ); 11844 }, 11845 teardown: function() { 11846 var doc = this.ownerDocument || this.document || this, 11847 dataHolder = document.documentMode ? this : doc, 11848 attaches = dataPriv.get( dataHolder, delegateType ) - 1; 11849 11850 if ( !attaches ) { 11851 if ( document.documentMode ) { 11852 this.removeEventListener( delegateType, focusMappedHandler ); 11853 } else { 11854 doc.removeEventListener( type, focusMappedHandler, true ); 11855 } 11856 dataPriv.remove( dataHolder, delegateType ); 11857 } else { 11858 dataPriv.set( dataHolder, delegateType, attaches ); 11859 } 11860 } 11861 }; 11862} ); 11863 11864// Create mouseenter/leave events using mouseover/out and event-time checks 11865// so that event delegation works in jQuery. 11866// Do the same for pointerenter/pointerleave and pointerover/pointerout 11867// 11868// Support: Safari 7 only 11869// Safari sends mouseenter too often; see: 11870// https://bugs.chromium.org/p/chromium/issues/detail?id=470258 11871// for the description of the bug (it existed in older Chrome versions as well). 11872jQuery.each( { 11873 mouseenter: "mouseover", 11874 mouseleave: "mouseout", 11875 pointerenter: "pointerover", 11876 pointerleave: "pointerout" 11877}, function( orig, fix ) { 11878 jQuery.event.special[ orig ] = { 11879 delegateType: fix, 11880 bindType: fix, 11881 11882 handle: function( event ) { 11883 var ret, 11884 target = this, 11885 related = event.relatedTarget, 11886 handleObj = event.handleObj; 11887 11888 // For mouseenter/leave call the handler if related is outside the target. 11889 // NB: No relatedTarget if the mouse left/entered the browser window 11890 if ( !related || ( related !== target && !jQuery.contains( target, related ) ) ) { 11891 event.type = handleObj.origType; 11892 ret = handleObj.handler.apply( this, arguments ); 11893 event.type = fix; 11894 } 11895 return ret; 11896 } 11897 }; 11898} ); 11899 11900jQuery.fn.extend( { 11901 11902 on: function( types, selector, data, fn ) { 11903 return on( this, types, selector, data, fn ); 11904 }, 11905 one: function( types, selector, data, fn ) { 11906 return on( this, types, selector, data, fn, 1 ); 11907 }, 11908 off: function( types, selector, fn ) { 11909 var handleObj, type; 11910 if ( types && types.preventDefault && types.handleObj ) { 11911 11912 // ( event ) dispatched jQuery.Event 11913 handleObj = types.handleObj; 11914 jQuery( types.delegateTarget ).off( 11915 handleObj.namespace ? 11916 handleObj.origType + "." + handleObj.namespace : 11917 handleObj.origType, 11918 handleObj.selector, 11919 handleObj.handler 11920 ); 11921 return this; 11922 } 11923 if ( typeof types === "object" ) { 11924 11925 // ( types-object [, selector] ) 11926 for ( type in types ) { 11927 this.off( type, selector, types[ type ] ); 11928 } 11929 return this; 11930 } 11931 if ( selector === false || typeof selector === "function" ) { 11932 11933 // ( types [, fn] ) 11934 fn = selector; 11935 selector = undefined; 11936 } 11937 if ( fn === false ) { 11938 fn = returnFalse; 11939 } 11940 return this.each( function() { 11941 jQuery.event.remove( this, types, fn, selector ); 11942 } ); 11943 } 11944} ); 11945 11946 11947var 11948 11949 // Support: IE <=10 - 11, Edge 12 - 13 only 11950 // In IE/Edge using regex groups here causes severe slowdowns. 11951 // See https://connect.microsoft.com/IE/feedback/details/1736512/ 11952 rnoInnerhtml = /<script|<style|<link/i, 11953 11954 // checked="checked" or checked 11955 rchecked = /checked\s*(?:[^=]|=\s*.checked.)/i, 11956 11957 rcleanScript = /^\s*<!\[CDATA\[|\]\]>\s*$/g; 11958 11959// Prefer a tbody over its parent table for containing new rows 11960function manipulationTarget( elem, content ) { 11961 if ( nodeName( elem, "table" ) && 11962 nodeName( content.nodeType !== 11 ? content : content.firstChild, "tr" ) ) { 11963 11964 return jQuery( elem ).children( "tbody" )[ 0 ] || elem; 11965 } 11966 11967 return elem; 11968} 11969 11970// Replace/restore the type attribute of script elements for safe DOM manipulation 11971function disableScript( elem ) { 11972 elem.type = ( elem.getAttribute( "type" ) !== null ) + "/" + elem.type; 11973 return elem; 11974} 11975function restoreScript( elem ) { 11976 if ( ( elem.type || "" ).slice( 0, 5 ) === "true/" ) { 11977 elem.type = elem.type.slice( 5 ); 11978 } else { 11979 elem.removeAttribute( "type" ); 11980 } 11981 11982 return elem; 11983} 11984 11985function cloneCopyEvent( src, dest ) { 11986 var i, l, type, pdataOld, udataOld, udataCur, events; 11987
vendor: 6,382 bytes, lines 11988-12217
11988 if ( dest.nodeType !== 1 ) { 11989 return; 11990 } 11991 11992 // 1. Copy private data: events, handlers, etc. 11993 if ( dataPriv.hasData( src ) ) { 11994 pdataOld = dataPriv.get( src ); 11995 events = pdataOld.events; 11996 11997 if ( events ) { 11998 dataPriv.remove( dest, "handle events" ); 11999 12000 for ( type in events ) { 12001 for ( i = 0, l = events[ type ].length; i < l; i++ ) { 12002 jQuery.event.add( dest, type, events[ type ][ i ] ); 12003 } 12004 } 12005 } 12006 } 12007 12008 // 2. Copy user data 12009 if ( dataUser.hasData( src ) ) { 12010 udataOld = dataUser.access( src ); 12011 udataCur = jQuery.extend( {}, udataOld ); 12012 12013 dataUser.set( dest, udataCur ); 12014 } 12015} 12016 12017// Fix IE bugs, see support tests 12018function fixInput( src, dest ) { 12019 var nodeName = dest.nodeName.toLowerCase(); 12020 12021 // Fails to persist the checked state of a cloned checkbox or radio button. 12022 if ( nodeName === "input" && rcheckableType.test( src.type ) ) { 12023 dest.checked = src.checked; 12024 12025 // Fails to return the selected option to the default selected state when cloning options 12026 } else if ( nodeName === "input" || nodeName === "textarea" ) { 12027 dest.defaultValue = src.defaultValue; 12028 } 12029} 12030 12031function domManip( collection, args, callback, ignored ) { 12032 12033 // Flatten any nested arrays 12034 args = flat( args ); 12035 12036 var fragment, first, scripts, hasScripts, node, doc, 12037 i = 0, 12038 l = collection.length, 12039 iNoClone = l - 1, 12040 value = args[ 0 ], 12041 valueIsFunction = isFunction( value ); 12042 12043 // We can't cloneNode fragments that contain checked, in WebKit 12044 if ( valueIsFunction || 12045 ( l > 1 && typeof value === "string" && 12046 !support.checkClone && rchecked.test( value ) ) ) { 12047 return collection.each( function( index ) { 12048 var self = collection.eq( index ); 12049 if ( valueIsFunction ) { 12050 args[ 0 ] = value.call( this, index, self.html() ); 12051 } 12052 domManip( self, args, callback, ignored ); 12053 } ); 12054 } 12055 12056 if ( l ) { 12057 fragment = buildFragment( args, collection[ 0 ].ownerDocument, false, collection, ignored ); 12058 first = fragment.firstChild; 12059 12060 if ( fragment.childNodes.length === 1 ) { 12061 fragment = first; 12062 } 12063 12064 // Require either new content or an interest in ignored elements to invoke the callback 12065 if ( first || ignored ) { 12066 scripts = jQuery.map( getAll( fragment, "script" ), disableScript ); 12067 hasScripts = scripts.length; 12068 12069 // Use the original fragment for the last item 12070 // instead of the first because it can end up 12071 // being emptied incorrectly in certain situations (trac-8070). 12072 for ( ; i < l; i++ ) { 12073 node = fragment; 12074 12075 if ( i !== iNoClone ) { 12076 node = jQuery.clone( node, true, true ); 12077 12078 // Keep references to cloned scripts for later restoration 12079 if ( hasScripts ) { 12080 12081 // Support: Android <=4.0 only, PhantomJS 1 only 12082 // push.apply(_, arraylike) throws on ancient WebKit 12083 jQuery.merge( scripts, getAll( node, "script" ) ); 12084 } 12085 } 12086 12087 callback.call( collection[ i ], node, i ); 12088 } 12089 12090 if ( hasScripts ) { 12091 doc = scripts[ scripts.length - 1 ].ownerDocument; 12092 12093 // Re-enable scripts 12094 jQuery.map( scripts, restoreScript ); 12095 12096 // Evaluate executable scripts on first document insertion 12097 for ( i = 0; i < hasScripts; i++ ) { 12098 node = scripts[ i ]; 12099 if ( rscriptType.test( node.type || "" ) && 12100 !dataPriv.access( node, "globalEval" ) && 12101 jQuery.contains( doc, node ) ) { 12102 12103 if ( node.src && ( node.type || "" ).toLowerCase() !== "module" ) { 12104 12105 // Optional AJAX dependency, but won't run scripts if not present 12106 if ( jQuery._evalUrl && !node.noModule ) { 12107 jQuery._evalUrl( node.src, { 12108 nonce: node.nonce || node.getAttribute( "nonce" ) 12109 }, doc ); 12110 } 12111 } else { 12112 12113 // Unwrap a CDATA section containing script contents. This shouldn't be 12114 // needed as in XML documents they're already not visible when 12115 // inspecting element contents and in HTML documents they have no 12116 // meaning but we're preserving that logic for backwards compatibility. 12117 // This will be removed completely in 4.0. See gh-4904. 12118 DOMEval( node.textContent.replace( rcleanScript, "" ), node, doc ); 12119 } 12120 } 12121 } 12122 } 12123 } 12124 } 12125 12126 return collection; 12127} 12128 12129function remove( elem, selector, keepData ) { 12130 var node, 12131 nodes = selector ? jQuery.filter( selector, elem ) : elem, 12132 i = 0; 12133 12134 for ( ; ( node = nodes[ i ] ) != null; i++ ) { 12135 if ( !keepData && node.nodeType === 1 ) { 12136 jQuery.cleanData( getAll( node ) ); 12137 } 12138 12139 if ( node.parentNode ) { 12140 if ( keepData && isAttached( node ) ) { 12141 setGlobalEval( getAll( node, "script" ) ); 12142 } 12143 node.parentNode.removeChild( node ); 12144 } 12145 } 12146 12147 return elem; 12148} 12149 12150jQuery.extend( { 12151 htmlPrefilter: function( html ) { 12152 return html; 12153 }, 12154 12155 clone: function( elem, dataAndEvents, deepDataAndEvents ) { 12156 var i, l, srcElements, destElements, 12157 clone = elem.cloneNode( true ), 12158 inPage = isAttached( elem ); 12159 12160 // Fix IE cloning issues 12161 if ( !support.noCloneChecked && ( elem.nodeType === 1 || elem.nodeType === 11 ) && 12162 !jQuery.isXMLDoc( elem ) ) { 12163 12164 // We eschew jQuery#find here for performance reasons: 12165 // https://jsperf.com/getall-vs-sizzle/2 12166 destElements = getAll( clone ); 12167 srcElements = getAll( elem ); 12168 12169 for ( i = 0, l = srcElements.length; i < l; i++ ) { 12170 fixInput( srcElements[ i ], destElements[ i ] ); 12171 } 12172 } 12173 12174 // Copy the events from the original to the clone 12175 if ( dataAndEvents ) { 12176 if ( deepDataAndEvents ) { 12177 srcElements = srcElements || getAll( elem ); 12178 destElements = destElements || getAll( clone ); 12179 12180 for ( i = 0, l = srcElements.length; i < l; i++ ) { 12181 cloneCopyEvent( srcElements[ i ], destElements[ i ] ); 12182 } 12183 } else { 12184 cloneCopyEvent( elem, clone ); 12185 } 12186 } 12187 12188 // Preserve script evaluation history 12189 destElements = getAll( clone, "script" ); 12190 if ( destElements.length > 0 ) { 12191 setGlobalEval( destElements, !inPage && getAll( elem, "script" ) ); 12192 } 12193 12194 // Return the cloned set 12195 return clone; 12196 }, 12197 12198 cleanData: function( elems ) { 12199 var data, elem, type, 12200 special = jQuery.event.special, 12201 i = 0; 12202 12203 for ( ; ( elem = elems[ i ] ) !== undefined; i++ ) { 12204 if ( acceptData( elem ) ) { 12205 if ( ( data = elem[ dataPriv.expando ] ) ) { 12206 if ( data.events ) { 12207 for ( type in data.events ) { 12208 if ( special[ type ] ) { 12209 jQuery.event.remove( elem, type ); 12210 12211 // This is a shortcut to avoid jQuery.event.remove's overhead 12212 } else { 12213 jQuery.removeEvent( elem, type, data.handle ); 12214 } 12215 } 12216 } 12217
vendor: 1,119 bytes, lines 12218-12262
12218 // Support: Chrome <=35 - 45+ 12219 // Assign undefined instead of using delete, see Data#remove 12220 elem[ dataPriv.expando ] = undefined; 12221 } 12222 if ( elem[ dataUser.expando ] ) { 12223 12224 // Support: Chrome <=35 - 45+ 12225 // Assign undefined instead of using delete, see Data#remove 12226 elem[ dataUser.expando ] = undefined; 12227 } 12228 } 12229 } 12230 } 12231} ); 12232 12233jQuery.fn.extend( { 12234 detach: function( selector ) { 12235 return remove( this, selector, true ); 12236 }, 12237 12238 remove: function( selector ) { 12239 return remove( this, selector ); 12240 }, 12241 12242 text: function( value ) { 12243 return access( this, function( value ) { 12244 return value === undefined ? 12245 jQuery.text( this ) : 12246 this.empty().each( function() { 12247 if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) { 12248 this.textContent = value; 12249 } 12250 } ); 12251 }, null, value, arguments.length ); 12252 }, 12253 12254 append: function() { 12255 return domManip( this, arguments, function( elem ) { 12256 if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) { 12257 var target = manipulationTarget( this, elem ); 12258 target.appendChild( elem ); 12259 } 12260 } ); 12261 }, 12262
vendor: 4,514 bytes, lines 12263-12454
12263 prepend: function() { 12264 return domManip( this, arguments, function( elem ) { 12265 if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) { 12266 var target = manipulationTarget( this, elem ); 12267 target.insertBefore( elem, target.firstChild ); 12268 } 12269 } ); 12270 }, 12271 12272 before: function() { 12273 return domManip( this, arguments, function( elem ) { 12274 if ( this.parentNode ) { 12275 this.parentNode.insertBefore( elem, this ); 12276 } 12277 } ); 12278 }, 12279 12280 after: function() { 12281 return domManip( this, arguments, function( elem ) { 12282 if ( this.parentNode ) { 12283 this.parentNode.insertBefore( elem, this.nextSibling ); 12284 } 12285 } ); 12286 }, 12287 12288 empty: function() { 12289 var elem, 12290 i = 0; 12291 12292 for ( ; ( elem = this[ i ] ) != null; i++ ) { 12293 if ( elem.nodeType === 1 ) { 12294 12295 // Prevent memory leaks 12296 jQuery.cleanData( getAll( elem, false ) ); 12297 12298 // Remove any remaining nodes 12299 elem.textContent = ""; 12300 } 12301 } 12302 12303 return this; 12304 }, 12305 12306 clone: function( dataAndEvents, deepDataAndEvents ) { 12307 dataAndEvents = dataAndEvents == null ? false : dataAndEvents; 12308 deepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents; 12309 12310 return this.map( function() { 12311 return jQuery.clone( this, dataAndEvents, deepDataAndEvents ); 12312 } ); 12313 }, 12314 12315 html: function( value ) { 12316 return access( this, function( value ) { 12317 var elem = this[ 0 ] || {}, 12318 i = 0, 12319 l = this.length; 12320 12321 if ( value === undefined && elem.nodeType === 1 ) { 12322 return elem.innerHTML; 12323 } 12324 12325 // See if we can take a shortcut and just use innerHTML 12326 if ( typeof value === "string" && !rnoInnerhtml.test( value ) && 12327 !wrapMap[ ( rtagName.exec( value ) || [ "", "" ] )[ 1 ].toLowerCase() ] ) { 12328 12329 value = jQuery.htmlPrefilter( value ); 12330 12331 try { 12332 for ( ; i < l; i++ ) { 12333 elem = this[ i ] || {}; 12334 12335 // Remove element nodes and prevent memory leaks 12336 if ( elem.nodeType === 1 ) { 12337 jQuery.cleanData( getAll( elem, false ) ); 12338 elem.innerHTML = value; 12339 } 12340 } 12341 12342 elem = 0; 12343 12344 // If using innerHTML throws an exception, use the fallback method 12345 } catch ( e ) {} 12346 } 12347 12348 if ( elem ) { 12349 this.empty().append( value ); 12350 } 12351 }, null, value, arguments.length ); 12352 }, 12353 12354 replaceWith: function() { 12355 var ignored = []; 12356 12357 // Make the changes, replacing each non-ignored context element with the new content 12358 return domManip( this, arguments, function( elem ) { 12359 var parent = this.parentNode; 12360 12361 if ( jQuery.inArray( this, ignored ) < 0 ) { 12362 jQuery.cleanData( getAll( this ) ); 12363 if ( parent ) { 12364 parent.replaceChild( elem, this ); 12365 } 12366 } 12367 12368 // Force callback invocation 12369 }, ignored ); 12370 } 12371} ); 12372 12373jQuery.each( { 12374 appendTo: "append", 12375 prependTo: "prepend", 12376 insertBefore: "before", 12377 insertAfter: "after", 12378 replaceAll: "replaceWith" 12379}, function( name, original ) { 12380 jQuery.fn[ name ] = function( selector ) { 12381 var elems, 12382 ret = [], 12383 insert = jQuery( selector ), 12384 last = insert.length - 1, 12385 i = 0; 12386 12387 for ( ; i <= last; i++ ) { 12388 elems = i === last ? this : this.clone( true ); 12389 jQuery( insert[ i ] )[ original ]( elems ); 12390 12391 // Support: Android <=4.0 only, PhantomJS 1 only 12392 // .get() because push.apply(_, arraylike) throws on ancient WebKit 12393 push.apply( ret, elems.get() ); 12394 } 12395 12396 return this.pushStack( ret ); 12397 }; 12398} ); 12399var rnumnonpx = new RegExp( "^(" + pnum + ")(?!px)[a-z%]+$", "i" ); 12400 12401var rcustomProp = /^--/; 12402 12403 12404var getStyles = function( elem ) { 12405 12406 // Support: IE <=11 only, Firefox <=30 (trac-15098, trac-14150) 12407 // IE throws on elements created in popups 12408 // FF meanwhile throws on frame elements through "defaultView.getComputedStyle" 12409 var view = elem.ownerDocument.defaultView; 12410 12411 if ( !view || !view.opener ) { 12412 view = window; 12413 } 12414 12415 return view.getComputedStyle( elem ); 12416 }; 12417 12418var swap = function( elem, options, callback ) { 12419 var ret, name, 12420 old = {}; 12421 12422 // Remember the old values, and insert the new ones 12423 for ( name in options ) { 12424 old[ name ] = elem.style[ name ]; 12425 elem.style[ name ] = options[ name ]; 12426 } 12427 12428 ret = callback.call( elem ); 12429 12430 // Revert the old values 12431 for ( name in options ) { 12432 elem.style[ name ] = old[ name ]; 12433 } 12434 12435 return ret; 12436}; 12437 12438 12439var rboxStyle = new RegExp( cssExpand.join( "|" ), "i" ); 12440 12441 12442 12443( function() { 12444 12445 // Executing both pixelPosition & boxSizingReliable tests require only one layout 12446 // so they're executed at the same time to save the second computation. 12447 function computeStyleTests() { 12448 12449 // This is a singleton, we need to execute it only once 12450 if ( !div ) { 12451 return; 12452 } 12453 12454 container.style.cssText = "position:absolute;
vendor: 4,156 bytes, lines 12454-12573
12454left:-11111px;width:60px;" + 12455 "margin-top:1px;padding:0;border:0"; 12456 div.style.cssText = 12457 "position:relative;display:block;box-sizing:border-box;overflow:scroll;" + 12458 "margin:auto;border:1px;padding:1px;" + 12459 "width:60%;top:1%"; 12460 documentElement.appendChild( container ).appendChild( div ); 12461 12462 var divStyle = window.getComputedStyle( div ); 12463 pixelPositionVal = divStyle.top !== "1%"; 12464 12465 // Support: Android 4.0 - 4.3 only, Firefox <=3 - 44 12466 reliableMarginLeftVal = roundPixelMeasures( divStyle.marginLeft ) === 12; 12467 12468 // Support: Android 4.0 - 4.3 only, Safari <=9.1 - 10.1, iOS <=7.0 - 9.3 12469 // Some styles come back with percentage values, even though they shouldn't 12470 div.style.right = "60%"; 12471 pixelBoxStylesVal = roundPixelMeasures( divStyle.right ) === 36; 12472 12473 // Support: IE 9 - 11 only 12474 // Detect misreporting of content dimensions for box-sizing:border-box elements 12475 boxSizingReliableVal = roundPixelMeasures( divStyle.width ) === 36; 12476 12477 // Support: IE 9 only 12478 // Detect overflow:scroll screwiness (gh-3699) 12479 // Support: Chrome <=64 12480 // Don't get tricked when zoom affects offsetWidth (gh-4029) 12481 div.style.position = "absolute"; 12482 scrollboxSizeVal = roundPixelMeasures( div.offsetWidth / 3 ) === 12; 12483 12484 documentElement.removeChild( container ); 12485 12486 // Nullify the div so it wouldn't be stored in the memory and 12487 // it will also be a sign that checks already performed 12488 div = null; 12489 } 12490 12491 function roundPixelMeasures( measure ) { 12492 return Math.round( parseFloat( measure ) ); 12493 } 12494 12495 var pixelPositionVal, boxSizingReliableVal, scrollboxSizeVal, pixelBoxStylesVal, 12496 reliableTrDimensionsVal, reliableMarginLeftVal, 12497 container = document.createElement( "div" ), 12498 div = document.createElement( "div" ); 12499 12500 // Finish early in limited (non-browser) environments 12501 if ( !div.style ) { 12502 return; 12503 } 12504 12505 // Support: IE <=9 - 11 only 12506 // Style of cloned element affects source element cloned (trac-8908) 12507 div.style.backgroundClip = "content-box"; 12508 div.cloneNode( true ).style.backgroundClip = ""; 12509 support.clearCloneStyle = div.style.backgroundClip === "content-box"; 12510 12511 jQuery.extend( support, { 12512 boxSizingReliable: function() { 12513 computeStyleTests(); 12514 return boxSizingReliableVal; 12515 }, 12516 pixelBoxStyles: function() { 12517 computeStyleTests(); 12518 return pixelBoxStylesVal; 12519 }, 12520 pixelPosition: function() { 12521 computeStyleTests(); 12522 return pixelPositionVal; 12523 }, 12524 reliableMarginLeft: function() { 12525 computeStyleTests(); 12526 return reliableMarginLeftVal; 12527 }, 12528 scrollboxSize: function() { 12529 computeStyleTests(); 12530 return scrollboxSizeVal; 12531 }, 12532 12533 // Support: IE 9 - 11+, Edge 15 - 18+ 12534 // IE/Edge misreport `getComputedStyle` of table rows with width/height 12535 // set in CSS while `offset*` properties report correct values. 12536 // Behavior in IE 9 is more subtle than in newer versions & it passes 12537 // some versions of this test; make sure not to make it pass there! 12538 // 12539 // Support: Firefox 70+ 12540 // Only Firefox includes border widths 12541 // in computed dimensions. (gh-4529) 12542 reliableTrDimensions: function() { 12543 var table, tr, trChild, trStyle; 12544 if ( reliableTrDimensionsVal == null ) { 12545 table = document.createElement( "table" ); 12546 tr = document.createElement( "tr" ); 12547 trChild = document.createElement( "div" ); 12548 12549 table.style.cssText = "position:absolute;left:-11111px;border-collapse:separate"; 12550 tr.style.cssText = "box-sizing:content-box;border:1px solid"; 12551 12552 // Support: Chrome 86+ 12553 // Height set through cssText does not get applied. 12554 // Computed height then comes back as 0. 12555 tr.style.height = "1px"; 12556 trChild.style.height = "9px"; 12557 12558 // Support: Android 8 Chrome 86+ 12559 // In our bodyBackground.html iframe, 12560 // display for all div elements is set to "inline", 12561 // which causes a problem only in Android 8 Chrome 86. 12562 // Ensuring the div is `display: block` 12563 // gets around this issue. 12564 trChild.style.display = "block"; 12565 12566 documentElement 12567 .appendChild( table ) 12568 .appendChild( tr ) 12569 .appendChild( trChild ); 12570 12571 trStyle = window.getComputedStyle( tr ); 12572 reliableTrDimensionsVal = ( parseInt( trStyle.height, 10 ) + 12573 parseInt( trStyle.borderTopWidth, 10 ) +
vendor: 12,879 bytes, lines 12574-13000
12574 parseInt( trStyle.borderBottomWidth, 10 ) ) === tr.offsetHeight; 12575 12576 documentElement.removeChild( table ); 12577 } 12578 return reliableTrDimensionsVal; 12579 } 12580 } ); 12581} )(); 12582 12583 12584function curCSS( elem, name, computed ) { 12585 var width, minWidth, maxWidth, ret, 12586 isCustomProp = rcustomProp.test( name ), 12587 12588 // Support: Firefox 51+ 12589 // Retrieving style before computed somehow 12590 // fixes an issue with getting wrong values 12591 // on detached elements 12592 style = elem.style; 12593 12594 computed = computed || getStyles( elem ); 12595 12596 // getPropertyValue is needed for: 12597 // .css('filter') (IE 9 only, trac-12537) 12598 // .css('--customProperty) (gh-3144) 12599 if ( computed ) { 12600 12601 // Support: IE <=9 - 11+ 12602 // IE only supports `"float"` in `getPropertyValue`; in computed styles 12603 // it's only available as `"cssFloat"`. We no longer modify properties 12604 // sent to `.css()` apart from camelCasing, so we need to check both. 12605 // Normally, this would create difference in behavior: if 12606 // `getPropertyValue` returns an empty string, the value returned 12607 // by `.css()` would be `undefined`. This is usually the case for 12608 // disconnected elements. However, in IE even disconnected elements 12609 // with no styles return `"none"` for `getPropertyValue( "float" )` 12610 ret = computed.getPropertyValue( name ) || computed[ name ]; 12611 12612 if ( isCustomProp && ret ) { 12613 12614 // Support: Firefox 105+, Chrome <=105+ 12615 // Spec requires trimming whitespace for custom properties (gh-4926). 12616 // Firefox only trims leading whitespace. Chrome just collapses 12617 // both leading & trailing whitespace to a single space. 12618 // 12619 // Fall back to `undefined` if empty string returned. 12620 // This collapses a missing definition with property defined 12621 // and set to an empty string but there's no standard API 12622 // allowing us to differentiate them without a performance penalty 12623 // and returning `undefined` aligns with older jQuery. 12624 // 12625 // rtrimCSS treats U+000D CARRIAGE RETURN and U+000C FORM FEED 12626 // as whitespace while CSS does not, but this is not a problem 12627 // because CSS preprocessing replaces them with U+000A LINE FEED 12628 // (which *is* CSS whitespace) 12629 // https://www.w3.org/TR/css-syntax-3/#input-preprocessing 12630 ret = ret.replace( rtrimCSS, "$1" ) || undefined; 12631 } 12632 12633 if ( ret === "" && !isAttached( elem ) ) { 12634 ret = jQuery.style( elem, name ); 12635 } 12636 12637 // A tribute to the "awesome hack by Dean Edwards" 12638 // Android Browser returns percentage for some values, 12639 // but width seems to be reliably pixels. 12640 // This is against the CSSOM draft spec: 12641 // https://drafts.csswg.org/cssom/#resolved-values 12642 if ( !support.pixelBoxStyles() && rnumnonpx.test( ret ) && rboxStyle.test( name ) ) { 12643 12644 // Remember the original values 12645 width = style.width; 12646 minWidth = style.minWidth; 12647 maxWidth = style.maxWidth; 12648 12649 // Put in the new values to get a computed value out 12650 style.minWidth = style.maxWidth = style.width = ret; 12651 ret = computed.width; 12652 12653 // Revert the changed values 12654 style.width = width; 12655 style.minWidth = minWidth; 12656 style.maxWidth = maxWidth; 12657 } 12658 } 12659 12660 return ret !== undefined ? 12661 12662 // Support: IE <=9 - 11 only 12663 // IE returns zIndex value as an integer. 12664 ret + "" : 12665 ret; 12666} 12667 12668 12669function addGetHookIf( conditionFn, hookFn ) { 12670 12671 // Define the hook, we'll check on the first run if it's really needed. 12672 return { 12673 get: function() { 12674 if ( conditionFn() ) { 12675 12676 // Hook not needed (or it's not possible to use it due 12677 // to missing dependency), remove it. 12678 delete this.get; 12679 return; 12680 } 12681 12682 // Hook needed; redefine it so that the support test is not executed again. 12683 return ( this.get = hookFn ).apply( this, arguments ); 12684 } 12685 }; 12686} 12687 12688 12689var cssPrefixes = [ "Webkit", "Moz", "ms" ], 12690 emptyStyle = document.createElement( "div" ).style, 12691 vendorProps = {}; 12692 12693// Return a vendor-prefixed property or undefined 12694function vendorPropName( name ) { 12695 12696 // Check for vendor prefixed names 12697 var capName = name[ 0 ].toUpperCase() + name.slice( 1 ), 12698 i = cssPrefixes.length; 12699 12700 while ( i-- ) { 12701 name = cssPrefixes[ i ] + capName; 12702 if ( name in emptyStyle ) { 12703 return name; 12704 } 12705 } 12706} 12707 12708// Return a potentially-mapped jQuery.cssProps or vendor prefixed property 12709function finalPropName( name ) { 12710 var final = jQuery.cssProps[ name ] || vendorProps[ name ]; 12711 12712 if ( final ) { 12713 return final; 12714 } 12715 if ( name in emptyStyle ) { 12716 return name; 12717 } 12718 return vendorProps[ name ] = vendorPropName( name ) || name; 12719} 12720 12721 12722var 12723 12724 // Swappable if display is none or starts with table 12725 // except "table", "table-cell", or "table-caption" 12726 // See here for display values: https://developer.mozilla.org/en-US/docs/CSS/display 12727 rdisplayswap = /^(none|table(?!-c[ea]).+)/, 12728 cssShow = { position: "absolute", visibility: "hidden", display: "block" }, 12729 cssNormalTransform = { 12730 letterSpacing: "0", 12731 fontWeight: "400" 12732 }; 12733 12734function setPositiveNumber( _elem, value, subtract ) { 12735 12736 // Any relative (+/-) values have already been 12737 // normalized at this point 12738 var matches = rcssNum.exec( value ); 12739 return matches ? 12740 12741 // Guard against undefined "subtract", e.g., when used as in cssHooks 12742 Math.max( 0, matches[ 2 ] - ( subtract || 0 ) ) + ( matches[ 3 ] || "px" ) : 12743 value; 12744} 12745 12746function boxModelAdjustment( elem, dimension, box, isBorderBox, styles, computedVal ) { 12747 var i = dimension === "width" ? 1 : 0, 12748 extra = 0, 12749 delta = 0, 12750 marginDelta = 0; 12751 12752 // Adjustment may not be necessary 12753 if ( box === ( isBorderBox ? "border" : "content" ) ) { 12754 return 0; 12755 } 12756 12757 for ( ; i < 4; i += 2 ) { 12758 12759 // Both box models exclude margin 12760 // Count margin delta separately to only add it after scroll gutter adjustment. 12761 // This is needed to make negative margins work with `outerHeight( true )` (gh-3982). 12762 if ( box === "margin" ) { 12763 marginDelta += jQuery.css( elem, box + cssExpand[ i ], true, styles ); 12764 } 12765 12766 // If we get here with a content-box, we're seeking "padding" or "border" or "margin" 12767 if ( !isBorderBox ) { 12768 12769 // Add padding 12770 delta += jQuery.css( elem, "padding" + cssExpand[ i ], true, styles ); 12771 12772 // For "border" or "margin", add border 12773 if ( box !== "padding" ) { 12774 delta += jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles ); 12775 12776 // But still keep track of it otherwise 12777 } else { 12778 extra += jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles ); 12779 } 12780 12781 // If we get here with a border-box (content + padding + border), we're seeking "content" or 12782 // "padding" or "margin" 12783 } else { 12784 12785 // For "content", subtract padding 12786 if ( box === "content" ) { 12787 delta -= jQuery.css( elem, "padding" + cssExpand[ i ], true, styles ); 12788 } 12789 12790 // For "content" or "padding", subtract border 12791 if ( box !== "margin" ) { 12792 delta -= jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles ); 12793 } 12794 } 12795 } 12796 12797 // Account for positive content-box scroll gutter when requested by providing computedVal 12798 if ( !isBorderBox && computedVal >= 0 ) { 12799 12800 // offsetWidth/offsetHeight is a rounded sum of content, padding, scroll gutter, and border 12801 // Assuming integer scroll gutter, subtract the rest and round down 12802 delta += Math.max( 0, Math.ceil( 12803 elem[ "offset" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 ) ] - 12804 computedVal - 12805 delta - 12806 extra - 12807 0.5 12808 12809 // If offsetWidth/offsetHeight is unknown, then we can't determine content-box scroll gutter 12810 // Use an explicit zero to avoid NaN (gh-3964) 12811 ) ) || 0; 12812 } 12813 12814 return delta + marginDelta; 12815} 12816 12817function getWidthOrHeight( elem, dimension, extra ) { 12818 12819 // Start with computed style 12820 var styles = getStyles( elem ), 12821 12822 // To avoid forcing a reflow, only fetch boxSizing if we need it (gh-4322). 12823 // Fake content-box until we know it's needed to know the true value. 12824 boxSizingNeeded = !support.boxSizingReliable() || extra, 12825 isBorderBox = boxSizingNeeded && 12826 jQuery.css( elem, "boxSizing", false, styles ) === "border-box", 12827 valueIsBorderBox = isBorderBox, 12828 12829 val = curCSS( elem, dimension, styles ), 12830 offsetProp = "offset" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 ); 12831 12832 // Support: Firefox <=54 12833 // Return a confounding non-pixel value or feign ignorance, as appropriate. 12834 if ( rnumnonpx.test( val ) ) { 12835 if ( !extra ) { 12836 return val; 12837 } 12838 val = "auto"; 12839 } 12840 12841 12842 // Support: IE 9 - 11 only 12843 // Use offsetWidth/offsetHeight for when box sizing is unreliable. 12844 // In those cases, the computed value can be trusted to be border-box. 12845 if ( ( !support.boxSizingReliable() && isBorderBox || 12846 12847 // Support: IE 10 - 11+, Edge 15 - 18+ 12848 // IE/Edge misreport `getComputedStyle` of table rows with width/height 12849 // set in CSS while `offset*` properties report correct values. 12850 // Interestingly, in some cases IE 9 doesn't suffer from this issue. 12851 !support.reliableTrDimensions() && nodeName( elem, "tr" ) || 12852 12853 // Fall back to offsetWidth/offsetHeight when value is "auto" 12854 // This happens for inline elements with no explicit setting (gh-3571) 12855 val === "auto" || 12856 12857 // Support: Android <=4.1 - 4.3 only 12858 // Also use offsetWidth/offsetHeight for misreported inline dimensions (gh-3602) 12859 !parseFloat( val ) && jQuery.css( elem, "display", false, styles ) === "inline" ) && 12860 12861 // Make sure the element is visible & connected 12862 elem.getClientRects().length ) { 12863 12864 isBorderBox = jQuery.css( elem, "boxSizing", false, styles ) === "border-box"; 12865 12866 // Where available, offsetWidth/offsetHeight approximate border box dimensions. 12867 // Where not available (e.g., SVG), assume unreliable box-sizing and interpret the 12868 // retrieved value as a content box dimension. 12869 valueIsBorderBox = offsetProp in elem; 12870 if ( valueIsBorderBox ) { 12871 val = elem[ offsetProp ]; 12872 } 12873 } 12874 12875 // Normalize "" and auto 12876 val = parseFloat( val ) || 0; 12877 12878 // Adjust for the element's box model 12879 return ( val + 12880 boxModelAdjustment( 12881 elem, 12882 dimension, 12883 extra || ( isBorderBox ? "border" : "content" ), 12884 valueIsBorderBox, 12885 styles, 12886 12887 // Provide the current computed size to request scroll gutter calculation (gh-3589) 12888 val 12889 ) 12890 ) + "px"; 12891} 12892 12893jQuery.extend( { 12894 12895 // Add in style property hooks for overriding the default 12896 // behavior of getting and setting a style property 12897 cssHooks: { 12898 opacity: { 12899 get: function( elem, computed ) { 12900 if ( computed ) { 12901 12902 // We should always get a number back from opacity 12903 var ret = curCSS( elem, "opacity" ); 12904 return ret === "" ? "1" : ret; 12905 } 12906 } 12907 } 12908 }, 12909 12910 // Don't automatically add "px" to these possibly-unitless properties 12911 cssNumber: { 12912 animationIterationCount: true, 12913 aspectRatio: true, 12914 borderImageSlice: true, 12915 columnCount: true, 12916 flexGrow: true, 12917 flexShrink: true, 12918 fontWeight: true, 12919 gridArea: true, 12920 gridColumn: true, 12921 gridColumnEnd: true, 12922 gridColumnStart: true, 12923 gridRow: true, 12924 gridRowEnd: true, 12925 gridRowStart: true, 12926 lineHeight: true, 12927 opacity: true, 12928 order: true, 12929 orphans: true, 12930 scale: true, 12931 widows: true, 12932 zIndex: true, 12933 zoom: true, 12934 12935 // SVG-related 12936 fillOpacity: true, 12937 floodOpacity: true, 12938 stopOpacity: true, 12939 strokeMiterlimit: true, 12940 strokeOpacity: true 12941 }, 12942 12943 // Add in properties whose names you wish to fix before 12944 // setting or getting the value 12945 cssProps: {}, 12946 12947 // Get and set the style property on a DOM Node 12948 style: function( elem, name, value, extra ) { 12949 12950 // Don't set styles on text and comment nodes 12951 if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style ) { 12952 return; 12953 } 12954 12955 // Make sure that we're working with the right name 12956 var ret, type, hooks, 12957 origName = camelCase( name ), 12958 isCustomProp = rcustomProp.test( name ), 12959 style = elem.style; 12960 12961 // Make sure that we're working with the right name. We don't 12962 // want to query the value if it is a CSS custom property 12963 // since they are user-defined. 12964 if ( !isCustomProp ) { 12965 name = finalPropName( origName ); 12966 } 12967 12968 // Gets hook for the prefixed version, then unprefixed version 12969 hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ]; 12970 12971 // Check if we're setting a value 12972 if ( value !== undefined ) { 12973 type = typeof value; 12974 12975 // Convert "+=" or "-=" to relative numbers (trac-7345) 12976 if ( type === "string" && ( ret = rcssNum.exec( value ) ) && ret[ 1 ] ) { 12977 value = adjustCSS( elem, name, ret ); 12978 12979 // Fixes bug trac-9237 12980 type = "number"; 12981 } 12982 12983 // Make sure that null and NaN values aren't set (trac-7116) 12984 if ( value == null || value !== value ) { 12985 return; 12986 } 12987 12988 // If a number was passed in, add the unit (except for certain CSS properties) 12989 // The isCustomProp check can be removed in jQuery 4.0 when we only auto-append 12990 // "px" to a few hardcoded values. 12991 if ( type === "number" && !isCustomProp ) { 12992 value += ret && ret[ 3 ] || ( jQuery.cssNumber[ origName ] ? "" : "px" ); 12993 } 12994 12995 // background-* props affect original clone's values 12996 if ( !support.clearCloneStyle && value === "" && name.indexOf( "background" ) === 0 ) { 12997 style[ name ] = "inherit"; 12998 } 12999 13000 // If a hook was provided, use that value, otherwise just set the specified value
vendor: 16,052 bytes, lines 13001-13605
13001 if ( !hooks || !( "set" in hooks ) || 13002 ( value = hooks.set( elem, value, extra ) ) !== undefined ) { 13003 13004 if ( isCustomProp ) { 13005 style.setProperty( name, value ); 13006 } else { 13007 style[ name ] = value; 13008 } 13009 } 13010 13011 } else { 13012 13013 // If a hook was provided get the non-computed value from there 13014 if ( hooks && "get" in hooks && 13015 ( ret = hooks.get( elem, false, extra ) ) !== undefined ) { 13016 13017 return ret; 13018 } 13019 13020 // Otherwise just get the value from the style object 13021 return style[ name ]; 13022 } 13023 }, 13024 13025 css: function( elem, name, extra, styles ) { 13026 var val, num, hooks, 13027 origName = camelCase( name ), 13028 isCustomProp = rcustomProp.test( name ); 13029 13030 // Make sure that we're working with the right name. We don't 13031 // want to modify the value if it is a CSS custom property 13032 // since they are user-defined. 13033 if ( !isCustomProp ) { 13034 name = finalPropName( origName ); 13035 } 13036 13037 // Try prefixed name followed by the unprefixed name 13038 hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ]; 13039 13040 // If a hook was provided get the computed value from there 13041 if ( hooks && "get" in hooks ) { 13042 val = hooks.get( elem, true, extra ); 13043 } 13044 13045 // Otherwise, if a way to get the computed value exists, use that 13046 if ( val === undefined ) { 13047 val = curCSS( elem, name, styles ); 13048 } 13049 13050 // Convert "normal" to computed value 13051 if ( val === "normal" && name in cssNormalTransform ) { 13052 val = cssNormalTransform[ name ]; 13053 } 13054 13055 // Make numeric if forced or a qualifier was provided and val looks numeric 13056 if ( extra === "" || extra ) { 13057 num = parseFloat( val ); 13058 return extra === true || isFinite( num ) ? num || 0 : val; 13059 } 13060 13061 return val; 13062 } 13063} ); 13064 13065jQuery.each( [ "height", "width" ], function( _i, dimension ) { 13066 jQuery.cssHooks[ dimension ] = { 13067 get: function( elem, computed, extra ) { 13068 if ( computed ) { 13069 13070 // Certain elements can have dimension info if we invisibly show them 13071 // but it must have a current display style that would benefit 13072 return rdisplayswap.test( jQuery.css( elem, "display" ) ) && 13073 13074 // Support: Safari 8+ 13075 // Table columns in Safari have non-zero offsetWidth & zero 13076 // getBoundingClientRect().width unless display is changed. 13077 // Support: IE <=11 only 13078 // Running getBoundingClientRect on a disconnected node 13079 // in IE throws an error. 13080 ( !elem.getClientRects().length || !elem.getBoundingClientRect().width ) ? 13081 swap( elem, cssShow, function() { 13082 return getWidthOrHeight( elem, dimension, extra ); 13083 } ) : 13084 getWidthOrHeight( elem, dimension, extra ); 13085 } 13086 }, 13087 13088 set: function( elem, value, extra ) { 13089 var matches, 13090 styles = getStyles( elem ), 13091 13092 // Only read styles.position if the test has a chance to fail 13093 // to avoid forcing a reflow. 13094 scrollboxSizeBuggy = !support.scrollboxSize() && 13095 styles.position === "absolute", 13096 13097 // To avoid forcing a reflow, only fetch boxSizing if we need it (gh-3991) 13098 boxSizingNeeded = scrollboxSizeBuggy || extra, 13099 isBorderBox = boxSizingNeeded && 13100 jQuery.css( elem, "boxSizing", false, styles ) === "border-box", 13101 subtract = extra ? 13102 boxModelAdjustment( 13103 elem, 13104 dimension, 13105 extra, 13106 isBorderBox, 13107 styles 13108 ) : 13109 0; 13110 13111 // Account for unreliable border-box dimensions by comparing offset* to computed and 13112 // faking a content-box to get border and padding (gh-3699) 13113 if ( isBorderBox && scrollboxSizeBuggy ) { 13114 subtract -= Math.ceil( 13115 elem[ "offset" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 ) ] - 13116 parseFloat( styles[ dimension ] ) - 13117 boxModelAdjustment( elem, dimension, "border", false, styles ) - 13118 0.5 13119 ); 13120 } 13121 13122 // Convert to pixels if value adjustment is needed 13123 if ( subtract && ( matches = rcssNum.exec( value ) ) && 13124 ( matches[ 3 ] || "px" ) !== "px" ) { 13125 13126 elem.style[ dimension ] = value; 13127 value = jQuery.css( elem, dimension ); 13128 } 13129 13130 return setPositiveNumber( elem, value, subtract ); 13131 } 13132 }; 13133} ); 13134 13135jQuery.cssHooks.marginLeft = addGetHookIf( support.reliableMarginLeft, 13136 function( elem, computed ) { 13137 if ( computed ) { 13138 return ( parseFloat( curCSS( elem, "marginLeft" ) ) || 13139 elem.getBoundingClientRect().left - 13140 swap( elem, { marginLeft: 0 }, function() { 13141 return elem.getBoundingClientRect().left; 13142 } ) 13143 ) + "px"; 13144 } 13145 } 13146); 13147 13148// These hooks are used by animate to expand properties 13149jQuery.each( { 13150 margin: "", 13151 padding: "", 13152 border: "Width" 13153}, function( prefix, suffix ) { 13154 jQuery.cssHooks[ prefix + suffix ] = { 13155 expand: function( value ) { 13156 var i = 0, 13157 expanded = {}, 13158 13159 // Assumes a single number if not a string 13160 parts = typeof value === "string" ? value.split( " " ) : [ value ]; 13161 13162 for ( ; i < 4; i++ ) { 13163 expanded[ prefix + cssExpand[ i ] + suffix ] = 13164 parts[ i ] || parts[ i - 2 ] || parts[ 0 ]; 13165 } 13166 13167 return expanded; 13168 } 13169 }; 13170 13171 if ( prefix !== "margin" ) { 13172 jQuery.cssHooks[ prefix + suffix ].set = setPositiveNumber; 13173 } 13174} ); 13175 13176jQuery.fn.extend( { 13177 css: function( name, value ) { 13178 return access( this, function( elem, name, value ) { 13179 var styles, len, 13180 map = {}, 13181 i = 0; 13182 13183 if ( Array.isArray( name ) ) { 13184 styles = getStyles( elem ); 13185 len = name.length; 13186 13187 for ( ; i < len; i++ ) { 13188 map[ name[ i ] ] = jQuery.css( elem, name[ i ], false, styles ); 13189 } 13190 13191 return map; 13192 } 13193 13194 return value !== undefined ? 13195 jQuery.style( elem, name, value ) : 13196 jQuery.css( elem, name ); 13197 }, name, value, arguments.length > 1 ); 13198 } 13199} ); 13200 13201 13202function Tween( elem, options, prop, end, easing ) { 13203 return new Tween.prototype.init( elem, options, prop, end, easing ); 13204} 13205jQuery.Tween = Tween; 13206 13207Tween.prototype = { 13208 constructor: Tween, 13209 init: function( elem, options, prop, end, easing, unit ) { 13210 this.elem = elem; 13211 this.prop = prop; 13212 this.easing = easing || jQuery.easing._default; 13213 this.options = options; 13214 this.start = this.now = this.cur(); 13215 this.end = end; 13216 this.unit = unit || ( jQuery.cssNumber[ prop ] ? "" : "px" ); 13217 }, 13218 cur: function() { 13219 var hooks = Tween.propHooks[ this.prop ]; 13220 13221 return hooks && hooks.get ? 13222 hooks.get( this ) : 13223 Tween.propHooks._default.get( this ); 13224 }, 13225 run: function( percent ) { 13226 var eased, 13227 hooks = Tween.propHooks[ this.prop ]; 13228 13229 if ( this.options.duration ) { 13230 this.pos = eased = jQuery.easing[ this.easing ]( 13231 percent, this.options.duration * percent, 0, 1, this.options.duration 13232 ); 13233 } else { 13234 this.pos = eased = percent; 13235 } 13236 this.now = ( this.end - this.start ) * eased + this.start; 13237 13238 if ( this.options.step ) { 13239 this.options.step.call( this.elem, this.now, this ); 13240 } 13241 13242 if ( hooks && hooks.set ) { 13243 hooks.set( this ); 13244 } else { 13245 Tween.propHooks._default.set( this ); 13246 } 13247 return this; 13248 } 13249}; 13250 13251Tween.prototype.init.prototype = Tween.prototype; 13252 13253Tween.propHooks = { 13254 _default: { 13255 get: function( tween ) { 13256 var result; 13257 13258 // Use a property on the element directly when it is not a DOM element, 13259 // or when there is no matching style property that exists. 13260 if ( tween.elem.nodeType !== 1 || 13261 tween.elem[ tween.prop ] != null && tween.elem.style[ tween.prop ] == null ) { 13262 return tween.elem[ tween.prop ]; 13263 } 13264 13265 // Passing an empty string as a 3rd parameter to .css will automatically 13266 // attempt a parseFloat and fallback to a string if the parse fails. 13267 // Simple values such as "10px" are parsed to Float; 13268 // complex values such as "rotate(1rad)" are returned as-is. 13269 result = jQuery.css( tween.elem, tween.prop, "" ); 13270 13271 // Empty strings, null, undefined and "auto" are converted to 0. 13272 return !result || result === "auto" ? 0 : result; 13273 }, 13274 set: function( tween ) { 13275 13276 // Use step hook for back compat. 13277 // Use cssHook if its there. 13278 // Use .style if available and use plain properties where available. 13279 if ( jQuery.fx.step[ tween.prop ] ) { 13280 jQuery.fx.step[ tween.prop ]( tween ); 13281 } else if ( tween.elem.nodeType === 1 && ( 13282 jQuery.cssHooks[ tween.prop ] || 13283 tween.elem.style[ finalPropName( tween.prop ) ] != null ) ) { 13284 jQuery.style( tween.elem, tween.prop, tween.now + tween.unit ); 13285 } else { 13286 tween.elem[ tween.prop ] = tween.now; 13287 } 13288 } 13289 } 13290}; 13291 13292// Support: IE <=9 only 13293// Panic based approach to setting things on disconnected nodes 13294Tween.propHooks.scrollTop = Tween.propHooks.scrollLeft = { 13295 set: function( tween ) { 13296 if ( tween.elem.nodeType && tween.elem.parentNode ) { 13297 tween.elem[ tween.prop ] = tween.now; 13298 } 13299 } 13300}; 13301 13302jQuery.easing = { 13303 linear: function( p ) { 13304 return p; 13305 }, 13306 swing: function( p ) { 13307 return 0.5 - Math.cos( p * Math.PI ) / 2; 13308 }, 13309 _default: "swing" 13310}; 13311 13312jQuery.fx = Tween.prototype.init; 13313 13314// Back compat <1.8 extension point 13315jQuery.fx.step = {}; 13316 13317 13318 13319 13320var 13321 fxNow, inProgress, 13322 rfxtypes = /^(?:toggle|show|hide)$/, 13323 rrun = /queueHooks$/; 13324 13325function schedule() { 13326 if ( inProgress ) { 13327 if ( document.hidden === false && window.requestAnimationFrame ) { 13328 window.requestAnimationFrame( schedule ); 13329 } else { 13330 window.setTimeout( schedule, jQuery.fx.interval ); 13331 } 13332 13333 jQuery.fx.tick(); 13334 } 13335} 13336 13337// Animations created synchronously will run synchronously 13338function createFxNow() { 13339 window.setTimeout( function() { 13340 fxNow = undefined; 13341 } ); 13342 return ( fxNow = Date.now() ); 13343} 13344 13345// Generate parameters to create a standard animation 13346function genFx( type, includeWidth ) { 13347 var which, 13348 i = 0, 13349 attrs = { height: type }; 13350 13351 // If we include width, step value is 1 to do all cssExpand values, 13352 // otherwise step value is 2 to skip over Left and Right 13353 includeWidth = includeWidth ? 1 : 0; 13354 for ( ; i < 4; i += 2 - includeWidth ) { 13355 which = cssExpand[ i ]; 13356 attrs[ "margin" + which ] = attrs[ "padding" + which ] = type; 13357 } 13358 13359 if ( includeWidth ) { 13360 attrs.opacity = attrs.width = type; 13361 } 13362 13363 return attrs; 13364} 13365 13366function createTween( value, prop, animation ) { 13367 var tween, 13368 collection = ( Animation.tweeners[ prop ] || [] ).concat( Animation.tweeners[ "*" ] ), 13369 index = 0, 13370 length = collection.length; 13371 for ( ; index < length; index++ ) { 13372 if ( ( tween = collection[ index ].call( animation, prop, value ) ) ) { 13373 13374 // We're done with this property 13375 return tween; 13376 } 13377 } 13378} 13379 13380function defaultPrefilter( elem, props, opts ) { 13381 var prop, value, toggle, hooks, oldfire, propTween, restoreDisplay, display, 13382 isBox = "width" in props || "height" in props, 13383 anim = this, 13384 orig = {}, 13385 style = elem.style, 13386 hidden = elem.nodeType && isHiddenWithinTree( elem ), 13387 dataShow = dataPriv.get( elem, "fxshow" ); 13388 13389 // Queue-skipping animations hijack the fx hooks 13390 if ( !opts.queue ) { 13391 hooks = jQuery._queueHooks( elem, "fx" ); 13392 if ( hooks.unqueued == null ) { 13393 hooks.unqueued = 0; 13394 oldfire = hooks.empty.fire; 13395 hooks.empty.fire = function() { 13396 if ( !hooks.unqueued ) { 13397 oldfire(); 13398 } 13399 }; 13400 } 13401 hooks.unqueued++; 13402 13403 anim.always( function() { 13404 13405 // Ensure the complete handler is called before this completes 13406 anim.always( function() { 13407 hooks.unqueued--; 13408 if ( !jQuery.queue( elem, "fx" ).length ) { 13409 hooks.empty.fire(); 13410 } 13411 } ); 13412 } ); 13413 } 13414 13415 // Detect show/hide animations 13416 for ( prop in props ) { 13417 value = props[ prop ]; 13418 if ( rfxtypes.test( value ) ) { 13419 delete props[ prop ]; 13420 toggle = toggle || value === "toggle"; 13421 if ( value === ( hidden ? "hide" : "show" ) ) { 13422 13423 // Pretend to be hidden if this is a "show" and 13424 // there is still data from a stopped show/hide 13425 if ( value === "show" && dataShow && dataShow[ prop ] !== undefined ) { 13426 hidden = true; 13427 13428 // Ignore all other no-op show/hide data 13429 } else { 13430 continue; 13431 } 13432 } 13433 orig[ prop ] = dataShow && dataShow[ prop ] || jQuery.style( elem, prop ); 13434 } 13435 } 13436 13437 // Bail out if this is a no-op like .hide().hide() 13438 propTween = !jQuery.isEmptyObject( props ); 13439 if ( !propTween && jQuery.isEmptyObject( orig ) ) { 13440 return; 13441 } 13442 13443 // Restrict "overflow" and "display" styles during box animations 13444 if ( isBox && elem.nodeType === 1 ) { 13445 13446 // Support: IE <=9 - 11, Edge 12 - 15 13447 // Record all 3 overflow attributes because IE does not infer the shorthand 13448 // from identically-valued overflowX and overflowY and Edge just mirrors 13449 // the overflowX value there. 13450 opts.overflow = [ style.overflow, style.overflowX, style.overflowY ]; 13451 13452 // Identify a display type, preferring old show/hide data over the CSS cascade 13453 restoreDisplay = dataShow && dataShow.display; 13454 if ( restoreDisplay == null ) { 13455 restoreDisplay = dataPriv.get( elem, "display" ); 13456 } 13457 display = jQuery.css( elem, "display" ); 13458 if ( display === "none" ) { 13459 if ( restoreDisplay ) { 13460 display = restoreDisplay; 13461 } else { 13462 13463 // Get nonempty value(s) by temporarily forcing visibility 13464 showHide( [ elem ], true ); 13465 restoreDisplay = elem.style.display || restoreDisplay; 13466 display = jQuery.css( elem, "display" ); 13467 showHide( [ elem ] ); 13468 } 13469 } 13470 13471 // Animate inline elements as inline-block 13472 if ( display === "inline" || display === "inline-block" && restoreDisplay != null ) { 13473 if ( jQuery.css( elem, "float" ) === "none" ) { 13474 13475 // Restore the original display value at the end of pure show/hide animations 13476 if ( !propTween ) { 13477 anim.done( function() { 13478 style.display = restoreDisplay; 13479 } ); 13480 if ( restoreDisplay == null ) { 13481 display = style.display; 13482 restoreDisplay = display === "none" ? "" : display; 13483 } 13484 } 13485 style.display = "inline-block"; 13486 } 13487 } 13488 } 13489 13490 if ( opts.overflow ) { 13491 style.overflow = "hidden"; 13492 anim.always( function() { 13493 style.overflow = opts.overflow[ 0 ]; 13494 style.overflowX = opts.overflow[ 1 ]; 13495 style.overflowY = opts.overflow[ 2 ]; 13496 } ); 13497 } 13498 13499 // Implement show/hide animations 13500 propTween = false; 13501 for ( prop in orig ) { 13502 13503 // General show/hide setup for this element animation 13504 if ( !propTween ) { 13505 if ( dataShow ) { 13506 if ( "hidden" in dataShow ) { 13507 hidden = dataShow.hidden; 13508 } 13509 } else { 13510 dataShow = dataPriv.access( elem, "fxshow", { display: restoreDisplay } ); 13511 } 13512 13513 // Store hidden/visible for toggle so `.stop().toggle()` "reverses" 13514 if ( toggle ) { 13515 dataShow.hidden = !hidden; 13516 } 13517 13518 // Show elements before animating them 13519 if ( hidden ) { 13520 showHide( [ elem ], true ); 13521 } 13522 13523 /* eslint-disable no-loop-func */ 13524 13525 anim.done( function() { 13526 13527 /* eslint-enable no-loop-func */ 13528 13529 // The final step of a "hide" animation is actually hiding the element 13530 if ( !hidden ) { 13531 showHide( [ elem ] ); 13532 } 13533 dataPriv.remove( elem, "fxshow" ); 13534 for ( prop in orig ) { 13535 jQuery.style( elem, prop, orig[ prop ] ); 13536 } 13537 } ); 13538 } 13539 13540 // Per-property setup 13541 propTween = createTween( hidden ? dataShow[ prop ] : 0, prop, anim ); 13542 if ( !( prop in dataShow ) ) { 13543 dataShow[ prop ] = propTween.start; 13544 if ( hidden ) { 13545 propTween.end = propTween.start; 13546 propTween.start = 0; 13547 } 13548 } 13549 } 13550} 13551 13552function propFilter( props, specialEasing ) { 13553 var index, name, easing, value, hooks; 13554 13555 // camelCase, specialEasing and expand cssHook pass 13556 for ( index in props ) { 13557 name = camelCase( index ); 13558 easing = specialEasing[ name ]; 13559 value = props[ index ]; 13560 if ( Array.isArray( value ) ) { 13561 easing = value[ 1 ]; 13562 value = props[ index ] = value[ 0 ]; 13563 } 13564 13565 if ( index !== name ) { 13566 props[ name ] = value; 13567 delete props[ index ]; 13568 } 13569 13570 hooks = jQuery.cssHooks[ name ]; 13571 if ( hooks && "expand" in hooks ) { 13572 value = hooks.expand( value ); 13573 delete props[ name ]; 13574 13575 // Not quite $.extend, this won't overwrite existing keys. 13576 // Reusing 'index' because we have the correct "name" 13577 for ( index in value ) { 13578 if ( !( index in props ) ) { 13579 props[ index ] = value[ index ]; 13580 specialEasing[ index ] = easing; 13581 } 13582 } 13583 } else { 13584 specialEasing[ name ] = easing; 13585 } 13586 } 13587} 13588 13589function Animation( elem, properties, options ) { 13590 var result, 13591 stopped, 13592 index = 0, 13593 length = Animation.prefilters.length, 13594 deferred = jQuery.Deferred().always( function() { 13595 13596 // Don't match elem in the :animated selector 13597 delete tick.elem; 13598 } ), 13599 tick = function() { 13600 if ( stopped ) { 13601 return false; 13602 } 13603 var currentTime = fxNow || createFxNow(), 13604 remaining = Math.max( 0, animation.startTime + animation.duration - currentTime ), 13605
vendor: 9,542 bytes, lines 13606-13996
13606 // Support: Android 2.3 only 13607 // Archaic crash bug won't allow us to use `1 - ( 0.5 || 0 )` (trac-12497) 13608 temp = remaining / animation.duration || 0, 13609 percent = 1 - temp, 13610 index = 0, 13611 length = animation.tweens.length; 13612 13613 for ( ; index < length; index++ ) { 13614 animation.tweens[ index ].run( percent ); 13615 } 13616 13617 deferred.notifyWith( elem, [ animation, percent, remaining ] ); 13618 13619 // If there's more to do, yield 13620 if ( percent < 1 && length ) { 13621 return remaining; 13622 } 13623 13624 // If this was an empty animation, synthesize a final progress notification 13625 if ( !length ) { 13626 deferred.notifyWith( elem, [ animation, 1, 0 ] ); 13627 } 13628 13629 // Resolve the animation and report its conclusion 13630 deferred.resolveWith( elem, [ animation ] ); 13631 return false; 13632 }, 13633 animation = deferred.promise( { 13634 elem: elem, 13635 props: jQuery.extend( {}, properties ), 13636 opts: jQuery.extend( true, { 13637 specialEasing: {}, 13638 easing: jQuery.easing._default 13639 }, options ), 13640 originalProperties: properties, 13641 originalOptions: options, 13642 startTime: fxNow || createFxNow(), 13643 duration: options.duration, 13644 tweens: [], 13645 createTween: function( prop, end ) { 13646 var tween = jQuery.Tween( elem, animation.opts, prop, end, 13647 animation.opts.specialEasing[ prop ] || animation.opts.easing ); 13648 animation.tweens.push( tween ); 13649 return tween; 13650 }, 13651 stop: function( gotoEnd ) { 13652 var index = 0, 13653 13654 // If we are going to the end, we want to run all the tweens 13655 // otherwise we skip this part 13656 length = gotoEnd ? animation.tweens.length : 0; 13657 if ( stopped ) { 13658 return this; 13659 } 13660 stopped = true; 13661 for ( ; index < length; index++ ) { 13662 animation.tweens[ index ].run( 1 ); 13663 } 13664 13665 // Resolve when we played the last frame; otherwise, reject 13666 if ( gotoEnd ) { 13667 deferred.notifyWith( elem, [ animation, 1, 0 ] ); 13668 deferred.resolveWith( elem, [ animation, gotoEnd ] ); 13669 } else { 13670 deferred.rejectWith( elem, [ animation, gotoEnd ] ); 13671 } 13672 return this; 13673 } 13674 } ), 13675 props = animation.props; 13676 13677 propFilter( props, animation.opts.specialEasing ); 13678 13679 for ( ; index < length; index++ ) { 13680 result = Animation.prefilters[ index ].call( animation, elem, props, animation.opts ); 13681 if ( result ) { 13682 if ( isFunction( result.stop ) ) { 13683 jQuery._queueHooks( animation.elem, animation.opts.queue ).stop = 13684 result.stop.bind( result ); 13685 } 13686 return result; 13687 } 13688 } 13689 13690 jQuery.map( props, createTween, animation ); 13691 13692 if ( isFunction( animation.opts.start ) ) { 13693 animation.opts.start.call( elem, animation ); 13694 } 13695 13696 // Attach callbacks from options 13697 animation 13698 .progress( animation.opts.progress ) 13699 .done( animation.opts.done, animation.opts.complete ) 13700 .fail( animation.opts.fail ) 13701 .always( animation.opts.always ); 13702 13703 jQuery.fx.timer( 13704 jQuery.extend( tick, { 13705 elem: elem, 13706 anim: animation, 13707 queue: animation.opts.queue 13708 } ) 13709 ); 13710 13711 return animation; 13712} 13713 13714jQuery.Animation = jQuery.extend( Animation, { 13715 13716 tweeners: { 13717 "*": [ function( prop, value ) { 13718 var tween = this.createTween( prop, value ); 13719 adjustCSS( tween.elem, prop, rcssNum.exec( value ), tween ); 13720 return tween; 13721 } ] 13722 }, 13723 13724 tweener: function( props, callback ) { 13725 if ( isFunction( props ) ) { 13726 callback = props; 13727 props = [ "*" ]; 13728 } else { 13729 props = props.match( rnothtmlwhite ); 13730 } 13731 13732 var prop, 13733 index = 0, 13734 length = props.length; 13735 13736 for ( ; index < length; index++ ) { 13737 prop = props[ index ]; 13738 Animation.tweeners[ prop ] = Animation.tweeners[ prop ] || []; 13739 Animation.tweeners[ prop ].unshift( callback ); 13740 } 13741 }, 13742 13743 prefilters: [ defaultPrefilter ], 13744 13745 prefilter: function( callback, prepend ) { 13746 if ( prepend ) { 13747 Animation.prefilters.unshift( callback ); 13748 } else { 13749 Animation.prefilters.push( callback ); 13750 } 13751 } 13752} ); 13753 13754jQuery.speed = function( speed, easing, fn ) { 13755 var opt = speed && typeof speed === "object" ? jQuery.extend( {}, speed ) : { 13756 complete: fn || !fn && easing || 13757 isFunction( speed ) && speed, 13758 duration: speed, 13759 easing: fn && easing || easing && !isFunction( easing ) && easing 13760 }; 13761 13762 // Go to the end state if fx are off 13763 if ( jQuery.fx.off ) { 13764 opt.duration = 0; 13765 13766 } else { 13767 if ( typeof opt.duration !== "number" ) { 13768 if ( opt.duration in jQuery.fx.speeds ) { 13769 opt.duration = jQuery.fx.speeds[ opt.duration ]; 13770 13771 } else { 13772 opt.duration = jQuery.fx.speeds._default; 13773 } 13774 } 13775 } 13776 13777 // Normalize opt.queue - true/undefined/null -> "fx" 13778 if ( opt.queue == null || opt.queue === true ) { 13779 opt.queue = "fx"; 13780 } 13781 13782 // Queueing 13783 opt.old = opt.complete; 13784 13785 opt.complete = function() { 13786 if ( isFunction( opt.old ) ) { 13787 opt.old.call( this ); 13788 } 13789 13790 if ( opt.queue ) { 13791 jQuery.dequeue( this, opt.queue ); 13792 } 13793 }; 13794 13795 return opt; 13796}; 13797 13798jQuery.fn.extend( { 13799 fadeTo: function( speed, to, easing, callback ) { 13800 13801 // Show any hidden elements after setting opacity to 0 13802 return this.filter( isHiddenWithinTree ).css( "opacity", 0 ).show() 13803 13804 // Animate to the value specified 13805 .end().animate( { opacity: to }, speed, easing, callback ); 13806 }, 13807 animate: function( prop, speed, easing, callback ) { 13808 var empty = jQuery.isEmptyObject( prop ), 13809 optall = jQuery.speed( speed, easing, callback ), 13810 doAnimation = function() { 13811 13812 // Operate on a copy of prop so per-property easing won't be lost 13813 var anim = Animation( this, jQuery.extend( {}, prop ), optall ); 13814 13815 // Empty animations, or finishing resolves immediately 13816 if ( empty || dataPriv.get( this, "finish" ) ) { 13817 anim.stop( true ); 13818 } 13819 }; 13820 13821 doAnimation.finish = doAnimation; 13822 13823 return empty || optall.queue === false ? 13824 this.each( doAnimation ) : 13825 this.queue( optall.queue, doAnimation ); 13826 }, 13827 stop: function( type, clearQueue, gotoEnd ) { 13828 var stopQueue = function( hooks ) { 13829 var stop = hooks.stop; 13830 delete hooks.stop; 13831 stop( gotoEnd ); 13832 }; 13833 13834 if ( typeof type !== "string" ) { 13835 gotoEnd = clearQueue; 13836 clearQueue = type; 13837 type = undefined; 13838 } 13839 if ( clearQueue ) { 13840 this.queue( type || "fx", [] ); 13841 } 13842 13843 return this.each( function() { 13844 var dequeue = true, 13845 index = type != null && type + "queueHooks", 13846 timers = jQuery.timers, 13847 data = dataPriv.get( this ); 13848 13849 if ( index ) { 13850 if ( data[ index ] && data[ index ].stop ) { 13851 stopQueue( data[ index ] ); 13852 } 13853 } else { 13854 for ( index in data ) { 13855 if ( data[ index ] && data[ index ].stop && rrun.test( index ) ) { 13856 stopQueue( data[ index ] ); 13857 } 13858 } 13859 } 13860 13861 for ( index = timers.length; index--; ) { 13862 if ( timers[ index ].elem === this && 13863 ( type == null || timers[ index ].queue === type ) ) { 13864 13865 timers[ index ].anim.stop( gotoEnd ); 13866 dequeue = false; 13867 timers.splice( index, 1 ); 13868 } 13869 } 13870 13871 // Start the next in the queue if the last step wasn't forced. 13872 // Timers currently will call their complete callbacks, which 13873 // will dequeue but only if they were gotoEnd. 13874 if ( dequeue || !gotoEnd ) { 13875 jQuery.dequeue( this, type ); 13876 } 13877 } ); 13878 }, 13879 finish: function( type ) { 13880 if ( type !== false ) { 13881 type = type || "fx"; 13882 } 13883 return this.each( function() { 13884 var index, 13885 data = dataPriv.get( this ), 13886 queue = data[ type + "queue" ], 13887 hooks = data[ type + "queueHooks" ], 13888 timers = jQuery.timers, 13889 length = queue ? queue.length : 0; 13890 13891 // Enable finishing flag on private data 13892 data.finish = true; 13893 13894 // Empty the queue first 13895 jQuery.queue( this, type, [] ); 13896 13897 if ( hooks && hooks.stop ) { 13898 hooks.stop.call( this, true ); 13899 } 13900 13901 // Look for any active animations, and finish them 13902 for ( index = timers.length; index--; ) { 13903 if ( timers[ index ].elem === this && timers[ index ].queue === type ) { 13904 timers[ index ].anim.stop( true ); 13905 timers.splice( index, 1 ); 13906 } 13907 } 13908 13909 // Look for any animations in the old queue and finish them 13910 for ( index = 0; index < length; index++ ) { 13911 if ( queue[ index ] && queue[ index ].finish ) { 13912 queue[ index ].finish.call( this ); 13913 } 13914 } 13915 13916 // Turn off finishing flag 13917 delete data.finish; 13918 } ); 13919 } 13920} ); 13921 13922jQuery.each( [ "toggle", "show", "hide" ], function( _i, name ) { 13923 var cssFn = jQuery.fn[ name ]; 13924 jQuery.fn[ name ] = function( speed, easing, callback ) { 13925 return speed == null || typeof speed === "boolean" ? 13926 cssFn.apply( this, arguments ) : 13927 this.animate( genFx( name, true ), speed, easing, callback ); 13928 }; 13929} ); 13930 13931// Generate shortcuts for custom animations 13932jQuery.each( { 13933 slideDown: genFx( "show" ), 13934 slideUp: genFx( "hide" ), 13935 slideToggle: genFx( "toggle" ), 13936 fadeIn: { opacity: "show" }, 13937 fadeOut: { opacity: "hide" }, 13938 fadeToggle: { opacity: "toggle" } 13939}, function( name, props ) { 13940 jQuery.fn[ name ] = function( speed, easing, callback ) { 13941 return this.animate( props, speed, easing, callback ); 13942 }; 13943} ); 13944 13945jQuery.timers = []; 13946jQuery.fx.tick = function() { 13947 var timer, 13948 i = 0, 13949 timers = jQuery.timers; 13950 13951 fxNow = Date.now(); 13952 13953 for ( ; i < timers.length; i++ ) { 13954 timer = timers[ i ]; 13955 13956 // Run the timer and safely remove it when done (allowing for external removal) 13957 if ( !timer() && timers[ i ] === timer ) { 13958 timers.splice( i--, 1 ); 13959 } 13960 } 13961 13962 if ( !timers.length ) { 13963 jQuery.fx.stop(); 13964 } 13965 fxNow = undefined; 13966}; 13967 13968jQuery.fx.timer = function( timer ) { 13969 jQuery.timers.push( timer ); 13970 jQuery.fx.start(); 13971}; 13972 13973jQuery.fx.interval = 13; 13974jQuery.fx.start = function() { 13975 if ( inProgress ) { 13976 return; 13977 } 13978 13979 inProgress = true; 13980 schedule(); 13981}; 13982 13983jQuery.fx.stop = function() { 13984 inProgress = null; 13985}; 13986 13987jQuery.fx.speeds = { 13988 slow: 600, 13989 fast: 200, 13990 13991 // Default speed 13992 _default: 400 13993}; 13994 13995 13996// Based off of the plugin by Clint Helfers, with permission.
vendor: 5,177 bytes, lines 13997-14217
13997jQuery.fn.delay = function( time, type ) { 13998 time = jQuery.fx ? jQuery.fx.speeds[ time ] || time : time; 13999 type = type || "fx"; 14000 14001 return this.queue( type, function( next, hooks ) { 14002 var timeout = window.setTimeout( next, time ); 14003 hooks.stop = function() { 14004 window.clearTimeout( timeout ); 14005 }; 14006 } ); 14007}; 14008 14009 14010( function() { 14011 var input = document.createElement( "input" ), 14012 select = document.createElement( "select" ), 14013 opt = select.appendChild( document.createElement( "option" ) ); 14014 14015 input.type = "checkbox"; 14016 14017 // Support: Android <=4.3 only 14018 // Default value for a checkbox should be "on" 14019 support.checkOn = input.value !== ""; 14020 14021 // Support: IE <=11 only 14022 // Must access selectedIndex to make default options select 14023 support.optSelected = opt.selected; 14024 14025 // Support: IE <=11 only 14026 // An input loses its value after becoming a radio 14027 input = document.createElement( "input" ); 14028 input.value = "t"; 14029 input.type = "radio"; 14030 support.radioValue = input.value === "t"; 14031} )(); 14032 14033 14034var boolHook, 14035 attrHandle = jQuery.expr.attrHandle; 14036 14037jQuery.fn.extend( { 14038 attr: function( name, value ) { 14039 return access( this, jQuery.attr, name, value, arguments.length > 1 ); 14040 }, 14041 14042 removeAttr: function( name ) { 14043 return this.each( function() { 14044 jQuery.removeAttr( this, name ); 14045 } ); 14046 } 14047} ); 14048 14049jQuery.extend( { 14050 attr: function( elem, name, value ) { 14051 var ret, hooks, 14052 nType = elem.nodeType; 14053 14054 // Don't get/set attributes on text, comment and attribute nodes 14055 if ( nType === 3 || nType === 8 || nType === 2 ) { 14056 return; 14057 } 14058 14059 // Fallback to prop when attributes are not supported 14060 if ( typeof elem.getAttribute === "undefined" ) { 14061 return jQuery.prop( elem, name, value ); 14062 } 14063 14064 // Attribute hooks are determined by the lowercase version 14065 // Grab necessary hook if one is defined 14066 if ( nType !== 1 || !jQuery.isXMLDoc( elem ) ) { 14067 hooks = jQuery.attrHooks[ name.toLowerCase() ] || 14068 ( jQuery.expr.match.bool.test( name ) ? boolHook : undefined ); 14069 } 14070 14071 if ( value !== undefined ) { 14072 if ( value === null ) { 14073 jQuery.removeAttr( elem, name ); 14074 return; 14075 } 14076 14077 if ( hooks && "set" in hooks && 14078 ( ret = hooks.set( elem, value, name ) ) !== undefined ) { 14079 return ret; 14080 } 14081 14082 elem.setAttribute( name, value + "" ); 14083 return value; 14084 } 14085 14086 if ( hooks && "get" in hooks && ( ret = hooks.get( elem, name ) ) !== null ) { 14087 return ret; 14088 } 14089 14090 ret = jQuery.find.attr( elem, name ); 14091 14092 // Non-existent attributes return null, we normalize to undefined 14093 return ret == null ? undefined : ret; 14094 }, 14095 14096 attrHooks: { 14097 type: { 14098 set: function( elem, value ) { 14099 if ( !support.radioValue && value === "radio" && 14100 nodeName( elem, "input" ) ) { 14101 var val = elem.value; 14102 elem.setAttribute( "type", value ); 14103 if ( val ) { 14104 elem.value = val; 14105 } 14106 return value; 14107 } 14108 } 14109 } 14110 }, 14111 14112 removeAttr: function( elem, value ) { 14113 var name, 14114 i = 0, 14115 14116 // Attribute names can contain non-HTML whitespace characters 14117 // https://html.spec.whatwg.org/multipage/syntax.html#attributes-2 14118 attrNames = value && value.match( rnothtmlwhite ); 14119 14120 if ( attrNames && elem.nodeType === 1 ) { 14121 while ( ( name = attrNames[ i++ ] ) ) { 14122 elem.removeAttribute( name ); 14123 } 14124 } 14125 } 14126} ); 14127 14128// Hooks for boolean attributes 14129boolHook = { 14130 set: function( elem, value, name ) { 14131 if ( value === false ) { 14132 14133 // Remove boolean attributes when set to false 14134 jQuery.removeAttr( elem, name ); 14135 } else { 14136 elem.setAttribute( name, name ); 14137 } 14138 return name; 14139 } 14140}; 14141 14142jQuery.each( jQuery.expr.match.bool.source.match( /\w+/g ), function( _i, name ) { 14143 var getter = attrHandle[ name ] || jQuery.find.attr; 14144 14145 attrHandle[ name ] = function( elem, name, isXML ) { 14146 var ret, handle, 14147 lowercaseName = name.toLowerCase(); 14148 14149 if ( !isXML ) { 14150 14151 // Avoid an infinite loop by temporarily removing this function from the getter 14152 handle = attrHandle[ lowercaseName ]; 14153 attrHandle[ lowercaseName ] = ret; 14154 ret = getter( elem, name, isXML ) != null ? 14155 lowercaseName : 14156 null; 14157 attrHandle[ lowercaseName ] = handle; 14158 } 14159 return ret; 14160 }; 14161} ); 14162 14163 14164 14165 14166var rfocusable = /^(?:input|select|textarea|button)$/i, 14167 rclickable = /^(?:a|area)$/i; 14168 14169jQuery.fn.extend( { 14170 prop: function( name, value ) { 14171 return access( this, jQuery.prop, name, value, arguments.length > 1 ); 14172 }, 14173 14174 removeProp: function( name ) { 14175 return this.each( function() { 14176 delete this[ jQuery.propFix[ name ] || name ]; 14177 } ); 14178 } 14179} ); 14180 14181jQuery.extend( { 14182 prop: function( elem, name, value ) { 14183 var ret, hooks, 14184 nType = elem.nodeType; 14185 14186 // Don't get/set properties on text, comment and attribute nodes 14187 if ( nType === 3 || nType === 8 || nType === 2 ) { 14188 return; 14189 } 14190 14191 if ( nType !== 1 || !jQuery.isXMLDoc( elem ) ) { 14192 14193 // Fix name and attach hooks 14194 name = jQuery.propFix[ name ] || name; 14195 hooks = jQuery.propHooks[ name ]; 14196 } 14197 14198 if ( value !== undefined ) { 14199 if ( hooks && "set" in hooks && 14200 ( ret = hooks.set( elem, value, name ) ) !== undefined ) { 14201 return ret; 14202 } 14203 14204 return ( elem[ name ] = value ); 14205 } 14206 14207 if ( hooks && "get" in hooks && ( ret = hooks.get( elem, name ) ) !== null ) { 14208 return ret; 14209 } 14210 14211 return elem[ name ]; 14212 }, 14213 14214 propHooks: { 14215 tabIndex: { 14216 get: function( elem ) { 14217
vendor: 6,126 bytes, lines 14218-14477
14218 // Support: IE <=9 - 11 only 14219 // elem.tabIndex doesn't always return the 14220 // correct value when it hasn't been explicitly set 14221 // Use proper attribute retrieval (trac-12072) 14222 var tabindex = jQuery.find.attr( elem, "tabindex" ); 14223 14224 if ( tabindex ) { 14225 return parseInt( tabindex, 10 ); 14226 } 14227 14228 if ( 14229 rfocusable.test( elem.nodeName ) || 14230 rclickable.test( elem.nodeName ) && 14231 elem.href 14232 ) { 14233 return 0; 14234 } 14235 14236 return -1; 14237 } 14238 } 14239 }, 14240 14241 propFix: { 14242 "for": "htmlFor", 14243 "class": "className" 14244 } 14245} ); 14246 14247// Support: IE <=11 only 14248// Accessing the selectedIndex property 14249// forces the browser to respect setting selected 14250// on the option 14251// The getter ensures a default option is selected 14252// when in an optgroup 14253// eslint rule "no-unused-expressions" is disabled for this code 14254// since it considers such accessions noop 14255if ( !support.optSelected ) { 14256 jQuery.propHooks.selected = { 14257 get: function( elem ) { 14258 14259 /* eslint no-unused-expressions: "off" */ 14260 14261 var parent = elem.parentNode; 14262 if ( parent && parent.parentNode ) { 14263 parent.parentNode.selectedIndex; 14264 } 14265 return null; 14266 }, 14267 set: function( elem ) { 14268 14269 /* eslint no-unused-expressions: "off" */ 14270 14271 var parent = elem.parentNode; 14272 if ( parent ) { 14273 parent.selectedIndex; 14274 14275 if ( parent.parentNode ) { 14276 parent.parentNode.selectedIndex; 14277 } 14278 } 14279 } 14280 }; 14281} 14282 14283jQuery.each( [ 14284 "tabIndex", 14285 "readOnly", 14286 "maxLength", 14287 "cellSpacing", 14288 "cellPadding", 14289 "rowSpan", 14290 "colSpan", 14291 "useMap", 14292 "frameBorder", 14293 "contentEditable" 14294], function() { 14295 jQuery.propFix[ this.toLowerCase() ] = this; 14296} ); 14297 14298 14299 14300 14301 // Strip and collapse whitespace according to HTML spec 14302 // https://infra.spec.whatwg.org/#strip-and-collapse-ascii-whitespace 14303 function stripAndCollapse( value ) { 14304 var tokens = value.match( rnothtmlwhite ) || []; 14305 return tokens.join( " " ); 14306 } 14307 14308 14309function getClass( elem ) { 14310 return elem.getAttribute && elem.getAttribute( "class" ) || ""; 14311} 14312 14313function classesToArray( value ) { 14314 if ( Array.isArray( value ) ) { 14315 return value; 14316 } 14317 if ( typeof value === "string" ) { 14318 return value.match( rnothtmlwhite ) || []; 14319 } 14320 return []; 14321} 14322 14323jQuery.fn.extend( { 14324 addClass: function( value ) { 14325 var classNames, cur, curValue, className, i, finalValue; 14326 14327 if ( isFunction( value ) ) { 14328 return this.each( function( j ) { 14329 jQuery( this ).addClass( value.call( this, j, getClass( this ) ) ); 14330 } ); 14331 } 14332 14333 classNames = classesToArray( value ); 14334 14335 if ( classNames.length ) { 14336 return this.each( function() { 14337 curValue = getClass( this ); 14338 cur = this.nodeType === 1 && ( " " + stripAndCollapse( curValue ) + " " ); 14339 14340 if ( cur ) { 14341 for ( i = 0; i < classNames.length; i++ ) { 14342 className = classNames[ i ]; 14343 if ( cur.indexOf( " " + className + " " ) < 0 ) { 14344 cur += className + " "; 14345 } 14346 } 14347 14348 // Only assign if different to avoid unneeded rendering. 14349 finalValue = stripAndCollapse( cur ); 14350 if ( curValue !== finalValue ) { 14351 this.setAttribute( "class", finalValue ); 14352 } 14353 } 14354 } ); 14355 } 14356 14357 return this; 14358 }, 14359 14360 removeClass: function( value ) { 14361 var classNames, cur, curValue, className, i, finalValue; 14362 14363 if ( isFunction( value ) ) { 14364 return this.each( function( j ) { 14365 jQuery( this ).removeClass( value.call( this, j, getClass( this ) ) ); 14366 } ); 14367 } 14368 14369 if ( !arguments.length ) { 14370 return this.attr( "class", "" ); 14371 } 14372 14373 classNames = classesToArray( value ); 14374 14375 if ( classNames.length ) { 14376 return this.each( function() { 14377 curValue = getClass( this ); 14378 14379 // This expression is here for better compressibility (see addClass) 14380 cur = this.nodeType === 1 && ( " " + stripAndCollapse( curValue ) + " " ); 14381 14382 if ( cur ) { 14383 for ( i = 0; i < classNames.length; i++ ) { 14384 className = classNames[ i ]; 14385 14386 // Remove *all* instances 14387 while ( cur.indexOf( " " + className + " " ) > -1 ) { 14388 cur = cur.replace( " " + className + " ", " " ); 14389 } 14390 } 14391 14392 // Only assign if different to avoid unneeded rendering. 14393 finalValue = stripAndCollapse( cur ); 14394 if ( curValue !== finalValue ) { 14395 this.setAttribute( "class", finalValue ); 14396 } 14397 } 14398 } ); 14399 } 14400 14401 return this; 14402 }, 14403 14404 toggleClass: function( value, stateVal ) { 14405 var classNames, className, i, self, 14406 type = typeof value, 14407 isValidValue = type === "string" || Array.isArray( value ); 14408 14409 if ( isFunction( value ) ) { 14410 return this.each( function( i ) { 14411 jQuery( this ).toggleClass( 14412 value.call( this, i, getClass( this ), stateVal ), 14413 stateVal 14414 ); 14415 } ); 14416 } 14417 14418 if ( typeof stateVal === "boolean" && isValidValue ) { 14419 return stateVal ? this.addClass( value ) : this.removeClass( value ); 14420 } 14421 14422 classNames = classesToArray( value ); 14423 14424 return this.each( function() { 14425 if ( isValidValue ) { 14426 14427 // Toggle individual class names 14428 self = jQuery( this ); 14429 14430 for ( i = 0; i < classNames.length; i++ ) { 14431 className = classNames[ i ]; 14432 14433 // Check each className given, space separated list 14434 if ( self.hasClass( className ) ) { 14435 self.removeClass( className ); 14436 } else { 14437 self.addClass( className ); 14438 } 14439 } 14440 14441 // Toggle whole class name 14442 } else if ( value === undefined || type === "boolean" ) { 14443 className = getClass( this ); 14444 if ( className ) { 14445 14446 // Store className if set 14447 dataPriv.set( this, "__className__", className ); 14448 } 14449 14450 // If the element has a class name or if we're passed `false`, 14451 // then remove the whole classname (if there was one, the above saved it). 14452 // Otherwise bring back whatever was previously saved (if anything), 14453 // falling back to the empty string if nothing was stored. 14454 if ( this.setAttribute ) { 14455 this.setAttribute( "class", 14456 className || value === false ? 14457 "" : 14458 dataPriv.get( this, "__className__" ) || "" 14459 ); 14460 } 14461 } 14462 } ); 14463 }, 14464 14465 hasClass: function( selector ) { 14466 var className, elem, 14467 i = 0; 14468 14469 className = " " + selector + " "; 14470 while ( ( elem = this[ i++ ] ) ) { 14471 if ( elem.nodeType === 1 && 14472 ( " " + stripAndCollapse( getClass( elem ) ) + " " ).indexOf( className ) > -1 ) { 14473 return true; 14474 } 14475 } 14476 14477 return false;
vendor: 1,385 bytes, lines 14478-14547
14478 } 14479} ); 14480 14481 14482 14483 14484var rreturn = /\r/g; 14485 14486jQuery.fn.extend( { 14487 val: function( value ) { 14488 var hooks, ret, valueIsFunction, 14489 elem = this[ 0 ]; 14490 14491 if ( !arguments.length ) { 14492 if ( elem ) { 14493 hooks = jQuery.valHooks[ elem.type ] || 14494 jQuery.valHooks[ elem.nodeName.toLowerCase() ]; 14495 14496 if ( hooks && 14497 "get" in hooks && 14498 ( ret = hooks.get( elem, "value" ) ) !== undefined 14499 ) { 14500 return ret; 14501 } 14502 14503 ret = elem.value; 14504 14505 // Handle most common string cases 14506 if ( typeof ret === "string" ) { 14507 return ret.replace( rreturn, "" ); 14508 } 14509 14510 // Handle cases where value is null/undef or number 14511 return ret == null ? "" : ret; 14512 } 14513 14514 return; 14515 } 14516 14517 valueIsFunction = isFunction( value ); 14518 14519 return this.each( function( i ) { 14520 var val; 14521 14522 if ( this.nodeType !== 1 ) { 14523 return; 14524 } 14525 14526 if ( valueIsFunction ) { 14527 val = value.call( this, i, jQuery( this ).val() ); 14528 } else { 14529 val = value; 14530 } 14531 14532 // Treat null/undefined as ""; convert numbers to string 14533 if ( val == null ) { 14534 val = ""; 14535 14536 } else if ( typeof val === "number" ) { 14537 val += ""; 14538 14539 } else if ( Array.isArray( val ) ) { 14540 val = jQuery.map( val, function( value ) { 14541 return value == null ? "" : value + ""; 14542 } ); 14543 } 14544 14545 hooks = jQuery.valHooks[ this.type ] || jQuery.valHooks[ this.nodeName.toLowerCase() ]; 14546 14547 // If set returns undefined, fall back to normal setting
vendor: 4,458 bytes, lines 14548-14733
14548 if ( !hooks || !( "set" in hooks ) || hooks.set( this, val, "value" ) === undefined ) { 14549 this.value = val; 14550 } 14551 } ); 14552 } 14553} ); 14554 14555jQuery.extend( { 14556 valHooks: { 14557 option: { 14558 get: function( elem ) { 14559 14560 var val = jQuery.find.attr( elem, "value" ); 14561 return val != null ? 14562 val : 14563 14564 // Support: IE <=10 - 11 only 14565 // option.text throws exceptions (trac-14686, trac-14858) 14566 // Strip and collapse whitespace 14567 // https://html.spec.whatwg.org/#strip-and-collapse-whitespace 14568 stripAndCollapse( jQuery.text( elem ) ); 14569 } 14570 }, 14571 select: { 14572 get: function( elem ) { 14573 var value, option, i, 14574 options = elem.options, 14575 index = elem.selectedIndex, 14576 one = elem.type === "select-one", 14577 values = one ? null : [], 14578 max = one ? index + 1 : options.length; 14579 14580 if ( index < 0 ) { 14581 i = max; 14582 14583 } else { 14584 i = one ? index : 0; 14585 } 14586 14587 // Loop through all the selected options 14588 for ( ; i < max; i++ ) { 14589 option = options[ i ]; 14590 14591 // Support: IE <=9 only 14592 // IE8-9 doesn't update selected after form reset (trac-2551) 14593 if ( ( option.selected || i === index ) && 14594 14595 // Don't return options that are disabled or in a disabled optgroup 14596 !option.disabled && 14597 ( !option.parentNode.disabled || 14598 !nodeName( option.parentNode, "optgroup" ) ) ) { 14599 14600 // Get the specific value for the option 14601 value = jQuery( option ).val(); 14602 14603 // We don't need an array for one selects 14604 if ( one ) { 14605 return value; 14606 } 14607 14608 // Multi-Selects return an array 14609 values.push( value ); 14610 } 14611 } 14612 14613 return values; 14614 }, 14615 14616 set: function( elem, value ) { 14617 var optionSet, option, 14618 options = elem.options, 14619 values = jQuery.makeArray( value ), 14620 i = options.length; 14621 14622 while ( i-- ) { 14623 option = options[ i ]; 14624 14625 /* eslint-disable no-cond-assign */ 14626 14627 if ( option.selected = 14628 jQuery.inArray( jQuery.valHooks.option.get( option ), values ) > -1 14629 ) { 14630 optionSet = true; 14631 } 14632 14633 /* eslint-enable no-cond-assign */ 14634 } 14635 14636 // Force browsers to behave consistently when non-matching value is set 14637 if ( !optionSet ) { 14638 elem.selectedIndex = -1; 14639 } 14640 return values; 14641 } 14642 } 14643 } 14644} ); 14645 14646// Radios and checkboxes getter/setter 14647jQuery.each( [ "radio", "checkbox" ], function() { 14648 jQuery.valHooks[ this ] = { 14649 set: function( elem, value ) { 14650 if ( Array.isArray( value ) ) { 14651 return ( elem.checked = jQuery.inArray( jQuery( elem ).val(), value ) > -1 ); 14652 } 14653 } 14654 }; 14655 if ( !support.checkOn ) { 14656 jQuery.valHooks[ this ].get = function( elem ) { 14657 return elem.getAttribute( "value" ) === null ? "on" : elem.value; 14658 }; 14659 } 14660} ); 14661 14662 14663 14664 14665// Return jQuery for attributes-only inclusion 14666var location = window.location; 14667 14668var nonce = { guid: Date.now() }; 14669 14670var rquery = ( /\?/ ); 14671 14672 14673 14674// Cross-browser xml parsing 14675jQuery.parseXML = function( data ) { 14676 var xml, parserErrorElem; 14677 if ( !data || typeof data !== "string" ) { 14678 return null; 14679 } 14680 14681 // Support: IE 9 - 11 only 14682 // IE throws on parseFromString with invalid input. 14683 try { 14684 xml = ( new window.DOMParser() ).parseFromString( data, "text/xml" ); 14685 } catch ( e ) {} 14686 14687 parserErrorElem = xml && xml.getElementsByTagName( "parsererror" )[ 0 ]; 14688 if ( !xml || parserErrorElem ) { 14689 jQuery.error( "Invalid XML: " + ( 14690 parserErrorElem ? 14691 jQuery.map( parserErrorElem.childNodes, function( el ) { 14692 return el.textContent; 14693 } ).join( "\n" ) : 14694 data 14695 ) ); 14696 } 14697 return xml; 14698}; 14699 14700 14701var rfocusMorph = /^(?:focusinfocus|focusoutblur)$/, 14702 stopPropagationCallback = function( e ) { 14703 e.stopPropagation(); 14704 }; 14705 14706jQuery.extend( jQuery.event, { 14707 14708 trigger: function( event, data, elem, onlyHandlers ) { 14709 14710 var i, cur, tmp, bubbleType, ontype, handle, special, lastElement, 14711 eventPath = [ elem || document ], 14712 type = hasOwn.call( event, "type" ) ? event.type : event, 14713 namespaces = hasOwn.call( event, "namespace" ) ? event.namespace.split( "." ) : []; 14714 14715 cur = lastElement = tmp = elem = elem || document; 14716 14717 // Don't do events on text and comment nodes 14718 if ( elem.nodeType === 3 || elem.nodeType === 8 ) { 14719 return; 14720 } 14721 14722 // focus/blur morphs to focusin/out; ensure we're not firing them right now 14723 if ( rfocusMorph.test( type + jQuery.event.triggered ) ) { 14724 return; 14725 } 14726 14727 if ( type.indexOf( "." ) > -1 ) { 14728 14729 // Namespaced trigger; create a regexp to match event type in handle() 14730 namespaces = type.split( "." ); 14731 type = namespaces.shift(); 14732 namespaces.sort(); 14733 }
vendor: 6,524 bytes, lines 14734-14983
14734 ontype = type.indexOf( ":" ) < 0 && "on" + type; 14735 14736 // Caller can pass in a jQuery.Event object, Object, or just an event type string 14737 event = event[ jQuery.expando ] ? 14738 event : 14739 new jQuery.Event( type, typeof event === "object" && event ); 14740 14741 // Trigger bitmask: & 1 for native handlers; & 2 for jQuery (always true) 14742 event.isTrigger = onlyHandlers ? 2 : 3; 14743 event.namespace = namespaces.join( "." ); 14744 event.rnamespace = event.namespace ? 14745 new RegExp( "(^|\\.)" + namespaces.join( "\\.(?:.*\\.|)" ) + "(\\.|$)" ) : 14746 null; 14747 14748 // Clean up the event in case it is being reused 14749 event.result = undefined; 14750 if ( !event.target ) { 14751 event.target = elem; 14752 } 14753 14754 // Clone any incoming data and prepend the event, creating the handler arg list 14755 data = data == null ? 14756 [ event ] : 14757 jQuery.makeArray( data, [ event ] ); 14758 14759 // Allow special events to draw outside the lines 14760 special = jQuery.event.special[ type ] || {}; 14761 if ( !onlyHandlers && special.trigger && special.trigger.apply( elem, data ) === false ) { 14762 return; 14763 } 14764 14765 // Determine event propagation path in advance, per W3C events spec (trac-9951) 14766 // Bubble up to document, then to window; watch for a global ownerDocument var (trac-9724) 14767 if ( !onlyHandlers && !special.noBubble && !isWindow( elem ) ) { 14768 14769 bubbleType = special.delegateType || type; 14770 if ( !rfocusMorph.test( bubbleType + type ) ) { 14771 cur = cur.parentNode; 14772 } 14773 for ( ; cur; cur = cur.parentNode ) { 14774 eventPath.push( cur ); 14775 tmp = cur; 14776 } 14777 14778 // Only add window if we got to document (e.g., not plain obj or detached DOM) 14779 if ( tmp === ( elem.ownerDocument || document ) ) { 14780 eventPath.push( tmp.defaultView || tmp.parentWindow || window ); 14781 } 14782 } 14783 14784 // Fire handlers on the event path 14785 i = 0; 14786 while ( ( cur = eventPath[ i++ ] ) && !event.isPropagationStopped() ) { 14787 lastElement = cur; 14788 event.type = i > 1 ? 14789 bubbleType : 14790 special.bindType || type; 14791 14792 // jQuery handler 14793 handle = ( dataPriv.get( cur, "events" ) || Object.create( null ) )[ event.type ] && 14794 dataPriv.get( cur, "handle" ); 14795 if ( handle ) { 14796 handle.apply( cur, data ); 14797 } 14798 14799 // Native handler 14800 handle = ontype && cur[ ontype ]; 14801 if ( handle && handle.apply && acceptData( cur ) ) { 14802 event.result = handle.apply( cur, data ); 14803 if ( event.result === false ) { 14804 event.preventDefault(); 14805 } 14806 } 14807 } 14808 event.type = type; 14809 14810 // If nobody prevented the default action, do it now 14811 if ( !onlyHandlers && !event.isDefaultPrevented() ) { 14812 14813 if ( ( !special._default || 14814 special._default.apply( eventPath.pop(), data ) === false ) && 14815 acceptData( elem ) ) { 14816 14817 // Call a native DOM method on the target with the same name as the event. 14818 // Don't do default actions on window, that's where global variables be (trac-6170) 14819 if ( ontype && isFunction( elem[ type ] ) && !isWindow( elem ) ) { 14820 14821 // Don't re-trigger an onFOO event when we call its FOO() method 14822 tmp = elem[ ontype ]; 14823 14824 if ( tmp ) { 14825 elem[ ontype ] = null; 14826 } 14827 14828 // Prevent re-triggering of the same event, since we already bubbled it above 14829 jQuery.event.triggered = type; 14830 14831 if ( event.isPropagationStopped() ) { 14832 lastElement.addEventListener( type, stopPropagationCallback ); 14833 } 14834 14835 elem[ type ](); 14836 14837 if ( event.isPropagationStopped() ) { 14838 lastElement.removeEventListener( type, stopPropagationCallback ); 14839 } 14840 14841 jQuery.event.triggered = undefined; 14842 14843 if ( tmp ) { 14844 elem[ ontype ] = tmp; 14845 } 14846 } 14847 } 14848 } 14849 14850 return event.result; 14851 }, 14852 14853 // Piggyback on a donor event to simulate a different one 14854 // Used only for `focus(in | out)` events 14855 simulate: function( type, elem, event ) { 14856 var e = jQuery.extend( 14857 new jQuery.Event(), 14858 event, 14859 { 14860 type: type, 14861 isSimulated: true 14862 } 14863 ); 14864 14865 jQuery.event.trigger( e, null, elem ); 14866 } 14867 14868} ); 14869 14870jQuery.fn.extend( { 14871 14872 trigger: function( type, data ) { 14873 return this.each( function() { 14874 jQuery.event.trigger( type, data, this ); 14875 } ); 14876 }, 14877 triggerHandler: function( type, data ) { 14878 var elem = this[ 0 ]; 14879 if ( elem ) { 14880 return jQuery.event.trigger( type, data, elem, true ); 14881 } 14882 } 14883} ); 14884 14885 14886var 14887 rbracket = /\[\]$/, 14888 rCRLF = /\r?\n/g, 14889 rsubmitterTypes = /^(?:submit|button|image|reset|file)$/i, 14890 rsubmittable = /^(?:input|select|textarea|keygen)/i; 14891 14892function buildParams( prefix, obj, traditional, add ) { 14893 var name; 14894 14895 if ( Array.isArray( obj ) ) { 14896 14897 // Serialize array item. 14898 jQuery.each( obj, function( i, v ) { 14899 if ( traditional || rbracket.test( prefix ) ) { 14900 14901 // Treat each array item as a scalar. 14902 add( prefix, v ); 14903 14904 } else { 14905 14906 // Item is non-scalar (array or object), encode its numeric index. 14907 buildParams( 14908 prefix + "[" + ( typeof v === "object" && v != null ? i : "" ) + "]", 14909 v, 14910 traditional, 14911 add 14912 ); 14913 } 14914 } ); 14915 14916 } else if ( !traditional && toType( obj ) === "object" ) { 14917 14918 // Serialize object item. 14919 for ( name in obj ) { 14920 buildParams( prefix + "[" + name + "]", obj[ name ], traditional, add ); 14921 } 14922 14923 } else { 14924 14925 // Serialize scalar item. 14926 add( prefix, obj ); 14927 } 14928} 14929 14930// Serialize an array of form elements or a set of 14931// key/values into a query string 14932jQuery.param = function( a, traditional ) { 14933 var prefix, 14934 s = [], 14935 add = function( key, valueOrFunction ) { 14936 14937 // If value is a function, invoke it and use its return value 14938 var value = isFunction( valueOrFunction ) ? 14939 valueOrFunction() : 14940 valueOrFunction; 14941 14942 s[ s.length ] = encodeURIComponent( key ) + "=" + 14943 encodeURIComponent( value == null ? "" : value ); 14944 }; 14945 14946 if ( a == null ) { 14947 return ""; 14948 } 14949 14950 // If an array was passed in, assume that it is an array of form elements. 14951 if ( Array.isArray( a ) || ( a.jquery && !jQuery.isPlainObject( a ) ) ) { 14952 14953 // Serialize the form elements 14954 jQuery.each( a, function() { 14955 add( this.name, this.value ); 14956 } ); 14957 14958 } else { 14959 14960 // If traditional, encode the "old" way (the way 1.3.2 or older 14961 // did it), otherwise encode params recursively. 14962 for ( prefix in a ) { 14963 buildParams( prefix, a[ prefix ], traditional, add ); 14964 } 14965 } 14966 14967 // Return the resulting serialization 14968 return s.join( "&" ); 14969}; 14970 14971jQuery.fn.extend( { 14972 serialize: function() { 14973 return jQuery.param( this.serializeArray() ); 14974 }, 14975 serializeArray: function() { 14976 return this.map( function() { 14977 14978 // Can add propHook for "elements" to filter or add form elements 14979 var elements = jQuery.prop( this, "elements" ); 14980 return elements ? jQuery.makeArray( elements ) : this; 14981 } ).filter( function() { 14982 var type = this.type; 14983
vendor: 32,437 bytes, lines 14984-16237
14984 // Use .is( ":disabled" ) so that fieldset[disabled] works 14985 return this.name && !jQuery( this ).is( ":disabled" ) && 14986 rsubmittable.test( this.nodeName ) && !rsubmitterTypes.test( type ) && 14987 ( this.checked || !rcheckableType.test( type ) ); 14988 } ).map( function( _i, elem ) { 14989 var val = jQuery( this ).val(); 14990 14991 if ( val == null ) { 14992 return null; 14993 } 14994 14995 if ( Array.isArray( val ) ) { 14996 return jQuery.map( val, function( val ) { 14997 return { name: elem.name, value: val.replace( rCRLF, "\r\n" ) }; 14998 } ); 14999 } 15000 15001 return { name: elem.name, value: val.replace( rCRLF, "\r\n" ) }; 15002 } ).get(); 15003 } 15004} ); 15005 15006 15007var 15008 r20 = /%20/g, 15009 rhash = /#.*$/, 15010 rantiCache = /([?&])_=[^&]*/, 15011 rheaders = /^(.*?):[ \t]*([^\r\n]*)$/mg, 15012 15013 // trac-7653, trac-8125, trac-8152: local protocol detection 15014 rlocalProtocol = /^(?:about|app|app-storage|.+-extension|file|res|widget):$/, 15015 rnoContent = /^(?:GET|HEAD)$/, 15016 rprotocol = /^\/\//, 15017 15018 /* Prefilters 15019 * 1) They are useful to introduce custom dataTypes (see ajax/jsonp.js for an example) 15020 * 2) These are called: 15021 * - BEFORE asking for a transport 15022 * - AFTER param serialization (s.data is a string if s.processData is true) 15023 * 3) key is the dataType 15024 * 4) the catchall symbol "*" can be used 15025 * 5) execution will start with transport dataType and THEN continue down to "*" if needed 15026 */ 15027 prefilters = {}, 15028 15029 /* Transports bindings 15030 * 1) key is the dataType 15031 * 2) the catchall symbol "*" can be used 15032 * 3) selection will start with transport dataType and THEN go to "*" if needed 15033 */ 15034 transports = {}, 15035 15036 // Avoid comment-prolog char sequence (trac-10098); must appease lint and evade compression 15037 allTypes = "*/".concat( "*" ), 15038 15039 // Anchor tag for parsing the document origin 15040 originAnchor = document.createElement( "a" ); 15041 15042originAnchor.href = location.href; 15043 15044// Base "constructor" for jQuery.ajaxPrefilter and jQuery.ajaxTransport 15045function addToPrefiltersOrTransports( structure ) { 15046 15047 // dataTypeExpression is optional and defaults to "*" 15048 return function( dataTypeExpression, func ) { 15049 15050 if ( typeof dataTypeExpression !== "string" ) { 15051 func = dataTypeExpression; 15052 dataTypeExpression = "*"; 15053 } 15054 15055 var dataType, 15056 i = 0, 15057 dataTypes = dataTypeExpression.toLowerCase().match( rnothtmlwhite ) || []; 15058 15059 if ( isFunction( func ) ) { 15060 15061 // For each dataType in the dataTypeExpression 15062 while ( ( dataType = dataTypes[ i++ ] ) ) { 15063 15064 // Prepend if requested 15065 if ( dataType[ 0 ] === "+" ) { 15066 dataType = dataType.slice( 1 ) || "*"; 15067 ( structure[ dataType ] = structure[ dataType ] || [] ).unshift( func ); 15068 15069 // Otherwise append 15070 } else { 15071 ( structure[ dataType ] = structure[ dataType ] || [] ).push( func ); 15072 } 15073 } 15074 } 15075 }; 15076} 15077 15078// Base inspection function for prefilters and transports 15079function inspectPrefiltersOrTransports( structure, options, originalOptions, jqXHR ) { 15080 15081 var inspected = {}, 15082 seekingTransport = ( structure === transports ); 15083 15084 function inspect( dataType ) { 15085 var selected; 15086 inspected[ dataType ] = true; 15087 jQuery.each( structure[ dataType ] || [], function( _, prefilterOrFactory ) { 15088 var dataTypeOrTransport = prefilterOrFactory( options, originalOptions, jqXHR ); 15089 if ( typeof dataTypeOrTransport === "string" && 15090 !seekingTransport && !inspected[ dataTypeOrTransport ] ) { 15091 15092 options.dataTypes.unshift( dataTypeOrTransport ); 15093 inspect( dataTypeOrTransport ); 15094 return false; 15095 } else if ( seekingTransport ) { 15096 return !( selected = dataTypeOrTransport ); 15097 } 15098 } ); 15099 return selected; 15100 } 15101 15102 return inspect( options.dataTypes[ 0 ] ) || !inspected[ "*" ] && inspect( "*" ); 15103} 15104 15105// A special extend for ajax options 15106// that takes "flat" options (not to be deep extended) 15107// Fixes trac-9887 15108function ajaxExtend( target, src ) { 15109 var key, deep, 15110 flatOptions = jQuery.ajaxSettings.flatOptions || {}; 15111 15112 for ( key in src ) { 15113 if ( src[ key ] !== undefined ) { 15114 ( flatOptions[ key ] ? target : ( deep || ( deep = {} ) ) )[ key ] = src[ key ]; 15115 } 15116 } 15117 if ( deep ) { 15118 jQuery.extend( true, target, deep ); 15119 } 15120 15121 return target; 15122} 15123 15124/* Handles responses to an ajax request: 15125 * - finds the right dataType (mediates between content-type and expected dataType) 15126 * - returns the corresponding response 15127 */ 15128function ajaxHandleResponses( s, jqXHR, responses ) { 15129 15130 var ct, type, finalDataType, firstDataType, 15131 contents = s.contents, 15132 dataTypes = s.dataTypes; 15133 15134 // Remove auto dataType and get content-type in the process 15135 while ( dataTypes[ 0 ] === "*" ) { 15136 dataTypes.shift(); 15137 if ( ct === undefined ) { 15138 ct = s.mimeType || jqXHR.getResponseHeader( "Content-Type" ); 15139 } 15140 } 15141 15142 // Check if we're dealing with a known content-type 15143 if ( ct ) { 15144 for ( type in contents ) { 15145 if ( contents[ type ] && contents[ type ].test( ct ) ) { 15146 dataTypes.unshift( type ); 15147 break; 15148 } 15149 } 15150 } 15151 15152 // Check to see if we have a response for the expected dataType 15153 if ( dataTypes[ 0 ] in responses ) { 15154 finalDataType = dataTypes[ 0 ]; 15155 } else { 15156 15157 // Try convertible dataTypes 15158 for ( type in responses ) { 15159 if ( !dataTypes[ 0 ] || s.converters[ type + " " + dataTypes[ 0 ] ] ) { 15160 finalDataType = type; 15161 break; 15162 } 15163 if ( !firstDataType ) { 15164 firstDataType = type; 15165 } 15166 } 15167 15168 // Or just use first one 15169 finalDataType = finalDataType || firstDataType; 15170 } 15171 15172 // If we found a dataType 15173 // We add the dataType to the list if needed 15174 // and return the corresponding response 15175 if ( finalDataType ) { 15176 if ( finalDataType !== dataTypes[ 0 ] ) { 15177 dataTypes.unshift( finalDataType ); 15178 } 15179 return responses[ finalDataType ]; 15180 } 15181} 15182 15183/* Chain conversions given the request and the original response 15184 * Also sets the responseXXX fields on the jqXHR instance 15185 */ 15186function ajaxConvert( s, response, jqXHR, isSuccess ) { 15187 var conv2, current, conv, tmp, prev, 15188 converters = {}, 15189 15190 // Work with a copy of dataTypes in case we need to modify it for conversion 15191 dataTypes = s.dataTypes.slice(); 15192 15193 // Create converters map with lowercased keys 15194 if ( dataTypes[ 1 ] ) { 15195 for ( conv in s.converters ) { 15196 converters[ conv.toLowerCase() ] = s.converters[ conv ]; 15197 } 15198 } 15199 15200 current = dataTypes.shift(); 15201 15202 // Convert to each sequential dataType 15203 while ( current ) { 15204 15205 if ( s.responseFields[ current ] ) { 15206 jqXHR[ s.responseFields[ current ] ] = response; 15207 } 15208 15209 // Apply the dataFilter if provided 15210 if ( !prev && isSuccess && s.dataFilter ) { 15211 response = s.dataFilter( response, s.dataType ); 15212 } 15213 15214 prev = current; 15215 current = dataTypes.shift(); 15216 15217 if ( current ) { 15218 15219 // There's only work to do if current dataType is non-auto 15220 if ( current === "*" ) { 15221 15222 current = prev; 15223 15224 // Convert response if prev dataType is non-auto and differs from current 15225 } else if ( prev !== "*" && prev !== current ) { 15226 15227 // Seek a direct converter 15228 conv = converters[ prev + " " + current ] || converters[ "* " + current ]; 15229 15230 // If none found, seek a pair 15231 if ( !conv ) { 15232 for ( conv2 in converters ) { 15233 15234 // If conv2 outputs current 15235 tmp = conv2.split( " " ); 15236 if ( tmp[ 1 ] === current ) { 15237 15238 // If prev can be converted to accepted input 15239 conv = converters[ prev + " " + tmp[ 0 ] ] || 15240 converters[ "* " + tmp[ 0 ] ]; 15241 if ( conv ) { 15242 15243 // Condense equivalence converters 15244 if ( conv === true ) { 15245 conv = converters[ conv2 ]; 15246 15247 // Otherwise, insert the intermediate dataType 15248 } else if ( converters[ conv2 ] !== true ) { 15249 current = tmp[ 0 ]; 15250 dataTypes.unshift( tmp[ 1 ] ); 15251 } 15252 break; 15253 } 15254 } 15255 } 15256 } 15257 15258 // Apply converter (if not an equivalence) 15259 if ( conv !== true ) { 15260 15261 // Unless errors are allowed to bubble, catch and return them 15262 if ( conv && s.throws ) { 15263 response = conv( response ); 15264 } else { 15265 try { 15266 response = conv( response ); 15267 } catch ( e ) { 15268 return { 15269 state: "parsererror", 15270 error: conv ? e : "No conversion from " + prev + " to " + current 15271 }; 15272 } 15273 } 15274 } 15275 } 15276 } 15277 } 15278 15279 return { state: "success", data: response }; 15280} 15281 15282jQuery.extend( { 15283 15284 // Counter for holding the number of active queries 15285 active: 0, 15286 15287 // Last-Modified header cache for next request 15288 lastModified: {}, 15289 etag: {}, 15290 15291 ajaxSettings: { 15292 url: location.href, 15293 type: "GET", 15294 isLocal: rlocalProtocol.test( location.protocol ), 15295 global: true, 15296 processData: true, 15297 async: true, 15298 contentType: "application/x-www-form-urlencoded; charset=UTF-8", 15299 15300 /* 15301 timeout: 0, 15302 data: null, 15303 dataType: null, 15304 username: null, 15305 password: null, 15306 cache: null, 15307 throws: false, 15308 traditional: false, 15309 headers: {}, 15310 */ 15311 15312 accepts: { 15313 "*": allTypes, 15314 text: "text/plain", 15315 html: "text/html", 15316 xml: "application/xml, text/xml", 15317 json: "application/json, text/javascript" 15318 }, 15319 15320 contents: { 15321 xml: /\bxml\b/, 15322 html: /\bhtml/, 15323 json: /\bjson\b/ 15324 }, 15325 15326 responseFields: { 15327 xml: "responseXML", 15328 text: "responseText", 15329 json: "responseJSON" 15330 }, 15331 15332 // Data converters 15333 // Keys separate source (or catchall "*") and destination types with a single space 15334 converters: { 15335 15336 // Convert anything to text 15337 "* text": String, 15338 15339 // Text to html (true = no transformation) 15340 "text html": true, 15341 15342 // Evaluate text as a json expression 15343 "text json": JSON.parse, 15344 15345 // Parse text as xml 15346 "text xml": jQuery.parseXML 15347 }, 15348 15349 // For options that shouldn't be deep extended: 15350 // you can add your own custom options here if 15351 // and when you create one that shouldn't be 15352 // deep extended (see ajaxExtend) 15353 flatOptions: { 15354 url: true, 15355 context: true 15356 } 15357 }, 15358 15359 // Creates a full fledged settings object into target 15360 // with both ajaxSettings and settings fields. 15361 // If target is omitted, writes into ajaxSettings. 15362 ajaxSetup: function( target, settings ) { 15363 return settings ? 15364 15365 // Building a settings object 15366 ajaxExtend( ajaxExtend( target, jQuery.ajaxSettings ), settings ) : 15367 15368 // Extending ajaxSettings 15369 ajaxExtend( jQuery.ajaxSettings, target ); 15370 }, 15371 15372 ajaxPrefilter: addToPrefiltersOrTransports( prefilters ), 15373 ajaxTransport: addToPrefiltersOrTransports( transports ), 15374 15375 // Main method 15376 ajax: function( url, options ) { 15377 15378 // If url is an object, simulate pre-1.5 signature 15379 if ( typeof url === "object" ) { 15380 options = url; 15381 url = undefined; 15382 } 15383 15384 // Force options to be an object 15385 options = options || {}; 15386 15387 var transport, 15388 15389 // URL without anti-cache param 15390 cacheURL, 15391 15392 // Response headers 15393 responseHeadersString, 15394 responseHeaders, 15395 15396 // timeout handle 15397 timeoutTimer, 15398 15399 // Url cleanup var 15400 urlAnchor, 15401 15402 // Request state (becomes false upon send and true upon completion) 15403 completed, 15404 15405 // To know if global events are to be dispatched 15406 fireGlobals, 15407 15408 // Loop variable 15409 i, 15410 15411 // uncached part of the url 15412 uncached, 15413 15414 // Create the final options object 15415 s = jQuery.ajaxSetup( {}, options ), 15416 15417 // Callbacks context 15418 callbackContext = s.context || s, 15419 15420 // Context for global events is callbackContext if it is a DOM node or jQuery collection 15421 globalEventContext = s.context && 15422 ( callbackContext.nodeType || callbackContext.jquery ) ? 15423 jQuery( callbackContext ) : 15424 jQuery.event, 15425 15426 // Deferreds 15427 deferred = jQuery.Deferred(), 15428 completeDeferred = jQuery.Callbacks( "once memory" ), 15429 15430 // Status-dependent callbacks 15431 statusCode = s.statusCode || {}, 15432 15433 // Headers (they are sent all at once) 15434 requestHeaders = {}, 15435 requestHeadersNames = {}, 15436 15437 // Default abort message 15438 strAbort = "canceled", 15439 15440 // Fake xhr 15441 jqXHR = { 15442 readyState: 0, 15443 15444 // Builds headers hashtable if needed 15445 getResponseHeader: function( key ) { 15446 var match; 15447 if ( completed ) { 15448 if ( !responseHeaders ) { 15449 responseHeaders = {}; 15450 while ( ( match = rheaders.exec( responseHeadersString ) ) ) { 15451 responseHeaders[ match[ 1 ].toLowerCase() + " " ] = 15452 ( responseHeaders[ match[ 1 ].toLowerCase() + " " ] || [] ) 15453 .concat( match[ 2 ] ); 15454 } 15455 } 15456 match = responseHeaders[ key.toLowerCase() + " " ]; 15457 } 15458 return match == null ? null : match.join( ", " ); 15459 }, 15460 15461 // Raw string 15462 getAllResponseHeaders: function() { 15463 return completed ? responseHeadersString : null; 15464 }, 15465 15466 // Caches the header 15467 setRequestHeader: function( name, value ) { 15468 if ( completed == null ) { 15469 name = requestHeadersNames[ name.toLowerCase() ] = 15470 requestHeadersNames[ name.toLowerCase() ] || name; 15471 requestHeaders[ name ] = value; 15472 } 15473 return this; 15474 }, 15475 15476 // Overrides response content-type header 15477 overrideMimeType: function( type ) { 15478 if ( completed == null ) { 15479 s.mimeType = type; 15480 } 15481 return this; 15482 }, 15483 15484 // Status-dependent callbacks 15485 statusCode: function( map ) { 15486 var code; 15487 if ( map ) { 15488 if ( completed ) { 15489 15490 // Execute the appropriate callbacks 15491 jqXHR.always( map[ jqXHR.status ] ); 15492 } else { 15493 15494 // Lazy-add the new callbacks in a way that preserves old ones 15495 for ( code in map ) { 15496 statusCode[ code ] = [ statusCode[ code ], map[ code ] ]; 15497 } 15498 } 15499 } 15500 return this; 15501 }, 15502 15503 // Cancel the request 15504 abort: function( statusText ) { 15505 var finalText = statusText || strAbort; 15506 if ( transport ) { 15507 transport.abort( finalText ); 15508 } 15509 done( 0, finalText ); 15510 return this; 15511 } 15512 }; 15513 15514 // Attach deferreds 15515 deferred.promise( jqXHR ); 15516 15517 // Add protocol if not provided (prefilters might expect it) 15518 // Handle falsy url in the settings object (trac-10093: consistency with old signature) 15519 // We also use the url parameter if available 15520 s.url = ( ( url || s.url || location.href ) + "" ) 15521 .replace( rprotocol, location.protocol + "//" ); 15522 15523 // Alias method option to type as per ticket trac-12004 15524 s.type = options.method || options.type || s.method || s.type; 15525 15526 // Extract dataTypes list 15527 s.dataTypes = ( s.dataType || "*" ).toLowerCase().match( rnothtmlwhite ) || [ "" ]; 15528 15529 // A cross-domain request is in order when the origin doesn't match the current origin. 15530 if ( s.crossDomain == null ) { 15531 urlAnchor = document.createElement( "a" ); 15532 15533 // Support: IE <=8 - 11, Edge 12 - 15 15534 // IE throws exception on accessing the href property if url is malformed, 15535 // e.g. http://example.com:80x/ 15536 try { 15537 urlAnchor.href = s.url; 15538 15539 // Support: IE <=8 - 11 only 15540 // Anchor's host property isn't correctly set when s.url is relative 15541 urlAnchor.href = urlAnchor.href; 15542 s.crossDomain = originAnchor.protocol + "//" + originAnchor.host !== 15543 urlAnchor.protocol + "//" + urlAnchor.host; 15544 } catch ( e ) { 15545 15546 // If there is an error parsing the URL, assume it is crossDomain, 15547 // it can be rejected by the transport if it is invalid 15548 s.crossDomain = true; 15549 } 15550 } 15551 15552 // Convert data if not already a string 15553 if ( s.data && s.processData && typeof s.data !== "string" ) { 15554 s.data = jQuery.param( s.data, s.traditional ); 15555 } 15556 15557 // Apply prefilters 15558 inspectPrefiltersOrTransports( prefilters, s, options, jqXHR ); 15559 15560 // If request was aborted inside a prefilter, stop there 15561 if ( completed ) { 15562 return jqXHR; 15563 } 15564 15565 // We can fire global events as of now if asked to 15566 // Don't fire events if jQuery.event is undefined in an AMD-usage scenario (trac-15118) 15567 fireGlobals = jQuery.event && s.global; 15568 15569 // Watch for a new set of requests 15570 if ( fireGlobals && jQuery.active++ === 0 ) { 15571 jQuery.event.trigger( "ajaxStart" ); 15572 } 15573 15574 // Uppercase the type 15575 s.type = s.type.toUpperCase(); 15576 15577 // Determine if request has content 15578 s.hasContent = !rnoContent.test( s.type ); 15579 15580 // Save the URL in case we're toying with the If-Modified-Since 15581 // and/or If-None-Match header later on 15582 // Remove hash to simplify url manipulation 15583 cacheURL = s.url.replace( rhash, "" ); 15584 15585 // More options handling for requests with no content 15586 if ( !s.hasContent ) { 15587 15588 // Remember the hash so we can put it back 15589 uncached = s.url.slice( cacheURL.length ); 15590 15591 // If data is available and should be processed, append data to url 15592 if ( s.data && ( s.processData || typeof s.data === "string" ) ) { 15593 cacheURL += ( rquery.test( cacheURL ) ? "&" : "?" ) + s.data; 15594 15595 // trac-9682: remove data so that it's not used in an eventual retry 15596 delete s.data; 15597 } 15598 15599 // Add or update anti-cache param if needed 15600 if ( s.cache === false ) { 15601 cacheURL = cacheURL.replace( rantiCache, "$1" ); 15602 uncached = ( rquery.test( cacheURL ) ? "&" : "?" ) + "_=" + ( nonce.guid++ ) + 15603 uncached; 15604 } 15605 15606 // Put hash and anti-cache on the URL that will be requested (gh-1732) 15607 s.url = cacheURL + uncached; 15608 15609 // Change '%20' to '+' if this is encoded form body content (gh-2658) 15610 } else if ( s.data && s.processData && 15611 ( s.contentType || "" ).indexOf( "application/x-www-form-urlencoded" ) === 0 ) { 15612 s.data = s.data.replace( r20, "+" ); 15613 } 15614 15615 // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode. 15616 if ( s.ifModified ) { 15617 if ( jQuery.lastModified[ cacheURL ] ) { 15618 jqXHR.setRequestHeader( "If-Modified-Since", jQuery.lastModified[ cacheURL ] ); 15619 } 15620 if ( jQuery.etag[ cacheURL ] ) { 15621 jqXHR.setRequestHeader( "If-None-Match", jQuery.etag[ cacheURL ] ); 15622 } 15623 } 15624 15625 // Set the correct header, if data is being sent 15626 if ( s.data && s.hasContent && s.contentType !== false || options.contentType ) { 15627 jqXHR.setRequestHeader( "Content-Type", s.contentType ); 15628 } 15629 15630 // Set the Accepts header for the server, depending on the dataType 15631 jqXHR.setRequestHeader( 15632 "Accept", 15633 s.dataTypes[ 0 ] && s.accepts[ s.dataTypes[ 0 ] ] ? 15634 s.accepts[ s.dataTypes[ 0 ] ] + 15635 ( s.dataTypes[ 0 ] !== "*" ? ", " + allTypes + "; q=0.01" : "" ) : 15636 s.accepts[ "*" ] 15637 ); 15638 15639 // Check for headers option 15640 for ( i in s.headers ) { 15641 jqXHR.setRequestHeader( i, s.headers[ i ] ); 15642 } 15643 15644 // Allow custom headers/mimetypes and early abort 15645 if ( s.beforeSend && 15646 ( s.beforeSend.call( callbackContext, jqXHR, s ) === false || completed ) ) { 15647 15648 // Abort if not done already and return 15649 return jqXHR.abort(); 15650 } 15651 15652 // Aborting is no longer a cancellation 15653 strAbort = "abort"; 15654 15655 // Install callbacks on deferreds 15656 completeDeferred.add( s.complete ); 15657 jqXHR.done( s.success ); 15658 jqXHR.fail( s.error ); 15659 15660 // Get transport 15661 transport = inspectPrefiltersOrTransports( transports, s, options, jqXHR ); 15662 15663 // If no transport, we auto-abort 15664 if ( !transport ) { 15665 done( -1, "No Transport" ); 15666 } else { 15667 jqXHR.readyState = 1; 15668 15669 // Send global event 15670 if ( fireGlobals ) { 15671 globalEventContext.trigger( "ajaxSend", [ jqXHR, s ] ); 15672 } 15673 15674 // If request was aborted inside ajaxSend, stop there 15675 if ( completed ) { 15676 return jqXHR; 15677 } 15678 15679 // Timeout 15680 if ( s.async && s.timeout > 0 ) { 15681 timeoutTimer = window.setTimeout( function() { 15682 jqXHR.abort( "timeout" ); 15683 }, s.timeout ); 15684 } 15685 15686 try { 15687 completed = false; 15688 transport.send( requestHeaders, done ); 15689 } catch ( e ) { 15690 15691 // Rethrow post-completion exceptions 15692 if ( completed ) { 15693 throw e; 15694 } 15695 15696 // Propagate others as results 15697 done( -1, e ); 15698 } 15699 } 15700 15701 // Callback for when everything is done 15702 function done( status, nativeStatusText, responses, headers ) { 15703 var isSuccess, success, error, response, modified, 15704 statusText = nativeStatusText; 15705 15706 // Ignore repeat invocations 15707 if ( completed ) { 15708 return; 15709 } 15710 15711 completed = true; 15712 15713 // Clear timeout if it exists 15714 if ( timeoutTimer ) { 15715 window.clearTimeout( timeoutTimer ); 15716 } 15717 15718 // Dereference transport for early garbage collection 15719 // (no matter how long the jqXHR object will be used) 15720 transport = undefined; 15721 15722 // Cache response headers 15723 responseHeadersString = headers || ""; 15724 15725 // Set readyState 15726 jqXHR.readyState = status > 0 ? 4 : 0; 15727 15728 // Determine if successful 15729 isSuccess = status >= 200 && status < 300 || status === 304; 15730 15731 // Get response data 15732 if ( responses ) { 15733 response = ajaxHandleResponses( s, jqXHR, responses ); 15734 } 15735 15736 // Use a noop converter for missing script but not if jsonp 15737 if ( !isSuccess && 15738 jQuery.inArray( "script", s.dataTypes ) > -1 && 15739 jQuery.inArray( "json", s.dataTypes ) < 0 ) { 15740 s.converters[ "text script" ] = function() {}; 15741 } 15742 15743 // Convert no matter what (that way responseXXX fields are always set) 15744 response = ajaxConvert( s, response, jqXHR, isSuccess ); 15745 15746 // If successful, handle type chaining 15747 if ( isSuccess ) { 15748 15749 // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode. 15750 if ( s.ifModified ) { 15751 modified = jqXHR.getResponseHeader( "Last-Modified" ); 15752 if ( modified ) { 15753 jQuery.lastModified[ cacheURL ] = modified; 15754 } 15755 modified = jqXHR.getResponseHeader( "etag" ); 15756 if ( modified ) { 15757 jQuery.etag[ cacheURL ] = modified; 15758 } 15759 } 15760 15761 // if no content 15762 if ( status === 204 || s.type === "HEAD" ) { 15763 statusText = "nocontent"; 15764 15765 // if not modified 15766 } else if ( status === 304 ) { 15767 statusText = "notmodified"; 15768 15769 // If we have data, let's convert it 15770 } else { 15771 statusText = response.state; 15772 success = response.data; 15773 error = response.error; 15774 isSuccess = !error; 15775 } 15776 } else { 15777 15778 // Extract error from statusText and normalize for non-aborts 15779 error = statusText; 15780 if ( status || !statusText ) { 15781 statusText = "error"; 15782 if ( status < 0 ) { 15783 status = 0; 15784 } 15785 } 15786 } 15787 15788 // Set data for the fake xhr object 15789 jqXHR.status = status; 15790 jqXHR.statusText = ( nativeStatusText || statusText ) + ""; 15791 15792 // Success/Error 15793 if ( isSuccess ) { 15794 deferred.resolveWith( callbackContext, [ success, statusText, jqXHR ] ); 15795 } else { 15796 deferred.rejectWith( callbackContext, [ jqXHR, statusText, error ] ); 15797 } 15798 15799 // Status-dependent callbacks 15800 jqXHR.statusCode( statusCode ); 15801 statusCode = undefined; 15802 15803 if ( fireGlobals ) { 15804 globalEventContext.trigger( isSuccess ? "ajaxSuccess" : "ajaxError", 15805 [ jqXHR, s, isSuccess ? success : error ] ); 15806 } 15807 15808 // Complete 15809 completeDeferred.fireWith( callbackContext, [ jqXHR, statusText ] ); 15810 15811 if ( fireGlobals ) { 15812 globalEventContext.trigger( "ajaxComplete", [ jqXHR, s ] ); 15813 15814 // Handle the global AJAX counter 15815 if ( !( --jQuery.active ) ) { 15816 jQuery.event.trigger( "ajaxStop" ); 15817 } 15818 } 15819 } 15820 15821 return jqXHR; 15822 }, 15823 15824 getJSON: function( url, data, callback ) { 15825 return jQuery.get( url, data, callback, "json" ); 15826 }, 15827 15828 getScript: function( url, callback ) { 15829 return jQuery.get( url, undefined, callback, "script" ); 15830 } 15831} ); 15832 15833jQuery.each( [ "get", "post" ], function( _i, method ) { 15834 jQuery[ method ] = function( url, data, callback, type ) { 15835 15836 // Shift arguments if data argument was omitted 15837 if ( isFunction( data ) ) { 15838 type = type || callback; 15839 callback = data; 15840 data = undefined; 15841 } 15842 15843 // The url can be an options object (which then must have .url) 15844 return jQuery.ajax( jQuery.extend( { 15845 url: url, 15846 type: method, 15847 dataType: type, 15848 data: data, 15849 success: callback 15850 }, jQuery.isPlainObject( url ) && url ) ); 15851 }; 15852} ); 15853 15854jQuery.ajaxPrefilter( function( s ) { 15855 var i; 15856 for ( i in s.headers ) { 15857 if ( i.toLowerCase() === "content-type" ) { 15858 s.contentType = s.headers[ i ] || ""; 15859 } 15860 } 15861} ); 15862 15863 15864jQuery._evalUrl = function( url, options, doc ) { 15865 return jQuery.ajax( { 15866 url: url, 15867 15868 // Make this explicit, since user can override this through ajaxSetup (trac-11264) 15869 type: "GET", 15870 dataType: "script", 15871 cache: true, 15872 async: false, 15873 global: false, 15874 15875 // Only evaluate the response if it is successful (gh-4126) 15876 // dataFilter is not invoked for failure responses, so using it instead 15877 // of the default converter is kludgy but it works. 15878 converters: { 15879 "text script": function() {} 15880 }, 15881 dataFilter: function( response ) { 15882 jQuery.globalEval( response, options, doc ); 15883 } 15884 } ); 15885}; 15886 15887 15888jQuery.fn.extend( { 15889 wrapAll: function( html ) { 15890 var wrap; 15891 15892 if ( this[ 0 ] ) { 15893 if ( isFunction( html ) ) { 15894 html = html.call( this[ 0 ] ); 15895 } 15896 15897 // The elements to wrap the target around 15898 wrap = jQuery( html, this[ 0 ].ownerDocument ).eq( 0 ).clone( true ); 15899 15900 if ( this[ 0 ].parentNode ) { 15901 wrap.insertBefore( this[ 0 ] ); 15902 } 15903 15904 wrap.map( function() { 15905 var elem = this; 15906 15907 while ( elem.firstElementChild ) { 15908 elem = elem.firstElementChild; 15909 } 15910 15911 return elem; 15912 } ).append( this ); 15913 } 15914 15915 return this; 15916 }, 15917 15918 wrapInner: function( html ) { 15919 if ( isFunction( html ) ) { 15920 return this.each( function( i ) { 15921 jQuery( this ).wrapInner( html.call( this, i ) ); 15922 } ); 15923 } 15924 15925 return this.each( function() { 15926 var self = jQuery( this ), 15927 contents = self.contents(); 15928 15929 if ( contents.length ) { 15930 contents.wrapAll( html ); 15931 15932 } else { 15933 self.append( html ); 15934 } 15935 } ); 15936 }, 15937 15938 wrap: function( html ) { 15939 var htmlIsFunction = isFunction( html ); 15940 15941 return this.each( function( i ) { 15942 jQuery( this ).wrapAll( htmlIsFunction ? html.call( this, i ) : html ); 15943 } ); 15944 }, 15945 15946 unwrap: function( selector ) { 15947 this.parent( selector ).not( "body" ).each( function() { 15948 jQuery( this ).replaceWith( this.childNodes ); 15949 } ); 15950 return this; 15951 } 15952} ); 15953 15954 15955jQuery.expr.pseudos.hidden = function( elem ) { 15956 return !jQuery.expr.pseudos.visible( elem ); 15957}; 15958jQuery.expr.pseudos.visible = function( elem ) { 15959 return !!( elem.offsetWidth || elem.offsetHeight || elem.getClientRects().length ); 15960}; 15961 15962 15963 15964 15965jQuery.ajaxSettings.xhr = function() { 15966 try { 15967 return new window.XMLHttpRequest(); 15968 } catch ( e ) {} 15969}; 15970 15971var xhrSuccessStatus = { 15972 15973 // File protocol always yields status code 0, assume 200 15974 0: 200, 15975 15976 // Support: IE <=9 only 15977 // trac-1450: sometimes IE returns 1223 when it should be 204 15978 1223: 204 15979 }, 15980 xhrSupported = jQuery.ajaxSettings.xhr(); 15981 15982support.cors = !!xhrSupported && ( "withCredentials" in xhrSupported ); 15983support.ajax = xhrSupported = !!xhrSupported; 15984 15985jQuery.ajaxTransport( function( options ) { 15986 var callback, errorCallback; 15987 15988 // Cross domain only allowed if supported through XMLHttpRequest 15989 if ( support.cors || xhrSupported && !options.crossDomain ) { 15990 return { 15991 send: function( headers, complete ) { 15992 var i, 15993 xhr = options.xhr(); 15994 15995 xhr.open( 15996 options.type, 15997 options.url, 15998 options.async, 15999 options.username, 16000 options.password 16001 ); 16002 16003 // Apply custom fields if provided 16004 if ( options.xhrFields ) { 16005 for ( i in options.xhrFields ) { 16006 xhr[ i ] = options.xhrFields[ i ]; 16007 } 16008 } 16009 16010 // Override mime type if needed 16011 if ( options.mimeType && xhr.overrideMimeType ) { 16012 xhr.overrideMimeType( options.mimeType ); 16013 } 16014 16015 // X-Requested-With header 16016 // For cross-domain requests, seeing as conditions for a preflight are 16017 // akin to a jigsaw puzzle, we simply never set it to be sure. 16018 // (it can always be set on a per-request basis or even using ajaxSetup) 16019 // For same-domain requests, won't change header if already provided. 16020 if ( !options.crossDomain && !headers[ "X-Requested-With" ] ) { 16021 headers[ "X-Requested-With" ] = "XMLHttpRequest"; 16022 } 16023 16024 // Set headers 16025 for ( i in headers ) { 16026 xhr.setRequestHeader( i, headers[ i ] ); 16027 } 16028 16029 // Callback 16030 callback = function( type ) { 16031 return function() { 16032 if ( callback ) { 16033 callback = errorCallback = xhr.onload = 16034 xhr.onerror = xhr.onabort = xhr.ontimeout = 16035 xhr.onreadystatechange = null; 16036 16037 if ( type === "abort" ) { 16038 xhr.abort(); 16039 } else if ( type === "error" ) { 16040 16041 // Support: IE <=9 only 16042 // On a manual native abort, IE9 throws 16043 // errors on any property access that is not readyState 16044 if ( typeof xhr.status !== "number" ) { 16045 complete( 0, "error" ); 16046 } else { 16047 complete( 16048 16049 // File: protocol always yields status 0; see trac-8605, trac-14207 16050 xhr.status, 16051 xhr.statusText 16052 ); 16053 } 16054 } else { 16055 complete( 16056 xhrSuccessStatus[ xhr.status ] || xhr.status, 16057 xhr.statusText, 16058 16059 // Support: IE <=9 only 16060 // IE9 has no XHR2 but throws on binary (trac-11426) 16061 // For XHR2 non-text, let the caller handle it (gh-2498) 16062 ( xhr.responseType || "text" ) !== "text" || 16063 typeof xhr.responseText !== "string" ? 16064 { binary: xhr.response } : 16065 { text: xhr.responseText }, 16066 xhr.getAllResponseHeaders() 16067 ); 16068 } 16069 } 16070 }; 16071 }; 16072 16073 // Listen to events 16074 xhr.onload = callback(); 16075 errorCallback = xhr.onerror = xhr.ontimeout = callback( "error" ); 16076 16077 // Support: IE 9 only 16078 // Use onreadystatechange to replace onabort 16079 // to handle uncaught aborts 16080 if ( xhr.onabort !== undefined ) { 16081 xhr.onabort = errorCallback; 16082 } else { 16083 xhr.onreadystatechange = function() { 16084 16085 // Check readyState before timeout as it changes 16086 if ( xhr.readyState === 4 ) { 16087 16088 // Allow onerror to be called first, 16089 // but that will not handle a native abort 16090 // Also, save errorCallback to a variable 16091 // as xhr.onerror cannot be accessed 16092 window.setTimeout( function() { 16093 if ( callback ) { 16094 errorCallback(); 16095 } 16096 } ); 16097 } 16098 }; 16099 } 16100 16101 // Create the abort callback 16102 callback = callback( "abort" ); 16103 16104 try { 16105 16106 // Do send the request (this may raise an exception) 16107 xhr.send( options.hasContent && options.data || null ); 16108 } catch ( e ) { 16109 16110 // trac-14683: Only rethrow if this hasn't been notified as an error yet 16111 if ( callback ) { 16112 throw e; 16113 } 16114 } 16115 }, 16116 16117 abort: function() { 16118 if ( callback ) { 16119 callback(); 16120 } 16121 } 16122 }; 16123 } 16124} ); 16125 16126 16127 16128 16129// Prevent auto-execution of scripts when no explicit dataType was provided (See gh-2432) 16130jQuery.ajaxPrefilter( function( s ) { 16131 if ( s.crossDomain ) { 16132 s.contents.script = false; 16133 } 16134} ); 16135 16136// Install script dataType 16137jQuery.ajaxSetup( { 16138 accepts: { 16139 script: "text/javascript, application/javascript, " + 16140 "application/ecmascript, application/x-ecmascript" 16141 }, 16142 contents: { 16143 script: /\b(?:java|ecma)script\b/ 16144 }, 16145 converters: { 16146 "text script": function( text ) { 16147 jQuery.globalEval( text ); 16148 return text; 16149 } 16150 } 16151} ); 16152 16153// Handle cache's special case and crossDomain 16154jQuery.ajaxPrefilter( "script", function( s ) { 16155 if ( s.cache === undefined ) { 16156 s.cache = false; 16157 } 16158 if ( s.crossDomain ) { 16159 s.type = "GET"; 16160 } 16161} ); 16162 16163// Bind script tag hack transport 16164jQuery.ajaxTransport( "script", function( s ) { 16165 16166 // This transport only deals with cross domain or forced-by-attrs requests 16167 if ( s.crossDomain || s.scriptAttrs ) { 16168 var script, callback; 16169 return { 16170 send: function( _, complete ) { 16171 script = jQuery( "<script>" ) 16172 .attr( s.scriptAttrs || {} ) 16173 .prop( { charset: s.scriptCharset, src: s.url } ) 16174 .on( "load error", callback = function( evt ) { 16175 script.remove(); 16176 callback = null; 16177 if ( evt ) { 16178 complete( evt.type === "error" ? 404 : 200, evt.type ); 16179 } 16180 } ); 16181 16182 // Use native DOM manipulation to avoid our domManip AJAX trickery 16183 document.head.appendChild( script[ 0 ] ); 16184 }, 16185 abort: function() { 16186 if ( callback ) { 16187 callback(); 16188 } 16189 } 16190 }; 16191 } 16192} ); 16193 16194 16195 16196 16197var oldCallbacks = [], 16198 rjsonp = /(=)\?(?=&|$)|\?\?/; 16199 16200// Default jsonp settings 16201jQuery.ajaxSetup( { 16202 jsonp: "callback", 16203 jsonpCallback: function() { 16204 var callback = oldCallbacks.pop() || ( jQuery.expando + "_" + ( nonce.guid++ ) ); 16205 this[ callback ] = true; 16206 return callback; 16207 } 16208} ); 16209 16210// Detect, normalize options and install callbacks for jsonp requests 16211jQuery.ajaxPrefilter( "json jsonp", function( s, originalSettings, jqXHR ) { 16212 16213 var callbackName, overwritten, responseContainer, 16214 jsonProp = s.jsonp !== false && ( rjsonp.test( s.url ) ? 16215 "url" : 16216 typeof s.data === "string" && 16217 ( s.contentType || "" ) 16218 .indexOf( "application/x-www-form-urlencoded" ) === 0 && 16219 rjsonp.test( s.data ) && "data" 16220 ); 16221 16222 // Handle iff the expected data type is "jsonp" or we have a parameter to set 16223 if ( jsonProp || s.dataTypes[ 0 ] === "jsonp" ) { 16224 16225 // Get callback name, remembering preexisting value associated with it 16226 callbackName = s.jsonpCallback = isFunction( s.jsonpCallback ) ? 16227 s.jsonpCallback() : 16228 s.jsonpCallback; 16229 16230 // Insert callback into url or form data 16231 if ( jsonProp ) { 16232 s[ jsonProp ] = s[ jsonProp ].replace( rjsonp, "$1" + callbackName ); 16233 } else if ( s.jsonp !== false ) { 16234 s.url += ( rquery.test( s.url ) ? "&" : "?" ) + s.jsonp + "=" + callbackName; 16235 } 16236 16237 // Use data converter to retrieve json after script execution
vendor: 8,362 bytes, lines 16238-16549
16238 s.converters[ "script json" ] = function() { 16239 if ( !responseContainer ) { 16240 jQuery.error( callbackName + " was not called" ); 16241 } 16242 return responseContainer[ 0 ]; 16243 }; 16244 16245 // Force json dataType 16246 s.dataTypes[ 0 ] = "json"; 16247 16248 // Install callback 16249 overwritten = window[ callbackName ]; 16250 window[ callbackName ] = function() { 16251 responseContainer = arguments; 16252 }; 16253 16254 // Clean-up function (fires after converters) 16255 jqXHR.always( function() { 16256 16257 // If previous value didn't exist - remove it 16258 if ( overwritten === undefined ) { 16259 jQuery( window ).removeProp( callbackName ); 16260 16261 // Otherwise restore preexisting value 16262 } else { 16263 window[ callbackName ] = overwritten; 16264 } 16265 16266 // Save back as free 16267 if ( s[ callbackName ] ) { 16268 16269 // Make sure that re-using the options doesn't screw things around 16270 s.jsonpCallback = originalSettings.jsonpCallback; 16271 16272 // Save the callback name for future use 16273 oldCallbacks.push( callbackName ); 16274 } 16275 16276 // Call if it was a function and we have a response 16277 if ( responseContainer && isFunction( overwritten ) ) { 16278 overwritten( responseContainer[ 0 ] ); 16279 } 16280 16281 responseContainer = overwritten = undefined; 16282 } ); 16283 16284 // Delegate to script 16285 return "script"; 16286 } 16287} ); 16288 16289 16290 16291 16292// Support: Safari 8 only 16293// In Safari 8 documents created via document.implementation.createHTMLDocument 16294// collapse sibling forms: the second one becomes a child of the first one. 16295// Because of that, this security measure has to be disabled in Safari 8. 16296// https://bugs.webkit.org/show_bug.cgi?id=137337 16297support.createHTMLDocument = ( function() { 16298 var body = document.implementation.createHTMLDocument( "" ).body; 16299 body.innerHTML = "<form></form><form></form>"; 16300 return body.childNodes.length === 2; 16301} )(); 16302 16303 16304// Argument "data" should be string of html 16305// context (optional): If specified, the fragment will be created in this context, 16306// defaults to document 16307// keepScripts (optional): If true, will include scripts passed in the html string 16308jQuery.parseHTML = function( data, context, keepScripts ) { 16309 if ( typeof data !== "string" ) { 16310 return []; 16311 } 16312 if ( typeof context === "boolean" ) { 16313 keepScripts = context; 16314 context = false; 16315 } 16316 16317 var base, parsed, scripts; 16318 16319 if ( !context ) { 16320 16321 // Stop scripts or inline event handlers from being executed immediately 16322 // by using document.implementation 16323 if ( support.createHTMLDocument ) { 16324 context = document.implementation.createHTMLDocument( "" ); 16325 16326 // Set the base href for the created document 16327 // so any parsed elements with URLs 16328 // are based on the document's URL (gh-2965) 16329 base = context.createElement( "base" ); 16330 base.href = document.location.href; 16331 context.head.appendChild( base ); 16332 } else { 16333 context = document; 16334 } 16335 } 16336 16337 parsed = rsingleTag.exec( data ); 16338 scripts = !keepScripts && []; 16339 16340 // Single tag 16341 if ( parsed ) { 16342 return [ context.createElement( parsed[ 1 ] ) ]; 16343 } 16344 16345 parsed = buildFragment( [ data ], context, scripts ); 16346 16347 if ( scripts && scripts.length ) { 16348 jQuery( scripts ).remove(); 16349 } 16350 16351 return jQuery.merge( [], parsed.childNodes ); 16352}; 16353 16354 16355/** 16356 * Load a url into a page 16357 */ 16358jQuery.fn.load = function( url, params, callback ) { 16359 var selector, type, response, 16360 self = this, 16361 off = url.indexOf( " " ); 16362 16363 if ( off > -1 ) { 16364 selector = stripAndCollapse( url.slice( off ) ); 16365 url = url.slice( 0, off ); 16366 } 16367 16368 // If it's a function 16369 if ( isFunction( params ) ) { 16370 16371 // We assume that it's the callback 16372 callback = params; 16373 params = undefined; 16374 16375 // Otherwise, build a param string 16376 } else if ( params && typeof params === "object" ) { 16377 type = "POST"; 16378 } 16379 16380 // If we have elements to modify, make the request 16381 if ( self.length > 0 ) { 16382 jQuery.ajax( { 16383 url: url, 16384 16385 // If "type" variable is undefined, then "GET" method will be used. 16386 // Make value of this field explicit since 16387 // user can override it through ajaxSetup method 16388 type: type || "GET", 16389 dataType: "html", 16390 data: params 16391 } ).done( function( responseText ) { 16392 16393 // Save response for use in complete callback 16394 response = arguments; 16395 16396 self.html( selector ? 16397 16398 // If a selector was specified, locate the right elements in a dummy div 16399 // Exclude scripts to avoid IE 'Permission Denied' errors 16400 jQuery( "<div>" ).append( jQuery.parseHTML( responseText ) ).find( selector ) : 16401 16402 // Otherwise use the full result 16403 responseText ); 16404 16405 // If the request succeeds, this function gets "data", "status", "jqXHR" 16406 // but they are ignored because response was set above. 16407 // If it fails, this function gets "jqXHR", "status", "error" 16408 } ).always( callback && function( jqXHR, status ) { 16409 self.each( function() { 16410 callback.apply( this, response || [ jqXHR.responseText, status, jqXHR ] ); 16411 } ); 16412 } ); 16413 } 16414 16415 return this; 16416}; 16417 16418 16419 16420 16421jQuery.expr.pseudos.animated = function( elem ) { 16422 return jQuery.grep( jQuery.timers, function( fn ) { 16423 return elem === fn.elem; 16424 } ).length; 16425}; 16426 16427 16428 16429 16430jQuery.offset = { 16431 setOffset: function( elem, options, i ) { 16432 var curPosition, curLeft, curCSSTop, curTop, curOffset, curCSSLeft, calculatePosition, 16433 position = jQuery.css( elem, "position" ), 16434 curElem = jQuery( elem ), 16435 props = {}; 16436 16437 // Set position first, in-case top/left are set even on static elem 16438 if ( position === "static" ) { 16439 elem.style.position = "relative"; 16440 } 16441 16442 curOffset = curElem.offset(); 16443 curCSSTop = jQuery.css( elem, "top" ); 16444 curCSSLeft = jQuery.css( elem, "left" ); 16445 calculatePosition = ( position === "absolute" || position === "fixed" ) && 16446 ( curCSSTop + curCSSLeft ).indexOf( "auto" ) > -1; 16447 16448 // Need to be able to calculate position if either 16449 // top or left is auto and position is either absolute or fixed 16450 if ( calculatePosition ) { 16451 curPosition = curElem.position(); 16452 curTop = curPosition.top; 16453 curLeft = curPosition.left; 16454 16455 } else { 16456 curTop = parseFloat( curCSSTop ) || 0; 16457 curLeft = parseFloat( curCSSLeft ) || 0; 16458 } 16459 16460 if ( isFunction( options ) ) { 16461 16462 // Use jQuery.extend here to allow modification of coordinates argument (gh-1848) 16463 options = options.call( elem, i, jQuery.extend( {}, curOffset ) ); 16464 } 16465 16466 if ( options.top != null ) { 16467 props.top = ( options.top - curOffset.top ) + curTop; 16468 } 16469 if ( options.left != null ) { 16470 props.left = ( options.left - curOffset.left ) + curLeft; 16471 } 16472 16473 if ( "using" in options ) { 16474 options.using.call( elem, props ); 16475 16476 } else { 16477 curElem.css( props ); 16478 } 16479 } 16480}; 16481 16482jQuery.fn.extend( { 16483 16484 // offset() relates an element's border box to the document origin 16485 offset: function( options ) { 16486 16487 // Preserve chaining for setter 16488 if ( arguments.length ) { 16489 return options === undefined ? 16490 this : 16491 this.each( function( i ) { 16492 jQuery.offset.setOffset( this, options, i ); 16493 } ); 16494 } 16495 16496 var rect, win, 16497 elem = this[ 0 ]; 16498 16499 if ( !elem ) { 16500 return; 16501 } 16502 16503 // Return zeros for disconnected and hidden (display: none) elements (gh-2310) 16504 // Support: IE <=11 only 16505 // Running getBoundingClientRect on a 16506 // disconnected node in IE throws an error 16507 if ( !elem.getClientRects().length ) { 16508 return { top: 0, left: 0 }; 16509 } 16510 16511 // Get document-relative position by adding viewport scroll to viewport-relative gBCR 16512 rect = elem.getBoundingClientRect(); 16513 win = elem.ownerDocument.defaultView; 16514 return { 16515 top: rect.top + win.pageYOffset, 16516 left: rect.left + win.pageXOffset 16517 }; 16518 }, 16519 16520 // position() relates an element's margin box to its offset parent's padding box 16521 // This corresponds to the behavior of CSS absolute positioning 16522 position: function() { 16523 if ( !this[ 0 ] ) { 16524 return; 16525 } 16526 16527 var offsetParent, offset, doc, 16528 elem = this[ 0 ], 16529 parentOffset = { top: 0, left: 0 }; 16530 16531 // position:fixed elements are offset from the viewport, which itself always has zero offset 16532 if ( jQuery.css( elem, "position" ) === "fixed" ) { 16533 16534 // Assume position:fixed implies availability of getBoundingClientRect 16535 offset = elem.getBoundingClientRect(); 16536 16537 } else { 16538 offset = this.offset(); 16539 16540 // Account for the *real* offset parent, which can be the document or its root element 16541 // when a statically positioned element is identified 16542 doc = elem.ownerDocument; 16543 offsetParent = elem.offsetParent || doc.documentElement; 16544 while ( offsetParent && 16545 ( offsetParent === doc.body || offsetParent === doc.documentElement ) && 16546 jQuery.css( offsetParent, "position" ) === "static" ) { 16547 16548 offsetParent = offsetParent.parentNode; 16549 }
vendor: 8,818 bytes, lines 16550-16843
16550 if ( offsetParent && offsetParent !== elem && offsetParent.nodeType === 1 ) { 16551 16552 // Incorporate borders into its offset, since they are outside its content origin 16553 parentOffset = jQuery( offsetParent ).offset(); 16554 parentOffset.top += jQuery.css( offsetParent, "borderTopWidth", true ); 16555 parentOffset.left += jQuery.css( offsetParent, "borderLeftWidth", true ); 16556 } 16557 } 16558 16559 // Subtract parent offsets and element margins 16560 return { 16561 top: offset.top - parentOffset.top - jQuery.css( elem, "marginTop", true ), 16562 left: offset.left - parentOffset.left - jQuery.css( elem, "marginLeft", true ) 16563 }; 16564 }, 16565 16566 // This method will return documentElement in the following cases: 16567 // 1) For the element inside the iframe without offsetParent, this method will return 16568 // documentElement of the parent window 16569 // 2) For the hidden or detached element 16570 // 3) For body or html element, i.e. in case of the html node - it will return itself 16571 // 16572 // but those exceptions were never presented as a real life use-cases 16573 // and might be considered as more preferable results. 16574 // 16575 // This logic, however, is not guaranteed and can change at any point in the future 16576 offsetParent: function() { 16577 return this.map( function() { 16578 var offsetParent = this.offsetParent; 16579 16580 while ( offsetParent && jQuery.css( offsetParent, "position" ) === "static" ) { 16581 offsetParent = offsetParent.offsetParent; 16582 } 16583 16584 return offsetParent || documentElement; 16585 } ); 16586 } 16587} ); 16588 16589// Create scrollLeft and scrollTop methods 16590jQuery.each( { scrollLeft: "pageXOffset", scrollTop: "pageYOffset" }, function( method, prop ) { 16591 var top = "pageYOffset" === prop; 16592 16593 jQuery.fn[ method ] = function( val ) { 16594 return access( this, function( elem, method, val ) { 16595 16596 // Coalesce documents and windows 16597 var win; 16598 if ( isWindow( elem ) ) { 16599 win = elem; 16600 } else if ( elem.nodeType === 9 ) { 16601 win = elem.defaultView; 16602 } 16603 16604 if ( val === undefined ) { 16605 return win ? win[ prop ] : elem[ method ]; 16606 } 16607 16608 if ( win ) { 16609 win.scrollTo( 16610 !top ? val : win.pageXOffset, 16611 top ? val : win.pageYOffset 16612 ); 16613 16614 } else { 16615 elem[ method ] = val; 16616 } 16617 }, method, val, arguments.length ); 16618 }; 16619} ); 16620 16621// Support: Safari <=7 - 9.1, Chrome <=37 - 49 16622// Add the top/left cssHooks using jQuery.fn.position 16623// Webkit bug: https://bugs.webkit.org/show_bug.cgi?id=29084 16624// Blink bug: https://bugs.chromium.org/p/chromium/issues/detail?id=589347 16625// getComputedStyle returns percent when specified for top/left/bottom/right; 16626// rather than make the css module depend on the offset module, just check for it here 16627jQuery.each( [ "top", "left" ], function( _i, prop ) { 16628 jQuery.cssHooks[ prop ] = addGetHookIf( support.pixelPosition, 16629 function( elem, computed ) { 16630 if ( computed ) { 16631 computed = curCSS( elem, prop ); 16632 16633 // If curCSS returns percentage, fallback to offset 16634 return rnumnonpx.test( computed ) ? 16635 jQuery( elem ).position()[ prop ] + "px" : 16636 computed; 16637 } 16638 } 16639 ); 16640} ); 16641 16642 16643// Create innerHeight, innerWidth, height, width, outerHeight and outerWidth methods 16644jQuery.each( { Height: "height", Width: "width" }, function( name, type ) { 16645 jQuery.each( { 16646 padding: "inner" + name, 16647 content: type, 16648 "": "outer" + name 16649 }, function( defaultExtra, funcName ) { 16650 16651 // Margin is only for outerHeight, outerWidth 16652 jQuery.fn[ funcName ] = function( margin, value ) { 16653 var chainable = arguments.length && ( defaultExtra || typeof margin !== "boolean" ), 16654 extra = defaultExtra || ( margin === true || value === true ? "margin" : "border" ); 16655 16656 return access( this, function( elem, type, value ) { 16657 var doc; 16658 16659 if ( isWindow( elem ) ) { 16660 16661 // $( window ).outerWidth/Height return w/h including scrollbars (gh-1729) 16662 return funcName.indexOf( "outer" ) === 0 ? 16663 elem[ "inner" + name ] : 16664 elem.document.documentElement[ "client" + name ]; 16665 } 16666 16667 // Get document width or height 16668 if ( elem.nodeType === 9 ) { 16669 doc = elem.documentElement; 16670 16671 // Either scroll[Width/Height] or offset[Width/Height] or client[Width/Height], 16672 // whichever is greatest 16673 return Math.max( 16674 elem.body[ "scroll" + name ], doc[ "scroll" + name ], 16675 elem.body[ "offset" + name ], doc[ "offset" + name ], 16676 doc[ "client" + name ] 16677 ); 16678 } 16679 16680 return value === undefined ? 16681 16682 // Get width or height on the element, requesting but not forcing parseFloat 16683 jQuery.css( elem, type, extra ) : 16684 16685 // Set width or height on the element 16686 jQuery.style( elem, type, value, extra ); 16687 }, type, chainable ? margin : undefined, chainable ); 16688 }; 16689 } ); 16690} ); 16691 16692 16693jQuery.each( [ 16694 "ajaxStart", 16695 "ajaxStop", 16696 "ajaxComplete", 16697 "ajaxError", 16698 "ajaxSuccess", 16699 "ajaxSend" 16700], function( _i, type ) { 16701 jQuery.fn[ type ] = function( fn ) { 16702 return this.on( type, fn ); 16703 }; 16704} ); 16705 16706 16707 16708 16709jQuery.fn.extend( { 16710 16711 bind: function( types, data, fn ) { 16712 return this.on( types, null, data, fn ); 16713 }, 16714 unbind: function( types, fn ) { 16715 return this.off( types, null, fn ); 16716 }, 16717 16718 delegate: function( selector, types, data, fn ) { 16719 return this.on( types, selector, data, fn ); 16720 }, 16721 undelegate: function( selector, types, fn ) { 16722 16723 // ( namespace ) or ( selector, types [, fn] ) 16724 return arguments.length === 1 ? 16725 this.off( selector, "**" ) : 16726 this.off( types, selector || "**", fn ); 16727 }, 16728 16729 hover: function( fnOver, fnOut ) { 16730 return this 16731 .on( "mouseenter", fnOver ) 16732 .on( "mouseleave", fnOut || fnOver ); 16733 } 16734} ); 16735 16736jQuery.each( 16737 ( "blur focus focusin focusout resize scroll click dblclick " + 16738 "mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave " + 16739 "change select submit keydown keypress keyup contextmenu" ).split( " " ), 16740 function( _i, name ) { 16741 16742 // Handle event binding 16743 jQuery.fn[ name ] = function( data, fn ) { 16744 return arguments.length > 0 ? 16745 this.on( name, null, data, fn ) : 16746 this.trigger( name ); 16747 }; 16748 } 16749); 16750 16751 16752 16753 16754// Support: Android <=4.0 only 16755// Make sure we trim BOM and NBSP 16756// Require that the "whitespace run" starts from a non-whitespace 16757// to avoid O(N^2) behavior when the engine would try matching "\s+$" at each space position. 16758var rtrim = /^[\s\uFEFF\xA0]+|([^\s\uFEFF\xA0])[\s\uFEFF\xA0]+$/g; 16759 16760// Bind a function to a context, optionally partially applying any 16761// arguments. 16762// jQuery.proxy is deprecated to promote standards (specifically Function#bind) 16763// However, it is not slated for removal any time soon 16764jQuery.proxy = function( fn, context ) { 16765 var tmp, args, proxy; 16766 16767 if ( typeof context === "string" ) { 16768 tmp = fn[ context ]; 16769 context = fn; 16770 fn = tmp; 16771 } 16772 16773 // Quick check to determine if target is callable, in the spec 16774 // this throws a TypeError, but we will just return undefined. 16775 if ( !isFunction( fn ) ) { 16776 return undefined; 16777 } 16778 16779 // Simulated bind 16780 args = slice.call( arguments, 2 ); 16781 proxy = function() { 16782 return fn.apply( context || this, args.concat( slice.call( arguments ) ) ); 16783 }; 16784 16785 // Set the guid of unique handler to the same of original handler, so it can be removed 16786 proxy.guid = fn.guid = fn.guid || jQuery.guid++; 16787 16788 return proxy; 16789}; 16790 16791jQuery.holdReady = function( hold ) { 16792 if ( hold ) { 16793 jQuery.readyWait++; 16794 } else { 16795 jQuery.ready( true ); 16796 } 16797}; 16798jQuery.isArray = Array.isArray; 16799jQuery.parseJSON = JSON.parse; 16800jQuery.nodeName = nodeName; 16801jQuery.isFunction = isFunction; 16802jQuery.isWindow = isWindow; 16803jQuery.camelCase = camelCase; 16804jQuery.type = toType; 16805 16806jQuery.now = Date.now; 16807 16808jQuery.isNumeric = function( obj ) { 16809 16810 // As of jQuery 3.0, isNumeric is limited to 16811 // strings and numbers (primitives or objects) 16812 // that can be coerced to finite numbers (gh-2662) 16813 var type = jQuery.type( obj ); 16814 return ( type === "number" || type === "string" ) && 16815 16816 // parseFloat NaNs numeric-cast false positives ("") 16817 // ...but misinterprets leading-number strings, particularly hex literals ("0x...") 16818 // subtraction forces infinities to NaN 16819 !isNaN( obj - parseFloat( obj ) ); 16820}; 16821 16822jQuery.trim = function( text ) { 16823 return text == null ? 16824 "" : 16825 ( text + "" ).replace( rtrim, "$1" ); 16826}; 16827 16828 16829 16830// Register as a named AMD module, since jQuery can be concatenated with other 16831// files that may use define, but not via a proper concatenation script that 16832// understands anonymous AMD modules. A named AMD is safest and most robust 16833// way to register. Lowercase jquery is used because AMD module names are 16834// derived from file names, and jQuery is normally delivered in a lowercase 16835// file name. Do this after creating the global so that if an AMD module wants 16836// to call noConflict to hide this version of jQuery, it will work. 16837 16838// Note that for maximum portability, libraries that are not jQuery should 16839// declare themselves as anonymous modules, and avoid setting a global if an 16840// AMD loader is present. jQuery is a special case. For more information, see 16841// https://github.com/jrburke/requirejs/wiki/Updating-existing-libraries#wiki-anon 16842 16843if ( t
16843ypeof define === "function" && define.amd ) { 16844 define( "jquery", [], function() { 16845 return jQuery; 16846 } ); 16847} 16848 16849 16850 16851 16852var 16853 16854 // Map over jQuery in case of overwrite 16855 _jQuery = window.jQuery, 16856 16857 // Map over the $ in case of overwrite 16858 _$ = window.$; 16859 16860jQuery.noConflict = function( deep ) { 16861 if ( window.$ === jQuery ) { 16862 window.$ = _$; 16863 } 16864 16865 if ( deep && window.jQuery === jQuery ) { 16866 window.jQuery = _jQuery; 16867 } 16868 16869 return jQuery; 16870}; 16871 16872// Expose jQuery and $ identifiers, even in AMD 16873// (trac-7102#comment:10, https://github.com/jquery/jquery/pull/557) 16874// and CommonJS for browser emulators (trac-13566) 16875if ( typeof noGlobal === "undefined" ) { 16876 window.jQuery = window.$ = jQuery; 16877} 16878 16879 16880 16881 16882return jQuery; 16883} ); 16884 16885},{}],13:[function(require,module,exports){ 16886(function (global){(function (){
vendor: 13,312 bytes, lines 16887-17326
16887/** 16888 * lodash (Custom Build) <https://lodash.com/> 16889 * Build: `lodash modularize exports="npm" -o ./` 16890 * Copyright jQuery Foundation and other contributors <https://jquery.org/> 16891 * Released under MIT license <https://lodash.com/license> 16892 * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE> 16893 * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors 16894 */ 16895 16896/** Used as the `TypeError` message for "Functions" methods. */ 16897var FUNC_ERROR_TEXT = 'Expected a function'; 16898 16899/** Used as references for various `Number` constants. */ 16900var NAN = 0 / 0; 16901 16902/** `Object#toString` result references. */ 16903var symbolTag = '[object Symbol]'; 16904 16905/** Used to match leading and trailing whitespace. */ 16906var reTrim = /^\s+|\s+$/g; 16907 16908/** Used to detect bad signed hexadecimal string values. */ 16909var reIsBadHex = /^[-+]0x[0-9a-f]+$/i; 16910 16911/** Used to detect binary string values. */ 16912var reIsBinary = /^0b[01]+$/i; 16913 16914/** Used to detect octal string values. */ 16915var reIsOctal = /^0o[0-7]+$/i; 16916 16917/** Built-in method references without a dependency on `root`. */ 16918var freeParseInt = parseInt; 16919 16920/** Detect free variable `global` from Node.js. */ 16921var freeGlobal = typeof global == 'object' && global && global.Object === Object && global; 16922 16923/** Detect free variable `self`. */ 16924var freeSelf = typeof self == 'object' && self && self.Object === Object && self; 16925 16926/** Used as a reference to the global object. */ 16927var root = freeGlobal || freeSelf || Function('return this')(); 16928 16929/** Used for built-in method references. */ 16930var objectProto = Object.prototype; 16931 16932/** 16933 * Used to resolve the 16934 * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring) 16935 * of values. 16936 */ 16937var objectToString = objectProto.toString; 16938 16939/* Built-in method references for those with the same name as other `lodash` methods. */ 16940var nativeMax = Math.max, 16941 nativeMin = Math.min; 16942 16943/** 16944 * Gets the timestamp of the number of milliseconds that have elapsed since 16945 * the Unix epoch (1 January 1970 00:00:00 UTC). 16946 * 16947 * @static 16948 * @memberOf _ 16949 * @since 2.4.0 16950 * @category Date 16951 * @returns {number} Returns the timestamp. 16952 * @example 16953 * 16954 * _.defer(function(stamp) { 16955 * console.log(_.now() - stamp); 16956 * }, _.now()); 16957 * // => Logs the number of milliseconds it took for the deferred invocation. 16958 */ 16959var now = function() { 16960 return root.Date.now(); 16961}; 16962 16963/** 16964 * Creates a debounced function that delays invoking `func` until after `wait` 16965 * milliseconds have elapsed since the last time the debounced function was 16966 * invoked. The debounced function comes with a `cancel` method to cancel 16967 * delayed `func` invocations and a `flush` method to immediately invoke them. 16968 * Provide `options` to indicate whether `func` should be invoked on the 16969 * leading and/or trailing edge of the `wait` timeout. The `func` is invoked 16970 * with the last arguments provided to the debounced function. Subsequent 16971 * calls to the debounced function return the result of the last `func` 16972 * invocation. 16973 * 16974 * **Note:** If `leading` and `trailing` options are `true`, `func` is 16975 * invoked on the trailing edge of the timeout only if the debounced function 16976 * is invoked more than once during the `wait` timeout. 16977 * 16978 * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred 16979 * until to the next tick, similar to `setTimeout` with a timeout of `0`. 16980 * 16981 * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/) 16982 * for details over the differences between `_.debounce` and `_.throttle`. 16983 * 16984 * @static 16985 * @memberOf _ 16986 * @since 0.1.0 16987 * @category Function 16988 * @param {Function} func The function to debounce. 16989 * @param {number} [wait=0] The number of milliseconds to delay. 16990 * @param {Object} [options={}] The options object. 16991 * @param {boolean} [options.leading=false] 16992 * Specify invoking on the leading edge of the timeout. 16993 * @param {number} [options.maxWait] 16994 * The maximum time `func` is allowed to be delayed before it's invoked. 16995 * @param {boolean} [options.trailing=true] 16996 * Specify invoking on the trailing edge of the timeout. 16997 * @returns {Function} Returns the new debounced function. 16998 * @example 16999 * 17000 * // Avoid costly calculations while the window size is in flux. 17001 * jQuery(window).on('resize', _.debounce(calculateLayout, 150)); 17002 * 17003 * // Invoke `sendMail` when clicked, debouncing subsequent calls. 17004 * jQuery(element).on('click', _.debounce(sendMail, 300, { 17005 * 'leading': true, 17006 * 'trailing': false 17007 * })); 17008 * 17009 * // Ensure `batchLog` is invoked once after 1 second of debounced calls. 17010 * var debounced = _.debounce(batchLog, 250, { 'maxWait': 1000 }); 17011 * var source = new EventSource('/stream'); 17012 * jQuery(source).on('message', debounced); 17013 * 17014 * // Cancel the trailing debounced invocation. 17015 * jQuery(window).on('popstate', debounced.cancel); 17016 */ 17017function debounce(func, wait, options) { 17018 var lastArgs, 17019 lastThis, 17020 maxWait, 17021 result, 17022 timerId, 17023 lastCallTime, 17024 lastInvokeTime = 0, 17025 leading = false, 17026 maxing = false, 17027 trailing = true; 17028 17029 if (typeof func != 'function') { 17030 throw new TypeError(FUNC_ERROR_TEXT); 17031 } 17032 wait = toNumber(wait) || 0; 17033 if (isObject(options)) { 17034 leading = !!options.leading; 17035 maxing = 'maxWait' in options; 17036 maxWait = maxing ? nativeMax(toNumber(options.maxWait) || 0, wait) : maxWait; 17037 trailing = 'trailing' in options ? !!options.trailing : trailing; 17038 } 17039 17040 function invokeFunc(time) { 17041 var args = lastArgs, 17042 thisArg = lastThis; 17043 17044 lastArgs = lastThis = undefined; 17045 lastInvokeTime = time; 17046 result = func.apply(thisArg, args); 17047 return result; 17048 } 17049 17050 function leadingEdge(time) { 17051 // Reset any `maxWait` timer. 17052 lastInvokeTime = time; 17053 // Start the timer for the trailing edge. 17054 timerId = setTimeout(timerExpired, wait); 17055 // Invoke the leading edge. 17056 return leading ? invokeFunc(time) : result; 17057 } 17058 17059 function remainingWait(time) { 17060 var timeSinceLastCall = time - lastCallTime, 17061 timeSinceLastInvoke = time - lastInvokeTime, 17062 result = wait - timeSinceLastCall; 17063 17064 return maxing ? nativeMin(result, maxWait - timeSinceLastInvoke) : result; 17065 } 17066 17067 function shouldInvoke(time) { 17068 var timeSinceLastCall = time - lastCallTime, 17069 timeSinceLastInvoke = time - lastInvokeTime; 17070 17071 // Either this is the first call, activity has stopped and we're at the 17072 // trailing edge, the system time has gone backwards and we're treating 17073 // it as the trailing edge, or we've hit the `maxWait` limit. 17074 return (lastCallTime === undefined || (timeSinceLastCall >= wait) || 17075 (timeSinceLastCall < 0) || (maxing && timeSinceLastInvoke >= maxWait)); 17076 } 17077 17078 function timerExpired() { 17079 var time = now(); 17080 if (shouldInvoke(time)) { 17081 return trailingEdge(time); 17082 } 17083 // Restart the timer. 17084 timerId = setTimeout(timerExpired, remainingWait(time)); 17085 } 17086 17087 function trailingEdge(time) { 17088 timerId = undefined; 17089 17090 // Only invoke if we have `lastArgs` which means `func` has been 17091 // debounced at least once. 17092 if (trailing && lastArgs) { 17093 return invokeFunc(time); 17094 } 17095 lastArgs = lastThis = undefined; 17096 return result; 17097 } 17098 17099 function cancel() { 17100 if (timerId !== undefined) { 17101 clearTimeout(timerId); 17102 } 17103 lastInvokeTime = 0; 17104 lastArgs = lastCallTime = lastThis = timerId = undefined; 17105 } 17106 17107 function flush() { 17108 return timerId === undefined ? result : trailingEdge(now()); 17109 } 17110 17111 function debounced() { 17112 var time = now(), 17113 isInvoking = shouldInvoke(time); 17114 17115 lastArgs = arguments; 17116 lastThis = this; 17117 lastCallTime = time; 17118 17119 if (isInvoking) { 17120 if (timerId === undefined) { 17121 return leadingEdge(lastCallTime); 17122 } 17123 if (maxing) { 17124 // Handle invocations in a tight loop. 17125 timerId = setTimeout(timerExpired, wait); 17126 return invokeFunc(lastCallTime); 17127 } 17128 } 17129 if (timerId === undefined) { 17130 timerId = setTimeout(timerExpired, wait); 17131 } 17132 return result; 17133 } 17134 debounced.cancel = cancel; 17135 debounced.flush = flush; 17136 return debounced; 17137} 17138 17139/** 17140 * Creates a throttled function that only invokes `func` at most once per 17141 * every `wait` milliseconds. The throttled function comes with a `cancel` 17142 * method to cancel delayed `func` invocations and a `flush` method to 17143 * immediately invoke them. Provide `options` to indicate whether `func` 17144 * should be invoked on the leading and/or trailing edge of the `wait` 17145 * timeout. The `func` is invoked with the last arguments provided to the 17146 * throttled function. Subsequent calls to the throttled function return the 17147 * result of the last `func` invocation. 17148 * 17149 * **Note:** If `leading` and `trailing` options are `true`, `func` is 17150 * invoked on the trailing edge of the timeout only if the throttled function 17151 * is invoked more than once during the `wait` timeout. 17152 * 17153 * If `wait` is `0` and `leading` is `false`, `func` invocation is deferred 17154 * until to the next tick, similar to `setTimeout` with a timeout of `0`. 17155 * 17156 * See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/) 17157 * for details over the differences between `_.throttle` and `_.debounce`. 17158 * 17159 * @static 17160 * @memberOf _ 17161 * @since 0.1.0 17162 * @category Function 17163 * @param {Function} func The function to throttle. 17164 * @param {number} [wait=0] The number of milliseconds to throttle invocations to. 17165 * @param {Object} [options={}] The options object. 17166 * @param {boolean} [options.leading=true] 17167 * Specify invoking on the leading edge of the timeout. 17168 * @param {boolean} [options.trailing=true] 17169 * Specify invoking on the trailing edge of the timeout. 17170 * @returns {Function} Returns the new throttled function. 17171 * @example 17172 * 17173 * // Avoid excessively updating the position while scrolling. 17174 * jQuery(window).on('scroll', _.throttle(updatePosition, 100)); 17175 * 17176 * // Invoke `renewToken` when the click event is fired, but not more than once every 5 minutes. 17177 * var throttled = _.throttle(renewToken, 300000, { 'trailing': false }); 17178 * jQuery(element).on('click', throttled); 17179 * 17180 * // Cancel the trailing throttled invocation. 17181 * jQuery(window).on('popstate', throttled.cancel); 17182 */ 17183function throttle(func, wait, options) { 17184 var leading = true, 17185 trailing = true; 17186 17187 if (typeof func != 'function') { 17188 throw new TypeError(FUNC_ERROR_TEXT); 17189 } 17190 if (isObject(options)) { 17191 leading = 'leading' in options ? !!options.leading : leading; 17192 trailing = 'trailing' in options ? !!options.trailing : trailing; 17193 } 17194 return debounce(func, wait, { 17195 'leading': leading, 17196 'maxWait': wait, 17197 'trailing': trailing 17198 }); 17199} 17200 17201/** 17202 * Checks if `value` is the 17203 * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types) 17204 * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`) 17205 * 17206 * @static 17207 * @memberOf _ 17208 * @since 0.1.0 17209 * @category Lang 17210 * @param {*} value The value to check. 17211 * @returns {boolean} Returns `true` if `value` is an object, else `false`. 17212 * @example 17213 * 17214 * _.isObject({}); 17215 * // => true 17216 * 17217 * _.isObject([1, 2, 3]); 17218 * // => true 17219 * 17220 * _.isObject(_.noop); 17221 * // => true 17222 * 17223 * _.isObject(null); 17224 * // => false 17225 */ 17226function isObject(value) { 17227 var type = typeof value; 17228 return !!value && (type == 'object' || type == 'function'); 17229} 17230 17231/** 17232 * Checks if `value` is object-like. A value is object-like if it's not `null` 17233 * and has a `typeof` result of "object". 17234 * 17235 * @static 17236 * @memberOf _ 17237 * @since 4.0.0 17238 * @category Lang 17239 * @param {*} value The value to check. 17240 * @returns {boolean} Returns `true` if `value` is object-like, else `false`. 17241 * @example 17242 * 17243 * _.isObjectLike({}); 17244 * // => true 17245 * 17246 * _.isObjectLike([1, 2, 3]); 17247 * // => true 17248 * 17249 * _.isObjectLike(_.noop); 17250 * // => false 17251 * 17252 * _.isObjectLike(null); 17253 * // => false 17254 */ 17255function isObjectLike(value) { 17256 return !!value && typeof value == 'object'; 17257} 17258 17259/** 17260 * Checks if `value` is classified as a `Symbol` primitive or object. 17261 * 17262 * @static 17263 * @memberOf _ 17264 * @since 4.0.0 17265 * @category Lang 17266 * @param {*} value The value to check. 17267 * @returns {boolean} Returns `true` if `value` is a symbol, else `false`. 17268 * @example 17269 * 17270 * _.isSymbol(Symbol.iterator); 17271 * // => true 17272 * 17273 * _.isSymbol('abc'); 17274 * // => false 17275 */ 17276function isSymbol(value) { 17277 return typeof value == 'symbol' || 17278 (isObjectLike(value) && objectToString.call(value) == symbolTag); 17279} 17280 17281/** 17282 * Converts `value` to a number. 17283 * 17284 * @static 17285 * @memberOf _ 17286 * @since 4.0.0 17287 * @category Lang 17288 * @param {*} value The value to process. 17289 * @returns {number} Returns the number. 17290 * @example 17291 * 17292 * _.toNumber(3.2); 17293 * // => 3.2 17294 * 17295 * _.toNumber(Number.MIN_VALUE); 17296 * // => 5e-324 17297 * 17298 * _.toNumber(Infinity); 17299 * // => Infinity 17300 * 17301 * _.toNumber('3.2'); 17302 * // => 3.2 17303 */ 17304function toNumber(value) { 17305 if (typeof value == 'number') { 17306 return value; 17307 } 17308 if (isSymbol(value)) { 17309 return NAN; 17310 } 17311 if (isObject(value)) { 17312 var other = typeof value.valueOf == 'function' ? value.valueOf() : value; 17313 value = isObject(other) ? (other + '') : other; 17314 } 17315 if (typeof value != 'string') { 17316 return value === 0 ? value : +value; 17317 } 17318 value = value.replace(reTrim, ''); 17319 var isBinary = reIsBinary.test(value); 17320 return (isBinary || reIsOctal.test(value)) 17321 ? freeParseInt(value.slice(2), isBinary ? 2 : 8) 17322 : (reIsBadHex.test(value) ? NAN : +value); 17323} 17324 17325module.exports = throttle; 17326
17327}).call(this)}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) 17328},{}],14:[function(require,module,exports){ 17329(function (global){(function (){ 17330/**! 17331 * @fileOverview Kickass library to create and place poppers near their reference elements. 17332 * @version 1.16.0 17333 * @license 17334 * Copyright (c) 2016 Federico Zivolo and contributors 17335 * 17336 * Permission is hereby granted, free of charge, to any person obtaining a copy 17337 * of this software and associated documentation files (the "Software"), to deal 17338 * in the Software without restriction, including without limitation the rights 17339 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 17340 * copies of the Software, and to permit persons to whom the Software is 17341 * furnished to do so, subject to the following conditions: 17342 * 17343 * The above copyright notice and this permission notice shall be included in all 17344 * copies or substantial portions of the Software. 17345 * 17346 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 17347 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17348 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 17349 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 17350 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 17351 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 17352 * SOFTWARE. 17353 */ 17354(function (global, factory) { 17355 typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() : 17356 typeof define === 'function' && define.amd ? define(factory) : 17357 (global.Popper = factory()); 17358}(this, (function () { 'use strict'; 17359 17360var isBrowser = typeof window !== 'undefined' && typeof document !== 'undefined' && typeof navigator !== 'undefined'; 17361 17362var timeoutDuration = function () { 17363 var longerTimeoutBrowsers = ['Edge', 'Trident', 'Firefox']; 17364 for (var i = 0; i < longerTimeoutBrowsers.length; i += 1) { 17365 if (isBrowser && navigator.userAgent.indexOf(longerTimeoutBrowsers[i]) >= 0) { 17366 return 1; 17367 } 17368 } 17369 return 0; 17370}(); 17371 17372function microtaskDebounce(fn) { 17373 var called = false;
vendor: 3,141 bytes, lines 17374-17499
17374 return function () { 17375 if (called) { 17376 return; 17377 } 17378 called = true; 17379 window.Promise.resolve().then(function () { 17380 called = false; 17381 fn(); 17382 }); 17383 }; 17384} 17385 17386function taskDebounce(fn) { 17387 var scheduled = false; 17388 return function () { 17389 if (!scheduled) { 17390 scheduled = true; 17391 setTimeout(function () { 17392 scheduled = false; 17393 fn(); 17394 }, timeoutDuration); 17395 } 17396 }; 17397} 17398 17399var supportsMicroTasks = isBrowser && window.Promise; 17400 17401/** 17402* Create a debounced version of a method, that's asynchronously deferred 17403* but called in the minimum time possible. 17404* 17405* @method 17406* @memberof Popper.Utils 17407* @argument {Function} fn 17408* @returns {Function} 17409*/ 17410var debounce = supportsMicroTasks ? microtaskDebounce : taskDebounce; 17411 17412/** 17413 * Check if the given variable is a function 17414 * @method 17415 * @memberof Popper.Utils 17416 * @argument {Any} functionToCheck - variable to check 17417 * @returns {Boolean} answer to: is a function? 17418 */ 17419function isFunction(functionToCheck) { 17420 var getType = {}; 17421 return functionToCheck && getType.toString.call(functionToCheck) === '[object Function]'; 17422} 17423 17424/** 17425 * Get CSS computed property of the given element 17426 * @method 17427 * @memberof Popper.Utils 17428 * @argument {Eement} element 17429 * @argument {String} property 17430 */ 17431function getStyleComputedProperty(element, property) { 17432 if (element.nodeType !== 1) { 17433 return []; 17434 } 17435 // NOTE: 1 DOM access here 17436 var window = element.ownerDocument.defaultView; 17437 var css = window.getComputedStyle(element, null); 17438 return property ? css[property] : css; 17439} 17440 17441/** 17442 * Returns the parentNode or the host of the element 17443 * @method 17444 * @memberof Popper.Utils 17445 * @argument {Element} element 17446 * @returns {Element} parent 17447 */ 17448function getParentNode(element) { 17449 if (element.nodeName === 'HTML') { 17450 return element; 17451 } 17452 return element.parentNode || element.host; 17453} 17454 17455/** 17456 * Returns the scrolling parent of the given element 17457 * @method 17458 * @memberof Popper.Utils 17459 * @argument {Element} element 17460 * @returns {Element} scroll parent 17461 */ 17462function getScrollParent(element) { 17463 // Return body, `getScroll` will take care to get the correct `scrollTop` from it 17464 if (!element) { 17465 return document.body; 17466 } 17467 17468 switch (element.nodeName) { 17469 case 'HTML': 17470 case 'BODY': 17471 return element.ownerDocument.body; 17472 case '#document': 17473 return element.body; 17474 } 17475 17476 // Firefox want us to check `-x` and `-y` variations as well 17477 17478 var _getStyleComputedProp = getStyleComputedProperty(element), 17479 overflow = _getStyleComputedProp.overflow, 17480 overflowX = _getStyleComputedProp.overflowX, 17481 overflowY = _getStyleComputedProp.overflowY; 17482 17483 if (/(auto|scroll|overlay)/.test(overflow + overflowY + overflowX)) { 17484 return element; 17485 } 17486 17487 return getScrollParent(getParentNode(element)); 17488} 17489 17490/** 17491 * Returns the reference node of the reference object, or the reference object itself. 17492 * @method 17493 * @memberof Popper.Utils 17494 * @param {Element|Object} reference - the reference element (the popper will be relative to this) 17495 * @returns {Element} parent 17496 */ 17497function getReferenceNode(reference) { 17498 return reference && reference.referenceNode ? reference.referenceNode : reference; 17499}
vendor: 3,047 bytes, lines 17499-17605
17499 17500 17501var isIE11 = isBrowser && !!(window.MSInputMethodContext && document.documentMode); 17502var isIE10 = isBrowser && /MSIE 10/.test(navigator.userAgent); 17503 17504/** 17505 * Determines if the browser is Internet Explorer 17506 * @method 17507 * @memberof Popper.Utils 17508 * @param {Number} version to check 17509 * @returns {Boolean} isIE 17510 */ 17511function isIE(version) { 17512 if (version === 11) { 17513 return isIE11; 17514 } 17515 if (version === 10) { 17516 return isIE10; 17517 } 17518 return isIE11 || isIE10; 17519} 17520 17521/** 17522 * Returns the offset parent of the given element 17523 * @method 17524 * @memberof Popper.Utils 17525 * @argument {Element} element 17526 * @returns {Element} offset parent 17527 */ 17528function getOffsetParent(element) { 17529 if (!element) { 17530 return document.documentElement; 17531 } 17532 17533 var noOffsetParent = isIE(10) ? document.body : null; 17534 17535 // NOTE: 1 DOM access here 17536 var offsetParent = element.offsetParent || null; 17537 // Skip hidden elements which don't have an offsetParent 17538 while (offsetParent === noOffsetParent && element.nextElementSibling) { 17539 offsetParent = (element = element.nextElementSibling).offsetParent; 17540 } 17541 17542 var nodeName = offsetParent && offsetParent.nodeName; 17543 17544 if (!nodeName || nodeName === 'BODY' || nodeName === 'HTML') { 17545 return element ? element.ownerDocument.documentElement : document.documentElement; 17546 } 17547 17548 // .offsetParent will return the closest TH, TD or TABLE in case 17549 // no offsetParent is present, I hate this job... 17550 if (['TH', 'TD', 'TABLE'].indexOf(offsetParent.nodeName) !== -1 && getStyleComputedProperty(offsetParent, 'position') === 'static') { 17551 return getOffsetParent(offsetParent); 17552 } 17553 17554 return offsetParent; 17555} 17556 17557function isOffsetContainer(element) { 17558 var nodeName = element.nodeName; 17559 17560 if (nodeName === 'BODY') { 17561 return false; 17562 } 17563 return nodeName === 'HTML' || getOffsetParent(element.firstElementChild) === element; 17564} 17565 17566/** 17567 * Finds the root node (document, shadowDOM root) of the given element 17568 * @method 17569 * @memberof Popper.Utils 17570 * @argument {Element} node 17571 * @returns {Element} root node 17572 */ 17573function getRoot(node) { 17574 if (node.parentNode !== null) { 17575 return getRoot(node.parentNode); 17576 } 17577 17578 return node; 17579} 17580 17581/** 17582 * Finds the offset parent common to the two provided nodes 17583 * @method 17584 * @memberof Popper.Utils 17585 * @argument {Element} element1 17586 * @argument {Element} element2 17587 * @returns {Element} common offset parent 17588 */ 17589function findCommonOffsetParent(element1, element2) { 17590 // This check is needed to avoid errors in case one of the elements isn't defined for any reason 17591 if (!element1 || !element1.nodeType || !element2 || !element2.nodeType) { 17592 return document.documentElement; 17593 } 17594 17595 // Here we make sure to give as "start" the element that comes first in the DOM 17596 var order = element1.compareDocumentPosition(element2) & Node.DOCUMENT_POSITION_FOLLOWING; 17597 var start = order ? element1 : element2; 17598 var end = order ? element2 : element1; 17599 17600 // Get common ancestor container 17601 var range = document.createRange(); 17602 range.setStart(start, 0); 17603 range.setEnd(end, 0); 17604 var commonAncestorContainer = range.commonAncestorContainer; 17605
vendor: 6,175 bytes, lines 17606-17809
17606 // Both nodes are inside #document 17607 17608 if (element1 !== commonAncestorContainer && element2 !== commonAncestorContainer || start.contains(end)) { 17609 if (isOffsetContainer(commonAncestorContainer)) { 17610 return commonAncestorContainer; 17611 } 17612 17613 return getOffsetParent(commonAncestorContainer); 17614 } 17615 17616 // one of the nodes is inside shadowDOM, find which one 17617 var element1root = getRoot(element1); 17618 if (element1root.host) { 17619 return findCommonOffsetParent(element1root.host, element2); 17620 } else { 17621 return findCommonOffsetParent(element1, getRoot(element2).host); 17622 } 17623} 17624 17625/** 17626 * Gets the scroll value of the given element in the given side (top and left) 17627 * @method 17628 * @memberof Popper.Utils 17629 * @argument {Element} element 17630 * @argument {String} side `top` or `left` 17631 * @returns {number} amount of scrolled pixels 17632 */ 17633function getScroll(element) { 17634 var side = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'top'; 17635 17636 var upperSide = side === 'top' ? 'scrollTop' : 'scrollLeft'; 17637 var nodeName = element.nodeName; 17638 17639 if (nodeName === 'BODY' || nodeName === 'HTML') { 17640 var html = element.ownerDocument.documentElement; 17641 var scrollingElement = element.ownerDocument.scrollingElement || html; 17642 return scrollingElement[upperSide]; 17643 } 17644 17645 return element[upperSide]; 17646} 17647 17648/* 17649 * Sum or subtract the element scroll values (left and top) from a given rect object 17650 * @method 17651 * @memberof Popper.Utils 17652 * @param {Object} rect - Rect object you want to change 17653 * @param {HTMLElement} element - The element from the function reads the scroll values 17654 * @param {Boolean} subtract - set to true if you want to subtract the scroll values 17655 * @return {Object} rect - The modifier rect object 17656 */ 17657function includeScroll(rect, element) { 17658 var subtract = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false; 17659 17660 var scrollTop = getScroll(element, 'top'); 17661 var scrollLeft = getScroll(element, 'left'); 17662 var modifier = subtract ? -1 : 1; 17663 rect.top += scrollTop * modifier; 17664 rect.bottom += scrollTop * modifier; 17665 rect.left += scrollLeft * modifier; 17666 rect.right += scrollLeft * modifier; 17667 return rect; 17668} 17669 17670/* 17671 * Helper to detect borders of a given element 17672 * @method 17673 * @memberof Popper.Utils 17674 * @param {CSSStyleDeclaration} styles 17675 * Result of `getStyleComputedProperty` on the given element 17676 * @param {String} axis - `x` or `y` 17677 * @return {number} borders - The borders size of the given axis 17678 */ 17679 17680function getBordersSize(styles, axis) { 17681 var sideA = axis === 'x' ? 'Left' : 'Top'; 17682 var sideB = sideA === 'Left' ? 'Right' : 'Bottom'; 17683 17684 return parseFloat(styles['border' + sideA + 'Width'], 10) + parseFloat(styles['border' + sideB + 'Width'], 10); 17685} 17686 17687function getSize(axis, body, html, computedStyle) { 17688 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); 17689} 17690 17691function getWindowSizes(document) { 17692 var body = document.body; 17693 var html = document.documentElement; 17694 var computedStyle = isIE(10) && getComputedStyle(html); 17695 17696 return { 17697 height: getSize('Height', body, html, computedStyle), 17698 width: getSize('Width', body, html, computedStyle) 17699 }; 17700} 17701 17702var classCallCheck = function (instance, Constructor) { 17703 if (!(instance instanceof Constructor)) { 17704 throw new TypeError("Cannot call a class as a function"); 17705 } 17706}; 17707 17708var createClass = function () { 17709 function defineProperties(target, props) { 17710 for (var i = 0; i < props.length; i++) { 17711 var descriptor = props[i]; 17712 descriptor.enumerable = descriptor.enumerable || false; 17713 descriptor.configurable = true; 17714 if ("value" in descriptor) descriptor.writable = true; 17715 Object.defineProperty(target, descriptor.key, descriptor); 17716 } 17717 } 17718 17719 return function (Constructor, protoProps, staticProps) { 17720 if (protoProps) defineProperties(Constructor.prototype, protoProps); 17721 if (staticProps) defineProperties(Constructor, staticProps); 17722 return Constructor; 17723 }; 17724}(); 17725 17726 17727 17728 17729 17730var defineProperty = function (obj, key, value) { 17731 if (key in obj) { 17732 Object.defineProperty(obj, key, { 17733 value: value, 17734 enumerable: true, 17735 configurable: true, 17736 writable: true 17737 }); 17738 } else { 17739 obj[key] = value; 17740 } 17741 17742 return obj; 17743}; 17744 17745var _extends = Object.assign || function (target) { 17746 for (var i = 1; i < arguments.length; i++) { 17747 var source = arguments[i]; 17748 17749 for (var key in source) { 17750 if (Object.prototype.hasOwnProperty.call(source, key)) { 17751 target[key] = source[key]; 17752 } 17753 } 17754 } 17755 17756 return target; 17757}; 17758 17759/** 17760 * Given element offsets, generate an output similar to getBoundingClientRect 17761 * @method 17762 * @memberof Popper.Utils 17763 * @argument {Object} offsets 17764 * @returns {Object} ClientRect like output 17765 */ 17766function getClientRect(offsets) { 17767 return _extends({}, offsets, { 17768 right: offsets.left + offsets.width, 17769 bottom: offsets.top + offsets.height 17770 }); 17771} 17772 17773/** 17774 * Get bounding client rect of given element 17775 * @method 17776 * @memberof Popper.Utils 17777 * @param {HTMLElement} element 17778 * @return {Object} client rect 17779 */ 17780function getBoundingClientRect(element) { 17781 var rect = {}; 17782 17783 // IE10 10 FIX: Please, don't ask, the element isn't 17784 // considered in DOM in some circumstances... 17785 // This isn't reproducible in IE10 compatibility mode of IE11 17786 try { 17787 if (isIE(10)) { 17788 rect = element.getBoundingClientRect(); 17789 var scrollTop = getScroll(element, 'top'); 17790 var scrollLeft = getScroll(element, 'left'); 17791 rect.top += scrollTop; 17792 rect.left += scrollLeft; 17793 rect.bottom += scrollTop; 17794 rect.right += scrollLeft; 17795 } else { 17796 rect = element.getBoundingClientRect(); 17797 } 17798 } catch (e) {} 17799 17800 var result = { 17801 left: rect.left, 17802 top: rect.top, 17803 width: rect.right - rect.left, 17804 height: rect.bottom - rect.top 17805 }; 17806 17807 // subtract scrollbar size from sizes 17808 var sizes = element.nodeName === 'HTML' ? getWindowSizes(element.ownerDocument) : {}; 17809 var width = sizes.width || element.clientWidth || result.
vendor: 2,119 bytes, lines 17809-17862
17809width; 17810 var height = sizes.height || element.clientHeight || result.height; 17811 17812 var horizScrollbar = element.offsetWidth - width; 17813 var vertScrollbar = element.offsetHeight - height; 17814 17815 // if an hypothetical scrollbar is detected, we must be sure it's not a `border` 17816 // we make this check conditional for performance reasons 17817 if (horizScrollbar || vertScrollbar) { 17818 var styles = getStyleComputedProperty(element); 17819 horizScrollbar -= getBordersSize(styles, 'x'); 17820 vertScrollbar -= getBordersSize(styles, 'y'); 17821 17822 result.width -= horizScrollbar; 17823 result.height -= vertScrollbar; 17824 } 17825 17826 return getClientRect(result); 17827} 17828 17829function getOffsetRectRelativeToArbitraryNode(children, parent) { 17830 var fixedPosition = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false; 17831 17832 var isIE10 = isIE(10); 17833 var isHTML = parent.nodeName === 'HTML'; 17834 var childrenRect = getBoundingClientRect(children); 17835 var parentRect = getBoundingClientRect(parent); 17836 var scrollParent = getScrollParent(children); 17837 17838 var styles = getStyleComputedProperty(parent); 17839 var borderTopWidth = parseFloat(styles.borderTopWidth, 10); 17840 var borderLeftWidth = parseFloat(styles.borderLeftWidth, 10); 17841 17842 // In cases where the parent is fixed, we must ignore negative scroll in offset calc 17843 if (fixedPosition && isHTML) { 17844 parentRect.top = Math.max(parentRect.top, 0); 17845 parentRect.left = Math.max(parentRect.left, 0); 17846 } 17847 var offsets = getClientRect({ 17848 top: childrenRect.top - parentRect.top - borderTopWidth, 17849 left: childrenRect.left - parentRect.left - borderLeftWidth, 17850 width: childrenRect.width, 17851 height: childrenRect.height 17852 }); 17853 offsets.marginTop = 0; 17854 offsets.marginLeft = 0; 17855 17856 // Subtract margins of documentElement in case it's being used as parent 17857 // we do this only on HTML because it's the only element that behaves 17858 // differently when margins are applied to it. The margins are included in 17859 // the box of the documentElement, in the other cases not. 17860 if (!isIE10 && isHTML) { 17861 var marginTop = parseFloat(styles.marginTop, 10); 17862 var marginLeft = parseFloat(styles.marginLeft, 10
vendor: 17,895 bytes, lines 17862-18423
17862); 17863 17864 offsets.top -= borderTopWidth - marginTop; 17865 offsets.bottom -= borderTopWidth - marginTop; 17866 offsets.left -= borderLeftWidth - marginLeft; 17867 offsets.right -= borderLeftWidth - marginLeft; 17868 17869 // Attach marginTop and marginLeft because in some circumstances we may need them 17870 offsets.marginTop = marginTop; 17871 offsets.marginLeft = marginLeft; 17872 } 17873 17874 if (isIE10 && !fixedPosition ? parent.contains(scrollParent) : parent === scrollParent && scrollParent.nodeName !== 'BODY') { 17875 offsets = includeScroll(offsets, parent); 17876 } 17877 17878 return offsets; 17879} 17880 17881function getViewportOffsetRectRelativeToArtbitraryNode(element) { 17882 var excludeScroll = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false; 17883 17884 var html = element.ownerDocument.documentElement; 17885 var relativeOffset = getOffsetRectRelativeToArbitraryNode(element, html); 17886 var width = Math.max(html.clientWidth, window.innerWidth || 0); 17887 var height = Math.max(html.clientHeight, window.innerHeight || 0); 17888 17889 var scrollTop = !excludeScroll ? getScroll(html) : 0; 17890 var scrollLeft = !excludeScroll ? getScroll(html, 'left') : 0; 17891 17892 var offset = { 17893 top: scrollTop - relativeOffset.top + relativeOffset.marginTop, 17894 left: scrollLeft - relativeOffset.left + relativeOffset.marginLeft, 17895 width: width, 17896 height: height 17897 }; 17898 17899 return getClientRect(offset); 17900} 17901 17902/** 17903 * Check if the given element is fixed or is inside a fixed parent 17904 * @method 17905 * @memberof Popper.Utils 17906 * @argument {Element} element 17907 * @argument {Element} customContainer 17908 * @returns {Boolean} answer to "isFixed?" 17909 */ 17910function isFixed(element) { 17911 var nodeName = element.nodeName; 17912 if (nodeName === 'BODY' || nodeName === 'HTML') { 17913 return false; 17914 } 17915 if (getStyleComputedProperty(element, 'position') === 'fixed') { 17916 return true; 17917 } 17918 var parentNode = getParentNode(element); 17919 if (!parentNode) { 17920 return false; 17921 } 17922 return isFixed(parentNode); 17923} 17924 17925/** 17926 * Finds the first parent of an element that has a transformed property defined 17927 * @method 17928 * @memberof Popper.Utils 17929 * @argument {Element} element 17930 * @returns {Element} first transformed parent or documentElement 17931 */ 17932 17933function getFixedPositionOffsetParent(element) { 17934 // This check is needed to avoid errors in case one of the elements isn't defined for any reason 17935 if (!element || !element.parentElement || isIE()) { 17936 return document.documentElement; 17937 } 17938 var el = element.parentElement; 17939 while (el && getStyleComputedProperty(el, 'transform') === 'none') { 17940 el = el.parentElement; 17941 } 17942 return el || document.documentElement; 17943} 17944 17945/** 17946 * Computed the boundaries limits and return them 17947 * @method 17948 * @memberof Popper.Utils 17949 * @param {HTMLElement} popper 17950 * @param {HTMLElement} reference 17951 * @param {number} padding 17952 * @param {HTMLElement} boundariesElement - Element used to define the boundaries 17953 * @param {Boolean} fixedPosition - Is in fixed position mode 17954 * @returns {Object} Coordinates of the boundaries 17955 */ 17956function getBoundaries(popper, reference, padding, boundariesElement) { 17957 var fixedPosition = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false; 17958 17959 // NOTE: 1 DOM access here 17960 17961 var boundaries = { top: 0, left: 0 }; 17962 var offsetParent = fixedPosition ? getFixedPositionOffsetParent(popper) : findCommonOffsetParent(popper, getReferenceNode(reference)); 17963 17964 // Handle viewport case 17965 if (boundariesElement === 'viewport') { 17966 boundaries = getViewportOffsetRectRelativeToArtbitraryNode(offsetParent, fixedPosition); 17967 } else { 17968 // Handle other cases based on DOM element used as boundaries 17969 var boundariesNode = void 0; 17970 if (boundariesElement === 'scrollParent') { 17971 boundariesNode = getScrollParent(getParentNode(reference)); 17972 if (boundariesNode.nodeName === 'BODY') { 17973 boundariesNode = popper.ownerDocument.documentElement; 17974 } 17975 } else if (boundariesElement === 'window') { 17976 boundariesNode = popper.ownerDocument.documentElement; 17977 } else { 17978 boundariesNode = boundariesElement; 17979 } 17980 17981 var offsets = getOffsetRectRelativeToArbitraryNode(boundariesNode, offsetParent, fixedPosition); 17982 17983 // In case of HTML, we need a different computation 17984 if (boundariesNode.nodeName === 'HTML' && !isFixed(offsetParent)) { 17985 var _getWindowSizes = getWindowSizes(popper.ownerDocument), 17986 height = _getWindowSizes.height, 17987 width = _getWindowSizes.width; 17988 17989 boundaries.top += offsets.top - offsets.marginTop; 17990 boundaries.bottom = height + offsets.top; 17991 boundaries.left += offsets.left - offsets.marginLeft; 17992 boundaries.right = width + offsets.left; 17993 } else { 17994 // for all the other DOM elements, this one is good 17995 boundaries = offsets; 17996 } 17997 } 17998 17999 // Add paddings 18000 padding = padding || 0; 18001 var isPaddingNumber = typeof padding === 'number'; 18002 boundaries.left += isPaddingNumber ? padding : padding.left || 0; 18003 boundaries.top += isPaddingNumber ? padding : padding.top || 0; 18004 boundaries.right -= isPaddingNumber ? padding : padding.right || 0; 18005 boundaries.bottom -= isPaddingNumber ? padding : padding.bottom || 0; 18006 18007 return boundaries; 18008} 18009 18010function getArea(_ref) { 18011 var width = _ref.width, 18012 height = _ref.height; 18013 18014 return width * height; 18015} 18016 18017/** 18018 * Utility used to transform the `auto` placement to the placement with more 18019 * available space. 18020 * @method 18021 * @memberof Popper.Utils 18022 * @argument {Object} data - The data object generated by update method 18023 * @argument {Object} options - Modifiers configuration and options 18024 * @returns {Object} The data object, properly modified 18025 */ 18026function computeAutoPlacement(placement, refRect, popper, reference, boundariesElement) { 18027 var padding = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : 0; 18028 18029 if (placement.indexOf('auto') === -1) { 18030 return placement; 18031 } 18032 18033 var boundaries = getBoundaries(popper, reference, padding, boundariesElement); 18034 18035 var rects = { 18036 top: { 18037 width: boundaries.width, 18038 height: refRect.top - boundaries.top 18039 }, 18040 right: { 18041 width: boundaries.right - refRect.right, 18042 height: boundaries.height 18043 }, 18044 bottom: { 18045 width: boundaries.width, 18046 height: boundaries.bottom - refRect.bottom 18047 }, 18048 left: { 18049 width: refRect.left - boundaries.left, 18050 height: boundaries.height 18051 } 18052 }; 18053 18054 var sortedAreas = Object.keys(rects).map(function (key) { 18055 return _extends({ 18056 key: key 18057 }, rects[key], { 18058 area: getArea(rects[key]) 18059 }); 18060 }).sort(function (a, b) { 18061 return b.area - a.area; 18062 }); 18063 18064 var filteredAreas = sortedAreas.filter(function (_ref2) { 18065 var width = _ref2.width, 18066 height = _ref2.height; 18067 return width >= popper.clientWidth && height >= popper.clientHeight; 18068 }); 18069 18070 var computedPlacement = filteredAreas.length > 0 ? filteredAreas[0].key : sortedAreas[0].key; 18071 18072 var variation = placement.split('-')[1]; 18073 18074 return computedPlacement + (variation ? '-' + variation : ''); 18075} 18076 18077/** 18078 * Get offsets to the reference element 18079 * @method 18080 * @memberof Popper.Utils 18081 * @param {Object} state 18082 * @param {Element} popper - the popper element 18083 * @param {Element} reference - the reference element (the popper will be relative to this) 18084 * @param {Element} fixedPosition - is in fixed position mode 18085 * @returns {Object} An object containing the offsets which will be applied to the popper 18086 */ 18087function getReferenceOffsets(state, popper, reference) { 18088 var fixedPosition = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null; 18089 18090 var commonOffsetParent = fixedPosition ? getFixedPositionOffsetParent(popper) : findCommonOffsetParent(popper, getReferenceNode(reference)); 18091 return getOffsetRectRelativeToArbitraryNode(reference, commonOffsetParent, fixedPosition); 18092} 18093 18094/** 18095 * Get the outer sizes of the given element (offset size + margins) 18096 * @method 18097 * @memberof Popper.Utils 18098 * @argument {Element} element 18099 * @returns {Object} object containing width and height properties 18100 */ 18101function getOuterSizes(element) { 18102 var window = element.ownerDocument.defaultView; 18103 var styles = window.getComputedStyle(element); 18104 var x = parseFloat(styles.marginTop || 0) + parseFloat(styles.marginBottom || 0); 18105 var y = parseFloat(styles.marginLeft || 0) + parseFloat(styles.marginRight || 0); 18106 var result = { 18107 width: element.offsetWidth + y, 18108 height: element.offsetHeight + x 18109 }; 18110 return result; 18111} 18112 18113/** 18114 * Get the opposite placement of the given one 18115 * @method 18116 * @memberof Popper.Utils 18117 * @argument {String} placement 18118 * @returns {String} flipped placement 18119 */ 18120function getOppositePlacement(placement) { 18121 var hash = { left: 'right', right: 'left', bottom: 'top', top: 'bottom' }; 18122 return placement.replace(/left|right|bottom|top/g, function (matched) { 18123 return hash[matched]; 18124 }); 18125} 18126 18127/** 18128 * Get offsets to the popper 18129 * @method 18130 * @memberof Popper.Utils 18131 * @param {Object} position - CSS position the Popper will get applied 18132 * @param {HTMLElement} popper - the popper element 18133 * @param {Object} referenceOffsets - the reference offsets (the popper will be relative to this) 18134 * @param {String} placement - one of the valid placement options 18135 * @returns {Object} popperOffsets - An object containing the offsets which will be applied to the popper 18136 */ 18137function getPopperOffsets(popper, referenceOffsets, placement) { 18138 placement = placement.split('-')[0]; 18139 18140 // Get popper node sizes 18141 var popperRect = getOuterSizes(popper); 18142 18143 // Add position, width and height to our offsets object 18144 var popperOffsets = { 18145 width: popperRect.width, 18146 height: popperRect.height 18147 }; 18148 18149 // depending by the popper placement we have to compute its offsets slightly differently 18150 var isHoriz = ['right', 'left'].indexOf(placement) !== -1; 18151 var mainSide = isHoriz ? 'top' : 'left'; 18152 var secondarySide = isHoriz ? 'left' : 'top'; 18153 var measurement = isHoriz ? 'height' : 'width'; 18154 var secondaryMeasurement = !isHoriz ? 'height' : 'width'; 18155 18156 popperOffsets[mainSide] = referenceOffsets[mainSide] + referenceOffsets[measurement] / 2 - popperRect[measurement] / 2; 18157 if (placement === secondarySide) { 18158 popperOffsets[secondarySide] = referenceOffsets[secondarySide] - popperRect[secondaryMeasurement]; 18159 } else { 18160 popperOffsets[secondarySide] = referenceOffsets[getOppositePlacement(secondarySide)]; 18161 } 18162 18163 return popperOffsets; 18164} 18165 18166/** 18167 * Mimics the `find` method of Array 18168 * @method 18169 * @memberof Popper.Utils 18170 * @argument {Array} arr 18171 * @argument prop 18172 * @argument value 18173 * @returns index or -1 18174 */ 18175function find(arr, check) { 18176 // use native find if supported 18177 if (Array.prototype.find) { 18178 return arr.find(check); 18179 } 18180 18181 // use `filter` to obtain the same behavior of `find` 18182 return arr.filter(check)[0]; 18183} 18184 18185/** 18186 * Return the index of the matching object 18187 * @method 18188 * @memberof Popper.Utils 18189 * @argument {Array} arr 18190 * @argument prop 18191 * @argument value 18192 * @returns index or -1 18193 */ 18194function findIndex(arr, prop, value) { 18195 // use native findIndex if supported 18196 if (Array.prototype.findIndex) { 18197 return arr.findIndex(function (cur) { 18198 return cur[prop] === value; 18199 }); 18200 } 18201 18202 // use `find` + `indexOf` if `findIndex` isn't supported 18203 var match = find(arr, function (obj) { 18204 return obj[prop] === value; 18205 }); 18206 return arr.indexOf(match); 18207} 18208 18209/** 18210 * Loop trough the list of modifiers and run them in order, 18211 * each of them will then edit the data object. 18212 * @method 18213 * @memberof Popper.Utils 18214 * @param {dataObject} data 18215 * @param {Array} modifiers 18216 * @param {String} ends - Optional modifier name used as stopper 18217 * @returns {dataObject} 18218 */ 18219function runModifiers(modifiers, data, ends) { 18220 var modifiersToRun = ends === undefined ? modifiers : modifiers.slice(0, findIndex(modifiers, 'name', ends)); 18221 18222 modifiersToRun.forEach(function (modifier) { 18223 if (modifier['function']) { 18224 // eslint-disable-line dot-notation 18225 console.warn('`modifier.function` is deprecated, use `modifier.fn`!'); 18226 } 18227 var fn = modifier['function'] || modifier.fn; // eslint-disable-line dot-notation 18228 if (modifier.enabled && isFunction(fn)) { 18229 // Add properties to offsets to make them a complete clientRect object 18230 // we do this before each modifier to make sure the previous one doesn't 18231 // mess with these values 18232 data.offsets.popper = getClientRect(data.offsets.popper); 18233 data.offsets.reference = getClientRect(data.offsets.reference); 18234 18235 data = fn(data, modifier); 18236 } 18237 }); 18238 18239 return data; 18240} 18241 18242/** 18243 * Updates the position of the popper, computing the new offsets and applying 18244 * the new style.<br /> 18245 * Prefer `scheduleUpdate` over `update` because of performance reasons. 18246 * @method 18247 * @memberof Popper 18248 */ 18249function update() { 18250 // if popper is destroyed, don't perform any further update 18251 if (this.state.isDestroyed) { 18252 return; 18253 } 18254 18255 var data = { 18256 instance: this, 18257 styles: {}, 18258 arrowStyles: {}, 18259 attributes: {}, 18260 flipped: false, 18261 offsets: {} 18262 }; 18263 18264 // compute reference element offsets 18265 data.offsets.reference = getReferenceOffsets(this.state, this.popper, this.reference, this.options.positionFixed); 18266 18267 // compute auto placement, store placement inside the data object, 18268 // modifiers will be able to edit `placement` if needed 18269 // and refer to originalPlacement to know the original value 18270 data.placement = computeAutoPlacement(this.options.placement, data.offsets.reference, this.popper, this.reference, this.options.modifiers.flip.boundariesElement, this.options.modifiers.flip.padding); 18271 18272 // store the computed placement inside `originalPlacement` 18273 data.originalPlacement = data.placement; 18274 18275 data.positionFixed = this.options.positionFixed; 18276 18277 // compute the popper offsets 18278 data.offsets.popper = getPopperOffsets(this.popper, data.offsets.reference, data.placement); 18279 18280 data.offsets.popper.position = this.options.positionFixed ? 'fixed' : 'absolute'; 18281 18282 // run the modifiers 18283 data = runModifiers(this.modifiers, data); 18284 18285 // the first `update` will call `onCreate` callback 18286 // the other ones will call `onUpdate` callback 18287 if (!this.state.isCreated) { 18288 this.state.isCreated = true; 18289 this.options.onCreate(data); 18290 } else { 18291 this.options.onUpdate(data); 18292 } 18293} 18294 18295/** 18296 * Helper used to know if the given modifier is enabled. 18297 * @method 18298 * @memberof Popper.Utils 18299 * @returns {Boolean} 18300 */ 18301function isModifierEnabled(modifiers, modifierName) { 18302 return modifiers.some(function (_ref) { 18303 var name = _ref.name, 18304 enabled = _ref.enabled; 18305 return enabled && name === modifierName; 18306 }); 18307} 18308 18309/** 18310 * Get the prefixed supported property name 18311 * @method 18312 * @memberof Popper.Utils 18313 * @argument {String} property (camelCase) 18314 * @returns {String} prefixed property (camelCase or PascalCase, depending on the vendor prefix) 18315 */ 18316function getSupportedPropertyName(property) { 18317 var prefixes = [false, 'ms', 'Webkit', 'Moz', 'O']; 18318 var upperProp = property.charAt(0).toUpperCase() + property.slice(1); 18319 18320 for (var i = 0; i < prefixes.length; i++) { 18321 var prefix = prefixes[i]; 18322 var toCheck = prefix ? '' + prefix + upperProp : property; 18323 if (typeof document.body.style[toCheck] !== 'undefined') { 18324 return toCheck; 18325 } 18326 } 18327 return null; 18328} 18329 18330/** 18331 * Destroys the popper. 18332 * @method 18333 * @memberof Popper 18334 */ 18335function destroy() { 18336 this.state.isDestroyed = true; 18337 18338 // touch DOM only if `applyStyle` modifier is enabled 18339 if (isModifierEnabled(this.modifiers, 'applyStyle')) { 18340 this.popper.removeAttribute('x-placement'); 18341 this.popper.style.position = ''; 18342 this.popper.style.top = ''; 18343 this.popper.style.left = ''; 18344 this.popper.style.right = ''; 18345 this.popper.style.bottom = ''; 18346 this.popper.style.willChange = ''; 18347 this.popper.style[getSupportedPropertyName('transform')] = ''; 18348 } 18349 18350 this.disableEventListeners(); 18351 18352 // remove the popper if user explicitly asked for the deletion on destroy 18353 // do not use `remove` because IE11 doesn't support it 18354 if (this.options.removeOnDestroy) { 18355 this.popper.parentNode.removeChild(this.popper); 18356 } 18357 return this; 18358} 18359 18360/** 18361 * Get the window associated with the element 18362 * @argument {Element} element 18363 * @returns {Window} 18364 */ 18365function getWindow(element) { 18366 var ownerDocument = element.ownerDocument; 18367 return ownerDocument ? ownerDocument.defaultView : window; 18368} 18369 18370function attachToScrollParents(scrollParent, event, callback, scrollParents) { 18371 var isBody = scrollParent.nodeName === 'BODY'; 18372 var target = isBody ? scrollParent.ownerDocument.defaultView : scrollParent; 18373 target.addEventListener(event, callback, { passive: true }); 18374 18375 if (!isBody) { 18376 attachToScrollParents(getScrollParent(target.parentNode), event, callback, scrollParents); 18377 } 18378 scrollParents.push(target); 18379} 18380 18381/** 18382 * Setup needed event listeners used to update the popper position 18383 * @method 18384 * @memberof Popper.Utils 18385 * @private 18386 */ 18387function setupEventListeners(reference, options, state, updateBound) { 18388 // Resize event listener on window 18389 state.updateBound = updateBound; 18390 getWindow(reference).addEventListener('resize', state.updateBound, { passive: true }); 18391 18392 // Scroll event listener on scroll parents 18393 var scrollElement = getScrollParent(reference); 18394 attachToScrollParents(scrollElement, 'scroll', state.updateBound, state.scrollParents); 18395 state.scrollElement = scrollElement; 18396 state.eventsEnabled = true; 18397 18398 return state; 18399} 18400 18401/** 18402 * It will add resize/scroll events and start recalculating 18403 * position of the popper element when they are triggered. 18404 * @method 18405 * @memberof Popper 18406 */ 18407function enableEventListeners() { 18408 if (!this.state.eventsEnabled) { 18409 this.state = setupEventListeners(this.reference, this.options, this.state, this.scheduleUpdate); 18410 } 18411} 18412 18413/** 18414 * Remove event listeners used to update the popper position 18415 * @method 18416 * @memberof Popper.Utils 18417 * @private 18418 */ 18419function removeEventListeners(reference, state) { 18420 // Remove resize event listener on window 18421 getWindow(reference).removeEventListener('resize', state.updateBound); 18422 18423 // Remove scroll event listener on scroll parents
vendor: 54,378 bytes, lines 18424-19952
18424 state.scrollParents.forEach(function (target) { 18425 target.removeEventListener('scroll', state.updateBound); 18426 }); 18427 18428 // Reset state 18429 state.updateBound = null; 18430 state.scrollParents = []; 18431 state.scrollElement = null; 18432 state.eventsEnabled = false; 18433 return state; 18434} 18435 18436/** 18437 * It will remove resize/scroll events and won't recalculate popper position 18438 * when they are triggered. It also won't trigger `onUpdate` callback anymore, 18439 * unless you call `update` method manually. 18440 * @method 18441 * @memberof Popper 18442 */ 18443function disableEventListeners() { 18444 if (this.state.eventsEnabled) { 18445 cancelAnimationFrame(this.scheduleUpdate); 18446 this.state = removeEventListeners(this.reference, this.state); 18447 } 18448} 18449 18450/** 18451 * Tells if a given input is a number 18452 * @method 18453 * @memberof Popper.Utils 18454 * @param {*} input to check 18455 * @return {Boolean} 18456 */ 18457function isNumeric(n) { 18458 return n !== '' && !isNaN(parseFloat(n)) && isFinite(n); 18459} 18460 18461/** 18462 * Set the style to the given popper 18463 * @method 18464 * @memberof Popper.Utils 18465 * @argument {Element} element - Element to apply the style to 18466 * @argument {Object} styles 18467 * Object with a list of properties and values which will be applied to the element 18468 */ 18469function setStyles(element, styles) { 18470 Object.keys(styles).forEach(function (prop) { 18471 var unit = ''; 18472 // add unit if the value is numeric and is one of the following 18473 if (['width', 'height', 'top', 'right', 'bottom', 'left'].indexOf(prop) !== -1 && isNumeric(styles[prop])) { 18474 unit = 'px'; 18475 } 18476 element.style[prop] = styles[prop] + unit; 18477 }); 18478} 18479 18480/** 18481 * Set the attributes to the given popper 18482 * @method 18483 * @memberof Popper.Utils 18484 * @argument {Element} element - Element to apply the attributes to 18485 * @argument {Object} styles 18486 * Object with a list of properties and values which will be applied to the element 18487 */ 18488function setAttributes(element, attributes) { 18489 Object.keys(attributes).forEach(function (prop) { 18490 var value = attributes[prop]; 18491 if (value !== false) { 18492 element.setAttribute(prop, attributes[prop]); 18493 } else { 18494 element.removeAttribute(prop); 18495 } 18496 }); 18497} 18498 18499/** 18500 * @function 18501 * @memberof Modifiers 18502 * @argument {Object} data - The data object generated by `update` method 18503 * @argument {Object} data.styles - List of style properties - values to apply to popper element 18504 * @argument {Object} data.attributes - List of attribute properties - values to apply to popper element 18505 * @argument {Object} options - Modifiers configuration and options 18506 * @returns {Object} The same data object 18507 */ 18508function applyStyle(data) { 18509 // any property present in `data.styles` will be applied to the popper, 18510 // in this way we can make the 3rd party modifiers add custom styles to it 18511 // Be aware, modifiers could override the properties defined in the previous 18512 // lines of this modifier! 18513 setStyles(data.instance.popper, data.styles); 18514 18515 // any property present in `data.attributes` will be applied to the popper, 18516 // they will be set as HTML attributes of the element 18517 setAttributes(data.instance.popper, data.attributes); 18518 18519 // if arrowElement is defined and arrowStyles has some properties 18520 if (data.arrowElement && Object.keys(data.arrowStyles).length) { 18521 setStyles(data.arrowElement, data.arrowStyles); 18522 } 18523 18524 return data; 18525} 18526 18527/** 18528 * Set the x-placement attribute before everything else because it could be used 18529 * to add margins to the popper margins needs to be calculated to get the 18530 * correct popper offsets. 18531 * @method 18532 * @memberof Popper.modifiers 18533 * @param {HTMLElement} reference - The reference element used to position the popper 18534 * @param {HTMLElement} popper - The HTML element used as popper 18535 * @param {Object} options - Popper.js options 18536 */ 18537function applyStyleOnLoad(reference, popper, options, modifierOptions, state) { 18538 // compute reference element offsets 18539 var referenceOffsets = getReferenceOffsets(state, popper, reference, options.positionFixed); 18540 18541 // compute auto placement, store placement inside the data object, 18542 // modifiers will be able to edit `placement` if needed 18543 // and refer to originalPlacement to know the original value 18544 var placement = computeAutoPlacement(options.placement, referenceOffsets, popper, reference, options.modifiers.flip.boundariesElement, options.modifiers.flip.padding); 18545 18546 popper.setAttribute('x-placement', placement); 18547 18548 // Apply `position` to popper before anything else because 18549 // without the position applied we can't guarantee correct computations 18550 setStyles(popper, { position: options.positionFixed ? 'fixed' : 'absolute' }); 18551 18552 return options; 18553} 18554 18555/** 18556 * @function 18557 * @memberof Popper.Utils 18558 * @argument {Object} data - The data object generated by `update` method 18559 * @argument {Boolean} shouldRound - If the offsets should be rounded at all 18560 * @returns {Object} The popper's position offsets rounded 18561 * 18562 * The tale of pixel-perfect positioning. It's still not 100% perfect, but as 18563 * good as it can be within reason. 18564 * Discussion here: https://github.com/FezVrasta/popper.js/pull/715 18565 * 18566 * Low DPI screens cause a popper to be blurry if not using full pixels (Safari 18567 * as well on High DPI screens). 18568 * 18569 * Firefox prefers no rounding for positioning and does not have blurriness on 18570 * high DPI screens. 18571 * 18572 * Only horizontal placement and left/right values need to be considered. 18573 */ 18574function getRoundedOffsets(data, shouldRound) { 18575 var _data$offsets = data.offsets, 18576 popper = _data$offsets.popper, 18577 reference = _data$offsets.reference; 18578 var round = Math.round, 18579 floor = Math.floor; 18580 18581 var noRound = function noRound(v) { 18582 return v; 18583 }; 18584 18585 var referenceWidth = round(reference.width); 18586 var popperWidth = round(popper.width); 18587 18588 var isVertical = ['left', 'right'].indexOf(data.placement) !== -1; 18589 var isVariation = data.placement.indexOf('-') !== -1; 18590 var sameWidthParity = referenceWidth % 2 === popperWidth % 2; 18591 var bothOddWidth = referenceWidth % 2 === 1 && popperWidth % 2 === 1; 18592 18593 var horizontalToInteger = !shouldRound ? noRound : isVertical || isVariation || sameWidthParity ? round : floor; 18594 var verticalToInteger = !shouldRound ? noRound : round; 18595 18596 return { 18597 left: horizontalToInteger(bothOddWidth && !isVariation && shouldRound ? popper.left - 1 : popper.left), 18598 top: verticalToInteger(popper.top), 18599 bottom: verticalToInteger(popper.bottom), 18600 right: horizontalToInteger(popper.right) 18601 }; 18602} 18603 18604var isFirefox = isBrowser && /Firefox/i.test(navigator.userAgent); 18605 18606/** 18607 * @function 18608 * @memberof Modifiers 18609 * @argument {Object} data - The data object generated by `update` method 18610 * @argument {Object} options - Modifiers configuration and options 18611 * @returns {Object} The data object, properly modified 18612 */ 18613function computeStyle(data, options) { 18614 var x = options.x, 18615 y = options.y; 18616 var popper = data.offsets.popper; 18617 18618 // Remove this legacy support in Popper.js v2 18619 18620 var legacyGpuAccelerationOption = find(data.instance.modifiers, function (modifier) { 18621 return modifier.name === 'applyStyle'; 18622 }).gpuAcceleration; 18623 if (legacyGpuAccelerationOption !== undefined) { 18624 console.warn('WARNING: `gpuAcceleration` option moved to `computeStyle` modifier and will not be supported in future versions of Popper.js!'); 18625 } 18626 var gpuAcceleration = legacyGpuAccelerationOption !== undefined ? legacyGpuAccelerationOption : options.gpuAcceleration; 18627 18628 var offsetParent = getOffsetParent(data.instance.popper); 18629 var offsetParentRect = getBoundingClientRect(offsetParent); 18630 18631 // Styles 18632 var styles = { 18633 position: popper.position 18634 }; 18635 18636 var offsets = getRoundedOffsets(data, window.devicePixelRatio < 2 || !isFirefox); 18637 18638 var sideA = x === 'bottom' ? 'top' : 'bottom'; 18639 var sideB = y === 'right' ? 'left' : 'right'; 18640 18641 // if gpuAcceleration is set to `true` and transform is supported, 18642 // we use `translate3d` to apply the position to the popper we 18643 // automatically use the supported prefixed version if needed 18644 var prefixedProperty = getSupportedPropertyName('transform'); 18645 18646 // now, let's make a step back and look at this code closely (wtf?) 18647 // If the content of the popper grows once it's been positioned, it 18648 // may happen that the popper gets misplaced because of the new content 18649 // overflowing its reference element 18650 // To avoid this problem, we provide two options (x and y), which allow 18651 // the consumer to define the offset origin. 18652 // If we position a popper on top of a reference element, we can set 18653 // `x` to `top` to make the popper grow towards its top instead of 18654 // its bottom. 18655 var left = void 0, 18656 top = void 0; 18657 if (sideA === 'bottom') { 18658 // when offsetParent is <html> the positioning is relative to the bottom of the screen (excluding the scrollbar) 18659 // and not the bottom of the html element 18660 if (offsetParent.nodeName === 'HTML') { 18661 top = -offsetParent.clientHeight + offsets.bottom; 18662 } else { 18663 top = -offsetParentRect.height + offsets.bottom; 18664 } 18665 } else { 18666 top = offsets.top; 18667 } 18668 if (sideB === 'right') { 18669 if (offsetParent.nodeName === 'HTML') { 18670 left = -offsetParent.clientWidth + offsets.right; 18671 } else { 18672 left = -offsetParentRect.width + offsets.right; 18673 } 18674 } else { 18675 left = offsets.left; 18676 } 18677 if (gpuAcceleration && prefixedProperty) { 18678 styles[prefixedProperty] = 'translate3d(' + left + 'px, ' + top + 'px, 0)'; 18679 styles[sideA] = 0; 18680 styles[sideB] = 0; 18681 styles.willChange = 'transform'; 18682 } else { 18683 // othwerise, we use the standard `top`, `left`, `bottom` and `right` properties 18684 var invertTop = sideA === 'bottom' ? -1 : 1; 18685 var invertLeft = sideB === 'right' ? -1 : 1; 18686 styles[sideA] = top * invertTop; 18687 styles[sideB] = left * invertLeft; 18688 styles.willChange = sideA + ', ' + sideB; 18689 } 18690 18691 // Attributes 18692 var attributes = { 18693 'x-placement': data.placement 18694 }; 18695 18696 // Update `data` attributes, styles and arrowStyles 18697 data.attributes = _extends({}, attributes, data.attributes); 18698 data.styles = _extends({}, styles, data.styles); 18699 data.arrowStyles = _extends({}, data.offsets.arrow, data.arrowStyles); 18700 18701 return data; 18702} 18703 18704/** 18705 * Helper used to know if the given modifier depends from another one.<br /> 18706 * It checks if the needed modifier is listed and enabled. 18707 * @method 18708 * @memberof Popper.Utils 18709 * @param {Array} modifiers - list of modifiers 18710 * @param {String} requestingName - name of requesting modifier 18711 * @param {String} requestedName - name of requested modifier 18712 * @returns {Boolean} 18713 */ 18714function isModifierRequired(modifiers, requestingName, requestedName) { 18715 var requesting = find(modifiers, function (_ref) { 18716 var name = _ref.name; 18717 return name === requestingName; 18718 }); 18719 18720 var isRequired = !!requesting && modifiers.some(function (modifier) { 18721 return modifier.name === requestedName && modifier.enabled && modifier.order < requesting.order; 18722 }); 18723 18724 if (!isRequired) { 18725 var _requesting = '`' + requestingName + '`'; 18726 var requested = '`' + requestedName + '`'; 18727 console.warn(requested + ' modifier is required by ' + _requesting + ' modifier in order to work, be sure to include it before ' + _requesting + '!'); 18728 } 18729 return isRequired; 18730} 18731 18732/** 18733 * @function 18734 * @memberof Modifiers 18735 * @argument {Object} data - The data object generated by update method 18736 * @argument {Object} options - Modifiers configuration and options 18737 * @returns {Object} The data object, properly modified 18738 */ 18739function arrow(data, options) { 18740 var _data$offsets$arrow; 18741 18742 // arrow depends on keepTogether in order to work 18743 if (!isModifierRequired(data.instance.modifiers, 'arrow', 'keepTogether')) { 18744 return data; 18745 } 18746 18747 var arrowElement = options.element; 18748 18749 // if arrowElement is a string, suppose it's a CSS selector 18750 if (typeof arrowElement === 'string') { 18751 arrowElement = data.instance.popper.querySelector(arrowElement); 18752 18753 // if arrowElement is not found, don't run the modifier 18754 if (!arrowElement) { 18755 return data; 18756 } 18757 } else { 18758 // if the arrowElement isn't a query selector we must check that the 18759 // provided DOM node is child of its popper node 18760 if (!data.instance.popper.contains(arrowElement)) { 18761 console.warn('WARNING: `arrow.element` must be child of its popper element!'); 18762 return data; 18763 } 18764 } 18765 18766 var placement = data.placement.split('-')[0]; 18767 var _data$offsets = data.offsets, 18768 popper = _data$offsets.popper, 18769 reference = _data$offsets.reference; 18770 18771 var isVertical = ['left', 'right'].indexOf(placement) !== -1; 18772 18773 var len = isVertical ? 'height' : 'width'; 18774 var sideCapitalized = isVertical ? 'Top' : 'Left'; 18775 var side = sideCapitalized.toLowerCase(); 18776 var altSide = isVertical ? 'left' : 'top'; 18777 var opSide = isVertical ? 'bottom' : 'right'; 18778 var arrowElementSize = getOuterSizes(arrowElement)[len]; 18779 18780 // 18781 // extends keepTogether behavior making sure the popper and its 18782 // reference have enough pixels in conjunction 18783 // 18784 18785 // top/left side 18786 if (reference[opSide] - arrowElementSize < popper[side]) { 18787 data.offsets.popper[side] -= popper[side] - (reference[opSide] - arrowElementSize); 18788 } 18789 // bottom/right side 18790 if (reference[side] + arrowElementSize > popper[opSide]) { 18791 data.offsets.popper[side] += reference[side] + arrowElementSize - popper[opSide]; 18792 } 18793 data.offsets.popper = getClientRect(data.offsets.popper); 18794 18795 // compute center of the popper 18796 var center = reference[side] + reference[len] / 2 - arrowElementSize / 2; 18797 18798 // Compute the sideValue using the updated popper offsets 18799 // take popper margin in account because we don't have this info available 18800 var css = getStyleComputedProperty(data.instance.popper); 18801 var popperMarginSide = parseFloat(css['margin' + sideCapitalized], 10); 18802 var popperBorderSide = parseFloat(css['border' + sideCapitalized + 'Width'], 10); 18803 var sideValue = center - data.offsets.popper[side] - popperMarginSide - popperBorderSide; 18804 18805 // prevent arrowElement from being placed not contiguously to its popper 18806 sideValue = Math.max(Math.min(popper[len] - arrowElementSize, sideValue), 0); 18807 18808 data.arrowElement = arrowElement; 18809 data.offsets.arrow = (_data$offsets$arrow = {}, defineProperty(_data$offsets$arrow, side, Math.round(sideValue)), defineProperty(_data$offsets$arrow, altSide, ''), _data$offsets$arrow); 18810 18811 return data; 18812} 18813 18814/** 18815 * Get the opposite placement variation of the given one 18816 * @method 18817 * @memberof Popper.Utils 18818 * @argument {String} placement variation 18819 * @returns {String} flipped placement variation 18820 */ 18821function getOppositeVariation(variation) { 18822 if (variation === 'end') { 18823 return 'start'; 18824 } else if (variation === 'start') { 18825 return 'end'; 18826 } 18827 return variation; 18828} 18829 18830/** 18831 * List of accepted placements to use as values of the `placement` option.<br /> 18832 * Valid placements are: 18833 * - `auto` 18834 * - `top` 18835 * - `right` 18836 * - `bottom` 18837 * - `left` 18838 * 18839 * Each placement can have a variation from this list: 18840 * - `-start` 18841 * - `-end` 18842 * 18843 * Variations are interpreted easily if you think of them as the left to right 18844 * written languages. Horizontally (`top` and `bottom`), `start` is left and `end` 18845 * is right.<br /> 18846 * Vertically (`left` and `right`), `start` is top and `end` is bottom. 18847 * 18848 * Some valid examples are: 18849 * - `top-end` (on top of reference, right aligned) 18850 * - `right-start` (on right of reference, top aligned) 18851 * - `bottom` (on bottom, centered) 18852 * - `auto-end` (on the side with more space available, alignment depends by placement) 18853 * 18854 * @static 18855 * @type {Array} 18856 * @enum {String} 18857 * @readonly 18858 * @method placements 18859 * @memberof Popper 18860 */ 18861var 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']; 18862 18863// Get rid of `auto` `auto-start` and `auto-end` 18864var validPlacements = placements.slice(3); 18865 18866/** 18867 * Given an initial placement, returns all the subsequent placements 18868 * clockwise (or counter-clockwise). 18869 * 18870 * @method 18871 * @memberof Popper.Utils 18872 * @argument {String} placement - A valid placement (it accepts variations) 18873 * @argument {Boolean} counter - Set to true to walk the placements counterclockwise 18874 * @returns {Array} placements including their variations 18875 */ 18876function clockwise(placement) { 18877 var counter = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false; 18878 18879 var index = validPlacements.indexOf(placement); 18880 var arr = validPlacements.slice(index + 1).concat(validPlacements.slice(0, index)); 18881 return counter ? arr.reverse() : arr; 18882} 18883 18884var BEHAVIORS = { 18885 FLIP: 'flip', 18886 CLOCKWISE: 'clockwise', 18887 COUNTERCLOCKWISE: 'counterclockwise' 18888}; 18889 18890/** 18891 * @function 18892 * @memberof Modifiers 18893 * @argument {Object} data - The data object generated by update method 18894 * @argument {Object} options - Modifiers configuration and options 18895 * @returns {Object} The data object, properly modified 18896 */ 18897function flip(data, options) { 18898 // if `inner` modifier is enabled, we can't use the `flip` modifier 18899 if (isModifierEnabled(data.instance.modifiers, 'inner')) { 18900 return data; 18901 } 18902 18903 if (data.flipped && data.placement === data.originalPlacement) { 18904 // seems like flip is trying to loop, probably there's not enough space on any of the flippable sides 18905 return data; 18906 } 18907 18908 var boundaries = getBoundaries(data.instance.popper, data.instance.reference, options.padding, options.boundariesElement, data.positionFixed); 18909 18910 var placement = data.placement.split('-')[0]; 18911 var placementOpposite = getOppositePlacement(placement); 18912 var variation = data.placement.split('-')[1] || ''; 18913 18914 var flipOrder = []; 18915 18916 switch (options.behavior) { 18917 case BEHAVIORS.FLIP: 18918 flipOrder = [placement, placementOpposite]; 18919 break; 18920 case BEHAVIORS.CLOCKWISE: 18921 flipOrder = clockwise(placement); 18922 break; 18923 case BEHAVIORS.COUNTERCLOCKWISE: 18924 flipOrder = clockwise(placement, true); 18925 break; 18926 default: 18927 flipOrder = options.behavior; 18928 } 18929 18930 flipOrder.forEach(function (step, index) { 18931 if (placement !== step || flipOrder.length === index + 1) { 18932 return data; 18933 } 18934 18935 placement = data.placement.split('-')[0]; 18936 placementOpposite = getOppositePlacement(placement); 18937 18938 var popperOffsets = data.offsets.popper; 18939 var refOffsets = data.offsets.reference; 18940 18941 // using floor because the reference offsets may contain decimals we are not going to consider here 18942 var floor = Math.floor; 18943 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); 18944 18945 var overflowsLeft = floor(popperOffsets.left) < floor(boundaries.left); 18946 var overflowsRight = floor(popperOffsets.right) > floor(boundaries.right); 18947 var overflowsTop = floor(popperOffsets.top) < floor(boundaries.top); 18948 var overflowsBottom = floor(popperOffsets.bottom) > floor(boundaries.bottom); 18949 18950 var overflowsBoundaries = placement === 'left' && overflowsLeft || placement === 'right' && overflowsRight || placement === 'top' && overflowsTop || placement === 'bottom' && overflowsBottom; 18951 18952 // flip the variation if required 18953 var isVertical = ['top', 'bottom'].indexOf(placement) !== -1; 18954 18955 // flips variation if reference element overflows boundaries 18956 var flippedVariationByRef = !!options.flipVariations && (isVertical && variation === 'start' && overflowsLeft || isVertical && variation === 'end' && overflowsRight || !isVertical && variation === 'start' && overflowsTop || !isVertical && variation === 'end' && overflowsBottom); 18957 18958 // flips variation if popper content overflows boundaries 18959 var flippedVariationByContent = !!options.flipVariationsByContent && (isVertical && variation === 'start' && overflowsRight || isVertical && variation === 'end' && overflowsLeft || !isVertical && variation === 'start' && overflowsBottom || !isVertical && variation === 'end' && overflowsTop); 18960 18961 var flippedVariation = flippedVariationByRef || flippedVariationByContent; 18962 18963 if (overlapsRef || overflowsBoundaries || flippedVariation) { 18964 // this boolean to detect any flip loop 18965 data.flipped = true; 18966 18967 if (overlapsRef || overflowsBoundaries) { 18968 placement = flipOrder[index + 1]; 18969 } 18970 18971 if (flippedVariation) { 18972 variation = getOppositeVariation(variation); 18973 } 18974 18975 data.placement = placement + (variation ? '-' + variation : ''); 18976 18977 // this object contains `position`, we want to preserve it along with 18978 // any additional property we may add in the future 18979 data.offsets.popper = _extends({}, data.offsets.popper, getPopperOffsets(data.instance.popper, data.offsets.reference, data.placement)); 18980 18981 data = runModifiers(data.instance.modifiers, data, 'flip'); 18982 } 18983 }); 18984 return data; 18985} 18986 18987/** 18988 * @function 18989 * @memberof Modifiers 18990 * @argument {Object} data - The data object generated by update method 18991 * @argument {Object} options - Modifiers configuration and options 18992 * @returns {Object} The data object, properly modified 18993 */ 18994function keepTogether(data) { 18995 var _data$offsets = data.offsets, 18996 popper = _data$offsets.popper, 18997 reference = _data$offsets.reference; 18998 18999 var placement = data.placement.split('-')[0]; 19000 var floor = Math.floor; 19001 var isVertical = ['top', 'bottom'].indexOf(placement) !== -1; 19002 var side = isVertical ? 'right' : 'bottom'; 19003 var opSide = isVertical ? 'left' : 'top'; 19004 var measurement = isVertical ? 'width' : 'height'; 19005 19006 if (popper[side] < floor(reference[opSide])) { 19007 data.offsets.popper[opSide] = floor(reference[opSide]) - popper[measurement]; 19008 } 19009 if (popper[opSide] > floor(reference[side])) { 19010 data.offsets.popper[opSide] = floor(reference[side]); 19011 } 19012 19013 return data; 19014} 19015 19016/** 19017 * Converts a string containing value + unit into a px value number 19018 * @function 19019 * @memberof {modifiers~offset} 19020 * @private 19021 * @argument {String} str - Value + unit string 19022 * @argument {String} measurement - `height` or `width` 19023 * @argument {Object} popperOffsets 19024 * @argument {Object} referenceOffsets 19025 * @returns {Number|String} 19026 * Value in pixels, or original string if no values were extracted 19027 */ 19028function toValue(str, measurement, popperOffsets, referenceOffsets) { 19029 // separate value from unit 19030 var split = str.match(/((?:\-|\+)?\d*\.?\d*)(.*)/); 19031 var value = +split[1]; 19032 var unit = split[2]; 19033 19034 // If it's not a number it's an operator, I guess 19035 if (!value) { 19036 return str; 19037 } 19038 19039 if (unit.indexOf('%') === 0) { 19040 var element = void 0; 19041 switch (unit) { 19042 case '%p': 19043 element = popperOffsets; 19044 break; 19045 case '%': 19046 case '%r': 19047 default: 19048 element = referenceOffsets; 19049 } 19050 19051 var rect = getClientRect(element); 19052 return rect[measurement] / 100 * value; 19053 } else if (unit === 'vh' || unit === 'vw') { 19054 // if is a vh or vw, we calculate the size based on the viewport 19055 var size = void 0; 19056 if (unit === 'vh') { 19057 size = Math.max(document.documentElement.clientHeight, window.innerHeight || 0); 19058 } else { 19059 size = Math.max(document.documentElement.clientWidth, window.innerWidth || 0); 19060 } 19061 return size / 100 * value; 19062 } else { 19063 // if is an explicit pixel unit, we get rid of the unit and keep the value 19064 // if is an implicit unit, it's px, and we return just the value 19065 return value; 19066 } 19067} 19068 19069/** 19070 * Parse an `offset` string to extrapolate `x` and `y` numeric offsets. 19071 * @function 19072 * @memberof {modifiers~offset} 19073 * @private 19074 * @argument {String} offset 19075 * @argument {Object} popperOffsets 19076 * @argument {Object} referenceOffsets 19077 * @argument {String} basePlacement 19078 * @returns {Array} a two cells array with x and y offsets in numbers 19079 */ 19080function parseOffset(offset, popperOffsets, referenceOffsets, basePlacement) { 19081 var offsets = [0, 0]; 19082 19083 // Use height if placement is left or right and index is 0 otherwise use width 19084 // in this way the first offset will use an axis and the second one 19085 // will use the other one 19086 var useHeight = ['right', 'left'].indexOf(basePlacement) !== -1; 19087 19088 // Split the offset string to obtain a list of values and operands 19089 // The regex addresses values with the plus or minus sign in front (+10, -20, etc) 19090 var fragments = offset.split(/(\+|\-)/).map(function (frag) { 19091 return frag.trim(); 19092 }); 19093 19094 // Detect if the offset string contains a pair of values or a single one 19095 // they could be separated by comma or space 19096 var divider = fragments.indexOf(find(fragments, function (frag) { 19097 return frag.search(/,|\s/) !== -1; 19098 })); 19099 19100 if (fragments[divider] && fragments[divider].indexOf(',') === -1) { 19101 console.warn('Offsets separated by white space(s) are deprecated, use a comma (,) instead.'); 19102 } 19103 19104 // If divider is found, we divide the list of values and operands to divide 19105 // them by ofset X and Y. 19106 var splitRegex = /\s*,\s*|\s+/; 19107 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]; 19108 19109 // Convert the values with units to absolute pixels to allow our computations 19110 ops = ops.map(function (op, index) { 19111 // Most of the units rely on the orientation of the popper 19112 var measurement = (index === 1 ? !useHeight : useHeight) ? 'height' : 'width'; 19113 var mergeWithPrevious = false; 19114 return op 19115 // This aggregates any `+` or `-` sign that aren't considered operators 19116 // e.g.: 10 + +5 => [10, +, +5] 19117 .reduce(function (a, b) { 19118 if (a[a.length - 1] === '' && ['+', '-'].indexOf(b) !== -1) { 19119 a[a.length - 1] = b; 19120 mergeWithPrevious = true; 19121 return a; 19122 } else if (mergeWithPrevious) { 19123 a[a.length - 1] += b; 19124 mergeWithPrevious = false; 19125 return a; 19126 } else { 19127 return a.concat(b); 19128 } 19129 }, []) 19130 // Here we convert the string values into number values (in px) 19131 .map(function (str) { 19132 return toValue(str, measurement, popperOffsets, referenceOffsets); 19133 }); 19134 }); 19135 19136 // Loop trough the offsets arrays and execute the operations 19137 ops.forEach(function (op, index) { 19138 op.forEach(function (frag, index2) { 19139 if (isNumeric(frag)) { 19140 offsets[index] += frag * (op[index2 - 1] === '-' ? -1 : 1); 19141 } 19142 }); 19143 }); 19144 return offsets; 19145} 19146 19147/** 19148 * @function 19149 * @memberof Modifiers 19150 * @argument {Object} data - The data object generated by update method 19151 * @argument {Object} options - Modifiers configuration and options 19152 * @argument {Number|String} options.offset=0 19153 * The offset value as described in the modifier description 19154 * @returns {Object} The data object, properly modified 19155 */ 19156function offset(data, _ref) { 19157 var offset = _ref.offset; 19158 var placement = data.placement, 19159 _data$offsets = data.offsets, 19160 popper = _data$offsets.popper, 19161 reference = _data$offsets.reference; 19162 19163 var basePlacement = placement.split('-')[0]; 19164 19165 var offsets = void 0; 19166 if (isNumeric(+offset)) { 19167 offsets = [+offset, 0]; 19168 } else { 19169 offsets = parseOffset(offset, popper, reference, basePlacement); 19170 } 19171 19172 if (basePlacement === 'left') { 19173 popper.top += offsets[0]; 19174 popper.left -= offsets[1]; 19175 } else if (basePlacement === 'right') { 19176 popper.top += offsets[0]; 19177 popper.left += offsets[1]; 19178 } else if (basePlacement === 'top') { 19179 popper.left += offsets[0]; 19180 popper.top -= offsets[1]; 19181 } else if (basePlacement === 'bottom') { 19182 popper.left += offsets[0]; 19183 popper.top += offsets[1]; 19184 } 19185 19186 data.popper = popper; 19187 return data; 19188} 19189 19190/** 19191 * @function 19192 * @memberof Modifiers 19193 * @argument {Object} data - The data object generated by `update` method 19194 * @argument {Object} options - Modifiers configuration and options 19195 * @returns {Object} The data object, properly modified 19196 */ 19197function preventOverflow(data, options) { 19198 var boundariesElement = options.boundariesElement || getOffsetParent(data.instance.popper); 19199 19200 // If offsetParent is the reference element, we really want to 19201 // go one step up and use the next offsetParent as reference to 19202 // avoid to make this modifier completely useless and look like broken 19203 if (data.instance.reference === boundariesElement) { 19204 boundariesElement = getOffsetParent(boundariesElement); 19205 } 19206 19207 // NOTE: DOM access here 19208 // resets the popper's position so that the document size can be calculated excluding 19209 // the size of the popper element itself 19210 var transformProp = getSupportedPropertyName('transform'); 19211 var popperStyles = data.instance.popper.style; // assignment to help minification 19212 var top = popperStyles.top, 19213 left = popperStyles.left, 19214 transform = popperStyles[transformProp]; 19215 19216 popperStyles.top = ''; 19217 popperStyles.left = ''; 19218 popperStyles[transformProp] = ''; 19219 19220 var boundaries = getBoundaries(data.instance.popper, data.instance.reference, options.padding, boundariesElement, data.positionFixed); 19221 19222 // NOTE: DOM access here 19223 // restores the original style properties after the offsets have been computed 19224 popperStyles.top = top; 19225 popperStyles.left = left; 19226 popperStyles[transformProp] = transform; 19227 19228 options.boundaries = boundaries; 19229 19230 var order = options.priority; 19231 var popper = data.offsets.popper; 19232 19233 var check = { 19234 primary: function primary(placement) { 19235 var value = popper[placement]; 19236 if (popper[placement] < boundaries[placement] && !options.escapeWithReference) { 19237 value = Math.max(popper[placement], boundaries[placement]); 19238 } 19239 return defineProperty({}, placement, value); 19240 }, 19241 secondary: function secondary(placement) { 19242 var mainSide = placement === 'right' ? 'left' : 'top'; 19243 var value = popper[mainSide]; 19244 if (popper[placement] > boundaries[placement] && !options.escapeWithReference) { 19245 value = Math.min(popper[mainSide], boundaries[placement] - (placement === 'right' ? popper.width : popper.height)); 19246 } 19247 return defineProperty({}, mainSide, value); 19248 } 19249 }; 19250 19251 order.forEach(function (placement) { 19252 var side = ['left', 'top'].indexOf(placement) !== -1 ? 'primary' : 'secondary'; 19253 popper = _extends({}, popper, check[side](placement)); 19254 }); 19255 19256 data.offsets.popper = popper; 19257 19258 return data; 19259} 19260 19261/** 19262 * @function 19263 * @memberof Modifiers 19264 * @argument {Object} data - The data object generated by `update` method 19265 * @argument {Object} options - Modifiers configuration and options 19266 * @returns {Object} The data object, properly modified 19267 */ 19268function shift(data) { 19269 var placement = data.placement; 19270 var basePlacement = placement.split('-')[0]; 19271 var shiftvariation = placement.split('-')[1]; 19272 19273 // if shift shiftvariation is specified, run the modifier 19274 if (shiftvariation) { 19275 var _data$offsets = data.offsets, 19276 reference = _data$offsets.reference, 19277 popper = _data$offsets.popper; 19278 19279 var isVertical = ['bottom', 'top'].indexOf(basePlacement) !== -1; 19280 var side = isVertical ? 'left' : 'top'; 19281 var measurement = isVertical ? 'width' : 'height'; 19282 19283 var shiftOffsets = { 19284 start: defineProperty({}, side, reference[side]), 19285 end: defineProperty({}, side, reference[side] + reference[measurement] - popper[measurement]) 19286 }; 19287 19288 data.offsets.popper = _extends({}, popper, shiftOffsets[shiftvariation]); 19289 } 19290 19291 return data; 19292} 19293 19294/** 19295 * @function 19296 * @memberof Modifiers 19297 * @argument {Object} data - The data object generated by update method 19298 * @argument {Object} options - Modifiers configuration and options 19299 * @returns {Object} The data object, properly modified 19300 */ 19301function hide(data) { 19302 if (!isModifierRequired(data.instance.modifiers, 'hide', 'preventOverflow')) { 19303 return data; 19304 } 19305 19306 var refRect = data.offsets.reference; 19307 var bound = find(data.instance.modifiers, function (modifier) { 19308 return modifier.name === 'preventOverflow'; 19309 }).boundaries; 19310 19311 if (refRect.bottom < bound.top || refRect.left > bound.right || refRect.top > bound.bottom || refRect.right < bound.left) { 19312 // Avoid unnecessary DOM access if visibility hasn't changed 19313 if (data.hide === true) { 19314 return data; 19315 } 19316 19317 data.hide = true; 19318 data.attributes['x-out-of-boundaries'] = ''; 19319 } else { 19320 // Avoid unnecessary DOM access if visibility hasn't changed 19321 if (data.hide === false) { 19322 return data; 19323 } 19324 19325 data.hide = false; 19326 data.attributes['x-out-of-boundaries'] = false; 19327 } 19328 19329 return data; 19330} 19331 19332/** 19333 * @function 19334 * @memberof Modifiers 19335 * @argument {Object} data - The data object generated by `update` method 19336 * @argument {Object} options - Modifiers configuration and options 19337 * @returns {Object} The data object, properly modified 19338 */ 19339function inner(data) { 19340 var placement = data.placement; 19341 var basePlacement = placement.split('-')[0]; 19342 var _data$offsets = data.offsets, 19343 popper = _data$offsets.popper, 19344 reference = _data$offsets.reference; 19345 19346 var isHoriz = ['left', 'right'].indexOf(basePlacement) !== -1; 19347 19348 var subtractLength = ['top', 'left'].indexOf(basePlacement) === -1; 19349 19350 popper[isHoriz ? 'left' : 'top'] = reference[basePlacement] - (subtractLength ? popper[isHoriz ? 'width' : 'height'] : 0); 19351 19352 data.placement = getOppositePlacement(placement); 19353 data.offsets.popper = getClientRect(popper); 19354 19355 return data; 19356} 19357 19358/** 19359 * Modifier function, each modifier can have a function of this type assigned 19360 * to its `fn` property.<br /> 19361 * These functions will be called on each update, this means that you must 19362 * make sure they are performant enough to avoid performance bottlenecks. 19363 * 19364 * @function ModifierFn 19365 * @argument {dataObject} data - The data object generated by `update` method 19366 * @argument {Object} options - Modifiers configuration and options 19367 * @returns {dataObject} The data object, properly modified 19368 */ 19369 19370/** 19371 * Modifiers are plugins used to alter the behavior of your poppers.<br /> 19372 * Popper.js uses a set of 9 modifiers to provide all the basic functionalities 19373 * needed by the library. 19374 * 19375 * Usually you don't want to override the `order`, `fn` and `onLoad` props. 19376 * All the other properties are configurations that could be tweaked. 19377 * @namespace modifiers 19378 */ 19379var modifiers = { 19380 /** 19381 * Modifier used to shift the popper on the start or end of its reference 19382 * element.<br /> 19383 * It will read the variation of the `placement` property.<br /> 19384 * It can be one either `-end` or `-start`. 19385 * @memberof modifiers 19386 * @inner 19387 */ 19388 shift: { 19389 /** @prop {number} order=100 - Index used to define the order of execution */ 19390 order: 100, 19391 /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */ 19392 enabled: true, 19393 /** @prop {ModifierFn} */ 19394 fn: shift 19395 }, 19396 19397 /** 19398 * The `offset` modifier can shift your popper on both its axis. 19399 * 19400 * It accepts the following units: 19401 * - `px` or unit-less, interpreted as pixels 19402 * - `%` or `%r`, percentage relative to the length of the reference element 19403 * - `%p`, percentage relative to the length of the popper element 19404 * - `vw`, CSS viewport width unit 19405 * - `vh`, CSS viewport height unit 19406 * 19407 * For length is intended the main axis relative to the placement of the popper.<br /> 19408 * This means that if the placement is `top` or `bottom`, the length will be the 19409 * `width`. In case of `left` or `right`, it will be the `height`. 19410 * 19411 * You can provide a single value (as `Number` or `String`), or a pair of values 19412 * as `String` divided by a comma or one (or more) white spaces.<br /> 19413 * The latter is a deprecated method because it leads to confusion and will be 19414 * removed in v2.<br /> 19415 * Additionally, it accepts additions and subtractions between different units. 19416 * Note that multiplications and divisions aren't supported. 19417 * 19418 * Valid examples are: 19419 * ``` 19420 * 10 19421 * '10%' 19422 * '10, 10' 19423 * '10%, 10' 19424 * '10 + 10%' 19425 * '10 - 5vh + 3%' 19426 * '-10px + 5vh, 5px - 6%' 19427 * ``` 19428 * > **NB**: If you desire to apply offsets to your poppers in a way that may make them overlap 19429 * > with their reference element, unfortunately, you will have to disable the `flip` modifier. 19430 * > You can read more on this at this [issue](https://github.com/FezVrasta/popper.js/issues/373). 19431 * 19432 * @memberof modifiers 19433 * @inner 19434 */ 19435 offset: { 19436 /** @prop {number} order=200 - Index used to define the order of execution */ 19437 order: 200, 19438 /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */ 19439 enabled: true, 19440 /** @prop {ModifierFn} */ 19441 fn: offset, 19442 /** @prop {Number|String} offset=0 19443 * The offset value as described in the modifier description 19444 */ 19445 offset: 0 19446 }, 19447 19448 /** 19449 * Modifier used to prevent the popper from being positioned outside the boundary. 19450 * 19451 * A scenario exists where the reference itself is not within the boundaries.<br /> 19452 * We can say it has "escaped the boundaries" — or just "escaped".<br /> 19453 * In this case we need to decide whether the popper should either: 19454 * 19455 * - detach from the reference and remain "trapped" in the boundaries, or 19456 * - if it should ignore the boundary and "escape with its reference" 19457 * 19458 * When `escapeWithReference` is set to`true` and reference is completely 19459 * outside its boundaries, the popper will overflow (or completely leave) 19460 * the boundaries in order to remain attached to the edge of the reference. 19461 * 19462 * @memberof modifiers 19463 * @inner 19464 */ 19465 preventOverflow: { 19466 /** @prop {number} order=300 - Index used to define the order of execution */ 19467 order: 300, 19468 /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */ 19469 enabled: true, 19470 /** @prop {ModifierFn} */ 19471 fn: preventOverflow, 19472 /** 19473 * @prop {Array} [priority=['left','right','top','bottom']] 19474 * Popper will try to prevent overflow following these priorities by default, 19475 * then, it could overflow on the left and on top of the `boundariesElement` 19476 */ 19477 priority: ['left', 'right', 'top', 'bottom'], 19478 /** 19479 * @prop {number} padding=5 19480 * Amount of pixel used to define a minimum distance between the boundaries 19481 * and the popper. This makes sure the popper always has a little padding 19482 * between the edges of its container 19483 */ 19484 padding: 5, 19485 /** 19486 * @prop {String|HTMLElement} boundariesElement='scrollParent' 19487 * Boundaries used by the modifier. Can be `scrollParent`, `window`, 19488 * `viewport` or any DOM element. 19489 */ 19490 boundariesElement: 'scrollParent' 19491 }, 19492 19493 /** 19494 * Modifier used to make sure the reference and its popper stay near each other 19495 * without leaving any gap between the two. Especially useful when the arrow is 19496 * enabled and you want to ensure that it points to its reference element. 19497 * It cares only about the first axis. You can still have poppers with margin 19498 * between the popper and its reference element. 19499 * @memberof modifiers 19500 * @inner 19501 */ 19502 keepTogether: { 19503 /** @prop {number} order=400 - Index used to define the order of execution */ 19504 order: 400, 19505 /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */ 19506 enabled: true, 19507 /** @prop {ModifierFn} */ 19508 fn: keepTogether 19509 }, 19510 19511 /** 19512 * This modifier is used to move the `arrowElement` of the popper to make 19513 * sure it is positioned between the reference element and its popper element. 19514 * It will read the outer size of the `arrowElement` node to detect how many 19515 * pixels of conjunction are needed. 19516 * 19517 * It has no effect if no `arrowElement` is provided. 19518 * @memberof modifiers 19519 * @inner 19520 */ 19521 arrow: { 19522 /** @prop {number} order=500 - Index used to define the order of execution */ 19523 order: 500, 19524 /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */ 19525 enabled: true, 19526 /** @prop {ModifierFn} */ 19527 fn: arrow, 19528 /** @prop {String|HTMLElement} element='[x-arrow]' - Selector or node used as arrow */ 19529 element: '[x-arrow]' 19530 }, 19531 19532 /** 19533 * Modifier used to flip the popper's placement when it starts to overlap its 19534 * reference element. 19535 * 19536 * Requires the `preventOverflow` modifier before it in order to work. 19537 * 19538 * **NOTE:** this modifier will interrupt the current update cycle and will 19539 * restart it if it detects the need to flip the placement. 19540 * @memberof modifiers 19541 * @inner 19542 */ 19543 flip: { 19544 /** @prop {number} order=600 - Index used to define the order of execution */ 19545 order: 600, 19546 /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */ 19547 enabled: true, 19548 /** @prop {ModifierFn} */ 19549 fn: flip, 19550 /** 19551 * @prop {String|Array} behavior='flip' 19552 * The behavior used to change the popper's placement. It can be one of 19553 * `flip`, `clockwise`, `counterclockwise` or an array with a list of valid 19554 * placements (with optional variations) 19555 */ 19556 behavior: 'flip', 19557 /** 19558 * @prop {number} padding=5 19559 * The popper will flip if it hits the edges of the `boundariesElement` 19560 */ 19561 padding: 5, 19562 /** 19563 * @prop {String|HTMLElement} boundariesElement='viewport' 19564 * The element which will define the boundaries of the popper position. 19565 * The popper will never be placed outside of the defined boundaries 19566 * (except if `keepTogether` is enabled) 19567 */ 19568 boundariesElement: 'viewport', 19569 /** 19570 * @prop {Boolean} flipVariations=false 19571 * The popper will switch placement variation between `-start` and `-end` when 19572 * the reference element overlaps its boundaries. 19573 * 19574 * The original placement should have a set variation. 19575 */ 19576 flipVariations: false, 19577 /** 19578 * @prop {Boolean} flipVariationsByContent=false 19579 * The popper will switch placement variation between `-start` and `-end` when 19580 * the popper element overlaps its reference boundaries. 19581 * 19582 * The original placement should have a set variation. 19583 */ 19584 flipVariationsByContent: false 19585 }, 19586 19587 /** 19588 * Modifier used to make the popper flow toward the inner of the reference element. 19589 * By default, when this modifier is disabled, the popper will be placed outside 19590 * the reference element. 19591 * @memberof modifiers 19592 * @inner 19593 */ 19594 inner: { 19595 /** @prop {number} order=700 - Index used to define the order of execution */ 19596 order: 700, 19597 /** @prop {Boolean} enabled=false - Whether the modifier is enabled or not */ 19598 enabled: false, 19599 /** @prop {ModifierFn} */ 19600 fn: inner 19601 }, 19602 19603 /** 19604 * Modifier used to hide the popper when its reference element is outside of the 19605 * popper boundaries. It will set a `x-out-of-boundaries` attribute which can 19606 * be used to hide with a CSS selector the popper when its reference is 19607 * out of boundaries. 19608 * 19609 * Requires the `preventOverflow` modifier before it in order to work. 19610 * @memberof modifiers 19611 * @inner 19612 */ 19613 hide: { 19614 /** @prop {number} order=800 - Index used to define the order of execution */ 19615 order: 800, 19616 /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */ 19617 enabled: true, 19618 /** @prop {ModifierFn} */ 19619 fn: hide 19620 }, 19621 19622 /** 19623 * Computes the style that will be applied to the popper element to gets 19624 * properly positioned. 19625 * 19626 * Note that this modifier will not touch the DOM, it just prepares the styles 19627 * so that `applyStyle` modifier can apply it. This separation is useful 19628 * in case you need to replace `applyStyle` with a custom implementation. 19629 * 19630 * This modifier has `850` as `order` value to maintain backward compatibility 19631 * with previous versions of Popper.js. Expect the modifiers ordering method 19632 * to change in future major versions of the library. 19633 * 19634 * @memberof modifiers 19635 * @inner 19636 */ 19637 computeStyle: { 19638 /** @prop {number} order=850 - Index used to define the order of execution */ 19639 order: 850, 19640 /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */ 19641 enabled: true, 19642 /** @prop {ModifierFn} */ 19643 fn: computeStyle, 19644 /** 19645 * @prop {Boolean} gpuAcceleration=true 19646 * If true, it uses the CSS 3D transformation to position the popper. 19647 * Otherwise, it will use the `top` and `left` properties 19648 */ 19649 gpuAcceleration: true, 19650 /** 19651 * @prop {string} [x='bottom'] 19652 * Where to anchor the X axis (`bottom` or `top`). AKA X offset origin. 19653 * Change this if your popper should grow in a direction different from `bottom` 19654 */ 19655 x: 'bottom', 19656 /** 19657 * @prop {string} [x='left'] 19658 * Where to anchor the Y axis (`left` or `right`). AKA Y offset origin. 19659 * Change this if your popper should grow in a direction different from `right` 19660 */ 19661 y: 'right' 19662 }, 19663 19664 /** 19665 * Applies the computed styles to the popper element. 19666 * 19667 * All the DOM manipulations are limited to this modifier. This is useful in case 19668 * you want to integrate Popper.js inside a framework or view library and you 19669 * want to delegate all the DOM manipulations to it. 19670 * 19671 * Note that if you disable this modifier, you must make sure the popper element 19672 * has its position set to `absolute` before Popper.js can do its work! 19673 * 19674 * Just disable this modifier and define your own to achieve the desired effect. 19675 * 19676 * @memberof modifiers 19677 * @inner 19678 */ 19679 applyStyle: { 19680 /** @prop {number} order=900 - Index used to define the order of execution */ 19681 order: 900, 19682 /** @prop {Boolean} enabled=true - Whether the modifier is enabled or not */ 19683 enabled: true, 19684 /** @prop {ModifierFn} */ 19685 fn: applyStyle, 19686 /** @prop {Function} */ 19687 onLoad: applyStyleOnLoad, 19688 /** 19689 * @deprecated since version 1.10.0, the property moved to `computeStyle` modifier 19690 * @prop {Boolean} gpuAcceleration=true 19691 * If true, it uses the CSS 3D transformation to position the popper. 19692 * Otherwise, it will use the `top` and `left` properties 19693 */ 19694 gpuAcceleration: undefined 19695 } 19696}; 19697 19698/** 19699 * The `dataObject` is an object containing all the information used by Popper.js. 19700 * This object is passed to modifiers and to the `onCreate` and `onUpdate` callbacks. 19701 * @name dataObject 19702 * @property {Object} data.instance The Popper.js instance 19703 * @property {String} data.placement Placement applied to popper 19704 * @property {String} data.originalPlacement Placement originally defined on init 19705 * @property {Boolean} data.flipped True if popper has been flipped by flip modifier 19706 * @property {Boolean} data.hide True if the reference element is out of boundaries, useful to know when to hide the popper 19707 * @property {HTMLElement} data.arrowElement Node used as arrow by arrow modifier 19708 * @property {Object} data.styles Any CSS property defined here will be applied to the popper. It expects the JavaScript nomenclature (eg. `marginBottom`) 19709 * @property {Object} data.arrowStyles Any CSS property defined here will be applied to the popper arrow. It expects the JavaScript nomenclature (eg. `marginBottom`) 19710 * @property {Object} data.boundaries Offsets of the popper boundaries 19711 * @property {Object} data.offsets The measurements of popper, reference and arrow elements 19712 * @property {Object} data.offsets.popper `top`, `left`, `width`, `height` values 19713 * @property {Object} data.offsets.reference `top`, `left`, `width`, `height` values 19714 * @property {Object} data.offsets.arrow] `top` and `left` offsets, only one of them will be different from 0 19715 */ 19716 19717/** 19718 * Default options provided to Popper.js constructor.<br /> 19719 * These can be overridden using the `options` argument of Popper.js.<br /> 19720 * To override an option, simply pass an object with the same 19721 * structure of the `options` object, as the 3rd argument. For example: 19722 * ``` 19723 * new Popper(ref, pop, { 19724 * modifiers: { 19725 * preventOverflow: { enabled: false } 19726 * } 19727 * }) 19728 * ``` 19729 * @type {Object} 19730 * @static 19731 * @memberof Popper 19732 */ 19733var Defaults = { 19734 /** 19735 * Popper's placement. 19736 * @prop {Popper.placements} placement='bottom' 19737 */ 19738 placement: 'bottom', 19739 19740 /** 19741 * Set this to true if you want popper to position it self in 'fixed' mode 19742 * @prop {Boolean} positionFixed=false 19743 */ 19744 positionFixed: false, 19745 19746 /** 19747 * Whether events (resize, scroll) are initially enabled. 19748 * @prop {Boolean} eventsEnabled=true 19749 */ 19750 eventsEnabled: true, 19751 19752 /** 19753 * Set to true if you want to automatically remove the popper when 19754 * you call the `destroy` method. 19755 * @prop {Boolean} removeOnDestroy=false 19756 */ 19757 removeOnDestroy: false, 19758 19759 /** 19760 * Callback called when the popper is created.<br /> 19761 * By default, it is set to no-op.<br /> 19762 * Access Popper.js instance with `data.instance`. 19763 * @prop {onCreate} 19764 */ 19765 onCreate: function onCreate() {}, 19766 19767 /** 19768 * Callback called when the popper is updated. This callback is not called 19769 * on the initialization/creation of the popper, but only on subsequent 19770 * updates.<br /> 19771 * By default, it is set to no-op.<br /> 19772 * Access Popper.js instance with `data.instance`. 19773 * @prop {onUpdate} 19774 */ 19775 onUpdate: function onUpdate() {}, 19776 19777 /** 19778 * List of modifiers used to modify the offsets before they are applied to the popper. 19779 * They provide most of the functionalities of Popper.js. 19780 * @prop {modifiers} 19781 */ 19782 modifiers: modifiers 19783}; 19784 19785/** 19786 * @callback onCreate 19787 * @param {dataObject} data 19788 */ 19789 19790/** 19791 * @callback onUpdate 19792 * @param {dataObject} data 19793 */ 19794 19795// Utils 19796// Methods 19797var Popper = function () { 19798 /** 19799 * Creates a new Popper.js instance. 19800 * @class Popper 19801 * @param {Element|referenceObject} reference - The reference element used to position the popper 19802 * @param {Element} popper - The HTML / XML element used as the popper 19803 * @param {Object} options - Your custom options to override the ones defined in [Defaults](#defaults) 19804 * @return {Object} instance - The generated Popper.js instance 19805 */ 19806 function Popper(reference, popper) { 19807 var _this = this; 19808 19809 var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {}; 19810 classCallCheck(this, Popper); 19811 19812 this.scheduleUpdate = function () { 19813 return requestAnimationFrame(_this.update); 19814 }; 19815 19816 // make update() debounced, so that it only runs at most once-per-tick 19817 this.update = debounce(this.update.bind(this)); 19818 19819 // with {} we create a new object with the options inside it 19820 this.options = _extends({}, Popper.Defaults, options); 19821 19822 // init state 19823 this.state = { 19824 isDestroyed: false, 19825 isCreated: false, 19826 scrollParents: [] 19827 }; 19828 19829 // get reference and popper elements (allow jQuery wrappers) 19830 this.reference = reference && reference.jquery ? reference[0] : reference; 19831 this.popper = popper && popper.jquery ? popper[0] : popper; 19832 19833 // Deep merge modifiers options 19834 this.options.modifiers = {}; 19835 Object.keys(_extends({}, Popper.Defaults.modifiers, options.modifiers)).forEach(function (name) { 19836 _this.options.modifiers[name] = _extends({}, Popper.Defaults.modifiers[name] || {}, options.modifiers ? options.modifiers[name] : {}); 19837 }); 19838 19839 // Refactoring modifiers' list (Object => Array) 19840 this.modifiers = Object.keys(this.options.modifiers).map(function (name) { 19841 return _extends({ 19842 name: name 19843 }, _this.options.modifiers[name]); 19844 }) 19845 // sort the modifiers by order 19846 .sort(function (a, b) { 19847 return a.order - b.order; 19848 }); 19849 19850 // modifiers have the ability to execute arbitrary code when Popper.js get inited 19851 // such code is executed in the same order of its modifier 19852 // they could add new properties to their options configuration 19853 // BE AWARE: don't add options to `options.modifiers.name` but to `modifierOptions`! 19854 this.modifiers.forEach(function (modifierOptions) { 19855 if (modifierOptions.enabled && isFunction(modifierOptions.onLoad)) { 19856 modifierOptions.onLoad(_this.reference, _this.popper, _this.options, modifierOptions, _this.state); 19857 } 19858 }); 19859 19860 // fire the first update to position the popper in the right place 19861 this.update(); 19862 19863 var eventsEnabled = this.options.eventsEnabled; 19864 if (eventsEnabled) { 19865 // setup event listeners, they will take care of update the position in specific situations 19866 this.enableEventListeners(); 19867 } 19868 19869 this.state.eventsEnabled = eventsEnabled; 19870 } 19871 19872 // We can't use class properties because they don't get listed in the 19873 // class prototype and break stuff like Sinon stubs 19874 19875 19876 createClass(Popper, [{ 19877 key: 'update', 19878 value: function update$$1() { 19879 return update.call(this); 19880 } 19881 }, { 19882 key: 'destroy', 19883 value: function destroy$$1() { 19884 return destroy.call(this); 19885 } 19886 }, { 19887 key: 'enableEventListeners', 19888 value: function enableEventListeners$$1() { 19889 return enableEventListeners.call(this); 19890 } 19891 }, { 19892 key: 'disableEventListeners', 19893 value: function disableEventListeners$$1() { 19894 return disableEventListeners.call(this); 19895 } 19896 19897 /** 19898 * Schedules an update. It will run on the next UI update available. 19899 * @method scheduleUpdate 19900 * @memberof Popper 19901 */ 19902 19903 19904 /** 19905 * Collection of utilities useful when writing custom modifiers. 19906 * Starting from version 1.7, this method is available only if you 19907 * include `popper-utils.js` before `popper.js`. 19908 * 19909 * **DEPRECATION**: This way to access PopperUtils is deprecated 19910 * and will be removed in v2! Use the PopperUtils module directly instead. 19911 * Due to the high instability of the methods contained in Utils, we can't 19912 * guarantee them to follow semver. Use them at your own risk! 19913 * @static 19914 * @private 19915 * @type {Object} 19916 * @deprecated since version 1.8 19917 * @member Utils 19918 * @memberof Popper 19919 */ 19920 19921 }]); 19922 return Popper; 19923}(); 19924 19925/** 19926 * The `referenceObject` is an object that provides an interface compatible with Popper.js 19927 * and lets you use it as replacement of a real DOM node.<br /> 19928 * You can use this method to position a popper relatively to a set of coordinates 19929 * in case you don't have a DOM node to use as reference. 19930 * 19931 * ``` 19932 * new Popper(referenceObject, popperNode); 19933 * ``` 19934 * 19935 * NB: This feature isn't supported in Internet Explorer 10. 19936 * @name referenceObject 19937 * @property {Function} data.getBoundingClientRect 19938 * A function that returns a set of coordinates compatible with the native `getBoundingClientRect` method. 19939 * @property {number} data.clientWidth 19940 * An ES6 getter that will return the width of the virtual reference element. 19941 * @property {number} data.clientHeight 19942 * An ES6 getter that will return the height of the virtual reference element. 19943 */ 19944 19945 19946Popper.Utils = (typeof window !== 'undefined' ? window : global).PopperUtils; 19947Popper.placements = placements; 19948Popper.Defaults = Defaults; 19949 19950return Popper; 19951 19952})));
19953 19954 19955}).call(this)}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) 19956},{}],15:[function(require,module,exports){ 19957"use strict"; 19958 19959$(document).ready(function () { 19960 /*:::::::::: RGH Hero Banners ::::::::::*/ 19961 if ($(".rgh-overview-video").length) { 19962 // $(".mainnav").prependTo(".rgh-overview-video"); 19963 $(".breadcrumb").hide(); 19964 //$(".rgh-overview-video").closest(".par").parent().addClass("rgh-overview-fullpage"); 19965 19966 $("html, body").css("height", "100%"); 19967 function sizeContent() { 19968 var htmlHeight = $("html").height(); 19969 var navbarHeight = $(".navbar-fixed-bottom").height(); 19970 var mainnavHeight = $(".global-nav").height(); 19971 var ribbonHeight = 61; 19972 var copyHeight = htmlHeight - mainnavHeight - ribbonHeight - navbarHeight + "px"; 19973 var videoHeight = htmlHeight - mainnavHeight - ribbonHeight + "px"; 19974 $(".v-align-table").css("height", copyHeight); 19975 $(".rgh-overview-video").css("height", videoHeight); 19976 } 19977 sizeContent(); 19978 $(window).on('resize', sizeContent()); 19979 19980 /* Smooth Scroll Home Button */ 19981 $("a[href='#scroll-to']").on("click", function () { 19982 var mainnavHeight = $("header").height(); 19983 if ($(window).width() < 1025) { 19984 $('html,body').animate({ 19985 scrollTop: $(".thumbnail-section").offset().top - mainnavHeight 19986 }, 'slow'); 19987 } else { 19988 $('html,body').animate({ 19989 scrollTop: $(".thumbnail-section").offset().top 19990 }, 'slow'); 19991 } 19992 }); 19993 } 19994 /*:::::::::: RGH Hero Banners ::::::::::*/ 19995}); 19996 19997},{}],16:[function(require,module,exports){ 19998"use strict"; 19999 20000var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault"); 20001var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof")); 20002$(document).ready(function () { 20003 /*:::::::::: Equal Height Box ::::::::::*/ 20004 function equalBoxHeight(container, box) { 20005 $(container).each(function () { 20006 var highestBox = 0; 20007 $(this).find(box).each(function () { 20008 if ($(this).css('display') === 'none') { 20009 var initCSS = $(this).attr('style'); 20010 var newHeight = $(this).css({ 20011 height: 'auto', 20012 display: 'block' 20013 }).height(); 20014 if (newHeight > highestBox) { 20015 highestBox = $(this).height(); 20016 } 20017 $(this).attr('style', '').attr('style', initCSS !== 'undefined' ? initCSS : ''); 20018 } else { 20019 $(this).height("auto"); 20020 if ($(this).height() > highestBox) { 20021 highestBox = $(this).height(); 20022 } 20023 } 20024 }); 20025 $(this).find(box).height(highestBox); 20026 }); 20027 } 20028 $(window).on('load', function () { 20029 equalBoxHeight(".equal-height-container", ".equal-height-box"); 20030 }); 20031 $(window).on('resize', function () { 20032 equalBoxHeight(".equal-height-container", ".equal-height-box"); 20033 }); 20034 $('.modal').on('shown.bs.modal', function () { 20035 equalBoxHeight(".equal-height-container", ".equal-height-box"); 20036 }); 20037 $('.browser-back-link').each(function () { 20038 var link = $(this); 20039 link.on('click', function (e) { 20040 e.preventDefault(); 20041 history.back(); 20042 }); 20043 }); 20044 20045 //Equal height within carousels (works with flex vertical centering) 20046 function carouselNormalization() { 20047 var items = $('.equal-height-carousel .item'), 20048 //grab all slides 20049 heights = [], 20050 //create empty array to store height values 20051 tallest; //create variable to make note of the tallest slide 20052 20053 if (items.length) { 20054 function normalizeHeights() { 20055 items.each(function () { 20056 //add heights to array 20057 heights.push($(this).height()); 20058 }); 20059 tallest = Math.max.apply(null, heights); //cache largest value 20060 items.each(function () { 20061 $(this).find('.equal-height-slide').css('height', tallest + 'px'); 20062 }); 20063 } 20064 ; 20065 normalizeHeights(); 20066 $(window).on('resize orientationchange', function () { 20067 tallest = 0, heights.length = 0; //reset vars 20068 items.each(function () { 20069 $(this).find('.equal-height-slide').css('height', 'auto'); //reset min-height 20070 }); 20071 normalizeHeights(); //run it again 20072 }); 20073 } 20074 } 20075 carouselNormalization(); 20076 20077 /*:::::::::: Equal Height Box ::::::::::*/ 20078 20079 /*:::::::::: Sidebar Collapse ::::::::::*/ 20080 function collapseSidebar() { 20081 $('.btn-sidebar-collapse').each(function () { 20082 var toggleTarget = $(this).data('toggle'); 20083 if (typeof toggleTarget == 'undefined' || (0, _typeof2.default)(toggleTarget) == null) return; 20084 $(this).on('click', function (e) { 20085 e.preventDefault(); 20086 $(toggleTarget).toggleClass('open'); 20087 $(this).toggleClass('btn-primary'); 20088 $(this).toggleClass('btn-primary-outline'); 20089 $('.collapse-control').toggleClass('hide'); 20090 }); 20091 $('.collapse-control').on('click', $('.sidebar-collapse' + toggleTarget), function () { 20092 $(toggleTarget).removeClass('open'); 20093 $('.btn-sidebar-collapse').addClass('btn-primary-outline').removeClass('btn-primary'); 20094 $('.collapse-control').toggleClass('hide'); 20095 }); 20096 }); 20097 } 20098 $(window).on('load', function () { 20099 collapseSidebar(); 20100 }); 20101 $(window).on('resize', function () { 20102 var windowWidth = $(window).width(); 20103 if (windowWidth > 768) { 20104 $('.sidebar-collapse').removeClass('open'); 20105 $('.btn-sidebar-collapse').addClass('btn-primary-outline').removeClass('btn-primary'); 20106 $('.collapse-control').addClass('hide'); 20107 } 20108 }); 20109 20110 /*:::::::::: Sidebar Collapse ::::::::::*/ 20111 20112 /*:::::::::: Parent - Child Height ::::::::::*/ 20113 function fullHeight(parentHeightClass, childHeightClass) { 20114 $(childHeightClass).css("height", "0px"); 20115 $(parentHeightClass).each(function () { 20116 var parentHeight = $(this).height(); 20117 var childHeight = $(childHeightClass).height(); 20118 $(this).find(childHeightClass).css("height", parentHeight); 20119 }); 20120 } 20121 $(window).on('load', function () { 20122 fullHeight(".parent-height", ".child-height"); 20123 }); 20124 $(window).on('resize', function () { 20125 fullHeight(".parent-height", ".child-height"); 20126 }); 20127 20128 /*:::::::::: Parent - Child Height ::::::::::*/ 20129 20130 /*:::::::::: Smooth Link Scroll to Top ::::::::::*/ 20131 20132 $('.linktotop').on('click', function (e) { 20133 e.preventDefault(); 20134 $('html,body').animate({ 20135 scrollTop: 0 20136 }, 1000); 20137 }); 20138 20139 /*:::::::::: Smooth Link Scroll to Top ::::::::::*/ 20140 20141 /*:::::::::: Link Disabled ::::::::::*/ 20142 $('.link-disabled').on('click', function (e) { 20143 e.preventDefault(); 20144 }); 20145 /*:::::::::: Link Disabled ::::::::::*/ 20146 20147 spinnerButtonListener(); 20148}); 20149 20150/*:::::::::: Smooth scrollTo ::::::::::*/ 20151function scrollTo(targetElem) { 20152 var vOffset = 100; // 100px to avoid sticky header/nav overlaying content 20153 if (targetElem.length) {
20154 var dest = $(targetElem).offset().top - vOffset; 20155 $('html,body').animate({ 20156 scrollTop: dest 20157 }, 800); 20158 } 20159} 20160/*:::::::::: / Smooth scrollTo ::::::::::*/ 20161 20162/*:::::::::: Button Spinner Functionality ::::::::::*/ 20163 20164/* From Modernizr */ 20165window.whichTransitionEvent = function () { 20166 var t; 20167 var el = document.createElement('fakeelement'); 20168 var transitions = { 20169 'transition': 'transitionend', 20170 'OTransition': 'oTransitionEnd', 20171 'MozTransition': 'transitionend', 20172 'WebkitTransition': 'webkitTransitionEnd' 20173 }; 20174 for (t in transitions) { 20175 if (el.style[t] !== undefined) { 20176 return transitions[t]; 20177 } 20178 } 20179}; 20180var transitionEvent = window.whichTransitionEvent(); 20181if (transitionEvent) { 20182 window.spinnerButtonListener = function () { 20183 $('[data-button-spinner]').on('click', function () { 20184 var $btn = $(this), 20185 oHtml = $btn.html(), 20186 initWidth = $btn.css('width'), 20187 spinnerLabel = $btn.attr('data-button-spinner'), 20188 isDisabled = typeof $btn.attr('data-button-spinner-disabled') !== 'undefined', 20189 breathe = 2; 20190 if (!isDisabled) { 20191 $btn.data({ 20192 'ohtml': oHtml, 20193 'initwidth': initWidth 20194 }).addClass('no-animate'); 20195 var nhtml = '<span class="spinner-border spinner-border-sm" role="status" aria-hidden="true"></span> ' + spinnerLabel; 20196 $btn.html(nhtml); 20197 var newWidth = $btn.outerWidth() + breathe + 'px'; 20198 $btn.css('width', initWidth).removeClass('no-animate'); 20199 20200 //force DOM redraw to enable quick CSS transition 20201 $btn.hide().show(); 20202 $btn.css('width', newWidth); 20203 $btn.attr('disabled', true).addClass('disabled'); 20204 } 20205 }); 20206 }; 20207 window.resetSpinnerButton = function ($btn, disabled) { 20208 if (typeof $btn !== 'undefined' && $btn.length) { 20209 disabled = typeof disabled !== 'undefined'; 20210 $btn.css('width', $btn.data('initwidth')); 20211 20212 // non-transitionend solution for cross-browser support 20213 setTimeout(function () { 20214 $btn.attr('disabled', disabled).removeClass('disabled').html($btn.data('ohtml')); 20215 $btn.css('width', ''); 20216 }, 400); 20217 } 20218 }; 20219 window.completeSpinnerButton = function ($btn, label) { 20220 if (typeof $btn !== 'undefined' && $btn.length && typeof label !== 'undefined') { 20221 var breathe = 2, 20222 oHtml = $btn.html(), 20223 initWidth = $btn.css('width'); 20224 $btn.addClass('no-animate').html(label).css('width', 'auto'); 20225 var newWidth = $btn.outerWidth() + breathe + 'px'; 20226 $btn.css('width', initWidth).html(oHtml).removeClass('no-animate'); 20227 $btn.on(transitionEvent, function () { 20228 $btn.html(label).addClass('complete'); 20229 }); 20230 20231 // non-transitionend fallback 20232 setTimeout(function () { 20233 if (!$btn.hasClass('complete')) { 20234 $btn.html(label).addClass('complete'); 20235 } 20236 }, 400); 20237 20238 // force DOM redraw to enable quick CSS transition 20239 $btn.hide().show(); 20240 $btn.css('width', newWidth).data('initwidth', newWidth); 20241 } 20242 }; 20243} 20244/*:::::::::: / Button Spinner Functionality ::::::::::*/ 20245 20246/* Moved from mmenu.js */ 20247$('[data-toggle="popover"]').popover(); 20248 20249},{"@babel/runtime/helpers/interopRequireDefault":3,"@babel/runtime/helpers/typeof":7}],17:[function(require,module,exports){ 20250"use strict"; 20251 20252$(document).ready(function () { 20253 if (window.matchMedia) { 20254 var mediaQueryList = window.matchMedia('print'); 20255 mediaQueryList.addListener(function (mql) { 20256 if (mql.matches) { 20257 beforePrint(); 20258 } else { 20259 afterPrint(); 20260 } 20261 }); 20262 } else { 20263 window.onbeforeprint = beforePrint; 20264 window.onafterprint = afterPrint; 20265 } 20266 var beforePrint = function beforePrint() { 20267 var ua = navigator.userAgent; 20268 var M = ua.match(/(opera|chrome|safari|firefox|msie|trident(?=\/))\/?\s*(\d+)/i) || []; 20269 if (/trident/i.test(M[1])) { 20270 browser = "MSIE"; 20271 version = 11; 20272 } 20273 if (M[1] === 'Chrome') { 20274 temp = ua.match(/\b(OPR|Edge)\/(\d+)/); 20275 if (temp != null) { 20276 M = temp.slice(1).join(' ').replace('OPR', 'Opera'); 20277 } 20278 } 20279 M = M[2] ? [M[1], M[2]] : [navigator.appName, navigator.appVersion, '-?']; 20280 if ((temp = ua.match(/version\/(\d+)/i)) != null) { 20281 M.splice(1, 1, temp[1]); 20282 } 20283 browser = M[0]; 20284 version = parseInt(M[1]); 20285 window.scrollTo(0, 300); 20286 window.scrollTo(0, 0); 20287 $('.mainnav').css('display', 'none'); 20288 20289 /* BLUSKE STYLES TEST */ 20290 20291 if (browser === "Safari") { 20292 $('.col-md-pull-8').css('right', '58%'); 20293 $('.has-sticky body').css('padding-top', '134px'); 20294 $('.mainnav').css('display', 'block'); 20295 } 20296 }; 20297 var afterPrint = function afterPrint() { 20298 $('.col-md-pull-8').removeAttr('style'); 20299 $('.has-sticky body').removeAttr('style'); 20300 $('.mainnav').removeAttr('style'); 20301 }; 20302}); 20303 20304},{}],18:[function(require,module,exports){ 20305"use strict"; 20306 20307$(document).ready(function () { 20308 $('.accordion-default').find('.panel-title').find('a').on('click', function (e) { 20309 e.preventDefault(); 20310 $('.accordion-default').find('.btn-icon-expand').removeClass('btn-icon-expand').addClass('btn-icon-collapse'); 20311 if ($(this).hasClass('collapsed')) { 20312 $(this).toggleClass('btn-icon-collapse btn-icon-expand'); 20313 } 20314 $('.accordion-default').on('show.bs.collapse', function () { 20315 $('.accordion-default .in').collapse('hide'); 20316 }); 20317 $('.accordion-default').on('shown.bs.collapse', function () { 20318 var offset = $(this).find('.collapse.in').prev('.panel-heading'); 20319 if (offset) { 20320 $('html,body').animate({ 20321 scrollTop: $(offset).offset().top - 60 20322 }, 500); 20323 } 20324 }); 20325 }); 20326}); 20327 20328},{}],19:[function(require,module,exports){ 20329"use strict"; 20330 20331var myCounter = function myCounter(el) { 20332 this.el = el; 20333}; 20334myCounter.prototype.makeCounter = function () { 20335 var nu = this.el; 20336 var labelContainer = document.createElement("p"); 20337 var getLabel = nu.getAttribute("data-label"); 20338 var getColor = nu.getAttribute("data-color"); 20339 labelContainer.className = "pub-label"; 20340 labelContainer.textContent = getLabel; 20341 nu.innerHTML = ''; 20342 var num = nu.parentElement.nodeName !== "P" ? -30 : -24; 20343 var createCounter = function createCounter(d, x) { 20344 var count = d; 20345 if (typeof count === "number") count = String(count); 20346 var countArr = count.split(""); 20347 var container = document.createElement("ul"); 20348 var a = 0; 20349 container.className = "counter"; 20350 for (var c in countArr) { 20351 var li = document.createElement("li"); 20352 li.className = getColor ? getColor + "-gradient" : ''; 20353 for (var ia = 0, maxa = countArr[c]; ia <= maxa; ia++) { 20354 var span = document.createElement("span"); 20355 span.textContent = ia; 20356 li.appendChild(span); 20357 if (ia === 0) $(span).animate({ 20358 marginTop: num * maxa 20359 }, 1000); 20360 } 20361 container.appendChild(li); 20362 } 20363 x.appendChild(container); 20364 x.insertBefore(labelContainer, container.nextSibling); 20365 }; 20366 if (nu.getAttribute("data-count")) { 20367 var data = nu.getAttribute("data-count"); 20368 createCounter(data, nu); 20369 } else { 20370 var geturl = "https://services.illumina.com/api/publications/"; 20371 geturl += this.el.getAttribute("data-url"); 20372 var jax = typeof XDomainRequest !== "undefined" ? new XDomainRequest() : new XMLHttpRequest(); 20373 jax.onload = function () { 20374 var data = JSON.parse(this.responseText); 20375 createCounter(data, nu); 20376 }; 20377 jax.open('GET', encodeURI(geturl), true); 20378 jax.send(); 20379 } 20380}; 20381var $allNumber = $('.number-counter'); 20382if ($allNumber.length) { 20383 $allNumber.each(function (i) { 20384 var y = new myCounter(this); 20385 y.makeCounter(); 20386 }); 20387} 20388var authRegx = /author/; 20389var disRegx = /disabled/; 20390if (authRegx.test(window.location.href) && !disRegx.test(window.location.href)) { 20391 $('body').addClass('author-mode'); 20392} 20393var $staticWorkflow = $('.static-workflow'); 20394if ($staticWorkflow.length) { 20395 var $swWorkflowRow = $staticWorkflow.find('.row'); 20396 var $swCol = $swWorkflowRow.find('.col-xs-4'); 20397 var $swBtns = $('.static-workflow-control').find('.badge'); 20398 $swCol.css('height', $swWorkflowRow.innerHeight()); 20399 function wheresWorkflow() { 20400 var $swRowChildDivWidth = $swWorkflowRow.innerWidth() / 3; 20401 var $xpos = $swWorkflowRow.offset().left * -1; 20402 var ind; 20403 if ($xpos > $swRowChildDivWidth / 2 && $xpos < $swRowChildDivWidth / 2 + $swRowChildDivWidth) { 20404 ind = 1; 20405 } else if ($xpos > $swRowChildDivWidth / 2 + $swRowChildDivWidth) { 20406 ind = 2; 20407 } else if ($xpos < $swRowChildDivWidth / 2) { 20408 ind = 0; 20409 } 20410 $swBtns.removeClass('active'); 20411 $($swBtns[ind]).addClass('active'); 20412 } 20413 $swBtns.on({ 20414 click: function click() { 20415 var $that = $(this); 20416 var pos = $that.index(); 20417 var width = $swCol.innerWidth(); 20418 $staticWorkflow.animate({ 20419 "scrollLeft": pos * width 20420 }, 400); 20421 } 20422 }); 20423 $staticWorkflow.on({ 20424 scroll: function scroll() { 20425 wheresWorkflow(); 20426 } 20427 }); 20428 $(window).on({ 20429 resize: function resize() { 20430 wheresWorkflow(); 20431 $swCol.css('height', 'auto').css('height', $swWorkflowRow.innerHeight()); 20432 } 20433 }); 20434} 20435var $automationMethodsController = $('.automation-methods-controller'); 20436if ($automationMethodsController.length) { 20437 var $automationImg = $automationMethodsController.find('h6'); 20438 var $automationtMethods = $('.automation-methods'); 20439 var $automationModal = $('#am'); 20440 $automationImg.on({ 20441 click: function click() { 20442 var thisIndex = $(this).index(); 20443 var $amIndex = $($automationtMethods[thisIndex]).clone(); 20444 var $am = { 20445 title: $amIndex.find('h6').text(), 20446 desc: $amIndex.find('p'), 20447 table: $amIndex.find('table') 20448 };
20449 $automationModal.find('.modal-title').empty().text($am.title); 20450 $automationModal.find('.modal-body').empty().append($am.table); 20451 $automationModal.find('.modal-footer').empty().append($am.desc); 20452 $automationModal.find('[data-toggle="tooltip"]').tooltip(); 20453 $automationModal.modal('show'); 20454 } 20455 }); 20456} 20457var $sw1 = $('#sw1'); 20458if ($sw1.length) { 20459 var $swCtrl = $('.static-workflow-modal'); 20460 var $swh4 = $sw1.find('h4'); 20461 var $swImg = $sw1.find('img'); 20462 $swCtrl.find('a').on({ 20463 click: function click() { 20464 var current = $(this).parent().index(); 20465 $swh4.hide(); 20466 $swImg.hide(); 20467 $($swh4[current]).show(); 20468 $($swImg[current]).show().css({ 20469 display: "block", 20470 margin: "0 auto" 20471 }); 20472 } 20473 }); 20474} 20475$.fn.scrollr = function () { 20476 this.on({ 20477 click: function click(e) { 20478 e.preventDefault(); 20479 var $that = $(this); 20480 var $dest = $that.attr('href'); 20481 var $posx = $($dest).offset().top; 20482 $('body, html').animate({ 20483 scrollTop: $posx - 70 20484 }, 600); 20485 } 20486 }); 20487}; 20488$('.scrollr').scrollr(); 20489var myCounter = function myCounter(el) { 20490 this.el = el; 20491}; 20492var browserAgent = window.navigator.userAgent; 20493var ieVersion = browserAgent[browserAgent.indexOf('MSIE ') + 5]; 20494if (ieVersion === "9") { 20495 $('.modalLink').each(function () { 20496 var $el = $(this); 20497 if (/library-prep-and-array-kit-selector/.test($el.data('target'))) { 20498 $(this).hide().prev().removeClass('show-on-mobile'); 20499 } 20500 }); 20501} 20502 20503},{}],20:[function(require,module,exports){ 20504"use strict"; 20505 20506$(document).ready(function () { 20507 /*:::::::::: Marketo Sticky Nav Form ::::::::::*/ 20508 if ($(".marketo-sticky-nav").length) { 20509 $(".marketo-sticky-nav-btn").addClass("angle-down"); 20510 $(window).scroll(function () { 20511 if ($(document).scrollTop() > 150) $(".marketo-sticky-nav").fadeIn();else $(".marketo-sticky-nav").fadeOut(); 20512 }); 20513 } 20514 $("#marketo-sticky-nav-collapse").on("shown.bs.collapse", function () { 20515 $(".marketo-sticky-nav-btn").removeClass("angle-down"); 20516 $(".marketo-sticky-nav-btn").addClass("angle-up"); 20517 }); 20518 $("#marketo-sticky-nav-collapse").on("hidden.bs.collapse", function () { 20519 $(".marketo-sticky-nav-btn").removeClass("angle-up"); 20520 $(".marketo-sticky-nav-btn").addClass("angle-down"); 20521 }); 20522 /*:::::::::: Marketo Sticky Nav Form ::::::::::*/ 20523}); 20524 20525},{}],21:[function(require,module,exports){ 20526// import { library } from '@fortawesome/fontawesome-svg-core'; 20527// import { faAngleUp } from '@fortawesome/fontawesome-pro'; 20528// import { faAngleRight } from '@fortawesome/fontawesome-pro'; 20529// import { faAngleLeft } from '@fortawesome/fontawesome-pro'; 20530// import { faEnvelope } from '@fortawesome/fontawesome-pro'; 20531// import { faCheck } from '@fortawesome/fontawesome-pro'; 20532// import { faCertificate } from '@fortawesome/fontawesome-pro'; 20533// import { faCalculator } from '@fortawesome/fontawesome-pro'; 20534// import { faFileWord } from '@fortawesome/fontawesome-pro'; 20535// import { faFilePdf } from '@fortawesome/fontawesome-pro'; 20536// import { faFileExcel } from '@fortawesome/fontawesome-pro'; 20537// import { faFileAlt } from '@fortawesome/fontawesome-pro'; 20538// import { faAngleDoubleUp } from '@fortawesome/fontawesome-pro'; 20539// 20540// library.add(faAngleUp, faAngleRight, faAngleLeft, faEnvelope, faCheck, faCertificate, faCalculator, faFileWord, faFilePdf, faFileExcel, faFileAlt, faAngleDoubleUp); 20541"use strict"; 20542 20543},{}],22:[function(require,module,exports){ 20544"use strict"; 20545 20546var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault"); 20547var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray")); 20548var browserDetect = require('../../../sniffer/js/browserDetect'); 20549var appHelper = window.appHelper = module.exports = { 20550 init: function init() { 20551 appHelper.vars.aemhref = window.location.href; 20552 appHelper.vars.aemhost = window.location.hostname; 20553 }, 20554 region: function region() { 20555 var aemhost = appHelper.vars.aemhref; 20556 var region = 'global'; 20557 if (aemhost.indexOf("illumina.com.cn") > -1 || aemhost.indexOf("apac/zh_CN") > -1) { 20558 region = 'china'; 20559 } else if (aemhost.indexOf("jp.illumina.com") > -1 || aemhost.indexOf("jp.support.illumina.com") > -1 || aemhost.indexOf("apac/ja_JP") > -1) { 20560 region = 'japan'; 20561 } else if (aemhost.indexOf("sapac.illumina.com") > -1 || aemhost.indexOf("sapac.support.illumina.com") > -1 || aemhost.indexOf("spac/en_AU") > -1) { 20562 region = 'sapac'; 20563 } else if (aemhost.indexOf("emea.illumina.com") > -1 || aemhost.indexOf("emea.support.illumina.com") > -1 || aemhost.indexOf("emea/en_GB") > -1 || aemhost.indexOf("emeaetp.val-web.illumina.com/") > -1) { 20564 region = 'emea'; 20565 } else if (aemhost.indexOf("sparkgen.com") > -1 || aemhost.indexOf("sparkgen.val-web") > -1 || aemhost.indexOf("/content/sparkgen") > -1) { 20566 region = 'sparkgen'; 20567 } 20568 return region; 20569 }, 20570 getRegionLocale: function getRegionLocale() { 20571 var _document$querySelect, _document$querySelect2; 20572 // this logic currently does not account for support site /us/en vs /en 20573 var metaRegion = (_document$querySelect = document.querySelector('meta[name="region"]')) === null || _document$querySelect === void 0 ? void 0 : _document$querySelect.content; 20574 var metaLocale = (_document$querySelect2 = document.querySelector('meta[name="locale"]')) === null || _document$querySelect2 === void 0 ? void 0 : _document$querySelect2.content;
20575 var finalLocale = "/en"; 20576 if (metaRegion && metaLocale) { 20577 finalLocale = "/" + metaRegion + "/" + metaLocale; 20578 } 20579 return finalLocale; 20580 }, 20581 dataRegion: function dataRegion() { 20582 var hostname = window.location.hostname, 20583 dataRegion, 20584 isSupportSite; 20585 switch (hostname) { 20586 case 'www.illumina.com': 20587 dataRegion = '/amr/en_US'; 20588 break; 20589 case 'support.illumina.com': 20590 dataRegion = '/us/en/support'; 20591 isSupportSite = true; 20592 break; 20593 case 'www.illumina.com.cn': 20594 dataRegion = '/apac/zh_CN'; 20595 break; 20596 case 'support.illumina.com.cn': 20597 dataRegion = '/apac/zh_CN/support'; 20598 isSupportSite = true; 20599 break; 20600 case 'jp.illumina.com': 20601 dataRegion = '/apac/ja_JP'; 20602 break; 20603 case 'jp.support.illumina.com': 20604 dataRegion = '/apac/ja_JP/support'; 20605 isSupportSite = true; 20606 break; 20607 case 'emea.illumina.com': 20608 dataRegion = '/emea/en_GB'; 20609 break; 20610 case 'emea.support.illumina.com': 20611 dataRegion = '/us/en/support'; 20612 isSupportSite = true; 20613 break; 20614 case 'sapac.illumina.com': 20615 dataRegion = '/spac/en_AU'; 20616 break; 20617 case 'sapac.support.illumina.com': 20618 dataRegion = '/us/en/support'; 20619 isSupportSite = true; 20620 break; 20621 default: 20622 dataRegion = '/en'; 20623 isSupportSite = window.location.href.indexOf('illumina-support') > -1; 20624 } 20625 var props = { 20626 'dataRegion': dataRegion, 20627 'isSupportSite': isSupportSite 20628 }; 20629 return props; 20630 }, 20631 env: function env() { 20632 var aemhost = appHelper.vars.aemhost; 20633 var env = 'localhost'; 20634 Object.entries(appHelper.vars.envs).forEach(function (_ref) { 20635 var _ref2 = (0, _slicedToArray2.default)(_ref, 2), 20636 key = _ref2[0], 20637 value = _ref2[1]; 20638 if (value.includes(aemhost)) { 20639 env = String(key).replace(/([A-Z])/g, function (partialString) { 20640 return "-" + partialString.toLowerCase(); 20641 }); 20642 } 20643 }); 20644 return env; 20645 }, 20646 getURL: function getURL() { 20647 var url = window.location.href, 20648 arr = url.split("/"), 20649 result = arr[0] + "//" + arr[2]; 20650 return result; 20651 }, 20652 guid: function guid() { 20653 function s4() { 20654 return Math.floor((1 + Math.random()) * 0x10000).toString(16).substring(1); 20655 } 20656 return s4() + s4() + '-' + s4() + '-' + s4() + '-' + s4() + '-' + s4() + s4() + s4(); 20657 }, 20658 isIE: function isIE() { 20659 if (browserDetect.browser.indexOf('IE') > -1) { 20660 return true; 20661 } else { 20662 return false; 20663 } 20664 }, 20665 isMobile: function isMobile() { 20666 var mobile = false; 20667 (function (a) { 20668 if (/(android|bb\d+|meego).+mobile|avantgo|bada\/|blackberry|blazer|compal|elaine|fennec|hiptop|iemobile|ip(hone|od)|iris|kindle|lge |maemo|midp|mmp|mobile.+firefox|netfront|opera m(ob|in)i|palm( os)?|phone|p(ixi|re)\/|plucker|pocket|psp|series(4|6)0|symbian|treo|up\.(browser|link)|vodafone|wap|windows ce|xda|xiino|android|ipad|playbook|silk/i.test(a) || /1207|6310|6590|3gso|4thp|50[1-6]i|770s|802s|a wa|abac|ac(er|oo|s\-)|ai(ko|rn)|al(av|ca|co)|amoi|an(ex|ny|yw)|aptu|ar(ch|go)|as(te|us)|attw|au(di|\-m|r |s )|avan|be(ck|ll|nq)|bi(lb|rd)|bl(ac|az)|br(e|v)w|bumb|bw\-(n|u)|c55\/|capi|ccwa|cdm\-|cell|chtm|cldc|cmd\-|co(mp|nd)|craw|da(it|ll|ng)|dbte|dc\-s|devi|dica|dmob|do(c|p)o|ds(12|\-d)|el(49|ai)|em(l2|ul)|er(ic|k0)|esl8|ez([4-7]0|os|wa|ze)|fetc|fly(\-|_)|g1 u|g560|gene|gf\-5|g\-mo|go(\.w|od)|gr(ad|un)|haie|hcit|hd\-(m|p|t)|hei\-|hi(pt|ta)|hp( i|ip)|hs\-c|ht(c(\-| |_|a|g|p|s|t)|tp)|hu(aw|tc)|i\-(20|go|ma)|i230|iac( |\-|\/)|ibro|idea|ig01|ikom|im1k|inno|ipaq|iris|ja(t|v)a|jbro|jemu|jigs|kddi|keji|kgt( |\/)|klon|kpt |kwc\-|kyo(c|k)|le(no|xi)|lg( g|\/(k|l|u)|50|54|\-[a-w])|libw|lynx|m1\-w|m3ga|m50\/|ma(te|ui|xo)|mc(01|21|ca)|m\-cr|me(rc|ri)|mi(o8|oa|ts)|mmef|mo(01|02|bi|de|do|t(\-| |o|v)|zz)|mt(50|p1|v )|mwbp|mywa|n10[0-2]|n20[2-3]|n30(0|2)|n50(0|2|5)|n7(0(0|1)|10)|ne((c|m)\-|on|tf|wf|wg|wt)|nok(6|i)|nzph|o2im|op(ti|wv)|oran|owg1|p800|pan(a|d|t)|pdxg|pg(13|\-([1-8]|c))|phil|pire|pl(ay|uc)|pn\-2|po(ck|rt|se)|prox|psio|pt\-g|qa\-a|qc(07|12|21|32|60|\-[2-7]|i\-)|qtek|r380|r600|raks|rim9|ro(ve|zo)|s55\/|sa(ge|ma|mm|ms|ny|va)|sc(01|h\-|oo|p\-)|sdk\/|se(c(\-|0|1)|47|mc|nd|ri)|sgh\-|shar|sie(\-|m)|sk\-0|sl(45|id)|sm(al|ar|b3|it|t5)|so(ft|ny)|sp(01|h\-|v\-|v )|
20668sy(01|mb)|t2(18|50)|t6(00|10|18)|ta(gt|lk)|tcl\-|tdg\-|tel(i|m)|tim\-|t\-mo|to(pl|sh)|ts(70|m\-|m3|m5)|tx\-9|up(\.b|g1|si)|utst|v400|v750|veri|vi(rg|te)|vk(40|5[0-3]|\-v)|vm40|voda|vulc|vx(52|53|60|61|70|80|81|83|85|98)|w3c(\-| )|webc|whit|wi(g |nc|nw)|wmlb|wonu|x700|yas\-|your|zeto|zte\-/i.test(a.substr(0, 4))) mobile = true; 20669 })(navigator.userAgent || navigator.vendor || window.opera); 20670 return mobile; 20671 }, 20672 vars: { 20673 aemhref: null, 20674 aemhost: null, 20675 envs: { 20676 prodPublish: ['www.illumina.com.cn', 'illumina.com.cn', 'jp.illumina.com', 'sapac.illumina.com', 'emea.illumina.com', 'www.illumina.com', 'support.illumina.com.cn', 'jp.support.illumina.com', 'sapac.support.illumina.com', 'emea.support.illumina.com', 'support.illumina.com'], 20677 prodAuthor: ['prod-author.illumina.com'], 20678 stagePublish: ['www.stg-web.illumina.com'], 20679 stageAuthor: ['stage-author.illumina.com'], 20680 etpTest: ['etp.tst-web.illumina.com'], 20681 etpVal: ['etp.val-web.illumina.com', 'emeaetp.val-web.illumina.com'] 20682 } 20683 } 20684}; 20685appHelper.init(); 20686 20687},{"../../../sniffer/js/browserDetect":38,"@babel/runtime/helpers/interopRequireDefault":3,"@babel/runtime/helpers/slicedToArray":6}],23:[function(require,module,exports){ 20688"use strict"; 20689 20690var appHelper = require('./appHelper'); 20691var $cookie, 20692 cookieManager = window.cookieManager = window.$cookie = module.exports = { 20693 init: function init() { 20694 $cookie = this.vars; 20695 cookieManager.getDomain(); 20696 }, 20697 getCookie: function getCookie(name) { 20698 var value = '; ' + document.cookie; 20699 var parts = value.split('; ' + name + '='); 20700 if (parts.length === 2) return parts.pop().split(';').shift(); 20701 }, 20702 setCookie: function setCookie(name, value, days, domain) { 20703 if (!domain) { 20704 domain = cookieManager.vars.domain; 20705 } 20706 var expires = ''; 20707 if (days) { 20708 var date = new Date(); 20709 date.setTime(date.getTime() + days * 24 * 60 * 60 * 1000); 20710 expires = '; expires=' + date.toUTCString(); 20711 } 20712 document.cookie = name + '=' + (value || '') + expires + '; path=/' + (domain ? ";domain=" + domain : ""); 20713 }, 20714 clearCookie: function clearCookie(name, domain) { 20715 if (!domain) { 20716 domain = cookieManager.vars.domain; 20717 } 20718 if (cookieManager.getCookie(name)) { 20719 document.cookie = name + '=; expires=Thu, 01 Jan 1970 00:00:00 GMT; path=/' + (domain ? ";domain=" + domain : ""); 20720 } 20721 }, 20722 getDomain: function getDomain() { 20723 if (appHelper.region() === 'china') { 20724 cookieManager.vars.domain = '.illumina.com.cn'; 20725 } else if (appHelper.region() === 'sparkgen') { 20726 if (window.location.hostname.indexOf('.illumina.com') > -1) { 20727 cookieManager.vars.domain = '.illumina.com'; // test enviros 20728 } else { 20729 cookieManager.vars.domain = '.sparkgen.com'; // production 20730 } 20731 } else if (appHelper.env() === 'localhost') { 20732 cookieManager.vars.domain = 'localhost'; 20733 } 20734 return cookieManager.vars.domain; 20735 }, 20736 vars: { 20737 domain: '.illumina.com' 20738 } 20739 }; 20740cookieManager.init(); 20741 20742},{"./appHelper":22}],24:[function(require,module,exports){ 20743"use strict"; 20744 20745/** 20746 * This code seeks out all inputs with data-nospace attribute and prevents any instance of whitespace being typed or 20747 * pasted into the input field. Can be used globally. 20748 * @summary Global input element attribute decorator to remove all whitespace on keydown or paste. 20749 * @example <input data-nospace="true" class="form-control" type="text" id="myID" placeholder="no whitespace allowed here"> 20750 */ 20751var formHelper = window.formHelper = { 20752 init: function init() { 20753 var noSpaceInputs = document.querySelectorAll("input[data-nospace]"); 20754 [].concat(this._toConsumableArray(noSpaceInputs)).forEach(function (myinput) { 20755 // trim all white space on paste 20756 myinput.addEventListener('paste', function (e) { 20757 e.preventDefault(); 20758 var withoutSpaces = e.clipboardData.getData('Text'); 20759 withoutSpaces = withoutSpaces.replace(/\s+/g, ''); 20760 myinput.value = withoutSpaces; 20761 var changeEvent = new CustomEvent('change'); 20762 myinput.dispatchEvent(changeEvent); 20763 }); 20764 // trim all white space while typing 20765 myinput.addEventListener('keydown', function (e) { 20766 if (e.keyCode === 32) { 20767 e.preventDefault(); 20768 } 20769 }); 20770 }); 20771 }, 20772 _toConsumableArray: function _toConsumableArray(arr) { 20773 if (Array.isArray(arr)) { 20774 for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { 20775 arr2[i] = arr[i]; 20776 } 20777 return arr2; 20778 } else { 20779 return Array.from(arr); 20780 } 20781 } 20782}; 20783formHelper.init(); 20784 20785},{}],25:[function(require,module,exports){ 20786"use strict"; 20787 20788var throttle = require('lodash.throttle'); 20789var imageSwitcher = window.$dpis = window.imageSwitcher = module.exports = { 20790 init: function init(elm) { 20791 this.vars.elm = elm; 20792 if (elm.length) { 20793 $.each(elm, function () { 20794 imageSwitcher.bannerSwapInit($(this)); 20795 }); 20796 $(window).on('resize', function () { 20797 $.each(elm, function () { 20798 var throttleImageSwitch = throttle(imageSwitcher.bannerSwapInit, 250); 20799 throttleImageSwitch($(this)); 20800 }); 20801 }); 20802 } 20803 }, 20804 bannerSwapInit: function bannerSwapInit(elm) { 20805 $.each(elm, function () { 20806 elm = $(this); 20807 if (imageSwitcher.canSwap(elm)) { 20808 var imgUrlLg = imageSwitcher.getImgUrlLg(elm), 20809 imgUrlSm = imageSwitcher.getImgUrlSm(elm); 20810 imageSwitcher.doResize(elm, imgUrlLg, imgUrlSm); 20811 } 20812 }); 20813 }, 20814 doResize: function doResize(elm, imgLg, imgSm) { 20815 var imgUrl; 20816 if ($(window).width() < imageSwitcher.vars.breakpoint) { 20817 imgUrl = imgSm; 20818 } else { 20819 imgUrl = imgLg; 20820 } 20821 imageSwitcher.updateBgImg(elm, imgUrl); 20822 }, 20823 canSwap: function canSwap(elm) { 20824 return !!(imageSwitcher.getImgUrlLg(elm) && imageSwitcher.getImgUrlSm(elm)); 20825 }, 20826 getImgUrlLg: function getImgUrlLg(elm) { 20827 return elm.attr('data-bg'); 20828 }, 20829 getImgUrlSm: function getImgUrlSm(elm) { 20830 return elm.attr('data-bg-sm'); 20831 }, 20832 updateBgImg: function updateBgImg(elm, imgUrl) { 20833 elm.css('background-image', 'url(' + imgUrl + ')'); 20834 }, 20835 vars: { 20836 elm: null, 20837 breakpoint: 576, 20838 imgUrlLg: null, 20839 imgUrlSm: null 20840 } 20841}; 20842 20843},{"lodash.throttle":13}],26:[function(require,module,exports){ 20844"use strict"; 20845 20846var modalManager = window.modalManager = module.exports = {
20847 init: function init() { 20848 this.loader(); 20849 this.router(); 20850 $(window).on('hidden.bs.modal', function () { 20851 modalManager.vars.modal.find('.modal-content').html(''); 20852 }); 20853 }, 20854 loader: function loader() { 20855 modalManager.vars.modal = $('#modal'); 20856 if (modalManager.vars.modal.length === 0 || !modalManager.vars.modal) { 20857 $(document.body).append('<div id="modal" class="modal fade" tabindex="-1" role="dialog"><div class="modal-dialog modal-dialog-centered" role="document"><div class="modal-content"></div></div></div>'); 20858 modalManager.vars.modal = $('#modal'); 20859 } 20860 modalManager.vars.init = true; 20861 }, 20862 router: function router() { 20863 var bootstrap_enabled = typeof $().emulateTransitionEnd === 'function', 20864 fancybox_enabled = typeof $.fancybox === 'function'; 20865 if (bootstrap_enabled) { 20866 modalManager.vars.type = 'bootstrap'; 20867 } else if (fancybox_enabled) { 20868 modalManager.vars.type = 'fancybox'; 20869 } 20870 }, 20871 trigger: function trigger(type, html, large, options, classes) { 20872 classes = classes ? classes : ''; 20873 options = options ? options : modalManager.vars.options; 20874 large = large ? large : false; 20875 switch (type) { 20876 case 'cookie': 20877 break; 20878 case 'youtube': 20879 break; 20880 case 'image': 20881 break; 20882 case 'form': 20883 break; 20884 default: 20885 break; 20886 } 20887 modalManager.doModal(html, options, large, classes); 20888 }, 20889 doModal: function doModal(html, options, large, classes) { 20890 if (!modalManager.vars.modal) return; 20891 var modalContent = modalManager.vars.modal.find('.modal-content'), 20892 modalDialogue = modalManager.vars.modal.find('.modal-dialog'); 20893 modalContent.html(html); 20894 if (classes) {
20895 modalContent.addClass(classes); 20896 } 20897 var size = large === true ? 'modal-lg' : ''; 20898 if (size) { 20899 modalDialogue.addClass(size); 20900 } 20901 modalManager.show(options); 20902 }, 20903 isActive: function isActive() { 20904 return modalManager.vars.modal.hasClass('in'); 20905 }, 20906 show: function show(options) { 20907 var type = modalManager.vars.type; 20908 if (type === 'bootstrap') { 20909 options['show'] = true; 20910 modalManager.vars.modal.modal(options); 20911 } else if (type === 'fancybox') { 20912 if ($(modalManager.vars.modal).hasClass('fade')) { 20913 $(modalManager.vars.modal).removeClass('fade'); 20914 } 20915 $(modalManager.vars.modal).fancybox(options).trigger('click'); 20916 } 20917 }, 20918 hide: function hide() { 20919 var type = modalManager.vars.type; 20920 if (type === 'bootstrap') { 20921 modalManager.vars.modal.modal('hide'); 20922 } else if (type === 'fancybox') { 20923 $.fancybox.close(); 20924 } 20925 }, 20926 vars: { 20927 init: false, 20928 modal: null, 20929 type: '', 20930 options: { 20931 'backdrop': true, 20932 'keyboard': true, 20933 'focus': true 20934 // 'show': true 20935 } 20936 } 20937}; 20938$(document).ready(function () { 20939 modalManager.init(); 20940}); 20941 20942},{}],27:[function(require,module,exports){ 20943"use strict"; 20944 20945var ui = window.ui = module.exports = { 20946 init: function init() {}, 20947 pageReady: function pageReady() { 20948 ui.imgBleed(); 20949 }, 20950 listeners: function listeners() {}, 20951 debounce: function debounce(func, wait, immediate) { 20952 // Returns a function, that, as long as it continues to be invoked, will not 20953 // be triggered. The function will be called after it stops being called for 20954 // N milliseconds. If `immediate` is passed, trigger the function on the 20955 // leading edge, instead of the trailing. 20956 20957 var timeout; 20958 return function () { 20959 var context = this, 20960 args = arguments; 20961 var later = function later() { 20962 timeout = null; 20963 if (!immediate) func.apply(context, args); 20964 }; 20965 var callNow = immediate && !timeout; 20966 clearTimeout(timeout); 20967 timeout = setTimeout(later, wait); 20968 if (callNow) func.apply(context, args); 20969 }; 20970 }, 20971 throttle: function throttle(func, wait, options) { 20972 // Returns a function, that, when invoked, will only be triggered at most once 20973 // during a given window of time. Normally, the throttled function will run 20974 // as much as it can, without ever going more than once per `wait` duration; 20975 // but if you'd like to disable the execution on the leading edge, pass 20976 // `{leading: false}`. To disable execution on the trailing edge, ditto. 20977 var context, args, result; 20978 var timeout = null; 20979 var previous = 0; 20980 if (!options) options = {}; 20981 var later = function later() { 20982 previous = options.leading === false ? 0 : Date.now(); 20983 timeout = null; 20984 result = func.apply(context, args); 20985 if (!timeout) context = args = null; 20986 }; 20987 return function () { 20988 var now = Date.now(); 20989 if (!previous && options.leading === false) previous = now; 20990 var remaining = wait - (now - previous); 20991 context = this; 20992 args = arguments; 20993 if (remaining <= 0 || remaining > wait) { 20994 if (timeout) { 20995 clearTimeout(timeout); 20996 timeout = null; 20997 } 20998 previous = now; 20999 result = func.apply(context, args); 21000 if (!timeout) context = args = null; 21001 } else if (!timeout && options.trailing !== false) { 21002 timeout = setTimeout(later, remaining); 21003 } 21004 return result; 21005 }; 21006 }, 21007 imgBleed: function imgBleed() { 21008 var $img = $('[class*="img-bleed"]'); 21009 function setImgSize() { 21010 $img.each(function () { 21011 var sibling = ui.sibling($(this), '[class*="col-"]'); 21012 if (sibling.exists === true) { 21013 if ($(window).width() > 767) { 21014 $(this).css('width', 'calc(100vw - ' + sibling.width + 'px)'); 21015 } else { 21016 $(this).css('width', ''); 21017 } 21018 } 21019 }); 21020 } 21021 var resizeAgain = ui.debounce(function () { 21022 setImgSize(); 21023 }, 250); 21024 setImgSize(); 21025 window.addEventListener('resize', resizeAgain); 21026 }, 21027 sibling: function sibling(elm, attr) { 21028 var $parent = elm.closest(attr); 21029 var exists = false;
21030 if (!$parent) return; 21031 var width = $(window).width() - $parent.outerWidth(); 21032 var $siblings = $parent.siblings(attr); 21033 if ($siblings) { 21034 exists = true; 21035 width = $($siblings).outerWidth(); 21036 } 21037 var properties = { 21038 exists: exists, 21039 width: width, 21040 parentWidth: $parent.outerWidth() 21041 }; 21042 return properties; 21043 }, 21044 smoothScroll: function smoothScroll(elm, timing, buffer, callback) { 21045 callback = typeof callback !== 'undefined' ? callback : function () {}; 21046 buffer = typeof buffer !== 'undefined' ? buffer : 25; 21047 var offset = elm.offset().top - buffer + 'px'; 21048 $('html, body').animate({ 21049 scrollTop: offset 21050 }, timing); 21051 setTimeout(callback, timing); 21052 }, 21053 loggedInText: function loggedInText(attr) { 21054 var elm = $('[' + attr + ']'); 21055 if (elm.length) { 21056 elm.each(function () { 21057 var loggedInText = $(this).attr(attr); 21058 $(this).text(loggedInText); 21059 }); 21060 } 21061 }, 21062 vars: {} 21063}; 21064$(document).ready(function () { 21065 ui.init(); 21066 if (typeof ecommerce !== "undefined") { 21067 if (ecommerce.isLoggedIn) { 21068 ui.loggedInText('data-loggedin-text'); 21069 } 21070 } 21071 $(window).on('load', function () { 21072 //ui.loader(); 21073 }); 21074}); 21075 21076},{}],28:[function(require,module,exports){ 21077"use strict"; 21078 21079// DEPENDENCIES 21080window.jQuery = window.$ = require('jquery'); 21081jQuery.migrateMute = true; 21082require('jquery-migrate'); 21083require('popper.js'); 21084require('bootstrap'); 21085require('./fontawesome'); 21086require('./jquery.cookie'); 21087require('./marketo-forms'); 21088 21089// ENABLE TOUCH EVENTS FOR MOBILE DEVICES (USAGE: https://www.npmjs.com/package/jquery-touch-events || https://github.com/benmajor/jQuery-Touch-Events) 21090var loadTouchEvents = require('jquery-touch-events'); 21091loadTouchEvents($); 21092 21093// VENDOR 21094require('./vendor/modernizr-custom'); 21095require('./vendor/picturefill'); 21096 21097// HELPERS 21098var appHelper = require('./helpers/appHelper'); 21099var modalManager = require('./helpers/modalManager'); 21100require('./helpers/uiHelper'); 21101require('./helpers/cookieManager'); 21102var imageSwitcher = require('./helpers/image-switcher'); 21103 21104// UI patterns 21105var scrollToAnchor = require('./modules/scrollToAnchor'); 21106 21107// BASE 21108require('./base/banners'); 21109require('./base/page-structure'); 21110require('./base/print-override'); 21111 21112// CSS 21113require('./css/forms'); 21114 21115// LONE RANGERS 21116require('./collapse'); 21117require('./counter'); 21118require('./modal'); 21119require('./helpers/formHelper'); 21120require('./smoothscroll'); 21121require('./navs'); 21122require('./training-embed'); 21123 21124// Initialise UI helpers 21125scrollToAnchor.init(); 21126$(document).ready(function () { 21127 imageSwitcher.init($('.banner-image')); 21128}); 21129 21130},{"./base/banners":15,"./base/page-structure":16,"./base/print-override":17,"./collapse":18,"./counter":19,"./css/forms":20,"./fontawesome":21,"./helpers/appHelper":22,"./helpers/cookieManager":23,"./helpers/formHelper":24,"./helpers/image-switcher":25,"./helpers/modalManager":26,"./helpers/uiHelper":27,"./jquery.cookie":29,"./marketo-forms":30,"./modal":31,"./modules/scrollToAnchor":32,"./navs":33,"./smoothscroll":34,"./training-embed":35,"./vendor/modernizr-custom":36,"./vendor/picturefill":37,"bootstrap":9,"jquery":12,"jquery-migrate":10,"jquery-touch-events":11,"popper.js":14}],29:[function(require,module,exports){ 21131"use strict"; 21132 21133var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault"); 21134var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof")); 21135/*! 21136 * jQuery Cookie Plugin v1.4.1 21137 * https://github.com/carhartl/jquery-cookie 21138 * 21139 * Copyright 2013 Klaus Hartl 21140 * Released under the MIT license 21141 */ 21142(function (factory) { 21143 if (typeof define === 'function' && define.amd) { 21144 // AMD 21145 define(['jquery'], factory); 21146 } else if ((typeof exports === "undefined" ? "undefined" : (0, _typeof2.default)(exports)) === 'object') { 21147 // CommonJS 21148 factory(require('jquery')); 21149 } else { 21150 // Browser globals 21151 factory(jQuery); 21152 } 21153})(function ($) { 21154 var pluses = /\+/g; 21155 function encode(s) { 21156 return config.raw ? s : encodeURIComponent(s); 21157 } 21158 function decode(s) { 21159 return config.raw ? s : decodeURIComponent(s); 21160 } 21161 function stringifyCookieValue(value) { 21162 return encode(config.json ? JSON.stringify(value) : String(value)); 21163 } 21164 function parseCookieValue(s) { 21165 if (s.indexOf('"') === 0) { 21166 // This is a quoted cookie as according to RFC2068, unescape... 21167 s = s.slice(1, -1).replace(/\\"/g, '"').replace(/\\\\/g, '\\'); 21168 } 21169 try { 21170 // Replace server-side written pluses with spaces. 21171 // If we can't decode the cookie, ignore it, it's unusable. 21172 // If we can't parse the cookie, ignore it, it's unusable. 21173 s = decodeURIComponent(s.replace(pluses, ' ')); 21174 return config.json ? JSON.parse(s) : s; 21175 } catch (e) {} 21176 } 21177 function read(s, converter) { 21178 var value = config.raw ? s : parseCookieValue(s); 21179 return $.isFunction(converter) ? converter(value) : value; 21180 } 21181 var config = $.cookie = function (key, value, options) { 21182 // Write 21183 21184 if (value !== undefined && !$.isFunction(value)) { 21185 options = $.extend({}, config.defaults, options); 21186 if (typeof options.expires === 'number') { 21187 var days = options.expires, 21188 t = options.expires = new Date(); 21189 t.setTime(+t + days * 864e+5); 21190 } 21191 return document.cookie = [encode(key), '=', stringifyCookieValue(value), options.expires ? '; expires=' + options.expires.toUTCString() : '', 21192 // use expires attribute, max-age is not supported by IE 21193 options.path ? '; path=' + options.path : '', options.domain ? '; domain=' + options.domain : '', options.secure ? '; secure' : ''].join(''); 21194 } 21195 21196 // Read 21197 21198 var result = key ? undefined : {}; 21199 21200 // To prevent the for loop in the first place assign an empty array 21201 // in case there are no cookies at all. Also prevents odd result when 21202 // calling $.cookie(). 21203 var cookies = document.cookie ? document.cookie.split('; ') : []; 21204 for (var i = 0, l = cookies.length; i < l; i++) { 21205 var parts = cookies[i].split('='); 21206 var name = decode(parts.shift()); 21207 var cookie = parts.join('='); 21208 if (key && key === name) { 21209 // If second argument (value) is a function it's a converter... 21210 result = read(cookie, value); 21211 break; 21212 } 21213 21214 // Prevent storing a cookie that we couldn't decode. 21215 if (!key && (cookie = read(cookie)) !== undefined) { 21216 result[name] = cookie; 21217 } 21218 } 21219 return result; 21220 }; 21221 config.defaults = {}; 21222 $.removeCookie = function (key, options) { 21223 if ($.cookie(key) === undefined) { 21224 return false;
21225 } 21226 21227 // Must not alter options, thus extending a fresh object... 21228 $.cookie(key, '', $.extend({}, options, { 21229 expires: -1 21230 })); 21231 return !$.cookie(key); 21232 }; 21233}); 21234 21235},{"@babel/runtime/helpers/interopRequireDefault":3,"@babel/runtime/helpers/typeof":7,"jquery":12}],30:[function(require,module,exports){ 21236"use strict"; 21237 21238/* Soft-gate Modal Forms */ 21239var softgateArray = ["landing/miniseq-spec-sheet-soft-gate-form"]; 21240for (var i = 0; i < softgateArray.length; i++) { 21241 var urlEqualTo = window.location.href.indexOf(softgateArray[i]); 21242 if (urlEqualTo > -1) { 21243 $('.responsiveMarketoForm').hide(); 21244 $('iframe').appendTo('.iframe-holder'); 21245 } 21246} 21247/* Soft-gate Modal Forms */ 21248 21249//Function to write cookie for gated forms 21250var setCookieILMNGatedForm = function setCookieILMNGatedForm(formURL) { 21251 //Write a page level cookie by specifying the page path so that the same cookie can be used for different forms as long as there is only one Gated form on the page. 21252 $.cookie('ILMNGatedForm', formURL, { 21253 expires: 1, 21254 path: window.location.pathname 21255 }); 21256}; 21257 21258},{}],31:[function(require,module,exports){ 21259"use strict"; 21260 21261$('.modal').on('hidden.bs.modal', function (e) { 21262 resetIframes($(this)); 21263}); 21264$('.modal.carousel').on('slid.bs.carousel', function () { 21265 var prev = $(this).find('.active').prev(); 21266 var next = $(this).find('.active').next(); 21267 resetIframes(prev); 21268 resetIframes(next); 21269}); 21270function resetIframes(elem) { 21271 elem.find('iframe').each(function () { 21272 var embedSrc = $(this).attr('src'); 21273 $(this).attr('src', ''); 21274 $(this).attr('src', embedSrc); 21275 if (embedSrc.indexOf('gated=') > -1) { 21276 $(this).parent().removeClass('embed-container'); 21277 } 21278 }); 21279} 21280 21281// adding modalLink class for tracking 21282if (!$('a.btn-icon-video').hasClass('modalLink')) { 21283 $(void 0).addClass('modalLink'); 21284} 21285 21286},{}],32:[function(require,module,exports){ 21287"use strict"; 21288 21289var scrollToAnchor = module.exports = { 21290 init: function init() { 21291 if (location.hash && location.hash !== '') { 21292 var hash = location.hash; 21293 this.vars.hash = hash.replace('#', ''); 21294 window.addEventListener('load', function () { 21295 scrollToAnchor.pageReady(); 21296 }); 21297 } 21298 }, 21299 pageReady: function pageReady() { 21300 var elm = $('[' + scrollToAnchor.vars.anchor + '="' + scrollToAnchor.vars.hash + '"]'); 21301 if (elm.length) { 21302 scrollToAnchor.vars.elm = elm; 21303 if (!elm.attr(scrollToAnchor.vars.anchorOffset)) { 21304 scrollToAnchor.checkHeaderProperties(elm); 21305 } 21306 var getOffset = new Promise(function (resolve, reject) { 21307 scrollToAnchor.getOffset(); 21308 if (scrollToAnchor.getOffset()) { 21309 resolve(); 21310 } else { 21311 reject(); 21312 } 21313 }); 21314 getOffset.then(function () { 21315 try { 21316 scrollToAnchor.scrollInit(); 21317 } catch (err) { 21318 console.log(err); 21319 } 21320 }).catch(function (err) { 21321 // can't get offset 21322 }); 21323 } 21324 }, 21325 getUrlVars: function getUrlVars() { 21326 var vars = {}; 21327 var parts = window.location.href.replace(/[?&]+([^=&]+)=([^&]*)/gi, function (m, key, value) { 21328 vars[key] = value; 21329 }); 21330 return vars; 21331 }, 21332 getOffset: function getOffset() { 21333 if (!scrollToAnchor.vars.elm) { 21334 return; 21335 } 21336 var offset = scrollToAnchor.vars.elm.attr(scrollToAnchor.vars.anchorOffset); 21337 if (offset) { 21338 scrollToAnchor.vars.offsetValue = offset; 21339 } 21340 return scrollToAnchor.vars.offsetValue; 21341 }, 21342 checkHeaderProperties: function checkHeaderProperties(elm) { 21343 $.each(scrollToAnchor.vars.headerProperties, function (key, value) { 21344 if ($(key).length) { 21345 elm.addClass(value); 21346 } 21347 }); 21348 }, 21349 scrollInit: function scrollInit() { 21350 $('html, body').animate({ 21351 scrollTop: scrollToAnchor.vars.elm.offset().top - scrollToAnchor.vars.offsetValue 21352 }, 1500, function () { 21353 if (!scrollToAnchor.vars.elm.is(':focus')) { 21354 scrollToAnchor.vars.elm.attr('tabindex', '-1').focus(); 21355 } 21356 }); 21357 return false; 21358 }, 21359 vars: { 21360 hash: null, 21361 elm: null, 21362 anchor: 'data-anchor', 21363 anchorOffset: 'data-anchor-offset', 21364 offsetValue: 0, 21365 //megamenu is 88px tall, collapsed, with the stickynav. 88 + 10px (padding) = 98 21366 headerProperties: { 21367 '.global-nav__header': 'anchor-globalnav', 21368 '.stickynav': 'anchor-stickynav', 21369 '.persistent-nav': 'anchor-persistentnav' 21370 } 21371 } 21372}; 21373 21374},{}],33:[function(require,module,exports){ 21375"use strict"; 21376 21377var navSelects = $('.nav-select'); 21378navSelects.on('change', function (ev) { 21379 ev.preventDefault(); 21380 var target = ev.target.value; 21381 $(target).tab('show'); 21382}); 21383 21384},{}],34:[function(require,module,exports){ 21385"use strict"; 21386 21387$(document).ready(function () { 21388 // Select all links with hashes 21389 $('a.scroll-to').click(function (event) { 21390 // On-page links
21391 if (location.pathname.replace(/^\//, '') == this.pathname.replace(/^\//, '') && location.hostname == this.hostname) { 21392 // Figure out element to scroll to 21393 var target = $(this.hash); 21394 target = target.length ? target : $('[name=' + this.hash.slice(1) + ']'); 21395 // Does a scroll target exist? 21396 if (target.length) { 21397 $('html, body').animate({ 21398 scrollTop: target.offset().top - 85 21399 }, 1000); 21400 target.on('focus', function (e) { 21401 e.preventDefault(); 21402 }); 21403 target.focus(); // Setting focus 21404 if (target.is(":focus")) { 21405 // Checking if the target was focused 21406 return false; 21407 } else { 21408 target.attr('tabindex', '-1'); // Adding tabindex for elements not focusable 21409 target.focus(); // Setting focus 21410 } 21411 return false; 21412 } 21413 } 21414 }); 21415}); 21416 21417},{}],35:[function(require,module,exports){ 21418"use strict"; 21419 21420function init() { 21421 var iframesOnPage = document.querySelectorAll('iframe'); 21422 var hasTrainingIframe = Array.from(iframesOnPage).some(function (iframe) { 21423 if (iframe.src.includes('illumina-support/trainings')) { 21424 iframe.classList.add('training-embed'); 21425 return true; 21426 } 21427 return false; 21428 }); 21429 if (!hasTrainingIframe) return; 21430 function handleTrainingIframeMessage(event) { 21431 var message = event === null || event === void 0 ? void 0 : event.data; 21432 var isTrainingEmbed = (message === null || message === void 0 ? void 0 : message.type) === 'trainingEmbedResize'; 21433 var frameId = message !== null && message !== void 0 && message.frameId ? decodeURIComponent(message.frameId) : null; 21434 if (!isTrainingEmbed || !frameId) return; 21435 var iFrames = document.querySelectorAll('iframe'); 21436 iFrames.forEach(function (frame) { 21437 var frameSrc = frame.src ? decodeURIComponent(frame.src) : null; 21438 var newHeight = message.height; 21439 var isTargetFrame = (frameSrc === null || frameSrc === void 0 ? void 0 : frameSrc.includes(frameId)) || (frameId === null || frameId === void 0 ? void 0 : frameId.includes(frameSrc)); 21440 if (!frameSrc || !isTargetFrame || !newHeight) return; 21441 var ilmnOrigin = document.location.origin; 21442 frame.contentWindow.postMessage({ 21443 'action': 'trainingEmbedResizeDestroy', 21444 'frameUrl': frame.src, 21445 'parentUrl': window.location.href 21446 }, ilmnOrigin); 21447 frame.style.height = "".concat(newHeight, "px"); 21448 }); 21449 } 21450 window.addEventListener('message', handleTrainingIframeMessage, false); 21451} 21452init(); 21453 21454},{}],36:[function(require,module,exports){ 21455"use strict"; 21456 21457var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault"); 21458var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof")); 21459/*! modernizr 3.5.0 (Custom Build) | MIT * 21460 * https://modernizr.com/download/?-backgroundsize-canvas-csscalc-csscolumns-cssgradients-cssremunit-csstransforms-csstransitions-cssvhunit-cssvwunit-flexbox-flexboxlegacy-inlinesvg-multiplebgs-svg-svgasimg-touchevents-video-setclasses-shiv !*/ 21461!function (e, t, n) { 21462 function r(e, t) { 21463 return (0, _typeof2.default)(e) === t; 21464 } 21465 function o() { 21466 var e, t, n, o, a, i, s; 21467 for (var l in T) if (T.hasOwnProperty(l)) { 21468 if (e = [], t = T[l], t.name && (e.push(t.name.toLowerCase()), t.options && t.options.aliases && t.options.aliases.length)) for (n = 0; n < t.options.aliases.length; n++) e.push(t.options.aliases[n].toLowerCase()); 21469 for (o = r(t.fn, "function") ? t.fn() : t.fn, a = 0; a < e.length; a++) i = e[a], s = i.split("."), 1 === s.length ? Modernizr[s[0]] = o : (!Modernizr[s[0]] || Modernizr[s[0]] instanceof Boolean || (Modernizr[s[0]] = new Boolean(Modernizr[s[0]])), Modernizr[s[0]][s[1]] = o), b.push((o ? "" : "no-") + s.join("-")); 21470 } 21471 } 21472 function a(e) { 21473 var t = S.className, 21474 n = Modernizr._config.classPrefix || ""; 21475 if (x && (t = t.baseVal), Modernizr._config.enableJSClass) { 21476 var r = new RegExp("(^|\\s)" + n + "no-js(\\s|$)"); 21477 t = t.replace(r, "$1" + n + "js$2"); 21478 } 21479 Modernizr._config.enableClasses && (t += " " + n + e.join(" " + n), x ? S.className.baseVal = t : S.className = t); 21480 } 21481 function i() { 21482 return "function" != typeof t.createElement ? t.createElement(arguments[0]) : x ? t.createElementNS.call(t, "http://www.w3.org/2000/svg", arguments[0]) : t.createElement.apply(t, arguments); 21483 } 21484 function s(t, n, r) { 21485 var o; 21486 if ("getComputedStyle" in e) { 21487 o = getComputedStyle.call(e, t, n); 21488 var a = e.console; 21489 if (null !== o) r && (o = o.getPropertyValue(r));else if (a) { 21490 var i = a.error ? "error" : "log"; 21491 a[i].call(a, "getComputedStyle returning null, its possible modernizr test results are inaccurate"); 21492 } 21493 } else o = !n && t.currentStyle && t.currentStyle[r]; 21494 return o; 21495 } 21496 function l(e, t) { 21497 if ("object" == (0, _typeof2.default)(e)) for (var n in e) _(e, n) && l(n, e[n]);else { 21498 e = e.toLowerCase(); 21499 var r = e.split("."), 21500 o = Modernizr[r[0]]; 21501 if (2 == r.length && (o = o[r[1]]), "undefined" != typeof o) return Modernizr; 21502 t = "function" == typeof t ? t() : t, 1 == r.length ? Modernizr[r[0]] = t : (!Modernizr[r[0]] || Modernizr[r[0]] instanceof Boolean || (Modernizr[r[0]] = new Boolean(Modernizr[r[0]])), Modernizr[r[0]][r[1]] = t), a([(t && 0 != t ? "" : "no-") + r.join("-")]), Modernizr._trigger(e, t); 21503 } 21504 return Modernizr; 21505 } 21506 function c() { 21507 var e = t.body; 21508 return e || (e = i(x ? "svg" : "body"), e.fake = !0), e; 21509 } 21510 function u(e, n, r, o) { 21511 var a, 21512 s, 21513 l, 21514 u, 21515 d = "modernizr", 21516 f = i("div"), 21517 p = c(); 21518 if (parseInt(r, 10)) for (; r--;) l = i("div"), l.id = o ? o[r] : d + (r + 1), f.appendChild(l); 21519 return a = i("style"), a.type = "text/css", a.id = "s" + d, (p.fake ? p : f).appendChild(a), p.appendChild(f), a.styleSheet ? a.styleSheet.cssText = e : a.appendChild(t.createTextNode(e)), f.id = d, p.fake && (p.style.background = "", p.style.overflow = "hidden", u = S.style.overflow, S.style.overflow = "hidden", S.appendChild(p)), s = n(f, e), p.fake ? (p.parentNode.removeChild(p), S.style.overflow = u, S.offsetHeight) : f.parentNode.removeChild(f), !!s; 21520 } 21521 function d(e, t) {
21522 return !!~("" + e).indexOf(t); 21523 } 21524 function f(e) { 21525 return e.replace(/([a-z])-([a-z])/g, function (e, t, n) { 21526 return t + n.toUpperCase(); 21527 }).replace(/^-/, ""); 21528 } 21529 function p(e, t) { 21530 return function () { 21531 return e.apply(t, arguments); 21532 }; 21533 } 21534 function m(e, t, n) { 21535 var o; 21536 for (var a in e) if (e[a] in t) return n === !1 ? e[a] : (o = t[e[a]], r(o, "function") ? p(o, n || t) : o); 21537 return !1; 21538 } 21539 function h(e) { 21540 return e.replace(/([A-Z])/g, function (e, t) { 21541 return "-" + t.toLowerCase(); 21542 }).replace(/^ms-/, "-ms-"); 21543 } 21544 function g(t, r) { 21545 var o = t.length; 21546 if ("CSS" in e && "supports" in e.CSS) { 21547 for (; o--;) if (e.CSS.supports(h(t[o]), r)) return !0; 21548 return !1; 21549 } 21550 if ("CSSSupportsRule" in e) { 21551 for (var a = []; o--;) a.push("(" + h(t[o]) + ":" + r + ")"); 21552 return a = a.join(" or "), u("@supports (" + a + ") { #modernizr { position: absolute; } }", function (e) { 21553 return "absolute" == s(e, null, "position"); 21554 }); 21555 } 21556 return n; 21557 } 21558 function v(e, t, o, a) { 21559 function s() { 21560 c && (delete B.style, delete B.modElem); 21561 } 21562 if (a = r(a, "undefined") ? !1 : a, !r(o, "undefined")) { 21563 var l = g(e, o); 21564 if (!r(l, "undefined")) return l; 21565 } 21566 for (var c, u, p, m, h, v = ["modernizr", "tspan", "samp"]; !B.style && v.length;) c = !0, B.modElem = i(v.shift()), B.style = B.modElem.style; 21567 for (p = e.length, u = 0; p > u; u++) if (m = e[u], h = B.style[m], d(m, "-") && (m = f(m)), B.style[m] !== n) { 21568 if (a || r(o, "undefined")) return s(), "pfx" == t ? m : !0; 21569 try { 21570 B.style[m] = o; 21571 } catch (y) {} 21572 if (B.style[m] != h) return s(), "pfx" == t ? m : !0; 21573 } 21574 return s(), !1; 21575 } 21576 function y(e, t, n, o, a) { 21577 var i = e.charAt(0).toUpperCase() + e.slice(1), 21578 s = (e + " " + P.join(i + " ") + i).split(" "); 21579 return r(t, "string") || r(t, "undefined") ? v(s, t, o, a) : (s = (e + " " + N.join(i + " ") + i).split(" "), m(s, t, n)); 21580 } 21581 function w(e, t, r) { 21582 return y(e, n, n, t, r); 21583 } 21584 var b = [], 21585 T = [], 21586 C = { 21587 _version: "3.5.0", 21588 _config: { 21589 classPrefix: "", 21590 enableClasses: !0, 21591 enableJSClass: !0, 21592 usePrefixes: !0 21593 }, 21594 _q: [], 21595 on: function on(e, t) { 21596 var n = this; 21597 setTimeout(function () { 21598 t(n[e]); 21599 }, 0); 21600 }, 21601 addTest: function addTest(e, t, n) { 21602 T.push({ 21603 name: e, 21604 fn: t, 21605 options: n 21606 }); 21607 }, 21608 addAsyncTest: function addAsyncTest(e) { 21609 T.push({ 21610 name: null, 21611 fn: e 21612 }); 21613 } 21614 }, 21615 Modernizr = function Modernizr() {}; 21616 Modernizr.prototype = C, Modernizr = new Modernizr(), Modernizr.addTest("svg", !!t.createElementNS && !!t.createElementNS("http://www.w3.org/2000/svg", "svg").createSVGRect); 21617 var S = t.documentElement, 21618 x = "svg" === S.nodeName.toLowerCase(); 21619 x || !function (e, t) { 21620 function n(e, t) { 21621 var n = e.createElement("p"), 21622 r = e.getElementsByTagName("head")[0] || e.documentElement; 21623 return n.innerHTML = "x<style>" + t + "</style>", r.insertBefore(n.lastChild, r.firstChild); 21624 } 21625 function r() { 21626 var e = w.elements; 21627 return "string" == typeof e ? e.split(" ") : e; 21628 } 21629 function o(e, t) { 21630 var n = w.elements; 21631 "string" != typeof n && (n = n.join(" ")), "string" != typeof e && (e = e.join(" ")), w.elements = n + " " + e, c(t); 21632 } 21633 function a(e) { 21634 var t = y[e[g]]; 21635 return t || (t = {}, v++, e[g] = v, y[v] = t), t; 21636 } 21637 function i(e, n, r) { 21638 if (n || (n = t), d) return n.createElement(e); 21639 r || (r = a(n)); 21640 var o; 21641 return o = r.cache[e] ? r.cache[e].cloneNode() : h.test(e) ? (r.cache[e] = r.createElem(e)).cloneNode() : r.createElem(e), !o.canHaveChildren || m.test(e) || o.tagUrn ? o : r.frag.appendChild(o); 21642 } 21643 function s(e, n) { 21644 if (e || (e = t), d) return e.createDocumentFragment(); 21645 n = n || a(e); 21646 for (var o = n.frag.cloneNode(), i = 0, s = r(), l = s.length; l > i; i++) o.createElement(s[i]); 21647 return o; 21648 } 21649 function l(e, t) {
21650 t.cache || (t.cache = {}, t.createElem = e.createElement, t.createFrag = e.createDocumentFragment, t.frag = t.createFrag()), e.createElement = function (n) { 21651 return w.shivMethods ? i(n, e, t) : t.createElem(n); 21652 }, e.createDocumentFragment = Function("h,f", "return function(){var n=f.cloneNode(),c=n.createElement;h.shivMethods&&(" + r().join().replace(/[\w\-:]+/g, function (e) { 21653 return t.createElem(e), t.frag.createElement(e), 'c("' + e + '")'; 21654 }) + ");return n}")(w, t.frag); 21655 } 21656 function c(e) { 21657 e || (e = t); 21658 var r = a(e); 21659 return !w.shivCSS || u || r.hasCSS || (r.hasCSS = !!n(e, "article,aside,dialog,figcaption,figure,footer,header,hgroup,main,nav,section{display:block}mark{background:#FF0;color:#000}template{display:none}")), d || l(e, r), e; 21660 } 21661 var u, 21662 d, 21663 f = "3.7.3", 21664 p = e.html5 || {}, 21665 m = /^<|^(?:button|map|select|textarea|object|iframe|option|optgroup)$/i, 21666 h = /^(?:a|b|code|div|fieldset|h1|h2|h3|h4|h5|h6|i|label|li|ol|p|q|span|strong|style|table|tbody|td|th|tr|ul)$/i, 21667 g = "_html5shiv", 21668 v = 0, 21669 y = {}; 21670 !function () { 21671 try { 21672 var e = t.createElement("a"); 21673 e.innerHTML = "<xyz></xyz>", u = "hidden" in e, d = 1 == e.childNodes.length || function () { 21674 t.createElement("a"); 21675 var e = t.createDocumentFragment(); 21676 return "undefined" == typeof e.cloneNode || "undefined" == typeof e.createDocumentFragment || "undefined" == typeof e.createElement; 21677 }(); 21678 } catch (n) { 21679 u = !0, d = !0; 21680 } 21681 }(); 21682 var w = { 21683 elements: p.elements || "abbr article aside audio bdi canvas data datalist details dialog figcaption figure footer header hgroup main mark meter nav output picture progress section summary template time video", 21684 version: f, 21685 shivCSS: p.shivCSS !== !1, 21686 supportsUnknownElements: d, 21687 shivMethods: p.shivMethods !== !1, 21688 type: "default", 21689 shivDocument: c, 21690 createElement: i, 21691 createDocumentFragment: s, 21692 addElements: o 21693 }; 21694 e.html5 = w, c(t), "object" == (typeof module === "undefined" ? "undefined" : (0, _typeof2.default)(module)) && module.exports && (module.exports = w); 21695 }("undefined" != typeof e ? e : this, t), Modernizr.addTest("canvas", function () { 21696 var e = i("canvas"); 21697 return !(!e.getContext || !e.getContext("2d")); 21698 }), Modernizr.addTest("video", function () { 21699 var e = i("video"), 21700 t = !1; 21701 try { 21702 t = !!e.canPlayType, t && (t = new Boolean(t), t.ogg = e.canPlayType('video/ogg; codecs="theora"').replace(/^no$/, ""), t.h264 = e.canPlayType('video/mp4; codecs="avc1.42E01E"').replace(/^no$/, ""), t.webm = e.canPlayType('video/webm; codecs="vp8, vorbis"').replace(/^no$/, ""), t.vp9 = e.canPlayType('video/webm; codecs="vp9"').replace(/^no$/, ""), t.hls = e.canPlayType('application/x-mpegURL; codecs="avc1.42E01E"').replace(/^no$/, "")); 21703 } catch (n) {} 21704 return t; 21705 }), Modernizr.addTest("multiplebgs", function () { 21706 var e = i("a").style; 21707 return e.cssText = "background:url(https://),url(https://),red url(https://)", /(url\s*\(.*?){3}/.test(e.background); 21708 }), Modernizr.addTest("inlinesvg", function () { 21709 var e = i("div"); 21710 return e.innerHTML = "<svg/>", "http://www.w3.org/2000/svg" == ("undefined" != typeof SVGRect && e.firstChild && e.firstChild.namespaceURI); 21711 }); 21712 var E = C._config.usePrefixes ? " -webkit- -moz- -o- -ms- ".split(" ") : ["", ""]; 21713 C._prefixes = E, Modernizr.addTest("csscalc", function () { 21714 var e = "width:", 21715 t = "calc(10px);", 21716 n = i("a"); 21717 return n.style.cssText = e + E.join(t + e), !!n.style.length; 21718 }), Modernizr.addTest("cssgradients", function () { 21719 for (var e, t = "background-image:", n = "gradient(linear,left top,right bottom,from(#9f9),to(white));", r = "", o = 0, a = E.length - 1; a > o; o++) e = 0 === o ? "to " : "", r += t + E[o] + "linear-gradient(" + e + "left top, #9f9, white);"; 21720 Modernizr._config.usePrefixes && (r += t + "-webkit-" + n); 21721 var s = i("a"), 21722 l = s.style; 21723 return l.cssText = r, ("" + l.backgroundImage).indexOf("gradient") > -1; 21724 }); 21725 var _; 21726 !function () { 21727 var e = {}.hasOwnProperty; 21728 _ = r(e, "undefined") || r(e.call, "undefined") ? function (e, t) { 21729 return t in e && r(e.constructor.prototype[t], "undefined"); 21730 } : function (t, n) { 21731 return e.call(t, n); 21732 }; 21733 }(), C._l = {}, C.on = function (e, t) { 21734 this._l[e] || (this._l[e] = []), this._l[e].push(t), Modernizr.hasOwnProperty(e) && setTimeout(function () { 21735 Modernizr._trigger(e, Modernizr[e]); 21736 }, 0); 21737 }, C._trigger = function (e, t) { 21738 if (this._l[e]) { 21739 var n = this._l[e]; 21740 setTimeout(function () { 21741 var e, r; 21742 for (e = 0; e < n.length; e++) (r = n[e])(t); 21743 }, 0), delete this._l[e]; 21744 } 21745 }, Modernizr._q.push(function () { 21746 C.addTest = l; 21747 }), Modernizr.addTest("svgasimg", t.implementation.hasFeature("http://www.w3.org/TR/SVG11/feature#Image", "1.1")); 21748 var k = C.testStyles = u; 21749 Modernizr.addTest("touchevents", function () { 21750 var n; 21751 if ("ontouchstart" in e || e.DocumentTouch && t instanceof DocumentTouch) n = !0;else { 21752 var r = ["@media (", E.join("touch-enabled),("), "heartz", ")", "{#modernizr{top:9px;position:absolute}}"].join(""); 21753 k(r, function (e) { 21754 n = 9 === e.offsetTop; 21755 }); 21756 } 21757 return n; 21758 }), k("#modernizr { height: 50vh; }", function (t) {
21759 var n = parseInt(e.innerHeight / 2, 10), 21760 r = parseInt(s(t, null, "height"), 10); 21761 Modernizr.addTest("cssvhunit", r == n); 21762 }), k("#modernizr { width: 50vw; }", function (t) { 21763 var n = parseInt(e.innerWidth / 2, 10), 21764 r = parseInt(s(t, null, "width"), 10); 21765 Modernizr.addTest("cssvwunit", r == n); 21766 }); 21767 var z = "Moz O ms Webkit", 21768 P = C._config.usePrefixes ? z.split(" ") : []; 21769 C._cssomPrefixes = P; 21770 var N = C._config.usePrefixes ? z.toLowerCase().split(" ") : []; 21771 C._domPrefixes = N; 21772 var j = { 21773 elem: i("modernizr") 21774 }; 21775 Modernizr._q.push(function () { 21776 delete j.elem; 21777 }); 21778 var B = { 21779 style: j.elem.style 21780 }; 21781 Modernizr._q.unshift(function () { 21782 delete B.style; 21783 }), C.testAllProps = y, C.testAllProps = w, Modernizr.addTest("backgroundsize", w("backgroundSize", "100%", !0)), function () { 21784 Modernizr.addTest("csscolumns", function () { 21785 var e = !1, 21786 t = w("columnCount"); 21787 try { 21788 e = !!t, e && (e = new Boolean(e)); 21789 } catch (n) {} 21790 return e; 21791 });
21792 for (var e, t, n = ["Width", "Span", "Fill", "Gap", "Rule", "RuleColor", "RuleStyle", "RuleWidth", "BreakBefore", "BreakAfter", "BreakInside"], r = 0; r < n.length; r++) e = n[r].toLowerCase(), t = w("column" + n[r]), ("breakbefore" === e || "breakafter" === e || "breakinside" == e) && (t = t || w(n[r])), Modernizr.addTest("csscolumns." + e, t); 21793 }(), Modernizr.addTest("flexbox", w("flexBasis", "1px", !0)), Modernizr.addTest("flexboxlegacy", w("boxDirection", "reverse", !0)), Modernizr.addTest("csstransforms", function () { 21794 return -1 === navigator.userAgent.indexOf("Android 2.") && w("transform", "scale(1)", !0); 21795 }), Modernizr.addTest("csstransitions", w("transition", "all", !0)), Modernizr.addTest("cssremunit", function () { 21796 var e = i("a").style; 21797 try { 21798 e.fontSize = "3rem"; 21799 } catch (t) {} 21800 return /rem/.test(e.fontSize); 21801 }), o(), a(b), delete C.addTest, delete C.addAsyncTest; 21802 for (var F = 0; F < Modernizr._q.length; F++) Modernizr._q[F](); 21803 e.Modernizr = Modernizr; 21804}(window, document); 21805 21806},{"@babel/runtime/helpers/interopRequireDefault":3,"@babel/runtime/helpers/typeof":7}],37:[function(require,module,exports){ 21807"use strict"; 21808 21809var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault"); 21810var _typeof2 = _interopRequireDefault(require("@babel/runtime/helpers/typeof")); 21811/*! picturefill - v3.0.2 - 2016-02-12 21812 * https://scottjehl.github.io/picturefill/ 21813 * Copyright (c) 2016 https://github.com/scottjehl/picturefill/blob/master/Authors.txt; Licensed MIT 21814 */ 21815/*! Gecko-Picture - v1.0 21816 * https://github.com/scottjehl/picturefill/tree/3.0/src/plugins/gecko-picture 21817 * Firefox's early picture implementation (prior to FF41) is static and does 21818 * not react to viewport changes. This tiny module fixes this. 21819 */ 21820(function (window) { 21821 /*jshint eqnull:true */ 21822 var ua = navigator.userAgent; 21823 if (window.HTMLPictureElement && /ecko/.test(ua) && ua.match(/rv\:(\d+)/) && RegExp.$1 < 45) { 21824 addEventListener("resize", function () { 21825 var timer; 21826 var dummySrc = document.createElement("source"); 21827 var fixRespimg = function fixRespimg(img) { 21828 var source, sizes; 21829 var picture = img.parentNode; 21830 if (picture.nodeName.toUpperCase() === "PICTURE") { 21831 source = dummySrc.cloneNode(); 21832 picture.insertBefore(source, picture.firstElementChild); 21833 setTimeout(function () { 21834 picture.removeChild(source); 21835 }); 21836 } else if (!img._pfLastSize || img.offsetWidth > img._pfLastSize) { 21837 img._pfLastSize = img.offsetWidth; 21838 sizes = img.sizes; 21839 img.sizes += ",100vw"; 21840 setTimeout(function () { 21841 img.sizes = sizes; 21842 }); 21843 } 21844 }; 21845 var findPictureImgs = function findPictureImgs() { 21846 var i; 21847 var imgs = document.querySelectorAll("picture > img, img[srcset][sizes]"); 21848 for (i = 0; i < imgs.length; i++) { 21849 fixRespimg(imgs[i]); 21850 } 21851 }; 21852 var onResize = function onResize() { 21853 clearTimeout(timer); 21854 timer = setTimeout(findPictureImgs, 99); 21855 }; 21856 var mq = window.matchMedia && matchMedia("(orientation: landscape)"); 21857 var init = function init() { 21858 onResize(); 21859 if (mq && mq.addListener) { 21860 mq.addListener(onResize); 21861 } 21862 }; 21863 dummySrc.srcset = "data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw=="; 21864 if (/^[c|i]|d$/.test(document.readyState || "")) { 21865 init(); 21866 } else { 21867 document.addEventListener("DOMContentLoaded", init); 21868 } 21869 return onResize; 21870 }()); 21871 } 21872})(window); 21873 21874/*! Picturefill - v3.0.2 21875 * http://scottjehl.github.io/picturefill 21876 * Copyright (c) 2015 https://github.com/scottjehl/picturefill/blob/master/Authors.txt; 21877 * License: MIT 21878 */ 21879 21880(function (window, document, undefined) { 21881 // Enable strict mode 21882 "use strict"; 21883 21884 // HTML shim|v it for old IE (IE9 will still need the HTML video tag workaround) 21885 document.createElement("picture"); 21886 var warn, eminpx, alwaysCheckWDescriptor, evalId; 21887 // local object for method references and testing exposure 21888 var pf = {}; 21889 var isSupportTestReady = false;
21890 var noop = function noop() {}; 21891 var image = document.createElement("img"); 21892 var getImgAttr = image.getAttribute; 21893 var setImgAttr = image.setAttribute; 21894 var removeImgAttr = image.removeAttribute; 21895 var docElem = document.documentElement; 21896 var types = {}; 21897 var cfg = { 21898 //resource selection: 21899 algorithm: "" 21900 }; 21901 var srcAttr = "data-pfsrc"; 21902 var srcsetAttr = srcAttr + "set"; 21903 // ua sniffing is done for undetectable img loading features, 21904 // to do some non crucial perf optimizations 21905 var ua = navigator.userAgent; 21906 var supportAbort = /rident/.test(ua) || /ecko/.test(ua) && ua.match(/rv\:(\d+)/) && RegExp.$1 > 35; 21907 var curSrcProp = "currentSrc"; 21908 var regWDesc = /\s+\+?\d+(e\d+)?w/; 21909 var regSize = /(\([^)]+\))?\s*(.+)/; 21910 var setOptions = window.picturefillCFG; 21911 /** 21912 * Shortcut property for https://w3c.github.io/webappsec/specs/mixedcontent/#restricts-mixed-content ( for easy overriding in tests ) 21913 */ 21914 // baseStyle also used by getEmValue (i.e.: width: 1em is important) 21915 var baseStyle = "position:absolute;left:0;visibility:hidden;display:block;padding:0;border:none;font-size:1em;width:1em;overflow:hidden;clip:rect(0px, 0px, 0px, 0px)"; 21916 var fsCss = "font-size:100%!important;"; 21917 var isVwDirty = true; 21918 var cssCache = {}; 21919 var sizeLengthCache = {}; 21920 var DPR = window.devicePixelRatio; 21921 var units = { 21922 px: 1, 21923 "in": 96 21924 }; 21925 var anchor = document.createElement("a"); 21926 /** 21927 * alreadyRun flag used for setOptions. is it true setOptions will reevaluate 21928 * @type {boolean} 21929 */ 21930 var alreadyRun = false; 21931 21932 // Reusable, non-"g" Regexes 21933 21934 // (Don't use \s, to avoid matching non-breaking space.) 21935 var regexLeadingSpaces = /^[ \t\n\r\u000c]+/, 21936 regexLeadingCommasOrSpaces = /^[, \t\n\r\u000c]+/, 21937 regexLeadingNotSpaces = /^[^ \t\n\r\u000c]+/, 21938 regexTrailingCommas = /[,]+$/, 21939 regexNonNegativeInteger = /^\d+$/, 21940 // ( Positive or negative or unsigned integers or decimals, without or without exponents. 21941 // Must include at least one digit. 21942 // According to spec tests any decimal point must be followed by a digit. 21943 // No leading plus sign is allowed.) 21944 // https://html.spec.whatwg.org/multipage/infrastructure.html#valid-floating-point-number 21945 regexFloatingPoint = /^-?(?:[0-9]+|[0-9]*\.[0-9]+)(?:[eE][+-]?[0-9]+)?$/; 21946 var on = function on(obj, evt, fn, capture) { 21947 if (obj.addEventListener) { 21948 obj.addEventListener(evt, fn, capture || false); 21949 } else if (obj.attachEvent) { 21950 obj.attachEvent("on" + evt, fn); 21951 } 21952 }; 21953 21954 /** 21955 * simple memoize function: 21956 */ 21957 21958 var memoize = function memoize(fn) { 21959 var cache = {}; 21960 return function (input) { 21961 if (!(input in cache)) { 21962 cache[input] = fn(input); 21963 } 21964 return cache[input]; 21965 }; 21966 }; 21967 21968 // UTILITY FUNCTIONS 21969 21970 // Manual is faster than RegEx 21971 // http://jsperf.com/whitespace-character/5 21972 function isSpace(c) { 21973 return c === " " || 21974 // space 21975 c === "\t" || 21976 // horizontal tab 21977 c === "\n" || 21978 // new line 21979 c === "\f" || 21980 // form feed 21981 c === "\r"; // carriage return 21982 } 21983 21984 /** 21985 * gets a mediaquery and returns a boolean or gets a css length and returns a number 21986 * @param css mediaqueries or css length 21987 * @returns {boolean|number} 21988 * 21989 * based on: https://gist.github.com/jonathantneal/db4f77009b155f083738 21990 */ 21991 var evalCSS = function () { 21992 var regLength = /^([\d\.]+)(em|vw|px)$/; 21993 var replace = function replace() { 21994 var args = arguments, 21995 index = 0, 21996 string = args[0]; 21997 while (++index in args) { 21998 string = string.replace(args[index], args[++index]); 21999 } 22000 return string; 22001 }; 22002 var buildStr = memoize(function (css) { 22003 return "return " + replace((css || "").toLowerCase(), 22004 // interpret `and` 22005 /\band\b/g, "&&", 22006 // interpret `,` 22007 /,/g, "||", 22008 // interpret `min-` as >= 22009 /min-([a-z-\s]+):/g, "e.$1>=", 22010 // interpret `max-` as <= 22011 /max-([a-z-\s]+):/g, "e.$1<=", 22012 //calc value 22013 /calc([^)]+)/g, "($1)", 22014 // interpret css values 22015 /(\d+[\.]*[\d]*)([a-z]+)/g, "($1 * e.$2)", 22016 //make eval less evil 22017 /^(?!(e.[a-z]|[0-9\.&=|><\+\-\*\(\)\/])).*/ig, "") + ";"; 22018 }); 22019 return function (css, length) { 22020 var parsedLength; 22021 if (!(css in cssCache)) { 22022 cssCache[css] = false;
vendor: 15,227 bytes, lines 22023-22496
22023 if (length && (parsedLength = css.match(regLength))) { 22024 cssCache[css] = parsedLength[1] * units[parsedLength[2]]; 22025 } else { 22026 /*jshint evil:true */ 22027 try { 22028 cssCache[css] = new Function("e", buildStr(css))(units); 22029 } catch (e) {} 22030 /*jshint evil:false */ 22031 } 22032 } 22033 return cssCache[css]; 22034 }; 22035 }(); 22036 var setResolution = function setResolution(candidate, sizesattr) { 22037 if (candidate.w) { 22038 // h = means height: || descriptor.type === 'h' do not handle yet... 22039 candidate.cWidth = pf.calcListLength(sizesattr || "100vw"); 22040 candidate.res = candidate.w / candidate.cWidth; 22041 } else { 22042 candidate.res = candidate.d; 22043 } 22044 return candidate; 22045 }; 22046 22047 /** 22048 * 22049 * @param opt 22050 */ 22051 var picturefill = function picturefill(opt) { 22052 if (!isSupportTestReady) { 22053 return; 22054 } 22055 var elements, i, plen; 22056 var options = opt || {}; 22057 if (options.elements && options.elements.nodeType === 1) { 22058 if (options.elements.nodeName.toUpperCase() === "IMG") { 22059 options.elements = [options.elements]; 22060 } else { 22061 options.context = options.elements; 22062 options.elements = null; 22063 } 22064 } 22065 elements = options.elements || pf.qsa(options.context || document, options.reevaluate || options.reselect ? pf.sel : pf.selShort); 22066 if (plen = elements.length) { 22067 pf.setupRun(options); 22068 alreadyRun = true; 22069 22070 // Loop through all elements 22071 for (i = 0; i < plen; i++) { 22072 pf.fillImg(elements[i], options); 22073 } 22074 pf.teardownRun(options); 22075 } 22076 }; 22077 22078 /** 22079 * outputs a warning for the developer 22080 * @param {message} 22081 * @type {Function} 22082 */ 22083 warn = window.console && console.warn ? function (message) { 22084 console.warn(message); 22085 } : noop; 22086 if (!(curSrcProp in image)) { 22087 curSrcProp = "src"; 22088 } 22089 22090 // Add support for standard mime types. 22091 types["image/jpeg"] = true; 22092 types["image/gif"] = true; 22093 types["image/png"] = true; 22094 function detectTypeSupport(type, typeUri) { 22095 // based on Modernizr's lossless img-webp test 22096 // note: asynchronous 22097 var image = new window.Image(); 22098 image.onerror = function () { 22099 types[type] = false; 22100 picturefill(); 22101 }; 22102 image.onload = function () { 22103 types[type] = image.width === 1; 22104 picturefill(); 22105 }; 22106 image.src = typeUri; 22107 return "pending"; 22108 } 22109 22110 // test svg support 22111 types["image/svg+xml"] = document.implementation.hasFeature("http://www.w3.org/TR/SVG11/feature#Image", "1.1"); 22112 22113 /** 22114 * updates the internal vW property with the current viewport width in px 22115 */ 22116 function updateMetrics() { 22117 isVwDirty = false; 22118 DPR = window.devicePixelRatio; 22119 cssCache = {}; 22120 sizeLengthCache = {}; 22121 pf.DPR = DPR || 1; 22122 units.width = Math.max(window.innerWidth || 0, docElem.clientWidth); 22123 units.height = Math.max(window.innerHeight || 0, docElem.clientHeight); 22124 units.vw = units.width / 100; 22125 units.vh = units.height / 100; 22126 evalId = [units.height, units.width, DPR].join("-"); 22127 units.em = pf.getEmValue(); 22128 units.rem = units.em; 22129 } 22130 function chooseLowRes(lowerValue, higherValue, dprValue, isCached) { 22131 var bonusFactor, tooMuch, bonus, meanDensity; 22132 22133 //experimental 22134 if (cfg.algorithm === "saveData") { 22135 if (lowerValue > 2.7) { 22136 meanDensity = dprValue + 1; 22137 } else { 22138 tooMuch = higherValue - dprValue; 22139 bonusFactor = Math.pow(lowerValue - 0.6, 1.5); 22140 bonus = tooMuch * bonusFactor; 22141 if (isCached) { 22142 bonus += 0.1 * bonusFactor; 22143 } 22144 meanDensity = lowerValue + bonus; 22145 } 22146 } else { 22147 meanDensity = dprValue > 1 ? Math.sqrt(lowerValue * higherValue) : lowerValue; 22148 } 22149 return meanDensity > dprValue; 22150 } 22151 function applyBestCandidate(img) { 22152 var srcSetCandidates; 22153 var matchingSet = pf.getSet(img); 22154 var evaluated = false; 22155 if (matchingSet !== "pending") { 22156 evaluated = evalId; 22157 if (matchingSet) { 22158 srcSetCandidates = pf.setRes(matchingSet); 22159 pf.applySetCandidate(srcSetCandidates, img); 22160 } 22161 } 22162 img[pf.ns].evaled = evaluated; 22163 } 22164 function ascendingSort(a, b) { 22165 return a.res - b.res; 22166 } 22167 function setSrcToCur(img, src, set) { 22168 var candidate; 22169 if (!set && src) { 22170 set = img[pf.ns].sets; 22171 set = set && set[set.length - 1]; 22172 } 22173 candidate = getCandidateForSrc(src, set); 22174 if (candidate) { 22175 src = pf.makeUrl(src); 22176 img[pf.ns].curSrc = src; 22177 img[pf.ns].curCan = candidate; 22178 if (!candidate.res) { 22179 setResolution(candidate, candidate.set.sizes); 22180 } 22181 } 22182 return candidate; 22183 } 22184 function getCandidateForSrc(src, set) { 22185 var i, candidate, candidates; 22186 if (src && set) { 22187 candidates = pf.parseSet(set); 22188 src = pf.makeUrl(src); 22189 for (i = 0; i < candidates.length; i++) { 22190 if (src === pf.makeUrl(candidates[i].url)) { 22191 candidate = candidates[i]; 22192 break; 22193 } 22194 } 22195 } 22196 return candidate; 22197 } 22198 function getAllSourceElements(picture, candidates) { 22199 var i, len, source, srcset; 22200 22201 // SPEC mismatch intended for size and perf: 22202 // actually only source elements preceding the img should be used 22203 // also note: don't use qsa here, because IE8 sometimes doesn't like source as the key part in a selector 22204 var sources = picture.getElementsByTagName("source"); 22205 for (i = 0, len = sources.length; i < len; i++) { 22206 source = sources[i]; 22207 source[pf.ns] = true; 22208 srcset = source.getAttribute("srcset"); 22209 22210 // if source does not have a srcset attribute, skip 22211 if (srcset) { 22212 candidates.push({ 22213 srcset: srcset, 22214 media: source.getAttribute("media"), 22215 type: source.getAttribute("type"), 22216 sizes: source.getAttribute("sizes") 22217 }); 22218 } 22219 } 22220 } 22221 22222 /** 22223 * Srcset Parser 22224 * By Alex Bell | MIT License 22225 * 22226 * @returns Array [{url: _, d: _, w: _, h:_, set:_(????)}, ...] 22227 * 22228 * Based super duper closely on the reference algorithm at: 22229 * https://html.spec.whatwg.org/multipage/embedded-content.html#parse-a-srcset-attribute 22230 */ 22231 22232 // 1. Let input be the value passed to this algorithm. 22233 // (TO-DO : Explain what "set" argument is here. Maybe choose a more 22234 // descriptive & more searchable name. Since passing the "set" in really has 22235 // nothing to do with parsing proper, I would prefer this assignment eventually 22236 // go in an external fn.) 22237 function parseSrcset(input, set) { 22238 function collectCharacters(regEx) { 22239 var chars, 22240 match = regEx.exec(input.substring(pos)); 22241 if (match) { 22242 chars = match[0]; 22243 pos += chars.length; 22244 return chars; 22245 } 22246 } 22247 var inputLength = input.length, 22248 url, 22249 descriptors, 22250 currentDescriptor, 22251 state, 22252 c, 22253 // 2. Let position be a pointer into input, initially pointing at the start 22254 // of the string. 22255 pos = 0, 22256 // 3. Let candidates be an initially empty source set. 22257 candidates = []; 22258 22259 /** 22260 * Adds descriptor properties to a candidate, pushes to the candidates array 22261 * @return undefined 22262 */ 22263 // (Declared outside of the while loop so that it's only created once. 22264 // (This fn is defined before it is used, in order to pass JSHINT. 22265 // Unfortunately this breaks the sequencing of the spec comments. :/ ) 22266 function parseDescriptors() { 22267 // 9. Descriptor parser: Let error be no. 22268 var pError = false, 22269 // 10. Let width be absent. 22270 // 11. Let density be absent. 22271 // 12. Let future-compat-h be absent. (We're implementing it now as h) 22272 w, 22273 d, 22274 h, 22275 i, 22276 candidate = {}, 22277 desc, 22278 lastChar, 22279 value, 22280 intVal, 22281 floatVal; 22282 22283 // 13. For each descriptor in descriptors, run the appropriate set of steps 22284 // from the following list: 22285 for (i = 0; i < descriptors.length; i++) { 22286 desc = descriptors[i]; 22287 lastChar = desc[desc.length - 1]; 22288 value = desc.substring(0, desc.length - 1); 22289 intVal = parseInt(value, 10); 22290 floatVal = parseFloat(value); 22291 22292 // If the descriptor consists of a valid non-negative integer followed by 22293 // a U+0077 LATIN SMALL LETTER W character 22294 if (regexNonNegativeInteger.test(value) && lastChar === "w") { 22295 // If width and density are not both absent, then let error be yes. 22296 if (w || d) { 22297 pError = true; 22298 } 22299 22300 // Apply the rules for parsing non-negative integers to the descriptor. 22301 // If the result is zero, let error be yes. 22302 // Otherwise, let width be the result. 22303 if (intVal === 0) { 22304 pError = true; 22305 } else { 22306 w = intVal; 22307 } 22308 22309 // If the descriptor consists of a valid floating-point number followed by 22310 // a U+0078 LATIN SMALL LETTER X character 22311 } else if (regexFloatingPoint.test(value) && lastChar === "x") { 22312 // If width, density and future-compat-h are not all absent, then let error 22313 // be yes. 22314 if (w || d || h) { 22315 pError = true; 22316 } 22317 22318 // Apply the rules for parsing floating-point number values to the descriptor. 22319 // If the result is less than zero, let error be yes. Otherwise, let density 22320 // be the result. 22321 if (floatVal < 0) { 22322 pError = true; 22323 } else { 22324 d = floatVal; 22325 } 22326 22327 // If the descriptor consists of a valid non-negative integer followed by 22328 // a U+0068 LATIN SMALL LETTER H character 22329 } else if (regexNonNegativeInteger.test(value) && lastChar === "h") { 22330 // If height and density are not both absent, then let error be yes. 22331 if (h || d) { 22332 pError = true; 22333 } 22334 22335 // Apply the rules for parsing non-negative integers to the descriptor. 22336 // If the result is zero, let error be yes. Otherwise, let future-compat-h 22337 // be the result. 22338 if (intVal === 0) { 22339 pError = true; 22340 } else { 22341 h = intVal; 22342 } 22343 22344 // Anything else, Let error be yes. 22345 } else { 22346 pError = true; 22347 } 22348 } // (close step 13 for loop) 22349 22350 // 15. If error is still no, then append a new image source to candidates whose 22351 // URL is url, associated with a width width if not absent and a pixel 22352 // density density if not absent. Otherwise, there is a parse error. 22353 if (!pError) { 22354 candidate.url = url; 22355 if (w) { 22356 candidate.w = w; 22357 } 22358 if (d) { 22359 candidate.d = d; 22360 } 22361 if (h) { 22362 candidate.h = h; 22363 } 22364 if (!h && !d && !w) { 22365 candidate.d = 1; 22366 } 22367 if (candidate.d === 1) { 22368 set.has1x = true; 22369 } 22370 candidate.set = set; 22371 candidates.push(candidate); 22372 } 22373 } // (close parseDescriptors fn) 22374 22375 /** 22376 * Tokenizes descriptor properties prior to parsing 22377 * Returns undefined. 22378 * (Again, this fn is defined before it is used, in order to pass JSHINT. 22379 * Unfortunately this breaks the logical sequencing of the spec comments. :/ ) 22380 */ 22381 function tokenize() { 22382 // 8.1. Descriptor tokeniser: Skip whitespace 22383 collectCharacters(regexLeadingSpaces); 22384 22385 // 8.2. Let current descriptor be the empty string. 22386 currentDescriptor = ""; 22387 22388 // 8.3. Let state be in descriptor. 22389 state = "in descriptor"; 22390 while (true) { 22391 // 8.4. Let c be the character at position. 22392 c = input.charAt(pos); 22393 22394 // Do the following depending on the value of state. 22395 // For the purpose of this step, "EOF" is a special character representing 22396 // that position is past the end of input. 22397 22398 // In descriptor 22399 if (state === "in descriptor") { 22400 // Do the following, depending on the value of c: 22401 22402 // Space character 22403 // If current descriptor is not empty, append current descriptor to 22404 // descriptors and let current descriptor be the empty string. 22405 // Set state to after descriptor. 22406 if (isSpace(c)) { 22407 if (currentDescriptor) { 22408 descriptors.push(currentDescriptor); 22409 currentDescriptor = ""; 22410 state = "after descriptor"; 22411 } 22412 22413 // U+002C COMMA (,) 22414 // Advance position to the next character in input. If current descriptor 22415 // is not empty, append current descriptor to descriptors. Jump to the step 22416 // labeled descriptor parser. 22417 } else if (c === ",") { 22418 pos += 1; 22419 if (currentDescriptor) { 22420 descriptors.push(currentDescriptor); 22421 } 22422 parseDescriptors(); 22423 return; 22424 22425 // U+0028 LEFT PARENTHESIS (() 22426 // Append c to current descriptor. Set state to in parens. 22427 } else if (c === "(") { 22428 currentDescriptor = currentDescriptor + c; 22429 state = "in parens"; 22430 22431 // EOF 22432 // If current descriptor is not empty, append current descriptor to 22433 // descriptors. Jump to the step labeled descriptor parser. 22434 } else if (c === "") { 22435 if (currentDescriptor) { 22436 descriptors.push(currentDescriptor); 22437 } 22438 parseDescriptors(); 22439 return; 22440 22441 // Anything else 22442 // Append c to current descriptor. 22443 } else { 22444 currentDescriptor = currentDescriptor + c; 22445 } 22446 // (end "in descriptor" 22447 22448 // In parens 22449 } else if (state === "in parens") { 22450 // U+0029 RIGHT PARENTHESIS ()) 22451 // Append c to current descriptor. Set state to in descriptor. 22452 if (c === ")") { 22453 currentDescriptor = currentDescriptor + c; 22454 state = "in descriptor"; 22455 22456 // EOF 22457 // Append current descriptor to descriptors. Jump to the step labeled 22458 // descriptor parser. 22459 } else if (c === "") { 22460 descriptors.push(currentDescriptor); 22461 parseDescriptors(); 22462 return; 22463 22464 // Anything else 22465 // Append c to current descriptor. 22466 } else { 22467 currentDescriptor = currentDescriptor + c; 22468 } 22469 22470 // After descriptor 22471 } else if (state === "after descriptor") { 22472 // Do the following, depending on the value of c: 22473 // Space character: Stay in this state. 22474 if (isSpace(c)) { 22475 22476 // EOF: Jump to the step labeled descriptor parser. 22477 } else if (c === "") { 22478 parseDescriptors(); 22479 return; 22480 22481 // Anything else 22482 // Set state to in descriptor. Set position to the previous character in input. 22483 } else { 22484 state = "in descriptor"; 22485 pos -= 1; 22486 } 22487 } 22488 22489 // Advance position to the next character in input. 22490 pos += 1; 22491 22492 // Repeat this step. 22493 } // (close while true loop) 22494 } 22495 22496 // 4. Splitting loop: Collect a sequence of characters that are space
22497 // characters or U+002C COMMA characters. If any U+002C COMMA characters 22498 // were collected, that is a parse error. 22499 while (true) { 22500 collectCharacters(regexLeadingCommasOrSpaces); 22501 22502 // 5. If position is past the end of input, return candidates and abort these steps. 22503 if (pos >= inputLength) { 22504 return candidates; // (we're done, this is the sole return path) 22505 } 22506 22507 // 6. Collect a sequence of characters that are not space characters, 22508 // and let that be url. 22509 url = collectCharacters(regexLeadingNotSpaces); 22510 22511 // 7. Let descriptors be a new empty list. 22512 descriptors = []; 22513 22514 // 8. If url ends with a U+002C COMMA character (,), follow these substeps: 22515 // (1). Remove all trailing U+002C COMMA characters from url. If this removed 22516 // more than one character, that is a parse error. 22517 if (url.slice(-1) === ",") { 22518 url = url.replace(regexTrailingCommas, ""); 22519 // (Jump ahead to step 9 to skip tokenization and just push the candidate). 22520 parseDescriptors(); 22521 22522 // Otherwise, follow these substeps: 22523 } else { 22524 tokenize(); 22525 } // (close else of step 8) 22526 22527 // 16. Return to the step labeled splitting loop. 22528 } // (Close of big while loop.) 22529 } 22530 22531 /* 22532 * Sizes Parser 22533 * 22534 * By Alex Bell | MIT License 22535 * 22536 * Non-strict but accurate and lightweight JS Parser for the string value <img sizes="here"> 22537 * 22538 * Reference algorithm at: 22539 * https://html.spec.whatwg.org/multipage/embedded-content.html#parse-a-sizes-attribute 22540 * 22541 * Most comments are copied in directly from the spec 22542 * (except for comments in parens). 22543 * 22544 * Grammar is: 22545 * <source-size-list> = <source-size># [ , <source-size-value> ]? | <source-size-value> 22546 * <source-size> = <media-condition> <source-size-value> 22547 * <source-size-value> = <length> 22548 * http://www.w3.org/html/wg/drafts/html/master/embedded-content.html#attr-img-sizes 22549 * 22550 * E.g. "(max-width: 30em) 100vw, (max-width: 50em) 70vw, 100vw"
22551 * or "(min-width: 30em), calc(30vw - 15px)" or just "30vw" 22552 * 22553 * Returns the first valid <css-length> with a media condition that evaluates to true, 22554 * or "100vw" if all valid media conditions evaluate to false. 22555 * 22556 */ 22557 22558 function parseSizes(strValue) { 22559 // (Percentage CSS lengths are not allowed in this case, to avoid confusion: 22560 // https://html.spec.whatwg.org/multipage/embedded-content.html#valid-source-size-list 22561 // CSS allows a single optional plus or minus sign: 22562 // http://www.w3.org/TR/CSS2/syndata.html#numbers 22563 // CSS is ASCII case-insensitive: 22564 // http://www.w3.org/TR/CSS2/syndata.html#characters ) 22565 // Spec allows exponential notation for <number> type: 22566 // http://dev.w3.org/csswg/css-values/#numbers 22567 var regexCssLengthWithUnits = /^(?:[+-]?[0-9]+|[0-9]*\.[0-9]+)(?:[eE][+-]?[0-9]+)?(?:ch|cm|em|ex|in|mm|pc|pt|px|rem|vh|vmin|vmax|vw)$/i; 22568 22569 // (This is a quick and lenient test. Because of optional unlimited-depth internal 22570 // grouping parens and strict spacing rules, this could get very complicated.) 22571 var regexCssCalc = /^calc\((?:[0-9a-z \.\+\-\*\/\(\)]+)\)$/i; 22572 var i; 22573 var unparsedSizesList; 22574 var unparsedSizesListLength; 22575 var unparsedSize; 22576 var lastComponentValue; 22577 var size; 22578 22579 // UTILITY FUNCTIONS 22580 22581 // (Toy CSS parser. The goals here are: 22582 // 1) expansive test coverage without the weight of a full CSS parser. 22583 // 2) Avoiding regex wherever convenient. 22584 // Quick tests: http://jsfiddle.net/gtntL4gr/3/ 22585 // Returns an array of arrays.) 22586 function parseComponentValues(str) { 22587 var chrctr; 22588 var component = ""; 22589 var componentArray = []; 22590 var listArray = []; 22591 var parenDepth = 0; 22592 var pos = 0; 22593 var inComment = false; 22594 function pushComponent() { 22595 if (component) { 22596 componentArray.push(component); 22597 component = ""; 22598 } 22599 } 22600 function pushComponentArray() { 22601 if (componentArray[0]) { 22602 listArray.push(componentArray); 22603 componentArray = []; 22604 } 22605 } 22606 22607 // (Loop forwards from the beginning of the string.) 22608 while (true) { 22609 chrctr = str.charAt(pos); 22610 if (chrctr === "") { 22611 // ( End of string reached.) 22612 pushComponent(); 22613 pushComponentArray(); 22614 return listArray; 22615 } else if (inComment) { 22616 if (chrctr === "*" && str[pos + 1] === "/") { 22617 // (At end of a comment.) 22618 inComment = false; 22619 pos += 2; 22620 pushComponent(); 22621 continue; 22622 } else { 22623 pos += 1; // (Skip all characters inside comments.) 22624 continue; 22625 } 22626 } else if (isSpace(chrctr)) { 22627 // (If previous character in loop was also a space, or if 22628 // at the beginning of the string, do not add space char to 22629 // component.) 22630 if (str.charAt(pos - 1) && isSpace(str.charAt(pos - 1)) || !component) { 22631 pos += 1; 22632 continue; 22633 } else if (parenDepth === 0) { 22634 pushComponent(); 22635 pos += 1; 22636 continue; 22637 } else { 22638 // (Replace any space character with a plain space for legibility.) 22639 chrctr = " "; 22640 } 22641 } else if (chrctr === "(") { 22642 parenDepth += 1; 22643 } else if (chrctr === ")") { 22644 parenDepth -= 1; 22645 } else if (chrctr === ",") { 22646 pushComponent(); 22647 pushComponentArray(); 22648 pos += 1; 22649 continue; 22650 } else if (chrctr === "/" && str.charAt(pos + 1) === "*") { 22651 inComment = true; 22652 pos += 2; 22653 continue; 22654 } 22655 component = component + chrctr; 22656 pos += 1; 22657 } 22658 } 22659 function isValidNonNegativeSourceSizeValue(s) { 22660 if (regexCssLengthWithUnits.test(s) && parseFloat(s) >= 0) { 22661 return true; 22662 } 22663 if (regexCssCalc.test(s)) { 22664 return true; 22665 } 22666 // ( http://www.w3.org/TR/CSS2/syndata.html#numbers says: 22667 // "-0 is equivalent to 0 and is not a negative number." which means that 22668 // unitless zero and unitless negative zero must be accepted as special cases.) 22669 if (s === "0" || s === "-0" || s === "+0") { 22670 return true; 22671 } 22672 return false;
vendor: 14,498 bytes, lines 22673-23093
22673 } 22674 22675 // When asked to parse a sizes attribute from an element, parse a 22676 // comma-separated list of component values from the value of the element's 22677 // sizes attribute (or the empty string, if the attribute is absent), and let 22678 // unparsed sizes list be the result. 22679 // http://dev.w3.org/csswg/css-syntax/#parse-comma-separated-list-of-component-values 22680 22681 unparsedSizesList = parseComponentValues(strValue); 22682 unparsedSizesListLength = unparsedSizesList.length; 22683 22684 // For each unparsed size in unparsed sizes list: 22685 for (i = 0; i < unparsedSizesListLength; i++) { 22686 unparsedSize = unparsedSizesList[i]; 22687 22688 // 1. Remove all consecutive <whitespace-token>s from the end of unparsed size. 22689 // ( parseComponentValues() already omits spaces outside of parens. ) 22690 22691 // If unparsed size is now empty, that is a parse error; continue to the next 22692 // iteration of this algorithm. 22693 // ( parseComponentValues() won't push an empty array. ) 22694 22695 // 2. If the last component value in unparsed size is a valid non-negative 22696 // <source-size-value>, let size be its value and remove the component value 22697 // from unparsed size. Any CSS function other than the calc() function is 22698 // invalid. Otherwise, there is a parse error; continue to the next iteration 22699 // of this algorithm. 22700 // http://dev.w3.org/csswg/css-syntax/#parse-component-value 22701 lastComponentValue = unparsedSize[unparsedSize.length - 1]; 22702 if (isValidNonNegativeSourceSizeValue(lastComponentValue)) { 22703 size = lastComponentValue; 22704 unparsedSize.pop(); 22705 } else { 22706 continue; 22707 } 22708 22709 // 3. Remove all consecutive <whitespace-token>s from the end of unparsed 22710 // size. If unparsed size is now empty, return size and exit this algorithm. 22711 // If this was not the last item in unparsed sizes list, that is a parse error. 22712 if (unparsedSize.length === 0) { 22713 return size; 22714 } 22715 22716 // 4. Parse the remaining component values in unparsed size as a 22717 // <media-condition>. If it does not parse correctly, or it does parse 22718 // correctly but the <media-condition> evaluates to false, continue to the 22719 // next iteration of this algorithm. 22720 // (Parsing all possible compound media conditions in JS is heavy, complicated, 22721 // and the payoff is unclear. Is there ever an situation where the 22722 // media condition parses incorrectly but still somehow evaluates to true? 22723 // Can we just rely on the browser/polyfill to do it?) 22724 unparsedSize = unparsedSize.join(" "); 22725 if (!pf.matchesMedia(unparsedSize)) { 22726 continue; 22727 } 22728 22729 // 5. Return size and exit this algorithm. 22730 return size; 22731 } 22732 22733 // If the above algorithm exhausts unparsed sizes list without returning a 22734 // size value, return 100vw. 22735 return "100vw"; 22736 } 22737 22738 // namespace 22739 pf.ns = ("pf" + new Date().getTime()).substr(0, 9); 22740 22741 // srcset support test 22742 pf.supSrcset = "srcset" in image; 22743 pf.supSizes = "sizes" in image; 22744 pf.supPicture = !!window.HTMLPictureElement; 22745 22746 // UC browser does claim to support srcset and picture, but not sizes, 22747 // this extended test reveals the browser does support nothing 22748 if (pf.supSrcset && pf.supPicture && !pf.supSizes) { 22749 (function (image2) { 22750 image.srcset = "data:,a"; 22751 image2.src = "data:,a"; 22752 pf.supSrcset = image.complete === image2.complete; 22753 pf.supPicture = pf.supSrcset && pf.supPicture; 22754 })(document.createElement("img")); 22755 } 22756 22757 // Safari9 has basic support for sizes, but does't expose the `sizes` idl attribute 22758 if (pf.supSrcset && !pf.supSizes) { 22759 (function () { 22760 var width2 = "data:image/gif;base64,R0lGODlhAgABAPAAAP///wAAACH5BAAAAAAALAAAAAACAAEAAAICBAoAOw=="; 22761 var width1 = "data:image/gif;base64,R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw=="; 22762 var img = document.createElement("img"); 22763 var test = function test() { 22764 var width = img.width; 22765 if (width === 2) { 22766 pf.supSizes = true; 22767 } 22768 alwaysCheckWDescriptor = pf.supSrcset && !pf.supSizes; 22769 isSupportTestReady = true; 22770 // force async 22771 setTimeout(picturefill); 22772 }; 22773 img.onload = test; 22774 img.onerror = test; 22775 img.setAttribute("sizes", "9px"); 22776 img.srcset = width1 + " 1w," + width2 + " 9w"; 22777 img.src = width1; 22778 })(); 22779 } else { 22780 isSupportTestReady = true; 22781 } 22782 22783 // using pf.qsa instead of dom traversing does scale much better, 22784 // especially on sites mixing responsive and non-responsive images 22785 pf.selShort = "picture>img,img[srcset]"; 22786 pf.sel = pf.selShort; 22787 pf.cfg = cfg; 22788 22789 /** 22790 * Shortcut property for `devicePixelRatio` ( for easy overriding in tests ) 22791 */ 22792 pf.DPR = DPR || 1; 22793 pf.u = units; 22794 22795 // container of supported mime types that one might need to qualify before using 22796 pf.types = types; 22797 pf.setSize = noop; 22798 22799 /** 22800 * Gets a string and returns the absolute URL 22801 * @param src 22802 * @returns {String} absolute URL 22803 */ 22804 22805 pf.makeUrl = memoize(function (src) { 22806 anchor.href = src; 22807 return anchor.href; 22808 }); 22809 22810 /** 22811 * Gets a DOM element or document and a selctor and returns the found matches 22812 * Can be extended with jQuery/Sizzle for IE7 support 22813 * @param context 22814 * @param sel 22815 * @returns {NodeList|Array} 22816 */ 22817 pf.qsa = function (context, sel) { 22818 return "querySelector" in context ? context.querySelectorAll(sel) : []; 22819 }; 22820 22821 /** 22822 * Shortcut method for matchMedia ( for easy overriding in tests ) 22823 * wether native or pf.mMQ is used will be decided lazy on first call 22824 * @returns {boolean} 22825 */ 22826 pf.matchesMedia = function () { 22827 if (window.matchMedia && (matchMedia("(min-width: 0.1em)") || {}).matches) { 22828 pf.matchesMedia = function (media) { 22829 return !media || matchMedia(media).matches; 22830 }; 22831 } else { 22832 pf.matchesMedia = pf.mMQ; 22833 } 22834 return pf.matchesMedia.apply(this, arguments); 22835 }; 22836 22837 /** 22838 * A simplified matchMedia implementation for IE8 and IE9 22839 * handles only min-width/max-width with px or em values 22840 * @param media 22841 * @returns {boolean} 22842 */ 22843 pf.mMQ = function (media) { 22844 return media ? evalCSS(media) : true; 22845 }; 22846 22847 /** 22848 * Returns the calculated length in css pixel from the given sourceSizeValue 22849 * http://dev.w3.org/csswg/css-values-3/#length-value 22850 * intended Spec mismatches: 22851 * * Does not check for invalid use of CSS functions 22852 * * Does handle a computed length of 0 the same as a negative and therefore invalid value 22853 * @param sourceSizeValue 22854 * @returns {Number} 22855 */ 22856 pf.calcLength = function (sourceSizeValue) { 22857 var value = evalCSS(sourceSizeValue, true) || false; 22858 if (value < 0) { 22859 value = false; 22860 } 22861 return value; 22862 }; 22863 22864 /** 22865 * Takes a type string and checks if its supported 22866 */ 22867 22868 pf.supportsType = function (type) { 22869 return type ? types[type] : true; 22870 }; 22871 22872 /** 22873 * Parses a sourceSize into mediaCondition (media) and sourceSizeValue (length) 22874 * @param sourceSizeStr 22875 * @returns {*} 22876 */ 22877 pf.parseSize = memoize(function (sourceSizeStr) { 22878 var match = (sourceSizeStr || "").match(regSize); 22879 return { 22880 media: match && match[1], 22881 length: match && match[2] 22882 }; 22883 }); 22884 pf.parseSet = function (set) { 22885 if (!set.cands) { 22886 set.cands = parseSrcset(set.srcset, set); 22887 } 22888 return set.cands; 22889 }; 22890 22891 /** 22892 * returns 1em in css px for html/body default size 22893 * function taken from respondjs 22894 * @returns {*|number} 22895 */ 22896 pf.getEmValue = function () { 22897 var body; 22898 if (!eminpx && (body = document.body)) { 22899 var div = document.createElement("div"), 22900 originalHTMLCSS = docElem.style.cssText, 22901 originalBodyCSS = body.style.cssText; 22902 div.style.cssText = baseStyle; 22903 22904 // 1em in a media query is the value of the default font size of the browser 22905 // reset docElem and body to ensure the correct value is returned 22906 docElem.style.cssText = fsCss; 22907 body.style.cssText = fsCss; 22908 body.appendChild(div); 22909 eminpx = div.offsetWidth; 22910 body.removeChild(div); 22911 22912 //also update eminpx before returning 22913 eminpx = parseFloat(eminpx, 10); 22914 22915 // restore the original values 22916 docElem.style.cssText = originalHTMLCSS; 22917 body.style.cssText = originalBodyCSS; 22918 } 22919 return eminpx || 16; 22920 }; 22921 22922 /** 22923 * Takes a string of sizes and returns the width in pixels as a number 22924 */ 22925 pf.calcListLength = function (sourceSizeListStr) { 22926 // Split up source size list, ie ( max-width: 30em ) 100%, ( max-width: 50em ) 50%, 33% 22927 // 22928 // or (min-width:30em) calc(30% - 15px) 22929 if (!(sourceSizeListStr in sizeLengthCache) || cfg.uT) { 22930 var winningLength = pf.calcLength(parseSizes(sourceSizeListStr)); 22931 sizeLengthCache[sourceSizeListStr] = !winningLength ? units.width : winningLength; 22932 } 22933 return sizeLengthCache[sourceSizeListStr]; 22934 }; 22935 22936 /** 22937 * Takes a candidate object with a srcset property in the form of url/ 22938 * ex. "images/pic-medium.png 1x, images/pic-medium-2x.png 2x" or 22939 * "images/pic-medium.png 400w, images/pic-medium-2x.png 800w" or 22940 * "images/pic-small.png" 22941 * Get an array of image candidates in the form of 22942 * {url: "/foo/bar.png", resolution: 1} 22943 * where resolution is http://dev.w3.org/csswg/css-values-3/#resolution-value 22944 * If sizes is specified, res is calculated 22945 */ 22946 pf.setRes = function (set) { 22947 var candidates; 22948 if (set) { 22949 candidates = pf.parseSet(set); 22950 for (var i = 0, len = candidates.length; i < len; i++) { 22951 setResolution(candidates[i], set.sizes); 22952 } 22953 } 22954 return candidates; 22955 }; 22956 pf.setRes.res = setResolution; 22957 pf.applySetCandidate = function (candidates, img) { 22958 if (!candidates.length) { 22959 return; 22960 } 22961 var candidate, i, j, length, bestCandidate, curSrc, curCan, candidateSrc, abortCurSrc; 22962 var imageData = img[pf.ns]; 22963 var dpr = pf.DPR; 22964 curSrc = imageData.curSrc || img[curSrcProp]; 22965 curCan = imageData.curCan || setSrcToCur(img, curSrc, candidates[0].set); 22966 22967 // if we have a current source, we might either become lazy or give this source some advantage 22968 if (curCan && curCan.set === candidates[0].set) { 22969 // if browser can abort image request and the image has a higher pixel density than needed 22970 // and this image isn't downloaded yet, we skip next part and try to save bandwidth 22971 abortCurSrc = supportAbort && !img.complete && curCan.res - 0.1 > dpr; 22972 if (!abortCurSrc) { 22973 curCan.cached = true; 22974 22975 // if current candidate is "best", "better" or "okay", 22976 // set it to bestCandidate 22977 if (curCan.res >= dpr) { 22978 bestCandidate = curCan; 22979 } 22980 } 22981 } 22982 if (!bestCandidate) { 22983 candidates.sort(ascendingSort); 22984 length = candidates.length; 22985 bestCandidate = candidates[length - 1]; 22986 for (i = 0; i < length; i++) { 22987 candidate = candidates[i]; 22988 if (candidate.res >= dpr) { 22989 j = i - 1; 22990 22991 // we have found the perfect candidate, 22992 // but let's improve this a little bit with some assumptions ;-) 22993 if (candidates[j] && (abortCurSrc || curSrc !== pf.makeUrl(candidate.url)) && chooseLowRes(candidates[j].res, candidate.res, dpr, candidates[j].cached)) { 22994 bestCandidate = candidates[j]; 22995 } else { 22996 bestCandidate = candidate; 22997 } 22998 break; 22999 } 23000 } 23001 } 23002 if (bestCandidate) { 23003 candidateSrc = pf.makeUrl(bestCandidate.url); 23004 imageData.curSrc = candidateSrc; 23005 imageData.curCan = bestCandidate; 23006 if (candidateSrc !== curSrc) { 23007 pf.setSrc(img, bestCandidate); 23008 } 23009 pf.setSize(img); 23010 } 23011 }; 23012 pf.setSrc = function (img, bestCandidate) { 23013 var origWidth; 23014 img.src = bestCandidate.url; 23015 23016 // although this is a specific Safari issue, we don't want to take too much different code paths 23017 if (bestCandidate.set.type === "image/svg+xml") { 23018 origWidth = img.style.width; 23019 img.style.width = img.offsetWidth + 1 + "px"; 23020 23021 // next line only should trigger a repaint 23022 // if... is only done to trick dead code removal 23023 if (img.offsetWidth + 1) { 23024 img.style.width = origWidth; 23025 } 23026 } 23027 }; 23028 pf.getSet = function (img) { 23029 var i, set, supportsType; 23030 var match = false; 23031 var sets = img[pf.ns].sets; 23032 for (i = 0; i < sets.length && !match; i++) { 23033 set = sets[i]; 23034 if (!set.srcset || !pf.matchesMedia(set.media) || !(supportsType = pf.supportsType(set.type))) { 23035 continue; 23036 } 23037 if (supportsType === "pending") { 23038 set = supportsType; 23039 } 23040 match = set; 23041 break; 23042 } 23043 return match; 23044 }; 23045 pf.parseSets = function (element, parent, options) { 23046 var srcsetAttribute, imageSet, isWDescripor, srcsetParsed; 23047 var hasPicture = parent && parent.nodeName.toUpperCase() === "PICTURE"; 23048 var imageData = element[pf.ns]; 23049 if (imageData.src === undefined || options.src) { 23050 imageData.src = getImgAttr.call(element, "src"); 23051 if (imageData.src) { 23052 setImgAttr.call(element, srcAttr, imageData.src); 23053 } else { 23054 removeImgAttr.call(element, srcAttr); 23055 } 23056 } 23057 if (imageData.srcset === undefined || options.srcset || !pf.supSrcset || element.srcset) { 23058 srcsetAttribute = getImgAttr.call(element, "srcset"); 23059 imageData.srcset = srcsetAttribute; 23060 srcsetParsed = true; 23061 } 23062 imageData.sets = []; 23063 if (hasPicture) { 23064 imageData.pic = true; 23065 getAllSourceElements(parent, imageData.sets); 23066 } 23067 if (imageData.srcset) { 23068 imageSet = { 23069 srcset: imageData.srcset, 23070 sizes: getImgAttr.call(element, "sizes") 23071 }; 23072 imageData.sets.push(imageSet); 23073 isWDescripor = (alwaysCheckWDescriptor || imageData.src) && regWDesc.test(imageData.srcset || ""); 23074 23075 // add normal src as candidate, if source has no w descriptor 23076 if (!isWDescripor && imageData.src && !getCandidateForSrc(imageData.src, imageSet) && !imageSet.has1x) { 23077 imageSet.srcset += ", " + imageData.src; 23078 imageSet.cands.push({ 23079 url: imageData.src, 23080 d: 1, 23081 set: imageSet 23082 }); 23083 } 23084 } else if (imageData.src) { 23085 imageData.sets.push({ 23086 srcset: imageData.src, 23087 sizes: null 23088 }); 23089 } 23090 imageData.curCan = null; 23091 imageData.curSrc = undefined; 23092 23093 // if img has picture or the srcset was removed or has a srcset and does not support srcset at all
23094 // or has a w descriptor (and does not support sizes) set support to false to evaluate 23095 imageData.supported = !(hasPicture || imageSet && !pf.supSrcset || isWDescripor && !pf.supSizes); 23096 if (srcsetParsed && pf.supSrcset && !imageData.supported) { 23097 if (srcsetAttribute) { 23098 setImgAttr.call(element, srcsetAttr, srcsetAttribute); 23099 element.srcset = ""; 23100 } else { 23101 removeImgAttr.call(element, srcsetAttr); 23102 } 23103 } 23104 if (imageData.supported && !imageData.srcset && (!imageData.src && element.src || element.src !== pf.makeUrl(imageData.src))) { 23105 if (imageData.src === null) { 23106 element.removeAttribute("src"); 23107 } else { 23108 element.src = imageData.src; 23109 } 23110 } 23111 imageData.parsed = true; 23112 }; 23113 pf.fillImg = function (element, options) { 23114 var imageData; 23115 var extreme = options.reselect || options.reevaluate; 23116 23117 // expando for caching data on the img 23118 if (!element[pf.ns]) { 23119 element[pf.ns] = {}; 23120 } 23121 imageData = element[pf.ns]; 23122 23123 // if the element has already been evaluated, skip it 23124 // unless `options.reevaluate` is set to true ( this, for example, 23125 // is set to true when running `picturefill` on `resize` ). 23126 if (!extreme && imageData.evaled === evalId) { 23127 return; 23128 } 23129 if (!imageData.parsed || options.reevaluate) { 23130 pf.parseSets(element, element.parentNode, options); 23131 } 23132 if (!imageData.supported) { 23133 applyBestCandidate(element); 23134 } else { 23135 imageData.evaled = evalId; 23136 } 23137 }; 23138 pf.setupRun = function () { 23139 if (!alreadyRun || isVwDirty || DPR !== window.devicePixelRatio) { 23140 updateMetrics(); 23141 } 23142 }; 23143 23144 // If picture is supported, well, that's awesome. 23145 if (pf.supPicture) { 23146 picturefill = noop; 23147 pf.fillImg = noop; 23148 } else { 23149 // Set up picture polyfill by polling the document 23150 (function () { 23151 var isDomReady; 23152 var regReady = window.attachEvent ? /d$|^c/ : /d$|^c|^i/; 23153 var _run = function run() { 23154 var readyState = document.readyState || ""; 23155 timerId = setTimeout(_run, readyState === "loading" ? 200 : 999); 23156 if (document.body) { 23157 pf.fillImgs(); 23158 isDomReady = isDomReady || regReady.test(readyState); 23159 if (isDomReady) { 23160 clearTimeout(timerId); 23161 } 23162 } 23163 }; 23164 var timerId = setTimeout(_run, document.body ? 9 : 99); 23165 23166 // Also attach picturefill on resize and readystatechange 23167 // http://modernjavascript.blogspot.com/2013/08/building-better-debounce.html 23168 var debounce = function debounce(func, wait) { 23169 var timeout, timestamp; 23170 var _later = function later() { 23171 var last = new Date() - timestamp; 23172 if (last < wait) { 23173 timeout = setTimeout(_later, wait - last); 23174 } else { 23175 timeout = null; 23176 func(); 23177 } 23178 }; 23179 return function () { 23180 timestamp = new Date(); 23181 if (!timeout) { 23182 timeout = setTimeout(_later, wait); 23183 } 23184 }; 23185 }; 23186 var lastClientWidth = docElem.clientHeight; 23187 var onResize = function onResize() { 23188 isVwDirty = Math.max(window.innerWidth || 0, docElem.clientWidth) !== units.width || docElem.clientHeight !== lastClientWidth; 23189 lastClientWidth = docElem.clientHeight; 23190 if (isVwDirty) { 23191 pf.fillImgs(); 23192 } 23193 }; 23194 on(window, "resize", debounce(onResize, 99)); 23195 on(document, "readystatechange", _run); 23196 })(); 23197 } 23198 pf.picturefill = picturefill; 23199 //use this internally for easy monkey patching/performance testing 23200 pf.fillImgs = picturefill; 23201 pf.teardownRun = noop; 23202 23203 /* expose methods for testing */ 23204 picturefill._ = pf; 23205 window.picturefillCFG = { 23206 pf: pf, 23207 push: function push(args) { 23208 var name = args.shift(); 23209 if (typeof pf[name] === "function") { 23210 pf[name].apply(pf, args); 23211 } else { 23212 cfg[name] = args[0]; 23213 if (alreadyRun) { 23214 pf.fillImgs({ 23215 reselect: true 23216 }); 23217 } 23218 } 23219 } 23220 }; 23221 while (setOptions && setOptions.length) { 23222 window.picturefillCFG.push(setOptions.shift()); 23223 } 23224 23225 /* expose picturefill */ 23226 window.picturefill = picturefill; 23227 23228 /* expose picturefill */ 23229 if ((typeof module === "undefined" ? "undefined" : (0, _typeof2.default)(module)) === "object" && (0, _typeof2.default)(module.exports) === "object") { 23230 // CommonJS, just export 23231 module.exports = picturefill; 23232 } else if (typeof define === "function" && define.amd) { 23233 // AMD support 23234 define("picturefill", function () { 23235 return picturefill; 23236 }); 23237 } 23238
23239 // IE8 evals this sync, so it must be the last thing we do 23240 if (!pf.supPicture) { 23241 types["image/webp"] = detectTypeSupport("image/webp", "data:image/webp;base64,UklGRkoAAABXRUJQVlA4WAoAAAAQAAAAAAAAAAAAQUxQSAwAAAABBxAR/Q9ERP8DAABWUDggGAAAADABAJ0BKgEAAQADADQlpAADcAD++/1QAA=="); 23242 } 23243})(window, document); 23244 23245},{"@babel/runtime/helpers/interopRequireDefault":3,"@babel/runtime/helpers/typeof":7}],38:[function(require,module,exports){ 23246"use strict"; 23247 23248var uaTestStrings = require('./uaTestStrings'); 23249var browserDetect = window.browserDetect = module.exports = { 23250 init: function init() { 23251 this.detectBrowser(navigator.userAgent); 23252 23253 // uncomment to print test cases to console 23254 // this.testBrowserDetection(); 23255 }, 23256 detectBrowser: function detectBrowser(uaString) { 23257 // Edge (legacy) 23258 if (uaString.indexOf('Edge/') > -1) { 23259 this.browser = 'Edge'; 23260 this.version = uaString.match(/Edge\/([^.]+)/)[1]; 23261 } 23262 // Edge (Chromium) 23263 else if (uaString.indexOf('Edg/') > -1) { 23264 this.browser = 'Edge'; 23265 this.version = uaString.match(/Edg\/([^.]+)/)[1]; 23266 } else if (uaString.indexOf('WOW64') > -1) { 23267 // IE 9/10 23268 if (uaString.indexOf('MSIE') > -1) { 23269 this.browser = 'IE'; 23270 this.version = '9/10'; 23271 // IE 11 23272 } else if (uaString.indexOf('rv:11') > -1) { 23273 this.browser = 'IE'; 23274 this.version = '11'; 23275 } 23276 } 23277 // Firefox 23278 else if (uaString.indexOf('Firefox') > -1) { 23279 this.browser = 'Firefox'; 23280 this.version = uaString.match(/Firefox\/([^.]+)/)[1]; 23281 } else if (uaString.indexOf('Safari') > -1) { 23282 // Chrome + Brave 23283 if (uaString.indexOf('Chrome') > -1) { 23284 this.browser = 'Chrome'; 23285 this.version = uaString.match(/Chrome\/([^.]+)/)[1]; 23286 } else { 23287 // Safari (iPhone) 23288 if (uaString.indexOf('iPhone') > -1) { 23289 this.browser = '(iPhone/iPod) Safari'; 23290 // Safari (iPad) 23291 } else if (uaString.indexOf('iPad') > -1) { 23292 this.browser = '(iPad) Safari'; 23293 // Safari (desktop) 23294 } else { 23295 this.browser = 'Safari'; 23296 } 23297 this.version = uaString.match(/Version\/([^.]+)/)[1]; 23298 } 23299 } 23300 return this.browser + ' ' + this.version; 23301 }, 23302 testBrowserDetection: function testBrowserDetection() { 23303 console.log('current UA string: ' + navigator.userAgent); 23304 for (var i = 0; i < uaTestStrings.length; i++) { 23305 var uaString = uaTestStrings[i].string; 23306 var expectedResult = uaTestStrings[i].output; 23307 console.log('Expected: ' + expectedResult + '\n' + 'Actual: ' + this.detectBrowser(uaString)); 23308 } 23309 } 23310}; 23311 23312},{"./uaTestStrings":39}],39:[function(require,module,exports){ 23313"use strict"; 23314 23315var uaTestStrings = [{ 23316 output: 'Edge 14', 23317 string: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/51.0.2704.79 Safari/537.36 Edge/14.14393' 23318}, { 23319 output: 'Edge 16', 23320 string: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.36 Edge/16.16299' 23321}, { 23322 output: 'Edge 17', 23323 string: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/64.0.3282.140 Safari/537.36 Edge/17.17134' 23324}, { 23325 output: 'Edge 18', 23326 string: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.102 Safari/537.36 Edge/18.18363' 23327}, { 23328 output: 'Edge 80', 23329 string: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/80.0.3987.106 Safari/537.36 Edg/80.0.361.56' 23330}, { 23331 output: 'IE 9', 23332 string: 'Mozilla/5.0 (compatible; MSIE 10.0; Windows NT 6.1; WOW64; Trident/6.0; SLCC2; .NET CLR 2.0.50727; .NET CLR 3.5.30729; .NET CLR 3.0.30729; Media Center PC 6.0; .NET4.0C; .NET4.0E)' 23333}, { 23334 output: 'IE 10', 23335 string: 'Mozilla/5.0 (compatible; MSIE 10.0; Windows NT 6.1; WOW64; Trident/6.0; SLCC2; .NET CLR 2.0.50727; .NET CLR 3.5.30729; .NET CLR 3.0.30729; Media Center PC 6.0; .NET4.0C; .NET4.0E)' 23336}, { 23337 output: 'IE 11', 23338 string: 'Mozilla/5.0 (Windows NT 10.0; WOW64; Trident/7.0; .NET4.0C; .NET4.0E; rv:11.0) like Gecko' 23339}, { 23340 output: 'Firefox 50', 23341 string: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:50.0) Gecko/20100101 Firefox/50.0' 23342}, { 23343 output: 'Firefox 65', 23344 string: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:65.0) Gecko/20100101 Firefox/65.0' 23345}, { 23346 output: 'Firefox 69', 23347 string: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:69.0) Gecko/20100101 Firefox/69.0' 23348}, { 23349 output: 'Firefox 70', 23350 string: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:70.0) Gecko/20100101 Firefox/70.0' 23351}, { 23352 output: 'Firefox 83', 23353 string: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:83.0) Gecko/20100101 Firefox/83.0' 23354}, { 23355 output: 'Chrome 50', 23356 string: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/50.0.2661.75 Safari/537.36' 23357}, { 23358 output: 'Chrome 69', 23359 string: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/69.0.3497.81 Safari/537.36' 23360}, { 23361 output: 'Chrome 70', 23362 string: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.67 Safari/537.36' 23363}, { 23364 output: 'Chrome 83', 23365 string: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/83.0.4103.61 Safari/537.36' 23366}, { 23367 output: 'Safari 8', 23368 string: 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10_5) AppleWebKit/600.8.9 (KHTML, like Gecko) Version/8.0.8 Safari/600.8.9' 23369}, { 23370 output: 'Safari 9', 23371 string: 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_6) AppleWebKit/601.7.8 (KHTML, like Gecko) Version/9.1.3 Safari/601.7.8' 23372}, { 23373 output: 'Safari 10', 23374 string: 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_12_6) AppleWebKit/603.3.8 (KHTML, like Gecko) Version/10.1.2 Safari/603.3.8' 23375}, { 23376 output: 'Safari 11', 23377 string: 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_5) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/11.1.1 Safari/605.1.15' 23378}, { 23379 output: 'Safari 12', 23380 string: 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_14_6) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/12.1.2 Safari/605.1.15' 23381}, { 23382 output: 'Safari 13', 23383 string: 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_6) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/13.1.2 Safari/605.1.15' 23384}, { 23385 output: 'Safari 14', 23386 string: 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_6) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/14.0.1 Safari/605.1.15' 23387}, { 23388 output: 'Chrome 87', 23389 string: 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/87.0.4280.88 Safari/537.36' 23390}, { 23391 output: 'Firefox 83', 23392 string: 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:83.0) Gecko/20100101 Firefox/83.0' 23393}, 23394// { 23395// output: 'Brave 1', 23396// string: 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/87.0.4280.101 Safari/537.36]' 23397// }, 23398{ 23399 output: '(iPhone/iPod) Safari 12', 23400 string: 'Mozilla/5.0 (iPhone; CPU iPhone OS 12_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/12.0 Mobile/15E148 Safari/604.1' 23401}, { 23402 output: '(iPhone/iPod) Safari 14', 23403 string: 'Mozilla/5.0 (iPhone; CPU iPhone OS 14_3 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/14.0.1 Mobile/15E148 Safari/604.1' 23404}, { 23405 output: '(iPad) Safari 12', 23406 string: 'Mozilla/5.0 (iPad; CPU OS 12_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/12.0 Mobile/15E148 Safari/604.1' 23407}, { 23408 output: '(iPad) Safari 14', 23409 string: 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_6) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/14.0.1 Safari/605.1.15' 23410}]; 23411module.exports = uaTestStrings; 23412 23413},{}]},{},[28]);
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.