app.js?ver=2.1.30.1790240259

js prometheus.org.ua collected 2026-09-24 08:58:08 UTC 229,515 bytes, 4,549 lines download raw bytes

1(() => {
2    "use strict";
3    const modules_flsModules = {};
4    let isMobile = {
5        Android: function() {
6            return navigator.userAgent.match(/Android/i);
7        },
8        BlackBerry: function() {
9            return navigator.userAgent.match(/BlackBerry/i);
10        },
11        iOS: function() {
12            return navigator.userAgent.match(/iPhone|iPad|iPod/i);
13        },
14        Opera: function() {
15            return navigator.userAgent.match(/Opera Mini/i);
16        },
17        Windows: function() {
18            return navigator.userAgent.match(/IEMobile/i);
19        },
20        any: function() {
21            return isMobile.Android() || isMobile.BlackBerry() || isMobile.iOS() || isMobile.Opera() || isMobile.Windows();
22        },
23        isScreenMobile: function() {
24            return window.innerWidth <= 767.99;
25        },
26        isMobileDevice: function() {
27            return isMobile.any() && isMobile.isScreenMobile();
28        }
29    };
30    let _slideUp = (target, duration = 500, showmore = 0) => {
31        if (!target.classList.contains("_slide")) {
32            target.classList.add("_slide");
33            target.style.transitionProperty = "height, margin, padding";
34            target.style.transitionDuration = duration + "ms";
35            target.style.height = `${target.offsetHeight}px`;
36            target.offsetHeight;
37            target.style.overflow = "hidden";
38            target.style.height = showmore ? `${showmore}px` : `0px`;
39            target.style.paddingTop = 0;
40            target.style.paddingBottom = 0;
41            target.style.marginTop = 0;
42            target.style.marginBottom = 0;
43            window.setTimeout((() => {
44                target.hidden = !showmore ? true : false;
45                !showmore ? target.style.removeProperty("height") : null;
46                target.style.removeProperty("padding-top");
47                target.style.removeProperty("padding-bottom");
48                target.style.removeProperty("margin-top");
49                target.style.removeProperty("margin-bottom");
50                !showmore ? target.style.removeProperty("overflow") : null;
51                target.style.removeProperty("transition-duration");
52                target.style.removeProperty("transition-property");
53                target.classList.remove("_slide");
54                document.dispatchEvent(new CustomEvent("slideUpDone", {
55                    detail: {
56                        target
57                    }
58                }));
59            }), duration);
60        }
61    };
62    let _slideDown = (target, duration = 500, showmore = 0) => {
63        if (!target.classList.contains("_slide")) {
64            target.classList.add("_slide");
65            target.hidden = target.hidden ? false : null;
66            showmore ? target.style.removeProperty("height") : null;
67            let height = target.offsetHeight;
68            target.style.overflow = "hidden";
69            target.style.height = showmore ? `${showmore}px` : `0px`;
70            target.style.paddingTop = 0;
71            target.style.paddingBottom = 0;
72            target.style.marginTop = 0;
73            target.style.marginBottom = 0;
74            target.offsetHeight;
75            target.style.transitionProperty = "height, margin, padding";
76            target.style.transitionDuration = duration + "ms";
77            target.style.height = height + "px";
78            target.style.removeProperty("padding-top");
79            target.style.removeProperty("padding-bottom");
80            target.style.removeProperty("margin-top");
81            target.style.removeProperty("margin-bottom");
82            window.setTimeout((() => {
83                target.style.removeProperty("height");
84                target.style.removeProperty("overflow");
85                target.style.removeProperty("transition-duration");
86                target.style.removeProperty("transition-property");
87                target.classList.remove("_slide");
88                document.dispatchEvent(new CustomEvent("slideDownDone", {
89                    detail: {
90                        target
91                    }
92                }));
93            }), duration);
94        }
95    };
96    let _slideToggle = (target, duration = 500) => {
97        if (target.hidden) return _slideDown(target, duration); else return _slideUp(target, duration);
98    };
99    let bodyLockStatus = true;
100    let bodyLockToggle = (delay = 500) => {
101        if (document.documentElement.classList.contains("lock")) bodyUnlock(delay); else bodyLock(delay);
102    };
103    let bodyUnlock = (delay = 500) => {
104        if (bodyLockStatus) {
105            const lockPaddingElements = document.querySelectorAll("[data-lp]");
106            setTimeout((() => {

107                lockPaddingElements.forEach((lockPaddingElement => {
108                    lockPaddingElement.style.paddingRight = "";
109                }));
110                document.body.style.paddingRight = "";
111                document.documentElement.classList.remove("lock");
112            }), delay);
113            bodyLockStatus = false;
114            setTimeout((function() {
115                bodyLockStatus = true;
116            }), delay);
117        }
118    };
119    let bodyLock = (delay = 500) => {
120        if (bodyLockStatus) {
121            const lockPaddingElements = document.querySelectorAll("[data-lp]");
122            const lockPaddingValue = window.innerWidth - document.body.offsetWidth + "px";
123            lockPaddingElements.forEach((lockPaddingElement => {
124                lockPaddingElement.style.paddingRight = lockPaddingValue;
125            }));
126            document.body.style.paddingRight = lockPaddingValue;
127            document.documentElement.classList.add("lock");
128            bodyLockStatus = false;
129            setTimeout((function() {
130                bodyLockStatus = true;
131            }), delay);
132        }
133    };
134    function spollers() {
135        const spollersArray = document.querySelectorAll("[data-spollers]");
136        if (spollersArray.length > 0) {
137            document.addEventListener("click", setSpollerAction);
138            const spollersRegular = Array.from(spollersArray).filter((function(item, index, self) {
139                return !item.dataset.spollers.split(",")[0];
140            }));
141            if (spollersRegular.length) initSpollers(spollersRegular);
142            let mdQueriesArray = dataMediaQueries(spollersArray, "spollers");
143            if (mdQueriesArray && mdQueriesArray.length) mdQueriesArray.forEach((mdQueriesItem => {
144                mdQueriesItem.matchMedia.addEventListener("change", (function() {
145                    initSpollers(mdQueriesItem.itemsArray, mdQueriesItem.matchMedia);
146                }));
147                initSpollers(mdQueriesItem.itemsArray, mdQueriesItem.matchMedia);
148            }));
149            function initSpollers(spollersArray, matchMedia = false) {
150                spollersArray.forEach((spollersBlock => {
151                    spollersBlock = matchMedia ? spollersBlock.item : spollersBlock;
152                    if (matchMedia.matches || !matchMedia) {
153                        spollersBlock.classList.add("_spoller-init");
154                        initSpollerBody(spollersBlock);
155                    } else {
156                        spollersBlock.classList.remove("_spoller-init");
157                        initSpollerBody(spollersBlock, false);
158                    }
159                }));
160            }
161            function initSpollerBody(spollersBlock, hideSpollerBody = true) {
162                let spollerItems = spollersBlock.querySelectorAll("details");
163                if (spollerItems.length) spollerItems.forEach((spollerItem => {
164                    let spollerTitle = spollerItem.querySelector("summary");
165                    if (hideSpollerBody) {
166                        spollerTitle.removeAttribute("tabindex");
167                        if (!spollerItem.hasAttribute("data-open")) {
168                            spollerItem.open = false;
169                            spollerTitle.nextElementSibling.hidden = true;
170                        } else {
171                            spollerTitle.classList.add("_spoller-active");
172                            spollerItem.open = true;
173                        }
174                    } else {
175                        spollerTitle.setAttribute("tabindex", "-1");
176                        spollerTitle.classList.remove("_spoller-active");
177                        spollerItem.open = true;
178                        spollerTitle.nextElementSibling.hidden = false;
179                    }
180                }));
181            }
182            function setSpollerAction(e) {
183                const el = e.target;
184                if (el.closest("summary") && el.closest("[data-spollers]")) {
185                    e.preventDefault();
186                    if (el.closest("[data-spollers]").classList.contains("_spoller-init")) {
187                        const spollerTitle = el.closest("summary");
188                        const spollerBlock = spollerTitle.closest("details");
189                        const spollersBlock = spollerTitle.closest("[data-spollers]");
190                        const oneSpoller = spollersBlock.hasAttribute("data-one-spoller");
191                        const scrollSpoller = spollerBlock.hasAttribute("data-spoller-scroll");
192                        const spollerSpeed = spollersBlock.dataset.spollersSpeed ? parseInt(spollersBlock.dataset.spollersSpeed) : 500;
193                        if (!spollersBlock.querySelectorAll("._slide").length) {
194                            if (oneSpoller && !spollerBlock.open

194) hideSpollersBody(spollersBlock);
195                            !spollerBlock.open ? spollerBlock.open = true : setTimeout((() => {
196                                spollerBlock.open = false;
197                            }), spollerSpeed);
198                            spollerTitle.classList.toggle("_spoller-active");
199                            _slideToggle(spollerTitle.nextElementSibling, spollerSpeed);
200                            if (scrollSpoller && spollerTitle.classList.contains("_spoller-active")) {
201                                const scrollSpollerValue = spollerBlock.dataset.spollerScroll;
202                                const scrollSpollerOffset = +scrollSpollerValue ? +scrollSpollerValue : 0;
203                                const scrollSpollerNoHeader = spollerBlock.hasAttribute("data-spoller-scroll-noheader") ? document.querySelector(".header").offsetHeight : 0;
204                                window.scrollTo({
205                                    top: spollerBlock.offsetTop - (scrollSpollerOffset + scrollSpollerNoHeader),
206                                    behavior: "smooth"
207                                });
208                            }
209                        }
210                    }
211                }
212                if (!el.closest("[data-spollers]")) {
213                    const spollersClose = document.querySelectorAll("[data-spoller-close]");
214                    if (spollersClose.length) spollersClose.forEach((spollerClose => {
215                        const spollersBlock = spollerClose.closest("[data-spollers]");
216                        const spollerCloseBlock = spollerClose.parentNode;
217                        if (spollersBlock.classList.contains("_spoller-init")) {
218                            const spollerSpeed = spollersBlock.dataset.spollersSpeed ? parseInt(spollersBlock.dataset.spollersSpeed) : 500;
219                            spollerClose.classList.remove("_spoller-active");
220                            _slideUp(spollerClose.nextElementSibling, spollerSpeed);
221                            setTimeout((() => {
222                                spollerCloseBlock.open = false;
223                            }), spollerSpeed);
224                        }
225                    }));
226                }
227            }
228            function hideSpollersBody(spollersBlock) {
229                const spollerActiveBlock = spollersBlock.querySelector("details[open]");
230                if (spollerActiveBlock && !spollersBlock.querySelectorAll("._slide").length) {
231                    const spollerActiveTitle = spollerActiveBlock.querySelector("summary");
232                    const spollerSpeed = spollersBlock.dataset.spollersSpeed ? parseInt(spollersBlock.dataset.spollersSpeed) : 500;
233                    spollerActiveTitle.classList.remove("_spoller-active");
234                    _slideUp(spollerActiveTitle.nextElementSibling, spollerSpeed);
235                    setTimeout((() => {
236                        spollerActiveBlock.open = false;
237                    }), spollerSpeed);
238                }
239            }
240            function removeDataOpen() {
241                const tabletMaxWidth = 1023;
242                const screenWidth = window.innerWidth;
243                if (screenWidth <= tabletMaxWidth) {
244                    const detailsElements = document.querySelectorAll("details[data-open]");
245                    if (detailsElements.length) detailsElements.forEach((function(details) {
246                        let spollerTitle = details.querySelector("summary");
247                        details.removeAttribute("data-open");
248                        details.removeAttribute("open");
249                        spollerTitle.classList.remove("_spoller-active");
250                        spollerTitle.nextElementSibling.hidden = true;
251                    }));
252                }
253            }
254            window.addEventListener("load", removeDataOpen);
255            window.addEventListener("resize", removeDataOpen);
256        }
257    }
258    function menuInit() {
259        if (document.querySelector(".icon-menu")) document.addEventListener("click", (function(e) {
260            if (bodyLockStatus && e.target.closest(".icon-menu")) {

261                bodyLockToggle();
262                document.documentElement.classList.toggle("menu-open");
263            }
264        }));
265    }
266    function showMore() {
267        window.addEventListener("load", (function() {
268            const showMoreBlocks = document.querySelectorAll("[data-shwmore]");
269            let showMoreBlocksRegular;
270            let mdQueriesArray;
271            if (showMoreBlocks.length) {
272                showMoreBlocksRegular = Array.from(showMoreBlocks).filter((item => !item.dataset.showmoreMedia));
273                if (showMoreBlocksRegular.length) initItems(showMoreBlocksRegular);
274                document.addEventListener("click", showMoreActions);
275                window.addEventListener("resize", showMoreActions);
276                mdQueriesArray = dataMediaQueries(showMoreBlocks, "showmoreMedia");
277                if (mdQueriesArray && mdQueriesArray.length) {
278                    mdQueriesArray.forEach((mdQueriesItem => {
279                        mdQueriesItem.matchMedia.addEventListener("change", (() => {
280                            initItems(mdQueriesItem.itemsArray, mdQueriesItem.matchMedia);
281                        }));
282                    }));
283                    initItemsMedia(mdQueriesArray);
284                }
285            }
286            function initItemsMedia(mdQueriesArray) {
287                mdQueriesArray.forEach((mdQueriesItem => {
288                    initItems(mdQueriesItem.itemsArray, mdQueriesItem.matchMedia);
289                }));
290            }
291            function initItems(showMoreBlocks, matchMedia) {
292                showMoreBlocks.forEach((showMoreBlock => {
293                    initItem(showMoreBlock, matchMedia);
294                }));
295            }
296            function initItem(showMoreBlock, matchMedia = false) {
297                showMoreBlock = matchMedia ? showMoreBlock.item : showMoreBlock;
298                let showMoreContent = showMoreBlock.querySelector("[data-shwmore-content]");
299                let showMoreButton = showMoreBlock.querySelector("[data-shwmore-button]");
300                const hiddenHeight = getHeight(showMoreBlock, showMoreContent);
301                if (matchMedia.matches || !matchMedia) if (hiddenHeight < getOriginalHeight(showMoreContent)) {
302                    _slideUp(showMoreContent, 0, showMoreBlock.classList.contains("_showmore-active") ? getOriginalHeight(showMoreContent) : hiddenHeight);
303                    showMoreButton.hidden = false;
304                } else {
305                    _slideDown(showMoreContent, 0, hiddenHeight);
306                    showMoreButton.hidden = true;
307                } else {
308                    _slideDown(showMoreContent, 0, hiddenHeight);
309                    showMoreButton.hidden = true;
310                }
311            }
312            function getHeight(showMoreBlock, showMoreContent) {
313                let hiddenHeight = 0;
314                const showMoreType = showMoreBlock.dataset.showmore || "size";
315                const rowGap = parseFloat(getComputedStyle(showMoreContent).rowGap) || 0;
316                if (showMoreType === "items") {
317                    const showMoreTypeValue = parseInt(showMoreContent.dataset.showmoreContent, 10) || 3;
318                    const showMoreItems = showMoreContent.children;
319                    for (let index = 1; index < showMoreItems.length; index++) {
320                        const showMoreItem = showMoreItems[index - 1];
321                        const marginTop = parseFloat(getComputedStyle(showMoreItem).marginTop) || 0;
322                        const marginBottom = parseFloat(getComputedStyle(showMoreItem).marginBottom) || 0;
323                        hiddenHeight += showMoreItem.offsetHeight + marginTop;
324                        if (index === showMoreTypeValue) break;
325                        hiddenHeight += marginBottom;
326                    }
327                    hiddenHeight += (showMoreTypeValue - 1) * rowGap;
328                } else {
329                    const showMoreTypeValue = parseInt(showMoreContent.dataset.showmoreContent, 10) || 150;
330                    hiddenHeight = showMoreTypeValue;
331                }
332                return hiddenHeight;
333            }
334            function getOriginalHeight(showMoreContent) {
335                const hiddenHeight = showMoreContent.offsetHeight;
336                showMoreContent.style.removeProperty("height");
337                const originalHeight = showMoreContent.offsetHeight;
338                showMoreContent.style.height = `${hiddenHeight}px`;
339                return originalHeight;
340            }
341            function showMoreActions(e) {
342                const targetEvent = e.target;
343                const targetType = e.type;
344                if (targetType === "click" && targetEvent.closest("[data-shwmore-button]")) {
345                    const showMoreButton = targetEvent.closest("[data-shwmore-button]");
346                    const showMoreBlock = showMoreButton.closest("[data-shwmore]");
347                    const showMoreContent = showMoreBlock.querySelector("[data-shwmore-content]");
348                    const showMoreSpeed = showMoreBlock.dataset.showmoreButton || "500";
349                    const hiddenHeight = getHeight(showMoreBlock, showMoreContent);
350                    if (!showMoreContent.classList.contains("_slide")) {
351                        showMoreBlock.classList.contains("_showmore-active") ? _slideUp(showMoreContent, showMoreSpeed, hiddenHeight) : _slideDown(showMoreContent, showMoreSpeed, hiddenHeight);
352                        showMoreBlock.classList.toggle("_showmore-active");
353                    }
354                } else if (targetType === "resize") {
355                    if (showMoreBlocksRegular.length) initItems(showMoreBlocksRegular);
356                    if (mdQueriesArray && mdQueriesArray.length) initItemsMedia(mdQueriesArray);
357                }
358            }
359        }));
360    }
361    function uniqArray(array) {
362        return array.filter((function(item, index, self) {
363            return self.indexOf(item) === index;
364        }));
365    }
366    function dataMediaQueries(array, dataSetValue) {
367        const media = Array.from(array).filter((function(item, index, self) {
368            if (item.dataset[dataSetValue]) return item.dataset[dataSetValue].split(",")[0];
369        }));
370        if (media.length) {
371            const breakpointsArray = [];

372            media.forEach((item => {
373                const params = item.dataset[dataSetValue];
374                const breakpoint = {};
375                const paramsArray = params.split(",");
376                breakpoint.value = paramsArray[0];
377                breakpoint.type = paramsArray[1] ? paramsArray[1].trim() : "max";
378                breakpoint.item = item;
379                breakpointsArray.push(breakpoint);
380            }));
381            let mdQueries = breakpointsArray.map((function(item) {
382                return "(" + item.type + "-width: " + item.value + "px)," + item.value + "," + item.type;
383            }));
384            mdQueries = uniqArray(mdQueries);
385            const mdQueriesArray = [];
386            if (mdQueries.length) {
387                mdQueries.forEach((breakpoint => {
388                    const paramsArray = breakpoint.split(",");
389                    const mediaBreakpoint = paramsArray[1];
390                    const mediaType = paramsArray[2];
391                    const matchMedia = window.matchMedia(paramsArray[0]);
392                    const itemsArray = breakpointsArray.filter((function(item) {
393                        if (item.value === mediaBreakpoint && item.type === mediaType) return true;
394                    }));
395                    mdQueriesArray.push({
396                        itemsArray,
397                        matchMedia
398                    });
399                }));
400                return mdQueriesArray;
401            }
402        }
403    }
404    function stickBtn() {
405        const button = document.querySelector(".btn-sticky");
406        if (isMobile.isScreenMobile() && button) window.onscroll = function() {
407            const main = document.querySelector("main");
408            const mainOffset = main.getBoundingClientRect().bottom + window.scrollY;
409            const scrollPosition = window.scrollY + window.innerHeight;
410            if (window.scrollY >= 150 && scrollPosition < mainOffset) {
411                button.classList.add("stick");
412                button.classList.remove("hide");
413            } else if (scrollPosition >= mainOffset) {
414                button.classList.remove("stick");
415                button.classList.add("hide");
416            } else {
417                button.classList.remove("stick");
418                button.classList.remove("hide");
419            }
420        };
421    }
422    function showMoreBtn() {
423        document.addEventListener("DOMContentLoaded", (function() {
424            const blocks = document.querySelectorAll("[data-showmore]");
425            blocks.forEach(block => {
426                const spollers = block.querySelector(".spollers");
427                if (!spollers) return;
428                const spollersItems = spollers.querySelectorAll(".spollers__item");
429                const showMoreButton = block.querySelector("[data-showmore-button]");
430                const showMoreCount = parseInt(spollers.dataset.showmoreContent, 10);
431                function updateVisibility() {
432                    const totalItems = spollersItems.length;
433                    if (totalItems > showMoreCount) {
434                        showMoreButton.hidden = false;
435                        for (let i = 0; i < totalItems; i++) if (i < showMoreCount) spollersItems[i].style.display = ""; else spollersItems[i].style.display = "none";
436                    } else {
437                        showMoreButton.hidden = true;
438                        spollersItems.forEach((item => item.style.display = ""));
439                    }
440                }
441                function toggleShowMore() {
442                    const isExpanded = showMoreButton.getAttribute("aria-expanded") === "true";
443                    showMoreButton.setAttribute("aria-expanded", !isExpanded);
444                    showMoreButton.querySelector("span:nth-child(1)").style.display = isExpanded ? "" : "none";
445                    showMoreButton.querySelector("span:nth-child(2)").style.display = isExpanded ? "none" : "";
446                    spollersItems.forEach(((item, index) => {
447                        if (index >= showMoreCount) item.style.display = isExpanded ? "none" : "";
448                    }));
449                }
450                showMoreButton.addEventListener("click", toggleShowMore);
451                const observer = new MutationObserver(updateVisibility);
452                observer.observe(spollers, {
453                    childList: true,
454                    subtree: true
455                });
456                updateVisibility();
457            });
458        }));
459    }
460    function flipCard() {
461        document.addEventListener("DOMContentLoaded", (function() {
462            document.querySelectorAll(".mentor-card").forEach((function(card) {
463                card.addEventListener("click", (function(event) {
464                    const image = card.querySelector("img");
465                    const text = card.querySelector(".mentor-text");
466                    if (image && text) if (image.classList.contains("hidden")) {
467                        image.classList.remove("hidden");
468                        text.classList.add("hidden");
469                        card.classList.remove("mentor-card--active");
470                    } else {
471                        image.classList.add("hidden");
472                        text.classList.remove("hidden");
473                        card.classList.add("mentor-card--active");
474                    } else console.error("ÐÐµ Ð²Ð´Ð°Ð»Ð¾ÑÑ Ð·Ð½Ð°Ð¹ÑÐ¸ ÐµÐ»ÐµÐ¼ÐµÐ½ÑÐ¸ Ð·Ð¾Ð±ÑÐ°Ð¶ÐµÐ½Ð½Ñ Ð°Ð±Ð¾ ÑÐµÐºÑÑÑ Ð² ÐºÐ°ÑÑÑÑ");
475                }));
476            }));
477        }));
478    }
479    function breadcrumbs() {
480        const breadcrumb = document.querySelector(".breadcrumb");
481        if (breadcrumb) document.addEventListener("DOMContentLoaded", (function() {
482            function updateBreadcrumb() {
483                const items = breadcrumb.querySelectorAll("li");
484                const ellipsis = breadcrumb.querySelector(".ellipsis");
485                if (window.innerWidth <= 768) {

486                    items.forEach(((item, index) => {
487                        if (index !== 0 && index !== items.length - 1) item.style.display = "none";
488                    }));
489                    ellipsis.style.display = "flex";
490                } else {
491                    items.forEach((item => {
492                        item.style.display = "flex";
493                    }));
494                    ellipsis.style.display = "none";
495                }
496            }
497            updateBreadcrumb();
498            window.addEventListener("resize", updateBreadcrumb);
499        }));
500    }
501    function openDropdown() {
502        document.addEventListener("click", handleDropdownClick);
503        const overlay = document.querySelector(".dropdown-overlay");
504        function handleDropdownClick(e) {
505            const isDropdownButton = e.target.closest("[data-dropdown-btn]");
506            const isBackButton = e.target.matches(".dropdown-back");
507            const menuBody = document.querySelector(".menu__body");
508            const currentDropdown = e.target.closest("[data-dropdown]");
509            if (!isDropdownButton && !isBackButton && e.target.closest(".dropdown-submenu")) return;
510            if (isDropdownButton) toggleDropdown(currentDropdown); else if (isBackButton) closeSubmenu(e.target.closest(".dropdown-submenu__menu"));
511            closeOtherDropdowns(currentDropdown);
512            if (window.innerWidth <= 1024) toggleMenuBodyWidth(menuBody);
513        }
514        function toggleDropdown(dropdown) {
515            if (dropdown) {
516                const isActive = dropdown.classList.toggle("show");
517                document.body.classList.toggle("overflow-hidden", isActive);
518                if (overlay) overlay.classList.toggle("show", isActive);
519            }
520        }
521        function closeSubmenu(submenu) {
522            if (submenu) submenu.parentElement.classList.remove("show");
523        }
524        function closeOtherDropdowns(currentDropdown) {
525            document.querySelectorAll("[data-dropdown].show").forEach((dropdown => {
526                if (dropdown !== currentDropdown && !dropdown.contains(currentDropdown)) dropdown.classList.remove("show");
527            }));
528            if (!document.querySelector("[data-dropdown].show")) {
529                document.body.classList.remove("overflow-hidden");
530                if (overlay) overlay.classList.remove("show");
531            }
532        }
533        function toggleMenuBodyWidth(menuBody) {
534            if (document.querySelector(".dropdown-submenu.show")) menuBody.style.width = "100%"; else menuBody.style.width = "";
535        }
536    }
537    function setPrometheusPlusHeaderImage() {
538        function updateImageSrc() {
539            let heroImage = "";
540            const hero = document.querySelector("#hero-inner");
541            if (window.innerWidth < 768) ; else if (window.innerWidth >= 768 && window.innerWidth < 1024) heroImage = "https://dev.prometheus.org.ua/wp-content/themes/prometheus-new/assets/img/prometheus-plus/tablet.svg"; else if (window.innerWidth >= 1024) heroImage = "https://dev.prometheus.org.ua/wp-content/themes/prometheus-new/assets/img/about_desktop.svg";
542            if (hero) hero.style.backgroundImage = `url(${heroImage})`;
543        }
544        document.addEventListener("DOMContentLoaded", (function() {
545            updateImageSrc();
546            window.addEventListener("resize", (() => {
547                updateImageSrc();
548            }));
549        }));
550    }
551    class Popup {
552        constructor(options) {
553            let config = {
554                logging: true,
555                init: true,
556                attributeOpenButton: "data-popup",
557                attributeCloseButton: "data-close",
558                fixElementSelector: "[data-lp]",
559                youtubeAttribute: "data-popup-youtube",
560                youtubePlaceAttribute: "data-popup-youtube-place",
561                setAutoplayYoutube: true,
562                classes: {
563                    popup: "popup",
564                    popupContent: "popup__content",
565                    popupActive: "popup_show",

566                    bodyActive: "popup-show"
567                },
568                focusCatch: true,
569                closeEsc: true,
570                bodyLock: true,
571                hashSettings: {
572                    location: true,
573                    goHash: true
574                },
575                on: {
576                    beforeOpen: function() {},
577                    afterOpen: function() {},
578                    beforeClose: function() {},
579                    afterClose: function() {}
580                }
581            };
582            this.youTubeCode;
583            this.isOpen = false;
584            this.targetOpen = {
585                selector: false,
586                element: false
587            };
588            this.previousOpen = {
589                selector: false,
590                element: false
591            };
592            this.lastClosed = {
593                selector: false,
594                element: false
595            };
596            this._dataValue = false;
597            this.hash = false;
598            this._reopen = false;
599            this._selectorOpen = false;
600            this.lastFocusEl = false;
601            this._focusEl = [ "a[href]", 'input:not([disabled]):not([type="hidden"]):not([aria-hidden])', "button:not([disabled]):not([aria-hidden])", "select:not([disabled]):not([aria-hidden])", "textarea:not([disabled]):not([aria-hidden])", "area[href]", "iframe", "object", "embed", "[contenteditable]", '[tabindex]:not([tabindex^="-"])' ];
602            this.options = {
603                ...config,
604                ...options,
605                classes: {
606                    ...config.classes,
607                    ...options?.classes
608                },
609                hashSettings: {
610                    ...config.hashSettings,
611                    ...options?.hashSettings
612                },
613                on: {
614                    ...config.on,
615                    ...options?.on
616                }
617            };
618            this.bodyLock = false;
619            this.options.init ? this.initPopups() : null;
620        }
621        initPopups() {
622            this.eventsPopup();
623        }
624        eventsPopup() {
625            document.addEventListener("click", function(e) {
626                const buttonOpen = e.target.closest(`[${this.options.attributeOpenButton}]`);
627                if (buttonOpen) {
628                    e.preventDefault();
629                    this._dataValue = buttonOpen.getAttribute(this.options.attributeOpenButton) ? buttonOpen.getAttribute(this.options.attributeOpenButton) : "error";
630                    this.youTubeCode = buttonOpen.getAttribute(this.options.youtubeAttribute) ? buttonOpen.getAttribute(this.options.youtubeAttribute) : null;
631                    if (this._dataValue !== "error") {
632                        if (!this.isOpen) this.lastFocusEl = buttonOpen;
633                        this.targetOpen.selector = `${this._dataValue}`;
634                        this._selectorOpen = true;
635                        this.open();
636                        return;
637                    }
638                    return;
639                }
640                const buttonClose = e.target.closest(`[${this.options.attributeCloseButton}]`);
641                if (buttonClose || !e.target.closest(`.${this.options.classes.popupContent}`) && this.isOpen) {
642                    e.preventDefault();
643                    this.close();
644                    return;
645                }
646            }.bind(this));
647            document.addEventListener("keydown", function(e) {
648                if (this.options.closeEsc && e.which == 27 && e.code === "Escape" && this.isOpen) {
649                    e.preventDefault();
650                    this.close();
651                    return;
652                }
653                if (this.options.focusCatch && e.which == 9 && this.isOpen) {
654                    this._focusCatch(e);
655                    return;
656                }
657            }.bind(this));
658            if (this.options.hashSettings.goHash) {
659                window.addEventListener("hashchange", function() {
660                    if (window.location.hash) this._openToHash(); else this.close(this.targetOpen.selector);
661                }.bind(this));
662                window.addEventListener("load", function() {
663                    if (window.location.hash) this._openToHash();
664                }.bind(this));
665            }
666        }
667        open(selectorValue) {
668            if (bodyLockStatus) {
669                this.bodyLock = document.documentElement.classList.contains("lock") && !this.isOpen ? true : false;

670                if (selectorValue && typeof selectorValue === "string" && selectorValue.trim() !== "") {
671                    this.targetOpen.selector = selectorValue;
672                    this._selectorOpen = true;
673                }
674                if (this.isOpen) {
675                    this._reopen = true;
676                    this.close();
677                }
678                if (!this._selectorOpen) this.targetOpen.selector = this.lastClosed.selector;
679                if (!this._reopen) this.previousActiveElement = document.activeElement;
680                this.targetOpen.element = document.querySelector(this.targetOpen.selector);
681                if (this.targetOpen.element) {
682                    if (this.youTubeCode) {
683                        const codeVideo = this.youTubeCode;
684                        const urlVideo = `https://www.youtube.com/embed/${codeVideo}?rel=0&showinfo=0&autoplay=1`;
685                        const iframe = document.createElement("iframe");
686                        iframe.setAttribute("allowfullscreen", "");
687                        const autoplay = this.options.setAutoplayYoutube ? "autoplay;" : "";
688                        iframe.setAttribute("allow", `${autoplay}; encrypted-media`);
689                        iframe.setAttribute("src", urlVideo);
690                        if (!this.targetOpen.element.querySelector(`[${this.options.youtubePlaceAttribute}]`)) {
691                            this.targetOpen.element.querySelector(".popup__text").setAttribute(`${this.options.youtubePlaceAttribute}`, "");
692                        }
693                        this.targetOpen.element.querySelector(`[${this.options.youtubePlaceAttribute}]`).appendChild(iframe);
694                    }
695                    if (this.options.hashSettings.location) {
696                        this._getHash();
697                        this._setHash();
698                    }
699                    this.options.on.beforeOpen(this);
700                    document.dispatchEvent(new CustomEvent("beforePopupOpen", {
701                        detail: {
702                            popup: this
703                        }
704                    }));
705                    this.targetOpen.element.classList.add(this.options.classes.popupActive);
706                    document.documentElement.classList.add(this.options.classes.bodyActive);
707                    if (!this._reopen) !this.bodyLock ? bodyLock() : null; else this._reopen = false;
708                    this.targetOpen.element.setAttribute("aria-hidden", "false");
709                    this.previousOpen.selector = this.targetOpen.selector;
710                    this.previousOpen.element = this.targetOpen.element;
711                    this._selectorOpen = false;
712                    this.isOpen = true;
713                    setTimeout((() => {
714                        this._focusTrap();
715                    }), 50);
716                    this.options.on.afterOpen(this);
717                    document.dispatchEvent(new CustomEvent("afterPopupOpen", {
718                        detail: {
719                            popup: this
720                        }
721                    }));
722                }
723            }
724        }
725        close(selectorValue) {
726            if (selectorValue && typeof selectorValue === "string" && selectorValue.trim() !== "") this.previousOpen.selector = selectorValue;
727            if (!this.isOpen || !bodyLockStatus) return;
728            this.options.on.beforeClose(this);
729            document.dispatchEvent(new CustomEvent("beforePopupClose", {
730                detail: {
731                    popup: this
732                }
733            }));
734            if (this.youTubeCode) if (this.targetOpen.element.querySelector(`[${this.options.youtubePlaceAttribute}]`)) this.targetOpen.element.querySelector(`[${this.options.youtubePlaceAttribute}]`).innerHTML = "";
735            this.previousOpen.element.classList.remove(this.options.classes.popupActive);
736            this.previousOpen.element.setAttribute("aria-hidden", "true");
737            if (!this._reopen) {
738                document.documentElement.classList.remove(this.options.classes.bodyActive);
739                !this.bodyLock ? bodyUnlock() : null;
740                this.isOpen = false;

741            }
742            this._removeHash();
743            if (this._selectorOpen) {
744                this.lastClosed.selector = this.previousOpen.selector;
745                this.lastClosed.element = this.previousOpen.element;
746            }
747            this.options.on.afterClose(this);
748            document.dispatchEvent(new CustomEvent("afterPopupClose", {
749                detail: {
750                    popup: this
751                }
752            }));
753            setTimeout((() => {
754                this._focusTrap();
755            }), 50);
756        }
757        _getHash() {
758            if (this.options.hashSettings.location) this.hash = this.targetOpen.selector.includes("#") ? this.targetOpen.selector : this.targetOpen.selector.replace(".", "#");
759        }
760        _openToHash() {
761            let classInHash = document.querySelector(`.${window.location.hash.replace("#", "")}`) ? `.${window.location.hash.replace("#", "")}` : document.querySelector(`${window.location.hash}`) ? `${window.location.hash}` : null;
762            const buttons = document.querySelector(`[${this.options.attributeOpenButton} = "${classInHash}"]`) ? document.querySelector(`[${this.options.attributeOpenButton} = "${classInHash}"]`) : document.querySelector(`[${this.options.attributeOpenButton} = "${classInHash.replace(".", "#")}"]`);
763            this.youTubeCode = buttons.getAttribute(this.options.youtubeAttribute) ? buttons.getAttribute(this.options.youtubeAttribute) : null;
764            if (buttons && classInHash) this.open(classInHash);
765        }
766        _setHash() {
767            history.pushState("", "", this.hash);
768        }
769        _removeHash() {
770            history.pushState("", "", window.location.href.split("#")[0]);
771        }
772        _focusCatch(e) {
773            const focusable = this.targetOpen.element.querySelectorAll(this._focusEl);
774            const focusArray = Array.prototype.slice.call(focusable);
775            const focusedIndex = focusArray.indexOf(document.activeElement);
776            if (e.shiftKey && focusedIndex === 0) {
777                focusArray[focusArray.length - 1].focus();
778                e.preventDefault();
779            }
780            if (!e.shiftKey && focusedIndex === focusArray.length - 1) {
781                focusArray[0].focus();
782                e.preventDefault();
783            }
784        }
785        _focusTrap() {
786            const focusable = this.previousOpen.element.querySelectorAll(this._focusEl);
787            if (!this.isOpen && this.lastFocusEl) this.lastFocusEl.focus(); else focusable[0].focus();
788        }
789    }
790    modules_flsModules.popup = new Popup({});
791    function ssr_window_esm_isObject(obj) {
792        return obj !== null && typeof obj === "object" && "constructor" in obj && obj.constructor === Object;
793    }
794    function extend(target, src) {
795        if (target === void 0) target = {};
796        if (src === void 0) src = {};
797        Object.keys(src).forEach((key => {
798            if (typeof target[key] === "undefined") target[key] = src[key]; else if (ssr_window_esm_isObject(src[key]) && ssr_window_esm_isObject(target[key]) && Object.keys(src[key]).length > 0) extend(target[key], src[key]);
799        }));
800    }
801    const ssrDocument = {
802        body: {},
803        addEventListener() {},
804        removeEventListener() {},
805        activeElement: {
806            blur() {},
807            nodeName: ""
808        },
809        querySelector() {
810            return null;
811        },
812        querySelectorAll() {
813            return [];
814        },
815        getElementById() {
816            return null;
817        },
818        createEvent() {
819            return {
820                initEvent() {}
821            };
822        },
823        createElement() {
824            return {
825                children: [],
826                childNodes: [],
827                style: {},
828                setAttribute() {},
829                getElementsByTagName() {
830                    return [];
831                }
832            };
833        },
834        createElementNS() {
835            return {};
836        },
837        importNode() {
838            return null;
839        },
840        location: {
841            hash: "",
842            host: "",
843            hostname: "",
844            href: "",
845            origin: "",
846            pathname: "",
847            protocol: "",
848            search: ""
849        }
850    };
851    function ssr_window_esm_getDocument() {
852        const doc = typeof document !== "undefined" ? document : {};
853        extend(doc, ssrDocument);
854        return doc;
855    }
856    const ssrWindow = {
857        document: ssrDocument,
858        navigator: {
859            userAgent: ""
860        },
861        location: {
862            hash: "",
863            host: "",
864            hostname: "",
865            href: "",
866            origin: "",
867            pathname: "",
868            protocol: "",
869            search: ""
870        },
871        history: {
872            replaceState() {},
873            pushState() {},
874            go() {},
875            back() {}
876        },
877        CustomEvent: function CustomEvent() {
878            return this;
879        },
880        addEventListener() {},
881        removeEventListener() {},
882        getComputedStyle() {
883            return {
884                getPropertyValue() {
885                    return "";
886                }
887            };
888        },
889        Image() {},
890        Date() {},
891        screen: {},
892        setTimeout() {},
893        clearTimeout() {},
894        matchMedia() {
895            return {};
896        },
897        requestAnimationFrame(callback) {
898            if (typeof setTimeout === "undefined") {
899                callback();
900                return null;
901            }
902            return setTimeout(callback, 0);
903        },
904        cancelAnimationFrame(id) {
905            if (typeof setTimeout === "undefined") return;
906            clearTimeout(id);
907        }
908    };
909    function ssr_window_esm_getWindow() {
910        const win = typeof window !== "undefined" ? window : {};
911        extend(win, ssrWindow);
912        return win;
913    }

914    function utils_classesToTokens(classes) {
915        if (classes === void 0) classes = "";
916        return classes.trim().split(" ").filter((c => !!c.trim()));
917    }
918    function deleteProps(obj) {
919        const object = obj;
920        Object.keys(object).forEach((key => {
921            try {
922                object[key] = null;
923            } catch (e) {}
924            try {
925                delete object[key];
926            } catch (e) {}
927        }));
928    }
929    function utils_nextTick(callback, delay) {
930        if (delay === void 0) delay = 0;
931        return setTimeout(callback, delay);
932    }
933    function utils_now() {
934        return Date.now();
935    }
936    function utils_getComputedStyle(el) {
937        const window = ssr_window_esm_getWindow();
938        let style;
939        if (window.getComputedStyle) style = window.getComputedStyle(el, null);
940        if (!style && el.currentStyle) style = el.currentStyle;
941        if (!style) style = el.style;
942        return style;
943    }
944    function utils_getTranslate(el, axis) {
945        if (axis === void 0) axis = "x";
946        const window = ssr_window_esm_getWindow();
947        let matrix;
948        let curTransform;
949        let transformMatrix;
950        const curStyle = utils_getComputedStyle(el);
951        if (window.WebKitCSSMatrix) {
952            curTransform = curStyle.transform || curStyle.webkitTransform;
953            if (curTransform.split(",").length > 6) curTransform = curTransform.split(", ").map((a => a.replace(",", "."))).join(", ");
954            transformMatrix = new window.WebKitCSSMatrix(curTransform === "none" ? "" : curTransform);
955        } else {
956            transformMatrix = curStyle.MozTransform || curStyle.OTransform || curStyle.MsTransform || curStyle.msTransform || curStyle.transform || curStyle.getPropertyValue("transform").replace("translate(", "matrix(1, 0, 0, 1,");
957            matrix = transformMatrix.toString().split(",");
958        }
959        if (axis === "x") if (window.WebKitCSSMatrix) curTransform = transformMatrix.m41; else if (matrix.length === 16) curTransform = parseFloat(matrix[12]); else curTransform = parseFloat(matrix[4]);
960        if (axis === "y") if (window.WebKitCSSMatrix) curTransform = transformMatrix.m42; else if (matrix.length === 16) curTransform = parseFloat(matrix[13]); else curTransform = parseFloat(matrix[5]);
961        return curTransform || 0;
962    }
963    function utils_isObject(o) {
964        return typeof o === "object" && o !== null && o.constructor && Object.prototype.toString.call(o).slice(8, -1) === "Object";
965    }
966    function isNode(node) {
967        if (typeof window !== "undefined" && typeof window.HTMLElement !== "undefined") return node instanceof HTMLElement;
968        return node && (node.nodeType === 1 || node.nodeType === 11);
969    }
970    function utils_extend() {
971        const to = Object(arguments.length <= 0 ? void 0 : arguments[0]);
972        const noExtend = [ "__proto__", "constructor", "prototype" ];
973        for (let i = 1; i < arguments.length; i += 1) {
974            const nextSource = i < 0 || arguments.length <= i ? void 0 : arguments[i];
975            if (nextSource !== void 0 && nextSource !== null && !isNode(nextSource)) {
976                const keysArray = Object.keys(Object(nextSource)).filter((key => noExtend.indexOf(key) < 0));
977                for (let nextIndex = 0, len = keysArray.length; nextIndex < len; nextIndex += 1) {
978                    const nextKey = keysArray[nextIndex];
979                    const desc = Object.getOwnPropertyDescriptor(nextSource, nextKey);
980                    if (desc !== void 0 && desc.enumerable) if (utils_isObject(to[nextKey]) && utils_isObject(nextSource[nextKey])) if (nextSource[nextKey].__swiper__) to[nextKey] = nextSource[nextKey]; else utils_extend(to[nextKey], nextSource[nextKey]); else if (!utils_isObject(to[nextKey]) && utils_isObject(nextSource[nextKey])) {
981                        to[nextKey] = {};
982                        if (nextSource[nextKey].__swiper__) to[nextKey] = nextSource[nextKey]; else utils_extend(to[nextKey], nextSource[nextKey]);
983                    } else to[nextKey] = nextSource[nextKey];
984                }
985            }
986        }
987        return to;
988    }
989    function utils_setCSSProperty(el, varName, varValue) {
990        el.style.setProperty(varName, varValue);
991    }
992    function animateCSSModeScroll(_ref) {
993        let {swiper, targetPosition, side} = _ref;
994        const window = ssr_window_esm_getWindow();
995        const startPosition = -swiper.translate;
996        let startTime = null;
997        let time;
998        const duration = swiper.params.speed;
999        swiper.wrapperEl.style.scrollSnapType = "none";
1000        window.cancelAnimationFrame(swiper.cssModeFrameID);
1001        const dir = targetPosition > startPosition ? "next" : "prev";
1002        const isOutOfBound = (current, target) => dir === "next" && current >= target || dir === "prev" && current <= target;
1003        const animate = () => {
1004            time = (new Date).getTime();
1005            if (startTime === null) startTime = time;
1006            const progress = Math.max(Math.min((time - startTime) / duration, 1), 0);
1007            const easeProgress = .5 - Math.cos(progress * Math.PI) / 2;
1008            let currentPosition = startPosition + easeProgress * (targetPosition - startPosition);
1009            if (isOutOfBound(currentPosition, targetPosition)) currentPosition = targetPosition;
1010            swiper.wrapperEl.scrollTo({
1011                [side]: currentPosition
1012            });
1013            if (isOutOfBound(currentPosition, targetPosition)) {
1014                swiper.wrapperEl.style.overflow = "hidden";
1015                swiper.wrapperEl.style.scrollSnapType = "";
1016                setTimeout((() => {
1017                    swiper.wrapperEl.style.overflow = "";
1018                    swiper.wrapperEl.scrollTo({
1019                        [side]: currentPosition
1020                    });
1021                }));
1022                window.cancelAnimationFrame(swiper.cssModeFrameID);
1023                return;
1024            }
1025            swiper.cssModeFrameID = window.requestAnimationFrame(animate);
1026        };
1027        animate();
1028    }
1029    function utils_elementChildren(element, selector) {
1030        if (selector === void 0) selector = "";
1031        return [ ...element.children ].filter((el => el.matches(selector)));
1032    }
1033    function showWarning(text) {
1034        try {
1035            console.warn(text);
1036            return;
1037        } catch (err) {}
1038    }
1039    function utils_createElement(tag, classes) {
1040        if (classes === void 0) classes = [];
1041        const el = document.createElement(tag);

1042        el.classList.add(...Array.isArray(classes) ? classes : utils_classesToTokens(classes));
1043        return el;
1044    }
1045    function elementPrevAll(el, selector) {
1046        const prevEls = [];
1047        while (el.previousElementSibling) {
1048            const prev = el.previousElementSibling;
1049            if (selector) {
1050                if (prev.matches(selector)) prevEls.push(prev);
1051            } else prevEls.push(prev);
1052            el = prev;
1053        }
1054        return prevEls;
1055    }
1056    function elementNextAll(el, selector) {
1057        const nextEls = [];
1058        while (el.nextElementSibling) {
1059            const next = el.nextElementSibling;
1060            if (selector) {
1061                if (next.matches(selector)) nextEls.push(next);
1062            } else nextEls.push(next);
1063            el = next;
1064        }
1065        return nextEls;
1066    }
1067    function elementStyle(el, prop) {
1068        const window = ssr_window_esm_getWindow();
1069        return window.getComputedStyle(el, null).getPropertyValue(prop);
1070    }
1071    function utils_elementIndex(el) {
1072        let child = el;
1073        let i;
1074        if (child) {
1075            i = 0;
1076            while ((child = child.previousSibling) !== null) if (child.nodeType === 1) i += 1;
1077            return i;
1078        }
1079        return;
1080    }
1081    function utils_elementParents(el, selector) {
1082        const parents = [];
1083        let parent = el.parentElement;
1084        while (parent) {
1085            if (selector) {
1086                if (parent.matches(selector)) parents.push(parent);
1087            } else parents.push(parent);
1088            parent = parent.parentElement;
1089        }
1090        return parents;
1091    }
1092    function elementOuterSize(el, size, includeMargins) {
1093        const window = ssr_window_esm_getWindow();
1094        if (includeMargins) return el[size === "width" ? "offsetWidth" : "offsetHeight"] + parseFloat(window.getComputedStyle(el, null).getPropertyValue(size === "width" ? "margin-right" : "margin-top")) + parseFloat(window.getComputedStyle(el, null).getPropertyValue(size === "width" ? "margin-left" : "margin-bottom"));
1095        return el.offsetWidth;
1096    }
1097    function utils_makeElementsArray(el) {
1098        return (Array.isArray(el) ? el : [ el ]).filter((e => !!e));
1099    }
1100    let support;
1101    function calcSupport() {
1102        const window = ssr_window_esm_getWindow();
1103        const document = ssr_window_esm_getDocument();
1104        return {
1105            smoothScroll: document.documentElement && document.documentElement.style && "scrollBehavior" in document.documentElement.style,
1106            touch: !!("ontouchstart" in window || window.DocumentTouch && document instanceof window.DocumentTouch)
1107        };
1108    }
1109    function getSupport() {
1110        if (!support) support = calcSupport();
1111        return support;
1112    }
1113    let deviceCached;
1114    function calcDevice(_temp) {
1115        let {userAgent} = _temp === void 0 ? {} : _temp;

1116        const support = getSupport();
1117        const window = ssr_window_esm_getWindow();
1118        const platform = window.navigator.platform;
1119        const ua = userAgent || window.navigator.userAgent;
1120        const device = {
1121            ios: false,
1122            android: false
1123        };
1124        const screenWidth = window.screen.width;
1125        const screenHeight = window.screen.height;
1126        const android = ua.match(/(Android);?[\s\/]+([\d.]+)?/);
1127        let ipad = ua.match(/(iPad).*OS\s([\d_]+)/);
1128        const ipod = ua.match(/(iPod)(.*OS\s([\d_]+))?/);
1129        const iphone = !ipad && ua.match(/(iPhone\sOS|iOS)\s([\d_]+)/);
1130        const windows = platform === "Win32";
1131        let macos = platform === "MacIntel";
1132        const iPadScreens = [ "1024x1366", "1366x1024", "834x1194", "1194x834", "834x1112", "1112x834", "768x1024", "1024x768", "820x1180", "1180x820", "810x1080", "1080x810" ];
1133        if (!ipad && macos && support.touch && iPadScreens.indexOf(`${screenWidth}x${screenHeight}`) >= 0) {
1134            ipad = ua.match(/(Version)\/([\d.]+)/);
1135            if (!ipad) ipad = [ 0, 1, "13_0_0" ];
1136            macos = false;
1137        }
1138        if (android && !windows) {
1139            device.os = "android";
1140            device.android = true;
1141        }
1142        if (ipad || iphone || ipod) {
1143            device.os = "ios";
1144            device.ios = true;
1145        }
1146        return device;
1147    }
1148    function getDevice(overrides) {
1149        if (overrides === void 0) overrides = {};
1150        if (!deviceCached) deviceCached = calcDevice(overrides);
1151        return deviceCached;
1152    }
1153    let browser;
1154    function calcBrowser() {
1155        const window = ssr_window_esm_getWindow();
1156        const device = getDevice();
1157        let needPerspectiveFix = false;
1158        function isSafari() {
1159            const ua = window.navigator.userAgent.toLowerCase();
1160            return ua.indexOf("safari") >= 0 && ua.indexOf("chrome") < 0 && ua.indexOf("android") < 0;
1161        }
1162        if (isSafari()) {
1163            const ua = String(window.navigator.userAgent);
1164            if (ua.includes("Version/")) {
1165                const [major, minor] = ua.split("Version/")[1].split(" ")[0].split(".").map((num => Number(num)));
1166                needPerspectiveFix = major < 16 || major === 16 && minor < 2;
1167            }
1168        }
1169        const isWebView = /(iPhone|iPod|iPad).*AppleWebKit(?!.*Safari)/i.test(window.navigator.userAgent);
1170        const isSafariBrowser = isSafari();
1171        const need3dFix = isSafariBrowser || isWebView && device.ios;
1172        return {
1173            isSafari: needPerspectiveFix || isSafariBrowser,
1174            needPerspectiveFix,
1175            need3dFix,
1176            isWebView
1177        };
1178    }
1179    function getBrowser() {
1180        if (!browser) browser = calcBrowser();
1181        return browser;
1182    }
1183    function Resize(_ref) {
1184        let {swiper, on, emit} = _ref;
1185        const window = ssr_window_esm_getWindow();
1186        let observer = null;
1187        let animationFrame = null;
1188        const resizeHandler = () => {
1189            if (!swiper || swiper.destroyed || !swiper.initialized) return;
1190            emit("beforeResize");
1191            emit("resize");
1192        };
1193        const createObserver = () => {
1194            if (!swiper || swiper.destroyed || !swiper.initialized) return;
1195            observer = new ResizeObserver((entries => {
1196                animationFrame = window.requestAnimationFrame((() => {
1197                    const {width, height} = swiper;
1198                    let newWidth = width;
1199                    let newHeight = height;
1200                    entries.forEach((_ref2 => {
1201                        let {contentBoxSize, contentRect, target} = _ref2;
1202                        if (target && target !== swiper.el) return;
1203                        newWidth = contentRect ? contentRect.width : (contentBoxSize[0] || contentBoxSize).inlineSize;
1204                        newHeight = contentRect ? contentRect.height : (contentBoxSize[0] || contentBoxSize).blockSize;
1205                    }));
1206                    if (newWidth !== width || newHeight !== height) resizeHandler();
1207                }));
1208            }));
1209            observer.observe(swiper.el);
1210        };
1211        const removeObserver = () => {
1212            if (animationFrame) window.cancelAnimationFrame(animationFrame);
1213            if (observer && observer.unobserve && swiper.el) {
1214                observer.unobserve(swiper.el);
1215                observer = null;
1216            }
1217        };
1218        const orientationChangeHandler = () => {
1219            if (!swiper || swiper.destroyed || !swiper.initialized) return;
1220            emit("orientationchange");
1221        };
1222        on("init", (() => {
1223            if (swiper.params.resizeObserver && typeof window.ResizeObserver !== "undefined") {
1224                createObserver();
1225                return;
1226            }
1227            window.addEventListener("resize", resizeHandler);
1228            window.addEventListener("orientationchange", orientationChangeHandler);
1229        }));
1230        on("destroy", (() => {
1231            removeObserver();
1232            window.removeEventListener("resize", resizeHandler);
1233            window.removeEventListener("orientationchange", orientationChangeHandler);
1234        }));
1235    }
1236    function Observer(_ref) {
1237        let {swiper, extendParams, on, emit} = _ref;
1238        const observers = [];
1239        const window = ssr_window_esm_getWindow();
1240        const attach = function(target, options) {
1241            if (options === void 0) options = {};
1242            const ObserverFunc = window.MutationObserver || window.WebkitMutationObserver;
1243            const observer = new ObserverFunc((mutations => {
1244                if (swiper.__preventObserver__) return;
1245                if (mutations.length === 1) {
1246                    emit("observerUpdate", mutations[0]);
1247                    return;
1248                }
1249                const observerUpdate = function observerUpdate() {
1250                    emit("observerUpdate", mutations[0]);
1251                };
1252                if (window.requestAnimationFrame) window.requestAnimationFrame(observerUpdate); else window.setTimeout(observerUpdate, 0);
1253            }));
1254            observer.observe(target, {
1255                attributes: typeof options.attributes === "undefined" ? true : options.attributes,
1256                childList: swiper.isElement || (typeof options.childList === "undefined" ? true : options).childList,
1257                characterData: typeof options.characterData === "undefined" ? true : options.characterData
1258            });
1259            observers.push(observer);
1260        };
1261        const init = () => {
1262            if (!swiper.params.observer) return;
1263            if (swiper.params.observeParents) {
1264                const containerParents = utils_elementParents(swiper.hostEl);
1265                for (let i = 0; i < containerParents.length; i += 1) attach(containerParents[i]);
1266            }
1267            attach(swiper.hostEl, {
1268                childList: swiper.params.observeSlideChildren
1269            });
1270            attach(swiper.wrapperEl, {
1271                attributes: false
1272            });
1273        };
1274        const destroy = () => {

1275            observers.forEach((observer => {
1276                observer.disconnect();
1277            }));
1278            observers.splice(0, observers.length);
1279        };
1280        extendParams({
1281            observer: false,
1282            observeParents: false,
1283            observeSlideChildren: false
1284        });
1285        on("init", init);
1286        on("destroy", destroy);
1287    }
1288    var eventsEmitter = {
1289        on(events, handler, priority) {
1290            const self = this;
1291            if (!self.eventsListeners || self.destroyed) return self;
1292            if (typeof handler !== "function") return self;
1293            const method = priority ? "unshift" : "push";
1294            events.split(" ").forEach((event => {
1295                if (!self.eventsListeners[event]) self.eventsListeners[event] = [];
1296                self.eventsListeners[event][method](handler);
1297            }));
1298            return self;
1299        },
1300        once(events, handler, priority) {
1301            const self = this;
1302            if (!self.eventsListeners || self.destroyed) return self;
1303            if (typeof handler !== "function") return self;
1304            function onceHandler() {
1305                self.off(events, onceHandler);
1306                if (onceHandler.__emitterProxy) delete onceHandler.__emitterProxy;
1307                for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) args[_key] = arguments[_key];
1308                handler.apply(self, args);
1309            }
1310            onceHandler.__emitterProxy = handler;
1311            return self.on(events, onceHandler, priority);
1312        },
1313        onAny(handler, priority) {
1314            const self = this;
1315            if (!self.eventsListeners || self.destroyed) return self;
1316            if (typeof handler !== "function") return self;
1317            const method = priority ? "unshift" : "push";
1318            if (self.eventsAnyListeners.indexOf(handler) < 0) self.eventsAnyListeners[method](handler);
1319            return self;
1320        },
1321        offAny(handler) {
1322            const self = this;
1323            if (!self.eventsListeners || self.destroyed) return self;
1324            if (!self.eventsAnyListeners) return self;
1325            const index = self.eventsAnyListeners.indexOf(handler);
1326            if (index >= 0) self.eventsAnyListeners.splice(index, 1);
1327            return self;
1328        },
1329        off(events, handler) {
1330            const self = this;
1331            if (!self.eventsListeners || self.destroyed) return self;
1332            if (!self.eventsListeners) return self;
1333            events.split(" ").forEach((event => {
1334                if (typeof handler === "undefined") self.eventsListeners[event] = []; else if (self.eventsListeners[event]) self.eventsListeners[event].forEach(((eventHandler, index) => {
1335                    if (eventHandler === handler || eventHandler.__emitterProxy && eventHandler.__emitterProxy === handler) self.eventsListeners[event].splice(index, 1);
1336                }));
1337            }));
1338            return self;
1339        },
1340        emit() {
1341            const self = this;
1342            if (!self.eventsListeners || self.destroyed) return self;
1343            if (!self.eventsListeners) return self;
1344            let events;
1345            let data;
1346            let context;
1347            for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) args[_key2] = arguments[_key2];
1348            if (typeof args[0] === "string" || Array.isArray(args[0])) {
1349                events = args[0];
1350                data = args.slice(1, args.length);
1351                context = self;
1352            } else {
1353                events = args[0].events;
1354                data = args[0].data;
1355                context = args[0].context || self;
1356            }
1357            data.unshift(context);
1358            const eventsArray = Array.isArray(events) ? events : events.split(" ");
1359            eventsArray.forEach((event => {
1360                if (self.eventsAnyListeners && self.eventsAnyListeners.length) self.eventsAnyListeners.forEach((eventHandler => {
1361                    eventHandler.apply(context, [ event, ...data ]);
1362                }));
1363                if (self.eventsListeners && self.eventsListeners[event]) self.eventsListeners[event].forEach((eventHandler => {
1364                    eventHandler.apply(context, data);
1365                }));
1366            }));
1367            return self;
1368        }
1369    };
1370    function updateSize() {
1371        const swiper = this;
1372        let width;
1373        let height;
1374        const el = swiper.el;
1375        if (typeof swiper.params.width !== "undefined" && swiper.params.width !== null) width = swiper.params.width; else width = el.clientWidth;
1376        if (typeof swiper.params.height !== "undefined" && swiper.params.height !== null) height = swiper.params.height; else height = el.clientHeight;
1377        if (width === 0 && swiper.isHorizontal() || height === 0 && swiper.isVertical()) return;
1378        width = width - parseInt(elementStyle(el, "padding-left") || 0, 10) - parseInt(elementStyle(el, "padding-right") || 0, 10);
1379        height = height - parseInt(elementStyle(el, "padding-top") || 0, 10) - parseInt(elementStyle(el, "padding-bottom") || 0, 10);
1380        if (Number.isNaN(width)) width = 0;
1381        if (Number.isNaN(height)) height = 0;
1382        Object.assign(swiper, {
1383            width,
1384            height,
1385            size: swiper.isHorizontal() ? width : height
1386        });
1387    }
1388    function updateSlides() {
1389        const swiper = this;
1390        function getDirectionPropertyValue(node, label) {
1391            return parseFloat(node.getPropertyValue(swiper.getDirectionLabel(label)) || 0);
1392        }
1393        const params = swiper.params;
1394        const {wrapperEl, slidesEl, size: swiperSize, rtlTranslate: rtl, wrongRTL} = swiper;
1395        const isVirtual = swiper.virtual && params.virtual.enabled;
1396        const previousSlidesLength = isVirtual ? swiper.virtual.slides.length : swiper.slides.length;
1397        const slides = utils_elementChildren(slidesEl, `.${swiper.params.slideClass}, swiper-slide`);
1398        const slidesLength = isVirtual ? swiper.virtual.slides.length : slides.length;
1399        let snapGrid = [];
1400        const slidesGrid = [];
1401        const slidesSizesGrid = [];
1402        let offsetBefore = params.slidesOffsetBefore;
1403        if (typeof offsetBefore === "function") offsetBefore = params.slidesOffsetBefore.call(swi

1403per);
1404        let offsetAfter = params.slidesOffsetAfter;
1405        if (typeof offsetAfter === "function") offsetAfter = params.slidesOffsetAfter.call(swiper);
1406        const previousSnapGridLength = swiper.snapGrid.length;
1407        const previousSlidesGridLength = swiper.slidesGrid.length;
1408        let spaceBetween = params.spaceBetween;
1409        let slidePosition = -offsetBefore;
1410        let prevSlideSize = 0;
1411        let index = 0;
1412        if (typeof swiperSize === "undefined") return;
1413        if (typeof spaceBetween === "string" && spaceBetween.indexOf("%") >= 0) spaceBetween = parseFloat(spaceBetween.replace("%", "")) / 100 * swiperSize; else if (typeof spaceBetween === "string") spaceBetween = parseFloat(spaceBetween);
1414        swiper.virtualSize = -spaceBetween;
1415        slides.forEach((slideEl => {
1416            if (rtl) slideEl.style.marginLeft = ""; else slideEl.style.marginRight = "";
1417            slideEl.style.marginBottom = "";
1418            slideEl.style.marginTop = "";
1419        }));
1420        if (params.centeredSlides && params.cssMode) {
1421            utils_setCSSProperty(wrapperEl, "--swiper-centered-offset-before", "");
1422            utils_setCSSProperty(wrapperEl, "--swiper-centered-offset-after", "");
1423        }
1424        const gridEnabled = params.grid && params.grid.rows > 1 && swiper.grid;
1425        if (gridEnabled) swiper.grid.initSlides(slides); else if (swiper.grid) swiper.grid.unsetSlides();
1426        let slideSize;
1427        const shouldResetSlideSize = params.slidesPerView === "auto" && params.breakpoints && Object.keys(params.breakpoints).filter((key => typeof params.breakpoints[key].slidesPerView !== "undefined")).length > 0;
1428        for (let i = 0; i < slidesLength; i += 1) {
1429            slideSize = 0;
1430            let slide;
1431            if (slides[i]) slide = slides[i];
1432            if (gridEnabled) swiper.grid.updateSlide(i, slide, slides);
1433            if (slides[i] && elementStyle(slide, "display") === "none") continue;
1434            if (params.slidesPerView === "auto") {
1435                if (shouldResetSlideSize) slides[i].style[swiper.getDirectionLabel("width")] = ``;
1436                const slideStyles = getComputedStyle(slide);
1437                const currentTransform = slide.style.transform;
1438                const currentWebKitTransform = slide.style.webkitTransform;
1439                if (currentTransform) slide.style.transform = "none";
1440                if (currentWebKitTransform) slide.style.webkitTransform = "none";
1441                if (params.roundLengths) slideSize = swiper.isHorizontal() ? elementOuterSize(slide, "width", true) : elementOuterSize(slide, "height", true); else {
1442                    const width = getDirectionPropertyValue(slideStyles, "width");
1443                    const paddingLeft = getDirectionPropertyValue(slideStyles, "padding-left");
1444                    const paddingRight = getDirectionPropertyValue(slideStyles, "padding-right");
1445                    const marginLeft = getDirectionPropertyValue(slideStyles, "margin-left");
1446                    const marginRight = getDirectionPropertyValue(slideStyles, "margin-right");
1447                    const boxSizing = slideStyles.getPropertyValue("box-sizing");
1448                    if (boxSizing && boxSizing === "border-box") slideSize = width + marginLeft + marginRight; else {
1449                        const {clientWidth, offsetWidth} = slide;
1450                        slideSize = width + paddingLeft + paddingRight + marginLeft + marginRight + (offsetWidth - clientWidth);
1451                    }
1452                }
1453                if (currentTransform) slide.style.transform = currentTransform;
1454                if (currentWebKitTransform) slide.style.webkitTransform = currentWebKitTransform;
1455                if (params.roundLengths) slideSize = Math.floor(slideSize);
1456            } else {
1457                slideSize = (swiperSize - (params.slidesPerView - 1) * spaceBetween) / params.slidesPerView;
1458                if (params.roundLengths) slideSize = Math.floor(slideSize);
1459                if (slides[i]) slides[i].style[swiper.getDirectionLabel("width")] = `${slideSize}px`;
1460            }
1461            if (slides[i]) slides[i].swiperSlideSize = slideSize;
1462            slidesSizesGrid.push(slideSize);
1463            if (params.centeredSlides) {
1464                slidePosition = slidePosition + slideSize / 2 + prevSlideSize / 2 + spaceBetween;
1465                if (prevSlideSize === 0 && i !== 0) slidePosition = slidePosition - swiperSize / 2 - spaceBetween;
1466                if (i === 0) slidePosition = slidePosition - swiperSize / 2 - spaceBetween;
1467                if (Math.abs(slidePosition) < 1 / 1e3) slidePosition = 0;
1468                if (params.roundLengths) slidePosition = Math.floor(slidePosition);
1469                if (index % params.slidesPerGroup === 0) snapGrid.push(slidePosition);
1470                slidesGrid.push(slidePosition);
1471            } else {
1472                if (params.roundLengths) slidePosition = Math.floor(slidePosition);
1473                if ((index - Math.min(swiper.params.slidesPerGroupSkip, index)) % swiper.params.slidesPerGroup === 0) snapGrid.push(slidePosition);
1474                slidesGrid.push(slidePosition);
1475                slidePosition = slidePosition + slideSize + spaceBetween;
1476            }
1477            swiper.virtualSize += slideSize + spaceBetween;
1478            prevSlideSize = slideSize;
1479            index += 1;
1480        }
1481        swiper.virtualSize = Math.max(swiper.virtualSize, swiperSize) + offsetAfter;
1482        if (rtl && wrongRTL && (params.effect === "slide" || params.effect === "coverflow")) wrapperEl.style.width = `${swiper.virtualSize + spaceBetween}px`;
1483        if (params.setWrapperSize) wrapperEl.style[swiper.getDirectionLabel("width")] = `${swiper.virtualSize + spaceBetween}px`;
1484        if (gridEnabled) swiper.grid.updateWrapperSize(slideSize, snapGrid);
1485        if (!params.centeredSlides) {
1486            const newSlidesGrid = [];
1487            for (let i = 0; i < snapGrid.length; i += 1) {
1488                let slidesGridItem = snapGrid[i];
1489                if (params.roundLengths) slidesGridItem = Math.floor(slidesGridItem);

1490                if (snapGrid[i] <= swiper.virtualSize - swiperSize) newSlidesGrid.push(slidesGridItem);
1491            }
1492            snapGrid = newSlidesGrid;
1493            if (Math.floor(swiper.virtualSize - swiperSize) - Math.floor(snapGrid[snapGrid.length - 1]) > 1) snapGrid.push(swiper.virtualSize - swiperSize);
1494        }
1495        if (isVirtual && params.loop) {
1496            const size = slidesSizesGrid[0] + spaceBetween;
1497            if (params.slidesPerGroup > 1) {
1498                const groups = Math.ceil((swiper.virtual.slidesBefore + swiper.virtual.slidesAfter) / params.slidesPerGroup);
1499                const groupSize = size * params.slidesPerGroup;
1500                for (let i = 0; i < groups; i += 1) snapGrid.push(snapGrid[snapGrid.length - 1] + groupSize);
1501            }
1502            for (let i = 0; i < swiper.virtual.slidesBefore + swiper.virtual.slidesAfter; i += 1) {
1503                if (params.slidesPerGroup === 1) snapGrid.push(snapGrid[snapGrid.length - 1] + size);
1504                slidesGrid.push(slidesGrid[slidesGrid.length - 1] + size);
1505                swiper.virtualSize += size;
1506            }
1507        }
1508        if (snapGrid.length === 0) snapGrid = [ 0 ];
1509        if (spaceBetween !== 0) {
1510            const key = swiper.isHorizontal() && rtl ? "marginLeft" : swiper.getDirectionLabel("marginRight");
1511            slides.filter(((_, slideIndex) => {
1512                if (!params.cssMode || params.loop) return true;
1513                if (slideIndex === slides.length - 1) return false;
1514                return true;
1515            })).forEach((slideEl => {
1516                slideEl.style[key] = `${spaceBetween}px`;
1517            }));
1518        }
1519        if (params.centeredSlides && params.centeredSlidesBounds) {
1520            let allSlidesSize = 0;
1521            slidesSizesGrid.forEach((slideSizeValue => {
1522                allSlidesSize += slideSizeValue + (spaceBetween || 0);
1523            }));
1524            allSlidesSize -= spaceBetween;
1525            const maxSnap = allSlidesSize - swiperSize;
1526            snapGrid = snapGrid.map((snap => {
1527                if (snap <= 0) return -offsetBefore;
1528                if (snap > maxSnap) return maxSnap + offsetAfter;
1529                return snap;
1530            }));
1531        }
1532        if (params.centerInsufficientSlides) {
1533            let allSlidesSize = 0;
1534            slidesSizesGrid.forEach((slideSizeValue => {
1535                allSlidesSize += slideSizeValue + (spaceBetween || 0);
1536            }));
1537            allSlidesSize -= spaceBetween;
1538            const offsetSize = (params.slidesOffsetBefore || 0) + (params.slidesOffsetAfter || 0);
1539            if (allSlidesSize + offsetSize < swiperSize) {
1540                const allSlidesOffset = (swiperSize - allSlidesSize - offsetSize) / 2;
1541                snapGrid.forEach(((snap, snapIndex) => {
1542                    snapGrid[snapIndex] = snap - allSlidesOffset;
1543                }));
1544                slidesGrid.forEach(((snap, snapIndex) => {
1545                    slidesGrid[snapIndex] = snap + allSlidesOffset;
1546                }));
1547            }
1548        }
1549        Object.assign(swiper, {
1550            slides,
1551            snapGrid,
1552            slidesGrid,
1553            slidesSizesGrid
1554        });
1555        if (params.centeredSlides && params.cssMode && !params.centeredSlidesBounds) {
1556            utils_setCSSProperty(wrapperEl, "--swiper-centered-offset-before", `${-snapGrid[0]}px`);
1557            utils_setCSSProperty(wrapperEl, "--swiper-centered-offset-after", `${swiper.size / 2 - slidesSizesGrid[slidesSizesGrid.length - 1] / 2}px`);
1558            const addToSnapGrid = -swiper.snapGrid[0];
1559            const addToSlidesGrid = -swiper.slidesGrid[0];
1560            swiper.snapGrid = swiper.snapGrid.map((v => v + addToSnapGrid));
1561            swiper.slidesGrid = swiper.slidesGrid.map((v => v + addToSlidesGrid));
1562        }
1563        if (slidesLength !== previousSlidesLength) swiper.emit("slidesLengthChange");
1564        if (snapGrid.length !== previousSnapGridLength) {
1565            if (swiper.params.watchOverflow) swiper.checkOverflow();
1566            swiper.emit("snapGridLengthChange");
1567        }
1568        if (slidesGrid.length !== previousSlidesGridLength) swiper.emit("slidesGridLengthChange");
1569        if (params.watchSlidesProgress) swiper.updateSlidesOffset();
1570        swiper.emit("slidesUpdated");
1571        if (!isVirtual && !params.cssMode && (params.effect === "slide" || params.effect === "fade")) {
1572            const backFaceHiddenClass = `${params.containerModifierClass}backface-hidden`;
1573            const hasClassBackfaceClassAdded = swiper.el.classList.contains(backFaceHiddenClass);
1574            if (slidesLength <= params.maxBackfaceHiddenSlides) {
1575                if (!hasClassBackfaceClassAdded) swiper.el.classList.add(backFaceHiddenClass);
1576            } else if (hasClassBackfaceClassAdded) swiper.el.classList.remove(backFaceHiddenClass);
1577        }
1578    }
1579    function updateAutoHeight(speed) {
1580        const swiper = this;
1581        const activeSlides = [];
1582        const isVirtual = swiper.virtual && swiper.params.virtual.enabled;
1583        let newHeight = 0;
1584        let i;
1585        if (typeof speed === "number") swiper.setTransition(speed); else if (speed === true) swiper.setTransition(swiper.params.speed);
1586        const getSlideByIndex = index => {
1587            if (isVirtual) return swiper.slides[swiper.getSlideIndexByData(index)];
1588            return swiper.slides[index];
1589        };
1590        if (swiper.params.slidesPerView !== "auto" && swiper.params.slidesPerView > 1) if (swiper.params.centeredSlides) (swiper.visibleSlides || []).forEac

1590h((slide => {
1591            activeSlides.push(slide);
1592        })); else for (i = 0; i < Math.ceil(swiper.params.slidesPerView); i += 1) {
1593            const index = swiper.activeIndex + i;
1594            if (index > swiper.slides.length && !isVirtual) break;
1595            activeSlides.push(getSlideByIndex(index));
1596        } else activeSlides.push(getSlideByIndex(swiper.activeIndex));
1597        for (i = 0; i < activeSlides.length; i += 1) if (typeof activeSlides[i] !== "undefined") {
1598            const height = activeSlides[i].offsetHeight;
1599            newHeight = height > newHeight ? height : newHeight;
1600        }
1601        if (newHeight || newHeight === 0) swiper.wrapperEl.style.height = `${newHeight}px`;
1602    }
1603    function updateSlidesOffset() {
1604        const swiper = this;
1605        const slides = swiper.slides;
1606        const minusOffset = swiper.isElement ? swiper.isHorizontal() ? swiper.wrapperEl.offsetLeft : swiper.wrapperEl.offsetTop : 0;
1607        for (let i = 0; i < slides.length; i += 1) slides[i].swiperSlideOffset = (swiper.isHorizontal() ? slides[i].offsetLeft : slides[i].offsetTop) - minusOffset - swiper.cssOverflowAdjustment();
1608    }
1609    const toggleSlideClasses$1 = (slideEl, condition, className) => {
1610        if (condition && !slideEl.classList.contains(className)) slideEl.classList.add(className); else if (!condition && slideEl.classList.contains(className)) slideEl.classList.remove(className);
1611    };
1612    function updateSlidesProgress(translate) {
1613        if (translate === void 0) translate = this && this.translate || 0;
1614        const swiper = this;
1615        const params = swiper.params;
1616        const {slides, rtlTranslate: rtl, snapGrid} = swiper;
1617        if (slides.length === 0) return;
1618        if (typeof slides[0].swiperSlideOffset === "undefined") swiper.updateSlidesOffset();
1619        let offsetCenter = -translate;
1620        if (rtl) offsetCenter = translate;
1621        swiper.visibleSlidesIndexes = [];
1622        swiper.visibleSlides = [];
1623        let spaceBetween = params.spaceBetween;
1624        if (typeof spaceBetween === "string" && spaceBetween.indexOf("%") >= 0) spaceBetween = parseFloat(spaceBetween.replace("%", "")) / 100 * swiper.size; else if (typeof spaceBetween === "string") spaceBetween = parseFloat(spaceBetween);
1625        for (let i = 0; i < slides.length; i += 1) {
1626            const slide = slides[i];
1627            let slideOffset = slide.swiperSlideOffset;
1628            if (params.cssMode && params.centeredSlides) slideOffset -= slides[0].swiperSlideOffset;
1629            const slideProgress = (offsetCenter + (params.centeredSlides ? swiper.minTranslate() : 0) - slideOffset) / (slide.swiperSlideSize + spaceBetween);
1630            const originalSlideProgress = (offsetCenter - snapGrid[0] + (params.centeredSlides ? swiper.minTranslate() : 0) - slideOffset) / (slide.swiperSlideSize + spaceBetween);
1631            const slideBefore = -(offsetCenter - slideOffset);
1632            const slideAfter = slideBefore + swiper.slidesSizesGrid[i];
1633            const isFullyVisible = slideBefore >= 0 && slideBefore <= swiper.size - swiper.slidesSizesGrid[i];
1634            const isVisible = slideBefore >= 0 && slideBefore < swiper.size - 1 || slideAfter > 1 && slideAfter <= swiper.size || slideBefore <= 0 && slideAfter >= swiper.size;
1635            if (isVisible) {
1636                swiper.visibleSlides.push(slide);
1637                swiper.visibleSlidesIndexes.push(i);
1638            }

1639            toggleSlideClasses$1(slide, isVisible, params.slideVisibleClass);
1640            toggleSlideClasses$1(slide, isFullyVisible, params.slideFullyVisibleClass);
1641            slide.progress = rtl ? -slideProgress : slideProgress;
1642            slide.originalProgress = rtl ? -originalSlideProgress : originalSlideProgress;
1643        }
1644    }
1645    function updateProgress(translate) {
1646        const swiper = this;
1647        if (typeof translate === "undefined") {
1648            const multiplier = swiper.rtlTranslate ? -1 : 1;
1649            translate = swiper && swiper.translate && swiper.translate * multiplier || 0;
1650        }
1651        const params = swiper.params;
1652        const translatesDiff = swiper.maxTranslate() - swiper.minTranslate();
1653        let {progress, isBeginning, isEnd, progressLoop} = swiper;
1654        const wasBeginning = isBeginning;
1655        const wasEnd = isEnd;
1656        if (translatesDiff === 0) {
1657            progress = 0;
1658            isBeginning = true;
1659            isEnd = true;
1660        } else {
1661            progress = (translate - swiper.minTranslate()) / translatesDiff;
1662            const isBeginningRounded = Math.abs(translate - swiper.minTranslate()) < 1;
1663            const isEndRounded = Math.abs(translate - swiper.maxTranslate()) < 1;
1664            isBeginning = isBeginningRounded || progress <= 0;
1665            isEnd = isEndRounded || progress >= 1;
1666            if (isBeginningRounded) progress = 0;
1667            if (isEndRounded) progress = 1;
1668        }
1669        if (params.loop) {
1670            const firstSlideIndex = swiper.getSlideIndexByData(0);
1671            const lastSlideIndex = swiper.getSlideIndexByData(swiper.slides.length - 1);
1672            const firstSlideTranslate = swiper.slidesGrid[firstSlideIndex];
1673            const lastSlideTranslate = swiper.slidesGrid[lastSlideIndex];
1674            const translateMax = swiper.slidesGrid[swiper.slidesGrid.length - 1];
1675            const translateAbs = Math.abs(translate);
1676            if (translateAbs >= firstSlideTranslate) progressLoop = (translateAbs - firstSlideTranslate) / translateMax; else progressLoop = (translateAbs + translateMax - lastSlideTranslate) / translateMax;
1677            if (progressLoop > 1) progressLoop -= 1;
1678        }
1679        Object.assign(swiper, {
1680            progress,
1681            progressLoop,
1682            isBeginning,
1683            isEnd
1684        });
1685        if (params.watchSlidesProgress || params.centeredSlides && params.autoHeight) swiper.updateSlidesProgress(translate);
1686        if (isBeginning && !wasBeginning) swiper.emit("reachBeginning toEdge");
1687        if (isEnd && !wasEnd) swiper.emit("reachEnd toEdge");
1688        if (wasBeginning && !isBeginning || wasEnd && !isEnd) swiper.emit("fromEdge");
1689        swiper.emit("progress", progress);
1690    }
1691    const toggleSlideClasses = (slideEl, condition, className) => {
1692        if (condition && !slideEl.classList.contains(className)) slideEl.classList.add(className); else if (!condition && slideEl.classList.contains(className)) slideEl.classList.remove(className);
1693    };
1694    function updateSlidesClasses() {
1695        const swiper = this;
1696        const {slides, params, slidesEl, activeIndex} = swiper;
1697        const isVirtual = swiper.virtual && params.virtual.enabled;
1698        const gridEnabled = swiper.grid && params.grid && params.grid.rows > 1;
1699        const getFilteredSlide = selector => utils_elementChildren(slidesEl, `.${params.slideClass}${selector}, swiper-slide${selector}`)[0];
1700        let activeSlide;
1701        let prevSlide;
1702        let nextSlide;
1703        if (isVirtual) if (params.loop) {
1704            let slideIndex = activeIndex - swiper.virtual.slidesBefore;
1705            if (slideIndex < 0) slideIndex = swiper.virtual.slides.length + slideIndex;
1706            if (slideIndex >= swiper.virtual.slides.length) slideIndex -= swiper.virtual.slides.length;
1707            activeSlide = getFilteredSlide(`[data-swiper-slide-index="${slideIndex}"]`);
1708        } else activeSlide = getFilteredSlide(`[data-swiper-slide-index="${activeIndex}"]`); else if (gridEnabled) {
1709            activeSlide = slides.filter((slideEl => slideEl.column === activeIndex))[0];
1710            nextSlide = slides.filter((slideEl => slideEl.column === activeIndex + 1))[0];
1711            prevSlide = slides.filter((slideEl => slideEl.column === activeIndex - 1))[0];
1712        } else activeSlide = slides[activeIndex];
1713        if (activeSlide) if (!gridEnabled) {
1714            nextSlide = elementNextAll(activeSlide, `.${params.slideClass}, swiper-slide`)[0];
1715            if (params.loop && !nextSlide) nextSlide = slides[0];
1716            prevSlide = elementPrevAll(activeSlide, `.${params.slideClass}, swiper-slide`)[0];
1717            if (params.loop && !prevSlide === 0) prevSlide = slides[slides.length - 1];
1718        }

1719        slides.forEach((slideEl => {
1720            toggleSlideClasses(slideEl, slideEl === activeSlide, params.slideActiveClass);
1721            toggleSlideClasses(slideEl, slideEl === nextSlide, params.slideNextClass);
1722            toggleSlideClasses(slideEl, slideEl === prevSlide, params.slidePrevClass);
1723        }));
1724        swiper.emitSlidesClasses();
1725    }
1726    const processLazyPreloader = (swiper, imageEl) => {
1727        if (!swiper || swiper.destroyed || !swiper.params) return;
1728        const slideSelector = () => swiper.isElement ? `swiper-slide` : `.${swiper.params.slideClass}`;
1729        const slideEl = imageEl.closest(slideSelector());
1730        if (slideEl) {
1731            let lazyEl = slideEl.querySelector(`.${swiper.params.lazyPreloaderClass}`);
1732            if (!lazyEl && swiper.isElement) if (slideEl.shadowRoot) lazyEl = slideEl.shadowRoot.querySelector(`.${swiper.params.lazyPreloaderClass}`); else requestAnimationFrame((() => {
1733                if (slideEl.shadowRoot) {
1734                    lazyEl = slideEl.shadowRoot.querySelector(`.${swiper.params.lazyPreloaderClass}`);
1735                    if (lazyEl) lazyEl.remove();
1736                }
1737            }));
1738            if (lazyEl) lazyEl.remove();
1739        }
1740    };
1741    const unlazy = (swiper, index) => {
1742        if (!swiper.slides[index]) return;
1743        const imageEl = swiper.slides[index].querySelector('[loading="lazy"]');
1744        if (imageEl) imageEl.removeAttribute("loading");
1745    };
1746    const preload = swiper => {
1747        if (!swiper || swiper.destroyed || !swiper.params) return;
1748        let amount = swiper.params.lazyPreloadPrevNext;
1749        const len = swiper.slides.length;
1750        if (!len || !amount || amount < 0) return;
1751        amount = Math.min(amount, len);
1752        const slidesPerView = swiper.params.slidesPerView === "auto" ? swiper.slidesPerViewDynamic() : Math.ceil(swiper.params.slidesPerView);
1753        const activeIndex = swiper.activeIndex;
1754        if (swiper.params.grid && swiper.params.grid.rows > 1) {
1755            const activeColumn = activeIndex;
1756            const preloadColumns = [ activeColumn - amount ];
1757            preloadColumns.push(...Array.from({
1758                length: amount
1759            }).map(((_, i) => activeColumn + slidesPerView + i)));
1760            swiper.slides.forEach(((slideEl, i) => {
1761                if (preloadColumns.includes(slideEl.column)) unlazy(swiper, i);
1762            }));
1763            return;
1764        }
1765        const slideIndexLastInView = activeIndex + slidesPerView - 1;
1766        if (swiper.params.rewind || swiper.params.loop) for (let i = activeIndex - amount; i <= slideIndexLastInView + amount; i += 1) {
1767            const realIndex = (i % len + len) % len;
1768            if (realIndex < activeIndex || realIndex > slideIndexLastInView) unlazy(swiper, realIndex);
1769        } else for (let i = Math.max(activeIndex - amount, 0); i <= Math.min(slideIndexLastInView + amount, len - 1); i += 1) if (i !== activeIndex && (i > slideIndexLastInView || i < activeIndex)) unlazy(swiper, i);
1770    };
1771    function getActiveIndexByTranslate(swiper) {
1772        const {slidesGrid, params} = swiper;
1773        const translate = swiper.rtlTranslate ? swiper.translate : -swiper.translate;
1774        let activeIndex;
1775        for (let i = 0; i < slidesGrid.length; i += 1) if (typeof slidesGrid[i + 1] !== "undefined") {
1776            if (translate >= slidesGrid[i] && translate < slidesGrid[i + 1] - (slidesGrid[i + 1] - slidesGrid[i]) / 2) activeIndex = i; else if (translate >= slidesGrid[i] && translate < slidesGrid[i + 1]) activeIndex = i + 1;
1777        } else if (translate >= slidesGrid[i]) activeIndex = i;
1778        if (params.normalizeSlideIndex) if (activeIndex < 0 || typeof activeIndex === "undefined") activeIndex = 0;
1779        return activeIndex;
1780    }
1781    function updateActiveIndex(newActiveIndex) {
1782        const swiper = this;
1783        const translate = swiper.rtlTranslate ? swiper.translate : -swiper.translate;
1784        const {snapGrid, params, activeIndex: previousIndex, realIndex: previousRealIndex, snapIndex: previousSnapIndex} = swiper;
1785        let activeIndex = newActiveIndex;
1786        let snapIndex;
1787        const getVirtualRealIndex = aIndex => {
1788            let realIndex = aIndex - swiper.virtual.slidesBefore;
1789            if (realIndex < 0) realIndex = swiper.virtual.slides.length + realIndex;
1790            if (realIndex >= swiper.virtual.slides.length) realIndex -= swiper.virtual.slides.length;
1791            return realIndex;
1792        };
1793        if (typeof activeIndex === "undefined") activeIndex = getActiveIndexByTranslate(swiper);

1794        if (snapGrid.indexOf(translate) >= 0) snapIndex = snapGrid.indexOf(translate); else {
1795            const skip = Math.min(params.slidesPerGroupSkip, activeIndex);
1796            snapIndex = skip + Math.floor((activeIndex - skip) / params.slidesPerGroup);
1797        }
1798        if (snapIndex >= snapGrid.length) snapIndex = snapGrid.length - 1;
1799        if (activeIndex === previousIndex && !swiper.params.loop) {
1800            if (snapIndex !== previousSnapIndex) {
1801                swiper.snapIndex = snapIndex;
1802                swiper.emit("snapIndexChange");
1803            }
1804            return;
1805        }
1806        if (activeIndex === previousIndex && swiper.params.loop && swiper.virtual && swiper.params.virtual.enabled) {
1807            swiper.realIndex = getVirtualRealIndex(activeIndex);
1808            return;
1809        }
1810        const gridEnabled = swiper.grid && params.grid && params.grid.rows > 1;
1811        let realIndex;
1812        if (swiper.virtual && params.virtual.enabled && params.loop) realIndex = getVirtualRealIndex(activeIndex); else if (gridEnabled) {
1813            const firstSlideInColumn = swiper.slides.filter((slideEl => slideEl.column === activeIndex))[0];
1814            let activeSlideIndex = parseInt(firstSlideInColumn.getAttribute("data-swiper-slide-index"), 10);
1815            if (Number.isNaN(activeSlideIndex)) activeSlideIndex = Math.max(swiper.slides.indexOf(firstSlideInColumn), 0);
1816            realIndex = Math.floor(activeSlideIndex / params.grid.rows);
1817        } else if (swiper.slides[activeIndex]) {
1818            const slideIndex = swiper.slides[activeIndex].getAttribute("data-swiper-slide-index");
1819            if (slideIndex) realIndex = parseInt(slideIndex, 10); else realIndex = activeIndex;
1820        } else realIndex = activeIndex;
1821        Object.assign(swiper, {
1822            previousSnapIndex,
1823            snapIndex,
1824            previousRealIndex,
1825            realIndex,
1826            previousIndex,
1827            activeIndex
1828        });
1829        if (swiper.initialized) preload(swiper);
1830        swiper.emit("activeIndexChange");
1831        swiper.emit("snapIndexChange");
1832        if (swiper.initialized || swiper.params.runCallbacksOnInit) {
1833            if (previousRealIndex !== realIndex) swiper.emit("realIndexChange");
1834            swiper.emit("slideChange");
1835        }
1836    }
1837    function updateClickedSlide(el, path) {
1838        const swiper = this;
1839        const params = swiper.params;
1840        let slide = el.closest(`.${params.slideClass}, swiper-slide`);
1841        if (!slide && swiper.isElement && path && path.length > 1 && path.includes(el)) [ ...path.slice(path.indexOf(el) + 1, path.length) ].forEach((pathEl => {
1842            if (!slide && pathEl.matches && pathEl.matches(`.${params.slideClass}, swiper-slide`)) slide = pathEl;
1843        }));
1844        let slideFound = false;
1845        let slideIndex;
1846        if (slide) for (let i = 0; i < swiper.slides.length; i += 1) if (swiper.slides[i] === slide) {
1847            slideFound = true;
1848            slideIndex = i;
1849            break;
1850        }
1851        if (slide && slideFound) {
1852            swiper.clickedSlide = slide;
1853            if (swiper.virtual && swiper.params.virtual.enabled) swiper.clickedIndex = parseInt(slide.getAttribute("data-swiper-slide-index"), 10); else swiper.clickedIndex = slideIndex;
1854        } else {
1855            swiper.clickedSlide = void 0;
1856            swiper.clickedIndex = void 0;
1857            return;
1858        }
1859        if (params.slideToClickedSlide && swiper.clickedIndex !== void 0 && swiper.clickedIndex !== swiper.activeIndex) swiper.slideToClickedSlide();
1860    }
1861    var update = {
1862        updateSize,
1863        updateSlides,
1864        updateAutoHeight,
1865        updateSlidesOffset,
1866        updateSlidesProgress,
1867        updateProgress,
1868        updateSlidesClasses,
1869        updateActiveIndex,
1870        updateClickedSlide
1871    };
1872    function getSwiperTranslate(axis) {
1873        if (axis === void 0) axis = this.isHorizontal() ? "x" : "y";
1874        const swiper = this;
1875        const {params, rtlTranslate: rtl, translate, wrapperEl} = swiper;
1876        if (params.virtualTranslate) return rtl ? -translate : translate;
1877        if (params.cssMode) return translate;
1878        let currentTranslate = utils_getTranslate(wrapperEl, axis);
1879        currentTranslate += swiper.cssOverflowAdjustment();
1880        if (rtl) currentTranslate = -currentTranslate;
1881        return currentTranslate || 0;
1882    }
1883    function setTranslate(translate, byController) {
1884        const swiper = this;
1885        const {rtlTranslate: rtl, params, wrapperEl, progress} = swiper;
1886        let x = 0;
1887        let y = 0;
1888        const z = 0;
1889        if (swiper.isHorizontal()) x = rtl ? -translate : translate; else y = translate;
1890        if (params.roundLengths) {
1891            x = Math.floor(x);
1892            y = Math.floor(y);
1893        }
1894        swiper.previousTranslate = swiper.translate;
1895        swiper.translate = swiper.isHorizontal() ? x : y;
1896        if (params.cssMode) wrapperEl[swiper.isHorizontal() ? "scrollLeft" : "scrollTop"] = swiper.isHorizontal() ? -x : -y; else if (!params.virtualTranslate) {
1897            if (swiper.isHorizontal()) x -= swiper.cssOverflowAdjustment(); else y -= swiper.cssOverflowAdjustment();
1898            wrapperEl.style.transform = `translate3d(${x}px, ${y}px, ${z}px)`;
1899        }
1900        let newProgress;
1901        const translatesDiff = swiper.maxTranslate() - swiper.minTranslate();
1902        if (translatesDiff === 0) newProgress = 0; else newProgress = (translate - swiper.minTranslate()) / translatesDiff;
1903        if (newProgress !== progress) swiper.updateProgress(translate);
1904        swiper.emit("setTranslate", swiper.translate, byController);
1905    }
1906    function minTranslate() {
1907        return -this.snapGrid[0];
1908    }
1909    function maxTranslate() {
1910        return -this.snapGrid[this.snapGrid.length - 1];
1911    }
1912    function translateTo(translate, speed, runCallbacks, translateBounds, internal) {
1913        if (translate === void 0) translate = 0;
1914        if (speed === void 0) speed = this.params.speed;
1915        if (runCallbacks === void 0) runCallbacks = true;
1916        if (translateBounds === void 0) translateBounds = true;
1917        const swiper = this;
1918        const {params, wrapperEl} = swiper;
1919        if (swiper.animating && params.preventInteractionOnTransition) return false;

1920        const minTranslate = swiper.minTranslate();
1921        const maxTranslate = swiper.maxTranslate();
1922        let newTranslate;
1923        if (translateBounds && translate > minTranslate) newTranslate = minTranslate; else if (translateBounds && translate < maxTranslate) newTranslate = maxTranslate; else newTranslate = translate;
1924        swiper.updateProgress(newTranslate);
1925        if (params.cssMode) {
1926            const isH = swiper.isHorizontal();
1927            if (speed === 0) wrapperEl[isH ? "scrollLeft" : "scrollTop"] = -newTranslate; else {
1928                if (!swiper.support.smoothScroll) {
1929                    animateCSSModeScroll({
1930                        swiper,
1931                        targetPosition: -newTranslate,
1932                        side: isH ? "left" : "top"
1933                    });
1934                    return true;
1935                }
1936                wrapperEl.scrollTo({
1937                    [isH ? "left" : "top"]: -newTranslate,
1938                    behavior: "smooth"
1939                });
1940            }
1941            return true;
1942        }
1943        if (speed === 0) {
1944            swiper.setTransition(0);
1945            swiper.setTranslate(newTranslate);
1946            if (runCallbacks) {
1947                swiper.emit("beforeTransitionStart", speed, internal);
1948                swiper.emit("transitionEnd");
1949            }
1950        } else {
1951            swiper.setTransition(speed);
1952            swiper.setTranslate(newTranslate);
1953            if (runCallbacks) {
1954                swiper.emit("beforeTransitionStart", speed, internal);
1955                swiper.emit("transitionStart");
1956            }
1957            if (!swiper.animating) {
1958                swiper.animating = true;
1959                if (!swiper.onTranslateToWrapperTransitionEnd) swiper.onTranslateToWrapperTransitionEnd = function transitionEnd(e) {
1960                    if (!swiper || swiper.destroyed) return;
1961                    if (e.target !== this) return;
1962                    swiper.wrapperEl.removeEventListener("transitionend", swiper.onTranslateToWrapperTransitionEnd);
1963                    swiper.onTranslateToWrapperTransitionEnd = null;
1964                    delete swiper.onTranslateToWrapperTransitionEnd;
1965                    swiper.animating = false;
1966                    if (runCallbacks) swiper.emit("transitionEnd");
1967                };
1968                swiper.wrapperEl.addEventListener("transitionend", swiper.onTranslateToWrapperTransitionEnd);
1969            }
1970        }
1971        return true;
1972    }
1973    var translate = {
1974        getTranslate: getSwiperTranslate,
1975        setTranslate,
1976        minTranslate,
1977        maxTranslate,
1978        translateTo
1979    };
1980    function setTransition(duration, byController) {
1981        const swiper = this;
1982        if (!swiper.params.cssMode) {
1983            swiper.wrapperEl.style.transitionDuration = `${duration}ms`;
1984            swiper.wrapperEl.style.transitionDelay = duration === 0 ? `0ms` : "";
1985        }
1986        swiper.emit("setTransition", duration, byController);
1987    }
1988    function transitionEmit(_ref) {
1989        let {swiper, runCallbacks, direction, step} = _ref;
1990        const {activeIndex, previousIndex} = swiper;
1991        let dir = direction;
1992        if (!dir) if (activeIndex > previousIndex) dir = "next"; else if (activeIndex < previousIndex) dir = "prev"; else dir = "reset";
1993        swiper.emit(`transition${step}`);
1994        if (runCallbacks && activeIndex !== previousIndex) {
1995            if (dir === "reset") {
1996                swiper.emit(`slideResetTransition${step}`);
1997                return;
1998            }
1999            swiper.emit(`slideChangeTransition${step}`);
2000            if (dir === "next") swiper.emit(`slideNextTransition${step}`); else swiper.emit(`slidePrevTransition${step}`);
2001        }
2002    }
2003    function transitionStart(runCallbacks, direction) {
2004        if (runCallbacks === void 0) runCallbacks = true;
2005        const swiper = this;
2006        const {params} = swiper;
2007        if (params.cssMode) return;
2008        if (params.autoHeight) swiper.updateAutoHeight();
2009        transitionEmit({
2010            swiper,
2011            runCallbacks,
2012            direction,
2013            step: "Start"
2014        });
2015    }
2016    function transitionEnd(runCallbacks, direction) {
2017        if (runCallbacks === void 0) runCallbacks = true;
2018        const swiper = this;
2019        const {params} = swiper;
2020        swiper.animating = false;

2021        if (params.cssMode) return;
2022        swiper.setTransition(0);
2023        transitionEmit({
2024            swiper,
2025            runCallbacks,
2026            direction,
2027            step: "End"
2028        });
2029    }
2030    var transition = {
2031        setTransition,
2032        transitionStart,
2033        transitionEnd
2034    };
2035    function slideTo(index, speed, runCallbacks, internal, initial) {
2036        if (index === void 0) index = 0;
2037        if (runCallbacks === void 0) runCallbacks = true;
2038        if (typeof index === "string") index = parseInt(index, 10);
2039        const swiper = this;
2040        let slideIndex = index;
2041        if (slideIndex < 0) slideIndex = 0;
2042        const {params, snapGrid, slidesGrid, previousIndex, activeIndex, rtlTranslate: rtl, wrapperEl, enabled} = swiper;
2043        if (!enabled && !internal && !initial || swiper.destroyed || swiper.animating && params.preventInteractionOnTransition) return false;
2044        if (typeof speed === "undefined") speed = swiper.params.speed;
2045        const skip = Math.min(swiper.params.slidesPerGroupSkip, slideIndex);
2046        let snapIndex = skip + Math.floor((slideIndex - skip) / swiper.params.slidesPerGroup);
2047        if (snapIndex >= snapGrid.length) snapIndex = snapGrid.length - 1;
2048        const translate = -snapGrid[snapIndex];
2049        if (params.normalizeSlideIndex) for (let i = 0; i < slidesGrid.length; i += 1) {
2050            const normalizedTranslate = -Math.floor(translate * 100);
2051            const normalizedGrid = Math.floor(slidesGrid[i] * 100);
2052            const normalizedGridNext = Math.floor(slidesGrid[i + 1] * 100);
2053            if (typeof slidesGrid[i + 1] !== "undefined") {
2054                if (normalizedTranslate >= normalizedGrid && normalizedTranslate < normalizedGridNext - (normalizedGridNext - normalizedGrid) / 2) slideIndex = i; else if (normalizedTranslate >= normalizedGrid && normalizedTranslate < normalizedGridNext) slideIndex = i + 1;
2055            } else if (normalizedTranslate >= normalizedGrid) slideIndex = i;
2056        }
2057        if (swiper.initialized && slideIndex !== activeIndex) {
2058            if (!swiper.allowSlideNext && (rtl ? translate > swiper.translate && translate > swiper.minTranslate() : translate < swiper.translate && translate < swiper.minTranslate())) return false;
2059            if (!swiper.allowSlidePrev && translate > swiper.translate && translate > swiper.maxTranslate()) if ((activeIndex || 0) !== slideIndex) return false;
2060        }
2061        if (slideIndex !== (previousIndex || 0) && runCallbacks) swiper.emit("beforeSlideChangeStart");
2062        swiper.updateProgress(translate);
2063        let direction;
2064        if (slideIndex > activeIndex) direction = "next"; else if (slideIndex < activeIndex) direction = "prev"; else direction = "reset";
2065        if (rtl && -translate === swiper.translate || !rtl && translate === swiper.translate) {
2066            swiper.updateActiveIndex(slideIndex);
2067            if (params.autoHeight) swiper.updateAutoHeight();
2068            swiper.updateSlidesClasses();
2069            if (params.effect !== "slide") swiper.setTranslate(translate);
2070            if (direction !== "reset") {
2071                swiper.transitionStart(runCallbacks, direction);
2072                swiper.transitionEnd(runCallbacks, direction);
2073            }
2074            return false;
2075        }
2076        if (params.cssMode) {
2077            const isH = swiper.isHorizontal();
2078            const t = rtl ? translate : -translate;
2079            if (speed === 0) {
2080                const isVirtual = swiper.virtual && swiper.params.virtual.enabled;
2081                if (isVirtual) {
2082                    swiper.wrapperEl.style.scrollSnapType = "none";
2083                    swiper._immediateVirtual = true;
2084                }
2085                if (isVirtual && !swiper._cssModeVirtualInitialSet && swiper.params.initialSlide > 0) {
2086                    swiper._cssModeVirtualInitialSet = true;
2087                    requestAnimationFrame((() => {
2088                        wrapperEl[isH ? "scrollLeft" : "scrollTop"] = t;
2089                    }));
2090                } else wrapperEl[isH ? "scrollLeft" : "scrollTop"] = t;
2091                if (isVirtual) requestAnimationFrame((() => {
2092                    swiper.wrapperEl.style.scrollSnapType = "";
2093                    swiper._immediateVirtual = false;

2094                }));
2095            } else {
2096                if (!swiper.support.smoothScroll) {
2097                    animateCSSModeScroll({
2098                        swiper,
2099                        targetPosition: t,
2100                        side: isH ? "left" : "top"
2101                    });
2102                    return true;
2103                }
2104                wrapperEl.scrollTo({
2105                    [isH ? "left" : "top"]: t,
2106                    behavior: "smooth"
2107                });
2108            }
2109            return true;
2110        }
2111        swiper.setTransition(speed);
2112        swiper.setTranslate(translate);
2113        swiper.updateActiveIndex(slideIndex);
2114        swiper.updateSlidesClasses();
2115        swiper.emit("beforeTransitionStart", speed, internal);
2116        swiper.transitionStart(runCallbacks, direction);
2117        if (speed === 0) swiper.transitionEnd(runCallbacks, direction); else if (!swiper.animating) {
2118            swiper.animating = true;
2119            if (!swiper.onSlideToWrapperTransitionEnd) swiper.onSlideToWrapperTransitionEnd = function transitionEnd(e) {
2120                if (!swiper || swiper.destroyed) return;
2121                if (e.target !== this) return;
2122                swiper.wrapperEl.removeEventListener("transitionend", swiper.onSlideToWrapperTransitionEnd);
2123                swiper.onSlideToWrapperTransitionEnd = null;
2124                delete swiper.onSlideToWrapperTransitionEnd;
2125                swiper.transitionEnd(runCallbacks, direction);
2126            };
2127            swiper.wrapperEl.addEventListener("transitionend", swiper.onSlideToWrapperTransitionEnd);
2128        }
2129        return true;
2130    }
2131    function slideToLoop(index, speed, runCallbacks, internal) {
2132        if (index === void 0) index = 0;
2133        if (runCallbacks === void 0) runCallbacks = true;
2134        if (typeof index === "string") {
2135            const indexAsNumber = parseInt(index, 10);
2136            index = indexAsNumber;
2137        }
2138        const swiper = this;
2139        if (swiper.destroyed) return;
2140        if (typeof speed === "undefined") speed = swiper.params.speed;
2141        const gridEnabled = swiper.grid && swiper.params.grid && swiper.params.grid.rows > 1;
2142        let newIndex = index;
2143        if (swiper.params.loop) if (swiper.virtual && swiper.params.virtual.enabled) newIndex += swiper.virtual.slidesBefore; else {
2144            let targetSlideIndex;
2145            if (gridEnabled) {
2146                const slideIndex = newIndex * swiper.params.grid.rows;
2147                targetSlideIndex = swiper.slides.filter((slideEl => slideEl.getAttribute("data-swiper-slide-index") * 1 === slideIndex))[0].column;
2148            } else targetSlideIndex = swiper.getSlideIndexByData(newIndex);
2149            const cols = gridEnabled ? Math.ceil(swiper.slides.length / swiper.params.grid.rows) : swiper.slides.length;
2150            const {centeredSlides} = swiper.params;
2151            let slidesPerView = swiper.params.slidesPerView;
2152            if (slidesPerView === "auto") slidesPerView = swiper.slidesPerViewDynamic(); else {
2153                slidesPerView = Math.ceil(parseFloat(swiper.params.slidesPerView, 10));
2154                if (centeredSlides && slidesPerView % 2 === 0) slidesPerView += 1;
2155            }
2156            let needLoopFix = cols - targetSlideIndex < slidesPerView;
2157            if (centeredSlides) needLoopFix = needLoopFix || targetSlideIndex < Math.ceil(slidesPerView / 2);
2158            if (internal && centeredSlides && swiper.params.slidesPerView !== "auto" && !gridEnabled) needLoopFix = false;
2159            if (needLoopFix) {
2160                const direction = centeredSlides ? targetSlideIndex < swiper.activeIndex ? "prev" : "next" : targetSlideIndex - swiper.activeIndex - 1 < swiper.params.slidesPerView ? "next" : "prev";
2161                swiper.loopFix({
2162                    direction,
2163                    slideTo: true,
2164                    activeSlideIndex: direction === "next" ? targetSlideIndex + 1 : targetSlideIndex - cols + 1,
2165                    slideRealIndex: direction === "next" ? swiper.realIndex : void 0
2166                });
2167            }
2168            if (gridEnabled) {
2169                const slideIndex = newIndex * swiper.params.grid.rows;
2170                newIndex = swiper.slides.filter((slideEl => slideEl.getAttribute("data-swiper-slide-index") * 1 === slideIndex))[0].c

2170olumn;
2171            } else newIndex = swiper.getSlideIndexByData(newIndex);
2172        }
2173        requestAnimationFrame((() => {
2174            swiper.slideTo(newIndex, speed, runCallbacks, internal);
2175        }));
2176        return swiper;
2177    }
2178    function slideNext(speed, runCallbacks, internal) {
2179        if (runCallbacks === void 0) runCallbacks = true;
2180        const swiper = this;
2181        const {enabled, params, animating} = swiper;
2182        if (!enabled || swiper.destroyed) return swiper;
2183        if (typeof speed === "undefined") speed = swiper.params.speed;
2184        let perGroup = params.slidesPerGroup;
2185        if (params.slidesPerView === "auto" && params.slidesPerGroup === 1 && params.slidesPerGroupAuto) perGroup = Math.max(swiper.slidesPerViewDynamic("current", true), 1);
2186        const increment = swiper.activeIndex < params.slidesPerGroupSkip ? 1 : perGroup;
2187        const isVirtual = swiper.virtual && params.virtual.enabled;
2188        if (params.loop) {
2189            if (animating && !isVirtual && params.loopPreventsSliding) return false;
2190            swiper.loopFix({
2191                direction: "next"
2192            });
2193            swiper._clientLeft = swiper.wrapperEl.clientLeft;
2194            if (swiper.activeIndex === swiper.slides.length - 1 && params.cssMode) {
2195                requestAnimationFrame((() => {
2196                    swiper.slideTo(swiper.activeIndex + increment, speed, runCallbacks, internal);
2197                }));
2198                return true;
2199            }
2200        }
2201        if (params.rewind && swiper.isEnd) return swiper.slideTo(0, speed, runCallbacks, internal);
2202        return swiper.slideTo(swiper.activeIndex + increment, speed, runCallbacks, internal);
2203    }
2204    function slidePrev(speed, runCallbacks, internal) {
2205        if (runCallbacks === void 0) runCallbacks = true;
2206        const swiper = this;
2207        const {params, snapGrid, slidesGrid, rtlTranslate, enabled, animating} = swiper;
2208        if (!enabled || swiper.destroyed) return swiper;
2209        if (typeof speed === "undefined") speed = swiper.params.speed;
2210        const isVirtual = swiper.virtual && params.virtual.enabled;
2211        if (params.loop) {
2212            if (animating && !isVirtual && params.loopPreventsSliding) return false;
2213            swiper.loopFix({
2214                direction: "prev"
2215            });
2216            swiper._clientLeft = swiper.wrapperEl.clientLeft;
2217        }
2218        const translate = rtlTranslate ? swiper.translate : -swiper.translate;
2219        function normalize(val) {
2220            if (val < 0) return -Math.floor(Math.abs(val));
2221            return Math.floor(val);
2222        }
2223        const normalizedTranslate = normalize(translate);
2224        const normalizedSnapGrid = snapGrid.map((val => normalize(val)));
2225        let prevSnap = snapGrid[normalizedSnapGrid.indexOf(normalizedTranslate) - 1];
2226        if (typeof prevSnap === "undefined" && params.cssMode) {
2227            let prevSnapIndex;
2228            snapGrid.forEach(((snap, snapIndex) => {
2229                if (normalizedTranslate >= snap) prevSnapIndex = snapIndex;
2230            }));
2231            if (typeof prevSnapIndex !== "undefined") prevSnap = snapGrid[prevSnapIndex > 0 ? prevSnapIndex - 1 : prevSnapIndex];
2232        }
2233        let prevIndex = 0;
2234        if (typeof prevSnap !== "undefined") {
2235            prevIndex = slidesGrid.indexOf(prevSnap);
2236            if (prevIndex < 0) prevIndex = swiper.activeIndex - 1;
2237            if (params.slidesPerView === "auto" && params.slidesPerGroup === 1 && params.slidesPerGroupAuto) {
2238                prevIndex = prevIndex - swiper.slidesPerViewDynamic("previous", true) + 1;
2239                prevIndex = Math.max(prevIndex, 0);
2240            }
2241        }
2242        if (params.rewind && swiper.isBeginning) {
2243            const lastIndex = swiper.params.virtual && swiper.params.virtual.enabled && swiper.virtual ? swiper.virtual.slides.length - 1 : swiper.slides.length - 1;
2244            return swiper.slideTo(lastIndex, speed, runCallbacks, internal);
2245        } else if (params.loop && swiper.activeIndex === 0 && params.cssMode) {
2246            requestAnimationFrame((() => {
2247                swiper.slideTo(prevIndex, speed, runCallbacks, internal);
2248            }));
2249            return true;
2250        }
2251        return swiper.slideTo(prevIndex, speed, runCallbacks, internal);
2252    }
2253    function slideReset(speed, runCallbacks, internal) {
2254        if (runCallbacks === void 0) runCallbacks = true;
2255        const swiper = this;
2256        if (swiper.destroyed) return;
2257        if (typeof speed === "undefined") speed = swiper.params.speed;
2258        return swiper.slideTo(swiper.activeIndex, speed, runCallbacks, internal);
2259    }
2260    function slideToClosest(speed, runCallbacks, internal, threshold) {
2261        if (runCallbacks === void 0) runCallbacks = true;
2262        if (threshold === void 0) threshold = .5;
2263        const swiper = this;
2264        if (swiper.destroyed) return;
2265        if (typeof speed === "undefined") speed = swiper.params.speed;
2266        let index = swiper.activeIndex;
2267        const skip = Math.min(swiper.params.slidesPerGroupSkip, index);
2268        const snapIndex = skip + Math.floor((index - skip) / swiper.params.slidesPerGroup);
2269        const translate = swiper.rtlTranslate ? swiper.translate : -swi

2269per.translate;
2270        if (translate >= swiper.snapGrid[snapIndex]) {
2271            const currentSnap = swiper.snapGrid[snapIndex];
2272            const nextSnap = swiper.snapGrid[snapIndex + 1];
2273            if (translate - currentSnap > (nextSnap - currentSnap) * threshold) index += swiper.params.slidesPerGroup;
2274        } else {
2275            const prevSnap = swiper.snapGrid[snapIndex - 1];
2276            const currentSnap = swiper.snapGrid[snapIndex];
2277            if (translate - prevSnap <= (currentSnap - prevSnap) * threshold) index -= swiper.params.slidesPerGroup;
2278        }
2279        index = Math.max(index, 0);
2280        index = Math.min(index, swiper.slidesGrid.length - 1);
2281        return swiper.slideTo(index, speed, runCallbacks, internal);
2282    }
2283    function slideToClickedSlide() {
2284        const swiper = this;
2285        if (swiper.destroyed) return;
2286        const {params, slidesEl} = swiper;
2287        const slidesPerView = params.slidesPerView === "auto" ? swiper.slidesPerViewDynamic() : params.slidesPerView;
2288        let slideToIndex = swiper.clickedIndex;
2289        let realIndex;
2290        const slideSelector = swiper.isElement ? `swiper-slide` : `.${params.slideClass}`;
2291        if (params.loop) {
2292            if (swiper.animating) return;
2293            realIndex = parseInt(swiper.clickedSlide.getAttribute("data-swiper-slide-index"), 10);
2294            if (params.centeredSlides) if (slideToIndex < swiper.loopedSlides - slidesPerView / 2 || slideToIndex > swiper.slides.length - swiper.loopedSlides + slidesPerView / 2) {
2295                swiper.loopFix();
2296                slideToIndex = swiper.getSlideIndex(utils_elementChildren(slidesEl, `${slideSelector}[data-swiper-slide-index="${realIndex}"]`)[0]);
2297                utils_nextTick((() => {
2298                    swiper.slideTo(slideToIndex);
2299                }));
2300            } else swiper.slideTo(slideToIndex); else if (slideToIndex > swiper.slides.length - slidesPerView) {
2301                swiper.loopFix();
2302                slideToIndex = swiper.getSlideIndex(utils_elementChildren(slidesEl, `${slideSelector}[data-swiper-slide-index="${realIndex}"]`)[0]);
2303                utils_nextTick((() => {
2304                    swiper.slideTo(slideToIndex);
2305                }));
2306            } else swiper.slideTo(slideToIndex);
2307        } else swiper.slideTo(slideToIndex);
2308    }
2309    var slide = {
2310        slideTo,
2311        slideToLoop,
2312        slideNext,
2313        slidePrev,
2314        slideReset,
2315        slideToClosest,
2316        slideToClickedSlide
2317    };
2318    function loopCreate(slideRealIndex) {
2319        const swiper = this;
2320        const {params, slidesEl} = swiper;
2321        if (!params.loop || swiper.virtual && swiper.params.virtual.enabled) return;
2322        const initSlides = () => {
2323            const slides = utils_elementChildren(slidesEl, `.${params.slideClass}, swiper-slide`);
2324            slides.forEach(((el, index) => {
2325                el.setAttribute("data-swiper-slide-index", index);
2326            }));
2327        };
2328        const gridEnabled = swiper.grid && params.grid && params.grid.rows > 1;
2329        const slidesPerGroup = params.slidesPerGroup * (gridEnabled ? params.grid.rows : 1);
2330        const shouldFillGroup = swiper.slides.length % slidesPerGroup !== 0;
2331        const shouldFillGrid = gridEnabled && swiper.slides.length % params.grid.rows !== 0;
2332        const addBlankSlides = amountOfSlides => {
2333            for (let i = 0; i < amountOfSlides; i += 1) {
2334                const slideEl = swiper.isElement ? utils_createElement("swiper-slide", [ params.slideBlankClass ]) : utils_createElement("div", [ params.slideClass, params.slideBlankClass ]);
2335                swiper.slidesEl.append(slideEl);
2336            }
2337        };
2338        if (shouldFillGroup) {
2339            if (params.loopAddBlankSlides) {
2340                const slidesToAdd = slidesPerGroup - swiper.slides.length % slidesPerGroup;
2341                addBlankSlides(slidesToAdd);
2342                swiper.recalcSlides();
2343                swiper.updateSlides();
2344            } else showWarning("Swiper Loop Warning: The number of slides is not even to slidesPerGroup, loop mode may

2344not function properly. You need to add more slides (or make duplicates, or empty slides)");
2345            initSlides();
2346        } else if (shouldFillGrid) {
2347            if (params.loopAddBlankSlides) {
2348                const slidesToAdd = params.grid.rows - swiper.slides.length % params.grid.rows;
2349                addBlankSlides(slidesToAdd);
2350                swiper.recalcSlides();
2351                swiper.updateSlides();
2352            } else showWarning("Swiper Loop Warning: The number of slides is not even to grid.rows, loop mode may not function properly. You need to add more slides (or make duplicates, or empty slides)");
2353            initSlides();
2354        } else initSlides();
2355        swiper.loopFix({
2356            slideRealIndex,
2357            direction: params.centeredSlides ? void 0 : "next"
2358        });
2359    }
2360    function loopFix(_temp) {
2361        let {slideRealIndex, slideTo = true, direction, setTranslate, activeSlideIndex, byController, byMousewheel} = _temp === void 0 ? {} : _temp;
2362        const swiper = this;
2363        if (!swiper.params.loop) return;
2364        swiper.emit("beforeLoopFix");
2365        const {slides, allowSlidePrev, allowSlideNext, slidesEl, params} = swiper;
2366        const {centeredSlides} = params;
2367        swiper.allowSlidePrev = true;
2368        swiper.allowSlideNext = true;
2369        if (swiper.virtual && params.virtual.enabled) {
2370            if (slideTo) if (!params.centeredSlides && swiper.snapIndex === 0) swiper.slideTo(swiper.virtual.slides.length, 0, false, true); else if (params.centeredSlides && swiper.snapIndex < params.slidesPerView) swiper.slideTo(swiper.virtual.slides.length + swiper.snapIndex, 0, false, true); else if (swiper.snapIndex === swiper.snapGrid.length - 1) swiper.slideTo(swiper.virtual.slidesBefore, 0, false, true);
2371            swiper.allowSlidePrev = allowSlidePrev;
2372            swiper.allowSlideNext = allowSlideNext;
2373            swiper.emit("loopFix");
2374            return;
2375        }
2376        let slidesPerView = params.slidesPerView;
2377        if (slidesPerView === "auto") slidesPerView = swiper.slidesPerViewDynamic(); else {
2378            slidesPerView = Math.ceil(parseFloat(params.slidesPerView, 10));
2379            if (centeredSlides && slidesPerView % 2 === 0) slidesPerView += 1;
2380        }
2381        const slidesPerGroup = params.slidesPerGroupAuto ? slidesPerView : params.slidesPerGroup;
2382        let loopedSlides = slidesPerGroup;
2383        if (loopedSlides % slidesPerGroup !== 0) loopedSlides += slidesPerGroup - loopedSlides % slidesPerGroup;
2384        loopedSlides += params.loopAdditionalSlides;
2385        swiper.loopedSlides = loopedSlides;
2386        const gridEnabled = swiper.grid && params.grid && params.grid.rows > 1;
2387        if (slides.length < slidesPerView + loopedSlides) showWarning("Swiper Loop Warning: The number of slides is not enough for loop mode, it will be disabled and not function properly. You need to add more slides (or make duplicates) or lower the values of slidesPerView and slidesPerGroup parameters"); else if (gridEnabled && params.grid.fill === "row") showWarning("Swiper Loop Warning: Loop mode is not compatible with grid.fill = `row`");
2388        const prependSlidesIndexes = [];
2389        const appendSlidesIndexes = [];
2390        let activeIndex = swiper.activeIndex;
2391        if (typeof activeSlideIndex === "undefined") activeSlideIndex = swiper.getSlideIndex(slides.filter((el => el.classList.contains(params.slideActiveClass)))[0]); else activeIndex = activeSlideIndex;
2392        const isNext = direction === "next" || !direction;
2393        const isPrev = direction === "prev" || !direction;
2394        let slidesPrepended = 0;
2395        let slidesAppended = 0;
2396        const cols = gridEnabled ? Math.ceil(slides.length / params.grid.rows) : slides.length;
2397        const activeColIndex = gridEnabled ? slides[activeSlideIndex].column : activeSlideIndex;
2398        const activeColIndexWithShift = activeColIndex + (centeredSlides && typeof setTranslate === "undefined" ? -slidesPerView / 2 + .5 : 0);
2399        if (activeColIndexWithShift < loopedSlides) {
2400            slidesPrepended = Math.max(loopedSlides - activeColIndexWithShift, slidesPerGroup);
2401            for (let i = 0; i < loopedSlides - activeColIndexWithShift; i += 1) {

2402                const index = i - Math.floor(i / cols) * cols;
2403                if (gridEnabled) {
2404                    const colIndexToPrepend = cols - index - 1;
2405                    for (let i = slides.length - 1; i >= 0; i -= 1) if (slides[i].column === colIndexToPrepend) prependSlidesIndexes.push(i);
2406                } else prependSlidesIndexes.push(cols - index - 1);
2407            }
2408        } else if (activeColIndexWithShift + slidesPerView > cols - loopedSlides) {
2409            slidesAppended = Math.max(activeColIndexWithShift - (cols - loopedSlides * 2), slidesPerGroup);
2410            for (let i = 0; i < slidesAppended; i += 1) {
2411                const index = i - Math.floor(i / cols) * cols;
2412                if (gridEnabled) slides.forEach(((slide, slideIndex) => {
2413                    if (slide.column === index) appendSlidesIndexes.push(slideIndex);
2414                })); else appendSlidesIndexes.push(index);
2415            }
2416        }
2417        swiper.__preventObserver__ = true;
2418        requestAnimationFrame((() => {
2419            swiper.__preventObserver__ = false;
2420        }));
2421        if (isPrev) prependSlidesIndexes.forEach((index => {
2422            slides[index].swiperLoopMoveDOM = true;
2423            slidesEl.prepend(slides[index]);
2424            slides[index].swiperLoopMoveDOM = false;
2425        }));
2426        if (isNext) appendSlidesIndexes.forEach((index => {
2427            slides[index].swiperLoopMoveDOM = true;
2428            slidesEl.append(slides[index]);
2429            slides[index].swiperLoopMoveDOM = false;
2430        }));
2431        swiper.recalcSlides();
2432        if (params.slidesPerView === "auto") swiper.updateSlides(); else if (gridEnabled && (prependSlidesIndexes.length > 0 && isPrev || appendSlidesIndexes.length > 0 && isNext)) swiper.slides.forEach(((slide, slideIndex) => {
2433            swiper.grid.updateSlide(slideIndex, slide, swiper.slides);
2434        }));
2435        if (params.watchSlidesProgress) swiper.updateSlidesOffset();
2436        if (slideTo) if (prependSlidesIndexes.length > 0 && isPrev) {
2437            if (typeof slideRealIndex === "undefined") {
2438                const currentSlideTranslate = swiper.slidesGrid[activeIndex];
2439                const newSlideTranslate = swiper.slidesGrid[activeIndex + slidesPrepended];
2440                const diff = newSlideTranslate - currentSlideTranslate;
2441                if (byMousewheel) swiper.setTranslate(swiper.translate - diff); else {
2442                    swiper.slideTo(activeIndex + Math.ceil(slidesPrepended), 0, false, true);
2443                    if (setTranslate) {
2444                        swiper.touchEventsData.startTranslate = swiper.touchEventsData.startTranslate - diff;
2445                        swiper.touchEventsData.currentTranslate = swiper.touchEventsData.currentTranslate - diff;
2446                    }
2447                }
2448            } else if (setTranslate) {
2449                const shift = gridEnabled ? prependSlidesIndexes.length / params.grid.rows : prependSlidesIndexes.length;
2450                swiper.slideTo(swiper.activeIndex + shift, 0, false, true);
2451                swiper.touchEventsData.currentTranslate = swiper.translate;
2452            }
2453        } else if (appendSlidesIndexes.length > 0 && isNext) if (typeof slideRealIndex === "undefined") {
2454            const currentSlideTranslate = swiper.slidesGrid[activeIndex];
2455            const newSlideTranslate = swiper.slidesGrid[activeIndex - slidesAppended];
2456            const diff = newSlideTranslate - currentSlideTranslate;
2457            if (byMousewheel) swiper.setTranslate(swiper.translate - diff); else {
2458                swiper.slideTo(activeIndex - slidesAppended, 0, false, true);
2459                if (setTranslate) {
2460                    swiper.touchEventsData.startTranslate = swiper.touchEventsData.startTranslate - diff;
2461                    swiper.touchEventsData.currentTranslate = swiper.touchEventsData.currentTranslate - diff;
2462                }
2463            }
2464        } else {
2465            const shift = gridEnabled ? appendSlidesIndexes.length / params.grid.rows : appendSlidesIndexes.length;
2466            swiper.slideTo(swiper.activeIndex - shift, 0, false, true);
2467        }
2468        swiper.allowSlidePrev = allowSlidePrev;
2469        swiper.allowSlideNext = allowSlideNext;
2470        if (swiper.controller && swiper.controller.control && !byController) {
2471            const loopParams = {
2472                slideRealIndex,
2473                direction,
2474                setTranslate,
2475                activeSlideIndex,
2476                byController: true
2477            };
2478            if (Array.isArray(swiper.controller.control)) swiper.controller.control.forEach((c => {
2479                if (!c.destroyed && c.params.loop) c.loopFix({
2480                    ...loopParams,
2481                    slideTo: c.params.slidesPerView === params.slidesPerView ? slideTo : false
2482                });
2483            })); else if (swiper.controller.control instanceof swiper.constructor && swiper.controller.control.params.loop) swiper.controller.control.loopFix({
2484                ...loopParams,
2485                slideTo: swiper.controller.control.params.slidesPerView === params.slidesPerView ? slideTo : false
2486            });
2487        }
2488        swiper.emit("loopFix");
2489    }
2490    function loopDestroy() {
2491        const swiper = this;
2492        const {params, slidesEl} = swiper;
2493        if (!params.loop || swiper.virtual && swiper.params.virtual.enabled) return;
2494        swiper.recalcSlides();
2495        const newSlidesOrder = [];

2496        swiper.slides.forEach((slideEl => {
2497            const index = typeof slideEl.swiperSlideIndex === "undefined" ? slideEl.getAttribute("data-swiper-slide-index") * 1 : slideEl.swiperSlideIndex;
2498            newSlidesOrder[index] = slideEl;
2499        }));
2500        swiper.slides.forEach((slideEl => {
2501            slideEl.removeAttribute("data-swiper-slide-index");
2502        }));
2503        newSlidesOrder.forEach((slideEl => {
2504            slidesEl.append(slideEl);
2505        }));
2506        swiper.recalcSlides();
2507        swiper.slideTo(swiper.realIndex, 0);
2508    }
2509    var loop = {
2510        loopCreate,
2511        loopFix,
2512        loopDestroy
2513    };
2514    function setGrabCursor(moving) {
2515        const swiper = this;
2516        if (!swiper.params.simulateTouch || swiper.params.watchOverflow && swiper.isLocked || swiper.params.cssMode) return;
2517        const el = swiper.params.touchEventsTarget === "container" ? swiper.el : swiper.wrapperEl;
2518        if (swiper.isElement) swiper.__preventObserver__ = true;
2519        el.style.cursor = "move";
2520        el.style.cursor = moving ? "grabbing" : "grab";
2521        if (swiper.isElement) requestAnimationFrame((() => {
2522            swiper.__preventObserver__ = false;
2523        }));
2524    }
2525    function unsetGrabCursor() {
2526        const swiper = this;
2527        if (swiper.params.watchOverflow && swiper.isLocked || swiper.params.cssMode) return;
2528        if (swiper.isElement) swiper.__preventObserver__ = true;
2529        swiper[swiper.params.touchEventsTarget === "container" ? "el" : "wrapperEl"].style.cursor = "";
2530        if (swiper.isElement) requestAnimationFrame((() => {
2531            swiper.__preventObserver__ = false;
2532        }));
2533    }
2534    var grabCursor = {
2535        setGrabCursor,
2536        unsetGrabCursor
2537    };
2538    function closestElement(selector, base) {
2539        if (base === void 0) base = this;
2540        function __closestFrom(el) {
2541            if (!el || el === ssr_window_esm_getDocument() || el === ssr_window_esm_getWindow()) return null;
2542            if (el.assignedSlot) el = el.assignedSlot;
2543            const found = el.closest(selector);
2544            if (!found && !el.getRootNode) return null;
2545            return found || __closestFrom(el.getRootNode().host);
2546        }
2547        return __closestFrom(base);
2548    }
2549    function preventEdgeSwipe(swiper, event, startX) {
2550        const window = ssr_window_esm_getWindow();
2551        const {params} = swiper;
2552        const edgeSwipeDetection = params.edgeSwipeDetection;
2553        const edgeSwipeThreshold = params.edgeSwipeThreshold;
2554        if (edgeSwipeDetection && (startX <= edgeSwipeThreshold || startX >= window.innerWidth - edgeSwipeThreshold)) {
2555            if (edgeSwipeDetection === "prevent") {
2556                event.preventDefault();
2557                return true;
2558            }
2559            return false;
2560        }
2561        return true;
2562    }
2563    function onTouchStart(event) {
2564        const swiper = this;
2565        const document = ssr_window_esm_getDocument();
2566        let e = event;
2567        if (e.originalEvent) e = e.originalEvent;
2568        const data = swiper.touchEventsData;
2569        if (e.type === "pointerdown") {
2570            if (data.pointerId !== null && data.pointerId !== e.pointerId) return;
2571            data.pointerId = e.pointerId;
2572        } else if (e.type === "touchstart" && e.targetTouches.length === 1) data.touchId = e.targetTouches[0].identifier;
2573        if (e.type === "touchstart") {
2574            preventEdgeSwipe(swiper, e, e.targetTouches[0].pageX);
2575            return;
2576        }
2577        const {params, touches, enabled} = swiper;
2578        if (!enabled) return;
2579        if (!params.simulateTouch && e.pointerType === "mouse") return;
2580        if (swiper.animating && params.preventInteractionOnTransition) return;
2581        if (!swiper.animating && params.cssMode && params.loop) swiper.loopFix();
2582        let targetEl = e.target;
2583        if (params.touchEventsTarget === "wrapper") if (!swiper.wrapperEl.contains(targetEl)) return;
2584        if ("which" in e && e.which === 3) return;
2585        if ("button" in e && e.button > 0) return;
2586        if (data.isTouched && data.isMoved) return;
2587        const swipingClassHasValue = !!params.noSwipingClass && params.noSwipingClass !== "";
2588        const eventPath = e.composedPath ? e.composedPath() : e.path;
2589        if (swipingClassHasValue && e.target && e.target.shadowRoot && eventPath) targetEl = eventPath[0];
2590        const noSwipingSelector = params.noSwipingSelector ? params.noSwipingSelector : `.${params.noSwipingClass}`;
2591        const isTargetShadow = !!(e.target && e.target.shadowRoot);
2592        if (params.noSwiping && (isTargetShadow ? closestElement(noSwipingSelector, targetEl) : targetEl.closest(noSwipingSelector))) {
2593            swiper.allowClick = true;
2594            return;
2595        }
2596        if (params.swipeHandler) if (!targetEl.closest(params.swipeHandler)) return;
2597        touches.currentX = e.pageX;
2598        touches.currentY = e.pageY;
2599        const startX = touches.currentX;
2600        const startY = touches.currentY;
2601        if (!preventEdgeSwipe(swiper, e, startX)) return;
2602        Object.assign(data, {
2603            isTouched: true,
2604            isMoved: false,
2605            allowTouchCallbacks: true,
2606            isScrolling: void 0,
2607            startMoving: void 0
2608        });
2609        touches.startX = startX;
2610        touches.startY = startY;
2611        data.touchStartTime = utils_now();
2612        swiper.allowClick = true;
2613        swiper.updateSize();
2614        swiper.swipeDirection = void 0;
2615        if (params.threshold > 0) data.allowThresholdMove = false;

2616        let preventDefault = true;
2617        if (targetEl.matches(data.focusableElements)) {
2618            preventDefault = false;
2619            if (targetEl.nodeName === "SELECT") data.isTouched = false;
2620        }
2621        if (document.activeElement && document.activeElement.matches(data.focusableElements) && document.activeElement !== targetEl) document.activeElement.blur();
2622        const shouldPreventDefault = preventDefault && swiper.allowTouchMove && params.touchStartPreventDefault;
2623        if ((params.touchStartForcePreventDefault || shouldPreventDefault) && !targetEl.isContentEditable) e.preventDefault();
2624        if (params.freeMode && params.freeMode.enabled && swiper.freeMode && swiper.animating && !params.cssMode) swiper.freeMode.onTouchStart();
2625        swiper.emit("touchStart", e);
2626    }
2627    function onTouchMove(event) {
2628        const document = ssr_window_esm_getDocument();
2629        const swiper = this;
2630        const data = swiper.touchEventsData;
2631        const {params, touches, rtlTranslate: rtl, enabled} = swiper;
2632        if (!enabled) return;
2633        if (!params.simulateTouch && event.pointerType === "mouse") return;
2634        let e = event;
2635        if (e.originalEvent) e = e.originalEvent;
2636        if (e.type === "pointermove") {
2637            if (data.touchId !== null) return;
2638            const id = e.pointerId;
2639            if (id !== data.pointerId) return;
2640        }
2641        let targetTouch;
2642        if (e.type === "touchmove") {
2643            targetTouch = [ ...e.changedTouches ].filter((t => t.identifier === data.touchId))[0];
2644            if (!targetTouch || targetTouch.identifier !== data.touchId) return;
2645        } else targetTouch = e;
2646        if (!data.isTouched) {
2647            if (data.startMoving && data.isScrolling) swiper.emit("touchMoveOpposite", e);
2648            return;
2649        }
2650        const pageX = targetTouch.pageX;
2651        const pageY = targetTouch.pageY;
2652        if (e.preventedByNestedSwiper) {
2653            touches.startX = pageX;
2654            touches.startY = pageY;
2655            return;
2656        }
2657        if (!swiper.allowTouchMove) {
2658            if (!e.target.matches(data.focusableElements)) swiper.allowClick = false;
2659            if (data.isTouched) {
2660                Object.assign(touches, {
2661                    startX: pageX,
2662                    startY: pageY,
2663                    currentX: pageX,
2664                    currentY: pageY
2665                });
2666                data.touchStartTime = utils_now();
2667            }
2668            return;
2669        }
2670        if (params.touchReleaseOnEdges && !params.loop) if (swiper.isVertical()) {
2671            if (pageY < touches.startY && swiper.translate <= swiper.maxTranslate() || pageY > touches.startY && swiper.translate >= swiper.minTranslate()) {
2672                data.isTouched = false;
2673                data.isMoved = false;
2674                return;
2675            }
2676        } else if (pageX < touches.startX && swiper.translate <= swiper.maxTranslate() || pageX > touches.startX && swiper.translate >= swiper.minTranslate()) return;
2677        if (document.activeElement) if (e.target === document.activeElement && e.target.matches(data.focusableElements)) {
2678            data.isMoved = true;
2679            swiper.allowClick = false;
2680            return;
2681        }
2682        if (data.allowTouchCallbacks) swiper.emit("touchMove", e);
2683        touches.previousX = touches.currentX;
2684        touches.previousY = touches.currentY;
2685        touches.currentX = pageX;
2686        touches.currentY = pageY;
2687        const diffX = touches.currentX - touches.startX;
2688        const diffY = touches.currentY - touches.startY;
2689        if (swiper.params.threshold && Math.sqrt(diffX ** 2 + diffY ** 2) < swiper.params.threshold) return;
2690        if (typeof data.isScrolling === "undefined") {
2691            let touchAngle;
2692            if (swiper.isHorizontal() && touches.currentY === touches.startY || swiper.isVertical() && touches.currentX === touches.startX) data.isScrolling = false; else if (diffX * diffX + diffY * diffY >= 25) {
2693                touchAngle = Math.atan2(Math.abs(diffY), Math.abs(diffX)) * 180 / Math.PI;
2694                data.isScrolling = swiper.isHorizontal() ? touchAngle > params.touchAngle : 90 - touchAngle > params.touchAngle;
2695            }
2696        }
2697        if (data.isScrolling) swiper.emit("touchMoveOpposite", e);
2698        if (typeof data.startMoving === "undefined") if (touches.currentX !== touches.startX || touches.currentY !== touches.startY) data.startMoving = true;
2699        if (data.isScrolling || e.type === "touchmove" && data.preventTouchMoveFromPointerMove) {
2700            data.isTouched = false;

2701            return;
2702        }
2703        if (!data.startMoving) return;
2704        swiper.allowClick = false;
2705        if (!params.cssMode && e.cancelable) e.preventDefault();
2706        if (params.touchMoveStopPropagation && !params.nested) e.stopPropagation();
2707        let diff = swiper.isHorizontal() ? diffX : diffY;
2708        let touchesDiff = swiper.isHorizontal() ? touches.currentX - touches.previousX : touches.currentY - touches.previousY;
2709        if (params.oneWayMovement) {
2710            diff = Math.abs(diff) * (rtl ? 1 : -1);
2711            touchesDiff = Math.abs(touchesDiff) * (rtl ? 1 : -1);
2712        }
2713        touches.diff = diff;
2714        diff *= params.touchRatio;
2715        if (rtl) {
2716            diff = -diff;
2717            touchesDiff = -touchesDiff;
2718        }
2719        const prevTouchesDirection = swiper.touchesDirection;
2720        swiper.swipeDirection = diff > 0 ? "prev" : "next";
2721        swiper.touchesDirection = touchesDiff > 0 ? "prev" : "next";
2722        const isLoop = swiper.params.loop && !params.cssMode;
2723        const allowLoopFix = swiper.touchesDirection === "next" && swiper.allowSlideNext || swiper.touchesDirection === "prev" && swiper.allowSlidePrev;
2724        if (!data.isMoved) {
2725            if (isLoop && allowLoopFix) swiper.loopFix({
2726                direction: swiper.swipeDirection
2727            });
2728            data.startTranslate = swiper.getTranslate();
2729            swiper.setTransition(0);
2730            if (swiper.animating) {
2731                const evt = new window.CustomEvent("transitionend", {
2732                    bubbles: true,
2733                    cancelable: true,
2734                    detail: {
2735                        bySwiperTouchMove: true
2736                    }
2737                });
2738                swiper.wrapperEl.dispatchEvent(evt);
2739            }
2740            data.allowMomentumBounce = false;
2741            if (params.grabCursor && (swiper.allowSlideNext === true || swiper.allowSlidePrev === true)) swiper.setGrabCursor(true);
2742            swiper.emit("sliderFirstMove", e);
2743        }
2744        let loopFixed;
2745        (new Date).getTime();
2746        if (data.isMoved && data.allowThresholdMove && prevTouchesDirection !== swiper.touchesDirection && isLoop && allowLoopFix && Math.abs(diff) >= 1) {
2747            Object.assign(touches, {
2748                startX: pageX,
2749                startY: pageY,
2750                currentX: pageX,
2751                currentY: pageY,
2752                startTranslate: data.currentTranslate
2753            });
2754            data.loopSwapReset = true;
2755            data.startTranslate = data.currentTranslate;
2756            return;
2757        }
2758        swiper.emit("sliderMove", e);
2759        data.isMoved = true;
2760        data.currentTranslate = diff + data.startTranslate;
2761        let disableParentSwiper = true;
2762        let resistanceRatio = params.resistanceRatio;
2763        if (params.touchReleaseOnEdges) resistanceRatio = 0;
2764        if (diff > 0) {
2765            if (isLoop && allowLoopFix && !loopFixed && data.allowThresholdMove && data.currentTranslate > (params.centeredSlides ? swiper.minTranslate() - swiper.slidesSizesGrid[swiper.activeIndex + 1] : swiper.minTranslate())) swiper.loopFix({
2766                direction: "prev",
2767                setTranslate: true,
2768                activeSlideIndex: 0
2769            });
2770            if (data.currentTranslate > swiper.minTranslate()) {
2771                disableParentSwiper = false;

2772                if (params.resistance) data.currentTranslate = swiper.minTranslate() - 1 + (-swiper.minTranslate() + data.startTranslate + diff) ** resistanceRatio;
2773            }
2774        } else if (diff < 0) {
2775            if (isLoop && allowLoopFix && !loopFixed && data.allowThresholdMove && data.currentTranslate < (params.centeredSlides ? swiper.maxTranslate() + swiper.slidesSizesGrid[swiper.slidesSizesGrid.length - 1] : swiper.maxTranslate())) swiper.loopFix({
2776                direction: "next",
2777                setTranslate: true,
2778                activeSlideIndex: swiper.slides.length - (params.slidesPerView === "auto" ? swiper.slidesPerViewDynamic() : Math.ceil(parseFloat(params.slidesPerView, 10)))
2779            });
2780            if (data.currentTranslate < swiper.maxTranslate()) {
2781                disableParentSwiper = false;
2782                if (params.resistance) data.currentTranslate = swiper.maxTranslate() + 1 - (swiper.maxTranslate() - data.startTranslate - diff) ** resistanceRatio;
2783            }
2784        }
2785        if (disableParentSwiper) e.preventedByNestedSwiper = true;
2786        if (!swiper.allowSlideNext && swiper.swipeDirection === "next" && data.currentTranslate < data.startTranslate) data.currentTranslate = data.startTranslate;
2787        if (!swiper.allowSlidePrev && swiper.swipeDirection === "prev" && data.currentTranslate > data.startTranslate) data.currentTranslate = data.startTranslate;
2788        if (!swiper.allowSlidePrev && !swiper.allowSlideNext) data.currentTranslate = data.startTranslate;
2789        if (params.threshold > 0) if (Math.abs(diff) > params.threshold || data.allowThresholdMove) {
2790            if (!data.allowThresholdMove) {
2791                data.allowThresholdMove = true;
2792                touches.startX = touches.currentX;
2793                touches.startY = touches.currentY;
2794                data.currentTranslate = data.startTranslate;
2795                touches.diff = swiper.isHorizontal() ? touches.currentX - touches.startX : touches.currentY - touches.startY;
2796                return;
2797            }
2798        } else {
2799            data.currentTranslate = data.startTranslate;
2800            return;
2801        }
2802        if (!params.followFinger || params.cssMode) return;
2803        if (params.freeMode && params.freeMode.enabled && swiper.freeMode || params.watchSlidesProgress) {
2804            swiper.updateActiveIndex();
2805            swiper.updateSlidesClasses();
2806        }
2807        if (params.freeMode && params.freeMode.enabled && swiper.freeMode) swiper.freeMode.onTouchMove();
2808        swiper.updateProgress(data.currentTranslate);
2809        swiper.setTranslate(data.currentTranslate);
2810    }
2811    function onTouchEnd(event) {
2812        const swiper = this;
2813        const data = swiper.touchEventsData;
2814        let e = event;
2815        if (e.originalEvent) e = e.originalEvent;
2816        let targetTouch;
2817        const isTouchEvent = e.type === "touchend" || e.type === "touchcancel";
2818        if (!isTouchEvent) {
2819            if (data.touchId !== null) return;
2820            if (e.pointerId !== data.pointerId) return;
2821            targetTouch = e;
2822        } else {
2823            targetTouch = [ ...e.changedTouches ].filter((t => t.identifier === data.touchId))[0];
2824            if (!targetTouch || targetTouch.identifier !== data.touchId) return;
2825        }
2826        if ([ "pointercancel", "pointerout", "pointerleave", "contextmenu" ].includes(e.type)) {
2827            const proceed = [ "pointercancel", "contextmenu" ].includes(e.type) && (swiper.browser.isSafari || swiper.browser.isWebView);
2828            if (!proceed) return;
2829        }
2830        data.pointerId = null;
2831        data.touchId = null;
2832        const {params, touches, rtlTranslate: rtl, slidesGrid, enabled} = swiper;
2833        if (!enabled) return;
2834        if (!params.simulateTouch && e.pointerType === "mouse") return;
2835        if (data.allowTouchCallbacks) swiper.emit("touchEnd", e);
2836        data.allowTouchCallbacks = false;
2837        if (!data.isTouched) {
2838            if (data.isMoved && params.grabCursor) swiper.setGrabCursor(false);
2839            data.isMoved = false;
2840            data.startMoving = false;
2841            return;
2842        }
2843        if (params.grabCursor && data.isMoved && data.isTouched && (swiper.allowSlideNext === true || swiper.allowSlidePrev === true)) swiper.setGrabCursor(false);
2844        const touchEndTime = utils_now();
2845        const timeDiff = touchEndTime - data.touchStartTime;
2846        if (swiper.allowClick) {
2847            const pathTree = e.path || e.composedPath && e.composedPath();
2848            swiper.updateClickedSlide(pathTree && pathTree[0] || e.target, pathTree);
2849            swiper.emit("tap click", e);
2850            if (timeDiff < 300 && touchEndTime - data.lastClickTime < 300) swiper.emit("doubleTap doubleClick", e);
2851        }
2852        data.lastClickTime = utils_now();
2853        utils_nextTick((() => {
2854            if (!swiper.destroyed) swiper.allowClick = true;
2855        }));
2856        if (!data.isTouched || !data.isMoved || !swiper.swipeDirection || touches.diff === 0 && !data.loopSwapReset || data.currentTranslate === data.startTranslate && !data.loopSwapReset) {
2857            data.isTouched = false;

2858            data.isMoved = false;
2859            data.startMoving = false;
2860            return;
2861        }
2862        data.isTouched = false;
2863        data.isMoved = false;
2864        data.startMoving = false;
2865        let currentPos;
2866        if (params.followFinger) currentPos = rtl ? swiper.translate : -swiper.translate; else currentPos = -data.currentTranslate;
2867        if (params.cssMode) return;
2868        if (params.freeMode && params.freeMode.enabled) {
2869            swiper.freeMode.onTouchEnd({
2870                currentPos
2871            });
2872            return;
2873        }
2874        const swipeToLast = currentPos >= -swiper.maxTranslate() && !swiper.params.loop;
2875        let stopIndex = 0;
2876        let groupSize = swiper.slidesSizesGrid[0];
2877        for (let i = 0; i < slidesGrid.length; i += i < params.slidesPerGroupSkip ? 1 : params.slidesPerGroup) {
2878            const increment = i < params.slidesPerGroupSkip - 1 ? 1 : params.slidesPerGroup;
2879            if (typeof slidesGrid[i + increment] !== "undefined") {
2880                if (swipeToLast || currentPos >= slidesGrid[i] && currentPos < slidesGrid[i + increment]) {
2881                    stopIndex = i;
2882                    groupSize = slidesGrid[i + increment] - slidesGrid[i];
2883                }
2884            } else if (swipeToLast || currentPos >= slidesGrid[i]) {
2885                stopIndex = i;
2886                groupSize = slidesGrid[slidesGrid.length - 1] - slidesGrid[slidesGrid.length - 2];
2887            }
2888        }
2889        let rewindFirstIndex = null;
2890        let rewindLastIndex = null;
2891        if (params.rewind) if (swiper.isBeginning) rewindLastIndex = params.virtual && params.virtual.enabled && swiper.virtual ? swiper.virtual.slides.length - 1 : swiper.slides.length - 1; else if (swiper.isEnd) rewindFirstIndex = 0;
2892        const ratio = (currentPos - slidesGrid[stopIndex]) / groupSize;
2893        const increment = stopIndex < params.slidesPerGroupSkip - 1 ? 1 : params.slidesPerGroup;
2894        if (timeDiff > params.longSwipesMs) {
2895            if (!params.longSwipes) {
2896                swiper.slideTo(swiper.activeIndex);
2897                return;
2898            }
2899            if (swiper.swipeDirection === "next") if (ratio >= params.longSwipesRatio) swiper.slideTo(params.rewind && swiper.isEnd ? rewindFirstIndex : stopIndex + increment); else swiper.slideTo(stopIndex);
2900            if (swiper.swipeDirection === "prev") if (ratio > 1 - params.longSwipesRatio) swiper.slideTo(stopIndex + increment); else if (rewindLastIndex !== null && ratio < 0 && Math.abs(ratio) > params.longSwipesRatio) swiper.slideTo(rewindLastIndex); else swiper.slideTo(stopIndex);
2901        } else {
2902            if (!params.shortSwipes) {
2903                swiper.slideTo(swiper.activeIndex);
2904                return;
2905            }
2906            const isNavButtonTarget = swiper.navigation && (e.target === swiper.navigation.nextEl || e.target === swiper.navigation.prevEl);
2907            if (!isNavButtonTarget) {
2908                if (swiper.swipeDirection === "next") swiper.slideTo(rewindFirstIndex !== null ? rewindFirstIndex : stopIndex + increment);
2909                if (swiper.swipeDirection === "prev") swiper.slideTo(rewindLastIndex !== null ? rewindLastIndex : stopIndex);
2910            } else if (e.target === swiper.navigation.nextEl) swiper.slideTo(stopIndex + increment); else swiper.slideTo(stopIndex);
2911        }
2912    }
2913    function onResize() {
2914        const swiper = this;
2915        const {params, el} = swiper;
2916        if (el && el.offsetWidth === 0) return;
2917        if (params.breakpoints) swiper.setBreakpoint();
2918        const {allowSlideNext, allowSlidePrev, snapGrid} = swiper;
2919        const isVirtual = swiper.virtual && swiper.params.virtual.enabled;
2920        swiper.allowSlideNext = true;
2921        swiper.allowSlidePrev = true;
2922        swiper.updateSize();
2923        swiper.updateSlides();
2924        swiper.updateSlidesClasses();
2925        const isVirtualLoop = isVirtual && params.loop;
2926        if ((params.slidesPerView === "auto" || params.slidesPerView > 1) && swiper.isEnd && !swiper.isBeginning && !swiper.params.centeredSlides && !isVirtualLoop) swiper.slideTo(swiper.slides.length - 1, 0, false, true); else if (swiper.params.loop && !isVirtual) swiper.slideToLoop(swiper.realIndex, 0, false, true); else swiper.slideTo(swiper.activeIndex, 0, false, true);
2927        if (swiper.autoplay && swiper.autoplay.running && swiper.autoplay.paused) {
2928            clearTimeout(swiper.autoplay.resizeTimeout);
2929            swiper.autoplay.resizeTimeout = setTimeout((() => {
2930                if (swiper.autoplay && swiper.autoplay.running && swiper.autoplay.paused) swiper.autoplay.resume();
2931            }), 500);
2932        }
2933        swiper.allowSlidePrev = allowSlidePrev;
2934        swiper.allowSlideNext = allowSlideNext;
2935        if (swiper.params.watchOverflow && snapGrid !== swiper.snapGrid) swiper.checkOverflow();
2936    }
2937    function onClick(e) {
2938        const swiper = this;
2939        if (!swiper.enabled) return;
2940        if (!swiper.allowClick) {
2941            if (swiper.params.preventClicks) e.preventDefault();
2942            if (swiper.params.preventClicksPropagation && swiper.animating) {
2943                e.stopPropagation();
2944                e.stopImmediatePropagation();
2945            }
2946        }
2947    }
2948    function onScroll() {
2949        const swiper = this;
2950        const {wrapperEl, rtlTranslate, enabled} = swiper;
2951        if (!enabled) return;
2952        swiper.previousTranslate = swiper.translate;
2953        if (swiper.isHorizontal()) swiper.translate = -wrapperEl.scrollLeft; else swiper.translate = -wrapperEl.scrollTop;
2954        if (swiper.translate === 0) swiper.translate = 0;
2955        swiper.updateActiveIndex();
2956        swiper.updateSlidesClasses();
2957        let newProgress;
2958        const translatesDiff = swiper.maxTranslate() - swiper.minTranslate();
2959        if (translatesDiff === 0) newProgress = 0; else newProgress = (swiper.translate - swiper.minTranslate()) / translatesDiff;
2960        if (newProgress !== swiper.progress) swiper.updateProgress(rtlTranslate ? -swiper.translate : swiper.translate);
2961        swiper.emit("setTranslate", swiper.translate, false);
2962    }
2963    function onLoad(e) {
2964        const swiper = this;
2965        processLazyPreloader(swiper, e.target);
2966        if (swiper.params.cssMode || swiper.params.slidesPerView !== "auto" && !swiper.params.autoHeight) return;

2967        swiper.update();
2968    }
2969    function onDocumentTouchStart() {
2970        const swiper = this;
2971        if (swiper.documentTouchHandlerProceeded) return;
2972        swiper.documentTouchHandlerProceeded = true;
2973        if (swiper.params.touchReleaseOnEdges) swiper.el.style.touchAction = "auto";
2974    }
2975    const events = (swiper, method) => {
2976        const document = ssr_window_esm_getDocument();
2977        const {params, el, wrapperEl, device} = swiper;
2978        const capture = !!params.nested;
2979        const domMethod = method === "on" ? "addEventListener" : "removeEventListener";
2980        const swiperMethod = method;
2981        if (!el || typeof el === "string") return;
2982        document[domMethod]("touchstart", swiper.onDocumentTouchStart, {
2983            passive: false,
2984            capture
2985        });
2986        el[domMethod]("touchstart", swiper.onTouchStart, {
2987            passive: false
2988        });
2989        el[domMethod]("pointerdown", swiper.onTouchStart, {
2990            passive: false
2991        });
2992        document[domMethod]("touchmove", swiper.onTouchMove, {
2993            passive: false,
2994            capture
2995        });
2996        document[domMethod]("pointermove", swiper.onTouchMove, {
2997            passive: false,
2998            capture
2999        });
3000        document[domMethod]("touchend", swiper.onTouchEnd, {
3001            passive: true
3002        });
3003        document[domMethod]("pointerup", swiper.onTouchEnd, {
3004            passive: true
3005        });
3006        document[domMethod]("pointercancel", swiper.onTouchEnd, {
3007            passive: true
3008        });
3009        document[domMethod]("touchcancel", swiper.onTouchEnd, {
3010            passive: true
3011        });
3012        document[domMethod]("pointerout", swiper.onTouchEnd, {
3013            passive: true
3014        });
3015        document[domMethod]("pointerleave", swiper.onTouchEnd, {
3016            passive: true
3017        });
3018        document[domMethod]("contextmenu", swiper.onTouchEnd, {
3019            passive: true
3020        });
3021        if (params.preventClicks || params.preventClicksPropagation) el[domMethod]("click", swiper.onClick, true);
3022        if (params.cssMode) wrapperEl[domMethod]("scroll", swiper.onScroll);
3023        if (params.updateOnWindowResize) swiper[swiperMethod](device.ios || device.android ? "resize orientationchange observerUpdate" : "resize observerUpdate", onResize, true); else swiper[swiperMethod]("observerUpdate", onResize, true);
3024        el[domMethod]("load", swiper.onLoad, {
3025            capture: true
3026        });
3027    };
3028    function attachEvents() {
3029        const swiper = this;
3030        const {params} = swiper;
3031        swiper.onTouchStart = onTouchStart.bind(swiper);
3032        swiper.onTouchMove = onTouchMove.bind(swiper);
3033        swiper.onTouchEnd = onTouchEnd.bind(swiper);
3034        swiper.onDocumentTouchStart = onDocumentTouchStart.bind(swiper);
3035        if (params.cssMode) swiper.onScroll = onScroll.bind(swiper);
3036        swiper.onClick = onClick.bind(swiper);
3037        swiper.onLoad = onLoad.bind(swiper);
3038        events(swiper, "on");
3039    }
3040    function detachEvents() {
3041        const swiper = this;
3042        events(swiper, "off");
3043    }
3044    var events$1 = {
3045        attachEvents,
3046        detachEvents
3047    };
3048    const isGridEnabled = (swiper, params) => swiper.grid && params.grid && params.grid.rows > 1;
3049    function setBreakpoint() {
3050        const swiper = this;
3051        const {realIndex, initialized, params, el} = swiper;
3052        const breakpoints = params.breakpoints;
3053        if (!breakpoints || breakpoints && Object.keys(breakpoints).length === 0) return;
3054        const breakpoint = swiper.getBreakpoint(breakpoints, swiper.params.breakpointsBase, swiper.el);
3055        if (!breakpoint || swiper.currentBreakpoint === breakpoint) return;
3056        const breakpointOnlyParams = breakpoint in breakpoints ? breakpoints[breakpoint] : void 0;
3057        const breakpointParams = breakpointOnlyParams || swiper.originalParams;
3058        const wasMultiRow = isGridEnabled(swiper, params);
3059        const isMultiRow = isGridEnabled(swiper, breakpointParams);
3060        const wasGrabCursor = swiper.params.grabCursor;
3061        const isGrabCursor = breakpointParams.grabCursor;
3062        const wasEnabled = params.enabled;
3063        if (wasMultiRow && !isMultiRow) {
3064            el.classList.remove(`${params.containerModifierClass}grid`, `${params.containerModifierClass}grid-column`);
3065            swiper.emitContainerClasses();
3066        } else if (!wasMultiRow && isMultiRow) {
3067            el.classList.add(`${params.containerModifierClass}grid`);
3068            if (breakpointParams.grid.fill && breakpointParams.grid.fill === "column" || !breakpointParams.grid.fill && params.grid.fill === "column") el.classList.add(`${params.containerModifierClass}grid-column`);
3069            swiper.emitContainerClasses();
3070        }
3071        if (wasGrabCursor && !isGrabCursor) swiper.unsetGrabCursor(

3071); else if (!wasGrabCursor && isGrabCursor) swiper.setGrabCursor();
3072        [ "navigation", "pagination", "scrollbar" ].forEach((prop => {
3073            if (typeof breakpointParams[prop] === "undefined") return;
3074            const wasModuleEnabled = params[prop] && params[prop].enabled;
3075            const isModuleEnabled = breakpointParams[prop] && breakpointParams[prop].enabled;
3076            if (wasModuleEnabled && !isModuleEnabled) swiper[prop].disable();
3077            if (!wasModuleEnabled && isModuleEnabled) swiper[prop].enable();
3078        }));
3079        const directionChanged = breakpointParams.direction && breakpointParams.direction !== params.direction;
3080        const needsReLoop = params.loop && (breakpointParams.slidesPerView !== params.slidesPerView || directionChanged);
3081        const wasLoop = params.loop;
3082        if (directionChanged && initialized) swiper.changeDirection();
3083        utils_extend(swiper.params, breakpointParams);
3084        const isEnabled = swiper.params.enabled;
3085        const hasLoop = swiper.params.loop;
3086        Object.assign(swiper, {
3087            allowTouchMove: swiper.params.allowTouchMove,
3088            allowSlideNext: swiper.params.allowSlideNext,
3089            allowSlidePrev: swiper.params.allowSlidePrev
3090        });
3091        if (wasEnabled && !isEnabled) swiper.disable(); else if (!wasEnabled && isEnabled) swiper.enable();
3092        swiper.currentBreakpoint = breakpoint;
3093        swiper.emit("_beforeBreakpoint", breakpointParams);
3094        if (initialized) if (needsReLoop) {
3095            swiper.loopDestroy();
3096            swiper.loopCreate(realIndex);
3097            swiper.updateSlides();
3098        } else if (!wasLoop && hasLoop) {
3099            swiper.loopCreate(realIndex);
3100            swiper.updateSlides();
3101        } else if (wasLoop && !hasLoop) swiper.loopDestroy();
3102        swiper.emit("breakpoint", breakpointParams);
3103    }
3104    function getBreakpoint(breakpoints, base, containerEl) {
3105        if (base === void 0) base = "window";
3106        if (!breakpoints || base === "container" && !containerEl) return;
3107        let breakpoint = false;
3108        const window = ssr_window_esm_getWindow();
3109        const currentHeight = base === "window" ? window.innerHeight : containerEl.clientHeight;

3110        const points = Object.keys(breakpoints).map((point => {
3111            if (typeof point === "string" && point.indexOf("@") === 0) {
3112                const minRatio = parseFloat(point.substr(1));
3113                const value = currentHeight * minRatio;
3114                return {
3115                    value,
3116                    point
3117                };
3118            }
3119            return {
3120                value: point,
3121                point
3122            };
3123        }));
3124        points.sort(((a, b) => parseInt(a.value, 10) - parseInt(b.value, 10)));
3125        for (let i = 0; i < points.length; i += 1) {
3126            const {point, value} = points[i];
3127            if (base === "window") {
3128                if (window.matchMedia(`(min-width: ${value}px)`).matches) breakpoint = point;
3129            } else if (value <= containerEl.clientWidth) breakpoint = point;
3130        }
3131        return breakpoint || "max";
3132    }
3133    var breakpoints = {
3134        setBreakpoint,
3135        getBreakpoint
3136    };
3137    function prepareClasses(entries, prefix) {
3138        const resultClasses = [];
3139        entries.forEach((item => {
3140            if (typeof item === "object") Object.keys(item).forEach((classNames => {
3141                if (item[classNames]) resultClasses.push(prefix + classNames);
3142            })); else if (typeof item === "string") resultClasses.push(prefix + item);
3143        }));
3144        return resultClasses;
3145    }
3146    function addClasses() {
3147        const swiper = this;
3148        const {classNames, params, rtl, el, device} = swiper;
3149        const suffixes = prepareClasses([ "initialized", params.direction, {
3150            "free-mode": swiper.params.freeMode && params.freeMode.enabled
3151        }, {
3152            autoheight: params.autoHeight
3153        }, {
3154            rtl
3155        }, {
3156            grid: params.grid && params.grid.rows > 1
3157        }, {
3158            "grid-column": params.grid && params.grid.rows > 1 && params.grid.fill === "column"
3159        }, {
3160            android: device.android
3161        }, {
3162            ios: device.ios
3163        }, {
3164            "css-mode": params.cssMode
3165        }, {
3166            centered: params.cssMode && params.centeredSlides
3167        }, {
3168            "watch-progress": params.watchSlidesProgress
3169        } ], params.containerModifierClass);
3170        classNames.push(...suffixes);
3171        el.classList.add(...classNames);
3172        swiper.emitContainerClasses();
3173    }
3174    function swiper_core_removeClasses() {
3175        const swiper = this;
3176        const {el, classNames} = swiper;
3177        if (!el || typeof el === "string") return;
3178        el.classList.remove(...classNames);
3179        swiper.emitContainerClasses();
3180    }
3181    var classes = {
3182        addClasses,
3183        removeClasses: swiper_core_removeClasses
3184    };
3185    function checkOverflow() {
3186        const swiper = this;
3187        const {isLocked: wasLocked, params} = swiper;
3188        const {slidesOffsetBefore} = params;
3189        if (slidesOffsetBefore) {
3190            const lastSlideIndex = swiper.slides.length - 1;
3191            const lastSlideRightEdge = swiper.slidesGrid[lastSlideIndex] + swiper.slidesSizesGrid[lastSlideIndex] + slidesOffsetBefore * 2;
3192            swiper.isLocked = swiper.size > lastSlideRightEdge;
3193        } else swiper.isLocked = swiper.snapGrid.length === 1;
3194        if (params.allowSlideNext === true) swiper.allowSlideNext = !swiper.isLocked;
3195        if (params.allowSlidePrev === true) swiper.allowSlidePrev = !swiper.isLocked;
3196        if (wasLocked && wasLocked !== swiper.isLocked) swiper.isEnd = false;
3197        if (wasLocked !== swiper.isLocked) swiper.emit(swiper.isLocked ? "lock" : "unlock");
3198    }
3199    var checkOverflow$1 = {
3200        checkOverflow
3201    };
3202    var defaults = {
3203        init: true,
3204        direction: "horizontal",
3205        oneWayMovement: false,
3206        swiperElementNodeName: "SWIPER-CONTAINER",
3207        touchEventsTarget: "wrapper",
3208        initialSlide: 0,
3209        speed: 300,
3210        cssMode: false,
3211        updateOnWindowResize: true,
3212        resizeObserver: true,
3213        nested: false,
3214        createElements: false,
3215        eventsPrefix: "swiper",
3216        enabled: true,
3217        focusableElements: "input, select, option, textarea, button, video, label",
3218        width: null,
3219        height: null,
3220        preventInteractionOnTransition: false,
3221        userAgent: null,
3222        url: null,
3223        edgeSwipeDetection: false,
3224        edgeSwipeThreshold: 20,
3225        autoHeight: false,
3226        setWrapperSize: false,
3227        virtualTranslate: false,
3228        effect: "slide",
3229        breakpoints: void 0,
3230        breakpointsBase: "window",
3231        spaceBetween: 0,
3232        slidesPerView: 1,
3233        slidesPerGroup: 1,
3234        slidesPerGroupSkip: 0,
3235        slidesPerGroupAuto: false,
3236        centeredSlides: false,

3237        centeredSlidesBounds: false,
3238        slidesOffsetBefore: 0,
3239        slidesOffsetAfter: 0,
3240        normalizeSlideIndex: true,
3241        centerInsufficientSlides: false,
3242        watchOverflow: true,
3243        roundLengths: false,
3244        touchRatio: 1,
3245        touchAngle: 45,
3246        simulateTouch: true,
3247        shortSwipes: true,
3248        longSwipes: true,
3249        longSwipesRatio: .5,
3250        longSwipesMs: 300,
3251        followFinger: true,
3252        allowTouchMove: true,
3253        threshold: 5,
3254        touchMoveStopPropagation: false,
3255        touchStartPreventDefault: true,
3256        touchStartForcePreventDefault: false,
3257        touchReleaseOnEdges: false,
3258        uniqueNavElements: true,
3259        resistance: true,
3260        resistanceRatio: .85,
3261        watchSlidesProgress: false,
3262        grabCursor: false,
3263        preventClicks: true,
3264        preventClicksPropagation: true,
3265        slideToClickedSlide: false,
3266        loop: false,
3267        loopAddBlankSlides: true,
3268        loopAdditionalSlides: 0,
3269        loopPreventsSliding: true,
3270        rewind: false,
3271        allowSlidePrev: true,
3272        allowSlideNext: true,
3273        swipeHandler: null,
3274        noSwiping: true,
3275        noSwipingClass: "swiper-no-swiping",
3276        noSwipingSelector: null,
3277        passiveListeners: true,
3278        maxBackfaceHiddenSlides: 10,
3279        containerModifierClass: "swiper-",
3280        slideClass: "swiper-slide",
3281        slideBlankClass: "swiper-slide-blank",
3282        slideActiveClass: "swiper-slide-active",
3283        slideVisibleClass: "swiper-slide-visible",
3284        slideFullyVisibleClass: "swiper-slide-fully-visible",
3285        slideNextClass: "swiper-slide-next",
3286        slidePrevClass: "swiper-slide-prev",
3287        wrapperClass: "swiper-wrapper",
3288        lazyPreloaderClass: "swiper-lazy-preloader",
3289        lazyPreloadPrevNext: 0,
3290        runCallbacksOnInit: true,
3291        _emitClasses: false
3292    };
3293    function moduleExtendParams(params, allModulesParams) {
3294        return function extendParams(obj) {
3295            if (obj === void 0) obj = {};
3296            const moduleParamName = Object.keys(obj)[0];
3297            const moduleParams = obj[moduleParamName];
3298            if (typeof moduleParams !== "object" || moduleParams === null) {
3299                utils_extend(allModulesParams, obj);
3300                return;
3301            }
3302            if (params[moduleParamName] === true) params[moduleParamName] = {
3303                enabled: true
3304            };
3305            if (moduleParamName === "navigation" && params[moduleParamName] && params[moduleParamName].enabled && !params[moduleParamName].prevEl && !params[moduleParamName].nextEl) params[moduleParamName].auto = true;
3306            if ([ "pagination", "scrollbar" ].indexOf(moduleParamName) >= 0 && params[moduleParamName] && params[moduleParamName].enabled && !params[moduleParamName].el) params[moduleParamName].auto = true;
3307            if (!(moduleParamName in params && "enabled" in moduleParams)) {
3308                utils_extend(allModulesParams, obj);
3309                return;
3310            }
3311            if (typeof params[moduleParamName] === "object" && !("enabled" in params[moduleParamName])) params[moduleParamName].enabled = true;
3312            if (!params[moduleParamName]) params[moduleParamName] = {
3313                enabled: false
3314            };
3315            utils_extend(allModulesParams, obj);
3316        };
3317    }
3318    const prototypes = {
3319        eventsEmitter,
3320        update,
3321        translate,
3322        transition,
3323        slide,
3324        loop,
3325        grabCursor,
3326        events: events$1,
3327        breakpoints,
3328        checkOverflow: checkOverflow$1,
3329        classes
3330    };
3331    const extendedDefaults = {};
3332    class swiper_core_Swiper {
3333        constructor() {
3334            let el;
3335            let params;
3336            for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) args[_key] = arguments[_key];
3337            if (args.length === 1 && args[0].constructor && Object.prototype.toString.call(args[0]).slice(8, -1) === "Object") params = args[0]; else [el, params] = args;
3338            if (!params) params = {};
3339            params = utils_extend({}, params);
3340            if (el && !params.el) params.el = el;
3341            const document = ssr_window_esm_getDocument();
3342            if (params.el && typeof params.el === "string" && document.querySelectorAll(params.el).length > 1) {
3343                const swipers = [];
3344                document.querySelectorAll(params.el).forEach((containerEl => {
3345                    const newParams = utils_extend({}, params, {
3346                        el: containerEl
3347                    });
3348                    swipers.push(new swiper_core_Swiper(newParams));
3349                }));
3350                return swipers;
3351            }
3352            const swiper = this;
3353            swiper.__swiper__ = true;

3354            swiper.support = getSupport();
3355            swiper.device = getDevice({
3356                userAgent: params.userAgent
3357            });
3358            swiper.browser = getBrowser();
3359            swiper.eventsListeners = {};
3360            swiper.eventsAnyListeners = [];
3361            swiper.modules = [ ...swiper.__modules__ ];
3362            if (params.modules && Array.isArray(params.modules)) swiper.modules.push(...params.modules);
3363            const allModulesParams = {};
3364            swiper.modules.forEach((mod => {
3365                mod({
3366                    params,
3367                    swiper,
3368                    extendParams: moduleExtendParams(params, allModulesParams),
3369                    on: swiper.on.bind(swiper),
3370                    once: swiper.once.bind(swiper),
3371                    off: swiper.off.bind(swiper),
3372                    emit: swiper.emit.bind(swiper)
3373                });
3374            }));
3375            const swiperParams = utils_extend({}, defaults, allModulesParams);
3376            swiper.params = utils_extend({}, swiperParams, extendedDefaults, params);
3377            swiper.originalParams = utils_extend({}, swiper.params);
3378            swiper.passedParams = utils_extend({}, params);
3379            if (swiper.params && swiper.params.on) Object.keys(swiper.params.on).forEac

3379h((eventName => {
3380                swiper.on(eventName, swiper.params.on[eventName]);
3381            }));
3382            if (swiper.params && swiper.params.onAny) swiper.onAny(swiper.params.onAny);
3383            Object.assign(swiper, {
3384                enabled: swiper.params.enabled,
3385                el,
3386                classNames: [],
3387                slides: [],
3388                slidesGrid: [],
3389                snapGrid: [],
3390                slidesSizesGrid: [],
3391                isHorizontal() {
3392                    return swiper.params.direction === "horizontal";
3393                },
3394                isVertical() {
3395                    return swiper.params.direction === "vertical";
3396                },
3397                activeIndex: 0,
3398                realIndex: 0,
3399                isBeginning: true,
3400                isEnd: false,
3401                translate: 0,
3402                previousTranslate: 0,
3403                progress: 0,
3404                velocity: 0,
3405                animating: false,
3406                cssOverflowAdjustment() {
3407                    return Math.trunc(this.translate / 2 ** 23) * 2 ** 23;
3408                },
3409                allowSlideNext: swiper.params.allowSlideNext,
3410                allowSlidePrev: swiper.params.allowSlidePrev,
3411                touchEventsData: {
3412                    isTouched: void 0,
3413                    isMoved: void 0,
3414                    allowTouchCallbacks: void 0,
3415                    touchStartTime: void 0,
3416                    isScrolling: void 0,
3417                    currentTranslate: void 0,
3418                    startTranslate: void 0,
3419                    allowThresholdMove: void 0,
3420                    focusableElements: swiper.params.focusableElements,
3421                    lastClickTime: 0,
3422                    clickTimeout: void 0,
3423                    velocities: [],
3424                    allowMomentumBounce: void 0,
3425                    startMoving: void 0,
3426                    pointerId: null,
3427                    touchId: null
3428                },
3429                allowClick: true,
3430                allowTouchMove: swiper.params.allowTouchMove,
3431                touches: {
3432                    startX: 0,
3433                    startY: 0,
3434                    currentX: 0,
3435                    currentY: 0,
3436                    diff: 0
3437                },
3438                imagesToLoad: [],
3439                imagesLoaded: 0
3440            });
3441            swiper.emit("_swiper");
3442            if (swiper.params.init) swiper.init();
3443            return swiper;
3444        }
3445        getDirectionLabel(property) {
3446            if (this.isHorizontal()) return property;
3447            return {
3448                width: "height",
3449                "margin-top": "margin-left",
3450                "margin-bottom ": "margin-right",
3451                "margin-left": "margin-top",
3452                "margin-right": "margin-bottom",
3453                "padding-left": "padding-top",
3454                "padding-right": "padding-bottom",
3455                marginRight: "marginBottom"
3456            }[property];
3457        }
3458        getSlideIndex(slideEl) {
3459            const {slidesEl, params} = this;
3460            const slides = utils_elementChildren(slidesEl, `.${params.slideClass}, swiper-slide`);
3461            const firstSlideIndex = utils_elementIndex(slides[0]);
3462            return utils_elementIndex(slideEl) - firstSlideIndex;
3463        }
3464        getSlideIndexByData(index) {
3465            return this.getSlideIndex(this.slides.filter((slideEl => slideEl.getAttribute("data-swiper-slide-index") * 1 === index))[0]);
3466        }
3467        recalcSlides() {
3468            const swiper = this;
3469            const {slidesEl, params} = swiper;
3470            swiper.slides = utils_elementChildren(slidesEl, `.${params.slideClass}, swiper-slide`);
3471        }
3472        enable() {
3473            const swiper = this;
3474            if (swiper.enabled) return;
3475            swiper.enabled = true;
3476            if (swiper.params.grabCursor) swiper.setGrabCursor();
3477            swiper.emit("enable");
3478        }
3479        disable() {
3480            const swiper = this;
3481            if (!swiper.enabled) return;
3482            swiper.enabled = false;
3483            if (swiper.params.grabCursor) swiper.unsetGrabCursor(

3483);
3484            swiper.emit("disable");
3485        }
3486        setProgress(progress, speed) {
3487            const swiper = this;
3488            progress = Math.min(Math.max(progress, 0), 1);
3489            const min = swiper.minTranslate();
3490            const max = swiper.maxTranslate();
3491            const current = (max - min) * progress + min;
3492            swiper.translateTo(current, typeof speed === "undefined" ? 0 : speed);
3493            swiper.updateActiveIndex();
3494            swiper.updateSlidesClasses();
3495        }
3496        emitContainerClasses() {
3497            const swiper = this;
3498            if (!swiper.params._emitClasses || !swiper.el) return;
3499            const cls = swiper.el.className.split(" ").filter((className => className.indexOf("swiper") === 0 || className.indexOf(swiper.params.containerModifierClass) === 0));
3500            swiper.emit("_containerClasses", cls.join(" "));
3501        }
3502        getSlideClasses(slideEl) {
3503            const swiper = this;
3504            if (swiper.destroyed) return "";
3505            return slideEl.className.split(" ").filter((className => className.indexOf("swiper-slide") === 0 || className.indexOf(swiper.params.slideClass) === 0)).join(" ");
3506        }
3507        emitSlidesClasses() {
3508            const swiper = this;
3509            if (!swiper.params._emitClasses || !swiper.el) return;
3510            const updates = [];
3511            swiper.slides.forEach((slideEl => {
3512                const classNames = swiper.getSlideClasses(slideEl);
3513                updates.push({
3514                    slideEl,
3515                    classNames
3516                });
3517                swiper.emit("_slideClass", slideEl, classNames);
3518            }));
3519            swiper.emit("_slideClasses", updates);
3520        }
3521        slidesPerViewDynamic(view, exact) {
3522            if (view === void 0) view = "current";
3523            if (exact === void 0) exact = false;
3524            const swiper = this;
3525            const {params, slides, slidesGrid, slidesSizesGrid, size: swiperSize, activeIndex} = swiper;
3526            let spv = 1;
3527            if (typeof params.slidesPerView === "number") return params.slidesPerView;
3528            if (params.centeredSlides) {
3529                let slideSize = slides[activeIndex] ? Math.ceil(slides[activeIndex].swiperSlideSize) : 0;
3530                let breakLoop;
3531                for (let i = activeIndex + 1; i < slides.length; i += 1) if (slides[i] && !breakLoop) {
3532                    slideSize += Math.ceil(slides[i].swiperSlideSize);
3533                    spv += 1;
3534                    if (slideSize > swiperSize) breakLoop = true;
3535                }
3536                for (let i = activeIndex - 1; i >= 0; i -= 1) if (slides[i] && !breakLoop) {
3537                    slideSize += slides[i].swiperSlideSize;
3538                    spv += 1;
3539                    if (slideSize > swiperSize) breakLoop = true;
3540                }
3541            } else if (view === "current") for (let i = activeIndex + 1; i < slides.length; i += 1) {
3542                const slideInView = exact ? slidesGrid[i] + slidesSizesGrid[i] - slidesGrid[activeIndex] < swiperSize : slidesGrid[i] - slidesGrid[activeIndex] < swiperSize;
3543                if (slideInView) spv += 1;
3544            } else for (let i = activeIndex - 1; i >= 0; i -= 1) {
3545                const slideInView = slidesGrid[activeIndex] - slidesGrid[i] < swiperSize;
3546                if (slideInView) spv += 1;
3547            }
3548            return spv;
3549        }
3550        update() {
3551            const swiper = this;
3552            if (!swiper || swiper.destroyed) return;
3553            const {snapGrid, params} = swiper;
3554            if (params.breakpoints) swiper.setBreakpoint();
3555            [ ...swiper.el.querySelectorAll('[loading="lazy"]') ].forEach((imageEl => {
3556                if (imageEl.complete) processLazyPreloader(swiper, imageEl);
3557            }));
3558            swiper.updateSize();
3559            swiper.updateSlides();
3560            swiper.updateProgress();
3561            swiper.updateSlidesClasses();
3562            function setTranslate() {
3563                const translateValue = swiper.rtlTranslate ? swiper.translate * -1 : swiper.translate;
3564                const newTranslate = Math.min(Math.max(translateValue, swiper.maxTranslate()), swiper.minTranslate());
3565                swiper.setTranslate(newTranslate);
3566                swiper.updateActiveIndex();
3567                swiper.updateSlidesClasses();
3568            }
3569            let translated;
3570            if (params.freeMode && params.freeMode.enabled && !params.cssMode) {
3571                setTranslate();
3572                if (params.autoHeight) swiper.updateAutoHeight();
3573            } else {
3574                if ((params.slidesPerView === "auto" || params.slidesPerView > 1) && swiper.isEnd && !params.centeredSlides) {
3575                    const slides = swiper.virtual && params.virtual.enabled ? swiper.virtual.slides : swiper.slides;
3576                    translated = swiper.slideTo(slides.length - 1, 0, false, true);
3577                } else translated = swiper.slideTo(swiper.activeIndex, 0, false, true);
3578                if (!translated) setTranslate();
3579            }
3580            if (params.watchOverflow && snapGrid !== swiper.snapGrid) swiper.checkOverflow();
3581            swiper.emit("update");
3582        }
3583        changeDirection(newDirection, needUpdate) {
3584            if (needUpdate === void 0) needUpdate = true;
3585            const swiper = this;
3586            const currentDirection = swiper.params.direction;
3587            if (!newDirection) newDirection = currentDirection === "horizontal" ? "vertical" : "horizontal";
3588            if (newDirection === currentDirection || newDirection !== "horizontal" && newDirection !== "vertical") return swiper;
3589            swiper.el.classList.remove(`${swiper.params.containerModifierClass}${currentDirection}`);
3590            swiper.el.classList.add(`${swiper.params.containerModifierClass}${newDirection}`);
3591            swiper.emitContainerClasses();
3592            swiper.params.direction = newDirection;

3593            swiper.slides.forEach((slideEl => {
3594                if (newDirection === "vertical") slideEl.style.width = ""; else slideEl.style.height = "";
3595            }));
3596            swiper.emit("changeDirection");
3597            if (needUpdate) swiper.update();
3598            return swiper;
3599        }
3600        changeLanguageDirection(direction) {
3601            const swiper = this;
3602            if (swiper.rtl && direction === "rtl" || !swiper.rtl && direction === "ltr") return;
3603            swiper.rtl = direction === "rtl";
3604            swiper.rtlTranslate = swiper.params.direction === "horizontal" && swiper.rtl;
3605            if (swiper.rtl) {
3606                swiper.el.classList.add(`${swiper.params.containerModifierClass}rtl`);
3607                swiper.el.dir = "rtl";
3608            } else {
3609                swiper.el.classList.remove(`${swiper.params.containerModifierClass}rtl`);
3610                swiper.el.dir = "ltr";
3611            }
3612            swiper.update();
3613        }
3614        mount(element) {
3615            const swiper = this;
3616            if (swiper.mounted) return true;
3617            let el = element || swiper.params.el;
3618            if (typeof el === "string") el = document.querySelector(el);
3619            if (!el) return false;
3620            el.swiper = swiper;
3621            if (el.parentNode && el.parentNode.host && el.parentNode.host.nodeName === swiper.params.swiperElementNodeName.toUpperCase()) swiper.isElement = true;
3622            const getWrapperSelector = () => `.${(swiper.params.wrapperClass || "").trim().split(" ").join(".")}`;
3623            const getWrapper = () => {
3624                if (el && el.shadowRoot && el.shadowRoot.querySelector) {
3625                    const res = el.shadowRoot.querySelector(getWrapperSelector());
3626                    return res;
3627                }
3628                return utils_elementChildren(el, getWrapperSelector())[0];
3629            };
3630            let wrapperEl = getWrapper();
3631            if (!wrapperEl && swiper.params.createElements) {
3632                wrapperEl = utils_createElement("div", swiper.params.wrapperClass);
3633                el.append(wrapperEl);
3634                utils_elementChildren(el, `.${swiper.params.slideClass}`).forEach((slideEl => {
3635                    wrapperEl.append(slideEl);
3636                }));
3637            }
3638            Object.assign(swiper, {
3639                el,
3640                wrapperEl,
3641                slidesEl: swiper.isElement && !el.parentNode.host.slideSlots ? el.parentNode.host : wrapperEl,
3642                hostEl: swiper.isElement ? el.parentNode.host : el,
3643                mounted: true,
3644                rtl: el.dir.toLowerCase() === "rtl" || elementStyle(el, "direction") === "rtl",
3645                rtlTranslate: swiper.params.direction === "horizontal" && (el.dir.toLowerCase() === "rtl" || elementStyle(el, "direction") === "rtl"),
3646                wrongRTL: elementStyle(wrapperEl, "display") === "-webkit-box"
3647            });
3648            return true;
3649        }
3650        init(el) {
3651            const swiper = this;
3652            if (swiper.initialized) return swiper;
3653            const mounted = swiper.mount(el);
3654            if (mounted === false) return swiper;
3655            swiper.emit("beforeInit");
3656            if (swiper.params.breakpoints) swiper.setBreakpoint();
3657            swiper.addClasses();
3658            swiper.updateSize();
3659            swiper.updateSlides();
3660            if (swiper.params.watchOverflow) swiper.checkOverflow();
3661            if (swiper.params.grabCursor && swiper.enabled) swiper.setGrabCursor();
3662            if (swiper.params.loop && swiper.virtual && swiper.params.virtual.enabled) swiper.slideTo(swiper.params.initialSlide + swiper.virtual.slidesBefore, 0, swiper.params.runCallbacksOnInit, false, true); else swiper.slideTo(swiper.params.initialSlide, 0, swiper.params.runCallbacksOnInit, false, true);
3663            if (swiper.params.loop) swiper.loopCreate();
3664            swiper.attachEvents();
3665            const lazyElements = [ ...swiper.el.querySelectorAll('[loading="lazy"]') ];
3666            if (swiper.isElement) lazyElements.push(...swiper.hostEl.querySelectorAll('[loading="lazy"]'));

3667            lazyElements.forEach((imageEl => {
3668                if (imageEl.complete) processLazyPreloader(swiper, imageEl); else imageEl.addEventListener("load", (e => {
3669                    processLazyPreloader(swiper, e.target);
3670                }));
3671            }));
3672            preload(swiper);
3673            swiper.initialized = true;
3674            preload(swiper);
3675            swiper.emit("init");
3676            swiper.emit("afterInit");
3677            return swiper;
3678        }
3679        destroy(deleteInstance, cleanStyles) {
3680            if (deleteInstance === void 0) deleteInstance = true;
3681            if (cleanStyles === void 0) cleanStyles = true;
3682            const swiper = this;
3683            const {params, el, wrapperEl, slides} = swiper;
3684            if (typeof swiper.params === "undefined" || swiper.destroyed) return null;
3685            swiper.emit("beforeDestroy");
3686            swiper.initialized = false;
3687            swiper.detachEvents();
3688            if (params.loop) swiper.loopDestroy();
3689            if (cleanStyles) {
3690                swiper.removeClasses();
3691                if (el && typeof el !== "string") el.removeAttribute("style");
3692                if (wrapperEl) wrapperEl.removeAttribute("style");
3693                if (slides && slides.length) slides.forEach((slideEl => {
3694                    slideEl.classList.remove(params.slideVisibleClass, params.slideFullyVisibleClass, params.slideActiveClass, params.slideNextClass, params.slidePrevClass);
3695                    slideEl.removeAttribute("style");
3696                    slideEl.removeAttribute("data-swiper-slide-index");
3697                }));
3698            }
3699            swiper.emit("destroy");
3700            Object.keys(swiper.eventsListeners).forEach((eventName => {
3701                swiper.off(eventName);
3702            }));
3703            if (deleteInstance !== false) {
3704                if (swiper.el && typeof swiper.el !== "string") swiper.el.swiper = null;
3705                deleteProps(swiper);
3706            }
3707            swiper.destroyed = true;
3708            return null;
3709        }
3710        static extendDefaults(newDefaults) {
3711            utils_extend(extendedDefaults, newDefaults);
3712        }
3713        static get extendedDefaults() {
3714            return extendedDefaults;
3715        }
3716        static get defaults() {
3717            return defaults;
3718        }
3719        static installModule(mod) {
3720            if (!swiper_core_Swiper.prototype.__modules__) swiper_core_Swiper.prototype.__modules__ = [];
3721            const modules = swiper_core_Swiper.prototype.__modules__;
3722            if (typeof mod === "function" && modules.indexOf(mod) < 0) modules.push(mod);
3723        }
3724        static use(module) {
3725            if (Array.isArray(module)) {
3726                module.forEach((m => swiper_core_Swiper.installModule(m)));
3727                return swiper_core_Swiper;
3728            }
3729            swiper_core_Swiper.installModule(module);
3730            return swiper_core_Swiper;
3731        }
3732    }
3733    Object.keys(prototypes).forEach((prototypeGroup => {
3734        Object.keys(prototypes[prototypeGroup]).forEach((protoMethod => {
3735            swiper_core_Swiper.prototype[protoMethod] = prototypes[prototypeGroup][protoMethod];
3736        }));
3737    }));
3738    swiper_core_Swiper.use([ Resize, Observer ]);
3739    function create_element_if_not_defined_createElementIfNotDefined(swiper, originalParams, params, checkProps) {
3740        if (swiper.params.createElements) Object.keys(checkProps).forEach((key => {
3741            if (!params[key] && params.auto === true) {
3742                let element = utils_elementChildren(swiper.el, `.${checkProps[key]}`)[0];
3743                if (!element) {
3744                    element = utils_createElement("div", checkProps[key]);
3745                    element.className = checkProps[key];
3746                    swiper.el.append(element);
3747                }
3748                params[key] = element;
3749                originalParams[key] = element;
3750            }
3751        }));
3752        return params;
3753    }
3754    function Navigation(_ref) {
3755        let {swiper, extendParams, on, emit} = _ref;
3756        extendParams({
3757            navigation: {
3758                nextEl: null,
3759                prevEl: null,
3760                hideOnClick: false,
3761                disabledClass: "swiper-button-disabled",
3762                hiddenClass: "swiper-button-hidden",
3763                lockClass: "swiper-button-lock",
3764                navigationDisabledClass: "swiper-navigation-disabled"
3765            }
3766        });
3767        swiper.navigation = {
3768            nextEl: null,
3769            prevEl: null
3770        };
3771        function getEl(el) {
3772            let res;
3773            if (el && typeof el === "string" && swiper.isElement) {
3774                res = swiper.el.querySelector(el);
3775                if (res) return res;
3776            }
3777            if (el) {
3778                if (typeof el === "string") res = [ ...document.querySelectorAll(el) ];
3779                if (swiper.params.uniqueNavElements && typeof el === "string" && res && res.length > 1 && swiper.el.querySelectorAll(el).length === 1) res = swiper.el.querySelector(el); else if (res && res.length === 1) res = res[0];
3780            }
3781            if (el && !res) return el;
3782            return res;
3783        }
3784        function toggleEl(el, disabled) {
3785            const params = swiper.params.navigation;
3786            el = utils_makeElementsArray(el);
3787            el.forEach((subEl => {
3788                if (subEl) {
3789                    subEl.classList[disabled ? "add" : "remove"](...params.disabledClass.split(" "));
3790                    if (subEl.tagName === "BUTTON") subEl.disabled = disabled;
3791                    if (swiper.params.watchOverflow && swiper.enabled) subEl.classList[swiper.isLocked ? "add" : "remove"](params.lockClass);
3792                }
3793            }));
3794        }

3795        function update() {
3796            const {nextEl, prevEl} = swiper.navigation;
3797            if (swiper.params.loop) {
3798                toggleEl(prevEl, false);
3799                toggleEl(nextEl, false);
3800                return;
3801            }
3802            toggleEl(prevEl, swiper.isBeginning && !swiper.params.rewind);
3803            toggleEl(nextEl, swiper.isEnd && !swiper.params.rewind);
3804        }
3805        function onPrevClick(e) {
3806            e.preventDefault();
3807            if (swiper.isBeginning && !swiper.params.loop && !swiper.params.rewind) return;
3808            swiper.slidePrev();
3809            emit("navigationPrev");
3810        }
3811        function onNextClick(e) {
3812            e.preventDefault();
3813            if (swiper.isEnd && !swiper.params.loop && !swiper.params.rewind) return;
3814            swiper.slideNext();
3815            emit("navigationNext");
3816        }
3817        function init() {
3818            const params = swiper.params.navigation;
3819            swiper.params.navigation = create_element_if_not_defined_createElementIfNotDefined(swiper, swiper.originalParams.navigation, swiper.params.navigation, {
3820                nextEl: "swiper-button-next",
3821                prevEl: "swiper-button-prev"
3822            });
3823            if (!(params.nextEl || params.prevEl)) return;
3824            let nextEl = getEl(params.nextEl);
3825            let prevEl = getEl(params.prevEl);
3826            Object.assign(swiper.navigation, {
3827                nextEl,
3828                prevEl
3829            });
3830            nextEl = utils_makeElementsArray(nextEl);
3831            prevEl = utils_makeElementsArray(prevEl);
3832            const initButton = (el, dir) => {
3833                if (el) el.addEventListener("click", dir === "next" ? onNextClick : onPrevClick);
3834                if (!swiper.enabled && el) el.classList.add(...params.lockClass.split(" "));
3835            };
3836            nextEl.forEach((el => initButton(el, "next")));
3837            prevEl.forEach((el => initButton(el, "prev")));
3838        }
3839        function destroy() {
3840            let {nextEl, prevEl} = swiper.navigation;
3841            nextEl = utils_makeElementsArray(nextEl);
3842            prevEl = utils_makeElementsArray(prevEl);
3843            const destroyButton = (el, dir) => {
3844                el.removeEventListener("click", dir === "next" ? onNextClick : onPrevClick);
3845                el.classList.remove(...swiper.params.navigation.disabledClass.split(" "));
3846            };
3847            nextEl.forEach((el => destroyButton(el, "next")));
3848            prevEl.forEach((el => destroyButton(el, "prev")));
3849        }
3850        on("init", (() => {
3851            if (swiper.params.navigation.enabled === false) disable(); else {
3852                init();
3853                update();
3854            }
3855        }));
3856        on("toEdge fromEdge lock unlock", (() => {
3857            update();
3858        }));
3859        on("destroy", (() => {
3860            destroy();
3861        }));
3862        on("enable disable", (() => {
3863            let {nextEl, prevEl} = swiper.navigation;
3864            nextEl = utils_makeElementsArray(nextEl);
3865            prevEl = utils_makeElementsArray(prevEl);
3866            if (swiper.enabled) {
3867                update();
3868                return;
3869            }
3870            [ ...nextEl, ...prevEl ].filter((el => !!el)).forEach((el => el.classList.add(swiper.params.navigation.lockClass)));
3871        }));
3872        on("click", ((_s, e) => {
3873            let {nextEl, prevEl} = swiper.navigation;
3874            nextEl = utils_makeElementsArray(nextEl);
3875            prevEl = utils_makeElementsArray(prevEl);
3876            const targetEl = e.target;
3877            let targetIsButton = prevEl.includes(targetEl) || nextEl.includes(targetEl);
3878            if (swiper.isElement && !targetIsButton) {
3879                const path = e.path || e.composedPath && e.composedPath();
3880                if (path) targetIsButton = path.find((pathEl => nextEl.includes(pathEl) || prevEl.includes(pathEl)));
3881            }
3882            if (swiper.params.navigation.hideOnClick && !targetIsButton) {
3883                if (swiper.pagination && swiper.params.pagination && swiper.params.pagination.clickable && (swiper.pagination.el === targetEl || swiper.pagination.el.contains(targetEl))) return;
3884                let isHidden;
3885                if (nextEl.length) isHidden = nextEl[0].classList.contains(swiper.params.navigation.hiddenClass); else if (prevEl.length) isHidden = prevEl[0].classList.contains(swiper.params.navigation.hiddenClass);
3886                if (isHidden === true) emit("navigationShow");

3886 else emit("navigationHide");
3887                [ ...nextEl, ...prevEl ].filter((el => !!el)).forEach((el => el.classList.toggle(swiper.params.navigation.hiddenClass)));
3888            }
3889        }));
3890        const enable = () => {
3891            swiper.el.classList.remove(...swiper.params.navigation.navigationDisabledClass.split(" "));
3892            init();
3893            update();
3894        };
3895        const disable = () => {
3896            swiper.el.classList.add(...swiper.params.navigation.navigationDisabledClass.split(" "));
3897            destroy();
3898        };
3899        Object.assign(swiper.navigation, {
3900            enable,
3901            disable,
3902            update,
3903            init,
3904            destroy
3905        });
3906    }
3907    function classes_to_selector_classesToSelector(classes) {
3908        if (classes === void 0) classes = "";
3909        return `.${classes.trim().replace(/([\.:!+\/])/g, "\\$1").replace(/ /g, ".")}`;
3910    }
3911    function Pagination(_ref) {
3912        let {swiper, extendParams, on, emit} = _ref;
3913        const pfx = "swiper-pagination";
3914        extendParams({
3915            pagination: {
3916                el: null,
3917                bulletElement: "span",
3918                clickable: false,
3919                hideOnClick: false,
3920                renderBullet: null,
3921                renderProgressbar: null,
3922                renderFraction: null,
3923                renderCustom: null,
3924                progressbarOpposite: false,
3925                type: "bullets",
3926                dynamicBullets: false,
3927                dynamicMainBullets: 1,
3928                formatFractionCurrent: number => number,
3929                formatFractionTotal: number => number,
3930                bulletClass: `${pfx}-bullet`,
3931                bulletActiveClass: `${pfx}-bullet-active`,
3932                modifierClass: `${pfx}-`,
3933                currentClass: `${pfx}-current`,
3934                totalClass: `${pfx}-total`,
3935                hiddenClass: `${pfx}-hidden`,
3936                progressbarFillClass: `${pfx}-progressbar-fill`,
3937                progressbarOppositeClass: `${pfx}-progressbar-opposite`,
3938                clickableClass: `${pfx}-clickable`,
3939                lockClass: `${pfx}-lock`,
3940                horizontalClass: `${pfx}-horizontal`,
3941                verticalClass: `${pfx}-vertical`,
3942                paginationDisabledClass: `${pfx}-disabled`
3943            }
3944        });
3945        swiper.pagination = {
3946            el: null,
3947            bullets: []
3948        };
3949        let bulletSize;
3950        let dynamicBulletIndex = 0;
3951        function isPaginationDisabled() {
3952            return !swiper.params.pagination.el || !swiper.pagination.el || Array.isArray(swiper.pagination.el) && swiper.pagination.el.length === 0;
3953        }
3954        function setSideBullets(bulletEl, position) {
3955            const {bulletActiveClass} = swiper.params.pagination;
3956            if (!bulletEl) return;
3957            bulletEl = bulletEl[`${position === "prev" ? "previous" : "next"}ElementSibling`];
3958            if (bulletEl) {
3959                bulletEl.classList.add(`${bulletActiveClass}-${position}`);
3960                bulletEl = bulletEl[`${position === "prev" ? "previous" : "next"}ElementSibling`];
3961                if (bulletEl) bulletEl.classList.add(`${bulletActiveClass}-${position}-${position}`);
3962            }
3963        }
3964        function onBulletClick(e) {
3965            const bulletEl = e.target.closest(classes_to_selector_classesToSelector(swiper.params.pagination.bulletClass));
3966            if (!bulletEl) return;
3967            e.preventDefault();
3968            const index = utils_elementIndex(bulletEl) * swiper.params.slidesPerGroup;
3969            if (swiper.params.loop) {
3970                if (swiper.realIndex === index) return;
3971                swiper.slideToLoop(index);
3972            } else swiper.slideTo(index);
3973        }
3974        function update() {
3975            const rtl = swiper.rtl;
3976            const params = swiper.params.pagination;
3977            if (isPaginationDisabled()) return;
3978            let el = swiper.pagination.el;
3979            el = utils_makeElementsArray(el);
3980            let current;
3981            let previousIndex;
3982            const slidesLength = swiper.virtual && swiper.params.virtual.enabled ? swiper.virtual.slides.length : swiper.slides.length;
3983            const total = swiper.params.loop ? Math.ceil(slidesLength / swiper.params.slidesPerGroup) : swiper.snapGrid.length;
3984            if (swiper.params.loop) {
3985                previousIndex = swiper.previousRealIndex || 0;
3986                current = swiper.params.slidesPerGroup > 1 ? Math.floor(swiper.realIndex / swiper.params.slidesPerGroup) : swiper.realIndex;
3987            } else if (typeof swiper.snapIndex !== "undefined") {
3988                current = swiper.snapIndex;
3989                previousIndex = swiper.previousSnapIndex;
3990            } else {
3991                previousIndex = swiper.previousIndex || 0;
3992                current = swiper.activeIndex || 0;
3993            }
3994            if (params.type === "bullets" && swiper.pagination.bullets && swiper.pagination.bullets.length > 0) {
3995                const bullets = swiper.pagination.bullets;
3996                let firstIndex;
3997                let lastIndex;
3998                let midIndex;
3999                if (params.dynamicBullets) {
4000                    bulletSize = elementOuterSize(bullets[0], swiper.isHorizontal() ? "width" : "height", true);
4001                    el.forEach((subEl => {
4002                        subEl.style[swiper.isHorizontal() ? "width" : "height"] = `${bulletSize * (params.dynamicMainBullets + 4)}px`;
4003                    }));
4004                    if (params.dynamicMainBullets > 1 && previousIndex !== void 0) {
4005                        dynamicBulletIndex += current - (previousIndex || 0);
4006                        if (dynamicBulletIndex > params.dynamicMainBullets - 1) dynamicBulletIndex = params.dynamicMainBullets - 1; else if (dynamicBulletIndex < 0) dynamicBulletIndex = 0;
4007                    }
4008                    firstIndex = Math.max(current - dynamicBulletIndex, 0);
4009                    lastIndex = firstIndex + (Math.min(bullets.length, params.dynamicMainBullets) - 1);
4010                    midIndex = (lastIndex + firstIndex) / 2;
4011                }

4012                bullets.forEach((bulletEl => {
4013                    const classesToRemove = [ ...[ "", "-next", "-next-next", "-prev", "-prev-prev", "-main" ].map((suffix => `${params.bulletActiveClass}${suffix}`)) ].map((s => typeof s === "string" && s.includes(" ") ? s.split(" ") : s)).flat();
4014                    bulletEl.classList.remove(...classesToRemove);
4015                }));
4016                if (el.length > 1) bullets.forEach((bullet => {
4017                    const bulletIndex = utils_elementIndex(bullet);
4018                    if (bulletIndex === current) bullet.classList.add(...params.bulletActiveClass.split(" ")); else if (swiper.isElement) bullet.setAttribute("part", "bullet");
4019                    if (params.dynamicBullets) {
4020                        if (bulletIndex >= firstIndex && bulletIndex <= lastIndex) bullet.classList.add(...`${params.bulletActiveClass}-main`.split(" "));
4021                        if (bulletIndex === firstIndex) setSideBullets(bullet, "prev");
4022                        if (bulletIndex === lastIndex) setSideBullets(bullet, "next");
4023                    }
4024                })); else {
4025                    const bullet = bullets[current];
4026                    if (bullet) bullet.classList.add(...params.bulletActiveClass.split(" "));
4027                    if (swiper.isElement) bullets.forEach(((bulletEl, bulletIndex) => {
4028                        bulletEl.setAttribute("part", bulletIndex === current ? "bullet-active" : "bullet");
4029                    }));
4030                    if (params.dynamicBullets) {
4031                        const firstDisplayedBullet = bullets[firstIndex];
4032                        const lastDisplayedBullet = bullets[lastIndex];
4033                        for (let i = firstIndex; i <= lastIndex; i += 1) if (bullets[i]) bullets[i].classList.add(...`${params.bulletActiveClass}-main`.split(" "));
4034                        setSideBullets(firstDisplayedBullet, "prev");
4035                        setSideBullets(lastDisplayedBullet, "next");
4036                    }
4037                }
4038                if (params.dynamicBullets) {
4039                    const dynamicBulletsLength = Math.min(bullets.length, params.dynamicMainBullets + 4);
4040                    const bulletsOffset = (bulletSize * dynamicBulletsLength - bulletSize) / 2 - midIndex * bulletSize;
4041                    const offsetProp = rtl ? "right" : "left";
4042                    bullets.forEach((bullet => {
4043                        bullet.style[swiper.isHorizontal() ? offsetProp : "top"] = `${bulletsOffset}px`;
4044                    }));
4045                }
4046            }
4047            el.forEach(((subEl, subElIndex) => {
4048                if (params.type === "fraction") {
4049                    subEl.querySelectorAll(classes_to_selector_classesToSelector(params.currentClass)).forEach((fractionEl => {
4050                        fractionEl.textContent = params.formatFractionCurrent(current + 1);
4051                    }));
4052                    subEl.querySelectorAll(classes_to_selector_classesToSelector(params.totalClass)).forEach((totalEl => {
4053                        totalEl.textContent = params.formatFractionTotal(total);
4054                    }));
4055                }
4056                if (params.type === "progressbar") {
4057                    let progressbarDirection;
4058                    if (params.progressbarOpposite) progressbarDirection = swiper.isHorizontal() ? "vertical" : "horizontal"; else progressbarDirection = swiper.isHorizontal() ? "horizontal" : "vertical";
4059                    const scale = (current + 1) / total;
4060                    let scaleX = 1;
4061                    let scaleY = 1;
4062                    if (progressbarDirection === "horizontal") scaleX = scale; else scaleY = scale;
4063                    subEl.querySelectorAll(classes_to_selector_classesToSelector(params.progressbarFillClass)).forEach((progressEl => {
4064                        progressEl.style.transform = `translate3d(0,0,0) scaleX(${scaleX}) scaleY(${scaleY})`;
4065                        progressEl.style.transitionDuration = `${swiper.params.speed}ms`;
4066                    }));
4067                }
4068                if (params.type === "custom" && params.renderCustom) {
4069                    subEl.innerHTML = params.renderCustom(swiper, current + 1, total);
4070                    if (subElIndex === 0) emit("paginationRender", subEl);
4071                } else {
4072                    if (subElIndex === 0) emit("paginationRender", subEl);
4073                    emit("paginationUpdate", subEl);
4074                }
4075                if (swiper.params.watchOverflow && swiper.enabled) subEl.classList[swiper.isLocked ? "add" : "remove"](params.lockClass);
4076            }));
4077        }
4078        function render() {
4079            const params = swiper.params.pagination;
4080            if (isPaginationDisabled()) return;
4081            const slidesLength = swiper.virtual && swiper.params.virtual.enabled ? swiper.virtual.slides.length : swiper.grid && swiper.params.grid.rows > 1 ? swiper.slides.length / Math.ceil(swiper.params.grid.rows) : swiper.slides.length;
4082            let el = swiper.pagination.el;
4083            el = utils_makeElementsArray(el);
4084            let paginationHTML = "";
4085            if (params.type === "bullets") {
4086                let numberOfBullets = swiper.params.loop ? Math.ceil(slidesLength / swiper.params.slidesPerGroup) : swiper.snapGrid.length;
4087                if (swiper.params.freeMode && swiper.params.freeMode.enabled && numberOfBullets > slidesLength) numberOfBullets = slidesLength;
4088                for (let i = 0; i < numberOfBullets; i += 1) if (params.renderBullet) paginationHTML += params.renderBullet.call(swi

4088per, i, params.bulletClass); else paginationHTML += `<${params.bulletElement} ${swiper.isElement ? 'part="bullet"' : ""} class="${params.bulletClass}"></${params.bulletElement}>`;
4089            }
4090            if (params.type === "fraction") if (params.renderFraction) paginationHTML = params.renderFraction.call(swiper, params.currentClass, params.totalClass); else paginationHTML = `<span class="${params.currentClass}"></span>` + " / " + `<span class="${params.totalClass}"></span>`;
4091            if (params.type === "progressbar") if (params.renderProgressbar) paginationHTML = params.renderProgressbar.call(swiper, params.progressbarFillClass); else paginationHTML = `<span class="${params.progressbarFillClass}"></span>`;
4092            swiper.pagination.bullets = [];
4093            el.forEach((subEl => {
4094                if (params.type !== "custom") subEl.innerHTML = paginationHTML || "";
4095                if (params.type === "bullets") swiper.pagination.bullets.push(...subEl.querySelectorAll(classes_to_selector_classesToSelector(params.bulletClass)));
4096            }));
4097            if (params.type !== "custom") emit("paginationRender", el[0]);
4098        }
4099        function init() {
4100            swiper.params.pagination = create_element_if_not_defined_createElementIfNotDefined(swiper, swiper.originalParams.pagination, swiper.params.pagination, {
4101                el: "swiper-pagination"
4102            });
4103            const params = swiper.params.pagination;
4104            if (!params.el) return;
4105            let el;
4106            if (typeof params.el === "string" && swiper.isElement) el = swiper.el.querySelector(params.el);
4107            if (!el && typeof params.el === "string") el = [ ...document.querySelectorAll(params.el) ];
4108            if (!el) el = params.el;
4109            if (!el || el.length === 0) return;
4110            if (swiper.params.uniqueNavElements && typeof params.el === "string" && Array.isArray(el) && el.length > 1) {
4111                el = [ ...swiper.el.querySelectorAll(params.el) ];
4112                if (el.length > 1) el = el.filter((subEl => {
4113                    if (utils_elementParents(subEl, ".swiper")[0] !== swiper.el) return false;
4114                    return true;
4115                }))[0];
4116            }
4117            if (Array.isArray(el) && el.length === 1) el = el[0];
4118            Object.assign(swiper.pagination, {
4119                el
4120            });
4121            el = utils_makeElementsArray(el);
4122            el.forEach((subEl => {
4123                if (params.type === "bullets" && params.clickable) subEl.classList.add(...(params.clickableClass || "").split(" "));
4124                subEl.classList.add(params.modifierClass + params.type);
4125                subEl.classList.add(swiper.isHorizontal() ? params.horizontalClass : params.verticalClass);
4126                if (params.type === "bullets" && params.dynamicBullets) {
4127                    subEl.classList.add(`${params.modifierClass}${params.type}-dynamic`);
4128                    dynamicBulletIndex = 0;
4129                    if (params.dynamicMainBullets < 1) params.dynamicMainBullets = 1;
4130                }
4131                if (params.type === "progressbar" && params.progressbarOpposite) subEl.classList.add(params.progressbarOppositeClass);
4132                if (params.clickable) subEl.addEventListener("click", onBulletClick);
4133                if (!swiper.enabled) subEl.classList.add(params.lockClass);
4134            }));
4135        }
4136        function destroy() {
4137            const params = swiper.params.pagination;
4138            if (isPaginationDisabled()) return;
4139            let el = swiper.pagination.el;
4140            if (el) {
4141                el = utils_makeElementsArray(el);
4142                el.forEach((subEl => {
4143                    subEl.classList.remove(params.hiddenClass);
4144                    subEl.classList.remove(params.modifierClass + params.type);
4145                    subEl.classList.remove(swiper.isHorizontal() ? params.horizontalClass : params.verticalClass);
4146                    if (params.clickable) {
4147                        subEl.classList.remove(...(params.clickableClass || "").split(" "));
4148                        subEl.removeEventListener("click", onBulletClick);
4149                    }
4150                }));
4151            }
4152            if (swiper.pagination.bullets) swiper.pagination.bullets.forEac

4152h((subEl => subEl.classList.remove(...params.bulletActiveClass.split(" "))));
4153        }
4154        on("changeDirection", (() => {
4155            if (!swiper.pagination || !swiper.pagination.el) return;
4156            const params = swiper.params.pagination;
4157            let {el} = swiper.pagination;
4158            el = utils_makeElementsArray(el);
4159            el.forEach((subEl => {
4160                subEl.classList.remove(params.horizontalClass, params.verticalClass);
4161                subEl.classList.add(swiper.isHorizontal() ? params.horizontalClass : params.verticalClass);
4162            }));
4163        }));
4164        on("init", (() => {
4165            if (swiper.params.pagination.enabled === false) disable(); else {
4166                init();
4167                render();
4168                update();
4169            }
4170        }));
4171        on("activeIndexChange", (() => {
4172            if (typeof swiper.snapIndex === "undefined") update();
4173        }));
4174        on("snapIndexChange", (() => {
4175            update();
4176        }));
4177        on("snapGridLengthChange", (() => {
4178            render();
4179            update();
4180        }));
4181        on("destroy", (() => {
4182            destroy();
4183        }));
4184        on("enable disable", (() => {
4185            let {el} = swiper.pagination;
4186            if (el) {
4187                el = utils_makeElementsArray(el);
4188                el.forEach((subEl => subEl.classList[swiper.enabled ? "remove" : "add"](swiper.params.pagination.lockClass)));
4189            }
4190        }));
4191        on("lock unlock", (() => {
4192            update();
4193        }));
4194        on("click", ((_s, e) => {
4195            const targetEl = e.target;
4196            const el = utils_makeElementsArray(swiper.pagination.el);
4197            if (swiper.params.pagination.el && swiper.params.pagination.hideOnClick && el && el.length > 0 && !targetEl.classList.contains(swiper.params.pagination.bulletClass)) {
4198                if (swiper.navigation && (swiper.navigation.nextEl && targetEl === swiper.navigation.nextEl || swiper.navigation.prevEl && targetEl === swiper.navigation.prevEl)) return;
4199                const isHidden = el[0].classList.contains(swiper.params.pagination.hiddenClass);
4200                if (isHidden === true) emit("paginationShow"); else emit("paginationHide");
4201                el.forEach((subEl => subEl.classList.toggle(swiper.params.pagination.hiddenClass)));
4202            }
4203        }));
4204        const enable = () => {
4205            swiper.el.classList.remove(swiper.params.pagination.paginationDisabledClass);
4206            let {el} = swiper.pagination;
4207            if (el) {
4208                el = utils_makeElementsArray(el);
4209                el.forEach((subEl => subEl.classList.remove(swiper.params.pagination.paginationDisabledClass)));
4210            }
4211            init();
4212            render();
4213            update();
4214        };
4215        const disable = () => {
4216            swiper.el.classList.add(swiper.params.pagination.paginationDisabledClass);
4217            let {el} = swiper.pagination;
4218            if (el) {
4219                el = utils_makeElementsArray(el);
4220                el.forEach((subEl => subEl.classList.add(swiper.params.pagination.paginationDisabledClass)));
4221            }
4222            destroy();
4223        };
4224        Object.assign(swiper.pagination, {
4225            enable,
4226            disable,
4227            render,
4228            update,
4229            init,
4230            destroy
4231        });
4232    }
4233    const buildSwiperSlider = (sliderElm, spaceBetween, slidesPerView, breakpoints, isLoop, pagination, initialSlide, centeredSlides) => {
4234        const sliderId = sliderElm.dataset.id;
4235
4236        const swiperConfig = {
4237            direction: "horizontal",
4238            loop: isLoop,
4239            slidesPerView,
4240            initialSlide,
4241            centeredSlides,
4242            modules: [ Navigation, Pagination ],
4243            navigation: {
4244                nextEl: `.button-next-${sliderId}`,
4245                prevEl: `.button-prev-${sliderId}`
4246            },
4247            scrollbar: {
4248                el: ".swiper-scrollbar",
4249                draggable: true,
4250                dragClass: "swiper-scrollbar-drag",
4251                hide: false
4252            },
4253            pagination,
4254            spaceBetween,
4255            breakpoints,
4256            observer: true,
4257            observeParents: true,
4258            disabledClass: "swiper-button-disabled"
4259        };
4260
4261
4262       // Add special event handling for proctoring works slider
4263       if (sliderElm.id === 'swiper-proctoring-works') {
4264            swiperConfig.on = {
4265                slideChange: function () {
4266                    const currentSlideIndex = this.realIndex + 1;
4267
4268                    const currentSlideElement = document.querySelector('.current-slide');
4269                    if (currentSlideElement) {
4270                        currentSlideElement.textContent = currentSlideIndex;
4271                    }
4272
4273                    const h3Elements = document.querySelectorAll('.proctoring-title');
4274                    const pElement = document.querySelector('.proctoring-description');
4275        
4276                    if (h3Elements.length > 0 && pElement) {
4277                        switch (this.realIndex) {
4278                            case 0:

4279                                h3Elements.forEach(h3 => h3.textContent = 'ÐÐ±ÐµÑÑÑÑ Ð±Ð°Ð¶Ð°Ð½Ð¸Ð¹ ÐºÑÑÑ ÑÐ° ÑÐ¾Ð·Ð¿Ð¾ÑÐ½ÑÑÑ Ð½Ð°Ð²ÑÐ°Ð½Ð½Ñ');
4280                                pElement.textContent = 'ÐÐ±Ð¸ÑÐ°Ð¹ÑÐµ ÑÐµÑÐµÐ´ Ð±ÑÐ»ÑÑ Ð½ÑÐ¶ 400 Ð´Ð¾ÑÑÑÐ¿Ð½Ð¸Ñ ÐºÑÑÑÑÐ² ÑÐ· Ð¼Ð¾Ð¶Ð»Ð¸Ð²ÑÑÑÑ Ð²ÐµÑÐ¸ÑÑÐºÐ°ÑÑÑ ÑÐ° ÑÐ¾Ð·Ð¿Ð¾ÑÐ¸Ð½Ð°Ð¹ÑÐµ Ð½Ð°Ð²ÑÐ°Ð½Ð½Ñ. ÐÑÐ´Ð¿Ð¸ÑÐºÐ° Ð½Ð° Ð²ÐµÑÐ¸ÑÑÐºÐ¾Ð²Ð°Ð½Ñ ÑÐµÑÑÐ¸ÑÑÐºÐ°ÑÐ¸ Ð½Ðµ Ð¼Ð°Ñ Ð¾Ð±Ð¼ÐµÐ¶ÐµÐ½Ñ Ð·Ð° ÐºÑÐ»ÑÐºÑÑÑÑ Ð¿ÑÐ¾Ð¹Ð´ÐµÐ½Ð¸Ñ ÐºÑÑÑÑÐ².';
4281                                break;
4282                            case 1:
4283                                h3Elements.forEach(h3 => h3.textContent = 'ÐÐ°Ð»Ð°ÑÑÑÐ²Ð°Ð½Ð½Ñ Ð¿ÑÐ¸ÑÑÑÐ¾ÑÐ²');
4284                                pElement.textContent = 'ÐÐµÑÐµÐ´ ÑÐºÐ»Ð°Ð´Ð°Ð½Ð½ÑÐ¼ ÑÐµÑÑÑ Ð¿Ð¾ÑÑÑÐ±Ð½Ð¾ Ð½Ð°Ð»Ð°ÑÑÑÐ²Ð°ÑÐ¸ ÐºÐ°Ð¼ÐµÑÑ. ÐÐ¾Ð½Ð° Ð²Ð¸ÐºÐ¾ÑÐ¸ÑÑÐ¾Ð²ÑÑÑÑÑÑ Ð´Ð»Ñ Ð¿ÑÐ´ÑÐ²ÐµÑÐ´Ð¶ÐµÐ½Ð½Ñ Ð²Ð°ÑÐ¾Ñ Ð¾ÑÐ¾Ð±Ð¸ÑÑÐ¾ÑÑÑ, ÑÐ¾ Ð´Ð¾Ð¿Ð¾Ð¼Ð°Ð³Ð°Ñ Ð·Ð°Ð±ÐµÐ·Ð¿ÐµÑÐ¸ÑÐ¸ Ð´Ð¾ÑÑÐ¾Ð²ÑÑÐ½ÑÑÑÑ ÑÐµÑÑÑÐ²Ð°Ð½Ð½Ñ.';

4285                                break;
4286                            case 2:
4287                                h3Elements.forEach(h3 => h3.textContent = 'ÐÑÐ¾Ð¹Ð´ÑÑÑ ÑÐµÑÑÑÐ²Ð°Ð½Ð½Ñ');
4288                                pElement.textContent = 'ÐÑÐ´ ÑÐ°Ñ Ð¿ÑÐ¾ÑÐ¾Ð´Ð¶ÐµÐ½Ð½Ñ ÑÐµÑÑÑ ÑÐ¸ÑÑÐµÐ¼Ð° Ð¿ÐµÑÐµÐ²ÑÑÑÑ, ÑÐ¾ ÑÑÐ¿Ð¸Ñ ÑÐºÐ»Ð°Ð´Ð°Ñ ÑÐ°Ð¼Ðµ ÑÐ° Ð»ÑÐ´Ð¸Ð½Ð°, ÑÐ¸Ñ ÑÐ¼\'Ñ Ð±ÑÐ´Ðµ Ð·Ð°Ð·Ð½Ð°ÑÐµÐ½Ð¾ Ð½Ð° ÑÐµÑÑÐ¸ÑÑÐºÐ°ÑÑ. ÐÐ»Ñ ÑÑÐ¾Ð³Ð¾ Ð²Ð¸ÐºÐ¾ÑÐ¸ÑÑÐ¾Ð²ÑÑÑÑÑÑ Ð²ÐµÐ±-ÐºÐ°Ð¼ÐµÑÐ° ÑÐ° Ð°Ð½Ð°Ð»ÑÐ· Ð¿Ð¾Ð²ÐµÐ´ÑÐ½ÐºÐ¸ ÑÐ»ÑÑÐ°ÑÑÐ².';
4289                                break;
4290                            case 3:
4291                                h3Elements.forEach(h3 => h3.textContent = 'ÐÑÑÐ¸Ð¼Ð°Ð¹ÑÐµ Ð²ÐµÑÐ¸ÑÑÐºÐ¾Ð²Ð°Ð½Ð¸Ð¹ ÑÐµÑÑÐ¸ÑÑÐºÐ°Ñ');
4292                                pElement.textContent = 'ÐÑÑÐ»Ñ ÑÑÐ¿ÑÑÐ½Ð¾Ð³Ð¾ Ð¿ÑÐ¾ÑÐ¾Ð´Ð¶ÐµÐ½Ð½Ñ ÑÐµÑÑÑÐ²Ð°Ð½Ð½Ñ Ð²Ð¸ Ð¾ÑÑÐ¸Ð¼Ð°ÑÑÐµ ÑÐµÑÑÐ¸ÑÑÐºÐ°Ñ, ÑÐ¾ Ð¿ÑÐ´ÑÐ²ÐµÑÐ´Ð¶ÑÑ Ð²Ð°ÑÑ Ð·Ð½Ð°Ð½Ð½Ñ ÑÐ° ÑÐµÐ·ÑÐ»ÑÑÐ°ÑÐ¸ Ð½ÐµÐ·Ð°Ð»ÐµÐ¶Ð½Ð¾Ð³Ð¾ Ð¾ÑÑÐ½ÑÐ²Ð°Ð½Ð½Ñ Ð·Ð° Ð´Ð¾Ð¿Ð¾Ð¼Ð¾Ð³Ð¾Ñ Ð²ÐµÐ±-ÐºÐ°Ð¼ÐµÑÐ¸ ÑÐ° Ð°Ð½Ð°Ð»ÑÐ·Ñ Ð¿Ð¾Ð²ÐµÐ´ÑÐ½ÐºÐ¸ ÑÐ»ÑÑÐ°ÑÑÐ².';
4293                                break;
4294                        }
4295                    }
4296                },
4297                navigation: {
4298                    nextEl: `.button-next-proctoring-works`,
4299                    prevEl: `.button-prev-proctoring-works`
4300                },
4301            };
4302        }
4303
4304        return new swiper_core_Swiper(`#${sliderElm.id}`, swiperConfig);
4305    };
4306    function initSliders() {
4307        const allSliders = document.querySelectorAll(".swiper");
4308        allSliders.forEach((slider => {
4309            let isLoop = false;
4310            let slidesPerView = "auto";
4311            let spaceBetween = 16;
4312            let centeredSlides = false;
4313            let initialSlide = 0;
4314            let breakpoints = {
4315                640: {
4316                    spaceBetween: 16
4317                },
4318                768: {
4319                    spaceBetween: 24
4320                },
4321                1024: {
4322                    spaceBetween: 36
4323                }
4324            };
4325            let pagination = {
4326                el: `.swiper-pagination-${slider.dataset.id}`,
4327                clickable: true
4328            };
4329            if (slider.id === "swiper-bootcamp") {
4330                slidesPerView = "auto";
4331                breakpoints = {
4332                    640: {
4333                        slidesPerView: "auto"
4334                    },
4335                    768: {
4336                        slidesPerView: "auto"
4337                    },
4338                    1024: {
4339                        slidesPerView: 1
4340                    }
4341                };
4342                pagination = {
4343                    el: `.swiper-pagination-${slider.dataset.id}`,
4344                    clickable: true,
4345                    renderBullet: function(index, className) {
4346                        const slideTitles = slider.querySelectorAll("#bootcamp-title");
4347                        const title = slideTitles[index] ? slideTitles[index].textContent : "";
4348                        return '<div class="' + className + '">' + title + "</div>";
4349                    }
4350                };
4351            }
4352            if (slider.id === "swiper-blog") {
4353                spaceBetween = 40;
4354                breakpoints = {
4355                    640: {
4356                        spaceBetween
4357                    },
4358                    768: {
4359                        spaceBetween: 48
4360                    },
4361                    1024: {
4362                        spaceBetween: 56
4363                    }
4364                };
4365            }
4366            if (slider.id === "swiper-skill-sm") breakpoints = {
4367                640: {
4368                    spaceBetween: 16
4369                },
4370                768: {
4371                    spaceBetween: 20
4372                },
4373                1024: {
4374                    spaceBetween: 16
4375                }
4376            };
4377            if (slider.id === "swiper-mentors") breakpoints = {
4378                640: {
4379                    spaceBetween: 16
4380                },
4381                768: {
4382                    spaceBetween: 32
4383                },
4384                1024: {
4385                    spaceBetween: 32
4386                }
4387            };
4388            if (slider.id === "swiper-career-nav" || slider.id === "swiper-category") {
4389                slidesPerView = "auto";
4390                isLoop = true;
4391                spaceBetween = 8;
4392                breakpoints = {
4393                    640: {
4394                        spaceBetween
4395                    },
4396                    768: {
4397                        spaceBetween
4398                    },
4399                    1024: {
4400                        spaceBetween
4401                    }
4402                };
4403            }
4404            if (slider.id === "swiper-category") ;
4405            if (slider.id === "swiper-career") {
4406                spaceBetween = 24;
4407                breakpoints = {
4408                    640: {
4409                        spaceBetween
4410                    },
4411                    768: {
4412                        spaceBetween
4413                    },
4414                    1024: {
4415                        spaceBetween
4416                    }
4417                };
4418            }
4419            if (slider.id === "swiper-plus" || slider.id === "swiper-plus-skills") {
4420                spaceBetween = 24;
4421                centeredSlides = true;
4422                initialSlide = 1;
4423                isLoop = true;
4424                breakpoints = {
4425                    640: {
4426                        initialSlide: 1,
4427                        spaceBetween,
4428                        centeredSlides: true
4429                    },
4430                    768: {
4431                        initialSlide: 2,
4432                        centeredSlides: true,
4433                        spaceBetween
4434                    },
4435                    1024: {
4436                        initialSlide: 0,
4437                        centeredSlides: false,
4438                        spaceBetween: 16
4439                    }
4440                };
4441            }
4442            if (slider.id === "swiper-feedbacks") breakpoints = {
4443                640: {
4444                    spaceBetween: 16
4445                },
4446                768: {
4447                    spaceBetween: 24
4448                },
4449                1024: {
4450                    spaceBetween: 24
4451                }
4452            };
4453            if (slider.id === "swiper-our-stuff") breakpoints = {
4454                640: {
4455                    spaceBetween: 16
4456                },
4457                768: {
4458                    spaceBetween: 24
4459                },
4460                1024: {
4461                    spaceBetween: 24
4462                }
4463            };
4464            if (slider.id === "swiper-our-methods") breakpoints = {
4465                640: {
4466                    spaceBetween: 24
4467                },
4468                768: {
4469                    spaceBetween: 24
4470                },
4471                1024: {
4472                    spaceBetween: 36
4473                }
4474            };
4475            if (slider.id === "swiper-proctoring-works") {
4476                spaceBetween = 14;
4477                slidesPerView = 1;
4478            }
4479            buildSwiperSlider(slider, spaceBetween, slidesPerView, breakpoints, isLoop, pagination, centeredSlides, initialSlide);
4480        }));
4481    }
4482    window.addEventListener("DOMContentLoaded", (function(e) {
4483        initSliders();
4484    }));
4485    let addWindowScrollEvent = false;

