https://www.ren.pt/js/dist/critical.js

1import { c as getCssVars } from "./app.f9c60ec2.js";
2import { a as getEls } from "./app.44854383.js";
3function checkImgCache$1(url, el = false, newClass = false) {
4 let image = new Image();
5 image.src = url;
6 if (image.complete && newClass) {
7  el.classList.add(newClass);
8 }
9 return image.complete;
10}
11function changeUrl(type, el, srcSetUrl = false) {
12 if (type == "bg") {
13  const url = el.getAttribute("data-bg");
14  el.style.backgroundImage = "url(" + url + ")";
15  el.classList.remove("lazyload");
16 }
17 if (type == "src") {
18  const url = el.getAttribute("data-src");
19  el.setAttribute("src", url);
20  el.classList.remove("lazyload");
21 }
22 if (type == "srcset") {
23  el.setAttribute("src", srcSetUrl);
24  el.classList.remove("lazyload");
25 }
26}
27function getSrcSet(srcSet) {
28 if (!srcSet) {
29  return false;
30 }
31 const srcSetList = [];
32 const viewportWidth = window.innerWidth;
33 srcSet.split(",").filter((value, index) => {
34  value = value.trim().split(" ");
35  value[1] = parseInt(value[1]);
36  srcSetList.push(value);
37 });
38 let bestImage = srcSetList.find((srcSet2) => srcSet2[1] >= viewportWidth);
39 if (!bestImage) {
40  bestImage = srcSetList[srcSetList.length - 1];
41 }
42 return bestImage[0];
43}
44getEls(".lazyload").forEach((el) => {
45 const bg = el.getAttribute("data-bg");
46 const src = el.getAttribute("data-src");
47 let srcSet = getSrcSet(el.getAttribute("data-srcset"));
48 if (bg && checkImgCache$1(bg, el, "is-cached")) {
49  changeUrl("bg", el);
50 }
51 if (src && checkImgCache$1(src, el, "is-cached")) {
52  changeUrl("src", el);
53 }
54 if (srcSet && checkImgCache$1(srcSet, el, "is-cached")) {
55  changeUrl("srcset", el, srcSet);
56 }
57 window.addEventListener("resize", (e) => {
58  srcSet = getSrcSet(el.getAttribute("data-srcset"));
59  if (srcSet && checkImgCache$1(srcSet, el, "is-cached")) {
60   changeUrl("srcset", el, srcSet);
61  }
62 });
63});
64var lazysizes = { exports: {} };
65(function (module) {
66 (function (window2, factory) {
67  var lazySizes = factory(window2, window2.document, Date);
68  window2.lazySizes = lazySizes;
69  if (module.exports) {
70   module.exports = lazySizes;
71  }
72 })(
73  typeof window != "undefined" ? window : {},
74  function l(window2, document2, Date2) {
75   var lazysizes2, lazySizesCfg;
76   (function () {
77    var prop;
78    var lazySizesDefaults = {
79     lazyClass: "lazyload",
80     loadedClass: "lazyloaded",
81     loadingClass: "lazyloading",
82     preloadClass: "lazypreload",
83     errorClass: "lazyerror",
84     autosizesClass: "lazyautosizes",
85     fastLoadedClass: "ls-is-cached",
86     iframeLoadMode: 0,
87     srcAttr: "data-src",
88     srcsetAttr: "data-srcset",
89     sizesAttr: "data-sizes",
90     minSize: 40,
91     customMedia: {},
92     init: true,
93     expFactor: 1.5,
94     hFac: 0.8,
95     loadMode: 2,
96     loadHidden: true,
97     ricTimeout: 0,
98     throttleDelay: 125
99    };
100    lazySizesCfg = window2.lazySizesConfig || window2.lazysizesConfig || {};
101    for (prop in lazySizesDefaults) {
102     if (!(prop in lazySizesCfg)) {
103      lazySizesCfg[prop] = lazySizesDefaults[prop];
104     }
105    }
106   })();
107   if (!document2 || !document2.getElementsByClassName) {
108    return {
109     init: function () {
110     },
111     cfg: lazySizesCfg,
112     noSupport: true
113    };
114   }
115   var docElem = document2.documentElement;
116   var supportPicture = window2.HTMLPictureElement;
117   var _addEventListener = "addEventListener";
118   var _getAttribute = "getAttribute";
119   var addEventListener = window2[_addEventListener].bind(window2);
120   var setTimeout = window2.setTimeout;
121   var requestAnimationFrame = window2.requestAnimationFrame || setTimeout;
122   var requestIdleCallback = window2.requestIdleCallback;
123   var regPicture = /^picture$/i;
124   var loadEvents = ["load", "error", "lazyincluded", "_lazyloaded"];
125   var regClassCache = {};
126   var forEach = Array.prototype.forEach;
127   var hasClass = function (ele, cls) {
128    if (!regClassCache[cls]) {
129     regClassCache[cls] = new RegExp("(\\s|^)" + cls + "(\\s|$)");
130    }
131    return regClassCache[cls].test(ele[_getAttribute]("class") || "") && regClassCache[cls];
132   };
133   var addClass = function (ele, cls) {
134    if (!hasClass(ele, cls)) {
135     ele.setAttribute("class", (ele[_getAttribute]("class") || "").trim() + " " + cls);
136    }
137   };
138   var removeClass = function (ele, cls) {
139    var reg;
140    if (reg = hasClass(ele, cls)) {
141     ele.setAttribute("class", (ele[_getAttribute]("class") || "").replace(reg, " "));

142    }
143   };
144   var addRemoveLoadEvents = function (dom, fn, add) {
145    var action = add ? _addEventListener : "removeEventListener";
146    if (add) {
147     addRemoveLoadEvents(dom, fn);
148    }
149    loadEvents.forEach(function (evt) {
150     dom[action](evt, fn);
151    });
152   };
153   var triggerEvent = function (elem, name, detail, noBubbles, noCancelable) {
154    var event = document2.createEvent("Event");
155    if (!detail) {
156     detail = {};
157    }
158    detail.instance = lazysizes2;
159    event.initEvent(name, !noBubbles, !noCancelable);
160    event.detail = detail;
161    elem.dispatchEvent(event);
162    return event;
163   };
164   var updatePolyfill = function (el, full) {
165    var polyfill;
166    if (!supportPicture && (polyfill = window2.picturefill || lazySizesCfg.pf)) {
167     if (full && full.src && !el[_getAttribute]("srcset")) {
168      el.setAttribute("srcset", full.src);
169     }
170     polyfill({ reevaluate: true, elements: [el] });
171    } else if (full && full.src) {
172     el.src = full.src;
173    }
174   };
175   var getCSS = function (elem, style) {
176    return (getComputedStyle(elem, null) || {})[style];
177   };
178   var getWidth = function (elem, parent, width) {
179    width = width || elem.offsetWidth;
180    while (width < lazySizesCfg.minSize && parent && !elem._lazysizesWidth) {
181     width = parent.offsetWidth;
182     parent = parent.parentNode;
183    }
184    return width;
185   };
186   var rAF = function () {
187    var running, waiting;
188    var firstFns = [];
189    var secondFns = [];
190    var fns = firstFns;
191    var run = function () {
192     var runFns = fns;
193     fns = firstFns.length ? secondFns : firstFns;
194     running = true;
195     waiting = false;
196     while (runFns.length) {
197      runFns.shift()();
198     }
199     running = false;
200    };
201    var rafBatch = function (fn, queue) {
202     if (running && !queue) {
203      fn.apply(this, arguments);
204     } else {
205      fns.push(fn);
206      if (!waiting) {
207       waiting = true;
208       (document2.hidden ? setTimeout : requestAnimationFrame)(run);
209      }
210     }
211    };
212    rafBatch._lsFlush = run;
213    return rafBatch;
214   }();
215   var rAFIt = function (fn, simple) {
216    return simple ? function () {
217     rAF(fn);
218    } : function () {
219     var that = this;
220     var args = arguments;
221     rAF(function () {
222      fn.apply(that, args);
223     });
224    };
225   };
226   var throttle = function (fn) {
227    var running;
228    var lastTime = 0;
229    var gDelay = lazySizesCfg.throttleDelay;
230    var rICTimeout = lazySizesCfg.ricTimeout;
231    var run = function () {
232     running = false;
233     lastTime = Date2.now();
234     fn();
235    };
236    var idleCallback = requestIdleCallback && rICTimeout > 49 ? function () {
237     requestIdleCallback(run, { timeout: rICTimeout });
238     if (rICTimeout !== lazySizesCfg.ricTimeout) {
239      rICTimeout = lazySizesCfg.ricTimeout;
240     }
241    } : rAFIt(function () {
242     setTimeout(run);
243    }, true);
244    return function (isPriority) {
245     var delay;
246     if (isPriority = isPriority === true) {
247      rICTimeout = 33;
248     }
249     if (running) {
250      return;
251     }
252     running = true;
253     delay = gDelay - (Date2.now() - lastTime);
254     if (delay < 0) {
255      delay = 0;
256     }
257     if (isPriority || delay < 9) {
258      idleCallback();
259     } else {
260      setTimeout(idleCallback, delay);
261     }
262    };
263   };
264   var debounce = function (func) {
265    var timeout, timestamp;
266    var wait = 99;
267    var run = function () {
268     timeout = null;
269     func();
270    };
271    var later = function () {
272     var last = Date2.now() - timestamp;
273     if (last < wait) {
274      setTimeout(later, wait - last);
275     } else {
276      (requestIdleCallback || run)(run);
277     }
278    };
279    return function () {
280     timestamp = Date2.now();
281     if (!timeout) {
282      timeout = setTimeout(later, wait);
283     }
284    };
285   };
286   var loader = function () {
287    var preloadElems, isCompleted, resetPreloadingTimer, loadMode, started;
288    var eLvW, elvH, eLtop, eLleft, eLright, eLbottom, isBodyHidden;
289    var regImg = /^img$/i;
290    var regIframe = /^iframe$/i;
291    var supportScroll = "onscroll" in window2 && !/(gle|ing)bot/.test(navigator.userAgent);
292    var shrinkExpand = 0;
293    var currentExpand = 0;
294    var isLoading = 0;
295    var lowRuns = -1;
296    var resetPreloading = function (e) {
297     isLoading--;
298     if (!e || isLoading < 0 || !e.target) {
299      isLoading = 0;
300     }
301    };
302    var isVisible = function (elem) {
303     if (isBodyHidden == null) {
304      isBodyHidden = getCSS(document2.body, "visibility") == "hidden";
305     }
306     return isBodyHidden || !(getCSS(elem.parentNode, "visibility") == "hidden" && getCSS(elem, "visibility") == "hidden");
307    };
308    var isNestedVisible = function (elem, elemExpand) {
309     var outerRect;
310     var parent = elem;
311     var visible = isVisible(elem);
312     eLtop -= elemExpand;
313     eLbottom += elemExpand;
314     eLleft -= elemExpand;
315     eLright += elemExpand;
316     while (visible && (parent = parent.offsetParent) && parent != document2.body && parent != docElem) {
317      visible = (getCSS(parent, "opacity") || 1) > 0;
318      if (visible && getCSS(parent, "overflow") != "visible") {
319       outerRect = parent.getBoundingClientRect();
320       visible = eLright > outerRect.left && eLleft < outerRect.right && eLbottom > outerRect.top - 1 && eLtop < outerRect.bottom + 1;
321      }
322     }
323     return visible;
324    };
325    var checkElements = function () {
326     var eLlen, i, rect, autoLoadElem, loadedSomething, elemExpand, elemNegativeExpand, elemExpandVal, beforeE

326xpandVal, defaultExpand, preloadExpand, hFac;
327     var lazyloadElems = lazysizes2.elements;
328     if ((loadMode = lazySizesCfg.loadMode) && isLoading < 8 && (eLlen = lazyloadElems.length)) {
329      i = 0;
330      lowRuns++;
331      for (; i < eLlen; i++) {
332       if (!lazyloadElems[i] || lazyloadElems[i]._lazyRace) {
333        continue;
334       }
335       if (!supportScroll || lazysizes2.prematureUnveil && lazysizes2.prematureUnveil(lazyloadElems[i])) {
336        unveilElement(lazyloadElems[i]);
337        continue;
338       }
339       if (!(elemExpandVal = lazyloadElems[i][_getAttribute]("data-expand")) || !(elemExpand = elemExpandVal * 1)) {
340        elemExpand = currentExpand;
341       }
342       if (!defaultExpand) {
343        defaultExpand = !lazySizesCfg.expand || lazySizesCfg.expand < 1 ? docElem.clientHeight > 500 && docElem.clientWidth > 500 ? 500 : 370 : lazySizesCfg.expand;
344        lazysizes2._defEx = defaultExpand;
345        preloadExpand = defaultExpand * lazySizesCfg.expFactor;
346        hFac = lazySizesCfg.hFac;
347        isBodyHidden = null;
348        if (currentExpand < preloadExpand && isLoading < 1 && lowRuns > 2 && loadMode > 2 && !document2.hidden) {
349         currentExpand = preloadExpand;
350         lowRuns = 0;
351        } else if (loadMode > 1 && lowRuns > 1 && isLoading < 6) {
352         currentExpand = defaultExpand;
353        } else {
354         currentExpand = shrinkExpand;
355        }
356       }
357       if (beforeExpandVal !== elemExpand) {
358        eLvW = innerWidth + elemExpand * hFac;
359        elvH = innerHeight + elemExpand;
360        elemNegativeExpand = elemExpand * -1;
361        beforeExpandVal = elemExpand;
362       }
363       rect = lazyloadElems[i].getBoundingClientRect();
364       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))) {
365        unveilElement(lazyloadElems[i]);
366        loadedSomething = true;
367        if (isLoading > 9) {
368         break;
369        }
370       } 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"))) {
371        autoLoadElem = preloadElems[0] || lazyloadElems[i];
372       }
373      }
374      if (autoLoadElem && !loadedSomething) {
375       unveilElement(autoLoadElem);
376      }
377     }
378    };
379    var throttledCheckElements = throttle(checkElements);
380    var switchLoadingClass = function (e) {
381     var elem = e.target;
382     if (elem._lazyCache) {
383      delete elem._lazyCache;
384      return;
385     }
386     resetPreloading(e);
387     addClass(elem, lazySizesCfg.loadedClass);
388     removeClass(elem, lazySizesCfg.loadingClass);
389     addRemoveLoadEvents(elem, rafSwitchLoadingClass);
390     triggerEvent(elem, "lazyloaded");
391    };
392    var rafedSwitchLoadingClass = rAFIt(switchLoadingClass);
393    var rafSwitchLoadingClass = function (e) {
394     rafedSwitchLoadingClass({ target: e.target });
395    };
396    var changeIframeSrc = function (elem, src) {
397     var loadMode2 = elem.getAttribute("data-load-mode") || lazySizesCfg.iframeLoadMode;
398     if (loadMode2 == 0) {
399      elem.contentWindow.location.replace(src);
400     } else if (loadMode2 == 1) {
401      elem.src = src;
402     }
403    };
404    var handleSources = function (source) {
405     var customMedia;
406     var sourceSrcset = source[_getAttribute](lazySizesCfg.srcsetAttr);
407     if (customMedia = lazySizesCfg.customMedia[source[_getAttribute]("data-media") || source[_getAttribute]("media")]) {
408      source.setAttribute("media", customMedia);
409     }
410     if (sourceSrcset) {
411      source.setAttribute("srcset", sourceSrcset);
412     }
413    };
414    var lazyUnveil = rAFIt(function (elem, detail, isAuto, sizes, isImg) {
415     var src, srcset, parent, isPicture, event, firesLoad;
416     if (!(event = triggerEvent(elem, "lazybeforeunveil", detail)).defaultPrevented) {
417      if (sizes) {
418       if (isAuto) {
419        addClass(elem, lazySizesCfg.autosizesClass);
420       } else {
421        elem.setAttribute("sizes", sizes);
422       }
423      }
424      srcset = elem[_getAttribute](lazySizesCfg.srcsetAttr);
425      src = elem[_getAttribute](lazySizesCfg.srcAttr);
426      if (isImg) {
427       parent = elem.parentNode;
428       isPicture = parent && regPicture.test(parent.nodeName || "");
429      }
430      firesLoad = detail.firesLoad || "src" in elem && (srcset || src || isPicture);
431      event = { target: elem };
432      addClass(elem, lazySizesCfg.loadingClass);
433      if (firesLoad) {
434       clearTimeout(resetPreloadingTimer);
435       resetPreloadingTimer = setTimeout(resetPreloading, 2500);
436       addRemoveLoadEvents(elem, rafSwitchLoadingClass, true);
437      }
438      if (isPicture) {

439       forEach.call(parent.getElementsByTagName("source"), handleSources);
440      }
441      if (srcset) {
442       elem.setAttribute("srcset", srcset);
443      } else if (src && !isPicture) {
444       if (regIframe.test(elem.nodeName)) {
445        changeIframeSrc(elem, src);
446       } else {
447        elem.src = src;
448       }
449      }
450      if (isImg && (srcset || isPicture)) {
451       updatePolyfill(elem, { src });
452      }
453     }
454     if (elem._lazyRace) {
455      delete elem._lazyRace;
456     }
457     removeClass(elem, lazySizesCfg.lazyClass);
458     rAF(function () {
459      var isLoaded = elem.complete && elem.naturalWidth > 1;
460      if (!firesLoad || isLoaded) {
461       if (isLoaded) {
462        addClass(elem, lazySizesCfg.fastLoadedClass);
463       }
464       switchLoadingClass(event);
465       elem._lazyCache = true;
466       setTimeout(function () {
467        if ("_lazyCache" in elem) {
468         delete elem._lazyCache;
469        }
470       }, 9);
471      }
472      if (elem.loading == "lazy") {
473       isLoading--;
474      }
475     }, true);
476    });
477    var unveilElement = function (elem) {
478     if (elem._lazyRace) {
479      return;
480     }
481     var detail;
482     var isImg = regImg.test(elem.nodeName);
483     var sizes = isImg && (elem[_getAttribute](lazySizesCfg.sizesAttr) || elem[_getAttribute]("sizes"));
484     var isAuto = sizes == "auto";
485     if ((isAuto || !isCompleted) && isImg && (elem[_getAttribute]("src") || elem.srcset) && !elem.complete && !hasClass(elem, lazySizesCfg.errorClass) && hasClass(elem, lazySizesCfg.lazyClass)) {
486      return;
487     }
488     detail = triggerEvent(elem, "lazyunveilread").detail;
489     if (isAuto) {
490      autoSizer.updateElem(elem, true, elem.offsetWidth);
491     }
492     elem._lazyRace = true;
493     isLoading++;
494     lazyUnveil(elem, detail, isAuto, sizes, isImg);
495    };
496    var afterScroll = debounce(function () {
497     lazySizesCfg.loadMode = 3;
498     throttledCheckElements();
499    });
500    var altLoadmodeScrollListner = function () {
501     if (lazySizesCfg.loadMode == 3) {
502      lazySizesCfg.loadMode = 2;
503     }
504     afterScroll();
505    };
506    var onload = function () {
507     if (isCompleted) {
508      return;
509     }
510     if (Date2.now() - started < 999) {
511      setTimeout(onload, 999);
512      return;
513     }
514     isCompleted = true;
515     lazySizesCfg.loadMode = 3;
516     throttledCheckElements();
517     addEventListener("scroll", altLoadmodeScrollListner, true);
518    };
519    return {
520     _: function () {
521      started = Date2.now();
522      lazysizes2.elements = document2.getElementsByClassName(lazySizesCfg.lazyClass);
523      preloadElems = document2.getElementsByClassName(lazySizesCfg.lazyClass + " " + lazySizesCfg.preloadClass);
524      addEventListener("scroll", throttledCheckElements, true);
525      addEventListener("resize", throttledCheckElements, true);
526      addEventListener("pageshow", function (e) {
527       if (e.persisted) {
528        var loadingElements = document2.querySelectorAll("." + lazySizesCfg.loadingClass);
529        if (loadingElements.length && loadingElements.forEach) {
530         requestAnimationFrame(function () {
531          loadingElements.forEach(function (img) {
532           if (img.complete) {
533            unveilElement(img);
534           }
535          });
536         });
537        }
538       }
539      });
540      if (window2.MutationObserver) {
541       new MutationObserver(throttledCheckElements).observe(docElem, { childList: true, subtree: true, attributes: true });
542      } else {
543       docElem[_addEventListener]("DOMNodeInserted", throttledCheckElements, true);
544       docElem[_addEventListener]("DOMAttrModified", throttledCheckElements, true);
545       setInterval(throttledCheckElements, 999);
546      }
547      addEventListener("hashchange", throttledCheckElements, true);
548      ["focus", "mouseover", "click", "load", "transitionend", "animationend"].forEach(function (name) {
549       document2[_addEventListener](name, throttledCheckElements, true);
550      });
551      if (/d$|^c/.test(document2.readyState)) {
552       onload();
553      } else {
554       addEventListener("load", onload);
555       document2[_addEventListener]("DOMContentLoaded", throttledCheckElements);
556       setTimeout(onload, 2e4);
557      }
558      if (lazysizes2.elements.length) {
559       checkElements();
560       rAF._lsFlush();

561      } else {
562       throttledCheckElements();
563      }
564     },
565     checkElems: throttledCheckElements,
566     unveil: unveilElement,
567     _aLSL: altLoadmodeScrollListner
568    };
569   }();
570   var autoSizer = function () {
571    var autosizesElems;
572    var sizeElement = rAFIt(function (elem, parent, event, width) {
573     var sources, i, len;
574     elem._lazysizesWidth = width;
575     width += "px";
576     elem.setAttribute("sizes", width);
577     if (regPicture.test(parent.nodeName || "")) {
578      sources = parent.getElementsByTagName("source");
579      for (i = 0, len = sources.length; i < len; i++) {
580       sources[i].setAttribute("sizes", width);
581      }
582     }
583     if (!event.detail.dataAttr) {
584      updatePolyfill(elem, event.detail);
585     }
586    });
587    var getSizeElement = function (elem, dataAttr, width) {
588     var event;
589     var parent = elem.parentNode;
590     if (parent) {
591      width = getWidth(elem, parent, width);
592      event = triggerEvent(elem, "lazybeforesizes", { width, dataAttr: !!dataAttr });
593      if (!event.defaultPrevented) {
594       width = event.detail.width;
595       if (width && width !== elem._lazysizesWidth) {
596        sizeElement(elem, parent, event, width);
597       }
598      }
599     }
600    };
601    var updateElementsSizes = function () {
602     var i;
603     var len = autosizesElems.length;
604     if (len) {
605      i = 0;
606      for (; i < len; i++) {
607       getSizeElement(autosizesElems[i]);
608      }
609     }
610    };
611    var debouncedUpdateElementsSizes = debounce(updateElementsSizes);
612    return {
613     _: function () {
614      autosizesElems = document2.getElementsByClassName(lazySizesCfg.autosizesClass);
615      addEventListener("resize", debouncedUpdateElementsSizes);
616     },
617     checkElems: debouncedUpdateElementsSizes,
618     updateElem: getSizeElement
619    };
620   }();
621   var init = function () {
622    if (!init.i && document2.getElementsByClassName) {
623     init.i = true;
624     autoSizer._();
625     loader._();
626    }
627   };
628   setTimeout(function () {
629    if (lazySizesCfg.init) {
630     init();
631    }
632   });
633   lazysizes2 = {
634    cfg: lazySizesCfg,
635    autoSizer,
636    loader,
637    init,
638    uP: updatePolyfill,
639    aC: addClass,
640    rC: removeClass,
641    hC: hasClass,
642    fire: triggerEvent,
643    gW: getWidth,
644    rAF
645   };
646   return lazysizes2;
647  }
648 );
649})(lazysizes);
650function checkImgCache(el, url, newClass = false) {
651 let image = new Image();
652 image.src = url;
653 if (image.complete && newClass) {
654  el.classList.add(newClass);
655 }
656 return image.complete;
657}
658function changeBgUrl(el) {
659 const url = el.getAttribute("data-bg");
660 el.style.backgroundImage = "url(" + url + ")";
661 el.classList.add("bg-lazyloaded");
662}
663function preloadImage(el, callback) {
664 const url = el.getAttribute("data-bg");
665 let img = new Image();
666 img.src = url;
667 img.addEventListener("load", () => {
668  callback(el);
669 });
670}
671document.addEventListener("lazybeforeunveil", function (e) {
672 const el = e.target;
673 const bg = el.getAttribute("data-bg");
674 if (bg) {
675  if (checkImgCache(el, bg, "bg-is-cached")) {
676   changeBgUrl(el);
677  } else {
678   preloadImage(el, changeBgUrl);
679  }
680 }
681});
682getCssVars();
683
684function applyPointerAddon(image) {
685    try {
686        const bg = getComputedStyle(image).backgroundImage;
687        const urlMatch = bg.match(/url\((['"]?)([^'"]*)\1\)/i);
688
689        if (!urlMatch || !urlMatch[2]) return;
690
691        const url = urlMatch[2].trim();
692
693        if (!url || url === 'none') return;
694
695        // Check if the URL is valid before trying to parse it
696        try {
697            // Use a regular expression to extract parameters instead of URL constructor
698            const rxyMatch = url.match(/[?&]rxy=([^&#]*)/);
699
700            if (rxyMatch && rxyMatch[1]) {
701                const rxy = decodeURIComponent(rxyMatch[1].replace(/\+/g, ' '));
702                const [x, y] = rxy.split(",").map(parseFloat);
703
704                if (!isNaN(x) && !isNaN(y) && x >= 0 && x <= 1 && y >= 0 && y <= 1) {
705                    image.style.backgroundPosition = `${x * 100}% ${y * 100}%`;
706                }
707            }
708        } catch { }
709    } catch { }
710}
711
712function runPointerFix() {
713    const possiblePointerBgImages = getEls('[style*="background-image: url"]');
714

715    possiblePointerBgImages.forEach((image) => {
716        try {
717            applyPointerAddon(image);
718        } catch { }
719    });
720}
721
722document.addEventListener("DOMContentLoaded", (e) => {
723 const executionTimes = [0, 500, 1000, 2000, 4000, 6000, 8000, 10000, 200000, 400000, 600000]
724
725 executionTimes.forEach((t) => {
726  setTimeout(() => {
727   runPointerFix()
728  }, t)
729 })
730
731
732 function fixComplexTables() {
733  const tables = document.querySelectorAll('.sheet__table')
734
735
736  for (const table of tables) {
737   const td_colspan = table.querySelectorAll('td[colspan]')
738   const td_rowspan = table.querySelectorAll('td[rowspan]')
739
740   if (!td_colspan.length || !td_rowspan.length) return
741
742   const lastTdColspan = td_colspan[td_colspan.length - 1]
743   const lastTdRowspan = td_rowspan[td_rowspan.length - 1]
744
745   lastTdColspan.classList.add('js-last-colspan')
746   lastTdRowspan.classList.add('js-last-rowspan')
747  }
748 }
749
750 fixComplexTables()
751
752});