https://app.getterms.io/build/js/index-CATTCrhM.js

1import "./preload-helper-0tpz3Uaa.js";
2import { c as commonjsGlobal, $ as $$1 } from "./jquery-owkqGIup.js";
3import { w as widgetPreviewUpdateEventHandler } from "./widgetPreviewUpdateEventHandler-DodjIeca.js";
4import { w as widgetScan } from "./widget-scan-CJOpgxH1.js";
5import { c as checkoutForm } from "./checkout-02xYAXw6.js";
6import { a6 as axios } from "./vendor-BACcT7ut.js";
7import { p as policyView } from "./policy-view-BE_dSg8E.js";
8(function(module, exports) {
9  (function(global, factory) {
10    factory();
11  })(commonjsGlobal, function() {
12    function applyFocusVisiblePolyfill(scope) {
13      var hadKeyboardEvent = true;
14      var hadFocusVisibleRecently = false;
15      var hadFocusVisibleRecentlyTimeout = null;
16      var inputTypesAllowlist = {
17        text: true,
18        search: true,
19        url: true,
20        tel: true,
21        email: true,
22        password: true,
23        number: true,
24        date: true,
25        month: true,
26        week: true,
27        time: true,
28        datetime: true,
29        "datetime-local": true
30      };
31      function isValidFocusTarget(el) {
32        if (el && el !== document && el.nodeName !== "HTML" && el.nodeName !== "BODY" && "classList" in el && "contains" in el.classList) {
33          return true;
34        }
35        return false;
36      }
37      function focusTriggersKeyboardModality(el) {
38        var type = el.type;
39        var tagName = el.tagName;
40        if (tagName === "INPUT" && inputTypesAllowlist[type] && !el.readOnly) {
41          return true;
42        }
43        if (tagName === "TEXTAREA" && !el.readOnly) {
44          return true;
45        }
46        if (el.isContentEditable) {
47          return true;
48        }
49        return false;
50      }
51      function addFocusVisibleClass(el) {
52        if (el.classList.contains("focus-visible")) {
53          return;
54        }
55        el.classList.add("focus-visible");
56        el.setAttribute("data-focus-visible-added", "");
57      }
58      function removeFocusVisibleClass(el) {
59        if (!el.hasAttribute("data-focus-visible-added")) {
60          return;
61        }
62        el.classList.remove("focus-visible");
63        el.removeAttribute("data-focus-visible-added");
64      }
65      function onKeyDown(e) {
66        if (e.metaKey || e.altKey || e.ctrlKey) {
67          return;
68        }
69        if (isValidFocusTarget(scope.activeElement)) {
70          addFocusVisibleClass(scope.activeElement);
71        }
72        hadKeyboardEvent = true;
73      }
74      function onPointerDown(e) {
75        hadKeyboardEvent = false;
76      }
77      function onFocus(e) {
78        if (!isValidFocusTarget(e.target)) {
79          return;
80        }
81        if (hadKeyboardEvent || focusTriggersKeyboardModality(e.target)) {
82          addFocusVisibleClass(e.target);
83        }
84      }
85      function onBlur(e) {
86        if (!isValidFocusTarget(e.target)) {
87          return;
88        }
89        if (e.target.classList.contains("focus-visible") || e.target.hasAttribute("data-focus-visible-added")) {
90          hadFocusVisibleRecently = true;
91          window.clearTimeout(hadFocusVisibleRecentlyTimeout);
92          hadFocusVisibleRecentlyTimeout = window.setTimeout(function() {
93            hadFocusVisibleRecently = false;
94          }, 100);
95          removeFocusVisibleClass(e.target);
96        }
97      }
98      function onVisibilityChange(e) {
99        if (document.visibilityState === "hidden") {
100          if (hadFocusVisibleRecently) {
101            hadKeyboardEvent = true;
102          }
103          addInitialPointerMoveListeners();
104        }
105      }
106      function addInitialPointerMoveListeners() {
107        document.addEventListener("mousemove", onInitialPointerMove);
108        document.addEventListener("mousedown", onInitialPointerMove);
109        document.addEventListener("mouseup", onInitialPointerMove);
110        document.addEventListener("pointermove", onInitialPointerMove);
111        document.addEventListener("pointerdown", onInitialPointerMove);
112        document.addEventListener("pointerup", onInitialPointerMove);
113        document.addEventListener("touchmove", onInitialPointerMove);
114        document.addEventListener("touchstart", onInitialPointerMove);
115        document.addEventListener("touchend", onInitialPointerMove);
116      }
117      function removeInitialPointerMoveListeners() {
118        document.removeEventListener("mousemove", onInitialPointerMove);
119        document.removeEventListener("mousedown", onInitialPointerMove);
120        document.removeEventListener("mouseup", onInitialPointerMove);
121        document.removeEventListener("pointermove", onInitialPointerMove);
122        document.removeEventListener("pointerdown", onInitialPointerMove);
123        document.removeEventListener("pointerup", onInitialPointerMove);
124        document.removeEventListener("touchmove", onInitialPointerMove);
125        document.removeEventListener("touchstart", onInitialPointerMove);
126        document.removeEventListener("touchend", onInitialPointerMove);
127      }
128      function onInitialPointerMove(e) {
129        if (e.target.nodeName && e.target.nodeName.toLowerCase() === "html") {
130          return;
131        }
132        hadKeyboardEvent = false;

133        removeInitialPointerMoveListeners();
134      }
135      document.addEventListener("keydown", onKeyDown, true);
136      document.addEventListener("mousedown", onPointerDown, true);
137      document.addEventListener("pointerdown", onPointerDown, true);
138      document.addEventListener("touchstart", onPointerDown, true);
139      document.addEventListener("visibilitychange", onVisibilityChange, true);
140      addInitialPointerMoveListeners();
141      scope.addEventListener("focus", onFocus, true);
142      scope.addEventListener("blur", onBlur, true);
143      if (scope.nodeType === Node.DOCUMENT_FRAGMENT_NODE && scope.host) {
144        scope.host.setAttribute("data-js-focus-visible", "");
145      } else if (scope.nodeType === Node.DOCUMENT_NODE) {
146        document.documentElement.classList.add("js-focus-visible");
147        document.documentElement.setAttribute("data-js-focus-visible", "");
148      }
149    }
150    if (typeof window !== "undefined" && typeof document !== "undefined") {
151      window.applyFocusVisiblePolyfill = applyFocusVisiblePolyfill;
152      var event;
153      try {
154        event = new CustomEvent("focus-visible-polyfill-ready");
155      } catch (error) {
156        event = document.createEvent("CustomEvent");
157        event.initCustomEvent("focus-visible-polyfill-ready", false, false, {});
158      }
159      window.dispatchEvent(event);
160    }
161    if (typeof document !== "undefined") {
162      applyFocusVisiblePolyfill(document);
163    }
164  });
165})();
166var lazysizes = { exports: {} };
167(function(module) {
168  (function(window2, factory) {
169    var lazySizes = factory(window2, window2.document, Date);
170    window2.lazySizes = lazySizes;
171    if (module.exports) {
172      module.exports = lazySizes;
173    }
174  })(
175    typeof window != "undefined" ? window : {},
176    /**
177     * import("./types/global")
178     * @typedef { import("./types/lazysizes-config").LazySizesConfigPartial } LazySizesConfigPartial
179     */
180    function l(window2, document2, Date2) {
181      var lazysizes2, lazySizesCfg;
182      (function() {
183        var prop;
184        var lazySizesDefaults = {
185          lazyClass: "lazyload",
186          loadedClass: "lazyloaded",
187          loadingClass: "lazyloading",
188          preloadClass: "lazypreload",
189          errorClass: "lazyerror",
190          //strictClass: 'lazystrict',
191          autosizesClass: "lazyautosizes",
192          fastLoadedClass: "ls-is-cached",
193          iframeLoadMode: 0,
194          srcAttr: "data-src",
195          srcsetAttr: "data-srcset",
196          sizesAttr: "data-sizes",
197          //preloadAfterLoad: false,
198          minSize: 40,
199          customMedia: {},
200          init: true,
201          expFactor: 1.5,
202          hFac: 0.8,
203          loadMode: 2,
204          loadHidden: true,
205          ricTimeout: 0,
206          throttleDelay: 125
207        };
208        lazySizesCfg = window2.lazySizesConfig || window2.lazysizesConfig || {};
209        for (prop in lazySizesDefaults) {
210          if (!(prop in lazySizesCfg)) {
211            lazySizesCfg[prop] = lazySizesDefaults[prop];
212          }
213        }
214      })();
215      if (!document2 || !document2.getElementsByClassName) {
216        return {
217          init: function() {
218          },
219          /**
220           * @type { LazySizesConfigPartial }
221           */
222          cfg: lazySizesCfg,
223          /**
224           * @type { true }
225           */
226          noSupport: true
227        };
228      }
229      var docElem = document2.documentElement;
230      var supportPicture = window2.HTMLPictureElement;
231      var _addEventListener = "addEventListener";
232      var _getAttribute = "getAttribute";
233      var addEventListener = window2[_addEventListener].bind(window2);
234      var setTimeout2 = window2.setTimeout;
235      var requestAnimationFrame = window2.requestAnimationFrame || setTimeout2;
236      var requestIdleCallback = window2.requestIdleCallback;
237      var regPicture = /^picture$/i;
238      var loadEvents = ["load", "error", "lazyincluded", "_lazyloaded"];
239      var regClassCache = {};
240      var forEach = Array.prototype.forEach;
241      var hasClass = function(ele, cls) {
242        if (!regClassCache[cls]) {
243          regClassCache[cls] = new RegExp("(\\s|^)" + cls + "(\\s|$)");
244        }
245        return regClassCache[cls].test(ele[_getAttribute]("class") || "") && regClassCache[cls];
246      };
247      var addClass = function(ele, cls) {
248        if (!hasClass(ele, cls)) {
249          ele.setAttribute("class", (ele[_getAttribute]("class") || "").trim() + " " + cls);
250        }
251      };
252      var removeClass = function(ele, cls) {
253        var reg;
254        if (reg = hasClass(ele, cls)) {
255          ele.setAttribute("class", (ele[_getAttribute]("class") || "").replace(reg, " "));
256        }
257      };
258      var addRemoveLoadEvents = function(dom, fn, add) {
259        var action = add ? _addEventListener : "removeEventListener";
260        if (add) {
261          addRemoveLoadEvents(dom, fn);
262        }

263        loadEvents.forEach(function(evt) {
264          dom[action](evt, fn);
265        });
266      };
267      var triggerEvent = function(elem, name, detail, noBubbles, noCancelable) {
268        var event = document2.createEvent("Event");
269        if (!detail) {
270          detail = {};
271        }
272        detail.instance = lazysizes2;
273        event.initEvent(name, !noBubbles, !noCancelable);
274        event.detail = detail;
275        elem.dispatchEvent(event);
276        return event;
277      };
278      var updatePolyfill = function(el, full) {
279        var polyfill;
280        if (!supportPicture && (polyfill = window2.picturefill || lazySizesCfg.pf)) {
281          if (full && full.src && !el[_getAttribute]("srcset")) {
282            el.setAttribute("srcset", full.src);
283          }
284          polyfill({ reevaluate: true, elements: [el] });
285        } else if (full && full.src) {
286          el.src = full.src;
287        }
288      };
289      var getCSS = function(elem, style) {
290        return (getComputedStyle(elem, null) || {})[style];
291      };
292      var getWidth = function(elem, parent, width) {
293        width = width || elem.offsetWidth;
294        while (width < lazySizesCfg.minSize && parent && !elem._lazysizesWidth) {
295          width = parent.offsetWidth;
296          parent = parent.parentNode;
297        }
298        return width;
299      };
300      var rAF = function() {
301        var running, waiting;
302        var firstFns = [];
303        var secondFns = [];
304        var fns = firstFns;
305        var run = function() {
306          var runFns = fns;
307          fns = firstFns.length ? secondFns : firstFns;
308          running = true;
309          waiting = false;
310          while (runFns.length) {
311            runFns.shift()();
312          }
313          running = false;
314        };
315        var rafBatch = function(fn, queue) {
316          if (running && !queue) {
317            fn.apply(this, arguments);
318          } else {
319            fns.push(fn);
320            if (!waiting) {
321              waiting = true;
322              (document2.hidden ? setTimeout2 : requestAnimationFrame)(run);
323            }
324          }
325        };
326        rafBatch._lsFlush = run;
327        return rafBatch;
328      }();
329      var rAFIt = function(fn, simple) {
330        return simple ? function() {
331          rAF(fn);
332        } : function() {
333          var that = this;
334          var args = arguments;
335          rAF(function() {
336            fn.apply(that, args);
337          });
338        };
339      };
340      var throttle = function(fn) {
341        var running;
342        var lastTime = 0;
343        var gDelay = lazySizesCfg.throttleDelay;
344        var rICTimeout = lazySizesCfg.ricTimeout;
345        var run = function() {
346          running = false;
347          lastTime = Date2.now();
348          fn();
349        };
350        var idleCallback = requestIdleCallback && rICTimeout > 49 ? function() {
351          requestIdleCallback(run, { timeout: rICTimeout });
352          if (rICTimeout !== lazySizesCfg.ricTimeout) {
353            rICTimeout = lazySizesCfg.ricTimeout;
354          }
355        } : rAFIt(function() {
356          setTimeout2(run);
357        }, true);
358        return function(isPriority) {
359          var delay;
360          if (isPriority = isPriority === true) {
361            rICTimeout = 33;
362          }
363          if (running) {
364            return;
365          }
366          running = true;
367          delay = gDelay - (Date2.now() - lastTime);
368          if (delay < 0) {
369            delay = 0;
370          }
371          if (isPriority || delay < 9) {
372            idleCallback();
373          } else {
374            setTimeout2(idleCallback, delay);
375          }
376        };
377      };
378      var debounce2 = function(func) {
379        var timeout, timestamp;
380        var wait = 99;
381        var run = function() {
382          timeout = null;
383          func();
384        };
385        var later = function() {
386          var last = Date2.now() - timestamp;
387          if (last < wait) {
388            setTimeout2(later, wait - last);
389          } else {
390            (requestIdleCallback || run)(run);
391          }
392        };
393        return function() {
394          timestamp = Date2.now();
395          if (!timeout) {
396            timeout = setTimeout2(later, wait);
397          }
398        };
399      };
400      var loader = function() {
401        var preloadElems, isCompleted, resetPreloadingTimer, loadMode, started;
402        var eLvW, elvH, eLtop, eLleft, eLright, eLbottom, isBodyHidden;
403        var regImg = /^img$/i;
404        var regIframe = /^iframe$/i;
405        var supportScroll = "onscroll" in window2 && !/(gle|ing)bot/.test(navigator.userAgent);
406        var shrinkExpand = 0;
407        var currentExpand = 0;
408        var isLoading = 0;
409        var lowRuns = -1;
410        var resetPreloading = function(e) {
411          isLoading--;
412          if (!e || isLoading < 0 || !e.target) {
413            isLoading = 0;
414          }
415        };
416        var isVisible = function(elem) {
417          if (isBodyHidden == null) {
418            isBodyHidden = getCSS(document2.body, "visibility") == "hidden";
419          }
420          return isBodyHidden || !(getCSS(elem.parentNode, "visibility") == "hidden" && getCSS(elem, "visibility") == "hidden");
421        };
422        var isNestedVisible = function(elem, elemExpand) {
423          var outerRect;
424          var parent = elem;
425          var visible = isVisible(elem);
426          eLtop -= elemExpand;
427          eLbottom += elemExpand;
428          eLleft -= elemExpand;
429          eLright += elemExpand;
430          while (visible && (parent = parent.offsetParent) && parent != document2.body && parent != docElem) {
431            visible = (getCSS(parent, "opacity") || 1) > 0;
432            if (visible && getCSS(parent, "overflow") != "visible") {
433              outerRect = parent.getBoundingClientRect();
434              visible = eLright > outerRect.left && eLleft < outerRect.right && eLbottom > outerRect.top - 1 && eLtop < outerRect.bottom + 1;
435            }
436          }
437          return visible;
438        };
439        var checkElements = function() {
440          var eLlen, i, rect, autoLoadElem, loadedSomething, elemExpand, elemNegativeExpand, elemExpandVal, beforeE

440xpandVal, defaultExpand, preloadExpand, hFac;
441          var lazyloadElems = lazysizes2.elements;
442          if ((loadMode = lazySizesCfg.loadMode) && isLoading < 8 && (eLlen = lazyloadElems.length)) {
443            i = 0;
444            lowRuns++;
445            for (; i < eLlen; i++) {
446              if (!lazyloadElems[i] || lazyloadElems[i]._lazyRace) {
447                continue;
448              }
449              if (!supportScroll || lazysizes2.prematureUnveil && lazysizes2.prematureUnveil(lazyloadElems[i])) {
450                unveilElement(lazyloadElems[i]);
451                continue;
452              }
453              if (!(elemExpandVal = lazyloadElems[i][_getAttribute]("data-expand")) || !(elemExpand = elemExpandVal * 1)) {
454                elemExpand = currentExpand;
455              }
456              if (!defaultExpand) {
457                defaultExpand = !lazySizesCfg.expand || lazySizesCfg.expand < 1 ? docElem.clientHeight > 500 && docElem.clientWidth > 500 ? 500 : 370 : lazySizesCfg.expand;
458                lazysizes2._defEx = defaultExpand;
459                preloadExpand = defaultExpand * lazySizesCfg.expFactor;
460                hFac = lazySizesCfg.hFac;
461                isBodyHidden = null;
462                if (currentExpand < preloadExpand && isLoading < 1 && lowRuns > 2 && loadMode > 2 && !document2.hidden) {
463                  currentExpand = preloadExpand;
464                  lowRuns = 0;
465                } else if (loadMode > 1 && lowRuns > 1 && isLoading < 6) {
466                  currentExpand = defaultExpand;
467                } else {
468                  currentExpand = shrinkExpand;
469                }
470              }
471              if (beforeExpandVal !== elemExpand) {
472                eLvW = innerWidth + elemExpand * hFac;
473                elvH = innerHeight + elemExpand;
474                elemNegativeExpand = elemExpand * -1;
475                beforeExpandVal = elemExpand;
476              }
477              rect = lazyloadElems[i].getBoundingClientRect();
478              if ((eLbottom = rect.bottom) >= elemNegativeExpand && (eLtop = rect.top) <= elvH && (eLright = rect.right) >= elemNegativeExpand * hFac && (eLleft = rect.left) <= eLvW && (eLbottom || eLright || eLleft || eLtop) && (lazySizesCfg.loadHidden || isVisible(lazyloadElems[i])) && (isCompleted && isLoading < 3 && !elemExpandVal && (loadMode < 3 || lowRuns < 4) || isNestedVisible(lazyloadElems[i], elemExpand))) {
479                unveilElement(lazyloadElems[i]);
480                loadedSomething = true;
481                if (isLoading > 9) {
482                  break;
483                }
484              } else if (!loadedSomething && isCompleted && !autoLoadElem && isLoading < 4 && lowRuns < 4 && loadMode > 2 && (preloadElems[0] || lazySizesCfg.preloadAfterLoad) && (preloadElems[0] || !elemExpandVal && (eLbottom || eLright || eLleft || eLtop || lazyloadElems[i][_getAttribute](lazySizesCfg.sizesAttr) != "auto"))) {
485                autoLoadElem = preloadElems[0] || lazyloadElems[i];
486              }
487            }
488            if (autoLoadElem && !loadedSomething) {
489              unveilElement(autoLoadElem);
490            }
491          }
492        };
493        var throttledCheckElements = throttle(checkElements);
494        var switchLoadingClass = function(e) {
495          var elem = e.target;
496          if (elem._lazyCache) {
497            delete elem._lazyCache;
498            return;
499          }
500          resetPreloading(e);
501          addClass(elem, lazySizesCfg.loadedClass);
502          removeClass(elem, lazySizesCfg.loadingClass);
503          addRemoveLoadEvents(elem, rafSwitchLoadingClass);
504          triggerEvent(elem, "lazyloaded");
505        };
506        var rafedSwitchLoadingClass = rAFIt(switchLoadingClass);
507        var rafSwitchLoadingClass = function(e) {
508          rafedSwitchLoadingClass({ target: e.target });
509        };
510        var changeIframeSrc = function(elem, src) {
511          var loadMode2 = elem.getAttribute("data-load-mode") || lazySizesCfg.iframeLoadMode;
512          if (loadMode2 == 0) {
513            elem.contentWindow.location.replace(src);
514          } else if (loadMode2 == 1) {
515            elem.src = src;
516          }
517        };
518        var handleSources = function(source) {
519          var customMedia;
520          var sourceSrcset = source[_getAttribute](lazySizesCfg.srcsetAttr);
521          if (customMedia = lazySizesCfg.customMedia[source[_getAttribute]("data-media") || source[_getAttribute]("media")]) {
522            source.setAttribute("media", customMedia);
523          }
524          if (sourceSrcset) {
525            source.setAttribute("srcset", sourceSrcset);
526          }
527        };
528        var lazyUnveil = rAFIt(function(elem, detail, isAuto, sizes, isImg) {
529          var src, srcset, parent, isPicture, event, firesLoad;
530          if (!(event = triggerEvent(elem, "lazybeforeunveil", detail)).defaultPrevented) {
531            if (sizes) {
532              if (isAuto) {
533                addClass(elem, lazySizesCfg.autosizesClass);
534              } else {
535                elem.setAttribute("sizes", sizes);
536              }
537            }
538            srcset = elem[_getAttribute](lazySizesCfg.srcsetAttr);
539            src = elem[_getAttribute](lazySizesCfg.srcAttr);
540            if (isImg) {
541              parent = elem.parentNode;
542              isPicture = parent && regPicture.test(parent.nodeName || "");
543            }
544            firesLoad = detail.firesLoad || "src" in elem && (srcset || src || isPicture);
545            event = { target: elem };
546            addClass(elem, lazySizesCfg.loadingClass);
547            if (firesLoad) {
548              clearTimeout(resetPreloadingTimer);
549              resetPreloadingTimer = setTimeout2(resetPreloading, 2500);
550              addRemoveLoadEvents(elem, rafSwitchLoadingClass, true);
551            }
552            if (isPicture) {

553              forEach.call(parent.getElementsByTagName("source"), handleSources);
554            }
555            if (srcset) {
556              elem.setAttribute("srcset", srcset);
557            } else if (src && !isPicture) {
558              if (regIframe.test(elem.nodeName)) {
559                changeIframeSrc(elem, src);
560              } else {
561                elem.src = src;
562              }
563            }
564            if (isImg && (srcset || isPicture)) {
565              updatePolyfill(elem, { src });
566            }
567          }
568          if (elem._lazyRace) {
569            delete elem._lazyRace;
570          }
571          removeClass(elem, lazySizesCfg.lazyClass);
572          rAF(function() {
573            var isLoaded = elem.complete && elem.naturalWidth > 1;
574            if (!firesLoad || isLoaded) {
575              if (isLoaded) {
576                addClass(elem, lazySizesCfg.fastLoadedClass);
577              }
578              switchLoadingClass(event);
579              elem._lazyCache = true;
580              setTimeout2(function() {
581                if ("_lazyCache" in elem) {
582                  delete elem._lazyCache;
583                }
584              }, 9);
585            }
586            if (elem.loading == "lazy") {
587              isLoading--;
588            }
589          }, true);
590        });
591        var unveilElement = function(elem) {
592          if (elem._lazyRace) {
593            return;
594          }
595          var detail;
596          var isImg = regImg.test(elem.nodeName);
597          var sizes = isImg && (elem[_getAttribute](lazySizesCfg.sizesAttr) || elem[_getAttribute]("sizes"));
598          var isAuto = sizes == "auto";
599          if ((isAuto || !isCompleted) && isImg && (elem[_getAttribute]("src") || elem.srcset) && !elem.complete && !hasClass(elem, lazySizesCfg.errorClass) && hasClass(elem, lazySizesCfg.lazyClass)) {
600            return;
601          }
602          detail = triggerEvent(elem, "lazyunveilread").detail;
603          if (isAuto) {
604            autoSizer.updateElem(elem, true, elem.offsetWidth);
605          }
606          elem._lazyRace = true;
607          isLoading++;
608          lazyUnveil(elem, detail, isAuto, sizes, isImg);
609        };
610        var afterScroll = debounce2(function() {
611          lazySizesCfg.loadMode = 3;
612          throttledCheckElements();
613        });
614        var altLoadmodeScrollListner = function() {
615          if (lazySizesCfg.loadMode == 3) {
616            lazySizesCfg.loadMode = 2;
617          }
618          afterScroll();
619        };
620        var onload = function() {
621          if (isCompleted) {
622            return;
623          }
624          if (Date2.now() - started < 999) {
625            setTimeout2(onload, 999);
626            return;
627          }
628          isCompleted = true;
629          lazySizesCfg.loadMode = 3;
630          throttledCheckElements();
631          addEventListener("scroll", altLoadmodeScrollListner, true);
632        };
633        return {
634          _: function() {
635            started = Date2.now();
636            lazysizes2.elements = document2.getElementsByClassName(lazySizesCfg.lazyClass);
637            preloadElems = document2.getElementsByClassName(lazySizesCfg.lazyClass + " " + lazySizesCfg.preloadClass);
638            addEventListener("scroll", throttledCheckElements, true);
639            addEventListener("resize", throttledCheckElements, true);
640            addEventListener("pageshow", function(e) {
641              if (e.persisted) {
642                var loadingElements = document2.querySelectorAll("." + lazySizesCfg.loadingClass);
643                if (loadingElements.length && loadingElements.forEach) {
644                  requestAnimationFrame(function() {
645                    loadingElements.forEach(function(img) {
646                      if (img.complete) {
647                        unveilElement(img);
648                      }
649                    });
650                  });
651                }
652              }
653            });
654            if (window2.MutationObserver) {
655              new MutationObserver(throttledCheckElements).observe(docElem, { childList: true, subtree: true, attributes: true });
656            } else {
657              docElem[_addEventListener]("DOMNodeInserted", throttledCheckElements, true);
658              docElem[_addEventListener]("DOMAttrModified", throttledCheckElements, true);
659              setInterval(throttledCheckElements, 999);
660            }
661            addEventListener("hashchange", throttledCheckElements, true);
662            ["focus", "mouseover", "click", "load", "transitionend", "animationend"].forEach(function(name) {
663              document2[_addEventListener](name, throttledCheckElements, true);
664            });
665            if (/d$|^c/.test(document2.readyState)) {
666              onload();
667            } else {
668              addEventListener("load", onload);
669              document2[_addEventListener]("DOMContentLoaded", throttledCheckElements);
670              setTimeout2(onload, 2e4);
671            }
672            if (lazysizes2.elements.length) {
673              checkElements();
674              rAF._lsFlush();
675            } else {
676              throttledCheckElements();
677            }
678          },
679          checkElems: throttledCheckElements,
680          unveil: unveilElement,
681          _aLSL: altLoadmodeScrollListner
682        };
683      }();
684      var autoSizer = function() {
685        var autosizesElems;
686        var sizeElement = rAFIt(function(elem, parent, event, width) {
687          var sources, i, len;
688          elem._lazysizesWidth = width;
689          width += "px";
690          elem.setAttribute("sizes", width);
691          if (regPicture.test(parent.nodeName || "")) {
692            sources = parent.getElementsByTagName("source");
693            for (i = 0, len = sources.length; i < len; i++) {
694              sources[i].setAttribute("sizes", width);
695            }
696          }
697          if (!event.detail.dataAttr) {
698            updatePolyfill(elem, event.detail);
699          }
700        });
701        var getSizeElement = function(elem, dataAttr, width) {
702          var event;
703          var parent = elem.parentNode;
704          if (parent) {
705            width = getWidth(elem, parent, width);
706            event = triggerEvent(elem, "lazybeforesizes", { width, dataAttr: !!dataAttr });
707            if (!event.defaultPrevented) {
708              width = event.detail.width;
709              if (width && width !== elem._lazysizesWidth) {
710                sizeElement(elem, parent, event, width);
711              }
712            }
713          }
714        };
715        var updateElementsSizes = function() {
716          var i;
717          var len = autosizesElems.length;
718          if (len) {
719            i = 0;
720            for (; i < len; i++) {
721              getSizeElement(autosizesElems[i]);
722            }
723          }
724        };
725        var debouncedUpdateElementsSizes = debounce2(updateElementsSizes);
726        return {
727          _: function() {
728            autosizesElems = document2.getElementsByClassName(lazySizesCfg.autosizesClass);
729            addEventListener("resize", debouncedUpdateElementsSizes);
730          },
731          checkElems: debouncedUpdateElementsSizes,
732          updateElem: getSizeElement
733        };
734      }();
735      var init = function() {
736        if (!init.i && document2.getElementsByClassName) {
737          init.i = true;
738          autoSizer._();
739          loader._();
740        }
741      };
742      setTimeout2(function() {
743        if (lazySizesCfg.init) {
744          init();
745        }
746      });
747      lazysizes2 = {
748        /**
749         * @type { LazySizesConfigPartial }
750         */
751        cfg: lazySizesCfg,
752        autoSizer,
753        loader,
754        init,
755        uP: updatePolyfill,
756        aC: addClass,
757        rC: removeClass,
758        hC: hasClass,
759        fire: triggerEvent,
760        gW: getWidth,
761        rAF
762      };
763      return lazysizes2;
764    }
765  );
766})(lazysizes);
767function smoothScroll() {
768  $$1('a[href*="#"]').not('[href="#"]').not('[href="#0"]').click(function(event) {
769    var scrollElem = "html, body";
770    var innerScroll = false;

771    var focusShift = true;
772    var self = $$1(this);
773    if (self.attr("data-scroll-element")) {
774      innerScroll = true;
775      scrollElem = self.attr("data-scroll-element");
776    }
777    if (self.attr("data-focus-shift") == "false") {
778      focusShift = false;
779    }
780    if (location.pathname.replace(/^\//, "") == this.pathname.replace(/^\//, "") && location.hostname == this.hostname) {
781      var target = $$1(this.hash);
782      target = target.length ? target : $$1("[name=" + this.hash.slice(1) + "]");
783      if (target.length) {
784        event.preventDefault();
785        var offset = target.offset().top;
786        if (innerScroll) {
787          offset = target.position().top;
788        }
789        var $scroll_animation_duration = window.matchMedia(
790          "(prefers-reduced-motion: reduce)"
791        ).matches ? 0 : 1e3;
792        $$1(scrollElem).animate(
793          {
794            scrollTop: offset - $$1(".header-main").outerHeight()
795          },
796          $scroll_animation_duration,
797          function() {
798            if (focusShift) {
799              var $target = $$1(target);
800              $target.focus();
801              if ($target.is(":focus")) {
802                return false;
803              } else {
804                $target.attr("tabindex", "-1");
805                var x = window.scrollX, y = window.scrollY;
806                $target.focus();
807                window.scrollTo(x, y);
808                return $target;
809              }
810            }
811          }
812        );
813      }
814    }
815  });
816}
817class Accordion {
818  constructor(node) {
819    if (!node) return;
820    this.node = node;
821    this.trigger = this.node.querySelector("[data-accordion-trigger]");
822    this.panel = this.node.querySelector("[data-accordion-panel]");
823    this.group = this.trigger.getAttribute("data-accordion-group");
824    this.breakpoint = this.node.getAttribute("data-breakpoint");
825    this.boundToggle = this.toggle.bind(this);
826    this.init();
827  }
828  init() {
829    this.trigger.addEventListener("click", this.boundToggle);
830  }
831  toggle() {
832    const isExpanded = this.trigger.getAttribute("aria-expanded") === "true";
833    this.expandPanel(this.trigger, !isExpanded ? true : false);
834    if (this.group && !isExpanded) {
835      const accordionsInGroup = document.querySelectorAll(
836        `[aria-expanded="true"][data-accordion-group="${this.group}"]:not([aria-controls="${this.trigger.getAttribute(
837          "aria-controls"
838        )}"])`
839      );
840      accordionsInGroup.forEach((accordion) => {
841        this.expandPanel(accordion, false);
842      });
843    }
844  }
845  expandPanel(trigger, isExpanded) {
846    const panel = document.getElementById(
847      trigger.getAttribute("aria-controls")
848    );
849    trigger.setAttribute("aria-expanded", isExpanded ? "true" : "false");
850    this.node.classList.toggle("open", isExpanded);
851    if (panel) {
852      panel.setAttribute("data-expanded", isExpanded ? "true" : "false");
853    }
854  }
855}
856function accordionCookies() {
857  const theAccordionCookies = Array.prototype.slice.call(
858    document.querySelectorAll(".accordion-cookies")
859  );
860  if (theAccordionCookies.length) {
861    theAccordionCookies.forEach((accordionCookies2) => {
862      const head = accordionCookies2.querySelector(
863        ".accordion-cookies__head"
864      );
865      const panel = accordionCookies2.querySelector(
866        ".accordion-cookies__panel"
867      );
868      const pinner = accordionCookies2.querySelector(
869        ".accordion-cookies__panel__inner"
870      );
871      const accordionCookiesIsActive = () => accordionCookies2.classList.contains("is-active");
872      pinner.setAttribute("hidden", "hidden");
873      panel.addEventListener("transitionend", () => panel.style = "");
874      const openPanel = () => {
875        panel.style.maxHeight = "0px";
876        panel.style.overflow = "hidden";
877        void panel.offsetHeight;
878        panel.style.transition = "max-height 0.5s cubic-bezier(0.2, 0, 0, 1)";
879        panel.style.maxHeight = panel.scrollHeight + "px";
880        accordionCookies2.classList.add("is-active");
881        head.setAttribute("aria-expanded", true);
882      };
883      const closePanel = () => {
884        panel.style.maxHeight = panel.scrollHeight + "px";
885        panel.style.transition = "max-height 0.5s cubic-bezier(0.2, 0, 0, 1)";
886        panel.style.overflow = "hidden";
887        void panel.offsetHeight;
888        panel.style.maxHeight = "0px";
889        accordionCookies2.classList.remove("is-active");
890        head.setAttribute("aria-expanded", false);
891      };
892      head.addEventListener("click", () => {
893        if (!accordionCookiesIsActive()) {
894          pinner.removeAttribute("hidden");

895          openPanel();
896        } else {
897          closePanel();
898          setTimeout(function() {
899            pinner.setAttribute("hidden", "hidden");
900          }, 500);
901        }
902      });
903    });
904  }
905}
906function inactiveCookiesForm() {
907  $$1(function() {
908    $$1(".reactivate-inactive-cookie-btn").each(function() {
909      var btn = $$1(this);
910      btn.click(function() {
911        $$1.ajax({
912          type: "POST",
913          url: btn.data("href"),
914          data: {},
915          dataType: "json",
916          headers: {
917            "X-CSRF-TOKEN": btn.data("csrf")
918          }
919        }).done(function(response) {
920          if (response.success) {
921            btn.closest("tr").remove();
922          }
923          window.location.reload();
924        });
925        return false;
926      });
927    });
928    $$1(".delete-inactive-cookie-btn").each(function() {
929      var btn = $$1(this);
930      btn.click(function() {
931        if (confirm(
932          "This will remove the cookie from your database. It will be re-added if detected in a future scan."
933        )) {
934          $$1.ajax({
935            type: "POST",
936            url: btn.data("href"),
937            data: {},
938            dataType: "json",
939            headers: {
940              "X-CSRF-TOKEN": btn.data("csrf")
941            }
942          }).done(function(response) {
943            var accordion = btn.closest(".accordion-cookies");
944            var accordion_title = accordion.find("span.accordion-title").text(title);
945            if (response.success) {
946              btn.closest("tr").remove();
947            }
948            var count = accordion.find("tbody tr").length;
949            var title = "Inactive Cookies (" + count + ")";
950            accordion_title.text(title);
951            if (count == 0) {
952              accordion.hide();
953            }
954          });
955        }
956        return false;
957      });
958    });
959  });
960}
961function inactiveStorageItemsForm() {
962  $$1(function() {
963    $$1(".reactivate-inactive-storage-item-btn").each(function() {
964      var btn = $$1(this);
965      btn.click(function() {
966        $$1.ajax({
967          type: "POST",
968          url: btn.data("href"),
969          data: {},
970          dataType: "json",
971          headers: {
972            "X-CSRF-TOKEN": btn.data("csrf")
973          }
974        }).done(function(response) {
975          if (response.success) {
976            btn.closest("tr").remove();
977          }
978          window.location.reload();
979        });
980        return false;
981      });
982    });
983    $$1(".delete-inactive-storage-item-btn").each(function() {
984      var btn = $$1(this);
985      btn.click(function() {
986        if (confirm(
987          "This will remove the storage item from your database. It will be re-added if detected in a future scan."
988        )) {
989          $$1.ajax({
990            type: "POST",
991            url: btn.data("href"),
992            data: {},
993            dataType: "json",
994            headers: {
995              "X-CSRF-TOKEN": btn.data("csrf")
996            }
997          }).done(function(response) {
998            if (response.success) {
999              btn.closest("tr").remove();
1000            }
1001          });
1002        }
1003        return false;
1004      });
1005    });
1006  });
1007}
1008class Dropdown {
1009  constructor(selector, config = {
1010    arguments: {},
1011    events: {}
1012  }) {
1013    this.selector = selector;
1014    this.config = config;
1015    this.elements = document.querySelectorAll(this.selector);
1016    this.arguments = this.config.arguments;
1017    this.toggleSelector = this.config.toggleSelector;
1018    if (this.elements.length === 0) {
1019      return;
1020    }
1021    this.mount();
1022  }
1023  mount() {
1024    if (this.config.events) {
1025      Object.keys(this.config.events).forEach((eventName) => {
1026        let eventCallback = this.config.events[eventName];
1027        this.elements.forEach(
1028          (el) => el.addEventListener(eventName, eventCallback, {
1029            passive: true,
1030            once: false
1031          })
1032        );
1033      });
1034    }
1035    this.init();
1036  }
1037  init() {
1038    this.elements.forEach((el) => {
1039      const toggle = el.querySelector(this.toggleSelector);
1040      if (!toggle) return;
1041      toggle.addEventListener("click", () => {
1042        this.expandPanel(
1043          toggle,
1044          toggle.getAttribute("aria-expanded") == "false" ? true : false
1045        );
1046        document.onkeyup = (e) => {
1047          e = e || window.event;
1048          let isEscape = false;

1049          if ("key" in e) {
1050            isEscape = e.key === "Escape" || e.key === "Esc";
1051          } else {
1052            isEscape = e.keyCode === 27;
1053          }
1054          if (isEscape) {
1055            if (toggle.getAttribute("aria-expanded") === "true") {
1056              this.expandPanel(toggle, false);
1057              toggle.focus();
1058            }
1059          }
1060        };
1061        const clickOutsideHandler = (event) => {
1062          const isClickInside = el.contains(event.target);
1063          if (!isClickInside) {
1064            this.expandPanel(toggle, false);
1065            document.removeEventListener(
1066              "click",
1067              clickOutsideHandler
1068            );
1069          }
1070        };
1071        document.addEventListener("click", clickOutsideHandler);
1072      });
1073    });
1074  }
1075  expandPanel(toggle, isExpanded) {
1076    const target = document.getElementById(
1077      toggle.getAttribute("aria-controls")
1078    );
1079    toggle.setAttribute("aria-expanded", isExpanded ? "true" : "false");
1080    if (target) {
1081      target.setAttribute("data-expanded", isExpanded ? "true" : "false");
1082    }
1083    if (!target) {
1084      return;
1085    }
1086    const links = [
1087      ...target.querySelectorAll("a"),
1088      ...target.querySelectorAll("button")
1089    ];
1090    if (links) {
1091      links.forEach((link) => {
1092        const handleLinkClick = () => {
1093          this.expandPanel(toggle, false);
1094          toggle.focus();
1095          link.removeEventListener("click", handleLinkClick);
1096        };
1097        link.addEventListener("click", handleLinkClick);
1098      });
1099    }
1100  }
1101}
1102class DropdownToggle {
1103  constructor(node) {
1104    if (!node) return;
1105    this.node = node;
1106    this.current = this.node.querySelector("[data-dropdown-current]");
1107    this.selects = this.node.querySelectorAll("[data-dropdown-select]");
1108    this.input = this.node.querySelector("[data-dropdown-value]");
1109    this.defaultValue = this.input ? this.input.value : null;
1110    this.init();
1111  }
1112  init() {
1113    this.selects.forEach((select) => {
1114      select.addEventListener("click", () => {
1115        this.select(select);
1116      });
1117    });
1118    if (this.input && this.input.form) {
1119      this.input.form.addEventListener("reset", () => {
1120        const fallback = [...this.selects].find(
1121          (select) => select.getAttribute("data-value") === this.defaultValue
1122        );
1123        if (fallback) {
1124          this.select(fallback, true);
1125        }
1126      });
1127    }
1128  }
1129  select(option, silent = false) {
1130    if (this.current) {
1131      this.current.innerHTML = option.innerHTML;
1132    }
1133    this.selects.forEach((select) => {
1134      select.classList.toggle("is-active", select === option);
1135    });
1136    if (this.input && option.hasAttribute("data-value")) {
1137      this.input.value = option.getAttribute("data-value");
1138      if (!silent) {
1139        this.input.dispatchEvent(new Event("change", { bubbles: true }));
1140      }
1141    }
1142  }
1143}
1144function colorPicker() {
1145  const fields = document.querySelectorAll(".widget-color");
1146  const hexRegex = /^#?[A-Fa-f0-9]{0,6}$/;
1147  fields.forEach((field) => {
1148    const picker = field.querySelector(".widget-color__input");
1149    const text = field.querySelector(".widget-color__value");
1150    let textValue = text.value;
1151    picker.addEventListener("input", () => {
1152      text.value = picker.value.toUpperCase();
1153    });
1154    text.addEventListener("input", (e) => {
1155      if (!hexRegex.test(text.value)) text.value = textValue;
1156      textValue = text.value;
1157    });
1158    text.addEventListener("change", () => {
1159      text.value = text.value.toUpperCase();
1160      if (text.value[0] !== "#") {
1161        text.value = "#" + text.value;
1162      }
1163      const withoutHash = text.value.slice(1);
1164      if (withoutHash.length < 6) {
1165        const padZeroes = new Array(6 - withoutHash.length).fill("0").join("");
1166        text.value += padZeroes;
1167      }
1168      if (hexRegex.test(text.value)) {
1169        picker.value = text.value;
1170        picker.dispatchEvent(new Event("input"));
1171        textValue = text.value;
1172      }
1173    });
1174  });
1175}
1176function widgetLanguage() {
1177  const languageDropdown = document.getElementById("languageSelect");
1178  if (languageDropdown) {
1179    languageDropdown.addEventListener("change", () => {
1180      document.querySelectorAll(".widget-content-language").forEach((element) => {
1181        element.style.display = "none";
1182        element.removeAttribute("data-active-language");
1183      });
1184      const contentToShow = document.querySelector(
1185        `[data-content-id="${languageDropdown.value}"]`
1186      );
1187      if (contentToShow) {
1188        contentToShow.style.display = "block";
1189        contentToShow.dataset.activeLanguage = "true";
1190      }
1191    });
1192  }
1193}
1194function restoreWidgetMessageOnClick() {
1195  const field = document.querySelector("#widget-message");
1196  const button = document.querySelector("#widget-message-reset");
1197  if (field && button) {
1198    button.addEventListener("click", () => {
1199      field.value = button.dataset.reset;
1200      field.dispatchEvent(new Event("change"));
1201    });
1202  }
1203}
1204const widgetPreview = () => {
1205  const iframe = document.querySelector("#widget-preview-iframe");
1206  const iframeWindow = iframe && iframe.contentWindow;
1207  const themeInputs = document.querySelectorAll(
1208    "[data-update-preview-theme]"
1209  );
1210  const appearanceInputs = document.querySelectorAll(
1211    "[data-update-preview-appearance]"
1212  );
1213  const positionsRadioGroup = document.getElementById(
1214    "widget-radio-group-embed_config[layout][position]"
1215  );
1216  const positionInputs = document.querySelectorAll(
1217    "[data-update-preview-position]"
1218  );
1219  const preferencesInputs = document.querySelectorAll(
1220    "[data-update-preview-preferences]"
1221  );
1222  const blockInteractionInputs = document.querySelectorAll(
1223    "[data-update-preview-block-interaction]"
1224  );
1225  const rejectInputs = document.querySelectorAll(
1226    "[data-update-preview-reject-all]"
1227  );
1228  const updatePreferenceInputs = document.querySelectorAll(
1229    "[data-update-preview-update-after-close]"
1230  );
1231  const reopenButtonPositionInputs = document.querySelectorAll(
1232    "[data-update-preview-reopen-button-position]"
1233  );
1234  const cookiePolicyLanguageDropdown = document.querySelector(
1235    "[data-update-preview-language]"
1236  );
1237  const widgetContentFieldMap = {
1238    "[data-update-preview-policy]": "updateCookiePolicyUrl",
1239    "[data-update-preview-link-text]": "updateCookiePolicyLinkText",
1240    "[data-update-after-close-button-color]": "updateAfterCloseButtonColor",
1241    "[data-update-make-all-buttons-primary]": "makeAllBtnPrimary",
1242    "[data-update-dialog-title]": "updateDialogTitle",
1243    "[data-update-dialog-message]": "updateDialogMessage",
1244    "[data-update-dialog-save-preferences-button]": "updateDialogSavePreferences",
1245    "[data-update-dialog-accept-all-button]": "updateDialogAcceptAll",
1246    "[data-update-dialog-reject-all-button]": "updateDialogRejectAll",
1247    "[data-update-preview-message]": "updateMessage",
1248    "[data-update-widget-pill-message]": "updatePillMessage",
1249    "[data-update-widget-banner-title]": "updateBannerTitle",
1250    "[data-update-widget-manage-preferences-button]": "updateWidgetManagePreferences",
1251    "[data-update-widget-reject-all-button]": "updateWidgetRejectAllButton",
1252    "[data-update-widget-accept-all-button]": "updateWidgetAcceptAllButton",
1253    "[data-update-preview-update-after-close]": "updateShowPreferencesAfterClose",
1254    "[data-update-widget-show-cookies-button]": "updateWidgetShowCookiesButton",

1255    "[data-update-widget-hide-cookies-button]": "updateWidgetHideCookiesButton",
1256    "[data-update-cookie-essential-title]": "updateEssentialTitle",
1257    "[data-update-cookie-essential-description]": "updateEssentialDescription",
1258    "[data-update-cookie-functional-title]": "updateFunctionalTitle",
1259    "[data-update-cookie-functional-description]": "updateFunctionalDescription",
1260    "[data-update-cookie-marketing-title]": "updateMarketingTitle",
1261    "[data-update-cookie-marketing-description]": "updateMarketingDescription",
1262    "[data-update-cookie-analytics-title]": "updateAnalyticsTitle",
1263    "[data-update-cookie-analytics-description]": "updateAnalyticsDescription",
1264    "[data-update-cookie-unclassified-title]": "updateUnclassifiedTitle",
1265    "[data-update-cookie-unclassified-description]": "updateUnclassifiedDescription",
1266    "[data-update-cookie-heading-platform]": "updateCookieHeadingPlatform",
1267    "[data-update-cookie-heading-name-description]": "updateCookieHeadingNameDescription",
1268    "[data-update-cookie-heading-retention]": "updateCookieHeadingRetention",
1269    "[data-update-storage-heading]": "updateStorageHeading",
1270    "[data-update-storage-heading-type]": "updateStorageHeadingType",
1271    "[data-update-storage-heading-name]": "updateStorageHeadingName",
1272    "[data-update-storage-heading-origin]": "updateStorageHeadingOrigin"
1273  };
1274  const widgetFullPreviewButton = document.querySelector(
1275    "#widget-preview-full"
1276  );
1277  let isWidgetPreviewShowing = false;
1278  document.addEventListener("previewUpdate", (event) => {
1279    const eventData = event.detail.data;
1280    const reinit = event.detail.reinit;
1281    widgetPreviewUpdateEventHandler(
1282      eventData,
1283      reinit && isWidgetPreviewShowing
1284    );
1285    iframeWindow.postMessage({ data: eventData, reinit });
1286  });
1287  function triggerPreviewUpdate(data, reinit = true) {
1288    document.dispatchEvent(
1289      new CustomEvent("previewUpdate", { detail: { data, reinit } })
1290    );
1291  }
1292  if (iframeWindow) {

1293    window.gtCookieWidgetConfig = JSON.parse(iframe.dataset.config);
1294    themeInputs.forEach(
1295      (input) => input.addEventListener("input", () => {
1296        triggerPreviewUpdate(
1297          {
1298            type: "updateTheme",
1299            value: {
1300              variable: input.dataset.updatePreviewTheme,
1301              value: input.value
1302            }
1303          },
1304          true
1305        );
1306      })
1307    );
1308    appearanceInputs.forEach(
1309      (input) => input.addEventListener("change", () => {
1310        if (input.checked) {
1311          triggerPreviewUpdate(
1312            {
1313              type: "updateAppearance",
1314              value: input.value
1315            },
1316            true
1317          );
1318          positionsRadioGroup.classList.toggle(
1319            "hide",
1320            input.value === "banner" || input.value === "popup"
1321          );
1322        }
1323      })
1324    );
1325    positionInputs.forEach(
1326      (input) => input.addEventListener("change", () => {
1327        if (input.checked) {
1328          triggerPreviewUpdate(
1329            {
1330              type: "updatePosition",
1331              value: input.value
1332            },
1333            true
1334          );
1335        }
1336      })
1337    );
1338    preferencesInputs.forEach(
1339      (input) => input.addEventListener("change", () => {
1340        if (input.checked) {
1341          triggerPreviewUpdate(
1342            {
1343              type: "updateAllowPreferences",
1344              value: input.value
1345            },
1346            true
1347          );
1348        }
1349      })
1350    );
1351    blockInteractionInputs.forEach(
1352      (input) => input.addEventListener("change", () => {
1353        if (input.checked) {
1354          triggerPreviewUpdate(
1355            {
1356              type: "updateBlockInteraction",
1357              value: input.value
1358            },
1359            true
1360          );
1361        }
1362      })
1363    );
1364    rejectInputs.forEach(
1365      (input) => input.addEventListener("change", () => {
1366        if (input.checked) {
1367          triggerPreviewUpdate(
1368            {
1369              type: "updateRejectAll",
1370              value: input.value
1371            },
1372            true
1373          );
1374        }
1375      })
1376    );
1377    updatePreferenceInputs.forEach(
1378      (input) => input.addEventListener("change", () => {
1379        if (input.checked) {
1380          triggerPreviewUpdate(
1381            {
1382              type: "updateShowPreferencesAfterClose",
1383              value: input.value
1384            },
1385            true
1386          );
1387        }
1388      })
1389    );
1390    reopenButtonPositionInputs.forEach(
1391      (input) => input.addEventListener("change", () => {
1392        if (input.checked) {
1393          triggerPreviewUpdate(
1394            {
1395              type: "updateReopenButtonPosition",
1396              value: input.value
1397            },
1398            false
1399          );
1400        }
1401      })
1402    );
1403    if (cookiePolicyLanguageDropdown) {
1404      cookiePolicyLanguageDropdown.addEventListener("change", () => {
1405        const languageContainer = document.querySelector(
1406          `[data-content-id="${cookiePolicyLanguageDropdown.value}"`
1407        );
1408        if (languageContainer) {
1409          Object.entries(widgetContentFieldMap).forEach(
1410            ([selector, event], index, array) => {
1411              const input = languageContainer.querySelector(selector);
1412              if (input) {
1413                triggerPreviewUpdate(
1414                  {
1415                    type: event,
1416                    value: input.value
1417                  },
1418                  index === array.length - 1
1419                );
1420              }
1421            }
1422          );
1423        }
1424      });
1425    }
1426    Object.entries(widgetContentFieldMap).forEach(([selector, event]) => {
1427      const inputs = document.querySelectorAll(selector);
1428      inputs.forEach((input) => {
1429        input.addEventListener("change", (e) => {
1430          triggerPreviewUpdate({
1431            type: event,
1432            value: input.value
1433          });
1434        });
1435      });
1436    });
1437  }
1438  if (widgetFullPreviewButton) {
1439    widgetFullPreviewButton.addEventListener("click", () => {
1440      const scriptTag = document.querySelector("#widget-script");
1441      const textTag = widgetFullPreviewButton.querySelector(".inner");
1442      isWidgetPreviewShowing = !isWidgetPreviewShowing;
1443      updateButton();
1444      if (isWidgetPreviewShowing) {
1445        if (!scriptTag) {
1446          const script = document.createElement("script");
1447          script.src = "/build/js/cookie-widget-vue.js";
1448          script.id = "widget-script";
1449          script.async = false;

1450          script.onload = () => {
1451            window.gtCookieWidgetPreview();
1452            document.addEventListener(
1453              "click",
1454              onDocumentClickCheckWidgetDismiss
1455            );
1456          };
1457          document.head.appendChild(script);
1458        } else {
1459          window.gtCookieWidgetPreview();
1460          document.addEventListener(
1461            "click",
1462            onDocumentClickCheckWidgetDismiss
1463          );
1464        }
1465      } else {
1466        const widget = document.querySelector(
1467          ".gt-cookie-widget-wrapper"
1468        );
1469        widget && widget.remove();
1470        document.removeEventListener(
1471          "click",
1472          onDocumentClickCheckWidgetDismiss
1473        );
1474      }
1475      function updateButton() {
1476        widgetFullPreviewButton.classList.toggle(
1477          "btn--border-primary",
1478          isWidgetPreviewShowing
1479        );
1480        widgetFullPreviewButton.classList.toggle(
1481          "btn--border-grey",
1482          !isWidgetPreviewShowing
1483        );
1484        textTag.textContent = isWidgetPreviewShowing ? widgetFullPreviewButton.dataset.hideMessage : widgetFullPreviewButton.dataset.showMessage;
1485      }
1486      function onDocumentClickCheckWidgetDismiss(e) {
1487        if (e.target.closest(
1488          "[data-gt-cookie-accept-all], [data-gt-cookie-save], [data-gt-cookie-reject-all]"
1489        )) {
1490          isWidgetPreviewShowing = false;
1491          updateButton();
1492          document.removeEventListener(
1493            "click",
1494            onDocumentClickCheckWidgetDismiss
1495          );
1496        }
1497      }
1498    });
1499  }
1500};
1501const widgetTabs = () => {
1502  const preview = document.querySelector(".widget-preview");
1503  const tabButtons = document.querySelectorAll(".widget-tabs__button");
1504  const tabPanels = document.querySelectorAll(".widget-tab-panel");
1505  if (!preview || !tabButtons.length) {
1506    return;
1507  }
1508  function openTabId(id) {
1509    const button = Array.from(tabButtons).find(
1510      (button2) => button2.dataset.tabId === id
1511    );
1512    const hidePreview = button.dataset.hidePreview !== void 0;
1513    tabButtons.forEach((button2) => {
1514      button2.classList.toggle(
1515        "widget-tabs__button--active",
1516        button2.dataset.tabId === id
1517      );
1518    });
1519    tabPanels.forEach((panel) => {
1520      panel.classList.toggle("widget-tab-panel--active", panel.id === id);
1521    });
1522    preview.classList.toggle("widget-preview--hidden", hidePreview);
1523  }
1524  tabButtons.forEach((button) => {
1525    button.addEventListener("click", () => {
1526      openTabId(button.dataset.tabId);
1527    });
1528  });
1529};
1530const policyContentTabs = () => {
1531  document.addEventListener("click", (e) => {
1532    const button = e.target.closest(".policy-content-tabs .tab-btn");
1533    if (!button) {
1534      return;
1535    }
1536    const nav = button.closest(".policy-content-tabs");
1537    const target = button.dataset.tab;
1538    nav.querySelectorAll(".tab-btn").forEach((btn) => {
1539      btn.classList.toggle("is-active", btn === button);
1540    });
1541    document.querySelectorAll(".tab-content").forEach((content) => {
1542      content.classList.toggle("hidden", content.id !== `tab-${target}`);
1543    });
1544  });
1545};
1546function widgetInstructions() {
1547  var _a, _b;
1548  const googleConsentModeInputs = document.querySelectorAll(
1549    "[data-update-consent-mode]"
1550  );
1551  const instructionSets = document.querySelectorAll("[data-instructions]");
1552  googleConsentModeInputs.forEach(
1553    (input) => input.addEventListener("change", () => {
1554      if (input.checked) {
1555        switch (input.value) {
1556          case "on":
1557            instructionSets.forEach((el) => {
1558              el.classList.toggle(
1559                "hidden",
1560                el.dataset.instructions !== "consent-mode"
1561              );
1562            });
1563            break;
1564          case "off":
1565            instructionSets.forEach((el) => {
1566              el.classList.toggle(
1567                "hidden",
1568                el.dataset.instructions !== "default"
1569              );
1570            });
1571            break;
1572        }
1573      }
1574    })
1575  );
1576  const instructionSections = document.querySelectorAll("[data-instructions]");
1577  instructionSections.forEach((section) => {
1578    const dropdown = section.querySelector("[data-installation-language]");
1579    const embedCode = section.querySelectorAll("[data-embed-code], #code-inner-widget-embed, #code-inner-widget-embed-v2");
1580    const embedAutoCode = section.querySelector("[data-embed-auto-code]");
1581    const autoLanguageRadios = section.querySelectorAll("[name='embed_config[functionality][enable_auto_language]']");
1582    if (!dropdown) return;
1583    let priorValue = dropdown.value;
1584    autoLanguageRadios.forEach((radio) => {
1585      radio.addEventListener("change", () => {
1586        if (radio.checked) {
1587          console.log("Auto language changed to:", radio.value);
1588          if (radio.value === "on") {
1589            if (embedCode && embedCode.length > 0) {
1590              embedCode.forEach((el) => {
1591                if (el.innerHTML.includes("?auto=true")) return;
1592                el.innerHTML = el.innerHTML.replaceAll(
1593                  `/${priorValue}`,
1594                  `/${priorValue}?auto=true`
1595                );
1596                createUpdateMessage(el);
1597              });
1598            }
1599          } else {
1600            if (embedCode && embedCode.length > 0) {
1601              embedCode.forEach((el) => {
1602                el.innerHTML = el.innerHTML.replaceAll(
1603                  `?auto=true`,
1604                  ""
1605                );
1606                createUpdateMessage(el);
1607              });
1608            }
1609          }
1610        }
1611      });
1612    });
1613    dropdown.addEventListener("change", () => {
1614      if (embedCode && embedCode.length > 0) {
1615        embedCode.forEach((el) => {
1616          el.innerHTML = el.innerHTML.replaceAll(
1617            `/${priorValue}`,
1618            `/${dropdown.value}`
1619          );
1620          createUpdateMessage(el);
1621        });
1622      }
1623      if (embedAutoCode) {
1624        embedAutoCode.innerHTML = embedAutoCode.innerHTML.replaceAll(
1625          `/${priorValue}?auto=true`,
1626          `/${dropdown.value}?auto=true`
1627        );
1628      }
1629      priorValue = dropdown.value;
1630    });
1631  });
1632  const debugRadios = document.querySelectorAll("[data-installation-debug-toggle]");
1633  if (debugRadios && debugRadios.length) {
1634    const container = document.getElementById("widget-installation");
1635    const endpoint = container ? container.dataset.debugUrl : null;
1636    const csrf = (_a = document.querySelector('meta[name="csrf-token"]')) == null ? void 0 : _a.getAttribute("content");
1637    debugRadios.forEach((radio) => {
1638      radio.addEventListener("change", async () => {
1639        if (!radio.checked) return;
1640        const enable = radio.value === "on";
1641        const embeds = document.querySelectorAll("[data-embed-code], #code-inner-widget-embed, #code-inner-widget-embed-v2");
1642        embeds.forEach((el) => {
1643          const updated = updateEmbedCodeDebug(el.innerHTML, enable);
1644          if (updated !== el.innerHTML) {
1645            el.innerHTML = updated;
1646            createUpdateMessage(el);
1647          }
1648        });
1649        if (endpoint) {
1650          try {
1651            const res = await fetch(endpoint, {
1652              method: "POST",
1653              headers: {
1654                "Content-Type": "application/json",
1655                "Accept": "application/json",
1656                ...csrf ? { "X-CSRF-TOKEN": csrf }

1656 : {}
1657              },
1658              body: JSON.stringify({ _value: enable ? "on" : "off" }),
1659              credentials: "same-origin"
1660            });
1661            if (!res.ok) throw new Error("Network error");
1662            const data = await res.json();
1663            const firstEl = embeds[0] || container;
1664            if (firstEl) createUpdateMessage(firstEl, "Debug mode saved");
1665          } catch (e) {
1666            const groupName = radio.getAttribute("name");
1667            const other = document.querySelector(`input[name="${groupName}"][value="${enable ? "off" : "on"}"]`);
1668            if (other) other.checked = true;
1669            const firstEl = embeds[0] || container;
1670            if (firstEl) createUpdateMessage(firstEl, "Failed to save debug mode");
1671          }
1672        }
1673      });
1674    });
1675  }
1676  const diagRadios = document.querySelectorAll("[data-installation-diagnostics-toggle]");
1677  if (diagRadios && diagRadios.length) {
1678    const container = document.getElementById("widget-installation");
1679    const endpoint = container ? container.dataset.diagnosticsUrl : null;
1680    const csrf = document.querySelector('meta[name="csrf-token"]').getAttribute("content");
1681    const issuesSection = document.getElementById("installation-issues");
1682    diagRadios.forEach((radio) => {
1683      radio.addEventListener("change", async () => {
1684        if (!radio.checked) return;
1685        const enable = radio.value === "on";
1686        if (issuesSection) {
1687          if (!enable) {
1688            issuesSection.classList.add("hidden");
1689          } else {
1690            issuesSection.classList.remove("hidden");
1691          }
1692        }
1693        if (endpoint) {
1694          try {
1695            const res = await fetch(endpoint, {
1696              method: "POST",
1697              headers: {
1698                "Content-Type": "application/json",
1699                "Accept": "application/json",
1700                ...csrf ? { "X-CSRF-TOKEN": csrf } : {}
1701              },
1702              body: JSON.stringify({ _value: enable ? "on" : "off" }),
1703              credentials: "same-origin"
1704            });
1705            if (!res.ok) throw new Error("Network error");
1706            const target = issuesSection || container;
1707            if (target) createUpdateMessage(target, "Diagnostics setting saved");
1708          } catch (e) {
1709            const groupName = radio.getAttribute("name");
1710            const other = document.querySelector(`input[name="${groupName}"][value="${enable ? "off" : "on"}"]`);
1711            if (other) other.checked = true;
1712            const target = issuesSection || container;
1713            if (target) createUpdateMessage(target, "Failed to save diagnostics setting");
1714            if (issuesSection) {
1715              if (enable) {
1716                issuesSection.classList.add("hidden");
1717              } else {
1718                issuesSection.classList.remove("hidden");
1719              }
1720            }
1721          }
1722        }
1723      });
1724    });
1725  }
1726  try {
1727    const issuesSection = document.getElementById("installation-issues");
1728    if (issuesSection) {
1729      const listEl = issuesSection.querySelector(".installation-issues__list");
1730      const resolveUrl = issuesSection.dataset.diagResolveUrl;
1731      const ignoreUrl = issuesSection.dataset.diagIgnoreUrl;
1732      const csrf = (_b = document.querySelector('meta[name="csrf-token"]')) == null ? void 0 : _b.getAttribute("content");
1733      issuesSection.addEventListener("click", async (e) => {
1734        const toggle = e.target.closest('button[data-toggle="issue-help"]');
1735        if (toggle) {
1736          const issue = toggle.closest(".issue");
1737          const help = issue ? issue.querySelector(".issue__help") : null;
1738          if (help) {
1739            const isHidden = help.style.display === "none";
1740            help.style.display = isHidden ? "block" : "none";
1741            toggle.setAttribute("aria-expanded", String(isHidden));
1742            toggle.textContent = isHidden ? "Hide details" : "What does this mean?";
1743          }
1744          return;
1745        }
1746        const btn = e.target.closest("button[data-action]");
1747        if (!btn) return;
1748        const action = btn.dataset.action;
1749        const code = btn.dataset.code;
1750        const url = action === "resolve" ? resolveUrl : ignoreUrl;
1751        btn.disabled = true;
1752        try {
1753          const res = await fetch(url, {
1754            method: "POST",
1755            headers: {
1756              "Content-Type": "application/json",
1757              "Accept": "application/json",
1758              ...csrf ? { "X-CSRF-TOKEN": csrf }

1758 : {}
1759            },
1760            body: JSON.stringify({ code }),
1761            credentials: "same-origin"
1762          });
1763          if (!res.ok) throw new Error("Network error");
1764          const li = btn.closest("li.installation-issues__item");
1765          if (li) li.remove();
1766          if (listEl && listEl.children.length === 0) {
1767            issuesSection.remove();
1768          }
1769        } catch (err) {
1770          btn.disabled = false;
1771        }
1772      });
1773    }
1774  } catch (e) {
1775  }
1776}
1777function updateEmbedCodeDebug(html, enable) {
1778  try {
1779    const srcMatch = html.match(/src=\"([^\"]+)\"/i);
1780    if (!srcMatch) return html;
1781    let url = srcMatch[1];
1782    const hasParam = /[?&]getterms_debug=1(?!\d)/.test(url);
1783    if (enable && !hasParam) {
1784      url += (url.includes("?") ? "&" : "?") + "getterms_debug=1";
1785    } else if (!enable && hasParam) {
1786      url = url.replace(/([?&])getterms_debug=1(&?)/, (m, p1, p2) => {
1787        if (p1 === "?" && p2) return "?";
1788        if (p1 === "?" && !p2) return "";
1789        if (p1 === "&" && p2) return "&";
1790        return "";
1791      }).replace(/\?$/, "");
1792    }
1793    return html.replace(srcMatch[1], url);
1794  } catch (e) {
1795    return html;
1796  }
1797}
1798const createUpdateMessage = (el, message = "Embed code updated") => {
1799  const updateMessage = document.createElement("div");
1800  updateMessage.classList.add("code-block__notification");
1801  updateMessage.role = "alert";
1802  updateMessage.ariaAtomic = "true";
1803  updateMessage.textContent = message;
1804  el.parentNode.appendChild(updateMessage);
1805  setTimeout(() => {
1806    updateMessage.classList.add("is-active");
1807  }, 100);
1808  setTimeout(() => {
1809    updateMessage.classList.remove("is-active");
1810    updateMessage.addEventListener("transitionend", function() {
1811      updateMessage.remove();
1812    });
1813  }, 2e3);
1814};
1815function copyText() {
1816  const copyTextButtons = document.querySelectorAll("[data-copy]");
1817  copyTextButtons.forEach((button) => {
1818    button.addEventListener("click", async () => {
1819      const copyTargetSelector = button.dataset.copy;
1820      const successMessageString = button.dataset.successMessage || "Copied to the clipboard";
1821      const elementToCopy = document.querySelector(copyTargetSelector);
1822      if (elementToCopy) {
1823        console.log(elementToCopy);
1824        try {
1825          const textToCopy = elementToCopy.innerText.trim();
1826          await navigator.clipboard.writeText(textToCopy).then(() => {
1827            const isInlineMessage = button.classList.contains("inline-message");
1828            const buttonLabel = button.querySelector(".btn__label");
1829            const successMessage = document.createElement("div");
1830            successMessage.classList.add("clipboard-message");
1831            successMessage.classList.add(isInlineMessage ? "clipboard-message--inline" : "clipboard-message--fixed");
1832            successMessage.role = "alert";
1833            successMessage.ariaAtomic = "true";
1834            successMessage.innerHTML = "<p>" + successMessageString + "</p>";
1835            if (isInlineMessage) {
1836              button.parentNode.appendChild(successMessage);
1837            } else {
1838              document.body.appendChild(successMessage);
1839            }
1840            setTimeout(function() {
1841              successMessage.classList.add("is-active");
1842              if (buttonLabel) {
1843                buttonLabel.textContent = "Copied";
1844              }
1845            }, 100);
1846            setTimeout(function() {
1847              successMessage.classList.remove("is-active");
1848              successMessage.addEventListener("transitionend", function() {
1849                successMessage.remove();
1850                if (buttonLabel) {
1851                  buttonLabel.textContent = "Copy";
1852                }
1853              });
1854            }, 1500);
1855          });
1856        } catch (error) {
1857          console.error(
1858            `Failed to copy from selector ${copyTargetSelector}`,
1859            error
1860          );
1861        }
1862      } else {
1863        console.error(
1864          `Failed to find element using selector ${copyTargetSelector}`
1865        );
1866      }
1867    });
1868  });
1869}
1870function typeDropdown() {
1871  const typeDropdownEl = document.querySelector(".type-dropdown");
1872  if (typeDropdownEl) {
1873    const button = typeDropdownEl.querySelector("button");
1874    button.addEventListener("click", () => {
1875      let is_expanded = typeDropdownEl.classList.contains("is-open") ? true : false;

1876      if (!is_expanded) {
1877        typeDropdownEl.querySelector(".types-wrap").removeAttribute("hidden");
1878        setTimeout(function() {
1879          typeDropdownEl.classList.add("is-open");
1880        }, 200);
1881      } else {
1882        typeDropdownEl.classList.remove("is-open");
1883        typeDropdownEl.querySelector("button").focus();
1884        setTimeout(function() {
1885          typeDropdownEl.querySelector(".types-wrap").setAttribute("hidden", "");
1886        }, 200);
1887      }
1888      toggleDropdown(button, is_expanded ? false : true);
1889    });
1890  }
1891  document.addEventListener("keydown", typeEsc, false);
1892  function typeEsc(evt) {
1893    evt = evt || window.event;
1894    if (evt.keyCode == 27) {
1895      typeClose();
1896    }
1897  }
1898  document.addEventListener(
1899    "click",
1900    (evt) => {
1901      if (!evt.target.classList.contains("type-dropdown") && jQuery(evt.target).parents(".type-dropdown").length === 0) {
1902        typeClose();
1903      }
1904    },
1905    false
1906  );
1907  function typeClose() {
1908    if (typeDropdownEl == null) {
1909      return;
1910    }
1911    typeDropdownEl.classList.remove("is-open");
1912    setTimeout(function() {
1913      typeDropdownEl.querySelector(".types-wrap").setAttribute("hidden", "");
1914    }, 200);
1915  }
1916  function toggleDropdown(toggle, is_expanded) {
1917    const target = document.getElementById(
1918      toggle.getAttribute("aria-controls")
1919    );
1920    toggle.setAttribute("aria-expanded", is_expanded ? "true" : "false");
1921    if (target) {
1922      target.setAttribute(
1923        "data-expanded",
1924        is_expanded ? "true" : "false"
1925      );
1926    }
1927  }
1928}
1929function menuToggle() {
1930  const mainNav = document.querySelector(".main-nav");
1931  const hamburgerSelector = document.querySelectorAll(".js-open-main-nav");
1932  hamburgerSelector.forEach(function(hamburger) {
1933    hamburger.addEventListener("click", function(e) {
1934      e.preventDefault();
1935      if (!document.documentElement.classList.contains("is-menu-open")) {
1936        mainNav.removeAttribute("hidden");
1937        setTimeout(function() {
1938          scrollControl.disable();
1939          document.documentElement.classList.add("is-menu-open");
1940          mainNav.querySelector(".title").focus();
1941        }, 100);
1942      } else {
1943        scrollControl.enable();
1944        document.documentElement.classList.remove("is-menu-open");
1945        setTimeout(function() {
1946          mainNav.setAttribute("hidden", "");
1947          document.querySelector(".hamburger").focus();
1948        }, 650);
1949      }
1950    });
1951  });
1952  document.addEventListener("keydown", menuEsc, false);
1953  function menuEsc(evt) {
1954    evt = evt || window.event;
1955    if (evt.keyCode == 27 && document.documentElement.classList.contains("is-menu-open")) {
1956      scrollControl.enable();
1957      document.documentElement.classList.remove("is-menu-open");
1958      setTimeout(function() {
1959        mainNav.setAttribute("hidden", "");
1960        document.querySelector(".hamburger").focus();
1961      }, 650);
1962    }
1963  }
1964  const scrollControl = {
1965    scrollContainer: document.scrollingElement || document.documentElement,
1966    scrollTop: null,
1967    originalStyles: null,
1968    enable: () => {
1969      document.body.style.cssText = scrollControl.originalStyles;
1970      scrollControl.scrollContainer.scrollTop = scrollControl.scrollTop;
1971    },
1972    disable: () => {
1973      scrollControl.scrollTop = scrollControl.scrollContainer.scrollTop;
1974      scrollControl.originalStyles = document.body.style.cssText;
1975      document.body.style.cssText = `overflow: hidden; position: fixed; height: 100%; width: 100%; top: ${-scrollControl.scrollTop}px`;
1976    }
1977  };
1978}
1979function planSelect() {
1980  const eleContainer = document.querySelector(".hero-home__grid");
1981  const ele = document.querySelectorAll(".card-plan");

1982  if (eleContainer) {
1983    eleContainer.addEventListener("mouseenter", function() {
1984      if (!eleContainer.classList.contains("is-hovered")) {
1985        eleContainer.classList.add("is-hovered");
1986      }
1987    });
1988    eleContainer.addEventListener("mouseleave", function() {
1989      if (eleContainer.classList.contains("is-hovered")) {
1990        eleContainer.classList.remove("is-hovered");
1991      }
1992      setTimeout(function() {
1993      }, 150);
1994    });
1995    ele.forEach(function(item) {
1996      item.addEventListener("mouseenter", function() {
1997        if (!item.parentNode.classList.contains("is-active")) {
1998          item.parentNode.classList.add("is-active");
1999        }
2000      });
2001      item.addEventListener("mouseleave", function() {
2002        if (item.parentNode.classList.contains("is-active")) {
2003          item.parentNode.classList.remove("is-active");
2004        }
2005        setTimeout(function() {
2006        }, 150);
2007      });
2008    });
2009  }
2010}
2011function comparisonToggle() {
2012  const optionsSection = document.querySelector(".hero-home");
2013  if (optionsSection) {
2014    const compareBtn = optionsSection.querySelector(".js-compare");
2015    const inclusionsLists = Array.prototype.slice.call(
2016      optionsSection.querySelectorAll(".js-inclusions")
2017    );
2018    const compareIsOpen = () => optionsSection.classList.contains("js-compare-open");
2019    inclusionsLists.forEach((item) => {
2020      item.addEventListener("transitionend", () => {
2021        item.style = "";
2022      });
2023    });
2024    const openCompare = () => {
2025      inclusionsLists.forEach((item) => {
2026        item.style.maxHeight = "0px";
2027        item.style.overflow = "hidden";
2028        void item.offsetHeight;
2029        item.style.transition = "max-height 0.5s cubic-bezier(0.2, 0, 0, 1)";
2030        item.style.maxHeight = item.scrollHeight + "px";
2031        item.setAttribute("aria-expanded", true);
2032      });
2033      optionsSection.classList.add("js-compare-open");
2034    };
2035    const closeCompare = () => {
2036      inclusionsLists.forEach((item) => {
2037        item.style.maxHeight = item.scrollHeight + "px";
2038        item.style.transition = "max-height 0.5s cubic-bezier(0.2, 0, 0, 1)";
2039        item.style.overflow = "hidden";
2040        void item.offsetHeight;
2041        item.style.maxHeight = "0px";
2042        item.setAttribute("aria-expanded", false);
2043      });
2044      optionsSection.classList.remove("js-compare-open");
2045    };
2046    compareBtn.addEventListener("click", (e) => {
2047      const span = e.currentTarget.querySelector("span.inner");
2048      let isOpening = true;
2049      if (compareIsOpen()) {
2050        isOpening = false;
2051        closeCompare();
2052      } else {
2053        openCompare();
2054      }
2055      if (span) {
2056        span.innerText = isOpening ? "Hide Comparison" : "Compare Packages";
2057      }
2058    });
2059  }
2060}
2061const reviewsTicker = function() {
2062  const reviews2 = document.querySelector(".reviews");
2063  if (reviews2) {
2064    const reviewsRows = reviews2.querySelectorAll(".reviews__row");
2065    reviewsRows.forEach((row) => {
2066      const reviewCards = row.querySelectorAll(".card-review");
2067      reviewCards.forEach((card) => {
2068        const clonedCard = card.cloneNode(true);
2069        row.appendChild(clonedCard);
2070      });
2071    });
2072  }
2073};
2074function addLoader() {
2075  const svg = `<svg aria-hidden="true" style="--icon-width: 1em;" class="stroke" width="14" height="14" viewBox="0 0 14 14" xmlns="http://www.w3.org/2000/svg"><path d="M7 13a6 6 0 1 0-6-6" stroke="#FFF" stroke-width="2" fill="none" fill-rule="evenodd" stroke-linecap="round"/></svg>`;
2076  const loader = document.createElement("div");
2077  loader.classList.add("loading-icon");
2078  loader.innerHTML = svg;
2079  return loader;
2080}
2081var HOOKS = [
2082  "onChange",
2083  "onClose",
2084  "onDayCreate",
2085  "onDestroy",
2086  "onKeyDown",
2087  "onMonthChange",
2088  "onOpen",
2089  "onParseConfig",
2090  "onReady",
2091  "onValueUpdate",
2092  "onYearChange",
2093  "onPreCalendarPosition"
2094];
2095var defaults = {
2096  _disable: [],
2097  allowInput: false,
2098  allowInvalidPreload: false,
2099  altFormat: "F j, Y",
2100  altInput: false,
2101  altInputClass: "form-control input",
2102  animate: typeof window === "object" && window.navigator.userAgent.indexOf("MSIE") === -1,
2103  ariaDateFormat: "F j, Y",
2104  autoFillDefaultTime: true,
2105  clickOpens: true,
2106  closeOnSelect: true,
2107  conjunction: ", ",
2108  dateFormat: "Y-m-d",
2109  defaultHour: 12,
2110  defaultMinute: 0,
2111  defaultSeconds: 0,
2112  disable: [],
2113  disableMobile: false,
2114  enableSeconds: false,
2115  enableTime: false,
2116  errorHandler: function(err) {
2117    return typeof console !== "undefined" && console.warn(err);
2118  },
2119  getWeek: function(givenDate) {
2120    var date = new Date(givenDate.getTime());
2121    date.setHours(0, 0, 0, 0);
2122    date.setDate(date.getDate() + 3 - (date.getDay() + 6) % 7);
2123    var week1 = new Date(date.getFullYear(), 0, 4);
2124    return 1 + Math.round(((date.getTime() - week1.getTime()) / 864e5 - 3 + (week1.getDay() + 6) % 7) / 7);
2125  },
2126  hourIncrement: 1,
2127  ignoredFocusElements: [],
2128  inline: false,
2129  locale: "default",
2130  minuteIncrement: 5,
2131  mode: "single",
2132  monthSelectorType: "dropdown",
2133  nextArrow: "<svg version='1.1' xmlns='http://www.w3.org/2000/svg' xmlns:xlink='http://www.w3.org/1999/xlink' viewB

2133ox='0 0 17 17'><g></g><path d='M13.207 8.472l-7.854 7.854-0.707-0.707 7.146-7.146-7.146-7.148 0.707-0.707 7.854 7.854z' /></svg>",
2134  noCalendar: false,
2135  now: /* @__PURE__ */ new Date(),
2136  onChange: [],
2137  onClose: [],
2138  onDayCreate: [],
2139  onDestroy: [],
2140  onKeyDown: [],
2141  onMonthChange: [],
2142  onOpen: [],
2143  onParseConfig: [],
2144  onReady: [],
2145  onValueUpdate: [],
2146  onYearChange: [],
2147  onPreCalendarPosition: [],
2148  plugins: [],
2149  position: "auto",
2150  positionElement: void 0,
2151  prevArrow: "<svg version='1.1' xmlns='http://www.w3.org/2000/svg' xmlns:xlink='http://www.w3.org/1999/xlink' viewBox='0 0 17 17'><g></g><path d='M5.207 8.471l7.146 7.147-0.707 0.707-7.853-7.854 7.854-7.853 0.707 0.707-7.147 7.146z' /></svg>",
2152  shorthandCurrentMonth: false,
2153  showMonths: 1,
2154  static: false,
2155  time_24hr: false,
2156  weekNumbers: false,
2157  wrap: false
2158};
2159var english = {
2160  weekdays: {
2161    shorthand: ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"],
2162    longhand: [
2163      "Sunday",
2164      "Monday",
2165      "Tuesday",
2166      "Wednesday",
2167      "Thursday",
2168      "Friday",
2169      "Saturday"
2170    ]
2171  },
2172  months: {
2173    shorthand: [
2174      "Jan",
2175      "Feb",
2176      "Mar",
2177      "Apr",
2178      "May",
2179      "Jun",
2180      "Jul",
2181      "Aug",
2182      "Sep",
2183      "Oct",
2184      "Nov",
2185      "Dec"
2186    ],
2187    longhand: [
2188      "January",
2189      "February",
2190      "March",
2191      "April",
2192      "May",
2193      "June",
2194      "July",
2195      "August",
2196      "September",
2197      "October",
2198      "November",
2199      "December"
2200    ]
2201  },
2202  daysInMonth: [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31],
2203  firstDayOfWeek: 0,
2204  ordinal: function(nth) {
2205    var s = nth % 100;
2206    if (s > 3 && s < 21)
2207      return "th";
2208    switch (s % 10) {
2209      case 1:
2210        return "st";
2211      case 2:
2212        return "nd";
2213      case 3:
2214        return "rd";
2215      default:
2216        return "th";
2217    }
2218  },
2219  rangeSeparator: " to ",
2220  weekAbbreviation: "Wk",
2221  scrollTitle: "Scroll to increment",
2222  toggleTitle: "Click to toggle",
2223  amPM: ["AM", "PM"],
2224  yearAriaLabel: "Year",
2225  monthAriaLabel: "Month",
2226  hourAriaLabel: "Hour",
2227  minuteAriaLabel: "Minute",
2228  time_24hr: false
2229};
2230var pad = function(number, length) {
2231  if (length === void 0) {
2232    length = 2;
2233  }
2234  return ("000" + number).slice(length * -1);
2235};
2236var int = function(bool) {
2237  return bool === true ? 1 : 0;
2238};
2239function debounce(fn, wait) {
2240  var t;
2241  return function() {
2242    var _this = this;
2243    var args = arguments;
2244    clearTimeout(t);
2245    t = setTimeout(function() {
2246      return fn.apply(_this, args);
2247    }, wait);
2248  };
2249}
2250var arrayify = function(obj) {
2251  return obj instanceof Array ? obj : [obj];
2252};
2253function toggleClass(elem, className, bool) {
2254  if (bool === true)
2255    return elem.classList.add(className);
2256  elem.classList.remove(className);
2257}
2258function createElement(tag, className, content) {
2259  var e = window.document.createElement(tag);
2260  className = className || "";
2261  content = content || "";
2262  e.className = className;
2263  if (content !== void 0)
2264    e.textContent = content;
2265  return e;
2266}
2267function clearNode(node) {
2268  while (node.firstChild)
2269    node.removeChild(node.firstChild);
2270}
2271function findParent(node, condition) {
2272  if (condition(node))
2273    return node;
2274  else if (node.parentNode)
2275    return findParent(node.parentNode, condition);
2276  return void 0;
2277}
2278function createNumberInput(inputClassName, opts) {
2279  var wrapper = createElement("div", "numInputWrapper"), numInput = createElement("input", "numInput " + inputClassName), arrowUp = createElement("span", "arrowUp"), arrowDown = createElement("span", "arrowDown");
2280  if (navigator.userAgent.indexOf("MSIE 9.0") === -1) {
2281    numInput.type = "number";
2282  } else {
2283    numInput.type = "text";
2284    numInput.pattern = "\\d*";
2285  }
2286  if (opts !== void 0)
2287    for (var key in opts)
2288      numInput.setAttribute(key, opts[key]);
2289  wrapper.appendChild(numInput);
2290  wrapper.appendChild(arrowUp);
2291  wrapper.appendChild(arrowDown);
2292  return wrapper;
2293}
2294function getEventTarget(event) {
2295  try {
2296    if (typeof event.composedPath === "function") {
2297      var path = event.composedPath();
2298      return path[0];
2299    }
2300    return event.target;
2301  } catch (error) {
2302    return event.target;
2303  }
2304}
2305var doNothing = function() {
2306  return void 0;
2307};
2308var monthToStr = function(monthNumber, shorthand, locale) {
2309  return locale.months[shorthand ? "shorthand" : "longhand"][monthNumber];
2310};
2311var revFormat = {
2312  D: doNothing,
2313  F: function(dateObj, monthName, locale) {
2314    dateObj.setMonth(locale.months.longhand.indexOf(monthName));
2315  },
2316  G: function(dateObj, hour) {
2317    dateObj.setHours((dateObj.getHours() >= 12 ? 12 : 0) + parseFloat(hour));
2318  },
2319  H: function(dateObj, hour) {
2320    dateObj.setHours(parseFloat(hour));
2321  },
2322  J: function(dateObj, day) {
2323    dateObj.setDate(parseFloat(day));
2324  },
2325  K: function(dateObj, amPM, locale) {
2326    dateObj.setHours(dateObj.getHours() % 12 + 12 * int(new RegExp(locale.amPM[1], "i").test(amPM)));
2327  },
2328  M: function(dateObj, shortMonth, locale) {
2329    dateObj.setMonth(locale.months.shorthand.indexOf(shortMonth));
2330  },
2331  S: function(dateObj, seconds) {
2332    dateObj.setSeconds(parseFloat(seconds));
2333  },
2334  U: function(_2, unixSeconds) {
2335    return new Date(parseFloat(unixSeconds) * 1e3);
2336  },
2337  W: function(dateObj, weekNum, locale) {
2338    var weekNumber = parseInt(weekNum);
2339    var date = new Date(dateObj.getFullYear(), 0, 2 + (weekNumber - 1) * 7, 0, 0, 0, 0);
2340    date.setDate(date.getDate() - date.getDay() + locale.firstDayOfWeek);
2341    return date;
2342  },
2343  Y: function(dateObj, year) {
2344    dateObj.setFullYear(parseFloat(year));
2345  },
2346  Z: function(_2, ISODate) {
2347    return new Date(ISODate);
2348  },
2349  d: function(dateObj, day) {
2350    dateObj.setDate(parseFloat(day));
2351  },
2352  h: function(dateObj, hour) {
2353    dateObj.setHours((dateObj.getHours() >= 12 ? 12 : 0) + parseFloat(hour));
2354  },
2355  i: function(dateObj, minutes) {
2356    dateObj.setMinutes(parseFloat(minutes));
2357  },
2358  j: function(dateObj, day) {
2359    dateObj.setDate(parseFloat(day));
2360  },
2361  l: doNothing,
2362  m: function(dateObj, month) {
2363    dateObj.setMonth(parseFloat(month) - 1);
2364  },
2365  n: function(dateObj, month) {
2366    dateObj.setMonth(parseFloat(month) - 1);
2367  },
2368  s: function(dateObj, seconds) {
2369    dateObj.setSeconds(parseFloat(seconds));
2370  },
2371  u: function(_2, unixMillSeconds) {
2372    return new Date(parseFloat(unixMillSeconds));
2373  },
2374  w: doNothing,
2375  y: function(dateObj, year) {
2376    dateObj.setFullYear(2e3 + parseFloat(year));
2377  }
2378};
2379var tokenRegex = {
2380  D: "",
2381  F: "",
2382  G: "(\\d\\d|\\d)",
2383  H: "(\\d\\d|\\d)",
2384  J: "(\\d\\d|\\d)\\w+",
2385  K: "",
2386  M: "",
2387  S: "(\\d\\d|\\d)",
2388  U: "(.+)",
2389  W: "(\\d\\d|\\d)",
2390  Y: "(\\d{4})",
2391  Z: "(.+)",
2392  d: "(\\d\\d|\\d)",
2393  h: "(\\d\\d|\\d)",
2394  i: "(\\d\\d|\\d)",
2395  j: "(\\d\\d|\\d)",
2396  l: "",
2397  m: "(\\d\\d|\\d)",
2398  n: "(\\d\\d|\\d)",
2399  s: "(\\d\\d|\\d)",
2400  u: "(.+)",
2401  w: "(\\d\\d|\\d)",
2402  y: "(\\d{2})"
2403};
2404var formats = {
2405  Z: function(date) {
2406    return date.toISOString();
2407  },
2408  D: function(date, locale, options) {
2409    return locale.weekdays.shorthand[formats.w(date, locale, options)];
2410  },
2411  F: function(date, locale, options) {
2412    return monthToStr(formats.n(date, locale, options) - 1, false, locale);
2413  },
2414  G: function(date, locale, options) {
2415    return pad(formats.h(date, locale, options));
2416  },
2417  H: function(date) {
2418    return pad(date.getHours());
2419  },
2420  J: function(date, locale) {
2421    return locale.ordinal !== void 0 ? date.getDate() + locale.ordinal(date.getDate()) : date.getDate();
2422  },
2423  K: function(date, locale) {
2424    return locale.amPM[int(date.getHours() > 11)];
2425  },
2426  M: function(date, locale) {
2427    return monthToStr(date.getMonth(), true, locale);
2428  },
2429  S: function(date) {
2430    return pad(date.getSeconds());
2431  },
2432  U: function(date) {
2433    return date.getTime() / 1e3;
2434  },
2435  W: function(date, _2, options) {
2436    return options.getWeek(date);
2437  },
2438  Y: function(date) {
2439    return pad(date.getFullYear(), 4);
2440  },
2441  d: function(date) {
2442    return pad(date.getDate());
2443  },
2444  h: function(date) {
2445    return date.getHours() % 12 ? date.getHours() % 12 : 12;
2446  },
2447  i: function(date) {
2448    return pad(date.getMinutes());
2449  },
2450  j: function(date) {
2451    return date.getDate();
2452  },
2453  l: function(date, locale) {
2454    return locale.weekdays.longhand[date.getDay()];
2455  },
2456  m: function(date) {
2457    return pad(date.getMonth() + 1);
2458  },
2459  n: function(date) {
2460    return date.getMonth() + 1;
2461  },
2462  s: function(date) {
2463    return date.getSeconds();
2464  },
2465  u: function(date) {
2466    return date.getTime();
2467  },
2468  w: function(date) {
2469    return date.getDay();
2470  },
2471  y: function(date) {
2472    return String(date.getFullYear()).substring(2);
2473  }
2474};
2475var createDateFormatter = function(_a) {
2476  var _b = _a.config, config = _b === void 0 ? defaults : _b, _c = _a.l10n, l10n = _c === void 0 ? english : _

2476c, _d = _a.isMobile, isMobile = _d === void 0 ? false : _d;
2477  return function(dateObj, frmt, overrideLocale) {
2478    var locale = overrideLocale || l10n;
2479    if (config.formatDate !== void 0 && !isMobile) {
2480      return config.formatDate(dateObj, frmt, locale);
2481    }
2482    return frmt.split("").map(function(c, i, arr) {
2483      return formats[c] && arr[i - 1] !== "\\" ? formats[c](dateObj, locale, config) : c !== "\\" ? c : "";
2484    }).join("");
2485  };
2486};
2487var createDateParser = function(_a) {
2488  var _b = _a.config, config = _b === void 0 ? defaults : _b, _c = _a.l10n, l10n = _c === void 0 ? english : _c;
2489  return function(date, givenFormat, timeless, customLocale) {
2490    if (date !== 0 && !date)
2491      return void 0;
2492    var locale = customLocale || l10n;
2493    var parsedDate;
2494    var dateOrig = date;
2495    if (date instanceof Date)
2496      parsedDate = new Date(date.getTime());
2497    else if (typeof date !== "string" && date.toFixed !== void 0)
2498      parsedDate = new Date(date);
2499    else if (typeof date === "string") {
2500      var format = givenFormat || (config || defaults).dateFormat;
2501      var datestr = String(date).trim();
2502      if (datestr === "today") {
2503        parsedDate = /* @__PURE__ */ new Date();
2504        timeless = true;
2505      } else if (config && config.parseDate) {
2506        parsedDate = config.parseDate(date, format);
2507      } else if (/Z$/.test(datestr) || /GMT$/.test(datestr)) {
2508        parsedDate = new Date(date);
2509      } else {
2510        var matched = void 0, ops = [];
2511        for (var i = 0, matchIndex = 0, regexStr = ""; i < format.length; i++) {
2512          var token = format[i];
2513          var isBackSlash = token === "\\";
2514          var escaped = format[i - 1] === "\\" || isBackSlash;
2515          if (tokenRegex[token] && !escaped) {
2516            regexStr += tokenRegex[token];
2517            var match = new RegExp(regexStr).exec(date);
2518            if (match && (matched = true)) {
2519              ops[token !== "Y" ? "push" : "unshift"]({
2520                fn: revFormat[token],
2521                val: match[++matchIndex]
2522              });
2523            }
2524          } else if (!isBackSlash)
2525            regexStr += ".";
2526        }
2527        parsedDate = !config || !config.noCalendar ? new Date((/* @__PURE__ */ new Date()).getFullYear(), 0, 1, 0, 0, 0, 0) : new Date((/* @__PURE__ */ new Date()).setHours(0, 0, 0, 0));
2528        ops.forEach(function(_a2) {
2529          var fn = _a2.fn, val = _a2.val;
2530          return parsedDate = fn(parsedDate, val, locale) || parsedDate;
2531        });
2532        parsedDate = matched ? parsedDate : void 0;
2533      }
2534    }
2535    if (!(parsedDate instanceof Date && !isNaN(parsedDate.getTime()))) {
2536      config.errorHandler(new Error("Invalid date provided: " + dateOrig));
2537      return void 0;
2538    }
2539    if (timeless === true)
2540      parsedDate.setHours(0, 0, 0, 0);
2541    return parsedDate;
2542  };
2543};
2544function compareDates(date1, date2, timeless) {
2545  if (timeless === void 0) {
2546    timeless = true;
2547  }
2548  if (timeless !== false) {
2549    return new Date(date1.getTime()).setHours(0, 0, 0, 0) - new Date(date2.getTime()).setHours(0, 0, 0, 0);
2550  }
2551  return date1.getTime() - date2.getTime();
2552}
2553var isBetween = function(ts, ts1, ts2) {
2554  return ts > Math.min(ts1, ts2) && ts < Math.max(ts1, ts2);
2555};
2556var calculateSecondsSinceMidnight = function(hours, minutes, seconds) {
2557  return hours * 3600 + minutes * 60 + seconds;
2558};
2559var parseSeconds = function(secondsSinceMidnight) {
2560  var hours = Math.floor(secondsSinceMidnight / 3600), minutes = (secondsSinceMidnight - hours * 3600) / 60;
2561  return [hours, minutes, secondsSinceMidnight - hours * 3600 - minutes * 60];
2562};
2563var duration = {
2564  DAY: 864e5
2565};
2566function getDefaultHours(config) {
2567  var hours = config.defaultHour;
2568  var minutes = config.defaultMinute;
2569  var seconds = config.defaultSeconds;
2570  if (config.minDate !== void 0) {
2571    var minHour = config.minDate.getHours();
2572    var minMinutes = config.minDate.getMinutes();
2573    var minSeconds = config.minDate.getSeconds();
2574    if (hours < minHour) {
2575      hours = minHour;
2576    }
2577    if (hours === minHour && minutes < minMinutes) {
2578      minutes = minMinutes;
2579    }
2580    if (hours === minHour && minutes === minMinutes && seconds < minSeconds)
2581      seconds = config.minDate.getSeconds();
2582  }
2583  if (config.maxDate !== void 0) {
2584    var maxHr = config.maxDate.getHours();
2585    var maxMinutes = config.maxDate.getMinutes();
2586    hours = Math.min(hours, maxHr);
2587    if (hours === maxHr)
2588      minutes = Math.min(maxMinutes, minutes);
2589    if (hours === maxHr && minutes === maxMinutes)
2590      seconds = config.maxDate.getSeconds();
2591  }
2592  return { hours, minutes, seconds };
2593}
2594if (typeof Object.assign !== "function") {
2595  Object.assign = function(target) {
2596    var args = [];
2597    for (var _i = 1; _i < arguments.length; _i++) {
2598      args[_i - 1] = arguments[_i];
2599    }
2600    if (!target) {
2601      throw TypeError("Cannot convert undefined or null to object");
2602    }
2603    var _loop_1 = function(source2) {
2604      if (source2) {
2605        Object.keys(source2).forEach(function(key) {
2606          return target[key] = source2[key];
2607        });
2608      }
2609    };
2610    for (var _a = 0, args_1 = args; _a < args_1.length; _a++) {
2611      var source = args_1[_a];
2612      _loop_1(source);
2613    }
2614    return target;
2615  };
2616}
2617var __assign = function() {
2618  __assign = Object.assign || function(t) {
2619    for (var s, i = 1, n = arguments.length; i < n; i++) {
2620      s = arguments[i];
2621      for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
2622        t[p] = s[p];
2623    }
2624    return t;
2625  };
2626  return __assign.apply(this, arguments);
2627};

2628var __spreadArrays = function() {
2629  for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
2630  for (var r = Array(s), k = 0, i = 0; i < il; i++)
2631    for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
2632      r[k] = a[j];
2633  return r;
2634};
2635var DEBOUNCED_CHANGE_MS = 300;
2636function FlatpickrInstance(element, instanceConfig) {
2637  var self = {
2638    config: __assign(__assign({}, defaults), flatpickr.defaultConfig),
2639    l10n: english
2640  };
2641  self.parseDate = createDateParser({ config: self.config, l10n: self.l10n });
2642  self._handlers = [];
2643  self.pluginElements = [];
2644  self.loadedPlugins = [];
2645  self._bind = bind;
2646  self._setHoursFromDate = setHoursFromDate;
2647  self._positionCalendar = positionCalendar;
2648  self.changeMonth = changeMonth;
2649  self.changeYear = changeYear;
2650  self.clear = clear;
2651  self.close = close;
2652  self.onMouseOver = onMouseOver;
2653  self._createElement = createElement;
2654  self.createDay = createDay;
2655  self.destroy = destroy;
2656  self.isEnabled = isEnabled;
2657  self.jumpToDate = jumpToDate;
2658  self.updateValue = updateValue;
2659  self.open = open;
2660  self.redraw = redraw;
2661  self.set = set;
2662  self.setDate = setDate;
2663  self.toggle = toggle;
2664  function setupHelperFunctions() {
2665    self.utils = {
2666      getDaysInMonth: function(month, yr) {
2667        if (month === void 0) {
2668          month = self.currentMonth;
2669        }
2670        if (yr === void 0) {
2671          yr = self.currentYear;
2672        }
2673        if (month === 1 && (yr % 4 === 0 && yr % 100 !== 0 || yr % 400 === 0))
2674          return 29;
2675        return self.l10n.daysInMonth[month];
2676      }
2677    };
2678  }
2679  function init() {
2680    self.element = self.input = element;
2681    self.isOpen = false;
2682    parseConfig();
2683    setupLocale();
2684    setupInputs();
2685    setupDates();
2686    setupHelperFunctions();
2687    if (!self.isMobile)
2688      build2();
2689    bindEvents();
2690    if (self.selectedDates.length || self.config.noCalendar) {
2691      if (self.config.enableTime) {
2692        setHoursFromDate(self.config.noCalendar ? self.latestSelectedDateObj : void 0);
2693      }
2694      updateValue(false);
2695    }
2696    setCalendarWidth();
2697    var isSafari = /^((?!chrome|android).)*safari/i.test(navigator.userAgent);
2698    if (!self.isMobile && isSafari) {
2699      positionCalendar();
2700    }
2701    triggerEvent("onReady");
2702  }
2703  function getClosestActiveElement() {
2704    var _a;
2705    return ((_a = self.calendarContainer) === null || _a === void 0 ? void 0 : _a.getRootNode()).activeElement || document.activeElement;
2706  }
2707  function bindToInstance(fn) {
2708    return fn.bind(self);
2709  }
2710  function setCalendarWidth() {
2711    var config = self.config;
2712    if (config.weekNumbers === false && config.showMonths === 1) {
2713      return;
2714    } else if (config.noCalendar !== true) {
2715      window.requestAnimationFrame(function() {
2716        if (self.calendarContainer !== void 0) {
2717          self.calendarContainer.style.visibility = "hidden";
2718          self.calendarContainer.style.display = "block";
2719        }
2720        if (self.daysContainer !== void 0) {
2721          var daysWidth = (self.days.offsetWidth + 1) * config.showMonths;
2722          self.daysContainer.style.width = daysWidth + "px";
2723          self.calendarContainer.style.width = daysWidth + (self.weekWrapper !== void 0 ? self.weekWrapper.offsetWidth : 0) + "px";
2724          self.calendarContainer.style.removeProperty("visibility");
2725          self.calendarContainer.style.removeProperty("display");
2726        }
2727      });
2728    }
2729  }
2730  function updateTime(e) {
2731    if (self.selectedDates.length === 0) {
2732      var defaultDate = self.config.minDate === void 0 || compareDates(/* @__PURE__ */ new Date(), self.config.minDate) >= 0 ? /* @__PURE__ */ new Date() : new Date(self.config.minDate.getTime());
2733      var defaults2 = getDefaultHours(self.config);
2734      defaultDate.setHours(defaults2.hours, defaults2.minutes, defaults2.seconds, defaultDate.getMilliseconds());
2735      self.selectedDates = [defaultDate];
2736      self.latestSelectedDateObj = defaultDate;
2737    }
2738    if (e !== void 0 && e.type !== "blur") {
2739      timeWrapper(e);
2740    }
2741    var prevValue = self._input.value;
2742    setHoursFromInputs();