1/******/ 2(() => { // webpackBootstrap 3 /******/ 4 var __webpack_modules__ = ({ 5 6
6/***/ "./resources/js/cookie-consent.js": 7 /*!****************************************!*\ 8 !*** ./resources/js/cookie-consent.js ***! 9 \****************************************/ 10 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { 11 12 "use strict"; 13 __webpack_require__.r(__webpack_exports__); 14 /* harmony import */ 15 var _util_cookies__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./util/cookies */ "./resources/js/util/cookies.js"); 16 /* harmony import */ 17 var _util_dom__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./util/dom */ "./resources/js/util/dom.js"); 18 /* harmony import */ 19 var _util_modals__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./util/modals */ "./resources/js/util/modals.js"); 20 /* harmony import */ 21 var wicg_inert__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! wicg-inert */ "./node_modules/wicg-inert/dist/inert.esm.js"); 22 /* harmony import */ 23 var wicg_inert__WEBPACK_IMPORTED_MODULE_3___default = /*#__PURE__*/__webpack_require__.n(wicg_inert__WEBPACK_IMPORTED_MODULE_3__); 24 25 26 var modalAlert = document.querySelector('.js-lcc-modal-alert'); 27 var modalSettings = document.querySelector('.js-lcc-modal-settings'); 28 var modalSettingsTrigger = document.querySelector('button.js-lcc-settings-toggle'); 29 var backdrop = document.querySelector('.js-lcc-backdrop'); 30 var checkboxAnalytics = document.getElementById('lcc-checkbox-analytics'); 31 var checkboxMarketing = document.getElementById('lcc-checkbox-marketing'); 32 var COOKIE_KEY = modalAlert.dataset.cookieKey || '__cookie_consent'; 33 var COOKIE_VALUE_ANALYTICS = modalAlert.dataset.cookieValueAnalytics || '2'; 34 var COOKIE_VALUE_MARKETING = modalAlert.dataset.cookieValueMarketing || '3'; 35 var COOKIE_VALUE_NONE = modalAlert.dataset.cookieValueNone || 'false'; 36 var COOKIE_VALUE_BOTH = modalAlert.dataset.cookieValueBoth || 'true'; 37 var COOKIE_EXPIRATION_DAYS = modalAlert.dataset.cookieExpirationDays || '365'; 38 var GTM_EVENT = modalAlert.dataset.gtmEvent || 'pageview'; 39 var ignoredPaths = modalAlert.dataset.ignoredPaths || null; 40 var onConsentChange; 41 initialize(); 42 43 window.cookieBannerConsentChange = function (callback) { 44 onConsentChange = callback; 45 }; 46 47 function initialize() { 48 var ignoredPathsArray = ignoredPaths ? ignoredPaths.split(',').map(function (ignoredPath) { 49 return ignoredPath.trim(); 50 }) : []; 51 var isIgnoredPage = ignoredPathsArray.indexOf(location.pathname) > -1; 52 var isRobot = /bot|google|baidu|bing|msn|duckduckbot|teoma|slurp|yandex/i.test(navigator.userAgent); 53 if (isRobot || !modalAlert || !modalSettings) return; 54 55 if (!(0, _util_cookies__WEBPACK_IMPORTED_MODULE_0__.getCookie)(COOKIE_KEY) && !isIgnoredPage) { 56 (0, _util_modals__WEBPACK_IMPORTED_MODULE_2__.showModal)(modalAlert); 57 } 58 59 initSettings(); 60 (0, _util_dom__WEBPACK_IMPORTED_MODULE_1__.addEventListener)('click', '.js-lcc-settings-toggle', function () { 61 toggleModalSettings(); 62 }); 63 (0, _util_dom__WEBPACK_IMPORTED_MODULE_1__.addEventListener)('click', '.js-lcc-essentials', function () { 64 updateCookie(COOKIE_VALUE_NONE); 65 (0, _util_modals__WEBPACK_IMPORTED_MODULE_2__.hideModal)(modalSettings, true); 66 (0, _util_modals__WEBPACK_IMPORTED_MODULE_2__.hideModal)(modalAlert); 67 }); 68 (0, _util_dom__WEBPACK_IMPORTED_MODULE_1__.addEventListener)('click', '.js-lcc-accept', function () { 69 updateCookie('true'); 70 (0, _util_modals__WEBPACK_IMPORTED_MODULE_2__.hideModal)(modalSettings, true); 71 (0, _util_modals__WEBPACK_IMPORTED_MODULE_2__.hideModal)(modalAlert); 72 }); 73 (0, _util_dom__WEBPACK_IMPORTED_MODULE_1__.addEventListener)('click', '.js-lcc-settings-save', function () { 74 saveSettings(); 75 toggleModalSettings(); 76 (0, _util_modals__WEBPACK_IMPORTED_MODULE_2__.hideModal)(modalAlert); 77 }); 78 } 79 80 function toggleModalSettings() { 81 if ((0, _util_dom__WEBPACK_IMPORTED_MODULE_1__.isHidden)(modalSettings)) { 82 (0, _util_modals__WEBPACK_IMPORTED_MODULE_2__.showModal)(modalSettings, !(0, _util_dom__WEBPACK_IMPORTED_MODULE_1__.isHidden)(modalAlert)); 83 initSettings(); 84 backdrop.addEventListener('click', backdropListener); 85 document.body.addEventListener('keydown', keyboardListener); 86 } else { 87 hideModalSettings(); 88 } 89 90 function backdropListener() { 91 hideModalSettings(); 92 } 93 94 function keyboardListener(event) { 95 // Close modal on pressing Escape key 96 if ((event.which || event.keyCode) == 27) { 97 event.preventDefault(); 98 hideModalSettings(); 99 } 100 } 101 102 function hideModalSettings() { 103 backdrop.removeEventListener('click', backdropListener); 104 document.body.removeEventListener('keydown', keyboardListener); 105 (0, _util_modals__WEBPACK_IMPORTED_MODULE_2__.hideModal)(modalSettings, !(0, _util_cookies__WEBPACK_IMPORTED_MODULE_0__.getCookie)(COOKIE_KEY)); 106 107 if (!(0, _util_cookies__WEBPACK_IMPORTED_MODULE_0__.getCookie)(COOKIE_KEY)) { 108 (0, _util_modals__WEBPACK_IMPORTED_MODULE_2__.showModal)(modalAlert, true); 109 } 110 111 modalSettingsTrigger.focus(); 112 } 113 } 114 115 function initSettings() { 116 var cookieValue = (0, _util_cookies__WEBPACK_IMPORTED_MODULE_0__.getCookie)(COOKIE_KEY); 117 checkboxAnalytics.checked = cookieValue === COOKIE_VALUE_BOTH || cookieValue === COOKIE_VALUE_ANALYTICS; 118 checkboxMarketing.checked = cookieValue === COOKIE_VALUE_BOTH || cookieValue === COOKIE_VALUE_MARKETING; 119 } 120 121 function saveSettings() { 122 var cookieValue; 123 124 if (checkboxAnalytics.checked && checkboxMarketing.checked) { 125 cookieValue = COOKIE_VALUE_BOTH; 126 } else if (checkboxAnalytics.checked) { 127 cookieValue = COOKIE_VALUE_ANALYTICS; 128 } else if (checkboxMarketing.checked) { 129 cookieValue = COOKIE_VALUE_MARKETING; 130 } else { 131 cookieValue = COOKIE_VALUE_NONE; 132 } 133 134 updateCookie(cookieValue); 135 } 136 137 function updateCookie(cookieValue) { 138 (0, _util_cookies__WEBPACK_IMPORTED_MODULE_0__.setCookie)(COOKIE_KEY, COOKIE_EXPIRATION_DAYS, cookieValue); 139 140 if (onConsentChange) { 141 onConsentChange(cookieValue); 142 } // Fire GTM event if dataLayer is found 143 144 145 if (window.dataLayer) { 146 window.dataLayer.push({ 147 event: GTM_EVENT 148 }); 149 } 150 } 151 152 /***/ 153 }), 154 155
155/***/ "./resources/js/util/cookies.js": 156 /*!**************************************!*\ 157 !*** ./resources/js/util/cookies.js ***! 158 \**************************************/ 159 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { 160 161 "use strict"; 162 __webpack_require__.r(__webpack_exports__); 163 /* harmony export */ 164 __webpack_require__.d(__webpack_exports__, { 165 /* harmony export */ "getCookie": () => (/* binding */ getCookie), 166 /* harmony export */ "setCookie": () => (/* binding */ setCookie) 167 /* harmony export */ 168 }); 169 170 function getCookie(key) { 171 if (!key) return null; 172 return decodeURIComponent(document.cookie.replace(new RegExp('(?:(?:^|.*;)\\s*' + encodeURIComponent(key).replace(/[\-\.\+\*]/g, '\\$&') + '\\s*\\=\\s*([^;]*).*$)|^.*$'), '$1')) || null; 173 } 174 175 function setCookie(key, expireDays, value) { 176 var date = new Date(); 177 var expires = null; 178 179 if (expireDays) { 180 date.setTime(date.getTime() + expireDays * 24 * 60 * 60 * 1000); 181 expires = date.toUTCString(); 182 } 183 184 document.cookie = "".concat(encodeURIComponent(key), "=").concat(encodeURIComponent(value)).concat(expires ? "; expires=".concat(expires) : '', "; path=/"); 185 } 186 187 /***/ 188 }), 189 190
190/***/ "./resources/js/util/dom.js": 191 /*!**********************************!*\ 192 !*** ./resources/js/util/dom.js ***! 193 \**********************************/ 194 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { 195 196 "use strict"; 197 __webpack_require__.r(__webpack_exports__); 198 /* harmony export */ 199 __webpack_require__.d(__webpack_exports__, { 200 /* harmony export */ "addEventListener": () => (/* binding */ addEventListener), 201 /* harmony export */ "elementMatchesSelector": () => (/* binding */ elementMatchesSelector), 202 /* harmony export */ "getSiblings": () => (/* binding */ getSiblings), 203 /* harmony export */ "hideElement": () => (/* binding */ hideElement), 204 /* harmony export */ "isHidden": () => (/* binding */ isHidden), 205 /* harmony export */ "showElement": () => (/* binding */ showElement) 206 /* harmony export */ 207 }); 208 209 function showElement(element) { 210 element.style.display = ''; 211 } 212 213 function hideElement(element) { 214 element.style.display = 'none'; 215 } 216 217 function isHidden(element) { 218 return element.style.display === 'none'; 219 } 220 221 function elementMatchesSelector(element, selector) { 222 if (typeof element.matches === 'function') { 223 return element.matches(selector); 224 } 225 226 var propertySuffix = 'MatchesSelector'; // Fallback for older browsers that don't support Element.matches(), but do support prefixed functions 227 228 for (var property in element) { 229 if (property.substring(property.length - propertySuffix.length, property.length) === propertySuffix) { 230 return element[property](selector); 231 } 232 } 233 234 return false; 235 } 236 237 function getSiblings(element, selector) { 238 var siblings = []; 239 var sibling = element.parentNode.firstChild; 240 241 while (sibling) { 242 if (sibling.nodeType === 1 && sibling !== element) { 243 if (typeof selector !== 'undefined') { 244 if (elementMatchesSelector(sibling, selector)) { 245 siblings.push(sibling); 246 } 247 } else { 248 siblings.push(sibling); 249 } 250 } 251 252 sibling = sibling.nextSibling; 253 } 254 255 return siblings; 256 } 257 258 function addEventListener(eventType, selector, listener) { 259 [].forEach.call(document.querySelectorAll(selector), function (element) { 260 element.addEventListener(eventType, listener); 261 }); 262 } 263 264 /***/ 265 }), 266 267
267/***/ "./resources/js/util/modals.js": 268 /*!*************************************!*\ 269 !*** ./resources/js/util/modals.js ***! 270 \*************************************/ 271 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { 272 273 "use strict"; 274 __webpack_require__.r(__webpack_exports__); 275 /* harmony export */ 276 __webpack_require__.d(__webpack_exports__, { 277 /* harmony export */ "hideModal": () => (/* binding */ hideModal), 278 /* harmony export */ "showModal": () => (/* binding */ showModal) 279 /* harmony export */ 280 }); 281 /* harmony import */ 282 var _dom__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./dom */ "./resources/js/util/dom.js"); 283 284 function showModal(modal) { 285 var ignoreBackdrop = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false; 286 // Make all sibling elements inert (not focusable) 287 (0, _dom__WEBPACK_IMPORTED_MODULE_0__.getSiblings)(modal, ':not(.js-lcc-backdrop)').forEach(function (sibling) { 288 sibling.inert = true; 289 }); 290 modal.inert = false; 291 292 if (!ignoreBackdrop) { 293 fadeBackdrop(); 294 } 295 296 (0, _dom__WEBPACK_IMPORTED_MODULE_0__.showElement)(modal); 297 } 298 299 function hideModal(modal) { 300 var ignoreBackdrop = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false; 301 (0, _dom__WEBPACK_IMPORTED_MODULE_0__.getSiblings)(modal, ':not(.js-lcc-modal)').forEach(function (sibling) { 302 sibling.inert = false; 303 }); 304 modal.inert = true; 305 (0, _dom__WEBPACK_IMPORTED_MODULE_0__.hideElement)(modal); 306 307 if (!ignoreBackdrop) { 308 fadeBackdrop(); 309 } 310 } 311 312 function fadeBackdrop() { 313 var backdropElement = document.querySelector('.js-lcc-backdrop'); 314 315 if ((0, _dom__WEBPACK_IMPORTED_MODULE_0__.isHidden)(backdropElement)) { 316 (0, _dom__WEBPACK_IMPORTED_MODULE_0__.showElement)(backdropElement); 317 backdropElement.style.opacity = '1'; 318 } else { 319 backdropElement.addEventListener('transitionend', hideBackdrop); 320 backdropElement.style.opacity = '0'; 321 } 322 323 function hideBackdrop() { 324 (0, _dom__WEBPACK_IMPORTED_MODULE_0__.hideElement)(backdropElement); 325 backdropElement.removeEventListener('transitionend', hideBackdrop); 326 } 327 328 ; 329 } 330 331 /***/ 332 }), 333 334
334/***/ "./resources/sass/cookie-consent.scss": 335 /*!********************************************!*\ 336 !*** ./resources/sass/cookie-consent.scss ***! 337 \********************************************/ 338 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => { 339 340 "use strict"; 341 __webpack_require__.r(__webpack_exports__); 342// extracted by mini-css-extract-plugin 343 344 345 /***/ 346 }), 347 348
vendor: 42,587 bytes, lines 348-1214
348/***/ "./node_modules/wicg-inert/dist/inert.esm.js": 349 /*!***************************************************!*\ 350 !*** ./node_modules/wicg-inert/dist/inert.esm.js ***! 351 \***************************************************/ 352 /***/ (() => { 353 354 var _createClass = function () { 355 function defineProperties(target, props) { 356 for (var i = 0; i < props.length; i++) { 357 var descriptor = props[i]; 358 descriptor.enumerable = descriptor.enumerable || false; 359 descriptor.configurable = true; 360 if ("value" in descriptor) descriptor.writable = true; 361 Object.defineProperty(target, descriptor.key, descriptor); 362 } 363 } 364 365 return function (Constructor, protoProps, staticProps) { 366 if (protoProps) defineProperties(Constructor.prototype, protoProps); 367 if (staticProps) defineProperties(Constructor, staticProps); 368 return Constructor; 369 }; 370 }(); 371 372 function _classCallCheck(instance, Constructor) { 373 if (!(instance instanceof Constructor)) { 374 throw new TypeError("Cannot call a class as a function"); 375 } 376 } 377 378 /** 379 * This work is licensed under the W3C Software and Document License 380 * (http://www.w3.org/Consortium/Legal/2015/copyright-software-and-document). 381 */ 382 383 (function () { 384 // Return early if we're not running inside of the browser. 385 if (typeof window === 'undefined') { 386 return; 387 } 388 389 // Convenience function for converting NodeLists. 390 /** @type {typeof Array.prototype.slice} */ 391 var slice = Array.prototype.slice; 392 393 /** 394 * IE has a non-standard name for "matches". 395 * @type {typeof Element.prototype.matches} 396 */ 397 var matches = Element.prototype.matches || Element.prototype.msMatchesSelector; 398 399 /** @type {string} */ 400 var _focusableElementsString = ['a[href]', 'area[href]', 'input:not([disabled])', 'select:not([disabled])', 'textarea:not([disabled])', 'button:not([disabled])', 'details', 'summary', 'iframe', 'object', 'embed', '[contenteditable]'].join(','); 401 402 /** 403 * `InertRoot` manages a single inert subtree, i.e. a DOM subtree whose root element has an `inert` 404 * attribute. 405 * 406 * Its main functions are: 407 * 408 * - to create and maintain a set of managed `InertNode`s, including when mutations occur in the 409 * subtree. The `makeSubtreeUnfocusable()` method handles collecting `InertNode`s via registering 410 * each focusable node in the subtree with the singleton `InertManager` which manages all known 411 * focusable nodes within inert subtrees. `InertManager` ensures that a single `InertNode` 412 * instance exists for each focusable node which has at least one inert root as an ancestor. 413 * 414 * - to notify all managed `InertNode`s when this subtree stops being inert (i.e. when the `inert` 415 * attribute is removed from the root node). This is handled in the destructor, which calls the 416 * `deregister` method on `InertManager` for each managed inert node. 417 */ 418 419 var InertRoot = function () { 420 /** 421 * @param {!Element} rootElement The Element at the root of the inert subtree. 422 * @param {!InertManager} inertManager The global singleton InertManager object. 423 */ 424 function InertRoot(rootElement, inertManager) { 425 _classCallCheck(this, InertRoot); 426 427 /** @type {!InertManager} */ 428 this._inertManager = inertManager; 429 430 /** @type {!Element} */ 431 this._rootElement = rootElement; 432 433 /** 434 * @type {!Set<!InertNode>} 435 * All managed focusable nodes in this InertRoot's subtree. 436 */ 437 this._managedNodes = new Set(); 438 439 // Make the subtree hidden from assistive technology 440 if (this._rootElement.hasAttribute('aria-hidden')) { 441 /** @type {?string} */ 442 this._savedAriaHidden = this._rootElement.getAttribute('aria-hidden'); 443 } else { 444 this._savedAriaHidden = null; 445 } 446 this._rootElement.setAttribute('aria-hidden', 'true'); 447 448 // Make all focusable elements in the subtree unfocusable and add them to _managedNodes 449 this._makeSubtreeUnfocusable(this._rootElement); 450 451 // Watch for: 452 // - any additions in the subtree: make them unfocusable too 453 // - any removals from the subtree: remove them from this inert root's managed nodes 454 // - attribute changes: if `tabindex` is added, or removed from an intrinsically focusable 455 // element, make that node a managed node. 456 this._observer = new MutationObserver(this._onMutation.bind(this)); 457 this._observer.observe(this._rootElement, {attributes: true, childList: true, subtree: true}); 458 } 459 460 /** 461 * Call this whenever this object is about to become obsolete. This unwinds all of the state 462 * stored in this object and updates the state of all of the managed nodes. 463 */ 464 465 466 _createClass(InertRoot, [{ 467 key: 'destructor', 468 value: function destructor() { 469 this._observer.disconnect(); 470 471 if (this._rootElement) { 472 if (this._savedAriaHidden !== null) { 473 this._rootElement.setAttribute('aria-hidden', this._savedAriaHidden); 474 } else { 475 this._rootElement.removeAttribute('aria-hidden'); 476 } 477 } 478 479 this._managedNodes.forEach(function (inertNode) { 480 this._unmanageNode(inertNode.node); 481 }, this); 482 483 // Note we cast the nulls to the ANY type here because: 484 // 1) We want the class properties to be declared as non-null, or else we 485 // need even more casts throughout this code. All bets are off if an 486 // instance has been destroyed and a method is called. 487 // 2) We don't want to cast "this", because we want type-aware optimizations 488 // to know which properties we're setting. 489 this._observer = /** @type {?} */null; 490 this._rootElement = /** @type {?} */null; 491 this._managedNodes = /** @type {?} */null; 492 this._inertManager = /** @type {?} */null; 493 } 494 495 /** 496 * @return {!Set<!InertNode>} A copy of this InertRoot's managed nodes set. 497 */ 498 499 }, { 500 key: '_makeSubtreeUnfocusable', 501 502 503 /** 504 * @param {!Node} startNode 505 */ 506 value: function _makeSubtreeUnfocusable(startNode) { 507 var _this2 = this; 508 509 composedTreeWalk(startNode, function (node) { 510 return _this2._visitNode(node); 511 }); 512 513 var activeElement = document.activeElement; 514 515 if (!document.body.contains(startNode)) { 516 // startNode may be in shadow DOM, so find its nearest shadowRoot to get the activeElement. 517 var node = startNode; 518 /** @type {!ShadowRoot|undefined} */ 519 var root = undefined; 520 while (node) { 521 if (node.nodeType === Node.DOCUMENT_FRAGMENT_NODE) { 522 root = /** @type {!ShadowRoot} */node; 523 break; 524 } 525 node = node.parentNode; 526 } 527 if (root) { 528 activeElement = root.activeElement; 529 } 530 } 531 if (startNode.contains(activeElement)) { 532 activeElement.blur(); 533 // In IE11, if an element is already focused, and then set to tabindex=-1 534 // calling blur() will not actually move the focus. 535 // To work around this we call focus() on the body instead. 536 if (activeElement === document.activeElement) { 537 document.body.focus(); 538 } 539 } 540 } 541 542 /** 543 * @param {!Node} node 544 */ 545 546 }, { 547 key: '_visitNode', 548 value: function _visitNode(node) { 549 if (node.nodeType !== Node.ELEMENT_NODE) { 550 return; 551 } 552 var element = /** @type {!Element} */node; 553 554 // If a descendant inert root becomes un-inert, its descendants will still be inert because of 555 // this inert root, so all of its managed nodes need to be adopted by this InertRoot. 556 if (element !== this._rootElement && element.hasAttribute('inert')) { 557 this._adoptInertRoot(element); 558 } 559 560 if (matches.call(element, _focusableElementsString) || element.hasAttribute('tabindex')) { 561 this._manageNode(element); 562 } 563 } 564 565 /** 566 * Register the given node with this InertRoot and with InertManager. 567 * @param {!Node} node 568 */ 569 570 }, { 571 key: '_manageNode', 572 value: function _manageNode(node) { 573 var inertNode = this._inertManager.register(node, this); 574 this._managedNodes.add(inertNode); 575 } 576 577 /** 578 * Unregister the given node with this InertRoot and with InertManager. 579 * @param {!Node} node 580 */ 581 582 }, { 583 key: '_unmanageNode', 584 value: function _unmanageNode(node) { 585 var inertNode = this._inertManager.deregister(node, this); 586 if (inertNode) { 587 this._managedNodes['delete'](inertNode); 588 } 589 } 590 591 /** 592 * Unregister the entire subtree starting at `startNode`. 593 * @param {!Node} startNode 594 */ 595 596 }, { 597 key: '_unmanageSubtree', 598 value: function _unmanageSubtree(startNode) { 599 var _this3 = this; 600 601 composedTreeWalk(startNode, function (node) { 602 return _this3._unmanageNode(node); 603 }); 604 } 605 606 /** 607 * If a descendant node is found with an `inert` attribute, adopt its managed nodes. 608 * @param {!Element} node 609 */ 610 611 }, { 612 key: '_adoptInertRoot', 613 value: function _adoptInertRoot(node) { 614 var inertSubroot = this._inertManager.getInertRoot(node); 615 616 // During initialisation this inert root may not have been registered yet, 617 // so register it now if need be. 618 if (!inertSubroot) { 619 this._inertManager.setInert(node, true); 620 inertSubroot = this._inertManager.getInertRoot(node); 621 } 622 623 inertSubroot.managedNodes.forEach(function (savedInertNode) { 624 this._manageNode(savedInertNode.node); 625 }, this); 626 } 627 628 /** 629 * Callback used when mutation observer detects subtree additions, removals, or attribute changes. 630 * @param {!Array<!MutationRecord>} records 631 * @param {!MutationObserver} self 632 */ 633 634 }, { 635 key: '_onMutation', 636 value: function _onMutation(records, self) { 637 records.forEach(function (record) { 638 var target = /** @type {!Element} */record.target; 639 if (record.type === 'childList') { 640 // Manage added nodes 641 slice.call(record.addedNodes).forEach(function (node) { 642 this._makeSubtreeUnfocusable(node); 643 }, this); 644 645 // Un-manage removed nodes 646 slice.call(record.removedNodes).forEach(function (node) { 647 this._unmanageSubtree(node); 648 }, this); 649 } else if (record.type === 'attributes') { 650 if (record.attributeName === 'tabindex') { 651 // Re-initialise inert node if tabindex changes 652 this._manageNode(target); 653 } else if (target !== this._rootElement && record.attributeName === 'inert' && target.hasAttribute('inert')) { 654 // If a new inert root is added, adopt its managed nodes and make sure it knows about the 655 // already managed nodes from this inert subroot. 656 this._adoptInertRoot(target); 657 var inertSubroot = this._inertManager.getInertRoot(target); 658 this._managedNodes.forEach(function (managedNode) { 659 if (target.contains(managedNode.node)) { 660 inertSubroot._manageNode(managedNode.node); 661 } 662 }); 663 } 664 } 665 }, this); 666 } 667 }, { 668 key: 'managedNodes', 669 get: function get() { 670 return new Set(this._managedNodes); 671 } 672 673 /** @return {boolean} */ 674 675 }, { 676 key: 'hasSavedAriaHidden', 677 get: function get() { 678 return this._savedAriaHidden !== null; 679 } 680 681 /** @param {?string} ariaHidden */ 682 683 }, { 684 key: 'savedAriaHidden', 685 set: function set(ariaHidden) { 686 this._savedAriaHidden = ariaHidden; 687 } 688 689 /** @return {?string} */ 690 , 691 get: function get() { 692 return this._savedAriaHidden; 693 } 694 }]); 695 696 return InertRoot; 697 }(); 698 699 /** 700 * `InertNode` initialises and manages a single inert node. 701 * A node is inert if it is a descendant of one or more inert root elements. 702 * 703 * On construction, `InertNode` saves the existing `tabindex` value for the node, if any, and 704 * either removes the `tabindex` attribute or sets it to `-1`, depending on whether the element 705 * is intrinsically focusable or not. 706 * 707 * `InertNode` maintains a set of `InertRoot`s which are descendants of this `InertNode`. When an 708 * `InertRoot` is destroyed, and calls `InertManager.deregister()`, the `InertManager` notifies the 709 * `InertNode` via `removeInertRoot()`, which in turn destroys the `InertNode` if no `InertRoot`s 710 * remain in the set. On destruction, `InertNode` reinstates the stored `tabindex` if one exists, 711 * or removes the `tabindex` attribute if the element is intrinsically focusable. 712 */ 713 714 715 var InertNode = function () { 716 /** 717 * @param {!Node} node A focusable element to be made inert. 718 * @param {!InertRoot} inertRoot The inert root element associated with this inert node. 719 */ 720 function InertNode(node, inertRoot) { 721 _classCallCheck(this, InertNode); 722 723 /** @type {!Node} */ 724 this._node = node; 725 726 /** @type {boolean} */ 727 this._overrodeFocusMethod = false; 728 729 /** 730 * @type {!Set<!InertRoot>} The set of descendant inert roots. 731 * If and only if this set becomes empty, this node is no longer inert. 732 */ 733 this._inertRoots = new Set([inertRoot]); 734 735 /** @type {?number} */ 736 this._savedTabIndex = null; 737 738 /** @type {boolean} */ 739 this._destroyed = false; 740 741 // Save any prior tabindex info and make this node untabbable 742 this.ensureUntabbable(); 743 } 744 745 /** 746 * Call this whenever this object is about to become obsolete. 747 * This makes the managed node focusable again and deletes all of the previously stored state. 748 */ 749 750 751 _createClass(InertNode, [{ 752 key: 'destructor', 753 value: function destructor() { 754 this._throwIfDestroyed(); 755 756 if (this._node && this._node.nodeType === Node.ELEMENT_NODE) { 757 var element = /** @type {!Element} */this._node; 758 if (this._savedTabIndex !== null) { 759 element.setAttribute('tabindex', this._savedTabIndex); 760 } else { 761 element.removeAttribute('tabindex'); 762 } 763 764 // Use `delete` to restore native focus method. 765 if (this._overrodeFocusMethod) { 766 delete element.focus; 767 } 768 } 769 770 // See note in InertRoot.destructor for why we cast these nulls to ANY. 771 this._node = /** @type {?} */null; 772 this._inertRoots = /** @type {?} */null; 773 this._destroyed = true; 774 } 775 776 /** 777 * @type {boolean} Whether this object is obsolete because the managed node is no longer inert. 778 * If the object has been destroyed, any attempt to access it will cause an exception. 779 */ 780 781 }, { 782 key: '_throwIfDestroyed', 783 784 785 /** 786 * Throw if user tries to access destroyed InertNode. 787 */ 788 value: function _throwIfDestroyed() { 789 if (this.destroyed) { 790 throw new Error('Trying to access destroyed InertNode'); 791 } 792 } 793 794 /** @return {boolean} */ 795 796 }, { 797 key: 'ensureUntabbable', 798 799 800 /** Save the existing tabindex value and make the node untabbable and unfocusable */ 801 value: function ensureUntabbable() { 802 if (this.node.nodeType !== Node.ELEMENT_NODE) { 803 return; 804 } 805 var element = /** @type {!Element} */this.node; 806 if (matches.call(element, _focusableElementsString)) { 807 if ( /** @type {!HTMLElement} */element.tabIndex === -1 && this.hasSavedTabIndex) { 808 return; 809 } 810 811 if (element.hasAttribute('tabindex')) { 812 this._savedTabIndex = /** @type {!HTMLElement} */element.tabIndex; 813 } 814 element.setAttribute('tabindex', '-1'); 815 if (element.nodeType === Node.ELEMENT_NODE) { 816 element.focus = function () { 817 }; 818 this._overrodeFocusMethod = true; 819 } 820 } else if (element.hasAttribute('tabindex')) { 821 this._savedTabIndex = /** @type {!HTMLElement} */element.tabIndex; 822 element.removeAttribute('tabindex'); 823 } 824 } 825 826 /** 827 * Add another inert root to this inert node's set of managing inert roots. 828 * @param {!InertRoot} inertRoot 829 */ 830 831 }, { 832 key: 'addInertRoot', 833 value: function addInertRoot(inertRoot) { 834 this._throwIfDestroyed(); 835 this._inertRoots.add(inertRoot); 836 } 837 838 /** 839 * Remove the given inert root from this inert node's set of managing inert roots. 840 * If the set of managing inert roots becomes empty, this node is no longer inert, 841 * so the object should be destroyed. 842 * @param {!InertRoot} inertRoot 843 */ 844 845 }, { 846 key: 'removeInertRoot', 847 value: function removeInertRoot(inertRoot) { 848 this._throwIfDestroyed(); 849 this._inertRoots['delete'](inertRoot); 850 if (this._inertRoots.size === 0) { 851 this.destructor(); 852 } 853 } 854 }, { 855 key: 'destroyed', 856 get: function get() { 857 return (/** @type {!InertNode} */this._destroyed 858 ); 859 } 860 }, { 861 key: 'hasSavedTabIndex', 862 get: function get() { 863 return this._savedTabIndex !== null; 864 } 865 866 /** @return {!Node} */ 867 868 }, { 869 key: 'node', 870 get: function get() { 871 this._throwIfDestroyed(); 872 return this._node; 873 } 874 875 /** @param {?number} tabIndex */ 876 877 }, { 878 key: 'savedTabIndex', 879 set: function set(tabIndex) { 880 this._throwIfDestroyed(); 881 this._savedTabIndex = tabIndex; 882 } 883 884 /** @return {?number} */ 885 , 886 get: function get() { 887 this._throwIfDestroyed(); 888 return this._savedTabIndex; 889 } 890 }]); 891 892 return InertNode; 893 }(); 894 895 /** 896 * InertManager is a per-document singleton object which manages all inert roots and nodes. 897 * 898 * When an element becomes an inert root by having an `inert` attribute set and/or its `inert` 899 * property set to `true`, the `setInert` method creates an `InertRoot` object for the element. 900 * The `InertRoot` in turn registers itself as managing all of the element's focusable descendant 901 * nodes via the `register()` method. The `InertManager` ensures that a single `InertNode` instance 902 * is created for each such node, via the `_managedNodes` map. 903 */ 904 905 906 var InertManager = function () { 907 /** 908 * @param {!Document} document 909 */ 910 function InertManager(document) { 911 _classCallCheck(this, InertManager); 912 913 if (!document) { 914 throw new Error('Missing required argument; InertManager needs to wrap a document.'); 915 } 916 917 /** @type {!Document} */ 918 this._document = document; 919 920 /** 921 * All managed nodes known to this InertManager. In a map to allow looking up by Node. 922 * @type {!Map<!Node, !InertNode>} 923 */ 924 this._managedNodes = new Map(); 925 926 /** 927 * All inert roots known to this InertManager. In a map to allow looking up by Node. 928 * @type {!Map<!Node, !InertRoot>} 929 */ 930 this._inertRoots = new Map(); 931 932 /** 933 * Observer for mutations on `document.body`. 934 * @type {!MutationObserver} 935 */ 936 this._observer = new MutationObserver(this._watchForInert.bind(this)); 937 938 // Add inert style. 939 addInertStyle(document.head || document.body || document.documentElement); 940 941 // Wait for document to be loaded. 942 if (document.readyState === 'loading') { 943 document.addEventListener('DOMContentLoaded', this._onDocumentLoaded.bind(this)); 944 } else { 945 this._onDocumentLoaded(); 946 } 947 } 948 949 /** 950 * Set whether the given element should be an inert root or not. 951 * @param {!Element} root 952 * @param {boolean} inert 953 */ 954 955 956 _createClass(InertManager, [{ 957 key: 'setInert', 958 value: function setInert(root, inert) { 959 if (inert) { 960 if (this._inertRoots.has(root)) { 961 // element is already inert 962 return; 963 } 964 965 var inertRoot = new InertRoot(root, this); 966 root.setAttribute('inert', ''); 967 this._inertRoots.set(root, inertRoot); 968 // If not contained in the document, it must be in a shadowRoot. 969 // Ensure inert styles are added there. 970 if (!this._document.body.contains(root)) { 971 var parent = root.parentNode; 972 while (parent) { 973 if (parent.nodeType === 11) { 974 addInertStyle(parent); 975 } 976 parent = parent.parentNode; 977 } 978 } 979 } else { 980 if (!this._inertRoots.has(root)) { 981 // element is already non-inert 982 return; 983 } 984 985 var _inertRoot = this._inertRoots.get(root); 986 _inertRoot.destructor(); 987 this._inertRoots['delete'](root); 988 root.removeAttribute('inert'); 989 } 990 } 991 992 /** 993 * Get the InertRoot object corresponding to the given inert root element, if any. 994 * @param {!Node} element 995 * @return {!InertRoot|undefined} 996 */ 997 998 }, { 999 key: 'getInertRoot', 1000 value: function getInertRoot(element) { 1001 return this._inertRoots.get(element); 1002 } 1003 1004 /** 1005 * Register the given InertRoot as managing the given node. 1006 * In the case where the node has a previously existing inert root, this inert root will 1007 * be added to its set of inert roots. 1008 * @param {!Node} node 1009 * @param {!InertRoot} inertRoot 1010 * @return {!InertNode} inertNode 1011 */ 1012 1013 }, { 1014 key: 'register', 1015 value: function register(node, inertRoot) { 1016 var inertNode = this._managedNodes.get(node); 1017 if (inertNode !== undefined) { 1018 // node was already in an inert subtree 1019 inertNode.addInertRoot(inertRoot); 1020 } else { 1021 inertNode = new InertNode(node, inertRoot); 1022 } 1023 1024 this._managedNodes.set(node, inertNode); 1025 1026 return inertNode; 1027 } 1028 1029 /** 1030 * De-register the given InertRoot as managing the given inert node. 1031 * Removes the inert root from the InertNode's set of managing inert roots, and remove the inert 1032 * node from the InertManager's set of managed nodes if it is destroyed. 1033 * If the node is not currently managed, this is essentially a no-op. 1034 * @param {!Node} node 1035 * @param {!InertRoot} inertRoot 1036 * @return {?InertNode} The potentially destroyed InertNode associated with this node, if any. 1037 */ 1038 1039 }, { 1040 key: 'deregister', 1041 value: function deregister(node, inertRoot) { 1042 var inertNode = this._managedNodes.get(node); 1043 if (!inertNode) { 1044 return null; 1045 } 1046 1047 inertNode.removeInertRoot(inertRoot); 1048 if (inertNode.destroyed) { 1049 this._managedNodes['delete'](node); 1050 } 1051 1052 return inertNode; 1053 } 1054 1055 /** 1056 * Callback used when document has finished loading. 1057 */ 1058 1059 }, { 1060 key: '_onDocumentLoaded', 1061 value: function _onDocumentLoaded() { 1062 // Find all inert roots in document and make them actually inert. 1063 var inertElements = slice.call(this._document.querySelectorAll('[inert]')); 1064 inertElements.forEach(function (inertElement) { 1065 this.setInert(inertElement, true); 1066 }, this); 1067 1068 // Comment this out to use programmatic API only. 1069 this._observer.observe(this._document.body || this._document.documentElement, { 1070 attributes: true, 1071 subtree: true, 1072 childList: true 1073 }); 1074 } 1075 1076 /** 1077 * Callback used when mutation observer detects attribute changes. 1078 * @param {!Array<!MutationRecord>} records 1079 * @param {!MutationObserver} self 1080 */ 1081 1082 }, { 1083 key: '_watchForInert', 1084 value: function _watchForInert(records, self) { 1085 var _this = this; 1086 records.forEach(function (record) { 1087 switch (record.type) { 1088 case 'childList': 1089 slice.call(record.addedNodes).forEach(function (node) { 1090 if (node.nodeType !== Node.ELEMENT_NODE) { 1091 return; 1092 } 1093 var inertElements = slice.call(node.querySelectorAll('[inert]')); 1094 if (matches.call(node, '[inert]')) { 1095 inertElements.unshift(node); 1096 } 1097 inertElements.forEach(function (inertElement) { 1098 this.setInert(inertElement, true); 1099 }, _this); 1100 }, _this); 1101 break; 1102 case 'attributes': 1103 if (record.attributeName !== 'inert') { 1104 return; 1105 } 1106 var target = /** @type {!Element} */record.target; 1107 var inert = target.hasAttribute('inert'); 1108 _this.setInert(target, inert); 1109 break; 1110 } 1111 }, this); 1112 } 1113 }]); 1114 1115 return InertManager; 1116 }(); 1117 1118 /** 1119 * Recursively walk the composed tree from |node|. 1120 * @param {!Node} node 1121 * @param {(function (!Element))=} callback Callback to be called for each element traversed, 1122 * before descending into child nodes. 1123 * @param {?ShadowRoot=} shadowRootAncestor The nearest ShadowRoot ancestor, if any. 1124 */ 1125 1126 1127 function composedTreeWalk(node, callback, shadowRootAncestor) { 1128 if (node.nodeType == Node.ELEMENT_NODE) { 1129 var element = /** @type {!Element} */node; 1130 if (callback) { 1131 callback(element); 1132 } 1133 1134 // Descend into node: 1135 // If it has a ShadowRoot, ignore all child elements - these will be picked 1136 // up by the <content> or <shadow> elements. Descend straight into the 1137 // ShadowRoot. 1138 var shadowRoot = /** @type {!HTMLElement} */element.shadowRoot; 1139 if (shadowRoot) { 1140 composedTreeWalk(shadowRoot, callback, shadowRoot); 1141 return; 1142 } 1143 1144 // If it is a <content> element, descend into distributed elements - these 1145 // are elements from outside the shadow root which are rendered inside the 1146 // shadow DOM. 1147 if (element.localName == 'content') { 1148 var content = /** @type {!HTMLContentElement} */element; 1149 // Verifies if ShadowDom v0 is supported. 1150 var distributedNodes = content.getDistributedNodes ? content.getDistributedNodes() : []; 1151 for (var i = 0; i < distributedNodes.length; i++) { 1152 composedTreeWalk(distributedNodes[i], callback, shadowRootAncestor); 1153 } 1154 return; 1155 } 1156 1157 // If it is a <slot> element, descend into assigned nodes - these 1158 // are elements from outside the shadow root which are rendered inside the 1159 // shadow DOM. 1160 if (element.localName == 'slot') { 1161 var slot = /** @type {!HTMLSlotElement} */element; 1162 // Verify if ShadowDom v1 is supported. 1163 var _distributedNodes = slot.assignedNodes ? slot.assignedNodes({flatten: true}) : []; 1164 for (var _i = 0; _i < _distributedNodes.length; _i++) { 1165 composedTreeWalk(_distributedNodes[_i], callback, shadowRootAncestor); 1166 } 1167 return; 1168 } 1169 } 1170 1171 // If it is neither the parent of a ShadowRoot, a <content> element, a <slot> 1172 // element, nor a <shadow> element recurse normally. 1173 var child = node.firstChild; 1174 while (child != null) { 1175 composedTreeWalk(child, callback, shadowRootAncestor); 1176 child = child.nextSibling; 1177 } 1178 } 1179 1180 /** 1181 * Adds a style element to the node containing the inert specific styles 1182 * @param {!Node} node 1183 */ 1184 function addInertStyle(node) { 1185 if (node.querySelector('style#inert-style, link#inert-style')) { 1186 return; 1187 } 1188 var style = document.createElement('style'); 1189 style.setAttribute('id', 'inert-style'); 1190 style.textContent = '\n' + '[inert] {\n' + ' pointer-events: none;\n' + ' cursor: default;\n' + '}\n' + '\n' + '[inert], [inert] * {\n' + ' -webkit-user-select: none;\n' + ' -moz-user-select: none;\n' + ' -ms-user-select: none;\n' + ' user-select: none;\n' + '}\n'; 1191 node.appendChild(style); 1192 } 1193 1194 if (!Element.prototype.hasOwnProperty('inert')) { 1195 /** @type {!InertManager} */ 1196 var inertManager = new InertManager(document); 1197 1198 Object.defineProperty(Element.prototype, 'inert', { 1199 enumerable: true, 1200 /** @this {!Element} */ 1201 get: function get() { 1202 return this.hasAttribute('inert'); 1203 }, 1204 /** @this {!Element} */ 1205 set: function set(inert) { 1206 inertManager.setInert(this, inert); 1207 } 1208 }); 1209 } 1210 })(); 1211 1212 1213 /***/ 1214 })
vendor: 9,589 bytes, lines 1214-1486
1214 1215 1216 /******/ 1217 }); 1218 /************************************************************************/ 1219 /******/ // The module cache 1220 /******/ 1221 var __webpack_module_cache__ = {}; 1222 /******/ 1223 /******/ // The require function 1224 /******/ 1225 function __webpack_require__(moduleId) { 1226 /******/ // Check if module is in cache 1227 /******/ 1228 var cachedModule = __webpack_module_cache__[moduleId]; 1229 /******/ 1230 if (cachedModule !== undefined) { 1231 /******/ 1232 return cachedModule.exports; 1233 /******/ 1234 } 1235 /******/ // Create a new module (and put it into the cache) 1236 /******/ 1237 var module = __webpack_module_cache__[moduleId] = { 1238 /******/ // no module.id needed 1239 /******/ // no module.loaded needed 1240 /******/ exports: {} 1241 /******/ 1242 }; 1243 /******/ 1244 /******/ // Execute the module function 1245 /******/ 1246 __webpack_modules__[moduleId](module, module.exports, __webpack_require__); 1247 /******/ 1248 /******/ // Return the exports of the module 1249 /******/ 1250 return module.exports; 1251 /******/ 1252 } 1253 1254 /******/ 1255 /******/ // expose the modules object (__webpack_modules__) 1256 /******/ 1257 __webpack_require__.m = __webpack_modules__; 1258 /******/ 1259 /************************************************************************/ 1260 /******/ /* webpack/runtime/chunk loaded */ 1261 /******/ 1262 (() => { 1263 /******/ 1264 var deferred = []; 1265 /******/ 1266 __webpack_require__.O = (result, chunkIds, fn, priority) => { 1267 /******/ 1268 if (chunkIds) { 1269 /******/ 1270 priority = priority || 0; 1271 /******/ 1272 for (var i = deferred.length; i > 0 && deferred[i - 1][2] > priority; i--) deferred[i] = deferred[i - 1]; 1273 /******/ 1274 deferred[i] = [chunkIds, fn, priority]; 1275 /******/ 1276 return; 1277 /******/ 1278 } 1279 /******/ 1280 var notFulfilled = Infinity; 1281 /******/ 1282 for (var i = 0; i < deferred.length; i++) { 1283 /******/ 1284 var [chunkIds, fn, priority] = deferred[i]; 1285 /******/ 1286 var fulfilled = true; 1287 /******/ 1288 for (var j = 0; j < chunkIds.length; j++) { 1289 /******/ 1290 if ((priority & 1 === 0 || notFulfilled >= priority) && Object.keys(__webpack_require__.O).every((key) => (__webpack_require__.O[key](chunkIds[j])))) { 1291 /******/ 1292 chunkIds.splice(j--, 1); 1293 /******/ 1294 } else { 1295 /******/ 1296 fulfilled = false; 1297 /******/ 1298 if (priority < notFulfilled) notFulfilled = priority; 1299 /******/ 1300 } 1301 /******/ 1302 } 1303 /******/ 1304 if (fulfilled) { 1305 /******/ 1306 deferred.splice(i--, 1) 1307 /******/ 1308 var r = fn(); 1309 /******/ 1310 if (r !== undefined) result = r; 1311 /******/ 1312 } 1313 /******/ 1314 } 1315 /******/ 1316 return result; 1317 /******/ 1318 }; 1319 /******/ 1320 })(); 1321 /******/ 1322 /******/ /* webpack/runtime/compat get default export */ 1323 /******/ 1324 (() => { 1325 /******/ // getDefaultExport function for compatibility with non-harmony modules 1326 /******/ 1327 __webpack_require__.n = (module) => { 1328 /******/ 1329 var getter = module && module.__esModule ? 1330 /******/ () => (module['default']) : 1331 /******/ () => (module); 1332 /******/ 1333 __webpack_require__.d(getter, {a: getter}); 1334 /******/ 1335 return getter; 1336 /******/ 1337 }; 1338 /******/ 1339 })(); 1340 /******/ 1341 /******/ /* webpack/runtime/define property getters */ 1342 /******/ 1343 (() => { 1344 /******/ // define getter functions for harmony exports 1345 /******/ 1346 __webpack_require__.d = (exports, definition) => { 1347 /******/ 1348 for (var key in definition) { 1349 /******/ 1350 if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) { 1351 /******/ 1352 Object.defineProperty(exports, key, {enumerable: true, get: definition[key]}); 1353 /******/ 1354 } 1355 /******/ 1356 } 1357 /******/ 1358 }; 1359 /******/ 1360 })(); 1361 /******/ 1362 /******/ /* webpack/runtime/hasOwnProperty shorthand */ 1363 /******/ 1364 (() => { 1365 /******/ 1366 __webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop)) 1367 /******/ 1368 })(); 1369 /******/ 1370 /******/ /* webpack/runtime/make namespace object */ 1371 /******/ 1372 (() => { 1373 /******/ // define __esModule on exports 1374 /******/ 1375 __webpack_require__.r = (exports) => { 1376 /******/ 1377 if (typeof Symbol !== 'undefined' && Symbol.toStringTag) { 1378 /******/ 1379 Object.defineProperty(exports, Symbol.toStringTag, {value: 'Module'}); 1380 /******/ 1381 } 1382 /******/ 1383 Object.defineProperty(exports, '__esModule', {value: true}); 1384 /******/ 1385 }; 1386 /******/ 1387 })(); 1388 /******/ 1389 /******/ /* webpack/runtime/jsonp chunk loading */ 1390 /******/ 1391 (() => { 1392 /******/ // no baseURI 1393 /******/ 1394 /******/ // object to store loaded and loading chunks 1395 /******/ // undefined = chunk not loaded, null = chunk preloaded/prefetched 1396 /******/ // [resolve, reject, Promise] = chunk loading, 0 = chunk loaded 1397 /******/ 1398 var installedChunks = { 1399 /******/ "/public/js/cookie-consent": 0, 1400 /******/ "public/css/cookie-consent": 0 1401 /******/ 1402 }; 1403 /******/ 1404 /******/ // no chunk on demand loading 1405 /******/ 1406 /******/ // no prefetching 1407 /******/ 1408 /******/ // no preloaded 1409 /******/ 1410 /******/ // no HMR 1411 /******/ 1412 /******/ // no HMR manifest 1413 /******/ 1414 /******/ 1415 __webpack_require__.O.j = (chunkId) => (installedChunks[chunkId] === 0); 1416 /******/ 1417 /******/ // install a JSONP callback for chunk loading 1418 /******/ 1419 var webpackJsonpCallback = (parentChunkLoadingFunction, data) => { 1420 /******/ 1421 var [chunkIds, moreModules, runtime] = data; 1422 /******/ // add "moreModules" to the modules object, 1423 /******/ // then flag all "chunkIds" as loaded and fire callback 1424 /******/ 1425 var moduleId, chunkId, i = 0; 1426 /******/ 1427 if (chunkIds.some((id) => (installedChunks[id] !== 0))) { 1428 /******/ 1429 for (moduleId in moreModules) { 1430 /******/ 1431 if (__webpack_require__.o(moreModules, moduleId)) { 1432 /******/ 1433 __webpack_require__.m[moduleId] = moreModules[moduleId]; 1434 /******/ 1435 } 1436 /******/ 1437 } 1438 /******/ 1439 if (runtime) var result = runtime(__webpack_require__); 1440 /******/ 1441 } 1442 /******/ 1443 if (parentChunkLoadingFunction) parentChunkLoadingFunction(data); 1444 /******/ 1445 for (; i < chunkIds.length; i++) { 1446 /******/ 1447 chunkId = chunkIds[i]; 1448 /******/ 1449 if (__webpack_require__.o(installedChunks, chunkId) && installedChunks[chunkId]) { 1450 /******/ 1451 installedChunks[chunkId][0](); 1452 /******/ 1453 } 1454 /******/ 1455 installedChunks[chunkId] = 0; 1456 /******/ 1457 } 1458 /******/ 1459 return __webpack_require__.O(result); 1460 /******/ 1461 } 1462 /******/ 1463 /******/ 1464 var chunkLoadingGlobal = self["webpackChunk"] = self["webpackChunk"] || []; 1465 /******/ 1466 chunkLoadingGlobal.forEach(webpackJsonpCallback.bind(null, 0)); 1467 /******/ 1468 chunkLoadingGlobal.push = webpackJsonpCallback.bind(null, chunkLoadingGlobal.push.bind(chunkLoadingGlobal)); 1469 /******/ 1470 })(); 1471 /******/ 1472 /************************************************************************/ 1473 /******/ 1474 /******/ // startup 1475 /******/ // Load entry module and return exports 1476 /******/ // This entry module depends on other loaded chunks and execution need to be delayed 1477 /******/ 1478 __webpack_require__.O(undefined, ["public/css/cookie-consent"], () => (__webpack_require__("./resources/js/cookie-consent.js"))) 1479 /******/ 1480 var __webpack_exports__ = __webpack_require__.O(undefined, ["public/css/cookie-consent"], () => (__webpack_require__("./resources/sass/cookie-consent.scss"))) 1481 /******/ 1482 __webpack_exports__ = __webpack_require__.O(__webpack_exports__); 1483 /******/ 1484 /******/ 1485})() 1486;
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.