https://ticket-hcspart.ru/local/modules/swiper/swiper-bundle.js?1753827452381828

1/**
2 * Swiper 10.3.1
3 * Most modern mobile touch slider and framework with hardware accelerated transitions
4 * https://swiperjs.com
5 *
6 * Copyright 2014-2023 Vladimir Kharlampidi
7 *
8 * Released under the MIT License
9 *
10 * Released on: September 28, 2023
11 */
12
13var Swiper = (function () {
14    'use strict';
15
16    /**
17     * SSR Window 4.0.2
18     * Better handling for window object in SSR environment
19     * https://github.com/nolimits4web/ssr-window
20     *
21     * Copyright 2021, Vladimir Kharlampidi
22     *
23     * Licensed under MIT
24     *
25     * Released on: December 13, 2021
26     */
27    /* eslint-disable no-param-reassign */
28    function isObject$1(obj) {
29        return obj !== null && typeof obj === 'object' && 'constructor' in obj && obj.constructor === Object;
30    }
31    function extend$1(target, src) {
32        if (target === void 0) {
33            target = {};
34        }
35        if (src === void 0) {
36            src = {};
37        }
38        Object.keys(src).forEach(key => {
39            if (typeof target[key] === 'undefined') target[key] = src[key];else if (isObject$1(src[key]) && isObject$1(target[key]) && Object.keys(src[key]).length > 0) {
40                extend$1(target[key], src[key]);
41            }
42        });
43    }
44    const ssrDocument = {
45        body: {},
46        addEventListener() {},
47        removeEventListener() {},
48        activeElement: {
49            blur() {},
50            nodeName: ''
51        },
52        querySelector() {
53            return null;
54        },
55        querySelectorAll() {
56            return [];
57        },
58        getElementById() {
59            return null;
60        },
61        createEvent() {
62            return {
63                initEvent() {}
64            };
65        },
66        createElement() {
67            return {
68                children: [],
69                childNodes: [],
70                style: {},
71                setAttribute() {},
72                getElementsByTagName() {
73                    return [];
74                }
75            };
76        },
77        createElementNS() {
78            return {};
79        },
80        importNode() {
81            return null;
82        },
83        location: {
84            hash: '',
85            host: '',
86            hostname: '',
87            href: '',
88            origin: '',
89            pathname: '',
90            protocol: '',
91            search: ''
92        }
93    };
94    function getDocument() {
95        const doc = typeof document !== 'undefined' ? document : {};
96        extend$1(doc, ssrDocument);
97        return doc;
98    }
99    const ssrWindow = {
100        document: ssrDocument,
101        navigator: {
102            userAgent: ''
103        },
104        location: {
105            hash: '',
106            host: '',
107            hostname: '',
108            href: '',
109            origin: '',
110            pathname: '',
111            protocol: '',
112            search: ''
113        },
114        history: {
115            replaceState() {},
116            pushState() {},
117            go() {},
118            back() {}
119        },
120        CustomEvent: function CustomEvent() {
121            return this;
122        },
123        addEventListener() {},
124        removeEventListener() {},
125        getComputedStyle() {
126            return {
127                getPropertyValue() {
128                    return '';
129                }
130            };
131        },
132        Image() {},
133        Date() {},
134        screen: {},
135        setTimeout() {},
136        clearTimeout() {},
137        matchMedia() {
138            return {};
139        },
140        requestAnimationFrame(callback) {
141            if (typeof setTimeout === 'undefined') {
142                callback();
143                return null;
144            }
145            return setTimeout(callback, 0);
146        },
147        cancelAnimationFrame(id) {
148            if (typeof setTimeout === 'undefined') {
149                return;
150            }
151            clearTimeout(id);
152        }
153    };
154    function getWindow() {
155        const win = typeof window !== 'undefined' ? window : {};
156        extend$1(win, ssrWindow);
157        return win;
158    }
159
160    function deleteProps(obj) {
161        const object = obj;
162        Object.keys(object).forEach(key => {
163            try {
164                object[key] = null;
165            } catch (e) {
166                // no getter for object
167            }
168            try {
169                delete object[key];
170            } catch (e) {
171                // something got wrong
172            }
173        });
174    }
175    function nextTick(callback, delay) {
176        if (delay === void 0) {

177            delay = 0;
178        }
179        return setTimeout(callback, delay);
180    }
181    function now() {
182        return Date.now();
183    }
184    function getComputedStyle$1(el) {
185        const window = getWindow();
186        let style;
187        if (window.getComputedStyle) {
188            style = window.getComputedStyle(el, null);
189        }
190        if (!style && el.currentStyle) {
191            style = el.currentStyle;
192        }
193        if (!style) {
194            style = el.style;
195        }
196        return style;
197    }
198    function getTranslate(el, axis) {
199        if (axis === void 0) {
200            axis = 'x';
201        }
202        const window = getWindow();
203        let matrix;
204        let curTransform;
205        let transformMatrix;
206        const curStyle = getComputedStyle$1(el);
207        if (window.WebKitCSSMatrix) {
208            curTransform = curStyle.transform || curStyle.webkitTransform;
209            if (curTransform.split(',').length > 6) {
210                curTransform = curTransform.split(', ').map(a => a.replace(',', '.')).join(', ');
211            }
212            // Some old versions of Webkit choke when 'none' is passed; pass
213            // empty string instead in this case
214            transformMatrix = new window.WebKitCSSMatrix(curTransform === 'none' ? '' : curTransform);
215        } else {
216            transformMatrix = curStyle.MozTransform || curStyle.OTransform || curStyle.MsTransform || curStyle.msTransform || curStyle.transform || curStyle.getPropertyValue('transform').replace('translate(', 'matrix(1, 0, 0, 1,');
217            matrix = transformMatrix.toString().split(',');
218        }
219        if (axis === 'x') {
220            // Latest Chrome and webkits Fix
221            if (window.WebKitCSSMatrix) curTransform = transformMatrix.m41;
222            // Crazy IE10 Matrix
223            else if (matrix.length === 16) curTransform = parseFloat(matrix[12]);
224            // Normal Browsers
225            else curTransform = parseFloat(matrix[4]);
226        }
227        if (axis === 'y') {
228            // Latest Chrome and webkits Fix
229            if (window.WebKitCSSMatrix) curTransform = transformMatrix.m42;
230            // Crazy IE10 Matrix
231            else if (matrix.length === 16) curTransform = parseFloat(matrix[13]);
232            // Normal Browsers
233            else curTransform = parseFloat(matrix[5]);
234        }
235        return curTransform || 0;
236    }
237    function isObject(o) {
238        return typeof o === 'object' && o !== null && o.constructor && Object.prototype.toString.call(o).slice(8, -1) === 'Object';
239    }
240    function isNode(node) {
241        // eslint-disable-next-line
242        if (typeof window !== 'undefined' && typeof window.HTMLElement !== 'undefined') {
243            return node instanceof HTMLElement;
244        }
245        return node && (node.nodeType === 1 || node.nodeType === 11);
246    }
247    function extend() {
248        const to = Object(arguments.length <= 0 ? undefined : arguments[0]);
249        const noExtend = ['__proto__', 'constructor', 'prototype'];
250        for (let i = 1; i < arguments.length; i += 1) {
251            const nextSource = i < 0 || arguments.length <= i ? undefined : arguments[i];
252            if (nextSource !== undefined && nextSource !== null && !isNode(nextSource)) {
253                const keysArray = Object.keys(Object(nextSource)).filter(key => noExtend.indexOf(key) < 0);
254                for (let nextIndex = 0, len = keysArray.length; nextIndex < len; nextIndex += 1) {
255                    const nextKey = keysArray[nextIndex];
256                    const desc = Object.getOwnPropertyDescriptor(nextSource, nextKey);
257                    if (desc !== undefined && desc.enumerable) {
258                        if (isObject(to[nextKey]) && isObject(nextSource[nextKey])) {
259                            if (nextSource[nextKey].__swiper__) {
260                                to[nextKey] = nextSource[nextKey];
261                            } else {
262                                extend(to[nextKey], nextSource[nextKey]);
263                            }
264                        } else if (!isObject(to[nextKey]) && isObject(nextSource[nextKey])) {
265                            to[nextKey] = {};
266                            if (nextSource[nextKey].__swiper__) {
267                                to[nextKey] = nextSource[nextKey];
268                            } else {
269                                extend(to[nextKey], nextSource[nextKey]);
270                            }
271                        } else {
272                            to[nextKey] = nextSource[nextKey];
273                        }
274                    }
275                }
276            }
277        }
278        return to;
279    }
280    function setCSSProperty(el, varName, varValue) {
281        el.style.setProperty(varName, varValue);
282    }
283    function animateCSSModeScroll(_ref) {
284        let {
285            swiper,
286            targetPosition,
287            side
288        } = _ref;
289        const window = getWindow();
290        const startPosition = -swiper.translate;
291        let startTime = null;
292        let time;
293        const duration = swiper.params.speed;
294        swiper.wrapperEl.style.scrollSnapType = 'none';
295        window.cancelAnimationFrame(swiper.cssModeFrameID);
296        const dir = targetPosition > startPosition ? 'next' : 'prev';
297        const isOutOfBound = (current, target) => {
298            return dir === 'next' && current >= target || dir === 'prev' && current <= target;
299        };
300        const animate = () => {
301            time = new Date().getTime();
302            if (startTime === null) {
303                startTime = time;
304            }
305            const progress = Math.max(Math.min((time - startTime) / duration, 1), 0);
306            const easeProgress = 0.5 - Math.cos(progress * Math.PI) / 2;
307            let currentPosition = startPosition + easeProgress * (targetPosition - startPosition);
308            if (isOutOfBound(currentPosition, targetPosition)) {
309                currentPosition = targetPosition;
310            }
311            swiper.wrapperEl.scrollTo({
312                [side]: currentPosition
313            });
314            if (isOutOfBound(currentPosition, targetPosition)) {
315                swiper.wrapperEl.style.overflow = 'hidden';
316                swiper.wrapperEl.style.scrollSnapType = '';
317                setTimeout(() => {
318                    swiper.wrapperEl.style.overflow = '';
319                    swiper.wrapperEl.scrollTo({
320                        [side]: currentPosition
321                    });
322                });
323                window.cancelAnimationFrame(swiper.cssModeFrameID);
324                return;
325            }
326            swiper.cssModeFrameID = window.requestAnimationFrame(animate);
327        };
328        animate();
329    }
330    function getSlideTransformEl(slideEl) {
331        return slideEl.querySelector('.swiper-slide-transform') || slideEl.shadowRoot && slideEl.shadowRoot.querySelector('.swiper-slide-transform') || slideEl;
332    }
333    function elementChildren(element, selector) {
334        if (selector === void 0) {
335            selector = '';
336        }
337        return [...element.children].filter(el => el.matches(selector));
338    }
339    function createElement(tag, classes) {
340        if (classes === void 0) {
341            classes = [];
342        }
343        const el = document.createElement(tag);

344        el.classList.add(...(Array.isArray(classes) ? classes : [classes]));
345        return el;
346    }
347    function elementOffset(el) {
348        const window = getWindow();
349        const document = getDocument();
350        const box = el.getBoundingClientRect();
351        const body = document.body;
352        const clientTop = el.clientTop || body.clientTop || 0;
353        const clientLeft = el.clientLeft || body.clientLeft || 0;
354        const scrollTop = el === window ? window.scrollY : el.scrollTop;
355        const scrollLeft = el === window ? window.scrollX : el.scrollLeft;
356        return {
357            top: box.top + scrollTop - clientTop,
358            left: box.left + scrollLeft - clientLeft
359        };
360    }
361    function elementPrevAll(el, selector) {
362        const prevEls = [];
363        while (el.previousElementSibling) {
364            const prev = el.previousElementSibling; // eslint-disable-line
365            if (selector) {
366                if (prev.matches(selector)) prevEls.push(prev);
367            } else prevEls.push(prev);
368            el = prev;
369        }
370        return prevEls;
371    }
372    function elementNextAll(el, selector) {
373        const nextEls = [];
374        while (el.nextElementSibling) {
375            const next = el.nextElementSibling; // eslint-disable-line
376            if (selector) {
377                if (next.matches(selector)) nextEls.push(next);
378            } else nextEls.push(next);
379            el = next;
380        }
381        return nextEls;
382    }
383    function elementStyle(el, prop) {
384        const window = getWindow();
385        return window.getComputedStyle(el, null).getPropertyValue(prop);
386    }
387    function elementIndex(el) {
388        let child = el;
389        let i;
390        if (child) {
391            i = 0;
392            // eslint-disable-next-line
393            while ((child = child.previousSibling) !== null) {
394                if (child.nodeType === 1) i += 1;
395            }
396            return i;
397        }
398        return undefined;
399    }
400    function elementParents(el, selector) {
401        const parents = []; // eslint-disable-line
402        let parent = el.parentElement; // eslint-disable-line
403        while (parent) {
404            if (selector) {
405                if (parent.matches(selector)) parents.push(parent);
406            } else {
407                parents.push(parent);
408            }
409            parent = parent.parentElement;
410        }
411        return parents;
412    }
413    function elementTransitionEnd(el, callback) {
414        function fireCallBack(e) {
415            if (e.target !== el) return;
416            callback.call(el, e);
417            el.removeEventListener('transitionend', fireCallBack);
418        }
419        if (callback) {
420            el.addEventListener('transitionend', fireCallBack);
421        }
422    }
423    function elementOuterSize(el, size, includeMargins) {
424        const window = getWindow();
425        if (includeMargins) {
426            return el[size === 'width' ? 'offsetWidth' : 'offsetHeight'] + parseFloat(window.getComputedStyle(el, null).getPropertyValue(size === 'width' ? 'margin-right' : 'margin-top')) + parseFloat(window.getComputedStyle(el, null).getPropertyValue(size === 'width' ? 'margin-left' : 'margin-bottom'));
427        }
428        return el.offsetWidth;
429    }
430
431    let support;
432    function calcSupport() {
433        const window = getWindow();
434        const document = getDocument();
435        return {
436            smoothScroll: document.documentElement && document.documentElement.style && 'scrollBehavior' in document.documentElement.style,
437            touch: !!('ontouchstart' in window || window.DocumentTouch && document instanceof window.DocumentTouch)
438        };
439    }
440    function getSupport() {
441        if (!support) {
442            support = calcSupport();
443        }
444        return support;
445    }
446
447    let deviceCached;
448    function calcDevice(_temp) {
449        let {
450            userAgent
451        } = _temp === void 0 ? {} : _temp;

452        const support = getSupport();
453        const window = getWindow();
454        const platform = window.navigator.platform;
455        const ua = userAgent || window.navigator.userAgent;
456        const device = {
457            ios: false,
458            android: false
459        };
460        const screenWidth = window.screen.width;
461        const screenHeight = window.screen.height;
462        const android = ua.match(/(Android);?[\s\/]+([\d.]+)?/); // eslint-disable-line
463        let ipad = ua.match(/(iPad).*OS\s([\d_]+)/);
464        const ipod = ua.match(/(iPod)(.*OS\s([\d_]+))?/);
465        const iphone = !ipad && ua.match(/(iPhone\sOS|iOS)\s([\d_]+)/);
466        const windows = platform === 'Win32';
467        let macos = platform === 'MacIntel';
468
469        // iPadOs 13 fix
470        const iPadScreens = ['1024x1366', '1366x1024', '834x1194', '1194x834', '834x1112', '1112x834', '768x1024', '1024x768', '820x1180', '1180x820', '810x1080', '1080x810'];
471        if (!ipad && macos && support.touch && iPadScreens.indexOf(`${screenWidth}x${screenHeight}`) >= 0) {
472            ipad = ua.match(/(Version)\/([\d.]+)/);
473            if (!ipad) ipad = [0, 1, '13_0_0'];
474            macos = false;
475        }
476
477        // Android
478        if (android && !windows) {
479            device.os = 'android';
480            device.android = true;
481        }
482        if (ipad || iphone || ipod) {
483            device.os = 'ios';
484            device.ios = true;
485        }
486
487        // Export object
488        return device;
489    }
490    function getDevice(overrides) {
491        if (overrides === void 0) {
492            overrides = {};
493        }
494        if (!deviceCached) {
495            deviceCached = calcDevice(overrides);
496        }
497        return deviceCached;
498    }
499
500    let browser;
501    function calcBrowser() {
502        const window = getWindow();
503        let needPerspectiveFix = false;
504        function isSafari() {
505            const ua = window.navigator.userAgent.toLowerCase();
506            return ua.indexOf('safari') >= 0 && ua.indexOf('chrome') < 0 && ua.indexOf('android') < 0;
507        }
508        if (isSafari()) {
509            const ua = String(window.navigator.userAgent);
510            if (ua.includes('Version/')) {
511                const [major, minor] = ua.split('Version/')[1].split(' ')[0].split('.').map(num => Number(num));
512                needPerspectiveFix = major < 16 || major === 16 && minor < 2;
513            }
514        }
515        return {
516            isSafari: needPerspectiveFix || isSafari(),
517            needPerspectiveFix,
518            isWebView: /(iPhone|iPod|iPad).*AppleWebKit(?!.*Safari)/i.test(window.navigator.userAgent)
519        };
520    }
521    function getBrowser() {
522        if (!browser) {
523            browser = calcBrowser();
524        }
525        return browser;
526    }
527
528    function Resize(_ref) {
529        let {
530            swiper,
531            on,
532            emit
533        } = _ref;
534        const window = getWindow();
535        let observer = null;
536        let animationFrame = null;
537        const resizeHandler = () => {
538            if (!swiper || swiper.destroyed || !swiper.initialized) return;
539            emit('beforeResize');
540            emit('resize');
541        };
542        const createObserver = () => {
543            if (!swiper || swiper.destroyed || !swiper.initialized) return;
544            observer = new ResizeObserver(entries => {
545                animationFrame = window.requestAnimationFrame(() => {
546                    const {
547                        width,
548                        height
549                    } = swiper;
550                    let newWidth = width;
551                    let newHeight = height;
552                    entries.forEach(_ref2 => {
553                        let {
554                            contentBoxSize,
555                            contentRect,
556                            target
557                        } = _ref2;
558                        if (target && target !== swiper.el) return;
559                        newWidth = contentRect ? contentRect.width : (contentBoxSize[0] || contentBoxSize).inlineSize;
560                        newHeight = contentRect ? contentRect.height : (contentBoxSize[0] || contentBoxSize).blockSize;
561                    });
562                    if (newWidth !== width || newHeight !== height) {
563                        resizeHandler();
564                    }
565                });
566            });
567            observer.observe(swiper.el);
568        };
569        const removeObserver = () => {
570            if (animationFrame) {
571                window.cancelAnimationFrame(animationFrame);
572            }
573            if (observer && observer.unobserve && swiper.el) {
574                observer.unobserve(swiper.el);
575                observer = null;
576            }
577        };
578        const orientationChangeHandler = () => {
579            if (!swiper || swiper.destroyed || !swiper.initialized) return;
580            emit('orientationchange');
581        };
582        on('init', () => {
583            if (swiper.params.resizeObserver && typeof window.ResizeObserver !== 'undefined') {
584                createObserver();
585                return;
586            }
587            window.addEventListener('resize', resizeHandler);
588            window.addEventListener('orientationchange', orientationChangeHandler);
589        });
590        on('destroy', () => {
591            removeObserver();
592            window.removeEventListener('resize', resizeHandler);
593            window.removeEventListener('orientationchange', orientationChangeHandler);
594        });
595    }
596
597    function Observer(_ref) {
598        let {
599            swiper,
600            extendParams,
601            on,
602            emit
603        } = _ref;
604        const observers = [];
605        const window = getWindow();
606        const attach = function (target, options) {
607            if (options === void 0) {
608                options = {};
609            }
610            const ObserverFunc = window.MutationObserver || window.WebkitMutationObserver;
611            const observer = new ObserverFunc(mutations => {
612                // The observerUpdate event should only be triggered
613                // once despite the number of mutations.  Additional
614                // triggers are redundant and are very costly
615                if (swiper.__preventObserver__) return;
616                if (mutations.length === 1) {
617                    emit('observerUpdate', mutations[0]);
618                    return;
619                }
620                const observerUpdate = function observerUpdate() {
621                    emit('observerUpdate', mutations[0]);
622                };
623                if (window.requestAnimationFrame) {
624                    window.requestAnimationFrame(observerUpdate);
625                } else {
626                    window.setTimeout(observerUpdate, 0);
627                }
628            });
629            observer.observe(target, {
630                attributes: typeof options.attributes === 'undefined' ? true : options.attributes,
631                childList: typeof options.childList === 'undefined' ? true : options.childList,
632                characterData: typeof options.characterData === 'undefined' ? true : options.characterData
633            });
634            observers.push(observer);
635        };
636        const init = () => {
637            if (!swiper.params.observer) return;
638            if (swiper.params.observeParents) {
639                const containerParents = elementParents(swiper.hostEl);
640                for (let i = 0; i < containerParents.length; i += 1) {
641                    attach(containerParents[i]);
642                }
643            }
644            // Observe container
645            attach(swiper.hostEl, {
646                childList: swiper.params.observeSlideChildren
647            });
648
649            // Observe wrapper
650            attach(swiper.wrapperEl, {
651                attributes: false
652            });
653        };
654        const destroy = () => {
655            observers.forEach(observer => {
656                observer.disconnect();
657            });
658            observers.splice(0, observers.length);
659        };
660        extendParams({
661            observer: false,
662            observeParents: false,
663            observeSlideChildren: false
664        });
665        on('init', init);
666        on('destroy', destroy);
667    }
668
669    /* eslint-disable no-underscore-dangle */
670
671    var eventsEmitter = {
672        on(events, handler, priority) {
673            const self = this;
674            if (!self.eventsListeners || self.destroyed) return self;
675            if (typeof handler !== 'function') return self;
676            const method = priority ? 'unshift' : 'push';
677            events.split(' ').forEach(event => {
678                if (!self.eventsListeners[event]) self.eventsListeners[event] = [];
679                self.eventsListeners[event][method](handler);
680            });
681            return self;
682        },
683        once(events, handler, priority) {
684            const self = this;
685            if (!self.eventsListeners || self.destroyed) return self;
686            if (typeof handler !== 'function') return self;
687            function onceHandler() {
688                self.off(events, onceHandler);
689                if (onceHandler.__emitterProxy) {
690                    delete onceHandler.__emitterProxy;
691                }
692                for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
693                    args[_key] = arguments[_key];
694                }
695                handler.apply(self, args);
696            }
697            onceHandler.__emitterProxy = handler;
698            return self.on(events, onceHandler, priority);
699        },
700        onAny(handler, priority) {
701            const self = this;
702            if (!self.eventsListeners || self.destroyed) return self;
703            if (typeof handler !== 'function') return self;
704            const method = priority ? 'unshift' : 'push';
705            if (self.eventsAnyListeners.indexOf(handler) < 0) {
706                self.eventsAnyListeners[method](handler);
707            }
708            return self;
709        },
710        offAny(handler) {
711            const self = this;
712            if (!self.eventsListeners || self.destroyed) return self;
713            if (!self.eventsAnyListeners) return self;
714            const index = self.eventsAnyListeners.indexOf(handler);
715            if (index >= 0) {
716                self.eventsAnyListeners.splice(index, 1);
717            }
718            return self;
719        },
720        off(events, handler) {
721            const self = this;
722            if (!self.eventsListeners || self.destroyed) return self;
723            if (!self.eventsListeners) return self;
724            events.split(' ').forEach(event => {
725                if (typeof handler === 'undefined') {
726                    self.eventsListeners[event] = [];
727                } else if (self.eventsListeners[event]) {
728                    self.eventsListeners[event].forEach((eventHandler, index) => {
729                        if (eventHandler === handler || eventHandler.__emitterProxy && eventHandler.__emitterProxy === handler) {
730                            self.eventsListeners[event].splice(index, 1);
731                        }
732                    });
733                }
734            });
735            return self;
736        },
737        emit() {
738            const self = this;
739            if (!self.eventsListeners || self.destroyed) return self;
740            if (!self.eventsListeners) return self;
741            let events;
742            let data;
743            let context;
744            for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
745                args[_key2] = arguments[_key2];
746            }
747            if (typeof args[0] === 'string' || Array.isArray(args[0])) {
748                events = args[0];
749                data = args.slice(1, args.length);
750                context = self;
751            } else {
752                events = args[0].events;
753                data = args[0].data;
754                context = args[0].context || self;
755            }
756            data.unshift(context);
757            const eventsArray = Array.isArray(events) ? events : events.split(' ');
758            eventsArray.forEach(event => {
759                if (self.eventsAnyListeners && self.eventsAnyListeners.length) {

760                    self.eventsAnyListeners.forEach(eventHandler => {
761                        eventHandler.apply(context, [event, ...data]);
762                    });
763                }
764                if (self.eventsListeners && self.eventsListeners[event]) {
765                    self.eventsListeners[event].forEach(eventHandler => {
766                        eventHandler.apply(context, data);
767                    });
768                }
769            });
770            return self;
771        }
772    };
773
774    function updateSize() {
775        const swiper = this;
776        let width;
777        let height;
778        const el = swiper.el;
779        if (typeof swiper.params.width !== 'undefined' && swiper.params.width !== null) {
780            width = swiper.params.width;
781        } else {
782            width = el.clientWidth;
783        }
784        if (typeof swiper.params.height !== 'undefined' && swiper.params.height !== null) {
785            height = swiper.params.height;
786        } else {
787            height = el.clientHeight;
788        }
789        if (width === 0 && swiper.isHorizontal() || height === 0 && swiper.isVertical()) {
790            return;
791        }
792
793        // Subtract paddings
794        width = width - parseInt(elementStyle(el, 'padding-left') || 0, 10) - parseInt(elementStyle(el, 'padding-right') || 0, 10);
795        height = height - parseInt(elementStyle(el, 'padding-top') || 0, 10) - parseInt(elementStyle(el, 'padding-bottom') || 0, 10);
796        if (Number.isNaN(width)) width = 0;
797        if (Number.isNaN(height)) height = 0;
798        Object.assign(swiper, {
799            width,
800            height,
801            size: swiper.isHorizontal() ? width : height
802        });
803    }
804
805    function updateSlides() {
806        const swiper = this;
807        function getDirectionLabel(property) {
808            if (swiper.isHorizontal()) {
809                return property;
810            }
811            // prettier-ignore
812            return {
813                'width': 'height',
814                'margin-top': 'margin-left',
815                'margin-bottom ': 'margin-right',
816                'margin-left': 'margin-top',
817                'margin-right': 'margin-bottom',
818                'padding-left': 'padding-top',
819                'padding-right': 'padding-bottom',
820                'marginRight': 'marginBottom'
821            }[property];
822        }
823        function getDirectionPropertyValue(node, label) {
824            return parseFloat(node.getPropertyValue(getDirectionLabel(label)) || 0);
825        }
826        const params = swiper.params;
827        const {
828            wrapperEl,
829            slidesEl,
830            size: swiperSize,
831            rtlTranslate: rtl,
832            wrongRTL
833        } = swiper;
834        const isVirtual = swiper.virtual && params.virtual.enabled;
835        const previousSlidesLength = isVirtual ? swiper.virtual.slides.length : swiper.slides.length;
836        const slides = elementChildren(slidesEl, `.${swiper.params.slideClass}, swiper-slide`);
837        const slidesLength = isVirtual ? swiper.virtual.slides.length : slides.length;
838        let snapGrid = [];
839        const slidesGrid = [];
840        const slidesSizesGrid = [];
841        let offsetBefore = params.slidesOffsetBefore;
842        if (typeof offsetBefore === 'function') {
843            offsetBefore = params.slidesOffsetBefore.call(swiper);
844        }
845        let offsetAfter = params.slidesOffsetAfter;
846        if (typeof offsetAfter === 'function') {
847            offsetAfter = params.slidesOffsetAfter.call(swiper);
848        }
849        const previousSnapGridLength = swiper.snapGrid.length;
850        const previousSlidesGridLength = swiper.slidesGrid.length;
851        let spaceBetween = params.spaceBetween;
852        let slidePosition = -offsetBefore;
853        let prevSlideSize = 0;
854        let index = 0;
855        if (typeof swiperSize === 'undefined') {
856            return;
857        }
858        if (typeof spaceBetween === 'string' && spaceBetween.indexOf('%') >= 0) {
859            spaceBetween = parseFloat(spaceBetween.replace('%', '')) / 100 * swiperSize;
860        } else if (typeof spaceBetween === 'string') {
861            spaceBetween = parseFloat(spaceBetween);
862        }
863        swiper.virtualSize = -spaceBetween;
864
865        // reset margins
866        slides.forEach(slideEl => {
867            if (rtl) {
868                slideEl.style.marginLeft = '';
869            } else {
870                slideEl.style.marginRight = '';
871            }
872            slideEl.style.marginBottom = '';
873            slideEl.style.marginTop = '';
874        });
875
876        // reset cssMode offsets
877        if (params.centeredSlides && params.cssMode) {
878            setCSSProperty(wrapperEl, '--swiper-centered-offset-before', '');
879            setCSSProperty(wrapperEl, '--swiper-centered-offset-after', '');
880        }
881        const gridEnabled = params.grid && params.grid.rows > 1 && swiper.grid;
882        if (gridEnabled) {
883            swiper.grid.initSlides(slidesLength);
884        }
885
886        // Calc slides
887        let slideSize;
888        const shouldResetSlideSize = params.slidesPerView === 'auto' && params.breakpoints && Object.keys(params.breakpoints).filter(key => {
889            return typeof params.breakpoints[key].slidesPerView !== 'undefined';
890        }).length > 0;
891        for (let i = 0; i < slidesLength; i += 1) {
892            slideSize = 0;
893            let slide;
894            if (slides[i]) slide = slides[i];
895            if (gridEnabled) {
896                swiper.grid.updateSlide(i, slide, slidesLength, getDirectionLabel);
897            }
898            if (slides[i] && elementStyle(slide, 'display') === 'none') continue; // eslint-disable-line
899
900            if (params.slidesPerView === 'auto') {
901                if (shouldResetSlideSize) {
902                    slides[i].style[getDirectionLabel('width')] = ``;
903                }
904                const slideStyles = getComputedStyle(slide);
905                const currentTransform = slide.style.transform;
906                const currentWebKitTransform = slide.style.webkitTransform;
907                if (currentTransform) {
908                    slide.style.transform = 'none';
909                }
910                if (currentWebKitTransform) {
911                    slide.style.webkitTransform = 'none';
912                }
913                if (params.roundLengths) {
914                    slideSize = swiper.isHorizontal() ? elementOuterSize(slide, 'width', true) : elementOuterSize(slide, 'height', true);
915                } else {
916                    // eslint-disable-next-line
917                    const width = getDirectionPropertyValue(slideStyles, 'width');
918                    const paddingLeft = getDirectionPropertyValue(slideStyles, 'padding-left');
919                    const paddingRight = getDirectionPropertyValue(slideStyles, 'padding-right');
920                    const marginLeft = getDirectionPropertyValue(slideStyles, 'margin-left');
921                    const marginRight = getDirectionPropertyValue(slideStyles, 'margin-right');
922                    const boxSizing = slideStyles.getPropertyValue('box-sizing');
923                    if (boxSizing && boxSizing === 'border-box') {
924                        slideSize = width + marginLeft + marginRight;
925                    } else {
926                        const {
927                            clientWidth,
928                            offsetWidth
929                        } = slide;
930                        slideSize = width + paddingLeft + paddingRight + marginLeft + marginRight + (offsetWidth - clientWidth);
931                    }
932                }
933                if (currentTransform) {
934                    slide.style.transform = currentTransform;
935                }
936                if (currentWebKitTransform) {
937                    slide.style.webkitTransform = currentWebKitTransform;
938                }
939                if (params.roundLengths) slideSize = Math.floor(slideSize);
940            } else {
941                slideSize = (swiperSize - (params.slidesPerView - 1) * spaceBetween) / params.slidesPerView;
942                if (params.roundLengths) slideSize = Math.floor(slideSize);
943                if (slides[i]) {
944                    slides[i].style[getDirectionLabel('width')] = `${slideSize}px`;
945                }
946            }
947            if (slides[i]) {
948                slides[i].swiperSlideSize = slideSize;
949            }
950            slidesSizesGrid.push(slideSize);
951            if (params.centeredSlides) {
952                slidePosition = slidePosition + slideSize / 2 + prevSlideSize / 2 + spaceBetween;
953                if (prevSlideSize === 0 && i !== 0) slidePosition = slidePosition - swiperSize / 2 - spaceBetween;
954                if (i === 0) slidePosition = slidePosition - swiperSize / 2 - spaceBetween;
955                if (Math.abs(slidePosition) < 1 / 1000) slidePosition = 0;
956                if (params.roundLengths) slidePosition = Math.floor(slidePosition);
957                if (index % params.slidesPerGroup === 0) snapGrid.push(slidePosition);
958                slidesGrid.push(slidePosition);
959            } else {
960                if (params.roundLengths) slidePosition = Math.floor(slidePosition);
961                if ((index - Math.min(swiper.params.slidesPerGroupSkip, index)) % swiper.params.slidesPerGroup === 0) snapGrid.push(slidePosition);
962                slidesGrid.push(slidePosition);
963                slidePosition = slidePosition + slideSize + spaceBetween;
964            }
965            swiper.virtualSize += slideSize + spaceBetween;
966            prevSlideSize = slideSize;
967            index += 1;
968        }
969        swiper.virtualSize = Math.max(swiper.virtualSize, swiperSize) + offsetAfter;
970        if (rtl && wrongRTL && (params.effect === 'slide' || params.effect === 'coverflow')) {
971            wrapperEl.style.width = `${swiper.virtualSize + spaceBetween}px`;
972        }
973        if (params.setWrapperSize) {
974            wrapperEl.style[getDirectionLabel('width')] = `${swiper.virtualSize + spaceBetween}px`;
975        }
976        if (gridEnabled) {
977            swiper.grid.updateWrapperSize(slideSize, snapGrid, getDirectionLabel);
978        }
979
980        // Remove last grid elements depending on width
981        if (!params.centeredSlides) {
982            const newSlidesGrid = [];
983            for (let i = 0; i < snapGrid.length; i += 1) {
984                let slidesGridItem = snapGrid[i];
985                if (params.roundLengths) slidesGridItem = Math.floor(slidesGridItem);
986                if (snapGrid[i] <= swiper.virtualSize - swiperSize) {
987                    newSlidesGrid.push(slidesGridItem);
988                }
989            }
990            snapGrid = newSlidesGrid;
991            if (Math.floor(swiper.virtualSize - swiperSize) - Math.floor(snapGrid[snapGrid.length - 1]) > 1) {
992                snapGrid.push(swiper.virtualSize - swiperSize);
993            }
994        }
995        if (isVirtual && params.loop) {
996            const size = slidesSizesGrid[0] + spaceBetween;
997            if (params.slidesPerGroup > 1) {
998                const groups = Math.ceil((swiper.virtual.slidesBefore + swiper.virtual.slidesAfter) / params.slidesPerGroup);
999                const groupSize = size * params.slidesPerGroup;
1000                for (let i = 0; i < groups; i += 1) {
1001                    snapGrid.push(snapGrid[snapGrid.length - 1] + groupSize);
1002                }
1003            }
1004            for (let i = 0; i < swiper.virtual.slidesBefore + swiper.virtual.slidesAfter; i += 1) {
1005                if (params.slidesPerGroup === 1) {
1006                    snapGrid.push(snapGrid[snapGrid.length - 1] + size);
1007                }
1008                slidesGrid.push(slidesGrid[slidesGrid.length - 1] + size);
1009                swiper.virtualSize += size;
1010            }
1011        }
1012        if (snapGrid.length === 0) snapGrid = [0];
1013        if (spaceBetween !== 0) {
1014            const key = swiper.isHorizontal() && rtl ? 'marginLeft' : getDirectionLabel('marginRight');
1015            slides.filter((_, slideIndex) => {
1016                if (!params.cssMode || params.loop) return true;
1017                if (slideIndex === slides.length - 1) {
1018                    return false;
1019                }
1020                return true;
1021            }).forEach(slideEl => {
1022                slideEl.style[key] = `${spaceBetween}px`;
1023            });
1024        }
1025        if (params.centeredSlides && params.centeredSlidesBounds) {
1026            let allSlidesSize = 0;
1027            slidesSizesGrid.forEach(slideSizeValue => {
1028                allSlidesSize += slideSizeValue + (spaceBetween || 0);
1029            });
1030            allSlidesSize -= spaceBetween;
1031            const maxSnap = allSlidesSize - swiperSize;
1032            snapGrid = snapGrid.map(snap => {
1033                if (snap <= 0) return -offsetBefore;
1034                if (snap > maxSnap) return maxSnap + offsetAfter;
1035                return snap;
1036            });
1037        }
1038        if (params.centerInsufficientSlides) {
1039            let allSlidesSize = 0;
1040            slidesSizesGrid.forEach(slideSizeValue => {
1041                allSlidesSize += slideSizeValue + (spaceBetween || 0);
1042            });
1043            allSlidesSize -= spaceBetween;
1044            if (allSlidesSize < swiperSize) {
1045                const allSlidesOffset = (swiperSize - allSlidesSize) / 2;
1046                snapGrid.forEach((snap, snapIndex) => {
1047                    snapGrid[snapIndex] = snap - allSlidesOffset;
1048                });
1049                slidesGrid.forEach((snap, snapIndex) => {
1050                    slidesGrid[snapIndex] = snap + allSlidesOffset;
1051                });
1052            }
1053        }
1054        Object.assign(swiper, {
1055            slides,
1056            snapGrid,
1057            slidesGrid,
1058            slidesSizesGrid
1059        });
1060        if (params.centeredSlides && params.cssMode && !params.centeredSlidesBounds) {
1061            setCSSProperty(wrapperEl, '--swiper-centered-offset-before', `${-snapGrid[0]}px`);
1062            setCSSProperty(wrapperEl, '--swiper-centered-offset-after', `${swiper.size / 2 - slidesSizesGrid[slidesSizesGrid.length - 1] / 2}px`);
1063            const addToSnapGrid = -swiper.snapGrid[0];
1064            const addToSlidesGrid = -swiper.slidesGrid[0];
1065            swiper.snapGrid = swiper.snapGrid.map(v => v + addToSnapGrid);
1066            swiper.slidesGrid = swiper.slidesGrid.map(v => v + addToSlidesGrid);
1067        }
1068        if (slidesLength !== previousSlidesLength) {
1069            swiper.emit('slidesLengthChange');
1070        }
1071        if (snapGrid.length !== previousSnapGridLength) {
1072            if (swiper.params.watchOverflow) swiper.checkOverflow();
1073            swiper.emit('snapGridLengthChange');
1074        }
1075        if (slidesGrid.length !== previousSlidesGridLength) {
1076            swiper.emit('slidesGridLengthChange');
1077        }
1078        if (params.watchSlidesProgress) {
1079            swiper.updateSlidesOffset();
1080        }
1081        if (!isVirtual && !params.cssMode && (params.effect === 'slide' || params.effect === 'fade')) {
1082            const backFaceHiddenClass = `${params.containerModifierClass}backface-hidden`;
1083            const hasClassBackfaceClassAdded = swiper.el.classList.contains(backFaceHiddenClass);
1084            if (slidesLength <= params.maxBackfaceHiddenSlides) {
1085                if (!hasClassBackfaceClassAdded) swiper.el.classList.add(backFaceHiddenClass);
1086            } else if (hasClassBackfaceClassAdded) {
1087                swiper.el.classList.remove(backFaceHiddenClass);
1088            }
1089        }
1090    }
1091
1092    function updateAutoHeight(speed) {
1093        const swiper = this;
1094        const activeSlides = [];
1095        const isVirtual = swiper.virtual && swiper.params.virtual.enabled;
1096        let newHeight = 0;
1097        let i;
1098        if (typeof speed === 'number') {
1099            swiper.setTransition(speed);
1100        } else if (speed === true) {
1101            swiper.setTransition(swiper.params.speed);
1102        }
1103        const getSlideByIndex = index => {
1104            if (isVirtual) {
1105                return swiper.slides[swiper.getSlideIndexByData(index)];
1106            }
1107            return swiper.slides[index];
1108        };
1109        // Find slides currently in view
1110        if (swiper.params.slidesPerView !== 'auto' && swiper.params.slidesPerView > 1) {
1111            if (swiper.params.centeredSlides) {

1112                (swiper.visibleSlides || []).forEach(slide => {
1113                    activeSlides.push(slide);
1114                });
1115            } else {
1116                for (i = 0; i < Math.ceil(swiper.params.slidesPerView); i += 1) {
1117                    const index = swiper.activeIndex + i;
1118                    if (index > swiper.slides.length && !isVirtual) break;
1119                    activeSlides.push(getSlideByIndex(index));
1120                }
1121            }
1122        } else {
1123            activeSlides.push(getSlideByIndex(swiper.activeIndex));
1124        }
1125
1126        // Find new height from highest slide in view
1127        for (i = 0; i < activeSlides.length; i += 1) {
1128            if (typeof activeSlides[i] !== 'undefined') {
1129                const height = activeSlides[i].offsetHeight;
1130                newHeight = height > newHeight ? height : newHeight;
1131            }
1132        }
1133
1134        // Update Height
1135        if (newHeight || newHeight === 0) swiper.wrapperEl.style.height = `${newHeight}px`;
1136    }
1137
1138    function updateSlidesOffset() {
1139        const swiper = this;
1140        const slides = swiper.slides;
1141        // eslint-disable-next-line
1142        const minusOffset = swiper.isElement ? swiper.isHorizontal() ? swiper.wrapperEl.offsetLeft : swiper.wrapperEl.offsetTop : 0;
1143        for (let i = 0; i < slides.length; i += 1) {
1144            slides[i].swiperSlideOffset = (swiper.isHorizontal() ? slides[i].offsetLeft : slides[i].offsetTop) - minusOffset - swiper.cssOverflowAdjustment();
1145        }
1146    }
1147
1148    function updateSlidesProgress(translate) {
1149        if (translate === void 0) {
1150            translate = this && this.translate || 0;
1151        }
1152        const swiper = this;
1153        const params = swiper.params;
1154        const {
1155            slides,
1156            rtlTranslate: rtl,
1157            snapGrid
1158        } = swiper;
1159        if (slides.length === 0) return;
1160        if (typeof slides[0].swiperSlideOffset === 'undefined') swiper.updateSlidesOffset();
1161        let offsetCenter = -translate;
1162        if (rtl) offsetCenter = translate;
1163
1164        // Visible Slides

1165        slides.forEach(slideEl => {
1166            slideEl.classList.remove(params.slideVisibleClass);
1167        });
1168        swiper.visibleSlidesIndexes = [];
1169        swiper.visibleSlides = [];
1170        let spaceBetween = params.spaceBetween;
1171        if (typeof spaceBetween === 'string' && spaceBetween.indexOf('%') >= 0) {
1172            spaceBetween = parseFloat(spaceBetween.replace('%', '')) / 100 * swiper.size;
1173        } else if (typeof spaceBetween === 'string') {
1174            spaceBetween = parseFloat(spaceBetween);
1175        }
1176        for (let i = 0; i < slides.length; i += 1) {
1177            const slide = slides[i];
1178            let slideOffset = slide.swiperSlideOffset;
1179            if (params.cssMode && params.centeredSlides) {
1180                slideOffset -= slides[0].swiperSlideOffset;
1181            }
1182            const slideProgress = (offsetCenter + (params.centeredSlides ? swiper.minTranslate() : 0) - slideOffset) / (slide.swiperSlideSize + spaceBetween);
1183            const originalSlideProgress = (offsetCenter - snapGrid[0] + (params.centeredSlides ? swiper.minTranslate() : 0) - slideOffset) / (slide.swiperSlideSize + spaceBetween);
1184            const slideBefore = -(offsetCenter - slideOffset);
1185            const slideAfter = slideBefore + swiper.slidesSizesGrid[i];
1186            const isVisible = slideBefore >= 0 && slideBefore < swiper.size - 1 || slideAfter > 1 && slideAfter <= swiper.size || slideBefore <= 0 && slideAfter >= swiper.size;
1187            if (isVisible) {
1188                swiper.visibleSlides.push(slide);
1189                swiper.visibleSlidesIndexes.push(i);
1190                slides[i].classList.add(params.slideVisibleClass);
1191            }
1192            slide.progress = rtl ? -slideProgress : slideProgress;
1193            slide.originalProgress = rtl ? -originalSlideProgress : originalSlideProgress;
1194        }
1195    }
1196
1197    function updateProgress(translate) {
1198        const swiper = this;
1199        if (typeof translate === 'undefined') {
1200            const multiplier = swiper.rtlTranslate ? -1 : 1;
1201            // eslint-disable-next-line
1202            translate = swiper && swiper.translate && swiper.translate * multiplier || 0;
1203        }
1204        const params = swiper.params;
1205        const translatesDiff = swiper.maxTranslate() - swiper.minTranslate();
1206        let {
1207            progress,
1208            isBeginning,
1209            isEnd,
1210            progressLoop
1211        } = swiper;
1212        const wasBeginning = isBeginning;
1213        const wasEnd = isEnd;
1214        if (translatesDiff === 0) {
1215            progress = 0;
1216            isBeginning = true;
1217            isEnd = true;
1218        } else {
1219            progress = (translate - swiper.minTranslate()) / translatesDiff;
1220            const isBeginningRounded = Math.abs(translate - swiper.minTranslate()) < 1;
1221            const isEndRounded = Math.abs(translate - swiper.maxTranslate()) < 1;
1222            isBeginning = isBeginningRounded || progress <= 0;
1223            isEnd = isEndRounded || progress >= 1;
1224            if (isBeginningRounded) progress = 0;
1225            if (isEndRounded) progress = 1;
1226        }
1227        if (params.loop) {
1228            const firstSlideIndex = swiper.getSlideIndexByData(0);
1229            const lastSlideIndex = swiper.getSlideIndexByData(swiper.slides.length - 1);
1230            const firstSlideTranslate = swiper.slidesGrid[firstSlideIndex];
1231            const lastSlideTranslate = swiper.slidesGrid[lastSlideIndex];
1232            const translateMax = swiper.slidesGrid[swiper.slidesGrid.length - 1];
1233            const translateAbs = Math.abs(translate);
1234            if (translateAbs >= firstSlideTranslate) {
1235                progressLoop = (translateAbs - firstSlideTranslate) / translateMax;
1236            } else {
1237                progressLoop = (translateAbs + translateMax - lastSlideTranslate) / translateMax;
1238            }
1239            if (progressLoop > 1) progressLoop -= 1;
1240        }
1241        Object.assign(swiper, {
1242            progress,
1243            progressLoop,
1244            isBeginning,
1245            isEnd
1246        });
1247        if (params.watchSlidesProgress || params.centeredSlides && params.autoHeight) swiper.updateSlidesProgress(translate);
1248        if (isBeginning && !wasBeginning) {
1249            swiper.emit('reachBeginning toEdge');
1250        }
1251        if (isEnd && !wasEnd) {
1252            swiper.emit('reachEnd toEdge');
1253        }
1254        if (wasBeginning && !isBeginning || wasEnd && !isEnd) {
1255            swiper.emit('fromEdge');
1256        }
1257        swiper.emit('progress', progress);
1258    }
1259
1260    function updateSlidesClasses() {
1261        const swiper = this;
1262        const {
1263            slides,
1264            params,
1265            slidesEl,
1266            activeIndex
1267        } = swiper;
1268        const isVirtual = swiper.virtual && params.virtual.enabled;
1269        const getFilteredSlide = selector => {
1270            return elementChildren(slidesEl, `.${params.slideClass}${selector}, swiper-slide${selector}`)[0];
1271        };
1272        slides.forEach(slideEl => {
1273            slideEl.classList.remove(params.slideActiveClass, params.slideNextClass, params.slidePrevClass);
1274        });
1275        let activeSlide;
1276        if (isVirtual) {
1277            if (params.loop) {
1278                let slideIndex = activeIndex - swiper.virtual.slidesBefore;
1279                if (slideIndex < 0) slideIndex = swiper.virtual.slides.length + slideIndex;
1280                if (slideIndex >= swiper.virtual.slides.length) slideIndex -= swiper.virtual.slides.length;
1281                activeSlide = getFilteredSlide(`[data-swiper-slide-index="${slideIndex}"]`);
1282            } else {
1283                activeSlide = getFilteredSlide(`[data-swiper-slide-index="${activeIndex}"]`);
1284            }
1285        } else {
1286            activeSlide = slides[activeIndex];
1287        }
1288        if (activeSlide) {
1289            // Active classes
1290            activeSlide.classList.add(params.slideActiveClass);
1291
1292            // Next Slide
1293            let nextSlide = elementNextAll(activeSlide, `.${params.slideClass}, swiper-slide`)[0];
1294            if (params.loop && !nextSlide) {
1295                nextSlide = slides[0];
1296            }
1297            if (nextSlide) {
1298                nextSlide.classList.add(params.slideNextClass);
1299            }
1300            // Prev Slide
1301            let prevSlide = elementPrevAll(activeSlide, `.${params.slideClass}, swiper-slide`)[0];
1302            if (params.loop && !prevSlide === 0) {
1303                prevSlide = slides[slides.length - 1];
1304            }
1305            if (prevSlide) {
1306                prevSlide.classList.add(params.slidePrevClass);
1307            }
1308        }
1309        swiper.emitSlidesClasses();
1310    }
1311
1312    const processLazyPreloader = (swiper, imageEl) => {
1313        if (!swiper || swiper.destroyed || !swiper.params) return;
1314        const slideSelector = () => swiper.isElement ? `swiper-slide` : `.${swiper.params.slideClass}`;
1315        const slideEl = imageEl.closest(slideSelector());
1316        if (slideEl) {
1317            let lazyEl = slideEl.querySelector(`.${swiper.params.lazyPreloaderClass}`);
1318            if (!lazyEl && swiper.isElement) {
1319                if (slideEl.shadowRoot) {
1320                    lazyEl = slideEl.shadowRoot.querySelector(`.${swiper.params.lazyPreloaderClass}`);
1321                } else {
1322                    // init later
1323                    requestAnimationFrame(() => {
1324                        if (slideEl.shadowRoot) {
1325                            lazyEl = slideEl.shadowRoot.querySelector(`.${swiper.params.lazyPreloaderClass}`);
1326                            if (lazyEl) lazyEl.remove();
1327                        }
1328                    });
1329                }
1330            }
1331            if (lazyEl) lazyEl.remove();
1332        }
1333    };
1334    const unlazy = (swiper, index) => {
1335        if (!swiper.slides[index]) return;
1336        const imageEl = swiper.slides[index].querySelector('[loading="lazy"]');
1337        if (imageEl) imageEl.removeAttribute('loading');
1338    };
1339    const preload = swiper => {
1340        if (!swiper || swiper.destroyed || !swiper.params) return;
1341        let amount = swiper.params.lazyPreloadPrevNext;
1342        const len = swiper.slides.length;
1343        if (!len || !amount || amount < 0) return;
1344        amount = Math.min(amount, len);
1345        const slidesPerView = swiper.params.slidesPerView === 'auto' ? swiper.slidesPerViewDynamic() : Math.ceil(swiper.params.slidesPerView);
1346        const activeIndex = swiper.activeIndex;
1347        if (swiper.params.grid && swiper.params.grid.rows > 1) {
1348            const activeColumn = activeIndex;
1349            const preloadColumns = [activeColumn - amount];
1350            preloadColumns.push(...Array.from({
1351                length: amount
1352            }).map((_, i) => {
1353                return activeColumn + slidesPerView + i;
1354            }));
1355            swiper.slides.forEach((slideEl, i) => {
1356                if (preloadColumns.includes(slideEl.column)) unlazy(swiper, i);
1357            });
1358            return;
1359        }
1360        const slideIndexLastInView = activeIndex + slidesPerView - 1;
1361        if (swiper.params.rewind || swiper.params.loop) {
1362            for (let i = activeIndex - amount; i <= slideIndexLastInView + amount; i += 1) {
1363                const realIndex = (i % len + len) % len;
1364                if (realIndex < activeIndex || realIndex > slideIndexLastInView) unlazy(swiper, realIndex);
1365            }
1366        } else {
1367            for (let i = Math.max(activeIndex - amount, 0); i <= Math.min(slideIndexLastInView + amount, len - 1); i += 1) {
1368                if (i !== activeIndex && (i > slideIndexLastInView || i < activeIndex)) {
1369                    unlazy(swiper, i);
1370                }
1371            }
1372        }
1373    };
1374
1375    function getActiveIndexByTranslate(swiper) {
1376        const {
1377            slidesGrid,
1378            params
1379        } = swiper;
1380        const translate = swiper.rtlTranslate ? swiper.translate : -swiper.translate;
1381        let activeIndex;
1382        for (let i = 0; i < slidesGrid.length; i += 1) {
1383            if (typeof slidesGrid[i + 1] !== 'undefined') {
1384                if (translate >= slidesGrid[i] && translate < slidesGrid[i + 1] - (slidesGrid[i + 1] - slidesGrid[i]) / 2) {
1385                    activeIndex = i;
1386                } else if (translate >= slidesGrid[i] && translate < slidesGrid[i + 1]) {
1387                    activeIndex = i + 1;
1388                }
1389            } else if (translate >= slidesGrid[i]) {
1390                activeIndex = i;
1391            }
1392        }
1393        // Normalize slideIndex
1394        if (params.normalizeSlideIndex) {
1395            if (activeIndex < 0 || typeof activeIndex === 'undefined') activeIndex = 0;
1396        }
1397        return activeIndex;
1398    }
1399    function updateActiveIndex(newActiveIndex) {
1400        const swiper = this;
1401        const translate = swiper.rtlTranslate ? swiper.translate : -swiper.translate;
1402        const {
1403            snapGrid,
1404            params,
1405            activeIndex: previousIndex,
1406            realIndex: previousRealIndex,
1407            snapIndex: previousSnapIndex
1408        } = swiper;
1409        let activeIndex = newActiveIndex;
1410        let snapIndex;
1411        const getVirtualRealIndex = aIndex => {
1412            let realIndex = aIndex - swiper.virtual.slidesBefore;
1413            if (realIndex < 0) {
1414                realIndex = swiper.virtual.slides.length + realIndex;
1415            }
1416            if (realIndex >= swiper.virtual.slides.length) {
1417                realIndex -= swiper.virtual.slides.length;
1418            }
1419            return realIndex;
1420        };
1421        if (typeof activeIndex === 'undefined') {
1422            activeIndex = getActiveIndexByTranslate(swiper);
1423        }
1424        if (snapGrid.indexOf(translate) >= 0) {
1425            snapIndex = snapGrid.indexOf(translate);
1426        } else {
1427            const skip = Math.min(params.slidesPerGroupSkip, activeIndex);
1428            snapIndex = skip + Math.floor((activeIndex - skip) / params.slidesPerGroup);
1429        }
1430        if (snapIndex >= snapGrid.length) snapIndex = snapGrid.length - 1;
1431        if (activeIndex === previousIndex) {
1432            if (snapIndex !== previousSnapIndex) {
1433                swiper.snapIndex = snapIndex;
1434                swiper.emit('snapIndexChange');
1435            }
1436            if (swiper.params.loop && swiper.virtual && swiper.params.virtual.enabled) {
1437                swiper.realIndex = getVirtualRealIndex(activeIndex);
1438            }
1439            return;
1440        }
1441        // Get real index
1442        let realIndex;
1443        if (swiper.virtual && params.virtual.enabled && params.loop) {
1444            realIndex = getVirtualRealIndex(activeIndex);
1445        } else if (swiper.slides[activeIndex]) {
1446            realIndex = parseInt(swiper.slides[activeIndex].getAttribute('data-swiper-slide-index') || activeIndex, 10);
1447        } else {
1448            realIndex = activeIndex;
1449        }
1450        Object.assign(swiper, {
1451            previousSnapIndex,
1452            snapIndex,
1453            previousRealIndex,
1454            realIndex,
1455            previousIndex,
1456            activeIndex
1457        });
1458        if (swiper.initialized) {
1459            preload(swiper);
1460        }
1461        swiper.emit('activeIndexChange');
1462        swiper.emit('snapIndexChange');
1463        if (swiper.initialized || swiper.params.runCallbacksOnInit) {
1464            if (previousRealIndex !== realIndex) {
1465                swiper.emit('realIndexChange');
1466            }
1467            swiper.emit('slideChange');
1468        }
1469    }
1470
1471    function updateClickedSlide(el, path) {
1472        const swiper = this;
1473        const params = swiper.params;
1474        let slide = el.closest(`.${params.slideClass}, swiper-slide`);
1475        if (!slide && swiper.isElement && path && path.length > 1 && path.includes(el)) {
1476            [...path.slice(path.indexOf(el) + 1, path.length)].forEac

1476h(pathEl => {
1477                if (!slide && pathEl.matches && pathEl.matches(`.${params.slideClass}, swiper-slide`)) {
1478                    slide = pathEl;
1479                }
1480            });
1481        }
1482        let slideFound = false;
1483        let slideIndex;
1484        if (slide) {
1485            for (let i = 0; i < swiper.slides.length; i += 1) {
1486                if (swiper.slides[i] === slide) {
1487                    slideFound = true;
1488                    slideIndex = i;
1489                    break;
1490                }
1491            }
1492        }
1493        if (slide && slideFound) {
1494            swiper.clickedSlide = slide;
1495            if (swiper.virtual && swiper.params.virtual.enabled) {
1496                swiper.clickedIndex = parseInt(slide.getAttribute('data-swiper-slide-index'), 10);
1497            } else {
1498                swiper.clickedIndex = slideIndex;
1499            }
1500        } else {
1501            swiper.clickedSlide = undefined;
1502            swiper.clickedIndex = undefined;
1503            return;
1504        }
1505        if (params.slideToClickedSlide && swiper.clickedIndex !== undefined && swiper.clickedIndex !== swiper.activeIndex) {
1506            swiper.slideToClickedSlide();
1507        }
1508    }
1509
1510    var update = {
1511        updateSize,
1512        updateSlides,
1513        updateAutoHeight,
1514        updateSlidesOffset,
1515        updateSlidesProgress,
1516        updateProgress,
1517        updateSlidesClasses,
1518        updateActiveIndex,
1519        updateClickedSlide
1520    };
1521
1522    function getSwiperTranslate(axis) {
1523        if (axis === void 0) {
1524            axis = this.isHorizontal() ? 'x' : 'y';
1525        }
1526        const swiper = this;
1527        const {
1528            params,
1529            rtlTranslate: rtl,
1530            translate,
1531            wrapperEl
1532        } = swiper;
1533        if (params.virtualTranslate) {
1534            return rtl ? -translate : translate;
1535        }
1536        if (params.cssMode) {
1537            return translate;
1538        }
1539        let currentTranslate = getTranslate(wrapperEl, axis);
1540        currentTranslate += swiper.cssOverflowAdjustment();
1541        if (rtl) currentTranslate = -currentTranslate;
1542        return currentTranslate || 0;
1543    }
1544
1545    function setTranslate(translate, byController) {
1546        const swiper = this;
1547        const {
1548            rtlTranslate: rtl,
1549            params,
1550            wrapperEl,
1551            progress
1552        } = swiper;
1553        let x = 0;
1554        let y = 0;
1555        const z = 0;
1556        if (swiper.isHorizontal()) {
1557            x = rtl ? -translate : translate;
1558        } else {
1559            y = translate;
1560        }
1561        if (params.roundLengths) {
1562            x = Math.floor(x);
1563            y = Math.floor(y);
1564        }
1565        swiper.previousTranslate = swiper.translate;
1566        swiper.translate = swiper.isHorizontal() ? x : y;
1567        if (params.cssMode) {
1568            wrapperEl[swiper.isHorizontal() ? 'scrollLeft' : 'scrollTop'] = swiper.isHorizontal() ? -x : -y;
1569        } else if (!params.virtualTranslate) {
1570            if (swiper.isHorizontal()) {
1571                x -= swiper.cssOverflowAdjustment();
1572            } else {
1573                y -= swiper.cssOverflowAdjustment();
1574            }
1575            wrapperEl.style.transform = `translate3d(${x}px, ${y}px, ${z}px)`;
1576        }
1577
1578        // Check if we need to update progress
1579        let newProgress;
1580        const translatesDiff = swiper.maxTranslate() - swiper.minTranslate();
1581        if (translatesDiff === 0) {
1582            newProgress = 0;
1583        } else {
1584            newProgress = (translate - swiper.minTranslate()) / translatesDiff;
1585        }
1586        if (newProgress !== progress) {
1587            swiper.updateProgress(translate);
1588        }
1589        swiper.emit('setTranslate', swiper.translate, byController);
1590    }
1591
1592    function minTranslate() {
1593        return -this.snapGrid[0];
1594    }
1595
1596    function maxTranslate() {
1597        return -this.snapGrid[this.snapGrid.length - 1];
1598    }
1599
1600    function translateTo(translate, speed, runCallbacks, translateBounds, internal) {
1601        if (translate === void 0) {
1602            translate = 0;
1603        }
1604        if (speed === void 0) {
1605            speed = this.params.speed;
1606        }
1607        if (runCallbacks === void 0) {
1608            runCallbacks = true;
1609        }
1610        if (translateBounds === void 0) {
1611            translateBounds = true;
1612        }
1613        const swiper = this;
1614        const {
1615            params,
1616            wrapperEl
1617        } = swiper;
1618        if (swiper.animating && params.preventInteractionOnTransition) {
1619            return false;

1620        }
1621        const minTranslate = swiper.minTranslate();
1622        const maxTranslate = swiper.maxTranslate();
1623        let newTranslate;
1624        if (translateBounds && translate > minTranslate) newTranslate = minTranslate;else if (translateBounds && translate < maxTranslate) newTranslate = maxTranslate;else newTranslate = translate;
1625
1626        // Update progress
1627        swiper.updateProgress(newTranslate);
1628        if (params.cssMode) {
1629            const isH = swiper.isHorizontal();
1630            if (speed === 0) {
1631                wrapperEl[isH ? 'scrollLeft' : 'scrollTop'] = -newTranslate;
1632            } else {
1633                if (!swiper.support.smoothScroll) {
1634                    animateCSSModeScroll({
1635                        swiper,
1636                        targetPosition: -newTranslate,
1637                        side: isH ? 'left' : 'top'
1638                    });
1639                    return true;
1640                }
1641                wrapperEl.scrollTo({
1642                    [isH ? 'left' : 'top']: -newTranslate,
1643                    behavior: 'smooth'
1644                });
1645            }
1646            return true;
1647        }
1648        if (speed === 0) {
1649            swiper.setTransition(0);
1650            swiper.setTranslate(newTranslate);
1651            if (runCallbacks) {
1652                swiper.emit('beforeTransitionStart', speed, internal);
1653                swiper.emit('transitionEnd');
1654            }
1655        } else {
1656            swiper.setTransition(speed);
1657            swiper.setTranslate(newTranslate);
1658            if (runCallbacks) {
1659                swiper.emit('beforeTransitionStart', speed, internal);
1660                swiper.emit('transitionStart');
1661            }
1662            if (!swiper.animating) {
1663                swiper.animating = true;
1664                if (!swiper.onTranslateToWrapperTransitionEnd) {
1665                    swiper.onTranslateToWrapperTransitionEnd = function transitionEnd(e) {
1666                        if (!swiper || swiper.destroyed) return;
1667                        if (e.target !== this) return;
1668                        swiper.wrapperEl.removeEventListener('transitionend', swiper.onTranslateToWrapperTransitionEnd);
1669                        swiper.onTranslateToWrapperTransitionEnd = null;
1670                        delete swiper.onTranslateToWrapperTransitionEnd;
1671                        if (runCallbacks) {
1672                            swiper.emit('transitionEnd');
1673                        }
1674                    };
1675                }
1676                swiper.wrapperEl.addEventListener('transitionend', swiper.onTranslateToWrapperTransitionEnd);
1677            }
1678        }
1679        return true;
1680    }
1681
1682    var translate = {
1683        getTranslate: getSwiperTranslate,
1684        setTranslate,
1685        minTranslate,
1686        maxTranslate,
1687        translateTo
1688    };
1689
1690    function setTransition(duration, byController) {
1691        const swiper = this;
1692        if (!swiper.params.cssMode) {
1693            swiper.wrapperEl.style.transitionDuration = `${duration}ms`;
1694            swiper.wrapperEl.style.transitionDelay = duration === 0 ? `0ms` : '';
1695        }
1696        swiper.emit('setTransition', duration, byController);
1697    }
1698
1699    function transitionEmit(_ref) {
1700        let {
1701            swiper,
1702            runCallbacks,
1703            direction,
1704            step
1705        } = _ref;
1706        const {
1707            activeIndex,
1708            previousIndex
1709        } = swiper;
1710        let dir = direction;
1711        if (!dir) {
1712            if (activeIndex > previousIndex) dir = 'next';else if (activeIndex < previousIndex) dir = 'prev';else dir = 'reset';
1713        }
1714        swiper.emit(`transition${step}`);
1715        if (runCallbacks && activeIndex !== previousIndex) {
1716            if (dir === 'reset') {
1717                swiper.emit(`slideResetTransition${step}`);
1718                return;
1719            }
1720            swiper.emit(`slideChangeTransition${step}`);
1721            if (dir === 'next') {
1722                swiper.emit(`slideNextTransition${step}`);
1723            } else {
1724                swiper.emit(`slidePrevTransition${step}`);
1725            }
1726        }
1727    }
1728
1729    function transitionStart(runCallbacks, direction) {
1730        if (runCallbacks === void 0) {
1731            runCallbacks = true;
1732        }
1733        const swiper = this;
1734        const {
1735            params
1736        } = swiper;
1737        if (params.cssMode) return;
1738        if (params.autoHeight) {
1739            swiper.updateAutoHeight();
1740        }
1741        transitionEmit({
1742            swiper,
1743            runCallbacks,
1744            direction,
1745            step: 'Start'
1746        });
1747    }
1748
1749    function transitionEnd(runCallbacks, direction) {
1750        if (runCallbacks === void 0) {
1751            runCallbacks = true;
1752        }
1753        const swiper = this;
1754        const {
1755            params
1756        } = swiper;
1757        swiper.animating = false;

1758        if (params.cssMode) return;
1759        swiper.setTransition(0);
1760        transitionEmit({
1761            swiper,
1762            runCallbacks,
1763            direction,
1764            step: 'End'
1765        });
1766    }
1767
1768    var transition = {
1769        setTransition,
1770        transitionStart,
1771        transitionEnd
1772    };
1773
1774    function slideTo(index, speed, runCallbacks, internal, initial) {
1775        if (index === void 0) {
1776            index = 0;
1777        }
1778        if (speed === void 0) {
1779            speed = this.params.speed;
1780        }
1781        if (runCallbacks === void 0) {
1782            runCallbacks = true;
1783        }
1784        if (typeof index === 'string') {
1785            index = parseInt(index, 10);
1786        }
1787        const swiper = this;
1788        let slideIndex = index;
1789        if (slideIndex < 0) slideIndex = 0;
1790        const {
1791            params,
1792            snapGrid,
1793            slidesGrid,
1794            previousIndex,
1795            activeIndex,
1796            rtlTranslate: rtl,
1797            wrapperEl,
1798            enabled
1799        } = swiper;
1800        if (swiper.animating && params.preventInteractionOnTransition || !enabled && !internal && !initial) {
1801            return false;
1802        }
1803        const skip = Math.min(swiper.params.slidesPerGroupSkip, slideIndex);
1804        let snapIndex = skip + Math.floor((slideIndex - skip) / swiper.params.slidesPerGroup);
1805        if (snapIndex >= snapGrid.length) snapIndex = snapGrid.length - 1;
1806        const translate = -snapGrid[snapIndex];
1807        // Normalize slideIndex
1808        if (params.normalizeSlideIndex) {
1809            for (let i = 0; i < slidesGrid.length; i += 1) {
1810                const normalizedTranslate = -Math.floor(translate * 100);
1811                const normalizedGrid = Math.floor(slidesGrid[i] * 100);
1812                const normalizedGridNext = Math.floor(slidesGrid[i + 1] * 100);
1813                if (typeof slidesGrid[i + 1] !== 'undefined') {
1814                    if (normalizedTranslate >= normalizedGrid && normalizedTranslate < normalizedGridNext - (normalizedGridNext - normalizedGrid) / 2) {
1815                        slideIndex = i;
1816                    } else if (normalizedTranslate >= normalizedGrid && normalizedTranslate < normalizedGridNext) {
1817                        slideIndex = i + 1;
1818                    }
1819                } else if (normalizedTranslate >= normalizedGrid) {
1820                    slideIndex = i;
1821                }
1822            }
1823        }
1824        // Directions locks
1825        if (swiper.initialized && slideIndex !== activeIndex) {
1826            if (!swiper.allowSlideNext && (rtl ? translate > swiper.translate && translate > swiper.minTranslate() : translate < swiper.translate && translate < swiper.minTranslate())) {
1827                return false;
1828            }
1829            if (!swiper.allowSlidePrev && translate > swiper.translate && translate > swiper.maxTranslate()) {
1830                if ((activeIndex || 0) !== slideIndex) {
1831                    return false;
1832                }
1833            }
1834        }
1835        if (slideIndex !== (previousIndex || 0) && runCallbacks) {
1836            swiper.emit('beforeSlideChangeStart');
1837        }
1838
1839        // Update progress
1840        swiper.updateProgress(translate);
1841        let direction;
1842        if (slideIndex > activeIndex) direction = 'next';else if (slideIndex < activeIndex) direction = 'prev';else direction = 'reset';
1843
1844        // Update Index
1845        if (rtl && -translate === swiper.translate || !rtl && translate === swiper.translate) {
1846            swiper.updateActiveIndex(slideIndex);
1847            // Update Height
1848            if (params.autoHeight) {
1849                swiper.updateAutoHeight();
1850            }
1851            swiper.updateSlidesClasses();
1852            if (params.effect !== 'slide') {
1853                swiper.setTranslate(translate);
1854            }
1855            if (direction !== 'reset') {
1856                swiper.transitionStart(runCallbacks, direction);
1857                swiper.transitionEnd(runCallbacks, direction);
1858            }
1859            return false;
1860        }
1861        if (params.cssMode) {
1862            const isH = swiper.isHorizontal();
1863            const t = rtl ? translate : -translate;
1864            if (speed === 0) {
1865                const isVirtual = swiper.virtual && swiper.params.virtual.enabled;
1866                if (isVirtual) {
1867                    swiper.wrapperEl.style.scrollSnapType = 'none';
1868                    swiper._immediateVirtual = true;
1869                }
1870                if (isVirtual && !swiper._cssModeVirtualInitialSet && swiper.params.initialSlide > 0) {
1871                    swiper._cssModeVirtualInitialSet = true;
1872                    requestAnimationFrame(() => {
1873                        wrapperEl[isH ? 'scrollLeft' : 'scrollTop'] = t;
1874                    });
1875                } else {
1876                    wrapperEl[isH ? 'scrollLeft' : 'scrollTop'] = t;
1877                }
1878                if (isVirtual) {
1879                    requestAnimationFrame(() => {
1880                        swiper.wrapperEl.style.scrollSnapType = '';
1881                        swiper._immediateVirtual = false;

1882                    });
1883                }
1884            } else {
1885                if (!swiper.support.smoothScroll) {
1886                    animateCSSModeScroll({
1887                        swiper,
1888                        targetPosition: t,
1889                        side: isH ? 'left' : 'top'
1890                    });
1891                    return true;
1892                }
1893                wrapperEl.scrollTo({
1894                    [isH ? 'left' : 'top']: t,
1895                    behavior: 'smooth'
1896                });
1897            }
1898            return true;
1899        }
1900        swiper.setTransition(speed);
1901        swiper.setTranslate(translate);
1902        swiper.updateActiveIndex(slideIndex);
1903        swiper.updateSlidesClasses();
1904        swiper.emit('beforeTransitionStart', speed, internal);
1905        swiper.transitionStart(runCallbacks, direction);
1906        if (speed === 0) {
1907            swiper.transitionEnd(runCallbacks, direction);
1908        } else if (!swiper.animating) {
1909            swiper.animating = true;
1910            if (!swiper.onSlideToWrapperTransitionEnd) {
1911                swiper.onSlideToWrapperTransitionEnd = function transitionEnd(e) {
1912                    if (!swiper || swiper.destroyed) return;
1913                    if (e.target !== this) return;
1914                    swiper.wrapperEl.removeEventListener('transitionend', swiper.onSlideToWrapperTransitionEnd);
1915                    swiper.onSlideToWrapperTransitionEnd = null;
1916                    delete swiper.onSlideToWrapperTransitionEnd;
1917                    swiper.transitionEnd(runCallbacks, direction);
1918                };
1919            }
1920            swiper.wrapperEl.addEventListener('transitionend', swiper.onSlideToWrapperTransitionEnd);
1921        }
1922        return true;
1923    }
1924
1925    function slideToLoop(index, speed, runCallbacks, internal) {
1926        if (index === void 0) {
1927            index = 0;
1928        }
1929        if (speed === void 0) {
1930            speed = this.params.speed;
1931        }
1932        if (runCallbacks === void 0) {
1933            runCallbacks = true;
1934        }
1935        if (typeof index === 'string') {
1936            const indexAsNumber = parseInt(index, 10);
1937            index = indexAsNumber;
1938        }
1939        const swiper = this;
1940        let newIndex = index;
1941        if (swiper.params.loop) {
1942            if (swiper.virtual && swiper.params.virtual.enabled) {
1943                // eslint-disable-next-line
1944                newIndex = newIndex + swiper.virtual.slidesBefore;
1945            } else {
1946                newIndex = swiper.getSlideIndexByData(newIndex);
1947            }
1948        }
1949        return swiper.slideTo(newIndex, speed, runCallbacks, internal);
1950    }
1951
1952    /* eslint no-unused-vars: "off" */
1953    function slideNext(speed, runCallbacks, internal) {
1954        if (speed === void 0) {
1955            speed = this.params.speed;
1956        }
1957        if (runCallbacks === void 0) {
1958            runCallbacks = true;
1959        }
1960        const swiper = this;
1961        const {
1962            enabled,
1963            params,
1964            animating
1965        } = swiper;
1966        if (!enabled) return swiper;
1967        let perGroup = params.slidesPerGroup;
1968        if (params.slidesPerView === 'auto' && params.slidesPerGroup === 1 && params.slidesPerGroupAuto) {
1969            perGroup = Math.max(swiper.slidesPerViewDynamic('current', true), 1);
1970        }
1971        const increment = swiper.activeIndex < params.slidesPerGroupSkip ? 1 : perGroup;
1972        const isVirtual = swiper.virtual && params.virtual.enabled;
1973        if (params.loop) {
1974            if (animating && !isVirtual && params.loopPreventsSliding) return false;
1975            swiper.loopFix({
1976                direction: 'next'
1977            });
1978            // eslint-disable-next-line
1979            swiper._clientLeft = swiper.wrapperEl.clientLeft;
1980            if (swiper.activeIndex === swiper.slides.length - 1 && params.cssMode) {
1981                requestAnimationFrame(() => {
1982                    swiper.slideTo(swiper.activeIndex + increment, speed, runCallbacks, internal);
1983                });
1984                return true;
1985            }
1986        }
1987        if (params.rewind && swiper.isEnd) {
1988            return swiper.slideTo(0, speed, runCallbacks, internal);
1989        }
1990        return swiper.slideTo(swiper.activeIndex + increment, speed, runCallbacks, internal);
1991    }
1992
1993    /* eslint no-unused-vars: "off" */
1994    function slidePrev(speed, runCallbacks, internal) {
1995        if (speed === void 0) {
1996            speed = this.params.speed;
1997        }
1998        if (runCallbacks === void 0) {
1999            runCallbacks = true;
2000        }
2001        const swiper = this;
2002        const {
2003            params,
2004            snapGrid,
2005            slidesGrid,
2006            rtlTranslate,
2007            enabled,
2008            animating
2009        } = swiper;
2010        if (!enabled) return swiper;
2011        const isVirtual = swiper.virtual && params.virtual.enabled;
2012        if (params.loop) {
2013            if (animating && !isVirtual && params.loopPreventsSliding) return false;

2014            swiper.loopFix({
2015                direction: 'prev'
2016            });
2017            // eslint-disable-next-line
2018            swiper._clientLeft = swiper.wrapperEl.clientLeft;
2019        }
2020        const translate = rtlTranslate ? swiper.translate : -swiper.translate;
2021        function normalize(val) {
2022            if (val < 0) return -Math.floor(Math.abs(val));
2023            return Math.floor(val);
2024        }
2025        const normalizedTranslate = normalize(translate);
2026        const normalizedSnapGrid = snapGrid.map(val => normalize(val));
2027        let prevSnap = snapGrid[normalizedSnapGrid.indexOf(normalizedTranslate) - 1];
2028        if (typeof prevSnap === 'undefined' && params.cssMode) {
2029            let prevSnapIndex;
2030            snapGrid.forEach((snap, snapIndex) => {
2031                if (normalizedTranslate >= snap) {
2032                    // prevSnap = snap;
2033                    prevSnapIndex = snapIndex;
2034                }
2035            });
2036            if (typeof prevSnapIndex !== 'undefined') {
2037                prevSnap = snapGrid[prevSnapIndex > 0 ? prevSnapIndex - 1 : prevSnapIndex];
2038            }
2039        }
2040        let prevIndex = 0;
2041        if (typeof prevSnap !== 'undefined') {
2042            prevIndex = slidesGrid.indexOf(prevSnap);
2043            if (prevIndex < 0) prevIndex = swiper.activeIndex - 1;
2044            if (params.slidesPerView === 'auto' && params.slidesPerGroup === 1 && params.slidesPerGroupAuto) {
2045                prevIndex = prevIndex - swiper.slidesPerViewDynamic('previous', true) + 1;
2046                prevIndex = Math.max(prevIndex, 0);
2047            }
2048        }
2049        if (params.rewind && swiper.isBeginning) {
2050            const lastIndex = swiper.params.virtual && swiper.params.virtual.enabled && swiper.virtual ? swiper.virtual.slides.length - 1 : swiper.slides.length - 1;
2051            return swiper.slideTo(lastIndex, speed, runCallbacks, internal);
2052        } else if (params.loop && swiper.activeIndex === 0 && params.cssMode) {
2053            requestAnimationFrame(() => {
2054                swiper.slideTo(prevIndex, speed, runCallbacks, internal);
2055            });
2056            return true;
2057        }
2058        return swiper.slideTo(prevIndex, speed, runCallbacks, internal);
2059    }
2060
2061    /* eslint no-unused-vars: "off" */
2062    function slideReset(speed, runCallbacks, internal) {
2063        if (speed === void 0) {
2064            speed = this.params.speed;
2065        }
2066        if (runCallbacks === void 0) {
2067            runCallbacks = true;
2068        }
2069        const swiper = this;
2070        return swiper.slideTo(swiper.activeIndex, speed, runCallbacks, internal);
2071    }
2072
2073    /* eslint no-unused-vars: "off" */
2074    function slideToClosest(speed, runCallbacks, internal, threshold) {
2075        if (speed === void 0) {
2076            speed = this.params.speed;
2077        }
2078        if (runCallbacks === void 0) {
2079            runCallbacks = true;
2080        }
2081        if (threshold === void 0) {
2082            threshold = 0.5;
2083        }
2084        const swiper = this;
2085        let index = swiper.activeIndex;
2086        const skip = Math.min(swiper.params.slidesPerGroupSkip, index);
2087        const snapIndex = skip + Math.floor((index - skip) / swiper.params.slidesPerGroup);
2088        const translate = swiper.rtlTranslate ? swiper.translate : -swiper.translate;
2089        if (translate >= swiper.snapGrid[snapIndex]) {
2090            // The current translate is on or after the current snap index, so the choice
2091            // is between the current index and the one after it.
2092            const currentSnap = swiper.snapGrid[snapIndex];
2093            const nextSnap = swiper.snapGrid[snapIndex + 1];
2094            if (translate - currentSnap > (nextSnap - currentSnap) * threshold) {
2095                index += swiper.params.slidesPerGroup;
2096            }
2097        } else {
2098            // The current translate is before the current snap index, so the choice
2099            // is between the current index and the one before it.
2100            const prevSnap = swiper.snapGrid[snapIndex - 1];
2101            const currentSnap = swiper.snapGrid[snapIndex];
2102            if (translate - prevSnap <= (currentSnap - prevSnap) * threshold) {
2103                index -= swiper.params.slidesPerGroup;
2104            }
2105        }
2106        index = Math.max(index, 0);
2107        index = Math.min(index, swiper.slidesGrid.length - 1);
2108        return swiper.slideTo(index, speed, runCallbacks, internal);
2109    }
2110
2111    function slideToClickedSlide() {
2112        const swiper = this;
2113        const {
2114            params,
2115            slidesEl
2116        } = swiper;
2117        const slidesPerView = params.slidesPerView === 'auto' ? swiper.slidesPerViewDynamic() : params.slidesPerView;
2118        let slideToIndex = swiper.clickedIndex;
2119        let realIndex;
2120        const slideSelector = swiper.isElement ? `swiper-slide` : `.${params.slideClass}`;
2121        if (params.loop) {
2122            if (swiper.animating) return;
2123            realIndex = parseInt(swiper.clickedSlide.getAttribute('data-swiper-slide-index'), 10);
2124            if (params.centeredSlides) {
2125                if (slideToIndex < swiper.loopedSlides - slidesPerView / 2 || slideToIndex > swiper.slides.length - swiper.loopedSlides + slidesPerView / 2) {
2126                    swiper.loopFix();
2127                    slideToIndex = swiper.getSlideIndex(elementChildren(slidesEl, `${slideSelector}[data-swiper-slide-index="${realIndex}"]`)[0]);
2128                    nextTick(() => {
2129                        swiper.slideTo(slideToIndex);
2130                    });
2131                } else {
2132                    swiper.slideTo(slideToIndex);
2133                }
2134            } else if (slideToIndex > swiper.slides.length - slidesPerView) {
2135                swiper.loopFix();
2136                slideToIndex = swiper.getSlideIndex(elementChildren(slidesEl, `${slideSelector}[data-swiper-slide-index="${realIndex}"]`)[0]);
2137                nextTick(() => {
2138                    swiper.slideTo(slideToIndex);
2139                });
2140            } else {
2141                swiper.slideTo(slideToIndex);
2142            }
2143        } else {
2144            swiper.slideTo(slideToIndex);
2145        }
2146    }
2147
2148    var slide = {
2149        slideTo,
2150        slideToLoop,
2151        slideNext,
2152        slidePrev,
2153        slideReset,
2154        slideToClosest,
2155        slideToClickedSlide
2156    };
2157
2158    function loopCreate(slideRealIndex) {
2159        const swiper = this;
2160        const {
2161            params,
2162            slidesEl
2163        } = swiper;
2164        if (!params.loop || swiper.virtual && swiper.params.virtual.enabled) return;
2165        const slides = elementChildren(slidesEl, `.${params.slideClass}, swiper-slide`);

2166        slides.forEach((el, index) => {
2167            el.setAttribute('data-swiper-slide-index', index);
2168        });
2169        swiper.loopFix({
2170            slideRealIndex,
2171            direction: params.centeredSlides ? undefined : 'next'
2172        });
2173    }
2174
2175    function loopFix(_temp) {
2176        let {
2177            slideRealIndex,
2178            slideTo = true,
2179            direction,
2180            setTranslate,
2181            activeSlideIndex,
2182            byController,
2183            byMousewheel
2184        } = _temp === void 0 ? {} : _temp;
2185        const swiper = this;
2186        if (!swiper.params.loop) return;
2187        swiper.emit('beforeLoopFix');
2188        const {
2189            slides,
2190            allowSlidePrev,
2191            allowSlideNext,
2192            slidesEl,
2193            params
2194        } = swiper;
2195        swiper.allowSlidePrev = true;
2196        swiper.allowSlideNext = true;
2197        if (swiper.virtual && params.virtual.enabled) {
2198            if (slideTo) {
2199                if (!params.centeredSlides && swiper.snapIndex === 0) {
2200                    swiper.slideTo(swiper.virtual.slides.length, 0, false, true);
2201                } else if (params.centeredSlides && swiper.snapIndex < params.slidesPerView) {
2202                    swiper.slideTo(swiper.virtual.slides.length + swiper.snapIndex, 0, false, true);
2203                } else if (swiper.snapIndex === swiper.snapGrid.length - 1) {
2204                    swiper.slideTo(swiper.virtual.slidesBefore, 0, false, true);
2205                }
2206            }
2207            swiper.allowSlidePrev = allowSlidePrev;
2208            swiper.allowSlideNext = allowSlideNext;
2209            swiper.emit('loopFix');
2210            return;
2211        }
2212        const slidesPerView = params.slidesPerView === 'auto' ? swiper.slidesPerViewDynamic() : Math.ceil(parseFloat(params.slidesPerView, 10));
2213        let loopedSlides = params.loopedSlides || slidesPerView;
2214        if (loopedSlides % params.slidesPerGroup !== 0) {
2215            loopedSlides += params.slidesPerGroup - loopedSlides % params.slidesPerGroup;
2216        }
2217        swiper.loopedSlides = loopedSlides;
2218        const prependSlidesIndexes = [];
2219        const appendSlidesIndexes = [];
2220        let activeIndex = swiper.activeIndex;
2221        if (typeof activeSlideIndex === 'undefined') {
2222            activeSlideIndex = swiper.getSlideIndex(swiper.slides.filter(el => el.classList.contains(params.slideActiveClass))[0]);
2223        } else {
2224            activeIndex = activeSlideIndex;
2225        }
2226        const isNext = direction === 'next' || !direction;
2227        const isPrev = direction === 'prev' || !direction;
2228        let slidesPrepended = 0;
2229        let slidesAppended = 0;
2230        // prepend last slides before start
2231        if (activeSlideIndex < loopedSlides) {
2232            slidesPrepended = Math.max(loopedSlides - activeSlideIndex, params.slidesPerGroup);
2233            for (let i = 0; i < loopedSlides - activeSlideIndex; i += 1) {
2234                const index = i - Math.floor(i / slides.length) * slides.length;
2235                prependSlidesIndexes.push(slides.length - index - 1);
2236            }
2237        } else if (activeSlideIndex /* + slidesPerView */ > swiper.slides.length - loopedSlides * 2) {
2238            slidesAppended = Math.max(activeSlideIndex - (swiper.slides.length - loopedSlides * 2), params.slidesPerGroup);
2239            for (let i = 0; i < slidesAppended; i += 1) {
2240                const index = i - Math.floor(i / slides.length) * slides.length;
2241                appendSlidesIndexes.push(index);
2242            }
2243        }
2244        if (isPrev) {
2245            prependSlidesIndexes.forEach(index => {
2246                swiper.slides[index].swiperLoopMoveDOM = true;
2247                slidesEl.prepend(swiper.slides[index]);
2248                swiper.slides[index].swiperLoopMoveDOM = false;
2249            });
2250        }
2251        if (isNext) {
2252            appendSlidesIndexes.forEach(index => {
2253                swiper.slides[index].swiperLoopMoveDOM = true;
2254                slidesEl.append(swiper.slides[index]);
2255                swiper.slides[index].swiperLoopMoveDOM = false;
2256            });
2257        }
2258        swiper.recalcSlides();
2259        if (params.slidesPerView === 'auto') {
2260            swiper.updateSlides();
2261        }
2262        if (params.watchSlidesProgress) {
2263            swiper.updateSlidesOffset();
2264        }
2265        if (slideTo) {
2266            if (prependSlidesIndexes.length > 0 && isPrev) {
2267                if (typeof slideRealIndex === 'undefined') {
2268                    const currentSlideTranslate = swiper.slidesGrid[activeIndex];
2269                    const newSlideTranslate = swiper.slidesGrid[activeIndex + slidesPrepended];
2270                    const diff = newSlideTranslate - currentSlideTranslate;
2271                    if (byMousewheel) {
2272                        swiper.setTranslate(swiper.translate - diff);
2273                    } else {
2274                        swiper.slideTo(activeIndex + slidesPrepended, 0, false, true);
2275                        if (setTranslate) {
2276                            swiper.touches[swiper.isHorizontal() ? 'startX' : 'startY'] += diff;
2277                            swiper.touchEventsData.currentTranslate = swiper.translate;
2278                        }
2279                    }
2280                } else {
2281                    if (setTranslate) {
2282                        swiper.slideToLoop(slideRealIndex, 0, false, true);
2283                        swiper.touchEventsData.currentTranslate = swiper.translate;
2284                    }
2285                }
2286            } else if (appendSlidesIndexes.length > 0 && isNext) {
2287                if (typeof slideRealIndex === 'undefined') {
2288                    const currentSlideTranslate = swiper.slidesGrid[activeIndex];
2289                    const newSlideTranslate = swiper.slidesGrid[activeIndex - slidesAppended];
2290                    const diff = newSlideTranslate - currentSlideTranslate;
2291                    if (byMousewheel) {
2292                        swiper.setTranslate(swiper.translate - diff);
2293                    } else {
2294                        swiper.slideTo(activeIndex - slidesAppended, 0, false, true);
2295                        if (setTranslate) {
2296                            swiper.touches[swiper.isHorizontal() ? 'startX' : 'startY'] += diff;
2297                            swiper.touchEventsData.currentTranslate = swiper.translate;
2298                        }
2299                    }
2300                } else {
2301                    swiper.slideToLoop(slideRealIndex, 0, false, true);
2302                }
2303            }
2304        }
2305        swiper.allowSlidePrev = allowSlidePrev;
2306        swiper.allowSlideNext = allowSlideNext;
2307        if (swiper.controller && swiper.controller.control && !byController) {
2308            const loopParams = {
2309                slideRealIndex,
2310                direction,
2311                setTranslate,
2312                activeSlideIndex,
2313                byController: true
2314            };
2315            if (Array.isArray(swiper.controller.control)) {
2316                swiper.controller.control.forEach(c => {
2317                    if (!c.destroyed && c.params.loop) c.loopFix({
2318                        ...loopParams,
2319                        slideTo: c.params.slidesPerView === params.slidesPerView ? slideTo : false
2320                    });
2321                });
2322            } else if (swiper.controller.control instanceof swiper.constructor && swiper.controller.control.params.loop) {
2323                swiper.controller.control.loopFix({
2324                    ...loopParams,
2325                    slideTo: swiper.controller.control.params.slidesPerView === params.slidesPerView ? slideTo : false
2326                });
2327            }
2328        }
2329        swiper.emit('loopFix');
2330    }
2331
2332    function loopDestroy() {
2333        const swiper = this;
2334        const {
2335            params,
2336            slidesEl
2337        } = swiper;
2338        if (!params.loop || swiper.virtual && swiper.params.virtual.enabled) return;
2339        swiper.recalcSlides();
2340        const newSlidesOrder = [];
2341        swiper.slides.forEach(slideEl => {
2342            const index = typeof slideEl.swiperSlideIndex === 'undefined' ? slideEl.getAttribute('data-swiper-slide-index') * 1 : slideEl.swiperSlideIndex;
2343            newSlidesOrder[index] = slideEl;
2344        });
2345        swiper.slides.forEach(slideEl => {
2346            slideEl.removeAttribute('data-swiper-slide-index');
2347        });
2348        newSlidesOrder.forEach(slideEl => {
2349            slidesEl.append(slideEl);
2350        });
2351        swiper.recalcSlides();
2352        swiper.slideTo(swiper.realIndex, 0);
2353    }
2354
2355    var loop = {
2356        loopCreate,
2357        loopFix,
2358        loopDestroy
2359    };
2360
2361    function setGrabCursor(moving) {
2362        const swiper = this;
2363        if (!swiper.params.simulateTouch || swiper.params.watchOverflow && swiper.isLocked || swiper.params.cssMode) return;
2364        const el = swiper.params.touchEventsTarget === 'container' ? swiper.el : swiper.wrapperEl;
2365        if (swiper.isElement) {
2366            swiper.__preventObserver__ = true;
2367        }
2368        el.style.cursor = 'move';
2369        el.style.cursor = moving ? 'grabbing' : 'grab';
2370        if (swiper.isElement) {
2371            requestAnimationFrame(() => {
2372                swiper.__preventObserver__ = false;
2373            });
2374        }
2375    }
2376
2377    function unsetGrabCursor() {
2378        const swiper = this;
2379        if (swiper.params.watchOverflow && swiper.isLocked || swiper.params.cssMode) {
2380            return;
2381        }
2382        if (swiper.isElement) {
2383            swiper.__preventObserver__ = true;
2384        }
2385        swiper[swiper.params.touchEventsTarget === 'container' ? 'el' : 'wrapperEl'].style.cursor = '';
2386        if (swiper.isElement) {
2387            requestAnimationFrame(() => {
2388                swiper.__preventObserver__ = false;
2389            });
2390        }
2391    }
2392
2393    var grabCursor = {
2394        setGrabCursor,
2395        unsetGrabCursor
2396    };
2397
2398    // Modified from https://stackoverflow.com/questions/54520554/custom-element-getrootnode-closest-function-crossing-multiple-parent-shadowd
2399    function closestElement(selector, base) {
2400        if (base === void 0) {
2401            base = this;
2402        }
2403        function __closestFrom(el) {
2404            if (!el || el === getDocument() || el === getWindow()) return null;
2405            if (el.assignedSlot) el = el.assignedSlot;
2406            const found = el.closest(selector);
2407            if (!found && !el.getRootNode) {
2408                return null;
2409            }
2410            return found || __closestFrom(el.getRootNode().host);
2411        }
2412        return __closestFrom(base);
2413    }
2414    function onTouchStart(event) {
2415        const swiper = this;
2416        const document = getDocument();
2417        const window = getWindow();
2418        const data = swiper.touchEventsData;
2419        data.evCache.push(event);
2420        const {
2421            params,
2422            touches,
2423            enabled
2424        } = swiper;
2425        if (!enabled) return;
2426        if (!params.simulateTouch && event.pointerType === 'mouse') return;
2427        if (swiper.animating && params.preventInteractionOnTransition) {
2428            return;
2429        }
2430        if (!swiper.animating && params.cssMode && params.loop) {
2431            swiper.loopFix();
2432        }
2433        let e = event;
2434        if (e.originalEvent) e = e.originalEvent;
2435        let targetEl = e.target;
2436        if (params.touchEventsTarget === 'wrapper') {
2437            if (!swiper.wrapperEl.contains(targetEl)) return;
2438        }
2439        if ('which' in e && e.which === 3) return;
2440        if ('button' in e && e.button > 0) return;
2441        if (data.isTouched && data.isMoved) return;
2442
2443        // change target el for shadow root component
2444        const swipingClassHasValue = !!params.noSwipingClass && params.noSwipingClass !== '';
2445        // eslint-disable-next-line
2446        const eventPath = event.composedPath ? event.composedPath() : event.path;
2447        if (swipingClassHasValue && e.target && e.target.shadowRoot && eventPath) {
2448            targetEl = eventPath[0];
2449        }
2450        const noSwipingSelector = params.noSwipingSelector ? params.noSwipingSelector : `.${params.noSwipingClass}`;
2451        const isTargetShadow = !!(e.target && e.target.shadowRoot);
2452
2453        // use closestElement for shadow root element to get the actual closest for nested shadow root element
2454        if (params.noSwiping && (isTargetShadow ? closestElement(noSwipingSelector, targetEl) : targetEl.closest(noSwipingSelector))) {
2455            swiper.allowClick = true;
2456            return;
2457        }
2458        if (params.swipeHandler) {
2459            if (!targetEl.closest(params.swipeHandler)) return;
2460        }
2461        touches.currentX = e.pageX;
2462        touches.currentY = e.pageY;
2463        const startX = touches.currentX;
2464        const startY = touches.currentY;
2465
2466        // Do NOT start if iOS edge swipe is detected. Otherwise iOS app cannot swipe-to-go-back anymore
2467
2468        const edgeSwipeDetection = params.edgeSwipeDetection || params.iOSEdgeSwipeDetection;
2469        const edgeSwipeThreshold = params.edgeSwipeThreshold || params.iOSEdgeSwipeThreshold;
2470        if (edgeSwipeDetection && (startX <= edgeSwipeThreshold || startX >= window.innerWidth - edgeSwipeThreshold)) {
2471            if (edgeSwipeDetection === 'prevent') {
2472                event.preventDefault();
2473            } else {
2474                return;
2475            }
2476        }
2477        Object.assign(data, {
2478            isTouched: true,
2479            isMoved: false,
2480            allowTouchCallbacks: true,
2481            isScrolling: undefined,
2482            startMoving: undefined
2483        });
2484        touches.startX = startX;
2485        touches.startY = startY;
2486        data.touchStartTime = now();
2487        swiper.allowClick = true;
2488        swiper.updateSize();
2489        swiper.swipeDirection = undefined;
2490        if (params.threshold > 0) data.allowThresholdMove = false;
2491        let preventDefault = true;
2492        if (targetEl.matches(data.focusableElements)) {
2493            preventDefault = false;
2494            if (targetEl.nodeName === 'SELECT') {
2495                data.isTouched = false;
2496            }
2497        }
2498        if (document.activeElement && document.activeElement.matches(data.focusableElements) && document.activeElement !== targetEl) {
2499            document.activeElement.blur();
2500        }
2501        const shouldPreventDefault = preventDefault && swiper.allowTouchMove && params.touchStartPreventDefault;
2502        if ((params.touchStartForcePreventDefault || shouldPreventDefault) && !targetEl.isContentEditable) {
2503            e.preventDefault();
2504        }
2505        if (params.freeMode && params.freeMode.enabled && swiper.freeMode && swiper.animating && !params.cssMode) {
2506            swiper.freeMode.onTouchStart();
2507        }
2508        swiper.emit('touchStart', e);
2509    }
2510
2511    function onTouchMove(event) {
2512        const document = getDocument();
2513        const swiper = this;
2514        const data = swiper.touchEventsData;
2515        const {
2516            params,
2517            touches,
2518            rtlTranslate: rtl,
2519            enabled
2520        } = swiper;
2521        if (!enabled) return;
2522        if (!params.simulateTouch && event.pointerType === 'mouse') return;
2523        let e = event;
2524        if (e.originalEvent) e = e.originalEvent;
2525        if (!data.isTouched) {
2526            if (data.startMoving && data.isScrolling) {
2527                swiper.emit('touchMoveOpposite', e);
2528            }
2529            return;
2530        }
2531        const pointerIndex = data.evCache.findIndex(cachedEv => cachedEv.pointerId === e.pointerId);
2532        if (pointerIndex >= 0) data.evCache[pointerIndex] = e;
2533        const targetTouch = data.evCache.length > 1 ? data.evCache[0] : e;
2534        const pageX = targetTouch.pageX;
2535        const pageY = targetTouch.pageY;
2536        if (e.preventedByNestedSwiper) {
2537            touches.startX = pageX;
2538            touches.startY = pageY;
2539            return;
2540        }
2541        if (!swiper.allowTouchMove) {
2542            if (!e.target.matches(data.focusableElements)) {
2543                swiper.allowClick = false;
2544            }
2545            if (data.isTouched) {
2546                Object.assign(touches, {
2547                    startX: pageX,
2548                    startY: pageY,
2549                    prevX: swiper.touches.currentX,
2550                    prevY: swiper.touches.currentY,
2551                    currentX: pageX,
2552                    currentY: pageY
2553                });
2554                data.touchStartTime = now();
2555            }
2556            return;
2557        }
2558        if (params.touchReleaseOnEdges && !params.loop) {
2559            if (swiper.isVertical()) {
2560                // Vertical
2561                if (pageY < touches.startY && swiper.translate <= swiper.maxTranslate() || pageY > touches.startY && swiper.translate >= swiper.minTranslate()) {
2562                    data.isTouched = false;
2563                    data.isMoved = false;
2564                    return;
2565                }
2566            } else if (pageX < touches.startX && swiper.translate <= swiper.maxTranslate() || pageX > touches.startX && swiper.translate >= swiper.minTranslate()) {
2567                return;
2568            }
2569        }
2570        if (document.activeElement) {
2571            if (e.target === document.activeElement && e.target.matches(data.focusableElements)) {
2572                data.isMoved = true;
2573                swiper.allowClick = false;
2574                return;
2575            }
2576        }
2577        if (data.allowTouchCallbacks) {
2578            swiper.emit('touchMove', e);
2579        }
2580        if (e.targetTouches && e.targetTouches.length > 1) return;
2581        touches.currentX = pageX;
2582        touches.currentY = pageY;
2583        const diffX = touches.currentX - touches.startX;
2584        const diffY = touches.currentY - touches.startY;
2585        if (swiper.params.threshold && Math.sqrt(diffX ** 2 + diffY ** 2) < swiper.params.threshold) return;
2586        if (typeof data.isScrolling === 'undefined') {
2587            let touchAngle;
2588            if (swiper.isHorizontal() && touches.currentY === touches.startY || swiper.isVertical() && touches.currentX === touches.startX) {
2589                data.isScrolling = false;
2590            } else {
2591                // eslint-disable-next-line
2592                if (diffX * diffX + diffY * diffY >= 25) {
2593                    touchAngle = Math.atan2(Math.abs(diffY), Math.abs(diffX)) * 180 / Math.PI;
2594                    data.isScrolling = swiper.isHorizontal() ? touchAngle > params.touchAngle : 90 - touchAngle > params.touchAngle;
2595                }
2596            }
2597        }
2598        if (data.isScrolling) {
2599            swiper.emit('touchMoveOpposite', e);
2600        }
2601        if (typeof data.startMoving === 'undefined') {
2602            if (touches.currentX !== touches.startX || touches.currentY !== touches.startY) {
2603                data.startMoving = true;
2604            }
2605        }
2606        if (data.isScrolling || swiper.zoom && swiper.params.zoom && swiper.params.zoom.enabled && data.evCache.length > 1) {
2607            data.isTouched = false;
2608            return;
2609        }
2610        if (!data.startMoving) {
2611            return;
2612        }
2613        swiper.allowClick = false;
2614        if (!params.cssMode && e.cancelable) {
2615            e.preventDefault();
2616        }
2617        if (params.touchMoveStopPropagation && !params.nested) {
2618            e.stopPropagation();
2619        }
2620        let diff = swiper.isHorizontal() ? diffX : diffY;
2621        let touchesDiff = swiper.isHorizontal() ? touches.currentX - touches.previousX : touches.currentY - touches.previousY;
2622        if (params.oneWayMovement) {
2623            diff = Math.abs(diff) * (rtl ? 1 : -1);
2624            touchesDiff = Math.abs(touchesDiff) * (rtl ? 1 : -1);
2625        }
2626        touches.diff = diff;
2627        diff *= params.touchRatio;
2628        if (rtl) {
2629            diff = -diff;
2630            touchesDiff = -touchesDiff;
2631        }
2632        const prevTouchesDirection = swiper.touchesDirection;
2633        swiper.swipeDirection = diff > 0 ? 'prev' : 'next';
2634        swiper.touchesDirection = touchesDiff > 0 ? 'prev' : 'next';
2635        const isLoop = swiper.params.loop && !params.cssMode;
2636        const allowLoopFix = swiper.swipeDirection === 'next' && swiper.allowSlideNext || swiper.swipeDirection === 'prev' && swiper.allowSlidePrev;
2637        if (!data.isMoved) {
2638            if (isLoop && allowLoopFix) {
2639                swiper.loopFix({
2640                    direction: swiper.swipeDirection
2641                });
2642            }
2643            data.startTranslate = swiper.getTranslate();
2644            swiper.setTransition(0);
2645            if (swiper.animating) {
2646                const evt = new window.CustomEvent('transitionend', {
2647                    bubbles: true,
2648                    cancelable: true
2649                });
2650                swiper.wrapperEl.dispatchEvent(evt);
2651            }
2652            data.allowMomentumBounce = false;
2653            // Grab Cursor
2654            if (params.grabCursor && (swiper.allowSlideNext === true || swiper.allowSlidePrev === true)) {
2655                swiper.setGrabCursor(true);
2656            }
2657            swiper.emit('sliderFirstMove', e);
2658        }
2659        let loopFixed;
2660        if (data.isMoved && prevTouchesDirection !== swiper.touchesDirection && isLoop && allowLoopFix && Math.abs(diff) >= 1) {
2661            // need another loop fix
2662            swiper.loopFix({
2663                direction: swiper.swipeDirection,
2664                setTranslate: true
2665            });
2666            loopFixed = true;
2667        }
2668        swiper.emit('sliderMove', e);
2669        data.isMoved = true;
2670        data.currentTranslate = diff + data.startTranslate;
2671        let disableParentSwiper = true;
2672        let resistanceRatio = params.resistanceRatio;
2673        if (params.touchReleaseOnEdges) {
2674            resistanceRatio = 0;
2675        }
2676        if (diff > 0) {
2677            if (isLoop && allowLoopFix && !loopFixed && data.currentTranslate > (params.centeredSlides ? swiper.minTranslate() - swiper.size / 2 : swiper.minTranslate())) {
2678                swiper.loopFix({
2679                    direction: 'prev',
2680                    setTranslate: true,
2681                    activeSlideIndex: 0
2682                });
2683            }
2684            if (data.currentTranslate > swiper.minTranslate()) {
2685                disableParentSwiper = false;