https://byd-egypt.com/front-assets/js/clientlib-service-swiper.min.75f5f6c8cf43a471ce8369e0942f0d21.js

1(function(){
2    var __pow = Math.pow;
3    function isObject$1(obj) {
4        return obj !== null && typeof obj === "object" && "constructor" in obj && obj.constructor === Object;
5    }
6    function extend$1(target = {}, src = {}) {
7        Object.keys(src).forEach((key) => {
8            if (typeof target[key] === "undefined")
9                target[key] = src[key];
10            else if (isObject$1(src[key]) && isObject$1(target[key]) && Object.keys(src[key]).length > 0) {
11                extend$1(target[key], src[key]);
12            }
13        });
14    }
15    const ssrDocument = {
16        body: {},
17        addEventListener() {
18        },
19        removeEventListener() {
20        },
21        activeElement: {
22            blur() {
23            },
24            nodeName: ""
25        },
26        querySelector() {
27            return null;
28        },
29        querySelectorAll() {
30            return [];
31        },
32        getElementById() {
33            return null;
34        },
35        createEvent() {
36            return {
37                initEvent() {
38                }
39            };
40        },
41        createElement() {
42            return {
43                children: [],
44                childNodes: [],
45                style: {},
46                setAttribute() {
47                },
48                getElementsByTagName() {
49                    return [];
50                }
51            };
52        },
53        createElementNS() {
54            return {};
55        },
56        importNode() {
57            return null;
58        },
59        location: {
60            hash: "",
61            host: "",
62            hostname: "",
63            href: "",
64            origin: "",
65            pathname: "",
66            protocol: "",
67            search: ""
68        }
69    };
70    function getDocument() {
71        const doc = typeof document !== "undefined" ? document : {};
72        extend$1(doc, ssrDocument);
73        return doc;
74    }
75    const ssrWindow = {
76        document: ssrDocument,
77        navigator: {
78            userAgent: ""
79        },
80        location: {
81            hash: "",
82            host: "",
83            hostname: "",
84            href: "",
85            origin: "",
86            pathname: "",
87            protocol: "",
88            search: ""
89        },
90        history: {
91            replaceState() {
92            },
93            pushState() {
94            },
95            go() {
96            },
97            back() {
98            }
99        },
100        CustomEvent: function CustomEvent() {
101            return this;
102        },
103        addEventListener() {
104        },
105        removeEventListener() {
106        },
107        getComputedStyle() {
108            return {
109                getPropertyValue() {
110                    return "";
111                }
112            };
113        },
114        Image() {
115        },
116        Date() {
117        },
118        screen: {},
119        setTimeout() {
120        },
121        clearTimeout() {
122        },
123        matchMedia() {
124            return {};
125        },
126        requestAnimationFrame(callback) {
127            if (typeof setTimeout === "undefined") {
128                callback();
129                return null;
130            }
131            return setTimeout(callback, 0);
132        },
133        cancelAnimationFrame(id) {
134            if (typeof setTimeout === "undefined") {
135                return;
136            }
137            clearTimeout(id);
138        }
139    };
140    function getWindow() {
141        const win = typeof window !== "undefined" ? window : {};
142        extend$1(win, ssrWindow);
143        return win;
144    }
145    function makeReactive(obj) {
146        const proto = obj.__proto__;
147        Object.defineProperty(obj, "__proto__", {
148            get() {
149                return proto;
150            },
151            set(value) {
152                proto.__proto__ = value;
153            }
154        });
155    }
156    class Dom7 extends Array {
157        constructor(items) {
158            if (typeof items === "number") {
159                super(items);
160            } else {
161                super(...items || []);
162                makeReactive(this);
163            }
164        }
165    }
166    function arrayFlat(arr = []) {
167        const res = [];
168        arr.forEach((el) => {
169            if (Array.isArray(el)) {
170                res.push(...arrayFlat(el));
171            } else {
172                res.push(el);
173            }
174        });
175        return res;
176    }
177    function arrayFilter(arr, callback) {
178        return Array.prototype.filter.call(arr, callback);
179    }
180    function arrayUnique(arr) {
181        const uniqueArray = [];
182        for (let i = 0; i < arr.length; i += 1) {

313        function handleLiveEvent(e) {
314            const target = e.target;
315            if (!target)
316                return;
317            const eventData = e.target.dom7EventData || [];
318            if (eventData.indexOf(e) < 0) {
319                eventData.unshift(e);
320            }
321            if ($(target).is(targetSelector))
322                listener.apply(target, eventData);
323            else {
324                const parents2 = $(target).parents();
325                for (let k = 0; k < parents2.length; k += 1) {
326                    if ($(parents2[k]).is(targetSelector))
327                        listener.apply(parents2[k], eventData);
328                }
329            }
330        }
331        function handleEvent(e) {
332            const eventData = e && e.target ? e.target.dom7EventData || [] : [];
333            if (eventData.indexOf(e) < 0) {
334                eventData.unshift(e);
335            }
336            listener.apply(this, eventData);
337        }
338        const events2 = eventType.split(" ");
339        let j;
340        for (let i = 0; i < this.length; i += 1) {
341            const el = this[i];
342            if (!targetSelector) {
343                for (j = 0; j < events2.length; j += 1) {
344                    const event = events2[j];
345                    if (!el.dom7Listeners)
346                        el.dom7Listeners = {};
347                    if (!el.dom7Listeners[event])
348                        el.dom7Listeners[event] = [];
349                    el.dom7Listeners[event].push({
350                        listener,
351                        proxyListener: handleEvent
352                    });
353                    el.addEventListener(event, handleEvent, capture);
354                }
355            } else {
356                for (j = 0; j < events2.length; j += 1) {
357                    const event = events2[j];
358                    if (!el.dom7LiveListeners)
359                        el.dom7LiveListeners = {};
360                    if (!el.dom7LiveListeners[event])
361                        el.dom7LiveListeners[event] = [];
362                    el.dom7LiveListeners[event].push({
363                        listener,
364                        proxyListener: handleLiveEvent
365                    });
366                    el.addEventListener(event, handleLiveEvent, capture);
367                }
368            }
369        }
370        return this;
371    }
372    function off(...args) {
373        let [eventType, targetSelector, listener, capture] = args;
374        if (typeof args[1] === "function") {
375            [eventType, listener, capture] = args;
376            targetSelector = void 0;
377        }
378        if (!capture)
379            capture = false;
380        const events2 = eventType.split(" ");
381        for (let i = 0; i < events2.length; i += 1) {
382            const event = events2[i];
383            for (let j = 0; j < this.length; j += 1) {
384                const el = this[j];
385                let handlers;
386                if (!targetSelector && el.dom7Listeners) {
387                    handlers = el.dom7Listeners[event];
388                } else if (targetSelector && el.dom7LiveListeners) {
389                    handlers = el.dom7LiveListeners[event];
390                }
391                if (handlers && handlers.length) {
392                    for (let k = handlers.length - 1; k >= 0; k -= 1) {
393                        const handler = handlers[k];
394                        if (listener && handler.listener === listener) {
395                            el.removeEventListener(event, handler.proxyListener, capture);
396                            handlers.splice(k, 1);
397                        } else if (listener && handler.listener && handler.listener.dom7proxy && handler.listener.dom7proxy === listener) {
398                            el.removeEventListener(event, handler.proxyListener, capture);
399                            handlers.splice(k, 1);
400                        } else if (!listener) {
401                            el.removeEventListener(event, handler.proxyListener, capture);
402                            handlers.splice(k, 1);
403                        }
404                    }
405                }
406            }
407        }
408        return this;
409    }
410    function trigger(...args) {
411        const window2 = getWindow();
412        const events2 = args[0].split(" ");
413        const eventData = args[1];
414        for (let i = 0; i < events2.length; i += 1) {
415            const event = events2[i];
416            for (let j = 0; j < this.length; j += 1) {
417                const el = this[j];
418                if (window2.CustomEvent) {
419                    const evt = new window2.CustomEvent(event, {
420                        detail: eventData,
421                        bubbles: true,
422                        cancelable: true
423                    });
424                    el.dom7EventData = args.filter((data, dataIndex) => dataIndex > 0);
425                    el.dispatchEvent(evt);
426                    el.dom7EventData = [];
427                    delete el.dom7EventData;
428                }
429            }
430        }
431        return this;
432    }
433    function transitionEnd$1(callback) {
434        const dom = this;
435        function fireCallBack(e) {
436            if (e.target !== this)
437                return;
438            callback.call(this, e);
439            dom.off("transitionend", fireCallBack);
440        }
441        if (callback) {
442            dom.on("transitionend", fireCallBack);
443        }
444        return this;
445    }
446    function outerWidth(includeMargins) {
447        if (this.length > 0) {
448            if (includeMargins) {
449                const styles2 = this.styles();
450                return this[0].offsetWidth + parseFloat(styles2.getPropertyValue("margin-right")) + parseFloat(styles2.getPropertyValue("margin-left"));
451            }
452            return this[0].offsetWidth;
453        }
454        return null;
455    }
456    function outerHeight(includeMargins) {
457        if (this.length > 0) {
458            if (includeMargins) {
459                const styles2 = this.styles();
460                return this[0].offsetHeight + parseFloat(styles2.getPropertyValue("margin-top")) + parseFloat(styles2.getPropertyValue("margin-bottom"));
461            }
462            return this[0].offsetHeight;
463        }
464        return null;
465    }
466    function offset() {
467        if (this.length > 0) {
468            const window2 = getWindow();
469            const document2 = getDocument();
470            const el = this[0];
471            const box = el.getBoundingClientRect();
472            const body = document2.body;
473            const clientTop = el.clientTop || body.clientTop || 0;
474            const clientLeft = el.clientLeft || body.clientLeft || 0;
475            const scrollTop = el === window2 ? window2.scrollY : el.scrollTop;
476            const scrollLeft = el === window2 ? window2.scrollX : el.scrollLeft;
477            return {
478                top: box.top + scrollTop - clientTop,
479                left: box.left + scrollLeft - clientLeft
480            };
481        }
482        return null;
483    }
484    function styles() {
485        const window2 = getWindow();
486        if (this[0])
487            return window2.getComputedStyle(this[0], null);
488        return {};
489    }
490    function css(props, value) {
491        const window2 = getWindow();
492        let i;
493        if (arguments.length === 1) {
494            if (typeof props === "string") {
495                if (this[0])
496                    return window2.getComputedStyle(this[0], null).getPropertyValue(props);
497            } else {
498                for (i = 0; i < this.length; i += 1) {
499                    for (const prop in props) {
500                        this[i].style[prop] = props[prop];
501                    }
502                }
503                return this;
504            }
505        }
506        if (arguments.length === 2 && typeof props === "string") {
507            for (i = 0; i < this.length; i += 1) {
508                this[i].style[props] = value;
509            }
510            return this;
511        }
512        return this;
513    }
514    function each(callback) {
515        if (!callback)
516            return this;
517        this.forEach((el, index2) => {
518            callback.apply(el, [el, index2]);
519        });
520        return this;
521    }
522    function filter(callback) {
523        const result = arrayFilter(this, callback);
524        return $(result);
525    }
526    function html(html2) {
527        if (typeof html2 === "undefined") {
528            return this[0] ? this[0].innerHTML : null;
529        }
530        for (let i = 0; i < this.length; i += 1) {
531            this[i].innerHTML = html2;
532        }
533        return this;
534    }
535    function text(text2) {
536        if (typeof text2 === "undefined") {
537            return this[0] ? this[0].textContent.trim() : null;
538        }
539        for (let i = 0; i < this.length; i += 1) {
540            this[i].textContent = text2;
541        }
542        return this;
543    }
544    function is(selector) {
545        const window2 = getWindow();
546        const document2 = getDocument();
547        const el = this[0];
548        let compareWith;
549        let i;
550        if (!el || typeof selector === "undefined")
551            return false;
552        if (typeof selector === "string") {
553            if (el.matches)
554                return el.matches(selector);
555            if (el.webkitMatchesSelector)
556                return el.webkitMatchesSelector(selector);
557            if (el.msMatchesSelector)
558                return el.msMatchesSelector(selector);
559            compareWith = $(selector);
560            for (i = 0; i < compareWith.length; i += 1) {
561                if (compareWith[i] === el)
562                    return true;
563            }
564            return false;
565        }
566        if (selector === document2) {
567            return el === document2;
568        }
569        if (selector === window2) {
570            return el === window2;
571        }
572        if (selector.nodeType || selector instanceof Dom7) {
573            compareWith = selector.nodeType ? [selector] : selector;
574            for (i = 0; i < compareWith.length; i += 1) {
575                if (compareWith[i] === el)
576                    return true;
577            }
578            return false;
579        }
580        return false;
581    }
582    function index() {
583        let child = this[0];
584        let i;
585        if (child) {
586            i = 0;
587            while ((child = child.previousSibling) !== null) {
588                if (child.nodeType === 1)
589                    i += 1;
590            }
591            return i;
592        }
593        return void 0;
594    }
595    function eq(index2) {
596        if (typeof index2 === "undefined")
597            return this;
598        const length = this.length;
599        if (index2 > length - 1) {
600            return $([]);
601        }
602        if (index2 < 0) {
603            const returnIndex = length + index2;
604            if (returnIndex < 0)
605                return $([]);
606            return $([this[returnIndex]]);
607        }
608        return $([this[index2]]);
609    }
610    function append(...els) {
611        let newChild;
612        const document2 = getDocument();
613        for (let k = 0; k < els.length; k += 1) {
614            newChild = els[k];
615            for (let i = 0; i < this.length; i += 1) {
616                if (typeof newChild === "string") {
617                    const tempDiv = document2.createElement("div");
618                    tempDiv.innerHTML = newChild;
619                    while (tempDiv.firstChild) {
620                        this[i].appendChild(tempDiv.firstChild);
621                    }
622                } else if (newChild instanceof Dom7) {
623                    for (let j = 0; j < newChild.length; j += 1) {
624                        this[i].appendChild(newChild[j]);
625                    }
626                } else {
627                    this[i].appendChild(newChild);
628                }
629            }
630        }
631        return this;
632    }
633    function prepend(newChild) {
634        const document2 = getDocument();
635        let i;
636        let j;
637        for (i = 0; i < this.length; i += 1) {
638            if (typeof newChild === "string") {
639                const tempDiv = document2.createElement("div");
640                tempDiv.innerHTML = newChild;
641                for (j = tempDiv.childNodes.length - 1; j >= 0; j -= 1) {
642                    this[i].insertBefore(tempDiv.childNodes[j], this[i].childNodes[0]);
643                }
644            } else if (newChild instanceof Dom7) {
645                for (j = 0; j < newChild.length; j += 1) {
646                    this[i].insertBefore(newChild[j], this[i].childNodes[0]);
647                }
648            } else {
649                this[i].insertBefore(newChild, this[i].childNodes[0]);
650            }
651        }
652        return this;
653    }
654    function next(selector) {
655        if (this.length > 0) {
656            if (selector) {
657                if (this[0].nextElementSibling && $(this[0].nextElementSibling).is(selector)) {
658                    return $([this[0].nextElementSibling]);
659                }
660                return $([]);
661            }
662            if (this[0].nextElementSibling)
663                return $([this[0].nextElementSibling]);
664            return $([]);
665        }
666        return $([]);
667    }
668    function nextAll(selector) {
669        const nextEls = [];
670        let el = this[0];
671        if (!el)
672            return $([]);
673        while (el.nextElementSibling) {
674            const next2 = el.nextElementSibling;
675            if (selector) {
676                if ($(next2).is(selector))
677                    nextEls.push(next2);
678            } else
679                nextEls.push(next2);
680            el = next2;
681        }
682        return $(nextEls);
683    }
684    function prev(selector) {
685        if (this.length > 0) {
686            const el = this[0];
687            if (selector) {
688                if (el.previousElementSibling && $(el.previousElementSibling).is(selector)) {
689                    return $([el.previousElementSibling]);
690                }
691                return $([]);
692            }
693            if (el.previousElementSibling)
694                return $([el.previousElementSibling]);
695            return $([]);
696        }
697        return $([]);
698    }
699    function prevAll(selector) {
700        const prevEls = [];
701        let el = this[0];
702        if (!el)
703            return $([]);
704        while (el.previousElementSibling) {
705            const prev2 = el.previousElementSibling;
706            if (selector) {
707                if ($(prev2).is(selector))
708                    prevEls.push(prev2);
709            } else
710                prevEls.push(prev2);
711            el = prev2;
712        }
713        return $(prevEls);
714    }
715    function parent(selector) {
716        const parents2 = [];
717        for (let i = 0; i < this.length; i += 1) {
718            if (this[i].parentNode !== null) {
719                if (selector) {
720                    if ($(this[i].parentNode).is(selector))
721                        parents2.push(this[i].parentNode);
722                } else {
723                    parents2.push(this[i].parentNode);
724                }
725            }
726        }
727        return $(parents2);
728    }
729    function parents(selector) {
730        const parents2 = [];
731        for (let i = 0; i < this.length; i += 1) {
732            let parent2 = this[i].parentNode;
733            while (parent2) {
734                if (selector) {
735                    if ($(parent2).is(selector))
736                        parents2.push(parent2);
737                } else {
738                    parents2.push(parent2);
739                }
740                parent2 = parent2.parentNode;
741            }
742        }
743        return $(parents2);
744    }
745    function closest(selector) {
746        let closest2 = this;
747        if (typeof selector === "undefined") {
748            return $([]);
749        }

750        if (!closest2.is(selector)) {
751            closest2 = closest2.parents(selector).eq(0);
752        }
753        return closest2;
754    }
755    function find(selector) {
756        const foundElements = [];
757        for (let i = 0; i < this.length; i += 1) {
758            const found = this[i].querySelectorAll(selector);
759            for (let j = 0; j < found.length; j += 1) {
760                foundElements.push(found[j]);
761            }
762        }
763        return $(foundElements);
764    }
765    function children(selector) {
766        const children2 = [];
767        for (let i = 0; i < this.length; i += 1) {
768            const childNodes = this[i].children;
769            for (let j = 0; j < childNodes.length; j += 1) {
770                if (!selector || $(childNodes[j]).is(selector)) {
771                    children2.push(childNodes[j]);
772                }
773            }
774        }
775        return $(children2);
776    }
777    function remove() {
778        for (let i = 0; i < this.length; i += 1) {
779            if (this[i].parentNode)
780                this[i].parentNode.removeChild(this[i]);
781        }
782        return this;
783    }
784    const Methods = {
785        addClass,
786        removeClass,
787        hasClass,
788        toggleClass,
789        attr,
790        removeAttr,
791        transform,
792        transition: transition$1,
793        on,
794        off,
795        trigger,
796        transitionEnd: transitionEnd$1,
797        outerWidth,
798        outerHeight,
799        styles,
800        offset,
801        css,
802        each,
803        html,
804        text,
805        is,
806        index,
807        eq,
808        append,
809        prepend,
810        next,
811        nextAll,
812        prev,
813        prevAll,
814        parent,
815        parents,
816        closest,
817        find,
818        children,
819        filter,
820        remove
821    };
822    Object.keys(Methods).forEach((methodName) => {
823        Object.defineProperty($.fn, methodName, {
824            value: Methods[methodName],
825            writable: true
826        });
827    });
828    function deleteProps(obj) {
829        const object = obj;
830        Object.keys(object).forEach((key) => {
831            try {
832                object[key] = null;
833            } catch (e) {
834            }
835            try {
836                delete object[key];
837            } catch (e) {
838            }
839        });
840    }
841    function nextTick(callback, delay = 0) {
842        return setTimeout(callback, delay);
843    }
844    function now() {
845        return Date.now();
846    }
847    function getComputedStyle$1(el) {
848        const window2 = getWindow();
849        let style;
850        if (window2.getComputedStyle) {
851            style = window2.getComputedStyle(el, null);
852        }
853        if (!style && el.currentStyle) {
854            style = el.currentStyle;
855        }
856        if (!style) {
857            style = el.style;
858        }
859        return style;
860    }
861    function getTranslate(el, axis = "x") {
862        const window2 = getWindow();
863        let matrix;
864        let curTransform;
865        let transformMatrix;
866        const curStyle = getComputedStyle$1(el);
867        if (window2.WebKitCSSMatrix) {
868            curTransform = curStyle.transform || curStyle.webkitTransform;
869            if (curTransform.split(",").length > 6) {
870                curTransform = curTransform.split(", ").map((a) => a.replace(",", ".")).join(", ");
871            }
872            transformMatrix = new window2.WebKitCSSMatrix(curTransform === "none" ? "" : curTransform);
873        } else {
874            transformMatrix = curStyle.MozTransform || curStyle.OTransform || curStyle.MsTransform || curStyle.msTransform || curStyle.transform || curStyle.getPropertyValue("transform").replace("translate(", "matrix(1, 0, 0, 1,");
875            matrix = transformMatrix.toString().split(",");
876        }
877        if (axis === "x") {
878            if (window2.WebKitCSSMatrix)
879                curTransform = transformMatrix.m41;
880            else if (matrix.length === 16)
881                curTransform = parseFloat(matrix[12]);
882            else
883                curTransform = parseFloat(matrix[4]);
884        }
885        if (axis === "y") {
886            if (window2.WebKitCSSMatrix)
887                curTransform = transformMatrix.m42;
888            else if (matrix.length === 16)
889                curTransform = parseFloat(matrix[13]);
890            else
891                curTransform = parseFloat(matrix[5]);
892        }
893        return curTransform || 0;
894    }
895    function isObject(o) {
896        return typeof o === "object" && o !== null && o.constructor && Ob

896ject.prototype.toString.call(o).slice(8, -1) === "Object";
897    }
898    function isNode(node) {
899        if (typeof window !== "undefined" && typeof window.HTMLElement !== "undefined") {
900            return node instanceof HTMLElement;
901        }
902        return node && (node.nodeType === 1 || node.nodeType === 11);
903    }
904    function extend(...args) {
905        const to = Object(args[0]);
906        const noExtend = ["__proto__", "constructor", "prototype"];
907        for (let i = 1; i < args.length; i += 1) {
908            const nextSource = args[i];
909            if (nextSource !== void 0 && nextSource !== null && !isNode(nextSource)) {
910                const keysArray = Object.keys(Object(nextSource)).filter((key) => noExtend.indexOf(key) < 0);
911                for (let nextIndex = 0, len = keysArray.length; nextIndex < len; nextIndex += 1) {
912                    const nextKey = keysArray[nextIndex];
913                    const desc = Object.getOwnPropertyDescriptor(nextSource, nextKey);
914                    if (desc !== void 0 && desc.enumerable) {
915                        if (isObject(to[nextKey]) && isObject(nextSource[nextKey])) {
916                            if (nextSource[nextKey].__swiper__) {
917                                to[nextKey] = nextSource[nextKey];
918                            } else {
919                                extend(to[nextKey], nextSource[nextKey]);
920                            }
921                        } else if (!isObject(to[nextKey]) && isObject(nextSource[nextKey])) {
922                            to[nextKey] = {};
923                            if (nextSource[nextKey].__swiper__) {
924                                to[nextKey] = nextSource[nextKey];
925                            } else {
926                                extend(to[nextKey], nextSource[nextKey]);
927                            }
928                        } else {
929                            to[nextKey] = nextSource[nextKey];
930                        }
931                    }
932                }
933            }
934        }
935        return to;
936    }
937    function setCSSProperty(el, varName, varValue) {
938        el.style.setProperty(varName, varValue);
939    }
940    function animateCSSModeScroll({
941                                      swiper,
942                                      targetPosition,
943                                      side
944                                  }) {
945        const window2 = getWindow();
946        const startPosition = -swiper.translate;
947        let startTime = null;
948        let time;
949        const duration = swiper.params.speed;
950        swiper.wrapperEl.style.scrollSnapType = "none";
951        window2.cancelAnimationFrame(swiper.cssModeFrameID);
952        const dir = targetPosition > startPosition ? "next" : "prev";
953        const isOutOfBound = (current, target) => {
954            return dir === "next" && current >= target || dir === "prev" && current <= target;
955        };
956        const animate = () => {
957            time = new Date().getTime();
958            if (startTime === null) {
959                startTime = time;
960            }
961            const progress = Math.max(Math.min((time - startTime) / duration, 1), 0);
962            const easeProgress = 0.5 - Math.cos(progress * Math.PI) / 2;
963            let currentPosition = startPosition + easeProgress * (targetPosition - startPosition);
964            if (isOutOfBound(currentPosition, targetPosition)) {
965                currentPosition = targetPosition;
966            }
967            swiper.wrapperEl.scrollTo({
968                [side]: currentPosition
969            });
970            if (isOutOfBound(currentPosition, targetPosition)) {
971                swiper.wrapperEl.style.overflow = "hidden";
972                swiper.wrapperEl.style.scrollSnapType = "";
973                setTimeout(() => {
974                    swiper.wrapperEl.style.overflow = "";
975                    swiper.wrapperEl.scrollTo({
976                        [side]: currentPosition
977                    });
978                });
979                window2.cancelAnimationFrame(swiper.cssModeFrameID);
980                return;
981            }
982            swiper.cssModeFrameID = window2.requestAnimationFrame(animate);
983        };
984        animate();
985    }
986    let support;
987    function calcSupport() {
988        const window2 = getWindow();
989        const document2 = getDocument();
990        return {
991            smoothScroll: document2.documentElement && "scrollBehavior" in document2.documentElement.style,
992            touch: !!("ontouchstart" in window2 || window2.DocumentTouch && document2 instanceof window2.DocumentTouch),
993            passiveListener: function checkPassiveListener() {
994                let supportsPassive = false;
995                try {
996                    const opts = Object.defineProperty({}, "passive", {
997                        get() {
998                            supportsPassive = true;
999                        }
1000                    });
1001                    window2.addEventListener("testPassiveListener", null, opts);
1002                } catch (e) {
1003                }
1004                return supportsPassive;
1005            }(),
1006            gestures: function checkGestures() {
1007                return "ongesturestart" in window2;
1008            }()
1009        };
1010    }
1011    function getSupport() {
1012        if (!support) {
1013            support = calcSupport();
1014        }
1015        return support;
1016    }
1017    let deviceCached;
1018    function calcDevice({
1019                            userAgent
1020                        } = {}) {
1021        const support2 = getSupport();
1022        const window2 = getWindow();
1023        const platform = window2.navigator.platform;
1024        const ua = userAgent || window2.navigator.userAgent;
1025        const device = {
1026            ios: false,
1027            android: false
1028        };
1029        const screenWidth = window2.screen.width;
1030        const screenHeight = window2.screen.height;
1031        const android = ua.match(/(Android);?[\s\/]+([\d.]+)?/);
1032        let ipad = ua.match(/(iPad).*OS\s([\d_]+)/);
1033        const ipod = ua.match(/(iPod)(.*OS\s([\d_]+))?/);
1034        const iphone = !ipad && ua.match(/(iPhone\sOS|iOS)\s([\d_]+)/);
1035        const windows = platform === "Win32";
1036        let macos = platform === "MacIntel";
1037        const iPadScreens = ["1024x1366", "1366x1024", "834x1194", "1194x834", "834x1112", "1112x834", "768x1024", "1024x768", "820x1180", "1180x820", "810x1080", "1080x810"];
1038        if (!ipad && macos && support2.touch && iPadScreens.indexOf(`${screenWidth}x${screenHeight}`) >= 0) {
1039            ipad = ua.match(/(Version)\/([\d.]+)/);
1040            if (!ipad)
1041                ipad = [0, 1, "13_0_0"];
1042            macos = false;
1043        }
1044        if (android && !windows) {
1045            device.os = "android";
1046            device.android = true;
1047        }
1048        if (ipad || iphone || ipod) {
1049            device.os = "ios";
1050            device.ios = true;
1051        }
1052        return device;
1053    }
1054    function getDevice(overrides = {}) {
1055        if (!deviceCached) {
1056            deviceCached = calcDevice(overrides);
1057        }
1058        return deviceCached;
1059    }
1060    let browser;
1061    function calcBrowser() {
1062        const window2 = getWindow();
1063        function isSafari() {
1064            const ua = window2.navigator.userAgent.toLowerCase();
1065            return ua.indexOf("safari") >= 0 && ua.indexOf("chrome") < 0 && ua.indexOf("android") < 0;
1066        }
1067        return {
1068            isSafari: isSafari(),
1069            isWebView: /(iPhone|iPod|iPad).*AppleWebKit(?!.*Safari)/i.test(window2.navigator.userAgent)
1070        };
1071    }
1072    function getBrowser() {
1073        if (!browser) {
1074            browser = calcBrowser();
1075        }
1076        return browser;
1077    }
1078    function Resize({
1079                        swiper,
1080                        on: on2,
1081                        emit
1082                    }) {
1083        const window2 = getWindow();
1084        let observer = null;
1085        const resizeHandler = () => {
1086            if (!swiper || swiper.destroyed || !swiper.initialized)
1087                return;
1088            emit("beforeResize");
1089            emit("resize");
1090        };
1091        const createObserver = () => {
1092            if (!swiper || swiper.destroyed || !swiper.initialized)
1093                return;
1094            observer = new ResizeObserver((entries) => {
1095                const {
1096                    width,
1097                    height
1098                } = swiper;
1099                let newWidth = width;
1100                let newHeight = height;
1101                entries.forEach(({
1102                                     contentBoxSize,
1103                                     contentRect,
1104                                     target
1105                                 }) => {
1106                    if (target && target !== swiper.el)
1107                        return;
1108                    newWidth = contentRect ? contentRect.width : (contentBoxSize[0] || contentBoxSize).inlineSize;
1109                    newHeight = contentRect ? contentRect.height : (contentBoxSize[0] || contentBoxSize).blockSize;
1110                });
1111                if (newWidth !== width || newHeight !== height) {
1112                    resizeHandler();
1113                }
1114            });
1115            observer.observe(swiper.el);
1116        };
1117        const removeObserver = () => {
1118            if (observer && observer.unobserve && swiper.el) {
1119                observer.unobserve(swiper.el);
1120                observer = null;
1121            }
1122        };
1123        const orientationChangeHandler = () => {
1124            if (!swiper || swiper.destroyed || !swiper.initialized)
1125                return;
1126            emit("orientationchange");
1127        };
1128        on2("init", () => {
1129            if (swiper.params.resizeObserver && typeof window2.ResizeObserver !== "undefined") {
1130                createObserver();
1131                return;
1132            }
1133            window2.addEventListener("resize", resizeHandler);
1134            window2.addEventListener("orientationchange", orientationChangeHandler);
1135        });
1136        on2("destroy", () => {
1137            removeObserver();
1138            window2.removeEventListener("resize", resizeHandler);
1139            window2.removeEventListener("orientationchange", orientationChangeHandler);
1140        });
1141    }
1142    function Observer({
1143                          swiper,
1144                          extendParams,
1145                          on: on2,
1146                          emit
1147                      }) {
1148        const observers = [];
1149        const window2 = getWindow();
1150        const attach = (target, options = {}) => {
1151            const ObserverFunc = window2.MutationObserver || window2.WebkitMutationObserver;
1152            const observer = new ObserverFunc((mutations) => {
1153                if (mutations.length === 1) {
1154                    emit("observerUpdate", mutations[0]);
1155                    return;
1156                }
1157                const observerUpdate = function observerUpdate2() {
1158                    emit("observerUpdate", mutations[0]);
1159                };
1160                if (window2.requestAnimationFrame) {
1161                    window2.requestAnimationFrame(observerUpdate);
1162                } else {
1163                    window2.setTimeout(observerUpdate, 0);
1164                }
1165            });
1166            observer.observe(target, {
1167                attributes: typeof options.attributes === "undefined" ? true : options.attributes,
1168                childList: typeof options.childList === "undefined" ? true : options.childList,
1169                characterData: typeof options.characterData === "undefined" ? true : options.characterData
1170            });
1171            observers.push(observer);
1172        };
1173        const init = () => {
1174            if (!swiper.params.observer)
1175                return;
1176            if (swiper.params.observeParents) {
1177                const containerParents = swiper.$el.parents();
1178                for (let i = 0; i < containerParents.length; i += 1) {
1179                    attach(containerParents[i]);
1180                }
1181            }
1182            attach(swiper.$el[0], {
1183                childList: swiper.params.observeSlideChildren
1184            });
1185            attach(swiper.$wrapperEl[0], {
1186                attributes: false
1187            });
1188        };
1189        const destroy = () => {

1190            observers.forEach((observer) => {
1191                observer.disconnect();
1192            });
1193            observers.splice(0, observers.length);
1194        };
1195        extendParams({
1196            observer: false,
1197            observeParents: false,
1198            observeSlideChildren: false
1199        });
1200        on2("init", init);
1201        on2("destroy", destroy);
1202    }
1203    var eventsEmitter = {
1204        on(events2, handler, priority) {
1205            const self = this;
1206            if (typeof handler !== "function")
1207                return self;
1208            const method = priority ? "unshift" : "push";
1209            events2.split(" ").forEach((event) => {
1210                if (!self.eventsListeners[event])
1211                    self.eventsListeners[event] = [];
1212                self.eventsListeners[event][method](handler);
1213            });
1214            return self;
1215        },
1216        once(events2, handler, priority) {
1217            const self = this;
1218            if (typeof handler !== "function")
1219                return self;
1220            function onceHandler(...args) {
1221                self.off(events2, onceHandler);
1222                if (onceHandler.__emitterProxy) {
1223                    delete onceHandler.__emitterProxy;
1224                }
1225                handler.apply(self, args);
1226            }
1227            onceHandler.__emitterProxy = handler;
1228            return self.on(events2, onceHandler, priority);
1229        },
1230        onAny(handler, priority) {
1231            const self = this;
1232            if (typeof handler !== "function")
1233                return self;
1234            const method = priority ? "unshift" : "push";
1235            if (self.eventsAnyListeners.indexOf(handler) < 0) {
1236                self.eventsAnyListeners[method](handler);
1237            }
1238            return self;
1239        },
1240        offAny(handler) {
1241            const self = this;
1242            if (!self.eventsAnyListeners)
1243                return self;
1244            const index2 = self.eventsAnyListeners.indexOf(handler);
1245            if (index2 >= 0) {
1246                self.eventsAnyListeners.splice(index2, 1);
1247            }
1248            return self;
1249        },
1250        off(events2, handler) {
1251            const self = this;
1252            if (!self.eventsListeners)
1253                return self;
1254            events2.split(" ").forEach((event) => {
1255                if (typeof handler === "undefined") {
1256                    self.eventsListeners[event] = [];
1257                } else if (self.eventsListeners[event]) {
1258                    self.eventsListeners[event].forEach((eventHandler, index2) => {
1259                        if (eventHandler === handler || eventHandler.__emitterProxy && eventHandler.__emitterProxy === handler) {
1260                            self.eventsListeners[event].splice(index2, 1);
1261                        }
1262                    });
1263                }
1264            });
1265            return self;
1266        },
1267        emit(...args) {
1268            const self = this;
1269            if (!self.eventsListeners)
1270                return self;
1271            let events2;
1272            let data;
1273            let context;
1274            if (typeof args[0] === "string" || Array.isArray(args[0])) {
1275                events2 = args[0];
1276                data = args.slice(1, args.length);
1277                context = self;
1278            } else {
1279                events2 = args[0].events;
1280                data = args[0].data;
1281                context = args[0].context || self;
1282            }
1283            data.unshift(context);
1284            const eventsArray = Array.isArray(events2) ? events2 : events2.split(" ");
1285            eventsArray.forEach((event) => {
1286                if (self.eventsAnyListeners && self.eventsAnyListeners.length) {
1287                    self.eventsAnyListeners.forEach((eventHandler) => {
1288                        eventHandler.apply(context, [event, ...data]);
1289                    });
1290                }
1291                if (self.eventsListeners && self.eventsListeners[event]) {
1292                    self.eventsListeners[event].forEach((eventHandler) => {
1293                        eventHandler.apply(context, data);
1294                    });
1295                }
1296            });
1297            return self;
1298        }
1299    };
1300    function updateSize() {
1301        const swiper = this;
1302        let width;
1303        let height;
1304        const $el = swiper.$el;
1305        if (typeof swiper.params.width !== "undefined" && swiper.params.width !== null) {
1306            width = swiper.params.width;
1307        } else {
1308            width = $el[0].clientWidth;
1309        }
1310        if (typeof swiper.params.height !== "undefined" && swiper.params.height !== null) {
1311            height = swiper.params.height;
1312        } else {
1313            height = $el[0].clientHeight;
1314        }
1315        if (width === 0 && swiper.isHorizontal() || height === 0 && swiper.isVertical()) {
1316            return;
1317        }
1318        width = width - parseInt($el.css("padding-left") || 0, 10) - parseInt($el.css("padding-right") || 0, 10);
1319        height = height - parseInt($el.css("padding-top") || 0, 10) - parseInt($el.css("padding-bottom") || 0, 10);
1320        if (Number.isNaN(width))
1321            width = 0;
1322        if (Number.isNaN(height))
1323            height = 0;
1324        Object.assign(swiper, {
1325            width,
1326            height,
1327            size: swiper.isHorizontal() ? width : height
1328        });
1329    }
1330    function updateSlides() {
1331        const swiper = this;
1332        function getDirectionLabel(property) {
1333            if (swiper.isHorizontal()) {
1334                return property;
1335            }
1336            return {
1337                "width": "height",
1338                "margin-top": "margin-left",
1339                "margin-bottom ": "margin-right",
1340                "margin-left": "margin-top",
1341                "margin-right": "margin-bottom",
1342                "padding-left": "padding-top",
1343                "padding-right": "padding-bottom",
1344                "marginRight": "marginBottom"
1345            }[property];
1346        }
1347        function getDirectionPropertyValue(node, label) {
1348            return parseFloat(node.getPropertyValue(getDirectionLabel(label)) || 0);
1349        }
1350        const params = swiper.params;
1351        const {
1352            $wrapperEl,
1353            size: swiperSize,
1354            rtlTranslate: rtl,
1355            wrongRTL
1356        } = swiper;
1357        const isVirtual = swiper.virtual && params.virtual.enabled;
1358        const previousSlidesLength = isVirtual ? swiper.virtual.slides.length : swiper.slides.length;
1359        const slides = $wrapperEl.children(`.${swiper.params.slideClass}`);
1360        const slidesLength = isVirtual ? swiper.virtual.slides.length : slides.length;
1361        let snapGrid = [];
1362        const slidesGrid = [];
1363        const slidesSizesGrid = [];
1364        let offsetBefore = params.slidesOffsetBefore;
1365        if (typeof offsetBefore === "function") {

1366            offsetBefore = params.slidesOffsetBefore.call(swiper);
1367        }
1368        let offsetAfter = params.slidesOffsetAfter;
1369        if (typeof offsetAfter === "function") {
1370            offsetAfter = params.slidesOffsetAfter.call(swiper);
1371        }
1372        const previousSnapGridLength = swiper.snapGrid.length;
1373        const previousSlidesGridLength = swiper.slidesGrid.length;
1374        let spaceBetween = params.spaceBetween;
1375        let slidePosition = -offsetBefore;
1376        let prevSlideSize = 0;
1377        let index2 = 0;
1378        if (typeof swiperSize === "undefined") {
1379            return;
1380        }
1381        if (typeof spaceBetween === "string" && spaceBetween.indexOf("%") >= 0) {
1382            spaceBetween = parseFloat(spaceBetween.replace("%", "")) / 100 * swiperSize;
1383        }
1384        swiper.virtualSize = -spaceBetween;
1385        if (rtl)
1386            slides.css({
1387                marginLeft: "",
1388                marginBottom: "",
1389                marginTop: ""
1390            });
1391        else
1392            slides.css({
1393                marginRight: "",
1394                marginBottom: "",
1395                marginTop: ""
1396            });
1397        if (params.centeredSlides && params.cssMode) {
1398            setCSSProperty(swiper.wrapperEl, "--swiper-centered-offset-before", "");
1399            setCSSProperty(swiper.wrapperEl, "--swiper-centered-offset-after", "");
1400        }
1401        const gridEnabled = params.grid && params.grid.rows > 1 && swiper.grid;
1402        if (gridEnabled) {
1403            swiper.grid.initSlides(slidesLength);
1404        }
1405        let slideSize;
1406        const shouldResetSlideSize = params.slidesPerView === "auto" && params.breakpoints && Object.keys(params.breakpoints).filter((key) => {
1407            return typeof params.breakpoints[key].slidesPerView !== "undefined";
1408        }).length > 0;
1409        for (let i = 0; i < slidesLength; i += 1) {
1410            slideSize = 0;
1411            const slide2 = slides.eq(i);
1412            if (gridEnabled) {
1413                swiper.grid.updateSlide(i, slide2, slidesLength, getDirectionLabel);
1414            }
1415            if (slide2.css("display") === "none")
1416                continue;
1417            if (params.slidesPerView === "auto") {
1418                if (shouldResetSlideSize) {
1419                    slides[i].style[getDirectionLabel("width")] = ``;
1420                }
1421                const slideStyles = getComputedStyle(slide2[0]);
1422                const currentTransform = slide2[0].style.transform;
1423                const currentWebKitTransform = slide2[0].style.webkitTransform;
1424                if (currentTransform) {
1425                    slide2[0].style.transform = "none";
1426                }
1427                if (currentWebKitTransform) {
1428                    slide2[0].style.webkitTransform = "none";
1429                }
1430                if (params.roundLengths) {
1431                    slideSize = swiper.isHorizontal() ? slide2.outerWidth(true) : slide2.outerHeight(true);
1432                } else {
1433                    const width = getDirectionPropertyValue(slideStyles, "width");
1434                    const paddingLeft = getDirectionPropertyValue(slideStyles, "padding-left");
1435                    const paddingRight = getDirectionPropertyValue(slideStyles, "padding-right");
1436                    const marginLeft = getDirectionPropertyValue(slideStyles, "margin-left");
1437                    const marginRight = getDirectionPropertyValue(slideStyles, "margin-right");
1438                    const boxSizing = slideStyles.getPropertyValue("box-sizing");
1439                    if (boxSizing && boxSizing === "border-box") {
1440                        slideSize = width + marginLeft + marginRight;
1441                    } else {
1442                        const {
1443                            clientWidth,
1444                            offsetWidth
1445                        } = slide2[0];
1446                        slideSize = width + paddingLeft + paddingRight + marginLeft + marginRight + (offsetWidth - clientWidth);
1447                    }
1448                }
1449                if (currentTransform) {
1450                    slide2[0].style.transform = currentTransform;
1451                }
1452                if (currentWebKitTransform) {
1453                    slide2[0].style.webkitTransform = currentWebKitTransform;
1454                }
1455                if (params.roundLengths)
1456                    slideSize = Math.floor(slideSize);
1457            } else {
1458                slideSize = (swiperSize - (params.slidesPerView - 1) * spaceBetween) / params.slidesPerView;
1459                if (params.roundLengths)
1460                    slideSize = Math.floor(slideSize);
1461                if (slides[i]) {
1462                    slides[i].style[getDirectionLabel("width")] = `${slideSize}px`;
1463                }
1464            }
1465            if (slides[i]) {
1466                slides[i].swiperSlideSize = slideSize;
1467            }
1468            slidesSizesGrid.push(slideSize);
1469            if (params.centeredSlides) {
1470                slidePosition = slidePosition + slideSize / 2 + prevSlideSize / 2 + spaceBetween;
1471                if (prevSlideSize === 0 && i !== 0)
1472                    slidePosition = slidePosition - swiperSize / 2 - spaceBetween;
1473                if (i === 0)
1474                    slidePosition = slidePosition - swiperSize / 2 - spaceBetween;
1475                if (Math.abs(slidePosition) < 1 / 1e3)
1476                    slidePosition = 0;
1477                if (params.roundLengths)
1478                    slidePosition = Math.floor(slidePosition);
1479                if (index2 % params.slidesPerGroup === 0)
1480                    snapGrid.push(slidePosition);
1481                slidesGrid.push(slidePosition);
1482            } else {
1483                if (params.roundLengths)
1484                    slidePosition = Math.floor(slidePosition);
1485                if ((index2 - Math.min(swiper.params.slidesPerGroupSkip, index2)) % swiper.params.slidesPerGroup === 0)
1486                    snapGrid.push(slidePosition);
1487                slidesGrid.push(slidePosition);
1488                slidePosition = slidePosition + slideSize + spaceBetween;
1489            }
1490            swiper.virtualSize += slideSize + spaceBetween;
1491            prevSlideSize = slideSize;
1492            index2 += 1;
1493        }
1494        swiper.virtualSize = Math.max(swiper.virtualSize, swiperSize) + offsetAfter;
1495        if (rtl && wrongRTL && (params.effect === "slide" || params.effect === "coverflow")) {
1496            $wrapperEl.css({
1497                width: `${swiper.virtualSize + params.spaceBetween}px`
1498            });
1499        }
1500        if (params.setWrapperSize) {
1501            $wrapperEl.css({
1502                [getDirectionLabel("width")]: `${swiper.virtualSize + params.spaceBetween}px`
1503            });
1504        }
1505        if (gridEnabled) {
1506            swiper.grid.updateWrapperSize(slideSize, snapGrid, getDirectionLabel);
1507        }
1508        if (!params.centeredSlides) {
1509            const newSlidesGrid = [];
1510            for (let i = 0; i < snapGrid.length; i += 1) {
1511                let slidesGridItem = snapGrid[i];
1512                if (params.roundLengths)
1513                    slidesGridItem = Math.floor(slidesGridItem);

1621 i < Math.ceil(swiper.params.slidesPerView); i += 1) {
1622                    const index2 = swiper.activeIndex + i;
1623                    if (index2 > swiper.slides.length && !isVirtual)
1624                        break;
1625                    activeSlides.push(getSlideByIndex(index2));
1626                }
1627            }
1628        } else {
1629            activeSlides.push(getSlideByIndex(swiper.activeIndex));
1630        }
1631        for (i = 0; i < activeSlides.length; i += 1) {
1632            if (typeof activeSlides[i] !== "undefined") {
1633                const height = activeSlides[i].offsetHeight;
1634                newHeight = height > newHeight ? height : newHeight;
1635            }
1636        }
1637        if (newHeight || newHeight === 0)
1638            swiper.$wrapperEl.css("height", `${newHeight}px`);
1639    }
1640    function updateSlidesOffset() {
1641        const swiper = this;
1642        const slides = swiper.slides;
1643        for (let i = 0; i < slides.length; i += 1) {
1644            slides[i].swiperSlideOffset = swiper.isHorizontal() ? slides[i].offsetLeft : slides[i].offsetTop;
1645        }
1646    }
1647    function updateSlidesProgress(translate2 = this && this.translate || 0) {
1648        const swiper = this;
1649        const params = swiper.params;
1650        const {
1651            slides,
1652            rtlTranslate: rtl,
1653            snapGrid
1654        } = swiper;
1655        if (slides.length === 0)
1656            return;
1657        if (typeof slides[0].swiperSlideOffset === "undefined")
1658            swiper.updateSlidesOffset();
1659        let offsetCenter = -translate2;
1660        if (rtl)
1661            offsetCenter = translate2;
1662        slides.removeClass(params.slideVisibleClass);
1663        swiper.visibleSlidesIndexes = [];
1664        swiper.visibleSlides = [];
1665        for (let i = 0; i < slides.length; i += 1) {
1666            const slide2 = slides[i];
1667            let slideOffset = slide2.swiperSlideOffset;
1668            if (params.cssMode && params.centeredSlides) {
1669                slideOffset -= slides[0].swiperSlideOffset;
1670            }
1671            const slideProgress = (offsetCenter + (params.centeredSlides ? swiper.minTranslate() : 0) - slideOffset) / (slide2.swiperSlideSize + params.spaceBetween);
1672            const originalSlideProgress = (offsetCenter - snapGrid[0] + (params.centeredSlides ? swiper.minTranslate() : 0) - slideOffset) / (slide2.swiperSlideSize + params.spaceBetween);
1673            const slideBefore = -(offsetCenter - slideOffset);
1674            const slideAfter = slideBefore + swiper.slidesSizesGrid[i];
1675            const isVisible = slideBefore >= 0 && slideBefore < swiper.size - 1 || slideAfter > 1 && slideAfter <= swiper.size || slideBefore <= 0 && slideAfter >= swiper.size;
1676            if (isVisible) {
1677                swiper.visibleSlides.push(slide2);
1678                swiper.visibleSlidesIndexes.push(i);
1679                slides.eq(i).addClass(params.slideVisibleClass);
1680            }
1681            slide2.progress = rtl ? -slideProgress : slideProgress;
1682            slide2.originalProgress = rtl ? -originalSlideProgress : originalSlideProgress;
1683        }
1684        swiper.visibleSlides = $(swiper.visibleSlides);
1685    }
1686    function updateProgress(translate2) {
1687        const swiper = this;
1688        if (typeof translate2 === "undefined") {
1689            const multiplier = swiper.rtlTranslate ? -1 : 1;
1690            translate2 = swiper && swiper.translate && swiper.translate * multiplier || 0;
1691        }
1692        const params = swiper.params;
1693        const translatesDiff = swiper.maxTranslate() - swiper.minTranslate();
1694        let {
1695            progress,
1696            isBeginning,
1697            isEnd
1698        } = swiper;
1699        const wasBeginning = isBeginning;
1700        const wasEnd = isEnd;
1701        if (translatesDiff === 0) {
1702            progress = 0;
1703            isBeginning = true;
1704            isEnd = true;
1705        } else {
1706            progress = (translate2 - swiper.minTranslate()) / translatesDiff;
1707            isBeginning = progress <= 0;
1708            isEnd = progress >= 1;
1709        }
1710        Object.assign(swiper, {
1711            progress,
1712            isBeginning,
1713            isEnd
1714        });
1715        if (params.watchSlidesProgress || params.centeredSlides && params.autoHeight)
1716            swiper.updateSlidesProgress(translate2);
1717        if (isBeginning && !wasBeginning) {
1718            swiper.emit("reachBeginning toEdge");
1719        }
1720        if (isEnd && !wasEnd) {
1721            swiper.emit("reachEnd toEdge");
1722        }
1723        if (wasBeginning && !isBeginning || wasEnd && !isEnd) {
1724            swiper.emit("fromEdge");
1725        }
1726        swiper.emit("progress", progress);
1727    }
1728    function updateSlidesClasses() {
1729        const swiper = this;
1730        const {
1731            slides,
1732            params,
1733            $wrapperEl,
1734            activeIndex,
1735            realIndex
1736        } = swiper;
1737        const isVirtual = swiper.virtual && params.virtual.enabled;
1738        slides.removeClass(`${params.slideActiveClass} ${params.slideNextClass} ${params.slidePrevClass} ${params.slideDuplicateActiveClass} ${params.slideDuplicateNextClass} ${params.slideDuplicatePrevClass}`);
1739        let activeSlide;
1740        if (isVirtual) {
1741            activeSlide = swiper.$wrapperEl.find(`.${params.slideClass}[data-swiper-slide-index="${activeIndex}"]`);
1742        } else {
1743            activeSlide = slides.eq(activeIndex);
1744        }
1745        activeSlide.addClass(params.slideActiveClass);
1746        if (params.loop) {
1747            if (activeSlide.hasClass(params.slideDuplicateClass)) {
1748                $wrapperEl.children(`.${params.slideClass}:not(.${params.slideDuplicateClass})[data-swiper-slide-index="${realIndex}"]`).addClass(params.slideDuplicateActiveClass);
1749            } else {
1750                $wrapperEl.children(`.${params.slideClass}.${params.slideDuplicateClass}[data-swiper-slide-index="${realIndex}"]`).addClass(params.slideDuplicateActiveClass);
1751            }
1752        }
1753        let nextSlide = activeSlide.nextAll(`.${params.slideClass}`).eq(0).addClass(params.slideNextClass);
1754        if (params.loop && nextSlide.length === 0) {
1755            nextSlide = slides.eq(0);
1756            nextSlide.addClass(params.slideNextClass);
1757        }
1758        let prevSlide = activeSlide.prevAll(`.${params.slideClass}`).eq(0).addClass(params.slidePrevClass);
1759        if (params.loop && prevSlide.length === 0) {
1760            prevSlide = slides.eq(-1);
1761            prevSlide.addClass(params.slidePrevClass);
1762        }
1763        if (params.loop) {
1764            if (nextSlide.hasClass(params.slideDuplicateClass)) {
1765                $wrapperEl.children(`.${params.slideClass}:not(.${params.slideDuplicateClass})[data-swiper-slide-index="${nextSlide.attr("data-swiper-slide-index")}"]`).addClass(params.slideDuplicateNextClass);
1766            } else {
1767                $wrapperEl.children(`.${params.slideClass}.${params.slideDuplicateClass}[data-swiper-slide-index="${nextSlide.attr("data-swiper-slide-index")}"]`).addClass(params.slideDuplicateNextClass);
1768            }
1769            if (prevSlide.hasClass(params.slideDuplicateClass)) {
1770                $wrapperEl.children(`.${params.slideClass}:not(.${params.slideDuplicateClass})[data-swiper-slide-index="${prevSlide.attr("data-swiper-slide-index")}"]`).addClass(params.slideDuplicatePrevClass);
1771            } else {
1772                $wrapperEl.children(`.${params.slideClass}.${params.slideDuplicateClass}[data-swiper-slide-index="${prevSlide.attr("data-swiper-slide-index")}"]`).addClass(params.slideDuplicatePrevClass);
1773            }
1774        }
1775        swiper.emitSlidesClasses();
1776    }
1777    function updateActiveIndex(newActiveIndex) {
1778        const swiper = this;
1779        const translate2 = swiper.rtlTranslate ? swiper.translate : -swi

1779per.translate;
1780        const {
1781            slidesGrid,
1782            snapGrid,
1783            params,
1784            activeIndex: previousIndex,
1785            realIndex: previousRealIndex,
1786            snapIndex: previousSnapIndex
1787        } = swiper;
1788        let activeIndex = newActiveIndex;
1789        let snapIndex;
1790        if (typeof activeIndex === "undefined") {
1791            for (let i = 0; i < slidesGrid.length; i += 1) {
1792                if (typeof slidesGrid[i + 1] !== "undefined") {
1793                    if (translate2 >= slidesGrid[i] && translate2 < slidesGrid[i + 1] - (slidesGrid[i + 1] - slidesGrid[i]) / 2) {
1794                        activeIndex = i;
1795                    } else if (translate2 >= slidesGrid[i] && translate2 < slidesGrid[i + 1]) {
1796                        activeIndex = i + 1;
1797                    }
1798                } else if (translate2 >= slidesGrid[i]) {
1799                    activeIndex = i;
1800                }
1801            }
1802            if (params.normalizeSlideIndex) {
1803                if (activeIndex < 0 || typeof activeIndex === "undefined")
1804                    activeIndex = 0;
1805            }
1806        }
1807        if (snapGrid.indexOf(translate2) >= 0) {
1808            snapIndex = snapGrid.indexOf(translate2);
1809        } else {
1810            const skip = Math.min(params.slidesPerGroupSkip, activeIndex);
1811            snapIndex = skip + Math.floor((activeIndex - skip) / params.slidesPerGroup);
1812        }
1813        if (snapIndex >= snapGrid.length)
1814            snapIndex = snapGrid.length - 1;
1815        if (activeIndex === previousIndex) {
1816            if (snapIndex !== previousSnapIndex) {
1817                swiper.snapIndex = snapIndex;
1818                swiper.emit("snapIndexChange");
1819            }
1820            return;
1821        }
1822        const realIndex = parseInt(swiper.slides.eq(activeIndex).attr("data-swiper-slide-index") || activeIndex, 10);
1823        Object.assign(swiper, {
1824            snapIndex,
1825            realIndex,
1826            previousIndex,
1827            activeIndex
1828        });
1829        swiper.emit("activeIndexChange");
1830        swiper.emit("snapIndexChange");
1831        if (previousRealIndex !== realIndex) {
1832            swiper.emit("realIndexChange");
1833        }
1834        if (swiper.initialized || swiper.params.runCallbacksOnInit) {
1835            swiper.emit("slideChange");
1836        }
1837    }
1838    function updateClickedSlide(e) {
1839        const swiper = this;
1840        const params = swiper.params;
1841        const slide2 = $(e).closest(`.${params.slideClass}`)[0];
1842        let slideFound = false;
1843        let slideIndex;
1844        if (slide2) {
1845            for (let i = 0; i < swiper.slides.length; i += 1) {
1846                if (swiper.slides[i] === slide2) {
1847                    slideFound = true;
1848                    slideIndex = i;
1849                    break;
1850                }
1851            }
1852        }
1853        if (slide2 && slideFound) {
1854            swiper.clickedSlide = slide2;
1855            if (swiper.virtual && swiper.params.virtual.enabled) {
1856                swiper.clickedIndex = parseInt($(slide2).attr("data-swiper-slide-index"), 10);
1857            } else {
1858                swiper.clickedIndex = slideIndex;
1859            }
1860        } else {
1861            swiper.clickedSlide = void 0;
1862            swiper.clickedIndex = void 0;
1863            return;
1864        }
1865        if (params.slideToClickedSlide && swiper.clickedIndex !== void 0 && swiper.clickedIndex !== swiper.activeIndex) {
1866            swiper.slideToClickedSlide();
1867        }
1868    }
1869    var update = {
1870        updateSize,
1871        updateSlides,
1872        updateAutoHeight,
1873        updateSlidesOffset,
1874        updateSlidesProgress,
1875        updateProgress,
1876        updateSlidesClasses,
1877        updateActiveIndex,
1878        updateClickedSlide
1879    };
1880    function getSwiperTranslate(axis = this.isHorizontal() ? "x" : "y") {
1881        const swiper = this;
1882        const {
1883            params,
1884            rtlTranslate: rtl,
1885            translate: translate2,
1886            $wrapperEl
1887        } = swiper;
1888        if (params.virtualTranslate) {
1889            return rtl ? -translate2 : translate2;
1890        }
1891        if (params.cssMode) {
1892            return translate2;
1893        }
1894        let currentTranslate = getTranslate($wrapperEl[0], axis);
1895        if (rtl)
1896            currentTranslate = -currentTranslate;
1897        return currentTranslate || 0;
1898    }
1899    function setTranslate(translate2, byController) {
1900        const swiper = this;
1901        const {
1902            rtlTranslate: rtl,
1903            params,
1904            $wrapperEl,
1905            wrapperEl,
1906            progress
1907        } = swiper;
1908        let x = 0;
1909        let y = 0;
1910        const z = 0;
1911        if (swiper.isHorizontal()) {
1912            x = rtl ? -translate2 : translate2;
1913        } else {
1914            y = translate2;
1915        }
1916        if (params.roundLengths) {
1917            x = Math.floor(x);
1918            y = Math.floor(y);
1919        }
1920        if (params.cssMode) {
1921            wrapperEl[swiper.isHorizontal() ? "scrollLeft" : "scrollTop"] = swiper.isHorizontal() ? -x : -y;
1922        } else if (!params.virtualTranslate) {
1923            $wrapperEl.transform(`translate3d(${x}px, ${y}px, ${z}px)`);
1924        }
1925        swiper.previousTranslate = swiper.translate;
1926        swiper.translate = swiper.isHorizontal() ? x : y;
1927        let newProgress;
1928        const translatesDiff = swiper.maxTranslate() - swiper.minTranslate();
1929        if (translatesDiff === 0) {
1930            newProgress = 0;
1931        } else {
1932            newProgress = (translate2 - swiper.minTranslate()) / translatesDiff;
1933        }
1934        if (newProgress !== progress) {
1935            swiper.updateProgress(translate2);
1936        }
1937        swiper.emit("setTranslate", swiper.translate, byController);
1938    }
1939    function minTranslate() {
1940        return -this.snapGrid[0];
1941    }
1942    function maxTranslate() {
1943        return -this.snapGrid[this.snapGrid.length - 1];
1944    }
1945    function translateTo(translate2 = 0, speed = this.params.speed, runCallbacks = true, translateBounds = true, internal) {
1946        const swiper = this;
1947        const {
1948            params,
1949            wrapperEl
1950        } = swiper;
1951        if (swiper.animating && params.preventInteractionOnTransition) {
1952            return false;
1953        }
1954        const minTranslate2 = swiper.minTranslate();
1955        const maxTranslate2 = swiper.maxTranslate();
1956        let newTranslate;
1957        if (translateBounds && translate2 > minTranslate2)
1958            newTranslate = minTranslate2;
1959        else if (translateBounds && translate2 < maxTranslate2)
1960            newTranslate = maxTranslate2;
1961        else
1962            newTranslate = translate2;
1963        swiper.updateProgress(newTranslate);
1964        if (params.cssMode) {
1965            const isH = swiper.isHorizontal();
1966            if (speed === 0) {
1967                wrapperEl[isH ? "scrollLeft" : "scrollTop"] = -newTranslate;
1968            } else {
1969                if (!swiper.support.smoothScroll) {
1970                    animateCSSModeScroll({
1971                        swiper,
1972                        targetPosition: -newTranslate,
1973                        side: isH ? "left" : "top"
1974                    });
1975                    return true;
1976                }
1977                wrapperEl.scrollTo({
1978                    [isH ? "left" : "top"]: -newTranslate,
1979                    behavior: "smooth"
1980                });
1981            }
1982            return true;
1983        }
1984        if (speed === 0) {
1985            swiper.setTransition(0);
1986            swiper.setTranslate(newTranslate);
1987            if (runCallbacks) {
1988                swiper.emit("beforeTransitionStart", speed, internal);
1989                swiper.emit("transitionEnd");
1990            }
1991        } else {
1992            swiper.setTransition(speed);
1993            swiper.setTranslate(newTranslate);
1994            if (runCallbacks) {
1995                swiper.emit("beforeTransitionStart", speed, internal);
1996                swiper.emit("transitionStart");
1997            }
1998            if (!swiper.animating) {
1999                swiper.animating = true;
2000                if (!swiper.onTranslateToWrapperTransitionEnd) {
2001                    swiper.onTranslateToWrapperTransitionEnd = function transitionEnd2(e) {
2002                        if (!swiper || swiper.destroyed)
2003                            return;
2004                        if (e.target !== this)
2005                            return;
2006                        swiper.$wrapperEl[0].removeEventListener("transitionend", swiper.onTranslateToWrapperTransitionEnd);
2007                        swiper.$wrapperEl[0].removeEventListener("webkitTransitionEnd", swiper.onTranslateToWrapperTransitionEnd);
2008                        swiper.onTranslateToWrapperTransitionEnd = null;
2009                        delete swiper.onTranslateToWrapperTransitionEnd;
2010                        if (runCallbacks) {
2011                            swiper.emit("transitionEnd");
2012                        }
2013                    };
2014                }
2015                swiper.$wrapperEl[0].addEventListener("transitionend", swiper.onTranslateToWrapperTransitionEnd);
2016                swiper.$wrapperEl[0].addEventListener("webkitTransitionEnd", swiper.onTranslateToWrapperTransitionEnd);
2017            }
2018        }
2019        return true;
2020    }
2021    var translate = {
2022        getTranslate: getSwiperTranslate,
2023        setTranslate,
2024        minTranslate,
2025        maxTranslate,
2026        translateTo
2027    };
2028    function setTransition(duration, byController) {
2029        const swiper = this;
2030        if (!swiper.params.cssMode) {
2031            swiper.$wrapperEl.transition(duration);
2032        }
2033        swiper.emit("setTransition", duration, byController);
2034    }
2035    function transitionEmit({
2036                                swiper,
2037                                runCallbacks,
2038                                direction,
2039                                step
2040                            }) {
2041        const {
2042            activeIndex,
2043            previousIndex
2044        } = swiper;
2045        let dir = direction;
2046        if (!dir) {
2047            if (activeIndex > previousIndex)
2048                dir = "next";
2049            else if (activeIndex < previousIndex)
2050                dir = "prev";
2051            else
2052                dir = "reset";
2053        }
2054        swiper.emit(`transition${step}`);
2055        if (runCallbacks && activeIndex !== previousIndex) {
2056            if (dir === "reset") {
2057                swiper.emit(`slideResetTransition${step}`);
2058                return;
2059            }
2060            swiper.emit(`slideChangeTransition${step}`);
2061            if (dir === "next") {
2062                swiper.emit(`slideNextTransition${step}`);
2063            } else {
2064                swiper.emit(`slidePrevTransition${step}`);
2065            }
2066        }
2067    }
2068    function transitionStart(runCallbacks = true, direction) {
2069        const swiper = this;
2070        const {
2071            params
2072        } = swiper;
2073        if (params.cssMode)
2074            return;
2075        if (params.autoHeight) {
2076            swiper.updateAutoHeight();
2077        }
2078        transitionEmit({
2079            swiper,
2080            runCallbacks,
2081            direction,
2082            step: "Start"
2083        });
2084    }
2085    function transitionEnd(runCallbacks = true, direction) {
2086        const swiper = this;
2087        const {
2088            params
2089        } = swiper;
2090        swiper.animating = false;

2091        if (params.cssMode)
2092            return;
2093        swiper.setTransition(0);
2094        transitionEmit({
2095            swiper,
2096            runCallbacks,
2097            direction,
2098            step: "End"
2099        });
2100    }
2101    var transition = {
2102        setTransition,
2103        transitionStart,
2104        transitionEnd
2105    };
2106    function slideTo(index2 = 0, speed = this.params.speed, runCallbacks = true, internal, initial) {
2107        if (typeof index2 !== "number" && typeof index2 !== "string") {
2108            throw new Error(`The 'index' argument cannot have type other than 'number' or 'string'. [${typeof index2}] given.`);
2109        }
2110        if (typeof index2 === "string") {
2111            const indexAsNumber = parseInt(index2, 10);
2112            const isValidNumber = isFinite(indexAsNumber);
2113            if (!isValidNumber) {
2114                throw new Error(`The passed-in 'index' (string) couldn't be converted to 'number'. [${index2}] given.`);
2115            }
2116            index2 = indexAsNumber;
2117        }
2118        const swiper = this;
2119        let slideIndex = index2;
2120        if (slideIndex < 0)
2121            slideIndex = 0;
2122        const {
2123            params,
2124            snapGrid,
2125            slidesGrid,
2126            previousIndex,
2127            activeIndex,
2128            rtlTranslate: rtl,
2129            wrapperEl,
2130            enabled
2131        } = swiper;
2132        if (swiper.animating && params.preventInteractionOnTransition || !enabled && !internal && !initial) {
2133            return false;
2134        }
2135        const skip = Math.min(swiper.params.slidesPerGroupSkip, slideIndex);
2136        let snapIndex = skip + Math.floor((slideIndex - skip) / swiper.params.slidesPerGroup);
2137        if (snapIndex >= snapGrid.length)
2138            snapIndex = snapGrid.length - 1;
2139        if ((activeIndex || params.initialSlide || 0) === (previousIndex || 0) && runCallbacks) {
2140            swiper.emit("beforeSlideChangeStart");
2141        }
2142        const translate2 = -snapGrid[snapIndex];
2143        swiper.updateProgress(translate2);
2144        if (params.normalizeSlideIndex) {
2145            for (let i = 0; i < slidesGrid.length; i += 1) {
2146                const normalizedTranslate = -Math.floor(translate2 * 100);
2147                const normalizedGrid = Math.floor(slidesGrid[i] * 100);
2148                const normalizedGridNext = Math.floor(slidesGrid[i + 1] * 100);
2149                if (typeof slidesGrid[i + 1] !== "undefined") {
2150                    if (normalizedTranslate >= normalizedGrid && normalizedTranslate < normalizedGridNext - (normalizedGridNext - normalizedGrid) / 2) {
2151                        slideIndex = i;
2152                    } else if (normalizedTranslate >= normalizedGrid && normalizedTranslate < normalizedGridNext) {
2153                        slideIndex = i + 1;
2154                    }
2155                } else if (normalizedTranslate >= normalizedGrid) {
2156                    slideIndex = i;
2157                }
2158            }
2159        }
2160        if (swiper.initialized && slideIndex !== activeIndex) {
2161            if (!swiper.allowSlideNext && translate2 < swiper.translate && translate2 < swiper.minTranslate()) {
2162                return false;
2163            }
2164            if (!swiper.allowSlidePrev && translate2 > swiper.translate && translate2 > swiper.maxTranslate()) {
2165                if ((activeIndex || 0) !== slideIndex)
2166                    return false;
2167            }
2168        }
2169        let direction;
2170        if (slideIndex > activeIndex)
2171            direction = "next";
2172        else if (slideIndex < activeIndex)
2173            direction = "prev";
2174        else
2175            direction = "reset";
2176        if (rtl && -translate2 === swiper.translate || !rtl && translate2 === swiper.translate) {
2177            swiper.updateActiveIndex(slideIndex);
2178            if (params.autoHeight) {
2179                swiper.updateAutoHeight();
2180            }
2181            swiper.updateSlidesClasses();
2182            if (params.effect !== "slide") {
2183                swiper.setTranslate(translate2);
2184            }
2185            if (direction !== "reset") {
2186                swiper.transitionStart(runCallbacks, direction);
2187                swiper.transitionEnd(runCallbacks, direction);
2188            }
2189            return false;
2190        }
2191        if (params.cssMode) {
2192            const isH = swiper.isHorizontal();
2193            const t = rtl ? translate2 : -translate2;
2194            if (speed === 0) {
2195                const isVirtual = swiper.virtual && swiper.params.virtual.enabled;
2196                if (isVirtual) {
2197                    swiper.wrapperEl.style.scrollSnapType = "none";
2198                    swiper._immediateVirtual = true;
2199                }
2200                wrapperEl[isH ? "scrollLeft" : "scrollTop"] = t;
2201                if (isVirtual) {
2202                    requestAnimationFrame(() => {
2203                        swiper.wrapperEl.style.scrollSnapType = "";
2204                        swiper._swiperImmediateVirtual = false;
2205                    });
2206                }
2207            } else {
2208                if (!swiper.support.smoothScroll) {
2209                    animateCSSModeScroll({
2210                        swiper,
2211                        targetPosition: t,
2212                        side: isH ? "left" : "top"
2213                    });
2214                    return true;
2215                }
2216                wrapperEl.scrollTo({
2217                    [isH ? "left" : "top"]: t,
2218                    behavior: "smooth"
2219                });
2220            }
2221            return true;
2222        }
2223        swiper.setTransition(speed);
2224        swiper.setTranslate(translate2);
2225        swiper.updateActiveIndex(slideIndex);
2226        swiper.updateSlidesClasses();
2227        swiper.emit("beforeTransitionStart", speed, internal);
2228        swiper.transitionStart(runCallbacks, direction);
2229        if (speed === 0) {
2230            swiper.transitionEnd(runCallbacks, direction);
2231        } else if (!swiper.animating) {
2232            swiper.animating = true;
2233            if (!swiper.onSlideToWrapperTransitionEnd) {
2234                swiper.onSlideToWrapperTransitionEnd = function transitionEnd2(e) {
2235                    if (!swiper || swiper.destroyed)
2236                        return;
2237                    if (e.target !== this)
2238                        return;
2239                    swiper.$wrapperEl[0].removeEventListener("transitionend", swiper.onSlideToWrapperTransitionEnd);
2240                    swiper.$wrapperEl[0].removeEventListener("webkitTransitionEnd", swiper.onSlideToWrapperTransitionEnd);
2241                    swiper.onSlideToWrapperTransitionEnd = null;
2242                    delete swiper.onSlideToWrapperTransitionEnd;
2243                    swiper.transitionEnd(runCallbacks, direction);
2244                };
2245            }
2246            swiper.$wrapperEl[0].addEventListener("transitionend", swiper.onSlideToWrapperTransitionEnd);
2247            swiper.$wrapperEl[0].addEventListener("webkitTransitionEnd", swiper.onSlideToWrapperTransitionEnd);
2248        }
2249        return true;
2250    }
2251    function slideToLoop(index2 = 0, speed = this.params.speed, runCallbacks = true, internal) {
2252        const swiper = this;
2253        let newIndex = index2;
2254        if (swiper.params.loop) {
2255            newIndex += swiper.loopedSlides;
2256        }
2257        return swiper.slideTo(newIndex, speed, runCallbacks, internal);
2258    }
2259    function slideNext(speed = this.params.speed, runCallbacks = true, internal) {
2260        const swiper = this;
2261        const {
2262            animating,
2263            enabled,
2264            params
2265        } = swiper;
2266        if (!enabled)
2267            return swiper;
2268        let perGroup = params.slidesPerGroup;
2269        if (params.slidesPerView === "auto" && params.slidesPerGroup === 1 && params.slidesPerGroupAuto) {
2270            perGroup = Math.max(swiper.slidesPerViewDynamic("current", true), 1);
2271        }
2272        const increment = swiper.activeIndex < params.slidesPerGroupSkip ? 1 : perGroup;
2273        if (params.loop) {
2274            if (animating && params.loopPreventsSlide)
2275                return false;
2276            swiper.loopFix();
2277            swiper._clientLeft = swiper.$wrapperEl[0].clientLeft;
2278        }
2279        if (params.rewind && swiper.isEnd) {
2280            return swiper.slideTo(0, speed, runCallbacks, internal);
2281        }
2282        return swiper.slideTo(swiper.activeIndex + increment, speed, runCallbacks, internal);
2283    }
2284    function slidePrev(speed = this.params.speed, runCallbacks = true, internal) {
2285        const swiper = this;
2286        const {
2287            params,
2288            animating,
2289            snapGrid,
2290            slidesGrid,
2291            rtlTranslate,
2292            enabled
2293        } = swiper;
2294        if (!enabled)
2295            return swiper;
2296        if (params.loop) {
2297            if (animating && params.loopPreventsSlide)
2298                return false;
2299            swiper.loopFix();
2300            swiper._clientLeft = swiper.$wrapperEl[0].clientLeft;
2301        }
2302        const translate2 = rtlTranslate ? swiper.translate : -swiper.translate;
2303        function normalize(val) {
2304            if (val < 0)
2305                return -Math.floor(Math.abs(val));
2306            return Math.floor(val);
2307        }
2308        const normalizedTranslate = normalize(translate2);
2309        const normalizedSnapGrid = snapGrid.map((val) => normalize(val));
2310        let prevSnap = snapGrid[normalizedSnapGrid.indexOf(normalizedTranslate) - 1];
2311        if (typeof prevSnap === "undefined" && params.cssMode) {
2312            let prevSnapIndex;
2313            snapGrid.forEach((snap, snapIndex) => {
2314                if (normalizedTranslate >= snap) {
2315                    prevSnapIndex = snapIndex;
2316                }
2317            });
2318            if (typeof prevSnapIndex !== "undefined") {
2319                prevSnap = snapGrid[prevSnapIndex > 0 ? prevSnapIndex - 1 : prevSnapIndex];
2320            }
2321        }
2322        let prevIndex = 0;
2323        if (typeof prevSnap !== "undefined") {
2324            prevIndex = slidesGrid.indexOf(prevSnap);
2325            if (prevIndex < 0)
2326                prevIndex = swiper.activeIndex - 1;
2327            if (params.slidesPerView === "auto" && params.slidesPerGroup === 1 && params.slidesPerGroupAuto) {
2328                prevIndex = prevIndex - swiper.slidesPerViewDynamic("previous", true) + 1;
2329                prevIndex = Math.max(prevIndex, 0);
2330            }
2331        }
2332        if (params.rewind && swiper.isBeginning) {
2333            return swiper.slideTo(swiper.slides.length - 1, speed, runCallbacks, internal);
2334        }
2335        return swiper.slideTo(prevIndex, speed, runCallbacks, internal);
2336    }
2337    function slideReset(speed = this.params.speed, runCallbacks = true, internal) {
2338        const swiper = this;
2339        return swiper.slideTo(swiper.activeIndex, speed, runCallbacks, internal);
2340    }
2341    function slideToClosest(speed = this.params.speed, runCallbacks = true, internal, threshold = 0.5) {
2342        const swiper = this;
2343        let index2 = swiper.activeIndex;
2344        const skip = Math.min(swiper.params.slidesPerGroupSkip, index2);
2345        const snapIndex = skip + Math.floor((index2 - skip) / swiper.params.slidesPerGroup);
2346        const translate2 = swiper.rtlTranslate ? swiper.translate : -swiper.translate;
2347        if (translate2 >= swiper.snapGrid[snapIndex]) {
2348            const currentSnap = swiper.snapGrid[snapIndex];
2349            const nextSnap = swiper.snapGrid[snapIndex + 1];
2350            if (translate2 - currentSnap > (nextSnap - currentSnap) * threshold) {
2351                index2 += swiper.params.slidesPerGroup;
2352            }
2353        } else {
2354            const prevSnap = swiper.snapGrid[snapIndex - 1];
2355            const currentSnap = swiper.snapGrid[snapIndex];
2356            if (translate2 - prevSnap <= (currentSnap - prevSnap) * threshold) {
2357                index2 -= swiper.params.slidesPerGroup;
2358            }
2359        }
2360        index2 = Math.max(index2, 0);
2361        index2 = Math.min(index2, swiper.slidesGrid.length - 1);
2362        return swiper.slideTo(index2, speed, runCallbacks, internal);
2363    }
2364    function slideToClickedSlide() {
2365        const swiper = this;
2366        const {
2367            params,
2368            $wrapperEl
2369        } = swiper;
2370        const slidesPerView = params.slidesPerView === "auto" ? swiper.slidesPerViewDynamic() : params.slidesPerView;
2371        let slideToIndex = swiper.clickedIndex;
2372        let realIndex;
2373        if (params.loop) {
2374            if (swiper.animating)
2375                return;
2376            realIndex = parseInt($(swiper.clickedSlide).attr("data-swiper-slide-index"), 10);
2377            if (params.centeredSlides) {
2378                if (slideToIndex < swiper.loopedSlides - slidesPerView / 2 || slideToIndex > swiper.slides.length - swiper.loopedSlides + slidesPerView / 2) {
2379                    swiper.loopFix();
2380                    slideToIndex = $wrapperEl.children(`.${params.slideClass}[data-swiper-slide-index="${realIndex}"]:not(.${params.slideDuplicateClass})`).eq(0).index();
2381                    nextTick(() => {
2382                        swiper.slideTo(slideToIndex);
2383                    });
2384                } else {
2385                    swiper.slideTo(slideToIndex);
2386                }
2387            } else if (slideToIndex > swiper.slides.length - slidesPerView) {
2388                swiper.loopFix();
2389                slideToIndex = $wrapperEl.children(`.${params.slideClass}[data-swiper-slide-index="${realIndex}"]:not(.${params.slideDuplicateClass})`).eq(0).index();
2390                nextTick(() => {
2391                    swiper.slideTo(slideToIndex);
2392                });
2393            } else {
2394                swiper.slideTo(slideToIndex);
2395            }
2396        } else {
2397            swiper.slideTo(slideToIndex);
2398        }
2399    }
2400    var slide = {
2401        slideTo,
2402        slideToLoop,
2403        slideNext,
2404        slidePrev,
2405        slideReset,
2406        slideToClosest,
2407        slideToClickedSlide
2408    };
2409    function loopCreate() {
2410        const swiper = this;
2411        const document2 = getDocument();
2412        const {
2413            params,
2414            $wrapperEl
2415        } = swiper;
2416        const $selector = $wrapperEl.children().length > 0 ? $($wrapperEl.children()[0].parentNode) : $wrapperEl;
2417        $selector.children(`.${params.slideClass}.${params.slideDuplicateClass}`).remove();
2418        let slides = $selector.children(`.${params.slideClass}`);
2419        if (params.loopFillGroupWithBlank) {
2420            const blankSlidesNum = params.slidesPerGroup - slides.length % params.slidesPerGroup;
2421            if (blankSlidesNum !== params.slidesPerGroup) {
2422                for (let i = 0; i < blankSlidesNum; i += 1) {
2423                    const blankNode = $(document2.createElement("div")).addClass(`${params.slideClass} ${params.slideBlankClass}`);
2424                    $selector.append(blankNode);
2425                }
2426                slides = $selector.children(`.${params.slideClass}`);
2427            }
2428        }
2429        if (params.slidesPerView === "auto" && !params.loopedSlides)
2430            params.loopedSlides = slides.length;
2431        swiper.loopedSlides = Math.ceil(parseFloat(params.loopedSlides || params.slidesPerView, 10));
2432        swiper.loopedSlides += params.loopAdditionalSlides;
2433        if (swiper.loopedSlides > slides.length) {
2434            swiper.loopedSlides = slides.length;
2435        }
2436        const prependSlides = [];
2437        const appendSlides = [];
2438        slides.each((el, index2) => {
2439            const slide2 = $(el);
2440            if (index2 < swiper.loopedSlides) {
2441                appendSlides.push(el);
2442            }
2443            if (index2 < slides.length && index2 >= slides.length - swiper.loopedSlides) {
2444                prependSlides.push(el);
2445            }
2446            slide2.attr("data-swiper-slide-index", index2);
2447        });
2448        for (let i = 0; i < appendSlides.length; i += 1) {
2449            $selector.append($(appendSlides[i].cloneNode(true)).addClass(params.slideDuplicateClass));
2450        }
2451        for (let i = prependSlides.length - 1; i >= 0; i -= 1) {

2452            $selector.prepend($(prependSlides[i].cloneNode(true)).addClass(params.slideDuplicateClass));
2453        }
2454    }
2455    function loopFix() {
2456        const swiper = this;
2457        swiper.emit("beforeLoopFix");
2458        const {
2459            activeIndex,
2460            slides,
2461            loopedSlides,
2462            allowSlidePrev,
2463            allowSlideNext,
2464            snapGrid,
2465            rtlTranslate: rtl
2466        } = swiper;
2467        let newIndex;
2468        swiper.allowSlidePrev = true;
2469        swiper.allowSlideNext = true;
2470        const snapTranslate = -snapGrid[activeIndex];
2471        const diff = snapTranslate - swiper.getTranslate();
2472        if (activeIndex < loopedSlides) {
2473            newIndex = slides.length - loopedSlides * 3 + activeIndex;
2474            newIndex += loopedSlides;
2475            const slideChanged = swiper.slideTo(newIndex, 0, false, true);
2476            if (slideChanged && diff !== 0) {
2477                swiper.setTranslate((rtl ? -swiper.translate : swiper.translate) - diff);
2478            }
2479        } else if (activeIndex >= slides.length - loopedSlides) {
2480            newIndex = -slides.length + activeIndex + loopedSlides;
2481            newIndex += loopedSlides;
2482            const slideChanged = swiper.slideTo(newIndex, 0, false, true);
2483            if (slideChanged && diff !== 0) {
2484                swiper.setTranslate((rtl ? -swiper.translate : swiper.translate) - diff);
2485            }
2486        }
2487        swiper.allowSlidePrev = allowSlidePrev;
2488        swiper.allowSlideNext = allowSlideNext;
2489        swiper.emit("loopFix");
2490    }
2491    function loopDestroy() {
2492        const swiper = this;
2493        const {
2494            $wrapperEl,
2495            params,
2496            slides
2497        } = swiper;
2498        $wrapperEl.children(`.${params.slideClass}.${params.slideDuplicateClass},.${params.slideClass}.${params.slideBlankClass}`).remove();
2499        slides.removeAttr("data-swiper-slide-index");
2500    }
2501    var loop = {
2502        loopCreate,
2503        loopFix,
2504        loopDestroy
2505    };
2506    function setGrabCursor(moving) {
2507        const swiper = this;
2508        if (swiper.support.touch || !swiper.params.simulateTouch || swiper.params.watchOverflow && swiper.isLocked || swiper.params.cssMode)
2509            return;
2510        const el = swiper.params.touchEventsTarget === "container" ? swiper.el : swiper.wrapperEl;
2511        el.style.cursor = "move";
2512        el.style.cursor = moving ? "-webkit-grabbing" : "-webkit-grab";
2513        el.style.cursor = moving ? "-moz-grabbin" : "-moz-grab";
2514        el.style.cursor = moving ? "grabbing" : "grab";
2515    }
2516    function unsetGrabCursor() {
2517        const swiper = this;
2518        if (swiper.support.touch || swiper.params.watchOverflow && swiper.isLocked || swiper.params.cssMode) {
2519            return;
2520        }
2521        swiper[swiper.params.touchEventsTarget === "container" ? "el" : "wrapperEl"].style.cursor = "";
2522    }
2523    var grabCursor = {
2524        setGrabCursor,
2525        unsetGrabCursor
2526    };
2527    function closestElement(selector, base = this) {
2528        function __closestFrom(el) {
2529            if (!el || el === getDocument() || el === getWindow())
2530                return null;
2531            if (el.assignedSlot)
2532                el = el.assignedSlot;
2533            const found = el.closest(selector);
2534            return found || __closestFrom(el.getRootNode().host);
2535        }
2536        return __closestFrom(base);
2537    }
2538    function onTouchStart(event) {
2539        const swiper = this;
2540        const document2 = getDocument();
2541        const window2 = getWindow();
2542        const data = swiper.touchEventsData;
2543        const {
2544            params,
2545            touches,
2546            enabled
2547        } = swiper;
2548        if (!enabled)
2549            return;
2550        if (swiper.animating && params.preventInteractionOnTransition) {
2551            return;
2552        }
2553        if (!swiper.animating && params.cssMode && params.loop) {
2554            swiper.loopFix();
2555        }
2556        let e = event;
2557        if (e.originalEvent)
2558            e = e.originalEvent;
2559        let $targetEl = $(e.target);
2560        if (params.touchEventsTarget === "wrapper") {

2561            if (!$targetEl.closest(swiper.wrapperEl).length)
2562                return;
2563        }
2564        data.isTouchEvent = e.type === "touchstart";
2565        if (!data.isTouchEvent && "which" in e && e.which === 3)
2566            return;
2567        if (!data.isTouchEvent && "button" in e && e.button > 0)
2568            return;
2569        if (data.isTouched && data.isMoved)
2570            return;
2571        const swipingClassHasValue = !!params.noSwipingClass && params.noSwipingClass !== "";
2572        if (swipingClassHasValue && e.target && e.target.shadowRoot && event.path && event.path[0]) {
2573            $targetEl = $(event.path[0]);
2574        }
2575        const noSwipingSelector = params.noSwipingSelector ? params.noSwipingSelector : `.${params.noSwipingClass}`;
2576        const isTargetShadow = !!(e.target && e.target.shadowRoot);
2577        if (params.noSwiping && (isTargetShadow ? closestElement(noSwipingSelector, e.target) : $targetEl.closest(noSwipingSelector)[0])) {
2578            swiper.allowClick = true;
2579            return;
2580        }
2581        if (params.swipeHandler) {
2582            if (!$targetEl.closest(params.swipeHandler)[0])
2583                return;
2584        }
2585        touches.currentX = e.type === "touchstart" ? e.targetTouches[0].pageX : e.pageX;
2586        touches.currentY = e.type === "touchstart" ? e.targetTouches[0].pageY : e.pageY;
2587        const startX = touches.currentX;
2588        const startY = touches.currentY;
2589        const edgeSwipeDetection = params.edgeSwipeDetection || params.iOSEdgeSwipeDetection;
2590        const edgeSwipeThreshold = params.edgeSwipeThreshold || params.iOSEdgeSwipeThreshold;
2591        if (edgeSwipeDetection && (startX <= edgeSwipeThreshold || startX >= window2.innerWidth - edgeSwipeThreshold)) {
2592            if (edgeSwipeDetection === "prevent") {
2593                event.preventDefault();
2594            } else {
2595                return;
2596            }
2597        }
2598        Object.assign(data, {
2599            isTouched: true,
2600            isMoved: false,
2601            allowTouchCallbacks: true,
2602            isScrolling: void 0,
2603            startMoving: void 0
2604        });
2605        touches.startX = startX;
2606        touches.startY = startY;
2607        data.touchStartTime = now();
2608        swiper.allowClick = true;
2609        swiper.updateSize();
2610        swiper.swipeDirection = void 0;
2611        if (params.threshold > 0)
2612            data.allowThresholdMove = false;
2613        if (e.type !== "touchstart") {
2614            let preventDefault = true;
2615            if ($targetEl.is(data.focusableElements))
2616                preventDefault = false;
2617            if (document2.activeElement && $(document2.activeElement).is(data.focusableElements) && document2.activeElement !== $targetEl[0]) {
2618                document2.activeElement.blur();
2619            }
2620            const shouldPreventDefault = preventDefault && swiper.allowTouchMove && params.touchStartPreventDefault;
2621            if ((params.touchStartForcePreventDefault || shouldPreventDefault) && !$targetEl[0].isContentEditable) {
2622                e.preventDefault();
2623            }
2624        }
2625        swiper.emit("touchStart", e);
2626    }
2627    function onTouchMove(event) {
2628        const document2 = getDocument();
2629        const swiper = this;
2630        const data = swiper.touchEventsData;
2631        const {
2632            params,
2633            touches,
2634            rtlTranslate: rtl,
2635            enabled
2636        } = swiper;
2637        if (!enabled)
2638            return;
2639        let e = event;
2640        if (e.originalEvent)
2641            e = e.originalEvent;
2642        if (!data.isTouched) {
2643            if (data.startMoving && data.isScrolling) {
2644                swiper.emit("touchMoveOpposite", e);
2645            }
2646            return;
2647        }
2648        if (data.isTouchEvent && e.type !== "touchmove")
2649            return;
2650        const targetTouch = e.type === "touchmove" && e.targetTouches && (e.targetTouches[0] || e.changedTouches[0]);
2651        const pageX = e.type === "touchmove" ? targetTouch.pageX : e.pageX;
2652        const pageY = e.type === "touchmove" ? targetTouch.pageY : e.pageY;
2653        if (e.preventedByNestedSwiper) {
2654            touches.startX = pageX;
2655            touches.startY = pageY;
2656            return;
2657        }
2658        if (!swiper.allowTouchMove) {
2659            swiper.allowClick = false;
2660            if (data.isTouched) {
2661                Object.assign(touches, {
2662                    startX: pageX,
2663                    startY: pageY,
2664                    currentX: pageX,
2665                    currentY: pageY
2666                });
2667                data.touchStartTime = now();
2668            }
2669            return;
2670        }
2671        if (data.isTouchEvent && params.touchReleaseOnEdges && !params.loop) {
2672            if (swiper.isVertical()) {
2673                if (pageY < touches.startY && swiper.translate <= swiper.maxTranslate() || pageY > touches.startY && swiper.translate >= swiper.minTranslate()) {
2674                    data.isTouched = false;
2675                    data.isMoved = false;
2676                    return;
2677                }
2678            } else if (pageX < touches.startX && swiper.translate <= swiper.maxTranslate() || pageX > touches.startX && swiper.translate >= swiper.minTranslate()) {
2679                return;
2680            }
2681        }
2682        if (data.isTouchEvent && document2.activeElement) {
2683            if (e.target === document2.activeElement && $(e.target).is(data.focusableElements)) {
2684                data.isMoved = true;
2685                swiper.allowClick = false;
2686                return;
2687            }
2688        }
2689        if (data.allowTouchCallbacks) {
2690            swiper.emit("touchMove", e);
2691        }
2692        if (e.targetTouches && e.targetTouches.length > 1)
2693            return;
2694        touches.currentX = pageX;
2695        touches.currentY = pageY;
2696        const diffX = touches.currentX - touches.startX;
2697        const diffY = touches.currentY - touches.startY;
2698        if (swiper.params.threshold && Math.sqrt(__pow(diffX, 2) + __pow(diffY, 2)) < swiper.params.threshold)
2699            return;
2700        if (typeof data.isScrolling === "undefined") {
2701            let touchAngle;
2702            if (swiper.isHorizontal() && touches.currentY === touches.startY || swiper.isVertical() && touches.currentX === touches.startX) {
2703                data.isScrolling = false;
2704            } else {
2705                if (diffX * diffX + diffY * diffY >= 25) {
2706                    touchAngle = Math.atan2(Math.abs(diffY), Math.abs(diffX)) * 180 / Math.PI;
2707                    data.isScrolling = swiper.isHorizontal() ? touchAngle > params.touchAngle : 90 - touchAngle > params.touchAngle;
2708                }
2709            }
2710        }
2711        if (data.isScrolling) {
2712            swiper.emit("touchMoveOpposite", e);
2713        }
2714        if (typeof data.startMoving === "undefined") {
2715            if (touches.currentX !== touches.startX || touches.currentY !== touches.startY) {
2716                data.startMoving = true;
2717            }
2718        }
2719        if (data.isScrolling) {
2720            data.isTouched = false;
2721            return;
2722        }
2723        if (!data.startMoving) {
2724            return;
2725        }
2726        swiper.allowClick = false;
2727        if (!params.cssMode && e.cancelable) {
2728            e.preventDefault();
2729        }
2730        if (params.touchMoveStopPropagation && !params.nested) {
2731            e.stopPropagation();
2732        }
2733        if (!data.isMoved) {
2734            if (params.loop && !params.cssMode) {
2735                swiper.loopFix();
2736            }
2737            data.startTranslate = swiper.getTranslate();
2738            swiper.setTransition(0);
2739            if (swiper.animating) {
2740                swiper.$wrapperEl.trigger("webkitTransitionEnd transitionend");
2741            }
2742            data.allowMomentumBounce = false;
2743            if (params.grabCursor && (swiper.allowSlideNext === true || swiper.allowSlidePrev === true)) {
2744                swiper.setGrabCursor(true);
2745            }
2746            swiper.emit("sliderFirstMove", e);
2747        }
2748        swiper.emit("sliderMove", e);
2749        data.isMoved = true;
2750        let diff = swiper.isHorizontal() ? diffX : diffY;
2751        touches.diff = diff;
2752        diff *= params.touchRatio;
2753        if (rtl)
2754            diff = -diff;
2755        swiper.swipeDirection = diff > 0 ? "prev" : "next";
2756        data.currentTranslate = diff + data.startTranslate;
2757        let disableParentSwiper = true;
2758        let resistanceRatio = params.resistanceRatio;
2759        if (params.touchReleaseOnEdges) {
2760            resistanceRatio = 0;
2761        }
2762        if (diff > 0 && data.currentTranslate > swiper.minTranslate()) {
2763            disableParentSwiper = false;
2764            if (params.resistance)
2765                data.currentTranslate = swiper.minTranslate() - 1 + __pow(-swiper.minTranslate() + data.startTranslate + diff, resistanceRatio);
2766        } else if (diff < 0 && data.currentTranslate < swiper.maxTranslate()) {
2767            disableParentSwiper = false;
2768            if (params.resistance)
2769                data.currentTranslate = swiper.maxTranslate() + 1 - __pow(swiper.maxTranslate() - data.startTranslate - diff, resistanceRatio);
2770        }
2771        if (disableParentSwiper) {
2772            e.preventedByNestedSwiper = true;
2773        }
2774        if (!swiper.allowSlideNext && swiper.swipeDirection === "next" && data.currentTranslate < data.startTranslate) {
2775            data.currentTranslate = data.startTranslate;
2776        }
2777        if (!swiper.allowSlidePrev && swiper.swipeDirection === "prev" && data.currentTranslate > data.startTranslate) {
2778            data.currentTranslate = data.startTranslate;
2779        }
2780        if (!swiper.allowSlidePrev && !swiper.allowSlideNext) {
2781            data.currentTranslate = data.startTranslate;
2782        }
2783        if (params.threshold > 0) {
2784            if (Math.abs(diff) > params.threshold || data.allowThresholdMove) {
2785                if (!data.allowThresholdMove) {
2786                    data.allowThresholdMove = true;
2787                    touches.startX = touches.currentX;
2788                    touches.startY = touches.currentY;
2789                    data.currentTranslate = data.startTranslate;
2790                    touches.diff = swiper.isHorizontal() ? touches.currentX - touches.startX : touches.currentY - touches.startY;
2791                    return;
2792                }
2793            } else {
2794                data.currentTranslate = data.startTranslate;
2795                return;
2796            }
2797        }
2798        if (!params.followFinger || params.cssMode)
2799            return;
2800        if (params.freeMode && params.freeMode.enabled && swiper.freeMode || params.watchSlidesProgress) {
2801            swiper.updateActiveIndex();
2802            swiper.updateSlidesClasses();
2803        }
2804        if (swiper.params.freeMode && params.freeMode.enabled && swiper.freeMode) {
2805            swiper.freeMode.onTouchMove();
2806        }
2807        swiper.updateProgress(data.currentTranslate);
2808        swiper.setTranslate(data.currentTranslate);
2809    }
2810    function onTouchEnd(event) {
2811        const swiper = this;
2812        const data = swiper.touchEventsData;
2813        const {
2814            params,
2815            touches,
2816            rtlTranslate: rtl,
2817            slidesGrid,
2818            enabled
2819        } = swiper;
2820        if (!enabled)
2821            return;
2822        let e = event;
2823        if (e.originalEvent)
2824            e = e.originalEvent;
2825        if (data.allowTouchCallbacks) {
2826            swiper.emit("touchEnd", e);
2827        }
2828        data.allowTouchCallbacks = false;
2829        if (!data.isTouched) {
2830            if (data.isMoved && params.grabCursor) {
2831                swiper.setGrabCursor(false);
2832            }
2833            data.isMoved = false;
2834            data.startMoving = false;
2835            return;
2836        }
2837        if (params.grabCursor && data.isMoved && data.isTouched && (swiper.allowSlideNext === true || swiper.allowSlidePrev === true)) {
2838            swiper.setGrabCursor(false);
2839        }
2840        const touchEndTime = now();
2841        const timeDiff = touchEndTime - data.touchStartTime;
2842        if (swiper.allowClick) {
2843            const pathTree = e.path || e.composedPath && e.composedPath();
2844            swiper.updateClickedSlide(pathTree && pathTree[0] || e.target);
2845            swiper.emit("tap click", e);
2846            if (timeDiff < 300 && touchEndTime - data.lastClickTime < 300) {
2847                swiper.emit("doubleTap doubleClick", e);
2848            }
2849        }
2850        data.lastClickTime = now();
2851        nextTick(() => {
2852            if (!swiper.destroyed)
2853                swiper.allowClick = true;
2854        });
2855        if (!data.isTouched || !data.isMoved || !swiper.swipeDirection || touches.diff === 0 || data.currentTranslate === data.startTranslate) {
2856            data.isTouched = false;
2857            data.isMoved = false;
2858            data.startMoving = false;
2859            return;
2860        }
2861        data.isTouched = false;
2862        data.isMoved = false;
2863        data.startMoving = false;
2864        let currentPos;
2865        if (params.followFinger) {
2866            currentPos = rtl ? swiper.translate : -swiper.translate;
2867        } else {
2868            currentPos = -data.currentTranslate;
2869        }
2870        if (params.cssMode) {
2871            return;
2872        }
2873        if (swiper.params.freeMode && params.freeMode.enabled) {
2874            swiper.freeMode.onTouchEnd({
2875                currentPos
2876            });
2877            return;
2878        }
2879        let stopIndex = 0;
2880        let groupSize = swiper.slidesSizesGrid[0];
2881        for (let i = 0; i < slidesGrid.length; i += i < params.slidesPerGroupSkip ? 1 : params.slidesPerGroup) {
2882            const increment2 = i < params.slidesPerGroupSkip - 1 ? 1 : params.slidesPerGroup;
2883            if (typeof slidesGrid[i + increment2] !== "undefined") {
2884                if (currentPos >= slidesGrid[i] && currentPos < slidesGrid[i + increment2]) {
2885                    stopIndex = i;
2886                    groupSize = slidesGrid[i + increment2] - slidesGrid[i];
2887                }
2888            } else if (currentPos >= slidesGrid[i]) {
2889                stopIndex = i;
2890                groupSize = slidesGrid[slidesGrid.length - 1] - slidesGrid[slidesGrid.length - 2];
2891            }
2892        }
2893        const ratio = (currentPos - slidesGrid[stopIndex]) / groupSize;
2894        const increment = stopIndex < params.slidesPerGroupSkip - 1 ? 1 : params.slidesPerGroup;
2895        if (timeDiff > params.longSwipesMs) {
2896            if (!params.longSwipes) {
2897                swiper.slideTo(swiper.activeIndex);
2898                return;
2899            }
2900            if (swiper.swipeDirection === "next") {
2901                if (ratio >= params.longSwipesRatio)
2902                    swiper.slideTo(stopIndex + increment);
2903                else
2904                    swiper.slideTo(stopIndex);
2905            }
2906            if (swiper.swipeDirection === "prev") {
2907                if (ratio > 1 - params.longSwipesRatio)
2908                    swiper.slideTo(stopIndex + increment);
2909                else
2910                    swiper.slideTo(stopIndex);
2911            }
2912        } else {
2913            if (!params.shortSwipes) {
2914                swiper.slideTo(swiper.activeIndex);
2915                return;
2916            }
2917            const isNavButtonTarget = swiper.navigation && (e.target === swiper.navigation.nextEl || e.target === swiper.navigation.prevEl);
2918            if (!isNavButtonTarget) {
2919                if (swiper.swipeDirection === "next") {
2920                    swiper.slideTo(stopIndex + increment);
2921                }
2922                if (swiper.swipeDirection === "prev") {
2923                    swiper.slideTo(stopIndex);
2924                }
2925            } else if (e.target === swiper.navigation.nextEl) {
2926                swiper.slideTo(stopIndex + increment);
2927            } else {
2928                swiper.slideTo(stopIndex);
2929            }
2930        }
2931    }
2932    function onResize() {
2933        const swiper = this;
2934        const {
2935            params,
2936            el
2937        } = swiper;
2938        if (el && el.offsetWidth === 0)
2939            return;
2940        if (params.breakpoints) {
2941            swiper.setBreakpoint();
2942        }
2943        const {
2944            allowSlideNext,
2945            allowSlidePrev,
2946            snapGrid
2947        } = swiper;
2948        swiper.allowSlideNext = true;
2949        swiper.allowSlidePrev = true;
2950        swiper.updateSize();
2951        swiper.updateSlides();
2952        swiper.updateSlidesClasses();
2953        if ((params.slidesPerView === "auto" || params.slidesPerView > 1) && swiper.isEnd && !swiper.isBeginning && !swiper.params.centeredSlides) {
2954            swiper.slideTo(swiper.slides.length - 1, 0, false, true);
2955        } else {
2956            swiper.slideTo(swiper.activeIndex, 0, false, true);
2957        }
2958        if (swiper.autoplay && swiper.autoplay.running && swiper.autoplay.paused) {
2959            swiper.autoplay.run();
2960        }
2961        swiper.allowSlidePrev = allowSlidePrev;
2962        swiper.allowSlideNext = allowSlideNext;
2963        if (swiper.params.watchOverflow && snapGrid !== swiper.snapGrid) {
2964            swiper.checkOverflow();
2965        }
2966    }
2967    function onClick(e) {
2968        const swiper = this;
2969        if (!swiper.enabled)
2970            return;
2971        if (!swiper.allowClick) {
2972            if (swiper.params.preventClicks)
2973                e.preventDefault();
2974            if (swiper.params.preventClicksPropagation && swiper.animating) {
2975                e.stopPropagation();
2976                e.stopImmediatePropagation();
2977            }
2978        }
2979    }
2980    function onScroll() {
2981        const swiper = this;
2982        const {
2983            wrapperEl,
2984            rtlTranslate,
2985            enabled
2986        } = swiper;
2987        if (!enabled)
2988            return;
2989        swiper.previousTranslate = swiper.translate;
2990        if (swiper.isHorizontal()) {
2991            swiper.translate = -wrapperEl.scrollLeft;
2992        } else {
2993            swiper.translate = -wrapperEl.scrollTop;
2994        }
2995        if (swiper.translate === -0)
2996            swiper.translate = 0;
2997        swiper.updateActiveIndex();
2998        swiper.updateSlidesClasses();
2999        let newProgress;
3000        const translatesDiff = swiper.maxTranslate() - swiper.minTranslate();
3001        if (translatesDiff === 0) {
3002            newProgress = 0;
3003        } else {
3004            newProgress = (swiper.translate - swiper.minTranslate()) / translatesDiff;
3005        }
3006        if (newProgress !== swiper.progress) {
3007            swiper.updateProgress(rtlTranslate ? -swiper.translate : swiper.translate);
3008        }
3009        swiper.emit("setTranslate", swiper.translate, false);
3010    }
3011    let dummyEventAttached = false;