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){ 2'use strict'; 3 4var _require = require('lory.js'), 5 lory = _require.lory; 6 7var carouselAnimation = require('../utils/carousel-animation'); 8 9var carouselDots = require('../utils/carousel-dots.js'); 10/** 11 * Initializes Home Page carousels. 12 * @returns {void} 13 */ 14 15 16module.exports = function () { 17 var options = { 18 infinite: 1, 19 enableMouseEvents: true, 20 slideSpeed: 500 21 }; 22 var carousels = document.getElementsByClassName('carousel'); 23 24 for (var i = 0; i < carousels.length; i++) { 25 var element = carousels[i]; 26 var animate = carouselAnimation(element); 27 var dots = carouselDots(element, options); 28 var carousel = lory(element, options); 29 animate(dots(carousel)); 30 } 31}; 32 33},{"../utils/carousel-animation":8,"../utils/carousel-dots.js":9,"lory.js":78}],2:[function(require,module,exports){ 34'use strict'; 35 36if (typeof window.Element.prototype.matches !== 'function') { 37 window.Element.prototype.matches = window.Element.prototype.msMatchesSelector || window.Element.prototype.webkitMatchesSelector; 38} 39 40},{}],3:[function(require,module,exports){ 41'use strict'; 42 43var isCustomEventSupported = typeof window.CustomEvent === 'function'; 44var isEventSupported = typeof window.Event === 'function'; 45module.exports = { 46 createCustomEvent: createCustomEvent, 47 createEvent: createEvent 48}; 49/** 50 * Uses CustomEvent() constructor when possible. 51 * As IE does not support it, the deprecated method document.createEvent() is used instead. 52 * @template T 53 * @param {string} type 54 * @param {CustomEventInit<T>} params 55 * @returns {CustomEvent<T>} 56 */ 57 58function createCustomEvent(type) { 59 var params = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : { 60 bubbles: false, 61 cancelable: false, 62 details: null 63 }; 64 if (isCustomEventSupported) return new window.CustomEvent(type, params); 65 /** @type {CustomEvent<T>} */ 66 67 var event = document.createEvent('CustomEvent'); 68 event.initCustomEvent(type, params.bubbles, params.cancelable, params.detail); 69 return event; 70} 71/** 72 * Uses Event() constructor when possible. 73 * As IE does not support it, the deprecated method document.createEvent() is used instead. 74 * @param {string} type 75 * @param {EventInit} params 76 */ 77 78 79function createEvent(type) { 80 var params = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : { 81 bubbles: false, 82 cancelable: false 83 }; 84 if (isEventSupported) return new window.Event(type, params); 85 var event = document.createEvent('Event'); 86 event.initEvent(type, params.bubbles, params.cancelable); 87 return event; 88} 89 90},{}],4:[function(require,module,exports){ 91'use strict'; 92 93var anchors = document.querySelector('#sector-rankings-anchors > div'); 94if (anchors) Stickyfill.addOne(anchors); 95 96require('./home/carousel.js')(); 97 98require('./utils/foldable.js')(0, 80); 99 100require('./sector/rankings.js')(); 101 102require('./utils/gotop.js')(); 103 104require('./utils/events.js').trackEvents(); 105 106require('./utils/searchBar.js')(); 107 108require('./utils/banners/common.js'); 109 110},{"./home/carousel.js":1,"./sector/rankings.js":5,"./utils/banners/common.js":6,"./utils/events.js":11,"./utils/foldable.js":12,"./utils/gotop.js":13,"./utils/searchBar.js":14}],5:[function(require,module,exports){ 111'use strict'; 112 113require("core-js/modules/es.array.for-each"); 114 115require("core-js/modules/web.dom-collections.for-each"); 116 117module.exports = function initializeRankingGroups() { 118 Array.prototype.forEach.call(document.querySelectorAll('#sector-rankings-datagrid .sector-rankings-group'), initializeRankingGroup); 119}; 120/** 121 * Initialize a foldable list. 122 * @param {Element} container 123 * @returns {void} 124 */ 125 126 127function initializeRankingGroup(container) { 128 var CLASS_FODLED = 'mobile-folded'; 129 var foldable = container.querySelector('.foldable'); 130 var toggler = container.querySelector('.mobile-foldable-toggler'); 131 132 toggler.onclick = function () { 133 if (foldable.classList.contains(CLASS_FODLED)) { 134 foldable.classList.remove(CLASS_FODLED); 135 } else { 136 foldable.classList.add(CLASS_FODLED); 137 } 138 139 if (toggler.classList.contains(CLASS_FODLED)) { 140 toggler.classList.remove(CLASS_FODLED); 141 } else { 142 toggler.classList.add(CLASS_FODLED); 143 } 144 }; 145} 146 147},{"core-js/modules/es.array.for-each":74,"core-js/modules/web.dom-collections.for-each":77}],6:[function(require,module,exports){ 148'use strict'; 149 150var createIframeBanner = require('./generator.js'); 151 152if (window.nmx.banner) { 153 var banner = createIframeBanner(window.nmx.banner.url); 154 banner.open(); 155} 156 157},{"./generator.js":7}],7:[function(require,module,exports){ 158'use strict'; 159 160var tracking = require('../events.js'); 161/** 162 * @param {string} src 163 */ 164 165 166module.exports = function createIframeBanner(src) { 167 var localStorageKey = "banner-wrapper-iframe__".concat(src); 168 /** @type {HTMLIFrameElement|undefined} */ 169 170 var iframe; 171 return { 172 open: open, 173 close: close 174 }; 175 /** 176 * @returns {boolean} - `true` if the iframe could be open, `false` otherwise. 177 */ 178 179 function open() { 180 if (!iframe && !window.localStorage.getItem(localStorageKey)) { 181 iframe = createIframe(); 182 document.body.append(iframe); 183 return true; 184 } 185 186 return false;
187 } 188 189 function close() { 190 window.localStorage.setItem(localStorageKey, 'true'); 191 iframe = undefined; 192 } 193 194 function createIframe() { 195 var element = document.createElement('iframe'); 196 element.setAttribute('frameborder', '0'); 197 element.setAttribute('scrolling', 'no'); 198 element.setAttribute('src', src); 199 element.className = 'banner-wrapper-iframe'; 200 element.addEventListener('close', close); 201 element.addEventListener('tracking', onTracking); 202 return element; 203 } 204 /** 205 * @param {CustomEvent} event 206 */ 207 208 209 function onTracking(event) { 210 if (event.detail && event.detail.action) { 211 tracking.track(event.detail); 212 } 213 } 214}; 215 216},{"../events.js":11}],8:[function(require,module,exports){ 217'use strict'; 218/** 219 * Animates a carousel. 220 * @param {Element} element 221 * @param {Carousel.DynamicCarouselOptions} [options] 222 * @returns {Carousel.bindCarousel} 223 */ 224 225module.exports = function carouselAnimation(element) { 226 var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}, 227 _ref$classNameSlideCo = _ref.classNameSlideContainer, 228 classNameSlideContainer = _ref$classNameSlideCo === void 0 ? 'js_slides' : _ref$classNameSlideCo, 229 _ref$slidePause = _ref.slidePause, 230 slidePause = _ref$slidePause === void 0 ? 10000 : _ref$slidePause; 231 232 /** @type {import('lory.js').LoryStatic} */ 233 var carousel; 234 /** @type {number} */ 235 236 var timeoutId; 237 var slideContainer = element.querySelector(".".concat(classNameSlideContainer)); 238 var slideCount = slideContainer ? slideContainer.children.length : 0; 239 240 if (slidePause > 0 && slideCount > 1) { 241 element.addEventListener('after.lory.init', moveForward); 242 element.addEventListener('before.lory.slide', function () { 243 return clearTimeout(timeoutId); 244 }); 245 element.addEventListener('after.lory.slide', moveForward); 246 element.addEventListener('on.lory.resize', resetTimer); 247 } 248 249 return function (lory) { 250 return carousel = lory; 251 }; 252 /** 253 * Prepares next slide to show. 254 * @returns {void} 255 */ 256 257 function moveForward() { 258 var time = Math.abs(+element.querySelector(".".concat(classNameSlideContainer, " > .active")).getAttribute('data-time')); 259 timeoutId = setTimeout(function () { 260 return carousel.next(); 261 }, time || slidePause); 262 } 263 /** 264 * Resets timer to the trigger the next slide after the right tiem. 265 * @returns {void} 266 */ 267 268 269 function resetTimer() { 270 clearTimeout(timeoutId); 271 moveForward(); 272 } 273}; 274 275},{}],9:[function(require,module,exports){ 276'use strict'; 277/** 278 * Adds clickable dots to the given carousel. 279 * @param {Element} element 280 * @param {Carousel.DotsCarouselOptions} [options] 281 * @returns {Carousel.bindCarousel} 282 */ 283 284require("core-js/modules/es.array.index-of"); 285 286module.exports = function carouselDots(element) { 287 var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}, 288 _ref$classNameDotCont = _ref.classNameDotContainer, 289 classNameDotContainer = _ref$classNameDotCont === void 0 ? 'js_dots' : _ref$classNameDotCont, 290 _ref$classNameSlideCo = _ref.classNameSlideContainer, 291 classNameSlideContainer = _ref$classNameSlideCo === void 0 ? 'js_slides' : _ref$classNameSlideCo, 292 infinite = _ref.infinite; 293 294 /** @type {import('lory.js').LoryStatic} */ 295 var carousel; 296 var CLASS_ACTIVE = 'active'; 297 var dotContainer = element.querySelector(".".concat(classNameDotContainer)); 298 var slideContainer = element.querySelector(".".concat(classNameSlideContainer)); 299 var dotCount = slideContainer ? slideContainer.children.length : 0; 300 301 if (dotContainer && dotCount > 1) { 302 element.addEventListener('before.lory.init', createDots); 303 element.addEventListener('after.lory.init', bindDots); 304 element.addEventListener('after.lory.slide', selectActiveDot); 305 element.addEventListener('on.lory.resize', function () { 306 return selectDot(0); 307 }); 308 } 309 310 return function (lory) { 311 return carousel = lory; 312 }; 313 /** 314 * Creates as many dots as slides in the carousel. 315 * @returns {void} 316 */ 317 318 function createDots() { 319 for (var i = 0; i < dotCount; i++) { 320 dotContainer.appendChild(document.createElement('li')); 321 } 322 323 dotContainer.children[0].classList.add(CLASS_ACTIVE); 324 } 325 /** 326 * Binds dots event handlers. 327 * @returns {void} 328 */ 329 330 331 function bindDots() { 332 for (var i = 0; i < dotContainer.children.length; i++) { 333 dotContainer.children[i].addEventListener('click', onDotClick); 334 } 335 } 336 /** 337 * Selects the new active dot and unselect the previous active one. 338 * @param {CustomEvent} event 339 * @returns {void} 340 */ 341 342 343 function selectActiveDot(event) { 344 selectDot(infinite ? event.detail.currentSlide - 1 : event.detail.currentSlide); 345 } 346 /** 347 * Displays the slide associated to the clicked dot. 348 * @param {Event} event 349 * @returns {void} 350 */ 351 352 353 function onDotClick(event) { 354 var index = Array.prototype.indexOf.call(dotContainer.children, event.target); 355 carousel.slideTo(index); 356 } 357 /** 358 * Selects the dot at the given index and unselect all the others. 359 * @param {number} index 360 * @returns {void} 361 */ 362 363 364 function selectDot(index) { 365 for (var i = 0; i < dotContainer.children.length; i++) { 366 dotContainer.children[i].classList.remove(CLASS_ACTIVE); 367 } 368 369 dotContainer.children[index].classList.add(CLASS_ACTIVE); 370 } 371}; 372 373},{"core-js/modules/es.array.index-of":75}],10:[function(require,module,exports){ 374'use strict'; 375/** 376 * Delays function `func` invocation for `wait` milliseconds, using `setTimeout()`, so the return value will be lost. 377 * If the debounced function is invoked multiple times within the `wait` period, 378 * only the last invocation will actually call the function `func`, canceling the preceding invocations. 379 * For a more advanced implementation, see [lodash.debounce](https://lodash.com/docs/4.17.15#debounce). 380 * @param {Function} func 381 * @param {number} wait time in milliseconds 382 */ 383 384module.exports = function debounce(func) { 385 var wait = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0; 386 387 /** @type {number} */ 388 var timeoutId; 389 /** @this any */ 390 391 return function debounced() { 392 var _this = this; 393 394 for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) { 395 args[_key] = arguments[_key]; 396 } 397 398 clearTimeout(timeoutId); 399 timeoutId = setTimeout(function () { 400 return func.apply(_this, args); 401 }, wait); 402 }; 403}; 404 405},{}],11:[function(require,module,exports){ 406'use strict'; 407 408require("core-js/modules/es.array.for-each"); 409 410require("core-js/modules/es.array.index-of"); 411 412require("core-js/modules/es.string.trim"); 413 414require("core-js/modules/web.dom-collections.for-each"); 415 416require('../polyfills/element-matches.js'); 417 418module.exports = { 419 trackEvents: trackEvents, 420 trackEventsInContainer: trackEventsInContainer, 421 onTrackedAction: onTrackedAction, 422 track: track, 423 getDataEvent: getDataEvent, 424 getPageName: getPageName 425}; 426var SELECTOR_FOLD = '.foldable-toggler'; 427var SELECTOR_ANALYTICS_FORM = 'form.search[data-event-action]'; 428var SELECTOR_ANALYTICS = '[data-event-action]:not(form)'; 429 430function trackEvents() { 431 Array.prototype.forEach.call(document.querySelectorAll(SELECTOR_FOLD), function (foldableElement) { 432 foldableElement.addEventListener('toggle', onFoldAction); 433 }); 434 Array.prototype.forEach.call(document.querySelectorAll(SELECTOR_ANALYTICS_FORM), function (formElement) { 435 formElement.addEventListener('submit', onSearchAction); 436 }); 437 Array.prototype.forEach.call(document.querySelectorAll(SELECTOR_ANALYTICS), function (element) { 438 element.addEventListener('click', onTrackedAction); 439 }); 440} 441/** 442 * Like `trackEvents()`, but uses event delegation to track actions in a live container (which deletes or creates new children). 443 * @param {HTMLElement} container 444 */ 445 446 447function trackEventsInContainer(container) { 448 container.addEventListener('toggle', function (event) { 449 if (event.target.matches(SELECTOR_FOLD)) { 450 trakFoldAction(event.target, event.detail); 451 } 452 }); 453 container.addEventListener('click', function (event) { 454 if (event.target.matches(SELECTOR_ANALYTICS)) { 455 trackAction(event.target); 456 } 457 }); 458 container.addEventListener('submit', function (event) { 459 if (event.target.matches(SELECTOR_ANALYTICS_FORM)) { 460 trackSearchAction(event.target); 461 } 462 }); 463} 464/** @param {CustomEvent<boolean>} event */ 465 466 467function onFoldAction(event) { 468 trakFoldAction(event.currentTarget, event.detail); 469} 470/** 471 * @param {HTMLElement} element 472 * @param {boolean} isFolded toggler new state 473 */ 474 475 476function trakFoldAction(element, isFolded) { 477 /* We want to track the click on the toggler before it changes its state. 478 * But at this point, it has changed already. 479 * So we get the data corresponding to its previous state, when the click occurred. 480 */ 481 var data = getFoldDataEvent(element, !isFolded); 482 483 if (data && data.action) { 484 track(data); 485 } 486} 487/** 488 * @param {HTMLElement} element 489 * @param {boolean} isFolded toggler new state 490 */ 491 492 493function getFoldDataEvent(element, isFolded) { 494 if (element) { 495 var state = isFolded ? 'folded' : 'unfolded'; 496 return getDataEvent(element, { 497 eventActionClass: "data-event-action-".concat(state), 498 eventLabelClass: "data-event-label-".concat(state) 499 }); 500 } 501} 502/** 503 * Track submit form with page as category and action as data-event-action on form element 504 * The form must contain an input[type="search"] to get a label tracking 505 * @param {Event} event 506 */ 507 508 509function onSearchAction(event) { 510 trackSearchAction(event.currentTarget); 511} 512/** @param {HTMLElement} element */ 513 514 515function trackSearchAction(element) { 516 var searchInputElement = element.querySelector('input[type="search"]'); 517 track({ 518 category: getPageName(), 519 action: element.getAttribute('data-event-action'), 520 label: searchInputElement && searchInputElement.value || '' 521 }); 522} 523/** @param {Event} event */ 524 525 526function onTrackedAction(event) { 527 trackAction(event.currentTarget); 528} 529/** @param {HTMLElement} element */ 530 531 532function trackAction(element) { 533 var data = getDataEvent(element); 534 535 if (data && data.action) { 536 track(data); 537 } 538} 539/** 540 * @param {Element} element 541 * @param {{ eventActionClass?: string, eventLabelClass?: string }} [options] 542 * @returns {{ category: string, action: string|null, label: string } | undefined} 543 */ 544 545 546function getDataEvent(element) { 547 var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}, 548 _ref$eventActionClass = _ref.eventActionClass, 549 eventActionClass = _ref$eventActionClass === void 0 ? 'data-event-action' : _ref$eventActionClass, 550 _ref$eventLabelClass = _ref.eventLabelClass, 551 eventLabelClass = _ref$eventLabelClass === void 0 ? 'data-event-label' : _ref$eventLabelClass; 552 553 if (element) { 554 return { 555 category: getPageName(), 556 action: element.getAttribute(eventActionClass), 557 label: element.getAttribute(eventLabelClass) || element.textContent.trim() 558 }; 559 } 560} 561 562function track(_ref2) { 563 var category = _ref2.category, 564 action = _ref2.action, 565 label = _ref2.label; 566 var _window = window, 567 gtag = _window.gtag; 568 569 if (gtag) { 570 gtag('event', action, { 571 event_category: category, 572 event_label: label 573 }); 574 } 575} 576/** 577 * @param {Window} context 578 * @returns 579 */ 580 581 582function getPageName() { 583 var context = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : window; 584 var urlPrefix = context.urlPrefix; 585 var pageName = context.document.location.pathname; 586 587 if (pageName === "/") { 588 pageName = "Home Page"; 589 } else if (pageName.indexOf("".concat(urlPrefix, "/sector/")) === 0) { 590 pageName = "Sector Page"; 591 } else if (pageName.indexOf("".concat(urlPrefix, "/ranking/")) === 0) { 592 pageName = "Ranking Page"; 593 } else if (pageName.indexOf('/search') === 0) { 594 pageName = 'Search Page'; 595 } else if (pageName.indexOf("".concat(urlPrefix, "/timeseries/")) === 0) { 596 pageName = "Data Page"; 597 } 598 599 return pageName; 600} 601 602},{"../polyfills/element-matches.js":2,"core-js/modules/es.array.for-each":74,"core-js/modules/es.array.index-of":75,"core-js/modules/es.string.trim":76,"core-js/modules/web.dom-collections.for-each":77}],12:[function(require,module,exports){ 603'use strict'; 604 605require("core-js/modules/es.array.for-each"); 606 607require("core-js/modules/web.dom-collections.for-each"); 608 609var _require = require('../ponyfills/events.js'), 610 createCustomEvent = _require.createCustomEvent; 611/** 612 * Initialize all foldable lists on the page. 613 * @param {number} [offsetX=0] 614 * @param {number} [offsetY=0] 615 * @returns{void} 616 */ 617 618 619module.exports = function initializaFoldableLists() { 620 var offsetX = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0; 621 var offsetY = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0; 622 Array.prototype.forEach.call(document.querySelectorAll('.foldable'), function (foldable) { 623 return initializeFoldableList(foldable, offsetX, offsetY); 624 }); 625}; 626/** 627 * Initialize a foldable list. 628 * If you need to watch state changes, subscribe to the **toggle** event. 629 * @param {Element} foldable 630 * @param {number} offsetX 631 * @param {number} offsetY 632 * @returns {void} 633 */ 634 635 636function initializeFoldableList(foldable, offsetX, offsetY) { 637 var CLASS_FOLDED = 'folded'; 638 var toggler = foldable.querySelector('.foldable-toggler'); 639 var scrollOrigin = foldable.querySelector('.foldable-scroll-origin') || foldable; 640 if (!toggler) return; 641 toggler.textContent = foldable.classList.contains(CLASS_FOLDED) ? toggler.dataset.labelFolded : toggler.dataset.labelUnfolded; 642 toggler.addEventListener('click', function () { 643 var isFolded = foldable.classList.contains(CLASS_FOLDED); 644 645 if (isFolded) { 646 foldable.classList.remove(CLASS_FOLDED); 647 toggler.textContent = toggler.dataset.labelUnfolded; 648 } else { 649 foldable.classList.add(CLASS_FOLDED); 650 toggler.textContent = toggler.dataset.labelFolded; 651 var boundingBox = scrollOrigin.getBoundingClientRect(); 652 653 if (boundingBox.left < offsetX || boundingBox.top < offsetY) { 654 var bodyBoundingBox = document.documentElement.getBoundingClientRect(); 655 window.scrollTo(boundingBox.left - bodyBoundingBox.left - offsetX, boundingBox.top - bodyBoundingBox.top - offsetY); 656 } 657 } 658 659 toggler.dispatchEvent(createCustomEvent('toggle', { 660 bubbles: true, 661 detail: !isFolded 662 })); 663 }); 664} 665 666},{"../ponyfills/events.js":3,"core-js/modules/es.array.for-each":74,"core-js/modules/web.dom-collections.for-each":77}],13:[function(require,module,exports){ 667'use strict'; 668/** 669 * Initializes the Go Top button. 670 * @returns {void} 671 */ 672 673module.exports = function initializeGotop() { 674 var CLASS_ACTIVE = 'gotop-active'; 675 var SCROLL_LIMIT = 80; // corresponds to the header's height (px) 676 677 var button = document.getElementById('gotop'); 678 button.onclick = goBackToTop;
679 document.addEventListener('scroll', toggleGoTopButton); 680 toggleGoTopButton(); 681 682 function toggleGoTopButton() { 683 if (document.documentElement.scrollTop >= SCROLL_LIMIT) { 684 button.classList.add(CLASS_ACTIVE); 685 } else { 686 button.classList.remove(CLASS_ACTIVE); 687 } 688 } 689 /** 690 * @param {Event} event 691 * @returns {void} 692 */ 693 694 695 function goBackToTop(event) { 696 event.preventDefault(); 697 document.documentElement.scrollTop = 0; 698 } 699}; 700 701},{}],14:[function(require,module,exports){ 702'use strict'; 703 704require("core-js/modules/es.array.for-each"); 705 706require("core-js/modules/web.dom-collections.for-each"); 707 708var MIN_SUGGESTION_SIZE = 3; 709var INPUT_DELTA = 100; 710var ESCAPE_KEY = 27; 711var HTTP_STATUS_CODE_OK = 200; 712var SUGGEST_PATH = '/search/suggest'; 713 714var eventsService = require('./events'); 715 716var debounce = require('./debounce.js'); 717 718module.exports = function search() { 719 var form = document.getElementById('header-search-bar'); 720 var suggestionsContainer = document.getElementById('header-search-suggestions-results'); 721 var input = form.querySelector('input'); 722 var hasContent = false; 723 form.appendChild(suggestionsContainer); 724 input.oninput = debounce(processNewInputEvent, INPUT_DELTA); 725 input.onblur = hideSuggestionsContainer; 726 input.onfocus = showSuggestionsContainer; 727 728 input.onkeyup = function (event) { 729 if (event.keyCode === ESCAPE_KEY) { 730 hideSuggestionsContainer(); 731 input.blur(); 732 } 733 }; 734 735 function processNewInputEvent(event) { 736 var text = event.target.value; 737 738 if (text.length >= MIN_SUGGESTION_SIZE) { 739 var request = new window.XMLHttpRequest(); 740 request.open('GET', "".concat(SUGGEST_PATH, "?text=").concat(text)); 741 request.onload = handleSearchSuggestions; 742 request.send(); 743 } else { 744 clearSearchSuggestions(); 745 } 746 } 747 748 function handleSearchSuggestions(event) { 749 if (event.target.status === HTTP_STATUS_CODE_OK) { 750 suggestionsContainer.innerHTML = event.target.responseText;
750 // prevents the mouse click from trigger the input onblur event 751 752 Array.prototype.forEach.call(suggestionsContainer.querySelectorAll('a, #suggestion-did-you-mean'), function (link) { 753 link.onmousedown = function (linkEvent) { 754 return linkEvent.preventDefault(); 755 }; 756 }); 757 var didYouMean = suggestionsContainer.querySelector('#suggestion-did-you-mean'); 758 759 if (didYouMean) { 760 didYouMean.addEventListener('click', function () { 761 input.value = didYouMean.textContent; 762 form.submit(); 763 }); 764 } 765 766 hasContent = true; 767 showSuggestionsContainer(); 768 } else { 769 clearSearchSuggestions(); 770 } 771 } 772 773 function clearSearchSuggestions() { 774 hideSuggestionsContainer(); 775 suggestionsContainer.innerHTML = ''; 776 hasContent = false; 777 } 778 779 function showSuggestionsContainer() { 780 if (hasContent) { 781 suggestionsContainer.classList.add('active'); //monitor clicks on suggestions 782 783 Array.prototype.forEach.call(document.querySelectorAll('#header-search-suggestions-results *[data-event-action]'), function (element) { 784 element.addEventListener('click', eventsService.onTrackedAction); 785 }); 786 } 787 } 788 789 function hideSuggestionsContainer() { 790 suggestionsContainer.classList.remove('active'); 791 } 792}; 793 794},{"./debounce.js":10,"./events":11,"core-js/modules/es.array.for-each":74,"core-js/modules/web.dom-collections.for-each":77}],15:[function(require,module,exports){ 795module.exports = function (it) { 796 if (typeof it != 'function') { 797 throw TypeError(String(it) + ' is not a function'); 798 } return it; 799}; 800 801},{}],16:[function(require,module,exports){ 802var isObject = require('../internals/is-object'); 803 804module.exports = function (it) { 805 if (!isObject(it)) { 806 throw TypeError(String(it) + ' is not an object'); 807 } return it; 808}; 809 810},{"../internals/is-object":44}],17:[function(require,module,exports){ 811'use strict'; 812var $forEach = require('../internals/array-iteration').forEach; 813var arrayMethodIsStrict = require('../internals/array-method-is-strict'); 814var arrayMethodUsesToLength = require('../internals/array-method-uses-to-length'); 815 816var STRICT_METHOD = arrayMethodIsStrict('forEach'); 817var USES_TO_LENGTH = arrayMethodUsesToLength('forEach'); 818 819// `Array.prototype.forEach` method implementation 820// https://tc39.github.io/ecma262/#sec-array.prototype.foreach 821module.exports = (!STRICT_METHOD || !USES_TO_LENGTH) ? function forEach(callbackfn /* , thisArg */) { 822 return $forEach(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined); 823} : [].forEach; 824 825},{"../internals/array-iteration":19,"../internals/array-method-is-strict":20,"../internals/array-method-uses-to-length":21}],18:[function(require,module,exports){ 826var toIndexedObject = require('../internals/to-indexed-object'); 827var toLength = require('../internals/to-length'); 828var toAbsoluteIndex = require('../internals/to-absolute-index'); 829 830// `Array.prototype.{ indexOf, includes }` methods implementation 831var createMethod = function (IS_INCLUDES) { 832 return function ($this, el, fromIndex) { 833 var O = toIndexedObject($this); 834 var length = toLength(O.length); 835 var index = toAbsoluteIndex(fromIndex, length); 836 var value; 837 // Array#includes uses SameValueZero equality algorithm 838 // eslint-disable-next-line no-self-compare 839 if (IS_INCLUDES && el != el) while (length > index) { 840 value = O[index++]; 841 // eslint-disable-next-line no-self-compare 842 if (value != value) return true; 843 // Array#indexOf ignores holes, Array#includes - not 844 } else for (;length > index; index++) { 845 if ((IS_INCLUDES || index in O) && O[index] === el) return IS_INCLUDES || index || 0; 846 } return !IS_INCLUDES && -1; 847 }; 848}; 849 850module.exports = { 851 // `Array.prototype.includes` method 852 // https://tc39.github.io/ecma262/#sec-array.prototype.includes 853 includes: createMethod(true), 854 // `Array.prototype.indexOf` method 855 // https://tc39.github.io/ecma262/#sec-array.prototype.indexof 856 indexOf: createMethod(false) 857}; 858 859},{"../internals/to-absolute-index":64,"../internals/to-indexed-object":65,"../internals/to-length":67}],19:[function(require,module,exports){ 860var bind = require('../internals/function-bind-context'); 861var IndexedObject = require('../internals/indexed-object'); 862var toObject = require('../internals/to-object');
vendor: 8,278 bytes, lines 863-1097
863var toLength = require('../internals/to-length'); 864var arraySpeciesCreate = require('../internals/array-species-create'); 865 866var push = [].push; 867 868// `Array.prototype.{ forEach, map, filter, some, every, find, findIndex }` methods implementation 869var createMethod = function (TYPE) { 870 var IS_MAP = TYPE == 1; 871 var IS_FILTER = TYPE == 2; 872 var IS_SOME = TYPE == 3; 873 var IS_EVERY = TYPE == 4; 874 var IS_FIND_INDEX = TYPE == 6; 875 var NO_HOLES = TYPE == 5 || IS_FIND_INDEX; 876 return function ($this, callbackfn, that, specificCreate) { 877 var O = toObject($this); 878 var self = IndexedObject(O); 879 var boundFunction = bind(callbackfn, that, 3); 880 var length = toLength(self.length); 881 var index = 0; 882 var create = specificCreate || arraySpeciesCreate; 883 var target = IS_MAP ? create($this, length) : IS_FILTER ? create($this, 0) : undefined; 884 var value, result; 885 for (;length > index; index++) if (NO_HOLES || index in self) { 886 value = self[index]; 887 result = boundFunction(value, index, O); 888 if (TYPE) { 889 if (IS_MAP) target[index] = result; // map 890 else if (result) switch (TYPE) { 891 case 3: return true; // some 892 case 5: return value; // find 893 case 6: return index; // findIndex 894 case 2: push.call(target, value); // filter 895 } else if (IS_EVERY) return false; // every 896 } 897 } 898 return IS_FIND_INDEX ? -1 : IS_SOME || IS_EVERY ? IS_EVERY : target; 899 }; 900}; 901 902module.exports = { 903 // `Array.prototype.forEach` method 904 // https://tc39.github.io/ecma262/#sec-array.prototype.foreach 905 forEach: createMethod(0), 906 // `Array.prototype.map` method 907 // https://tc39.github.io/ecma262/#sec-array.prototype.map 908 map: createMethod(1), 909 // `Array.prototype.filter` method 910 // https://tc39.github.io/ecma262/#sec-array.prototype.filter 911 filter: createMethod(2), 912 // `Array.prototype.some` method 913 // https://tc39.github.io/ecma262/#sec-array.prototype.some 914 some: createMethod(3), 915 // `Array.prototype.every` method 916 // https://tc39.github.io/ecma262/#sec-array.prototype.every 917 every: createMethod(4), 918 // `Array.prototype.find` method 919 // https://tc39.github.io/ecma262/#sec-array.prototype.find 920 find: createMethod(5), 921 // `Array.prototype.findIndex` method 922 // https://tc39.github.io/ecma262/#sec-array.prototype.findIndex 923 findIndex: createMethod(6) 924}; 925 926},{"../internals/array-species-create":22,"../internals/function-bind-context":33,"../internals/indexed-object":39,"../internals/to-length":67,"../internals/to-object":68}],20:[function(require,module,exports){ 927'use strict'; 928var fails = require('../internals/fails'); 929 930module.exports = function (METHOD_NAME, argument) { 931 var method = [][METHOD_NAME]; 932 return !!method && fails(function () { 933 // eslint-disable-next-line no-useless-call,no-throw-literal 934 method.call(null, argument || function () { throw 1; }, 1); 935 }); 936}; 937 938},{"../internals/fails":32}],21:[function(require,module,exports){ 939var DESCRIPTORS = require('../internals/descriptors'); 940var fails = require('../internals/fails'); 941var has = require('../internals/has'); 942 943var defineProperty = Object.defineProperty; 944var cache = {}; 945 946var thrower = function (it) { throw it; }; 947 948module.exports = function (METHOD_NAME, options) { 949 if (has(cache, METHOD_NAME)) return cache[METHOD_NAME]; 950 if (!options) options = {}; 951 var method = [][METHOD_NAME]; 952 var ACCESSORS = has(options, 'ACCESSORS') ? options.ACCESSORS : false; 953 var argument0 = has(options, 0) ? options[0] : thrower; 954 var argument1 = has(options, 1) ? options[1] : undefined; 955 956 return cache[METHOD_NAME] = !!method && !fails(function () { 957 if (ACCESSORS && !DESCRIPTORS) return true; 958 var O = { length: -1 }; 959 960 if (ACCESSORS) defineProperty(O, 1, { enumerable: true, get: thrower }); 961 else O[1] = 1; 962 963 method.call(O, argument0, argument1); 964 }); 965}; 966 967},{"../internals/descriptors":27,"../internals/fails":32,"../internals/has":36}],22:[function(require,module,exports){ 968var isObject = require('../internals/is-object'); 969var isArray = require('../internals/is-array'); 970var wellKnownSymbol = require('../internals/well-known-symbol'); 971 972var SPECIES = wellKnownSymbol('species'); 973 974// `ArraySpeciesCreate` abstract operation 975// https://tc39.github.io/ecma262/#sec-arrayspeciescreate 976module.exports = function (originalArray, length) { 977 var C; 978 if (isArray(originalArray)) { 979 C = originalArray.constructor; 980 // cross-realm fallback 981 if (typeof C == 'function' && (C === Array || isArray(C.prototype))) C = undefined; 982 else if (isObject(C)) { 983 C = C[SPECIES]; 984 if (C === null) C = undefined; 985 } 986 } return new (C === undefined ? Array : C)(length === 0 ? 0 : length); 987}; 988 989},{"../internals/is-array":42,"../internals/is-object":44,"../internals/well-known-symbol":72}],23:[function(require,module,exports){ 990var toString = {}.toString; 991 992module.exports = function (it) { 993 return toString.call(it).slice(8, -1); 994}; 995 996},{}],24:[function(require,module,exports){ 997var has = require('../internals/has'); 998var ownKeys = require('../internals/own-keys'); 999var getOwnPropertyDescriptorModule = require('../internals/object-get-own-property-descriptor'); 1000var definePropertyModule = require('../internals/object-define-property'); 1001 1002module.exports = function (target, source) { 1003 var keys = ownKeys(source); 1004 var defineProperty = definePropertyModule.f; 1005 var getOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f; 1006 for (var i = 0; i < keys.length; i++) { 1007 var key = keys[i]; 1008 if (!has(target, key)) defineProperty(target, key, getOwnPropertyDescriptor(source, key)); 1009 } 1010}; 1011 1012},{"../internals/has":36,"../internals/object-define-property":48,"../internals/object-get-own-property-descriptor":49,"../internals/own-keys":54}],25:[function(require,module,exports){ 1013var DESCRIPTORS = require('../internals/descriptors'); 1014var definePropertyModule = require('../internals/object-define-property'); 1015var createPropertyDescriptor = require('../internals/create-property-descriptor'); 1016 1017module.exports = DESCRIPTORS ? function (object, key, value) { 1018 return definePropertyModule.f(object, key, createPropertyDescriptor(1, value)); 1019} : function (object, key, value) { 1020 object[key] = value; 1021 return object; 1022}; 1023 1024},{"../internals/create-property-descriptor":26,"../internals/descriptors":27,"../internals/object-define-property":48}],26:[function(require,module,exports){ 1025module.exports = function (bitmap, value) { 1026 return { 1027 enumerable: !(bitmap & 1), 1028 configurable: !(bitmap & 2), 1029 writable: !(bitmap & 4), 1030 value: value 1031 }; 1032}; 1033 1034},{}],27:[function(require,module,exports){ 1035var fails = require('../internals/fails'); 1036 1037// Thank's IE8 for his funny defineProperty 1038module.exports = !fails(function () { 1039 return Object.defineProperty({}, 1, { get: function () { return 7; } })[1] != 7; 1040}); 1041 1042},{"../internals/fails":32}],28:[function(require,module,exports){ 1043var global = require('../internals/global'); 1044var isObject = require('../internals/is-object'); 1045 1046var document = global.document; 1047// typeof document.createElement is 'object' in old IE 1048var EXISTS = isObject(document) && isObject(document.createElement); 1049 1050module.exports = function (it) { 1051 return EXISTS ? document.createElement(it) : {}; 1052}; 1053 1054},{"../internals/global":35,"../internals/is-object":44}],29:[function(require,module,exports){ 1055// iterable DOM collections 1056// flag - `iterable` interface - 'entries', 'keys', 'values', 'forEach' methods 1057module.exports = { 1058 CSSRuleList: 0, 1059 CSSStyleDeclaration: 0, 1060 CSSValueList: 0, 1061 ClientRectList: 0, 1062 DOMRectList: 0, 1063 DOMStringList: 0, 1064 DOMTokenList: 1, 1065 DataTransferItemList: 0, 1066 FileList: 0, 1067 HTMLAllCollection: 0, 1068 HTMLCollection: 0, 1069 HTMLFormElement: 0, 1070 HTMLSelectElement: 0, 1071 MediaList: 0, 1072 MimeTypeArray: 0, 1073 NamedNodeMap: 0, 1074 NodeList: 1, 1075 PaintRequestList: 0, 1076 Plugin: 0, 1077 PluginArray: 0, 1078 SVGLengthList: 0, 1079 SVGNumberList: 0, 1080 SVGPathSegList: 0, 1081 SVGPointList: 0, 1082 SVGStringList: 0, 1083 SVGTransformList: 0, 1084 SourceBufferList: 0, 1085 StyleSheetList: 0, 1086 TextTrackCueList: 0, 1087 TextTrackList: 0, 1088 TouchList: 0 1089}; 1090 1091},{}],30:[function(require,module,exports){ 1092// IE8- don't enum bug keys 1093module.exports = [ 1094 'constructor', 1095 'hasOwnProperty', 1096 'isPrototypeOf', 1097 'propertyIsEnumerable',
vendor: 19,064 bytes, lines 1098-1595
1098 'toLocaleString', 1099 'toString', 1100 'valueOf' 1101]; 1102 1103},{}],31:[function(require,module,exports){ 1104var global = require('../internals/global'); 1105var getOwnPropertyDescriptor = require('../internals/object-get-own-property-descriptor').f; 1106var createNonEnumerableProperty = require('../internals/create-non-enumerable-property'); 1107var redefine = require('../internals/redefine'); 1108var setGlobal = require('../internals/set-global'); 1109var copyConstructorProperties = require('../internals/copy-constructor-properties'); 1110var isForced = require('../internals/is-forced'); 1111 1112/* 1113 options.target - name of the target object 1114 options.global - target is the global object 1115 options.stat - export as static methods of target 1116 options.proto - export as prototype methods of target 1117 options.real - real prototype method for the `pure` version 1118 options.forced - export even if the native feature is available 1119 options.bind - bind methods to the target, required for the `pure` version 1120 options.wrap - wrap constructors to preventing global pollution, required for the `pure` version 1121 options.unsafe - use the simple assignment of property instead of delete + defineProperty 1122 options.sham - add a flag to not completely full polyfills 1123 options.enumerable - export as enumerable property 1124 options.noTargetGet - prevent calling a getter on target 1125*/ 1126module.exports = function (options, source) { 1127 var TARGET = options.target; 1128 var GLOBAL = options.global; 1129 var STATIC = options.stat; 1130 var FORCED, target, key, targetProperty, sourceProperty, descriptor; 1131 if (GLOBAL) { 1132 target = global; 1133 } else if (STATIC) { 1134 target = global[TARGET] || setGlobal(TARGET, {}); 1135 } else { 1136 target = (global[TARGET] || {}).prototype; 1137 } 1138 if (target) for (key in source) { 1139 sourceProperty = source[key]; 1140 if (options.noTargetGet) { 1141 descriptor = getOwnPropertyDescriptor(target, key); 1142 targetProperty = descriptor && descriptor.value; 1143 } else targetProperty = target[key]; 1144 FORCED = isForced(GLOBAL ? key : TARGET + (STATIC ? '.' : '#') + key, options.forced); 1145 // contained in target 1146 if (!FORCED && targetProperty !== undefined) { 1147 if (typeof sourceProperty === typeof targetProperty) continue; 1148 copyConstructorProperties(sourceProperty, targetProperty); 1149 } 1150 // add a flag to not completely full polyfills 1151 if (options.sham || (targetProperty && targetProperty.sham)) { 1152 createNonEnumerableProperty(sourceProperty, 'sham', true); 1153 } 1154 // extend global 1155 redefine(target, key, sourceProperty, options); 1156 } 1157}; 1158 1159},{"../internals/copy-constructor-properties":24,"../internals/create-non-enumerable-property":25,"../internals/global":35,"../internals/is-forced":43,"../internals/object-get-own-property-descriptor":49,"../internals/redefine":56,"../internals/set-global":58}],32:[function(require,module,exports){ 1160module.exports = function (exec) { 1161 try { 1162 return !!exec(); 1163 } catch (error) { 1164 return true; 1165 } 1166}; 1167 1168},{}],33:[function(require,module,exports){ 1169var aFunction = require('../internals/a-function'); 1170 1171// optional / simple context binding 1172module.exports = function (fn, that, length) { 1173 aFunction(fn); 1174 if (that === undefined) return fn; 1175 switch (length) { 1176 case 0: return function () { 1177 return fn.call(that); 1178 }; 1179 case 1: return function (a) { 1180 return fn.call(that, a); 1181 }; 1182 case 2: return function (a, b) { 1183 return fn.call(that, a, b); 1184 }; 1185 case 3: return function (a, b, c) { 1186 return fn.call(that, a, b, c); 1187 }; 1188 } 1189 return function (/* ...args */) { 1190 return fn.apply(that, arguments); 1191 }; 1192}; 1193 1194},{"../internals/a-function":15}],34:[function(require,module,exports){ 1195var path = require('../internals/path'); 1196var global = require('../internals/global'); 1197 1198var aFunction = function (variable) { 1199 return typeof variable == 'function' ? variable : undefined; 1200}; 1201 1202module.exports = function (namespace, method) { 1203 return arguments.length < 2 ? aFunction(path[namespace]) || aFunction(global[namespace]) 1204 : path[namespace] && path[namespace][method] || global[namespace] && global[namespace][method]; 1205}; 1206 1207},{"../internals/global":35,"../internals/path":55}],35:[function(require,module,exports){ 1208(function (global){ 1209var check = function (it) { 1210 return it && it.Math == Math && it; 1211}; 1212 1213// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028 1214module.exports = 1215 // eslint-disable-next-line no-undef 1216 check(typeof globalThis == 'object' && globalThis) || 1217 check(typeof window == 'object' && window) || 1218 check(typeof self == 'object' && self) || 1219 check(typeof global == 'object' && global) || 1220 // eslint-disable-next-line no-new-func 1221 Function('return this')(); 1222 1223}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) 1224 1225},{}],36:[function(require,module,exports){ 1226var hasOwnProperty = {}.hasOwnProperty; 1227 1228module.exports = function (it, key) { 1229 return hasOwnProperty.call(it, key); 1230}; 1231 1232},{}],37:[function(require,module,exports){ 1233module.exports = {}; 1234 1235},{}],38:[function(require,module,exports){ 1236var DESCRIPTORS = require('../internals/descriptors'); 1237var fails = require('../internals/fails'); 1238var createElement = require('../internals/document-create-element'); 1239 1240// Thank's IE8 for his funny defineProperty 1241module.exports = !DESCRIPTORS && !fails(function () { 1242 return Object.defineProperty(createElement('div'), 'a', { 1243 get: function () { return 7; } 1244 }).a != 7; 1245}); 1246 1247},{"../internals/descriptors":27,"../internals/document-create-element":28,"../internals/fails":32}],39:[function(require,module,exports){ 1248var fails = require('../internals/fails'); 1249var classof = require('../internals/classof-raw'); 1250 1251var split = ''.split; 1252 1253// fallback for non-array-like ES3 and non-enumerable old V8 strings 1254module.exports = fails(function () { 1255 // throws an error in rhino, see https://github.com/mozilla/rhino/issues/346 1256 // eslint-disable-next-line no-prototype-builtins 1257 return !Object('z').propertyIsEnumerable(0); 1258}) ? function (it) { 1259 return classof(it) == 'String' ? split.call(it, '') : Object(it); 1260} : Object; 1261 1262},{"../internals/classof-raw":23,"../internals/fails":32}],40:[function(require,module,exports){ 1263var store = require('../internals/shared-store'); 1264 1265var functionToString = Function.toString; 1266 1267// this helper broken in `3.4.1-3.4.4`, so we can't use `shared` helper 1268if (typeof store.inspectSource != 'function') { 1269 store.inspectSource = function (it) { 1270 return functionToString.call(it); 1271 }; 1272} 1273 1274module.exports = store.inspectSource; 1275 1276},{"../internals/shared-store":60}],41:[function(require,module,exports){ 1277var NATIVE_WEAK_MAP = require('../internals/native-weak-map'); 1278var global = require('../internals/global'); 1279var isObject = require('../internals/is-object'); 1280var createNonEnumerableProperty = require('../internals/create-non-enumerable-property'); 1281var objectHas = require('../internals/has'); 1282var sharedKey = require('../internals/shared-key'); 1283var hiddenKeys = require('../internals/hidden-keys'); 1284 1285var WeakMap = global.WeakMap; 1286var set, get, has; 1287 1288var enforce = function (it) { 1289 return has(it) ? get(it) : set(it, {}); 1290}; 1291 1292var getterFor = function (TYPE) { 1293 return function (it) { 1294 var state; 1295 if (!isObject(it) || (state = get(it)).type !== TYPE) { 1296 throw TypeError('Incompatible receiver, ' + TYPE + ' required'); 1297 } return state; 1298 }; 1299}; 1300 1301if (NATIVE_WEAK_MAP) { 1302 var store = new WeakMap(); 1303 var wmget = store.get; 1304 var wmhas = store.has; 1305 var wmset = store.set; 1306 set = function (it, metadata) { 1307 wmset.call(store, it, metadata); 1308 return metadata; 1309 }; 1310 get = function (it) { 1311 return wmget.call(store, it) || {}; 1312 }; 1313 has = function (it) { 1314 return wmhas.call(store, it); 1315 }; 1316} else { 1317 var STATE = sharedKey('state'); 1318 hiddenKeys[STATE] = true; 1319 set = function (it, metadata) { 1320 createNonEnumerableProperty(it, STATE, metadata); 1321 return metadata; 1322 }; 1323 get = function (it) { 1324 return objectHas(it, STATE) ? it[STATE] : {}; 1325 }; 1326 has = function (it) { 1327 return objectHas(it, STATE); 1328 }; 1329} 1330 1331module.exports = { 1332 set: set, 1333 get: get, 1334 has: has, 1335 enforce: enforce, 1336 getterFor: getterFor 1337}; 1338 1339},{"../internals/create-non-enumerable-property":25,"../internals/global":35,"../internals/has":36,"../internals/hidden-keys":37,"../internals/is-object":44,"../internals/native-weak-map":47,"../internals/shared-key":59}],42:[function(require,module,exports){ 1340var classof = require('../internals/classof-raw'); 1341 1342// `IsArray` abstract operation 1343// https://tc39.github.io/ecma262/#sec-isarray 1344module.exports = Array.isArray || function isArray(arg) { 1345 return classof(arg) == 'Array'; 1346}; 1347 1348},{"../internals/classof-raw":23}],43:[function(require,module,exports){ 1349var fails = require('../internals/fails'); 1350 1351var replacement = /#|\.prototype\./; 1352 1353var isForced = function (feature, detection) { 1354 var value = data[normalize(feature)]; 1355 return value == POLYFILL ? true 1356 : value == NATIVE ? false 1357 : typeof detection == 'function' ? fails(detection) 1358 : !!detection; 1359}; 1360 1361var normalize = isForced.normalize = function (string) { 1362 return String(string).replace(replacement, '.').toLowerCase(); 1363}; 1364 1365var data = isForced.data = {}; 1366var NATIVE = isForced.NATIVE = 'N'; 1367var POLYFILL = isForced.POLYFILL = 'P'; 1368 1369module.exports = isForced; 1370 1371},{"../internals/fails":32}],44:[function(require,module,exports){ 1372module.exports = function (it) { 1373 return typeof it === 'object' ? it !== null : typeof it === 'function'; 1374}; 1375 1376},{}],45:[function(require,module,exports){ 1377module.exports = false; 1378 1379},{}],46:[function(require,module,exports){ 1380var fails = require('../internals/fails'); 1381 1382module.exports = !!Object.getOwnPropertySymbols && !fails(function () { 1383 // Chrome 38 Symbol has incorrect toString conversion 1384 // eslint-disable-next-line no-undef 1385 return !String(Symbol()); 1386}); 1387 1388},{"../internals/fails":32}],47:[function(require,module,exports){ 1389var global = require('../internals/global'); 1390var inspectSource = require('../internals/inspect-source'); 1391 1392var WeakMap = global.WeakMap; 1393 1394module.exports = typeof WeakMap === 'function' && /native code/.test(inspectSource(WeakMap)); 1395 1396},{"../internals/global":35,"../internals/inspect-source":40}],48:[function(require,module,exports){ 1397var DESCRIPTORS = require('../internals/descriptors'); 1398var IE8_DOM_DEFINE = require('../internals/ie8-dom-define'); 1399var anObject = require('../internals/an-object'); 1400var toPrimitive = require('../internals/to-primitive'); 1401 1402var nativeDefineProperty = Object.defineProperty; 1403 1404// `Object.defineProperty` method 1405// https://tc39.github.io/ecma262/#sec-object.defineproperty 1406exports.f = DESCRIPTORS ? nativeDefineProperty : function defineProperty(O, P, Attributes) { 1407 anObject(O); 1408 P = toPrimitive(P, true); 1409 anObject(Attributes); 1410 if (IE8_DOM_DEFINE) try { 1411 return nativeDefineProperty(O, P, Attributes); 1412 } catch (error) { /* empty */ } 1413 if ('get' in Attributes || 'set' in Attributes) throw TypeError('Accessors not supported'); 1414 if ('value' in Attributes) O[P] = Attributes.value; 1415 return O; 1416}; 1417 1418},{"../internals/an-object":16,"../internals/descriptors":27,"../internals/ie8-dom-define":38,"../internals/to-primitive":69}],49:[function(require,module,exports){ 1419var DESCRIPTORS = require('../internals/descriptors'); 1420var propertyIsEnumerableModule = require('../internals/object-property-is-enumerable'); 1421var createPropertyDescriptor = require('../internals/create-property-descriptor'); 1422var toIndexedObject = require('../internals/to-indexed-object'); 1423var toPrimitive = require('../internals/to-primitive'); 1424var has = require('../internals/has'); 1425var IE8_DOM_DEFINE = require('../internals/ie8-dom-define'); 1426 1427var nativeGetOwnPropertyDescriptor = Object.getOwnPropertyDescriptor; 1428 1429// `Object.getOwnPropertyDescriptor` method 1430// https://tc39.github.io/ecma262/#sec-object.getownpropertydescriptor 1431exports.f = DESCRIPTORS ? nativeGetOwnPropertyDescriptor : function getOwnPropertyDescriptor(O, P) { 1432 O = toIndexedObject(O); 1433 P = toPrimitive(P, true); 1434 if (IE8_DOM_DEFINE) try { 1435 return nativeGetOwnPropertyDescriptor(O, P); 1436 } catch (error) { /* empty */ } 1437 if (has(O, P)) return createPropertyDescriptor(!propertyIsEnumerableModule.f.call(O, P), O[P]); 1438}; 1439 1440},{"../internals/create-property-descriptor":26,"../internals/descriptors":27,"../internals/has":36,"../internals/ie8-dom-define":38,"../internals/object-property-is-enumerable":53,"../internals/to-indexed-object":65,"../internals/to-primitive":69}],50:[function(require,module,exports){ 1441var internalObjectKeys = require('../internals/object-keys-internal'); 1442var enumBugKeys = require('../internals/enum-bug-keys'); 1443 1444var hiddenKeys = enumBugKeys.concat('length', 'prototype'); 1445 1446// `Object.getOwnPropertyNames` method 1447// https://tc39.github.io/ecma262/#sec-object.getownpropertynames 1448exports.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O) { 1449 return internalObjectKeys(O, hiddenKeys); 1450}; 1451 1452},{"../internals/enum-bug-keys":30,"../internals/object-keys-internal":52}],51:[function(require,module,exports){ 1453exports.f = Object.getOwnPropertySymbols; 1454 1455},{}],52:[function(require,module,exports){ 1456var has = require('../internals/has'); 1457var toIndexedObject = require('../internals/to-indexed-object'); 1458var indexOf = require('../internals/array-includes').indexOf; 1459var hiddenKeys = require('../internals/hidden-keys'); 1460 1461module.exports = function (object, names) { 1462 var O = toIndexedObject(object); 1463 var i = 0; 1464 var result = []; 1465 var key; 1466 for (key in O) !has(hiddenKeys, key) && has(O, key) && result.push(key); 1467 // Don't enum bug & hidden keys 1468 while (names.length > i) if (has(O, key = names[i++])) { 1469 ~indexOf(result, key) || result.push(key); 1470 } 1471 return result; 1472}; 1473 1474},{"../internals/array-includes":18,"../internals/has":36,"../internals/hidden-keys":37,"../internals/to-indexed-object":65}],53:[function(require,module,exports){ 1475'use strict'; 1476var nativePropertyIsEnumerable = {}.propertyIsEnumerable; 1477var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor; 1478 1479// Nashorn ~ JDK8 bug 1480var NASHORN_BUG = getOwnPropertyDescriptor && !nativePropertyIsEnumerable.call({ 1: 2 }, 1); 1481 1482// `Object.prototype.propertyIsEnumerable` method implementation 1483// https://tc39.github.io/ecma262/#sec-object.prototype.propertyisenumerable 1484exports.f = NASHORN_BUG ? function propertyIsEnumerable(V) { 1485 var descriptor = getOwnPropertyDescriptor(this, V); 1486 return !!descriptor && descriptor.enumerable; 1487} : nativePropertyIsEnumerable; 1488 1489},{}],54:[function(require,module,exports){ 1490var getBuiltIn = require('../internals/get-built-in'); 1491var getOwnPropertyNamesModule = require('../internals/object-get-own-property-names'); 1492var getOwnPropertySymbolsModule = require('../internals/object-get-own-property-symbols'); 1493var anObject = require('../internals/an-object'); 1494 1495// all object keys, includes non-enumerable and symbols 1496module.exports = getBuiltIn('Reflect', 'ownKeys') || function ownKeys(it) { 1497 var keys = getOwnPropertyNamesModule.f(anObject(it)); 1498 var getOwnPropertySymbols = getOwnPropertySymbolsModule.f; 1499 return getOwnPropertySymbols ? keys.concat(getOwnPropertySymbols(it)) : keys; 1500}; 1501 1502},{"../internals/an-object":16,"../internals/get-built-in":34,"../internals/object-get-own-property-names":50,"../internals/object-get-own-property-symbols":51}],55:[function(require,module,exports){ 1503var global = require('../internals/global'); 1504 1505module.exports = global; 1506 1507},{"../internals/global":35}],56:[function(require,module,exports){ 1508var global = require('../internals/global'); 1509var createNonEnumerableProperty = require('../internals/create-non-enumerable-property'); 1510var has = require('../internals/has'); 1511var setGlobal = require('../internals/set-global'); 1512var inspectSource = require('../internals/inspect-source'); 1513var InternalStateModule = require('../internals/internal-state'); 1514 1515var getInternalState = InternalStateModule.get; 1516var enforceInternalState = InternalStateModule.enforce; 1517var TEMPLATE = String(String).split('String'); 1518 1519(module.exports = function (O, key, value, options) { 1520 var unsafe = options ? !!options.unsafe : false; 1521 var simple = options ? !!options.enumerable : false; 1522 var noTargetGet = options ? !!options.noTargetGet : false; 1523 if (typeof value == 'function') { 1524 if (typeof key == 'string' && !has(value, 'name')) createNonEnumerableProperty(value, 'name', key); 1525 enforceInternalState(value).source = TEMPLATE.join(typeof key == 'string' ? key : ''); 1526 } 1527 if (O === global) { 1528 if (simple) O[key] = value; 1529 else setGlobal(key, value); 1530 return; 1531 } else if (!unsafe) { 1532 delete O[key]; 1533 } else if (!noTargetGet && O[key]) { 1534 simple = true; 1535 } 1536 if (simple) O[key] = value; 1537 else createNonEnumerableProperty(O, key, value); 1538// add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative 1539})(Function.prototype, 'toString', function toString() { 1540 return typeof this == 'function' && getInternalState(this).source || inspectSource(this); 1541}); 1542 1543},{"../internals/create-non-enumerable-property":25,"../internals/global":35,"../internals/has":36,"../internals/inspect-source":40,"../internals/internal-state":41,"../internals/set-global":58}],57:[function(require,module,exports){ 1544// `RequireObjectCoercible` abstract operation 1545// https://tc39.github.io/ecma262/#sec-requireobjectcoercible 1546module.exports = function (it) { 1547 if (it == undefined) throw TypeError("Can't call method on " + it); 1548 return it; 1549}; 1550 1551},{}],58:[function(require,module,exports){ 1552var global = require('../internals/global'); 1553var createNonEnumerableProperty = require('../internals/create-non-enumerable-property'); 1554 1555module.exports = function (key, value) { 1556 try { 1557 createNonEnumerableProperty(global, key, value); 1558 } catch (error) { 1559 global[key] = value; 1560 } return value; 1561}; 1562 1563},{"../internals/create-non-enumerable-property":25,"../internals/global":35}],59:[function(require,module,exports){ 1564var shared = require('../internals/shared'); 1565var uid = require('../internals/uid'); 1566 1567var keys = shared('keys'); 1568 1569module.exports = function (key) { 1570 return keys[key] || (keys[key] = uid(key)); 1571}; 1572 1573},{"../internals/shared":61,"../internals/uid":70}],60:[function(require,module,exports){ 1574var global = require('../internals/global'); 1575var setGlobal = require('../internals/set-global'); 1576 1577var SHARED = '__core-js_shared__'; 1578var store = global[SHARED] || setGlobal(SHARED, {}); 1579 1580module.exports = store; 1581 1582},{"../internals/global":35,"../internals/set-global":58}],61:[function(require,module,exports){ 1583var IS_PURE = require('../internals/is-pure'); 1584var store = require('../internals/shared-store'); 1585 1586(module.exports = function (key, value) { 1587 return store[key] || (store[key] = value !== undefined ? value : {}); 1588})('versions', []).push({ 1589 version: '3.6.5', 1590 mode: IS_PURE ? 'pure' : 'global', 1591 copyright: '© 2020 Denis Pushkarev (zloirock.ru)' 1592}); 1593 1594},{"../internals/is-pure":45,"../internals/shared-store":60}],62:[function(require,module,exports){ 1595var fails = require('../internals/fails');
1596var whitespaces = require('../internals/whitespaces'); 1597 1598var non = '\u200B\u0085\u180E'; 1599 1600// check that a method works with the correct list 1601// of whitespaces and has a correct name 1602module.exports = function (METHOD_NAME) { 1603 return fails(function () { 1604 return !!whitespaces[METHOD_NAME]() || non[METHOD_NAME]() != non || whitespaces[METHOD_NAME].name !== METHOD_NAME; 1605 }); 1606}; 1607 1608},{"../internals/fails":32,"../internals/whitespaces":73}],63:[function(require,module,exports){ 1609var requireObjectCoercible = require('../internals/require-object-coercible'); 1610var whitespaces = require('../internals/whitespaces'); 1611 1612var whitespace = '[' + whitespaces + ']'; 1613var ltrim = RegExp('^' + whitespace + whitespace + '*'); 1614var rtrim = RegExp(whitespace + whitespace + '*$'); 1615 1616// `String.prototype.{ trim, trimStart, trimEnd, trimLeft, trimRight }` methods implementation 1617var createMethod = function (TYPE) { 1618 return function ($this) { 1619 var string = String(requireObjectCoercible($this)); 1620 if (TYPE & 1) string = string.replace(ltrim, ''); 1621 if (TYPE & 2) string = string.replace(rtrim, ''); 1622 return string; 1623 }; 1624}; 1625 1626module.exports = { 1627 // `String.prototype.{ trimLeft, trimStart }` methods 1628 // https://tc39.github.io/ecma262/#sec-string.prototype.trimstart 1629 start: createMethod(1), 1630 // `String.prototype.{ trimRight, trimEnd }` methods 1631 // https://tc39.github.io/ecma262/#sec-string.prototype.trimend 1632 end: createMethod(2), 1633 // `String.prototype.trim` method 1634 // https://tc39.github.io/ecma262/#sec-string.prototype.trim 1635 trim: createMethod(3) 1636}; 1637 1638},{"../internals/require-object-coercible":57,"../internals/whitespace
vendor: 4,317 bytes, lines 1638-1743
1638s":73}],64:[function(require,module,exports){ 1639var toInteger = require('../internals/to-integer'); 1640 1641var max = Math.max; 1642var min = Math.min; 1643 1644// Helper for a popular repeating case of the spec: 1645// Let integer be ? ToInteger(index). 1646// If integer < 0, let result be max((length + integer), 0); else let result be min(integer, length). 1647module.exports = function (index, length) { 1648 var integer = toInteger(index); 1649 return integer < 0 ? max(integer + length, 0) : min(integer, length); 1650}; 1651 1652},{"../internals/to-integer":66}],65:[function(require,module,exports){ 1653// toObject with fallback for non-array-like ES3 strings 1654var IndexedObject = require('../internals/indexed-object'); 1655var requireObjectCoercible = require('../internals/require-object-coercible'); 1656 1657module.exports = function (it) { 1658 return IndexedObject(requireObjectCoercible(it)); 1659}; 1660 1661},{"../internals/indexed-object":39,"../internals/require-object-coercible":57}],66:[function(require,module,exports){ 1662var ceil = Math.ceil; 1663var floor = Math.floor; 1664 1665// `ToInteger` abstract operation 1666// https://tc39.github.io/ecma262/#sec-tointeger 1667module.exports = function (argument) { 1668 return isNaN(argument = +argument) ? 0 : (argument > 0 ? floor : ceil)(argument); 1669}; 1670 1671},{}],67:[function(require,module,exports){ 1672var toInteger = require('../internals/to-integer'); 1673 1674var min = Math.min; 1675 1676// `ToLength` abstract operation 1677// https://tc39.github.io/ecma262/#sec-tolength 1678module.exports = function (argument) { 1679 return argument > 0 ? min(toInteger(argument), 0x1FFFFFFFFFFFFF) : 0; // 2 ** 53 - 1 == 9007199254740991 1680}; 1681 1682},{"../internals/to-integer":66}],68:[function(require,module,exports){ 1683var requireObjectCoercible = require('../internals/require-object-coercible'); 1684 1685// `ToObject` abstract operation 1686// https://tc39.github.io/ecma262/#sec-toobject 1687module.exports = function (argument) { 1688 return Object(requireObjectCoercible(argument)); 1689}; 1690 1691},{"../internals/require-object-coercible":57}],69:[function(require,module,exports){ 1692var isObject = require('../internals/is-object'); 1693 1694// `ToPrimitive` abstract operation 1695// https://tc39.github.io/ecma262/#sec-toprimitive 1696// instead of the ES6 spec version, we didn't implement @@toPrimitive case 1697// and the second argument - flag - preferred type is a string 1698module.exports = function (input, PREFERRED_STRING) { 1699 if (!isObject(input)) return input; 1700 var fn, val; 1701 if (PREFERRED_STRING && typeof (fn = input.toString) == 'function' && !isObject(val = fn.call(input))) return val; 1702 if (typeof (fn = input.valueOf) == 'function' && !isObject(val = fn.call(input))) return val; 1703 if (!PREFERRED_STRING && typeof (fn = input.toString) == 'function' && !isObject(val = fn.call(input))) return val; 1704 throw TypeError("Can't convert object to primitive value"); 1705}; 1706 1707},{"../internals/is-object":44}],70:[function(require,module,exports){ 1708var id = 0; 1709var postfix = Math.random(); 1710 1711module.exports = function (key) { 1712 return 'Symbol(' + String(key === undefined ? '' : key) + ')_' + (++id + postfix).toString(36); 1713}; 1714 1715},{}],71:[function(require,module,exports){ 1716var NATIVE_SYMBOL = require('../internals/native-symbol'); 1717 1718module.exports = NATIVE_SYMBOL 1719 // eslint-disable-next-line no-undef 1720 && !Symbol.sham 1721 // eslint-disable-next-line no-undef 1722 && typeof Symbol.iterator == 'symbol'; 1723 1724},{"../internals/native-symbol":46}],72:[function(require,module,exports){ 1725var global = require('../internals/global'); 1726var shared = require('../internals/shared'); 1727var has = require('../internals/has'); 1728var uid = require('../internals/uid'); 1729var NATIVE_SYMBOL = require('../internals/native-symbol'); 1730var USE_SYMBOL_AS_UID = require('../internals/use-symbol-as-uid'); 1731 1732var WellKnownSymbolsStore = shared('wks'); 1733var Symbol = global.Symbol; 1734var createWellKnownSymbol = USE_SYMBOL_AS_UID ? Symbol : Symbol && Symbol.withoutSetter || uid; 1735 1736module.exports = function (name) { 1737 if (!has(WellKnownSymbolsStore, name)) { 1738 if (NATIVE_SYMBOL && has(Symbol, name)) WellKnownSymbolsStore[name] = Symbol[name]; 1739 else WellKnownSymbolsStore[name] = createWellKnownSymbol('Symbol.' + name); 1740 } return WellKnownSymbolsStore[name]; 1741}; 1742 1743},{"../internals/global":35,"../internals/has":36,"../internals/native-symbol":46,"../internals/shared":61,"../internals/uid":70,"../internals/use-symbol-as-uid":71}],73:[function(require,module,exports){
1744// a string of all valid unicode whitespaces 1745// eslint-disable-next-line max-len 1746module.exports = '\u0009\u000A\u000B\u000C\u000D\u0020\u00A0\u1680\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\u2028\u2029\uFEFF'; 1747 1748},{}],74:[function(require,module,exports){ 1749'use strict'; 1750var $ = require('../internals/export'); 1751var forEach = require('../internals/array-for-each'); 1752 1753// `Array.prototype.forEach` method 1754// https://tc39.github.io/ecma262/#sec-array.prototype.foreach 1755$({ target: 'Array', proto: true, forced: [].forEach != forEach }, { 1756 forEach: forEach 1757}); 1758 1759},{"../internals/array-for-each":17,"../internals/export":31}],75:[function(require,module,exports){ 1760'use strict'; 1761var $ = require('../internals/export'); 1762var $indexOf = require('../internals/array-includes').indexOf; 1763var arrayMethodIsStrict = require('../internals/array-method-is-strict'); 1764var arrayMethodUsesToLength = require('../internals/array-method-uses-to-length'); 1765 1766var nativeIndexOf = [].indexOf; 1767 1768var NEGATIVE_ZERO = !!nativeIndexOf && 1 / [1].indexOf(1, -0) < 0; 1769var STRICT_METHOD = arrayMethodIsStrict('indexOf'); 1770var USES_TO_LENGTH = arrayMethodUsesToLength('indexOf', { ACCESSORS: true, 1: 0 }); 1771 1772// `Array.prototype.indexOf` method 1773// https://tc39.github.io/ecma262/#sec-array.prototype.indexof 1774$({ target: 'Array', proto: true, forced: NEGATIVE_ZERO || !STRICT_METHOD || !USES_TO_LENGTH }, { 1775 indexOf: function indexOf(searchElement /* , fromIndex = 0 */) { 1776 return NEGATIVE_ZERO 1777 // convert -0 to +0 1778 ? nativeIndexOf.apply(this, arguments) || 0 1779 : $indexOf(this, searchElement, arguments.length > 1 ? arguments[1] : undefined); 1780 } 1781}); 1782 1783},{"../internals/array-includes":18,"../internals/array-method-is-strict":20,"../internals/array-method-uses-to-length":21,"../internals/export":31}],76:[function(require,module,exports){ 1784'use strict'; 1785var $ = require('../internals/export'); 1786var $trim = require('../internals/string-trim').trim; 1787var forcedStringTrimMethod = require('../internals/string-trim-forced'); 1788 1789// `String.prototype.trim` method 1790// https://tc39.github.io/ecma262/#sec-string.prototype.trim 1791$({ target: 'String', proto: true, forced: forcedStringTrimMethod('trim') }, { 1792 trim: function trim() { 1793 return $trim(this); 1794 } 1795}); 1796 1797},{"../internals/export":31,"../internals/string-trim":63,"../internals/string-trim-forced":62}],77:[function(require,module,exports){ 1798var global = require('../internals/global'); 1799var DOMIterables = require('../internals/dom-iterables'); 1800var forEach = require('../internals/array-for-each'); 1801var createNonEnumerableProperty = require('../internals/create-non-enumerable-property'); 1802 1803for (var COLLECTION_NAME in DOMIterables) { 1804 var Collection = global[COLLECTION_NAME]; 1805 var CollectionPrototype = Collection && Collection.prototype; 1806 // some Chrome versions have non-configurable methods on DOMTokenList 1807 if (CollectionPrototype && CollectionPrototype.forEach !== forEach) try { 1808 createNonEnumerableProperty(CollectionPrototype, 'forEach', forEach); 1809 } catch (error) { 1810 CollectionPrototype.forEach = forEach; 1811 } 1812} 1813 1814},{"../internals/array-for-each":17,"../internals/create-non-enumerable-property":25,"../internals/dom-iterables":29,"../internals/global":35}],78:[function(require,module,exports){ 1815(function webpackUniversalModuleDefinition(root, factory) { 1816 if(typeof exports === 'object' && typeof module === 'object') 1817 module.exports = factory(); 1818 else if(typeof define === 'function' && define.amd) 1819 define([], factory); 1820 else { 1821 var a = factory(); 1822 for(var i in a) (typeof exports === 'object' ? exports : root)[i] = a[i]; 1823 } 1824})(typeof self !== 'undefined' ? self : this, function() { 1825return /******/ (function(modules) { // webpackBootstrap 1826/******/ // The module cache 1827/******/ var installedModules = {}; 1828/******/ 1829/******/ // The require function 1830/******/ function __webpack_require__(moduleId) { 1831/******/ 1832/******/ // Check if module is in cache 1833/******/ if(installedModules[moduleId]) { 1834/******/ return installedModules[moduleId].exports; 1835/******/ } 1836/******/ // Create a new module (and put it into the cache) 1837/******/ var module = installedModules[moduleId] = { 1838/******/ i: moduleId, 1839/******/ l: false, 1840/******/ exports: {} 1841/******/ }; 1842/******/ 1843/******/ // Execute the module function 1844/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__); 1845/******/ 1846/******/ // Flag the module as loaded
1847/******/ module.l = true; 1848/******/ 1849/******/ // Return the exports of the module 1850/******/ return module.exports; 1851/******/ } 1852/******/ 1853/******/ 1854/******/ // expose the modules object (__webpack_modules__) 1855/******/ __webpack_require__.m = modules; 1856/******/ 1857/******/ // expose the module cache 1858/******/ __webpack_require__.c = installedModules; 1859/******/ 1860/******/ // define getter function for harmony exports 1861/******/ __webpack_require__.d = function(exports, name, getter) { 1862/******/ if(!__webpack_require__.o(exports, name)) { 1863/******/ Object.defineProperty(exports, name, { 1864/******/ configurable: false, 1865/******/ enumerable: true, 1866/******/ get: getter 1867/******/ }); 1868/******/ } 1869/******/ }; 1870/******/ 1871/******/ // getDefaultExport function for compatibility with non-harmony modules 1872/******/ __webpack_require__.n = function(module) { 1873/******/ var getter = module && module.__esModule ? 1874/******/ function getDefault() { return module['default']; } : 1875/******/ function getModuleExports() { return module; }; 1876/******/ __webpack_require__.d(getter, 'a', getter); 1877/******/ return getter; 1878/******/ }; 1879/******/ 1880/******/ // Object.prototype.hasOwnProperty.call 1881/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); }; 1882/******/ 1883/******/ // __webpack_public_path__ 1884/******/ __webpack_require__.p = ""; 1885/******/ 1886/******/ // Load entry module and return exports 1887/******/ return __webpack_require__(__webpack_require__.s = 7); 1888/******/ }) 1889/************************************************************************/ 1890/******/ ([ 1891/* 0 */ 1892/***/ (function(module, exports, __webpack_require__) { 1893 1894"use strict"; 1895 1896 1897Object.defineProperty(exports, "__esModule", { 1898 value: true 1899}); 1900 1901var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; /* globals jQuery */ 1902 1903exports.lory = lory; 1904 1905var _detectPrefixes = __webpack_require__(1); 1906 1907var _detectPrefixes2 = _interopRequireDefault(_detectPrefixes); 1908 1909var _detectSupportsPassive = __webpack_require__(2); 1910 1911var _detectSupportsPassive2 = _interopRequireDefault(_detectSupportsPassive); 1912 1913var _dispatchEvent = __webpack_require__(3); 1914 1915var _dispatchEvent2 = _interopRequireDefault(_dispatchEvent); 1916 1917var _defaults = __webpack_require__(6); 1918 1919var _defaults2 = _interopRequireDefault(_defaults); 1920 1921function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } 1922 1923var slice = Array.prototype.slice; 1924 1925function lory(slider, opts) { 1926 var position = void 0; 1927 var slidesWidth = void 0; 1928 var frameWidth = void 0; 1929 var slides = void 0; 1930 1931 /** 1932 * slider DOM elements 1933 */ 1934 var frame = void 0; 1935 var slideContainer = void 0; 1936 var prevCtrl = void 0; 1937 var nextCtrl = void 0; 1938 var prefixes = void 0; 1939 var transitionEndCallback = void 0; 1940 1941 var index = 0; 1942 var options = {}; 1943 var touchEventParams = (0, _detectSupportsPassive2.default)() ? { passive: true } : false; 1944 1945 /** 1946 * if object is jQuery convert to native DOM element 1947 */ 1948 if (typeof jQuery !== 'undefined' && slider instanceof jQuery) { 1949 slider = slider[0]; 1950 } 1951 1952 /** 1953 * private 1954 * set active class to element which is the current slide 1955 */ 1956 function setActiveElement(slides, currentIndex) { 1957 var _options = options, 1958 classNameActiveSlide = _options.classNameActiveSlide; 1959 1960 1961 slides.forEach(function (element, index) { 1962 if (element.classList.contains(classNameActiveSlide)) { 1963 element.classList.remove(classNameActiveSlide); 1964 } 1965 }); 1966 1967 slides[currentIndex].classList.add(classNameActiveSlide); 1968 } 1969 1970 /** 1971 * private 1972 * setupInfinite: function to setup if infinite is set 1973 * 1974 * @param {array} slideArray 1975 * @return {array} array of updated slideContainer elements 1976 */ 1977 function setupInfinite(slideArray) { 1978 var _options2 = options, 1979 infinite = _options2.infinite; 1980 1981 1982 var front = slideArray.slice(0, infinite); 1983 var back = slideArray.slice(slideArray.length - infinite, slideArray.length); 1984 1985 front.forEach(function (element) { 1986 var cloned = element.cloneNode(true); 1987 1988 slideContainer.appendChild(cloned); 1989 }); 1990
1991 back.reverse().forEach(function (element) { 1992 var cloned = element.cloneNode(true); 1993 1994 slideContainer.insertBefore(cloned, slideContainer.firstChild); 1995 }); 1996 1997 slideContainer.addEventListener(prefixes.transitionEnd, onTransitionEnd); 1998 1999 return slice.call(slideContainer.children); 2000 } 2001 2002 /** 2003 * [dispatchSliderEvent description] 2004 * @return {[type]} [description] 2005 */ 2006 function dispatchSliderEvent(phase, type, detail) { 2007 (0, _dispatchEvent2.default)(slider, phase + '.lory.' + type, detail); 2008 } 2009 2010 /** 2011 * translates to a given position in a given time in milliseconds 2012 * 2013 * @to {number} number in pixels where to translate to 2014 * @duration {number} time in milliseconds for the transistion 2015 * @ease {string} easing css property 2016 */ 2017 function translate(to, duration, ease) { 2018 var style = slideContainer && slideContainer.style; 2019 2020 if (style) { 2021 style[prefixes.transition + 'TimingFunction'] = ease; 2022 style[prefixes.transition + 'Duration'] = duration + 'ms'; 2023 style[prefixes.transform] = 'translateX(' + to + 'px)'; 2024 } 2025 } 2026 2027 /** 2028 * returns an element's width 2029 */ 2030 function elementWidth(element) { 2031 return element.getBoundingClientRect().width || element.offsetWidth; 2032 } 2033 2034 /** 2035 * slidefunction called by prev, next & touchend 2036 * 2037 * determine nextIndex and slide to next postion 2038 * under restrictions of the defined options 2039 * 2040 * @direction {boolean} 2041 */ 2042 function slide(nextIndex, direction) { 2043 var _options3 = options, 2044 slideSpeed = _options3.slideSpeed, 2045 slidesToScroll = _options3.slidesToScroll, 2046 infinite = _options3.infinite, 2047 rewind = _options3.rewind, 2048 rewindPrev = _options3.rewindPrev, 2049 rewindSpeed = _options3.rewindSpeed, 2050 ease = _options3.ease, 2051 classNameActiveSlide = _options3.classNameActiveSlide, 2052 _options3$classNameDi = _options3.classNameDisabledNextCtrl, 2053 classNameDisabledNextCtrl = _options3$classNameDi === undefined ? 'disabled' : _options3$classNameDi, 2054 _options3$classNameDi2 = _options3.classNameDisabledPrevCtrl, 2055 classNameDisabledPrevCtrl = _options3$classNameDi2 === undefined ? 'disabled' : _options3$classNameDi2; 2056 2057 2058 var duration = slideSpeed; 2059 2060 var nextSlide = direction ? index + 1 : index - 1; 2061 var maxOffset = Math.round(slidesWidth - frameWidth); 2062 2063 dispatchSliderEvent('before', 'slide', { 2064 index: index, 2065 nextSlide: nextSlide 2066 }); 2067 2068 /** 2069 * Reset control classes 2070 */ 2071 if (prevCtrl) { 2072 prevCtrl.classList.remove(classNameDisabledPrevCtrl); 2073 } 2074 if (nextCtrl) { 2075 nextCtrl.classList.remove(classNameDisabledNextCtrl); 2076 } 2077 2078 if (typeof nextIndex !== 'number') { 2079 if (direction) { 2080 if (infinite && index + infinite * 2 !== slides.length) { 2081 nextIndex = index + (infinite - index % infinite); 2082 } else { 2083 nextIndex = index + slidesToScroll; 2084 } 2085 } else { 2086 if (infinite && index % infinite !== 0) { 2087 nextIndex = index - index % infinite; 2088 } else { 2089 nextIndex = index - slidesToScroll; 2090 } 2091 } 2092 } 2093 2094 nextIndex = Math.min(Math.max(nextIndex, 0), slides.length - 1); 2095 2096 if (infinite && direction === undefined) { 2097 nextIndex += infinite; 2098 } 2099 2100 if (rewindPrev && Math.abs(position.x) === 0 && direction === false) { 2101 nextIndex = slides.length - 1; 2102 duration = rewindSpeed; 2103 } 2104 2105 var nextOffset = Math.min(Math.max(slides[nextIndex].offsetLeft * -1, maxOffset * -1), 0); 2106 2107 if (rewind && Math.abs(position.x) === maxOffset && direction) { 2108 nextOffset = 0; 2109 nextIndex = 0; 2110 duration = rewindSpeed; 2111 } 2112 2113 /** 2114 * translate to the nextOffset by a defined duration and ease function 2115 */ 2116 translate(nextOffset, duration, ease); 2117 2118 /** 2119 * update the position with the next position 2120 */ 2121 position.x = nextOffset; 2122 2123 /** 2124 * update the index with the nextIndex only if 2125 * the offset of the nextIndex is in the range of the maxOffset 2126 */ 2127 if (slides[nextIndex].offsetLeft <= maxOffset) { 2128 index = nextIndex; 2129 } 2130 2131 if (infinite && (nextIndex === slides.length - infinite || nextIndex === slides.length - slides.length % infinite || nextIndex === 0)) { 2132 if (direction) { 2133 index = infinite; 2134 } 2135 2136 if (!direction) { 2137 index = slides.length - infinite * 2; 2138 } 2139 2140 position.x = slides[index].offsetLeft * -1; 2141 2142 transitionEndCallback = function transitionEndCallback() { 2143 translate(slides[index].offsetLeft * -1, 0, undefined); 2144 }; 2145 } 2146 2147 if (classNameActiveSlide) {
2148 setActiveElement(slice.call(slides), index); 2149 } 2150 2151 /** 2152 * update classes for next and prev arrows 2153 * based on user settings 2154 */ 2155 if (prevCtrl && !infinite && !rewindPrev && nextIndex === 0) { 2156 prevCtrl.classList.add(classNameDisabledPrevCtrl); 2157 } 2158 2159 if (nextCtrl && !infinite && !rewind && nextIndex + 1 === slides.length) { 2160 nextCtrl.classList.add(classNameDisabledNextCtrl); 2161 } 2162 2163 dispatchSliderEvent('after', 'slide', { 2164 currentSlide: index 2165 }); 2166 } 2167 2168 /** 2169 * public 2170 * setup function 2171 */ 2172 function setup() { 2173 dispatchSliderEvent('before', 'init'); 2174 2175 prefixes = (0, _detectPrefixes2.default)(); 2176 options = _extends({}, _defaults2.default, opts); 2177 2178 var _options4 = options, 2179 classNameFrame = _options4.classNameFrame, 2180 classNameSlideContainer = _options4.classNameSlideContainer, 2181 classNamePrevCtrl = _options4.classNamePrevCtrl, 2182 classNameNextCtrl = _options4.classNameNextCtrl, 2183 _options4$classNameDi = _options4.classNameDisabledNextCtrl, 2184 classNameDisabledNextCtrl = _options4$classNameDi === undefined ? 'disabled' : _options4$classNameDi, 2185 _options4$classNameDi2 = _options4.classNameDisabledPrevCtrl, 2186 classNameDisabledPrevCtrl = _options4$classNameDi2 === undefined ? 'disabled' : _options4$classNameDi2, 2187 enableMouseEvents = _options4.enableMouseEvents, 2188 classNameActiveSlide = _options4.classNameActiveSlide, 2189 initialIndex = _options4.initialIndex; 2190 2191 2192 index = initialIndex; 2193 frame = slider.getElementsByClassName(classNameFrame)[0]; 2194 slideContainer = frame.getElementsByClassName(classNameSlideContainer)[0]; 2195 prevCtrl = slider.getElementsByClassName(classNamePrevCtrl)[0]; 2196 nextCtrl = slider.getElementsByClassName(classNameNextCtrl)[0]; 2197 2198 position = { 2199 x: slideContainer.offsetLeft, 2200 y: slideContainer.offsetTop 2201 }; 2202 2203 if (options.infinite) { 2204 slides = setupInfinite(slice.call(slideContainer.children)); 2205 } else { 2206 slides = slice.call(slideContainer.children); 2207 2208 if (prevCtrl && !options.rewindPrev) { 2209 prevCtrl.classList.add(classNameDisabledPrevCtrl); 2210 } 2211 2212 if (nextCtrl && slides.length === 1 && !options.rewind) { 2213 nextCtrl.classList.add(classNameDisabledNextCtrl); 2214 } 2215 } 2216 2217 reset(); 2218 2219 if (classNameActiveSlide) {
2220 setActiveElement(slides, index); 2221 } 2222 2223 if (prevCtrl && nextCtrl) { 2224 prevCtrl.addEventListener('click', prev); 2225 nextCtrl.addEventListener('click', next); 2226 } 2227 2228 frame.addEventListener('touchstart', onTouchstart, touchEventParams); 2229 2230 if (enableMouseEvents) { 2231 frame.addEventListener('mousedown', onTouchstart); 2232 frame.addEventListener('click', onClick); 2233 } 2234 2235 options.window.addEventListener('resize', onResize); 2236 2237 dispatchSliderEvent('after', 'init'); 2238 } 2239 2240 /** 2241 * public 2242 * reset function: called on resize 2243 */ 2244 function reset() { 2245 var _options5 = options, 2246 infinite = _options5.infinite, 2247 ease = _options5.ease, 2248 rewindSpeed = _options5.rewindSpeed, 2249 rewindOnResize = _options5.rewindOnResize, 2250 classNameActiveSlide = _options5.classNameActiveSlide, 2251 initialIndex = _options5.initialIndex; 2252 2253 2254 slidesWidth = elementWidth(slideContainer); 2255 frameWidth = elementWidth(frame); 2256 2257 if (frameWidth === slidesWidth) { 2258 slidesWidth = slides.reduce(function (previousValue, slide) { 2259 return previousValue + elementWidth(slide); 2260 }, 0); 2261 } 2262 2263 if (rewindOnResize) { 2264 index = initialIndex; 2265 } else { 2266 ease = null; 2267 rewindSpeed = 0; 2268 } 2269 2270 if (infinite) { 2271 translate(slides[index + infinite].offsetLeft * -1, 0, null); 2272 2273 index = index + infinite; 2274 position.x = slides[index].offsetLeft * -1; 2275 } else { 2276 translate(slides[index].offsetLeft * -1, rewindSpeed, ease); 2277 position.x = slides[index].offsetLeft * -1; 2278 } 2279 2280 if (classNameActiveSlide) {
2281 setActiveElement(slice.call(slides), index); 2282 } 2283 } 2284 2285 /** 2286 * public 2287 * slideTo: called on clickhandler 2288 */ 2289 function slideTo(index) { 2290 slide(index); 2291 } 2292 2293 /** 2294 * public 2295 * returnIndex function: called on clickhandler 2296 */ 2297 function returnIndex() { 2298 return index - options.infinite || 0; 2299 } 2300 2301 /** 2302 * public 2303 * prev function: called on clickhandler 2304 */ 2305 function prev() { 2306 slide(false, false); 2307 } 2308 2309 /** 2310 * public 2311 * next function: called on clickhandler 2312 */ 2313 function next() { 2314 slide(false, true); 2315 } 2316 2317 /** 2318 * public 2319 * destroy function: called to gracefully destroy the lory instance 2320 */ 2321 function destroy() { 2322 dispatchSliderEvent('before', 'destroy'); 2323 2324 // remove event listeners 2325 frame.removeEventListener(prefixes.transitionEnd, onTransitionEnd); 2326 frame.removeEventListener('touchstart', onTouchstart, touchEventParams); 2327 frame.removeEventListener('touchmove', onTouchmove, touchEventParams); 2328 frame.removeEventListener('touchend', onTouchend); 2329 frame.removeEventListener('mousemove', onTouchmove); 2330 frame.removeEventListener('mousedown', onTouchstart); 2331 frame.removeEventListener('mouseup', onTouchend); 2332 frame.removeEventListener('mouseleave', onTouchend); 2333 frame.removeEventListener('click', onClick); 2334 2335 options.window.removeEventListener('resize', onResize); 2336 2337 if (prevCtrl) { 2338 prevCtrl.removeEventListener('click', prev); 2339 } 2340 2341 if (nextCtrl) { 2342 nextCtrl.removeEventListener('click', next); 2343 } 2344 2345 // remove cloned slides if infinite is set 2346 if (options.infinite) { 2347 Array.apply(null, Array(options.infinite)).forEach(function () { 2348 slideContainer.removeChild(slideContainer.firstChild); 2349 slideContainer.removeChild(slideContainer.lastChild); 2350 }); 2351 } 2352 2353 dispatchSliderEvent('after', 'destroy'); 2354 } 2355 2356 // event handling 2357 2358 var touchOffset = void 0; 2359 var delta = void 0; 2360 var isScrolling = void 0; 2361 2362 function onTransitionEnd() { 2363 if (transitionEndCallback) { 2364 transitionEndCallback(); 2365 2366 transitionEndCallback = undefined; 2367 } 2368 } 2369 2370 function onTouchstart(event) { 2371 var _options6 = options, 2372 enableMouseEvents = _options6.enableMouseEvents; 2373 2374 var touches = event.touches ? event.touches[0] : event; 2375 2376 if (enableMouseEvents) { 2377 frame.addEventListener('mousemove', onTouchmove); 2378 frame.addEventListener('mouseup', onTouchend); 2379 frame.addEventListener('mouseleave', onTouchend); 2380 } 2381 2382 frame.addEventListener('touchmove', onTouchmove, touchEventParams); 2383 frame.addEventListener('touchend', onTouchend); 2384 2385 var pageX = touches.pageX, 2386 pageY = touches.pageY; 2387 2388 2389 touchOffset = { 2390 x: pageX, 2391 y: pageY, 2392 time: Date.now() 2393 }; 2394 2395 isScrolling = undefined; 2396 2397 delta = {}; 2398 2399 dispatchSliderEvent('on', 'touchstart', { 2400 event: event 2401 }); 2402 } 2403 2404 function onTouchmove(event) { 2405 var touches = event.touches ? event.touches[0] : event; 2406 var pageX = touches.pageX, 2407 pageY = touches.pageY; 2408 2409 2410 delta = { 2411 x: pageX - touchOffset.x, 2412 y: pageY - touchOffset.y 2413 }; 2414 2415 if (typeof isScrolling === 'undefined') { 2416 isScrolling = !!(isScrolling || Math.abs(delta.x) < Math.abs(delta.y)); 2417 } 2418 2419 if (!isScrolling && touchOffset) { 2420 translate(position.x + delta.x, 0, null); 2421 } 2422 2423 // may be 2424 dispatchSliderEvent('on', 'touchmove', { 2425 event: event 2426 }); 2427 } 2428 2429 function onTouchend(event) { 2430 /** 2431 * time between touchstart and touchend in milliseconds 2432 * @duration {number} 2433 */ 2434 var duration = touchOffset ? Date.now() - touchOffset.time : undefined; 2435 2436 /** 2437 * is valid if: 2438 * 2439 * -> swipe attempt time is over 300 ms 2440 * and 2441 * -> swipe distance is greater than 25px 2442 * or 2443 * -> swipe distance is more then a third of the swipe area 2444 * 2445 * @isValidSlide {Boolean} 2446 */ 2447 var isValid = Number(duration) < 300 && Math.abs(delta.x) > 25 || Math.abs(delta.x) > frameWidth / 3; 2448 2449 /** 2450 * is out of bounds if: 2451 * 2452 * -> index is 0 and delta x is greater than 0 2453 * or 2454 * -> index is the last slide and delta is smaller than 0 2455 * 2456 * @isOutOfBounds {Boolean} 2457 */ 2458 var isOutOfBounds = !index && delta.x > 0 || index === slides.length - 1 && delta.x < 0; 2459 2460 var direction = delta.x < 0; 2461 2462 if (!isScrolling) { 2463 if (isValid && !isOutOfBounds) { 2464 slide(false, direction); 2465 } else { 2466 translate(position.x, options.snapBackSpeed); 2467 } 2468 } 2469 2470 touchOffset = undefined; 2471 2472 /** 2473 * remove eventlisteners after swipe attempt 2474 */ 2475 frame.removeEventListener('touchmove', onTouchmove); 2476 frame.removeEventListener('touchend', onTouchend); 2477 frame.removeEventListener('mousemove', onTouchmove); 2478 frame.removeEventListener('mouseup', onTouchend); 2479 frame.removeEventListener('mouseleave', onTouchend); 2480 2481 dispatchSliderEvent('on', 'touchend', { 2482 event: event 2483 }); 2484 } 2485 2486 function onClick(event) { 2487 if (delta.x) { 2488 event.preventDefault(); 2489 } 2490 } 2491 2492 function onResize(event) { 2493 if (frameWidth !== elementWidth(frame)) { 2494 reset(); 2495 2496 dispatchSliderEvent('on', 'resize', { 2497 event: event 2498 }); 2499 } 2500 } 2501 2502 // trigger initial setup 2503 setup(); 2504 2505 // expose public api 2506 return { 2507 setup: setup, 2508 reset: reset, 2509 slideTo: slideTo, 2510 returnIndex: returnIndex, 2511 prev: prev, 2512 next: next, 2513 destroy: destroy 2514 }; 2515} 2516 2517/***/ }), 2518/* 1 */ 2519/***/ (function(module, exports, __webpack_require__) { 2520 2521"use strict"; 2522 2523 2524Object.defineProperty(exports, "__esModule", { 2525 value: true 2526}); 2527exports.default = detectPrefixes; 2528/** 2529 * Detecting prefixes for saving time and bytes 2530 */ 2531function detectPrefixes() { 2532 var transform = void 0; 2533 var transition = void 0; 2534 var transitionEnd = void 0; 2535 2536 (function () { 2537 var el = document.createElement('_'); 2538 var style = el.style; 2539 2540 var prop = void 0; 2541 2542 if (style[prop = 'webkitTransition'] === '') { 2543 transitionEnd = 'webkitTransitionEnd'; 2544 transition = prop; 2545 } 2546 2547 if (style[prop = 'transition'] === '') { 2548 transitionEnd = 'transitionend'; 2549 transition = prop; 2550 } 2551 2552 if (style[prop = 'webkitTransform'] === '') { 2553 transform = prop; 2554 } 2555 2556 if (style[prop = 'msTransform'] === '') { 2557 transform = prop; 2558 } 2559 2560 if (style[prop = 'transform'] === '') { 2561 transform = prop; 2562 } 2563 2564 document.body.insertBefore(el, null); 2565 style[transform] = 'translateX(0)'; 2566 document.body.removeChild(el); 2567 })(); 2568 2569 return { 2570 transform: transform, 2571 transition: transition, 2572 transitionEnd: transitionEnd 2573 }; 2574} 2575 2576/***/ }), 2577/* 2 */ 2578/***/ (function(module, exports, __webpack_require__) { 2579 2580"use strict"; 2581 2582 2583Object.defineProperty(exports, "__esModule", { 2584 value: true 2585}); 2586exports.default = detectSupportsPassive; 2587function detectSupportsPassive() { 2588 var supportsPassive = false;
2589 2590 try { 2591 var opts = Object.defineProperty({}, 'passive', { 2592 get: function get() { 2593 supportsPassive = true; 2594 } 2595 }); 2596 2597 window.addEventListener('testPassive', null, opts); 2598 window.removeEventListener('testPassive', null, opts); 2599 } catch (e) {} 2600 2601 return supportsPassive; 2602} 2603 2604/***/ }), 2605/* 3 */ 2606/***/ (function(module, exports, __webpack_require__) { 2607 2608"use strict"; 2609 2610 2611Object.defineProperty(exports, "__esModule", { 2612 value: true 2613}); 2614exports.default = dispatchEvent; 2615 2616var _customEvent = __webpack_require__(4); 2617 2618var _customEvent2 = _interopRequireDefault(_customEvent); 2619 2620function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } 2621 2622/** 2623 * dispatch custom events 2624 * 2625 * @param {element} el slideshow element 2626 * @param {string} type custom event name 2627 * @param {object} detail custom detail information 2628 */ 2629function dispatchEvent(target, type, detail) { 2630 var event = new _customEvent2.default(type, { 2631 bubbles: true, 2632 cancelable: true, 2633 detail: detail 2634 }); 2635 2636 target.dispatchEvent(event); 2637} 2638 2639/***/ }), 2640/* 4 */ 2641/***/ (function(module, exports, __webpack_require__) { 2642 2643/* WEBPACK VAR INJECTION */(function(global) { 2644var NativeCustomEvent = global.CustomEvent; 2645 2646function useNative () { 2647 try { 2648 var p = new NativeCustomEvent('cat', { detail: { foo: 'bar' } }); 2649 return 'cat' === p.type && 'bar' === p.detail.foo; 2650 } catch (e) { 2651 } 2652 return false; 2653} 2654 2655/** 2656 * Cross-browser `CustomEvent` constructor. 2657 * 2658 * https://developer.mozilla.org/en-US/docs/Web/API/CustomEvent.CustomEvent 2659 * 2660 * @public 2661 */ 2662 2663module.exports = useNative() ? NativeCustomEvent : 2664 2665// IE >= 9 2666'undefined' !== typeof document && 'function' === typeof document.createEvent ? function CustomEvent (type, params) { 2667 var e = document.createEvent('CustomEvent'); 2668 if (params) { 2669 e.initCustomEvent(type, params.bubbles, params.cancelable, params.detail); 2670 } else { 2671 e.initCustomEvent(type, false, false, void 0); 2672 } 2673 return e; 2674} : 2675 2676// IE <= 8 2677function CustomEvent (type, params) { 2678 var e = document.createEventObject(); 2679 e.type = type; 2680 if (params) { 2681 e.bubbles = Boolean(params.bubbles); 2682 e.cancelable = Boolean(params.cancelable); 2683 e.detail = params.detail; 2684 } else { 2685 e.bubbles = false; 2686 e.cancelable = false; 2687 e.detail = void 0; 2688 } 2689 return e; 2690} 2691 2692/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(5))) 2693 2694/***/ }), 2695/* 5 */ 2696/***/ (function(module, exports) { 2697 2698var g; 2699 2700// This works in non-strict mode 2701g = (function() { 2702 return this; 2703})(); 2704 2705try { 2706 // This works if eval is allowed (see CSP) 2707 g = g || Function("return this")() || (1,eval)("this"); 2708} catch(e) { 2709 // This works if the window reference is available 2710 if(typeof window === "object") 2711 g = window; 2712} 2713 2714// g can still be undefined, but nothing to do about it... 2715// We return undefined, instead of nothing here, so it's 2716// easier to handle this case. if(!global) { ...} 2717 2718module.exports = g; 2719 2720 2721/***/ }), 2722/* 6 */ 2723/***/ (function(module, exports, __webpack_require__) { 2724 2725"use strict"; 2726 2727 2728Object.defineProperty(exports, "__esModule", { 2729 value: true 2730}); 2731exports.default = { 2732 /** 2733 * slides scrolled at once 2734 * @slidesToScroll {Number} 2735 */ 2736 slidesToScroll: 1, 2737 2738 /** 2739 * time in milliseconds for the animation of a valid slide attempt 2740 * @slideSpeed {Number} 2741 */ 2742 slideSpeed: 300, 2743 2744 /** 2745 * time in milliseconds for the animation of the rewind after the last slide 2746 * @rewindSpeed {Number} 2747 */ 2748 rewindSpeed: 600, 2749 2750 /** 2751 * time for the snapBack of the slider if the slide attempt was not valid 2752 * @snapBackSpeed {Number} 2753 */ 2754 snapBackSpeed: 200, 2755 2756 /** 2757 * Basic easing functions: https://developer.mozilla.org/de/docs/Web/CSS/transition-timing-function 2758 * cubic bezier easing functions: http://easings.net/de 2759 * @ease {String} 2760 */ 2761 ease: 'ease', 2762 2763 /** 2764 * if slider reached the last slide, with next click the slider goes back to the startindex. 2765 * use infinite or rewind, not both 2766 * @rewind {Boolean} 2767 */ 2768 rewind: false, 2769 2770 /** 2771 * number of visible slides or false 2772 * use infinite or rewind, not both 2773 * @infinite {number} 2774 */ 2775 infinite: false, 2776 2777 /**
2778 * the slide index to show when the slider is initialized. 2779 * @initialIndex {number} 2780 */ 2781 initialIndex: 0, 2782 2783 /** 2784 * class name for slider frame 2785 * @classNameFrame {string} 2786 */ 2787 classNameFrame: 'js_frame', 2788 2789 /** 2790 * class name for slides container 2791 * @classNameSlideContainer {string} 2792 */ 2793 classNameSlideContainer: 'js_slides', 2794 2795 /** 2796 * class name for slider prev control 2797 * @classNamePrevCtrl {string} 2798 */ 2799 classNamePrevCtrl: 'js_prev', 2800 2801 /** 2802 * class name for slider next control 2803 * @classNameNextCtrl {string} 2804 */ 2805 classNameNextCtrl: 'js_next', 2806 2807 /** 2808 * class name for current active slide 2809 * if emptyString then no class is set 2810 * @classNameActiveSlide {string} 2811 */ 2812 classNameActiveSlide: 'active', 2813 2814 /** 2815 * enables mouse events for swiping on desktop devices 2816 * @enableMouseEvents {boolean} 2817 */ 2818 enableMouseEvents: false, 2819 2820 /** 2821 * window instance 2822 * @window {object} 2823 */ 2824 window: typeof window !== 'undefined' ? window : null, 2825 2826 /** 2827 * If false, slides lory to the first slide on window resize. 2828 * @rewindOnResize {boolean} 2829 */ 2830 rewindOnResize: true 2831}; 2832 2833/***/ }), 2834/* 7 */ 2835/***/ (function(module, exports, __webpack_require__) { 2836 2837module.exports = __webpack_require__(0); 2838 2839 2840/***/ }) 2841/******/ ]); 2842}); 2843},{}]},{},[4]) 2844//# sourceMappingURL=data:application/json;charset=utf-8;base64,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
28440FBQUEsS0FBOUM7QUFDQSxJQUFBLE9BQU8sQ0FBQyxnQkFBUixDQUF5QixrQkFBekIsRUFBNkMsV0FBN0M7QUFDQSxJQUFBLE9BQU8sQ0FBQyxnQkFBUixDQUF5QixnQkFBekIsRUFBMkMsVUFBM0M7QUFDRDs7QUFFRCxTQUFPLFVBQUEsSUFBSTtBQUFBLFdBQUssUUFBUSxHQUFHLElBQWhCO0FBQUEsR0FBWDtBQUVBOzs7OztBQUlBLFdBQVMsV0FBVCxHQUFzQjtBQUNwQixRQUFNLElBQUksR0FBRyxJQUFJLENBQUMsR0FBTCxDQUFTLENBQUMsT0FBTyxDQUFDLGFBQVIsWUFBMkIsdUJBQTNCLGlCQUFpRSxZQUFqRSxDQUE4RSxXQUE5RSxDQUFWLENBQWI7QUFDQSxJQUFBLFNBQVMsR0FBRyxVQUFVLENBQUM7QUFBQSxhQUFNLFFBQVEsQ0FBQyxJQUFULEVBQU47QUFBQSxLQUFELEVBQXdCLElBQUksSUFBSSxVQUFoQyxDQUF0QjtBQUNEO0FBRUQ7Ozs7OztBQUlBLFdBQVMsVUFBVCxHQUFxQjtBQUNuQixJQUFBLFlBQVksQ0FBQyxTQUFELENBQVo7QUFDQSxJQUFBLFdBQVc7QUFDWjtBQUNGLENBbENEOzs7QUNSQTtBQUVBOzs7Ozs7Ozs7QUFNQSxNQUFNLENBQUMsT0FBUCxHQUFpQixTQUFTLFlBQVQsQ0FBc0IsT0FBdEIsRUFBMkg7QUFBQSxpRkFBSCxFQUFHO0FBQUEsbUNBQTFGLHFCQUEwRjtBQUFBLE1BQTFGLHFCQUEwRixzQ0FBbEUsU0FBa0U7QUFBQSxtQ0FBdkQsdUJBQXVEO0FBQUEsTUFBdkQsdUJBQXVELHNDQUE3QixXQUE2QjtBQUFBLE1BQWhCLFFBQWdCLFFBQWhCLFFBQWdCOztBQUMxSTtBQUNBLE1BQUksUUFBSjtBQUNBLE1BQU0sWUFBWSxHQUFHLFFBQXJCO0FBQ0EsTUFBTSxZQUFZLEdBQUcsT0FBTyxDQUFDLGFBQVIsWUFBMkIscUJBQTNCLEVBQXJCO0FBQ0EsTUFBTSxjQUFjLEdBQUcsT0FBTyxDQUFDLGFBQVIsWUFBMkIsdUJBQTNCLEVBQXZCO0FBQ0EsTUFBTSxRQUFRLEdBQUcsY0FBYyxHQUFHLGNBQWMsQ0FBQyxRQUFmLENBQXdCLE1BQTNCLEdBQW9DLENBQW5FOztBQUVBLE1BQUcsWUFBWSxJQUFJLFFBQVEsR0FBRyxDQUE5QixFQUFnQztBQUM5QixJQUFBLE9BQU8sQ0FBQyxnQkFBUixDQUF5QixrQkFBekIsRUFBNkMsVUFBN0M7QUFDQSxJQUFBLE9BQU8sQ0FBQyxnQkFBUixDQUF5QixpQkFBekIsRUFBNEMsUUFBNUM7QUFDQSxJQUFBLE9BQU8sQ0FBQyxnQkFBUixDQUF5QixrQkFBekIsRUFBNkMsZUFBN0M7QUFDQSxJQUFBLE9BQU8sQ0FBQyxnQkFBUixDQUF5QixnQkFBekIsRUFBMkM7QUFBQSxhQUFNLFNBQVMsQ0FBQyxDQUFELENBQWY7QUFBQSxLQUEzQztBQUNEOztBQUVELFNBQU8sVUFBQSxJQUFJO0FBQUEsV0FBSyxRQUFRLEdBQUcsSUFBaEI7QUFBQSxHQUFYO0FBRUE7Ozs7O0FBSUEsV0FBUyxVQUFULEdBQXFCO0FBQ25CLFNBQUksSUFBSSxDQUFDLEdBQUcsQ0FBWixFQUFlLENBQUMsR0FBRyxRQUFuQixFQUE2QixDQUFDLEVBQTlCLEVBQWlDO0FBQy9CLE1BQUEsWUFBWSxDQUFDLFdBQWIsQ0FBeUIsUUFBUSxDQUFDLGFBQVQsQ0FBdUIsSUFBdkIsQ0FBekI7QUFDRDs7QUFFRCxJQUFBLFlBQVksQ0FBQyxRQUFiLENBQXNCLENBQXRCLEVBQXlCLFNBQXpCLENBQW1DLEdBQW5DLENBQXVDLFlBQXZDO0FBQ0Q7QUFFRDs7Ozs7O0FBSUEsV0FBUyxRQUFULEdBQW1CO0FBQ2pCLFNBQUksSUFBSSxDQUFDLEdBQUcsQ0FBWixFQUFlLENBQUMsR0FBRyxZQUFZLENBQUMsUUFBYixDQUFzQixNQUF6QyxFQUFpRCxDQUFDLEVBQWxELEVBQXFEO0FBQ25ELE1BQUEsWUFBWSxDQUFDLFFBQWIsQ0FBc0IsQ0FBdEIsRUFBeUIsZ0JBQXpCLENBQTBDLE9BQTFDLEVBQW1ELFVBQW5EO0FBQ0Q7QUFDRjtBQUVEOzs7Ozs7O0FBS0EsV0FBUyxlQUFULENBQXlCLEtBQXpCLEVBQStCO0FBQzdCLElBQUEsU0FBUyxDQUFDLFFBQVEsR0FBRyxLQUFLLENBQUMsTUFBTixDQUFhLFlBQWIsR0FBNEIsQ0FBL0IsR0FBbUMsS0FBSyxDQUFDLE1BQU4sQ0FBYSxZQUF6RCxDQUFUO0FBQ0Q7QUFFRDs7Ozs7OztBQUtBLFdBQVMsVUFBVCxDQUFvQixLQUFwQixFQUEwQjtBQUN4QixRQUFNLEtBQUssR0FBRyxLQUFLLENBQUMsU0FBTixDQUFnQixPQUFoQixDQUF3QixJQUF4QixDQUE2QixZQUFZLENBQUMsUUFBMUMsRUFBb0QsS0FBSyxDQUFDLE1BQTFELENBQWQ7QUFDQSxJQUFBLFFBQVEsQ0FBQyxPQUFULENBQWlCLEtBQWpCO0FBQ0Q7QUFFRDs7Ozs7OztBQUtBLFdBQVMsU0FBVCxDQUFtQixLQUFuQixFQUF5QjtBQUN2QixTQUFJLElBQUksQ0FBQyxHQUFHLENBQVosRUFBZSxDQUFDLEdBQUcsWUFBWSxDQUFDLFFBQWIsQ0FBc0IsTUFBekMsRUFBaUQsQ0FBQyxFQUFsRCxFQUFxRDtBQUNuRCxNQUFBLFlBQVksQ0FBQyxRQUFiLENBQXNCLENBQXRCLEVBQXlCLFNBQXpCLENBQW1DLE1BQW5DLENBQTBDLFlBQTFDO0FBQ0Q7O0FBRUQsSUFBQSxZQUFZLENBQUMsUUFBYixDQUFzQixLQUF0QixFQUE2QixTQUE3QixDQUF1QyxHQUF2QyxDQUEyQyxZQUEzQztBQUNEO0FBQ0YsQ0F0RUQ7OztBQ1JBO0FBRUE7Ozs7Ozs7OztBQVFBLE1BQU0sQ0FBQyxPQUFQLEdBQWlCLFNBQVMsUUFBVCxDQUFrQixJQUFsQixFQUFpQztBQUFBLE1BQVQsSUFBUyx1RUFBRixDQUFFOztBQUNoRDtBQUNBLE1BQUksU0FBSjtBQUVBOztBQUNBLFNBQU8sU0FBUyxTQUFULEdBQTJCO0FBQUE7O0FBQUEsc0NBQUwsSUFBSztBQUFMLE1BQUEsSUFBSztBQUFBOztBQUNoQyxJQUFBLFlBQVksQ0FBQyxTQUFELENBQVo7QUFDQSxJQUFBLFNBQVMsR0FBRyxVQUFVLENBQUM7QUFBQSxhQUFNLElBQUksQ0FBQyxLQUFMLENBQVcsS0FBWCxFQUFpQixJQUFqQixDQUFOO0FBQUEsS0FBRCxFQUErQixJQUEvQixDQUF0QjtBQUNELEdBSEQ7QUFJRCxDQVREOzs7QUNWQTs7Ozs7Ozs7OztBQUVBLE9BQU8sQ0FBQyxpQ0FBRCxDQUFQOztBQUVBLE1BQU0sQ0FBQyxPQUFQLEdBQWlCO0FBQ2YsRUFBQSxXQUFXLEVBQVgsV0FEZTtBQUVmLEVBQUEsc0JBQXNCLEVBQXRCLHNCQUZlO0FBR2YsRUFBQSxlQUFlLEVBQWYsZUFIZTtBQUlmLEVBQUEsS0FBSyxFQUFMLEtBSmU7QUFLZixFQUFBLFlBQVksRUFBWixZQUxlO0FBTWYsRUFBQSxXQUFXLEVBQVg7QUFOZSxDQUFqQjtBQVNBLElBQU0sYUFBYSxHQUFHLG1CQUF0QjtBQUNBLElBQU0sdUJBQXVCLEdBQUcsZ0NBQWhDO0FBQ0EsSUFBTSxrQkFBa0IsR0FBRywrQkFBM0I7O0FBRUEsU0FBUyxXQUFULEdBQXVCO0FBQ3JCLEVBQUEsS0FBSyxDQUFDLFNBQU4sQ0FBZ0IsT0FBaEIsQ0FBd0IsSUFBeEIsQ0FDRSxRQUFRLENBQUMsZ0JBQVQsQ0FBMEIsYUFBMUIsQ0FERixFQUVFLFVBQUEsZUFBZSxFQUFJO0FBQUUsSUFBQSxlQUFlLENBQUMsZ0JBQWhCLENBQWlDLFFBQWpDLEVBQTJDLFlBQTNDO0FBQTJELEdBRmxGO0FBS0EsRUFBQSxLQUFLLENBQUMsU0FBTixDQUFnQixPQUFoQixDQUF3QixJQUF4QixDQUNFLFFBQVEsQ0FBQyxnQkFBVCxDQUEwQix1QkFBMUIsQ0FERixFQUVFLFVBQUEsV0FBVyxFQUFJO0FBQUUsSUFBQSxXQUFXLENBQUMsZ0JBQVosQ0FBNkIsUUFBN0IsRUFBdUMsY0FBdkM7QU
2844FBeUQsR0FGNUU7QUFLQSxFQUFBLEtBQUssQ0FBQyxTQUFOLENBQWdCLE9BQWhCLENBQXdCLElBQXhCLENBQ0UsUUFBUSxDQUFDLGdCQUFULENBQTBCLGtCQUExQixDQURGLEVBRUUsVUFBQSxPQUFPLEVBQUk7QUFBRSxJQUFBLE9BQU8sQ0FBQyxnQkFBUixDQUF5QixPQUF6QixFQUFrQyxlQUFsQztBQUFxRCxHQUZwRTtBQUlEO0FBRUQ7Ozs7OztBQUlBLFNBQVMsc0JBQVQsQ0FBZ0MsU0FBaEMsRUFBMEM7QUFDeEMsRUFBQSxTQUFTLENBQUMsZ0JBQVYsQ0FBMkIsUUFBM0IsRUFBcUMsVUFBQSxLQUFLLEVBQUk7QUFDNUMsUUFBRyxLQUFLLENBQUMsTUFBTixDQUFhLE9BQWIsQ0FBcUIsYUFBckIsQ0FBSCxFQUF1QztBQUNyQyxNQUFBLGNBQWMsQ0FBQyxLQUFLLENBQUMsTUFBUCxFQUFlLEtBQUssQ0FBQyxNQUFyQixDQUFkO0FBQ0Q7QUFDRixHQUpEO0FBTUEsRUFBQSxTQUFTLENBQUMsZ0JBQVYsQ0FBMkIsT0FBM0IsRUFBb0MsVUFBQSxLQUFLLEVBQUk7QUFDM0MsUUFBRyxLQUFLLENBQUMsTUFBTixDQUFhLE9BQWIsQ0FBcUIsa0JBQXJCLENBQUgsRUFBNEM7QUFDMUMsTUFBQSxXQUFXLENBQUMsS0FBSyxDQUFDLE1BQVAsQ0FBWDtBQUNEO0FBQ0YsR0FKRDtBQU1BLEVBQUEsU0FBUyxDQUFDLGdCQUFWLENBQTJCLFFBQTNCLEVBQXFDLFVBQUEsS0FBSyxFQUFJO0FBQzVDLFFBQUcsS0FBSyxDQUFDLE1BQU4sQ0FBYSxPQUFiLENBQXFCLHVCQUFyQixDQUFILEVBQWlEO0FBQy9DLE1BQUEsaUJBQWlCLENBQUMsS0FBSyxDQUFDLE1BQVAsQ0FBakI7QUFDRDtBQUNGLEdBSkQ7QUFLRDtBQUVEOzs7QUFDQSxTQUFTLFlBQVQsQ0FBc0IsS0FBdEIsRUFBNEI7QU
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
28445hbWUoKSxcbiAgICBhY3Rpb246IGVsZW1lbnQuZ2V0QXR0cmlidXRlKCdkYXRhLWV2ZW50LWFjdGlvbicpLFxuICAgIGxhYmVsOiBzZWFyY2hJbnB1dEVsZW1lbnQgJiYgc2VhcmNoSW5wdXRFbGVtZW50LnZhbHVlIHx8ICcnLFxuICB9KTtcbn1cblxuLyoqIEBwYXJhbSB7RXZlbnR9IGV2ZW50ICovXG5mdW5jdGlvbiBvblRyYWNrZWRBY3Rpb24oZXZlbnQpe1xuICB0cmFja0FjdGlvbihldmVudC5jdXJyZW50VGFyZ2V0KTtcbn1cblxuLyoqIEBwYXJhbSB7SFRNTEVsZW1lbnR9IGVsZW1lbnQgKi9cbmZ1bmN0aW9uIHRyYWNrQWN0aW9uKGVsZW1lbnQpe1xuICBjb25zdCBkYXRhID0gZ2V0RGF0YUV2ZW50KGVsZW1lbnQpO1xuICBpZihkYXRhICYmIGRhdGEuYWN0aW9uKXtcbiAgICB0cmFjayhkYXRhKTtcbiAgfVxufVxuXG4vKipcbiAqIEBwYXJhbSB7RWxlbWVudH0gZWxlbWVudFxuICogQHBhcmFtIHt7IGV2ZW50QWN0aW9uQ2xhc3M/OiBzdHJpbmcsIGV2ZW50TGFiZWxDbGFzcz86IHN0cmluZyB9fSBbb3B0aW9uc11cbiAqIEByZXR1cm5zIHt7IGNhdGVnb3J5OiBzdHJpbmcsIGFjdGlvbjogc3RyaW5nfG51bGwsIGxhYmVsOiBzdHJpbmcgfSB8IHVuZGVmaW5lZH1cbiAqL1xuZnVuY3Rpb24gZ2V0RGF0YUV2ZW50KGVsZW1lbnQsIHsgZXZlbnRBY3Rpb25DbGFzcz0nZGF0YS1ldmVudC1hY3Rpb24nLCBldmVudExhYmVsQ2xhc3M9J2RhdGEtZXZlbnQtbGFiZWwnfSA9IHt9KXtcbiAgaWYoZWxlbWVudCl7XG4gICAgcmV0dXJuIHtcbiAgICAgIGNhdGVnb3J5OiBnZXRQYWdlTmFtZSgpLFxuICAgICAgYWN0aW9uOiBlbGVtZW50LmdldEF0dHJpYnV0ZShldmVudEFjdGlvbkNsYXNzKSxcbiAgICAgIGxhYmVsOiBlbGVtZW50LmdldEF0dHJpYnV0ZShldmVudExhYmVsQ2xhc3MpIHx8IGVsZW1lbnQudGV4dENvbnRlbnQudHJpbSgpLFxuICAgIH07XG4gIH1cbn1cblxuZnVuY3Rpb24gdHJhY2soeyBjYXRlZ29yeSwgYWN0aW9uLCBsYWJlbCB9KSB7XG4gIGNvbnN0IHsgZ3RhZyB9ID0gd2luZG93O1xuXG4gIGlmKGd0YWcpe1xuICAgIGd0YWcoJ2V2ZW50JywgYWN0aW9uLCB7XG4gICAgICBldmVudF9jYXRlZ29yeTogY2F0ZWdvcnksXG4gICAgICBldmVudF9sYWJlbDogbGFiZWwsXG4gICAgfSk7XG4gIH1cbn1cblxuLyoqXG4gKiBAcGFyYW0ge1dpbmRvd30gY29udGV4dFxuICogQHJldHVybnNcbiAqL1xuZnVuY3Rpb24gZ2V0UGFnZU5hbWUoY29udGV4dCA9IHdpbmRvdyl7XG4gIGNvbnN0IHsgdXJsUHJlZml4IH0gPSBjb250ZXh0O1xuICBsZXQgcGFnZU5hbWUgPSBjb250ZXh0LmRvY3VtZW50LmxvY2F0aW9uLnBhdGhuYW1lO1xuICBpZihwYWdlTmFtZSA9PT0gXCIvXCIpIHtcbiAgICBwYWdlTmFtZSA9IFwiSG9tZSBQYWdlXCI7XG4gIH0gZWxzZSBpZihwYWdlTmFtZS5pbmRleE9mKGAke3VybFByZWZpeH0vc2VjdG9yL2ApID09PSAwKSB7XG4gICAgcGFnZU5hbWUgPSBcIlNlY3RvciBQYWdlXCI7XG4gIH0gZWxzZSBpZiAocGFnZU5hbWUuaW5kZXhPZihgJHt1cmxQcmVmaXh9L3JhbmtpbmcvYCkgPT09IDApIHtcbiAgICBwYWdlTmFtZSA9IFwiUmFua2luZyBQYWdlXCI7XG4gIH0gZWxzZSBpZiAocGFnZU5hbWUuaW5kZXhPZignL3NlYXJjaCcpID09PSAwKSB7XG4gICAgcGFnZU5hbWUgPSAnU2VhcmNoIFBhZ2UnO1xuICB9IGVsc2UgaWYgKHBhZ2VOYW1lLmluZGV4T2YoYCR7dXJsUHJlZml4fS90aW1lc2VyaWVzL2ApID09PSAwKSB7XG4gICAgcGFnZU5hbWUgPSBcIkRhdGEgUGFnZVwiO1xuICB9XG4gIHJldHVybiBwYWdlTmFtZTtcbn1cbiIsIid1c2Ugc3RyaWN0JztcblxuY29uc3QgeyBjcmVhdGVDdXN0b21FdmVudCB9ID0gcmVxdWlyZSgnLi4vcG9ueWZpbGxzL2V2ZW50cy5qcycpO1xuXG4vKipcbiAqIEluaXRpYWxpemUgYWxsIGZvbGRhYmxlIGxpc3RzIG9uIHRoZSBwYWdlLlxuICogQHBhcmFtIHtudW1iZXJ9IFtvZmZzZXRYPTBdXG4gKiBAcGFyYW0ge251bWJlcn0gW29mZnNldFk9MF1cbiAqIEByZXR1cm5ze3ZvaWR9XG4gKi9cbm1vZHVsZS5leHBvcnRzID0gZnVuY3Rpb24gaW5pdGlhbGl6YUZvbGRhYmxlTGlzdHMob2Zmc2V0WCA9IDAsIG9mZnNldFkgPSAwKXtcbiAgQXJyYXkucHJvdG90eXBlLmZvckVhY2guY2FsbChcbiAgICBkb2N1bWVudC5xdWVyeVNlbGVjdG9yQWxsKCcuZm9sZGFibGUnKSxcbiAgICAoZm9sZGFibGUpID0+IGluaXRpYWxpemVGb2xkYWJsZUxpc3QoZm9sZGFibGUsIG9mZnNldFgsIG9mZnNldFkpXG4gICk7XG59O1xuXG4vKipcbiAqIEluaXRpYWxpemUgYSBmb2xkYWJsZSBsaXN0LlxuICogSWYgeW91IG5lZWQgdG8gd2F0Y2ggc3RhdGUgY2hhbmdlcywgc3Vic2NyaWJlIHRvIHRoZSAqKnRvZ2dsZSoqIGV2ZW50LlxuICogQHBhcmFtIHtFbGVtZW50fSBmb2xkYWJsZVxuICogQHBhcmFtIHtudW1iZXJ9IG9mZnNldFhcbiAqIEBwYXJhbSB7bnVtYmVyfSBvZmZzZXRZXG4gKiBAcmV0dXJucyB7dm9pZH1cbiAqL1xuZnVuY3Rpb24gaW5pdGlhbGl6ZUZvbGRhYmxlTGlzdChmb2xkYWJsZSwgb2Zmc2V0WCwgb2Zmc2V0WSl7XG4gIGNvbnN0IENMQVNTX0ZPTERFRCA9ICdmb2xkZWQnO1xuICBjb25zdCB0b2dnbGVyID0gZm9sZGFibGUucXVlcnlTZWxlY3RvcignLmZvbGRhYmxlLXRvZ2dsZXInKTtcbiAgY29uc3Qgc2Nyb2xsT3JpZ2luID0gZm9sZGFibGUucXVlcnlTZWxlY3RvcignLmZvbGRhYmxlLXNjcm9sbC1vcmlnaW4nKSB8fCBmb2xkYWJsZTtcblxuICBpZighdG9nZ2xlcikgcmV0dXJuO1xuXG4gIHRvZ2dsZXIudGV4dENvbnRlbnQgPSBmb2xkYWJsZS5jbGFzc0xpc3QuY29udGFpbnMoQ0xBU1NfRk9MREVEKSA/IHRvZ2dsZXIuZGF0YXNldC5sYWJlbEZvbGRlZCA6IHRvZ2dsZXIuZGF0YXNldC5sYWJlbFVuZm9sZGVkO1xuXG4gIHRvZ2dsZXIuYWRkRXZlbnRMaXN0ZW5lcignY2xpY2snLCAoKSA9PiB7XG4gICAgY29uc3QgaXNGb2xkZWQgPSBmb2xkYWJsZS5jbGFzc0xpc3QuY29udGFpbnMoQ0xBU1NfRk9MREVEKTtcblxuICAgIGlmKGlzRm9sZGVkKXtcbiAgICAgIGZvbGRhYmxlLmNsYXNzTGlzdC5yZW1vdmUoQ0xBU1NfRk9MREVEKTtcbiAgICAgIHRvZ2dsZXIudGV4dENvbnRlbnQgPSB0b2dnbGVyLmRhdGFzZXQubGFiZWxVbmZvbGRlZDtcbiAgICB9ZWxzZXtcbiAgICAgIGZvbGRhYmxlLmNsYXNzTGlzdC5hZGQoQ0xBU1NfRk9MREVEKTtcbiAgICAgIHRvZ2dsZXIudGV4dENvbnRlbnQgPSB0b2dnbGVyLmRhdGFzZXQubGFiZWxGb2xkZWQ7XG5cbiAgICAgIGNvbnN0IGJvdW5kaW5nQm94ID0gc2Nyb2xsT3JpZ2luLmdldEJvdW5kaW5nQ2xpZW50UmVjdCgpO1xuXG4gICAgICBpZihib3VuZGluZ0JveC5sZWZ0IDwgb2Zmc2V0WCB8fCBib3VuZGluZ0JveC50b3AgPCBvZmZzZXRZKXtcbiAgICAgICAgY29uc3QgYm9keUJvdW5kaW5nQm94ID0gZG9jdW1lbnQuZG9jdW1lbnRFbGVtZW50LmdldEJvdW5kaW5nQ2xpZW50UmVjdCgpO1xuXG4gICAgICAgI
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
2844IHNlZSBodHRwczovL2dpdGh1Yi5jb20vbW96aWxsYS9yaGluby9pc3N1ZXMvMzQ2XG4gIC8vIGVzbGludC1kaXNhYmxlLW5leHQtbGluZSBuby1wcm90b3R5cGUtYnVpbHRpbnNcbiAgcmV0dXJuICFPYmplY3QoJ3onKS5wcm9wZXJ0eUlzRW51bWVyYWJsZSgwKTtcbn0pID8gZnVuY3Rpb24gKGl0KSB7XG4gIHJldHVybiBjbGFzc29mKGl0KSA9PSAnU3RyaW5nJyA/IHNwbGl0LmNhbGwoaXQsICcnKSA6IE9iamVjdChpdCk7XG59IDogT2JqZWN0O1xuIiwidmFyIHN0b3JlID0gcmVxdWlyZSgnLi4vaW50ZXJuYWxzL3NoYXJlZC1zdG9yZScpO1xuXG52YXIgZnVuY3Rpb25Ub1N0cmluZyA9IEZ1bmN0aW9uLnRvU3RyaW5nO1xuXG4vLyB0aGlzIGhlbHBlciBicm9rZW4gaW4gYDMuNC4xLTMuNC40YCwgc28gd2UgY2FuJ3QgdXNlIGBzaGFyZWRgIGhlbHBlclxuaWYgKHR5cGVvZiBzdG9yZS5pbnNwZWN0U291cmNlICE9ICdmdW5jdGlvbicpIHtcbiAgc3RvcmUuaW5zcGVjdFNvdXJjZSA9IGZ1bmN0aW9uIChpdCkge1xuICAgIHJldHVybiBmdW5jdGlvblRvU3RyaW5nLmNhbGwoaXQpO1xuICB9O1xufVxuXG5tb2R1bGUuZXhwb3J0cyA9IHN0b3JlLmluc3BlY3RTb3VyY2U7XG4iLCJ2YXIgTkFUSVZFX1dFQUtfTUFQID0gcmVxdWlyZSgnLi4vaW50ZXJuYWxzL25hdGl2ZS13ZWFrLW1hcCcpO1xudmFyIGdsb2JhbCA9IHJlcXVpcmUoJy4uL2ludGVybmFscy9nbG9iYWwnKTtcbnZhciBpc09iamVjdCA9IHJlcXVpcmUoJy4uL2ludGVybmFscy9pcy1vYmplY3QnKTtcbnZhciBjcmVhdGVOb25FbnVtZXJhYmxlUHJvcGVydHkgPSByZXF1aXJlKCcuLi9pbnRlcm5hbHMvY3JlYXRlLW5vbi1lbnVtZXJhYmxlLXByb3BlcnR5Jyk7XG52YXIgb2JqZWN0SGFzID0gcmVxdWlyZSgnLi4vaW50ZXJuYWxzL2hhcycpO1xudmFyIHNoYXJlZEtleSA9IHJlcXVpcmUoJy4uL2ludGVybmFscy9zaGFyZWQta2V5Jyk7XG52YXIgaGlkZGVuS2V5cyA9IHJlcXVpcmUoJy4uL2ludGVybmFscy9oaWRkZW4ta2V5cycpO1xuXG52YXIgV2Vha01hcCA9IGdsb2JhbC5XZWFrTWFwO1xudmFyIHNldCwgZ2V0LCBoYXM7XG5cbnZhciBlbmZvcmNlID0gZnVuY3Rpb24gKGl0KSB7XG4gIHJldHVybiBoYXMoaXQpID8gZ2V0KGl0KSA6IHNldChpdCwge30pO1xufTtcblxudmFyIGdldHRlckZvciA9IGZ1bmN0aW9uIChUWVBFKSB7XG4gIHJldHVybiBmdW5jdGlvbiAoaXQpIHtcbiAgICB2YXIgc3RhdGU7XG4gICAgaWYgKCFpc09iamVjdChpdCkgfHwgKHN0YXRlID0gZ2V0KGl0KSkudHlwZSAhPT0gVFlQRSkge1xuICAgICAgdGhyb3cgVHlwZUVycm9yKCdJbmNvbXBhdGlibGUgcmVjZWl2ZXIsICcgKyBUWVBFICsgJyByZXF1aXJlZCcpO1xuICAgIH0gcmV0dXJuIHN0YXRlO1xuICB9O1xufTtcblxuaWYgKE5BVElWRV9XRUFLX01BUCkge1xuICB2YXIgc3RvcmUgPSBuZXcgV2Vha01hcCgpO1xuICB2YXIgd21nZXQgPSBzdG9yZS5nZXQ7XG4gIHZhciB3bWhhcyA9IHN0b3JlLmhhcztcbiAgdmFyIHdtc2V0ID0gc3RvcmUuc2V0O1xuICBzZXQgPSBmdW5jdGlvbiAoaXQsIG1ldGFkYXRhKSB7XG4gICAgd21zZXQuY2FsbChzdG9yZSwgaXQsIG1ldGFkYXRhKTtcbiAgICByZXR1cm4gbWV0YWRhdGE7XG4gIH07XG4gIGdldCA9IGZ1bmN0aW9uIChpdCkge1xuICAgIHJldHVybiB3bWdldC5jYWxsKHN0b3JlLCBpdCkgfHwge307XG4gIH07XG4gIGhhcyA9IGZ1bmN0aW9uIChpdCkge1xuICAgIHJldHVybiB3bWhhcy5jYWxsKHN0b3JlLCBpdCk7XG4gIH07XG59IGVsc2Uge1xuICB2YXIgU1RBVEUgPSBzaGFyZWRLZXkoJ3N0YXRlJyk7XG4gIGhpZGRlbktleXNbU1RBVEVdID0gdHJ1ZTtcbiAgc2V0ID0gZnVuY3Rpb24gKGl0LCBtZXRhZGF0YSkge1xuICAgIGNyZWF0ZU5vbkVudW1lcmFibGVQcm9wZXJ0eShpdCwgU1RBVEUsIG1ldGFkYXRhKTtcbiAgICByZXR1cm4gbWV0YWRhdGE7XG4gIH07XG4gIGdldCA9IGZ1bmN0aW9uIChpdCkge1xuICAgIHJldHVybiBvYmplY3RIYXMoaXQsIFNUQVRFKSA/IGl0W1NUQVRFXSA6IHt9O1xuICB9O1xuICBoYXMgPSBmdW5jdGlvbiAoaXQpIHtcbiAgICByZXR1cm4gb2JqZWN0SGFzKGl0LCBTVEFURSk7XG4gIH07XG59XG5cbm1vZHVsZS5leHBvcnRzID0ge1xuICBzZXQ6IHNldCxcbiAgZ2V0OiBnZXQsXG4gIGhhczogaGFzLFxuICBlbmZvcmNlOiBlbmZvcmNlLFxuICBnZXR0ZXJGb3I6IGdldHRlckZvclxufTtcbiIsInZhciBjbGFzc29mID0gcmVxdWlyZSgnLi4vaW50ZXJuYWxzL2NsYXNzb2YtcmF3Jyk7XG5cbi8vIGBJc0FycmF5YCBhYnN0cmFjdCBvcGVyYXRpb25cbi8vIGh0dHBzOi8vdGMzOS5naXRodWIuaW8vZWNtYTI2Mi8jc2VjLWlzYXJyYXlcbm1vZHVsZS5leHBvcnRzID0gQXJyYXkuaXNBcnJheSB8fCBmdW5jdGlvbiBpc0FycmF5KGFyZykge1xuICByZXR1cm4gY2xhc3NvZihhcmcpID09ICdBcnJheSc7XG59O1xuIiwidmFyIGZhaWxzID0gcmVxdWlyZSgnLi4vaW50ZXJuYWxzL2ZhaWxzJyk7XG5cbnZhciByZXBsYWNlbWVudCA9IC8jfFxcLnByb3RvdHlwZVxcLi87XG5cbnZhciBpc0ZvcmNlZCA9IGZ1bmN0aW9uIChmZWF0dXJlLCBkZXRlY3Rpb24pIHtcbiAgdmFyIHZhbHVlID0gZGF0YVtub3JtYWxpemUoZmVhdHVyZSldO1xuICByZXR1cm4gdmFsdWUgPT0gUE9MWUZJTEwgPyB0cnVlXG4gICAgOiB2YWx1ZSA9PSBOQVRJVkUgPyBmYWxzZVxuICAgIDogdHlwZW9mIGRldGVjdGlvbiA9PSAnZnVuY3Rpb24nID8gZmFpbHMoZGV0ZWN0aW9uKVxuICAgIDogISFkZXRlY3Rpb247XG59O1xuXG52YXIgbm9ybWFsaXplID0gaXNGb3JjZWQubm9ybWFsaXplID0gZnVuY3Rpb24gKHN0cmluZykge1xuICByZXR1cm4gU3RyaW5nKHN0cmluZykucmVwbGFjZShyZXBsYWNlbWVudCwgJy4nKS50b0xvd2VyQ2FzZSgpO1xufTtcblxudmFyIGRhdGEgPSBpc0ZvcmNlZC5kYXRhID0ge307XG52YXIgTkFUSVZFID0gaXNGb3JjZWQuTkFUSVZFID0gJ04nO1xudmFyIFBPTFlGSUxMID0gaXNGb3JjZWQuUE9MWUZJTEwgPSAnUCc7XG5cbm1vZHVsZS5leHBvcnRzID0gaXNGb3JjZWQ7XG4iLCJtb2R1bGUuZXhwb3J0cyA9IGZ1bmN0aW9uIChpdCkge1xuICByZXR1cm4gdHlwZW9mIGl0ID09PSAnb2JqZWN0JyA/IGl0ICE9PSBudWxsIDogdHlwZW9mIGl0ID09PSAnZnVuY3Rpb24nO1xufTtcbiIsIm1vZHVsZS5leHBvcnRzID0gZmFsc2U7XG4iLCJ2YXIgZmFpbHMgPSByZXF1aXJlKCcuLi9pbnRlcm5hbHMvZmFpbHMnKTtcblxubW9kdWxlLmV4cG9ydHMgPSAhIU9iamVjdC5nZXRPd25Qcm9wZXJ0eVN5bWJvbHMgJiYgIWZhaWxzKGZ1bmN0aW9uICgpIHtcbiAgLy8gQ2hyb21lIDM4IFN5bWJvbCBoYXMgaW5jb3JyZWN0IHRvU3RyaW5nIGNvbnZlcnNpb25cbiAgLy8gZXNsaW50LWRpc2FibGUtbmV4dC1saW5lIG5vLXVuZGVmXG4gIHJldHVybiAhU3RyaW5nKFN5bWJvbCgpKTtcbn0pO1xuIiwidmFyIGdsb2JhbCA9IHJlcXVpcmUoJy4uL2ludGVybmFscy9nbG9iYWwnKTtcbnZhciBpbnNwZWN0U291cmNlID0gcmVxdWlyZSgnLi4vaW50ZXJuYWxzL2luc3BlY3Qtc291cmNlJyk7XG5cbnZhciBXZWFrTWFwID0gZ2xvYmFsLldlYWtNYXA7XG5cbm1vZHVsZS5leHBvcnRzID0gdHlwZW9mIFdlYWtNYXAgPT09ICdmdW5jdGlvbicgJiYgL25hdGl2ZSBjb2RlLy50ZXN0KGluc3BlY3RTb3VyY2UoV2Vha01hcCkpO1xuIiwidmFyIERFU0NSSVBUT1JTID0gcmVxdWlyZSgnLi4vaW50ZXJuYWxzL2Rlc2NyaXB0b3JzJyk7XG52YXIgSUU4X0RPTV9ERUZJTkUgPSByZXF1aXJlKCcuLi9pbnRlcm5hbHMvaWU4LWRvbS1kZWZpbmUnKTtcbnZhciBhbk9iamVjdCA9IHJlcXVpcmUoJy4uL2ludGVybmFscy9hbi1vYmplY3QnKTtcbnZhciB0b1ByaW1pdGl2ZSA9IHJlcXVpcmUoJy4uL2ludGVybmFscy90by1wcmltaXRpdmUnKTtcblxudmFyIG5hdGl2ZURlZmluZVByb3BlcnR5ID0gT2JqZWN0LmRlZmluZVByb3BlcnR5O1xuXG4vLyBgT2JqZWN0LmRlZmluZVByb3BlcnR5YCBtZXRob2Rcbi8vIGh0dHBzOi8vdGMzOS5naXRodWIuaW8vZWNtYTI2Mi8jc2VjLW9iamVjdC5kZWZpbmVwcm9wZXJ0eVxuZXhwb3J0cy5mID0gREVTQ1JJUFRPUlMgPyBuYXRpdmVEZWZpbmVQcm9wZXJ0eSA6IGZ1bmN0aW9uIGRlZmluZVByb3BlcnR5KE8sIFAsIEF0dHJpYnV0ZXMpIHtcbiAgYW5PYmplY3QoTyk7XG4gIFAgPSB0b1ByaW1pdGl2ZShQLCB0cnVlKTtcbiAgYW5PYmplY3QoQXR0cmlidXRlcyk7XG4gIGlmIChJRThfRE9NX0RFRklORSkgdHJ5IHtcbiAgICByZXR1cm4gbmF0aXZlRGVmaW5lUHJvcGVydHkoTywgUCwgQXR0cmlidXRlcyk7XG4gIH0gY2F0Y2ggKGVycm9yKSB7IC8qIGVtcHR5ICovIH1cbiAgaWYgKCdnZXQnIGluIEF0dHJpYnV0ZXMgfHwgJ3NldCcgaW4gQXR0cmlidXRlcykgdGhyb3cgVHlwZUVycm9yKCdBY2Nlc3NvcnMgbm90IHN1cHBvcnRlZCcpO1xuICBpZiAoJ3ZhbHVlJyBpbiBBdHRyaWJ1dGVzKSBPW1BdID0gQXR0cmlidXRlcy52YWx1ZTtcbiAgcmV0dXJuIE87XG59O1xuIiwidmFyIERFU0NSSVBUT1JTID0gcmVxdWlyZSgnLi4vaW50ZXJuYWxzL2Rlc2NyaXB0b3JzJyk7XG52YXIgcHJvcGVydHlJc0VudW1lcmFibGVNb2R1bGUgPSByZXF1aXJlKCcuLi9pbnRlcm5hbHMvb2JqZWN0LXByb3BlcnR5LWlzLWVudW1lcmFibGUnKTtcbnZhciBjcmVhdGVQcm9wZXJ0eURlc2NyaXB0b3IgPSByZXF1aXJlKCcuLi9pbnRlcm5hbHMvY3JlYXRlLXByb3BlcnR5LWRlc2NyaXB0b3InKTtcbnZhciB0b0luZGV4ZWRPYmplY3QgPSByZXF1aXJlKCcuLi9pbnRlcm5hbHMvdG8taW5kZXhlZC1vYmplY3QnKTtcbnZhciB0b1ByaW1pdGl2ZSA9IHJlcXVpcmUoJy4uL2ludGVybmFscy90by1wcmltaXRpdmUnKTtcbnZhciBoYXMgPSByZXF1aXJlKCcuLi9pbnRlcm5hbHMvaGFzJyk7XG52YXIgSUU4X0RPTV9ERUZJTkUgPSByZXF1aXJlKCcuLi9pbnRlcm5hbHMvaWU4LWRvbS1kZWZpbmUnKTtcblxudmFyIG5hdGl2ZUdldE93blByb3BlcnR5RGVzY3JpcHRvciA9IE9iamVjdC5nZXRPd25Qcm9wZXJ0eURlc2NyaXB0b3I7XG5cbi8vIGBPYmplY3QuZ2V0T3duUHJvcGVydHlEZXNjcmlwdG9yYCBtZXRob2Rcbi8vIGh0dHBzOi8vdGMzOS5naXRodWIuaW8vZWNtYTI2Mi8jc2VjLW9iamVjdC5nZXRvd25wcm9wZXJ0eWRlc2NyaXB0b3JcbmV4cG9ydHMuZiA9IERFU0NSSVBUT1JTID8gbmF0aXZlR2V0T3duUHJvcGVydHlEZXNjcmlwdG9yIDogZnVuY3Rpb24gZ2V0T3duUHJvcGVydHlEZXNjcmlwdG9yKE8sIFApIHtcbiAgTyA9IHRvSW5kZXhlZE9iamVjdChPKTtcbiAgUCA9IHRvUHJpbWl0aXZlKFAsIHRydWUpO1xuICBpZiAoSUU4X0RPTV9ERUZJTkUpIHRyeSB7XG4gICAgcmV0dXJuIG5hdGl2ZUdldE93blByb3BlcnR5RGVzY3JpcHRvcihPLCBQKTtcbiAgfSBjYXRjaCAoZXJyb3IpIHsgLyogZW1wdHkgKi8gfVxuICBpZiAoaGFzKE8sIFApKSByZXR1cm4gY3JlYXRlUHJvcGVydHlEZXNjcmlwdG9yKCFwcm9wZXJ0eUlzRW51bWVyYWJsZU1vZHVsZS5mLmNhbGwoTywgUCksIE9bUF0pO1xufTtcbiIsInZhciBpbnRlcm5hbE9iamVjdEtleXMgPSByZXF1aXJlKCcuLi9pbnRlcm5hbHMvb2JqZWN0LWtleXMtaW50ZXJuYWwnKTtcbnZhciBlbnVtQnVnS2V5cyA9IHJlcXVpcmUoJy4uL2ludGVybmFscy9lbnVtLWJ1Zy1rZXlzJyk7XG5cbnZhciBoaWRkZW5L
2844ZXlzID0gZW51bUJ1Z0tleXMuY29uY2F0KCdsZW5ndGgnLCAncHJvdG90eXBlJyk7XG5cbi8vIGBPYmplY3QuZ2V0T3duUHJvcGVydHlOYW1lc2AgbWV0aG9kXG4vLyBodHRwczovL3RjMzkuZ2l0aHViLmlvL2VjbWEyNjIvI3NlYy1vYmplY3QuZ2V0b3ducHJvcGVydHluYW1lc1xuZXhwb3J0cy5mID0gT2JqZWN0LmdldE93blByb3BlcnR5TmFtZXMgfHwgZnVuY3Rpb24gZ2V0T3duUHJvcGVydHlOYW1lcyhPKSB7XG4gIHJldHVybiBpbnRlcm5hbE9iamVjdEtleXMoTywgaGlkZGVuS2V5cyk7XG59O1xuIiwiZXhwb3J0cy5mID0gT2JqZWN0LmdldE93blByb3BlcnR5U3ltYm9scztcbiIsInZhciBoYXMgPSByZXF1aXJlKCcuLi9pbnRlcm5hbHMvaGFzJyk7XG52YXIgdG9JbmRleGVkT2JqZWN0ID0gcmVxdWlyZSgnLi4vaW50ZXJuYWxzL3RvLWluZGV4ZWQtb2JqZWN0Jyk7XG52YXIgaW5kZXhPZiA9IHJlcXVpcmUoJy4uL2ludGVybmFscy9hcnJheS1pbmNsdWRlcycpLmluZGV4T2Y7XG52YXIgaGlkZGVuS2V5cyA9IHJlcXVpcmUoJy4uL2ludGVybmFscy9oaWRkZW4ta2V5cycpO1xuXG5tb2R1bGUuZXhwb3J0cyA9IGZ1bmN0aW9uIChvYmplY3QsIG5hbWVzKSB7XG4gIHZhciBPID0gdG9JbmRleGVkT2JqZWN0KG9iamVjdCk7XG4gIHZhciBpID0gMDtcbiAgdmFyIHJlc3VsdCA9IFtdO1xuICB2YXIga2V5O1xuICBmb3IgKGtleSBpbiBPKSAhaGFzKGhpZGRlbktleXMsIGtleSkgJiYgaGFzKE8sIGtleSkgJiYgcmVzdWx0LnB1c2goa2V5KTtcbiAgLy8gRG9uJ3QgZW51bSBidWcgJiBoaWRkZW4ga2V5c1xuICB3aGlsZSAobmFtZXMubGVuZ3RoID4gaSkgaWYgKGhhcyhPLCBrZXkgPSBuYW1lc1tpKytdKSkge1xuICAgIH5pbmRleE9mKHJlc3VsdCwga2V5KSB8fCByZXN1bHQucHVzaChrZXkpO1xuICB9XG4gIHJldHVybiByZXN1bHQ7XG59O1xuIiwiJ3VzZSBzdHJpY3QnO1xudmFyIG5hdGl2ZVByb3BlcnR5SXNFbnVtZXJhYmxlID0ge30ucHJvcGVydHlJc0VudW1lcmFibGU7XG52YXIgZ2V0T3duUHJvcGVydHlEZXNjcmlwdG9yID0gT2JqZWN0LmdldE93blByb3BlcnR5RGVzY3JpcHRvcjtcblxuLy8gTmFzaG9ybiB+IEpESzggYnVnXG52YXIgTkFTSE9STl9CVUcgPSBnZXRPd25Qcm9wZXJ0eURlc2NyaXB0b3IgJiYgIW5hdGl2ZVByb3BlcnR5SXNFbnVtZXJhYmxlLmNhbGwoeyAxOiAyIH0sIDEpO1xuXG4vLyBgT2JqZWN0LnByb3RvdHlwZS5wcm9wZXJ0eUlzRW51bWVyYWJsZWAgbWV0aG9kIGltcGxlbWVudGF0aW9uXG4vLyBodHRwczovL3RjMzkuZ2l0aHViLmlvL2VjbWEyNjIvI3NlYy1vYmplY3QucHJvdG90eXBlLnByb3BlcnR5aXNlbnVtZXJhYmxlXG5leHBvcnRzLmYgPSBOQVNIT1JOX0JVRyA/IGZ1bmN0aW9uIHByb3BlcnR5SXNFbnVtZXJhYmxlKFYpIHtcbiAgdmFyIGRlc2NyaXB0b3IgPSBnZXRPd25Qcm9wZXJ0eURlc2NyaXB0b3IodGhpcywgVik7XG4gIHJldHVybiAhIWRlc2NyaXB0b3IgJiYgZGVzY3JpcHRvci
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
2844HZhciBpbmRleCA9IDA7XG4gICAgdmFyIG9wdGlvbnMgPSB7fTtcbiAgICB2YXIgdG91Y2hFdmVudFBhcmFtcyA9ICgwLCBfZGV0ZWN0U3VwcG9ydHNQYXNzaXZlMi5kZWZhdWx0KSgpID8geyBwYXNzaXZlOiB0cnVlIH0gOiBmYWxzZTtcblxuICAgIC8qKlxuICAgICAqIGlmIG9iamVjdCBpcyBqUXVlcnkgY29udmVydCB0byBuYXRpdmUgRE9NIGVsZW1lbnRcbiAgICAgKi9cbiAgICBpZiAodHlwZW9mIGpRdWVyeSAhPT0gJ3VuZGVmaW5lZCcgJiYgc2xpZGVyIGluc3RhbmNlb2YgalF1ZXJ5KSB7XG4gICAgICAgIHNsaWRlciA9IHNsaWRlclswXTtcbiAgICB9XG5cbiAgICAvKipcbiAgICAgKiBwcml2YXRlXG4gICAgICogc2V0IGFjdGl2ZSBjbGFzcyB0byBlbGVtZW50IHdoaWNoIGlzIHRoZSBjdXJyZW50IHNsaWRlXG4gICAgICovXG4gICAgZnVuY3Rpb24gc2V0QWN0aXZlRWxlbWVudChzbGlkZXMsIGN1cnJlbnRJbmRleCkge1xuICAgICAgICB2YXIgX29wdGlvbnMgPSBvcHRpb25zLFxuICAgICAgICAgICAgY2xhc3NOYW1lQWN0aXZlU2xpZGUgPSBfb3B0aW9ucy5jbGFzc05hbWVBY3RpdmVTbGlkZTtcblxuXG4gICAgICAgIHNsaWRlcy5mb3JFYWNoKGZ1bmN0aW9uIChlbGVtZW50LCBpbmRleCkge1xuICAgICAgICAgICAgaWYgKGVsZW1lbnQuY2xhc3NMaXN0LmNvbnRhaW5zKGNsYXNzTmFtZUFjdGl2ZVNsaWRlKSkge1xuICAgICAgICAgICAgICAgIGVsZW1lbnQuY2xhc3NMaXN0LnJlbW92ZShjbGFzc05hbWVBY3RpdmVTbGlkZSk7XG4gICAgICAgICAgICB9XG4gICAgICAgIH0pO1xuXG4gICAgICAgIHNsaWRlc1tjdXJyZW50SW5kZXhdLmNsYXNzTGlzdC5hZGQoY2xhc3NOYW1lQWN0aXZlU2xpZGUpO1xuICAgIH1cblxuICAgIC8qKlxuICAgICAqIHByaXZhdGVcbiAgICAgKiBzZXR1cEluZmluaXRlOiBmdW5jdGlvbiB0byBzZXR1cCBpZiBpbmZpbml0ZSBpcyBzZXRcbiAgICAgKlxuICAgICAqIEBwYXJhbSAge2FycmF5fSBzbGlkZUFycmF5XG4gICAgICogQHJldHVybiB7YXJyYXl9IGFycmF5IG9mIHVwZGF0ZWQgc2xpZGVDb250YWluZXIgZWxlbWVudHNcbiAgICAgKi9cbiAgICBmdW5jdGlvbiBzZXR1cEluZmluaXRlKHNsaWRlQXJyYXkpIHtcbiAgICAgICAgdmFyIF9vcHRpb25zMiA9IG9wdGlvbnMsXG4gICAgICAgICAgICBpbmZpbml0ZSA9IF9vcHRpb25zMi5pbmZpbml0ZTtcblxuXG4gICAgICAgIHZhciBmcm9udCA9IHNsaWRlQXJyYXkuc2xpY2UoMCwgaW5maW5pdGUpO1xuICAgICAgICB2Y
2844XIgYmFjayA9IHNsaWRlQXJyYXkuc2xpY2Uoc2xpZGVBcnJheS5sZW5ndGggLSBpbmZpbml0ZSwgc2xpZGVBcnJheS5sZW5ndGgpO1xuXG4gICAgICAgIGZyb250LmZvckVhY2goZnVuY3Rpb24gKGVsZW1lbnQpIHtcbiAgICAgICAgICAgIHZhciBjbG9uZWQgPSBlbGVtZW50LmNsb25lTm9kZSh0cnVlKTtcblxuICAgICAgICAgICAgc2xpZGVDb250YWluZXIuYXBwZW5kQ2hpbGQoY2xvbmVkKTtcbiAgICAgICAgfSk7XG5cbiAgICAgICAgYmFjay5yZXZlcnNlKCkuZm9yRWFjaChmdW5jdGlvbiAoZWxlbWVudCkge1xuICAgICAgICAgICAgdmFyIGNsb25lZCA9IGVsZW1lbnQuY2xvbmVOb2RlKHRydWUpO1xuXG4gICAgICAgICAgICBzbGlkZUNvbnRhaW5lci5pbnNlcnRCZWZvcmUoY2xvbmVkLCBzbGlkZUNvbnRhaW5lci5maXJzdENoaWxkKTtcbiAgICAgICAgfSk7XG5cbiAgICAgICAgc2xpZGVDb250YWluZXIuYWRkRXZlbnRMaXN0ZW5lcihwcmVmaXhlcy50cmFuc2l0aW9uRW5kLCBvblRyYW5zaXRpb25FbmQpO1xuXG4gICAgICAgIHJldHVybiBzbGljZS5jYWxsKHNsaWRlQ29udGFpbmVyLmNoaWxkcmVuKTtcbiAgICB9XG5cbiAgICAvKipcbiAgICAgKiBbZGlzcGF0Y2hTbGlkZXJFdmVudCBkZXNjcmlwdGlvbl1cbiAgICAgKiBAcmV0dXJuIHtbdHlwZV19IFtkZXNjcmlwdGlvbl1cbiAgICAgKi9cbiAgICBmdW5jdGlvbiBkaXNwYXRjaFNsaWRlckV2ZW50KHBoYXNlLCB0eXBlLCBkZXRhaWwpIHtcbiAgICAgICAgKDAsIF9kaXNwYXRjaEV2ZW50Mi5kZWZhdWx0KShzbGlkZXIsIHBoYXNlICsgJy5sb3J5LicgKyB0eXBlLCBkZXRhaWwpO1xuICAgIH1cblxuICAgIC8qKlxuICAgICAqIHRyYW5zbGF0ZXMgdG8gYSBnaXZlbiBwb3NpdGlvbiBpbiBhIGdpdmVuIHRpbWUgaW4gbWlsbGlzZWNvbmRzXG4gICAgICpcbiAgICAgKiBAdG8gICAgICAgIHtudW1iZXJ9IG51bWJlciBpbiBwaXhlbHMgd2hlcmUgdG8gdHJhbnNsYXRlIHRvXG4gICAgICogQGR1cmF0aW9uICB7bnVtYmVyfSB0aW1lIGluIG1pbGxpc2Vjb25kcyBmb3IgdGhlIHRyYW5zaXN0aW9uXG4gICAgICogQGVhc2UgICAgICB7c3RyaW5nfSBlYXNpbmcgY3NzIHByb3BlcnR5XG4gICAgICovXG4gICAgZnVuY3Rpb24gdHJhbnNsYXRlKHRvLCBkdXJhdGlvbiwgZWFzZSkge1xuICAgICAgICB2Y
2844XIgc3R5bGUgPSBzbGlkZUNvbnRhaW5lciAmJiBzbGlkZUNvbnRhaW5lci5zdHlsZTtcblxuICAgICAgICBpZiAoc3R5bGUpIHtcbiAgICAgICAgICAgIHN0eWxlW3ByZWZpeGVzLnRyYW5zaXRpb24gKyAnVGltaW5nRnVuY3Rpb24nXSA9IGVhc2U7XG4gICAgICAgICAgICBzdHlsZVtwcmVmaXhlcy50cmFuc2l0aW9uICsgJ0R1cmF0aW9uJ10gPSBkdXJhdGlvbiArICdtcyc7XG4gICAgICAgICAgICBzdHlsZVtwcmVmaXhlcy50cmFuc2Zvcm1dID0gJ3RyYW5zbGF0ZVgoJyArIHRvICsgJ3B4KSc7XG4gICAgICAgIH1cbiAgICB9XG5cbiAgICAvKipcbiAgICAgKiByZXR1cm5zIGFuIGVsZW1lbnQncyB3aWR0aFxuICAgICAqL1xuICAgIGZ1bmN0aW9uIGVsZW1lbnRXaWR0aChlbGVtZW50KSB7XG4gICAgICAgIHJldHVybiBlbGVtZW50LmdldEJvdW5kaW5nQ2xpZW50UmVjdCgpLndpZHRoIHx8IGVsZW1lbnQub2Zmc2V0V2lkdGg7XG4gICAgfVxuXG4gICAgLyoqXG4gICAgICogc2xpZGVmdW5jdGlvbiBjYWxsZWQgYnkgcHJldiwgbmV4dCAmIHRvdWNoZW5kXG4gICAgICpcbiAgICAgKiBkZXRlcm1pbmUgbmV4dEluZGV4IGFuZCBzbGlkZSB0byBuZXh0IHBvc3Rpb25cbiAgICAgKiB1bmRlciByZXN0cmljdGlvbnMgb2YgdGhlIGRlZmluZWQgb3B0aW9uc1xuICAgICAqXG4gICAgICogQGRpcmVjdGlvbiAge2Jvb2xlYW59XG4gICAgICovXG4gICAgZnVuY3Rpb24gc2xpZGUobmV4dEluZGV4LCBkaXJlY3Rpb24pIHtcbiAgICAgICAgdmFyIF9vcHRpb25zMyA9IG9wdGlvbnMsXG4gICAgICAgICAgICBzbGlkZVNwZWVkID0gX29wdGlvbnMzLnNsaWRlU3BlZWQsXG4gICAgICAgICAgICBzbGlkZXNUb1Njcm9sbCA9I
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
2844HRyYW5zaXRpb25FbmRDYWxsYmFjayA9IHVuZGVmaW5lZDtcbiAgICAgICAgfVxuICAgIH1cblxuICAgIGZ1bmN0aW9uIG9uVG91Y2hzdGFydChldmVudCkge1xuICAgICAgICB2YXIgX29wdGlvbnM2ID0gb3B0aW9ucyxcbiAgICAgICAgICAgIGVuYWJsZU1vdXNlRXZlbnRzID0gX29wdGlvbnM2LmVuYWJsZU1vdXNlRXZlbnRzO1xuXG4gICAgICAgIHZhciB0b3VjaGVzID0gZXZlbnQudG91Y2hlcyA/IGV2ZW50LnRvdWNoZXNbMF0gOiBldmVudDtcblxuICAgICAgICBpZiAoZW5hYmxlTW91c2VFdmVudHMpIHtcbiAgICAgICAgICAgIGZyYW1lLmFkZEV2ZW50TGlzdGVuZXIoJ21vdXNlbW92ZScsIG9uVG91Y2htb3ZlKTtcbiAgICAgICAgICAgIGZyYW1lLmFkZEV2ZW50TGlzdGVuZXIoJ21vdXNldXAnLCBvblRvdWNoZW5kKTtcbiAgICAgICAgICAgIGZyYW1lLmFkZEV2ZW50TGlzdGVuZXIoJ21vdXNlbGVhdmUnLCBvblRvdWNoZW5kKTtcbiAgICAgICAgfVxuXG4gICAgICAgIGZyYW1lLmFkZEV2ZW50TGlzdGVuZXIoJ3RvdWNobW92ZScsIG9uVG91Y2htb3ZlLCB0b3VjaEV2ZW50UGFyYW1zKTtcbiAgICAgICAgZnJhbWUuYWRkRXZlbnRMaXN0ZW5lcigndG91Y2hlbmQnLCBvblRvdWNoZW5kKTtcblxuICAgICAgICB2YXIgcGFnZVggPSB0b3VjaGVzLnBhZ2VYLFxuICAgICAgICAgICAgcGFnZVkgPSB0b3VjaGVzLnBhZ2VZO1xuXG5cbiAgICAgICAgdG91Y2hPZmZzZXQgPSB7XG4gICAgICAgICAgICB4OiBwYWdlWCxcbiAgICAgICAgICAgIHk6IHBhZ2VZLFxuICAgICAgICAgICAgdGltZTogRGF0ZS5ub3coKVxuICAgICAgICB9O1xuXG4gICAgICAgIGlzU2Nyb2xsaW5nID0gdW5kZWZpbmVkO1xuXG4gICAgICAgIGRlbHRhID0ge307XG5cbiAgICAgICAgZGlzcGF0Y2hTbGlkZXJFdmVudCgnb24nLCAndG91Y2hzdGFydCcsIHtcbiAgICAgICAgICAgIGV2ZW50OiBldmVudFxuICAgICAgICB9KTtcbiAgICB9XG5cbiAgICBmdW5jdGlvbiBvblRvdWNobW92ZShldmVudCkge1xuICAgICAgICB2Y
2844XIgdG91Y2hlcyA9IGV2ZW50LnRvdWNoZXMgPyBldmVudC50b3VjaGVzWzBdIDogZXZlbnQ7XG4gICAgICAgIHZhciBwYWdlWCA9IHRvdWNoZXMucGFnZVgsXG4gICAgICAgICAgICBwYWdlWSA9IHRvdWNoZXMucGFnZVk7XG5cblxuICAgICAgICBkZWx0YSA9IHtcbiAgICAgICAgICAgIHg6IHBhZ2VYIC0gdG91Y2hPZmZzZXQueCxcbiAgICAgICAgICAgIHk6IHBhZ2VZIC0gdG91Y2hPZmZzZXQueVxuICAgICAgICB9O1xuXG4gICAgICAgIGlmICh0eXBlb2YgaXNTY3JvbGxpbmcgPT09ICd1bmRlZmluZWQnKSB7XG4gICAgICAgICAgICBpc1Njcm9sbGluZyA9ICEhKGlzU2Nyb2xsaW5nIHx8IE1hdGguYWJzKGRlbHRhLngpIDwgTWF0aC5hYnMoZGVsdGEueSkpO1xuICAgICAgICB9XG5cbiAgICAgICAgaWYgKCFpc1Njcm9sbGluZyAmJiB0b3VjaE9mZnNldCkge1xuICAgICAgICAgICAgdHJhbnNsYXRlKHBvc2l0aW9uLnggKyBkZWx0YS54LCAwLCBudWxsKTtcbiAgICAgICAgfVxuXG4gICAgICAgIC8vIG1heSBiZVxuICAgICAgICBkaXNwYXRjaFNsaWRlckV2ZW50KCdvbicsICd0b3VjaG1vdmUnLCB7XG4gICAgICAgICAgICBldmVudDogZXZlbnRcbiAgICAgICAgfSk7XG4gICAgfVxuXG4gICAgZnVuY3Rpb24gb25Ub3VjaGVuZChldmVudCkge1xuICAgICAgICAvKipcbiAgICAgICAgICogdGltZSBiZXR3ZWVuIHRvdWNoc3RhcnQgYW5kIHRvdWNoZW5kIGluIG1pbGxpc2Vjb25kc1xuICAgICAgICAgKiBAZHVyYXRpb24ge251bWJlcn1cbiAgICAgICAgICovXG4gICAgICAgIHZhciBkdXJhdGlvbiA9IHRvdWNoT2Zmc2V0ID8gRGF0ZS5ub3coKSAtIHRvdWNoT2Zmc2V0LnRpbWUgOiB1bmRlZmluZWQ7XG5cbiAgICAgICAgLyoqXG4gICAgICAgICAqIGlzIHZhbGlkIGlmOlxuICAgICAgICAgKlxuICAgICAgICAgKiAtPiBzd2lwZSBhdHRlbXB0IHRpbWUgaXMgb3ZlciAzMDAgbXNcbiAgICAgICAgICogYW5kXG4gICAgICAgICAqIC0+IHN3aXBlIGRpc3RhbmNlIGlzIGdyZWF0ZXIgdGhhbiAyNXB4XG4gICAgICAgICAqIG9yXG4gICAgICAgICAqIC0+IHN3aXBlIGRpc3RhbmNlIGlzIG1vcmUgdGhlbiBhIHRoaXJkIG9mIHRoZSBzd2lwZSBhcmVhXG4gICAgICAgICAqXG4gICAgICAgICAqIEBpc1ZhbGlkU2xpZGUge0Jvb2xlYW59XG4gICAgICAgICAqL1xuICAgICAgICB2Y
2844XIgaXNWYWxpZCA9IE51bWJlcihkdXJhdGlvbikgPCAzMDAgJiYgTWF0aC5hYnMoZGVsdGEueCkgPiAyNSB8fCBNYXRoLmFicyhkZWx0YS54KSA+IGZyYW1lV2lkdGggLyAzO1xuXG4gICAgICAgIC8qKlxuICAgICAgICAgKiBpcyBvdXQgb2YgYm91bmRzIGlmOlxuICAgICAgICAgKlxuICAgICAgICAgKiAtPiBpbmRleCBpcyAwIGFuZCBkZWx0YSB4IGlzIGdyZWF0ZXIgdGhhbiAwXG4gICAgICAgICAqIG9yXG4gICAgICAgICAqIC0+IGluZGV4IGlzIHRoZSBsYXN0IHNsaWRlIGFuZCBkZWx0YSBpcyBzbWFsbGVyIHRoYW4gMFxuICAgICAgICAgKlxuICAgICAgICAgKiBAaXNPdXRPZkJvdW5kcyB7Qm9vbGVhbn1cbiAgICAgICAgICovXG4gICAgICAgIHZhciBpc091dE9mQm91bmRzID0gIWluZGV4ICYmIGRlbHRhLnggPiAwIHx8IGluZGV4ID09PSBzbGlkZXMubGVuZ3RoIC0gMSAmJiBkZWx0YS54IDwgMDtcblxuICAgICAgICB2YXIgZGlyZWN0aW9uID0gZGVsdGEueCA8IDA7XG5cbiAgICAgICAgaWYgKCFpc1Njcm9sbGluZykge1xuICAgICAgICAgICAgaWYgKGlzVmFsaWQgJiYgIWlzT3V0T2ZCb3VuZHMpIHtcbiAgICAgICAgICAgICAgICBzbGlkZShmYWxzZSwgZGlyZWN0aW9uKTtcbiAgICAgICAgICAgIH0gZWxzZSB7XG4gICAgICAgICAgICAgICAgdHJhbnNsYXRlKHBvc2l0aW9uLngsIG9wdGlvbnMuc25hcEJhY2tTcGVlZCk7XG4gICAgICAgICAgICB9XG4gICAgICAgIH1cblxuICAgICAgICB0b3VjaE9mZnNldCA9IHVuZGVmaW5lZDtcblxuICAgICAgICAvKipcbiAgICAgICAgICogcmVtb3ZlIGV2ZW50bGlzdGVuZXJzIGFmdGVyIHN3aXBlIGF0dGVtcHRcbiAgICAgICAgICovXG4gICAgICAgIGZyYW1lLnJlbW92ZUV2ZW50TGlzdGVuZXIoJ3RvdWNobW92ZScsIG9uVG91Y2htb3ZlKTtcbiAgICAgICAgZnJhbWUucmVtb3ZlRXZlbnRMaXN0ZW5lcigndG91Y2hlbmQnLCBvblRvdWNoZW5kKTtcbiAgICAgICAgZnJhbWUucmVtb3ZlRXZlbnRMaXN0ZW5lcignbW91c2Vtb3ZlJywgb25Ub3VjaG1vdmUpO1xuICAgICAgICBmcmFtZS5yZW1vdmVFdmVudExpc3RlbmVyKCdtb3VzZXVwJywgb25Ub3VjaGVuZCk7XG4gICAgICAgIGZyYW1lLnJlbW92ZUV2ZW50TGlzdGVuZXIoJ21vdXNlbGVhdmUnLCBvblRvdWNoZW5kKTtcblxuICAgICAgICBkaXNwYXRjaFNsaWRlckV2ZW50KCdvbicsICd0b3VjaGVuZCcsIHtcbiAgICAgICAgICAgIGV2ZW50OiBldmVudFxuICAgICAgICB9KTtcbiAgICB9XG5cbiAgICBmdW5jdGlvbiBvbkNsaWNrKGV2ZW50KSB7XG4gICAgICAgIGlmIChkZWx0YS54KSB7XG4gICAgICAgICAgICBldmVudC5wcmV2ZW50RGVmYXVsdCgpO1xuICAgICAgICB9XG4gICAgfVxuXG4gICAgZnVuY3Rpb24gb25SZXNpemUoZXZlbnQpIHtcbiAgICAgICAgaWYgKGZyYW1lV2lkdGggIT09IGVsZW1lbnRXaWR0aChmcmFtZSkpIHtcbiAgICAgICAgICAgIHJlc2V0KCk7XG5cbiAgICAgICAgICAgIGRpc3BhdGNoU2xpZGVyRXZlbnQoJ29uJywgJ3Jlc2l6ZScsIHtcbiAgICAgICAgICAgICAgICBldmVudDogZXZlbnRcbiAgICAgICAgICAgIH0pO1xuICAgICAgICB9XG4gICAgfVxuXG4gICAgLy8gdHJpZ2dlciBpbml0aWFsIHNldHVwXG4gICAgc2V0dXAoKTtcblxuICAgIC8vIGV4cG9zZSBwdWJsaWMgYXBpXG4gICAgcmV0dXJuIHtcbiAgICAgICAgc2V0dXA6IHNldHVwLFxuICAgICAgICByZXNldDogcmVzZXQsXG4gICAgICAgIHNsaWRlVG86IHNsaWRlVG8sXG4gICAgICAgIHJldHVybkluZGV4OiByZXR1cm5JbmRleCxcbiAgICAgICAgcHJldjogcHJldixcbiAgICAgICAgbmV4dDogbmV4dCxcbiAgICAgICAgZGVzdHJveTogZGVzdHJveVxuICAgIH07XG59XG5cbi8qKiovIH0pLFxuLyogMSAqL1xuLyoqKi8gKGZ1bmN0aW9uKG1vZHVsZSwgZXhwb3J0cywgX193ZWJwYWNrX3JlcXVpcmVfXykge1xuXG5cInVzZSBzdHJpY3RcIjtcblxuXG5PYmplY3QuZGVmaW5lUHJvcGVydHkoZXhwb3J0cywgXCJfX2VzTW9kdWxlXCIsIHtcbiAgICB2YWx1ZTogdHJ1ZVxufSk7XG5leHBvcnRzLmRlZmF1bHQgPSBkZXRlY3RQcmVmaXhlcztcbi8qKlxuICogRGV0ZWN0aW5nIHByZWZpeGVzIGZvciBzYXZpbmcgdGltZSBhbmQgYnl0ZXNcbiAqL1xuZnVuY3Rpb24gZGV0ZWN0UHJlZml4ZXMoKSB7XG4gICAgdmFyIHRyYW5zZm9ybSA9IHZvaWQgMDtcbiAgICB2YXIgdHJhbnNpdGlvbiA9IHZvaWQgMDtcbiAgICB2YXIgdHJhbnNpdGlvbkVuZCA9IHZvaWQgMDtcblxuICAgIChmdW5jdGlvbiAoKSB7XG4gICAgICAgIHZhciBlbCA9IGRvY3VtZW50LmNyZWF0ZUVsZW1lbnQoJ18nKTtcbiAgICAgICAgdmFyIHN0eWxlID0gZWwuc3R5bGU7XG5cbiAgICAgICAgdmFyIHByb3AgPSB2b2lkIDA7XG5cbiAgICAgICAgaWYgKHN0eWxlW3Byb3AgPSAnd2Via2l0VHJhbnNpdGlvbiddID09PSAnJykge1xuICAgICAgICAgICAgdHJhbnNpdGlvbkVuZCA9ICd3ZWJraXRUcmFuc2l0aW9uRW5kJztcbiAgICAgICAgICAgIHRyYW5zaXRpb24gPSBwcm9wO1xuICAgICAgICB9XG5cbiAgICAgICAgaWYgKHN0eWxlW3Byb3AgPSAndHJhbnNpdGlvbiddID09PSAnJykge1xuICAgICAgICAgICAgdHJhbnNpdGlvbkVuZCA9ICd0cmFuc2l0aW9uZW5kJztcbiAgICAgICAgICAgIHRyYW5zaXRpb24gPSBwcm9wO1xuICAgICAgICB9XG5cbiAgICAgICAgaWYgKHN0eWxlW3Byb3AgPSAnd2Via2l0VHJhbnNmb3JtJ10gPT09ICcnKSB7XG4gICAgICAgICAgICB0cmFuc2Zvcm0gPSBwcm9wO1xuICAgICAgICB9XG5cbiAgICAgICAgaWYgKHN0eWxlW3Byb3AgPSAnbXNUcmFuc2Zvcm0nXSA9PT0gJycpIHtcbiAgICAgICAgICAgIHRyYW5zZm9ybSA9IHByb3A7XG4gICAgICAgIH1cblxuICAgICAgICBpZiAoc3R5bGVbcHJvcCA9ICd0cmFuc2Zvcm0nXSA9PT0gJycpIHtcbiAgICAgICAgICAgIHRyYW5zZm9ybSA9IHByb3A7XG4gICAgICAgIH1cblxuICAgICAgICBkb2
2844N1bWVudC5ib2R5Lmluc2VydEJlZm9yZShlbCwgbnVsbCk7XG4gICAgICAgIHN0eWxlW3RyYW5zZm9ybV0gPSAndHJhbnNsYXRlWCgwKSc7XG4gICAgICAgIGRvY3VtZW50LmJvZHkucmVtb3ZlQ2hpbGQoZWwpO1xuICAgIH0pKCk7XG5cbiAgICByZXR1cm4ge1xuICAgICAgICB0cmFuc2Zvcm06IHRyYW5zZm9ybSxcbiAgICAgICAgdHJhbnNpdGlvbjogdHJhbnNpdGlvbixcbiAgICAgICAgdHJhbnNpdGlvbkVuZDogdHJhbnNpdGlvbkVuZFxuICAgIH07XG59XG5cbi8qKiovIH0pLFxuLyogMiAqL1xuLyoqKi8gKGZ1bmN0aW9uKG1vZHVsZSwgZXhwb3J0cywgX193ZWJwYWNrX3JlcXVpcmVfXykge1xuXG5cInVzZSBzdHJpY3RcIjtcblxuXG5PYmplY3QuZGVmaW5lUHJvcGVydHkoZXhwb3J0cywgXCJfX2VzTW9kdWxlXCIsIHtcbiAgICB2YWx1ZTogdHJ1ZVxufSk7XG5leHBvcnRzLmRlZmF1bHQgPSBkZXRlY3RTdXBwb3J0c1Bhc3NpdmU7XG5mdW5jdGlvbiBkZXRlY3RTdXBwb3J0c1Bhc3NpdmUoKSB7XG4gICAgdmFyIHN1cHBvcnRzUGFzc2l2ZSA9IGZhbHNlO1xuXG4gICAgdHJ5IHtcbiAgICAgICAgdmFyIG9wdHMgPSBPYmplY3QuZGVmaW5lUHJvcGVydHkoe30sICdwYXNzaXZlJywge1xuICAgICAgICAgICAgZ2V0OiBmdW5jdGlvbiBnZXQoKSB7XG4gICAgICAgICAgICAgICAgc3VwcG9ydHNQYXNzaXZlID0gdHJ1ZTtcbiAgICAgICAgICAgIH1cbiAgICAgICAgfSk7XG5cbiAgICAgICAgd2luZG93LmFkZEV2ZW50TGlzdGVuZXIoJ3Rlc3RQYXNzaXZlJywgbnVsbCwgb3B0cyk7XG4gICAgICAgIHdpbmRvdy5yZW1vdmVFdmVudExpc3RlbmVyKCd0ZXN0UGFzc2l2ZScsIG51bGwsIG9wdHMpO1xuICAgIH0gY2F0Y2ggKGUpIHt9XG5cbiAgICByZXR1cm4gc3VwcG9ydHNQYXNzaXZlO1xufVxuXG4vKioqLyB9KSxcbi8qIDMgKi9cbi8qKiovIChmdW5jdGlvbihtb2R1bGUsIGV4cG9ydHMsIF9fd2VicGFja19yZXF1aXJlX18pIHtcblxuXCJ1c2Ugc3RyaWN0XCI7XG5cblxuT2JqZWN0LmRlZmluZVByb3BlcnR5KGV4cG9ydHMsIFwiX19lc01vZHVsZVwiLCB7XG4gICAgdmFsdWU6IHRydWVcbn0pO1xuZXhwb3J0cy5kZWZh
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
2844dGlhbEluZGV4IHtudW1iZXJ9XG4gICAqL1xuICBpbml0aWFsSW5kZXg6IDAsXG5cbiAgLyoqXG4gICAqIGNsYXNzIG5hbWUgZm9yIHNsaWRlciBmcmFtZVxuICAgKiBAY2xhc3NOYW1lRnJhbWUge3N0cmluZ31cbiAgICovXG4gIGNsYXNzTmFtZUZyYW1lOiAnanNfZnJhbWUnLFxuXG4gIC8qKlxuICAgKiBjbGFzcyBuYW1lIGZvciBzbGlkZXMgY29udGFpbmVyXG4gICAqIEBjbGFzc05hbWVTbGlkZUNvbnRhaW5lciB7c3RyaW5nfVxuICAgKi9cbiAgY2xhc3NOYW1lU2xpZGVDb250YWluZXI6ICdqc19zbGlkZXMnLFxuXG4gIC8qKlxuICAgKiBjbGFzcyBuYW1lIGZvciBzbGlkZXIgcHJldiBjb250cm9sXG4gICAqIEBjbGFzc05hbWVQcmV2Q3RybCB7c3RyaW5nfVxuICAgKi9cbiAgY2xhc3NOYW1lUHJldkN0cmw6ICdqc19wcmV2JyxcblxuICAvKipcbiAgICogY2xhc3MgbmFtZSBmb3Igc2xpZGVyIG5leHQgY29udHJvbFxuICAgKiBAY2xhc3NOYW1lTmV4dEN0cmwge3N0cmluZ31cbiAgICovXG4gIGNsYXNzTmFtZU5leHRDdHJsOiAnanNfbmV4dCcsXG5cbiAgLyoqXG4gICAqIGNsYXNzIG5hbWUgZm9yIGN1cnJlbnQgYWN0aXZlIHNsaWRlXG4gICAqIGlmIGVtcHR5U3RyaW5nIHRoZW4gbm8gY2xhc3MgaXMgc2V0XG4gICAqIEBjbGFzc05hbWVBY3RpdmVTbGlkZSB7c3RyaW5nfVxuICAgKi9cbiAgY2xhc3NOYW1lQWN0aXZlU2xpZGU6ICdhY3RpdmUnLFxuXG4gIC8qKlxuICAgKiBlbmFibGVzIG1vdXNlIGV2ZW50cyBmb3Igc3dpcGluZyBvbiBkZXNrdG9wIGRldmljZXNcbiAgICogQGVuYWJsZU1vdXNlRXZlbnRzIHtib29sZWFufVxuICAgKi9cbiAgZW5hYmxlTW91c2VFdmVudHM6IGZhbHNlLFxuXG4gIC8qKlxuICAgKiB3aW5kb3cgaW5zdGFuY2VcbiAgICogQHdpbmRvdyB7b2JqZWN0fVxuICAgKi9cbiAgd2luZG93OiB0eXBlb2Ygd2luZG93ICE9PSAndW5kZWZpbmVkJyA/IHdpbmRvdyA6IG51bGwsXG5cbiAgLyoqXG4gICAqIElmIGZhbHNlLCBzbGlkZXMgbG9yeSB0byB0aGUgZmlyc3Qgc2xpZGUgb24gd2luZG93IHJlc2l6ZS5cbiAgICogQHJld2luZE9uUmVzaXplIHtib29sZWFufVxuICAgKi9cbiAgcmV3aW5kT25SZXNpemU6IHRydWVcbn07XG5cbi8qKiovIH0pLFxuLyogNyAqL1xuLyoqKi8gKGZ1bmN0aW9uKG1vZHVsZSwgZXhwb3J0cywgX193ZWJwYWNrX3JlcXVpcmVfXykge1xuXG5tb2R1bGUuZXhwb3J0cyA9IF9fd2VicGFja19yZXF1aXJlX18oMCk7XG5cblxuLyoqKi8gfSlcbi8qKioqKiovIF0pO1xufSk7Il19
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.