4486    setTimeout((() => {
4487        if (addWindowScrollEvent) {
4488            let windowScroll = new Event("windowScroll");
4489            window.addEventListener("scroll", (function(e) {
4490                document.dispatchEvent(windowScroll);
4491            }));
4492        }
4493    }), 0);
4494    window["FLS"] = true;
4495    menuInit();
4496    openDropdown();
4497    stickBtn();
4498    showMoreBtn();
4499    spollers();
4500    flipCard();
4501    showMore();
4502    setPrometheusPlusHeaderImage();
4503
4504
4505    //scroll fixed navigation
4506    var windowheight = jQuery(window).height();
4507    jQuery(window).scroll(function() {
4508        if (jQuery(window).scrollTop() >= windowheight){
4509            if(jQuery('.landingbar').length){
4510               jQuery('.landingbar').addClass('fixednav');
4511            } else{
4512                jQuery('div#topnav').addClass('fixednav');
4513            }
4514        }else{
4515            jQuery('.landingbar').removeClass('fixednav');
4516            jQuery('div#topnav').removeClass('fixednav');
4517        }
4518    });
4519
4520    // Auto-dismiss WooCommerce notices after 4 seconds
4521    document.addEventListener( 'DOMContentLoaded', function () {
4522        function autoDismissNotices() {
4523            var notices = document.querySelectorAll(
4524                '.woocommerce-message, .woocommerce-error, .woocommerce-info'
4525            );
4526            notices.forEach( function ( notice ) {
4527                setTimeout( function () {
4528                    notice.style.transition = 'opacity 0.5s ease';
4529                    notice.style.opacity = '0';
4530                    setTimeout( function () {
4531                        notice.remove();
4532                    }, 500 ); // Ð²Ð¸Ð´Ð°Ð»ÑÑÐ¼Ð¾ Ð¿ÑÑÐ»Ñ Ð·Ð°Ð²ÐµÑÑÐµÐ½Ð½Ñ Ð°Ð½ÑÐ¼Ð°ÑÑÑ
4533                }, 6000 );
4534            } );
4535        }
4536
4537        autoDismissNotices();
4538
4539        // Ð¢Ð°ÐºÐ¾Ð¶ Ð´Ð»Ñ notices ÑÐ¾ Ð·'ÑÐ²Ð»ÑÑÑÑÑÑ Ð¿ÑÑÐ»Ñ AJAX (Ð½Ð°Ð¿ÑÐ¸ÐºÐ»Ð°Ð´ Ð¿ÑÐ¸ Ð¾Ð½Ð¾Ð²Ð»ÐµÐ½Ð½Ñ ÐºÐ¾ÑÐ¸ÐºÐ°)
4540        if ( typeof jQuery !== 'undefined' ) {
4541            jQuery( document.body ).on(
4542                'wc_fragments_refreshed updated_cart_totals updated_checkout',
4543                function () {
4544                    setTimeout( autoDismissNotices, 100 );
4545                }
4546            );
4547        }
4548    } );
4549})();

Line numbers count LF bytes from the start of the resource, as the search results do. Vendor segments are library code the classifier recognised; they are stored but not indexed. Bytes are shown as Latin1 characters, one per byte.